KoshiMazaki
/

akuspace-ltx25

+"""Build cathedral and small room at three levels, normalised to the joint batch.
+Three render batches exist, made in separate sessions at different send settings,
+so the same level word currently means different amounts depending on which batch
+a source came from:
+                 cathedral high    small high
+  joint (8)          -19.7            -14.3
+  male-female (4)    -18.9             -7.7
+  claps, old (2)      -9.1             -7.4
+Cathedral: joint and male-female already agree to 0.8 dB; the claps sit 10 dB
+wetter. Small room: male-female and claps agree; the joint batch is 6.6 dB drier.
+Each space has one batch out of step, and a different one each time.
+TARGET IS THE JOINT BATCH, per Radek. Every source is scaled to the joint median
+for its space and level, so a level word means one measured amount everywhere.
+BEATS ARE EXCLUDED, as previously decided: they needed the largest corrections and
+they are percussive, where a dense reverb reads very differently from how it reads
+on sustained material.
+Claps have only ONE rendered level (the old batch). Since they are verified send
+mixes, low and mid are derived offline by scaling R — the method validated at
+-71.6 dB against a real Ableton render, i.e. inaudible.
+Scaling touches R only, never the dry, so the dry stays a true dry.
+"""
+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"))
+JOINT, MF, SLICED = BASE / "Levels-Reverb/joint-catedral", BASE / "male-female", BASE / "Sliced"
+OUT = BASE / "v5-rooms"
+JOINT_SRC = ["citola_01", "citola_02", "beat_01", "beat_02",
+             "male_voice_01", "male_voice_02", "piano_01", "piano_sax"]
+MF_SRC = ["female_new_01", "female_new_02", "male_new_01", "male_new_02"]
+LEVELS = ["low", "mid", "high"]
+NO_NORMALIZE = {"beat_01", "beat_02"}
+CEILING_DB = -3.0
+SPACES = {
+    "synthetic_cathedral": {
+        "joint": ("dry.wav", ["cathedral low.wav", "cathedral mid.wav", "cathedral high.wav"]),
+        "mf": ("female-male-dry.wav", ["female-male-cathedral-low.wav",
+               "female-male-cathedral-mid.wav", "female-male-cathedral.wav"]),
+        "claps_dir": "synthetic_cathedral",
+    },
+    "small_room_0_67": {
+        "joint": ("dry.wav", ["smallroom_low.wav", "smallroom_mid.wav", "smallroom_high.wav"]),
+        "mf": ("female-male-dry.wav", ["female-male-small-low.wav",
+               "female-male-small-mid.wav", "female-male-small.wav"]),
+        "claps_dir": "small_room_0_67",
+    },
+}
+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)
+def ratio(d, R):
+    return db(R.mean(axis=1)) - db(d.mean(axis=1))
+# ---- gather every (source, space, level) as dry + R ------------------------
+pairs = {}
+for space, cfg in SPACES.items():
+    dj = load(JOINT / cfg["joint"][0])
+    wj = [load(JOINT / f) for f in cfg["joint"][1]]
+    for i, src in enumerate(JOINT_SRC):
+        a, b = i * SLOT, (i + 1) * SLOT
+        d = dj[a:b]
+        for lv, w in zip(LEVELS, wj):
+            pairs[(src, space, lv)] = ("joint", d, w[a:b] - d)
+    dm = load(MF / cfg["mf"][0])
+    wm = [load(MF / f) for f in cfg["mf"][1]]
+    for i, src in enumerate(MF_SRC):
+        a, b = i * SLOT, (i + 1) * SLOT
+        d = dm[a:b]
+        for lv, w in zip(LEVELS, wm):
+            pairs[(src, space, lv)] = ("male-female", d, w[a:b] - d)
+    # claps: one rendered level, treated as "high"; low/mid derived after scaling
+    for src in ("claps_rhythm", "claps_single"):
+        dp, wp = SLICED / "dry" / f"{src}.wav", SLICED / cfg["claps_dir"] / f"{src}.wav"
+        if dp.exists() and wp.exists():
+            d, w = load(dp)[:SLOT], load(wp)[:SLOT]
+            n = min(len(d), len(w))
+            pairs[(src, space, "high")] = ("claps", d[:n], w[:n] - d[:n])
+# ---- joint medians are the target ------------------------------------------
+targets = {}
+for space in SPACES:
+    for lv in LEVELS:
+        vals = [ratio(d, R) for (s, sp, l), (b, d, R) in pairs.items()
+                if sp == space and l == lv and b == "joint"]
+        targets[(space, lv)] = float(np.median(vals))
+print("targets (joint medians):")
+for (space, lv), t in sorted(targets.items()):
+    print(f"  {space:<22} {lv:<5} {t:>+7.1f} dB")
+# ---- normalise, derive missing clap levels, write ---------------------------
+print(f"\n{'source':<16} {'space':<22} {'level':<5} {'was':>8} {'corr':>7} {'now':>8}")
+print("-" * 74)
+out, corrections = {}, []
+for space in SPACES:
+    for src in JOINT_SRC + MF_SRC + ["claps_rhythm", "claps_single"]:
+        base = pairs.get((src, space, "high"))
+        if base is None:
+            continue
+        batch, d, R_high = base
+        for lv in LEVELS:
+            key = (src, space, lv)
+            if key in pairs:
+                _, d, R = pairs[key]
+            else:
+                # derive from high by the ratio the joint targets imply
+                R = R_high * 10 ** ((targets[(space, lv)] - targets[(space, "high")]) / 20)
+            was = ratio(d, R)
+            if src in NO_NORMALIZE:
+                corr = 0.0
+            else:
+                corr = targets[(space, lv)] - was
+                R = R * 10 ** (corr / 20)
+            out[key] = (d, R)
+            if abs(corr) > 0.05:
+                corrections.append(abs(corr))
+            print(f"{src:<16} {space:<22} {lv:<5} {was:>+7.1f} {corr:>+6.1f} "
+                  f"{ratio(d, R):>+7.1f}" + ("   (beats: left as rendered)" if src in NO_NORMALIZE else ""))
+# uniform trim so nothing clips; changes no ratio anywhere
+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"\nloudest {peak:+.1f} dBFS -> uniform trim {trim:+.1f} dB (ceiling {CEILING_DB:+g})")
+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")
+n = len(out)
+print(f"\n{n} pairs -> {OUT}")
+print(f"  {len(set(k[0] for k in out))} sources x {len(SPACES)} spaces x {len(LEVELS)} levels")
+print(f"  corrections applied: {len(corrections)}, median {np.median(corrections):.1f} dB, "
+      f"max {max(corrections):.1f} dB")