carta1 1.1.1 → 1.1.2

package/bin/cli.js

@@ -156,7 +156,7 @@ class ProgressTracker {
  * Provides async iteration over WAV file frames for memory-efficient
  * processing of large audio files. Automatically handles:
  * - Multi-channel deinterleaving
- * - Bit depth conversion to float32
+ * - Bit depth conversion to Float64
  * - Frame padding for the last partial frame
  *
  * @class
@@ -225,9 +225,9 @@ class WavReader {
    * Async iterator for streaming WAV file frames
    *
    * @param {number} [frameSize=SAMPLES_PER_FRAME] - Samples per frame
-   * @yields {Float32Array|Array<Float32Array>} Audio frame data
-   *   - Mono: Float32Array of samples
-   *   - Stereo: [left, right] Float32Arrays
+   * @yields {Float64Array|Array<Float64Array>} Audio frame data
+   *   - Mono: Float64Array of samples
+   *   - Stereo: [left, right] Float64Arrays
    */
   async *[Symbol.asyncIterator](frameSize = SAMPLES_PER_FRAME) {
     const fileStream = fs.createReadStream(this.filePath)
@@ -305,23 +305,23 @@ class WavReader {
   }
 
   /**
-   * Process raw PCM buffer into float32 frame data
+   * Process raw PCM buffer into float64 frame data
    *
    * @private
    * @param {Buffer} frameBuffer - Raw PCM data
    * @param {number} frameSize - Number of samples per channel
-   * @returns {Float32Array|Array<Float32Array>} Processed frame data
+   * @returns {Float64Array|Array<Float64Array>} Processed frame data
    */
   _processFrameBuffer(frameBuffer, frameSize) {
     if (this.channels === 1) {
-      const frame = new Float32Array(frameSize)
+      const frame = new Float64Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         frame[i] = this._sampleToFloat(frameBuffer, i * (this.bitDepth / 8))
       }
       return frame
     } else {
-      const left = new Float32Array(frameSize)
-      const right = new Float32Array(frameSize)
+      const left = new Float64Array(frameSize)
+      const right = new Float64Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         const offset = i * this.channels * (this.bitDepth / 8)
         left[i] = this._sampleToFloat(frameBuffer, offset)
@@ -332,7 +332,7 @@ class WavReader {
   }
 
   /**
-   * Convert PCM sample to normalized float32 value
+   * Convert PCM sample to normalized Float64 value
    *
    * @private
    * @param {Buffer} buffer - PCM data buffer

package/codec/analysis/transient.js

@@ -10,13 +10,13 @@ import { FFT } from '../transforms/fft.js'
 
 /**
  * Perform FFT on time-domain samples and return magnitude spectrum
- * @param {Float32Array} samples - Time-domain samples
+ * @param {Float64Array} samples - Time-domain samples
  * @param {number} fftSize - FFT size (must be power of 2)
- * @returns {Float32Array} Magnitude spectrum (positive frequencies only)
+ * @returns {Float64Array} Magnitude spectrum (positive frequencies only)
  */
 export function performFFT(samples, fftSize) {
-  const real = new Float32Array(fftSize)
-  const imag = new Float32Array(fftSize)
+  const real = new Float64Array(fftSize)
+  const imag = new Float64Array(fftSize)
 
   // Copy samples with zero-padding if necessary
   const copyLen = Math.min(samples.length, fftSize)
@@ -26,7 +26,7 @@ export function performFFT(samples, fftSize) {
   FFT.fft(real, imag)
 
   // Calculate magnitude spectrum for positive frequencies
-  const magnitude = new Float32Array(fftSize / 2)
+  const magnitude = new Float64Array(fftSize / 2)
   for (let i = 0; i < fftSize / 2; i++) {
     magnitude[i] = Math.sqrt(real[i] * real[i] + imag[i] * imag[i])
   }
@@ -36,8 +36,8 @@ export function performFFT(samples, fftSize) {
 
 /**
  * Detect transients by analyzing spectral changes between frames
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @param {number} threshold - Detection threshold
  * @returns {boolean} True if transient detected
  */
@@ -56,8 +56,8 @@ export function detectTransient(currentCoeffs, prevCoeffs, threshold) {
 
 /**
  * Calculate all spectral features for transient detection
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @returns {Object} Computed spectral features
  */
 function calculateSpectralFeatures(currentCoeffs, prevCoeffs) {
@@ -114,7 +114,7 @@ function calculateSpectralFlux(currentCoeffs, prevCoeffs) {
 /**
  * Calculate spectral flatness (geometric mean / arithmetic mean)
  * Measures how noise-like vs tonal the spectrum is
- * @param {Float32Array} coeffs - Spectral coefficients
+ * @param {Float64Array} coeffs - Spectral coefficients
  * @returns {number} Flatness measure (0 = tonal, 1 = noise-like)
  */
 function calculateSpectralFlatness(coeffs) {
@@ -143,7 +143,7 @@ function calculateSpectralFlatness(coeffs) {
 /**
  * Calculate ratio of high-frequency to total energy
  * High values indicate bright/harsh sounds that are perceptually important
- * @param {Float32Array} coeffs - Spectral coefficients
+ * @param {Float64Array} coeffs - Spectral coefficients
  * @returns {number} High-frequency energy ratio (0-1)
  */
 function calculateHighFrequencyRatio(coeffs) {
@@ -165,8 +165,8 @@ function calculateHighFrequencyRatio(coeffs) {
 
 /**
  * Calculate energy change between frames in dB
- * @param {Float32Array} currentCoeffs - Current frame coefficients
- * @param {Float32Array} prevCoeffs - Previous frame coefficients
+ * @param {Float64Array} currentCoeffs - Current frame coefficients
+ * @param {Float64Array} prevCoeffs - Previous frame coefficients
  * @returns {number} Energy change in dB (positive values only)
  */
 function calculateEnergyChange(currentCoeffs, prevCoeffs) {

package/codec/browser/interface.js

@@ -64,9 +64,9 @@ class Carta1Worker {
   /**
    * Encode PCM audio to ATRAC1 format
    *
-   * @param {Float32Array|Array<Float32Array>} pcmData - PCM audio data
-   *   - Mono: Float32Array
-   *   - Stereo: [left, right] Float32Arrays
+   * @param {Float64Array|Array<Float64Array>} pcmData - PCM audio data
+   *   - Mono: Float64Array
+   *   - Stereo: [left, right] Float64Arrays
    * @param {Object} [options={}] - Encoder options
    * @param {number} [options.transientThresholdLow] - Low band transient threshold
    * @param {number} [options.transientThresholdMid] - Mid band transient threshold

package/codec/browser/worker.js

@@ -56,7 +56,7 @@ self.onmessage = async (e) => {
 /**
  * Encode PCM audio data to ATRAC1 format
  *
- * @param {Array<Float32Array>} pcmData - PCM audio data [mono] or [left, right]
+ * @param {Array<Float64Array>} pcmData - PCM audio data [mono] or [left, right]
  * @param {Object} options - Encoder options
  * @returns {Promise<Object>} Encoded AEA blob
  */

package/codec/coding/bitallocation.js

@@ -35,7 +35,7 @@ import {
 
 /**
  * Allocate bits to BFUs using optimized greedy Lp-RDO
- * @param {Array<Float32Array>} bfuData
+ * @param {Array<Float64Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} maxBfuCount
  * @returns {{bfuCount:number, allocation:Int32Array, scaleFactorIndices:Int32Array}}
@@ -62,7 +62,7 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount) {
  * bits to the BFUs that provide the greatest distortion reduction per bit spent.
  *
  * @param {number} activeBfuCount
- * @param {Array<Float32Array>} bfuData
+ * @param {Array<Float64Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} remainingBits
  * @returns {{wordLengths: Int32Array, scaleFactorIndices: Int32Array}}
@@ -150,7 +150,7 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
 /**
  * Find the optimal scale factor index for a set of coefficients.
  * Same semantics as the original.
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @returns {number}
  */
 export function findScaleFactor(coefficients) {

package/codec/coding/quantization.js

@@ -26,7 +26,7 @@ import {
 
 /**
  * Quantize coefficients.
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
  * @returns {Int32Array} out
@@ -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
@@ -61,20 +60,19 @@ export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
  * @param {Int32Array} quantized
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
- * @returns {Float32Array}
+ * @returns {Float64Array}
  */
 export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
-    return new Float32Array(quantized.length)
+    return new Float64Array(quantized.length)
   }
 
   const scaleFactor = SCALE_FACTORS[scaleFactorIndex]
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
-  const denormFactor = scaleFactor / quantRange
 
-  const deq = new Float32Array(quantized.length)
+  const deq = new Float64Array(quantized.length)
   for (let i = 0; i < quantized.length; i++) {
-    deq[i] = quantized[i] * denormFactor
+    deq[i] = (quantized[i] * scaleFactor) / quantRange
   }
   return deq
 }
@@ -101,9 +99,9 @@ export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
  * - Long blocks (mode 0): Higher frequency resolution, fewer temporal segments
  * - Short blocks (mode 1): Lower frequency resolution, more temporal segments
  *
- * @param {Float32Array} coefficients
+ * @param {Float64Array} coefficients
  * @param {Array<number>} blockModes
- * @returns {{bfuData: Array<Float32Array>, bfuSizes: Array<number>, bfuCount: number}}
+ * @returns {{bfuData: Array<Float64Array>, bfuSizes: Array<number>, bfuCount: number}}
  */
 export function groupIntoBFUs(coefficients, blockModes) {
   const bfuData = []
@@ -123,7 +121,7 @@ export function groupIntoBFUs(coefficients, blockModes) {
       const size = SPECS_PER_BFU[bfuIndex]
       const startPos = startPositions[bfuIndex] - bandStart
       const endPos = startPos + size
-      const bfu = new Float32Array(size)
+      const bfu = new Float64Array(size)
 
       if (startPos >= 0 && endPos <= bandSize) {
         bfu.set(coefficients.subarray(bandStart + startPos, bandStart + endPos))

package/codec/core/buffers.js

@@ -8,74 +8,74 @@ export class BufferPool {
   constructor() {
     // Transform buffers
     this.transformBuffers = {
-      64: new Float32Array(64),
-      128: new Float32Array(128),
-      256: new Float32Array(256),
-      512: new Float32Array(512),
+      64: new Float64Array(64),
+      128: new Float64Array(128),
+      256: new Float64Array(256),
+      512: new Float64Array(512),
     }
 
     // QMF work buffers
     this.qmfWorkBuffers = {
       delay: {
-        128: new Float32Array(QMF_DELAY + 128),
-        256: new Float32Array(QMF_DELAY + 256),
-        512: new Float32Array(QMF_DELAY + 512),
+        128: new Float64Array(QMF_DELAY + 128),
+        256: new Float64Array(QMF_DELAY + 256),
+        512: new Float64Array(QMF_DELAY + 512),
       },
       highBandDelay: {
-        128: new Float32Array(QMF_HIGH_BAND_DELAY + 128),
-        256: new Float32Array(QMF_HIGH_BAND_DELAY + 256),
+        128: new Float64Array(QMF_HIGH_BAND_DELAY + 128),
+        256: new Float64Array(QMF_HIGH_BAND_DELAY + 256),
       },
     }
 
     // QMF delay lines
     this.qmfDelays = {
-      lowBand: new Float32Array(QMF_DELAY),
-      midBand: new Float32Array(QMF_DELAY),
-      highBand: new Float32Array(QMF_HIGH_BAND_DELAY),
+      lowBand: new Float64Array(QMF_DELAY),
+      midBand: new Float64Array(QMF_DELAY),
+      highBand: new Float64Array(QMF_HIGH_BAND_DELAY),
     }
 
     // Transient detector
     this.transientDetection = [
-      new Float32Array(64),
-      new Float32Array(64),
-      new Float32Array(128),
+      new Float64Array(64),
+      new Float64Array(64),
+      new Float64Array(128),
     ]
 
     // MDCT/IMDCT work buffers
     this.mdctBuffers = {
       16: {
-        real: new Float32Array(16),
-        imag: new Float32Array(16),
+        real: new Float64Array(16),
+        imag: new Float64Array(16),
       },
       64: {
-        real: new Float32Array(64),
-        imag: new Float32Array(64),
+        real: new Float64Array(64),
+        imag: new Float64Array(64),
       },
       128: {
-        real: new Float32Array(128),
-        imag: new Float32Array(128),
+        real: new Float64Array(128),
+        imag: new Float64Array(128),
       },
     }
 
-    // MDCT overlap buffers (encoder)
+    // MDCT overlap buffers
     this.mdctOverlap = [
-      new Float32Array(32),
-      new Float32Array(32),
-      new Float32Array(32),
+      new Float64Array(32),
+      new Float64Array(32),
+      new Float64Array(32),
     ]
 
-    // IMDCT overlap buffers (decoder)
+    // IMDCT overlap buffers
     this.imdctOverlap = [
-      new Float32Array(256),
-      new Float32Array(256),
-      new Float32Array(512),
+      new Float64Array(256),
+      new Float64Array(256),
+      new Float64Array(512),
     ]
 
     // Spectrum reversal buffers
     this.reversalBuffers = {
-      32: new Float32Array(32),
-      128: new Float32Array(128),
-      256: new Float32Array(256),
+      32: new Float64Array(32),
+      128: new Float64Array(128),
+      256: new Float64Array(256),
     }
   }
 }

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,40 +147,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

@@ -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) {