Blame for scripts/prepare_audio.py

#!/usr/bin/env python3
"""Resolve VeriSpoof-Bench audio from your local corpus copies and regenerate the derived items.

    python scripts/prepare_audio.py --roots LA19=/corpora/ASVspoof2019 InTheWild=/corpora/itw ... \
        [--musan /corpora/musan --rirs /corpora/RIRS_NOISES] [--subsets ...] [--out bench_audio] [--check] [--md5]

--roots      one ROOT=DIR per corpus root used by the items (`audio[].root`: LA19, ASVspoof2021, ASVspoof5, InTheWild,
             SpoofCeleb, MLAAD, STOPA, DFADD, LibriSeVoc, CodecFakePlus, PartialSpoof, HAD, PartialEdit,
             LlamaPartialSpoof). DIR/<audio[].path> should exist; if your layout differs, files are found by the longest
             matching path suffix under DIR.
--musan/--rirs  MUSAN (OpenSLR 17) and RIRS_NOISES (OpenSLR 28) roots, needed for augmented / recorded-condition items
--check      only report missing files (and with --md5, files whose MD5 differs from `audio[].md5`)

Writes <out>/manifest.csv (item_id, subset, role, path): for clean items the path of your original file (the model
reads it and uses the first 8 s, tiling shorter files); for derived items (augmented / recorded-condition /
post-processed) a 16 kHz float32 WAV of the exact 8 s window the evaluation used, regenerated by
scripts/vsbench_audio.py (the replayed random draws are checked against the stored `realization`). EnCodec items
need torch + transformers; ffmpeg 7.0.2 (static build, e.g. johnvansickle.com) via $VSBENCH_FFMPEG reproduces the
classical codecs bit-exactly.
"""
import argparse
import csv
import glob
import hashlib
import json
import os
import sys
from multiprocessing import Pool

import pyarrow.parquet as pq

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import vsbench_audio as VA  # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))


class Resolver:
    def __init__(self, roots):
        self.roots, self.index = roots, {}

    def _index(self, root):
        if root not in self.index:
            idx = {}
            for dp, _, fs in os.walk(self.roots[root]):
                for f in fs:
                    idx.setdefault(f, []).append(os.path.join(dp, f))
            self.index[root] = idx
        return self.index[root]

    def __call__(self, root, rel):
        if root not in self.roots:
            return None
        p = os.path.join(self.roots[root], rel)
        if os.path.exists(p):
            return p
        cands = self._index(root).get(os.path.basename(rel), [])
        best, score = None, -1
        parts = rel.split("/")
        for c in cands:
            cp = c.split(os.sep)
            n = 0
            while n < min(len(parts), len(cp)) and parts[-1 - n] == cp[-1 - n]:
                n += 1
            if n > score:
                best, score = c, n
            elif n == score:
                best = None  # ambiguous
        return best


def md5(p):
    h = hashlib.md5()
    with open(p, "rb") as f:
        for b in iter(lambda: f.read(1 << 20), b""):
            h.update(b)
    return h.hexdigest()


_W = {}


def _realize(job):
    key, src_path, seed_key, cond, proc, real, out, musan, rirs = job
    if "src" not in _W:
        _W["src"] = VA.Sources(musan, rirs) if musan else None
        _W["enc"] = None
    if cond and cond["codec_kind"] in ("neural", "cascade") and _W["enc"] is None:
        _W["enc"] = VA.EnCodec()
    if os.path.exists(out):
        return key, out, None
    try:
        x, tr = VA.realize(src_path, seed_key, cond, proc, _W["src"], _W["enc"], check=real)
    except AssertionError as e:
        return key, None, str(e)
    import soundfile as sf
    os.makedirs(os.path.dirname(out), exist_ok=True)
    sf.write(out + ".part.wav", x, VA.SR, subtype="FLOAT")
    os.replace(out + ".part.wav", out)
    return key, out, None


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--roots", nargs="+", default=[], help="ROOT=DIR")
    ap.add_argument("--musan")
    ap.add_argument("--rirs")
    ap.add_argument("--bench", default=os.path.join(HERE, ".."))
    ap.add_argument("--subsets", nargs="*")
    ap.add_argument("--out", default="bench_audio")
    ap.add_argument("--check", action="store_true")
    ap.add_argument("--md5", action="store_true")
    ap.add_argument("--workers", type=int, default=8)
    a = ap.parse_args()
    roots = dict(r.split("=", 1) for r in a.roots)
    res = Resolver(roots)
    files = sorted(glob.glob(f"{a.bench}/data/*.parquet"))
    subsets = a.subsets or [os.path.basename(f)[:-8] for f in files]
    rows, missing, bad, jobs, derived = [], {}, [], {}, {}
    for s in subsets:
        for it in pq.read_table(f"{a.bench}/data/{s}.parquet", columns=["item_id", "audio"]).to_pylist():
            for au in it["audio"]:
                p = res(au["root"], au["path"])
                if p is None:
                    missing.setdefault(au["root"], set()).add(au["path"])
                    continue
                if a.md5 and md5(p) != au["md5"]:
                    bad.append(p)
                if au["derived"] or au["post_processing"]:
                    proc = au["post_processing"]
                    key = au["seed_key"] + ("" if proc is None else "__proc_" + hashlib.md5(
                        json.dumps(proc, sort_keys=True).encode()).hexdigest()[:10])
                    out = os.path.join(a.out, "derived", key.replace("/", "__").replace("#", "_") + ".wav")
                    jobs[key] = (key, p, au["seed_key"], au["condition"] if au["derived"] else None, proc,
                                 au["realization"] if au["derived"] else None, out, a.musan, a.rirs)
                    derived[(it["item_id"], au["role"])] = key
                    rows.append([it["item_id"], s, au["role"], out])
                else:
                    rows.append([it["item_id"], s, au["role"], p])
    for r, ps in sorted(missing.items()):
        print(f"missing {len(ps)} files under root {r}" + ("" if r in roots else " (no --roots entry)"), flush=True)
    if a.md5:
        print(f"{len(bad)} files with a different MD5", flush=True)
    if a.check:
        return
    if any(j[3] for j in jobs.values()) and not (a.musan and a.rirs):
        raise SystemExit("augmented / recorded-condition items need --musan and --rirs")
    errors = []
    with Pool(a.workers) as pool:
        for k, (key, out, err) in enumerate(pool.imap_unordered(_realize, list(jobs.values()), chunksize=8)):
            if err:
                errors.append(err)
            if k % 1000 == 0:
                print(f"derived {k}/{len(jobs)}", flush=True)
    for e in errors[:10]:
        print("REALIZATION MISMATCH", e)
    os.makedirs(a.out, exist_ok=True)
    with open(f"{a.out}/manifest.csv", "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["item_id", "subset", "role", "path"])
        w.writerows(rows)
    print(f"{len(rows)} audio entries ({len(jobs)} derived files) -> {a.out}/manifest.csv; "
          f"{sum(map(len, missing.values()))} missing; {len(errors)} realization mismatches")


if __name__ == "__main__":
    main()