| """VeriSpoof-Bench audio realization (standalone; numpy, scipy, soundfile, librosa; torch + transformers only for |
| EnCodec; ffmpeg 7.0.2 for the classical codecs). |
| |
| Mirrors, operation for operation, the evaluation-time realization of the VeriSpoof research code |
| (`spoofllm/data/audio_bank.py`, `spoofllm/data/augment.py`, `spoofllm/data/processing.py`), so a derived item |
| (augmented `_aug*` / recorded-condition `_cond` / post-processed `+proc`) can be regenerated from the user's own copy of |
| the source corpus, MUSAN and the OpenSLR-28 RIRs: |
| |
| 1. read the source recording as mono float32 at 16 kHz (libsndfile; ffmpeg for files libsndfile rejects; soxr_hq |
| resampling when the file is not 16 kHz) |
| 2. post-processing only: silence trimming on the whole recording (`proc.silence == "trimmed"`) |
| 3. the model's window: the first `window` samples (128,000 = 8.0 s); shorter recordings are tiled |
| 4. augmentation (derived rows only), in the order reverb -> noise -> codec, with |
| rng = numpy.random.default_rng(zlib.crc32(seed_key)) where seed_key is the row's utt_id; the random draws pick the |
| RIR inside the RT60 bin, the SNR inside the level range, the noise type and MUSAN file(s) and offsets, and the |
| codec setting inside the codec kind; then peak normalisation to 0.99 if needed |
| 5. post-processing only: band filter, gain / clipping, then silence padding (low-level noise padding draws from the |
| same rng) |
| |
| Every draw is also returned in a trace (file names, SNR, offsets, codec setting, ...), which the benchmark files store |
| as `realization`; `realize(..., check=<stored realization>)` asserts that the replay reproduces it. |
| """ |
| import os |
| import subprocess |
| import zlib |
|
|
| import numpy as np |
| import soundfile as sf |
| from scipy.signal import butter, fftconvolve, sosfilt |
|
|
| SR = 16000 |
| WINDOW = 128000 |
| FFMPEG = os.environ.get("VSBENCH_FFMPEG", os.environ.get("SPOOFLLM_FFMPEG", "ffmpeg")) |
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| LISTS = os.path.join(HERE, "..", "aug_sources") |
|
|
| NOISE_LEVELS = {"clean": None, "mild": (20, 30), "moderate": (10, 20), "severe": (5, 10), "extreme": (0, 5)} |
| REVERB_LEVELS = {"minimal": None, "slight": (0.0, 0.3), "moderate": (0.3, 0.6), "heavy": (0.6, 1.0), |
| "extreme": (1.0, 9.9)} |
| _CODECS = { |
| "mp3": [("mp3_32k", ["-c:a", "libmp3lame", "-b:a", "32k"], 16000, "mp3"), |
| ("mp3_64k", ["-c:a", "libmp3lame", "-b:a", "64k"], 16000, "mp3"), |
| ("mp3_128k", ["-c:a", "libmp3lame", "-b:a", "128k"], 16000, "mp3")], |
| "aac": [("aac_32k", ["-c:a", "aac", "-b:a", "32k"], 16000, "adts"), |
| ("aac_64k", ["-c:a", "aac", "-b:a", "64k"], 16000, "adts")], |
| "opus": [("opus_12k", ["-c:a", "libopus", "-b:a", "12k"], 16000, "ogg"), |
| ("opus_24k", ["-c:a", "libopus", "-b:a", "24k"], 16000, "ogg")], |
| "narrowband": [("amrnb_12k2", ["-c:a", "libopencore_amrnb", "-b:a", "12.2k"], 8000, "amr"), |
| ("g711_ulaw", ["-c:a", "pcm_mulaw"], 8000, "wav"), |
| ("speex_nb", ["-c:a", "libspeex"], 8000, "ogg")], |
| "neural": [("encodec_1.5k", 1.5, 24000, None), ("encodec_3k", 3.0, 24000, None), ("encodec_6k", 6.0, 24000, None)], |
| } |
| |
| CODECS = {**_CODECS, |
| "narrowband": _CODECS["narrowband"] + [("opus_nb_8k", ["-c:a", "libopus", "-b:a", "8k"], 8000, "ogg")], |
| "wideband": [("amrwb_6k6", ["-c:a", "libvo_amrwbenc", "-b:a", "6.6k"], 16000, "amr"), |
| ("amrwb_12k65", ["-c:a", "libvo_amrwbenc", "-b:a", "12.65k"], 16000, "amr"), |
| ("amrwb_23k85", ["-c:a", "libvo_amrwbenc", "-b:a", "23.85k"], 16000, "amr"), |
| ("speex_wb_q3", ["-c:a", "libspeex", "-cbr_quality", "3"], 16000, "ogg"), |
| ("speex_wb_q8", ["-c:a", "libspeex", "-cbr_quality", "8"], 16000, "ogg"), |
| ("g722", ["-c:a", "g722"], 16000, "wav")], |
| "neural": _CODECS["neural"] + [("encodec_12k", 12.0, 24000, None), ("encodec_24k", 24.0, 24000, None)]} |
| CODECS["cascade"] = [(f"{m[0]}+{e[0]}", (m, e), None, None) for m in _CODECS["mp3"] for e in CODECS["neural"]] |
| DEMUX = {"adts": "aac"} |
|
|
|
|
| |
| def _ffmpeg_read(path, sr=SR): |
| out = subprocess.run([FFMPEG, "-v", "error", "-i", path, "-f", "f32le", "-ac", "1", "-ar", str(sr), "pipe:1"], |
| capture_output=True, check=True).stdout |
| return np.frombuffer(out, np.float32).copy() |
|
|
|
|
| def read_audio(path, sr=SR): |
| """Mono float32 at 16 kHz, exactly as the evaluation read it: first channel through libsndfile (soxr_hq |
| resampling if needed); files libsndfile rejects (a share of the ASVspoof 2021 FLACs) are decoded by ffmpeg.""" |
| try: |
| x, s = sf.read(path, dtype="float32", always_2d=True) |
| except sf.LibsndfileError: |
| return _ffmpeg_read(path, sr) |
| x = x[:, 0] |
| if s != sr: |
| import librosa |
| x = librosa.resample(x, orig_sr=s, target_sr=sr, res_type="soxr_hq") |
| return x |
|
|
|
|
| def fit_window(x, S=WINDOW): |
| """First S samples; shorter recordings are tiled; an empty one is digital silence -> (window, tiled).""" |
| if len(x) >= S: |
| return x[:S], False |
| if not len(x): |
| return np.zeros(S, np.float32), True |
| return np.tile(x, S // max(len(x), 1) + 1)[:S], True |
|
|
|
|
| |
| class Sources: |
| """MUSAN noise / music / speech file lists and SLR28 RIRs binned by RT60, in the evaluation's order (shipped in |
| aug_sources/, paths relative to the MUSAN and RIRS_NOISES roots).""" |
|
|
| def __init__(self, musan_root, rirs_root, lists=LISTS): |
| self.musan_root, self.rirs_root = musan_root, rirs_root |
| self.musan = {t: [l.strip() for l in open(f"{lists}/musan_{t}.txt") if l.strip()] |
| for t in ("noise", "music", "speech")} |
| self.rirs = {lv: [] for lv in REVERB_LEVELS if REVERB_LEVELS[lv]} |
| for line in open(f"{lists}/rir_rt60.tsv"): |
| p, t = line.rstrip("\n").split("\t") |
| t = float(t) |
| for lv, rng in REVERB_LEVELS.items(): |
| if rng and rng[0] <= t < rng[1]: |
| self.rirs[lv].append((p, t)) |
|
|
| def musan_path(self, rel): |
| return os.path.join(self.musan_root, rel) if self.musan_root else None |
|
|
| def rir_path(self, rel): |
| return os.path.join(self.rirs_root, rel) if self.rirs_root else None |
|
|
|
|
| def _segment(path, n, rng, dry=False): |
| """A random n-sample segment of a MUSAN file -> (segment, offset in the 16 kHz file).""" |
| try: |
| info = sf.info(path) |
| except sf.LibsndfileError: |
| info = None |
| if info is not None and info.samplerate == SR and info.frames >= n: |
| o = int(rng.integers(0, info.frames - n + 1)) |
| if dry: |
| return None, o |
| x, _ = sf.read(path, frames=n, start=o, dtype="float32", always_2d=True) |
| if len(x) == n: |
| return x[:, 0], o |
| return read_audio(path)[o:o + n], o |
| x = read_audio(path) |
| if len(x) < n: |
| x = np.tile(x, int(np.ceil(n / max(len(x), 1)))) |
| o = int(rng.integers(0, len(x) - n + 1)) |
| return x[o:o + n], o |
|
|
|
|
| def add_reverb(x, rir): |
| rir = rir / (np.abs(rir).max() + 1e-9) |
| d = int(np.argmax(np.abs(rir))) |
| y = fftconvolve(x, rir[d:])[:len(x)] |
| return y * (np.sqrt(np.mean(x ** 2)) / (np.sqrt(np.mean(y ** 2)) + 1e-9)) |
|
|
|
|
| def add_noise(x, noise, snr_db): |
| px, pn = np.mean(x ** 2) + 1e-12, np.mean(noise ** 2) + 1e-12 |
| return x + noise * np.sqrt(px / (pn * 10 ** (snr_db / 10))) |
|
|
|
|
| def _fit(y, n): |
| return y[:n] if len(y) >= n else np.pad(y, (0, n - len(y))) |
|
|
|
|
| def align(x, y, max_lag=4000): |
| n = len(x) + len(y) |
| c = np.fft.irfft(np.fft.rfft(y, n) * np.conj(np.fft.rfft(x, n)), n) |
| lags = np.concatenate([np.arange(0, max_lag + 1), np.arange(-max_lag, 0)]) |
| lag = int(lags[np.argmax(c[lags])]) |
| y = y[lag:] if lag >= 0 else np.pad(y, (-lag, 0)) |
| return _fit(y, len(x)) |
|
|
|
|
| def ffmpeg_codec(x, args, inter_sr, fmt): |
| pcm = (np.clip(x, -1, 1) * 32767).astype("<i2").tobytes() |
| enc = subprocess.run([FFMPEG, "-v", "error", "-f", "s16le", "-ar", str(SR), "-ac", "1", "-i", "pipe:0", |
| "-ar", str(inter_sr), *args, "-f", fmt, "pipe:1"], input=pcm, capture_output=True, check=True) |
| dec_args = ["-c:a", "libspeex"] if "libspeex" in args else [] |
| dec = subprocess.run([FFMPEG, "-v", "error", "-f", DEMUX.get(fmt, fmt), *dec_args, "-i", "pipe:0", "-f", "s16le", |
| "-ar", str(SR), "-ac", "1", "pipe:1"], input=enc.stdout, capture_output=True, check=True) |
| y = np.frombuffer(dec.stdout, "<i2").astype(np.float32) / 32767 |
| return align(x, y) |
|
|
|
|
| class EnCodec: |
| """facebook/encodec_24khz (transformers), fp32 on CPU as in the evaluation.""" |
|
|
| def __init__(self, device="cpu"): |
| import torch |
| from transformers import EncodecModel |
| torch.set_num_threads(1) |
| self.torch, self.device = torch, device |
| self.m = EncodecModel.from_pretrained("facebook/encodec_24khz").to(device).eval() |
|
|
| def __call__(self, x, bandwidth): |
| import librosa |
| y = librosa.resample(x, orig_sr=SR, target_sr=24000, res_type="soxr_hq") |
| bk = self.torch.backends |
| tf32 = bk.cudnn.allow_tf32, bk.cuda.matmul.allow_tf32 |
| bk.cudnn.allow_tf32 = bk.cuda.matmul.allow_tf32 = False |
| try: |
| with self.torch.no_grad(): |
| t = self.torch.from_numpy(y)[None, None].to(self.device) |
| out = self.m.decode(*self.m.encode(t, bandwidth=bandwidth)[:2], None)[0][0, 0].cpu().numpy() |
| finally: |
| bk.cudnn.allow_tf32, bk.cuda.matmul.allow_tf32 = tf32 |
| return align(x, librosa.resample(out, orig_sr=24000, target_sr=SR, res_type="soxr_hq")) |
|
|
|
|
| def augment(x, cond, src, rng, encodec=None, trace=None, dry=False): |
| """Recording condition {noise_level, reverb_level, codec_kind} on the window x (float32, 16 kHz).""" |
| tr = trace if trace is not None else {} |
| if cond["reverb_level"] != "minimal": |
| lst = src.rirs[cond["reverb_level"]] |
| p, t = lst[rng.integers(len(lst))] |
| tr.update(rir_file=p, rt60=t) |
| if not dry: |
| x = add_reverb(x, read_audio(src.rir_path(p))) |
| if cond["noise_level"] != "clean": |
| lo, hi = NOISE_LEVELS[cond["noise_level"]] |
| snr = float(rng.uniform(lo, hi)) |
| ntype = ["noise", "music", "babble"][rng.integers(3)] |
| files, offs, parts = [], [], [] |
| if ntype == "babble": |
| k = int(rng.integers(3, 6)) |
| for _ in range(k): |
| f = src.musan["speech"][rng.integers(len(src.musan["speech"]))] |
| seg, o = _segment(src.musan_path(f), len(x), rng, dry) |
| files.append(f), offs.append(o), parts.append(seg) |
| else: |
| f = src.musan[ntype][rng.integers(len(src.musan[ntype]))] |
| seg, o = _segment(src.musan_path(f), len(x), rng, dry) |
| files.append(f), offs.append(o), parts.append(seg) |
| tr.update(snr_db=snr, noise_type=ntype, noise_files=files, noise_offsets=offs) |
| if not dry: |
| x = add_noise(x, sum(parts) if ntype == "babble" else parts[0], snr) |
| if cond["codec_kind"] != "none": |
| kind = cond["codec_kind"] |
| detail, a, inter_sr, fmt = CODECS[kind][rng.integers(len(CODECS[kind]))] |
| if kind == "cascade": |
| (_, ma, msr, mfmt), (_, bw, _, _) = a |
| steps = [lambda v: ffmpeg_codec(v, ma, msr, mfmt), lambda v: encodec(v, bw)] |
| if rng.random() < 0.5: |
| steps, detail = steps[::-1], "+".join(detail.split("+")[::-1]) |
| if not dry: |
| for f in steps: |
| x = f(x) |
| elif kind == "neural": |
| if not dry: |
| x = encodec(x, a) |
| elif not dry: |
| pool = CODECS[kind] |
| for k in range(4): |
| try: |
| x = ffmpeg_codec(x, a, inter_sr, fmt) |
| break |
| except subprocess.CalledProcessError: |
| if k == 3: |
| raise |
| detail, a, inter_sr, fmt = pool[rng.integers(len(pool))] |
| tr["codec_detail"] = detail |
| if not dry: |
| peak = np.abs(x).max() |
| if peak > 0.99: |
| x = x * (0.99 / peak) |
| return x.astype(np.float32), tr |
|
|
|
|
| |
| def _trim(x, db=40.0, keep=0.05): |
| f = 320 |
| n = len(x) // f |
| if n < 2: |
| return x, 0 |
| e = 10 * np.log10(np.mean(x[:n * f].reshape(n, f) ** 2, 1) + 1e-12) |
| idx = np.where(e > e.max() - db)[0] |
| if not len(idx): |
| return x, 0 |
| pad = int(keep * SR) |
| a = max(0, idx[0] * f - pad) |
| return x[a:min(len(x), (idx[-1] + 1) * f + pad)], a |
|
|
|
|
| def proc_pre(x, c): |
| return _trim(x) if c.get("silence") == "trimmed" else (x, 0) |
|
|
|
|
| def proc_post(x, c, rng): |
| if c.get("hp") is not None: |
| x = sosfilt(butter(4, c["hp"], "highpass", fs=SR, output="sos"), x) |
| elif c.get("bp") is not None: |
| x = sosfilt(butter(4, list(c["bp"]), "bandpass", fs=SR, output="sos"), x) |
| peak = np.abs(x).max() + 1e-9 |
| if c.get("clip_peak") is not None: |
| x = np.clip(x * (c["clip_peak"] / peak), -1, 1) |
| elif c.get("gain_db") is not None: |
| x = x * min(10 ** (c["gain_db"] / 20), 0.99 / peak) |
| s = c.get("silence", "unchanged") |
| if s in ("digital silence added", "low-level noise added"): |
| S = len(x) |
| n = min(int(c["sil_len"] * SR), S // 3) |
| pad = lambda: np.zeros(n) if s == "digital silence added" else rng.standard_normal(n) * 10 ** (c["noise_dbfs"] / 20) |
| w = c["sil_where"] |
| x = np.concatenate([pad(), x[:S - n]]) if w == "start" else np.concatenate([x[:S - n], pad()]) if w == "end" \ |
| else np.concatenate([pad(), x[:S - 2 * n], pad()]) |
| return x.astype(np.float32), (0 if w == "end" else n, 0 if w == "start" else n) |
| return x.astype(np.float32), (0, 0) |
|
|
|
|
| |
| def seed_of(seed_key): |
| return zlib.crc32(seed_key.encode()) |
|
|
|
|
| def realize(source, seed_key, cond=None, proc=None, src=None, encodec=None, window=WINDOW, check=None, dry=False): |
| """-> (16 kHz float32 window as the model heard it, trace). |
| |
| source: path of the source recording (or a 1-D float32 array at 16 kHz); seed_key: the row's utt_id; |
| cond: {noise_level, reverb_level, codec_kind} for augmented / recorded-condition rows, else None; |
| proc: post-processing condition (benchmark column `proc`) or None; src: Sources (needed when cond is given); |
| check: a stored realization dict, compared with the replayed draws (AssertionError on a difference); |
| dry: replay the random draws only (no signal processing; noise files are only opened for their length).""" |
| rng = np.random.default_rng(seed_of(seed_key)) |
| x = (read_audio(source) if isinstance(source, str) else np.asarray(source, np.float32)) if not dry or proc else None |
| trace = {"seed": seed_of(seed_key)} |
| if dry and not proc: |
| x = np.zeros(window, np.float32) |
| trace["dry"] = True |
| trim = 0 |
| if proc: |
| x, trim = proc_pre(x.astype(np.float32), proc) |
| trace.update(trim_start=int(trim), length=int(len(x))) |
| x, tiled = fit_window(x, window) |
| x = x.astype(np.float32) |
| trace["tiled"] = bool(tiled) |
| if cond is not None: |
| x, _ = augment(x, cond, src, rng, encodec, trace, dry) |
| if proc: |
| x, (p0, p1) = proc_post(x, proc, rng) |
| trace.update(pad_start=int(p0), pad_end=int(p1)) |
| if check: |
| for k in ("rir_file", "snr_db", "noise_type", "noise_files", "noise_offsets", "codec_detail"): |
| if check.get(k) is not None or trace.get(k) is not None: |
| a, b = check.get(k), trace.get(k) |
| ok = np.allclose(a, b) if k == "snr_db" and a is not None and b is not None else list(np.atleast_1d(a)) == list(np.atleast_1d(b)) |
| assert ok, f"{seed_key}: {k} replayed {b!r}, stored {a!r}" |
| return x.astype(np.float32), trace |
|
|
