Update README.md

README.md

@@ -26,5 +26,266 @@ size_categories:
 
 ***
 
+## How to use (Linux/Ubuntu)
+
+### 1) Unzip the dataset into some folder
+
+### 2) Setup environment
+
+```sh
+!sudo apt install libsndfile1 ffmpeg libjack-jackd2-dev -y
+!pip install soundfile numpy scipy tqdm
+```
+
+### 3) Build and install [sfizz](https://github.com/sfztools/sfizz)
+
+```sh
+!sudo apt install cmake g++ git libsndfile1-dev libjack-jackd2-dev \
+                 libsamplerate0-dev libboost-dev libzstd-dev \
+                 libcurl4-openssl-dev libx11-dev -y
+
+!git clone https://github.com/sfztools/sfizz.git
+%cd sfizz
+!mkdir build
+%cd build
+!cmake .. -DCMAKE_BUILD_TYPE=Release
+!make -j$(nproc)
+!sudo make install
+!sudo ldconfig
+```
+
+### 4) Use the following python script to render your MIDIs
+
+```python
+#!/usr/bin/env python3
+"""
+render_and_mix.py
+
+Render MIDI+SFZ pairs using sfizz_render, mix them, apply basic mastering (limiter + normalize),
+and optionally run ffmpeg loudness normalization.
+
+Dependencies:
+  - sfizz_render (system binary)
+  - libsndfile (system)
+  - Python packages: soundfile, numpy, scipy, tqdm
+  - Optional: ffmpeg (for LUFS normalization)
+"""
+
+import os
+import shutil
+import subprocess
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Dict, Optional
+
+import numpy as np
+import soundfile as sf
+from scipy.signal import fftconvolve
+from tqdm import tqdm
+
+# ---------- Utility audio functions ----------
+
+def db_to_linear(db: float) -> float:
+    return 10.0 ** (db / 20.0)
+
+def linear_to_db(x: float) -> float:
+    return 20.0 * np.log10(np.maximum(x, 1e-12))
+
+def apply_pan(stereo: np.ndarray, pan: float) -> np.ndarray:
+    # pan: -1 (left) .. +1 (right)
+    left_gain = np.cos((pan + 1) * (np.pi / 4))
+    right_gain = np.sin((pan + 1) * (np.pi / 4))
+    stereo[:, 0] *= left_gain
+    stereo[:, 1] *= right_gain
+    return stereo
+
+def ensure_stereo(arr: np.ndarray) -> np.ndarray:
+    if arr.ndim == 1:
+        return np.stack([arr, arr], axis=1)
+    if arr.shape[1] == 1:
+        return np.repeat(arr, 2, axis=1)
+    return arr[:, :2]
+
+def soft_limiter(signal: np.ndarray, threshold: float = 0.98, release: float = 0.01, sample_rate: int = 48000) -> np.ndarray:
+    # Simple per-sample soft clipping with smoothing
+    out = np.copy(signal)
+    # apply tanh-style soft clip scaled to threshold
+    scale = 1.0 / threshold
+    out = np.tanh(out * scale) / scale
+    return out
+
+def normalize_peak(signal: np.ndarray, target_dbfs: float = -1.0) -> np.ndarray:
+    peak = np.max(np.abs(signal))
+    if peak <= 0:
+        return signal
+    target_lin = db_to_linear(target_dbfs)
+    gain = target_lin / peak
+    return signal * gain
+
+# ---------- sfizz_render wrapper ----------
+
+def find_sfizz_render() -> Optional[str]:
+    # Try common binary names
+    for name in ("sfizz_render", "sfizz-render", "sfizz_render.exe"):
+        path = shutil.which(name)
+        if path:
+            return path
+    return None
+
+def render_with_sfizz(sfizz_bin: str, midi_path: str, sfz_path: str, out_wav: str,
+                      sample_rate: int = 48000, quality: int = 3, polyphony: int = 256,
+                      use_eot: bool = True, verbose: bool = False) -> None:
+    cmd = [
+        sfizz_bin,
+        "--midi", str(midi_path),
+        "--sfz", str(sfz_path),
+        "--wav", str(out_wav),
+        "--samplerate", str(sample_rate),
+        "--quality", str(quality),
+        "--polyphony", str(polyphony),
+    ]
+    if use_eot:
+        cmd.append("--use-eot")
+    if verbose:
+        cmd.append("--verbose")
+    # Run and raise on error
+    subprocess.run(cmd, check=True)
+
+# ---------- Main render and mix function ----------
+
+def render_and_mix(
+    midi_sfz_map: Dict[str, str],
+    out_path: str,
+    *,
+    sample_rate: int = 48000,
+    quality: int = 3,
+    polyphony: int = 256,
+    track_options: Optional[Dict[str, Dict]] = None,
+    normalize_lufs: Optional[float] = None,
+    use_eot: bool = True,
+    workers: int = 2,
+    verbose: bool = False
+) -> None:
+    """
+    Render each MIDI->SFZ pair, mix, post-process, and write final WAV to out_path.
+    """
+    sfizz_bin = find_sfizz_render()
+    if not sfizz_bin:
+        raise FileNotFoundError("sfizz_render binary not found in PATH. Install sfizz-render first.")
+
+    tmpdir = Path(tempfile.mkdtemp(prefix="sfizz_render_"))
+    rendered_files = {}
+
+    # Render in parallel
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = {}
+        for midi, sfz in midi_sfz_map.items():
+            midi_p = Path(midi)
+            sfz_p = Path(sfz)
+            if not midi_p.exists():
+                raise FileNotFoundError(f"MIDI file not found: {midi}")
+            if not sfz_p.exists():
+                raise FileNotFoundError(f"SFZ file not found: {sfz}")
+            out_wav = tmpdir / (midi_p.stem + "_" + sfz_p.stem + ".wav")
+            futures[ex.submit(render_with_sfizz, sfizz_bin, str(midi_p), str(sfz_p), str(out_wav),
+                              sample_rate, quality, polyphony, use_eot, verbose)] = (midi, str(out_wav))
+
+        # Wait and collect
+        for fut in tqdm(as_completed(futures), total=len(futures), desc="Rendering"):
+            midi_key, wav_path = futures[fut]
+            fut.result()  # will raise if render failed
+            rendered_files[midi_key] = wav_path
+
+    # Load and align
+    tracks = []
+    max_len = 0
+    for midi_key, wav_path in rendered_files.items():
+        data, sr = sf.read(wav_path, always_2d=True)
+        if sr != sample_rate:
+            # resample if needed (simple linear resample)
+            import math
+            ratio = sample_rate / sr
+            new_len = int(math.ceil(data.shape[0] * ratio))
+            # use scipy.signal.resample for decent quality
+            from scipy.signal import resample
+            data = resample(data, new_len, axis=0)
+        data = ensure_stereo(data)
+        tracks.append((midi_key, data))
+        if data.shape[0] > max_len:
+            max_len = data.shape[0]
+
+    # Prepare final mix buffer
+    mix = np.zeros((max_len, 2), dtype=np.float32)
+
+    # Apply per-track options and mix
+    for midi_key, data in tracks:
+        opts = (track_options or {}).get(midi_key, {})
+        gain_db = float(opts.get("gain_db", 0.0))
+        pan = float(opts.get("pan", 0.0))
+        gain_lin = db_to_linear(gain_db)
+        # pad to max_len
+        pad_len = max_len - data.shape[0]
+        if pad_len > 0:
+            data = np.vstack([data, np.zeros((pad_len, 2), dtype=data.dtype)])
+        data = data.astype(np.float32) * gain_lin
+        data = apply_pan(data, pan)
+        mix[:data.shape[0], :] += data
+
+    # Basic safety: prevent NaNs/Infs
+    mix = np.nan_to_num(mix, nan=0.0, posinf=0.0, neginf=0.0)
+
+    # Apply soft limiter and normalization
+    mix = soft_limiter(mix, threshold=0.98, sample_rate=sample_rate)
+    mix = normalize_peak(mix, target_dbfs=-1.0)
+
+    # Write intermediate file
+    intermediate = tmpdir / "mixed_intermediate.wav"
+    sf.write(str(intermediate), mix, samplerate=sample_rate, subtype="PCM_24")
+
+    # Optional LUFS normalization via ffmpeg loudnorm
+    final_out = Path(out_path)
+    if normalize_lufs is not None:
+        ffmpeg = shutil.which("ffmpeg")
+        if not ffmpeg:
+            raise FileNotFoundError("ffmpeg not found but normalize_lufs requested.")
+        # two-pass loudnorm recommended; here we do a single-pass approximate target
+        cmd = [
+            ffmpeg, "-y", "-i", str(intermediate),
+            "-af", f"loudnorm=I={normalize_lufs}:TP=-1.5:LRA=11",
+            "-ar", str(sample_rate),
+            "-ac", "2",
+            "-c:a", "pcm_s24le",
+            str(final_out)
+        ]
+        subprocess.run(cmd, check=True)
+    else:
+        # move intermediate to final
+        shutil.move(str(intermediate), str(final_out))
+
+    # cleanup
+    try:
+        shutil.rmtree(tmpdir)
+    except Exception:
+        pass
+
+# ---------- Example usage ----------
+if __name__ == "__main__":
+    # Example mapping: two MIDI files each with their SFZ instrument
+    mapping = {
+        "midi/drums.mid": "sfz/drumkit.sfz",
+        "midi/piano.mid": "sfz/grand_piano.sfz",
+    }
+    track_opts = {
+        "midi/drums.mid": {"gain_db": -1.5, "pan": 0.0},
+        "midi/piano.mid": {"gain_db": -3.0, "pan": -0.1},
+    }
+    render_and_mix(mapping, "final_mix.wav", sample_rate=48000, quality=3, polyphony=256,
+                   track_options=track_opts, normalize_lufs=-14.0, use_eot=True, workers=2, verbose=False)
+
+```
+
+***
+
 ### Project Los Angeles
 ### Tegridy Code 2026