@audio/neural-denoise 0.1.0

package/deepfilter.js

@@ -0,0 +1,209 @@
+// DeepFilterNet3: H. Schröter, T. Rosenkranz, A. N. Escalante-B., A. Maier, "DeepFilterNet: Perceptually
+// Motivated Real-Time Speech Enhancement", Interspeech 2023 (arXiv:2305.08227). Two stages on a 10 ms
+// STFT at 48 kHz: gains on 32 ERB bands for the envelope, then a complex 5-tap filter over time on each
+// of the lowest 96 bins (up to 4.8 kHz) for the periodic structure. Upstream's three ONNX graphs
+// (encoder, ERB decoder, deep-filter decoder) run through @audio/neural-runtime.
+//
+// Copyright (c) 2021 Hendrik Schröter. MIT License (upstream is MIT OR Apache-2.0); the notice is in NOTICE.
+//
+// Changes, 2026, audiojs: translated to JavaScript from Rikorose/DeepFilterNet at d375b2d: libDF's STFT,
+// ERB filterbank and feature normalizations (libDF/src/lib.rs, transforms.rs) and df.enhance.enhance()
+// with DfNet.forward (DeepFilterNet/df/enhance.py, deepfilternet3.py, modules.py, multiframe.py): the
+// conv_lookahead shift, the ERB mask, the multi-frame deep filter, the attenuation limit. Model
+// parameters are read from the export's config.ini. The FFT is RNNoise's (fft.js) in float32.
+// Inputs longer than `chunk` frames run in chunks: upstream feeds the whole file, about 8 MB of
+// activations per second of audio. Each chunk's run starts `warmup` frames early from zero GRU state
+// (those outputs dropped) and continues `fade` frames past its end, where the next chunk crossfades in
+// (raised cosine). The GRUs keep a long memory of their start, so chunked output is another valid
+// trajectory, not the whole-file one; the STFT and the features stay exact across chunks.
+
+import { load, tensor, fetchModel } from '@audio/neural-runtime'
+import { WINDOW, rfft, irfft, N as FFT_N, HOP as FFT_HOP, BINS } from './fft.js'
+
+const f = Math.fround
+
+// models/DeepFilterNet3_onnx.tar.gz at d375b2d (7,983,136 bytes, sha256 c94d91f7…): enc, erb_dec, df_dec, config.ini
+export const MODEL = 'https://raw.githubusercontent.com/Rikorose/DeepFilterNet/d375b2d8309e0935d165700c91da9de862a99c31/models/DeepFilterNet3_onnx.tar.gz'
+
+// The attenuation limit, dB, that denoise() applies to this model unless given one (0: none, upstream's
+// output). Unlimited, it takes the pauses of ten home narrations as low as -152 dBFS, the digital silence
+// ACX Check flags; limited to 12 dB, they keep -91 to -57 dBFS at the same DNSMOS (README, Accuracy).
+export const LIMIT = 12
+
+const isNode = typeof process !== 'undefined' && !!process.versions?.node
+
+// ------------------------------------------------ model archive
+
+async function gunzip(bytes) {
+	if (isNode) return new Uint8Array((await import('node:zlib')).gunzipSync(bytes))
+	let stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip'))
+	return new Uint8Array(await new Response(stream).arrayBuffer())
+}
+
+// ustar: 512-byte headers, octal sizes, data padded to 512
+function untar(bytes) {
+	let files = {}, o = 0, str = (at, n) => new TextDecoder().decode(bytes.subarray(at, at + n)).replace(/\0.*$/s, '')
+	while (o + 512 <= bytes.length && bytes[o]) {
+		let name = str(o, 100), size = parseInt(str(o + 124, 12).trim() || '0', 8), prefix = str(o + 345, 155)
+		if (bytes[o + 156] === 48 || bytes[o + 156] === 0) files[(prefix ? prefix + '/' : '') + name] = bytes.subarray(o + 512, o + 512 + size)
+		o += 512 + Math.ceil(size / 512) * 512
+	}
+	return files
+}
+
+function ini(text) {
+	let out = {}, sec = out
+	for (let line of text.split(/\r?\n/)) {
+		let s = line.match(/^\s*\[(.+)\]\s*$/), kv = line.match(/^\s*([^=#;]+?)\s*=\s*(.*?)\s*$/)
+		if (s) sec = out[s[1]] = {}
+		else if (kv) sec[kv[1]] = kv[2]
+	}
+	return out
+}
+
+// load(model?) → { enc, erb, df, params }: the upstream export (tar.gz: enc.onnx, erb_dec.onnx, df_dec.onnx, config.ini)
+export async function loadDeepFilter(model = MODEL, opts = {}) {
+	let bytes = typeof model === 'string' ? await fetchModel(model, opts) : new Uint8Array(model)
+	if (bytes[0] === 0x1f && bytes[1] === 0x8b) bytes = await gunzip(bytes)
+	let files = untar(bytes), pick = n => Object.entries(files).find(([k]) => k.endsWith('/' + n) || k === n)?.[1]
+	let [enc, erb, df, cfg] = ['enc.onnx', 'erb_dec.onnx', 'df_dec.onnx', 'config.ini'].map(pick)
+	if (!enc || !erb || !df || !cfg) throw new Error('neural-denoise: a DeepFilterNet export needs enc.onnx, erb_dec.onnx, df_dec.onnx and config.ini')
+	let c = ini(new TextDecoder().decode(cfg)), d = c.df, m = c.deepfilternet
+	if (c.train?.model !== 'deepfilternet3') throw new Error(`neural-denoise: model type '${c.train?.model}' is not deepfilternet3`)
+	let params = {
+		sr: +d.sr, n: +d.fft_size, hop: +d.hop_size, nbErb: +d.nb_erb, nbDf: +d.nb_df, order: +(d.df_order ?? m.df_order),
+		dfLa: +(d.df_lookahead ?? m.df_lookahead), convLa: +m.conv_lookahead, tau: +d.norm_tau, minErb: +d.min_nb_erb_freqs,
+	}
+	if (params.n !== FFT_N || params.hop !== FFT_HOP || params.sr !== 48000) throw new Error('neural-denoise: only 48 kHz models with 960/480 framing are supported')
+	params.widths = erbWidths(params.sr, params.n, params.nbErb, params.minErb)
+	params.alpha = normAlpha(params.sr, params.hop, params.tau)
+	let ld = opts.session ?? (b => load(b, { backend: opts.device, sessionOptions: opts.sessionOptions }))
+	let e = await ld(enc), r = await ld(erb), g = await ld(df)
+	return { enc: e, erb: r, df: g, params, free() { e.free(); r.free(); g.free() } }
+}
+
+// ------------------------------------------------ libDF features
+
+const freq2erb = hz => f(f(9.265) * f(Math.log1p(f(hz / f(f(24.7) * f(9.265))))))
+const erb2freq = e => f(f(f(24.7) * f(9.265)) * f(f(Math.exp(f(e / f(9.265)))) - 1))
+
+// erb_fb: bins per band, equal ERB steps, at least `minNb` bins per band, all bins covered
+export function erbWidths(sr, n, bands, minNb) {
+	let width = f(sr / n), lo = freq2erb(0), hi = freq2erb(sr >> 1), step = f(f(hi - lo) / bands)
+	let erb = new Array(bands).fill(0), prev = 0, over = 0
+	for (let i = 1; i <= bands; i++) {
+		let fb = Math.round(f(erb2freq(f(lo + f(i * step))) / width)), nb = fb - prev - over
+		if (nb < minNb) { over = minNb - nb; nb = minNb } else over = 0
+		erb[i - 1] = nb; prev = fb
+	}
+	erb[bands - 1] += 1
+	let extra = erb.reduce((a, b) => a + b, 0) - (n / 2 + 1)
+	if (extra > 0) erb[bands - 1] -= extra
+	return erb
+}
+
+// df.utils.get_norm_alpha: exp(−hop/sr/τ), rounded to the fewest decimals (from 3) that keep it below 1
+function normAlpha(sr, hop, tau) {
+	let a = Math.exp(-hop / sr / tau), out = 1
+	for (let p = 3; out >= 1; p++) out = Math.round(a * 10 ** p) / 10 ** p
+	return f(out)
+}
+
+// ndarray's linspace, in f32 as libDF builds its initial normalization states
+const linspace = (a, b, n) => { let step = f(f(f(b) - f(a)) / (n - 1)); return Float32Array.from({ length: n }, (_, i) => f(f(a) + f(step * i))) }
+
+// ------------------------------------------------ enhance
+
+// enhance(x, net, opts) → Float32Array: one channel at 48 kHz, as df.enhance.enhance(model, state, x, pad=True)
+export async function enhance(x, net, { limit, chunk = 1000, warmup = 300, fade = 50 } = {}) {
+	let { hop, n, nbErb, nbDf, order, dfLa, convLa, widths, alpha } = net.params
+	let L = x.length, T = Math.floor((L + n) / hop), lead = order - 1 - dfLa, look = Math.max(convLa, dfLa)
+	let lim = limit != null && Math.abs(limit) > 0 ? 10 ** (-Math.abs(limit) / 20) : 0
+	// per-frame store, a ring big enough for one chunk with its context
+	chunk = Math.max(1, Math.min(chunk, T)); fade = Math.min(fade, chunk)
+	let cap = chunk + fade + warmup + look + lead + 2
+	let Sr = new Float32Array(cap * BINS), Si = new Float32Array(cap * BINS), FE = new Float32Array(cap * nbErb), FC = new Float32Array(cap * nbDf * 2)
+	let mean = linspace(-60, -90, nbErb), unit = linspace(0.001, 0.0001, nbDf), a1 = f(1 - alpha)
+	let mem = new Float32Array(hop), buf = new Float32Array(n), made = 0
+	let erbStart = new Int32Array(nbErb), erbK = new Float32Array(nbErb)
+	for (let b = 0, s = 0; b < nbErb; s += widths[b++]) { erbStart[b] = s; erbK[b] = f(1 / widths[b]) }
+
+	// frame_analysis + feat_erb + feat_cplx for frames up to t (sequential: the normalizations carry state)
+	function make(upto) {
+		for (; made <= upto && made < T; made++) {
+			let t = made, at = t * hop, slot = t % cap, o = slot * BINS
+			for (let i = 0; i < hop; i++) buf[i] = f(mem[i] * WINDOW[i])
+			for (let i = 0; i < hop; i++) { let v = at + i < L ? x[at + i] : 0; buf[hop + i] = f(v * WINDOW[hop + i]); mem[i] = v }
+			rfft(buf, Sr.subarray(o, o + BINS), Si.subarray(o, o + BINS))
+			for (let b = 0; b < nbErb; b++) {
+				let s = 0, k = erbK[b]
+				for (let j = erbStart[b], e = j + widths[b]; j < e; j++) s = f(s + f(f(f(Sr[o + j] * Sr[o + j]) + f(Si[o + j] * Si[o + j])) * k))
+				let v = f(f(Math.log10(f(s + f(1e-10)))) * 10)
+				mean[b] = f(f(v * a1) + f(mean[b] * alpha))
+				FE[slot * nbErb + b] = f(f(v - mean[b]) / 40)
+			}
+			for (let j = 0; j < nbDf; j++) {
+				let re = Sr[o + j], im = Si[o + j]
+				unit[j] = f(f(f(Math.hypot(re, im)) * a1) + f(unit[j] * alpha))
+				let d = f(Math.sqrt(unit[j]))
+				FC[slot * nbDf * 2 + j] = f(re / d); FC[slot * nbDf * 2 + nbDf + j] = f(im / d)
+			}
+		}
+	}
+
+	let out = new Float32Array(L), syn = new Float32Array(hop), y = new Float32Array(n), d = n - hop
+	let Er = new Float32Array(BINS), Ei = new Float32Array(BINS)
+	// a chunk's run continues `fade` frames past its end; the next chunk crossfades from those spectra
+	let tailR = new Float32Array(fade * BINS), tailI = new Float32Array(fade * BINS)
+	for (let a = 0, b; a < T; a = b) {
+		b = Math.min(T, a + chunk)
+		let e = Math.min(T, b + fade), a0 = Math.max(0, a - warmup), S = e - a0
+		make(Math.min(T - 1, e - 1 + look))
+		// network input: features shifted by conv_lookahead (DfNet.pad_feat), zeros past the end
+		let fe = new Float32Array(S * nbErb), fc = new Float32Array(2 * S * nbDf)
+		for (let s = 0; s < S; s++) {
+			let t = a0 + s + convLa
+			if (t >= T) continue
+			let slot = t % cap
+			fe.set(FE.subarray(slot * nbErb, slot * nbErb + nbErb), s * nbErb)
+			fc.set(FC.subarray(slot * nbDf * 2, slot * nbDf * 2 + nbDf), s * nbDf)
+			fc.set(FC.subarray(slot * nbDf * 2 + nbDf, slot * nbDf * 2 + 2 * nbDf), S * nbDf + s * nbDf)
+		}
+		let enc = await net.enc.run({ feat_erb: tensor(fe, [1, 1, S, nbErb]), feat_spec: tensor(fc, [1, 2, S, nbDf]) })
+		let M = (await net.erb.run({ emb: enc.emb, e3: enc.e3, e2: enc.e2, e1: enc.e1, e0: enc.e0 })).m.data
+		let C = (await net.df.run({ emb: enc.emb, c0: enc.c0 }, ['coefs'])).coefs.data
+		for (let t = a; t < e; t++) {
+			let s = t - a0, o = (t % cap) * BINS
+			// ERB gains (Mask with the unnormalized inverse filterbank: each bin takes its band's gain)
+			for (let band = 0; band < nbErb; band++) {
+				let g = M[s * nbErb + band]
+				for (let j = erbStart[band], end = j + widths[band]; j < end; j++) { Er[j] = f(Sr[o + j] * g); Ei[j] = f(Si[o + j] * g) }
+			}
+			// deep filter on the unmasked spectrum: Σₖ spec[t − lead + k] · coef[t, k], complex, below nbDf
+			for (let j = 0; j < nbDf; j++) { Er[j] = 0; Ei[j] = 0 }
+			for (let k = 0; k < order; k++) {
+				let tt = t - lead + k
+				if (tt < 0 || tt >= T) continue
+				let q = (tt % cap) * BINS, c = s * nbDf * order * 2
+				for (let j = 0; j < nbDf; j++) {
+					let cr = C[c + j * order * 2 + 2 * k], ci = C[c + j * order * 2 + 2 * k + 1], sr = Sr[q + j], si = Si[q + j]
+					Er[j] = f(Er[j] + f(f(sr * cr) - f(si * ci))); Ei[j] = f(Ei[j] + f(f(sr * ci) + f(si * cr)))
+				}
+			}
+			if (lim) for (let j = 0; j < BINS; j++) { Er[j] = f(f(Sr[o + j] * lim) + f(Er[j] * (1 - lim))); Ei[j] = f(f(Si[o + j] * lim) + f(Ei[j] * (1 - lim))) }
+			if (t >= b) { tailR.set(Er, (t - b) * BINS); tailI.set(Ei, (t - b) * BINS); continue }
+			if (a > 0 && t - a < fade) {
+				let w = .5 - .5 * Math.cos(Math.PI * (t - a + .5) / fade), q = (t - a) * BINS
+				for (let j = 0; j < BINS; j++) { Er[j] = f(tailR[q + j] + w * (Er[j] - tailR[q + j])); Ei[j] = f(tailI[q + j] + w * (Ei[j] - tailI[q + j])) }
+			}
+			// frame_synthesis: unnormalized inverse, window, overlap-add
+			irfft(Er, Ei, y)
+			for (let i = 0; i < hop; i++) {
+				let v = f(f(y[i] * WINDOW[i]) + syn[i]), p = t * hop + i - d
+				if (p >= 0 && p < L) out[p] = v
+				syn[i] = f(y[hop + i] * WINDOW[hop + i])
+			}
+		}
+	}
+	return out
+}

package/denoise.js

@@ -0,0 +1,74 @@
+// Neural speech enhancement: RNNoise (pure JS, weights bundled) and DeepFilterNet3 (ONNX through
+// @audio/neural-runtime, weights fetched from upstream and cached). Both run at 48 kHz on 10 ms hops;
+// other rates are resampled in and out with @audio/resample-sinc. Offline results are aligned with the
+// input: the models' delay is compensated.
+
+import resample from '@audio/resample-sinc'
+import { model as parseRNNoise, create, FRAME, LIMIT as RNNOISE_LIMIT } from './rnnoise.js'
+import { loadDeepFilter, enhance, MODEL, LIMIT as DFN_LIMIT } from './deepfilter.js'
+
+export { create as rnnoise, FRAME } from './rnnoise.js'
+export { MODEL } from './deepfilter.js'
+
+const RATE = 48000
+// the attenuation limit (dB) each model gets when opts.limit is not given; 0 is upstream's output
+const LIMITS = { rnnoise: RNNOISE_LIMIT, deepfilternet3: DFN_LIMIT }
+
+// weights() → the bundled RNNoise weights (upstream's weight blob, 3,544,320 bytes), for the worklet
+export async function weights() {
+	let url = new URL('./rnnoise.bin', import.meta.url)
+	if (url.protocol === 'file:') return new Uint8Array((await import('node:fs')).readFileSync(url))
+	let res = await fetch(url)
+	if (!res.ok) throw new Error(`neural-denoise: can't fetch ${url}: ${res.status}`)
+	return new Uint8Array(await res.arrayBuffer())
+}
+
+let bundled
+// load(model?, opts?) → a handle denoise() reuses: 'rnnoise' (default) or 'deepfilternet3'
+export async function load(model = 'rnnoise', opts = {}) {
+	if (model === 'rnnoise') {
+		let net = opts.weights ? parseRNNoise(opts.weights) : await (bundled ??= weights().then(parseRNNoise))
+		return { model, net, latency: 2 * FRAME, free() {} }
+	}
+	if (model === 'deepfilternet3') {
+		// ORT's arena keeps the largest chunk's activations: off, a 180 s file peaks at 563 MB instead of 665
+		let net = await loadDeepFilter(opts.weights ?? MODEL, { ...opts, sessionOptions: { enableCpuMemArena: false, enableMemPattern: false, ...opts.sessionOptions } })
+		return { model, net, latency: (net.params.n - net.params.hop) + net.params.hop * Math.max(net.params.convLa, net.params.dfLa), free: () => net.free() }
+	}
+	throw new Error(`neural-denoise: unknown model '${model}' (want 'rnnoise' or 'deepfilternet3')`)
+}
+
+// denoise(audio, opts) → the same shape back: Float32Array, Float32Array[] or { channelData, sampleRate }
+export default async function denoise(audio, opts = {}) {
+	let channels, rate = opts.sampleRate
+	if (audio instanceof Float32Array) channels = [audio]
+	else if (Array.isArray(audio)) channels = audio
+	else if (audio?.channelData) { channels = audio.channelData; rate = audio.sampleRate ?? rate }
+	else throw new TypeError('neural-denoise: audio must be a Float32Array, Float32Array[] or { channelData, sampleRate }')
+	if (!(rate > 0)) throw new TypeError('neural-denoise: sampleRate is required (opts.sampleRate, or audio.sampleRate)')
+	let handle = typeof opts.model === 'object' && opts.model ? opts.model : await load(opts.model, opts)
+	try {
+		let out = [], limit = opts.limit ?? LIMITS[handle.model]
+		for (let ch of channels) {
+			let x = rate === RATE ? Float32Array.from(ch) : resample(Float32Array.from(ch), { from: rate, to: RATE })
+			let y = handle.model === 'rnnoise' ? rnnoiseOffline(x, handle.net, limit) : await enhance(x, handle.net, { ...opts, limit })
+			out.push(rate === RATE ? y : fit(resample(y, { from: RATE, to: rate }), ch.length))
+		}
+		return audio instanceof Float32Array ? out[0] : Array.isArray(audio) ? out : { ...audio, channelData: out, sampleRate: rate }
+	} finally {
+		if (handle !== opts.model) handle.free()
+	}
+}
+
+const fit = (y, n) => y.length === n ? y : (() => { let o = new Float32Array(n); o.set(y.subarray(0, n)); return o })()
+
+// One channel through RNNoise at int16 scale, delay removed: out[i] lines up with x[i]
+function rnnoiseOffline(x, net, limit) {
+	let st = create(net), delay = 2 * FRAME, L = x.length, n = Math.ceil((L + delay) / FRAME) * FRAME
+	let pad = new Float32Array(n), y = new Float32Array(n)
+	for (let i = 0; i < L; i++) pad[i] = x[i] * 32768
+	for (let i = 0; i < n; i += FRAME) st.process(pad.subarray(i, i + FRAME), y.subarray(i, i + FRAME))
+	let lim = limit ? 10 ** (-Math.abs(limit) / 20) : 0, out = new Float32Array(L)
+	for (let i = 0; i < L; i++) out[i] = (y[i + delay] / 32768) * (1 - lim) + x[i] * lim
+	return out
+}

package/fft.js

@@ -0,0 +1,135 @@
+// The 960-point FFT and 20 ms Vorbis window both models frame speech with (10 ms hop at 48 kHz).
+//
+// Copyright (c) 2003-2004 Mark Borgerding; 2005-2009 Xiph.Org Foundation; 2008 CSIRO; 2017-2018 Mozilla;
+// 2023 Amazon. BSD-3-Clause: the conditions and the disclaimer are in LICENSE.
+//
+// Changes, 2026, audiojs: translated to JavaScript from xiph/rnnoise at 70f1d25 (src/kiss_fft.c,
+// _kiss_fft_guts.h, dump_rnnoise_tables.c): the float build of kiss_fft fixed at 960 points, radices
+// 5·3·4·4·4 as kf_factor orders them, twiddles and bit reversal generated as the tables generator does
+// (equal to rnnoise_tables.c), every float op rounded as float32.
+
+const f = Math.fround
+
+export const N = 960, HOP = 480, BINS = 481
+
+// sin(π/2 · sin²(π(i + ½)/960)): Vorbis power-complementary window (rnn_half_window, libDF DFState::new)
+export const WINDOW = new Float32Array(N)
+for (let i = 0; i < HOP; i++) {
+	let s = Math.sin(.5 * Math.PI * (i + .5) / HOP)
+	WINDOW[i] = WINDOW[N - 1 - i] = Math.sin(.5 * Math.PI * s * s)
+}
+
+const FACTORS = [5, 192, 3, 64, 4, 16, 4, 4, 4, 1]
+const SCALE = f(0.0010416667) // kiss_fft_state.scale as rnnoise_tables.c prints it: 1/960 in float32
+const TW_R = new Float32Array(N), TW_I = new Float32Array(N)
+for (let i = 0; i < N; i++) {
+	let phase = (-2 * 3.14159265358979323846264338327 / N) * i
+	TW_R[i] = Math.cos(phase); TW_I[i] = Math.sin(phase)
+}
+const BITREV = new Int32Array(N)
+;(function bitrev(fout, at, fstride, k) {
+	let p = FACTORS[k], m = FACTORS[k + 1]
+	if (m === 1) for (let j = 0; j < p; j++, at += fstride) BITREV[at] = fout + j
+	else for (let j = 0; j < p; j++, at += fstride, fout += m) bitrev(fout, at, fstride * p, k + 2)
+})(0, 0, 1, 0)
+
+// rnn_fft_c: out = FFT(in)/960, complex values as separate re/im arrays of 960
+export function fft(ir, ii, or, oi) {
+	for (let i = 0; i < N; i++) { or[BITREV[i]] = f(SCALE * ir[i]); oi[BITREV[i]] = f(SCALE * ii[i]) }
+	bfly4d(or, oi, 240)
+	bfly4(or, oi, 60, 4, 60, 16)
+	bfly4(or, oi, 15, 16, 15, 64)
+	bfly3(or, oi, 5, 64, 5, 192)
+	bfly5(or, oi, 1, 192)
+}
+
+const ZERO = new Float32Array(N), FR = new Float32Array(N), FI = new Float32Array(N), IR = new Float32Array(N), II = new Float32Array(N)
+
+// forward_transform: 481 bins of a real 960-sample frame, scaled by 1/960 (libDF's wnorm is the same 1/960)
+export function rfft(x, Xr, Xi) {
+	fft(x, ZERO, FR, FI)
+	for (let i = 0; i < BINS; i++) { Xr[i] = FR[i]; Xi[i] = FI[i] }
+}
+
+// inverse_transform: unnormalized inverse of 481 bins (Hermitian extension; imaginary parts of the
+// DC and Nyquist bins ignored, as realfft's ComplexToReal does)
+export function irfft(Xr, Xi, x) {
+	for (let i = 0; i < BINS; i++) { IR[i] = Xr[i]; II[i] = Xi[i] }
+	for (let i = BINS; i < N; i++) { IR[i] = IR[N - i]; II[i] = -II[N - i] }
+	fft(IR, II, FR, FI)
+	x[0] = f(N * FR[0])
+	for (let i = 1; i < N; i++) x[i] = f(N * FR[N - i])
+}
+
+function bfly4d(r, im, n) {
+	for (let i = 0, o = 0; i < n; i++, o += 4) {
+		let s0r = f(r[o] - r[o + 2]), s0i = f(im[o] - im[o + 2])
+		r[o] = f(r[o] + r[o + 2]); im[o] = f(im[o] + im[o + 2])
+		let s1r = f(r[o + 1] + r[o + 3]), s1i = f(im[o + 1] + im[o + 3])
+		r[o + 2] = f(r[o] - s1r); im[o + 2] = f(im[o] - s1i)
+		r[o] = f(r[o] + s1r); im[o] = f(im[o] + s1i)
+		s1r = f(r[o + 1] - r[o + 3]); s1i = f(im[o + 1] - im[o + 3])
+		r[o + 1] = f(s0r + s1i); im[o + 1] = f(s0i - s1r)
+		r[o + 3] = f(s0r - s1i); im[o + 3] = f(s0i + s1r)
+	}
+}
+
+function bfly4(r, im, fstride, m, n, mm) {
+	let m2 = 2 * m, m3 = 3 * m
+	for (let i = 0; i < n; i++) {
+		for (let j = 0, o = i * mm; j < m; j++, o++) {
+			let t1 = j * fstride, t2 = 2 * t1, t3 = 3 * t1, a = o + m, b = o + m2, c = o + m3
+			let s0r = f(f(r[a] * TW_R[t1]) - f(im[a] * TW_I[t1])), s0i = f(f(r[a] * TW_I[t1]) + f(im[a] * TW_R[t1]))
+			let s1r = f(f(r[b] * TW_R[t2]) - f(im[b] * TW_I[t2])), s1i = f(f(r[b] * TW_I[t2]) + f(im[b] * TW_R[t2]))
+			let s2r = f(f(r[c] * TW_R[t3]) - f(im[c] * TW_I[t3])), s2i = f(f(r[c] * TW_I[t3]) + f(im[c] * TW_R[t3]))
+			let s5r = f(r[o] - s1r), s5i = f(im[o] - s1i)
+			r[o] = f(r[o] + s1r); im[o] = f(im[o] + s1i)
+			let s3r = f(s0r + s2r), s3i = f(s0i + s2i), s4r = f(s0r - s2r), s4i = f(s0i - s2i)
+			r[b] = f(r[o] - s3r); im[b] = f(im[o] - s3i)
+			r[o] = f(r[o] + s3r); im[o] = f(im[o] + s3i)
+			r[a] = f(s5r + s4i); im[a] = f(s5i - s4r)
+			r[c] = f(s5r - s4i); im[c] = f(s5i + s4r)
+		}
+	}
+}
+
+function bfly3(r, im, fstride, m, n, mm) {
+	let m2 = 2 * m, epi = TW_I[fstride * m]
+	for (let i = 0; i < n; i++) {
+		for (let k = 0, o = i * mm; k < m; k++, o++) {
+			let t1 = k * fstride, t2 = 2 * t1, a = o + m, b = o + m2
+			let s1r = f(f(r[a] * TW_R[t1]) - f(im[a] * TW_I[t1])), s1i = f(f(r[a] * TW_I[t1]) + f(im[a] * TW_R[t1]))
+			let s2r = f(f(r[b] * TW_R[t2]) - f(im[b] * TW_I[t2])), s2i = f(f(r[b] * TW_I[t2]) + f(im[b] * TW_R[t2]))
+			let s3r = f(s1r + s2r), s3i = f(s1i + s2i), s0r = f(s1r - s2r), s0i = f(s1i - s2i)
+			r[a] = f(r[o] - f(s3r * .5)); im[a] = f(im[o] - f(s3i * .5))
+			s0r = f(s0r * epi); s0i = f(s0i * epi)
+			r[o] = f(r[o] + s3r); im[o] = f(im[o] + s3i)
+			r[b] = f(r[a] + s0i); im[b] = f(im[a] - s0r)
+			r[a] = f(r[a] - s0i); im[a] = f(im[a] + s0r)
+		}
+	}
+}
+
+function bfly5(r, im, fstride, m) {
+	let yar = TW_R[fstride * m], yai = TW_I[fstride * m], ybr = TW_R[2 * fstride * m], ybi = TW_I[2 * fstride * m]
+	for (let u = 0; u < m; u++) {
+		let o0 = u, o1 = u + m, o2 = u + 2 * m, o3 = u + 3 * m, o4 = u + 4 * m
+		let t1 = u * fstride, t2 = 2 * t1, t3 = 3 * t1, t4 = 4 * t1
+		let s0r = r[o0], s0i = im[o0]
+		let s1r = f(f(r[o1] * TW_R[t1]) - f(im[o1] * TW_I[t1])), s1i = f(f(r[o1] * TW_I[t1]) + f(im[o1] * TW_R[t1]))
+		let s2r = f(f(r[o2] * TW_R[t2]) - f(im[o2] * TW_I[t2])), s2i = f(f(r[o2] * TW_I[t2]) + f(im[o2] * TW_R[t2]))
+		let s3r = f(f(r[o3] * TW_R[t3]) - f(im[o3] * TW_I[t3])), s3i = f(f(r[o3] * TW_I[t3]) + f(im[o3] * TW_R[t3]))
+		let s4r = f(f(r[o4] * TW_R[t4]) - f(im[o4] * TW_I[t4])), s4i = f(f(r[o4] * TW_I[t4]) + f(im[o4] * TW_R[t4]))
+		let s7r = f(s1r + s4r), s7i = f(s1i + s4i), s10r = f(s1r - s4r), s10i = f(s1i - s4i)
+		let s8r = f(s2r + s3r), s8i = f(s2i + s3i), s9r = f(s2r - s3r), s9i = f(s2i - s3i)
+		r[o0] = f(r[o0] + f(s7r + s8r)); im[o0] = f(im[o0] + f(s7i + s8i))
+		let s5r = f(s0r + f(f(s7r * yar) + f(s8r * ybr))), s5i = f(s0i + f(f(s7i * yar) + f(s8i * ybr)))
+		let s6r = f(f(s10i * yai) + f(s9i * ybi)), s6i = -f(f(s10r * yai) + f(s9r * ybi))
+		r[o1] = f(s5r - s6r); im[o1] = f(s5i - s6i)
+		r[o4] = f(s5r + s6r); im[o4] = f(s5i + s6i)
+		let s11r = f(s0r + f(f(s7r * ybr) + f(s8r * yar))), s11i = f(s0i + f(f(s7i * ybr) + f(s8i * yar)))
+		let s12r = f(f(s9i * yai) - f(s10i * ybi)), s12i = f(f(s10r * ybi) - f(s9r * yai))
+		r[o2] = f(s11r + s12r); im[o2] = f(s11i + s12i)
+		r[o3] = f(s11r - s12r); im[o3] = f(s11i - s12i)
+	}
+}

package/gemv.wat

@@ -0,0 +1,38 @@
+;; RNNoise's int8 matrix-vector products (sparse_cgemv8x4 in xiph/rnnoise vec.h, without the scale) in
+;; WebAssembly SIMD, embedded in rnnoise.js as bytes. Rebuild: wat2wasm gemv.wat -o gemv.wasm (WABT).
+(module
+  (memory (export "memory") 1)
+  ;; gemv(w, idx, x, out, rows): int32 out[r] = Σ w[r, c] · x[c] over upstream's 8×4-blocked int8 layout
+  ;; (sparse_cgemv8x4 without the scale): per 8-row block, idx holds a count, then the column of each 4-wide block.
+  (func (export "gemv") (param $w i32) (param $idx i32) (param $x i32) (param $out i32) (param $rows i32)
+    (local $i i32) (local $n i32) (local $x16 v128) (local $wv v128)
+    (local $a v128) (local $b v128) (local $c v128) (local $d v128)
+    (loop $block
+      (local.set $n (i32.load (local.get $idx)))
+      (local.set $idx (i32.add (local.get $idx) (i32.const 4)))
+      (local.set $a (v128.const i32x4 0 0 0 0)) (local.set $b (v128.const i32x4 0 0 0 0))
+      (local.set $c (v128.const i32x4 0 0 0 0)) (local.set $d (v128.const i32x4 0 0 0 0))
+      (block $done
+        (loop $cols
+          (br_if $done (i32.eqz (local.get $n)))
+          (local.set $x16 (i16x8.extend_low_i8x16_s (i32x4.splat (i32.load (i32.add (local.get $x) (i32.load (local.get $idx)))))))
+          (local.set $wv (v128.load (local.get $w)))
+          (local.set $a (i32x4.add (local.get $a) (i32x4.dot_i16x8_s (i16x8.extend_low_i8x16_s (local.get $wv)) (local.get $x16))))
+          (local.set $b (i32x4.add (local.get $b) (i32x4.dot_i16x8_s (i16x8.extend_high_i8x16_s (local.get $wv)) (local.get $x16))))
+          (local.set $wv (v128.load offset=16 (local.get $w)))
+          (local.set $c (i32x4.add (local.get $c) (i32x4.dot_i16x8_s (i16x8.extend_low_i8x16_s (local.get $wv)) (local.get $x16))))
+          (local.set $d (i32x4.add (local.get $d) (i32x4.dot_i16x8_s (i16x8.extend_high_i8x16_s (local.get $wv)) (local.get $x16))))
+          (local.set $w (i32.add (local.get $w) (i32.const 32)))
+          (local.set $idx (i32.add (local.get $idx) (i32.const 4)))
+          (local.set $n (i32.sub (local.get $n) (i32.const 1)))
+          (br $cols)))
+      ;; lanes hold half-rows: row = lane pair sum
+      (v128.store (local.get $out) (i32x4.add
+        (i8x16.shuffle 0 1 2 3 8 9 10 11 16 17 18 19 24 25 26 27 (local.get $a) (local.get $b))
+        (i8x16.shuffle 4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31 (local.get $a) (local.get $b))))
+      (v128.store offset=16 (local.get $out) (i32x4.add
+        (i8x16.shuffle 0 1 2 3 8 9 10 11 16 17 18 19 24 25 26 27 (local.get $c) (local.get $d))
+        (i8x16.shuffle 4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31 (local.get $c) (local.get $d))))
+      (local.set $out (i32.add (local.get $out) (i32.const 32)))
+      (local.set $i (i32.add (local.get $i) (i32.const 8)))
+      (br_if $block (i32.lt_u (local.get $i) (local.get $rows))))))

package/index.d.ts

@@ -0,0 +1,57 @@
+/** Neural speech enhancement: RNNoise (pure JS, weights bundled) and DeepFilterNet3 (ONNX, fetched and cached). */
+
+export type Audio = Float32Array | Float32Array[] | { channelData: Float32Array[], sampleRate: number }
+
+export interface Model {
+  model: 'rnnoise' | 'deepfilternet3'
+  /** algorithmic delay in samples at 48 kHz: 960 (RNNoise), 1440 (DeepFilterNet3); offline results are aligned */
+  latency: number
+  /** releases the ONNX sessions (DeepFilterNet3); no-op for RNNoise */
+  free(): void
+}
+
+export interface LoadOptions {
+  /** RNNoise: bytes of an upstream weight blob (dump_weights_blob), default the bundled model. DeepFilterNet3: URL or bytes of an upstream ONNX export (.tar.gz), default MODEL */
+  weights?: string | Uint8Array | ArrayBuffer
+  /** DeepFilterNet3: @audio/neural-runtime backend, 'node' | 'wasm' | 'webgpu'; default 'auto' */
+  device?: 'auto' | 'node' | 'wasm' | 'webgpu'
+  /** DeepFilterNet3: ort.InferenceSession options passed through, e.g. { intraOpNumThreads: 4 } */
+  sessionOptions?: Record<string, unknown>
+  /** DeepFilterNet3: replaces @audio/neural-runtime's load() for each graph (a custom ORT setup, a test double) */
+  session?: (bytes: Uint8Array) => Promise<unknown>
+  /** fetch progress, as @audio/neural-runtime reports it */
+  progress?: (p: { loaded: number, total: number | null }) => void
+}
+
+export interface DenoiseOptions extends LoadOptions {
+  /** Hz; required unless audio is { channelData, sampleRate } */
+  sampleRate?: number
+  /** 'rnnoise' (default), 'deepfilternet3', or a handle from load() to reuse across calls */
+  model?: 'rnnoise' | 'deepfilternet3' | Model
+  /** attenuation limit in dB: mixes the input back in at 10^(−limit/20); default 20 for RNNoise, 12 for DeepFilterNet3 (README, API); 0 for none, upstream's output */
+  limit?: number
+  /** DeepFilterNet3: frames (10 ms) per model run, default 1000 */
+  chunk?: number
+  /** DeepFilterNet3: frames of context run before each chunk after the first, default 300 */
+  warmup?: number
+  /** DeepFilterNet3: frames over which consecutive chunks crossfade, default 50 */
+  fade?: number
+}
+
+/** Denoise speech; returns the same shape as `audio`, same length, aligned with it. */
+export default function denoise<T extends Audio>(audio: T, opts?: DenoiseOptions): Promise<T>
+
+/** Load a model once to reuse it across denoise() calls. */
+export function load(model?: 'rnnoise' | 'deepfilternet3', opts?: LoadOptions): Promise<Model>
+
+/** The bundled RNNoise weights (3,544,320 bytes), e.g. for the worklet's processorOptions.weights. */
+export function weights(): Promise<Uint8Array>
+
+/** RNNoise frame by frame, as rnnoise_process_frame: 480 samples at 48 kHz and int16 scale in and out; returns the frame's voice probability. Output lags input by 960 samples. */
+export function rnnoise(weights: Uint8Array | ArrayBuffer | object): { process(input: Float32Array, output: Float32Array): number, latency: number }
+
+/** RNNoise frame length: 480 samples, 10 ms at 48 kHz. */
+export const FRAME: 480
+
+/** Upstream's DeepFilterNet3 ONNX export at Rikorose/DeepFilterNet d375b2d, fetched on first use and cached. */
+export const MODEL: string

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@audio/neural-denoise",
+  "version": "0.1.0",
+  "description": "Neural speech enhancement: RNNoise (Valin 2018) in pure JS, bit-exact to its C, weights bundled; DeepFilterNet3 through ONNX Runtime, matching the Python original",
+  "type": "module",
+  "sideEffects": false,
+  "main": "denoise.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./denoise.js"
+    },
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./worklet": "./worklet.js",
+    "./rnnoise.bin": "./rnnoise.bin",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "denoise.js",
+    "audio.js",
+    "rnnoise.js",
+    "deepfilter.js",
+    "fft.js",
+    "worklet.js",
+    "rnnoise.bin",
+    "gemv.wat",
+    "index.d.ts",
+    "LICENSE",
+    "NOTICE",
+    "audio.d.ts"
+  ],
+  "dependencies": {
+    "@audio/neural-runtime": "^0.1.0",
+    "@audio/resample-sinc": "^1.2.0"
+  },
+  "devDependencies": {
+    "audio-lena": "^3.0.1",
+    "onnxruntime-node": "^1.29.0",
+    "tst": "^9.4.0"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "audio",
+    "ml",
+    "neural",
+    "denoise",
+    "noise-suppression",
+    "speech-enhancement",
+    "rnnoise",
+    "deepfilternet",
+    "audioworklet",
+    "onnx"
+  ],
+  "license": "BSD-3-Clause AND MIT",
+  "author": "Dmitry Iv. <dfcreative@gmail.com>",
+  "contributors": [
+    "Jean-Marc Valin, Xiph.Org Foundation, Mozilla, Amazon and the RNNoise authors (RNNoise)",
+    "Hendrik Schröter (DeepFilterNet)"
+  ],
+  "audio": "./audio.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/neural.git",
+    "directory": "packages/neural-denoise"
+  },
+  "funding": "https://github.com/sponsors/audiojs",
+  "publishConfig": {
+    "access": "public"
+  }
+}