@audio/denoise-core 0.1.2 → 0.1.4

package/index.js

@@ -1,6 +1,3 @@
 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.2",
-  "description": "Internal glue for @audio/denoise-* atoms — STFT (batch/stream/analyse), noise estimation (min-stats, IMCRA), AR modeling, quality metrics. VAD lives in @audio/vad (re-exported here).",
+  "version": "0.1.4",
+  "description": "Internal glue for @audio/denoise-* atoms — STFT (batch/stream/analyse), quality metrics, dB/linear + stream-writer utils. VAD → @audio/vad, noise estimation → @audio/noise-estimate, LPC/AR → @audio/lpc.",
   "type": "module",
   "sideEffects": false,
   "main": "index.js",
@@ -10,31 +10,22 @@
     "./package.json": "./package.json",
     "./stft": "./stft.js",
     "./util": "./util.js",
-    "./noise": "./noise.js",
-    "./vad": "./vad.js",
-    "./ar": "./ar.js",
     "./quality": "./quality.js"
   },
   "files": [
     "index.js",
     "stft.js",
     "util.js",
-    "noise.js",
-    "vad.js",
-    "ar.js",
     "quality.js"
   ],
   "dependencies": {
-    "fourier-transform": "^2.0.0",
-    "@audio/vad": "^1.0.0"
+    "fourier-transform": "^2.0.0"
   },
   "keywords": [
     "audio",
     "dsp",
     "denoise",
-    "stft",
-    "vad",
-    "noise-estimation"
+    "stft"
   ],
   "license": "MIT",
   "author": "Dmitry Iv. <dfcreative@gmail.com>",

package/stft.js

@@ -55,7 +55,10 @@ export function stftBatch(data, process, opts) {
   let sc = scratch(N, half)
   let pos = 0
 
-  while (pos + N <= outLen + hop) {
+  // Start a frame at every hop up to the last sample so the tail keeps the
+  // steady-state overlap count — bounding by `pos + N <= outLen` would stop
+  // N−hop samples early (tail under-normalized) and drop inputs shorter than N.
+  while (pos < outLen) {
     let sf = frame(data, pos, win, half, process, state, ctx, sc)
     for (let i = 0; i < N && pos + i < outLen; i++) {
       out[pos + i] += sf[i] * win[i]

package/ar.js

@@ -1,131 +0,0 @@
-// Auto-regressive modelling for click/click-burst interpolation and de-clip extrapolation.
-//   - Levinson-Durbin recursion → AR(p) coefficients from autocorrelation
-//   - LS interpolation of missing samples from neighbouring AR predictions
-//   - Forward AR extrapolation (used by de-clip)
-//
-// Reference: Godsill & Rayner (1998), "Digital Audio Restoration", §5.
-
-// Biased autocorrelation R[0..p]. Bias is preferable for short windows (Toeplitz PSD).
-export function autocorr(x, p) {
-  let n = x.length, R = new Float64Array(p + 1)
-  for (let k = 0; k <= p; k++) {
-    let s = 0
-    for (let i = 0; i + k < n; i++) s += x[i] * x[i + k]
-    R[k] = s
-  }
-  return R
-}
-
-// Levinson-Durbin: solve Toeplitz Yule-Walker for AR(p) coefficients.
-// Returns { a: Float64Array(p+1), e: residual variance }.  a[0] = 1 by convention.
-export function levinson(R, p) {
-  let a = new Float64Array(p + 1)
-  let prev = new Float64Array(p + 1)
-  a[0] = 1
-  let e = R[0]
-  if (e <= 0) return { a, e: 0 }
-
-  for (let i = 1; i <= p; i++) {
-    let k = -R[i]
-    for (let j = 1; j < i; j++) k -= a[j] * R[i - j]
-    k /= e
-    for (let j = 0; j <= i; j++) prev[j] = a[j]
-    a[i] = k
-    for (let j = 1; j < i; j++) a[j] = prev[j] + k * prev[i - j]
-    e *= 1 - k * k
-    if (e <= 0) { e = 0; break }
-  }
-  return { a, e }
-}
-
-// Convenience: AR fit on a window.
-export function arFit(x, p) {
-  return levinson(autocorr(x, p), p)
-}
-
-// Predict next sample via AR(p): x̂[n] = -∑ a[k]·x[n-k], k=1..p.
-export function arPredict(a, hist) {
-  let p = a.length - 1, s = 0
-  for (let k = 1; k <= p; k++) s -= a[k] * hist[hist.length - k]
-  return s
-}
-
-// Forward AR extrapolation by m samples beyond context tail.
-// Used for de-clip: fit AR on un-clipped neighbourhood, project into clipped region.
-export function arExtrapolate(context, a, m) {
-  let p = a.length - 1
-  let buf = new Float64Array(p + m)
-  for (let i = 0; i < p; i++) buf[i] = context[context.length - p + i]
-  for (let i = 0; i < m; i++) {
-    let s = 0
-    for (let k = 1; k <= p; k++) s -= a[k] * buf[p + i - k]
-    buf[p + i] = s
-  }
-  return buf.subarray(p)
-}
-
-// Least-squares interpolation of indices `gap` (sorted ints) inside x using AR(p).
-// Solves Bᵀ B  · u = -Bᵀ A · k, where u = unknowns, k = knowns,
-// (B,A) split of the AR convolution matrix on (gap, ¬gap).
-//
-// Direct sparse Gauss-Seidel is enough for clusters up to ~50 samples; very small
-// gaps (≤8) reduce to a few iterations and are dominated by the AR fit cost itself.
-export function arInterpolate(x, gap, a) {
-  let p = a.length - 1
-  let n = x.length, m = gap.length
-  if (m === 0) return x
-
-  let inGap = new Uint8Array(n)
-  for (let i = 0; i < m; i++) inGap[gap[i]] = 1
-
-  // M = sum over t of (sum_{k:t-k∈gap} a[k] * a[k - (t - gap_j)]) — assemble m×m system implicitly.
-  // For practicality, use Jacobi iteration: x_g = -∑_{j≠g} M[g,j]/M[g,g] · x_j  + b/M[g,g]
-  // with M[g,g] = ∑_k a[k]² for k where g+k≤n+p
-  // and forcing term computed from neighbours.
-  let mdiag = new Float64Array(m)
-  for (let i = 0; i < m; i++) {
-    let g = gap[i], s = 0
-    for (let k = 0; k <= p; k++) {
-      let t = g + k
-      if (t >= 0 && t < n + p) s += a[k] * a[k]
-    }
-    mdiag[i] = s || 1
-  }
-
-  // initial: linear interpolation between gap boundaries
-  for (let i = 0; i < m; i++) {
-    let g = gap[i]
-    let lo = g, hi = g
-    while (lo > 0 && inGap[lo - 1]) lo--
-    while (hi < n - 1 && inGap[hi + 1]) hi++
-    let xLo = lo > 0 ? x[lo - 1] : 0
-    let xHi = hi < n - 1 ? x[hi + 1] : 0
-    x[g] = xLo + (xHi - xLo) * (g - lo + 1) / (hi - lo + 2)
-  }
-
-  // 30 Gauss-Seidel sweeps converge well past audible accuracy for short gaps
-  let iter = 30
-  for (let it = 0; it < iter; it++) {
-    for (let i = 0; i < m; i++) {
-      let g = gap[i]
-      // residual r[t] = ∑_k a[k] x[t-k] for t = g..g+p; gradient wrt x[g] is
-      // ∑_k a[k] r[g+k]; setting it to zero gives the update.
-      let num = 0
-      for (let k = 0; k <= p; k++) {
-        let t = g + k
-        if (t < 0 || t >= n + p) continue
-        let rt = 0
-        for (let j = 0; j <= p; j++) {
-          let idx = t - j
-          if (idx < 0 || idx >= n) continue
-          rt += a[j] * x[idx]
-        }
-        // remove self-contribution so we can solve for x[g]
-        rt -= a[k] * x[g]
-        num -= a[k] * rt
-      }
-      x[g] = num / mdiag[i]
-    }
-  }
-  return x
-}

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,3 +0,0 @@
-// vad/spp/ddSnr were promoted to the standalone @audio/vad atom.
-// Re-exported here so restoration code (and the @audio/denoise umbrella) keep working.
-export * from '@audio/vad'