carta1 1.0.20 → 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/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