scripts/dataset: add build_v5_outdoor.py

scripts/dataset/build_v5_outdoor.py

@@ -0,0 +1,124 @@
+"""Add the two outdoor places to v5-rooms — de-ghosted, beds exactly as rendered.
+
+These are PLACES, not spaces — an ambience bed rather than a reverb. The bed is
+never scaled in either direction: boosting a bed amplifies the field recording's
+own noise floor (tried; sounded unnatural), and pulling everything down to the
+quietest loses the space. Two levels only, cut downward from the render: "high"
+is the bed as rendered, "low" 8 dB under it.
+
+THE DE-GHOST: the old render batches carry the dry at 0.74x (day) / 0.67x
+(night) for the eight old non-clap sources — a flat level offset from
+render-batch drift, while claps and the four new voices sit at 1.00. Building
+R = w - d straight from those renders buries a negative ghost of the dry inside
+R, which dominated every naive ambience measurement (the ghost alone reads
+-9.5 dB in night, which is why the old sources "measured" -9.4) and taught two
+transforms under one caption: "duck the voice ~3 dB + bed" on eight sources,
+"keep the voice + bed" on six. So the dry is projected out of each render and
+every pair is rebuilt on a unity dry: bed = w - fit*d, wet = d + bed. True bed
+levels are consistent across sources (day -11..-24, night -19..-28); the
+"17 dB spread" and "claps 10 dB low" stories were artifacts of the ghost.
+
+Chosen in the 08-13 A/B (Dataset/v5-outdoor-compare/): both versions sound
+near-identical by ear, so the de-ghosted one wins on consistency — all 28
+outdoor pairs teach the same transform, matching every room and SFX pair.
+"""
+import subprocess
+import wave
+import os
+from pathlib import Path
+
+import numpy as np
+
+SR, SLOT = 48000, 6 * 48000
+BASE = Path(os.environ.get("AKUSPACE_DATASET", "../../../../AUDIO-LTX-LORA/Dataset"))
+SLICED, MF, OUT = BASE / "Sliced", BASE / "male-female", BASE / "v5-rooms"
+DROP = {"femaleTTS_1", "femaleTTS_2", "voice_scot_01", "voice_scot_02"}
+MF_SRC = ["female_new_01", "female_new_02", "male_new_01", "male_new_02"]
+CEILING_DB = -3.0
+LOW_OFFSET_DB = -8.0   # "low" sits this far under "high"
+
+SPACES = {
+    "outdoor_day_birds": ("outdoor_day_birds", "female-male-outside.wav"),
+    "outdoor_night":     ("outdoor_night",     "female-male-outside-night.wav"),
+}
+
+
+def load(p, ch=2):
+    r = subprocess.run(["ffmpeg", "-v", "error", "-i", str(p), "-ac", str(ch),
+                        "-ar", str(SR), "-f", "f32le", "-"], capture_output=True)
+    return np.frombuffer(r.stdout, dtype="<f4").astype(np.float64).reshape(-1, ch)
+
+
+def save(x, p):
+    p.parent.mkdir(parents=True, exist_ok=True)
+    y = np.clip(x, -1.0, 1.0)
+    i = (y * 8388607.0).astype(np.int32)
+    b = np.stack([i & 0xFF, (i >> 8) & 0xFF, (i >> 16) & 0xFF], axis=-1).astype(np.uint8)
+    with wave.open(str(p), "wb") as w:
+        w.setnchannels(x.shape[1]); w.setsampwidth(3); w.setframerate(SR)
+        w.writeframes(b.tobytes())
+
+
+def db(x):
+    return 20 * np.log10(np.sqrt((x ** 2).mean()) + 1e-12)
+
+
+base, batch = {}, {}
+dmf = load(MF / "female-male-dry.wav")
+for space, (folder, mffile) in SPACES.items():
+    for p in sorted((SLICED / "dry").glob("*.wav")):
+        src = p.stem
+        if src in DROP:
+            continue
+        wp = SLICED / folder / f"{src}.wav"
+        if not wp.exists():
+            continue
+        d, w = load(p)[:SLOT], load(wp)
+        n = min(len(d), len(w), SLOT)
+        base[(src, space)] = (d[:n], w[:n] - d[:n])
+        batch[(src, space)] = "existing"
+    mp = MF / mffile
+    if mp.exists():
+        w = load(mp)
+        for i, src in enumerate(MF_SRC):
+            a, b = i * SLOT, (i + 1) * SLOT
+            d, ws = dmf[a:b], w[a:b]
+            n = min(len(d), len(ws))
+            base[(src, space)] = (d[:n], ws[:n] - d[:n])
+            batch[(src, space)] = "new"
+
+print(f"{'source':<16} {'space':<20} {'batch':<10} {'fit':>6} {'naive':>8} {'bed':>8}")
+print("-" * 76)
+out = {}
+for space in SPACES:
+    for (src, sp), (d, R) in sorted(base.items()):
+        if sp != space:
+            continue
+        naive = db(R.mean(axis=1)) - db(d.mean(axis=1))
+        # project the dry out of the render; fit = 1 + c, with c the ghost
+        # coefficient (about -0.33 on the night old sources, ~0 on claps and
+        # the new voices). The residual is the true bed, kept as rendered —
+        # the bed itself is never scaled up or down.
+        c = float(np.dot(R.ravel(), d.ravel()) / (np.dot(d.ravel(), d.ravel()) + 1e-12))
+        bed = R - c * d
+        out[(src, space, "high")] = (d, bed)
+        out[(src, space, "low")] = (d, bed * 10 ** (LOW_OFFSET_DB / 20))
+        print(f"{src:<16} {space:<20} {batch[(src, sp)]:<10} {1 + c:>6.3f} "
+              f"{naive:>+7.1f} {db(bed.mean(axis=1)) - db(d.mean(axis=1)):>+7.1f}")
+    print(f"{'':<16} {space:<20} beds as rendered on a unity dry; low = high {LOW_OFFSET_DB:+g} dB\n")
+
+peak = max(20 * np.log10(np.abs(d + R).max() + 1e-12) for d, R in out.values())
+trim = min(0.0, CEILING_DB - peak)
+print(f"loudest {peak:+.1f} dBFS -> uniform trim {trim:+.1f} dB")
+for (src, space, lv), (d, R) in out.items():
+    g = 10 ** (trim / 20)
+    save((d + R) * g, OUT / space / lv / f"{src}.wav")
+    save(d * g, OUT / space / "dry" / f"{src}.wav")
+
+import shutil
+for space in SPACES:                      # drop the old single-level folder
+    old = OUT / space / "bed"
+    if old.exists():
+        shutil.rmtree(old)
+
+print(f"\n{len(out)} pairs -> {OUT}  ({len(SPACES)} places x 2 levels)")