carta1 1.1.0 → 1.1.2

package/codec/core/constants.js

@@ -38,7 +38,7 @@ 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([
+export const BFU_FREQUENCIES = new Float64Array([
   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,
@@ -69,7 +69,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)
   }
@@ -82,7 +82,7 @@ export const QMF_DELAY = 46
 export const QMF_HIGH_BAND_DELAY = 39
 
 // QMF prototype filter coefficients
-export const QMF_COEFFS = new Float32Array([
+export const QMF_COEFFS = new Float64Array([
   -0.00001461907, -0.00009205479, -0.000056157569, 0.00030117269, 0.0002422519,
   -0.00085293897, -0.0005205574, 0.0020340169, 0.00078333891, -0.0042153862,
   -0.00075614988, 0.0078402944, -0.000061169922, -0.01344162, 0.0024626821,
@@ -92,7 +92,7 @@ export const QMF_COEFFS = new Float32Array([
 
 // QMF window function
 export const QMF_WINDOW = (() => {
-  const window = new Float32Array(QMF_TAPS)
+  const window = new Float64Array(QMF_TAPS)
   for (let i = 0; i < 24; i++) {
     window[i] = QMF_COEFFS[i] * 2.0
     window[47 - i] = QMF_COEFFS[i] * 2.0
@@ -102,7 +102,7 @@ export const QMF_WINDOW = (() => {
 
 // QMF even/odd taps for optimization
 export const QMF_EVEN = (() => {
-  const even = new Float32Array(24)
+  const even = new Float64Array(24)
   for (let i = 0; i < 24; i++) {
     even[i] = QMF_WINDOW[i * 2]
   }
@@ -110,47 +110,13 @@ export const QMF_EVEN = (() => {
 })()
 
 export const QMF_ODD = (() => {
-  const odd = new Float32Array(24)
+  const odd = new Float64Array(24)
   for (let i = 0; i < 24; i++) {
     odd[i] = QMF_WINDOW[i * 2 + 1]
   }
   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 +133,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,59 +147,25 @@ 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
-export const LP_DISTORTION_P = 4
-export const LP_DISTORTION_CONSTANT = 1 / 80 // For L4 (p=4), it's 1/80.
-export const { POW2_NEG_P, POW2_POS_P, SF_POW_P } = (() => {
-  // Calculate the 2^{-p*b} table
+// Bit allocation
+export const INV_POWER_OF_TWO = (() => {
   const maxBits = WORD_LENGTH_BITS[MAX_WORD_LENGTH_INDEX]
-  const pow2_neg_p = new Float64Array(maxBits + 1)
+  const table = new Float64Array(maxBits + 1)
   for (let b = 0; b <= maxBits; b++) {
-    pow2_neg_p[b] = Math.pow(2, -LP_DISTORTION_P * b)
+    table[b] = Math.pow(2, -b)
   }
-
-  // Calculate the 2^{p} constant for the D(0) case
-  const pow2_pos_p = Math.pow(2, LP_DISTORTION_P)
-
-  // Calculate the (scale_factor)^p table
-  const sfPowP = new Float64Array(SCALE_FACTORS.length)
-  for (let i = 0; i < SCALE_FACTORS.length; i++) {
-    sfPowP[i] = Math.pow(SCALE_FACTORS[i], LP_DISTORTION_P)
-  }
-
-  // Return all computed tables in a single object
-  return { POW2_NEG_P: pow2_neg_p, POW2_POS_P: pow2_pos_p, SF_POW_P: sfPowP }
+  return table
 })()

package/codec/io/processor.js

@@ -43,7 +43,7 @@ import {
 export class AudioProcessor {
   /**
    * Encodes a stream of audio frames to ATRAC1 format
-   * @param {AsyncIterable<Float32Array>|AsyncIterable<[Float32Array, Float32Array]>} audioFrames - Audio frame stream
+   * @param {AsyncIterable<Float64Array>|AsyncIterable<[Float64Array, Float64Array]>} audioFrames - Audio frame stream
    * @param {Object} [options={}] - Encoding options
    * @param {number} [options.channelCount=1] - Number of audio channels (1 or 2)
    * @param {Function} [options.onProgress] - Progress callback function
@@ -73,7 +73,7 @@ export class AudioProcessor {
 
   /**
    * Internal method for encoding mono audio streams
-   * @param {AsyncIterable<Float32Array>} audioFrames - Mono audio frame stream
+   * @param {AsyncIterable<Float64Array>} audioFrames - Mono audio frame stream
    * @param {Function} onProgress - Progress callback function
    * @param {EncoderOptions} encoderOptions - Encoder configuration
    * @returns {AsyncGenerator<Object>} Stream of encoded frame data
@@ -95,7 +95,7 @@ export class AudioProcessor {
 
   /**
    * Internal method for encoding stereo audio streams
-   * @param {AsyncIterable<[Float32Array, Float32Array]>} audioFrames - Stereo audio frame stream
+   * @param {AsyncIterable<[Float64Array, Float64Array]>} audioFrames - Stereo audio frame stream
    * @param {Function} onProgress - Progress callback function
    * @param {EncoderOptions} encoderOptions - Encoder configuration
    * @returns {AsyncGenerator<Object>} Stream of encoded frame data (left then right)
@@ -128,7 +128,7 @@ export class AudioProcessor {
    * @param {Object} [options={}] - Decoding options
    * @param {number} [options.channelCount=1] - Number of audio channels (1 or 2)
    * @param {Function} [options.onProgress] - Progress callback function
-   * @returns {AsyncGenerator<Float32Array>|AsyncGenerator<[Float32Array, Float32Array]>} Stream of decoded PCM frames
+   * @returns {AsyncGenerator<Float64Array>|AsyncGenerator<[Float64Array, Float64Array]>} Stream of decoded PCM frames
    * @throws {Error} If unsupported channel count is provided
    */
   static async *decodeStream(encodedFrames, options = {}) {
@@ -147,7 +147,7 @@ export class AudioProcessor {
    * Internal method for decoding mono audio streams
    * @param {AsyncIterable<Object>} encodedFrames - Mono encoded frame stream
    * @param {Function} onProgress - Progress callback function
-   * @returns {AsyncGenerator<Float32Array>} Stream of decoded mono PCM frames
+   * @returns {AsyncGenerator<Float64Array>} Stream of decoded mono PCM frames
    * @private
    */
   static async *_decodeMonoStream(encodedFrames, onProgress) {
@@ -174,7 +174,7 @@ export class AudioProcessor {
    * Internal method for decoding stereo audio streams
    * @param {AsyncIterable<Object>} encodedFrames - Stereo encoded frame stream (interleaved left/right)
    * @param {Function} onProgress - Progress callback function
-   * @returns {AsyncGenerator<[Float32Array, Float32Array]>} Stream of decoded stereo PCM frame pairs
+   * @returns {AsyncGenerator<[Float64Array, Float64Array]>} Stream of decoded stereo PCM frame pairs
    * @private
    */
   static async *_decodeStereoStream(encodedFrames, onProgress) {
@@ -225,9 +225,9 @@ export class AudioProcessor {
 
   /**
    * Converts channel buffer arrays to frame-based stream format
-   * @param {Float32Array[]} buffers - Array of channel buffers (1 for mono, 2 for stereo)
+   * @param {Float64Array[]} buffers - Array of channel buffers (1 for mono, 2 for stereo)
    * @param {number} [frameSize=SAMPLES_PER_FRAME] - Frame size in samples
-   * @returns {Generator<Float32Array>|Generator<[Float32Array, Float32Array]>} Stream of audio frames
+   * @returns {Generator<Float64Array>|Generator<[Float64Array, Float64Array]>} Stream of audio frames
    * @throws {Error} If unsupported channel count is provided
    */
   static *frameBufferToFrames(buffers, frameSize = SAMPLES_PER_FRAME) {
@@ -236,7 +236,7 @@ export class AudioProcessor {
     if (channelCount === 1) {
       const [left] = buffers
       for (let i = 0; i < left.length; i += frameSize) {
-        const frame = new Float32Array(frameSize)
+        const frame = new Float64Array(frameSize)
         const end = Math.min(i + frameSize, left.length)
         for (let j = 0; j < end - i; j++) {
           frame[j] = left[i + j]
@@ -248,8 +248,8 @@ export class AudioProcessor {
       const maxLength = Math.max(left.length, right.length)
 
       for (let i = 0; i < maxLength; i += frameSize) {
-        const leftFrame = new Float32Array(frameSize)
-        const rightFrame = new Float32Array(frameSize)
+        const leftFrame = new Float64Array(frameSize)
+        const rightFrame = new Float64Array(frameSize)
 
         const end = Math.min(i + frameSize, maxLength)
 
@@ -327,7 +327,7 @@ export class AudioProcessor {
 
   /**
    * Creates a WAV file blob from PCM audio frames
-   * @param {Float32Array[]|Float32Array|[Float32Array, Float32Array][]} pcmFrames - PCM audio frames
+   * @param {Float64Array[]|Float64Array|[Float64Array, Float64Array][]} pcmFrames - PCM audio frames
    * @param {number} [channelCount=1] - Number of audio channels
    * @param {number} [sampleRate=SAMPLE_RATE] - Audio sample rate
    * @returns {Blob} WAV file blob
@@ -347,7 +347,7 @@ export class AudioProcessor {
 
   /**
    * Creates a mono WAV file blob from PCM frames
-   * @param {Float32Array[]} frames - Array of mono PCM frames
+   * @param {Float64Array[]} frames - Array of mono PCM frames
    * @param {number} sampleRate - Audio sample rate
    * @returns {Blob} Mono WAV file blob
    * @private
@@ -383,7 +383,7 @@ export class AudioProcessor {
 
   /**
    * Creates a stereo WAV file blob from PCM frame pairs
-   * @param {[Float32Array, Float32Array][]} framePairs - Array of stereo PCM frame pairs
+   * @param {[Float64Array, Float64Array][]} framePairs - Array of stereo PCM frame pairs
    * @param {number} sampleRate - Audio sample rate
    * @returns {Blob} Stereo WAV file blob
    * @private
@@ -524,9 +524,9 @@ export class AudioProcessor {
 
   /**
    * Assembles PCM frames into a continuous buffer
-   * @param {Float32Array[]|[Float32Array, Float32Array][]} pcmFrames - Array of PCM frames
+   * @param {Float64Array[]|[Float64Array, Float64Array][]} pcmFrames - Array of PCM frames
    * @param {number} channelCount - Number of audio channels
-   * @returns {Float32Array} Continuous PCM buffer (interleaved for stereo)
+   * @returns {Float64Array} Continuous PCM buffer (interleaved for stereo)
    * @throws {Error} If unsupported channel count is provided
    */
   static assemblePcmFrames(pcmFrames, channelCount) {
@@ -535,7 +535,7 @@ export class AudioProcessor {
         (sum, frame) => sum + frame.length,
         0
       )
-      const pcm = new Float32Array(totalSamples)
+      const pcm = new Float64Array(totalSamples)
       let offset = 0
       for (const frame of pcmFrames) {
         pcm.set(frame, offset)
@@ -547,7 +547,7 @@ export class AudioProcessor {
         (sum, [left, right]) => sum + Math.max(left.length, right.length),
         0
       )
-      const pcm = new Float32Array(totalSamples * 2)
+      const pcm = new Float64Array(totalSamples * 2)
 
       let pcmOffset = 0
       for (const [leftFrame, rightFrame] of pcmFrames) {

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 {Float32Array} returns.coefficients - Reconstructed MDCT coefficients (512 samples)
+   * @returns {Float64Array} returns.coefficients - Reconstructed MDCT coefficients (512 samples)
    * @returns {Array<number>} returns.blockModes - Block modes for each band
    */
   return (frameData) => {
-    const coefficients = new Float32Array(512)
+    const coefficients = new Float64Array(512)
     const {
       nBfu,
       scaleFactorIndices,
@@ -123,13 +123,13 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform a single frequency band.
-   * @param {Float32Array} coeffs
+   * @param {Float64Array} coeffs
    * @param {number} bandIndex
    * @param {number} blockMode
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   function transformBand(
     coeffs,
@@ -164,13 +164,13 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform using long block.
-   * @param {Float32Array} coeffs
+   * @param {Float64Array} coeffs
    * @param {number} bandIndex
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
    * @param {Object} transformFunc
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   function inverseLongBlock(
     coeffs,
@@ -234,12 +234,12 @@ export function imdctStage(context) {
 
   /**
    * Inverse transform using short blocks.
-   * @param {Float32Array} coeffs
+   * @param {Float64Array} coeffs
    * @param {number} bandIndex
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
    * @param {Object} config
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   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 {Float32Array} input.coefficients - MDCT coefficients (512 samples)
+   * @param {Float64Array} 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]
+   * @returns {Array<Float64Array>} Three reconstructed frequency bands [low, mid, high]
    */
   return (input) => {
     const { coefficients, blockModes } = input
@@ -354,8 +354,8 @@ export function qmfSynthesisStage(context) {
 
   /**
    * Reconstruct full-spectrum PCM samples from frequency bands
-   * @param {Array<Float32Array>} bands - Three frequency bands [low, mid, high]
-   * @returns {Float32Array} Reconstructed PCM samples
+   * @param {Array<Float64Array>} bands - Three frequency bands [low, mid, high]
+   * @returns {Float64Array} Reconstructed PCM samples
    */
   return (bands) => {
     // Apply high band delay compensation

package/codec/pipeline/encoder.js

@@ -62,9 +62,9 @@ export function qmfAnalysisStage(context) {
 
   /**
    * Process PCM samples through QMF analysis
-   * @param {Float32Array} pcmSamples - Input PCM samples
+   * @param {Float64Array} pcmSamples - Input PCM samples
    * @returns {Object} Analysis result containing frequency bands
-   * @returns {Array<Float32Array>} returns.bands - Three frequency bands [low, mid, high]
+   * @returns {Array<Float64Array>} 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<Float32Array>} input.bands - Three frequency bands [low, mid, high]
+   * @param {Array<Float64Array>} input.bands - Three frequency bands [low, mid, high]
    * @returns {Object} Block selection results
-   * @returns {Array<Float32Array>} returns.bands - Original frequency bands
+   * @returns {Array<Float64Array>} 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 {Float32Array} samples
+   * @param {Float64Array} samples
    * @param {number} bandIndex
    * @param {number} blockMode
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   function transformBand(
     samples,
@@ -210,13 +210,13 @@ export function mdctStage(context) {
 
   /**
    * Transform using long block (better frequency resolution).
-   * @param {Float32Array} samples
+   * @param {Float64Array} samples
    * @param {number} bandIndex
    * @param {Object} config
    * @param {Object} transformFunc
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   function transformLongBlock(
     samples,
@@ -252,12 +252,12 @@ export function mdctStage(context) {
 
   /**
    * Transform using short blocks (better time resolution for transients).
-   * @param {Float32Array} samples
+   * @param {Float64Array} samples
    * @param {number} bandIndex
    * @param {Object} config
-   * @param {Float32Array} overlapBuffer
+   * @param {Float64Array} overlapBuffer
    * @param {Object} bufferPool
-   * @returns {Float32Array}
+   * @returns {Float64Array}
    */
   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 Float32Array(config.size)
+    const output = new Float64Array(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<Float32Array>} input.bands - Three frequency bands
+   * @param {Array<Float64Array>} 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<Float32Array>} returns.bands - Original frequency bands
-   * @returns {Float32Array} returns.coefficients - MDCT coefficients (512 samples)
+   * @returns {Array<Float64Array>} returns.bands - Original frequency bands
+   * @returns {Float64Array} 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 Float32Array(512)
+    const coefficients = new Float64Array(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 {Float32Array} input.coefficients - MDCT coefficients
+   * @param {Float64Array} 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

@@ -7,8 +7,8 @@ export class FFT {
 
   /**
    * 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
+   * @param {Float64Array} real - Real part of the input/output data
+   * @param {Float64Array} imag - Imaginary part of the input/output data
    */
   static fft(real, imag) {
     const n = real.length
@@ -123,8 +123,8 @@ export class FFT {
       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 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

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)
@@ -47,9 +47,9 @@ export class MDCT extends MDCTBase {
 
   /**
    * Perform forward MDCT transform
-   * @param {Float32Array} input - Time-domain input samples
+   * @param {Float64Array} input - Time-domain input samples
    * @param {Object} mdctBuffers - Optional work buffers for FFT
-   * @returns {Float32Array} Frequency-domain MDCT coefficients
+   * @returns {Float64Array} 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 Float32Array(this.halfSize)
+    const output = new Float64Array(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 {Float32Array} input - Frequency-domain MDCT coefficients
+   * @param {Float64Array} input - Frequency-domain MDCT coefficients
    * @param {Object} mdctBuffers - Optional work buffers for FFT
-   * @returns {Float32Array} Time-domain output samples
+   * @returns {Float64Array} Time-domain output samples
    */
   transform(input, mdctBuffers = null) {
     const buffers =
@@ -160,19 +160,19 @@ 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)
 
     // Post-FFT butterfly
-    const output = new Float32Array(this.size)
+    const output = new Float64Array(this.size)
 
     for (let i = 0; i < this.fftSize / 2; i++) {
       const i2 = i * 2
@@ -216,20 +216,20 @@ 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
- * @param {Float32Array} prev - Previous block samples
- * @param {Float32Array} curr - Current block samples
- * @param {Float32Array} window - Window function coefficients
- * @returns {Float32Array} Overlap-added output samples
+ * @param {Float64Array} prev - Previous block samples
+ * @param {Float64Array} curr - Current block samples
+ * @param {Float64Array} window - Window function coefficients
+ * @returns {Float64Array} Overlap-added output samples
  */
 export function overlapAdd(prev, curr, window) {
   const size = prev.length
-  const output = new Float32Array(size * 2)
+  const output = new Float64Array(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 {Float32Array} input - Input audio samples
- * @param {Float32Array} delayLine - QMF delay line state
+ * @param {Float64Array} input - Input audio samples
+ * @param {Float64Array} 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 Float32Array(outputLength)
-  const highBand = new Float32Array(outputLength)
+  const lowBand = new Float64Array(outputLength)
+  const highBand = new Float64Array(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 {Float32Array} lowBand - Low frequency band samples
- * @param {Float32Array} highBand - High frequency band samples
- * @param {Float32Array} delayLine - QMF delay line state
+ * @param {Float64Array} lowBand - Low frequency band samples
+ * @param {Float64Array} highBand - High frequency band samples
+ * @param {Float64Array} 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 Float32Array(outputLength)
+  const output = new Float64Array(outputLength)
 
   // Convolution
   for (let i = 0; i < subbandLength; i++) {