feat(synth): Add intelligent MIDI pre-processing to reduce harshness

This commit introduces a new, optional MIDI pre-processing stage for the 8-bit synthesizer. Its purpose is to proactively "tame" MIDI characteristics that are known to cause sonic harshness and aliasing before the audio synthesis process begins.

The new pre-processor implements two main rules:

1. **High-Pitch Attenuation:**
Automatically reduces the velocity of notes that exceed a user-defined pitch threshold (e.g., C6).
This mitigates the severe aliasing that occurs when rich-harmonic waveforms (like square and saw) are synthesized at very high frequencies.

2. **Chord Compression:**
Detects loud, dense chords based on user-defined thresholds for note count and average velocity.
Reduces the velocity of all notes within such chords.
This prevents the excessive harmonic buildup that leads to a harsh, saturated, and often clipped sound when multiple loud notes are played simultaneously.

app.py

@@ -175,10 +175,74 @@ class AppParameters:
     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
 
+    # --- MIDI Pre-processing to Reduce Harshness ---
+    s8bit_enable_midi_preprocessing: bool = True       # Master switch for this feature
+    s8bit_high_pitch_threshold: int = 84               # Pitch (C6) above which velocity is scaled
+    s8bit_high_pitch_velocity_scale: float = 0.8       # Velocity multiplier for high notes (e.g., 80%)
+    s8bit_chord_density_threshold: int = 4             # Min number of notes to be considered a dense chord
+    s8bit_chord_velocity_threshold: int = 100          # Min average velocity for a chord to be tamed
+    s8bit_chord_velocity_scale: float = 0.75           # Velocity multiplier for loud, dense chords
+
 # =================================================================================================
 # === Helper Functions ===
 # =================================================================================================
 
+def preprocess_midi_for_harshness(midi_data: pretty_midi.PrettyMIDI, params: AppParameters):
+    """
+    Analyzes and modifies a PrettyMIDI object in-place to reduce characteristics
+    that can cause harshness in simple synthesizers.
+    
+    Args:
+        midi_data: The PrettyMIDI object to process.
+        params: The AppParameters object containing the control thresholds.
+    """
+    print("Running MIDI pre-processing to reduce harshness...")
+    notes_modified = 0
+    chords_tamed = 0
+
+    # Rule 1: High-Pitch Attenuation
+    for instrument in midi_data.instruments:
+        for note in instrument.notes:
+            if note.pitch > params.s8bit_high_pitch_threshold:
+                original_velocity = note.velocity
+                note.velocity = int(note.velocity * params.s8bit_high_pitch_velocity_scale)
+                if note.velocity < 1: note.velocity = 1
+                notes_modified += 1
+    
+    if notes_modified > 0:
+        print(f"  - Tamed {notes_modified} individual high-pitched notes.")
+
+    # Rule 2: Chord Compression
+    # This is a simplified approach: group notes by near-simultaneous start times
+    all_notes = sorted([note for instrument in midi_data.instruments for note in instrument.notes], key=lambda x: x.start)
+    
+    time_window = 0.02  # 20ms window to group notes into a chord
+    i = 0
+    while i < len(all_notes):
+        current_chord = [all_notes[i]]
+        # Find other notes within the time window
+        j = i + 1
+        while j < len(all_notes) and (all_notes[j].start - all_notes[i].start) < time_window:
+            current_chord.append(all_notes[j])
+            j += 1
+        
+        # Analyze and potentially tame the chord
+        if len(current_chord) >= params.s8bit_chord_density_threshold:
+            avg_velocity = sum(n.velocity for n in current_chord) / len(current_chord)
+            if avg_velocity > params.s8bit_chord_velocity_threshold:
+                chords_tamed += 1
+                for note in current_chord:
+                    note.velocity = int(note.velocity * params.s8bit_chord_velocity_scale)
+                    if note.velocity < 1: note.velocity = 1
+        
+        # Move index past the current chord
+        i = j
+        
+    if chords_tamed > 0:
+        print(f"  - Tamed {chords_tamed} loud, dense chords.")
+        
+    return midi_data # Return the modified object
+
 def one_pole_lowpass(x, cutoff_hz, fs):
     """Simple one-pole lowpass filter (causal), stable and cheap."""
     if cutoff_hz <= 0 or cutoff_hz >= fs/2:
@@ -1281,6 +1345,10 @@ def Render_MIDI(*, input_midi_path: str, params: AppParameters, progress: gr.Pro
         try:
             # Load the MIDI file with pretty_midi for manual synthesis
             midi_data_for_synth = pretty_midi.PrettyMIDI(midi_to_render_path)
+            # --- Apply MIDI Pre-processing if enabled ---
+            if getattr(params, 's8bit_enable_midi_preprocessing', False):
+                midi_data_for_synth = preprocess_midi_for_harshness(midi_data_for_synth, params)
+
             # Synthesize the waveform
             # --- Passing new FX parameters to the synthesis function ---
             audio = synthesize_8bit_style(midi_data=midi_data_for_synth, fs=srate, params=params, progress=progress)
@@ -2727,7 +2795,7 @@ if __name__ == "__main__":
                                 merge_drums_to_render = gr.Checkbox(label="Merge Drums", value=False, visible=False)
                                 merge_bass_to_render = gr.Checkbox(label="Merge Bass", value=False, visible=False)
                                 # This checkbox will have its label changed dynamically
-                                merge_other_or_accompaniment = gr.Checkbox(label="Merge Accompaniment", value=True)
+                                merge_other_or_accompaniment = gr.Checkbox(label="Merge Accompaniment", value=False)
 
                     with gr.Accordion("General Purpose Transcription Settings", open=True) as general_transcription_settings:
                         # --- Preset dropdown for basic_pitch ---
@@ -2979,10 +3047,45 @@ if __name__ == "__main__":
                                         label="Echo Trigger Threshold (x Decay Time)",
                                         info="Controls how long a note must be to trigger echoes. This value is a multiplier of the 'Decay Time'. Example: If 'Decay Time' is 0.1s and this threshold is set to 10.0, only notes longer than 1.0s (0.1 * 10.0) will produce echoes."
                                     )
-                        # --- NEW: Accordion for Anti-Aliasing and Quality Settings ---
+                        # --- Re-architected into two separate, parallel accordions ---
+                        # --- Section 1: MIDI Pre-processing ---
+                        with gr.Accordion("MIDI Pre-processing (Anti-Harshness)", open=False):
+                            s8bit_enable_midi_preprocessing = gr.Checkbox(
+                                value=True,
+                                label="Enable MIDI Pre-processing",
+                                info="Intelligently reduces the velocity of notes that are likely to cause harshness (e.g., very high notes or loud, dense chords) before synthesis begins."
+                            )
+                            with gr.Group(visible=True) as midi_preprocessing_settings_box:
+                                s8bit_high_pitch_threshold = gr.Slider(
+                                    60, 108, value=84, step=1,
+                                    label="High Pitch Threshold (MIDI Note)",
+                                    info="Notes above this pitch will have their velocity reduced. 84 = C6."
+                                )
+                                s8bit_high_pitch_velocity_scale = gr.Slider(
+                                    0.1, 1.0, value=0.8, step=0.05,
+                                    label="High Pitch Velocity Scale",
+                                    info="Multiplier for high notes' velocity (e.g., 0.8 = 80% of original velocity)."
+                                )
+                                s8bit_chord_density_threshold = gr.Slider(
+                                    2, 10, value=4, step=1,
+                                    label="Chord Density Threshold",
+                                    info="Minimum number of notes to be considered a 'dense' chord."
+                                )
+                                s8bit_chord_velocity_threshold = gr.Slider(
+                                    50, 127, value=100, step=1,
+                                    label="Chord Velocity Threshold",
+                                    info="If a dense chord's average velocity is above this, it will be tamed."
+                                )
+                                s8bit_chord_velocity_scale = gr.Slider(
+                                    0.1, 1.0, value=0.75, step=0.05,
+                                    label="Chord Velocity Scale",
+                                    info="Velocity multiplier for loud, dense chords."
+                                )
+                        
+                        # --- Section 2: Audio Post-processing, accordion for Anti-Aliasing and Quality Settings ---
                         with gr.Accordion("Audio Quality & Anti-Aliasing (Advanced)", open=False):
                             s8bit_enable_anti_aliasing = gr.Checkbox(
-                                value=True,
+                                value=False,
                                 label="Enable All Audio Quality Enhancements",
                                 info="Master toggle for all settings below. Disabling may slightly speed up rendering but can result in harsher, more aliased sound."
                             )
@@ -3132,6 +3235,12 @@ if __name__ == "__main__":
             inputs=s8bit_enable_anti_aliasing,
             outputs=anti_aliasing_settings_box
         )
+        # Event listener for the new MIDI Pre-processing settings box
+        s8bit_enable_midi_preprocessing.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=s8bit_enable_midi_preprocessing,
+            outputs=midi_preprocessing_settings_box
+        )
 
     # Launch the Gradio app
     app.queue().launch(inbrowser=True, debug=True)