"""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 @lru_cache(maxsize=8) 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)