feat(transcription): Implement adaptive parameters for basic-pitch

Adds a new "Auto-Analyze Audio" mode for the "General Purpose" transcription.

When this mode is enabled, the system analyzes the input audio's tempo, spectral content, and dynamics to automatically determine optimal parameters for `basic-pitch`.

app.py

@@ -91,7 +91,7 @@ SYNTH_8_BIT_LABEL = "None (8-bit Synthesizer)"
 
 
 # =================================================================================================
-# === NEW: Central Parameter Object ===
+# === Central Parameter Object ===
 # =================================================================================================
 
 @dataclass
@@ -125,6 +125,7 @@ class AppParameters:
 
     enable_stereo_processing: bool = False
     transcription_method: str = "General Purpose"
+    basic_pitch_preset_selector: str = "Default (Balanced)"
     
     # Basic Pitch Settings
     onset_threshold: float = 0.5
@@ -206,6 +207,93 @@ class AppParameters:
 # === Helper Functions ===
 # =================================================================================================
 
+def analyze_audio_for_adaptive_params(audio_data: np.ndarray, sample_rate: int):
+    """
+    Analyzes raw audio data to dynamically determine optimal parameters for basic-pitch.
+    
+    Args:
+        audio_data: The audio signal as a NumPy array (can be stereo).
+        sample_rate: The sample rate of the audio.
+        
+    Returns:
+        A dictionary of recommended parameters for basic_pitch.
+    """
+    print("  - Running adaptive analysis on audio to determine optimal transcription parameters...")
+    
+    # Ensure audio is mono for most feature extractions
+    if audio_data.ndim > 1:
+        y_mono = librosa.to_mono(audio_data)
+    else:
+        y_mono = audio_data
+
+    params = {}
+
+    # 1. Tempo detection with enhanced stability
+    try:
+        tempo_info = librosa.beat.tempo(y=y_mono, sr=sample_rate, aggregate=np.median)
+        
+        # Ensure BPM is a scalar float
+        bpm = float(np.median(tempo_info))
+        
+        if bpm <= 0 or np.isnan(bpm):
+            raise ValueError("Invalid BPM detected")
+        
+        # A 64th note is a reasonable shortest note length for most music
+        # Duration of a beat (quarter note) in seconds = 60 / BPM
+        # Duration of a 64th note = (60 / BPM) / 16
+        min_len_s = (60.0 / bpm) / 16.0
+        # basic-pitch expects milliseconds
+        params['minimum_note_length'] = max(20, int(min_len_s * 1000))
+        print(f"    - Detected BPM (median): {bpm:.1f} -> minimum_note_length: {params['minimum_note_length']}ms")
+    except Exception as e:
+        print(f"    - BPM detection failed, using default minimum_note_length. Error: {e}")
+
+    # 2. Spectral analysis: centroid + rolloff for richer info
+    try:
+        spectral_centroid = librosa.feature.spectral_centroid(y=y_mono, sr=sample_rate)[0]
+        rolloff = librosa.feature.spectral_rolloff(y=y_mono, sr=sample_rate)[0]
+        avg_centroid = np.mean(spectral_centroid)
+        avg_rolloff = np.mean(rolloff)
+        print(f"    - Spectral centroid: {avg_centroid:.1f} Hz, rolloff (85%): {avg_rolloff:.1f} Hz")
+        # Simple logic: if the 'center of mass' of the spectrum is low, it's bass-heavy.
+        # If it's high, it contains high-frequency content.
+        if avg_centroid < 500 and avg_rolloff < 1500:
+            params['minimum_frequency'] = 30
+            params['maximum_frequency'] = 1200
+        elif avg_centroid > 2000 or avg_rolloff > 5000: # Likely bright, high-frequency content (cymbals, flutes)
+            params['minimum_frequency'] = 100
+            params['maximum_frequency'] = 8000
+        else:
+            params['minimum_frequency'] = 50
+            params['maximum_frequency'] = 4000
+    except Exception as e:
+        print(f"    - Spectral analysis failed, using default frequencies. Error: {e}")
+
+    # 3. Onset threshold based on percussiveness
+    try:
+        y_harmonic, y_percussive = librosa.effects.hpss(y_mono)
+        percussive_ratio = np.sum(y_percussive**2) / (np.sum(y_harmonic**2) + 1e-10)
+        # If the percussive energy is high, we need a higher onset threshold to be stricter
+        params['onset_threshold'] = 0.6 if percussive_ratio > 0.5 else 0.45
+        print(f"    - Percussive ratio: {percussive_ratio:.2f} -> onset_threshold: {params['onset_threshold']}")
+    except Exception as e:
+        print(f"    - Percussiveness analysis failed, using default onset_threshold. Error: {e}")
+
+    # 4. Frame threshold from RMS
+    try:
+        rms = librosa.feature.rms(y=y_mono)[0]
+        # Use the 10th percentile of energy as a proxy for the noise floor
+        noise_floor_rms = np.percentile(rms, 10)
+        # Set the frame_threshold to be slightly above this noise floor
+        # The scaling factor here is empirical and can be tuned
+        params['frame_threshold'] = max(0.05, min(0.4, noise_floor_rms * 4))
+        print(f"    - Noise floor RMS: {noise_floor_rms:.5f} -> frame_threshold: {params['frame_threshold']:.2f}")
+    except Exception as e:
+        print(f"    - RMS analysis failed, using default frame_threshold. Error: {e}")
+
+    return params
+
+
 def format_params_for_metadata(params: AppParameters) -> str:
     """
     Formats the AppParameters object into a human-readable string
@@ -1386,7 +1474,7 @@ def TranscribePianoAudio(input_file):
     # Return the path to the newly created MIDI file
     return out_mid_path
 
-def TranscribeGeneralAudio(input_file, onset_threshold, frame_threshold, minimum_note_length, minimum_frequency, maximum_frequency, infer_onsets, melodia_trick, multiple_bends):
+def TranscribeGeneralAudio(input_file, **kwargs):
     """
     Transcribes a general audio file into a MIDI file using basic-pitch.
     This is suitable for various instruments and vocals.
@@ -1409,14 +1497,7 @@ def TranscribeGeneralAudio(input_file, onset_threshold, frame_threshold, minimum
     model_output, midi_data, note_events = basic_pitch.inference.predict(
         audio_path=input_file,
         model_or_model_path=ICASSP_2022_MODEL_PATH,
-        onset_threshold=onset_threshold,
-        frame_threshold=frame_threshold,
-        minimum_note_length=minimum_note_length,
-        minimum_frequency=minimum_frequency,
-        maximum_frequency=maximum_frequency,
-        infer_onsets=infer_onsets,
-        melodia_trick=melodia_trick,
-        multiple_pitch_bends=multiple_bends
+        **kwargs
     )
     
     # --- Save the MIDI file ---
@@ -1967,6 +2048,25 @@ def _transcribe_stem(audio_path: str, base_name: str, temp_dir: str, params: App
     # Load the audio stem to process it
     audio_data, native_sample_rate = librosa.load(audio_path, sr=None, mono=False)
     
+    # --- Adaptive Parameter Logic ---
+    final_bp_params = {
+        "onset_threshold": params.onset_threshold,
+        "frame_threshold": params.frame_threshold,
+        "minimum_note_length": params.minimum_note_length,
+        "minimum_frequency": params.minimum_frequency,
+        "maximum_frequency": params.maximum_frequency,
+        "infer_onsets": params.infer_onsets,
+        "melodia_trick": params.melodia_trick,
+        "multiple_pitch_bends": params.multiple_pitch_bends,
+    }
+
+    # Check if the user has selected the auto-analysis option from the dropdown.
+    if params.transcription_method == "General Purpose" and params.basic_pitch_preset_selector == "Auto-Analyze Audio":
+        adaptive_params = analyze_audio_for_adaptive_params(audio_data, native_sample_rate)
+        # Update the final_bp_params dictionary with the new adaptive values
+        final_bp_params.update(adaptive_params)
+        print(f"  - Overriding manual settings with auto-analyzed parameters. final_bp_params: {final_bp_params}")
+
     if params.enable_stereo_processing and audio_data.ndim == 2 and audio_data.shape[0] == 2:
         print("Stereo processing enabled for stem.")
         left_channel_np = audio_data[0]
@@ -1986,8 +2086,8 @@ def _transcribe_stem(audio_path: str, base_name: str, temp_dir: str, params: App
         
         print("Transcribing left and right channel...")
         if params.transcription_method == "General Purpose":
-            midi_path_left = TranscribeGeneralAudio(temp_left_path, params.onset_threshold, params.frame_threshold, params.minimum_note_length, params.minimum_frequency, params.maximum_frequency, params.infer_onsets, params.melodia_trick, params.multiple_pitch_bends)
-            midi_path_right = TranscribeGeneralAudio(temp_right_path, params.onset_threshold, params.frame_threshold, params.minimum_note_length, params.minimum_frequency, params.maximum_frequency, params.infer_onsets, params.melodia_trick, params.multiple_pitch_bends)
+            midi_path_left = TranscribeGeneralAudio(temp_left_path, **final_bp_params)
+            midi_path_right = TranscribeGeneralAudio(temp_right_path, **final_bp_params)
         else: # Piano-Specific
             midi_path_left = TranscribePianoAudio(temp_left_path)
             midi_path_right = TranscribePianoAudio(temp_right_path)
@@ -2012,7 +2112,7 @@ def _transcribe_stem(audio_path: str, base_name: str, temp_dir: str, params: App
         sf.write(temp_mono_path, normalized_mono, native_sample_rate)
         
         if params.transcription_method == "General Purpose":
-            return TranscribeGeneralAudio(temp_mono_path, params.onset_threshold, params.frame_threshold, params.minimum_note_length, params.minimum_frequency, params.maximum_frequency, params.infer_onsets, params.melodia_trick, params.multiple_pitch_bends)
+            return TranscribeGeneralAudio(temp_mono_path, **final_bp_params)
         else:
             return TranscribePianoAudio(temp_mono_path)
 
@@ -3186,20 +3286,52 @@ if __name__ == "__main__":
                     with gr.Accordion("General Purpose Transcription Settings", open=True) as general_transcription_settings:
                         # --- Preset dropdown for basic_pitch ---
                         basic_pitch_preset_selector = gr.Dropdown(
-                            choices=["Custom"] + list(BASIC_PITCH_PRESETS.keys()),
+                            choices=["Auto-Analyze Audio", "Custom"] + list(BASIC_PITCH_PRESETS.keys()),
                             value="Default (Balanced)",
                             label="Transcription Profile Preset",
                             info="Select a profile to auto-fill settings for different instrument types."
                                  "For reference only; it is recommended to test and adjust for optimal results.")
                         # --- The existing basic_pitch components ---
-                        onset_threshold = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="On-set Threshold", info="Sensitivity for detecting note beginnings. Higher is stricter.")
-                        frame_threshold = gr.Slider(0.0, 1.0, value=0.3, step=0.05, label="Frame Threshold", info="Sensitivity for detecting active notes. Higher is stricter.")
-                        minimum_note_length = gr.Slider(10, 500, value=128, step=1, label="Minimum Note Length (ms)", info="Filters out very short, noisy notes.")
-                        minimum_frequency = gr.Slider(0, 500, value=60, step=5, label="Minimum Frequency (Hz)", info="Ignores pitches below this frequency.")
-                        maximum_frequency = gr.Slider(501, 10000, value=4000, step=10, label="Maximum Frequency (Hz)", info="Ignores pitches above this frequency.")
-                        infer_onsets = gr.Checkbox(value=True, label="Infer Onsets (Boost Onsets)")
-                        melodia_trick = gr.Checkbox(value=True, label="Melodia Trick (Contour Optimization)")
-                        multiple_pitch_bends = gr.Checkbox(value=False, label="Allow Multiple Pitch Bends")
+                        onset_threshold = gr.Slider(
+                            0.0, 1.0, value=0.5, step=0.05, 
+                            label="On-set Threshold", 
+                            info="Sensitivity for detecting the start of a new note. Lower values will detect more notes (even faint ones), but may create false positives. Higher values are stricter and cleaner, but might miss subtle notes."
+                        )
+                        frame_threshold = gr.Slider(
+                            0.0, 1.0, value=0.3, step=0.05, 
+                            label="Frame Threshold", 
+                            info="Sensitivity for determining if a note is 'on' or 'off'. Lower values will sustain notes longer, but can merge distinct notes. Higher values create shorter, more separated notes, but might cut off tails."
+                        )
+                        minimum_note_length = gr.Slider(
+                            10, 500, value=128, step=1, 
+                            label="Minimum Note Length (ms)", 
+                            info="Filters out notes shorter than this duration. Increase this to remove fast, noisy artifacts or clicks. Decrease it if the transcription is missing very short, staccato notes."
+                        )
+                        minimum_frequency = gr.Slider(
+                            0, 500, value=60, step=5, 
+                            label="Minimum Frequency (Hz)", 
+                            info="Ignores any detected pitches below this frequency. Increase this to filter out low-frequency noise like rumble or hum. Set it just below your target instrument's lowest note (e.g., ~80Hz for guitar)."
+                        )
+                        maximum_frequency = gr.Slider(
+                            501, 10000, value=4000, step=10, 
+                            label="Maximum Frequency (Hz)", 
+                            info="Ignores any detected pitches above this frequency. Decrease this to filter out high-frequency noise like hiss or cymbals. Set it just above your target instrument's highest note (e.g., ~1200Hz for vocals)."
+                        )
+                        infer_onsets = gr.Checkbox(
+                            value=True, 
+                            label="Infer Onsets (Boost Onsets)",
+                            info="When enabled, the model actively looks for and emphasizes the start of each note (the 'attack'). Recommended for percussive or clear, rhythmic music. Disable for very smooth, legato music like vocal pads."
+                        )
+                        melodia_trick = gr.Checkbox(
+                            value=True, 
+                            label="Melodia Trick (Contour Optimization)",
+                            info="When enabled, uses a secondary melody-detection algorithm to refine the main pitch contour. Highly recommended for most melodic content. Disable if you are transcribing non-melodic noise or complex polyphony."
+                        )
+                        multiple_pitch_bends = gr.Checkbox(
+                            value=False, 
+                            label="Allow Multiple Pitch Bends",
+                            info="When enabled, allows a single note to have multiple, continuous pitch bends within it. Essential for transcribing vocals, slides, or vibrato-heavy instruments. Disable for clean, discrete notes like a standard piano."
+                        )
 
                 with gr.Column(scale=1):
                     # --- Rendering Settings ---