Spaces:
Running
Running
Round 3: True-Peak, Stems-Jobs (Queue/ETA/Abbruch), Cloud-Autosave privat, Smart-Prompt mit Takes, Mixer + FX-Presets, Undo komplett
2cdb2ce verified Download studio/daw/engine.py from 2Btainment/2b-studio: direct link, hf CLI and curl.
- Browser
- Download file 15.2 kB
-
https://huggingface.co/spaces/2Btainment/2b-studio/resolve/main/studio/daw/engine.py
- Command line
-
hf download hf://spaces/2Btainment/2b-studio/studio/daw/engine.py
-
curl -L -o engine.py https://huggingface.co/spaces/2Btainment/2b-studio/resolve/main/studio/daw/engine.py
15.2 kB
| """DAW-DSP: destruktive Effekte (Audacity-Basis), VST3-Plugins (LSP, Dragonfly), Prozedurale SFX.""" | |
| from __future__ import annotations | |
| import math | |
| import os | |
| import threading | |
| from functools import lru_cache | |
| from pathlib import Path | |
| from typing import Any | |
| import numpy as np | |
| import pedalboard as pb | |
| from pedalboard.io import AudioFile | |
| SR = 48000 | |
| PLUGIN_DIR = Path(__file__).resolve().parents[2] / "plugins" / "vst3" | |
| _LOCK = threading.Lock() | |
| # ------------------------------------------------------------------ I/O | |
| def load(path: str | Path) -> tuple[np.ndarray, int]: | |
| """Liest WAV/MP3/FLAC/OGG → float32 (channels, samples), max. Stereo.""" | |
| with AudioFile(str(path)) as f: | |
| data = f.read(f.frames) | |
| sr = int(f.samplerate) | |
| if data.shape[0] == 1: | |
| data = np.vstack([data, data]) | |
| return np.ascontiguousarray(data[:2], dtype=np.float32), sr | |
| def save(path: str | Path, data: np.ndarray, sr: int, *, quality: Any = None) -> Path: | |
| path = Path(path) | |
| data = np.nan_to_num(np.asarray(data, dtype=np.float32)) | |
| kwargs = {"quality": quality} if quality is not None and path.suffix == ".mp3" else {} | |
| with AudioFile(str(path), "w", samplerate=sr, num_channels=data.shape[0], **kwargs) as f: | |
| f.write(data) | |
| return path | |
| def db(x: float) -> float: | |
| return 20 * math.log10(max(float(x), 1e-9)) | |
| def peak_db(data: np.ndarray) -> float: | |
| return db(np.max(np.abs(data))) if data.size else -120.0 | |
| def lufs(data: np.ndarray, sr: int) -> float: | |
| import pyloudnorm as pyln | |
| if data.shape[1] < int(0.45 * sr): | |
| return float("-inf") | |
| return float(pyln.Meter(sr).integrated_loudness(data.T.astype(np.float64))) | |
| def true_peak_db(data: np.ndarray) -> float: | |
| """True-Peak nach ITU-R BS.1770-4 (4× Oversampling, polyphaser FIR) in dBTP.""" | |
| if not data.size: | |
| return -120.0 | |
| from scipy.signal import resample_poly | |
| x = np.asarray(data, dtype=np.float64) | |
| if x.ndim == 1: | |
| x = x[None, :] | |
| peak = 0.0 | |
| step = 1 << 20 # blockweise → konstanter Speicher | |
| for s in range(0, x.shape[1], step): | |
| blk = x[:, max(0, s - 64):s + step + 64] | |
| peak = max(peak, float(np.max(np.abs(resample_poly(blk, 4, 1, axis=1, window=("kaiser", 8.0)))))) | |
| return db(max(peak, float(np.max(np.abs(x))))) | |
| def stats(data: np.ndarray, sr: int) -> dict[str, Any]: | |
| lv = lufs(data, sr) | |
| return {"peak_db": round(peak_db(data), 2), "true_peak_db": round(true_peak_db(data), 2), | |
| "lufs": None if not math.isfinite(lv) else round(lv, 2), | |
| "duration_s": round(data.shape[1] / sr, 3), "sample_rate": sr} | |
| # ------------------------------------------------------------------ VST3 | |
| def _plugin(file: str, name: str | None = None): | |
| path = PLUGIN_DIR / file | |
| if not path.exists() or os.environ.get("DAW_DISABLE_VST") == "1": | |
| return None | |
| try: | |
| return pb.load_plugin(str(path), plugin_name=name) if name else pb.load_plugin(str(path)) | |
| except Exception: # noqa: BLE001 – fehlende Systembibliotheken → Built-in-Fallback | |
| return None | |
| def plugin_status() -> dict[str, bool]: | |
| return { | |
| "LSP Compressor": _plugin("lsp-plugins.vst3", "Compressor Stereo") is not None, | |
| "LSP Limiter": _plugin("lsp-plugins.vst3", "Limiter Stereo") is not None, | |
| "Dragonfly Hall": _plugin("DragonflyHallReverb.vst3") is not None, | |
| "Dragonfly Plate": _plugin("DragonflyPlateReverb.vst3") is not None, | |
| } | |
| def _set(plugin: Any, **values: Any) -> None: | |
| for key, value in values.items(): | |
| try: | |
| setattr(plugin, key, value) | |
| except Exception: # noqa: BLE001 | |
| pass | |
| def _run(plugin: Any, data: np.ndarray, sr: int, flush_s: float = 1.0) -> np.ndarray: | |
| """VST3 aus Worker-Threads: kein reset() (nur Main-Thread) → Stille vorweg zum Leeren, | |
| Latenz (Lookahead) über reported_latency_samples kompensieren.""" | |
| with _LOCK: # Plugin-Instanzen sind nicht threadsicher | |
| n, flush = data.shape[1], int(flush_s * sr) | |
| lat = int(getattr(plugin, "reported_latency_samples", 0) or 0) | |
| padded = np.concatenate([np.zeros((data.shape[0], flush), np.float32), data, | |
| np.zeros((data.shape[0], lat + 64), np.float32)], axis=1) | |
| out = plugin(padded, sr, reset=False) | |
| return np.ascontiguousarray(out[:, flush + lat:flush + lat + n]) | |
| def preload() -> None: | |
| """Muss im Main-Thread laufen (VST3-Laden).""" | |
| for args in (("lsp-plugins.vst3", "Compressor Stereo"), ("lsp-plugins.vst3", "Limiter Stereo"), | |
| ("DragonflyHallReverb.vst3",), ("DragonflyPlateReverb.vst3",)): | |
| _plugin(*args) | |
| # ------------------------------------------------------------------ Effekte | |
| def fx_normalize(data, sr, peak=-1.0, **_): | |
| p = np.max(np.abs(data)) | |
| return data if p <= 0 else data * (10 ** (float(peak) / 20) / p), "Built-in" | |
| def fx_limiter(data, sr, ceiling=-1.0, release=80.0, **_): | |
| plug = _plugin("lsp-plugins.vst3", "Limiter Stereo") | |
| if plug is not None: | |
| _set(plug, threshold_db=float(ceiling), release_time_ms=float(release), lookahead_ms=5.0) | |
| out = np.clip(_run(plug, data, sr), -1, 1) | |
| want = min(peak_db(data), float(ceiling)) # Pegel halten, nur Spitzen begrenzen | |
| out = out * 10 ** ((want - peak_db(out)) / 20) | |
| return out, "VST3 · LSP Limiter" | |
| out = pb.Pedalboard([pb.Limiter(threshold_db=float(ceiling), release_ms=float(release))])(data, sr) | |
| return out, "Built-in Limiter" | |
| def fx_lufs(data, sr, target=-14.0, ceiling=-1.0, **_): | |
| import pyloudnorm as pyln | |
| current = lufs(data, sr) | |
| if not math.isfinite(current): | |
| return data, "Built-in (zu kurz für LUFS)" | |
| out = pyln.normalize.loudness(data.T.astype(np.float64), current, float(target)).T.astype(np.float32) | |
| if peak_db(out) > float(ceiling): | |
| out, eng = fx_limiter(out, sr, ceiling=ceiling) | |
| return out, f"pyloudnorm + {eng}" | |
| return out, "pyloudnorm (EBU R128)" | |
| def fx_compressor(data, sr, threshold=-18.0, ratio=4.0, attack=10.0, release=120.0, makeup=0.0, **_): | |
| plug = _plugin("lsp-plugins.vst3", "Compressor Stereo") | |
| if plug is not None: | |
| _set(plug, attack_threshold_db=float(threshold), ratio=float(ratio), attack_time_ms=float(attack), | |
| release_time_ms=float(release), makeup_gain_db=float(makeup), knee_db=-6.0) | |
| return _run(plug, data, sr), "VST3 · LSP Compressor" | |
| board = pb.Pedalboard([pb.Compressor(threshold_db=float(threshold), ratio=float(ratio), attack_ms=float(attack), | |
| release_ms=float(release)), pb.Gain(gain_db=float(makeup))]) | |
| return board(data, sr), "Built-in Compressor" | |
| def fx_dyncomp(data, sr, target=-18.0, amount=0.6, window_ms=60.0, lookahead_ms=30.0, **_): | |
| """Dynamic Compressor (Audacity-artig): RMS-Leveler mit Lookahead, hebt Leises, senkt Lautes.""" | |
| mono = np.mean(np.abs(data), axis=0) | |
| win = max(1, int(sr * float(window_ms) / 1000)) | |
| kernel = np.ones(win) / win | |
| rms = np.sqrt(np.convolve(mono**2, kernel, mode="same") + 1e-12) | |
| env_db = 20 * np.log10(rms) | |
| gain_db = np.clip((float(target) - env_db) * float(amount), -24, 12) | |
| gain_db[env_db < -60] = 0.0 # Stille nicht hochziehen | |
| look = int(sr * float(lookahead_ms) / 1000) | |
| gain_db = np.roll(gain_db, -look) | |
| smooth = max(1, int(sr * 0.08)) | |
| gain_db = np.convolve(gain_db, np.ones(smooth) / smooth, mode="same") | |
| out = data * (10 ** (gain_db / 20))[None, :] | |
| out, _eng = fx_limiter(out.astype(np.float32), sr, ceiling=-1.0) | |
| return out, "Dynamic Compressor (Leveler) + Limiter" | |
| def fx_eq(data, sr, low=0.0, mid=0.0, mid_freq=1000.0, high=0.0, hp=0.0, **_): | |
| chain = [] | |
| if float(hp) > 10: | |
| chain.append(pb.HighpassFilter(cutoff_frequency_hz=float(hp))) | |
| chain += [pb.LowShelfFilter(cutoff_frequency_hz=120, gain_db=float(low), q=0.7), | |
| pb.PeakFilter(cutoff_frequency_hz=float(mid_freq), gain_db=float(mid), q=0.9), | |
| pb.HighShelfFilter(cutoff_frequency_hz=8000, gain_db=float(high), q=0.7)] | |
| return pb.Pedalboard(chain)(data, sr), "Built-in EQ (Biquad)" | |
| def fx_denoise(data, sr, strength=0.6, **_): | |
| """Spektrales Gate: Rauschprofil aus den leisesten 10 % Frames, weiche Subtraktion.""" | |
| n, hop = 2048, 512 | |
| win = np.hanning(n).astype(np.float32) | |
| out = np.zeros_like(data) | |
| for ch in range(data.shape[0]): | |
| x = np.pad(data[ch], (n, n)) | |
| frames = np.lib.stride_tricks.sliding_window_view(x, n)[::hop] * win | |
| spec = np.fft.rfft(frames, axis=1) | |
| mag = np.abs(spec) | |
| energy = mag.mean(axis=1) | |
| quiet = mag[energy <= np.quantile(energy, 0.1)] | |
| noise = quiet.mean(axis=0) if len(quiet) else mag.min(axis=0) | |
| gain = np.clip(1 - float(strength) * 1.5 * noise[None, :] / (mag + 1e-9), 0.05, 1.0) | |
| gain = np.apply_along_axis(lambda g: np.convolve(g, np.ones(5) / 5, "same"), 0, gain) | |
| y = np.fft.irfft(spec * gain, n=n, axis=1) * win | |
| acc = np.zeros(len(x) + n, dtype=np.float32) | |
| norm = np.zeros_like(acc) | |
| for i, frame in enumerate(y): | |
| acc[i * hop:i * hop + n] += frame | |
| norm[i * hop:i * hop + n] += win**2 | |
| res = acc / np.maximum(norm, 1e-6) | |
| out[ch] = res[n:n + data.shape[1]] | |
| return out, "Spektrale Rauschminderung" | |
| def fx_reverb(data, sr, mix=0.25, size=0.6, plate=False, **_): | |
| plug = _plugin("DragonflyPlateReverb.vst3" if plate else "DragonflyHallReverb.vst3") | |
| tail = np.zeros((data.shape[0], int(sr * 2.5)), dtype=np.float32) | |
| padded = np.concatenate([data, tail], axis=1) | |
| if plug is not None: | |
| _set(plug, dry_level=0.0, decay_s=0.6 + 4 * float(size), size_m=12 + 40 * float(size)) | |
| if not plate: | |
| _set(plug, late_level=100.0, early_level=30.0) | |
| wet = _run(plug, padded, sr, flush_s=5.0) | |
| eng = "VST3 · Dragonfly " + ("Plate" if plate else "Hall") | |
| else: | |
| wet = pb.Reverb(room_size=float(size), wet_level=1.0, dry_level=0.0)(padded, sr) | |
| eng = "Built-in Reverb" | |
| out = padded * (1 - float(mix) * 0.5) + wet * float(mix) | |
| # Hall-Ausklang abschneiden, wenn praktisch still | |
| keep = data.shape[1] + int(np.max(np.nonzero(np.max(np.abs(out[:, data.shape[1]:]), axis=0) > 1e-4)[0], initial=0)) | |
| return out[:, :keep], eng | |
| def fx_gain(data, sr, gain=0.0, **_): | |
| return data * 10 ** (float(gain) / 20), "Built-in" | |
| def fx_reverse(data, sr, **_): | |
| return data[:, ::-1].copy(), "Built-in" | |
| def fx_fade(data, sr, fade_in=0.0, fade_out=0.0, **_): | |
| out = data.copy() | |
| n_in, n_out = int(float(fade_in) * sr), int(float(fade_out) * sr) | |
| if n_in > 0: | |
| out[:, :n_in] *= np.linspace(0, 1, min(n_in, out.shape[1]))[None, :] | |
| if n_out > 0: | |
| out[:, -n_out:] *= np.linspace(1, 0, min(n_out, out.shape[1]))[None, :] | |
| return out, "Built-in" | |
| EFFECTS = { | |
| "normalize": fx_normalize, "lufs": fx_lufs, "compressor": fx_compressor, "dyncomp": fx_dyncomp, | |
| "limiter": fx_limiter, "eq": fx_eq, "denoise": fx_denoise, "reverb": fx_reverb, "gain": fx_gain, | |
| "reverse": fx_reverse, "fade": fx_fade, | |
| } | |
| def apply_effect(data: np.ndarray, sr: int, effect: str, params: dict[str, Any]) -> tuple[np.ndarray, str]: | |
| if effect not in EFFECTS: | |
| raise ValueError(f"Unbekannter Effekt: {effect}") | |
| out, engine = EFFECTS[effect](data.astype(np.float32), sr, **params) | |
| return np.nan_to_num(np.asarray(out, dtype=np.float32)), engine | |
| # ------------------------------------------------------------------ Fit & Prozedural | |
| def fit(data: np.ndarray, sr: int, seconds: float | None, *, loop: bool = False, fade: float = 0.02) -> np.ndarray: | |
| if not seconds or seconds <= 0: | |
| return data | |
| n = int(seconds * sr) | |
| if data.shape[1] >= n: | |
| out = data[:, :n].copy() | |
| elif loop and data.shape[1] > sr // 2: | |
| reps = int(math.ceil(n / data.shape[1])) | |
| out = np.tile(data, (1, reps))[:, :n].copy() | |
| else: | |
| out = np.concatenate([data, np.zeros((data.shape[0], n - data.shape[1]), np.float32)], axis=1) | |
| f = min(int(fade * sr), out.shape[1] // 4) | |
| if f > 0: | |
| out[:, :f] *= np.linspace(0, 1, f)[None, :] | |
| out[:, -f:] *= np.linspace(1, 0, f)[None, :] | |
| return out | |
| def stretch_to_bpm(data: np.ndarray, sr: int, src_bpm: float | None, dst_bpm: float | None) -> np.ndarray: | |
| if not src_bpm or not dst_bpm: | |
| return data | |
| ratio = float(dst_bpm) / float(src_bpm) | |
| for cand in (ratio, ratio * 2, ratio / 2): | |
| if 0.85 <= cand <= 1.15: | |
| if abs(cand - 1) < 0.01: | |
| return data | |
| return pb.time_stretch(data, sr, stretch_factor=cand).astype(np.float32) | |
| return data | |
| def procedural(kind: str, seconds: float, sr: int = SR, seed: int = 0) -> np.ndarray: | |
| """Lizenzfreie, synthetisierte Übergänge/SFX: riser, downlifter, impact, whoosh, noise.""" | |
| rng = np.random.default_rng(seed or None) | |
| n = max(1, int(seconds * sr)) | |
| t = np.linspace(0, 1, n, dtype=np.float32) | |
| noise = rng.standard_normal((2, n)).astype(np.float32) | |
| if kind == "impact": | |
| env = np.exp(-t * 9) | |
| sub = np.sin(2 * np.pi * np.cumsum(np.linspace(90, 35, n)) / sr) | |
| y = (0.9 * sub[None, :] + 0.35 * noise * np.exp(-t * 30)[None, :]) * env[None, :] | |
| y = pb.Pedalboard([pb.Reverb(room_size=0.8, wet_level=0.35)])(y.astype(np.float32), sr) | |
| else: | |
| up = kind != "downlifter" | |
| curve = t if up else 1 - t | |
| cutoff_env = 200 + 9000 * curve**2 | |
| board_out = np.zeros_like(noise) | |
| blocks = 32 | |
| for b in range(blocks): | |
| s, e = b * n // blocks, (b + 1) * n // blocks | |
| fc = float(cutoff_env[(s + e) // 2]) | |
| board_out[:, s:e] = pb.Pedalboard([pb.LowpassFilter(cutoff_frequency_hz=fc)])(noise[:, s:e], sr) | |
| tone = np.sin(2 * np.pi * np.cumsum(220 * 2 ** (2 * (curve if up else curve))) / sr) * 0.25 | |
| amp = (curve**1.5) if up else (1 - t) ** 1.5 | |
| if kind == "whoosh": | |
| amp = np.sin(np.pi * t) ** 2 | |
| tone *= 0 | |
| y = (board_out * 0.6 + tone[None, :]) * amp[None, :] | |
| y = pb.Pedalboard([pb.Reverb(room_size=0.7, wet_level=0.3), pb.Delay(delay_seconds=0.18, feedback=0.25, mix=0.2)])(y.astype(np.float32), sr)[:, :n] | |
| y = y / max(1e-6, np.max(np.abs(y))) * 0.8 | |
| return y.astype(np.float32) | |
| def procedural_kind(prompt: str) -> str: | |
| p = (prompt or "").lower() | |
| for kind, words in (("impact", ("impact", "hit", "boom", "gunshot", "schuss", "explosion", "drop")), | |
| ("downlifter", ("down", "fall", "abwärts")), ("whoosh", ("whoosh", "swoosh", "wind", "train", "zug"))): | |
| if any(w in p for w in words): | |
| return kind | |
| return "riser" | |
| def mix_crossfade(a: np.ndarray, b: np.ndarray, sr: int, seconds: float) -> np.ndarray: | |
| n = min(int(seconds * sr), a.shape[1], b.shape[1]) | |
| if n <= 0: | |
| return np.concatenate([a, b], axis=1) | |
| t = np.linspace(0, np.pi / 2, n) | |
| xf = a[:, -n:] * np.cos(t)[None, :] + b[:, :n] * np.sin(t)[None, :] | |
| return np.concatenate([a[:, :-n], xf, b[:, n:]], axis=1) | |