carta1 1.0.22 → 1.1.0

package/codec/coding/quantization.js

@@ -1,9 +1,18 @@
 /**
- * Carta1 Audio Codec - Quantization
+ * Carta1 Audio Codec - Quantization Module
  *
- * This module implements quantization and dequantization of MDCT coefficients
- * for the ATRAC1 audio codec, organizing coefficients into Block Floating Units (BFUs)
- * and applying appropriate scale factors for optimal bit allocation.
+ * This module handles the quantization and dequantization of MDCT frequency coefficients
+ * for the Carta1 audio codec. It provides functions to convert floating-point frequency
+ * domain data into integer representations suitable for bitstream encoding.
+ *
+ * Key functions:
+ * - Quantization of coefficients using scale factors and bit depths
+ * - Dequantization for reconstruction during decoding
+ * - BFU (Band Frequency Unit) organization for psychoacoustic processing
+ *
+ * The quantization process uses configurable scale factors to maintain audio quality
+ * while achieving the target compression ratio. The module supports both uniform
+ * and non-uniform quantization schemes based on perceptual importance.
  */
 
 import {
@@ -16,70 +25,43 @@ import {
 } from '../core/constants.js'
 
 /**
- * Find the optimal scale factor index for a set of coefficients
- * @param {Float32Array} coefficients - MDCT coefficients to analyze
- * @returns {number} Scale factor index (0-63)
- */
-export function findScaleFactor(coefficients) {
-  let maxAmplitude = 0
-
-  for (let i = 0; i < coefficients.length; i++) {
-    maxAmplitude = Math.max(maxAmplitude, Math.abs(coefficients[i]))
-  }
-
-  if (maxAmplitude === 0) return 0
-
-  // Binary search for optimal scale factor
-  let low = 0
-  let high = SCALE_FACTORS.length - 1
-
-  while (low < high) {
-    const mid = (low + high) >> 1
-    if (maxAmplitude <= SCALE_FACTORS[mid]) {
-      high = mid
-    } else {
-      low = mid + 1
-    }
-  }
-
-  return low
-}
-
-/**
- * Quantize floating-point coefficients to integer values
- * @param {Float32Array} coefficients - Input coefficients to quantize
- * @param {number} scaleFactorIndex - Index into SCALE_FACTORS table
- * @param {number} bitsPerSample - Number of bits per quantized sample
- * @returns {Int32Array} Quantized integer coefficients
+ * Quantize coefficients.
+ * @param {Float32Array} coefficients
+ * @param {number} scaleFactorIndex
+ * @param {number} bitsPerSample
+ * @returns {Int32Array} out
  */
 export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
+  const length = coefficients.length
+  const out = new Int32Array(length)
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
-    return new Int32Array(coefficients.length)
+    // Zero fast path
+    out.fill(0, 0, length)
+    return out
   }
 
   const scaleFactor = SCALE_FACTORS[scaleFactorIndex]
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
   const normFactor = quantRange / scaleFactor
 
-  const quantized = new Int32Array(coefficients.length)
+  const hi = quantRange
+  const lo = -quantRange - 1
 
-  for (let i = 0; i < coefficients.length; i++) {
-    const normalized = coefficients[i] * normFactor
-    quantized[i] = Math.max(
-      -quantRange - 1,
-      Math.min(quantRange, Math.round(normalized))
-    )
+  for (let i = 0; i < length; i++) {
+    const x = coefficients[i] * normFactor
+    const y = (x + (x >= 0 ? 0.5 : -0.5)) | 0
+    out[i] = y > hi ? hi : y < lo ? lo : y
   }
 
-  return quantized
+  return out
 }
 
 /**
- * Dequantize integer coefficients back to floating-point values
- * @param {Int32Array} quantized - Quantized integer coefficients
- * @param {number} scaleFactorIndex - Index into SCALE_FACTORS table
- * @param {number} bitsPerSample - Number of bits per quantized sample
- * @returns {Float32Array} Dequantized floating-point coefficients
+ * Dequantize coefficients.
+ * @param {Int32Array} quantized
+ * @param {number} scaleFactorIndex
+ * @param {number} bitsPerSample
+ * @returns {Float32Array}
  */
 export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
@@ -90,24 +72,41 @@ export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
   const denormFactor = scaleFactor / quantRange
 
-  const dequantized = new Float32Array(quantized.length)
-
+  const deq = new Float32Array(quantized.length)
   for (let i = 0; i < quantized.length; i++) {
-    dequantized[i] = quantized[i] * denormFactor
+    deq[i] = quantized[i] * denormFactor
   }
-
-  return dequantized
+  return deq
 }
 
 /**
- * Group MDCT coefficients into Block Floating Units (BFUs)
- * @param {Float32Array} coefficients - Input MDCT coefficients
- * @param {number[]} blockModes - Block mode for each band (0=long, 1=short)
- * @param {Array<Float32Array>} bfuBuffers - Optional pre-allocated BFU buffers
- * @returns {Object} Object containing bfuData, bfuSizes, and bfuCount
+ * Groups MDCT coefficients into Band Frequency Units (BFUs) for bit allocation.
+ *
+ * This function organizes frequency-domain coefficients into perceptually meaningful
+ * frequency bands (BFUs) based on the block modes for each of the three frequency bands.
+ * It handles both long and short blocks, with different frequency resolutions and
+ * BFU start positions for each block type.
+ *
+ * The function implements copy-avoidance optimization: when a BFU slice is fully
+ * contained within a frequency band, it directly copies the data without buffer
+ * filling. For BFUs that span band boundaries or extend beyond the available
+ * coefficients, it handles partial copying and zero-padding appropriately.
+ *
+ * Frequency Band Structure:
+ * - Band 0: 0-128 coefficients (low frequencies)
+ * - Band 1: 128-256 coefficients (mid frequencies)
+ * - Band 2: 256-512 coefficients (high frequencies)
+ *
+ * Block Types:
+ * - Long blocks (mode 0): Higher frequency resolution, fewer temporal segments
+ * - Short blocks (mode 1): Lower frequency resolution, more temporal segments
+ *
+ * @param {Float32Array} coefficients
+ * @param {Array<number>} blockModes
+ * @returns {{bfuData: Array<Float32Array>, bfuSizes: Array<number>, bfuCount: number}}
  */
-export function groupIntoBFUs(coefficients, blockModes, bfuBuffers = null) {
-  const bfuData = bfuBuffers ?? []
+export function groupIntoBFUs(coefficients, blockModes) {
+  const bfuData = []
   const bfuSizes = []
 
   let coeffIndex = 0
@@ -123,22 +122,24 @@ export function groupIntoBFUs(coefficients, blockModes, bfuBuffers = null) {
     while (bfuIndex < bandEnd) {
       const size = SPECS_PER_BFU[bfuIndex]
       const startPos = startPositions[bfuIndex] - bandStart
-
-      const bfu = bfuBuffers ? bfuBuffers[bfuIndex] : new Float32Array(size)
-      bfu.fill(0) // Clear the buffer
-
-      if (startPos >= 0 && startPos < bandSize) {
-        const endPos = Math.min(startPos + size, bandSize)
-        const actualSize = endPos - startPos
-
-        for (let i = 0; i < actualSize; i++) {
-          bfu[i] = coefficients[bandStart + startPos + i]
+      const endPos = startPos + size
+      const bfu = new Float32Array(size)
+
+      if (startPos >= 0 && endPos <= bandSize) {
+        bfu.set(coefficients.subarray(bandStart + startPos, bandStart + endPos))
+      } else {
+        bfu.fill(0)
+        if (startPos < bandSize && endPos > 0) {
+          const srcStart = Math.max(0, startPos)
+          const srcEnd = Math.min(bandSize, endPos)
+          bfu.set(
+            coefficients.subarray(bandStart + srcStart, bandStart + srcEnd),
+            Math.max(0, -startPos)
+          )
         }
       }
 
-      if (!bfuBuffers) {
-        bfuData.push(bfu)
-      }
+      bfuData.push(bfu)
       bfuSizes.push(size)
       bfuIndex++
     }

package/codec/core/buffers.js

@@ -7,9 +7,6 @@ import {
   MAX_BFU_SIZE,
   QMF_DELAY,
   QMF_HIGH_BAND_DELAY,
-  PSYMODEL_CRITICAL_BANDS,
-  PSYMODEL_HALF_FFT_SIZE,
-  PSYMODEL_NUM_BINS,
 } from './constants.js'
 
 export class BufferPool {
@@ -91,20 +88,5 @@ export class BufferPool {
     for (let i = 0; i < NUM_BFUS; i++) {
       this.bfuData[i] = new Float32Array(MAX_BFU_SIZE)
     }
-
-    // Psychoacoustic model buffers (large Float32Arrays)
-    this.psychoBuffers = {
-      psdDb: new Float32Array(PSYMODEL_NUM_BINS),
-      linPower: new Float32Array(PSYMODEL_NUM_BINS),
-      tonalSPL: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      nonTonalSPL: new Float32Array(PSYMODEL_CRITICAL_BANDS.length),
-      maskSpl: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      maskPsd: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      maskBark: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      maskTonalOffset: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      maskPsdF1: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      maskPsdF2: new Float32Array(PSYMODEL_HALF_FFT_SIZE),
-      criticalBandThresholds: new Float32Array(PSYMODEL_CRITICAL_BANDS.length),
-    }
   }
 }

package/codec/core/constants.js

@@ -151,59 +151,6 @@ export const SPREADING_MATRIX = (() => {
   return matrix
 })()
 
-// ISO/IEC 11172-3:1993 Psychoacoustic Model Constants
-export const PSYMODEL_MIN_POWER_DB = -200
-export const PSYMODEL_FFT_SIZE = 2048
-export const PSYMODEL_HALF_FFT_SIZE = PSYMODEL_FFT_SIZE >>> 1
-export const PSYMODEL_NUM_BINS = PSYMODEL_HALF_FFT_SIZE + 1
-
-// Pre-computes lookup tables for resampling the MDCT power spectrum into a PSD.
-// For each PSD bin, these tables provide the two source MDCT indices and the
-// linear interpolation weight needed to calculate the final power value.
-export const [
-  PSYMODEL_PSD_SOURCE_IDX0,
-  PSYMODEL_PSD_SOURCE_IDX1,
-  PSYMODEL_PSD_INTERP_WEIGHT,
-] = (() => {
-  const half = PSYMODEL_FFT_SIZE >>> 1
-  const sizeMinus1 = PSYMODEL_FFT_SIZE - 1
-  const halfDiv2 = half / 2
-  const scale = sizeMinus1 / half
-
-  const idx0 = new Uint16Array(half + 1)
-  const idx1 = new Uint16Array(half + 1)
-  const w1 = new Float32Array(half + 1)
-
-  for (let i = 0; i <= half; i++) {
-    const src = i * scale
-    const base = src | 0
-
-    const j0 = base
-    idx0[i] =
-      j0 < half
-        ? j0 < halfDiv2
-          ? j0
-          : half - 1 - (j0 - halfDiv2)
-        : sizeMinus1 - (j0 - half)
-
-    const j1 = base + 1
-    if (j1 >= PSYMODEL_FFT_SIZE) {
-      idx1[i] = idx0[i]
-    } else {
-      idx1[i] =
-        j1 < half
-          ? j1 < halfDiv2
-            ? j1
-            : half - 1 - (j1 - halfDiv2)
-          : sizeMinus1 - (j1 - half)
-    }
-
-    w1[i] = src - base
-  }
-
-  return [idx0, idx1, w1]
-})()
-
 // FFT sizes for transient detection
 export const FFT_SIZE_LOW = 128
 export const FFT_SIZE_MID = 128
@@ -236,133 +183,6 @@ export const FRAME_HEADER_BITS = 16
 export const FRAME_WORD_LENGTH_BITS = 4
 export const FRAME_SCALE_FACTOR_BITS = 6
 
-// Tonal analysis flags
-export const PSYMODEL_NOT_EXAMINED = 0
-export const PSYMODEL_TONAL = 1
-export const PSYMODEL_NON_TONAL = 2
-export const PSYMODEL_IRRELEVANT = 3
-
-// Pre-computed conversion factors
-export const PSYMODEL_LOG10_FACTOR = 10 / Math.LN10
-export const PSYMODEL_POW10_FACTOR = Math.LN10 / 10
-
-// Critical band boundaries (0-24)
-export const PSYMODEL_CRITICAL_BANDS = new Uint8Array([
-  0, 1, 2, 4, 5, 7, 8, 10, 12, 14, 16, 19, 22, 26, 31, 36, 44, 49, 54, 60, 67,
-  74, 80, 92, 105,
-])
-
-// Threshold table: [frequency_index, bark_value, threshold_value]
-// prettier-ignore
-export const PSYMODEL_THRESHOLD_TABLE = [
-  [1.0, 0.85, 13.87], [2.0, 1.694, 2.85], [3.0, 2.525, -1.28], [4.0, 3.337, -3.5],
-  [5.0, 4.124, -4.9], [6.0, 4.882, -5.89], [7.0, 5.608, -6.63], [8.0, 6.301, -7.21],
-  [9.0, 6.959, -7.68], [10.0, 7.581, -8.08], [11.0, 8.169, -8.43], [12.0, 8.723, -8.75],
-  [13.0, 9.244, -9.05], [14.0, 9.734, -9.33], [15.0, 10.195, -9.61], [16.0, 10.629, -9.89],
-  [17.0, 11.037, -10.17], [18.0, 11.421, -10.47], [19.0, 11.783, -10.77], [20.0, 12.125, -11.1],
-  [21.0, 12.448, -11.44], [22.0, 12.753, -11.79], [23.0, 13.042, -12.17], [24.0, 13.317, -12.56],
-  [25.0, 13.577, -12.96], [26.0, 13.825, -13.38], [27.0, 14.062, -13.79], [28.0, 14.288, -14.21],
-  [29.0, 14.504, -14.63], [30.0, 14.711, -15.03], [31.0, 14.909, -15.41], [32.0, 15.1, -15.77],
-  [33.0, 15.283, -16.09], [34.0, 15.46, -16.37], [35.0, 15.631, -16.6], [36.0, 15.795, -16.78],
-  [37.0, 15.955, -16.91], [38.0, 16.11, -16.97], [39.0, 16.26, -16.98], [40.0, 16.405, -16.92],
-  [41.0, 16.547, -16.81], [42.0, 16.685, -16.65], [43.0, 16.82, -16.43], [44.0, 16.951, -16.17],
-  [45.0, 17.079, -15.87], [46.0, 17.204, -15.54], [47.0, 17.327, -15.19], [48.0, 17.447, -14.82],
-  [50.0, 17.68, -14.06], [52.0, 17.904, -13.32], [54.0, 18.121, -12.64], [56.0, 18.331, -12.04],
-  [58.0, 18.534, -11.53], [60.0, 18.73, -11.11], [62.0, 18.922, -10.77], [64.0, 19.108, -10.49],
-  [66.0, 19.288, -10.26], [68.0, 19.464, -10.07], [70.0, 19.635, -9.89], [72.0, 19.801, -9.72],
-  [74.0, 19.963, -9.54], [76.0, 20.12, -9.37], [78.0, 20.273, -9.18], [80.0, 20.421, -8.97],
-  [82.0, 20.565, -8.75], [84.0, 20.705, -8.51], [86.0, 20.84, -8.26], [88.0, 20.971, -7.98],
-  [90.0, 21.099, -7.68], [92.0, 21.222, -7.36], [94.0, 21.341, -7.02], [96.0, 21.457, -6.65],
-  [100.0, 21.676, -5.85], [104.0, 21.882, -4.93], [108.0, 22.074, -3.9], [112.0, 22.253, -2.75],
-  [116.0, 22.42, -1.46], [120.0, 22.575, -0.03], [124.0, 22.721, 1.56], [128.0, 22.857, 3.31],
-  [132.0, 22.984, 5.23], [136.0, 23.102, 7.34], [140.0, 23.213, 9.64], [144.0, 23.317, 12.15],
-  [148.0, 23.414, 14.88], [152.0, 23.506, 17.84], [156.0, 23.592, 21.05], [160.0, 23.673, 24.52],
-  [164.0, 23.749, 28.25], [168.0, 23.821, 32.27], [172.0, 23.888, 36.59], [176.0, 23.952, 41.22],
-  [180.0, 24.013, 46.18], [184.0, 24.07, 51.49], [188.0, 24.124, 56.0], [192.0, 24.176, 56.0],
-  [196.0, 24.225, 56.0], [200.0, 24.271, 56.0], [204.0, 24.316, 56.0], [208.0, 24.358, 56.0],
-  [212.0, 24.398, 56.0], [216.0, 24.436, 56.0], [220.0, 24.473, 56.0], [224.0, 24.508, 56.0],
-  [228.0, 24.541, 56.0], [232.0, 24.573, 56.0]
-]
-export const PSYMODEL_CB_FREQ_INDICES = PSYMODEL_CRITICAL_BANDS.map(
-  (cbIdx) => PSYMODEL_THRESHOLD_TABLE[cbIdx][0] - 1
-)
-
-// Frequency to critical band mapping
-export const PSYMODEL_FREQ_TO_CB_MAP = new Uint8Array([
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-  22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-  41, 42, 43, 44, 45, 46, 47, 47, 48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53,
-  53, 54, 54, 55, 55, 56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62,
-  63, 63, 64, 64, 65, 65, 66, 66, 67, 67, 68, 68, 69, 69, 70, 70, 71, 71, 71,
-  71, 72, 72, 72, 72, 73, 73, 73, 73, 74, 74, 74, 74, 75, 75, 75, 75, 76, 76,
-  76, 76, 77, 77, 77, 77, 78, 78, 78, 78, 79, 79, 79, 79, 80, 80, 80, 80, 81,
-  81, 81, 81, 82, 82, 82, 82, 83, 83, 83, 83, 84, 84, 84, 84, 85, 85, 85, 85,
-  86, 86, 86, 86, 87, 87, 87, 87, 88, 88, 88, 88, 89, 89, 89, 89, 90, 90, 90,
-  90, 91, 91, 91, 91, 92, 92, 92, 92, 93, 93, 93, 93, 94, 94, 94, 94, 95, 95,
-  95, 95, 96, 96, 96, 96, 97, 97, 97, 97, 98, 98, 98, 98, 99, 99, 99, 99, 100,
-  100, 100, 100, 101, 101, 101, 101, 102, 102, 102, 102, 103, 103, 103, 103,
-  104, 104, 104, 104, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
-  105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
-  105,
-])
-
-// Tonal detection neighbor offset patterns for different frequency ranges
-// These avoid per-iteration array allocations during tonal masker detection
-export const PSYMODEL_TONAL_OFFSETS_LOW_FREQ = Int8Array.of(-2, 2)
-export const PSYMODEL_TONAL_OFFSETS_MID_FREQ = Int8Array.of(-3, -2, 2, 3)
-export const PSYMODEL_TONAL_OFFSETS_HIGH_FREQ = Int8Array.of(-6, -5, -4, -3, -2 , 2, 3, 4, 5, 6) // prettier-ignore
-
-// Bit allocation
-export const INTERPOLATION_COMPENSATION_FACTOR = 0.25
-
-/**
- * Precomputed interpolation data for psychoacoustic mask interpolation
- * Creates lookup table for interpolating psychoacoustic mask values across BFUs
- */
-export const BFU_MASK_INTERPOLATION_TABLE = (() => {
-  const interpolationEntries = new Array(NUM_BFUS)
-  const frequencyPerBin = SAMPLE_RATE / PSYMODEL_FFT_SIZE
-  const criticalBandIndices = PSYMODEL_CB_FREQ_INDICES
-
-  for (let bfuIndex = 0; bfuIndex < NUM_BFUS; bfuIndex++) {
-    const fftBinIndex = Math.round(BFU_FREQUENCIES[bfuIndex] / frequencyPerBin)
-
-    // Find critical band index using binary search
-    let lowIndex = 0
-    let highIndex = criticalBandIndices.length - 1
-
-    while (lowIndex < highIndex) {
-      const midIndex = (lowIndex + highIndex + 1) >> 1
-      if (criticalBandIndices[midIndex] <= fftBinIndex) {
-        lowIndex = midIndex
-      } else {
-        highIndex = midIndex - 1
-      }
-    }
-
-    const currentBandIndex = lowIndex
-    const nextBandIndex = Math.min(
-      currentBandIndex + 1,
-      criticalBandIndices.length - 1
-    )
-    const currentBandFreq = criticalBandIndices[currentBandIndex]
-    const nextBandFreq = criticalBandIndices[nextBandIndex]
-    const bandWidth = nextBandFreq - currentBandFreq || 1
-    const inverseBandWidth = 1 / bandWidth
-
-    interpolationEntries[bfuIndex] = {
-      band: currentBandIndex,
-      next: nextBandIndex,
-      x0: currentBandFreq,
-      y0: currentBandIndex,
-      y1: nextBandIndex,
-      tInv: inverseBandWidth,
-    }
-  }
-
-  return interpolationEntries
-})()
-
 // Quantization
 export const MAX_WORD_LENGTH_INDEX = 15
 export const WORD_LENGTH_BITS = new Int32Array([
@@ -396,3 +216,27 @@ export const SCALE_FACTORS = (() => {
   }
   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
+  const maxBits = WORD_LENGTH_BITS[MAX_WORD_LENGTH_INDEX]
+  const pow2_neg_p = new Float64Array(maxBits + 1)
+  for (let b = 0; b <= maxBits; b++) {
+    pow2_neg_p[b] = Math.pow(2, -LP_DISTORTION_P * 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 }
+})()

package/codec/core/options.js

@@ -18,7 +18,6 @@ class EncoderOptions {
       transientThresholdLow: 1.0,
       transientThresholdMid: 1.5,
       transientThresholdHigh: 2.0,
-      normalizationDb: 68,
     }
 
     this.metadata = {
@@ -46,14 +45,6 @@ class EncoderOptions {
         range: [0.01, 4],
         step: 0.01,
       },
-      normalizationDb: {
-        default: this.values.normalizationDb,
-        name: 'Normalization Target (dB)',
-        description:
-          'Sets the target maximum level in decibels for psychoacoustic model normalization. This affects the dynamic range allocation and quantization precision. Higher values may increase bitrate but preserve more detail.',
-        range: [60, 80],
-        step: 1,
-      },
     }
 
     // Apply user-provided options
@@ -122,10 +113,6 @@ class EncoderOptions {
     return this.values.transientThresholdHigh
   }
 
-  get normalizationDb() {
-    return this.values.normalizationDb
-  }
-
   getMetadata(key) {
     return this.metadata[key]
   }

package/codec/pipeline/decoder.js

@@ -122,7 +122,14 @@ export function imdctStage(context) {
   const TRANSFORM_FUNCS = [imdct256, imdct256, imdct512]
 
   /**
-   * Inverse transform a single frequency band
+   * Inverse transform a single frequency band.
+   * @param {Float32Array} coeffs
+   * @param {number} bandIndex
+   * @param {number} blockMode
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @param {Object} config
+   * @returns {Float32Array}
    */
   function transformBand(
     coeffs,
@@ -156,7 +163,14 @@ export function imdctStage(context) {
   }
 
   /**
-   * Inverse transform using long block
+   * Inverse transform using long block.
+   * @param {Float32Array} coeffs
+   * @param {number} bandIndex
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @param {Object} config
+   * @param {Object} transformFunc
+   * @returns {Float32Array}
    */
   function inverseLongBlock(
     coeffs,
@@ -219,7 +233,13 @@ export function imdctStage(context) {
   }
 
   /**
-   * Inverse transform using short blocks
+   * Inverse transform using short blocks.
+   * @param {Float32Array} coeffs
+   * @param {number} bandIndex
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @param {Object} config
+   * @returns {Float32Array}
    */
   function inverseShortBlocks(
     coeffs,

package/codec/pipeline/encoder.js

@@ -22,11 +22,7 @@ import {
 } from '../utils.js'
 import { qmfAnalysis } from '../transforms/qmf.js'
 import { mdct64, mdct256, mdct512 } from '../transforms/mdct.js'
-import {
-  groupIntoBFUs,
-  findScaleFactor,
-  quantize,
-} from '../coding/quantization.js'
+import { groupIntoBFUs, quantize } from '../coding/quantization.js'
 import { allocateBits } from '../coding/bitallocation.js'
 import { BufferPool } from '../core/buffers.js'
 import { EncoderOptions } from '../core/options.js'
@@ -44,7 +40,6 @@ import {
   MDCT_OVERLAP_SIZE,
 } from '../core/constants.js'
 import { performFFT, detectTransient } from '../analysis/transient.js'
-import { psychoAnalysis } from '../analysis/psychoacoustics.js'
 
 /**
  * QMF Analysis Stage - Splits audio into frequency bands
@@ -174,7 +169,13 @@ export function mdctStage(context) {
   const TRANSFORM_FUNCS = [mdct256, mdct256, mdct512]
 
   /**
-   * Transform a single frequency band using MDCT
+   * Transform a single frequency band using MDCT.
+   * @param {Float32Array} samples
+   * @param {number} bandIndex
+   * @param {number} blockMode
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @returns {Float32Array}
    */
   function transformBand(
     samples,
@@ -208,7 +209,14 @@ export function mdctStage(context) {
   }
 
   /**
-   * Transform using long block (better frequency resolution)
+   * Transform using long block (better frequency resolution).
+   * @param {Float32Array} samples
+   * @param {number} bandIndex
+   * @param {Object} config
+   * @param {Object} transformFunc
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @returns {Float32Array}
    */
   function transformLongBlock(
     samples,
@@ -243,7 +251,13 @@ export function mdctStage(context) {
   }
 
   /**
-   * Transform using short blocks (better time resolution for transients)
+   * Transform using short blocks (better time resolution for transients).
+   * @param {Float32Array} samples
+   * @param {number} bandIndex
+   * @param {Object} config
+   * @param {Float32Array} overlapBuffer
+   * @param {Object} bufferPool
+   * @returns {Float32Array}
    */
   function transformShortBlocks(
     samples,
@@ -328,32 +342,22 @@ export function mdctStage(context) {
 }
 
 /**
- * Quantization Stage - Performs psychoacoustic analysis and quantization
+ * Quantization Stage - Performs RDO bit allocation and quantization
  *
  * The final encoding stage that:
  * 1. Groups coefficients into Block Floating Units (BFUs)
- * 2. Performs psychoacoustic analysis to determine masking thresholds
- * 3. Allocates bits based on perceptual importance
- * 4. Quantizes coefficients using scale factors and word lengths
+ * 2. Allocates bits using Rate-Distortion Optimization (RDO)
+ * 3. Quantizes coefficients using scale factors and word lengths
  *
- * Uses a perceptual model to ensure quantization noise remains below
- * the masking threshold, maximizing quality within the bit budget.
+ * Uses RDO to optimize the allocation of bits for maximum quality
+ * within the available bit budget.
  *
- * @param {Object} context - Pipeline context containing bufferPool and options
- * @param {BufferPool} context.bufferPool - Shared buffer pool for efficient memory management
- * @param {EncoderOptions} context.options - Encoding configuration options
  * @returns {Function} Stage function that processes MDCT results
- * @throws {Error} If bufferPool or options are not provided in context
+ * @throws {Error} If bufferPool is not provided in context
  */
-export function quantizationStage(context) {
-  const bufferPool =
-    context?.bufferPool ??
-    throwError('quantizationStage: bufferPool is required')
-  const options =
-    context?.options ?? throwError('quantizationStage: options is required')
-
+export function quantizationStage() {
   /**
-   * Perform psychoacoustic analysis and quantization
+   * Perform RDO bit allocation and quantization
    * @param {Object} input - MDCT transform results
    * @param {Float32Array} input.coefficients - MDCT coefficients
    * @param {Array<number>} input.blockModes - Block modes
@@ -369,31 +373,21 @@ export function quantizationStage(context) {
 
     const { bfuData, bfuSizes, bfuCount } = groupIntoBFUs(
       coefficients,
-      blockModes,
-      bufferPool.bfuData
+      blockModes
     )
 
-    const psychoResults = psychoAnalysis(
-      coefficients,
-      options.normalizationDb,
-      bufferPool.psychoBuffers
-    )
-    const { bfuCount: selectedBfuCount, allocation } = allocateBits(
-      psychoResults,
-      bfuData,
-      bfuSizes,
-      bfuCount
-    )
+    const {
+      bfuCount: selectedBfuCount,
+      allocation,
+      scaleFactorIndices,
+    } = allocateBits(bfuData, bfuSizes, bfuCount)
 
-    const scaleFactorIndices = new Int32Array(selectedBfuCount)
     const quantizedCoefficients = []
 
     for (let bfu = 0; bfu < selectedBfuCount; bfu++) {
       const data = bfuData[bfu].subarray(0, bfuSizes[bfu])
       const wordLength = allocation[bfu]
       const bitsPerSample = WORD_LENGTH_BITS[wordLength]
-
-      scaleFactorIndices[bfu] = findScaleFactor(data)
       const quantized = quantize(data, scaleFactorIndices[bfu], bitsPerSample)
       quantizedCoefficients.push(quantized)
     }