Upload dsp.py with huggingface_hub

dsp.py

@@ -3,7 +3,7 @@
 import tempfile
 import numpy as np
 from pedalboard import (
-    Pedalboard, Compressor, Limiter,
+    Pedalboard, Compressor,
     LowShelfFilter, HighShelfFilter, PeakFilter,
     HighpassFilter,
 )
@@ -14,63 +14,6 @@ from stereo import apply_stereo_width, linkwitz_riley_crossover
 from loudness import measure_loudness, measure_true_peak, normalize_to_lufs
 
 
-# ---------------------------------------------------------------------------
-# Maximizer — fill headroom between LUFS target and true-peak ceiling
-# ---------------------------------------------------------------------------
-
-def _maximize(processed, sample_rate, target_lufs, ceiling_dbtp=-0.1,
-              target_tp_min=-1.0, max_iters=4):
-    """Iterative gain + limit loop to push true peak into the target range.
-
-    If true peak is well below the ceiling after LUFS normalization (i.e. the
-    track has a high crest factor), this loop progressively reduces the crest
-    factor by:
-        1. Applying gain to bring peaks near the ceiling
-        2. Brick-wall limiting at the ceiling to shave the loudest peaks
-        3. Re-normalizing to the target LUFS
-
-    Each iteration reduces the peak-to-loudness ratio so that after
-    re-normalization the true peak lands closer to the ceiling.
-
-    Args:
-        processed: numpy array (samples, channels)
-        sample_rate: int
-        target_lufs: float — target integrated loudness
-        ceiling_dbtp: float — true-peak ceiling (default -0.1)
-        target_tp_min: float — minimum acceptable true peak (default -1.0)
-        max_iters: int — maximum iterations (default 4)
-
-    Returns:
-        processed (modified in-place where possible)
-    """
-    for _ in range(max_iters):
-        tp = measure_true_peak(processed, sample_rate)
-        headroom = ceiling_dbtp - tp  # positive = wasted headroom
-
-        if tp >= target_tp_min or headroom < 0.5:
-            break  # already in range or close enough
-
-        # Gain up so peaks approach the ceiling (leave 0.1 dB for limiter)
-        boost_db = headroom - 0.1
-        processed = (processed * 10.0 ** (boost_db / 20.0)).astype(np.float32)
-
-        # Brick-wall limit at ceiling — fast release for transparency
-        lim_board = Pedalboard([Limiter(
-            threshold_db=ceiling_dbtp,
-            release_ms=80.0,
-        )])
-        processed = lim_board(processed.T, sample_rate).T
-
-        # Re-normalize to target LUFS (limiting raised the loudness)
-        cur_lufs = measure_loudness(processed, sample_rate)
-        if not np.isinf(cur_lufs):
-            processed = normalize_to_lufs(
-                processed, sample_rate, cur_lufs, target_lufs
-            ).astype(np.float32)
-
-    return processed
-
-
 # ---------------------------------------------------------------------------
 # Slider-to-parameter mappings
 # ---------------------------------------------------------------------------
@@ -298,12 +241,6 @@ def master_audio(input_path, lows_db, mid_boost_db, highs_db, bass_boost_db,
             processed, sample_rate, pre_norm_lufs, target_lufs
         ).astype(np.float32)
 
-    # --- Stage 5.5: Maximizer — fill wasted headroom ---
-    # If true peak is well below -1.0 dBTP after LUFS normalization,
-    # iteratively gain up + limit to reduce crest factor so peaks land
-    # between -1.0 and -0.1 dBTP at the target LUFS.
-    processed = _maximize(processed, sample_rate, target_lufs)
-
     # --- Stage 6: Soft clipper (piecewise tanh saturation) ---
     # Perfectly linear below the knee; only the tips of peaks above it are
     # shaped with a tanh curve that asymptotes to the ceiling.  The knee
@@ -496,9 +433,6 @@ def master_audio_full(input_path, params, target_lufs):
             processed, sample_rate, pre_norm_lufs, target_lufs
         ).astype(np.float32)
 
-    # --- Stage 5.5: Maximizer — fill wasted headroom ---
-    processed = _maximize(processed, sample_rate, target_lufs)
-
     # --- Stage 6: Soft clipper (piecewise tanh saturation) ---
     ceiling_lin = 10.0 ** (-0.1 / 20.0)
     peak_lin = np.max(np.abs(processed))