@audio/denoise-detect 0.1.2 → 0.1.4

package/denoise.js

@@ -2,14 +2,15 @@
 // in `data` and dispatches to the most suitable single-pass method.
 //
 // Classification (single STFT sweep over the input):
-//   - tonalScore     — strong narrow peaks at mains harmonics → dehum
-//   - clickScore     — high kurtosis of AR residual → declick
-//   - lfScore        — LF/MF energy ratio above 4 → dewind
-//   - sibilanceScore — 5–9 kHz peaks vs. mids → deesser
-//   - reverbScore    — slow late-tail decay (cepstral peak) → dereverb
-//   - stationary    → omlsa  (best non-stationary general denoise)
-//   - otherwise     → wiener (transparent broadband)
+//   - hum   — narrow peaks at mains harmonics (Goertzel) → dehum
+//   - click — high kurtosis of AR residual → declick
+//   - hi    — 5–9 kHz / mid energy ratio → deesser
+//   - lf    — LF/mid energy ratio → dewind
+//   - stationarity — frame-energy floor CV: stable → wiener, wandering → omlsa
+//   - otherwise → wiener (transparent broadband)
 //
+// dereverb has no reliable single-pass signature, so auto-mode never selects it —
+// reach it explicitly via `denoise(data, { force: 'dereverb' })` or `dereverb()`.
 // Returns { out, plan } so callers can inspect which method ran.
 
 import { stftAnalyse } from '@audio/stft'
@@ -49,18 +50,19 @@ export function classify(data, fs = 44100) {
   let frameVar = []                                 // for stationarity
 
   stftAnalyse(data, mag => {
-    let lf = 0, mf = 0, hi = 0
+    let lf = 0, mf = 0, hi = 0, tot = 0
     for (let k = 0; k <= half; k++) {
       let p = mag[k] * mag[k]
       bins[k] += p
+      tot += p
       let f = k * fs / N
       if (f < 200) lf += p
       else if (f < 2000) mf += p
-      else if (f < 9000) hi += p
+      else if (f >= 5000 && f < 9000) hi += p    // sibilance band, kept specific (not 2–9 kHz)
     }
     lfSum += lf; mfSum += mf; hiSum += hi
-    frameVar.push(lf + mf + hi)
-    frames++
+    frameVar.push(tot)                            // full-spectrum energy — band-restricted
+    frames++                                      // sums under-average the floor statistic
   }, { frameSize: N, hopSize: hop })
   if (!frames) return { method: 'wiener', scores: {} }
 
@@ -91,46 +93,69 @@ export function classify(data, fs = 44100) {
   // HI/MF ratio
   let hiRatio = hiSum / Math.max(mfSum, 1e-30)
 
-  // Click score: AR residual kurtosis on a short window
+  // Click score: max AR-residual excess kurtosis over windows spanning the whole
+  // signal. Clicks are sparse and impulsive — a fixed prefix window can miss them
+  // entirely, so scan across and take the peak (the window holding a click spikes).
   let clickScore = 0
-  if (data.length >= 4096) {
-    let win = data.subarray(0, 4096)
-    try {
-      let { a } = arFit(win, 30)
-      let resid = new Float64Array(4096), mean = 0, m2 = 0, m4 = 0
-      for (let i = 30; i < 4096; i++) {
-        let s = win[i]
-        for (let k = 1; k <= 30; k++) s += a[k] * win[i - k]
-        resid[i] = s; mean += s
-      }
-      mean /= (4096 - 30)
-      for (let i = 30; i < 4096; i++) { let d = resid[i] - mean; m2 += d * d; m4 += d * d * d * d }
-      m2 /= (4096 - 30); m4 /= (4096 - 30)
-      clickScore = m2 > 0 ? m4 / (m2 * m2) - 3 : 0     // excess kurtosis
-    } catch {}
+  let cw = 4096
+  if (data.length >= cw) {
+    let stride = Math.max(cw, Math.floor((data.length - cw) / 8) || cw)
+    for (let start = 0; start + cw <= data.length; start += stride) {
+      let seg = data.subarray(start, start + cw)
+      try {
+        let { a } = arFit(seg, 30)
+        let resid = new Float64Array(cw), mean = 0, m2 = 0, m4 = 0
+        for (let i = 30; i < cw; i++) {
+          let s = seg[i]
+          for (let k = 1; k <= 30; k++) s += a[k] * seg[i - k]
+          resid[i] = s; mean += s
+        }
+        mean /= (cw - 30)
+        for (let i = 30; i < cw; i++) { let d = resid[i] - mean; m2 += d * d; m4 += d * d * d * d }
+        m2 /= (cw - 30); m4 /= (cw - 30)
+        let ex = m2 > 0 ? m4 / (m2 * m2) - 3 : 0       // excess kurtosis
+        if (ex > clickScore) clickScore = ex
+      } catch {}
+    }
   }
 
-  // Stationarity: variance-of-variances of frame energy
-  let mean = 0; for (let v of frameVar) mean += v; mean /= frames
-  let varE = 0; for (let v of frameVar) varE += (v - mean) ** 2; varE /= frames
-  let cv = mean > 0 ? Math.sqrt(varE) / mean : 0       // higher = less stationary
+  // Noise stationarity: CV of the frame-energy FLOOR (rolling minimum over ~0.75 s).
+  // Speech dynamics ride above the floor, so the floor tracks the *noise bed*:
+  // stationary noise → stable floor (CV ≈ 0.06 measured on speech+white), babble /
+  // wandering beds → drifting floor (CV ≈ 0.5). Raw frame-energy CV can't make this
+  // call — speech's own variance trips it regardless of the noise.
+  let floorCV = 0
+  {
+    let D = 64, step = 16, floors = []
+    for (let i = D; i < frames; i += step) {
+      let mn = Infinity
+      for (let j = i - D; j < i; j++) if (frameVar[j] < mn) mn = frameVar[j]
+      floors.push(mn)
+    }
+    if (floors.length >= 3) {
+      let m = 0; for (let f of floors) m += f; m /= floors.length
+      let v = 0; for (let f of floors) v += (f - m) ** 2; v /= floors.length
+      floorCV = m > 0 ? Math.sqrt(v) / m : 0
+    }
+  }
 
   let scores = {
     hum: humBest, humFreq,
     click: clickScore,
     lf: lfRatio,
     hi: hiRatio,
-    nonstationarity: cv
+    stationarity: floorCV                              // low = stationary noise bed
   }
 
-  // Priority: tonal hum > impulses > sibilance > rumble > non-stationary > broadband.
+  // Priority: tonal hum > impulses > sibilance > rumble > stationary → wiener,
+  // non-stationary → omlsa (IMCRA keeps adapting where a frozen profile can't).
   // humBest is a hit count: ≥2 of the first 3 harmonics show 20× peak-to-median sharpness.
   let method = 'wiener'
   if (humBest >= 2) method = 'dehum'
   else if (clickScore > 12) method = 'declick'
   else if (hiRatio > 8) method = 'deesser'                // white noise scores ~3.9 by bandwidth alone
   else if (lfRatio > 3) method = 'dewind'
-  else if (cv > 0.6) method = 'omlsa'
+  else if (floorCV > 0.3) method = 'omlsa'         // white ~0.06 · rumble ~0.2 · babble ~0.5
 
   return { method, scores, humFreq }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audio/denoise-detect",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "denoise — content-aware auto-selector that classifies the dominant noise type",
   "type": "module",
   "sideEffects": false,