README.md

---
license: cc-by-nc-sa-4.0
task_categories:
- audio-to-audio
language:
- en
tags:
- SFZ
- SFZ-Instruments
- Instruments
- MIDI
- MIDI-Instruments
pretty_name: sfzinstruments
size_categories:
- n<1K
---

# SFZ Instruments
## Select open source musical instruments which use the SFZ format

***

## Attribution

### All SFZ instruments were sourced from [sfzinstruments](https://github.com/sfzinstruments)

***

## 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