carta1 1.0.18 → 1.0.20

package/codec/core/buffers.js

@@ -40,11 +40,11 @@ export class BufferPool {
     }
 
     // Transient detector
-    this.transientDetection = {
-      prevLowCoeffs: new Float32Array(64),
-      prevMidCoeffs: new Float32Array(64),
-      prevHighCoeffs: new Float32Array(128),
-    }
+    this.transientDetection = [
+      new Float32Array(64),
+      new Float32Array(64),
+      new Float32Array(128),
+    ]
 
     // MDCT/IMDCT work buffers
     this.mdctBuffers = {

package/codec/pipeline/encoder.js

@@ -130,39 +130,21 @@ export function blockSelectorStage(context) {
    */
   return (input) => {
     const { bands } = input
-    const [lowBand, midBand, highBand] = bands
-
-    const lowCoeffs = performFFT(lowBand, FFT_SIZE_LOW)
-    const midCoeffs = performFFT(midBand, FFT_SIZE_MID)
-    const highCoeffs = performFFT(highBand, FFT_SIZE_HIGH)
-
-    const lowTransient = detectTransient(
-      lowCoeffs,
-      bufferPool.transientDetection.prevLowCoeffs,
-      options.transientThresholdLow
-    )
-    const midTransient = detectTransient(
-      midCoeffs,
-      bufferPool.transientDetection.prevMidCoeffs,
-      options.transientThresholdMid
-    )
-    const highTransient = detectTransient(
-      highCoeffs,
-      bufferPool.transientDetection.prevHighCoeffs,
-      options.transientThresholdHigh
-    )
-
-    bufferPool.transientDetection.prevLowCoeffs = lowCoeffs
-    bufferPool.transientDetection.prevMidCoeffs = midCoeffs
-    bufferPool.transientDetection.prevHighCoeffs = highCoeffs
+    const fftSizes = [FFT_SIZE_LOW, FFT_SIZE_MID, FFT_SIZE_HIGH]
+    const blockModes = bands.map((bandSamples, bandIndex) => {
+      const coeffs = performFFT(bandSamples, fftSizes[bandIndex])
+      const transient = detectTransient(
+        coeffs,
+        bufferPool.transientDetection[bandIndex],
+        options.transientThresholdLow
+      )
+      bufferPool.transientDetection[bandIndex] = coeffs
+      return transient * Math.max(bandIndex + 1, 2)
+    })
 
     return {
       bands,
-      blockModes: [
-        lowTransient ? 2 : 0,
-        midTransient ? 2 : 0,
-        highTransient ? 3 : 0,
-      ],
+      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 }
   }
 }