carta1 1.1.1 → 1.1.3

package/codec/coding/quantization.js

@@ -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
@@ -70,11 +69,10 @@ export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
 
   const scaleFactor = SCALE_FACTORS[scaleFactorIndex]
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
-  const denormFactor = scaleFactor / quantRange
 
   const deq = new Float32Array(quantized.length)
   for (let i = 0; i < quantized.length; i++) {
-    deq[i] = quantized[i] * denormFactor
+    deq[i] = (quantized[i] * scaleFactor) / quantRange
   }
   return deq
 }

package/codec/core/constants.js

@@ -6,7 +6,6 @@
 export const SAMPLE_RATE = 44100
 export const SAMPLES_PER_FRAME = 512
 export const FRAME_RATE = SAMPLE_RATE / SAMPLES_PER_FRAME
-export const CODEC_DELAY = 266
 
 // AEA file format
 export const AEA_MAGIC = new Uint8Array([0x00, 0x08, 0x00, 0x00])
@@ -37,16 +36,6 @@ export const BFU_AMOUNTS_COUNT = 8
 export const BFU_AMOUNTS = new Int32Array([20, 28, 32, 36, 40, 44, 48, 52])
 export const BFU_BAND_BOUNDARIES = new Int32Array([20, 36, 52])
 
-// BFU center frequencies (Hz)
-export const BFU_FREQUENCIES = new Float32Array([
-  172.3, 516.8, 861.3, 1205.9, 1464.3, 1636.5, 1808.8, 1981.1, 2239.5, 2584.0,
-  2928.5, 3273.0, 3574.5, 3832.9, 4091.3, 4349.7, 4608.1, 4866.5, 5124.9,
-  5383.3, 5641.7, 5900.1, 6158.5, 6416.9, 6696.8, 6998.3, 7299.8, 7601.2,
-  7945.8, 8333.3, 8720.9, 9108.5, 9517.7, 9948.3, 10379.0, 10809.7, 11283.4,
-  11800.2, 12317.0, 12833.8, 13350.6, 13867.4, 14384.2, 14901.0, 15590.0,
-  16451.4, 17312.7, 18174.0, 19035.4, 19896.7, 20758.0, 21619.3,
-])
-
 // BFU start positions
 export const BFU_START_LONG = new Int32Array([
   0, 8, 16, 24, 32, 36, 40, 44, 48, 56, 64, 72, 80, 86, 92, 98, 104, 110, 116,
@@ -69,7 +58,7 @@ export const MDCT_SIZE_LONG = 512
 
 // Window functions
 export const WINDOW_SHORT = (() => {
-  const table = new Float32Array(32)
+  const table = new Float64Array(32)
   for (let i = 0; i < 32; i++) {
     table[i] = Math.sin(((i + 0.5) * Math.PI) / 64)
   }
@@ -117,40 +106,6 @@ export const QMF_ODD = (() => {
   return odd
 })()
 
-// Psychoacoustic model
-export const BARK_SCALE = (() => {
-  const table = new Float32Array(NUM_BFUS)
-  for (let i = 0; i < NUM_BFUS; i++) {
-    const freq = BFU_FREQUENCIES[i]
-    table[i] =
-      13.0 * Math.atan(0.00076 * freq) + 3.5 * Math.atan((freq / 7500) ** 2)
-  }
-  return table
-})()
-
-export const SPREADING_MATRIX = (() => {
-  const matrix = new Float32Array(NUM_BFUS * NUM_BFUS)
-  for (let masker = 0; masker < NUM_BFUS; masker++) {
-    for (let masked = 0; masked < NUM_BFUS; masked++) {
-      const distance = BARK_SCALE[masker] - BARK_SCALE[masked]
-      let spreading = -100.0
-
-      if (distance >= -3.0 && distance < -1.0) {
-        spreading = 17.0 * (distance + 3.0) - 70.0
-      } else if (distance >= -1.0 && distance < 0) {
-        spreading = 36.0 * distance
-      } else if (distance >= 0 && distance < 1.0) {
-        spreading = -27.0 * distance
-      } else if (distance >= 1.0 && distance < 8.0) {
-        spreading = -(distance - 1.0) * 4.0 - 27.0
-      }
-
-      matrix[masker * NUM_BFUS + masked] = spreading
-    }
-  }
-  return matrix
-})()
-
 // FFT sizes for transient detection
 export const FFT_SIZE_LOW = 128
 export const FFT_SIZE_MID = 128
@@ -167,9 +122,6 @@ export const MDCT_SHORT_BLOCK_SIZE = 32
 export const MDCT_OVERLAP_SIZE = 32
 export const MDCT_TAIL_WINDOW_SIZE = 16
 
-// Quantization
-export const QUANTIZATION_SIGN_BIT_SHIFT = 1
-
 // WAV format
 export const WAV_HEADER_SIZE = 44
 export const WAV_BYTES_PER_SAMPLE = 2
@@ -184,40 +136,20 @@ export const FRAME_WORD_LENGTH_BITS = 4
 export const FRAME_SCALE_FACTOR_BITS = 6
 
 // Quantization
+export const QUANTIZATION_SIGN_BIT_SHIFT = 1
 export const MAX_WORD_LENGTH_INDEX = 15
 export const WORD_LENGTH_BITS = new Int32Array([
   0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
 ])
-export const QUANT_DISTORTION_TABLE = (() => {
-  const table = new Float32Array(MAX_WORD_LENGTH_INDEX + 1)
-  table[0] = 1.0
-  for (let wl = 1; wl <= MAX_WORD_LENGTH_INDEX; wl++) {
-    const bitsPerSample = WORD_LENGTH_BITS[wl]
-    const quantRange = (1 << (bitsPerSample - 1)) - 1
-    table[wl] = 1.0 / (12.0 * quantRange * quantRange)
-  }
-  return table
-})()
-export const DISTORTION_DELTA_DB = (() => {
-  const table = new Float32Array(MAX_WORD_LENGTH_INDEX)
-  for (let i = 0; i < MAX_WORD_LENGTH_INDEX; i++) {
-    table[i] =
-      10 *
-      Math.log10(
-        QUANT_DISTORTION_TABLE[i + 1] / (QUANT_DISTORTION_TABLE[i] || 1.0)
-      )
-  }
-  return table
-})()
 export const SCALE_FACTORS = (() => {
-  const table = new Float32Array(64)
+  const table = new Float64Array(64)
   for (let i = 0; i < 64; i++) {
     table[i] = Math.pow(2.0, i / 3.0 - 21)
   }
   return table
 })()
 
-// RDO bit allocation
+// Bit allocation
 export const INV_POWER_OF_TWO = (() => {
   const maxBits = WORD_LENGTH_BITS[MAX_WORD_LENGTH_INDEX]
   const table = new Float64Array(maxBits + 1)

package/codec/io/processor.js

@@ -30,12 +30,6 @@ import {
   WAV_DATA_OFFSET,
 } from '../core/constants.js'
 import { serializeFrame, deserializeFrame, AeaFile } from './serialization.js'
-import {
-  withFlushSamples,
-  withDelayCompensation,
-  withStereoFlushSamples,
-  withStereoDelayCompensation,
-} from '../utils.js'
 
 /**
  * Audio processing utility class providing high-level encoding and decoding operations
@@ -83,7 +77,7 @@ export class AudioProcessor {
     const options = encoderOptions || new EncoderOptions()
     const encoder = encode(options)
     let frameIndex = 0
-    for await (const frame of withFlushSamples(audioFrames)) {
+    for await (const frame of audioFrames) {
       const result = encoder(frame)
       yield result
 
@@ -107,9 +101,7 @@ export class AudioProcessor {
     const rightEncoder = encode(options)
     let frameIndex = 0
 
-    for await (const [leftFrame, rightFrame] of withStereoFlushSamples(
-      audioFrames
-    )) {
+    for await (const [leftFrame, rightFrame] of audioFrames) {
       const leftResult = leftEncoder(leftFrame)
       const rightResult = rightEncoder(rightFrame)
 
@@ -167,7 +159,7 @@ export class AudioProcessor {
     }
 
     // Always apply delay compensation
-    yield* withDelayCompensation(rawPcmFrames())
+    yield* rawPcmFrames()
   }
 
   /**
@@ -220,7 +212,7 @@ export class AudioProcessor {
     }
 
     // Always apply stereo delay compensation
-    yield* withStereoDelayCompensation(rawPcmFrames())
+    yield* rawPcmFrames()
   }
 
   /**

package/codec/pipeline/decoder.js

@@ -361,7 +361,7 @@ export function qmfSynthesisStage(context) {
     // 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/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 {Float32Array} real - Real part of the input/output data
-   * @param {Float32Array} 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 Float32Array(halfN)
-    const sinTbl = new Float32Array(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

@@ -28,7 +28,7 @@ class MDCTBase {
     const omega = (2.0 * Math.PI) / size
     const scaleRoot = Math.sqrt(scale / size)
 
-    this.sinCosTable = new Float32Array(this.halfSize)
+    this.sinCosTable = new Float64Array(this.halfSize)
     for (let i = 0; i < this.quarterSize; i++) {
       const angle = omega * i + alpha
       this.sinCosTable[i * 2] = scaleRoot * Math.cos(angle)
@@ -160,13 +160,13 @@ export class IMDCT extends MDCTBase {
     // Pre-FFT processing
     for (let i = 0; i < this.fftSize; i++) {
       const i2 = i * 2
-      const r = input[i2]
-      const im = input[this.halfSize - 1 - i2]
+      const r = -input[i2]
+      const im = -input[this.halfSize - 1 - i2]
       const c = this.sinCosTable[i2]
       const s = this.sinCosTable[i2 + 1]
 
-      real[i] = -2.0 * (im * s + r * c)
-      imag[i] = -2.0 * (im * c - r * s)
+      real[i] = im * s + r * c
+      imag[i] = im * c - r * s
     }
 
     FFT.fft(real, imag)
@@ -216,9 +216,9 @@ export const mdct64 = new MDCT(MDCT_SIZE_SHORT, 0.5)
 export const mdct256 = new MDCT(MDCT_SIZE_MID, 0.5)
 export const mdct512 = new MDCT(MDCT_SIZE_LONG, 1.0)
 
-export const imdct64 = new IMDCT(MDCT_SIZE_SHORT, MDCT_SIZE_SHORT * 4)
-export const imdct256 = new IMDCT(MDCT_SIZE_MID, MDCT_SIZE_MID * 4)
-export const imdct512 = new IMDCT(MDCT_SIZE_LONG, MDCT_SIZE_LONG * 2)
+export const imdct64 = new IMDCT(MDCT_SIZE_SHORT, MDCT_SIZE_SHORT * 8)
+export const imdct256 = new IMDCT(MDCT_SIZE_MID, MDCT_SIZE_MID * 8)
+export const imdct512 = new IMDCT(MDCT_SIZE_LONG, MDCT_SIZE_LONG * 4)
 
 /**
  * Perform overlap-add operation for MDCT reconstruction

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,121 +29,6 @@ export function pipe(context, ...stages) {
   }
 }
 
-/**
- * Pads audio frames and adds flush samples for proper codec delay handling
- * @param {AsyncIterable<Float32Array>} iter - Input frame stream
- * @param {number} [samplesToFlush=CODEC_DELAY] - Number of samples to flush
- * @yields {Float32Array} 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 Float32Array(SAMPLES_PER_FRAME)
-      paddedFrame.set(frame)
-      yield paddedFrame
-    }
-  }
-  if (SAMPLES_PER_FRAME - lastFrameLength < samplesToFlush) {
-    yield new Float32Array(SAMPLES_PER_FRAME)
-  }
-}
-
-/**
- * Applies delay compensation to PCM frame stream by dropping initial samples
- * @param {AsyncIterable<Float32Array>} pcmFrameStream - Input PCM frame stream
- * @param {number} [samplesToDrop=CODEC_DELAY] - Number of samples to drop for delay compensation
- * @yields {Float32Array} Delay-compensated PCM frames
- */
-export async function* withDelayCompensation(
-  pcmFrameStream,
-  samplesToDrop = CODEC_DELAY
-) {
-  let buffer = new Float32Array(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 Float32Array(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
  *
@@ -185,7 +68,3 @@ 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)