carta1 1.1.2 → 1.1.3

package/codec/pipeline/decoder.js

@@ -59,11 +59,11 @@ export function dequantizationStage() {
    * @param {Array<Int32Array>} frameData.quantizedCoefficients - Quantized coefficient data
    * @param {Array<number>} frameData.blockModes - Block modes for each band
    * @returns {Object} Dequantization results
-   * @returns {Float64Array} returns.coefficients - Reconstructed MDCT coefficients (512 samples)
+   * @returns {Float32Array} returns.coefficients - Reconstructed MDCT coefficients (512 samples)
    * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (frameData) => {
-    const coefficients = new Float64Array(512)
+    const coefficients = new Float32Array(512)
     const {
       nBfu,
       scaleFactorIndices,
@@ -123,13 +123,13 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform a single frequency band.
-   * @param {Float64Array} coeffs
+   * @param {Float32Array} coeffs
    * @param {number} bandIndex
    * @param {number} blockMode
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function transformBand(
     coeffs,
@@ -164,13 +164,13 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform using long block.
-   * @param {Float64Array} coeffs
+   * @param {Float32Array} coeffs
    * @param {number} bandIndex
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
    * @param {Object} transformFunc
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function inverseLongBlock(
     coeffs,
@@ -234,12 +234,12 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform using short blocks.
-   * @param {Float64Array} coeffs
+   * @param {Float32Array} coeffs
    * @param {number} bandIndex
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function inverseShortBlocks(
     coeffs,
@@ -308,9 +308,9 @@ export function imdctStage(context) {
   /**
    * Transform coefficients back to time domain using inverse MDCT
    * @param {Object} input - Dequantization results
-   * @param {Float64Array} input.coefficients - MDCT coefficients (512 samples)
+   * @param {Float32Array} input.coefficients - MDCT coefficients (512 samples)
    * @param {Array<number>} input.blockModes - Block modes for each band
-   * @returns {Array<Float64Array>} Three reconstructed frequency bands [low, mid, high]
+   * @returns {Array<Float32Array>} Three reconstructed frequency bands [low, mid, high]
    */
   return (input) => {
     const { coefficients, blockModes } = input
@@ -354,14 +354,14 @@ export function qmfSynthesisStage(context) {
 
   /**
    * Reconstruct full-spectrum PCM samples from frequency bands
-   * @param {Array<Float64Array>} bands - Three frequency bands [low, mid, high]
-   * @returns {Float64Array} Reconstructed PCM samples
+   * @param {Array<Float32Array>} bands - Three frequency bands [low, mid, high]
+   * @returns {Float32Array} Reconstructed PCM samples
    */
   return (bands) => {
     // Apply high band delay compensation
     const delayedHigh = bufferPool.qmfWorkBuffers.highBandDelay[bands[2].length]
     delayedHigh.set(delays.highBand)
-    delayedHigh.set(bands[2])
+    delayedHigh.set(bands[2], delays.highBand.length)
 
     const highBand = delayedHigh.slice(0, bands[0].length * 2)
     delays.highBand = delayedHigh.slice(bands[0].length * 2)

package/codec/pipeline/encoder.js

@@ -62,9 +62,9 @@ export function qmfAnalysisStage(context) {
 
   /**
    * Process PCM samples through QMF analysis
-   * @param {Float64Array} pcmSamples - Input PCM samples
+   * @param {Float32Array} pcmSamples - Input PCM samples
    * @returns {Object} Analysis result containing frequency bands
-   * @returns {Array<Float64Array>} returns.bands - Three frequency bands [low, mid, high]
+   * @returns {Array<Float32Array>} returns.bands - Three frequency bands [low, mid, high]
    */
   return (pcmSamples) => {
     const stage1 = qmfAnalysis(
@@ -118,9 +118,9 @@ export function blockSelectorStage(context) {
   /**
    * Analyze frequency bands and determine block modes
    * @param {Object} input - QMF analysis results
-   * @param {Array<Float64Array>} input.bands - Three frequency bands [low, mid, high]
+   * @param {Array<Float32Array>} input.bands - Three frequency bands [low, mid, high]
    * @returns {Object} Block selection results
-   * @returns {Array<Float64Array>} returns.bands - Original frequency bands
+   * @returns {Array<Float32Array>} returns.bands - Original frequency bands
    * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (input) => {
@@ -170,12 +170,12 @@ export function mdctStage(context) {
 
   /**
    * Transform a single frequency band using MDCT.
-   * @param {Float64Array} samples
+   * @param {Float32Array} samples
    * @param {number} bandIndex
    * @param {number} blockMode
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function transformBand(
     samples,
@@ -210,13 +210,13 @@ export function mdctStage(context) {
 
   /**
    * Transform using long block (better frequency resolution).
-   * @param {Float64Array} samples
+   * @param {Float32Array} samples
    * @param {number} bandIndex
    * @param {Object} config
    * @param {Object} transformFunc
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function transformLongBlock(
     samples,
@@ -252,12 +252,12 @@ export function mdctStage(context) {
 
   /**
    * Transform using short blocks (better time resolution for transients).
-   * @param {Float64Array} samples
+   * @param {Float32Array} samples
    * @param {number} bandIndex
    * @param {Object} config
-   * @param {Float64Array} overlapBuffer
+   * @param {Float32Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float64Array}
+   * @returns {Float32Array}
    */
   function transformShortBlocks(
     samples,
@@ -267,7 +267,7 @@ export function mdctStage(context) {
     bufferPool
   ) {
     const numBlocks = 1 << (config.size === 256 ? 3 : 2) // 8 for band 2, 4 for bands 0-1
-    const output = new Float64Array(config.size)
+    const output = new Float32Array(config.size)
 
     for (let block = 0; block < numBlocks; block++) {
       const blockStart = block * MDCT_SHORT_BLOCK_SIZE
@@ -311,18 +311,18 @@ export function mdctStage(context) {
   /**
    * Transform frequency bands using MDCT
    * @param {Object} input - Block selection results
-   * @param {Array<Float64Array>} input.bands - Three frequency bands
+   * @param {Array<Float32Array>} input.bands - Three frequency bands
    * @param {Array<number>} input.blockModes - Block modes for each band
    * @param {any} input.originalFrame - Original frame data (passed through)
    * @returns {Object} MDCT transform results
-   * @returns {Array<Float64Array>} returns.bands - Original frequency bands
-   * @returns {Float64Array} returns.coefficients - MDCT coefficients (512 samples)
+   * @returns {Array<Float32Array>} returns.bands - Original frequency bands
+   * @returns {Float32Array} returns.coefficients - MDCT coefficients (512 samples)
    * @returns {Array<number>} returns.blockModes - Block modes
    * @returns {any} returns.originalFrame - Original frame data
    */
   return (input) => {
     const { bands, blockModes, originalFrame } = input
-    const coefficients = new Float64Array(512)
+    const coefficients = new Float32Array(512)
 
     bands.forEach((bandSamples, bandIndex) => {
       const transformed = transformBand(
@@ -359,7 +359,7 @@ export function quantizationStage() {
   /**
    * Perform RDO bit allocation and quantization
    * @param {Object} input - MDCT transform results
-   * @param {Float64Array} input.coefficients - MDCT coefficients
+   * @param {Float32Array} input.coefficients - MDCT coefficients
    * @param {Array<number>} input.blockModes - Block modes
    * @returns {Object} Quantization results ready for bitstream encoding
    * @returns {number} returns.nBfu - Number of active BFUs

package/codec/transforms/fft.js

@@ -1,136 +1,144 @@
 /**
  * Carta1 Audio Codec - Fast Fourier Transform
- * Optimized radix-2 Cooley-Tukey FFT implementation
+ *
+ * This module implements a radix-2 Cooley-Tukey FFT algorithm for frequency domain
+ * analysis used in psychoacoustic modeling and transient detection.
  */
 export class FFT {
   static _cache = new Map()
 
   /**
-   * Perform an in-place forward FFT on complex data.
-   * @param {Float64Array} real - Real part of the input/output data
-   * @param {Float64Array} imag - Imaginary part of the input/output data
+   * Perform in-place FFT on complex data
+   * @param {Float32Array} real - Real part of input/output data
+   * @param {Float32Array} imag - Imaginary part of input/output data
    */
   static fft(real, imag) {
     const n = real.length
-    if (n !== imag.length) throw new Error('Mismatched array lengths.')
-    if ((n & (n - 1)) !== 0) throw new Error('Length must be power of 2.')
+    if (n !== imag.length)
+      throw new Error('Real and imaginary arrays must have the same length.')
+    if ((n & (n - 1)) !== 0) throw new Error('Input size must be a power of 2.')
     if (n <= 1) return
 
     let cache = FFT._cache.get(n)
     if (!cache) {
-      cache = FFT._buildCache(n)
+      // build plan in Float64 for precision
+      const log2n = Math.log2(n)
+
+      const bitRev = new Uint32Array(n)
+      for (let i = 1; i < n; i++) {
+        bitRev[i] = (bitRev[i >>> 1] >>> 1) | ((i & 1) << (log2n - 1))
+      }
+
+      const cosTbl = new Float64Array(n / 2)
+      const sinTbl = new Float64Array(n / 2)
+      for (let i = 0; i < n / 2; i++) {
+        const angle = (-2 * Math.PI * i) / n
+        // compute in f64, then enforce |W| = 1 to remove tiny drift
+        let c = Math.cos(angle)
+        let s = Math.sin(angle)
+        const invm = 1 / Math.hypot(c, s) // ~1, but fixes cos^2+sin^2 drift
+        cosTbl[i] = c * invm
+        sinTbl[i] = s * invm
+      }
+
+      cache = { bitRev, cos: cosTbl, sin: sinTbl }
       FFT._cache.set(n, cache)
     }
 
-    const bitRev = cache.bitRev
-    const cosTbl = cache.cos
-    const sinTbl = cache.sin
+    const { bitRev, cos: cosTbl, sin: sinTbl } = cache
+
+    // work in Float64 to avoid per-stage Float32 rounding
+    const needCopyBack =
+      !(real instanceof Float64Array) || !(imag instanceof Float64Array)
+    const r = needCopyBack ? new Float64Array(real) : real
+    const im = needCopyBack ? new Float64Array(imag) : imag
 
-    // Bit reversal
+    // bit reversal
     for (let i = 0; i < n; i++) {
       const j = bitRev[i]
       if (j > i) {
-        let tr = real[i]
-        let ti = imag[i]
-        real[i] = real[j]
-        imag[i] = imag[j]
-        real[j] = tr
-        imag[j] = ti
+        let t = r[i]
+        r[i] = r[j]
+        r[j] = t
+        t = im[i]
+        im[i] = im[j]
+        im[j] = t
       }
     }
 
-    // First stage: stride=2
+    // size-2 butterflies
     for (let i = 0; i < n; i += 2) {
-      let r0 = real[i],
-        i0 = imag[i]
-      let r1 = real[i + 1],
-        i1 = imag[i + 1]
-      real[i] = r0 + r1
-      imag[i] = i0 + i1
-      real[i + 1] = r0 - r1
-      imag[i + 1] = i0 - i1
+      const i1 = i + 1
+      const er = r[i],
+        ei = im[i]
+      const tr = r[i1],
+        ti = im[i1]
+      r[i] = er + tr
+      im[i] = ei + ti
+      r[i1] = er - tr
+      im[i1] = ei - ti
     }
 
-    // Second stage: stride=4
+    // size-4 butterflies (uses exact W = -i at k=1)
     if (n >= 4) {
       for (let i = 0; i < n; i += 4) {
-        let r0 = real[i],
-          i0 = imag[i]
-        let r2 = real[i + 2],
-          i2 = imag[i + 2]
-        real[i] = r0 + r2
-        imag[i] = i0 + i2
-        real[i + 2] = r0 - r2
-        imag[i + 2] = i0 - i2
-
-        r0 = real[i + 1]
-        i0 = imag[i + 1]
-        r2 = real[i + 3]
-        i2 = imag[i + 3]
-        // W^1 = -i
-        let tR = i2
-        let tI = -r2
-        real[i + 1] = r0 + tR
-        imag[i + 1] = i0 + tI
-        real[i + 3] = r0 - tR
-        imag[i + 3] = i0 - tI
+        const e0 = i,
+          o0 = i + 2
+        const er0 = r[e0],
+          ei0 = im[e0]
+        const tr0 = r[o0],
+          ti0 = im[o0]
+        r[e0] = er0 + tr0
+        im[e0] = ei0 + ti0
+        r[o0] = er0 - tr0
+        im[o0] = ei0 - ti0
+
+        const e1 = i + 1,
+          o1 = i + 3
+        const tr1 = im[o1] // multiply by -i
+        const ti1 = -r[o1]
+        const er1 = r[e1],
+          ei1 = im[e1]
+        r[e1] = er1 + tr1
+        im[e1] = ei1 + ti1
+        r[o1] = er1 - tr1
+        im[o1] = ei1 - ti1
       }
     }
 
-    // Higher stages
+    // size >= 8
     for (let stride = 8; stride <= n; stride <<= 1) {
-      const halfStride = stride >>> 1
-      const tblStep = n / stride
-      for (let base = 0; base < n; base += stride) {
-        // k = 0
-        let r0 = real[base],
-          i0 = imag[base]
-        let r1 = real[base + halfStride],
-          i1 = imag[base + halfStride]
-        real[base] = r0 + r1
-        imag[base] = i0 + i1
-        real[base + halfStride] = r0 - r1
-        imag[base + halfStride] = i0 - i1
-
-        let tw = tblStep
-        for (let k = 1; k < halfStride; k++) {
-          const c = cosTbl[tw]
-          const s = sinTbl[tw]
-          r1 = real[base + k]
-          i1 = imag[base + k]
-          let r2 = real[base + k + halfStride]
-          let i2 = imag[base + k + halfStride]
-          let tr = r2 * c - i2 * s
-          let ti = r2 * s + i2 * c
-          real[base + k] = r1 + tr
-          imag[base + k] = i1 + ti
-          real[base + k + halfStride] = r1 - tr
-          imag[base + k + halfStride] = i1 - ti
-          tw += tblStep
+      const half = stride >>> 1
+      const step = (n / stride) | 0
+      for (let i = 0; i < n; i += stride) {
+        let k = 0
+        for (let j = 0; j < half; j++, k += step) {
+          const even = i + j
+          const odd = even + half
+
+          const cr = cosTbl[k],
+            sr = sinTbl[k]
+          const orr = r[odd],
+            oii = im[odd]
+
+          const tr = orr * cr - oii * sr
+          const ti = orr * sr + oii * cr
+
+          const er = r[even],
+            ei = im[even]
+          r[even] = er + tr
+          im[even] = ei + ti
+          r[odd] = er - tr
+          im[odd] = ei - ti
         }
       }
     }
-  }
 
-  /**
-   * Build cache tables for FFT of size n
-   * @private
-   */
-  static _buildCache(n) {
-    const bitRev = new Uint32Array(n)
-    const log2n = Math.log2(n) | 0
-    for (let i = 1; i < n; i++) {
-      bitRev[i] = (bitRev[i >>> 1] >>> 1) | ((i & 1) << (log2n - 1))
-    }
-    const halfN = n >>> 1
-    const cosTbl = new Float64Array(halfN)
-    const sinTbl = new Float64Array(halfN)
-    const ang = (-2 * Math.PI) / n
-    for (let i = 0; i < halfN; i++) {
-      const a = ang * i
-      cosTbl[i] = Math.cos(a)
-      sinTbl[i] = Math.sin(a)
+    if (needCopyBack) {
+      for (let i = 0; i < n; i++) {
+        real[i] = r[i]
+        imag[i] = im[i]
+      }
     }
-    return { bitRev, cos: cosTbl, sin: sinTbl }
   }
 }

package/codec/transforms/mdct.js

@@ -47,9 +47,9 @@ export class MDCT extends MDCTBase {
 
   /**
    * Perform forward MDCT transform
-   * @param {Float64Array} input - Time-domain input samples
+   * @param {Float32Array} input - Time-domain input samples
    * @param {Object} mdctBuffers - Optional work buffers for FFT
-   * @returns {Float64Array} Frequency-domain MDCT coefficients
+   * @returns {Float32Array} Frequency-domain MDCT coefficients
    */
   transform(input, mdctBuffers = null) {
     const buffers =
@@ -107,7 +107,7 @@ export class MDCT extends MDCTBase {
     FFT.fft(real, imag)
 
     // Post-FFT processing
-    const output = new Float64Array(this.halfSize)
+    const output = new Float32Array(this.halfSize)
     for (let i = 0; i < this.fftSize; i++) {
       const c = this.sinCosTable[i * 2]
       const s = this.sinCosTable[i * 2 + 1]
@@ -132,9 +132,9 @@ export class IMDCT extends MDCTBase {
 
   /**
    * Perform inverse MDCT transform
-   * @param {Float64Array} input - Frequency-domain MDCT coefficients
+   * @param {Float32Array} input - Frequency-domain MDCT coefficients
    * @param {Object} mdctBuffers - Optional work buffers for FFT
-   * @returns {Float64Array} Time-domain output samples
+   * @returns {Float32Array} Time-domain output samples
    */
   transform(input, mdctBuffers = null) {
     const buffers =
@@ -172,7 +172,7 @@ export class IMDCT extends MDCTBase {
     FFT.fft(real, imag)
 
     // Post-FFT butterfly
-    const output = new Float64Array(this.size)
+    const output = new Float32Array(this.size)
 
     for (let i = 0; i < this.fftSize / 2; i++) {
       const i2 = i * 2
@@ -222,14 +222,14 @@ export const imdct512 = new IMDCT(MDCT_SIZE_LONG, MDCT_SIZE_LONG * 4)
 
 /**
  * Perform overlap-add operation for MDCT reconstruction
- * @param {Float64Array} prev - Previous block samples
- * @param {Float64Array} curr - Current block samples
- * @param {Float64Array} window - Window function coefficients
- * @returns {Float64Array} Overlap-added output samples
+ * @param {Float32Array} prev - Previous block samples
+ * @param {Float32Array} curr - Current block samples
+ * @param {Float32Array} window - Window function coefficients
+ * @returns {Float32Array} Overlap-added output samples
  */
 export function overlapAdd(prev, curr, window) {
   const size = prev.length
-  const output = new Float64Array(size * 2)
+  const output = new Float32Array(size * 2)
 
   for (let i = 0; i < size; i++) {
     const w1 = window[i]

package/codec/transforms/qmf.js

@@ -11,8 +11,8 @@ import { throwError } from '../utils.js'
 
 /**
  * Perform QMF analysis filtering to split input into low and high frequency bands
- * @param {Float64Array} input - Input audio samples
- * @param {Float64Array} delayLine - QMF delay line state
+ * @param {Float32Array} input - Input audio samples
+ * @param {Float32Array} delayLine - QMF delay line state
  * @param {Object} qmfWorkBuffers - Optional work buffers for processing
  * @returns {Object} Object containing lowBand, highBand, and newDelay
  */
@@ -26,8 +26,8 @@ export function qmfAnalysis(input, delayLine, qmfWorkBuffers = null) {
   workBuffer.set(delayLine)
   workBuffer.set(input, delayLine.length)
 
-  const lowBand = new Float64Array(outputLength)
-  const highBand = new Float64Array(outputLength)
+  const lowBand = new Float32Array(outputLength)
+  const highBand = new Float32Array(outputLength)
 
   for (let i = 0; i < outputLength; i++) {
     let evenSum = 0
@@ -51,9 +51,9 @@ export function qmfAnalysis(input, delayLine, qmfWorkBuffers = null) {
 
 /**
  * Perform QMF synthesis filtering to reconstruct audio from low and high frequency bands
- * @param {Float64Array} lowBand - Low frequency band samples
- * @param {Float64Array} highBand - High frequency band samples
- * @param {Float64Array} delayLine - QMF delay line state
+ * @param {Float32Array} lowBand - Low frequency band samples
+ * @param {Float32Array} highBand - High frequency band samples
+ * @param {Float32Array} delayLine - QMF delay line state
  * @param {Object} qmfWorkBuffers - Optional work buffers for processing
  * @returns {Object} Object containing output and newDelay
  */
@@ -82,7 +82,7 @@ export function qmfSynthesis(
     workBuffer[offset + 1] = 0.5 * (low - high)
   }
 
-  const output = new Float64Array(outputLength)
+  const output = new Float32Array(outputLength)
 
   // Convolution
   for (let i = 0; i < subbandLength; i++) {