@audio/denoise-core 0.1.1 → 0.1.3

package/index.js

@@ -1,6 +1,4 @@
 export * from './stft.js'
 export * from './util.js'
-export * from './noise.js'
-export * from './vad.js'
 export * from './ar.js'
 export * from './quality.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@audio/denoise-core",
-  "version": "0.1.1",
-  "description": "Shared restoration primitives — STFT (batch/stream/analyse), noise estimation (min-stats, IMCRA), VAD, AR modeling, quality metrics",
+  "version": "0.1.3",
+  "description": "Internal glue for @audio/denoise-* atoms — STFT (batch/stream/analyse), AR modeling, quality metrics, dB/linear + stream-writer utils. VAD → @audio/vad, noise estimation → @audio/noise-estimate.",
   "type": "module",
   "sideEffects": false,
   "main": "index.js",
@@ -10,8 +10,6 @@
     "./package.json": "./package.json",
     "./stft": "./stft.js",
     "./util": "./util.js",
-    "./noise": "./noise.js",
-    "./vad": "./vad.js",
     "./ar": "./ar.js",
     "./quality": "./quality.js"
   },
@@ -19,8 +17,6 @@
     "index.js",
     "stft.js",
     "util.js",
-    "noise.js",
-    "vad.js",
     "ar.js",
     "quality.js"
   ],
@@ -31,9 +27,7 @@
     "audio",
     "dsp",
     "denoise",
-    "stft",
-    "vad",
-    "noise-estimation"
+    "stft"
   ],
   "license": "MIT",
   "author": "Dmitry Iv. <dfcreative@gmail.com>",

package/noise.js

@@ -1,119 +0,0 @@
-// Noise PSD estimators feeding the statistical denoisers (Wiener, OM-LSA, MMSE).
-//   - profile: average |X|² over a user-chosen quiet segment (manual baseline)
-//   - minimumStatistics: Martin (2001) — track minima of smoothed |X|² in sliding window
-//   - imcra: Cohen (2003) — Improved MCRA, two-iteration smoothing + speech-presence-driven
-//
-// All estimators are stateful: pass the same params object across frames in stream mode.
-
-import { stftAnalyse } from './stft.js'
-
-// One-shot batch profile from a quiet segment of `data`. Returns Float64Array(N/2+1).
-export function noiseProfile(data, opts = {}) {
-  let N = opts.frameSize || 2048
-  let hop = opts.hopSize || (N >> 2)
-  let half = N >> 1
-  let from = Math.max(0, opts.from ?? 0)
-  let to = Math.min(data.length, opts.to ?? Math.min(data.length, from + N * 8))
-  let seg = data.subarray(from, to)
-  let psd = new Float64Array(half + 1)
-  let count = 0
-  stftAnalyse(seg, mag => {
-    for (let k = 0; k <= half; k++) psd[k] += mag[k] * mag[k]
-    count++
-  }, { frameSize: N, hopSize: hop })
-  let scale = count ? 1 / count : 0
-  for (let k = 0; k <= half; k++) psd[k] *= scale
-  return psd
-}
-
-// Minimum Statistics (Martin 2001) — frame-by-frame online updater.
-// Keeps a rolling D-frame minimum of smoothed PSD per bin; multiplies by a bias
-// compensation factor so the minimum tracks E{|N|²} rather than the lower-tail.
-//
-// Usage:
-//   let est = minStats(half, { D: 96 })
-//   stftAnalyse(data, m => est.update(m))
-//   let psd = est.psd  // current noise PSD
-//
-// D ≈ 1.5 s of frames at hop = N/4 ≈ 96 frames @ 44.1k / N=2048.
-export function minStats(half, opts = {}) {
-  let D = opts.D || 96
-  let alpha = opts.alpha ?? 0.7              // smoothing on PSD
-  let bias = opts.bias ?? 1.5                 // empirical comp from Martin §VII
-  let smoothed = new Float64Array(half + 1)
-  let psd = new Float64Array(half + 1)
-  let buf = []                                 // ring of recent smoothed frames
-
-  return {
-    psd,
-    update(mag) {
-      let p = new Float64Array(half + 1)
-      for (let k = 0; k <= half; k++) {
-        let pk = mag[k] * mag[k]
-        smoothed[k] = alpha * smoothed[k] + (1 - alpha) * pk
-        p[k] = smoothed[k]
-      }
-      buf.push(p)
-      if (buf.length > D) buf.shift()
-      for (let k = 0; k <= half; k++) {
-        let mn = Infinity
-        for (let i = 0; i < buf.length; i++) if (buf[i][k] < mn) mn = buf[i][k]
-        psd[k] = mn * bias
-      }
-    }
-  }
-}
-
-// IMCRA — Improved Minima Controlled Recursive Averaging (Cohen 2003).
-// Drives noise PSD via speech-presence probability (SPP) so it stops updating
-// during voiced regions. SPP itself is supplied by the caller (see vad.js spp())
-// or computed internally from the smoothed-to-min PSD ratio.
-export function imcra(half, opts = {}) {
-  let alpha = opts.alpha ?? 0.92
-  let alphaD = opts.alphaD ?? 0.85
-  let beta = opts.beta ?? 1.47
-  let psd = new Float64Array(half + 1)
-  let psdInit = false
-  let smoothed = new Float64Array(half + 1)
-  let mins = new Float64Array(half + 1)
-  let prevMins = new Float64Array(half + 1)
-  let frameCount = 0
-  let resetEvery = opts.resetEvery || 80      // ≈ 0.9 s @ 44.1k, hop=512
-
-  return {
-    psd,
-    update(mag, sppOverride) {
-      let init = !psdInit
-      for (let k = 0; k <= half; k++) {
-        let pk = mag[k] * mag[k]
-        smoothed[k] = init ? pk : alpha * smoothed[k] + (1 - alpha) * pk
-        if (init || smoothed[k] < mins[k]) mins[k] = smoothed[k]
-        if (!init && smoothed[k] < prevMins[k]) prevMins[k] = smoothed[k]
-      }
-      frameCount++
-      if (frameCount >= resetEvery) {
-        for (let k = 0; k <= half; k++) {
-          let mn = Math.min(mins[k], prevMins[k])
-          prevMins[k] = mins[k]
-          mins[k] = smoothed[k]
-          // bias-compensated minimum tracker
-          if (init) psd[k] = mn * beta
-        }
-        frameCount = 0
-        psdInit = true
-      }
-
-      if (!psdInit) return
-
-      for (let k = 0; k <= half; k++) {
-        let mn = Math.min(mins[k], prevMins[k]) * beta
-        // SPP from local SNR vs minimum: high if smoothed >> minimum.
-        let snr = smoothed[k] / Math.max(mn, 1e-30)
-        let p = sppOverride !== undefined ? sppOverride : 1 / (1 + Math.exp(-3 * (snr - 5)))
-        let alphaTilde = alphaD + (1 - alphaD) * p
-        let pk = mag[k] * mag[k]
-        psd[k] = alphaTilde * psd[k] + (1 - alphaTilde) * pk
-      }
-    }
-  }
-}

package/vad.js

@@ -1,91 +0,0 @@
-// Voice Activity Detection + Speech Presence Probability.
-//   - vad: hard 0/1 decision per frame from energy + spectral flatness + ZCR
-//   - spp: soft probability per bin from a-priori SNR (drives OM-LSA, IMCRA)
-//
-// Use vad() for gating decisions (debreath, gate); spp() for spectral denoise gain.
-
-import { stftAnalyse } from './stft.js'
-import { lin2db } from './util.js'
-
-// Returns { active: Uint8Array(frames), times: Float32Array(frames) of frame-start sec }.
-// Active iff energy is N dB above the rolling noise floor AND spectral flatness < flatTh.
-//
-// Floor estimation: minimum of energy over a sliding D-frame window with bias
-// correction — Martin-style minimum tracking. This avoids the "speech eats its own
-// floor" failure mode of plain exponential smoothing.
-//
-// flatTh ≈ 0.4 — speech is tonal (low flatness), noise is flat (high flatness).
-export function vad(data, opts = {}) {
-  let N = opts.frameSize || 1024
-  let hop = opts.hopSize || (N >> 1)
-  let fs = opts.fs || 44100
-  let snrTh = opts.snrTh ?? 6                  // dB above floor
-  let flatTh = opts.flatTh ?? 0.4              // spectral flatness threshold
-  let D = opts.window || 64                    // frames in min-tracker window
-  let bias = opts.bias ?? 5                    // dB — added to min to estimate true floor
-
-  let frames = Math.max(0, Math.floor((data.length - N) / hop) + 1)
-  let active = new Uint8Array(frames)
-  let times = new Float32Array(frames)
-  let energies = new Float64Array(frames)
-  let flats = new Float64Array(frames)
-  let i = 0
-
-  stftAnalyse(data, (mag, _phase, pos) => {
-    let half = mag.length - 1, e = 0
-    let logSum = 0, linSum = 0, nz = 0
-    for (let k = 1; k <= half; k++) {
-      let p = mag[k] * mag[k]
-      e += p
-      if (p > 1e-30) { logSum += Math.log(p); nz++ }
-      linSum += p
-    }
-    let geom = nz ? Math.exp(logSum / nz) : 0
-    let arith = linSum / Math.max(half, 1)
-    flats[i] = arith > 1e-30 ? geom / arith : 1
-    energies[i] = lin2db(Math.sqrt(e / N))
-    times[i] = pos / fs
-    i++
-  }, { frameSize: N, hopSize: hop })
-
-  // Global noise floor = 10th-percentile energy + bias. Robust on signals where
-  // any short window may be entirely speech.
-  let sorted = Float64Array.from(energies).sort()
-  let floor = sorted[Math.floor(sorted.length * 0.1)] + bias
-
-  for (let j = 0; j < frames; j++) {
-    active[j] = (energies[j] - floor > snrTh && flats[j] < flatTh) ? 1 : 0
-  }
-  return { active, times, hop, frameSize: N }
-}
-
-// Per-bin Speech Presence Probability from a-priori SNR ξ:
-//   p = ξ / (1 + ξ)   (Bayesian formulation under Gaussian model, q-prior = 0.5)
-// Bind to a noise PSD source (e.g. minStats.psd or imcra.psd) and an a-priori SNR estimate.
-export function spp(mag, noisePsd, opts = {}) {
-  let xiMin = opts.xiMin ?? 0.0316             // -15 dB floor
-  let half = mag.length - 1
-  let p = new Float64Array(half + 1)
-  for (let k = 0; k <= half; k++) {
-    let post = (mag[k] * mag[k]) / Math.max(noisePsd[k], 1e-30) - 1
-    let xi = Math.max(xiMin, post)
-    p[k] = xi / (1 + xi)
-  }
-  return p
-}
-
-// Decision-Directed a-priori SNR (Ephraim-Malah 1984), recursive smoothing.
-//   ξ̂[k] = α · |X̂_prev[k]|² / N̂[k]  +  (1-α) · max(γ-1, 0)
-// γ = posterior SNR = |Y[k]|² / N̂[k]. Used by Wiener, MMSE, OM-LSA gain rules.
-export function ddSnr(mag, noisePsd, prevGain, prevMag, alpha = 0.98) {
-  let half = mag.length - 1
-  let xi = new Float64Array(half + 1)
-  for (let k = 0; k <= half; k++) {
-    let n = Math.max(noisePsd[k], 1e-30)
-    let post = (mag[k] * mag[k]) / n
-    let g = prevGain[k] * prevMag[k]
-    let prev = (g * g) / n
-    xi[k] = Math.max(0.0316, alpha * prev + (1 - alpha) * Math.max(post - 1, 0))
-  }
-  return xi
-}