carta1 1.1.0 → 1.1.2

package/bin/cli.js

@@ -156,7 +156,7 @@ class ProgressTracker {
  * Provides async iteration over WAV file frames for memory-efficient
  * processing of large audio files. Automatically handles:
  * - Multi-channel deinterleaving
- * - Bit depth conversion to float32
+ * - Bit depth conversion to Float64
  * - Frame padding for the last partial frame
  *
  * @class
@@ -225,9 +225,9 @@ class WavReader {
    * Async iterator for streaming WAV file frames
    *
    * @param {number} [frameSize=SAMPLES_PER_FRAME] - Samples per frame
-   * @yields {Float32Array|Array<Float32Array>} Audio frame data
-   *   - Mono: Float32Array of samples
-   *   - Stereo: [left, right] Float32Arrays
+   * @yields {Float64Array|Array<Float64Array>} Audio frame data
+   *   - Mono: Float64Array of samples
+   *   - Stereo: [left, right] Float64Arrays
    */
   async *[Symbol.asyncIterator](frameSize = SAMPLES_PER_FRAME) {
     const fileStream = fs.createReadStream(this.filePath)
@@ -305,23 +305,23 @@ class WavReader {
   }
 
   /**
-   * Process raw PCM buffer into float32 frame data
+   * Process raw PCM buffer into float64 frame data
    *
    * @private
    * @param {Buffer} frameBuffer - Raw PCM data
    * @param {number} frameSize - Number of samples per channel
-   * @returns {Float32Array|Array<Float32Array>} Processed frame data
+   * @returns {Float64Array|Array<Float64Array>} Processed frame data
    */
   _processFrameBuffer(frameBuffer, frameSize) {
     if (this.channels === 1) {
-      const frame = new Float32Array(frameSize)
+      const frame = new Float64Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         frame[i] = this._sampleToFloat(frameBuffer, i * (this.bitDepth / 8))
       }
       return frame
     } else {
-      const left = new Float32Array(frameSize)
-      const right = new Float32Array(frameSize)
+      const left = new Float64Array(frameSize)
+      const right = new Float64Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         const offset = i * this.channels * (this.bitDepth / 8)
         left[i] = this._sampleToFloat(frameBuffer, offset)
@@ -332,7 +332,7 @@ class WavReader {
   }
 
   /**
-   * Convert PCM sample to normalized float32 value
+   * Convert PCM sample to normalized Float64 value
    *
    * @private
    * @param {Buffer} buffer - PCM data buffer

package/codec/analysis/transient.js

@@ -10,13 +10,13 @@ import { FFT } from '../transforms/fft.js'
 
 /**
  * Perform FFT on time-domain samples and return magnitude spectrum
- * @param {Float32Array} samples - Time-domain samples
+ * @param {Float64Array} samples - Time-domain samples
  * @param {number} fftSize - FFT size (must be power of 2)
- * @returns {Float32Array} Magnitude spectrum (positive frequencies only)
+ * @returns {Float64Array} Magnitude spectrum (positive frequencies only)
  */
 export function performFFT(samples, fftSize) {
-  const real = new Float32Array(fftSize)
-  const imag = new Float32Array(fftSize)
+  const real = new Float64Array(fftSize)
+  const imag = new Float64Array(fftSize)
 
   // Copy samples with zero-padding if necessary
   const copyLen = Math.min(samples.length, fftSize)
@@ -26,7 +26,7 @@ export function performFFT(samples, fftSize) {
   FFT.fft(real, imag)
 
   // Calculate magnitude spectrum for positive frequencies
-  const magnitude = new Float32Array(fftSize / 2)
+  const magnitude = new Float64Array(fftSize / 2)
   for (let i = 0; i < fftSize / 2; i++) {
     magnitude[i] = Math.sqrt(real[i] * real[i] + imag[i] * imag[i])
   }
@@ -36,8 +36,8 @@ export function performFFT(samples, fftSize) {
 
 /**
  * Detect transients by analyzing spectral changes between frames
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @param {number} threshold - Detection threshold
  * @returns {boolean} True if transient detected
  */
@@ -56,8 +56,8 @@ export function detectTransient(currentCoeffs, prevCoeffs, threshold) {
 
 /**
  * Calculate all spectral features for transient detection
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @returns {Object} Computed spectral features
  */
 function calculateSpectralFeatures(currentCoeffs, prevCoeffs) {
@@ -114,7 +114,7 @@ function calculateSpectralFlux(currentCoeffs, prevCoeffs) {
 /**
  * Calculate spectral flatness (geometric mean / arithmetic mean)
  * Measures how noise-like vs tonal the spectrum is
- * @param {Float32Array} coeffs - Spectral coefficients
+ * @param {Float64Array} coeffs - Spectral coefficients
  * @returns {number} Flatness measure (0 = tonal, 1 = noise-like)
  */
 function calculateSpectralFlatness(coeffs) {
@@ -143,7 +143,7 @@ function calculateSpectralFlatness(coeffs) {
 /**
  * Calculate ratio of high-frequency to total energy
  * High values indicate bright/harsh sounds that are perceptually important
- * @param {Float32Array} coeffs - Spectral coefficients
+ * @param {Float64Array} coeffs - Spectral coefficients
  * @returns {number} High-frequency energy ratio (0-1)
  */
 function calculateHighFrequencyRatio(coeffs) {
@@ -165,8 +165,8 @@ function calculateHighFrequencyRatio(coeffs) {
 
 /**
  * Calculate energy change between frames in dB
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @returns {number} Energy change in dB (positive values only)
  */
 function calculateEnergyChange(currentCoeffs, prevCoeffs) {

package/codec/browser/interface.js

@@ -64,9 +64,9 @@ class Carta1Worker {
   /**
    * Encode PCM audio to ATRAC1 format
    *
-   * @param {Float32Array|Array<Float32Array>} pcmData - PCM audio data
-   *   - Mono: Float32Array
-   *   - Stereo: [left, right] Float32Arrays
+   * @param {Float64Array|Array<Float64Array>} pcmData - PCM audio data
+   *   - Mono: Float64Array
+   *   - Stereo: [left, right] Float64Arrays
    * @param {Object} [options={}] - Encoder options
    * @param {number} [options.transientThresholdLow] - Low band transient threshold
    * @param {number} [options.transientThresholdMid] - Mid band transient threshold

package/codec/browser/worker.js

@@ -56,7 +56,7 @@ self.onmessage = async (e) => {
 /**
  * Encode PCM audio data to ATRAC1 format
  *
- * @param {Array<Float32Array>} pcmData - PCM audio data [mono] or [left, right]
+ * @param {Array<Float64Array>} pcmData - PCM audio data [mono] or [left, right]
  * @param {Object} options - Encoder options
  * @returns {Promise<Object>} Encoded AEA blob
  */

package/codec/coding/bitallocation.js

@@ -29,16 +29,13 @@ import {
   BITS_PER_BFU_METADATA,
   MAX_WORD_LENGTH_INDEX,
   WORD_LENGTH_BITS,
-  LP_DISTORTION_CONSTANT,
-  SF_POW_P,
-  POW2_POS_P,
-  POW2_NEG_P,
+  INV_POWER_OF_TWO,
   SCALE_FACTORS,
 } from '../core/constants.js'
 
 /**
  * Allocate bits to BFUs using optimized greedy Lp-RDO
- * @param {Array<Float32Array>} bfuData
+ * @param {Array<Float64Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} maxBfuCount
  * @returns {{bfuCount:number, allocation:Int32Array, scaleFactorIndices:Int32Array}}
@@ -64,21 +61,8 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount) {
  * while staying within the bit budget. It uses a priority queue (max-heap) to greedily allocate
  * bits to the BFUs that provide the greatest distortion reduction per bit spent.
  *
- * Mathematical Model:
- * Distortion for b bits is modeled as:
- *   D(b) = C * 2^{-p * b}            for b >= 1
- *   D(0) = C * 2^{ p }               (finite large step for "mute" case)
- * where C = N * (sf^p) * k, with N = BFU length, sf = scale factor, p and k constants.
- *
- * Hence, for an upgrade from b1 -> b2 (b2 > b1), ΔD = D(b1) - D(b2) can be computed with 2 table lookups.
- *
- * Precomputed tables:
- *   POW2_NEG_P[b] = 2^{-p*b}   for b=0..maxBits
- *   POW2_POS_P    = 2^{ p}
- *   SF_POW_P[sfIndex] = (SCALE_FACTORS[sfIndex])^p
- *
  * @param {number} activeBfuCount
- * @param {Array<Float32Array>} bfuData
+ * @param {Array<Float64Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} remainingBits
  * @returns {{wordLengths: Int32Array, scaleFactorIndices: Int32Array}}
@@ -87,38 +71,31 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
   const scaleFactorTable = new Int32Array(NUM_BFUS)
   const wordLengths = new Int32Array(activeBfuCount)
 
-  const baseWeight = new Float64Array(activeBfuCount) // C above
-  for (let bfuIndex = 0; bfuIndex < activeBfuCount; bfuIndex++) {
-    const sz = bfuSizes[bfuIndex] | 0
-    if (sz > 0) {
-      const sfi = findScaleFactor(bfuData[bfuIndex].subarray(0, sz))
-      scaleFactorTable[bfuIndex] = sfi
-      baseWeight[bfuIndex] = sz * SF_POW_P[sfi] * LP_DISTORTION_CONSTANT
-    } else {
-      scaleFactorTable[bfuIndex] = 0
-      baseWeight[bfuIndex] = 0
-    }
-  }
-
   const heapIndices = []
   const heapPriorities = []
-  const deltaDist = (bfuIndex, currentWl, nextWl) => {
-    const base = baseWeight[bfuIndex]
-    if (base === 0) return 0
+
+  const deltaDistPerCoeff = (bfuIndex, currentWl, nextWl) => {
+    const sfi = scaleFactorTable[bfuIndex]
+    const scaleFactor = SCALE_FACTORS[sfi]
+    if (scaleFactor === 0) return 0
 
     const bits1 = WORD_LENGTH_BITS[currentWl] | 0
     const bits2 = WORD_LENGTH_BITS[nextWl] | 0
 
-    const f1 = bits1 === 0 ? POW2_POS_P : POW2_NEG_P[bits1]
-    const f2 = POW2_NEG_P[bits2]
+    const f1 = bits1 === 0 ? 2.0 : INV_POWER_OF_TWO[bits1]
+    const f2 = INV_POWER_OF_TWO[bits2]
 
-    return base * (f1 - f2)
+    return scaleFactor * (f1 - f2)
   }
 
   for (let bfuIndex = 0; bfuIndex < activeBfuCount; bfuIndex++) {
     const sz = bfuSizes[bfuIndex] | 0
     if (sz === 0) continue
-    if (scaleFactorTable[bfuIndex] === 0) continue
+
+    const sfi = findScaleFactor(bfuData[bfuIndex].subarray(0, sz))
+    scaleFactorTable[bfuIndex] = sfi
+
+    if (sfi === 0) continue
 
     const currentWl = 0
     const nextWl = 1
@@ -126,11 +103,9 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
       (WORD_LENGTH_BITS[nextWl] - WORD_LENGTH_BITS[currentWl]) | 0
     if (deltaBits <= 0) continue
 
-    const deltaCost = deltaBits * sz
-    const dd = deltaDist(bfuIndex, currentWl, nextWl)
-
+    const ddPerCoeff = deltaDistPerCoeff(bfuIndex, currentWl, nextWl)
     heapIndices.push(bfuIndex)
-    heapPriorities.push(dd / deltaCost) // priority = ΔD / ΔR
+    heapPriorities.push(ddPerCoeff / deltaBits)
   }
 
   // Heapify
@@ -159,7 +134,7 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
       const nxt2 = nxt + 1
       const deltaBits2 = (WORD_LENGTH_BITS[nxt2] - WORD_LENGTH_BITS[nxt]) | 0
       if (deltaBits2 > 0) {
-        heapPriorities[0] = deltaDist(bfu, nxt, nxt2) / (deltaBits2 * sz)
+        heapPriorities[0] = deltaDistPerCoeff(bfu, nxt, nxt2) / deltaBits2
         siftDown(heapIndices, heapPriorities, 0)
       } else {
         popRoot(heapIndices, heapPriorities)
@@ -175,42 +150,18 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
 /**
  * Find the optimal scale factor index for a set of coefficients.
  * Same semantics as the original.
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @returns {number}
  */
 export function findScaleFactor(coefficients) {
   let maxAmplitude = 0.0
-  const n = coefficients.length | 0
-  let i = 0
-  const n4 = n & ~3
-  for (; i < n4; i += 4) {
-    const a0 = Math.abs(coefficients[i])
-    const a1 = Math.abs(coefficients[i + 1])
-    const a2 = Math.abs(coefficients[i + 2])
-    const a3 = Math.abs(coefficients[i + 3])
-    if (a0 > maxAmplitude) maxAmplitude = a0
-    if (a1 > maxAmplitude) maxAmplitude = a1
-    if (a2 > maxAmplitude) maxAmplitude = a2
-    if (a3 > maxAmplitude) maxAmplitude = a3
-  }
-  for (; i < n; i++) {
+  for (let i = 0; i < coefficients.length; i++) {
     const a = Math.abs(coefficients[i])
     if (a > maxAmplitude) maxAmplitude = a
   }
   if (maxAmplitude === 0) return 0
-
-  // Binary search
-  let low = 0
-  let high = SCALE_FACTORS.length - 1
-  while (low < high) {
-    const mid = (low + high) >> 1
-    if (maxAmplitude <= SCALE_FACTORS[mid]) {
-      high = mid
-    } else {
-      low = mid + 1
-    }
-  }
-  return low
+  const index = Math.ceil(3 * (Math.log2(maxAmplitude) + 21))
+  return Math.max(0, Math.min(63, index))
 }
 
 /**

package/codec/coding/quantization.js

@@ -26,7 +26,7 @@ import {
 
 /**
  * Quantize coefficients.
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
  * @returns {Int32Array} out
@@ -35,7 +35,6 @@ export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
   const length = coefficients.length
   const out = new Int32Array(length)
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
-    // Zero fast path
     out.fill(0, 0, length)
     return out
   }
@@ -45,7 +44,7 @@ export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
   const normFactor = quantRange / scaleFactor
 
   const hi = quantRange
-  const lo = -quantRange - 1
+  const lo = -quantRange
 
   for (let i = 0; i < length; i++) {
     const x = coefficients[i] * normFactor
@@ -61,20 +60,19 @@ export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
  * @param {Int32Array} quantized
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
- * @returns {Float32Array}
+ * @returns {Float64Array}
  */
 export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
-    return new Float32Array(quantized.length)
+    return new Float64Array(quantized.length)
   }
 
   const scaleFactor = SCALE_FACTORS[scaleFactorIndex]
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
-  const denormFactor = scaleFactor / quantRange
 
-  const deq = new Float32Array(quantized.length)
+  const deq = new Float64Array(quantized.length)
   for (let i = 0; i < quantized.length; i++) {
-    deq[i] = quantized[i] * denormFactor
+    deq[i] = (quantized[i] * scaleFactor) / quantRange
   }
   return deq
 }
@@ -101,9 +99,9 @@ export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
  * - Long blocks (mode 0): Higher frequency resolution, fewer temporal segments
  * - Short blocks (mode 1): Lower frequency resolution, more temporal segments
  *
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @param {Array<number>} blockModes
- * @returns {{bfuData: Array<Float32Array>, bfuSizes: Array<number>, bfuCount: number}}
+ * @returns {{bfuData: Array<Float64Array>, bfuSizes: Array<number>, bfuCount: number}}
  */
 export function groupIntoBFUs(coefficients, blockModes) {
   const bfuData = []
@@ -123,7 +121,7 @@ export function groupIntoBFUs(coefficients, blockModes) {
       const size = SPECS_PER_BFU[bfuIndex]
       const startPos = startPositions[bfuIndex] - bandStart
       const endPos = startPos + size
-      const bfu = new Float32Array(size)
+      const bfu = new Float64Array(size)
 
       if (startPos >= 0 && endPos <= bandSize) {
         bfu.set(coefficients.subarray(bandStart + startPos, bandStart + endPos))

package/codec/core/buffers.js

@@ -2,91 +2,80 @@
  * Carta1 Audio Codec - Buffer Management
  */
 
-import {
-  NUM_BFUS,
-  MAX_BFU_SIZE,
-  QMF_DELAY,
-  QMF_HIGH_BAND_DELAY,
-} from './constants.js'
+import { QMF_DELAY, QMF_HIGH_BAND_DELAY } from './constants.js'
 
 export class BufferPool {
   constructor() {
     // Transform buffers
     this.transformBuffers = {
-      64: new Float32Array(64),
-      128: new Float32Array(128),
-      256: new Float32Array(256),
-      512: new Float32Array(512),
+      64: new Float64Array(64),
+      128: new Float64Array(128),
+      256: new Float64Array(256),
+      512: new Float64Array(512),
     }
 
     // QMF work buffers
     this.qmfWorkBuffers = {
       delay: {
-        128: new Float32Array(QMF_DELAY + 128),
-        256: new Float32Array(QMF_DELAY + 256),
-        512: new Float32Array(QMF_DELAY + 512),
+        128: new Float64Array(QMF_DELAY + 128),
+        256: new Float64Array(QMF_DELAY + 256),
+        512: new Float64Array(QMF_DELAY + 512),
       },
       highBandDelay: {
-        128: new Float32Array(QMF_HIGH_BAND_DELAY + 128),
-        256: new Float32Array(QMF_HIGH_BAND_DELAY + 256),
+        128: new Float64Array(QMF_HIGH_BAND_DELAY + 128),
+        256: new Float64Array(QMF_HIGH_BAND_DELAY + 256),
       },
     }
 
     // QMF delay lines
     this.qmfDelays = {
-      lowBand: new Float32Array(QMF_DELAY),
-      midBand: new Float32Array(QMF_DELAY),
-      highBand: new Float32Array(QMF_HIGH_BAND_DELAY),
+      lowBand: new Float64Array(QMF_DELAY),
+      midBand: new Float64Array(QMF_DELAY),
+      highBand: new Float64Array(QMF_HIGH_BAND_DELAY),
     }
 
     // Transient detector
     this.transientDetection = [
-      new Float32Array(64),
-      new Float32Array(64),
-      new Float32Array(128),
+      new Float64Array(64),
+      new Float64Array(64),
+      new Float64Array(128),
     ]
 
     // MDCT/IMDCT work buffers
     this.mdctBuffers = {
       16: {
-        real: new Float32Array(16),
-        imag: new Float32Array(16),
+        real: new Float64Array(16),
+        imag: new Float64Array(16),
       },
       64: {
-        real: new Float32Array(64),
-        imag: new Float32Array(64),
+        real: new Float64Array(64),
+        imag: new Float64Array(64),
       },
       128: {
-        real: new Float32Array(128),
-        imag: new Float32Array(128),
+        real: new Float64Array(128),
+        imag: new Float64Array(128),
       },
     }
 
-    // MDCT overlap buffers (encoder)
+    // MDCT overlap buffers
     this.mdctOverlap = [
-      new Float32Array(32),
-      new Float32Array(32),
-      new Float32Array(32),
+      new Float64Array(32),
+      new Float64Array(32),
+      new Float64Array(32),
     ]
 
-    // IMDCT overlap buffers (decoder)
+    // IMDCT overlap buffers
     this.imdctOverlap = [
-      new Float32Array(256),
-      new Float32Array(256),
-      new Float32Array(512),
+      new Float64Array(256),
+      new Float64Array(256),
+      new Float64Array(512),
     ]
 
     // Spectrum reversal buffers
     this.reversalBuffers = {
-      32: new Float32Array(32),
-      128: new Float32Array(128),
-      256: new Float32Array(256),
-    }
-
-    // Bit allocation buffers
-    this.bfuData = new Array(NUM_BFUS)
-    for (let i = 0; i < NUM_BFUS; i++) {
-      this.bfuData[i] = new Float32Array(MAX_BFU_SIZE)
+      32: new Float64Array(32),
+      128: new Float64Array(128),
+      256: new Float64Array(256),
     }
   }
 }