How we measured our noise-removal numbers.

#!/usr/bin/env python3
"""Standalone DeepFilterNet3 streaming inference, mirroring
AristoTrack's deepfilter3_filter.cpp (480-sample hops @48kHz, carried state)."""
import sys, time, wave
import numpy as np
import onnxruntime as ort

HOP = 480
STATE_SIZE = 45304

def read_wav_48k_mono(path):
    with wave.open(path, 'rb') as w:
        assert w.getframerate() == 48000, f"{path}: expected 48kHz, got {w.getframerate()}"
        assert w.getnchannels() == 1, f"{path}: expected mono"
        assert w.getsampwidth() == 2
        data = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16)
    return data.astype(np.float32) / 32768.0

def write_wav_48k_mono(path, x):
    x = np.clip(x, -1.0, 1.0)
    with wave.open(path, 'wb') as w:
        w.setnchannels(1); w.setsampwidth(2); w.setframerate(48000)
        w.writeframes((x * 32767.0).astype(np.int16).tobytes())

def denoise(x, model_path, atten_lim_db=100.0):
    # One thread, so the reported speed matches the published
    # "single CPU thread" figure rather than onnxruntime's default pool.
    opts = ort.SessionOptions()
    opts.intra_op_num_threads = 1
    opts.inter_op_num_threads = 1
    sess = ort.InferenceSession(model_path, sess_options=opts, providers=['CPUExecutionProvider'])
    states = np.zeros(STATE_SIZE, dtype=np.float32)
    atten = np.array(atten_lim_db, dtype=np.float32)
    n = len(x)
    pad = (-n) % HOP
    xp = np.concatenate([x, np.zeros(pad, dtype=np.float32)])
    out = np.zeros_like(xp)
    t0 = time.time()
    for i in range(0, len(xp), HOP):
        frame = xp[i:i+HOP]
        enhanced, states, _lsnr = sess.run(
            ["enhanced_audio_frame", "new_states", "lsnr"],
            {"input_frame": frame, "states": states, "atten_lim_db": atten})
        out[i:i+len(enhanced)] = enhanced[:HOP]
    rtf = (time.time() - t0) / (len(xp) / 48000.0)
    return out[:n], rtf

if __name__ == "__main__":
    model, inp, outp = sys.argv[1], sys.argv[2], sys.argv[3]
    x = read_wav_48k_mono(inp)
    y, rtf = denoise(x, model)
    write_wav_48k_mono(outp, y)
    print(f"{inp} -> {outp}  RTF={rtf:.3f} ({1/rtf:.1f}x realtime)")

#!/usr/bin/env python3
"""SI-SDR scoring vs clean reference, with cross-correlation alignment
(DF3 streaming output is delayed by its internal lookahead)."""
import sys, wave
import numpy as np

def read_wav(path):
    with wave.open(path, 'rb') as w:
        data = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16)
    return data.astype(np.float64) / 32768.0

def align(ref, est, max_shift=4800):
    n = min(len(ref), len(est))
    r, e = ref[:n], est[:n]
    corr = np.correlate(e, r[:n - max_shift], mode='valid')[:max_shift]
    shift = int(np.argmax(np.abs(corr)))
    e2 = est[shift:shift + len(ref)]
    n2 = min(len(ref), len(e2))
    return ref[:n2], e2[:n2], shift

def si_sdr(ref, est):
    ref = ref - ref.mean(); est = est - est.mean()
    alpha = np.dot(est, ref) / (np.dot(ref, ref) + 1e-12)
    target = alpha * ref
    noise = est - target
    return 10 * np.log10((np.dot(target, target) + 1e-12) / (np.dot(noise, noise) + 1e-12))

if __name__ == "__main__":
    clean, noisy, enhanced = sys.argv[1], sys.argv[2], sys.argv[3]
    c, n_, e = read_wav(clean), read_wav(noisy), read_wav(enhanced)
    cn, nn, _ = align(c, n_)
    before = si_sdr(cn, nn)
    ce, ee, shift = align(c, e)
    after = si_sdr(ce, ee)
    print(f"{enhanced}: SI-SDR {before:+.1f} dB -> {after:+.1f} dB  (gain {after-before:+.1f} dB, align {shift})")