v0.3.1: NR mode selection (stationary/adaptive/auto) + advanced parameters

- Add stationary/adaptive/auto mode to noise reduction with auto-mode
  logic: stationary when stem-guided profile available, adaptive otherwise
- Add advanced NR dialog (threshold, freq/time smoothing, GPU toggle)
- Add torch/CUDA auto-detection for GPU-accelerated noise reduction
- Update defaults: HPF 100 Hz, EQ bright preset, limiter -0.7 dB
- 10 new tests (7 noise_reduction + 3 effects)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Artemarius

tests/test_effects.py

@@ -478,3 +478,36 @@ def test_eq_compressor_limiter_integration(self):
         assert result.shape == data.shape
         assert result.dtype == np.float32
         assert np.all(np.isfinite(result))
+
+
+# --- Spectral Noise Reduction wrapper tests ---
+
+
+class TestSpectralNoiseReduction:
+
+    def test_mode_param_accepted(self):
+        """Wrapper should accept mode kwarg without error."""
+        data = _make_tone(duration_s=2.0)
+        result = spectral_noise_reduction(data, SR, strength=0.5, mode="adaptive")
+        assert result.shape == data.shape
+        assert result.dtype == np.float32
+
+    def test_advanced_params_accepted(self):
+        """All new kwargs should pass through to reduce_noise."""
+        data = _make_tone(duration_s=2.0)
+        result = spectral_noise_reduction(
+            data, SR, strength=0.5, mode="stationary",
+            n_std_thresh=2.0, use_torch=False,
+            freq_smooth_hz=300, time_smooth_ms=80,
+        )
+        assert result.shape == data.shape
+        assert np.all(np.isfinite(result))
+
+    def test_default_config_includes_mode(self):
+        """DEFAULT_CONFIG should have mode='auto' for spectral_noise_reduction."""
+        snr_cfg = DEFAULT_CONFIG["spectral_noise_reduction"]
+        assert snr_cfg["mode"] == "auto"
+        assert "n_std_thresh" in snr_cfg
+        assert "use_torch" in snr_cfg
+        assert "freq_smooth_hz" in snr_cfg
+        assert "time_smooth_ms" in snr_cfg

tests/test_noise_reduction.py

@@ -255,3 +255,93 @@ def test_reduce_noise_with_hpf():
     # The 440 Hz tone should be preserved, the 40 Hz rumble attenuated
     corr_tone = np.corrcoef(tone, result)[0, 1]
     assert corr_tone > 0.95
+
+
+# --- Mode selection tests ---
+
+
+def test_stationary_mode_explicit():
+    """mode='stationary' with explicit noise clip should reduce noise."""
+    rng = np.random.default_rng(42)
+    noise_only = (0.1 * rng.standard_normal(SR // 2)).astype(np.float32)
+    tone_noisy = _make_noisy_tone(duration_s=1.5, noise_level=0.1)
+    signal = np.concatenate([noise_only, tone_noisy])
+    noise_clip = signal[:SR // 2]
+
+    reduced = reduce_noise(signal, SR, noise_clip=noise_clip,
+                           strength=1.0, mode="stationary")
+    original_rms = np.sqrt(np.mean(signal[:SR // 2].astype(np.float64) ** 2))
+    reduced_rms = np.sqrt(np.mean(reduced[:SR // 2].astype(np.float64) ** 2))
+    assert reduced_rms < original_rms
+
+
+def test_adaptive_mode_explicit():
+    """mode='adaptive' should reduce noise without explicit noise clip."""
+    noisy = _make_noisy_tone(duration_s=2.0, noise_level=0.15)
+    reduced = reduce_noise(noisy, SR, strength=0.75, mode="adaptive")
+    assert reduced.shape == noisy.shape
+    assert reduced.dtype == np.float32
+
+
+def test_auto_mode_with_guide_stem_uses_stationary():
+    """Auto mode with a good stem should use stationary (stronger NR)."""
+    rng = np.random.default_rng(42)
+    silence = np.zeros(SR, dtype=np.float32)
+    tone = _make_tone(duration_s=1.0, freq=440)
+    vocal_sep = np.concatenate([silence, tone])
+
+    noise_full = (0.1 * rng.standard_normal(SR * 2)).astype(np.float32)
+    vocal_rec = noise_full.copy()
+    vocal_rec[SR:] += tone
+
+    reduced = reduce_noise(vocal_rec, SR, strength=1.0,
+                           guide_stem=vocal_sep, mode="auto")
+    # Should successfully reduce noise in the silent region
+    original_rms = np.sqrt(np.mean(vocal_rec[:SR].astype(np.float64) ** 2))
+    reduced_rms = np.sqrt(np.mean(reduced[:SR].astype(np.float64) ** 2))
+    assert reduced_rms < original_rms
+
+
+def test_auto_mode_without_guide_uses_adaptive():
+    """Auto mode without stem or clip should fallback to adaptive."""
+    noisy = _make_noisy_tone(duration_s=2.0, noise_level=0.1)
+    reduced = reduce_noise(noisy, SR, strength=0.75, mode="auto")
+    assert reduced.shape == noisy.shape
+    assert reduced.dtype == np.float32
+
+
+def test_smoothing_parameters_accepted():
+    """Custom freq/time smoothing values should not crash."""
+    noisy = _make_noisy_tone(duration_s=1.0, noise_level=0.1)
+    result = reduce_noise(noisy, SR, strength=0.5,
+                          freq_smooth_hz=200, time_smooth_ms=100)
+    assert result.shape == noisy.shape
+    assert np.all(np.isfinite(result))
+
+
+def test_n_std_thresh_parameter():
+    """Lower n_std_thresh should produce more aggressive noise reduction."""
+    rng = np.random.default_rng(42)
+    noise_only = (0.1 * rng.standard_normal(SR // 2)).astype(np.float32)
+    tone_noisy = _make_noisy_tone(duration_s=1.5, noise_level=0.1)
+    signal = np.concatenate([noise_only, tone_noisy])
+    noise_clip = signal[:SR // 2]
+
+    reduced_mild = reduce_noise(signal, SR, noise_clip=noise_clip,
+                                strength=1.0, mode="stationary",
+                                n_std_thresh=3.0)
+    reduced_aggressive = reduce_noise(signal, SR, noise_clip=noise_clip,
+                                      strength=1.0, mode="stationary",
+                                      n_std_thresh=0.5)
+    rms_mild = np.sqrt(np.mean(reduced_mild[:SR // 2].astype(np.float64) ** 2))
+    rms_aggressive = np.sqrt(np.mean(
+        reduced_aggressive[:SR // 2].astype(np.float64) ** 2))
+    assert rms_aggressive <= rms_mild
+
+
+def test_use_torch_false_explicit():
+    """use_torch=False should work (CPU path)."""
+    noisy = _make_noisy_tone(duration_s=1.0, noise_level=0.1)
+    result = reduce_noise(noisy, SR, strength=0.5, use_torch=False)
+    assert result.shape == noisy.shape
+    assert result.dtype == np.float32

vocalforge/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.0"
+__version__ = "0.3.1"

vocalforge/audio/effects.py

@@ -46,6 +46,11 @@
         "stub": False,
         "strength": 0.75,
         "guide_stem": None,
+        "mode": "auto",
+        "n_std_thresh": 1.5,
+        "use_torch": None,
+        "freq_smooth_hz": 500,
+        "time_smooth_ms": 50,
     },
     "dereverb": {
         "enabled": False,
@@ -56,12 +61,12 @@
     "highpass_filter": {
         "enabled": True,
         "stub": False,
-        "cutoff_hz": 80.0,
+        "cutoff_hz": 100.0,
     },
     "parametric_eq": {
         "enabled": False,
         "stub": False,
-        "preset": "clean_up",
+        "preset": "bright",
         "bands": None,  # filled from EQ_PRESETS at import time (see below)
     },
     "compressor": {
@@ -86,7 +91,7 @@
     "limiter": {
         "enabled": True,
         "stub": False,
-        "ceiling_db": -1.0,
+        "ceiling_db": -0.7,
         "release_ms": 50.0,
     },
 }
@@ -97,26 +102,26 @@
     "Clean": {
         "noise_gate": {"enabled": True, "threshold_db": -35.0, "attack_ms": 2.0,
                         "release_ms": 100.0, "hold_ms": 50.0, "reduction_db": -40.0},
-        "spectral_noise_reduction": {"enabled": True, "strength": 0.75},
+        "spectral_noise_reduction": {"enabled": True, "strength": 0.75, "mode": "auto"},
         "dereverb": {"enabled": False},
-        "highpass_filter": {"enabled": True, "cutoff_hz": 80.0},
+        "highpass_filter": {"enabled": True, "cutoff_hz": 100.0},
         "parametric_eq": {"enabled": False},
         "compressor": {"enabled": False},
         "de_esser": {"enabled": False},
         "reverb": {"enabled": False},
-        "limiter": {"enabled": True, "ceiling_db": -1.0},
+        "limiter": {"enabled": True, "ceiling_db": -0.7},
     },
     "Enhanced": {
         "noise_gate": {"enabled": True, "threshold_db": -35.0, "attack_ms": 2.0,
                         "release_ms": 100.0, "hold_ms": 50.0, "reduction_db": -40.0},
-        "spectral_noise_reduction": {"enabled": True, "strength": 0.75},
+        "spectral_noise_reduction": {"enabled": True, "strength": 0.75, "mode": "auto"},
         "dereverb": {"enabled": True, "strength": 0.5},
-        "highpass_filter": {"enabled": True, "cutoff_hz": 80.0},
-        "parametric_eq": {"enabled": True, "preset": "clean_up"},
+        "highpass_filter": {"enabled": True, "cutoff_hz": 100.0},
+        "parametric_eq": {"enabled": True, "preset": "bright"},
         "compressor": {"enabled": True, "threshold_db": -18.0, "ratio": 3.0},
         "de_esser": {"enabled": False},
         "reverb": {"enabled": False},
-        "limiter": {"enabled": True, "ceiling_db": -1.0},
+        "limiter": {"enabled": True, "ceiling_db": -0.7},
     },
 }
 
@@ -142,7 +147,7 @@
 }
 
 # Patch DEFAULT_CONFIG with actual EQ bands now that EQ_PRESETS is defined
-DEFAULT_CONFIG["parametric_eq"]["bands"] = EQ_PRESETS["clean_up"]
+DEFAULT_CONFIG["parametric_eq"]["bands"] = EQ_PRESETS["bright"]
 
 
 def _merge_config(defaults: dict, overrides: dict | None) -> dict:
@@ -271,6 +276,11 @@ def spectral_noise_reduction(data: np.ndarray, sr: int, **params) -> np.ndarray:
     """
     strength = params.get("strength", 0.75)
     guide_stem = params.get("guide_stem", None)
+    mode = params.get("mode", "auto")
+    n_std_thresh = params.get("n_std_thresh", 1.5)
+    use_torch = params.get("use_torch", None)
+    freq_smooth_hz = params.get("freq_smooth_hz", 500)
+    time_smooth_ms = params.get("time_smooth_ms", 50)
 
     if strength == 0.0:
         return data
@@ -282,6 +292,11 @@ def spectral_noise_reduction(data: np.ndarray, sr: int, **params) -> np.ndarray:
         strength=strength,
         guide_stem=guide_stem,
         hpf_cutoff_hz=0.0,
+        mode=mode,
+        n_std_thresh=n_std_thresh,
+        use_torch=use_torch,
+        freq_smooth_hz=freq_smooth_hz,
+        time_smooth_ms=time_smooth_ms,
     )
 
 

vocalforge/audio/noise_reduction.py

@@ -157,6 +157,11 @@ def reduce_noise(
     strength: float = 1.0,
     guide_stem: np.ndarray | None = None,
     hpf_cutoff_hz: float = 0.0,
+    mode: str = "auto",
+    n_std_thresh: float = 1.5,
+    use_torch: bool | None = None,
+    freq_smooth_hz: float = 500,
+    time_smooth_ms: float = 50,
 ) -> np.ndarray:
     """Apply spectral-gating noise reduction to audio.
 
@@ -170,6 +175,14 @@ def reduce_noise(
         guide_stem: Optional separated vocal stem used to find silent regions
             for noise profiling.  Only used when noise_clip is None.
         hpf_cutoff_hz: High-pass filter cutoff in Hz.  0 = disabled.
+        mode: NR algorithm mode — "auto", "stationary", or "adaptive".
+            "auto" uses stationary when a reliable noise profile is available
+            (explicit clip or stem-guided), adaptive otherwise.
+        n_std_thresh: Stationary mode threshold sensitivity (0.5–3.0).
+        use_torch: Whether to use torch/CUDA acceleration.
+            None = auto-detect CUDA availability.
+        freq_smooth_hz: Frequency mask smoothing width in Hz.
+        time_smooth_ms: Temporal mask smoothing width in ms.
 
     Returns:
         Noise-reduced audio, same shape and dtype (float32) as input.
@@ -190,11 +203,33 @@ def reduce_noise(
 
     import noisereduce as nr
 
+    # Track whether we obtained a high-quality noise profile
+    _had_good_profile = noise_clip is not None  # user supplied explicitly
+
     if noise_clip is None and guide_stem is not None:
         noise_clip = estimate_noise_from_stem(data, guide_stem, sample_rate)
+        if noise_clip is not None:
+            _had_good_profile = True  # stem-guided = good quality
 
     if noise_clip is None:
         noise_clip = estimate_noise_profile(data, sample_rate)
+        # _had_good_profile stays False — first-0.5s fallback is weak
+
+    # Resolve mode → boolean
+    if mode == "auto":
+        stationary = _had_good_profile  # stationary when profile is reliable
+    elif mode == "stationary":
+        stationary = True
+    else:  # "adaptive"
+        stationary = False
+
+    # Torch / CUDA auto-detection
+    if use_torch is None:
+        try:
+            import torch
+            use_torch = torch.cuda.is_available()
+        except ImportError:
+            use_torch = False
 
     is_mono = data.ndim == 1
 
@@ -211,6 +246,12 @@ def reduce_noise(
         sr=sample_rate,
         y_noise=y_noise,
         prop_decrease=float(strength),
+        stationary=stationary,
+        n_std_thresh_stationary=float(n_std_thresh),
+        use_torch=use_torch,
+        device="cuda" if use_torch else "cpu",
+        freq_mask_smooth_hz=float(freq_smooth_hz),
+        time_mask_smooth_ms=float(time_smooth_ms),
     )
 
     # Transpose back for multichannel