feat(synth): Add auto-recommendation for 8-bit synthesizer parameters

This commit introduces a new "Auto-Recommend" feature for the 8-bit synthesizer, designed to help users quickly generate a suitable sound profile for their MIDI files without manual tweaking.

- A new `"Auto-Recommend (Analyze MIDI)"` option has been added to the "Style Preset" dropdown.
- When selected, the main processing function (`process_and_render_file`) now triggers the analysis and recommendation engine.
- The recommended parameters are then used for rendering and are also reflected back onto the UI sliders, allowing users to see and further adjust the generated settings.

app.py

@@ -166,14 +166,16 @@ def prepare_soundfonts():
 # =================================================================================================
 def synthesize_8bit_style(midi_data, waveform_type, envelope_type, decay_time_s, pulse_width,
                            vibrato_rate, vibrato_depth, bass_boost_level, fs=44100,
-                           smooth_notes=False, continuous_vibrato=False, noise_level=0.0,
-                           distortion_level=0.0, fm_modulation_depth=0.0, fm_modulation_rate=0.0):
+                           smooth_notes_level=0.0, continuous_vibrato_level=0.0, 
+                           noise_level=0.0, distortion_level=0.0, 
+                           fm_modulation_depth=0.0, fm_modulation_rate=0.0):
     """
     Synthesizes an 8-bit style audio waveform from a PrettyMIDI object.
     This function generates waveforms manually instead of using a synthesizer like FluidSynth.
     Includes an optional sub-octave bass booster with adjustable level.
     Instruments are panned based on their order in the MIDI file.
     Instrument 1 -> Left, Instrument 2 -> Right.
+    Now supports graded levels for smoothing and vibrato continuity.
     """
     total_duration = midi_data.get_end_time()
     # Initialize a stereo waveform buffer (2 channels: Left, Right)
@@ -213,26 +215,39 @@ def synthesize_8bit_style(midi_data, waveform_type, envelope_type, decay_time_s,
 
             t = np.arange(num_samples) / fs
 
-            # --- Vibrato LFO ---
-            if continuous_vibrato:
-                # Use accumulated phase to avoid vibrato reset per note
-                vib_phase_inc = 2 * np.pi * vibrato_rate / fs
-                vib_phase_array = vibrato_phase + np.arange(num_samples) * vib_phase_inc
-                vibrato_phase = (vib_phase_array[-1] + vib_phase_inc) % (2 * np.pi)
-                vibrato_lfo = vibrato_depth * np.sin(vib_phase_array)
-            else:
-                vibrato_lfo = vibrato_depth * np.sin(2 * np.pi * vibrato_rate * t)
-                
+            # --- Graded Continuous Vibrato ---
+            # This now interpolates between a fully reset vibrato and a fully continuous one.
+            # Use accumulated phase to avoid vibrato reset per note
+            vib_phase_inc = 2 * np.pi * vibrato_rate / fs
+            per_note_vib_phase = 2 * np.pi * vibrato_rate * t
+            continuous_vib_phase = vibrato_phase + np.arange(num_samples) * vib_phase_inc
+            
+            # Weighted average of the two phase types
+            final_vib_phase = (
+                per_note_vib_phase * (1 - continuous_vibrato_level) + 
+                continuous_vib_phase * continuous_vibrato_level
+            )
+            vibrato_lfo = vibrato_depth * np.sin(final_vib_phase)
+            
+            # Update the global vibrato phase for the next note
+            if num_samples > 0:
+                vibrato_phase = (continuous_vib_phase[-1] + vib_phase_inc) % (2 * np.pi)
+
+            # --- Waveform Generation with FM ---
+            fm_lfo = fm_modulation_depth * np.sin(2 * np.pi * fm_modulation_rate * t)
+            modulated_freq = freq * (1 + fm_lfo)
+
             # --- Waveform Generation (Main Oscillator with phase continuity) ---
-            phase_inc = 2 * np.pi * (freq + vibrato_lfo) / fs
+            phase_inc = 2 * np.pi * (modulated_freq + vibrato_lfo) / fs
             phase = osc_phase[i] + np.cumsum(phase_inc)
-            osc_phase[i] = phase[-1] % (2 * np.pi)  # Store last phase
+            if num_samples > 0:
+                osc_phase[i] = phase[-1] % (2 * np.pi)  # Store last phase
 
             if waveform_type == 'Square':
                 note_waveform = signal.square(phase, duty=pulse_width)
             elif waveform_type == 'Sawtooth':
                 note_waveform = signal.sawtooth(phase)
-            elif waveform_type == 'Triangle':
+            else: # Triangle
                 note_waveform = signal.sawtooth(phase, width=0.5)
                 
             # --- Bass Boost (Sub-Octave Oscillator) ---
@@ -249,49 +264,37 @@ def synthesize_8bit_style(midi_data, waveform_type, envelope_type, decay_time_s,
                     main_level = 1.0 - (0.5 * bass_boost_level)
                     note_waveform = (note_waveform * main_level) + (bass_sub_waveform * bass_boost_level)
 
-            # --- Noise Channel Simulation (White Noise) ---
+            # --- Noise & Distortion Simulation (White Noise) ---
             if noise_level > 0:
-                noise_waveform = np.random.uniform(-1, 1, num_samples)
-                note_waveform += noise_waveform * noise_level
+                note_waveform += np.random.uniform(-1, 1, num_samples) * noise_level
 
             # --- Distortion (Wave Shaping) ---
             if distortion_level > 0:
-                note_waveform = np.sign(note_waveform) * np.abs(note_waveform) ** (1.0 - distortion_level)
-
-            # --- Frequency Modulation (FM) ---
-            if fm_modulation_depth > 0:
-                modulated_freq = freq * (1 + fm_modulation_depth * np.sin(2 * np.pi * fm_modulation_rate * t))
-                phase_inc = 2 * np.pi * modulated_freq / fs
-                phase = osc_phase[i] + np.cumsum(phase_inc)
-                osc_phase[i] = phase[-1] % (2 * np.pi)  # Store last phase
-                if waveform_type == 'Square':
-                    note_waveform = signal.square(phase, duty=pulse_width)
-                elif waveform_type == 'Sawtooth':
-                    note_waveform = signal.sawtooth(phase)
-                elif waveform_type == 'Triangle':
-                    note_waveform = signal.sawtooth(phase, width=0.5)
+                # Using a tanh function for a smoother, "warmer" distortion
+                note_waveform = np.tanh(note_waveform * (1 + distortion_level * 5))
 
             # --- ADSR Envelope ---
             start_amp = note.velocity / 127.0
             envelope = np.zeros(num_samples)
 
             if envelope_type == 'Plucky (AD Envelope)':
-                attack_time_s = 0.005
-                attack_samples = min(int(attack_time_s * fs), num_samples)
+                attack_samples = min(int(0.005 * fs), num_samples)
                 decay_samples = min(int(decay_time_s * fs), num_samples - attack_samples)
 
                 envelope[:attack_samples] = np.linspace(0, start_amp, attack_samples)
                 if decay_samples > 0:
                     envelope[attack_samples:attack_samples+decay_samples] = np.linspace(start_amp, 0, decay_samples)
-            elif envelope_type == 'Sustained (Full Decay)':
+            else: # Sustained
                 envelope = np.linspace(start_amp, 0, num_samples)
 
-            if smooth_notes:
-                # Add short release
-                release_samples = min(int(0.005 * fs), num_samples)
-                envelope[-release_samples:] *= np.linspace(1, 0, release_samples)
-                # Small crossfade (to avoid clicks)
-                envelope[:min(10, num_samples)] *= np.linspace(0.5, 1, min(10, num_samples))
+            # --- Graded Note Smoothing ---
+            # The level controls the length of the fade in/out. Max fade is 10ms.
+            if smooth_notes_level > 0 and num_samples > 10:
+                fade_length = int(fs * 0.01 * smooth_notes_level)
+                fade_samples = min(fade_length, num_samples // 2)
+                if fade_samples > 0:
+                    envelope[:fade_samples] *= np.linspace(0.5, 1.0, fade_samples)
+                    envelope[-fade_samples:] *= np.linspace(1.0, 0.0, fade_samples)
 
             # Apply envelope to the (potentially combined) waveform
             note_waveform *= envelope
@@ -572,7 +575,7 @@ def Render_MIDI(input_midi_path,
                 # --- 8-bit synth params ---
                 s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
                 s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth,
-                s8bit_bass_boost_level, s8bit_smooth_notes, s8bit_continuous_vibrato,
+                s8bit_bass_boost_level, s8bit_smooth_notes_level, s8bit_continuous_vibrato_level,
                 s8bit_noise_level, s8bit_distortion_level, s8bit_fm_modulation_depth, s8bit_fm_modulation_rate
                 ):
     """
@@ -799,8 +802,8 @@ def Render_MIDI(input_midi_path,
                 s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth,
                 s8bit_bass_boost_level,
                 fs=srate,
-                smooth_notes=s8bit_smooth_notes,
-                continuous_vibrato=s8bit_continuous_vibrato,
+                smooth_notes_level=s8bit_smooth_notes_level,
+                continuous_vibrato_level=s8bit_continuous_vibrato_level,
                 noise_level=s8bit_noise_level,
                 distortion_level=s8bit_distortion_level,
                 fm_modulation_depth=s8bit_fm_modulation_depth,
@@ -855,11 +858,190 @@ def Render_MIDI(input_midi_path,
     
     return new_md5_hash, fn1, output_midi_summary, midi_to_render_path, (srate, audio_out), output_plot, song_description
 
+
+def analyze_midi_features(midi_data):
+    """
+    Analyzes a PrettyMIDI object to extract musical features for parameter recommendation.
+
+    Args:
+        midi_data (pretty_midi.PrettyMIDI): The MIDI data to analyze.
+
+    Returns:
+        dict or None: A dictionary containing features, or None if the MIDI is empty.
+                      Features: 'note_count', 'instruments_count', 'duration',
+                                'note_density', 'avg_velocity', 'pitch_range'.
+    """
+    all_notes = [note for instrument in midi_data.instruments for note in instrument.notes]
+    note_count = len(all_notes)
+    
+    # Return None if the MIDI file has no notes to analyze.
+    if note_count == 0:
+        return None
+
+    duration = midi_data.get_end_time()
+    # Avoid division by zero for empty-duration MIDI files.
+    if duration == 0:
+        note_density = 0
+    else:
+        note_density = note_count / duration
+
+    # --- Calculate new required features ---
+    avg_velocity = sum(note.velocity for note in all_notes) / note_count
+    avg_pitch = sum(note.pitch for note in all_notes) / note_count
+    avg_note_length = sum(note.end - note.start for note in all_notes) / note_count
+
+    # Calculate pitch range
+    if note_count > 1:
+        min_pitch = min(note.pitch for note in all_notes)
+        max_pitch = max(note.pitch for note in all_notes)
+        pitch_range = max_pitch - min_pitch
+    else:
+        pitch_range = 0
+
+    return {
+        'note_count': note_count,
+        'instruments_count': len(midi_data.instruments),
+        'duration': duration,
+        'note_density': note_density, # Notes per second
+        'avg_velocity': avg_velocity,
+        'pitch_range': pitch_range, # In semitones
+        'avg_pitch': avg_pitch,
+        'avg_note_length': avg_note_length,
+    }
+
+def determine_waveform_type(features):
+    """
+    Determines the best waveform type based on analyzed MIDI features.
+    - Square: Best for most general-purpose, bright melodies.
+    - Sawtooth: Best for intense, heavy, or powerful leads and basses.
+    - Triangle: Best for soft, gentle basses or flute-like sounds.
+    
+    Args:
+        features (dict): The dictionary of features from analyze_midi_features.
+
+    Returns:
+        str: The recommended waveform type ('Square', 'Sawtooth', or 'Triangle').
+    """
+    # 1. Check for conditions that strongly suggest a Triangle wave (soft bassline)
+    # MIDI Pitch 52 is ~G#3. If the average pitch is below this, it's likely a bass part.
+    # If notes are long and the pitch range is narrow, it confirms a simple, melodic bassline.
+    if features['avg_pitch'] <= 52 and features['avg_note_length'] >= 0.3 and features['pitch_range'] < 12:
+        return "Triangle"
+
+    # 2. Check for conditions that suggest a Sawtooth wave (intense/complex part)
+    # High note density or a very wide pitch range often indicates an aggressive lead or a complex solo.
+    # The sawtooth's rich harmonics are perfect for this.
+    if features['note_density'] >= 6 or features['pitch_range'] >= 18:
+        return "Sawtooth"
+
+    # 3. Default to the most versatile waveform: Square
+    return "Square"
+
+def recommend_8bit_params(midi_data, default_preset):
+    """
+    Recommends 8-bit synthesizer parameters using a unified, factor-based model.
+    This "AI" generates a sound profile based on normalized musical features.
+    
+    Args:
+        midi_data (pretty_midi.PrettyMIDI): The MIDI data to analyze.
+        default_preset (dict): A fallback preset if analysis fails.
+
+    Returns:
+        dict: A dictionary of recommended synthesizer parameters.
+    """
+    features = analyze_midi_features(midi_data)
+    if features is None:
+        # Return a default preset if MIDI is empty or cannot be analyzed
+        return default_preset
+
+    # --- Rule-based Parameter Recommendation ---
+    params = {}
+
+    # --- 1. Core Timbre Selection ---
+    # Intelligent Waveform Selection
+    params['waveform_type'] = determine_waveform_type(features)
+    # Determine pulse width *after* knowing the waveform.
+    # This only applies if the waveform is Square.
+    if params['waveform_type'] == 'Square':
+        # For Square waves, use pitch complexity to decide pulse width.
+        # Complex melodies get a thinner sound (0.3) for clarity.
+        # Simpler melodies get a fuller sound (0.5).
+        params['pulse_width'] = 0.3 if features['pitch_range'] > 30 else 0.5
+    else:
+        # For Sawtooth or Triangle, pulse width is not applicable. Set a default.
+        params['pulse_width'] = 0.5
+
+    # --- 2. Envelope and Rhythm ---
+    # Determine envelope type based on note density
+    is_plucky = features['note_density'] > 10
+    params['envelope_type'] = 'Plucky (AD Envelope)' if is_plucky else 'Sustained (Full Decay)'
+    params['decay_time_s'] = 0.15 if is_plucky else 0.4
+    
+    # --- 3. Modulation (Vibrato) ---
+    # Vibrato depth and rate based on velocity and density
+    params['vibrato_depth'] = min(max((features['avg_velocity'] - 60) / 20, 0), 10) # More velocity = more depth
+    if features['note_density'] > 12:
+        params['vibrato_rate'] = 7.0 # Very fast music -> frantic vibrato
+    elif features['note_density'] > 6:
+        params['vibrato_rate'] = 5.0 # Moderately fast music -> standard vibrato
+    else:
+        params['vibrato_rate'] = 3.0 # Slow music -> gentle vibrato
+
+    # --- 4. Progressive/Graded Parameters using Normalization ---
+    
+    # Smooth notes level (0.0 to 1.0): More smoothing for denser passages.
+    # Effective range: 3 to 8 notes/sec.
+    params['smooth_notes_level'] = min(max((features['note_density'] - 3) / 5.0, 0.0), 1.0) # Smoothen notes in denser passages
+
+    # Continuous vibrato level (0.0 to 1.0): Less dense passages get more lyrical, continuous vibrato.
+    # Effective range: 5 to 10 notes/sec. (Inverted)
+    params['continuous_vibrato_level'] = 1.0 - min(max((features['note_density'] - 5) / 5.0, 0.0), 1.0) # Lyrical (less dense) music gets connected vibrato
+    
+    # Noise level (0.0 to 0.1): Higher velocity passages get more "air" or "grit".
+    # Effective range: velocity 50 to 90.
+    params['noise_level'] = min(max((features['avg_velocity'] - 50) / 40.0, 0.0), 1.0) * 0.1
+
+    # Distortion level (0.0 to 0.1): Shorter notes get more distortion for punch.
+    # Effective range: note length 0.5s down to 0.25s. (Inverted)
+    if features['avg_note_length'] < 0.25: # Short, staccato notes
+        params['distortion_level'] = 0.1
+    elif features['avg_note_length'] < 0.5: # Medium length notes
+        params['distortion_level'] = 0.05
+    else: # Long, sustained notes
+        params['distortion_level'] = 0.0
+
+    # Progressive FM modulation based on a combined complexity factor.
+    # Normalizes note density and pitch range to a 0-1 scale.
+    density_factor = min(max((features['note_density'] - 5) / 15, 0), 1)  # Effective range 5-20 notes/sec
+    range_factor = min(max((features['pitch_range'] - 15) / 30, 0), 1)    # Effective range 15-45 semitones
+
+    # The overall complexity is the average of these two factors.
+    complexity_factor = (density_factor + range_factor) / 2
+    params['fm_modulation_depth'] = round(0.3 * complexity_factor, 3)
+    params['fm_modulation_rate'] = round(200 * complexity_factor, 1)
+
+    # Non-linear bass boost
+    # REFINED LOGIC: Non-linear bass boost based on instrument count.
+    # More instruments lead to less bass boost to avoid a muddy mix,
+    # while solo or duo arrangements get a significant boost to sound fuller.
+    # The boost level has a floor of 0.2 and a ceiling of 1.0.
+    params['bass_boost_level'] = max(0.2, 1.0 - (features['instruments_count'] - 1) * 0.15)
+    
+    # Round all float values for cleaner output
+    for key, value in params.items():
+        if isinstance(value, float):
+            params[key] = round(value, 3)
+
+    return params
+
+
 # =================================================================================================
 # === Main Application Logic ===
 # =================================================================================================
 
-def process_and_render_file(input_file, 
+def process_and_render_file(input_file,
+                            # --- Pass the preset selector value ---
+                            s8bit_preset_selector,
                             # --- Transcription params ---
                             enable_stereo_processing,
                             transcription_method,
@@ -871,7 +1053,7 @@ def process_and_render_file(input_file,
                             # --- 8-bit synth params ---
                             s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
                             s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth,
-                            s8bit_bass_boost_level, s8bit_smooth_notes, s8bit_continuous_vibrato,
+                            s8bit_bass_boost_level, s8bit_smooth_notes_level, s8bit_continuous_vibrato_level,
                             s8bit_noise_level, s8bit_distortion_level, s8bit_fm_modulation_depth, s8bit_fm_modulation_rate
                            ):
     """
@@ -880,8 +1062,8 @@ def process_and_render_file(input_file,
     """
     start_time = reqtime.time()
     if input_file is None:
-        # Return a list of updates to clear all output fields
-        return [gr.update(value=None)] * 7
+        # Return a list of updates to clear all output fields and UI controls
+        return [gr.update(value=None)] * (7 + 13) # 7 results + 13 synth controls
 
     # The input_file from gr.Audio(type="filepath") is now the direct path (a string),
     # not a temporary file object. We no longer need to access the .name attribute.
@@ -890,9 +1072,13 @@ def process_and_render_file(input_file,
     print(f"Processing new file: {filename}")
     
     try:
+        # Mono=False is required to correctly detect stereo channels
         audio_data, native_sample_rate = librosa.load(input_file_path, sr=None, mono=False)
     except Exception as e:
-        raise gr.Error(f"Failed to load audio file: {e}")
+        # If loading fails, it might be a MIDI file, which librosa cannot handle.
+        # We will proceed, assuming it's a MIDI, and let pretty_midi handle it later.
+        print(f"Could not load as audio: {e}. Assuming it is a MIDI file.")
+        pass
 
     # --- Step 1: Check file type and transcribe if necessary ---
     if filename.lower().endswith(('.mid', '.midi', '.kar')):
@@ -907,7 +1093,7 @@ def process_and_render_file(input_file,
 
         # === STEREO PROCESSING LOGIC ===
         if enable_stereo_processing:
-            if audio_data.ndim != 2 or audio_data.shape[0] != 2:
+            if 'audio_data' not in locals() or audio_data.ndim != 2 or audio_data.shape[0] != 2:
                 print("Warning: Audio is not stereo or could not be loaded as stereo. Falling back to mono transcription.")
                 enable_stereo_processing = False # Disable stereo processing if audio is not stereo
 
@@ -929,16 +1115,12 @@ def process_and_render_file(input_file,
                 print(f"Saved left channel to: {temp_left_wav_path}")
                 print(f"Saved right channel to: {temp_right_wav_path}")
                 
-                print("Transcribing left channel...")
+                print("Transcribing left and right channel...")
                 if transcription_method == "General Purpose":
                     midi_path_left = TranscribeGeneralAudio(temp_left_wav_path, onset_thresh, frame_thresh, min_note_len, min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool)
-                else:
-                    midi_path_left = TranscribePianoAudio(temp_left_wav_path)
-                
-                print("Transcribing right channel...")
-                if transcription_method == "General Purpose":
                     midi_path_right = TranscribeGeneralAudio(temp_right_wav_path, onset_thresh, frame_thresh, min_note_len, min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool)
                 else:
+                    midi_path_left = TranscribePianoAudio(temp_left_wav_path)
                     midi_path_right = TranscribePianoAudio(temp_right_wav_path)
                 
                 if midi_path_left and midi_path_right:
@@ -956,48 +1138,111 @@ def process_and_render_file(input_file,
             except Exception as e:
                 print(f"An error occurred during stereo processing: {e}")
                 raise gr.Error(f"Stereo Processing Failed: {e}")
-        else:
+        else: # Standard mono transcription
             print("Stereo processing disabled. Using standard mono transcription.")
-            if audio_data.ndim == 1:
-                mono_signal = audio_data
-            else:
-                mono_signal = np.mean(audio_data, axis=0)
-                
-            normalized_mono = normalize_loudness(mono_signal, native_sample_rate)
+            if 'audio_data' in locals():
+                if audio_data.ndim == 1:
+                    mono_signal = audio_data
+                else:
+                    mono_signal = np.mean(audio_data, axis=0)
 
-            temp_mono_wav_path = os.path.join(temp_dir, f"{base_name}_mono.wav")
-            sf.write(temp_mono_wav_path, normalized_mono, native_sample_rate)
+                normalized_mono = normalize_loudness(mono_signal, native_sample_rate)
+                
+                temp_mono_wav_path = os.path.join(temp_dir, f"{base_name}_mono.wav")
+                sf.write(temp_mono_wav_path, normalized_mono, native_sample_rate)
+                input_file_path = temp_mono_wav_path # Use the normalized mono file for transcription
             
             try:
                 if transcription_method == "General Purpose":
-                    midi_path_for_rendering = TranscribeGeneralAudio(
-                        temp_mono_wav_path, onset_thresh, frame_thresh, min_note_len, 
-                        min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool
-                    )
+                    midi_path_for_rendering = TranscribeGeneralAudio(input_file_path, onset_thresh, frame_thresh, min_note_len, min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool)
                 else: # Piano-Specific
-                    midi_path_for_rendering = TranscribePianoAudio(temp_mono_wav_path)
-                analyze_midi_velocity(midi_path_for_rendering)
+                    midi_path_for_rendering = TranscribePianoAudio(input_file_path)
             except Exception as e:
                 print(f"An error occurred during transcription: {e}")
                 raise gr.Error(f"Transcription Failed: {e}")
 
     # --- Step 2: Render the MIDI file with selected options ---
+    
+    # --- Auto-Recommendation Logic ---
+    # Store the original parameters from the UI sliders into a dictionary.
+    # The keys in this dictionary match the keys returned by recommend_8bit_params.
+    synth_params = {
+        'waveform_type': s8bit_waveform_type, 'pulse_width': s8bit_pulse_width, 'envelope_type': s8bit_envelope_type,
+        'decay_time_s': s8bit_decay_time_s, 'vibrato_rate': s8bit_vibrato_rate, 'vibrato_depth': s8bit_vibrato_depth,
+        'bass_boost_level': s8bit_bass_boost_level, 'smooth_notes_level': s8bit_smooth_notes_level, 'continuous_vibrato_level': s8bit_continuous_vibrato_level,
+        'noise_level': s8bit_noise_level, 'distortion_level': s8bit_distortion_level,
+        'fm_modulation_depth': s8bit_fm_modulation_depth, 'fm_modulation_rate': s8bit_fm_modulation_rate,
+    }
+    
+    # This variable will hold the values to update the UI sliders
+    ui_updates = {}
+
+    # If the user selected the auto-recommend option, override the parameters
+    if s8bit_preset_selector == "Auto-Recommend (Analyze MIDI)":
+        print("Auto-Recommendation is enabled. Analyzing MIDI features...")
+        try:
+            midi_to_analyze = pretty_midi.PrettyMIDI(midi_path_for_rendering)
+            default_params = S8BIT_PRESETS[FALLBACK_PRESET_NAME]
+            recommended_params = recommend_8bit_params(midi_to_analyze, default_params)
+            
+            print("Recommended parameters:", recommended_params)
+            # Both the synthesis parameters and the UI update values are set to the recommendations
+            synth_params.update(recommended_params)
+            ui_updates = recommended_params.copy() # Use a copy for UI updates
+        except Exception as e:
+            print(f"Could not auto-recommend parameters: {e}. Using default values from UI.")
+
     print(f"Proceeding to render MIDI file: {os.path.basename(midi_path_for_rendering)}")
-    # --- Passing new FX parameters to the Render_MIDI function ---
+    
+    # --- Correctly pass parameters to Render_MIDI ---
+    # The Render_MIDI function expects positional arguments, not keyword arguments.
+    # We must unpack the values from our synth_params dictionary in the correct order.
     results = Render_MIDI(midi_path_for_rendering,
                           render_type, soundfont_bank, render_sample_rate,
                           render_with_sustains, merge_misaligned_notes, custom_render_patch, render_align,
                           render_transpose_value, render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
-                          s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
-                          s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth, s8bit_bass_boost_level,
-                          s8bit_smooth_notes, s8bit_continuous_vibrato,
-                          s8bit_noise_level, s8bit_distortion_level, s8bit_fm_modulation_depth, s8bit_fm_modulation_rate
+                          # Unpack the values from the dictionary as positional arguments
+                          synth_params['waveform_type'],
+                          synth_params['envelope_type'],
+                          synth_params['decay_time_s'],
+                          synth_params['pulse_width'],
+                          synth_params['vibrato_rate'],
+                          synth_params['vibrato_depth'],
+                          synth_params['bass_boost_level'],
+                          synth_params['smooth_notes_level'],
+                          synth_params['continuous_vibrato_level'],
+                          synth_params['noise_level'],
+                          synth_params['distortion_level'],
+                          synth_params['fm_modulation_depth'],
+                          synth_params['fm_modulation_rate']
                           )
     
     print(f'Total processing time: {(reqtime.time() - start_time):.2f} sec')
     print('*' * 70)
     
-    return results
+    # --- Prepare the final return value for Gradio ---
+    
+    # This list defines the order of UI components to be updated.
+    # IT MUST MATCH THE ORDER IN `s8bit_updater_outputs` IN THE MAIN BLOCK.
+    param_order = [
+        'waveform_type', 'pulse_width', 'envelope_type', 'decay_time_s', 'vibrato_rate',
+        'vibrato_depth', 'bass_boost_level', 'smooth_notes_level', 'continuous_vibrato_level',
+        'noise_level', 'distortion_level', 'fm_modulation_depth', 'fm_modulation_rate'
+    ]
+
+    final_ui_updates = []
+    if ui_updates: # If auto-recommendation was successful
+        # We have new values, so we create a list of these values in the correct order.
+        for param in param_order:
+            final_ui_updates.append(ui_updates.get(param))
+    else:
+        # No auto-recommendation, so we tell Gradio not to change the UI.
+        # We send a gr.update() for each UI component.
+        for _ in param_order:
+            final_ui_updates.append(gr.update())
+
+    # The final return is a combination of the result values and the UI update values.
+    return list(results) + final_ui_updates
 
 # =================================================================================================
 # === Gradio UI Setup ===
@@ -1016,40 +1261,38 @@ def update_ui_visibility(transcription_method, soundfont_choice):
     }
 
 # --- Function to apply 8-bit synthesizer presets ---
+# --- This function must be defined before the UI components that use it ---
 def apply_8bit_preset(preset_name):
     """
     Takes the name of a preset and returns a dictionary of gr.update objects
-    to set the values of the 8-bit synthesizer's UI components.
+    to set the values of all 13 of the 8-bit synthesizer's UI components.
     """
+    # --- Use a list of keys for consistent updates ---
+    param_keys = [
+        'waveform_type', 'pulse_width', 'envelope_type', 'decay_time_s', 'vibrato_rate',
+        'vibrato_depth', 'bass_boost_level', 'smooth_notes_level', 'continuous_vibrato_level',
+        'noise_level', 'distortion_level', 'fm_modulation_depth', 'fm_modulation_rate'
+    ]
+    
     # If the user selects "Custom" or the preset is not found, do not change the values.
     if preset_name == "Custom" or preset_name not in S8BIT_PRESETS:
-        return {
-            s8bit_waveform_type: gr.update(),
-            s8bit_pulse_width: gr.update(),
-            s8bit_envelope_type: gr.update(),
-            s8bit_decay_time_s: gr.update(),
-            s8bit_vibrato_rate: gr.update(),
-            s8bit_vibrato_depth: gr.update(),
-            s8bit_smooth_notes: gr.update(),
-            s8bit_continuous_vibrato: gr.update(),
-            s8bit_bass_boost_level: gr.update()
-        }
+        # When switching to custom, don't change any values, just return empty updates.
+        return {comp: gr.update() for comp in s8bit_ui_components}
     
     # Get the settings dictionary for the chosen preset.
     settings = S8BIT_PRESETS[preset_name]
     
-    # Return a dictionary that maps each UI component to a gr.update call with the new value.
-    return {
-        s8bit_waveform_type: gr.update(value=settings['waveform_type']),
-        s8bit_pulse_width: gr.update(value=settings['pulse_width']),
-        s8bit_envelope_type: gr.update(value=settings['envelope_type']),
-        s8bit_decay_time_s: gr.update(value=settings['decay_time_s']),
-        s8bit_vibrato_rate: gr.update(value=settings['vibrato_rate']),
-        s8bit_vibrato_depth: gr.update(value=settings['vibrato_depth']),
-        s8bit_smooth_notes: gr.update(value=settings['smooth_notes']),
-        s8bit_continuous_vibrato: gr.update(value=settings['continuous_vibrato']),
-        s8bit_bass_boost_level: gr.update(value=settings['bass_boost_level'])
-    }
+    # Create a dictionary mapping UI components to their new values from the preset.
+    update_dict = {}
+    for i, key in enumerate(param_keys):
+        component = s8bit_ui_components[i]
+        value = settings.get(key)
+        if value is not None:
+            update_dict[component] = gr.update(value=value)
+        else:
+            update_dict[component] = gr.update()
+    return update_dict
+
 
 if __name__ == "__main__":
     # Initialize the app: download model (if needed) and apply patches
@@ -1066,146 +1309,268 @@ if __name__ == "__main__":
         print("\nWARNING: No SoundFonts were found or could be downloaded.")
         print("Rendering with SoundFonts will fail. Only the 8-bit synthesizer will be available.")
     
+    # --- Define a constant for the fallback preset name ---
+    # This prevents errors if the preset name is changed in the dictionary.
+    FALLBACK_PRESET_NAME = "Generic Chiptune Loop"
+
     # --- Data structure for 8-bit synthesizer presets ---
     # Comprehensive preset dictionary with new FX parameters for all presets
     # Comprehensive preset dictionary including new JRPG and Handheld classics
     # Note: Vibrato depth is mapped to a representative value on the 0-50 Hz slider.
     S8BIT_PRESETS = {
         # --- Rhythmic & Action ---
-        "Rhythm Pop Lead": {
+        "Rhythm Pop Lead (Rhythm Tengoku / リズム天国)": {
             # Description: A clean, round square wave perfect for the snappy, catchy feel of rhythm games.
-            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18, 'vibrato_rate': 4.5, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18,
+            'vibrato_rate': 4.5, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.9,          # Formerly True -> 1.0; slightly reduced for a bit more attack.
+            'continuous_vibrato_level': 0.8,    # Formerly True -> 1.0; slightly weakened for more defined note transitions.
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Arcade Brawler Lead": {
+        "Arcade Brawler Lead (Street Fighter / ストリートファイター)": {
             # Description: A gritty sawtooth lead with a hard attack, capturing the high-energy feel of classic fighting games.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15, 'vibrato_rate': 5.0, 'vibrato_depth': 6,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.4, 'noise_level': 0.05, 'distortion_level': 0.1, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15,
+            'vibrato_rate': 5.0, 'vibrato_depth': 6,
+            'smooth_notes_level': 0.8,
+            'continuous_vibrato_level': 0.7,
+            'bass_boost_level': 0.4, 'noise_level': 0.05, 'distortion_level': 0.1,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Mega Man (Rockman)": {
+        "Mega Man (Rockman / ロックマン)": {
             # Description: A thin, sharp square wave lead with fast vibrato, iconic for its driving, heroic melodies.
-            'waveform_type': 'Square', 'pulse_width': 0.2, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15, 'vibrato_rate': 6.0, 'vibrato_depth': 8,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.05, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.2, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15,
+            'vibrato_rate': 6.0, 'vibrato_depth': 8,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.85,
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.05,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Kirby's Bubbly Melody": {
+        "Kirby's Bubbly Melody (Hoshi no Kirby / 星のカービィ)": {
             # Description: A soft, round square wave with a bouncy vibrato, creating a cheerful and adorable sound.
-            'waveform_type': 'Square', 'pulse_width': 0.4, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2, 'vibrato_rate': 6.0, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': False, 'bass_boost_level': 0.1, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.4, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2,
+            'vibrato_rate': 6.0, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.85,
+            'continuous_vibrato_level': 0.3,   # Formerly False (0.0); adds a hint of continuity for more liveliness.
+            'bass_boost_level': 0.1, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Mario (Super Mario Bros)": {
+        "Mario (Super Mario Bros / スーパーマリオブラザーズ)": {
             # Description: A bright square wave with a per-note vibrato, producing the classic bouncy platformer sound.
-            'waveform_type': 'Square', 'pulse_width': 0.3, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.25, 'vibrato_rate': 5.0, 'vibrato_depth': 5,
-            'smooth_notes': True, 'continuous_vibrato': False, 'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.3, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.25,
+            'vibrato_rate': 5.0, 'vibrato_depth': 5,
+            'smooth_notes_level': 0.8,
+            'continuous_vibrato_level': 0.25,
+            'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         # --- Epic & Atmospheric ---
-        "Mecha & Tactics Brass": {
+        "Mecha & Tactics Brass (Super Robot Wars / スーパーロボット大戦)": {
             # Description: A powerful, sustained sawtooth emulating the bold, heroic synth-brass of strategy and mecha anime themes.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4, 'vibrato_rate': 3.5, 'vibrato_depth': 5,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.5, 'noise_level': 0.1, 'distortion_level': 0.15, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4,
+            'vibrato_rate': 3.5, 'vibrato_depth': 5,
+            'smooth_notes_level': 0.95,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.5, 'noise_level': 0.1, 'distortion_level': 0.15,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Mystic Mana Pad": {
-            # Description: A warm, ethereal square wave pad with slow vibrato, capturing a feeling of fantasy and wonder.
-            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.5, 'vibrato_rate': 2.5, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+        "Mystic Mana Pad (Secret of Mana / 聖剣伝説2)": {
+             # Description: A warm, ethereal square wave pad with slow vibrato, capturing a feeling of fantasy and wonder.
+            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.5,
+            'vibrato_rate': 2.5, 'vibrato_depth': 4,
+            'smooth_notes_level': 1.0,
+            'continuous_vibrato_level': 0.95,
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Dragon Quest (Orchestral Feel)": {
+        "Dragon Quest (ドラゴンクエスト)": {
             # Description: A pure triangle wave with a long decay, mimicking the grand, orchestral feel of a classical flute or string section.
-            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.6, 'vibrato_rate': 3.0, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+           'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.6,
+            'vibrato_rate': 3.0, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "ONI V (Wafu Mystic)": {
+        "ONI V (Wafu Mystic / ONI V 隠忍を継ぐ者)": {
             # Description: A solemn triangle wave with a slow, expressive vibrato, evoking the mysterious atmosphere of Japanese folklore.
-            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4, 'vibrato_rate': 3.5, 'vibrato_depth': 3,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.4, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4,
+            'vibrato_rate': 3.5, 'vibrato_depth': 3,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.85,
+            'bass_boost_level': 0.4, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Zelda (NES)": {
+        "Zelda (The Legend of Zelda / ゼルダの伝説)": {
             # Description: The classic pure triangle wave lead, perfect for heroic and adventurous overworld themes.
-            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.3, 'vibrato_rate': 4.5, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.15, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.3,
+            'vibrato_rate': 4.5, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.15, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         # --- JRPG & System Classics ---
-        "Falcom Ys (Rock Lead)": {
+        "Falcom Ys (Ys / イース)": {
             # Description: A powerful sawtooth with slight distortion, emulating the driving rock organ and guitar leads of action JRPGs.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15, 'vibrato_rate': 5.5, 'vibrato_depth': 6,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.4, 'noise_level': 0.05, 'distortion_level': 0.15, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.15,
+            'vibrato_rate': 5.5, 'vibrato_depth': 6,
+            'smooth_notes_level': 0.85,
+            'continuous_vibrato_level': 0.8,
+            'bass_boost_level': 0.4, 'noise_level': 0.05, 'distortion_level': 0.15,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Final Fantasy (Arpeggio)": {
+        "Final Fantasy (ファイナルファンタジー)": {
             # Description: A perfect, clean square wave with zero vibrato, creating the iconic, crystal-clear arpeggio sound.
-            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.22, 'vibrato_rate': 5.0, 'vibrato_depth': 0,
-            'smooth_notes': True, 'continuous_vibrato': False, 'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.22,
+            'vibrato_rate': 5.0, 'vibrato_depth': 0,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.2,
+            'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Castlevania (Akumajō Dracula)": {
+        "Castlevania (Akumajō Dracula / 悪魔城ドラキュラ)": {
             # Description: A sharp square wave with dramatic vibrato, ideal for fast, gothic, and baroque-inspired melodies.
-            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18, 'vibrato_rate': 6.5, 'vibrato_depth': 6,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.35, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18,
+            'vibrato_rate': 6.5, 'vibrato_depth': 6,
+            'smooth_notes_level': 0.85,
+            'continuous_vibrato_level': 0.85,
+            'bass_boost_level': 0.35, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Pokémon (Game Boy Classics)": {
+        "Pokémon (Game Boy Classics / ポケットモンスター)": {
             # Description: A full, friendly square wave sound, capturing the cheerful and adventurous spirit of early handheld RPGs.
-            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.22, 'vibrato_rate': 5.0, 'vibrato_depth': 5,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.25, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.22,
+            'vibrato_rate': 5.0, 'vibrato_depth': 5,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.25, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         # --- Advanced System Impressions ---
         "Commodore 64 (SID Feel)": {
             # Description: (Impression) Uses high-speed, shallow vibrato to mimic the characteristic "buzzy" texture of the SID chip's PWM.
-            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.25, 'vibrato_rate': 8.0, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': False, 'bass_boost_level': 0.2, 'noise_level': 0.05, 'distortion_level': 0.1, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.25,
+            'vibrato_rate': 8.0, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.3,
+            'bass_boost_level': 0.2, 'noise_level': 0.05, 'distortion_level': 0.1,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         "Megadrive/Genesis (FM Grit)": {
             # Description: (Impression) Uses FM, distortion, and noise to capture the gritty, metallic, and aggressive tone of the YM2612 chip.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18, 'vibrato_rate': 0.0, 'vibrato_depth': 0,
-            'smooth_notes': False, 'continuous_vibrato': True, 'bass_boost_level': 0.4, 'noise_level': 0.1, 'distortion_level': 0.2, 'fm_modulation_depth': 0.2, 'fm_modulation_rate': 150
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.18,
+            'vibrato_rate': 0.0, 'vibrato_depth': 0,
+            'smooth_notes_level': 0.0,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.4, 'noise_level': 0.1, 'distortion_level': 0.2,
+            'fm_modulation_depth': 0.2, 'fm_modulation_rate': 150
         },
-        "PC-98 (Touhou Feel)": {
+        "PC-98 (Touhou Feel / 東方Project)": {
             # Description: (Impression) A very sharp square wave with fast FM, emulating the bright, high-energy leads of Japanese PC games.
-            'waveform_type': 'Square', 'pulse_width': 0.15, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.12, 'vibrato_rate': 7.5, 'vibrato_depth': 7,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.1, 'fm_modulation_rate': 200
+            'waveform_type': 'Square', 'pulse_width': 0.15, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.12,
+            'vibrato_rate': 7.5, 'vibrato_depth': 7,
+            'smooth_notes_level': 0.95,
+            'continuous_vibrato_level': 0.85,
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.1, 'fm_modulation_rate': 200
         },
         "Roland SC-88 (GM Vibe)": {
             # Description: (Impression) A clean, stable triangle wave with no effects, mimicking the polished, sample-based sounds of General MIDI.
-            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.35, 'vibrato_rate': 0, 'vibrato_depth': 0,
-            'smooth_notes': True, 'continuous_vibrato': False, 'bass_boost_level': 0.1, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.35,
+            'vibrato_rate': 0, 'vibrato_depth': 0,
+            'smooth_notes_level': 1.0,
+            'continuous_vibrato_level': 0.0,
+            'bass_boost_level': 0.1, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         # --- Experimental & Sound FX ---
         "Sci-Fi Energy Field": {
             # Description: (SFX) High-speed vibrato and noise create a constant, shimmering hum suitable for energy shields or force fields.
-            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4, 'vibrato_rate': 10.0, 'vibrato_depth': 3,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.1, 'noise_level': 0.1, 'distortion_level': 0.0, 'fm_modulation_depth': 0.05, 'fm_modulation_rate': 50
+            'waveform_type': 'Triangle', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4,
+            'vibrato_rate': 10.0, 'vibrato_depth': 3,
+            'smooth_notes_level': 0.85,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.1, 'noise_level': 0.1, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.05, 'fm_modulation_rate': 50
         },
         "Industrial Alarm": {
             # Description: (SFX) Extreme vibrato rate on a sawtooth wave produces a harsh, metallic, dissonant alarm sound.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2, 'vibrato_rate': 15.0, 'vibrato_depth': 8,
-            'smooth_notes': False, 'continuous_vibrato': False, 'bass_boost_level': 0.3, 'noise_level': 0.2, 'distortion_level': 0.3, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2,
+            'vibrato_rate': 15.0, 'vibrato_depth': 8,
+            'smooth_notes_level': 0.0,
+            'continuous_vibrato_level': 0.0,
+            'bass_boost_level': 0.3, 'noise_level': 0.2, 'distortion_level': 0.3,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         "Laser Charge-Up": {
             # Description: (SFX) Extreme vibrato depth creates a dramatic, rising pitch effect, perfect for sci-fi weapon sounds.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.3, 'vibrato_rate': 4.0, 'vibrato_depth': 25,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.3,
+            'vibrato_rate': 4.0, 'vibrato_depth': 25,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.95,
+            'bass_boost_level': 0.2, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         "Unstable Machine Core": {
             # Description: (SFX) Maximum depth and distortion create a chaotic, atonal noise, simulating a machine on the verge of exploding.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.5, 'vibrato_rate': 1.0, 'vibrato_depth': 50,
-            'smooth_notes': False, 'continuous_vibrato': True, 'bass_boost_level': 0.5, 'noise_level': 0.3, 'distortion_level': 0.4, 'fm_modulation_depth': 0.5, 'fm_modulation_rate': 10
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.5,
+            'vibrato_rate': 1.0, 'vibrato_depth': 50,
+            'smooth_notes_level': 0.0,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.5, 'noise_level': 0.3, 'distortion_level': 0.4,
+            'fm_modulation_depth': 0.5, 'fm_modulation_rate': 10
         },
         "Hardcore Gabber Kick": {
             # Description: (Experimental) Maximum bass boost and distortion create an overwhelmingly powerful, clipped kick drum sound.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.1, 'vibrato_rate': 0, 'vibrato_depth': 0,
-            'smooth_notes': False, 'continuous_vibrato': False, 'bass_boost_level': 0.8, 'noise_level': 0.2, 'distortion_level': 0.5, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.1,
+            'vibrato_rate': 0, 'vibrato_depth': 0,
+            'smooth_notes_level': 0.0,
+            'continuous_vibrato_level': 0.0,
+            'bass_boost_level': 0.8, 'noise_level': 0.2, 'distortion_level': 0.5,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
         # --- Utility ---
         "Generic Chiptune Loop": {
             # Description: A well-balanced, pleasant square wave lead that serves as a great starting point for custom sounds.
-            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2, 'vibrato_rate': 5.5, 'vibrato_depth': 4,
-            'smooth_notes': True, 'continuous_vibrato': True, 'bass_boost_level': 0.25, 'noise_level': 0.0, 'distortion_level': 0.0, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+            'waveform_type': 'Square', 'pulse_width': 0.25, 'envelope_type': 'Plucky (AD Envelope)', 'decay_time_s': 0.2,
+            'vibrato_rate': 5.5, 'vibrato_depth': 4,
+            'smooth_notes_level': 0.9,
+            'continuous_vibrato_level': 0.85,
+            'bass_boost_level': 0.25, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         },
-        "Dark/Boss Atmosphere": {
-            # Description: An aggressive sawtooth with heavy bass and distortion, perfect for tense or menacing background music.
-            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.35, 'vibrato_rate': 7.0, 'vibrato_depth': 12,
-            'smooth_notes': False, 'continuous_vibrato': False, 'bass_boost_level': 0.4, 'noise_level': 0.15, 'distortion_level': 0.25, 'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+        "Dark/Boss Atmosphere (Shin Megami Tensei / 真・女神転生)": {
+            # Description: An aggressive sawtooth, inspired by the dark, rock-infused themes of SMT.
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.35,
+            'vibrato_rate': 7.0, 'vibrato_depth': 12,
+            'smooth_notes_level': 0.1,
+            'continuous_vibrato_level': 0.0,
+            'bass_boost_level': 0.4, 'noise_level': 0.15, 'distortion_level': 0.25,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+        },
+        "Modern JRPG Pad (Persona / ペルソナ)": {
+            # Description: A warm, stylish square wave pad, capturing the modern, pop/jazz-infused feel of the Persona series.
+            'waveform_type': 'Square', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.5,
+            'vibrato_rate': 2.5, 'vibrato_depth': 4,
+            'smooth_notes_level': 1.0,
+            'continuous_vibrato_level': 0.95,
+            'bass_boost_level': 0.3, 'noise_level': 0.0, 'distortion_level': 0.0,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
+        },
+        "Tactical Brass (Fire Emblem / ファイアーエムブレム)": {
+            # Description: A powerful, sustained sawtooth emulating the bold, heroic synth-brass of Fire Emblem's tactical themes.
+            'waveform_type': 'Sawtooth', 'pulse_width': 0.5, 'envelope_type': 'Sustained (Full Decay)', 'decay_time_s': 0.4,
+            'vibrato_rate': 3.5, 'vibrato_depth': 5,
+            'smooth_notes_level': 0.95,
+            'continuous_vibrato_level': 0.9,
+            'bass_boost_level': 0.5, 'noise_level': 0.1, 'distortion_level': 0.15,
+            'fm_modulation_depth': 0.0, 'fm_modulation_rate': 0.0
         }
     }
 
     app = gr.Blocks(theme=gr.themes.Base())
-    
+
     with app:
         gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Audio-to-MIDI & Advanced Renderer</h1>")
         gr.Markdown(
@@ -1348,10 +1713,12 @@ if __name__ == "__main__":
                 #   - High: Creates fast modulation, resulting in bright, complex, often metallic harmonics and sidebands.
                 # =================================================================================
                 #
+                # --- New option for auto-recommendation ---
+                # Define the 8-bit UI components in one place for easy reference
                 with gr.Accordion("8-bit Synthesizer Settings", open=False, visible=False) as synth_8bit_settings:
-                    # --- ADDED: Preset selector dropdown ---
+                    # --- Preset selector dropdown ---
                     s8bit_preset_selector = gr.Dropdown(
-                        choices=["Custom"] + list(S8BIT_PRESETS.keys()),
+                        choices=["Custom", "Auto-Recommend (Analyze MIDI)"] + list(S8BIT_PRESETS.keys()),
                         value="Custom",
                         label="Style Preset",
                         info="Select a preset to auto-fill the settings below. Choose 'Custom' for manual control.\nFor reference and entertainment only. These presets are not guaranteed to be perfectly accurate."
@@ -1360,20 +1727,20 @@ if __name__ == "__main__":
                     s8bit_waveform_type = gr.Dropdown(['Square', 'Sawtooth', 'Triangle'], value='Square', label="Waveform Type")
                     s8bit_pulse_width = gr.Slider(0.01, 0.99, value=0.5, step=0.01, label="Pulse Width (Square Wave Only)")
                     s8bit_envelope_type = gr.Dropdown(['Plucky (AD Envelope)', 'Sustained (Full Decay)'], value='Plucky (AD Envelope)', label="Envelope Type")
-                    s8bit_decay_time_s = gr.Slider(0.01, 0.6, value=0.1, step=0.01, label="Decay Time (s)")
+                    s8bit_decay_time_s = gr.Slider(0.01, 0.6, value=0.1, step=0.01, label="Decay Time (s)") # Increased max to 0.6 for DQ style
                     s8bit_vibrato_rate = gr.Slider(0, 20, value=5, label="Vibrato Rate (Hz)")
                     s8bit_vibrato_depth = gr.Slider(0, 50, value=0, label="Vibrato Depth (Hz)")
-                    s8bit_bass_boost_level = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.1, label="Bass Boost Level", info="Adjusts the volume of the sub-octave. 0 is off.")
-                    s8bit_smooth_notes = gr.Checkbox(value=True, label="Smooth Notes", info="Applies a tiny fade-in/out to notes to reduce clicking.")
-                    s8bit_continuous_vibrato = gr.Checkbox(value=True, label="Continuous Vibrato", info="Prevents vibrato from resetting on each note.")
-                    
+                    s8bit_bass_boost_level = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="Bass Boost Level", info="Adjusts the volume of the sub-octave. 0 is off.")
+                    s8bit_smooth_notes_level = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="Smooth Notes Level", info="Level of fade-in/out to reduce clicks. 0=off, 1=max.")
+                    s8bit_continuous_vibrato_level = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="Continuous Vibrato Level", info="Controls vibrato continuity. 0=resets per note, 1=fully continuous.")
+            
                     # --- New accordion for advanced effects ---
                     with gr.Accordion("Advanced Synthesis & FX", open=False):
                         s8bit_noise_level = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="Noise Level", info="Mixes in white noise. Great for percussion or adding 'air'.")
                         s8bit_distortion_level = gr.Slider(minimum=0.0, maximum=0.9, value=0.0, step=0.05, label="Distortion Level", info="Applies wave-shaping distortion for a grittier, harsher sound.")
                         s8bit_fm_modulation_depth = gr.Slider(minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="FM Depth", info="Depth of Frequency Modulation. Creates complex, metallic, or bell-like tones.")
                         s8bit_fm_modulation_rate = gr.Slider(minimum=0.0, maximum=500.0, value=0.0, step=1.0, label="FM Rate", info="Rate of Frequency Modulation. Higher values create brighter, more complex harmonics.")
-                        
+
                 # --- Original Advanced Options (Now tied to Piano-Specific) ---
                 with gr.Accordion("Advanced MIDI Rendering Options", open=False) as advanced_rendering_options:
                     render_with_sustains = gr.Checkbox(label="Apply sustain pedal effects (if present)", value=True)
@@ -1404,38 +1771,44 @@ if __name__ == "__main__":
                 output_midi_summary = gr.Textbox(label="MIDI metadata summary", lines=4)
                 
         # Define all input components for the click event, excluding the preset selector which is not a direct input to the final processing.
+        # all_inputs now includes the preset selector itself
+        # Inputs for the main processing function
         all_inputs = [
-            input_file, 
-            enable_stereo_processing,
-            transcription_method,
-            onset_threshold, frame_threshold, minimum_note_length, minimum_frequency, maximum_frequency,
-            infer_onsets, melodia_trick, multiple_pitch_bends,
-            render_type, soundfont_bank, render_sample_rate,
-            render_with_sustains, merge_misaligned_notes, custom_render_patch, render_align,
-            render_transpose_value, render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
+            input_file, s8bit_preset_selector, enable_stereo_processing,
+            transcription_method, onset_threshold, frame_threshold, minimum_note_length,
+            minimum_frequency, maximum_frequency, infer_onsets, melodia_trick, multiple_pitch_bends,
+            render_type, soundfont_bank, render_sample_rate, render_with_sustains,
+            merge_misaligned_notes, custom_render_patch, render_align, render_transpose_value,
+            render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
             s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
             s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth, s8bit_bass_boost_level,
-            s8bit_smooth_notes, s8bit_continuous_vibrato,
+            s8bit_smooth_notes_level, s8bit_continuous_vibrato_level,
             s8bit_noise_level, s8bit_distortion_level, s8bit_fm_modulation_depth, s8bit_fm_modulation_rate
         ]
-        all_outputs = [
+
+        # Outputs for the main results
+        result_outputs = [
             output_midi_md5, output_midi_title, output_midi_summary, 
             output_midi, output_audio, output_plot, output_song_description
         ]
-        
-        # Define the output components for the preset updater function.
-        s8bit_updater_outputs = [
-            s8bit_waveform_type, s8bit_pulse_width, s8bit_envelope_type,
-            s8bit_decay_time_s, s8bit_vibrato_rate, s8bit_vibrato_depth,
-            s8bit_smooth_notes, s8bit_continuous_vibrato, s8bit_bass_boost_level,
+
+        # The list of 8-bit UI components that can be updated
+        # This MUST be defined after the components themselves are created in the UI.
+        s8bit_ui_components = [
+            s8bit_waveform_type, s8bit_pulse_width, s8bit_envelope_type, s8bit_decay_time_s, s8bit_vibrato_rate,
+            s8bit_vibrato_depth, s8bit_bass_boost_level, 
+            s8bit_smooth_notes_level, s8bit_continuous_vibrato_level,
             s8bit_noise_level, s8bit_distortion_level, s8bit_fm_modulation_depth, s8bit_fm_modulation_rate
         ]
         
-        # --- Event Handling ---
+        # all_outputs now includes both results AND the UI controls to be updated
+        all_outputs = result_outputs + s8bit_ui_components
+        
+        # Event Handling
         submit_btn.click(
             process_and_render_file, 
             inputs=all_inputs,
-            outputs=all_outputs
+            outputs=all_outputs # Pass the combined list
         )
         
         # --- Listeners for dynamic UI updates ---
@@ -1450,14 +1823,16 @@ if __name__ == "__main__":
             outputs=[general_transcription_settings, synth_8bit_settings]
         )
         
+        # This listener now correctly handles only the named presets, ignoring "Auto-Recommend"
         # --- Event listener for the preset selector ---
         # When the preset dropdown changes, it calls the `apply_8bit_preset` function.
         # The input to the function is the selected preset name.
         # The outputs are all the individual 8-bit setting components that need to be updated.
+        # This listener is for manual preset selection (e.g., choosing "Mega Man")
         s8bit_preset_selector.change(
             fn=apply_8bit_preset,
             inputs=[s8bit_preset_selector],
-            outputs=s8bit_updater_outputs
+            outputs=s8bit_ui_components # This now correctly targets the new sliders
         )