carta1 1.0.17 → 1.0.19

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/core/constants.js

@@ -244,6 +244,17 @@ export const FFT_SIZE_LOW = 128
 export const FFT_SIZE_MID = 128
 export const FFT_SIZE_HIGH = 256
 
+// MDCT/IMDCT transform configuration
+export const MDCT_BAND_CONFIGS = [
+  { size: 128, windowStart: 48 }, // Low band (0-5.5kHz)
+  { size: 128, windowStart: 48 }, // Mid band (5.5-11kHz)
+  { size: 256, windowStart: 112 }, // High band (11-22kHz)
+]
+
+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
 

package/codec/pipeline/decoder.js

@@ -13,7 +13,12 @@
  * containing buffer pools and decoding options.
  */
 
-import { pipe, throwError } from '../utils.js'
+import {
+  pipe,
+  throwError,
+  reverseSpectrum,
+  extractBandCoefficients,
+} from '../utils.js'
 import { qmfSynthesis } from '../transforms/qmf.js'
 import { imdct64, imdct256, imdct512, overlapAdd } from '../transforms/mdct.js'
 import { dequantize } from '../coding/quantization.js'
@@ -25,6 +30,9 @@ import {
   WORD_LENGTH_BITS,
   WINDOW_SHORT,
   MDCT_SIZE_LONG,
+  MDCT_BAND_CONFIGS,
+  MDCT_SHORT_BLOCK_SIZE,
+  MDCT_TAIL_WINDOW_SIZE,
 } from '../core/constants.js'
 
 /**
@@ -110,89 +118,194 @@ export function imdctStage(context) {
     context?.bufferPool ?? throwError('imdctStage: bufferPool is required')
   const overlapBuffers = bufferPool.imdctOverlap
 
+  // Transform function mapping for each band
+  const TRANSFORM_FUNCS = [imdct256, imdct256, imdct512]
+
   /**
-   * 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
-   * @returns {Array<Float32Array>} Three reconstructed frequency bands [low, mid, high]
+   * Inverse transform a single frequency band
    */
-  return (input) => {
-    const [coefficients, blockModes] = input
-    const bands = []
-
-    const bandCoeffs = [
-      coefficients.subarray(0, 128),
-      coefficients.subarray(128, 256),
-      coefficients.subarray(256, 512),
-    ]
-
-    for (let band = 0; band < 3; band++) {
-      const bandSize = band === 2 ? 256 : 128
-      const numBlocks = 1 << blockModes[band]
-      const blockSize = numBlocks === 1 ? bandSize : 32
-
-      const imdctFunc =
-        numBlocks === 1 ? (band === 2 ? imdct512 : imdct256) : imdct64
-
-      const invBuf = bufferPool.transformBuffers[MDCT_SIZE_LONG]
-      invBuf.fill(0)
-      const dstBuf = overlapBuffers[band]
-      const prevBuf = dstBuf.slice(bandSize * 2 - 16, bandSize * 2)
-
-      let start = 0
-      let pos = 0
-
-      for (let block = 0; block < numBlocks; block++) {
-        let blockSpecs = bandCoeffs[band].slice(pos, pos + blockSize)
-
-        // Reverse spectral reversal for mid and high bands
-        if (band > 0) {
-          const reversed = bufferPool.reversalBuffers[blockSpecs.length]
-          for (let i = 0; i < blockSpecs.length; i++) {
-            reversed[i] = blockSpecs[blockSpecs.length - 1 - i]
-          }
-          blockSpecs = reversed
-        }
-
-        const inv = imdctFunc.transform(blockSpecs, bufferPool.mdctBuffers)
-        const invStart = inv.length / 4
-
-        for (let i = 0; i < blockSize; i++) {
-          invBuf[start + i] = inv[invStart + i]
-        }
-
-        const dstPart = overlapAdd(
-          prevBuf.slice(0, 16),
-          invBuf.slice(start, start + 16),
-          WINDOW_SHORT
-        )
+  function transformBand(
+    coeffs,
+    bandIndex,
+    blockMode,
+    overlapBuffer,
+    bufferPool,
+    config
+  ) {
+    const isLongBlock = blockMode === 0
+    const transformFunc = TRANSFORM_FUNCS[bandIndex]
+
+    if (isLongBlock) {
+      return inverseLongBlock(
+        coeffs,
+        bandIndex,
+        overlapBuffer,
+        bufferPool,
+        config,
+        transformFunc
+      )
+    } else {
+      return inverseShortBlocks(
+        coeffs,
+        bandIndex,
+        overlapBuffer,
+        bufferPool,
+        config
+      )
+    }
+  }
 
-        dstBuf.set(dstPart, start)
+  /**
+   * Inverse transform using long block
+   */
+  function inverseLongBlock(
+    coeffs,
+    bandIndex,
+    overlapBuffer,
+    bufferPool,
+    config,
+    transformFunc
+  ) {
+    // Unreverse spectral reversal for mid/high bands
+    let blockSpecs = coeffs
+    if (bandIndex > 0) {
+      blockSpecs = reverseSpectrum(coeffs, bufferPool.reversalBuffers)
+    }
+
+    // Apply inverse transform
+    const inv = transformFunc.transform(blockSpecs, bufferPool.mdctBuffers)
+    const invStart = inv.length / 4
 
-        for (let i = 0; i < 16; i++) {
-          prevBuf[i] = invBuf[start + 16 + i]
-        }
+    // Prepare output buffer
+    const invBuf = bufferPool.transformBuffers[MDCT_SIZE_LONG]
+    invBuf.fill(0)
+
+    // Copy transformed samples
+    for (let i = 0; i < config.size; i++) {
+      invBuf[i] = inv[invStart + i]
+    }
+
+    // Handle overlap-add with previous frame
+    const prevBuf = overlapBuffer.slice(
+      config.size * 2 - MDCT_TAIL_WINDOW_SIZE,
+      config.size * 2
+    )
+    const dstPart = overlapAdd(
+      prevBuf.slice(0, MDCT_TAIL_WINDOW_SIZE),
+      invBuf.slice(0, MDCT_TAIL_WINDOW_SIZE),
+      WINDOW_SHORT
+    )
 
-        start += blockSize
-        pos += blockSize
+    overlapBuffer.set(dstPart, 0)
+
+    // Save tail for next frame
+    for (let i = 0; i < MDCT_TAIL_WINDOW_SIZE; i++) {
+      prevBuf[i] = invBuf[MDCT_TAIL_WINDOW_SIZE + i]
+    }
+
+    // Copy main samples
+    const copyLen = bandIndex === 2 ? 240 : 112
+    for (let i = 0; i < copyLen; i++) {
+      overlapBuffer[32 + i] = invBuf[MDCT_TAIL_WINDOW_SIZE + i]
+    }
+
+    // Copy final samples
+    for (let i = 0; i < MDCT_TAIL_WINDOW_SIZE; i++) {
+      overlapBuffer[config.size * 2 - MDCT_TAIL_WINDOW_SIZE + i] =
+        invBuf[config.size - MDCT_TAIL_WINDOW_SIZE + i]
+    }
+
+    return overlapBuffer.slice(0, config.size)
+  }
+
+  /**
+   * Inverse transform using short blocks
+   */
+  function inverseShortBlocks(
+    coeffs,
+    bandIndex,
+    overlapBuffer,
+    bufferPool,
+    config
+  ) {
+    const numBlocks = 1 << (config.size === 256 ? 3 : 2)
+    const invBuf = bufferPool.transformBuffers[MDCT_SIZE_LONG]
+    invBuf.fill(0)
+
+    const prevBuf = overlapBuffer.slice(
+      config.size * 2 - MDCT_TAIL_WINDOW_SIZE,
+      config.size * 2
+    )
+
+    let start = 0
+    let pos = 0
+
+    for (let block = 0; block < numBlocks; block++) {
+      // Extract block coefficients
+      let blockSpecs = coeffs.slice(pos, pos + MDCT_SHORT_BLOCK_SIZE)
+
+      // Unreverse spectral reversal for mid/high bands
+      if (bandIndex > 0) {
+        blockSpecs = reverseSpectrum(blockSpecs, bufferPool.reversalBuffers)
       }
 
-      if (numBlocks === 1) {
-        const copyLen = band === 2 ? 240 : 112
-        for (let i = 0; i < copyLen; i++) {
-          dstBuf[32 + i] = invBuf[16 + i]
-        }
+      // Apply inverse transform
+      const inv = imdct64.transform(blockSpecs, bufferPool.mdctBuffers)
+      const invStart = inv.length / 4
+
+      // Copy to intermediate buffer
+      for (let i = 0; i < MDCT_SHORT_BLOCK_SIZE; i++) {
+        invBuf[start + i] = inv[invStart + i]
       }
 
-      for (let i = 0; i < 16; i++) {
-        dstBuf[bandSize * 2 - 16 + i] = invBuf[bandSize - 16 + i]
+      // Overlap-add with previous block
+      const dstPart = overlapAdd(
+        prevBuf.slice(0, MDCT_TAIL_WINDOW_SIZE),
+        invBuf.slice(start, start + MDCT_TAIL_WINDOW_SIZE),
+        WINDOW_SHORT
+      )
+
+      overlapBuffer.set(dstPart, start)
+
+      // Save tail for next block
+      for (let i = 0; i < MDCT_TAIL_WINDOW_SIZE; i++) {
+        prevBuf[i] = invBuf[start + MDCT_TAIL_WINDOW_SIZE + i]
       }
 
-      bands.push(dstBuf.slice(0, bandSize))
+      start += MDCT_SHORT_BLOCK_SIZE
+      pos += MDCT_SHORT_BLOCK_SIZE
+    }
+
+    // Copy final tail samples
+    for (let i = 0; i < MDCT_TAIL_WINDOW_SIZE; i++) {
+      overlapBuffer[config.size * 2 - MDCT_TAIL_WINDOW_SIZE + i] =
+        invBuf[config.size - MDCT_TAIL_WINDOW_SIZE + i]
     }
 
-    return bands
+    return overlapBuffer.slice(0, config.size)
+  }
+
+  /**
+   * 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
+   * @returns {Array<Float32Array>} Three reconstructed frequency bands [low, mid, high]
+   */
+  return (input) => {
+    const [coefficients, blockModes] = input
+
+    return MDCT_BAND_CONFIGS.map((config, bandIndex) => {
+      const bandCoeffs = extractBandCoefficients(coefficients, bandIndex)
+      return transformBand(
+        bandCoeffs,
+        bandIndex,
+        blockModes[bandIndex],
+        overlapBuffers[bandIndex],
+        bufferPool,
+        config
+      )
+    })
   }
 }
 

package/codec/pipeline/encoder.js

@@ -14,7 +14,12 @@
  * containing buffer pools and encoding options.
  */
 
-import { pipe, throwError } from '../utils.js'
+import {
+  pipe,
+  throwError,
+  reverseSpectrum,
+  calculateBandOffset,
+} from '../utils.js'
 import { qmfAnalysis } from '../transforms/qmf.js'
 import { mdct64, mdct256, mdct512 } from '../transforms/mdct.js'
 import {
@@ -34,6 +39,9 @@ import {
   MDCT_SIZE_SHORT,
   MDCT_SIZE_MID,
   MDCT_SIZE_LONG,
+  MDCT_BAND_CONFIGS,
+  MDCT_SHORT_BLOCK_SIZE,
+  MDCT_OVERLAP_SIZE,
 } from '../core/constants.js'
 import { performFFT, detectTransient } from '../analysis/transient.js'
 import { psychoAnalysis } from '../analysis/psychoacoustics.js'
@@ -122,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,
     }
   }
 }
@@ -180,6 +170,130 @@ export function mdctStage(context) {
     context?.bufferPool ?? throwError('mdctStage: bufferPool is required')
   const overlapBuffers = bufferPool.mdctOverlap
 
+  // Transform function mapping for each band
+  const TRANSFORM_FUNCS = [mdct256, mdct256, mdct512]
+
+  /**
+   * Transform a single frequency band using MDCT
+   */
+  function transformBand(
+    samples,
+    bandIndex,
+    blockMode,
+    overlapBuffer,
+    bufferPool
+  ) {
+    const config = MDCT_BAND_CONFIGS[bandIndex]
+    const transformFunc = TRANSFORM_FUNCS[bandIndex]
+    const isLongBlock = blockMode === 0
+
+    if (isLongBlock) {
+      return transformLongBlock(
+        samples,
+        bandIndex,
+        config,
+        transformFunc,
+        overlapBuffer,
+        bufferPool
+      )
+    } else {
+      return transformShortBlocks(
+        samples,
+        bandIndex,
+        config,
+        overlapBuffer,
+        bufferPool
+      )
+    }
+  }
+
+  /**
+   * Transform using long block (better frequency resolution)
+   */
+  function transformLongBlock(
+    samples,
+    bandIndex,
+    config,
+    transformFunc,
+    overlapBuffer,
+    bufferPool
+  ) {
+    const mdctSize = bandIndex === 2 ? MDCT_SIZE_LONG : MDCT_SIZE_MID
+    const mdctInput = bufferPool.transformBuffers[mdctSize]
+    mdctInput.fill(0)
+
+    // Apply overlap from previous frame
+    mdctInput.set(overlapBuffer, config.windowStart)
+
+    // Window and save tail for next frame
+    applyTailWindowing(samples, overlapBuffer, config.size)
+
+    // Add current frame samples
+    mdctInput.set(samples, config.windowStart + MDCT_OVERLAP_SIZE)
+
+    // Transform
+    let spectrum = transformFunc.transform(mdctInput, bufferPool.mdctBuffers)
+
+    // Apply spectral reversal for mid/high bands
+    if (bandIndex > 0) {
+      spectrum = reverseSpectrum(spectrum, bufferPool.reversalBuffers)
+    }
+
+    return spectrum
+  }
+
+  /**
+   * Transform using short blocks (better time resolution for transients)
+   */
+  function transformShortBlocks(
+    samples,
+    bandIndex,
+    config,
+    overlapBuffer,
+    bufferPool
+  ) {
+    const numBlocks = 1 << (config.size === 256 ? 3 : 2) // 8 for band 2, 4 for bands 0-1
+    const output = new Float32Array(config.size)
+
+    for (let block = 0; block < numBlocks; block++) {
+      const blockStart = block * MDCT_SHORT_BLOCK_SIZE
+      const blockSamples = samples.subarray(
+        blockStart,
+        blockStart + MDCT_SHORT_BLOCK_SIZE
+      )
+
+      // Prepare MDCT input
+      const mdctInput = bufferPool.transformBuffers[MDCT_SIZE_SHORT]
+      mdctInput.fill(0)
+      mdctInput.set(overlapBuffer, 0)
+
+      // Window and save tail
+      applyTailWindowing(blockSamples, overlapBuffer, MDCT_SHORT_BLOCK_SIZE)
+      mdctInput.set(blockSamples, MDCT_OVERLAP_SIZE)
+
+      // Transform
+      let spectrum = mdct64.transform(mdctInput, bufferPool.mdctBuffers)
+
+      // Apply spectral reversal for mid/high bands
+      if (bandIndex > 0) {
+        spectrum = reverseSpectrum(spectrum, bufferPool.reversalBuffers)
+      }
+
+      output.set(spectrum, blockStart)
+    }
+
+    return output
+  }
+
+  function applyTailWindowing(samples, overlapBuffer, blockSize) {
+    const tailStart = blockSize - MDCT_OVERLAP_SIZE
+    for (let i = 0; i < MDCT_OVERLAP_SIZE; i++) {
+      const tailValue = samples[tailStart + i]
+      overlapBuffer[i] = WINDOW_SHORT[i] * tailValue
+      samples[tailStart + i] = tailValue * WINDOW_SHORT[31 - i]
+    }
+  }
+
   /**
    * Transform frequency bands using MDCT
    * @param {Object} input - Block selection results
@@ -194,60 +308,20 @@ export function mdctStage(context) {
    */
   return (input) => {
     const { bands, blockModes, originalFrame } = input
-
     const coefficients = new Float32Array(512)
 
-    for (let band = 0; band < 3; band++) {
-      const samples = bands[band]
-      const bandSize = band === 2 ? 256 : 128
-      const numBlocks = 1 << blockModes[band]
-      const blockSize = numBlocks === 1 ? bandSize : 32
-
-      const mdctFunc =
-        numBlocks === 1 ? (band === 2 ? mdct512 : mdct256) : mdct64
-      const mdctSize =
-        numBlocks === 1
-          ? band === 2
-            ? MDCT_SIZE_LONG
-            : MDCT_SIZE_MID
-          : MDCT_SIZE_SHORT
-      const windowStart = numBlocks === 1 ? (band === 2 ? 112 : 48) : 0
-
-      const offset = band === 0 ? 0 : band === 1 ? 128 : 256
-
-      for (let block = 0; block < numBlocks; block++) {
-        const blockStart = block * blockSize
-        const mdctInput = bufferPool.transformBuffers[mdctSize]
-        mdctInput.fill(0)
-
-        mdctInput.set(overlapBuffers[band], windowStart)
-
-        for (let i = 0; i < 32; i++) {
-          const tailValue = samples[blockStart + blockSize - 32 + i]
-          overlapBuffers[band][i] = WINDOW_SHORT[i] * tailValue
-          samples[blockStart + blockSize - 32 + i] =
-            tailValue * WINDOW_SHORT[31 - i]
-        }
-
-        mdctInput.set(
-          samples.subarray(blockStart, blockStart + blockSize),
-          windowStart + 32
-        )
-
-        let spectrum = mdctFunc.transform(mdctInput, bufferPool.mdctBuffers)
-
-        if (band > 0) {
-          const reversed = bufferPool.reversalBuffers[spectrum.length]
-          reversed.fill(0)
-          for (let i = 0; i < spectrum.length; i++) {
-            reversed[i] = spectrum[spectrum.length - 1 - i]
-          }
-          spectrum = reversed
-        }
-
-        coefficients.set(spectrum, offset + blockStart)
-      }
-    }
+    bands.forEach((bandSamples, bandIndex) => {
+      const transformed = transformBand(
+        bandSamples,
+        bandIndex,
+        blockModes[bandIndex],
+        overlapBuffers[bandIndex],
+        bufferPool
+      )
+
+      const offset = calculateBandOffset(bandIndex)
+      coefficients.set(transformed, offset)
+    })
 
     return { bands, coefficients, blockModes, originalFrame }
   }

package/codec/utils.js

@@ -146,6 +146,46 @@ export function withStereo(monoTransform, ...args) {
   }
 }
 
+/**
+ * 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 {Float32Array} spectrum - Input spectrum coefficients
+ * @param {Object} reversalBuffers - Pre-allocated buffers for different spectrum sizes
+ * @returns {Float32Array} Spectrum with reversed coefficient order
+ */
+export function reverseSpectrum(spectrum, reversalBuffers) {
+  const reversed = reversalBuffers[spectrum.length]
+  for (let i = 0; i < spectrum.length; i++) {
+    reversed[i] = spectrum[spectrum.length - 1 - i]
+  }
+  return reversed
+}
+
+/**
+ * Calculates the starting offset for a frequency band in the coefficient array
+ *
+ * @param {number} bandIndex - Band index (0=low, 1=mid, 2=high)
+ * @returns {number} Starting offset in the 512-sample coefficient array
+ */
+export function calculateBandOffset(bandIndex) {
+  return bandIndex === 0 ? 0 : bandIndex === 1 ? 128 : 256
+}
+
+/**
+ * Extracts coefficients for a specific frequency band from the full coefficient array
+ *
+ * @param {Float32Array} coefficients - Full 512-sample coefficient array
+ * @param {number} bandIndex - Band index (0=low, 1=mid, 2=high)
+ * @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)