scripts/dataset: add build_eurorack_dry.py

scripts/dataset/build_eurorack_dry.py

@@ -0,0 +1,124 @@
+"""Build one combined dry file to run through the Eurorack in a single pass.
+
+WHY ONE FILE: processing every source in one continuous pass guarantees the patch
+settings are identical across all of them. Doing it per-source is exactly what
+broke the outdoor spaces — six sources ended up 0.11-0.33x the ambience level of
+the others because the treatment drifted between renders.
+
+GAPS BETWEEN SOURCES: a granular delay has a long, unpredictable tail. Without a
+gap, source N's tail bleeds into source N+1's opening and every slice after the
+first is contaminated. GAP_S of silence lets each tail decay before the next
+source starts. The tail is still ringing at the 6 s mark, which is what the
+dataset wants — clips are hard-cut with no fade, because a tail still sounding at
+the boundary teaches the model that reverb continues past the window.
+
+LEVELS: every source is normalised to the same ACTIVE loudness first, so the
+patch sees consistent input. Active rather than peak because claps are sparse —
+they read 12.7 dB quiet on RMS while sounding no quieter.
+
+SOURCES: the 10 clean existing sources plus the 4 new recordings. The four
+ElevenLabs sources are excluded — their Prohibited Use Policy bars training on
+output, so they are being replaced by these recordings.
+
+Writes the combined wav plus a manifest giving each source's exact offset, so the
+processed return can be sliced back precisely.
+"""
+import csv
+import subprocess
+import wave
+import os
+from pathlib import Path
+
+import numpy as np
+
+SLICED = Path(os.environ.get("AKUSPACE_DATASET", "../../../../AUDIO-LTX-LORA/Dataset")) / "Sliced" / "dry"
+NEW = Path(os.environ.get("AKUSPACE_DATASET", "../../../../AUDIO-LTX-LORA/Dataset")) / "male-female" / "female-male-dry.wav"
+OUT = Path(os.environ.get("AKUSPACE_DATASET", "../../../../AUDIO-LTX-LORA/Dataset")) / "eurorack-input"
+SR, SLOT_S, GAP_S = 48000, 6.0, 6.0
+TARGET_ACTIVE_DB = -16.0
+
+# ElevenLabs sources, excluded — being replaced by the new recordings
+DROP = {"femaleTTS_1", "femaleTTS_2", "voice_scot_01", "voice_scot_02"}
+# the new 24 s file is 4 x 6 s: female, female, male, male (iPhone)
+NEW_SLICES = ["female_new_01", "female_new_02", "male_new_01", "male_new_02"]
+
+
+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 active_db(x):
+    m = x.mean(axis=1)
+    fr = SR // 20
+    n = len(m) // fr
+    if n < 5:
+        return 20 * np.log10(np.sqrt((m ** 2).mean()) + 1e-12)
+    f = np.sqrt((m[:n * fr].reshape(n, fr) ** 2).mean(axis=1))
+    a = f[f > f.max() * 0.1]
+    return 20 * np.log10(a.mean() + 1e-12) if a.size else -99.0
+
+
+slot, gap = int(SLOT_S * SR), int(GAP_S * SR)
+items = []
+
+for p in sorted(SLICED.glob("*.wav")):
+    if p.stem in DROP:
+        continue
+    items.append((p.stem, load(p)[:slot]))
+
+if NEW.exists():
+    n = load(NEW)
+    for i, name in enumerate(NEW_SLICES):
+        seg = n[i * slot:(i + 1) * slot]
+        if len(seg) >= slot // 2:
+            items.append((name, seg))
+else:
+    print(f"!! missing {NEW}")
+
+print(f"{'source':<20} {'active in':>10} {'gain':>7} {'offset':>9}")
+print("-" * 52)
+buf, rows, pos = [], [], 0.0
+for name, x in items:
+    a = active_db(x)
+    g = 10 ** ((TARGET_ACTIVE_DB - a) / 20)
+    y = x * g
+    if len(y) < slot:
+        y = np.vstack([y, np.zeros((slot - len(y), y.shape[1]))])
+    buf.append(y)
+    buf.append(np.zeros((gap, y.shape[1])))
+    rows.append({"source": name, "start_s": f"{pos:.3f}",
+                 "end_s": f"{pos + SLOT_S:.3f}", "gain_db": f"{20*np.log10(g):+.2f}"})
+    print(f"{name:<20} {a:>9.1f} {20*np.log10(g):>+6.1f} {pos:>8.1f}s")
+    pos += SLOT_S + GAP_S
+
+combined = np.vstack(buf)
+peak = 20 * np.log10(np.abs(combined).max() + 1e-12)
+if peak > -3.0:                                   # uniform trim, changes no ratio
+    combined *= 10 ** ((-3.0 - peak) / 20)
+    print(f"\n  trimmed {-3.0 - peak:+.1f} dB for headroom")
+
+save(combined, OUT / "eurorack_input_dry.wav")
+with open(OUT / "eurorack_input_manifest.csv", "w", newline="") as fh:
+    w = csv.DictWriter(fh, fieldnames=list(rows[0].keys()))
+    w.writeheader(); w.writerows(rows)
+
+print(f"\n{len(items)} sources, {SLOT_S:g}s each + {GAP_S:g}s gap")
+print(f"  total {len(combined)/SR:.1f}s  peak {20*np.log10(np.abs(combined).max()+1e-12):+.1f} dBFS")
+print(f"  -> {OUT}/eurorack_input_dry.wav")
+print(f"  -> {OUT}/eurorack_input_manifest.csv  (offsets for slicing the return)")
+print("\nRun this whole file through the patch in ONE pass. Do not touch the")
+print("controls between sources — the modulation varying is fine and even")
+print("desirable, but the SEND LEVEL must stay constant or you reproduce the")
+print("outdoor bug, where one caption meant different amounts on different sources.")