feat(synth): Upgrade Delay/Echo effect to be tempo-synced

This commit refactors the MIDI Delay/Echo effect, transforming it from a static, time-based processor into a dynamic, musical tool that synchronizes with the song's rhythm.

app.py

@@ -199,7 +199,7 @@ class AppParameters:
     # --- MIDI Delay/Echo Effect Parameters ---
     s8bit_enable_delay: bool = False                   # Master switch for the delay effect
     s8bit_delay_on_melody_only: bool = True            # Apply delay only to the lead melody
-    s8bit_delay_time_s: float = 0.15                   # Time in seconds between each echo
+    s8bit_delay_division: str = "Dotted 8th Note"
     s8bit_delay_feedback: float = 0.5                  # Velocity scale for each subsequent echo (50%)
     s8bit_delay_repeats: int = 3                       # Number of echoes to generate
 
@@ -482,6 +482,7 @@ def arpeggiate_midi(midi_data: pretty_midi.PrettyMIDI, params: AppParameters):
         "Pulsing 4ths": [(0.0, 0.5)],
         "Galloping": [(0.0, 0.75), (0.75, 0.25)],
         "Simple Quarter Notes": [(0.0, 1.0)],
+        "Triplet 8ths": [(0.0, 1/3), (1/3, 1/3), (2/3, 1/3)],
     }
     selected_rhythm = rhythm_patterns.get(params.s8bit_arpeggio_rhythm, rhythm_patterns["Classic Upbeat (8th)"])
 
@@ -604,12 +605,34 @@ def create_delay_effect(midi_data: pretty_midi.PrettyMIDI, params: AppParameters
     """
     Creates a delay/echo effect by duplicating notes with delayed start times
     and scaled velocities. Can be configured to apply only to the lead melody.
+    based on the MIDI's estimated BPM and the user's selected musical division.
     """
-    print("Applying MIDI delay/echo effect...")
+    print("Applying tempo-synced MIDI delay/echo effect...")
     # Work on a deep copy to ensure the original MIDI object is not mutated.
     processed_midi = copy.deepcopy(midi_data)
-
-    # --- Step 1: Identify the notes that should receive the echo effect ---
+    
+    # --- Step 1: Estimate Tempo and Calculate Delay Time in Seconds ---
+    try:
+        bpm = midi_data.estimate_tempo()
+    except:
+        bpm = 120.0
+    print(f"  - Delay using tempo: {bpm:.2f} BPM")
+    
+    # This map defines the duration of each note division as a multiplier of a quarter note (a beat).
+    division_map = {
+        "Quarter Note": 1.0,
+        "Dotted 8th Note": 0.75,
+        "8th Note": 0.5,
+        "Triplet 8th Note": 1.0 / 3.0,
+        "16th Note": 0.25
+    }
+    beat_duration_s = 60.0 / bpm
+    division_multiplier = division_map.get(params.s8bit_delay_division, 0.75)
+    delay_time_s = beat_duration_s * division_multiplier
+    
+    print(f"  - Delay set to {params.s8bit_delay_division}, calculated time: {delay_time_s:.3f}s")
+    
+    # --- Step 2: Identify the notes that should receive the echo effect ---
     notes_to_echo = []
     
     if params.s8bit_delay_on_melody_only:
@@ -637,15 +660,15 @@ def create_delay_effect(midi_data: pretty_midi.PrettyMIDI, params: AppParameters
         print("  - No notes found to apply delay to. Skipping.")
         return processed_midi
 
-    # --- Step 2: Generate the echo notes ---
+    # --- Step 3: Generate echo notes using the calculated delay time ---
     echo_notes = []
     for i in range(1, params.s8bit_delay_repeats + 1):
         for original_note in notes_to_echo:
             # Create a copy of the note for the echo
             echo_note = copy.copy(original_note)
             
-            # Calculate new timing and velocity
-            time_offset = i * params.s8bit_delay_time_s
+            # Use the tempo-synced time and velocity
+            time_offset = i * delay_time_s
             echo_note.start += time_offset
             echo_note.end += time_offset
             echo_note.velocity = int(echo_note.velocity * (params.s8bit_delay_feedback ** i))
@@ -654,13 +677,21 @@ def create_delay_effect(midi_data: pretty_midi.PrettyMIDI, params: AppParameters
             if echo_note.velocity > 1:
                 echo_notes.append(echo_note)
 
-    # --- Step 3: Add the echo notes to a new, dedicated instrument track ---
+    # --- Step 4: Add the echo notes to a new, dedicated instrument track ---
     if echo_notes:
-        # Use a softer program for the echo, like a synth pad, to differentiate it.
-        echo_instrument = pretty_midi.Instrument(program=80, is_drum=False, name="Echo Layer")
+        # Inherit the program from the first non-drum instrument
+        # This ensures the echo has the same timbral character as the original sound,
+        # preventing perceived pitch shifts caused by different harmonic structures.
+        base_program = 0 # Default to piano if no instruments are found
+        for inst in midi_data.instruments:
+            if not inst.is_drum:
+                base_program = inst.program
+                break # Use the program of the first non-drum track we find
+        
+        echo_instrument = pretty_midi.Instrument(program=base_program, is_drum=False, name="Echo Layer")
         echo_instrument.notes.extend(echo_notes)
         processed_midi.instruments.append(echo_instrument)
-        print(f"  - Generated {len(echo_notes)} echo notes on a new track.")
+        print(f"  - Generated {len(echo_notes)} tempo-synced echo notes on a new track with program {base_program}.")
 
     return processed_midi
 
@@ -3655,6 +3686,7 @@ if __name__ == "__main__":
                                         "Continuous 16ths", 
                                         "Classic Upbeat (8th)",
                                         "Pulsing 8ths",
+                                        "Triplet 8ths",
                                         "Pulsing 4ths",
                                         "Galloping",
                                         "Simple Quarter Notes"
@@ -3662,12 +3694,13 @@ if __name__ == "__main__":
                                     value="Pulsing 8ths",
                                     label="Arpeggio Rhythm Pattern",
                                     info="""
-- **Continuous 16ths:** A constant, driving wall of sound with no breaks. Creates a very dense, high-energy texture.
-- **Classic Upbeat (8th):** The quintessential chiptune rhythm. Creates a bouncy, syncopated feel by playing on the off-beats. (Sounds like: _ _ ta-ta)
+- **Continuous 16ths:** A constant, driving wall of sound with no breaks. Creates a very dense, high-energy texture. (Sounds like: ta-ta-ta-ta ta-ta-ta-ta)
+- **Classic Upbeat (8th):** The quintessential chiptune rhythm. Creates a bouncy, syncopated feel by playing on the off-beats. (Sounds like: _ _ ta-ta _ _ ta-ta)
 - **Pulsing 8ths:** A steady, on-beat rhythm playing two notes per beat. Good for a solid, rhythmic foundation. (Sounds like: ta-ta ta-ta)
+- **Triplet 8ths:** A rolling, "three-feel" rhythm that creates a swing or shuffle groove. Very common in Blues, Jazz, and Hip-Hop. (Sounds like: ta-ta-ta ta-ta-ta)
 - **Pulsing 4ths:** A strong, deliberate pulse on each downbeat, with a clear separation between notes. (Sounds like: ta_ ta_ ta_)
 - **Galloping:** A driving, forward-moving rhythm with a distinctive long-short pattern. Excellent for action themes. (Sounds like: ta--ta ta--ta)
-- **Simple Quarter Notes:** The most sparse pattern, playing one sustained note per beat. Creates a calm and open feel.
+- **Simple Quarter Notes:** The most sparse pattern, playing one sustained note per beat. Creates a calm and open feel. (Sounds like: ta _ ta _ ta _ ta _)
                                     """
                                 )
                                 s8bit_arpeggio_pattern = gr.Dropdown(
@@ -3708,10 +3741,18 @@ if __name__ == "__main__":
                                         label="Apply Delay to Melody Only",
                                         info="Recommended. Applies the echo effect only to the lead melody notes, keeping the harmony clean."
                                     )
-                                    s8bit_delay_time_s = gr.Slider(
-                                        0.05, 0.5, value=0.15, step=0.01,
-                                        label="Delay Time (seconds)",
-                                        info="The time between each echo. Sync this to the beat for rhythmic delays (e.g., 0.25s for 8th notes at 120 BPM)."
+                                    s8bit_delay_division = gr.Dropdown(
+                                        ["Quarter Note", "Dotted 8th Note", "8th Note", "Triplet 8th Note", "16th Note"],
+                                        value="Dotted 8th Note",
+                                        label="Delay Time (Tempo Synced)",
+                                        info="""
+"The time between echoes, synced to the MIDI's tempo. 'Dotted 8th Note' is a classic rhythmic choice."
+- **Quarter Note:** A simple, stable echo on the next beat. (1, 2, 3, 4)
+- **Dotted 8th Note (Classic):** Creates a very popular, rolling syncopated rhythm. Highly recommended for adding energy and complexity.
+- **8th Note:** A steady, "call and response" echo on the off-beat. Creates a running or swing feel.
+- **Triplet 8th Note:** Creates a unique "shuffling" or "bouncing" 3-feel groove over the standard 4/4 beat.
+- **16th Note:** A very fast, dense echo. Can act more like a textural effect than a distinct rhythmic delay.
+                                        """
                                     )
                                     s8bit_delay_feedback = gr.Slider(
                                         0.1, 0.9, value=0.5, step=0.05,