carta1 1.0.19 → 1.0.21

package/bin/cli.js

@@ -552,7 +552,7 @@ async function dumpFile(inputFile, outputFile, options) {
           offset: offset,
           offsetHex: '0x' + offset.toString(16),
           nBfu: frame.nBfu,
-          blockSizeMode: frame.blockSizeMode,
+          blockModes: frame.blockModes,
           scaleFactorIndices: Array.from(frame.scaleFactorIndices),
           wordLengthIndices: Array.from(frame.wordLengthIndices),
           hasNonZeroScaleFactors: frame.scaleFactorIndices.some((sf) => sf > 0),

package/codec/io/processor.js

@@ -286,7 +286,7 @@ export class AudioProcessor {
   static _createDummyFrame() {
     return {
       nBfu: 0,
-      blockSizeMode: [0, 0, 0],
+      blockModes: [0, 0, 0],
       scaleFactorIndices: new Int32Array(0),
       wordLengthIndices: new Int32Array(0),
       quantizedCoefficients: [],

package/codec/io/serialization.js

@@ -32,7 +32,7 @@ import { packBits, unpackBits, unpackSignedBits } from './bitstream.js'
  * Serializes encoded frame data into binary format
  * @param {Object} frameData - The encoded frame data to serialize
  * @param {number} frameData.nBfu - Number of block floating units
- * @param {number[]} frameData.blockSizeMode - Block size mode for each band [0-2]
+ * @param {number[]} frameData.blockModes - Block modes for each band [0-2]
  * @param {Int32Array} frameData.scaleFactorIndices - Scale factor indices for each BFU
  * @param {Int32Array} frameData.wordLengthIndices - Word length indices for each BFU
  * @param {Int32Array[]} frameData.quantizedCoefficients - Quantized spectral coefficients
@@ -45,9 +45,9 @@ export function serializeFrame(frameData) {
   // Pack header (16 bits)
   const bfuIndex = BFU_AMOUNTS.indexOf(frameData.nBfu)
   const header =
-    ((2 - frameData.blockSizeMode[0]) << 14) |
-    ((2 - frameData.blockSizeMode[1]) << 12) |
-    ((3 - frameData.blockSizeMode[2]) << 10) |
+    ((2 - frameData.blockModes[0]) << 14) |
+    ((2 - frameData.blockModes[1]) << 12) |
+    ((3 - frameData.blockModes[2]) << 10) |
     (bfuIndex << 5)
 
   view.setUint16(0, header, false)
@@ -102,7 +102,7 @@ export function serializeFrame(frameData) {
  * @param {Uint8Array} buffer - Binary frame data buffer
  * @returns {Object} Deserialized frame data
  * @returns {number} returns.nBfu - Number of block floating units
- * @returns {number[]} returns.blockSizeMode - Block size mode for each band
+ * @returns {number[]} returns.blockModes - Block modes for each band
  * @returns {Int32Array} returns.scaleFactorIndices - Scale factor indices for each BFU
  * @returns {Int32Array} returns.wordLengthIndices - Word length indices for each BFU
  * @returns {Int32Array[]} returns.quantizedCoefficients - Quantized spectral coefficients
@@ -117,7 +117,7 @@ export function deserializeFrame(buffer) {
 
   // Unpack header
   const header = view.getUint16(0, false)
-  const blockSizeMode = [
+  const blockModes = [
     2 - ((header >> 14) & 3),
     2 - ((header >> 12) & 3),
     3 - ((header >> 10) & 3),
@@ -171,7 +171,7 @@ export function deserializeFrame(buffer) {
     scaleFactorIndices,
     wordLengthIndices,
     quantizedCoefficients,
-    blockSizeMode,
+    blockModes,
   }
 }
 

package/codec/pipeline/decoder.js

@@ -57,10 +57,10 @@ export function dequantizationStage() {
    * @param {Int32Array} frameData.scaleFactorIndices - Scale factor indices for each BFU
    * @param {Int32Array} frameData.wordLengthIndices - Word length indices for each BFU
    * @param {Array<Int32Array>} frameData.quantizedCoefficients - Quantized coefficient data
-   * @param {Array<number>} frameData.blockSizeMode - Block size mode for each band
-   * @returns {Array} Dequantization results [coefficients, blockModes]
-   * @returns {Float32Array} returns[0] - Reconstructed MDCT coefficients (512 samples)
-   * @returns {Array<number>} returns[1] - Block mode indices for each band
+   * @param {Array<number>} frameData.blockModes - Block modes for each band
+   * @returns {Object} Dequantization results
+   * @returns {Float32Array} returns.coefficients - Reconstructed MDCT coefficients (512 samples)
+   * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (frameData) => {
     const coefficients = new Float32Array(512)
@@ -69,7 +69,7 @@ export function dequantizationStage() {
       scaleFactorIndices,
       wordLengthIndices,
       quantizedCoefficients,
-      blockSizeMode,
+      blockModes,
     } = frameData
 
     for (let bfu = 0; bfu < nBfu; bfu++) {
@@ -79,7 +79,7 @@ export function dequantizationStage() {
       if (bfu >= BFU_BAND_BOUNDARIES[0]) band = 1
       if (bfu >= BFU_BAND_BOUNDARIES[1]) band = 2
 
-      const isLongBlock = blockSizeMode[band] === 0
+      const isLongBlock = blockModes[band] === 0
       const position = isLongBlock ? BFU_START_LONG[bfu] : BFU_START_SHORT[bfu]
 
       if (bitsPerSample > 0) {
@@ -93,7 +93,7 @@ export function dequantizationStage() {
       }
     }
 
-    return [coefficients, blockSizeMode]
+    return { coefficients, blockModes }
   }
 }
 
@@ -287,13 +287,13 @@ export function imdctStage(context) {
 
   /**
    * Transform coefficients back to time domain using inverse MDCT
-   * @param {Array} input - Dequantization results
-   * @param {Float32Array} input[0] - MDCT coefficients (512 samples)
-   * @param {Array<number>} input[1] - Block mode indices for each band
+   * @param {Object} input - Dequantization results
+   * @param {Float32Array} input.coefficients - MDCT coefficients (512 samples)
+   * @param {Array<number>} input.blockModes - Block modes for each band
    * @returns {Array<Float32Array>} Three reconstructed frequency bands [low, mid, high]
    */
   return (input) => {
-    const [coefficients, blockModes] = input
+    const { coefficients, blockModes } = input
 
     return MDCT_BAND_CONFIGS.map((config, bandIndex) => {
       const bandCoeffs = extractBandCoefficients(coefficients, bandIndex)

package/codec/pipeline/encoder.js

@@ -126,7 +126,7 @@ export function blockSelectorStage(context) {
    * @param {Array<Float32Array>} input.bands - Three frequency bands [low, mid, high]
    * @returns {Object} Block selection results
    * @returns {Array<Float32Array>} returns.bands - Original frequency bands
-   * @returns {Array<number>} returns.blockModes - Block mode indices for each band
+   * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (input) => {
     const { bands } = input
@@ -298,12 +298,12 @@ export function mdctStage(context) {
    * Transform frequency bands using MDCT
    * @param {Object} input - Block selection results
    * @param {Array<Float32Array>} input.bands - Three frequency bands
-   * @param {Array<number>} input.blockModes - Block mode indices for each band
+   * @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<Float32Array>} returns.bands - Original frequency bands
    * @returns {Float32Array} returns.coefficients - MDCT coefficients (512 samples)
-   * @returns {Array<number>} returns.blockModes - Block mode indices
+   * @returns {Array<number>} returns.blockModes - Block modes
    * @returns {any} returns.originalFrame - Original frame data
    */
   return (input) => {
@@ -356,13 +356,13 @@ export function quantizationStage(context) {
    * Perform psychoacoustic analysis and quantization
    * @param {Object} input - MDCT transform results
    * @param {Float32Array} input.coefficients - MDCT coefficients
-   * @param {Array<number>} input.blockModes - Block mode indices
+   * @param {Array<number>} input.blockModes - Block modes
    * @returns {Object} Quantization results ready for bitstream encoding
    * @returns {number} returns.nBfu - Number of active BFUs
    * @returns {Int32Array} returns.scaleFactorIndices - Scale factor indices for each BFU
    * @returns {Int32Array} returns.wordLengthIndices - Word length indices for each BFU
    * @returns {Array<Int32Array>} returns.quantizedCoefficients - Quantized coefficient data
-   * @returns {Array<number>} returns.blockSizeMode - Block size mode for each band
+   * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (input) => {
     const { coefficients, blockModes } = input
@@ -399,7 +399,7 @@ export function quantizationStage(context) {
       scaleFactorIndices,
       wordLengthIndices: allocation.slice(0, selectedBfuCount),
       quantizedCoefficients,
-      blockSizeMode: blockModes,
+      blockModes,
     }
   }
 }

package/codec/transforms/fft.js

@@ -12,12 +12,8 @@ export class FFT {
    */
   static fft(real, imag) {
     const n = real.length
-    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 !== imag.length) throw new Error('Mismatched array lengths.')
+    if ((n & (n - 1)) !== 0) throw new Error('Length must be power of 2.')
     if (n <= 1) return
 
     let cache = FFT._cache.get(n)
@@ -26,168 +22,91 @@ export class FFT {
       FFT._cache.set(n, cache)
     }
 
-    const { bitRev, cos: cosTbl, sin: sinTbl } = cache
+    const bitRev = cache.bitRev
+    const cosTbl = cache.cos
+    const sinTbl = cache.sin
 
-    // Bit-reversal permutation with improved memory access pattern
+    // Bit reversal
     for (let i = 0; i < n; i++) {
       const j = bitRev[i]
       if (j > i) {
-        // Use temporary variables to reduce array access
-        const tempR = real[i]
-        const tempI = imag[i]
+        let tr = real[i]
+        let ti = imag[i]
         real[i] = real[j]
         imag[i] = imag[j]
-        real[j] = tempR
-        imag[j] = tempI
+        real[j] = tr
+        imag[j] = ti
       }
     }
 
-    // Optimized butterfly computations for small strides
-    // Stride 2 - no twiddle factors needed
+    // First stage: stride=2
     for (let i = 0; i < n; i += 2) {
-      const evenR = real[i]
-      const evenI = imag[i]
-      const oddR = real[i + 1]
-      const oddI = imag[i + 1]
-
-      real[i] = evenR + oddR
-      imag[i] = evenI + oddI
-      real[i + 1] = evenR - oddR
-      imag[i + 1] = evenI - oddI
+      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
     }
 
-    // Stride 4 - simple twiddle factors
+    // Second stage: stride=4
     if (n >= 4) {
       for (let i = 0; i < n; i += 4) {
-        // First pair (W^0 = 1)
-        let evenR = real[i]
-        let evenI = imag[i]
-        let oddR = real[i + 2]
-        let oddI = imag[i + 2]
-
-        real[i] = evenR + oddR
-        imag[i] = evenI + oddI
-        real[i + 2] = evenR - oddR
-        imag[i + 2] = evenI - oddI
-
-        // Second pair (W^1 = -i)
-        evenR = real[i + 1]
-        evenI = imag[i + 1]
-        oddR = real[i + 3]
-        oddI = imag[i + 3]
-
-        const tR = oddI // Multiplication by -i
-        const tI = -oddR
-
-        real[i + 1] = evenR + tR
-        imag[i + 1] = evenI + tI
-        real[i + 3] = evenR - tR
-        imag[i + 3] = evenI - tI
-      }
-    }
-
-    // Stride 8 - unrolled for better performance
-    if (n >= 8) {
-      for (let i = 0; i < n; i += 8) {
-        // W^0 = 1
-        let idx0 = i
-        let idx4 = i + 4
-        let r0 = real[idx0],
-          i0 = imag[idx0]
-        let r4 = real[idx4],
-          i4 = imag[idx4]
-        real[idx0] = r0 + r4
-        imag[idx0] = i0 + i4
-        real[idx4] = r0 - r4
-        imag[idx4] = i0 - i4
-
-        // W^1 = cos(-π/4) - i*sin(-π/4)
-        let idx1 = i + 1
-        let idx5 = i + 5
-        r0 = real[idx1]
-        i0 = imag[idx1]
-        r4 = real[idx5]
-        i4 = imag[idx5]
-        const sqrt2_2 = 0.7071067811865476
-        let tR = sqrt2_2 * (r4 + i4)
-        let tI = sqrt2_2 * (i4 - r4)
-        real[idx1] = r0 + tR
-        imag[idx1] = i0 + tI
-        real[idx5] = r0 - tR
-        imag[idx5] = i0 - tI
-
-        // W^2 = -i
-        let idx2 = i + 2
-        let idx6 = i + 6
-        r0 = real[idx2]
-        i0 = imag[idx2]
-        r4 = real[idx6]
-        i4 = imag[idx6]
-        tR = i4
-        tI = -r4
-        real[idx2] = r0 + tR
-        imag[idx2] = i0 + tI
-        real[idx6] = r0 - tR
-        imag[idx6] = i0 - tI
-
-        // W^3 = cos(-3π/4) - i*sin(-3π/4)
-        let idx3 = i + 3
-        let idx7 = i + 7
-        r0 = real[idx3]
-        i0 = imag[idx3]
-        r4 = real[idx7]
-        i4 = imag[idx7]
-        tR = sqrt2_2 * (-r4 + i4)
-        tI = sqrt2_2 * (-r4 - i4)
-        real[idx3] = r0 + tR
-        imag[idx3] = i0 + tI
-        real[idx7] = r0 - tR
-        imag[idx7] = i0 - tI
+        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
       }
     }
 
-    // General Cooley-Tukey butterflies with optimized inner loop
-    for (let stride = 16; stride <= n; stride <<= 1) {
+    // Higher stages
+    for (let stride = 8; stride <= n; stride <<= 1) {
       const halfStride = stride >>> 1
-      const step = n / stride
-
-      // Process each group
-      for (let grp = 0; grp < n; grp += stride) {
-        // First butterfly (W^0 = 1) - no multiplication needed
-        let evenIdx = grp
-        let oddIdx = grp + halfStride
-        const r0 = real[evenIdx]
-        const i0 = imag[evenIdx]
-        const r1 = real[oddIdx]
-        const i1 = imag[oddIdx]
-        real[evenIdx] = r0 + r1
-        imag[evenIdx] = i0 + i1
-        real[oddIdx] = r0 - r1
-        imag[oddIdx] = i0 - i1
-
-        // Remaining butterflies with twiddle factors
-        let twiddleIdx = step
+      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++) {
-          evenIdx = grp + k
-          oddIdx = evenIdx + halfStride
-
-          const cosW = cosTbl[twiddleIdx]
-          const sinW = sinTbl[twiddleIdx]
-
-          const oddR = real[oddIdx]
-          const oddI = imag[oddIdx]
-          const tR = oddR * cosW - oddI * sinW
-          const tI = oddR * sinW + oddI * cosW
-
-          const evenR = real[evenIdx]
-          const evenI = imag[evenIdx]
-
-          real[evenIdx] = evenR + tR
-          imag[evenIdx] = evenI + tI
-          real[oddIdx] = evenR - tR
-          imag[oddIdx] = evenI - tI
-
-          twiddleIdx += step
+          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
         }
       }
     }
@@ -198,27 +117,20 @@ export class FFT {
    * @private
    */
   static _buildCache(n) {
-    const log2n = Math.log2(n) | 0
-
-    // Optimized bit-reversal using iterative approach
     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))
     }
-
-    // Pre-compute twiddle factors with better precision
     const halfN = n >>> 1
     const cosTbl = new Float32Array(halfN)
     const sinTbl = new Float32Array(halfN)
-
-    // Use higher precision calculation then cast to Float32
-    const angleStep = (-2 * Math.PI) / n
+    const ang = (-2 * Math.PI) / n
     for (let i = 0; i < halfN; i++) {
-      const angle = angleStep * i
-      cosTbl[i] = Math.fround(Math.cos(angle))
-      sinTbl[i] = Math.fround(Math.sin(angle))
+      const a = ang * i
+      cosTbl[i] = Math.cos(a)
+      sinTbl[i] = Math.sin(a)
     }
-
     return { bitRev, cos: cosTbl, sin: sinTbl }
   }
 }

package/codec/transforms/mdct.js

@@ -52,9 +52,19 @@ export class MDCT extends MDCTBase {
    * @returns {Float32Array} Frequency-domain MDCT coefficients
    */
   transform(input, mdctBuffers = null) {
-    const buffers = mdctBuffers?.[this.fftSize]
-    const real = buffers?.real ?? throwError('mdct: real is required')
-    const imag = buffers?.imag ?? throwError('mdct: imag is required')
+    const buffers =
+      mdctBuffers?.[this.fftSize] ??
+      throwError(`MDCT.transform: mdctBuffers[${this.fftSize}] is required`)
+    const real =
+      buffers?.real ??
+      throwError(
+        `MDCT.transform: mdctBuffers[${this.fftSize}].real is required`
+      )
+    const imag =
+      buffers?.imag ??
+      throwError(
+        `MDCT.transform: mdctBuffers[${this.fftSize}].imag is required`
+      )
 
     const n4 = this.quarterSize
     const n34 = 3 * n4
@@ -127,9 +137,19 @@ export class IMDCT extends MDCTBase {
    * @returns {Float32Array} Time-domain output samples
    */
   transform(input, mdctBuffers = null) {
-    const buffers = mdctBuffers?.[this.fftSize]
-    const real = buffers?.real ?? throwError('imdct: real is required')
-    const imag = buffers?.imag ?? throwError('imdct: imag is required')
+    const buffers =
+      mdctBuffers?.[this.fftSize] ??
+      throwError(`IMDCT.transform: mdctBuffers[${this.fftSize}] is required`)
+    const real =
+      buffers?.real ??
+      throwError(
+        `IMDCT.transform: mdctBuffers[${this.fftSize}].real is required`
+      )
+    const imag =
+      buffers?.imag ??
+      throwError(
+        `IMDCT.transform: mdctBuffers[${this.fftSize}].imag is required`
+      )
 
     const n4 = this.quarterSize
     const n34 = 3 * n4

package/codec/transforms/qmf.js

@@ -22,7 +22,7 @@ export function qmfAnalysis(input, delayLine, qmfWorkBuffers = null) {
 
   const workBuffer =
     qmfWorkBuffers?.delay?.[inputLength] ??
-    throwError('qmfAnalysis: workBuffer is required')
+    throwError(`qmfAnalysis: qmfWorkBuffers.delay[${inputLength}] is required`)
   workBuffer.set(delayLine)
   workBuffer.set(input, delayLine.length)
 
@@ -68,7 +68,9 @@ export function qmfSynthesis(
 
   const workBuffer =
     qmfWorkBuffers?.delay?.[outputLength] ??
-    throwError('qmfSynthesis: workBuffer is required')
+    throwError(
+      `qmfSynthesis: qmfWorkBuffers.delay[${outputLength}] is required`
+    )
   workBuffer.set(delayLine)
 
   // Upsample and merge