Datasets:

projectlosangeles
/

SFZ-Instruments

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