carta1 1.1.2 → 1.1.4

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,69 @@
 /**
  * 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()
 
+export class FFT {
   /**
-   * 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 <= 1) return
-
-    let cache = FFT._cache.get(n)
-    if (!cache) {
-      cache = FFT._buildCache(n)
-      FFT._cache.set(n, cache)
-    }
+    const size = real.length
+    if (size === 1) return
 
-    const bitRev = cache.bitRev
-    const cosTbl = cache.cos
-    const sinTbl = cache.sin
+    const bits = Math.log2(size)
 
     // 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
+    for (let i = 0; i < size; i++) {
+      let reversed = 0
+      let temp = i
+      for (let b = 0; b < bits; b++) {
+        reversed = (reversed << 1) | (temp & 1)
+        temp >>= 1
+      }
+      if (reversed > i) {
+        ;[real[i], real[reversed]] = [real[reversed], real[i]]
+        ;[imag[i], imag[reversed]] = [imag[reversed], imag[i]]
       }
     }
 
-    // First stage: stride=2
-    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
-    }
+    // Cooley-Tukey decimation-in-time
+    for (let stride = 2; stride <= size; stride <<= 1) {
+      const halfStride = stride >> 1
+      const angle = (-2 * Math.PI) / stride
+      const wReal = Math.cos(angle)
+      const wImag = Math.sin(angle)
 
-    // Second stage: stride=4
-    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
+      for (let start = 0; start < size; start += stride) {
+        let twiddleReal = 1
+        let twiddleImag = 0
 
-        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
-      }
-    }
+        for (let k = 0; k < halfStride; k++) {
+          const evenIndex = start + k
+          const oddIndex = evenIndex + halfStride
 
-    // Higher stages
-    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
+          const evenReal = real[evenIndex]
+          const evenImag = imag[evenIndex]
+          const oddReal = real[oddIndex]
+          const oddImag = imag[oddIndex]
 
-        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 tReal = oddReal * twiddleReal - oddImag * twiddleImag
+          const tImag = oddReal * twiddleImag + oddImag * twiddleReal
+
+          real[evenIndex] = evenReal + tReal
+          imag[evenIndex] = evenImag + tImag
+          real[oddIndex] = evenReal - tReal
+          imag[oddIndex] = evenImag - tImag
+
+          const nextReal = twiddleReal * wReal - twiddleImag * wImag
+          twiddleImag = twiddleReal * wImag + twiddleImag * wReal
+          twiddleReal = nextReal
         }
       }
     }
   }
-
-  /**
-   * 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)
-    }
-    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++) {

package/codec/utils.js

@@ -6,8 +6,6 @@
  * for delay compensation and frame padding.
  */
 
-import { CODEC_DELAY, SAMPLES_PER_FRAME } from './core/constants.js'
-
 /**
  * Throws an error with the given message
  * @param {string} msg - Error message
@@ -31,130 +29,15 @@ export function pipe(context, ...stages) {
   }
 }
 
-/**
- * Pads audio frames and adds flush samples for proper codec delay handling
- * @param {AsyncIterable<Float64Array>} iter - Input frame stream
- * @param {number} [samplesToFlush=CODEC_DELAY] - Number of samples to flush
- * @yields {Float64Array} Padded frames with flush samples
- */
-export async function* withFlushSamples(iter, samplesToFlush = CODEC_DELAY) {
-  let lastFrameLength = SAMPLES_PER_FRAME
-  for await (const frame of iter) {
-    lastFrameLength = frame.length
-    if (lastFrameLength === SAMPLES_PER_FRAME) {
-      yield frame
-    } else {
-      // We need to pad
-      const paddedFrame = new Float64Array(SAMPLES_PER_FRAME)
-      paddedFrame.set(frame)
-      yield paddedFrame
-    }
-  }
-  if (SAMPLES_PER_FRAME - lastFrameLength < samplesToFlush) {
-    yield new Float64Array(SAMPLES_PER_FRAME)
-  }
-}
-
-/**
- * Applies delay compensation to PCM frame stream by dropping initial samples
- * @param {AsyncIterable<Float64Array>} pcmFrameStream - Input PCM frame stream
- * @param {number} [samplesToDrop=CODEC_DELAY] - Number of samples to drop for delay compensation
- * @yields {Float64Array} Delay-compensated PCM frames
- */
-export async function* withDelayCompensation(
-  pcmFrameStream,
-  samplesToDrop = CODEC_DELAY
-) {
-  let buffer = new Float64Array(0)
-  let droppedInitialSamples = false
-
-  for await (const frame of pcmFrameStream) {
-    // Drop samples from the very first frame only
-    if (!droppedInitialSamples) {
-      droppedInitialSamples = true
-      if (samplesToDrop >= frame.length) {
-        // Entire first frame is dropped
-        samplesToDrop -= frame.length
-        continue
-      }
-      // Keep only the portion after dropped samples
-      buffer = frame.slice(samplesToDrop)
-      samplesToDrop = 0
-      continue
-    }
-
-    // Concatenate buffer with new frame
-    const combined = new Float64Array(buffer.length + frame.length)
-    combined.set(buffer)
-    combined.set(frame, buffer.length)
-
-    // Emit all complete frames
-    let offset = 0
-    while (offset + SAMPLES_PER_FRAME <= combined.length) {
-      yield combined.slice(offset, offset + SAMPLES_PER_FRAME)
-      offset += SAMPLES_PER_FRAME
-    }
-
-    // Buffer the remainder for next iteration
-    buffer = combined.slice(offset)
-  }
-
-  // Emit final partial frame
-  if (buffer.length > 0) {
-    yield buffer
-  }
-}
-
-/**
- * Adapts a mono transform function to work with stereo audio streams
- * @param {Function} monoTransform - Transform function for mono audio
- * @param {...*} args - Additional arguments to pass to the transform
- * @returns {Function} Stereo-adapted transform function
- */
-export function withStereo(monoTransform, ...args) {
-  return async function* (stereoIter) {
-    // Buffer to store frames temporarily
-    const leftFrames = []
-    const rightFrames = []
-
-    // Collect all frames first (necessary for proper synchronization)
-    for await (const [left, right] of stereoIter) {
-      leftFrames.push(left)
-      rightFrames.push(right)
-    }
-
-    // Create mono iterators
-    const leftIter = (async function* () {
-      for (const frame of leftFrames) yield frame
-    })()
-
-    const rightIter = (async function* () {
-      for (const frame of rightFrames) yield frame
-    })()
-
-    // Apply transform to each channel
-    const leftTransformed = monoTransform(leftIter, ...args)
-    const rightTransformed = monoTransform(rightIter, ...args)
-
-    // Zip back together
-    for await (const left of leftTransformed) {
-      const { value: right } = await rightTransformed.next()
-      if (right !== undefined) {
-        yield [left, right]
-      }
-    }
-  }
-}
-
 /**
  * Reverses the spectral order of coefficients for mid/high band processing
  *
  * Used in both MDCT and IMDCT stages to handle spectral reversal required
  * by the ATRAC1 format for mid and high frequency bands.
  *
- * @param {Float64Array} spectrum - Input spectrum coefficients
+ * @param {Float32Array} spectrum - Input spectrum coefficients
  * @param {Object} reversalBuffers - Pre-allocated buffers for different spectrum sizes
- * @returns {Float64Array} Spectrum with reversed coefficient order
+ * @returns {Float32Array} Spectrum with reversed coefficient order
  */
 export function reverseSpectrum(spectrum, reversalBuffers) {
   const reversed = reversalBuffers[spectrum.length]
@@ -177,15 +60,11 @@ export function calculateBandOffset(bandIndex) {
 /**
  * Extracts coefficients for a specific frequency band from the full coefficient array
  *
- * @param {Float64Array} coefficients - Full 512-sample coefficient array
+ * @param {Float32Array} coefficients - Full 512-sample coefficient array
  * @param {number} bandIndex - Band index (0=low, 1=mid, 2=high)
- * @returns {Float64Array} Subarray containing coefficients for the specified band
+ * @returns {Float32Array} Subarray containing coefficients for the specified band
  */
 export function extractBandCoefficients(coefficients, bandIndex) {
   const offsets = [0, 128, 256, 512]
   return coefficients.subarray(offsets[bandIndex], offsets[bandIndex + 1])
 }
-
-// Stereo-adapted utility functions
-export const withStereoFlushSamples = withStereo(withFlushSamples)
-export const withStereoDelayCompensation = withStereo(withDelayCompensation)