refine(synth): Make Bass Boost frequency-dependent to prevent muddiness

Upgrades the 8-bit synthesizer's Bass Boost feature to be "intelligent."

The effect is now dynamically scaled based on the note's pitch, so it is strongest on mid/high-frequency notes and automatically fades out on low-frequency notes. This prevents the muddiness and clipping that previously occurred when boosting an already deep bassline.

A new UI slider allows users to control the cutoff frequency for this behavior.

app.py

@@ -177,6 +177,7 @@ class AppParameters:
     s8bit_noise_lowpass_hz: float = 9000.0                # Lowpass filter frequency for noise
     s8bit_harmonic_lowpass_factor: float = 12.0           # Multiplier for frequency-dependent lowpass filter
     s8bit_final_gain: float = 0.8                         # Final gain/limiter level to prevent clipping
+    s8bit_bass_boost_cutoff_hz: float = 200.0             # Parameter for Intelligent Bass Boost
 
     # --- MIDI Pre-processing to Reduce Harshness ---
     s8bit_enable_midi_preprocessing: bool = True       # Master switch for this feature
@@ -1046,19 +1047,33 @@ def synthesize_8bit_style(*, midi_data: pretty_midi.PrettyMIDI,  fs: int, params
                 edge_smooth_ms = getattr(params, 's8bit_edge_smoothing_ms', 0.5)
                 note_waveform = smooth_square_or_saw(note_waveform, fs, smooth_ms=edge_smooth_ms)
 
-        # --- Bass Boost (Sub-Octave Oscillator) ---
+        # --- Intelligent Bass Boost (Frequency-Dependent) ---
         if params.s8bit_bass_boost_level > 0:
-            bass_freq = freq / 2.0
-            # Only add bass if the frequency is reasonably audible
-            if bass_freq > 20:
-                # Bass uses a simple square wave, no vibrato, for stability
-                bass_phase_inc = 2 * np.pi * bass_freq / fs
-                bass_phase = np.cumsum(np.full(num_samples, bass_phase_inc))
-                bass_sub_waveform = signal.square(bass_phase, duty=0.5)
-                # Mix the main and bass waveforms.
-                # As bass level increases, slightly decrease main waveform volume to prevent clipping.
-                main_level = 1.0 - (0.5 * params.s8bit_bass_boost_level)
-                note_waveform = (note_waveform * main_level) + (bass_sub_waveform * params.s8bit_bass_boost_level)
+            # --- Step 1: Calculate the dynamic boost level for this specific note ---
+            cutoff_hz = getattr(params, 's8bit_bass_boost_cutoff_hz', 200.0)
+            
+            # Create a smooth fade-out curve for the boost effect.
+            # The effect is at 100% strength at the cutoff frequency,
+            # and fades to 0% at half the cutoff frequency.
+            # `clip` ensures the value is between 0 and 1.
+            dynamic_boost_scale = np.clip((freq - (cutoff_hz / 2)) / (cutoff_hz / 2), 0, 1)
+            
+            # The final boost level is the user's setting multiplied by our dynamic scale.
+            final_boost_level = params.s8bit_bass_boost_level * dynamic_boost_scale
+            
+            # --- Step 2: Apply the boost only if it's still audible ---
+            if final_boost_level > 0.01: # A small threshold to avoid unnecessary computation
+                bass_freq = freq / 2.0
+                # Only add bass if the frequency is reasonably audible
+                if bass_freq > 20:
+                    # Bass uses a simple square wave, no vibrato, for stability
+                    bass_phase_inc = 2 * np.pi * bass_freq / fs
+                    bass_phase = np.cumsum(np.full(num_samples, bass_phase_inc))
+                    bass_sub_waveform = signal.square(bass_phase, duty=0.5)
+                    
+                    # The ducking amount is now also dynamic.
+                    main_level = 1.0 - (0.5 * final_boost_level)
+                    note_waveform = (note_waveform * main_level) + (bass_sub_waveform * final_boost_level)
                 
         # --- Noise & Distortion (Reordered and Improved) ---
         if params.s8bit_noise_level > 0:
@@ -3725,6 +3740,12 @@ if __name__ == "__main__":
                             label="Bass Boost Level", 
                             info="Mixes in a sub-octave (a square wave one octave lower). Low values have no effect; high values add significant weight and power."
                         )
+                        # UI control for Intelligent Bass Boost
+                        s8bit_bass_boost_cutoff_hz = gr.Slider(
+                            50.0, 500.0, value=200.0, step=10.0,
+                            label="Bass Boost Cutoff (Hz)",
+                            info="Intelligent Bass Boost: The boost effect will gradually fade out for notes BELOW this frequency, preventing muddiness in the low-end."
+                        )
                         s8bit_smooth_notes_level = gr.Slider(
                             0.0, 1.0, value=0.0, step=0.05, 
                             label="Smooth Notes Level",