Use real public-domain music loops for the sound beds

Add four FreePD (Kevin MacLeod, CC0/public-domain) loops as the background
beds — Ambient Drift (Ambient C Motion), Lo-fi Pulse (Chill Beat),
Cinematic Rise (Wonder Flow), Newsroom Bed (Action Investigation) — fetched
via scripts/build_music_loops.py and stored as compact mono FLAC (LFS).
tts/music.py now loads/loops the real track (crossfaded to episode length)
when present and falls back to the procedural numpy bed otherwise. Credits
added to the README.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

README.md

@@ -68,3 +68,11 @@ huggingface-cli login
 huggingface-cli upload <user>/podify . --repo-type=space
 # or: git push to the Space remote (preset .wav files tracked via Git LFS)
 ```
+
+## Credits / assets
+
+- **Voice samples** (`tts/voices/`): derived from [CMU ARCTIC](http://festvox.org/cmu_arctic/)
+  (free for research and commercial use). Rebuild with `scripts/build_voice_samples.py`.
+- **Background-music loops** (`tts/music_loops/`): [FreePD](https://freepd.com/) by Kevin
+  MacLeod — 100% public domain (CC0). Rebuild with `scripts/build_music_loops.py`.
+  A procedural numpy fallback in `tts/music.py` is used if the loops are absent.

scripts/build_music_loops.py

@@ -0,0 +1,83 @@
+"""Build background-music loops from FreePD (public-domain / CC0).
+
+FreePD (Kevin MacLeod) releases its catalogue as 100% public-domain music, mirrored on the
+Internet Archive (item `freepd`). We pull four mood tracks, trim each to a ~60s segment,
+normalise, fade, and save a compact mono OGG loop used by tts/music.py. No attribution is
+required (public domain), but FreePD is credited in the README.
+
+Run from the repo root:  python scripts/build_music_loops.py
+OGG files are tracked via Git LFS (see .gitattributes).
+"""
+
+from __future__ import annotations
+
+import io
+import os
+import urllib.parse
+import urllib.request
+
+import numpy as np
+import soundfile as sf
+
+IA_BASE = "https://archive.org/download/freepd"
+TARGET_SR = 44100
+SEG_START = 8.0   # skip any intro
+SEG_LEN = 60.0
+OUT_DIR = os.path.join("tts", "music_loops")
+
+# bed id -> FreePD track (path within the IA item)
+TRACKS = {
+    "ambient_drift": "Page2/Ambient C Motion.mp3",
+    "lofi_pulse": "Page2/Chill Beat.mp3",
+    "cinematic_rise": "Page2/Wonder Flow.mp3",
+    "newsroom_bed": "Page2/Action Investigation.mp3",
+}
+
+
+def _fetch(track: str) -> bytes:
+    url = IA_BASE + "/" + urllib.parse.quote(track)
+    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return r.read()
+
+
+def _resample(x: np.ndarray, sr: int, target: int) -> np.ndarray:
+    if sr == target:
+        return x
+    n = int(round(len(x) * target / sr))
+    xp = np.linspace(0, 1, len(x), dtype=np.float64)
+    fp = np.linspace(0, 1, n, dtype=np.float64)
+    return np.interp(fp, xp, x).astype(np.float32)
+
+
+def build():
+    os.makedirs(OUT_DIR, exist_ok=True)
+    for bed_id, track in TRACKS.items():
+        audio, sr = sf.read(io.BytesIO(_fetch(track)), dtype="float32")
+        if audio.ndim > 1:
+            audio = audio.mean(axis=1)
+        audio = _resample(audio, sr, TARGET_SR)
+
+        start = int(SEG_START * TARGET_SR)
+        if start + int(5 * TARGET_SR) >= len(audio):
+            start = 0
+        seg = audio[start:start + int(SEG_LEN * TARGET_SR)]
+
+        peak = float(np.abs(seg).max()) or 1.0
+        seg = (seg / peak * 0.9).astype(np.float32)
+
+        f = int(1.0 * TARGET_SR)
+        if len(seg) > 2 * f:
+            seg[:f] *= np.linspace(0, 1, f, dtype=np.float32)
+            seg[-f:] *= np.linspace(1, 0, f, dtype=np.float32)
+
+        # FLAC: stable libsndfile write + lossless/compact. Loops are read server-side
+        # only (mixed into the speech), so browser codec support is irrelevant.
+        out = os.path.join(OUT_DIR, f"{bed_id}.flac")
+        sf.write(out, seg, TARGET_SR, format="FLAC", subtype="PCM_16")
+        print(f"  {bed_id:16s} <- {track}  {len(seg)/TARGET_SR:.1f}s  {os.path.getsize(out)//1024}KB")
+
+
+if __name__ == "__main__":
+    build()
+    print("done.")

tts/music.py

@@ -8,11 +8,65 @@ kick pulses. Each ``render_bed`` returns a mono float32 track at the speech samp
 
 from __future__ import annotations
 
+import functools
+import os
+
 import numpy as np
 
 # Linear gain applied to the (peak-normalised) bed when mixed under speech.
 MUSIC_GAIN = 0.14
 
+# Real public-domain (FreePD/CC0) loops, used when present; else procedural fallback.
+_LOOPS_DIR = os.path.join(os.path.dirname(__file__), "music_loops")
+_LOOP_FILES = {
+    "ambient drift": "ambient_drift.flac",
+    "lo-fi pulse": "lofi_pulse.flac",
+    "cinematic rise": "cinematic_rise.flac",
+    "newsroom bed": "newsroom_bed.flac",
+}
+
+
+@functools.lru_cache(maxsize=8)
+def _load_loop(filename: str):
+    """Load a loop file as (mono float32, sr), cached. Returns None if unavailable."""
+    path = os.path.join(_LOOPS_DIR, filename)
+    if not os.path.isfile(path):
+        return None
+    try:
+        import soundfile as sf
+
+        audio, sr = sf.read(path, dtype="float32")
+        if audio.ndim > 1:
+            audio = audio.mean(axis=1)
+        return audio.astype(np.float32), int(sr)
+    except Exception:
+        return None
+
+
+def _resample(x: np.ndarray, sr: int, target: int) -> np.ndarray:
+    if sr == target or len(x) == 0:
+        return x
+    n = int(round(len(x) * target / sr))
+    return np.interp(np.linspace(0, 1, n), np.linspace(0, 1, len(x)), x).astype(np.float32)
+
+
+def _tile_to(x: np.ndarray, n: int, sr: int) -> np.ndarray:
+    """Repeat a loop to length n with a short equal-power crossfade at each seam."""
+    if len(x) >= n:
+        return x[:n]
+    xf = min(int(0.5 * sr), len(x) // 4)
+    if xf <= 0:
+        reps = int(np.ceil(n / len(x)))
+        return np.tile(x, reps)[:n]
+    fade_in = np.linspace(0, 1, xf, dtype=np.float32)
+    fade_out = fade_in[::-1]
+    out = np.array(x, dtype=np.float32)
+    while len(out) < n:
+        tail = out[-xf:] * fade_out
+        head = x[:xf] * fade_in
+        out = np.concatenate([out[:-xf], tail + head, x[xf:]])
+    return out[:n]
+
 
 def _sine(freq: float, n: int, sr: int, phase: float = 0.0) -> np.ndarray:
     t = np.arange(n, dtype=np.float32) / sr
@@ -88,12 +142,25 @@ def render_bed(name: str, duration_sec: float, sr: int) -> np.ndarray:
     return (m / peak * amp).astype(np.float32)
 
 
+def _bed_for(name: str, n: int, sr: int) -> np.ndarray:
+    """Length-n bed at sr: a real FreePD loop if bundled, else procedural synthesis."""
+    key = (name or "").strip().lower()
+    loaded = _load_loop(_LOOP_FILES.get(key, ""))
+    if loaded is not None:
+        loop, lsr = loaded
+        loop = _resample(loop, lsr, sr)
+        bed = _tile_to(loop, n, sr)
+        peak = float(np.abs(bed).max()) or 1.0
+        return (bed / peak * 0.9).astype(np.float32)
+    return render_bed(name, n / sr, sr)
+
+
 def mix(speech: np.ndarray, name: str, sr: int, gain: float = MUSIC_GAIN) -> np.ndarray:
     """Mix the named bed under the speech. Returns float32 in [-1, 1]."""
     speech = np.asarray(speech, dtype=np.float32).reshape(-1)
     if not name or name.strip().lower().startswith("no music"):
         return speech
-    bed = render_bed(name, len(speech) / sr, sr)
+    bed = _bed_for(name, len(speech), sr)
     if len(bed) < len(speech):
         bed = np.pad(bed, (0, len(speech) - len(bed)))
     else:

tts/music_loops/ambient_drift.flac

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c3173137804483ef766e03ad11319ff564853298b3faebf3befaba6ce328af3
+size 2530419

tts/music_loops/cinematic_rise.flac

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6426727da3d68f3c7495a35efad3b2368fd8406a42931be7b9bea41a8d0b0a0c
+size 3088641

tts/music_loops/lofi_pulse.flac

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b09dd6ba6be923d2db951d0cf6e785089b54eddf59d9a8f8061bcd22a427bba
+size 3048935

tts/music_loops/newsroom_bed.flac

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b254438fb0bb4e0a4ac2feeefc6aa6ce0ac39a42026a4d1e2dc2c9c46f4d000a
+size 1909197