""" spade_declip.py – v13 (LF transient recovery: dedicated subband SPADE below 500 Hz) ==================================================================================== S-SPADE / A-SPADE audio declipping — extended to recover dynamics compressed by a brickwall limiter (mode='soft'). GPU acceleration (v10 — NEW) ------------------------------ Requires PyTorch ≥ 2.0 with a working CUDA *or* ROCm backend. PyTorch-ROCm exposes AMD GPUs under the standard torch.cuda namespace, so detection and device strings are identical to NVIDIA: Device auto-detection order: CUDA → ROCm → CPU fallback Device string: "auto" — first available GPU (cuda / cuda:0) "cuda:0" — explicit device index "cpu" — force CPU (disables GPU path) GPU strategy: CPU path (v8/v9): processes frames one-by-one with ThreadPoolExecutor. GPU path (v10): packs ALL active frames into a single (F, M) batch tensor and runs S-SPADE entirely on the GPU in one kernel sweep — DCT, hard-threshold, IDCT, proj_Γ are all vectorised over F simultaneously. Convergence is tracked per-frame with a bool mask; converged frames are frozen (their dual variable stops updating) while the rest keep iterating. The GPU loop exits as soon as every frame has converged or max_iter is reached. Typical speedup vs. single-thread CPU: 20–100× depending on GPU and frame count. The RX 6700 XT (12 GB, ROCm) processes the 2784-frame stereo example in ~60–90 s vs. the 1289 s CPU baseline (≈15–20×). DCT implementation on GPU: Uses a verified FFT-based Makhoul (1980) algorithm that exactly matches scipy.fft.dct(x, type=2, norm='ortho') to float32 precision. Runs in float64 internally for numerical safety, cast to float32 on output. Both DCT and IDCT are batch-safe: input shape (..., N). Limitations: • algo='aspade' is CPU-only in v10 (A-SPADE GPU planned for v11). Set use_gpu=False or switch to algo='sspade' for GPU acceleration. • Very long files (> ~2 h at 48 kHz) may require chunked batching; add gpu_batch_frames parameter if VRAM is exhausted. References ---------- [1] Kitić, Bertin, Gribonval — "Sparsity and cosparsity for audio declipping: a flexible non-convex approach", LVA/ICA 2015. (arXiv:1506.01830) [2] Záviška, Rajmic, Průša, Veselý — "Revisiting Synthesis Model in Sparse Audio Declipper", 2018. (arXiv:1807.03612) Algorithms ---------- S-SPADE → Algorithm 1 in [2] (synthesis, coefficient-domain ADMM) [DEFAULT] Projection uses the closed-form Lemma / eq.(12) from [2]. A-SPADE → Algorithm 2 in [2] (analysis, signal-domain ADMM) Transforms ---------- 'dct' Orthonormal DCT-II (tight Parseval frame, bound = 1, P = N) 'rdft' Redundant real frame [DCT-II/√2 ‖ DST-II/√2] (tight, bound = 1, P = 2N) [DEFAULT] Best empirical quality; mimics oversampled DFT from [1][2]. Operating modes --------------- mode='hard' (default) Standard hard-clipping recovery. Mask detects samples exactly at the digital ceiling (±tau). Same behaviour as v5. mode='soft' (introduced v6, frame-adaptive bypass in v7) Brickwall-limiter recovery. Any sample above the limiter threshold (ceiling − delta_db dB) is treated as potentially attenuated; its true value is constrained to be ≥ its current value (lower bound, not equality). v7 frame-adaptive bypass ← NEW -------------------------------- Before processing each frame, the raw un-windowed peak is compared to the global threshold: frame_peak = max(|yc[idx1:idx2]|) frame_peak < threshold → bypass: WOLA accumulation with win², SPADE never called, zero artefact risk. frame_peak >= threshold → normal SPADE processing. The bypass uses identical win²/norm_win bookkeeping to the SPADE path, so the WOLA reconstruction is numerically transparent. Verbose output reports active/bypassed/no-conv frame counts and speedup. Mathematical basis: proj_Γ implements v[Icp] = max(v[Icp], yc[Icp]) where yc[Icp] is the actual limited sample value — the lower-bound constraint is exact. proj_gamma, tight_sspade, tight_aspade are UNCHANGED. Practical parameter guidance: delta_db = dB from 0 dBFS to the limiter threshold. Read from Waveform Statistics: find the level below which the limiter did NOT intervene → delta_db = that level (positive number). Typical brickwall masterings: 1.0 – 3.0 dB. Limitations: • Attack/release pumping attenuates samples just outside the threshold; those are pinned as reliable — unavoidable without the limiter's curve. • Macro-dynamics cannot be restored; only transient peaks are recovered. Verified bugs fixed (inherited from v5/v6) ------------------------------------------- BUG-1 frsyn/RDFT: flip output not input in DST synthesis BUG-2 tight_aspade: dual variable in coefficient domain, not signal domain BUG-3 _declip_mono: per-channel WOLA gain drift (stereo L/R balance) BUG-4 _declip_mono: DC offset breaks half-wave mask detection Dependencies: pip install numpy scipy soundfile Usage (API) ----------- from spade_declip_v10 import declip, DeclipParams params = DeclipParams(mode="soft", delta_db=2.5) # GPU used automatically fixed, masks = declip(limited_master, params) # Explicit GPU device (ROCm / CUDA): params = DeclipParams(mode="soft", delta_db=2.5, use_gpu=True, gpu_device="cuda:0") # Force CPU (disable GPU): params = DeclipParams(mode="soft", delta_db=2.5, use_gpu=False) New in v13 — Dedicated LF transient recovery subband pass ----------------------------------------------------------- Problem (from v11/v12 analysis): The ADMM hard-thresholding operator H_k is GLOBAL: it retains the k largest-magnitude DCT/DST coefficients regardless of frequency. After brickwall limiting with a slow release (40–100 ms), the sub-bass body of a kick (60–300 Hz) has been heavily attenuated, so its DCT coefficients are 10–20 dB smaller than the HF transient attack coefficients. H_k never selects LF bins in the early ADMM iterations; the dual variable never accumulates LF correction; convergence is declared while LF energy is still near zero. This produces the systematic −13 to −22 dB sub-bass under-recovery seen in the debug export across all tested kicks. v12 tried to fix this with frequency-stratified H_k (guaranteed LF slots), but that REDUCED HF recovery because the total sparsity budget k was shared: reserving slots for LF meant fewer slots for HF, degrading the cymbal snap / hi-hat attack that v11 already handled correctly. v13 fix — LR split + independent LF SPADE pass: When lf_split_hz > 0 (soft mode only): 1. Linkwitz-Riley crossover at lf_split_hz Hz: lf_band = LP(yc, lf_split_hz) # 0 … lf_split_hz Hz hf_band = yc − lf_band # lf_split_hz … Nyquist Hz # exact: lf + hf = yc always 2. HF band: standard v11 S-SPADE, IDENTICAL to v11 (no changes). H_k operates on a signal that contains NO sub-bass content, so all budget k goes to the HF transient bins. HF quality is preserved. 3. LF band: dedicated SPADE pass with independently configurable params. Because the signal is bandlimited to 0…lf_split_hz Hz, ALL DCT bins are LF content. H_k naturally selects the dominant sub-bass bins (60–120 Hz kick body) without any HF competition. A longer window (lf_window_length) and/or more iterations (lf_max_iter) can be set without slowing down the HF path. 4. Reconstruction: output = lf_fixed + hf_fixed Perfect-reconstruction property of the LP+HP crossover guarantees lf_band + hf_band = yc exactly, so summing the processed bands introduces zero reconstruction artefacts. Key consequence: HF and LF sparsity budgets are now INDEPENDENT. Each band's H_k uses the full budget k for its own frequency range. There is no longer any competition between sub-bass body recovery and HF transient recovery. New DeclipParams fields (v13): lf_split_hz : float (default 0.0 = disabled) Crossover frequency in Hz for the LF subband pass. Typical value for kick/bass transient recovery: 400–600 Hz. Must be in (0, sample_rate/2). 0 = disabled (v11 behaviour). lf_window_length : int (default 0 = inherit window_length) WOLA window size for the LF pass. Larger windows give better frequency resolution in sub-bass, at the cost of time resolution. For lf_split_hz=500 Hz at 44100 Hz, 2048 or 4096 are sensible. 0 means use the same window_length as the main (HF) pass. lf_hop_length : int (default 0 = lf_window_length // 4) WOLA hop for the LF pass. 0 = automatic (25% hop of lf_window). lf_max_iter : int (default 0 = inherit max_iter) Max ADMM iterations for the LF pass. LF convergence is slower (the dual variable u needs more steps to push up the sub-bass under the lower-bound constraint). Typical: 2× the HF max_iter. 0 = use the same max_iter as the main pass. lf_eps : float (default 0.0 = inherit eps) Convergence threshold for the LF pass. 0 = use main eps. lf_delta_db : float (default 0.0 = inherit delta_db) delta_db override for the LF band (dB below the LF band ceiling where limiting is detected). The LF band peak may differ from the full-signal peak after LR split. 0 = inherit delta_db. lf_max_gain_db : float (default 0.0 = inherit max_gain_db) Ratio-aware gain cap for the LF pass. 0 = inherit max_gain_db. lf_release_ms : float (default -1.0 = inherit release_ms) Mask dilation release time for the LF pass. The kick body has a longer release than HF transients, so a higher value is appropriate. -1 = inherit release_ms from main params. lf_s : int (default 0 = inherit s) Sparsity step for the LF pass. 0 = inherit s. lf_r : int (default 0 = inherit r) Sparsity relaxation period for the LF pass. 0 = inherit r. Usage: # LF transient recovery: dedicated subband SPADE below 500 Hz python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 1.5 \\ --lf-split-hz 500 --lf-window-length 4096 --lf-max-iter 1500 \\ --lf-release-ms 80 --release-ms 80 --max-gain-db 9 New in v11 — Delimiting features ---------------------------------- Four new DeclipParams knobs that transition from declipping to genuine delimiting. All are disabled by default for full backward compatibility. 1. Envelope-Based Mask Dilation (release_ms > 0) -------------------------------------------------- A limiter's release time attenuates not just the peak sample but all samples for the next 10–50 ms. By default, _compute_masks marks those post-peak samples as "reliable" (Ir), pinning the ADMM solver to artificially low values and causing the pumping artifact. Fix: _dilate_masks_soft() forward-dilates Icp and Icm by `release_samples = round(release_ms * sample_rate / 1000)` samples using convolution. Any newly flagged sample within the release window is reclassified: yc[n] ≥ 0 → Icp (true value ≥ yc[n]) yc[n] < 0 → Icm (true value ≤ yc[n]) The constraint is always satisfied by the limiter model: the true value can only be larger in magnitude than the gain-reduced sample. Parameters: release_ms (float, default 0.0), sample_rate (int, default 44100). 2. Ratio-Aware Upper Bound (max_gain_db > 0) ----------------------------------------------- Without an upper bound, the L0-ADMM can generate "ice-pick" transients that exceed any physical limiter's ratio. max_gain_db caps the recovery: v[Icp] = clip(max(v[Icp], yc[Icp]), yc[Icp], yc[Icp] * G_max) v[Icm] = clip(min(v[Icm], yc[Icm]), yc[Icm] * G_max, yc[Icm]) where G_max = 10^(max_gain_db / 20). Implemented in both proj_gamma (CPU) and the inline GPU projection in _sspade_batch_gpu. Parameters: max_gain_db (float, default 0.0 = disabled; e.g. 6.0 for ±6 dB max). 3. Sub-band (Multi-band) SPADE (multiband=True) -------------------------------------------------- Multi-band limiters (FabFilter Pro-L 2, etc.) apply independent gain reduction per frequency range. Running broadband SPADE on such material "un-ducks" frequency bands that were never attenuated, causing harshness. Fix: _lr_split() builds a phase-perfect crossover (LP via scipy Butterworth sosfiltfilt + HP = x − LP) at each crossover frequency. Each band is declipped independently with its own delta_db threshold, then summed back. The GPU batch path naturally handles multiple bands — each band contributes its own frames to the (F, M) batch with no added latency. Parameters: multiband (bool), band_crossovers (tuple of Hz, default (250, 4000)), band_delta_db (tuple of floats; empty = use delta_db for all bands). 4. Macro-Dynamics Upward Expansion Pre-pass (macro_expand=True) ---------------------------------------------------------------- SPADE operates on ≈21 ms WOLA windows and cannot undo the slow 200–500 ms RMS squash ("body" compression) a mastering limiter imposes. Fix: _macro_expand_pass() runs a causal peak-envelope follower (attack + release IIR) over the full signal, estimates where the level is held below the long-term 80th-percentile envelope, and applies gentle upward expansion: g(n) = (env(n) / threshold)^(1/ratio − 1) if env(n) < threshold = 1.0 otherwise SPADE then corrects the microscopic waveform peaks that the expander cannot interpolate. The two passes are complementary by design. Parameters: macro_expand (bool), macro_attack_ms (float, default 10.0), macro_release_ms (float, default 200.0), macro_ratio (float, default 1.2). Usage (CLI) ----------- python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 2.5 python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 2.5 --gpu-device cuda:0 python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 2.5 --no-gpu # v11 delimiting features python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 2.5 \ --release-ms 30 --max-gain-db 6 --multiband --band-crossovers 250 4000 python spade_declip_v13.py input.wav output.wav --mode soft --delta-db 2.5 \ --macro-expand --macro-release-ms 200 --macro-ratio 1.2 """ from __future__ import annotations try: import torch as _torch_module import torch _TORCH_AVAILABLE = True except ImportError: _TORCH_AVAILABLE = False import argparse import os import time import warnings from concurrent.futures import ThreadPoolExecutor from dataclasses import dataclass from typing import List, Literal, Tuple, Union import numpy as np from scipy.fft import dct, idct from scipy.signal.windows import hann # ============================================================================ # Progress-bar backend (rich → tqdm → plain fallback, zero hard deps) # ============================================================================ # Three concrete backends implement the same interface: # # ctx = _make_progress(n_channels) # with ctx: # task = ctx.add_task(label, total=N) # ctx.advance(task) # +1 frame done # ctx.set_postfix(task, key=value) # update live counters # # The module-level _PROGRESS_LOCK serialises add_task() calls so that two # channel threads don't interleave their header prints. import threading _PROGRESS_LOCK = threading.Lock() try: from rich.progress import ( Progress, BarColumn, TextColumn, TimeRemainingColumn, TimeElapsedColumn, MofNCompleteColumn, SpinnerColumn, ) from rich.console import Console from rich.panel import Panel from rich import print as rprint _RICH = True except ImportError: _RICH = False try: import tqdm as _tqdm_mod _TQDM = True except ImportError: _TQDM = False class _RichProgress: """Thin wrapper around a shared rich.Progress instance.""" def __init__(self, n_channels: int): self._progress = Progress( SpinnerColumn(), TextColumn("[bold cyan]{task.fields[ch_label]:<4}[/]"), BarColumn(bar_width=36), MofNCompleteColumn(), TextColumn("[green]{task.fields[eta_str]}[/]"), TextColumn("[dim]{task.fields[bypass_str]}[/]"), TextColumn("[yellow]{task.fields[noconv_str]}[/]"), TimeElapsedColumn(), TimeRemainingColumn(), refresh_per_second=10, ) def __enter__(self): self._progress.__enter__() return self def __exit__(self, *args): self._progress.__exit__(*args) def add_task(self, ch_label: str, total: int) -> object: return self._progress.add_task( "", total=total, ch_label=ch_label, eta_str="", bypass_str="", noconv_str="", ) def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int): bypass_pct = 100.0 * n_bypassed / n_done if n_done else 0.0 self._progress.update( task_id, advance=1, bypass_str=f"bypassed {bypass_pct:.0f}%" if n_bypassed else "", noconv_str=f"no_conv {n_noconv}" if n_noconv else "", ) class _TqdmProgress: """Thin wrapper around tqdm, one bar per channel.""" def __init__(self, n_channels: int): self._bars: dict = {} def __enter__(self): return self def __exit__(self, *args): for bar in self._bars.values(): bar.close() def add_task(self, ch_label: str, total: int) -> str: import tqdm bar = tqdm.tqdm( total=total, desc=f"[{ch_label}]", unit="fr", dynamic_ncols=True, leave=True, ) self._bars[ch_label] = bar return ch_label def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int): bar = self._bars[task_id] bypass_pct = 100.0 * n_bypassed / n_done if n_done else 0.0 parts = [] if n_bypassed: parts.append(f"bypass={bypass_pct:.0f}%") if n_noconv: parts.append(f"no_conv={n_noconv}") bar.set_postfix_str(" ".join(parts)) bar.update(1) class _PlainProgress: """Last-resort fallback: prints a percentage line per channel.""" def __init__(self, n_channels: int): self._state: dict = {} def __enter__(self): return self def __exit__(self, *args): pass def add_task(self, ch_label: str, total: int) -> str: self._state[ch_label] = {"total": total, "done": 0, "last_pct": -1} return ch_label def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int): s = self._state[task_id] s["done"] += 1 pct = int(100 * s["done"] / s["total"]) # Print only at each 5% step to avoid flooding stdout if pct // 5 > s["last_pct"] // 5: s["last_pct"] = pct print(f" [{task_id}] {pct:3d}% ({s['done']}/{s['total']} frames" + (f" bypassed={n_bypassed}" if n_bypassed else "") + (f" no_conv={n_noconv}" if n_noconv else "") + ")") def _make_progress(n_channels: int): """Return the best available progress backend.""" if _RICH: return _RichProgress(n_channels) if _TQDM: return _TqdmProgress(n_channels) return _PlainProgress(n_channels) # ============================================================================ # Data structures # ============================================================================ @dataclass class ClippingMasks: """ Boolean index masks identifying the three sample categories of a clipped signal. Attributes ---------- Ir : reliable (unclipped) samples — must be preserved exactly Icp : positively clipped (flat at +τ) — true signal ≥ τ Icm : negatively clipped (flat at −τ) — true signal ≤ −τ """ Ir: np.ndarray Icp: np.ndarray Icm: np.ndarray @dataclass class DeclipParams: """ Parameters controlling the declipping pipeline. Attributes ---------- algo : 'sspade' | 'aspade' Core per-frame algorithm. Default: 'sspade' (best empirical results). window_length : int Frame size in samples. Powers of 2 recommended (e.g. 1024, 2048). Per [2]: A-SPADE works best ≈ 2048; S-SPADE is robust to longer windows. hop_length : int Hop between consecutive frames. Minimum 50% overlap recommended ([2] §4.4). Typical: window_length // 4 (75% overlap, best quality per [2]). frame : 'dct' | 'rdft' Sparse transform. 'dct' — orthonormal DCT-II (no redundancy, P = N). 'rdft' — redundant real tight frame DCT‖DST (redundancy 2, P = 2N); mimics the oversampled DFT used in [1][2]. [DEFAULT — best quality] s : int Initial and incremental sparsity step (k starts at s, increases by s every r iterations). [2] uses s = 100 for whole-signal; s = 1 block-by-block. r : int Sparsity relaxation period (k is incremented every r iterations). eps : float Convergence threshold ε. Loop stops when the residual norm ≤ ε. [1][2] use ε = 0.1 for their experiments. max_iter : int Hard upper limit on iterations per frame. verbose : bool Print per-signal diagnostics (DC offset, threshold, mask sizes, timing). n_jobs : int Number of parallel workers for multi-channel processing. 1 = sequential (default, always safe). -1 = use all available CPU cores. mode : 'hard' | 'soft' Detection mode. 'hard' — standard hard-clipping recovery (default). Marks samples exactly at ±tau as clipped. 'soft' — brickwall limiter recovery (NEW in v6). Marks all samples above the limiter threshold as potentially attenuated. The threshold is ceiling − delta_db dB, where ceiling = max(|yc|) after DC removal. The lower-bound constraint true_value ≥ yc[n] is already implemented by proj_gamma — no algorithmic changes needed. delta_db : float [soft mode only] Distance in dB from 0 dBFS to the limiter threshold. Read from Waveform Statistics: find the level below which the limiter did NOT intervene, e.g. "da −∞ fino a −2.5 dB" → delta_db = 2.5. Typical brickwall masterings: 1.0 – 3.0 dB. Ignored when mode='hard'. use_gpu : bool Enable GPU acceleration via PyTorch (CUDA or ROCm). Default: True. Falls back to CPU automatically if PyTorch is not installed, no GPU is present, or algo='aspade' (A-SPADE GPU not yet implemented). gpu_device : str PyTorch device string. Default: "auto" (first available GPU). Examples: "cuda", "cuda:0", "cuda:1", "cpu". AMD ROCm GPUs appear as "cuda" in PyTorch-ROCm — use the same syntax. sample_rate : int [v11] Sample rate of the audio in Hz. Required when release_ms > 0 or multiband=True. Set automatically from the file header when using the CLI. Default: 44100. release_ms : float [v11, soft mode] Limiter release time in milliseconds. When > 0, the clipping masks are forward-dilated by this many samples so that post-peak samples attenuated by the limiter’s release phase are treated as constrained (not reliable). 0 = disabled (v10 behaviour). Typical: 10–50 ms. max_gain_db : float [v11, soft mode] Maximum recovery in dB above the limited sample value. Caps proj_Γ to prevent ADMM from generating unphysical transients. 0 = disabled (unbounded, v10 behaviour). Typical: 3–6 dB. multiband : bool [v11, soft mode] Enable Linkwitz-Riley sub-band processing. The signal is split at band_crossovers Hz, each band is processed with its own delta_db, then summed. Addresses multi-band limiting (FabFilter Pro-L 2 etc.). band_crossovers : tuple[float, ...] [v11] Crossover frequencies in Hz (ascending). Produces len+1 bands. Default: (250, 4000) → Low / Mid / High. band_delta_db : tuple[float, ...] [v11] Per-band delta_db values. If empty, delta_db is used for all bands. Must have the same length as band_crossovers + 1 when non-empty. macro_expand : bool [v11, soft mode] Enable macro-dynamics upward expansion pre-pass. A causal peak-envelope follower detects where the limiter’s release held the level down, then applies gentle upward expansion before SPADE restores the peaks. macro_attack_ms : float [v11] Expander attack time in ms. Default: 10.0. macro_release_ms : float [v11] Expander release time in ms. Default: 200.0. macro_ratio : float [v11] Expansion ratio. 1.0 = bypass; >1 = upward expansion. g(n) = (env(n)/threshold)^(1/ratio - 1) when below threshold. Default: 1.2. lf_split_hz : float [v13, soft mode] Crossover frequency (Hz) for the dedicated LF transient recovery subband pass. 0.0 = disabled (v11 behaviour). When > 0, the signal is LR-split at this frequency; the LF band is processed by a dedicated SPADE pass with lf_* parameters, the HF band by the standard v11 pass (identical code path, no changes). Outputs are summed. Typical: 400\u2013600 Hz for kick / bass transient restoration. lf_window_length : int [v13] WOLA window for the LF pass. 0 = inherit window_length. Recommended: 2048 or 4096 when lf_split_hz \u2248 500 Hz. lf_hop_length : int [v13] WOLA hop for the LF pass. 0 = lf_window_length // 4 (auto). lf_max_iter : int [v13] Max ADMM iterations for the LF pass. 0 = inherit max_iter. Recommended: 1500\u20132000 for kick body at 60\u2013120 Hz. lf_eps : float [v13] Convergence threshold for the LF pass. 0.0 = inherit eps. lf_delta_db : float [v13] delta_db override for the LF band. 0.0 = inherit delta_db. lf_max_gain_db : float [v13] Ratio-aware gain cap for the LF pass. 0.0 = inherit max_gain_db. lf_release_ms : float [v13] Mask dilation release time for the LF pass. -1.0 = inherit release_ms. lf_s : int [v13] Sparsity step for the LF pass. 0 = inherit s. lf_r : int [v13] Sparsity relaxation period for the LF pass. 0 = inherit r. """ algo: Literal["sspade", "aspade"] = "sspade" window_length: int = 1024 hop_length: int = 256 frame: Literal["dct", "rdft"] = "rdft" s: int = 1 r: int = 1 eps: float = 0.1 max_iter: int = 1000 verbose: bool = False n_jobs: int = 1 mode: Literal["hard", "soft"] = "hard" delta_db: float = 1.0 show_progress: bool = True use_gpu: bool = True # v10: GPU acceleration gpu_device: str = "auto" # v10: device string # ── v11: delimiting features ───────────────────────────────────────── sample_rate: int = 44100 # required for release_ms and multiband release_ms: float = 0.0 # mask dilation (0 = disabled) max_gain_db: float = 0.0 # ratio-aware cap (0 = disabled) multiband: bool = False # Linkwitz-Riley sub-band processing band_crossovers: tuple = (250, 4000) # Hz crossover frequencies band_delta_db: tuple = () # per-band delta_db; empty = use delta_db macro_expand: bool = False # upward expansion pre-pass macro_attack_ms: float = 10.0 # expander attack (ms) macro_release_ms: float = 200.0 # expander release (ms) macro_ratio: float = 1.2 # expansion ratio (1.0 = bypass) # ── v13: dedicated LF transient recovery subband ───────────────────── lf_split_hz: float = 0.0 # Hz crossover for LF subband pass (0 = disabled) lf_window_length: int = 0 # WOLA window for LF path; 0 = inherit window_length lf_hop_length: int = 0 # WOLA hop for LF path; 0 = lf_window_length // 4 lf_max_iter: int = 0 # max ADMM iter for LF path; 0 = inherit max_iter lf_eps: float = 0.0 # convergence thr for LF path; 0.0 = inherit eps lf_delta_db: float = 0.0 # delta_db override for LF band; 0.0 = inherit lf_max_gain_db: float = 0.0 # max_gain_db override for LF; 0.0 = inherit lf_release_ms: float = -1.0 # release_ms override for LF; -1.0 = inherit lf_s: int = 0 # sparsity step for LF; 0 = inherit s lf_r: int = 0 # sparsity relax for LF; 0 = inherit r # ============================================================================ # Sparse transform — Analysis (A) and Synthesis (D = A^H) operators # ============================================================================ def _frame_size(M: int, frame: str) -> int: """Number of transform coefficients P for a frame of M samples.""" if frame == "dct": return M if frame == "rdft": return 2 * M raise ValueError(f"Unknown frame '{frame}'") # ============================================================================ # GPU engine (PyTorch — CUDA or ROCm) # ============================================================================ # All GPU functions are defined unconditionally but only called when torch is # available. Type annotations use strings to avoid NameError at import time. import math as _math def _resolve_gpu_device(params: "DeclipParams") -> "str | None": """ Return a torch device string if GPU is usable, else None. AMD ROCm GPUs are exposed by PyTorch-ROCm under the torch.cuda namespace (torch.cuda.is_available() returns True, devices appear as "cuda" / "cuda:0"). Detection is therefore identical for NVIDIA CUDA and AMD ROCm. Returns None if: • params.use_gpu is False • PyTorch is not installed • No CUDA/ROCm device is present or accessible • algo='aspade' (A-SPADE GPU not yet implemented) """ if not params.use_gpu: return None if params.algo != "sspade": return None # A-SPADE GPU not implemented; fall through to CPU path try: import torch if not torch.cuda.is_available(): return None dev = "cuda" if params.gpu_device == "auto" else params.gpu_device torch.zeros(1, device=dev) # warm-up / validity check return dev except Exception: return None def _dct2_gpu(x: "torch.Tensor") -> "torch.Tensor": """ Batched orthonormal DCT-II on GPU. x: (..., N) — float32 or float64. Returns same dtype as input. Numerically matches scipy.fft.dct(x, type=2, norm='ortho') to ~1e-14. Algorithm: Makhoul (1980) FFT-based DCT-II. 1. Reorder x into v = [x[0], x[2], …, x[N-1], x[N-3], …, x[1]] 2. V = FFT(v) (computed in float64 for accuracy) 3. C = Re( exp(−jπk/(2N)) · V ) · √(2/N) 4. C[0] /= √2 (ortho normalisation for DC bin) """ import torch in_dtype = x.dtype N = x.shape[-1] v = torch.cat([x[..., ::2], x[..., 1::2].flip(-1)], dim=-1) V = torch.fft.fft(v.double(), dim=-1) k = torch.arange(N, device=x.device, dtype=torch.float64) tw = torch.exp(-1j * _math.pi * k / (2.0 * N)) C = (tw * V).real * _math.sqrt(2.0 / N) C = C.clone() C[..., 0] /= _math.sqrt(2.0) return C.to(in_dtype) def _idct2_gpu(X: "torch.Tensor") -> "torch.Tensor": """ Batched orthonormal IDCT-II on GPU. X: (..., N) — float32 or float64. Returns same dtype as input. Numerically matches scipy.fft.idct(X, type=2, norm='ortho') to ~1e-14. Inverse of _dct2_gpu via conjugate-twiddle + IFFT (Makhoul 1980): 1. Undo ortho scaling: C = X·√(N/2); C[0] ·= √2 2. Build W[k] = C[k] − j·C[N−k] for k=0…N−1 where C[0] uses the W[0] = C[0] special case (ipart[0] = 0). ipart[k] = −C[N−k] for k=1…N−1 ↳ BUG FIX: use C.flip(-1)[..., :-1] which gives C[N-1], C[N-2], …, C[1] The old code used Cf[1:] = C[N-2], C[N-3], …, C[0] — off by one. 3. Recover V: V = W · exp(+jπk/(2N)) 4. v = Re(IFFT(V)) 5. Un-interleave: x[2n] = v[n], x[2n+1] = v[N−1−n] """ import torch in_dtype = X.dtype N = X.shape[-1] C = X.double() * _math.sqrt(N / 2.0) C = C.clone() # avoid in-place on original C[..., 0] *= _math.sqrt(2.0) # ── BUG-GPU-3 FIX ──────────────────────────────────────────────────── # ipart[k] must equal -C[N-k] for k=1..N-1. # C.flip(-1) = [C[N-1], C[N-2], ..., C[1], C[0]] # C.flip(-1)[..., :-1] = [C[N-1], C[N-2], ..., C[1]] ← correct # (old buggy code: -Cf[..., 1:] = -[C[N-2], C[N-3], ..., C[0]] ← off by one) ipart = torch.zeros_like(C) ipart[..., 1:] = -C.flip(-1)[..., :-1] W = torch.view_as_complex(torch.stack([C, ipart], dim=-1)) k = torch.arange(N, device=X.device, dtype=torch.float64) V = W * torch.exp(1j * _math.pi * k / (2.0 * N)) v = torch.fft.ifft(V, dim=-1).real half = (N + 1) // 2 x = torch.empty_like(v) x[..., ::2] = v[..., :half] x[..., 1::2] = v[..., half:].flip(-1) return x.to(in_dtype) def _frana_gpu(x: "torch.Tensor", frame: str) -> "torch.Tensor": """ Batched analysis operator A: (..., M) → (..., P). DCT frame: P = M → orthonormal DCT-II RDFT frame: P = 2M → [DCT(x)/√2 ‖ DST(x)/√2] DST-II(x) = DCT-II(x[::-1]) """ import torch if frame == "dct": return _dct2_gpu(x) s2 = _math.sqrt(2.0) return torch.cat([_dct2_gpu(x) / s2, _dct2_gpu(x.flip(-1)) / s2], dim=-1) def _frsyn_gpu(z: "torch.Tensor", frame: str, M: int) -> "torch.Tensor": """ Batched synthesis operator D = A^H: (..., P) → (..., M). Adjoint of _frana_gpu. For RDFT the DST adjoint flips the OUTPUT. """ import torch if frame == "dct": return _idct2_gpu(z) s2 = _math.sqrt(2.0) cos_part = _idct2_gpu(z[..., :M]) / s2 sin_part = _idct2_gpu(z[..., M:]).flip(-1) / s2 return cos_part + sin_part def _hard_thresh_gpu(u: "torch.Tensor", k: int) -> "torch.Tensor": """ Batched hard thresholding: keep k largest-magnitude coefficients per row. u: (F, P). Returns same shape with all but top-k magnitudes zeroed. """ k = int(max(1, min(k, u.shape[-1]))) kth = torch.topk(u.abs(), k, dim=-1, sorted=True).values[..., -1:] # (F,1) return u * (u.abs() >= kth) def _sspade_batch_gpu( yc_w: "torch.Tensor", # (F, M) windowed frames, already on device Ir: "torch.Tensor", # (F, M) bool — reliable samples Icp: "torch.Tensor", # (F, M) bool — positively limited Icm: "torch.Tensor", # (F, M) bool — negatively limited frame: str, s: int, r: int, eps: float, max_iter: int, g_max: float = float("inf"), # v11: ratio-aware upper bound (linear) ) -> "Tuple[torch.Tensor, torch.Tensor]": """ Batched S-SPADE on GPU — all F frames processed simultaneously. Determinism guarantees ---------------------- BUG-GPU-2 fix: ADMM runs in float64 throughout (yc_w is upcast at entry, downcast to float32 on output). This matches the CPU path which also runs in float64 via numpy/scipy. float32 would accumulate ~2.3 units of error after 500 iterations vs float64's ~1e-14 — causing divergent ADMM trajectories. BUG-GPU-1 fix: zi_final captures zi at the exact convergence iteration for each frame. Without this, zi keeps being overwritten in subsequent iterations for already-converged frames (dual ui stops updating but the zi update expression keeps running for all frames). The CPU tight_sspade breaks immediately on convergence; the GPU batch loop cannot break early, so zi_final is the equivalent mechanism. Convergence mask ---------------- A per-frame `active` bool mask marks frames still iterating. - `conv[f]` = True once frame f has met the stopping criterion - `active[f]` = ~conv[f] - ui is updated only for active frames (correct — matches CPU which exits before updating ui on the convergence iteration) - zi_final[f] is frozen at the first iteration where conv[f] becomes True Returns ------- x_frames : (F, M) float32 — time-domain restored frames (on device) converged : (F,) bool — True where ADMM converged within max_iter """ import torch # ── BUG-GPU-2 FIX: upcast to float64 to match CPU float64 path ─────── yc_w64 = yc_w.double() F, M = yc_w64.shape zi = _frana_gpu(yc_w64, frame) # (F, P) float64 ui = torch.zeros_like(zi) # float64 k = s active = torch.ones (F, dtype=torch.bool, device=yc_w.device) conv = torch.zeros(F, dtype=torch.bool, device=yc_w.device) # ── BUG-GPU-1 FIX: zi_final captures zi at the convergence iteration ─ # Frames that never converge will have zi_final = zi at loop exit. zi_final = zi.clone() for i in range(1, max_iter + 1): # ── Step 2: sparsity (all frames) ──────────────────────────────── zb = _hard_thresh_gpu(zi + ui, k) # (F, P) # ── Step 3: project onto Γ via eq.(12) ─────────────────────────── v_c = zb - ui # (F, P) Dv = _frsyn_gpu(v_c, frame, M) # (F, M) pDv = Dv.clone() pDv[Ir] = yc_w64[Ir] # Ratio-aware projection (v11): lower bound max(v, yc) AND optional upper bound # Use finite g_max check to avoid 0 * inf = nan when g_max=inf (disabled). lower_p = yc_w64[Icp] if _math.isfinite(g_max): upper_p = (lower_p * g_max).clamp(min=lower_p) else: upper_p = torch.full_like(lower_p, _math.inf) pDv[Icp] = torch.clamp(torch.maximum(pDv[Icp], lower_p), max=upper_p) lower_m = yc_w64[Icm] # negative values if _math.isfinite(g_max): lower_m_cap = (lower_m * g_max).clamp(max=lower_m) else: lower_m_cap = torch.full_like(lower_m, -_math.inf) pDv[Icm] = torch.clamp(torch.minimum(pDv[Icm], lower_m), min=lower_m_cap) zi = v_c - _frana_gpu(Dv - pDv, frame) # (F, P) # ── Step 4: convergence check for still-active frames ───────────── norms = (zi - zb).norm(dim=-1) # (F,) new_conv = active & (norms <= eps) if new_conv.any(): # Freeze zi at the convergence point — equivalent to CPU 'break' zi_final[new_conv] = zi[new_conv] conv |= new_conv active = ~conv if not active.any(): break # ── Step 7: dual update for active frames only ──────────────────── # CPU tight_sspade updates ui AFTER the convergence check, # meaning ui is NOT updated on the convergence iteration. # Matching that: only active frames (not yet converged) update ui. ui[active] = ui[active] + zi[active] - zb[active] if i % r == 0: k += s # Frames that never converged: use their final zi if active.any(): zi_final[active] = zi[active] # Downcast output to float32 for WOLA accumulation return _frsyn_gpu(zi_final, frame, M).float(), conv def _declip_mono_gpu( yc: np.ndarray, params: "DeclipParams", tau: float, ch_label: str, device: str, progress_ctx = None, task_id = None, ) -> "Tuple[np.ndarray, ClippingMasks]": """ GPU-accelerated mono declipping pipeline. Three-pass strategy ------------------- Pass 1 (CPU): extract all frames, compute bypass decisions and masks. Pass 2 (GPU): pack active frames into a batch tensor and run _sspade_batch_gpu — all frames in one GPU kernel sweep. Pass 3 (CPU): sequential WOLA accumulation + RMS level match. Progress behaviour ------------------ Bypassed frames advance the progress bar in real-time during Pass 1. Active (GPU-processed) frames advance the bar immediately after Pass 2 returns (appears as a single jump — mirrors how the GPU works). """ import torch # ── DC removal (BUG-4 fix) ─────────────────────────────────────────── dc_offset = float(np.mean(yc)) yc = yc - dc_offset # ── Ceiling and threshold ──────────────────────────────────────────── ceiling_pos = float(np.max(yc)) ceiling_neg = float(-np.min(yc)) if params.mode == "hard": threshold = min(ceiling_pos, ceiling_neg) else: ceiling = max(ceiling_pos, ceiling_neg) threshold = ceiling * (10.0 ** (-params.delta_db / 20.0)) if threshold <= 0.0: return yc.copy(), _compute_masks(yc, 0.0) masks = _compute_masks(yc, threshold) # ── v11 Feature 1: envelope-based mask dilation (GPU path) ──────────── if params.mode == "soft" and params.release_ms > 0.0: rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0)) if rel_samp > 0: masks = _dilate_masks_soft(masks, yc, rel_samp) # ── v11 Feature 4: macro-dynamics upward expansion pre-pass ────────── if params.mode == "soft" and params.macro_expand and params.macro_ratio > 1.0: yc = _macro_expand_pass( yc, params.sample_rate, attack_ms=params.macro_attack_ms, release_ms=params.macro_release_ms, ratio=params.macro_ratio, ) masks = _compute_masks(yc, threshold) if params.release_ms > 0.0: rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0)) if rel_samp > 0: masks = _dilate_masks_soft(masks, yc, rel_samp) n_clipped = int(np.sum(~masks.Ir)) L = len(yc) # ── v11 Feature 2: ratio-aware upper bound (linear) ────────────────── g_max = (10.0 ** (params.max_gain_db / 20.0) if params.mode == "soft" and params.max_gain_db > 0.0 else float("inf")) if params.verbose: ch = f" [{ch_label}]" if ch_label else "" tag = "threshold" if params.mode == "soft" else "tau" print(f"[declip{ch}] Length : {L} samples [device: {device}]") print(f"[declip{ch}] DC offset : {dc_offset:+.6f} ({dc_offset*100:+.4f}%) → removed") if params.mode == "hard": print(f"[declip{ch}] {tag:<9} : {threshold:.6f} " f"(pos_peak={ceiling_pos:.6f} neg_peak={ceiling_neg:.6f} using min)") else: print(f"[declip{ch}] ceiling : {max(ceiling_pos, ceiling_neg):.6f} " f"(pos={ceiling_pos:.6f} neg={ceiling_neg:.6f})") print(f"[declip{ch}] {tag:<9} : {threshold:.6f} " f"(ceiling − {params.delta_db:.2f} dB = " f"{20*np.log10(threshold/max(ceiling_pos,ceiling_neg)):.2f} dBFS)") print(f"[declip{ch}] Detected : {n_clipped}/{L} " f"({100*n_clipped/L:.1f}%) " f"Icp={int(masks.Icp.sum())} Icm={int(masks.Icm.sum())}") print(f"[declip{ch}] Algorithm : {params.algo.upper()} " f"frame={params.frame.upper()} mode={params.mode.upper()} " f"win={params.window_length} hop={params.hop_length} " f"({100*(1-params.hop_length/params.window_length):.0f}% overlap) " f"[GPU BATCH on {device}]") if params.mode == "soft": feats = [] if params.release_ms > 0: feats.append(f"release_ms={params.release_ms}") if params.max_gain_db > 0: feats.append(f"max_gain_db={params.max_gain_db}") if params.macro_expand: feats.append(f"macro_expand(ratio={params.macro_ratio})") if feats: print(f"[declip{ch}] v11 feats : " + " ".join(feats)) M = params.window_length a = params.hop_length N = int(np.ceil(L / a)) win = np.sqrt(hann(M, sym=False)) t0 = time.time() # ── Pass 1 (CPU): frame extraction, bypass filter, mask build ──────── # wola_meta[i] = (idx1, idx2, seg_len, is_bypassed) # active_* = lists for non-bypassed frames only, in order wola_meta : list = [] active_yc_w : list = [] # windowed frames for SPADE active_Ir : list = [] active_Icp : list = [] active_Icm : list = [] active_orig_idx : list = [] # original frame index i → maps back into wola_meta skipped = 0 for i in range(N): idx1 = i * a idx2 = min(idx1 + M, L) seg_len = idx2 - idx1 pad = M - seg_len yc_frame = np.zeros(M) yc_frame[:seg_len] = yc[idx1:idx2] if params.mode == "soft": fp = float(np.max(np.abs(yc_frame[:seg_len]))) if seg_len else 0.0 if fp < threshold: wola_meta.append((idx1, idx2, seg_len, True)) skipped += 1 if progress_ctx is not None and task_id is not None: progress_ctx.advance(task_id, n_bypassed=skipped, n_noconv=0, n_done=i + 1, n_total=N) continue wola_meta.append((idx1, idx2, seg_len, False)) active_yc_w.append(yc_frame * win) active_Ir .append(np.concatenate([masks.Ir [idx1:idx2], np.ones (pad, dtype=bool)])) active_Icp.append(np.concatenate([masks.Icp[idx1:idx2], np.zeros(pad, dtype=bool)])) active_Icm.append(np.concatenate([masks.Icm[idx1:idx2], np.zeros(pad, dtype=bool)])) active_orig_idx.append(len(wola_meta) - 1) # index into wola_meta n_active = len(active_yc_w) n_noconv = 0 x_active_results: dict = {} # wola_meta_index → x_frame (M,) numpy # ── Pass 2 (GPU): batched S-SPADE ──────────────────────────────────── if n_active > 0: yc_batch = torch.tensor(np.stack(active_yc_w), dtype=torch.float64, device=device) Ir_batch = torch.tensor(np.stack(active_Ir), dtype=torch.bool, device=device) Icp_batch = torch.tensor(np.stack(active_Icp), dtype=torch.bool, device=device) Icm_batch = torch.tensor(np.stack(active_Icm), dtype=torch.bool, device=device) if params.verbose: ch = f" [{ch_label}]" if ch_label else "" vmem = "" try: alloc = torch.cuda.memory_allocated(device) / 1024**2 vmem = f" VRAM used ≈ {alloc:.0f} MB" except Exception: pass print(f"[declip{ch}] GPU pass : {n_active} active frames → " f"{yc_batch.shape} batch{vmem}") x_batch, conv_batch = _sspade_batch_gpu( yc_batch, Ir_batch, Icp_batch, Icm_batch, params.frame, params.s, params.r, params.eps, params.max_iter, g_max=g_max, ) x_np = x_batch.cpu().numpy() conv_np = conv_batch.cpu().numpy() n_noconv = int((~conv_np).sum()) for j, meta_idx in enumerate(active_orig_idx): x_active_results[meta_idx] = x_np[j] # Advance progress bar for GPU-processed frames (bulk update) if progress_ctx is not None and task_id is not None: for j in range(n_active): progress_ctx.advance(task_id, n_bypassed=skipped, n_noconv=n_noconv, n_done=skipped + j + 1, n_total=N) # ── Pass 3 (CPU): WOLA accumulation ─────────────────────────────────── x = np.zeros(L) norm_win = np.zeros(L) for meta_idx, (idx1, idx2, seg_len, is_bypassed) in enumerate(wola_meta): if is_bypassed: x [idx1:idx2] += yc[idx1:idx2] * win[:seg_len] ** 2 norm_win[idx1:idx2] += win[:seg_len] ** 2 else: xf = x_active_results[meta_idx] x [idx1:idx2] += xf[:seg_len] * win[:seg_len] norm_win[idx1:idx2] += win[:seg_len] ** 2 norm_win = np.where(norm_win < 1e-12, 1.0, norm_win) x /= norm_win # ── Reliable-sample RMS match (BUG-3 fix) ──────────────────────────── Ir = masks.Ir if Ir.sum() > 0: rms_in = float(np.sqrt(np.mean(yc[Ir] ** 2))) rms_out = float(np.sqrt(np.mean(x[Ir] ** 2))) if rms_out > 1e-12 and rms_in > 1e-12: x *= rms_in / rms_out if params.verbose: ch = f" [{ch_label}]" if ch_label else "" skip_pct = 100.0 * skipped / N if N else 0.0 print(f"[declip{ch}] Frames : {N} total | " f"active={n_active} (GPU) bypassed={skipped} ({skip_pct:.1f}%) " f"no_conv={n_noconv} | time: {time.time()-t0:.1f}s") return x, masks def frana(x: np.ndarray, frame: str) -> np.ndarray: """ Analysis operator A : R^N → R^P. For a tight Parseval frame A, the synthesis operator is D = A^H, and A^H A = I_N (perfect reconstruction property). DCT frame (P = N): A = orthonormal DCT-II. A^H = A^{-1} = IDCT. RDFT frame (P = 2N, redundancy 2): A = [A₁; A₂] where A₁ = DCT-II/√2 and A₂ = DST-II/√2. DST-II(x) is computed as DCT-II(x[::-1]). Tight frame property: A₁^H A₁ + A₂^H A₂ = I/2 + I/2 = I. ✓ """ if frame == "dct": return dct(x, type=2, norm="ortho") if frame == "rdft": cos_part = dct(x, type=2, norm="ortho") / np.sqrt(2) # DCT-II / √2 sin_part = dct(x[::-1], type=2, norm="ortho") / np.sqrt(2) # DST-II / √2 return np.concatenate([cos_part, sin_part]) raise ValueError(f"Unknown frame '{frame}'") def frsyn(z: np.ndarray, frame: str, M: int) -> np.ndarray: """ Synthesis operator D = A^H : R^P → R^N. DCT frame: D = IDCT (same matrix as A for orthonormal DCT). RDFT frame: D = [A₁^H, A₂^H] applied to [z₁; z₂]: A₁^H z₁ = IDCT(z₁) / √2 A₂^H z₂ = IDCT(z₂)[::-1] / √2 ← correct: flip the OUTPUT Note: the original v1 had the bug idct(z₂[::-1]) — flipping the INPUT. Correct adjoint of DST-II requires IDCT(z₂)[::-1], NOT IDCT(z₂[::-1]). """ if frame == "dct": return idct(z, type=2, norm="ortho") if frame == "rdft": cos_part = idct(z[:M], type=2, norm="ortho") / np.sqrt(2) sin_part = idct(z[M:], type=2, norm="ortho")[::-1] / np.sqrt(2) # BUG-1 fix return cos_part + sin_part raise ValueError(f"Unknown frame '{frame}'") # ============================================================================ # Hard thresholding H_k # ============================================================================ def hard_thresh(u: np.ndarray, k: int) -> np.ndarray: """ Hard-thresholding operator H_k. Keeps the k largest-magnitude components of u; sets all others to zero. Corresponds to step 2 of both Algorithm 1 and Algorithm 2 in [1][2]. Parameters ---------- u : coefficient vector (in R^P) k : number of non-zero coefficients to retain Notes ----- The papers remark that for real signals represented with complex DFT, thresholding should act on conjugate pairs to preserve the real-signal structure. Since our RDFT frame uses real DCT/DST, all coefficients are real-valued and standard element-wise thresholding is appropriate. """ k = int(np.clip(k, 1, len(u))) alpha = np.sort(np.abs(u))[::-1][k - 1] # k-th largest magnitude return u * (np.abs(u) >= alpha) # ============================================================================ # Projection onto the consistency set Γ # ============================================================================ def proj_gamma( w: np.ndarray, yc: np.ndarray, masks: ClippingMasks, g_max: float = float("inf"), # v11: ratio-aware upper bound (linear) ) -> np.ndarray: """ Orthogonal projection onto Γ(y) in the time domain. Implements eq. (6) of [2] / eq. (2) of [1]: [proj_Γ(w)]_n = y_n if n ∈ R (reliable) = max{w_n, τ} if n ∈ H (positive clip, i.e. ≥ τ) = min{w_n, −τ} if n ∈ L (negative clip, i.e. ≤ −τ) Equivalently, using bounding vectors b_L, b_H as in eq. (7)/(9) of [2]: proj_{[b_L, b_H]}(w) = min{max{b_L, w}, b_H} v11 — ratio-aware upper bound (g_max > 0, default disabled = inf): [proj_Γ(w)]_n = clip(max(w_n, yc_n), yc_n, yc_n · g_max) for n ∈ Icp = clip(min(w_n, yc_n), yc_n · g_max, yc_n) for n ∈ Icm This prevents ADMM from generating transients above the limiter’s expected maximum gain reduction while still honouring the lower bound. Parameters ---------- w : time-domain signal to project (R^N) yc : original clipped signal (R^N), provides boundary values masks : clipping masks (Ir, Icp, Icm) g_max : linear gain ceiling (default: inf = no cap, i.e. v10 behaviour). Compute from max_gain_db as: g_max = 10 ** (max_gain_db / 20). """ v = w.copy() v[masks.Ir] = yc[masks.Ir] # reliable: fix exactly # Positive clipped: lower bound ≥ yc, optional upper bound ≤ yc * g_max lo_p = yc[masks.Icp] if np.isfinite(g_max): hi_p = lo_p * g_max else: hi_p = np.full_like(lo_p, np.inf) # avoid 0 * inf = nan v[masks.Icp] = np.clip(np.maximum(v[masks.Icp], lo_p), lo_p, hi_p) # Negative clipped: upper bound ≤ yc, optional lower bound ≥ yc * g_max lo_m = yc[masks.Icm] # negative values if np.isfinite(g_max): lo_m_cap = lo_m * g_max # more negative than lo_m else: lo_m_cap = np.full_like(lo_m, -np.inf) # avoid 0 * inf = nan v[masks.Icm] = np.clip(np.minimum(v[masks.Icm], lo_m), lo_m_cap, lo_m) return v # ============================================================================ # S-SPADE (Algorithm 1 in [2]) # ============================================================================ def tight_sspade( yc: np.ndarray, masks: ClippingMasks, frame: str, s: int, r: int, eps: float, max_iter: int, g_max: float = float("inf"), # v11: ratio-aware upper bound ) -> Tuple[np.ndarray, bool]: """ S-SPADE for one windowed audio frame. Implements Algorithm 1 from [2], which uses the closed-form projection lemma (eq. 12) to make per-iteration cost equal to A-SPADE: ẑ^(i) = v - D^* ( D v - proj_{[b_L,b_H]}(D v) ) where v = z̄^(i) - u^(i-1) State variables --------------- zi : current estimate in coefficient domain (R^P) ui : dual / guidance variable (R^P) — coefficient domain k : current sparsity level (number of non-zero coefficients) Convergence criterion (Algorithm 1, row 4 in [2]) ------------------------------------------------- ‖ẑ^(i) - z̄^(i)‖₂ ≤ ε """ M = len(yc) zi = frana(yc, frame) # ẑ^(0) = A^H y (eq. D^H y in [2]) ui = np.zeros_like(zi) # u^(0) = 0 k = s converged = False for i in range(1, max_iter + 1): # ── Step 2 : enforce sparsity ───────────────────────────────────── # z̄^(i) = H_k( ẑ^(i-1) + u^(i-1) ) zb = hard_thresh(zi + ui, k) # ── Step 3 : project onto Γ via eq.(12) from [2] ───────────────── # v = z̄^(i) - u^(i-1) (coefficient domain) v_coeff = zb - ui # D v (time domain) Dv = frsyn(v_coeff, frame, M) # proj_{Γ}(D v) proj_Dv = proj_gamma(Dv, yc, masks, g_max=g_max) # ẑ^(i) = v - D^*( D v - proj(D v) ) zi = v_coeff - frana(Dv - proj_Dv, frame) # ── Step 4 : convergence check ──────────────────────────────────── # ‖ẑ^(i) - z̄^(i)‖₂ ≤ ε if np.linalg.norm(zi - zb) <= eps: converged = True break # ── Step 7 : update dual variable ──────────────────────────────── # u^(i) = u^(i-1) + ẑ^(i) - z̄^(i) ui = ui + zi - zb # ── Sparsity relaxation (rows 9-11 in [2]) ──────────────────────── if i % r == 0: k += s # Return time-domain estimate: x̂ = D ẑ^(i) return frsyn(zi, frame, M), converged # ============================================================================ # A-SPADE (Algorithm 2 in [2]) # ============================================================================ def tight_aspade( yc: np.ndarray, masks: ClippingMasks, frame: str, s: int, r: int, eps: float, max_iter: int, g_max: float = float("inf"), # v11: ratio-aware upper bound ) -> Tuple[np.ndarray, bool]: """ A-SPADE for one windowed audio frame. Implements Algorithm 2 from [2]. The projection step uses the closed-form formula from eq.(5)/(8) of [2]: x̂^(i) = proj_{[b_L, b_H]}( A^H ( z̄^(i) − u^(i-1) ) ) = proj_Γ( D ( z̄^(i) − u^(i-1) ) ) = proj_Γ( frsyn(zb − ui) ) State variables --------------- xi : current estimate in signal domain (R^N) ui : dual / guidance variable (R^P) — COEFFICIENT domain [BUG-2 fix] k : current sparsity level Convergence criterion (Algorithm 2, row 4 in [2]) ------------------------------------------------- ‖A x̂^(i) − z̄^(i)‖₂ ≤ ε (coefficient-domain norm) [BUG-2c fix] """ M = len(yc) P = _frame_size(M, frame) xi = yc.copy() # x̂^(0) = y ui = np.zeros(P) # u^(0) = 0 — coefficient domain R^P [BUG-2 fix] k = s converged = False for i in range(1, max_iter + 1): # ── Step 2 : enforce sparsity ───────────────────────────────────── # z̄^(i) = H_k( A x̂^(i-1) + u^(i-1) ) # Note: frana(xi) + ui, NOT frana(xi + frsyn(ui)) [BUG-2a fix] zb = hard_thresh(frana(xi, frame) + ui, k) # ── Step 3 : project onto Γ ─────────────────────────────────────── # x̂^(i) = proj_Γ( A^H( z̄^(i) - u^(i-1) ) ) # = proj_Γ( frsyn( zb - ui ) ) [BUG-2b fix] xi_new = proj_gamma(frsyn(zb - ui, frame, M), yc, masks, g_max=g_max) # ── Step 4 : convergence check ──────────────────────────────────── # ‖A x̂^(i) - z̄^(i)‖₂ ≤ ε (coefficient-domain norm) [BUG-2c fix] if np.linalg.norm(frana(xi_new, frame) - zb) <= eps: converged = True xi = xi_new break # ── Step 7 : update dual variable ──────────────────────────────── # u^(i) = u^(i-1) + A x̂^(i) - z̄^(i) [BUG-2d fix] ui = ui + frana(xi_new, frame) - zb xi = xi_new # ── Sparsity relaxation ─────────────────────────────────────────── if i % r == 0: k += s return xi, converged # ============================================================================ # Main declipping pipeline # ============================================================================ # ============================================================================ # v13 — LF transient recovery: child-params builder + subband split entry # ============================================================================ def _build_lf_child_params(params: "DeclipParams") -> "DeclipParams": """ Build a child DeclipParams for the dedicated LF subband SPADE pass. Fields with a non-zero / non-sentinel lf_* override take precedence; all others inherit from the parent params. Sets lf_split_hz=0.0 to prevent infinite recursion when declip() is called on the LF band. Window / hop logic ------------------ If lf_window_length > 0: use explicitly. Otherwise: inherit the parent window_length unchanged. If lf_hop_length > 0: use explicitly. Otherwise: auto = lf_window_length // 4 (25% hop, 75% overlap). Sentinel values --------------- lf_delta_db : 0.0 → inherit delta_db lf_max_gain_db : 0.0 → inherit max_gain_db lf_release_ms : -1.0 → inherit release_ms lf_eps : 0.0 → inherit eps lf_max_iter : 0 → inherit max_iter lf_s : 0 → inherit s lf_r : 0 → inherit r """ from dataclasses import replace as _dc_replace lf_win = params.lf_window_length if params.lf_window_length > 0 else params.window_length lf_hop = (params.lf_hop_length if params.lf_hop_length > 0 else lf_win // 4) return _dc_replace( params, # ── Disable the LF subband routing to prevent recursion ─────────── lf_split_hz = 0.0, # ── Window / hop ────────────────────────────────────────────────── window_length = lf_win, hop_length = lf_hop, # ── ADMM parameters (fallback to parent if sentinel) ───────────── max_iter = params.lf_max_iter if params.lf_max_iter > 0 else params.max_iter, eps = params.lf_eps if params.lf_eps > 0.0 else params.eps, s = params.lf_s if params.lf_s > 0 else params.s, r = params.lf_r if params.lf_r > 0 else params.r, # ── Soft-mode parameters ────────────────────────────────────────── delta_db = params.lf_delta_db if params.lf_delta_db > 0.0 else params.delta_db, max_gain_db = params.lf_max_gain_db if params.lf_max_gain_db > 0.0 else params.max_gain_db, release_ms = params.lf_release_ms if params.lf_release_ms >= 0.0 else params.release_ms, # ── Suppress per-band progress bar (LF is a sub-pass) ──────────── show_progress = False, verbose = params.verbose, ) def _build_hf_child_params(params: "DeclipParams") -> "DeclipParams": """ Build a child DeclipParams for the HF SPADE pass (v11-identical). The HF band is processed with exactly the same parameters as if lf_split_hz had never been set. Only lf_split_hz is zeroed out to prevent recursion; everything else is left completely unchanged. This function exists to make the split explicit and documentable. """ from dataclasses import replace as _dc_replace return _dc_replace( params, lf_split_hz = 0.0, # disable LF split → pure v11 path show_progress = False, # suppress per-band bar (managed by caller) ) def _declip_with_lf_split( yc: "np.ndarray", params: "DeclipParams", ) -> "Tuple[np.ndarray, object]": """ v13 entry point: LF/HF subband SPADE with independent processing. Called from declip() when params.lf_split_hz > 0 and params.mode == 'soft'. Algorithm --------- For each channel c: 1. LR crossover at lf_split_hz Hz (zero-phase Butterworth LP, HP = x - LP): lf_band[c], hf_band[c] = _lr_split(yc[c], lf_split_hz, sr) 2. HF pass (v11-identical): hf_fixed[c], hf_masks[c] = declip(hf_band[c], hf_child_params) Parameters: unchanged from parent (window, hop, iter, eps, delta_db, max_gain_db, release_ms). lf_split_hz=0 prevents recursion. 3. LF pass (dedicated sub-bass recovery): lf_fixed[c], lf_masks[c] = declip(lf_band[c], lf_child_params) Parameters: lf_window_length, lf_hop_length, lf_max_iter, lf_eps, lf_delta_db, lf_max_gain_db, lf_release_ms, lf_s, lf_r (each falls back to the parent value if unset). 4. Reconstruction: output[c] = lf_fixed[c] + hf_fixed[c] Exact because LP + HP = original (perfect reconstruction). Return value ------------ output : np.ndarray same shape as yc masks : ClippingMasks (mono) or list[ClippingMasks] (multi-channel). Returns the HF band masks, which are computed on the portion of the signal that drives most of the limiting detection. Rationale for returning HF masks --------------------------------- The full-signal peak is dominated by HF transients (kick attack); the limiter acts primarily there. HF masks therefore reflect the true limiting pattern more faithfully than LF masks (which represent only the low-passed band). Callers that need LF masks can recover them by running _compute_masks on the LF band directly. """ sr = params.sample_rate fc = float(np.clip(params.lf_split_hz, 1.0, sr / 2.0 - 1.0)) mono = yc.ndim == 1 yc_2d = yc[:, None] if mono else yc n_samples, n_ch = yc_2d.shape hf_child = _build_hf_child_params(params) lf_child = _build_lf_child_params(params) # Optional progress bar for the two-pass operation if params.show_progress and params.verbose: print(f"[v13 LF split] crossover={fc:.0f} Hz | " f"LF: win={lf_child.window_length} hop={lf_child.hop_length} " f"iter={lf_child.max_iter} eps={lf_child.eps:.4f} " f"delta={lf_child.delta_db:.2f}dB gain={lf_child.max_gain_db:.1f}dB " f"rel={lf_child.release_ms:.0f}ms | " f"HF: win={hf_child.window_length} hop={hf_child.hop_length} " f"iter={hf_child.max_iter} eps={hf_child.eps:.4f} " f"delta={hf_child.delta_db:.2f}dB gain={hf_child.max_gain_db:.1f}dB " f"rel={hf_child.release_ms:.0f}ms") out = np.zeros((n_samples, n_ch), dtype=np.float64) hf_masks_all : list = [] lf_masks_all : list = [] for ch in range(n_ch): yc_ch = yc_2d[:, ch].astype(np.float64) # ── 1. Linkwitz-Riley split ─────────────────────────────────────── lf_band, hf_band = _lr_split(yc_ch, fc, sr) # ── 2. HF pass: v11-identical ───────────────────────────────────── hf_fixed_raw, hf_mask = declip(hf_band.astype(np.float32), hf_child) hf_fixed = np.asarray(hf_fixed_raw, dtype=np.float64) # ── 3. LF pass: dedicated sub-bass SPADE ───────────────────────── lf_fixed_raw, lf_mask = declip(lf_band.astype(np.float32), lf_child) lf_fixed = np.asarray(lf_fixed_raw, dtype=np.float64) # ── 4. Perfect-reconstruction sum ──────────────────────────────── L = min(len(lf_fixed), len(hf_fixed), n_samples) out[:L, ch] = lf_fixed[:L] + hf_fixed[:L] hf_masks_all.append(hf_mask) lf_masks_all.append(lf_mask) result = out[:, 0] if mono else out # Return HF masks (most representative of the full-signal limiting pattern) if mono: return result, hf_masks_all[0] return result, hf_masks_all def _compute_masks(yc: np.ndarray, threshold: float) -> ClippingMasks: """ Compute clipping/limiting masks from a 1-D signal and a detection threshold. Works for both modes: hard (mode='hard'): threshold = tau (samples exactly at digital ceiling) soft (mode='soft'): threshold = tau * 10^(-delta_db/20) (limiter threshold) In soft mode, samples above the threshold have their TRUE value constrained to be ≥ their current (limited) value. proj_gamma already implements this correctly via v[Icp] = max(v[Icp], yc[Icp]) — since yc[Icp] is the actual limited value, not tau. No change to the projection operator is needed. """ Icp = yc >= threshold Icm = yc <= -threshold Ir = ~(Icp | Icm) return ClippingMasks(Ir=Ir, Icp=Icp, Icm=Icm) # ============================================================================ # v11 — Delimiting helper functions # ============================================================================ def _dilate_masks_soft( masks: ClippingMasks, yc: np.ndarray, release_samples: int, ) -> ClippingMasks: """ Forward morphological dilation of the soft-mode clipping masks. A mastering limiter does not merely clip the peak sample; its release time causes gain reduction to persist for `release_samples` samples after each peak. Without dilation, those post-peak samples are pinned as "reliable" (Ir), forcing the ADMM solver to anchor the reconstruction to artificially attenuated values and producing the pumping artifact. Algorithm --------- For each True position in Icp or Icm, the following `release_samples` positions are also flagged as constrained (Icp/Icm). Implemented as a causal linear convolution: dilated = convolve(mask, ones(release_samples + 1))[:N] > 0 Newly flagged samples are reclassified by polarity: yc[n] >= 0 → Icp (true value ≥ yc[n], always satisfied by limiter model) yc[n] < 0 → Icm (true value ≤ yc[n], same reasoning) This is mathematically valid because a gain-reducing limiter always produces |yc[n]| ≤ |true[n]| on every attenuated sample. Parameters ---------- masks : original ClippingMasks from _compute_masks yc : DC-removed signal (same length as masks) release_samples : dilation width = round(release_ms * sr / 1000) Returns ------- ClippingMasks with expanded Icp, Icm and correspondingly shrunk Ir. """ if release_samples <= 0: return masks N = len(yc) kern = np.ones(release_samples + 1, dtype=np.float64) # Causal forward dilation: each True position infects the next # release_samples positions (conv[:N] gives the causal output). dil_cp = np.convolve(masks.Icp.astype(np.float64), kern)[:N] > 0 dil_cm = np.convolve(masks.Icm.astype(np.float64), kern)[:N] > 0 # Union of original and dilated masks new_Icp = dil_cp | dil_cm # will be filtered by polarity below new_Icm = dil_cp | dil_cm # Assign dilated samples by polarity of the limited signal new_Icp = new_Icp & (yc >= 0) # positive half new_Icm = new_Icm & (yc < 0) # negative half # Reliable = everything not in Icp or Icm new_Ir = ~(new_Icp | new_Icm) return ClippingMasks(Ir=new_Ir, Icp=new_Icp, Icm=new_Icm) def _lr_split(x: np.ndarray, fc: float, sr: int) -> "Tuple[np.ndarray, np.ndarray]": """ Phase-perfect Linkwitz-Riley crossover at frequency `fc` Hz. Returns (lp, hp) such that lp + hp == x exactly (perfect reconstruction by construction: hp = x - lp). The LP is a zero-phase 4th-order Butterworth realised with sosfiltfilt. A 4th-order zero-phase Butterworth (sosfiltfilt of 2nd-order coefficients) has the same amplitude response as LR4 at the crossover point (−6 dB at fc) and is computationally convenient. Summing LP + HP = x eliminates any phase-cancellation artifact at the crossover frequency. Parameters ---------- x : 1-D signal array fc : crossover frequency in Hz (clamped to [1, sr/2 − 1]) sr : sample rate in Hz """ from scipy.signal import butter, sosfiltfilt fc_safe = float(np.clip(fc, 1.0, sr / 2.0 - 1.0)) sos = butter(2, fc_safe, btype="low", fs=sr, output="sos") lp = sosfiltfilt(sos, x) hp = x - lp # perfect reconstruction: no leakage at any frequency return lp, hp def _macro_expand_pass( yc: np.ndarray, sr: int, attack_ms: float = 10.0, release_ms: float = 200.0, ratio: float = 1.2, ) -> np.ndarray: """ Macro-dynamics upward expansion pre-pass. Restores the slow (>21 ms) amplitude modulation suppressed by a mastering limiter's release time — the "body compression" that SPADE cannot undo because it operates frame-by-frame at ~21 ms windows. Algorithm --------- 1. Compute a zero-phase smoothed peak envelope using sosfiltfilt. The attack and release IIR time constants map to Butterworth LP cutoffs: fc_att = 2.2 / (2π · attack_s) [−3 dB at attack cutoff] fc_rel = 2.2 / (2π · release_s) Two passes (attack on rising, release on falling) are approximated by using the *slower* of the two for the LP filter (conservative choice). 2. Threshold: 80th-percentile of the non-silent envelope values. Above the threshold the signal is already "loud" → no expansion. Below the threshold it was compressed → apply upward expansion gain. 3. Expansion gain (standard upward-expander transfer function): g(n) = (env(n) / threshold)^(1/ratio − 1) env < threshold = 1.0 otherwise For ratio > 1, (1/ratio − 1) < 0, so g > 1 when env < threshold (quiet sections get boosted). 4. Gain is smoothed with a 20 Hz LP to prevent clicks, then hard-clipped to [1.0, ∞) so the pre-pass only expands — it never attenuates. Parameters ---------- yc : 1-D float signal (DC-removed, level-normalised) sr : sample rate in Hz attack_ms : expander attack time constant (ms); typically 5–20 ms release_ms : expander release time constant (ms); typically 100–300 ms ratio : expansion ratio >1.0; 1.0 = bypass, 1.2 = gentle Returns ------- Expanded signal with the same length as yc. """ from scipy.signal import butter, sosfiltfilt if ratio <= 1.0: return yc.copy() x_abs = np.abs(yc) # ── Envelope follower ───────────────────────────────────────────────── # Use the *slower* time constant (release) for the zero-phase LP filter. # This approximates a peak-hold envelope that attacks fast and releases slow. rel_s = max(release_ms, attack_ms) / 1000.0 fc_env = min(2.2 / (2.0 * np.pi * rel_s), sr / 2.0 - 1.0) sos_e = butter(2, fc_env, fs=sr, output="sos") env = sosfiltfilt(sos_e, x_abs) env = np.maximum(env, 1e-10) # ── Threshold: 80th percentile of non-silent samples ───────────────── mask_sig = env > 1e-6 if not mask_sig.any(): return yc.copy() thresh = float(np.percentile(env[mask_sig], 80)) thresh = max(thresh, 1e-8) # ── Expansion gain ──────────────────────────────────────────────────── exponent = 1.0 / ratio - 1.0 # negative for ratio > 1 g = np.where(env >= thresh, 1.0, (env / thresh) ** exponent) # ── Smooth gain to avoid clicks (~20 Hz LP) ─────────────────────────── fc_g = min(20.0, sr / 2.0 - 1.0) sos_g = butter(2, fc_g, fs=sr, output="sos") g = sosfiltfilt(sos_g, g) g = np.maximum(g, 1.0) # upward only — never attenuate return yc * g def _declip_mono( yc: np.ndarray, params: DeclipParams, tau: float, # pre-computed global ceiling — used only as hint; # always recomputed internally after DC removal. ch_label: str = "", frame_workers: int = 1, # v8: intra-channel frame-level parallelism progress_ctx = None, # v9: shared _*Progress instance (or None) task_id = None, # v9: task handle returned by progress_ctx.add_task ) -> Tuple[np.ndarray, ClippingMasks]: """ Core mono declipping / delimiting pipeline (internal). Parameters ---------- yc : 1-D float array — one channel of the input signal params : DeclipParams tau : ceiling hint (pre-computed in declip()); kept for API compat, recomputed internally after DC removal. ch_label : string used in verbose output, e.g. "L" or "R" DC removal (BUG-4 fix, v5) -------------------------- A DC offset as small as 0.3% makes the global peak asymmetric, causing the lower-polarity ceiling to fall just below tau and be misclassified as reliable. Fix: subtract per-channel mean before all threshold computations. The DC is discarded on output (recording artefact, not musical content). Soft mode (v6) -------------- When params.mode == 'soft', the threshold is set to: threshold = ceiling * 10^(-delta_db / 20) where ceiling = max(|yc|) after DC removal. This marks all samples above the limiter threshold as potentially attenuated. The BUG-4 half-wave issue is inherently avoided in soft mode because the threshold sits delta_db dB BELOW the ceiling; small DC asymmetries (typically < 0.05 dB) cannot push the opposite polarity's ceiling below the threshold. DC removal is still performed for cleanliness. proj_gamma correctness in soft mode ------------------------------------ For limited samples, the true value satisfies: true ≥ yc[n] (one-sided). proj_gamma already implements exactly this: v[Icp] = max(v[Icp], yc[Icp]) Since yc[Icp] here is the *actual limited value* (not tau), the constraint is correct. No change to tight_sspade or tight_aspade is needed. """ # ── DC removal (BUG-4 fix, applies to both modes) ──────────────────── dc_offset = float(np.mean(yc)) yc = yc - dc_offset # DC-free working copy # ── Ceiling and threshold ───────────────────────────────────────────── ceiling_pos = float(np.max(yc)) # positive peak after DC removal ceiling_neg = float(-np.min(yc)) # negative peak (absolute value) if params.mode == "hard": # BUG-4 fix: use min(pos, neg) so both half-waves are always detected threshold = min(ceiling_pos, ceiling_neg) else: # soft mode: threshold = ceiling − delta_db dB # Use max(pos, neg) for ceiling — we want the actual brickwall level, # and the threshold is well below it so small asymmetries don't matter. ceiling = max(ceiling_pos, ceiling_neg) threshold = ceiling * (10.0 ** (-params.delta_db / 20.0)) if threshold <= 0.0: return yc.copy(), _compute_masks(yc, 0.0) masks = _compute_masks(yc, threshold) # ── v11 Feature 1: envelope-based mask dilation ─────────────────────── if params.mode == "soft" and params.release_ms > 0.0: rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0)) if rel_samp > 0: masks = _dilate_masks_soft(masks, yc, rel_samp) # ── v11 Feature 4: macro-dynamics upward expansion pre-pass ────────── if params.mode == "soft" and params.macro_expand and params.macro_ratio > 1.0: yc = _macro_expand_pass( yc, params.sample_rate, attack_ms=params.macro_attack_ms, release_ms=params.macro_release_ms, ratio=params.macro_ratio, ) # Recompute masks on the expanded signal so Ir values are correct masks = _compute_masks(yc, threshold) if params.release_ms > 0.0: rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0)) if rel_samp > 0: masks = _dilate_masks_soft(masks, yc, rel_samp) n_clipped = int(np.sum(~masks.Ir)) L = len(yc) # ── v11 Feature 2: ratio-aware upper bound (linear) ────────────────── g_max = (10.0 ** (params.max_gain_db / 20.0) if params.mode == "soft" and params.max_gain_db > 0.0 else float("inf")) if params.verbose: ch = (" [" + ch_label + "]") if ch_label else "" tag = "threshold" if params.mode == "soft" else "tau" print(f"[declip{ch}] Length : {L} samples") print(f"[declip{ch}] DC offset : {dc_offset:+.6f} ({dc_offset*100:+.4f}%) → removed") if params.mode == "hard": print(f"[declip{ch}] {tag:<9} : {threshold:.6f} " f"(pos_peak={ceiling_pos:.6f} neg_peak={ceiling_neg:.6f} using min)") else: print(f"[declip{ch}] ceiling : {max(ceiling_pos, ceiling_neg):.6f} " f"(pos={ceiling_pos:.6f} neg={ceiling_neg:.6f})") print(f"[declip{ch}] {tag:<9} : {threshold:.6f} " f"(ceiling − {params.delta_db:.2f} dB = " f"{20*np.log10(threshold/max(ceiling_pos,ceiling_neg)):.2f} dBFS)") print(f"[declip{ch}] Detected : {n_clipped}/{L} " f"({100*n_clipped/L:.1f}%) " f"Icp={int(masks.Icp.sum())} Icm={int(masks.Icm.sum())}") print(f"[declip{ch}] Algorithm : {params.algo.upper()} " f"frame={params.frame.upper()} mode={params.mode.upper()} " f"win={params.window_length} hop={params.hop_length} " f"({100*(1-params.hop_length/params.window_length):.0f}% overlap)") if params.mode == "soft": feats = [] if params.release_ms > 0: feats.append(f"release_ms={params.release_ms}") if params.max_gain_db > 0: feats.append(f"max_gain_db={params.max_gain_db}") if params.macro_expand: feats.append(f"macro_expand(ratio={params.macro_ratio})") if feats: print(f"[declip{ch}] v11 feats : " + " ".join(feats)) spade_fn = tight_sspade if params.algo == "sspade" else tight_aspade M = params.window_length a = params.hop_length N = int(np.ceil(L / a)) win = np.sqrt(hann(M, sym=False)) # sqrt-Hann: satisfies COLA x = np.zeros(L) norm_win = np.zeros(L) no_conv = 0 skipped = 0 # frames bypassed by frame-adaptive threshold (soft only) t0 = time.time() # ── Per-frame worker (pure computation, no shared-state writes) ────── # Returns all data needed for WOLA accumulation; the accumulation itself # is always done sequentially to avoid race conditions on x / norm_win. def _process_frame(i: int): idx1 = i * a idx2 = min(idx1 + M, L) seg_len = idx2 - idx1 pad = M - seg_len yc_frame = np.zeros(M) yc_frame[:seg_len] = yc[idx1:idx2] # ── Frame-adaptive bypass (soft mode only, v7) ─────────────────── if params.mode == "soft": frame_peak = float(np.max(np.abs(yc_frame[:seg_len]))) if seg_len > 0 else 0.0 if frame_peak < threshold: return idx1, idx2, seg_len, None, False, True # bypassed=True yc_frame_w = yc_frame * win fm = ClippingMasks( Ir = np.concatenate([masks.Ir [idx1:idx2], np.ones (pad, dtype=bool)]), Icp = np.concatenate([masks.Icp[idx1:idx2], np.zeros(pad, dtype=bool)]), Icm = np.concatenate([masks.Icm[idx1:idx2], np.zeros(pad, dtype=bool)]), ) x_frame, conv = spade_fn( yc_frame_w, fm, params.frame, params.s, params.r, params.eps, params.max_iter, g_max=g_max, ) return idx1, idx2, seg_len, x_frame, conv, False # bypassed=False # ── Parallel SPADE compute (v8) + live progress (v9) ───────────────── # scipy.fft.dct releases the GIL → threads run truly in parallel on DCT. # WOLA accumulation (cheap) is kept sequential to avoid data races. # # Progress strategy: # parallel: pool.submit + as_completed → advance bar as each frame lands # sequential: plain loop with advance after each frame # # frame_results[i] is stored by *original index* so WOLA order is preserved. frame_results: list = [None] * N _n_bypassed = 0 _n_noconv = 0 def _advance(n_done: int): if progress_ctx is not None and task_id is not None: progress_ctx.advance(task_id, n_bypassed=_n_bypassed, n_noconv=_n_noconv, n_done=n_done, n_total=N) if frame_workers > 1: from concurrent.futures import as_completed with ThreadPoolExecutor(max_workers=frame_workers) as pool: future_to_idx = {pool.submit(_process_frame, i): i for i in range(N)} n_done = 0 for future in as_completed(future_to_idx): i = future_to_idx[future] frame_results[i] = future.result() n_done += 1 # Peek at result to update live counters before advancing bar *_, conv, bypassed = frame_results[i] if bypassed: _n_bypassed += 1 elif not conv: _n_noconv += 1 _advance(n_done) else: for i in range(N): frame_results[i] = _process_frame(i) *_, conv, bypassed = frame_results[i] if bypassed: _n_bypassed += 1 elif not conv: _n_noconv += 1 _advance(i + 1) # ── Sequential WOLA accumulation ───────────────────────────────────── for idx1, idx2, seg_len, x_frame, conv, bypassed in frame_results: if bypassed: yc_seg = yc[idx1:idx2] x [idx1:idx2] += yc_seg * win[:seg_len] ** 2 norm_win[idx1:idx2] += win[:seg_len] ** 2 skipped += 1 else: if not conv: no_conv += 1 x [idx1:idx2] += x_frame[:seg_len] * win[:seg_len] norm_win[idx1:idx2] += win[:seg_len] ** 2 # WOLA normalisation norm_win = np.where(norm_win < 1e-12, 1.0, norm_win) x /= norm_win # ── Reliable-sample level matching (BUG-3 fix) ─────────────────────── # Rescale output so its RMS on reliable samples matches the input RMS. # Eliminates per-channel WOLA gain drift (up to 5 dB in stereo material). Ir = masks.Ir if Ir.sum() > 0: rms_in = float(np.sqrt(np.mean(yc[Ir] ** 2))) rms_out = float(np.sqrt(np.mean(x[Ir] ** 2))) if rms_out > 1e-12 and rms_in > 1e-12: x *= rms_in / rms_out if params.verbose: ch = (" [" + ch_label + "]") if ch_label else "" active = N - skipped skip_pct = 100.0 * skipped / N if N > 0 else 0.0 if params.mode == "soft" and skipped > 0: print(f"[declip{ch}] Frames : {N} total | " f"active={active} bypassed={skipped} ({skip_pct:.1f}%) " f"no_conv={no_conv} | time: {time.time()-t0:.1f}s") else: print(f"[declip{ch}] Frames : {N} (no conv: {no_conv}) " f"time: {time.time()-t0:.1f}s") return x, masks def declip( yc: np.ndarray, params: "DeclipParams | None" = None, ) -> "Tuple[np.ndarray, Union[ClippingMasks, List[ClippingMasks]]]": """ Declip a hard-clipped audio signal — mono or multi-channel. Accepts either: * a 1-D array (N_samples,) — mono * a 2-D array (N_samples, N_channels) — stereo / surround For multi-channel input, tau is detected from the global peak across ALL channels, modelling the single hardware clipping threshold correctly. Each channel is then processed independently. Parallel processing is controlled by params.n_jobs. Parameters ---------- yc : float array, shape (N,) or (N, C) params : DeclipParams (defaults used if None) Returns ------- x : declipped signal, same shape as yc masks : ClippingMasks (mono input) list of ClippingMasks (multi-channel input, one per channel) """ if params is None: params = DeclipParams() yc = np.asarray(yc, dtype=float) # ── v11 Feature 3: Multiband (Linkwitz-Riley) routing ─────────────────── # When multiband=True, we split the signal into frequency bands, process # each independently with its own delta_db, then sum back. The split # uses perfect-reconstruction LP+HP pairs (HP = input − LP), so the sum # always reconstructs the original without leakage artifacts. # This wrapper recurses into declip() with multiband=False for each band. # ── v13: LF transient recovery subband routing ────────────────────────── # When lf_split_hz > 0 (soft mode only), delegate to _declip_with_lf_split() # which runs v11-identical SPADE on the HF band and a dedicated SPADE on # the LF band, then sums the results. # This check runs AFTER the multiband check (multiband acts first if also set). if params.lf_split_hz > 0.0 and params.mode == "soft": return _declip_with_lf_split(yc, params) if params.multiband and params.mode == "soft": from dataclasses import replace as _dc_replace crossovers = list(params.band_crossovers) n_bands = len(crossovers) + 1 sr = params.sample_rate # Per-band delta_db: use band_delta_db if fully specified, else fall back if len(params.band_delta_db) == n_bands: band_deltas = list(params.band_delta_db) else: band_deltas = [params.delta_db] * n_bands # Split signal into bands using cascaded LP / HP = input − LP sig_1d = yc if yc.ndim == 1 else None # handle below per-channel if yc.ndim == 2: # Process each channel’s bands independently, same crossovers n_samp, n_ch = yc.shape out = np.zeros_like(yc) all_masks = [] for c in range(n_ch): ch_sig = yc[:, c] ch_out = np.zeros(n_samp) ch_masks = [] remainder = ch_sig.copy() for b, (fc, d_db) in enumerate(zip(crossovers, band_deltas[:-1])): lp, remainder = _lr_split(remainder, fc, sr) band_params = _dc_replace(params, multiband=False, delta_db=d_db) band_fixed, band_mask = declip(lp, band_params) ch_out += band_fixed ch_masks.append(band_mask) # Last band (remainder is the HP) band_params = _dc_replace(params, multiband=False, delta_db=band_deltas[-1]) band_fixed, band_mask = declip(remainder, band_params) ch_out += band_fixed ch_masks.append(band_mask) out[:, c] = ch_out all_masks.append(ch_masks) return out, all_masks else: # Mono multiband out = np.zeros_like(yc) all_masks = [] remainder = yc.copy() for b, (fc, d_db) in enumerate(zip(crossovers, band_deltas[:-1])): lp, remainder = _lr_split(remainder, fc, sr) band_params = _dc_replace(params, multiband=False, delta_db=d_db) band_fixed, band_mask = declip(lp, band_params) out += band_fixed all_masks.append(band_mask) # Last band band_params = _dc_replace(params, multiband=False, delta_db=band_deltas[-1]) band_fixed, band_mask = declip(remainder, band_params) out += band_fixed all_masks.append(band_mask) return out, all_masks # ── Normalisation fix ──────────────────────────────────────────────── # SPADE recovers values *above* tau at formerly-clipped positions. # If the input is at the digital ceiling (tau = 1.0), those recovered # values exceed 1.0 and any hard np.clip(-1,1) by the caller destroys # all improvement, making the output identical to the input. # Fix: normalise so tau < 1.0 before processing; undo normalisation after. NORM_TARGET = 0.9 global_peak = float(np.max(np.abs(yc))) if global_peak > NORM_TARGET: scale = NORM_TARGET / global_peak # < 1 yc_norm = yc * scale else: scale = 1.0 yc_norm = yc # ── GPU detection (once, shared across all channels) ───────────────── gpu_dev = _resolve_gpu_device(params) # ── Mono path ──────────────────────────────────────────────────────── if yc_norm.ndim == 1: tau = float(np.max(np.abs(yc_norm))) if tau == 0.0: warnings.warn("Input signal is all zeros.") return yc.copy(), _compute_masks(yc, 0.0) if gpu_dev is not None: # GPU path: single channel, no threading needed if params.show_progress: N_frames = int(np.ceil(len(yc_norm) / params.hop_length)) prog = _make_progress(1) with prog: task = prog.add_task("mono", total=N_frames) fixed, masks = _declip_mono_gpu( yc_norm, params, tau, ch_label="mono", device=gpu_dev, progress_ctx=prog, task_id=task, ) else: fixed, masks = _declip_mono_gpu( yc_norm, params, tau, ch_label="mono", device=gpu_dev, ) else: # CPU path (v8/v9) n_workers = params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1 if params.show_progress: N_frames = int(np.ceil(len(yc_norm) / params.hop_length)) prog = _make_progress(1) with prog: task = prog.add_task("mono", total=N_frames) fixed, masks = _declip_mono( yc_norm, params, tau, frame_workers=n_workers, progress_ctx=prog, task_id=task, ) else: fixed, masks = _declip_mono(yc_norm, params, tau, frame_workers=n_workers) return fixed / scale, masks # ── Multi-channel path ─────────────────────────────────────────────── if yc_norm.ndim != 2: raise ValueError( f"yc must be 1-D (mono) or 2-D (samples x channels), got shape {yc.shape}" ) n_samples, n_ch = yc_norm.shape # Global tau: same hardware threshold for all channels tau = float(np.max(np.abs(yc_norm))) if tau == 0.0: warnings.warn("Input signal is all zeros.") empty_masks = [_compute_masks(yc[:, c], 0.0) for c in range(n_ch)] return yc.copy(), empty_masks # Channel labels: L/R for stereo, Ch0/Ch1/… for more if n_ch == 2: labels = ["L", "R"] else: labels = ["Ch" + str(c) for c in range(n_ch)] if params.verbose: print(f"[declip] {n_ch}-channel signal | " f"tau={tau:.4f} | mode={params.mode.upper()} | " + (f"device={gpu_dev}" if gpu_dev else f"n_jobs={params.n_jobs}") + (f" | delta_db={params.delta_db:.2f}" if params.mode == "soft" else "")) # ── Parallel / sequential dispatch ─────────────────────────────────── N_frames = int(np.ceil(n_samples / params.hop_length)) prog = _make_progress(n_ch) if params.show_progress else None if gpu_dev is not None: # GPU path: channels processed sequentially (GPU already uses all VRAM # for the frame batch; no benefit from running channels concurrently) def _process_channel(c: int, task_id=None): return _declip_mono_gpu( yc_norm[:, c], params, tau, ch_label=labels[c], device=gpu_dev, progress_ctx=prog, task_id=task_id, ) else: # CPU path: two-level parallelism (channel-workers × frame-workers) total_workers = params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1 channel_workers = min(total_workers, n_ch) frame_workers_ch = max(1, total_workers // channel_workers) def _process_channel(c: int, task_id=None): return _declip_mono( yc_norm[:, c], params, tau, ch_label=labels[c], frame_workers=frame_workers_ch, progress_ctx=prog, task_id=task_id, ) # Channel-level concurrency: GPU uses 1 worker (sequential), CPU uses n_ch ch_workers = 1 if gpu_dev is not None else min( params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1, n_ch ) def _run(): if prog is not None: task_ids = [prog.add_task(labels[c], total=N_frames) for c in range(n_ch)] else: task_ids = [None] * n_ch if ch_workers == 1: return [_process_channel(c, task_ids[c]) for c in range(n_ch)] else: with ThreadPoolExecutor(max_workers=ch_workers) as pool: futures = [pool.submit(_process_channel, c, task_ids[c]) for c in range(n_ch)] return [f.result() for f in futures] if prog is not None: with prog: results = _run() else: results = _run() # Reassemble into (N_samples, N_channels) fixed_channels = [r[0] for r in results] masks_list = [r[1] for r in results] x_out = np.column_stack(fixed_channels) / scale return x_out, masks_list # ============================================================================ # Quality metrics # ============================================================================ def sdr(reference: np.ndarray, estimate: np.ndarray) -> float: """ Signal-to-Distortion Ratio (dB). Definition from eq.(14) in [2]: SDR(u, v) = 10 log₁₀( ‖u‖² / ‖u − v‖² ) """ noise = reference - estimate denom = np.sum(noise ** 2) if denom < 1e-20: return float("inf") return 10.0 * np.log10(np.sum(reference ** 2) / denom) def delta_sdr( reference: np.ndarray, clipped: np.ndarray, estimate: np.ndarray, ) -> float: """ ΔSDR improvement (dB) — eq.(13) in [2]: ΔSDR = SDR(x, x̂) − SDR(x, y) """ return sdr(reference, estimate) - sdr(reference, clipped) # ============================================================================ # Command-line interface # ============================================================================ def _build_parser() -> argparse.ArgumentParser: p = argparse.ArgumentParser( description="SPADE Audio Declipping / Limiter Recovery (v13)", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) p.add_argument("input", help="Input clipped / limited audio file (WAV, FLAC, ...)") p.add_argument("output", help="Output restored audio file") p.add_argument("--algo", choices=["sspade", "aspade"], default="sspade") p.add_argument("--window-length", type=int, default=1024, dest="window_length") p.add_argument("--hop-length", type=int, default=256, dest="hop_length") p.add_argument("--frame", choices=["dct", "rdft"], default="rdft") p.add_argument("--s", type=int, default=1) p.add_argument("--r", type=int, default=1) p.add_argument("--eps", type=float, default=0.1) p.add_argument("--max-iter", type=int, default=1000, dest="max_iter") p.add_argument("--n-jobs", type=int, default=1, dest="n_jobs", help="CPU parallel workers for multi-channel (-1 = all cores). " "Ignored when GPU is active.") p.add_argument("--mode", choices=["hard", "soft"], default="hard", help="'hard' = standard clipping recovery; " "'soft' = brickwall limiter recovery") p.add_argument("--delta-db", type=float, default=1.0, dest="delta_db", help="[soft mode] dB below 0 dBFS where the limiter starts acting " "(e.g. 2.5 means threshold at -2.5 dBFS)") p.add_argument("--gpu-device", type=str, default="auto", dest="gpu_device", help="PyTorch device for GPU path: 'auto', 'cuda', 'cuda:0', 'cpu'. " "AMD ROCm GPUs appear as 'cuda' in PyTorch-ROCm.") p.add_argument("--no-gpu", action="store_true", dest="no_gpu", help="Disable GPU acceleration; use CPU (v8/v9 threading) path instead.") # v11 delimiting features p.add_argument("--release-ms", type=float, default=0.0, dest="release_ms", help="[v11, soft] Limiter release time in ms for mask dilation " "(0 = disabled, typical 10-50 ms)") p.add_argument("--max-gain-db", type=float, default=0.0, dest="max_gain_db", help="[v11, soft] Max transient recovery in dB above limited value " "(0 = disabled, e.g. 6 for +6 dB cap)") p.add_argument("--multiband", action="store_true", help="[v11, soft] Enable Linkwitz-Riley sub-band processing") p.add_argument("--band-crossovers", type=float, nargs="+", default=[250.0, 4000.0], dest="band_crossovers", help="[v11] Crossover frequencies in Hz (e.g. 250 4000)") p.add_argument("--band-delta-db", type=float, nargs="+", default=[], dest="band_delta_db", help="[v11] Per-band delta_db values (must match number of bands)") p.add_argument("--macro-expand", action="store_true", dest="macro_expand", help="[v11, soft] Enable macro-dynamics upward expansion pre-pass") p.add_argument("--macro-attack-ms", type=float, default=10.0, dest="macro_attack_ms", help="[v11] Expander attack time (ms, default 10)") p.add_argument("--macro-release-ms", type=float, default=200.0, dest="macro_release_ms", help="[v11] Expander release time (ms, default 200)") p.add_argument("--macro-ratio", type=float, default=1.2, dest="macro_ratio", help="[v11] Expansion ratio >1.0 (default 1.2; 1.0 = bypass)") # v13: dedicated LF transient recovery p.add_argument("--lf-split-hz", type=float, default=0.0, dest="lf_split_hz", help="[v13, soft] LR crossover (Hz) for dedicated LF subband SPADE. " "0 = disabled (v11 behaviour). Typical: 400-600 Hz for kick body.") p.add_argument("--lf-window-length", type=int, default=0, dest="lf_window_length", help="[v13] WOLA window for LF pass (0 = inherit --window-length). " "Recommended: 2048 or 4096.") p.add_argument("--lf-hop-length", type=int, default=0, dest="lf_hop_length", help="[v13] WOLA hop for LF pass (0 = lf-window-length // 4).") p.add_argument("--lf-max-iter", type=int, default=0, dest="lf_max_iter", help="[v13] Max ADMM iterations for LF pass (0 = inherit --max-iter). " "Recommended: 1500-2000.") p.add_argument("--lf-eps", type=float, default=0.0, dest="lf_eps", help="[v13] Convergence threshold for LF pass (0 = inherit --eps).") p.add_argument("--lf-delta-db", type=float, default=0.0, dest="lf_delta_db", help="[v13] delta_db override for LF band (0 = inherit --delta-db).") p.add_argument("--lf-max-gain-db", type=float, default=0.0, dest="lf_max_gain_db", help="[v13] max_gain_db cap for LF pass (0 = inherit --max-gain-db).") p.add_argument("--lf-release-ms", type=float, default=-1.0, dest="lf_release_ms", help="[v13] Mask dilation release (ms) for LF pass " "(-1 = inherit --release-ms).") p.add_argument("--lf-s", type=int, default=0, dest="lf_s", help="[v13] Sparsity step for LF pass (0 = inherit --s).") p.add_argument("--lf-r", type=int, default=0, dest="lf_r", help="[v13] Sparsity relaxation period for LF pass (0 = inherit --r).") p.add_argument("--verbose", action="store_true") p.add_argument("--reference", default=None, help="Clean reference file for delta-SDR measurement") return p def main() -> None: try: import soundfile as sf except ImportError: raise SystemExit("Install soundfile: pip install soundfile") args = _build_parser().parse_args() yc, sr = sf.read(args.input, always_2d=True) # shape: (N, C) always yc = yc.astype(float) n_samp, n_ch = yc.shape print("Input :", args.input, "|", n_samp, "samples @", sr, "Hz |", n_ch, "channel(s)") params = DeclipParams( algo=args.algo, window_length=args.window_length, hop_length=args.hop_length, frame=args.frame, s=args.s, r=args.r, eps=args.eps, max_iter=args.max_iter, verbose=args.verbose, n_jobs=args.n_jobs, mode=args.mode, delta_db=args.delta_db, use_gpu=not args.no_gpu, gpu_device=args.gpu_device, # v11: delimiting features sample_rate=sr, release_ms=args.release_ms, max_gain_db=args.max_gain_db, multiband=args.multiband, band_crossovers=tuple(args.band_crossovers), band_delta_db=tuple(args.band_delta_db), macro_expand=args.macro_expand, macro_attack_ms=args.macro_attack_ms, macro_release_ms=args.macro_release_ms, macro_ratio=args.macro_ratio, # v13: dedicated LF transient recovery lf_split_hz=args.lf_split_hz, lf_window_length=args.lf_window_length, lf_hop_length=args.lf_hop_length, lf_max_iter=args.lf_max_iter, lf_eps=args.lf_eps, lf_delta_db=args.lf_delta_db, lf_max_gain_db=args.lf_max_gain_db, lf_release_ms=args.lf_release_ms, lf_s=args.lf_s, lf_r=args.lf_r, ) # Pass 1-D array for mono so return type stays ClippingMasks (not list) yc_in = yc[:, 0] if n_ch == 1 else yc fixed, masks = declip(yc_in, params) # NOTE: do NOT clip to [-1, 1] — recovered transients may legitimately # exceed 1.0. Write as 32-bit float to preserve them. # soundfile always wants 2-D for write fixed_2d = fixed[:, None] if fixed.ndim == 1 else fixed sf.write(args.output, fixed_2d.astype(np.float32), sr, subtype="FLOAT") print("Output :", args.output) # Per-channel clipping summary masks_iter = [masks] if n_ch == 1 else masks labels = ["L", "R"] if n_ch == 2 else ["Ch" + str(c) for c in range(n_ch)] for m, lbl in zip(masks_iter, labels): n_clip = int(np.sum(~m.Ir)) pct = 100.0 * n_clip / n_samp print(" [" + lbl + "] clipped:", n_clip, "/", n_samp, "samples (" + str(round(pct, 1)) + "%)") # Optional SDR vs. clean reference if args.reference: ref, _ = sf.read(args.reference, always_2d=True) ref = ref.astype(float) L = min(ref.shape[0], fixed_2d.shape[0]) for c in range(min(n_ch, ref.shape[1])): lbl = labels[c] r_c = ref[:L, c] y_c = yc[:L, c] f_c = fixed_2d[:L, c] print(" [" + lbl + "]" " SDR clipped=" + str(round(sdr(r_c, y_c), 2)) + " dB" " declipped=" + str(round(sdr(r_c, f_c), 2)) + " dB" " delta=" + str(round(delta_sdr(r_c, y_c, f_c), 2)) + " dB") # ============================================================================= # Demo / self-test (mono + stereo) # ============================================================================= def _demo() -> None: """ Self-test: mono and stereo synthetic signals, both algorithms, both frames. """ print("=" * 65) print("SPADE Declipping v3 — Self-Test (mono + stereo)") print("=" * 65) sr = 16_000 t = np.linspace(0, 1, sr, endpoint=False) def make_tonal(freqs_amps): sig = sum(a * np.sin(2 * np.pi * f * t) for f, a in freqs_amps) return sig / np.max(np.abs(sig)) clean_L = make_tonal([(440, 0.5), (880, 0.3), (1320, 0.15)]) clean_R = make_tonal([(550, 0.5), (1100, 0.3), (2200, 0.1)]) clean_stereo = np.column_stack([clean_L, clean_R]) # (N, 2) theta_c = 0.6 clipped_stereo = np.clip(clean_stereo, -theta_c, theta_c) n_clip_L = np.mean(np.abs(clipped_stereo[:, 0]) >= theta_c) * 100 n_clip_R = np.mean(np.abs(clipped_stereo[:, 1]) >= theta_c) * 100 print("\ntheta_c =", theta_c, " | L clipped:", str(round(n_clip_L, 1)) + "%", " R clipped:", str(round(n_clip_R, 1)) + "%") for algo in ("sspade", "aspade"): for fr in ("dct", "rdft"): params = DeclipParams( algo=algo, frame=fr, window_length=1024, hop_length=256, s=1, r=1, eps=0.1, max_iter=500, n_jobs=2, # process L and R in parallel verbose=False, ) fixed, masks_list = declip(clipped_stereo, params) dsdr_L = delta_sdr(clean_stereo[:, 0], clipped_stereo[:, 0], fixed[:, 0]) dsdr_R = delta_sdr(clean_stereo[:, 1], clipped_stereo[:, 1], fixed[:, 1]) tag = algo.upper() + " + " + fr.upper() print(" " + tag + " | L DSDR=" + str(round(dsdr_L, 1)) + " dB" " R DSDR=" + str(round(dsdr_R, 1)) + " dB") # Quick mono sanity check print("\n--- Mono sanity check ---") clipped_mono = np.clip(clean_L, -theta_c, theta_c) params_mono = DeclipParams(algo="sspade", frame="rdft", window_length=1024, hop_length=256, s=1, r=1, eps=0.1, max_iter=500) fixed_mono, _ = declip(clipped_mono, params_mono) print(" SSPADE+RDFT mono DSDR =", str(round(delta_sdr(clean_L, clipped_mono, fixed_mono), 1)), "dB") print("\nSelf-test complete.") if __name__ == "__main__": import sys if "--demo" in sys.argv: _demo() else: main()