carta1 1.0.12 → 1.0.14

package/codec/analysis/psychoacoustics.js

@@ -9,14 +9,17 @@ import {
   PSYMODEL_MIN_POWER_DB,
   PSYMODEL_NOT_EXAMINED,
   PSYMODEL_TONAL,
+  PSYMODEL_FFT_SIZE,
   PSYMODEL_NON_TONAL,
   PSYMODEL_IRRELEVANT,
   PSYMODEL_LOG10_FACTOR,
   PSYMODEL_POW10_FACTOR,
   PSYMODEL_CRITICAL_BANDS,
-  PSYMODEL_CB_FREQ_INDICES,
   PSYMODEL_THRESHOLD_TABLE,
   PSYMODEL_FREQ_TO_CB_MAP,
+  PSYMODEL_PSD_SOURCE_IDX0,
+  PSYMODEL_PSD_INTERP_WEIGHT,
+  PSYMODEL_PSD_SOURCE_IDX1,
 } from '../core/constants.js'
 
 /**
@@ -42,134 +45,70 @@ export function fromDb(db) {
 /**
  * Perform complete psychoacoustic analysis on MDCT coefficients
  * @param {Float32Array} mdctCoeffs - MDCT coefficients (512 samples)
- * @param {number} targetSize - Target FFT size for analysis
- * @param {Object} psychoBuffers - Reusable buffers for performance
+ * @param {number} normalizationDb - Target maximum power level in dB
  * @returns {Object} Analysis results including PSD, maskers, and thresholds
  */
-export function psychoAnalysis(
-  mdctCoeffs,
-  targetSize,
-  psychoBuffers,
-  normalizationDb
-) {
-  const fftScale = targetSize / 512
-
-  // Apply frequency band reversal correction
-  const correctedCoeffs = applyMdctCorrection(mdctCoeffs)
+export function psychoAnalysis(mdctCoeffs, normalizationDb) {
+  const fftScale = PSYMODEL_FFT_SIZE / 512
 
   // Calculate power spectral density
-  const psd = calculatePSDFromMDCT(correctedCoeffs, targetSize, normalizationDb)
+  const psd = calculatePSDFromMDCT(mdctCoeffs, normalizationDb)
 
   // Find tonal and non-tonal maskers
-  const { flags, tonalMaskers, nonTonalMaskers } = findAllMaskers(
-    psd,
-    psychoBuffers,
-    fftScale
-  )
+  const { flags, tonalMaskers, nonTonalMaskers } = findAllMaskers(psd, fftScale)
 
-  // Calculate global masking threshold
-  const globalThreshold = calculateGlobalThreshold(
+  // Calculate critical band masking thresholds
+  const criticalBandThresholds = calculateCriticalBandThresholds(
     psd,
     tonalMaskers,
-    nonTonalMaskers,
-    psychoBuffers.threshold,
-    targetSize
+    nonTonalMaskers
   )
 
   return {
     psd,
     tonalMaskers,
+    tonalMaskersCount: tonalMaskers.length,
     nonTonalMaskers,
-    globalThreshold,
+    nonTonalMaskersCount: nonTonalMaskers.length,
+    criticalBandThresholds,
     flags,
   }
 }
 
-/**
- * Apply frequency band reversal correction to MDCT coefficients
- * @param {Float32Array} mdctCoeffs - Original MDCT coefficients
- * @returns {Float32Array} Corrected coefficients
- */
-function applyMdctCorrection(mdctCoeffs) {
-  const corrected = new Float32Array(512)
-
-  // Low band: direct copy
-  corrected.set(mdctCoeffs.subarray(0, 128), 0)
-
-  // Mid band: reversed
-  for (let i = 0; i < 128; i++) {
-    corrected[128 + i] = mdctCoeffs[255 - i]
-  }
-
-  // High band: reversed
-  for (let i = 0; i < 256; i++) {
-    corrected[256 + i] = mdctCoeffs[511 - i]
-  }
-
-  return corrected
-}
-
 /**
  * Calculate Power Spectral Density from MDCT coefficients
  * @param {Float32Array} mdctCoeffs - MDCT coefficients
- * @param {number} targetSize - Target FFT size
  * @returns {Float32Array} Power spectral density in dB
  */
-function calculatePSDFromMDCT(mdctCoeffs, targetSize, normalizationDb) {
-  const halfTargetSize = targetSize / 2
-  const psd = new Float32Array(halfTargetSize + 1)
-
-  // Calculate power values and find maximum
-  const powers = new Float32Array(512)
-  let maxPower = 0
-
-  for (let i = 0; i < 512; i++) {
-    const power = mdctCoeffs[i] * mdctCoeffs[i]
-    powers[i] = power
-    maxPower = Math.max(maxPower, power)
-  }
-
-  const normFactor = 1 / (maxPower || 1)
-  let maxPsdValue = -Infinity
-
-  if (targetSize === 512) {
-    // Direct averaging for same size
-    for (let i = 0; i < 256; i++) {
-      const avgPower = (powers[i * 2] + powers[i * 2 + 1]) * 0.5 * normFactor
-      psd[i] = avgPower > 0 ? toDb(avgPower) : PSYMODEL_MIN_POWER_DB
-      maxPsdValue = Math.max(maxPsdValue, psd[i])
-    }
-    psd[256] = psd[255]
-    // Check if last value is the max
-    maxPsdValue = Math.max(maxPsdValue, psd[256])
-  } else {
-    // Interpolate for different sizes
-    const scaleFactor = 512 / targetSize
-
-    for (let i = 0; i <= halfTargetSize; i++) {
-      const srcIdx = i * scaleFactor
-      const srcIdxInt = Math.floor(srcIdx)
-      const frac = srcIdx - srcIdxInt
-
-      const power =
-        srcIdxInt < 511
-          ? powers[srcIdxInt] * (1 - frac) + powers[srcIdxInt + 1] * frac
-          : powers[511]
-
-      const normalizedPower = power * normFactor
-      psd[i] =
-        normalizedPower > 0 ? toDb(normalizedPower) : PSYMODEL_MIN_POWER_DB
-
-      maxPsdValue = Math.max(maxPsdValue, psd[i])
+function calculatePSDFromMDCT(mdctCoeffs, normalizationDb) {
+  const half = PSYMODEL_FFT_SIZE >>> 1
+  const psd = new Float32Array(half + 1)
+  const linearPower = new Float32Array(half + 1)
+
+  let maxLinearPower = 0
+  for (let i = 0; i <= half; i++) {
+    const a = mdctCoeffs[PSYMODEL_PSD_SOURCE_IDX0[i]]
+    const b = mdctCoeffs[PSYMODEL_PSD_SOURCE_IDX1[i]]
+
+    const power =
+      a * a * (1 - PSYMODEL_PSD_INTERP_WEIGHT[i]) +
+      b * b * PSYMODEL_PSD_INTERP_WEIGHT[i]
+    linearPower[i] = power
+
+    if (power > maxLinearPower) {
+      maxLinearPower = power
     }
   }
 
-  // Apply normalization to target maximum
-  const normalizationDelta = normalizationDb - maxPsdValue
+  const offset =
+    normalizationDb - PSYMODEL_LOG10_FACTOR * Math.log(maxLinearPower || 1)
 
-  for (let i = 0; i < psd.length; i++) {
-    if (psd[i] > PSYMODEL_MIN_POWER_DB) {
-      psd[i] += normalizationDelta
+  for (let i = 0; i <= half; i++) {
+    const power = linearPower[i]
+    if (power > 0) {
+      psd[i] = PSYMODEL_LOG10_FACTOR * Math.log(power) + offset
+    } else {
+      psd[i] = PSYMODEL_MIN_POWER_DB
     }
   }
 
@@ -179,20 +118,19 @@ function calculatePSDFromMDCT(mdctCoeffs, targetSize, normalizationDb) {
 /**
  * Find all maskers (tonal and non-tonal) in the spectrum
  * @param {Float32Array} psd - Power spectral density
- * @param {Object} psychoBuffers - Reusable buffers
  * @param {number} fftScale - FFT scaling factor
  * @returns {Object} Flags array and lists of maskers
  */
-function findAllMaskers(psd, psychoBuffers, fftScale) {
+function findAllMaskers(psd, fftScale) {
   // Initialize flags
-  const flags = psychoBuffers.flags
+  const flags = new Uint8Array(PSYMODEL_FFT_SIZE / 2)
   flags.fill(PSYMODEL_NOT_EXAMINED)
 
   // Find tonal maskers first
-  let { tonalList } = findTonalMaskers(psd, flags, fftScale)
+  const tonalList = findTonalMaskers(psd, flags, fftScale)
 
   // Find non-tonal maskers
-  let { nonTonalList } = findNonTonalMaskers(flags, psd)
+  const nonTonalList = findNonTonalMaskers(flags, psd)
 
   // Apply decimation to remove weak maskers
   const decimated = decimateMaskers(flags, tonalList, nonTonalList)
@@ -214,68 +152,67 @@ function findAllMaskers(psd, psychoBuffers, fftScale) {
 function findTonalMaskers(psd, flags, fftScale) {
   const tonalList = []
   const maxTonalBin = Math.floor(249 * fftScale)
-  const fftSize = (psd.length - 1) * 2
 
   // Frequency range boundaries
   const RANGE_LOW = Math.floor(63 * fftScale)
   const RANGE_MID = Math.floor(127 * fftScale)
   const RANGE_HIGH = Math.floor(150 * fftScale)
 
-  for (let k = 1; k < fftSize / 2 - 1 && k <= maxTonalBin; k++) {
+  for (let k = 1; k < psd.length - 1 && k <= maxTonalBin; k++) {
     // Check for local maximum
     if (psd[k] <= psd[k - 1] || psd[k] < psd[k + 1]) continue
 
     // Determine search range based on frequency
-    const searchOffsets = getSearchOffsets(k, RANGE_LOW, RANGE_MID, RANGE_HIGH)
-    if (!searchOffsets) continue
+    let searchOffsets
+    if (k > 2 && k < RANGE_LOW) {
+      searchOffsets = [-2, 2]
+    } else if (k >= RANGE_LOW && k < RANGE_MID) {
+      searchOffsets = [-3, -2, 2, 3]
+    } else if (k >= RANGE_MID && k < RANGE_HIGH) {
+      searchOffsets = [-6, -5, -4, -3, -2, 2, 3, 4, 5, 6]
+    } else {
+      continue
+    }
 
     // Check tonality criteria
     if (isTonal(psd, k, searchOffsets)) {
       // Calculate combined SPL
       const spl = toDb(fromDb(psd[k - 1]) + fromDb(psd[k]) + fromDb(psd[k + 1]))
-
       tonalList.push({ index: k, spl })
       markTonalComponent(flags, k, searchOffsets)
     }
   }
 
-  return { flags, tonalList }
-}
-
-/**
- * Get search offsets for tonality check based on frequency
- */
-function getSearchOffsets(k, rangeLow, rangeMid, rangeHigh) {
-  if (k > 2 && k < rangeLow) return [-2, 2]
-  if (k >= rangeLow && k < rangeMid) return [-3, -2, 2, 3]
-  if (k >= rangeMid && k < rangeHigh) return [-6, -5, -4, -3, -2, 2, 3, 4, 5, 6]
-  return null
+  return tonalList
 }
 
 /**
  * Check if a peak is tonal based on surrounding bins
+ * @param {Float32Array} psd - Power spectral density array
+ * @param {number} k - Index of the peak to test
+ * @param {number[]} offsets - Array of offset indices to check around the peak
+ * @returns {boolean} True if the peak qualifies as tonal
  */
 function isTonal(psd, k, offsets) {
-  const TONAL_THRESHOLD = 7 // dB
-
+  const TONAL_THRESHOLD = 7.0
   for (const offset of offsets) {
     const idx = k + offset
-    if (idx >= 0 && idx < psd.length) {
-      if (psd[k] - psd[idx] < TONAL_THRESHOLD) return false
+    if (idx >= 0 && idx < psd.length && psd[k] - psd[idx] < TONAL_THRESHOLD) {
+      return false
     }
   }
-
   return true
 }
 
 /**
  * Mark component and neighbors as tonal/irrelevant
+ * @param {Uint8Array} flags - Component classification flags array
+ * @param {number} k - Index of the tonal component
+ * @param {number[]} searchOffsets - Array of offset indices used for tonal detection
  */
 function markTonalComponent(flags, k, searchOffsets) {
   flags[k] = PSYMODEL_TONAL
-
-  const allOffsets = [...searchOffsets, -1, 1]
-  for (const offset of allOffsets) {
+  for (const offset of [...searchOffsets, -1, 1]) {
     const idx = k + offset
     if (idx >= 0 && idx < flags.length && idx !== k) {
       flags[idx] = PSYMODEL_IRRELEVANT
@@ -297,7 +234,6 @@ function findNonTonalMaskers(flags, psd) {
     const cbEnd =
       PSYMODEL_THRESHOLD_TABLE[PSYMODEL_CRITICAL_BANDS[i + 1]][0] - 1
 
-    // Calculate band energy and centroid
     const bandAnalysis = analyzeCriticalBand(
       psd,
       flags,
@@ -321,11 +257,17 @@ function findNonTonalMaskers(flags, psd) {
     }
   }
 
-  return { flags, nonTonalList }
+  return nonTonalList
 }
 
 /**
  * Analyze a critical band for non-tonal masking
+ * @param {Float32Array} psd - Power spectral density array
+ * @param {Uint8Array} flags - Component classification flags array
+ * @param {number} startBin - Starting frequency bin of the critical band
+ * @param {number} endBin - Ending frequency bin of the critical band
+ * @param {number} bandIndex - Critical band index for threshold table lookup
+ * @returns {Object} Analysis results with power and centroid offset
  */
 function analyzeCriticalBand(psd, flags, startBin, endBin, bandIndex) {
   let totalPower = 0
@@ -337,9 +279,11 @@ function analyzeCriticalBand(psd, flags, startBin, endBin, bandIndex) {
       const power = fromDb(psd[k])
       totalPower += power
 
-      const barkDiff =
-        PSYMODEL_THRESHOLD_TABLE[PSYMODEL_FREQ_TO_CB_MAP[k]][1] - baseBark
-      weightedPower += power * barkDiff
+      if (k < PSYMODEL_FREQ_TO_CB_MAP.length) {
+        const barkDiff =
+          PSYMODEL_THRESHOLD_TABLE[PSYMODEL_FREQ_TO_CB_MAP[k]][1] - baseBark
+        weightedPower += power * barkDiff
+      }
 
       flags[k] = PSYMODEL_IRRELEVANT
     }
@@ -401,52 +345,45 @@ function decimateMaskers(flags, tonalList, nonTonalList) {
 }
 
 /**
- * Calculate global masking threshold
+ * Calculate critical band masking thresholds
  * @param {Float32Array} psd - Power spectral density
  * @param {Array} tonalMaskers - List of tonal maskers
  * @param {Array} nonTonalMaskers - List of non-tonal maskers
- * @param {Float32Array} thresholdBuffer - Output buffer for threshold
- * @param {number} fftSize - FFT size
- * @returns {Float32Array} Global masking threshold
+ * @returns {Float32Array} Critical band thresholds
  */
-function calculateGlobalThreshold(
-  psd,
-  tonalMaskers,
-  nonTonalMaskers,
-  thresholdBuffer,
-  fftSize
-) {
+function calculateCriticalBandThresholds(psd, tonalMaskers, nonTonalMaskers) {
   const criticalBandThresholds = new Float32Array(
     PSYMODEL_CRITICAL_BANDS.length
   )
 
-  // Calculate threshold for each critical band
-  calculateCriticalBandThresholds(
-    psd,
-    tonalMaskers,
-    nonTonalMaskers,
-    criticalBandThresholds
-  )
+  // Pre-collect all maskers with their properties
+  const maskers = []
 
-  // Interpolate to full spectrum with compensation
-  interpolateThresholdCompensated(
-    criticalBandThresholds,
-    thresholdBuffer,
-    fftSize
-  )
+  for (const masker of tonalMaskers) {
+    const j = masker.index
+    if (j < PSYMODEL_FREQ_TO_CB_MAP.length) {
+      maskers.push({
+        spl: masker.spl,
+        psd: psd[j],
+        bark: PSYMODEL_THRESHOLD_TABLE[PSYMODEL_FREQ_TO_CB_MAP[j]][1],
+        isTonal: true,
+      })
+    }
+  }
 
-  return thresholdBuffer
-}
+  for (const masker of nonTonalMaskers) {
+    const j = masker.index
+    if (j < PSYMODEL_FREQ_TO_CB_MAP.length) {
+      maskers.push({
+        spl: masker.spl,
+        psd: psd[j],
+        bark: PSYMODEL_THRESHOLD_TABLE[PSYMODEL_FREQ_TO_CB_MAP[j]][1],
+        isTonal: false,
+      })
+    }
+  }
 
-/**
- * Calculate masking threshold for each critical band
- */
-function calculateCriticalBandThresholds(
-  psd,
-  tonalMaskers,
-  nonTonalMaskers,
-  output
-) {
+  // Calculate threshold for each critical band
   for (let i = 0; i < PSYMODEL_CRITICAL_BANDS.length; i++) {
     const bandData = PSYMODEL_THRESHOLD_TABLE[PSYMODEL_CRITICAL_BANDS[i]]
     const maskedBark = bandData[1]
@@ -456,57 +393,36 @@ function calculateCriticalBandThresholds(
     let summedEnergy = fromDb(quietThreshold)
 
     // Add contributions from all maskers
-    summedEnergy += calculateMaskerContributions(
-      psd,
-      tonalMaskers,
-      maskedBark,
-      true // isTonal
-    )
-
-    summedEnergy += calculateMaskerContributions(
-      psd,
-      nonTonalMaskers,
-      maskedBark,
-      false // isTonal
-    )
-
-    output[i] = toDb(summedEnergy)
-  }
-}
-
-/**
- * Calculate energy contributions from a set of maskers
- */
-function calculateMaskerContributions(psd, maskers, maskedBark, isTonal) {
-  let totalEnergy = 0
-
-  for (const masker of maskers) {
-    const j = masker.index
-    if (j >= PSYMODEL_FREQ_TO_CB_MAP.length) continue
-
-    const maskerBark = PSYMODEL_THRESHOLD_TABLE[PSYMODEL_FREQ_TO_CB_MAP[j]][1]
-    const barkDistance = maskedBark - maskerBark
-
-    // Check if within masking range
-    if (barkDistance < -3 || barkDistance >= 8) continue
-
-    // Calculate masking level
-    const maskedDb = calculateMaskingLevel(
-      masker.spl,
-      psd[j],
-      maskerBark,
-      barkDistance,
-      isTonal
-    )
+    for (const masker of maskers) {
+      const barkDistance = maskedBark - masker.bark
+
+      // Check if within masking range
+      if (barkDistance >= -3 && barkDistance < 8) {
+        const maskedDb = calculateMaskingLevel(
+          masker.spl,
+          masker.psd,
+          masker.bark,
+          barkDistance,
+          masker.isTonal
+        )
+        summedEnergy += fromDb(maskedDb)
+      }
+    }
 
-    totalEnergy += fromDb(maskedDb)
+    criticalBandThresholds[i] = toDb(summedEnergy)
   }
 
-  return totalEnergy
+  return criticalBandThresholds
 }
 
 /**
- * Calculate masking level based on masker properties
+ * Calculate energy contributions from a set of maskers
+ * @param {number} maskerSpl - Sound pressure level of the masker in dB
+ * @param {number} maskerPsd - Power spectral density of the masker in dB
+ * @param {number} maskerBark - Bark frequency of the masker
+ * @param {number} barkDistance - Distance in Bark scale from masker to maskee
+ * @param {boolean} isTonal - Whether the masker is tonal or non-tonal
+ * @returns {number} Masking threshold contribution in dB
  */
 function calculateMaskingLevel(
   maskerSpl,
@@ -515,75 +431,23 @@ function calculateMaskingLevel(
   barkDistance,
   isTonal
 ) {
-  // Masking index
   const tonalOffset = isTonal
     ? -1.525 - 0.275 * maskerBark - 4.5
     : -1.525 - 0.175 * maskerBark - 0.5
 
-  // PSD-dependent factors
-  const psdFactor1 = 0.4 * maskerPsd + 6
+  const psdFactor1 = 0.4 * maskerPsd + 6.0
   const psdFactor2 = 0.15 * maskerPsd
 
-  // Calculate masking function
   let maskingFunction
-  if (barkDistance < -1) {
-    maskingFunction = 17 * (barkDistance + 1) - psdFactor1
-  } else if (barkDistance < 0) {
+  if (barkDistance < -1.0) {
+    maskingFunction = 17.0 * (barkDistance + 1.0) - psdFactor1
+  } else if (barkDistance < 0.0) {
     maskingFunction = psdFactor1 * barkDistance
-  } else if (barkDistance < 1) {
-    maskingFunction = -17 * barkDistance
+  } else if (barkDistance < 1.0) {
+    maskingFunction = -17.0 * barkDistance
   } else {
-    maskingFunction = -(barkDistance - 1) * (17 - psdFactor2) - 17
+    maskingFunction = -(barkDistance - 1.0) * (17.0 - psdFactor2) - 17.0
   }
 
   return maskerSpl + tonalOffset + maskingFunction
 }
-
-/**
- * Interpolate critical band thresholds to full spectrum
- * @param {Float32Array} cbThresholds - Critical band thresholds
- * @param {Float32Array} output - Output buffer
- * @param {number} fftSize - FFT size
- */
-function interpolateThresholdCompensated(cbThresholds, output, fftSize) {
-  const COMPENSATION_FACTOR = 0.25
-  const halfSize = fftSize / 2
-
-  // Get frequency indices for critical bands
-  const freqIndices = PSYMODEL_CB_FREQ_INDICES
-
-  let bandIndex = 0
-  for (let i = 0; i <= halfSize; i++) {
-    if (i <= freqIndices[0]) {
-      // Before first critical band
-      output[i] = cbThresholds[0]
-    } else if (i >= freqIndices[freqIndices.length - 1]) {
-      // After last critical band
-      output[i] = cbThresholds[cbThresholds.length - 1]
-    } else {
-      // Find current band
-      while (
-        bandIndex < freqIndices.length - 1 &&
-        freqIndices[bandIndex + 1] < i
-      ) {
-        bandIndex++
-      }
-
-      // Interpolate with compensation
-      const x0 = freqIndices[bandIndex]
-      const x1 = freqIndices[bandIndex + 1]
-      const y0 = cbThresholds[bandIndex]
-      const y1 = cbThresholds[bandIndex + 1]
-      const bandWidth = x1 - x0
-
-      if (bandWidth > 0) {
-        const t = (i - x0) / bandWidth
-        const interpolated = y0 + (y1 - y0) * t
-        const compensation = Math.abs(y1 - y0) * COMPENSATION_FACTOR
-        output[i] = interpolated + compensation
-      } else {
-        output[i] = y0
-      }
-    }
-  }
-}