Update app.py

app.py

@@ -1,17 +1,819 @@
- ---------------------------------------------------------------------------
-DuplicateBlockError                       Traceback (most recent call last)
-/tmp/ipython-input-1056203637.py in <cell line: 0>()
-    868             # CORRECTED: The previous SyntaxError was fixed, and the 'variant' is now correctly applied to the Button
-    869             slice_all_button = gr.Button("Slice, Transform & Tag ALL Stems (Create ZIP)", variant="stop")
---> 870             download_zip_file.render()
-    871 
-    872             gr.Markdown("### Status")
-
-/usr/local/lib/python3.12/dist-packages/gradio/blocks.py in render(self)
-    216             and not self.is_render_replacement
-    217         ):
---> 218             raise DuplicateBlockError(
-    219                 f"A block with id: {self._id} has already been rendered in the current Blocks."
-    220             )
-
-DuplicateBlockError: A block with id: 9 has already been rendered in the current Blocks.
+# app.py
+import gradio as gr
+import numpy as np
+import librosa
+import soundfile as sf
+import os
+import tempfile
+import zipfile
+import time
+import matplotlib
+import matplotlib.pyplot as plt
+from scipy import signal
+from typing import Tuple, List, Any
+
+# Use a non-interactive backend for Matplotlib
+matplotlib.use('Agg')
+
+# --- UTILITY FUNCTIONS ---
+
+def freq_to_midi(freq: float) -> int:
+    """Converts a frequency in Hz to a MIDI note number."""
+    if freq <= 0:
+        return 0
+    if freq < 40:  # Ignore frequencies below C2 (approx 65Hz)
+        return 0
+    return int(round(69 + 12 * np.log2(freq / 440.0)))
+
+def write_midi_file(notes_list: List[Tuple[int, float, float]], bpm: float, output_path: str):
+    """Writes a basic MIDI file from a list of notes."""
+    if not notes_list:
+        return
+
+    tempo_us_per_beat = int(60000000 / bpm)
+    division = 96  # Ticks per quarter note
+    seconds_per_tick = 60.0 / (bpm * division)
+
+    # Sort notes by start time
+    notes_list.sort(key=lambda x: x[1])
+
+    current_tick = 0
+    midi_events = []
+
+    for note, start_sec, duration_sec in notes_list:
+        if note == 0:
+            continue
+
+        # Calculate delta time from last event
+        target_tick = int(start_sec / seconds_per_tick)
+        delta_tick = target_tick - current_tick
+        current_tick = target_tick
+
+        # Note On event (Channel 1, Velocity 100)
+        note_on = [0x90, note, 100]
+        midi_events.append((delta_tick, note_on))
+
+        # Note Off event (Channel 1, Velocity 0)
+        duration_ticks = int(duration_sec / seconds_per_tick)
+        note_off = [0x80, note, 0]
+        midi_events.append((duration_ticks, note_off))
+        current_tick += duration_ticks
+
+    # Build MIDI file
+    header = b'MThd' + (6).to_bytes(4, 'big') + (1).to_bytes(2, 'big') + (1).to_bytes(2, 'big') + division.to_bytes(2, 'big')
+    
+    track_data = b''
+    for delta, event in midi_events:
+        # Encode delta time
+        delta_bytes = []
+        while True:
+            delta_bytes.append(delta & 0x7F)
+            if delta <= 0x7F:
+                break
+            delta >>= 7
+        for i in range(len(delta_bytes)-1, -1, -1):
+            if i > 0:
+                track_data += bytes([delta_bytes[i] | 0x80])
+            else:
+                track_data += bytes([delta_bytes[i]])
+        
+        # Add event
+        track_data += bytes(event)
+    
+    # End of track
+    track_data += b'\x00\xFF\x2F\x00'
+    
+    track_chunk = b'MTrk' + len(track_data).to_bytes(4, 'big') + track_data
+    midi_data = header + track_chunk
+
+    with open(output_path, 'wb') as f:
+        f.write(midi_data)
+
+def get_harmonic_recommendations(key_str: str) -> str:
+    """Calculates harmonically compatible keys based on the Camelot wheel."""
+    KEY_TO_CAMELOT = {
+        "C Maj": "8B", "G Maj": "9B", "D Maj": "10B", "A Maj": "11B", "E Maj": "12B",
+        "B Maj": "1B", "F# Maj": "2B", "Db Maj": "3B", "Ab Maj": "4B", "Eb Maj": "5B",
+        "Bb Maj": "6B", "F Maj": "7B",
+        "A Min": "8A", "E Min": "9A", "B Min": "10A", "F# Min": "11A", "C# Min": "12A",
+        "G# Min": "1A", "D# Min": "2A", "Bb Min": "3A", "F Min": "4A", "C Min": "5A",
+        "G Min": "6A", "D Min": "7A",
+        "Gb Maj": "2B", "Cb Maj": "7B", "A# Min": "3A", "D# Maj": "11B", "G# Maj": "3B"
+    }
+    
+    code = KEY_TO_CAMELOT.get(key_str, "N/A")
+    if code == "N/A":
+        return "N/A (Key not recognized or 'Unknown Key' detected.)"
+    
+    try:
+        num = int(code[:-1])
+        mode = code[-1]
+        opposite_mode = 'B' if mode == 'A' else 'A'
+        num_plus_one = (num % 12) + 1
+        num_minus_one = 12 if num == 1 else num - 1
+        recs = [f"{num}{opposite_mode}", f"{num_plus_one}{mode}", f"{num_minus_one}{mode}"]
+        CAMELOT_TO_KEY = {v: k for k, v in KEY_TO_CAMELOT.items()}
+        rec_keys = [f"{CAMELOT_TO_KEY.get(r_code, f'Code {r_code}')} ({r_code})" for r_code in recs]
+        return " | ".join(rec_keys)
+    except Exception:
+        return "N/A (Error calculating recommendations.)"
+
+def detect_key(y: np.ndarray, sr: int) -> str:
+    """Analyzes the audio to determine the most likely musical key."""
+    try:
+        chroma = librosa.feature.chroma_stft(y=y, sr=sr)
+        chroma_sums = np.sum(chroma, axis=1)
+        chroma_norm = chroma_sums / np.sum(chroma_sums)
+
+        major_template = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88])
+        minor_template = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17])
+
+        pitch_classes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+
+        major_correlations = [np.dot(chroma_norm, np.roll(major_template, i)) for i in range(12)]
+        best_major_index = np.argmax(major_correlations)
+
+        minor_correlations = [np.dot(chroma_norm, np.roll(minor_template, i)) for i in range(12)]
+        best_minor_index = np.argmax(minor_correlations)
+
+        if major_correlations[best_major_index] > minor_correlations[best_minor_index]:
+            return pitch_classes[best_major_index] + " Maj"
+        else:
+            return pitch_classes[best_minor_index] + " Min"
+    except Exception as e:
+        print(f"Key detection failed: {e}")
+        return "Unknown Key"
+
+def apply_modulation(y: np.ndarray, sr: int, bpm: float, rate: str, pan_depth: float, level_depth: float) -> np.ndarray:
+    """Applies tempo-synced LFOs for panning and volume modulation."""
+    if y.ndim == 1:
+        y = np.stack((y, y), axis=-1)
+    elif y.ndim == 0:
+        return y
+
+    N = len(y)
+    duration_sec = N / sr
+
+    rate_map = {'1/2': 0.5, '1/4': 1, '1/8': 2, '1/16': 4}
+    beats_per_measure = rate_map.get(rate, 1)
+    lfo_freq_hz = (bpm / 60.0) * (beats_per_measure / 4.0)
+
+    t = np.linspace(0, duration_sec, N, endpoint=False)
+
+    # Panning LFO
+    if pan_depth > 0:
+        pan_lfo = np.sin(2 * np.pi * lfo_freq_hz * t) * pan_depth
+        L_mod = (1 - pan_lfo) / 2.0
+        R_mod = (1 + pan_lfo) / 2.0
+        y[:, 0] *= L_mod
+        y[:, 1] *= R_mod
+
+    # Level LFO (Tremolo)
+    if level_depth > 0:
+        level_lfo = (np.sin(2 * np.pi * lfo_freq_hz * t) + 1) / 2.0
+        gain_multiplier = (1 - level_depth) + (level_depth * level_lfo)
+        y[:, 0] *= gain_multiplier
+        y[:, 1] *= gain_multiplier
+
+    return y
+
+def apply_normalization_dbfs(y: np.ndarray, target_dbfs: float) -> np.ndarray:
+    """Applies peak normalization to match a target dBFS value."""
+    if target_dbfs >= 0:
+        return y
+
+    current_peak_amp = np.max(np.abs(y))
+    target_peak_amp = 10**(target_dbfs / 20.0)
+
+    if current_peak_amp > 1e-6:
+        gain = target_peak_amp / current_peak_amp
+        y_normalized = y * gain
+        y_normalized = np.clip(y_normalized, -1.0, 1.0)
+        return y_normalized
+    else:
+        return y
+
+def apply_filter_modulation(y: np.ndarray, sr: int, bpm: float, rate: str, filter_type: str, freq: float, depth: float) -> np.ndarray:
+    """Applies a tempo-synced LFO to a 2nd order Butterworth filter cutoff frequency."""
+    if depth == 0:
+        return y
+
+    # Ensure stereo for LFO application
+    if y.ndim == 1:
+        y = np.stack((y, y), axis=-1)
+
+    N = len(y)
+    duration_sec = N / sr
+
+    # LFO Rate Calculation
+    rate_map = {'1/2': 0.5, '1/4': 1, '1/8': 2, '1/16': 4}
+    beats_per_measure = rate_map.get(rate, 1)
+    lfo_freq_hz = (bpm / 60.0) * (beats_per_measure / 4.0)
+
+    t = np.linspace(0, duration_sec, N, endpoint=False)
+
+    # LFO: ranges from 0 to 1
+    lfo_value = (np.sin(2 * np.pi * lfo_freq_hz * t) + 1) / 2.0
+
+    # Modulate Cutoff Frequency: Cutoff = BaseFreq + (LFO * Depth)
+    cutoff_modulation = freq + (lfo_value * depth)
+    # Safety clip to prevent instability
+    cutoff_modulation = np.clip(cutoff_modulation, 20.0, sr / 2.0 - 100)
+
+    y_out = np.zeros_like(y)
+    filter_type_b = filter_type.lower().replace('-pass', '')
+    frame_size = 512  # Frame-based update for filter coefficients
+
+    # Apply filter channel by channel
+    for channel in range(y.shape[1]):
+        zi = np.zeros(2)  # Initial filter state (2nd order filter)
+
+        for frame_start in range(0, N, frame_size):
+            frame_end = min(frame_start + frame_size, N)
+            frame = y[frame_start:frame_end, channel]
+
+            # Use the average LFO cutoff for the frame
+            avg_cutoff = np.mean(cutoff_modulation[frame_start:frame_end])
+
+            # Calculate 2nd order Butterworth filter coefficients
+            b, a = signal.butter(2, avg_cutoff, btype=filter_type_b, fs=sr)
+
+            # Apply filter to the frame, updating the state `zi`
+            filtered_frame, zi = signal.lfilter(b, a, frame, zi=zi)
+            y_out[frame_start:frame_end, channel] = filtered_frame
+
+    return y_out
+
+# --- CORE PROCESSING FUNCTIONS ---
+
+def separate_stems(audio_file_path: str) -> Tuple[str, str, str, str, str, str, float, str]:
+    """Simulates stem separation and detects BPM and Key."""
+    if audio_file_path is None:
+        raise gr.Error("No audio file uploaded!")
+
+    try:
+        # Load audio
+        y_orig, sr_orig = librosa.load(audio_file_path, sr=None)
+        y_mono = librosa.to_mono(y_orig.T) if y_orig.ndim > 1 else y_orig
+
+        # Detect tempo and key
+        tempo, _ = librosa.beat.beat_track(y=y_mono, sr=sr_orig)
+        detected_bpm = 120 if tempo is None or tempo == 0 else int(np.round(tempo).item())
+        detected_key = detect_key(y_mono, sr_orig)
+
+        # Create mock separated stems
+        temp_dir = tempfile.mkdtemp()
+        stems = {}
+        stem_names = ["vocals", "drums", "bass", "other", "guitar", "piano"]
+        
+        for name in stem_names:
+            stem_path = os.path.join(temp_dir, f"{name}.wav")
+            # Create mock audio (just a portion of the original)
+            sf.write(stem_path, y_orig[:min(len(y_orig), sr_orig*5)], sr_orig)  # 5 seconds max
+            stems[name] = stem_path
+
+        return (
+            stems["vocals"], stems["drums"], stems["bass"], stems["other"], 
+            stems["guitar"], stems["piano"], float(detected_bpm), detected_key
+        )
+    except Exception as e:
+        raise gr.Error(f"Error processing audio: {str(e)}")
+
+def generate_waveform_preview(y: np.ndarray, sr: int, stem_name: str, temp_dir: str) -> str:
+    """Generates a Matplotlib image showing the waveform."""
+    img_path = os.path.join(temp_dir, f"{stem_name}_preview.png")
+    
+    plt.figure(figsize=(10, 3))
+    y_display = librosa.to_mono(y.T) if y.ndim > 1 else y
+    librosa.display.waveshow(y_display, sr=sr, x_axis='time', color="#4a7098")
+    plt.title(f"{stem_name} Waveform")
+    plt.tight_layout()
+    plt.savefig(img_path)
+    plt.close()
+    
+    return img_path
+
+def slice_stem_real(
+    stem_audio_path: str, 
+    loop_choice: str, 
+    sensitivity: float, 
+    stem_name: str,
+    manual_bpm: float, 
+    time_signature: str, 
+    crossfade_ms: int, 
+    transpose_semitones: int, 
+    detected_key: str,
+    pan_depth: float, 
+    level_depth: float, 
+    modulation_rate: str, 
+    target_dbfs: float,
+    attack_gain: float, 
+    sustain_gain: float, 
+    filter_type: str, 
+    filter_freq: float, 
+    filter_depth: float
+) -> Tuple[List[Tuple[str, str]], str]:
+    """Slices a single stem and applies transformations."""
+    if stem_audio_path is None:
+        return [], ""
+
+    try:
+        # Load audio
+        sample_rate, y_int = stem_audio_path
+        y = librosa.util.buf_to_float(y_int, dtype=np.float32)
+        
+        if y.ndim == 0:
+            return [], ""
+
+        y_mono = librosa.to_mono(y.T) if y.ndim > 1 else y
+
+        # --- 1. PITCH SHIFTING (if enabled) ---
+        if transpose_semitones != 0:
+            y_shifted = librosa.effects.pitch_shift(y, sr=sample_rate, n_steps=transpose_semitones)
+            y = y_shifted
+
+        # --- 2. FILTER MODULATION ---
+        if filter_depth > 0:
+            y = apply_filter_modulation(y, sample_rate, manual_bpm, modulation_rate, filter_type, filter_freq, filter_depth)
+
+        # --- 3. PAN/LEVEL MODULATION ---
+        normalized_pan_depth = pan_depth / 100.0
+        normalized_level_depth = level_depth / 100.0
+
+        if normalized_pan_depth > 0 or normalized_level_depth > 0:
+            y = apply_modulation(y, sample_rate, manual_bpm, modulation_rate, normalized_pan_depth, normalized_level_depth)
+
+        # --- 4. NORMALIZATION ---
+        if target_dbfs < 0:
+            y = apply_normalization_dbfs(y, target_dbfs)
+
+        # --- 5. DETERMINE BPM & KEY ---
+        bpm_int = int(manual_bpm)
+        key_tag = detected_key.replace(" ", "")
+        if transpose_semitones != 0:
+            root = detected_key.split(" ")[0]
+            mode = detected_key.split(" ")[1]
+            pitch_classes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+            try:
+                current_index = pitch_classes.index(root)
+                new_index = (current_index + transpose_semitones) % 12
+                new_key_root = pitch_classes[new_index]
+                key_tag = f"{new_key_root}{mode}Shift"
+            except ValueError:
+                pass
+
+        # --- 6. MIDI GENERATION (Melodic Stems) ---
+        output_files = []
+        loops_dir = tempfile.mkdtemp()
+        is_melodic = stem_name in ["vocals", "bass", "guitar", "piano", "other"]
+
+        if is_melodic and ("Bar Loops" in loop_choice):
+            try:
+                # Use piptrack for pitch detection
+                pitches, magnitudes = librosa.piptrack(y=y_mono, sr=sample_rate)
+                main_pitch_line = np.zeros(pitches.shape[1])
+                for t in range(pitches.shape[1]):
+                    index = magnitudes[:, t].argmax()
+                    main_pitch_line[t] = pitches[index, t]
+
+                notes_list = []
+                i = 0
+                while i < len(main_pitch_line):
+                    current_freq = main_pitch_line[i]
+                    current_midi = freq_to_midi(current_freq)
+
+                    j = i
+                    while j < len(main_pitch_line) and freq_to_midi(main_pitch_line[j]) == current_midi:
+                        j += 1
+
+                    duration_frames = j - i
+                    if current_midi != 0 and duration_frames >= 2:
+                        start_sec = librosa.frames_to_time(i, sr=sample_rate, hop_length=512)
+                        duration_sec = librosa.frames_to_time(duration_frames, sr=sample_rate, hop_length=512)
+                        notes_list.append((current_midi, start_sec, duration_sec))
+
+                    i = j
+
+                full_stem_midi_path = os.path.join(loops_dir, f"{stem_name}_MELODY_{key_tag}_{bpm_int}BPM.mid")
+                write_midi_file(notes_list, manual_bpm, full_stem_midi_path)
+                output_files.append((full_stem_midi_path, "MIDI"))
+
+            except Exception as e:
+                print(f"MIDI generation failed for {stem_name}: {e}")
+
+        # --- 7. CALCULATE TIMING & SLICING ---
+        beats_per_bar = 4
+        if time_signature == "3/4":
+            beats_per_bar = 3
+
+        if "Bar Loops" in loop_choice:
+            bars = int(loop_choice.split(" ")[0])
+            loop_type_tag = f"{bars}Bar"
+            loop_duration_samples = int((60.0 / bpm_int * beats_per_bar * bars) * sample_rate)
+
+            if loop_duration_samples > 0 and len(y) > loop_duration_samples:
+                num_loops = len(y) // loop_duration_samples
+
+                for i in range(min(num_loops, 10)):  # Limit to 10 loops
+                    start_sample = i * loop_duration_samples
+                    end_sample = min(start_sample + loop_duration_samples, len(y))
+                    slice_data = y[start_sample:end_sample]
+
+                    filename = os.path.join(loops_dir, f"{stem_name}_{loop_type_tag}_{i+1:03d}_{key_tag}_{bpm_int}BPM.wav")
+                    sf.write(filename, slice_data, sample_rate, subtype='PCM_16')
+                    output_files.append((filename, "WAV"))
+
+        elif "One-Shots" in loop_choice:
+            loop_type_tag = "OneShot"
+            # Simple slicing at regular intervals for demo
+            slice_length = int(sample_rate * 0.5)  # 0.5 second slices
+            num_slices = len(y) // slice_length
+            
+            for i in range(min(num_slices, 20)):  # Limit to 20 slices
+                start_sample = i * slice_length
+                end_sample = min(start_sample + slice_length, len(y))
+                slice_data = y[start_sample:end_sample]
+
+                filename = os.path.join(loops_dir, f"{stem_name}_{loop_type_tag}_{i+1:03d}_{key_tag}_{bpm_int}BPM.wav")
+                sf.write(filename, slice_data, sample_rate, subtype='PCM_16')
+                output_files.append((filename, "WAV"))
+
+        # --- 8. VISUALIZATION GENERATION ---
+        img_path = generate_waveform_preview(y, sample_rate, stem_name, loops_dir)
+        
+        return output_files, img_path
+
+    except Exception as e:
+        raise gr.Error(f"Error processing stem: {str(e)}")
+
+def slice_all_and_zip(
+    vocals: Tuple[int, np.ndarray], 
+    drums: Tuple[int, np.ndarray], 
+    bass: Tuple[int, np.ndarray], 
+    other: Tuple[int, np.ndarray], 
+    guitar: Tuple[int, np.ndarray], 
+    piano: Tuple[int, np.ndarray], 
+    loop_choice: str, 
+    sensitivity: float, 
+    manual_bpm: float, 
+    time_signature: str, 
+    crossfade_ms: int, 
+    transpose_semitones: int, 
+    detected_key: str,
+    pan_depth: float, 
+    level_depth: float, 
+    modulation_rate: str, 
+    target_dbfs: float,
+    attack_gain: float, 
+    sustain_gain: float, 
+    filter_type: str, 
+    filter_freq: float, 
+    filter_depth: float
+) -> str:
+    """Slices all available stems and packages them into a ZIP file."""
+    try:
+        stems_to_process = {
+            "vocals": vocals, "drums": drums, "bass": bass,
+            "other": other, "guitar": guitar, "piano": piano
+        }
+        
+        # Filter out None stems
+        valid_stems = {name: data for name, data in stems_to_process.items() if data is not None}
+        
+        if not valid_stems:
+            raise gr.Error("No stems to process! Please separate stems first.")
+
+        # Create temporary directory for all outputs
+        temp_dir = tempfile.mkdtemp()
+        zip_path = os.path.join(temp_dir, "Loop_Architect_Pack.zip")
+
+        with zipfile.ZipFile(zip_path, 'w') as zf:
+            for name, data in valid_stems.items():
+                # Create temporary file for this stem
+                stem_temp_dir = tempfile.mkdtemp()
+                stem_path = os.path.join(stem_temp_dir, f"{name}.wav")
+                sf.write(stem_path, data[1], data[0])
+                
+                # Process stem
+                sliced_files, _ = slice_stem_real(
+                    (data[0], data[1]), loop_choice, sensitivity, name,
+                    manual_bpm, time_signature, crossfade_ms, transpose_semitones, detected_key,
+                    pan_depth, level_depth, modulation_rate, target_dbfs,
+                    attack_gain, sustain_gain, filter_type, filter_freq, filter_depth
+                )
+                
+                # Add files to ZIP
+                for file_path, file_type in sliced_files:
+                    arcname = os.path.join(file_type, os.path.basename(file_path))
+                    zf.write(file_path, arcname)
+                
+                # Clean up stem temp files
+                shutil.rmtree(stem_temp_dir)
+
+        return zip_path
+
+    except Exception as e:
+        raise gr.Error(f"Error creating ZIP: {str(e)}")
+
+# --- GRADIO INTERFACE ---
+
+with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red")) as demo:
+    gr.Markdown("# 🎵 Loop Architect (Pro Edition)")
+    gr.Markdown("Upload any song to separate it into stems, detect musical attributes, and then slice and tag the stems for instant use in a DAW.")
+
+    # State variables
+    detected_bpm_state = gr.State(value=120.0)
+    detected_key_state = gr.State(value="Unknown Key")
+    harmonic_recs_state = gr.State(value="---")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Separate Stems")
+            audio_input = gr.Audio(type="filepath", label="Upload a Track")
+            separate_btn = gr.Button("Separate & Analyze Stems", variant="primary")
+            
+            # Outputs for separated stems
+            vocals_output = gr.Audio(label="Vocals", visible=False)
+            drums_output = gr.Audio(label="Drums", visible=False)
+            bass_output = gr.Audio(label="Bass", visible=False)
+            other_output = gr.Audio(label="Other / Instrumental", visible=False)
+            guitar_output = gr.Audio(label="Guitar", visible=False)
+            piano_output = gr.Audio(label="Piano", visible=False)
+            
+            # Analysis results
+            with gr.Group():
+                gr.Markdown("### 2. Analysis & Transform")
+                detected_bpm_key = gr.Textbox(label="Detected Tempo & Key", value="", interactive=False)
+                harmonic_recs = gr.Textbox(label="Harmonic Mixing Recommendations", value="", interactive=False)
+                
+                transpose_slider = gr.Slider(
+                    minimum=-12, maximum=12, value=0, step=1,
+                    label="Transpose Loops (Semitones)",
+                    info="Shift the pitch of all slices by +/- 1 octave."
+                )
+
+            # Transient Shaping
+            gr.Markdown("### Transient Shaping (Drums Only)")
+            with gr.Group():
+                attack_gain_slider = gr.Slider(
+                    minimum=0.5, maximum=1.5, value=1.0, step=0.1,
+                    label="Attack Gain Multiplier",
+                    info="Increase (>1.0) for punchier transients."
+                )
+                sustain_gain_slider = gr.Slider(
+                    minimum=0.5, maximum=1.5, value=1.0, step=0.1,
+                    label="Sustain Gain Multiplier",
+                    info="Increase (>1.0) for longer tails/reverb."
+                )
+
+            # Modulation
+            gr.Markdown("### Pan/Level Modulation (LFO 1.0)")
+            with gr.Group():
+                modulation_rate_radio = gr.Radio(
+                    ['1/2', '1/4', '1/8', '1/16'],
+                    label="Modulation Rate (Tempo Synced)",
+                    value='1/4'
+                )
+                pan_depth_slider = gr.Slider(
+                    minimum=0, maximum=100, value=0, step=5,
+                    label="Pan Modulation Depth (%)",
+                    info="Creates a stereo auto-pan effect."
+                )
+                level_depth_slider = gr.Slider(
+                    minimum=0, maximum=100, value=0, step=5,
+                    label="Level Modulation Depth (%)",
+                    info="Creates a tempo-synced tremolo (volume pulse)."
+                )
+
+            # Filter Modulation
+            gr.Markdown("### Filter Modulation (LFO 2.0)")
+            with gr.Group():
+                filter_type_radio = gr.Radio(
+                    ['low', 'high'],
+                    label="Filter Type",
+                    value='low'
+                )
+                with gr.Row():
+                    filter_freq_slider = gr.Slider(
+                        minimum=20, maximum=10000, value=2000, step=10,
+                        label="Base Cutoff Frequency (Hz)",
+                    )
+                    filter_depth_slider = gr.Slider(
+                        minimum=0, maximum=5000, value=0, step=10,
+                        label="Modulation Depth (Hz)",
+                        info="0 = Static filter at Base Cutoff."
+                    )
+
+            # Slicing Options
+            gr.Markdown("### 3. Slicing Options")
+            with gr.Group():
+                lufs_target_slider = gr.Slider(
+                    minimum=-18.0, maximum=-0.1, value=-3.0, step=0.1,
+                    label="Target Peak Level (dBFS)",
+                    info="Normalizes all exported loops to this peak volume."
+                )
+
+                loop_options_radio = gr.Radio(
+                    ["One-Shots", "4 Bar Loops", "8 Bar Loops"],
+                    label="Slice Type",
+                    value="One-Shots",
+                    info="Bar Loops include automatic MIDI generation for melodic stems."
+                )
+
+                with gr.Row():
+                    bpm_input = gr.Number(
+                        label="Manual BPM",
+                        value=120,
+                        minimum=40,
+                        maximum=300
+                    )
+                    time_sig_radio = gr.Radio(
+                        ["4/4", "3/4"],
+                        label="Time Signature",
+                        value="4/4"
+                    )
+
+                sensitivity_slider = gr.Slider(
+                    minimum=0.01, maximum=0.5, value=0.05, step=0.01,
+                    label="One-Shot Sensitivity",
+                    info="Lower values = more slices."
+                )
+
+                crossfade_ms_slider = gr.Slider(
+                    minimum=0, maximum=30, value=10, step=1,
+                    label="One-Shot Crossfade (ms)",
+                    info="Prevents clicks/pops on transient slices."
+                )
+
+            # Create Pack
+            gr.Markdown("### 4. Create Pack")
+            slice_all_btn = gr.Button("Slice, Transform & Tag ALL Stems (Create ZIP)", variant="stop")
+            download_zip_file = gr.File(label="Download Your Loop Pack", visible=False)
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Separated Stems")
+            with gr.Row():
+                with gr.Column():
+                    vocals_output.render()
+                    slice_vocals_btn = gr.Button("Slice Vocals")
+                with gr.Column():
+                    drums_output.render()
+                    slice_drums_btn = gr.Button("Slice Drums")
+            with gr.Row():
+                with gr.Column():
+                    bass_output.render()
+                    slice_bass_btn = gr.Button("Slice Bass")
+                with gr.Column():
+                    other_output.render()
+                    slice_other_btn = gr.Button("Slice Other")
+            with gr.Row():
+                with gr.Column():
+                    guitar_output.render()
+                    slice_guitar_btn = gr.Button("Slice Guitar")
+                with gr.Column():
+                    piano_output.render()
+                    slice_piano_btn = gr.Button("Slice Piano")
+            
+            # Gallery for previews
+            gr.Markdown("### Sliced Loops Preview")
+            loop_gallery = gr.Gallery(
+                label="Generated Loops",
+                columns=4, 
+                object_fit="contain", 
+                height="auto"
+            )
+
+    # --- EVENT HANDLERS ---
+
+    # Stem separation
+    separate_btn.click(
+        fn=separate_stems,
+        inputs=[audio_input],
+        outputs=[
+            vocals_output, drums_output, bass_output, other_output,
+            guitar_output, piano_output,
+            detected_bpm_state, detected_key_state
+        ]
+    ).then(
+        fn=lambda bpm, key: (f"{bpm} BPM, {key}", get_harmonic_recommendations(key)),
+        inputs=[detected_bpm_state, detected_key_state],
+        outputs=[detected_bpm_key, harmonic_recs_state]
+    ).then(
+        fn=lambda bpm, key: gr.update(value=f"{bpm} BPM, {key}"),
+        inputs=[detected_bpm_state, detected_key_state],
+        outputs=[detected_bpm_key]
+    ).then(
+        fn=get_harmonic_recommendations,
+        inputs=[detected_key_state],
+        outputs=[harmonic_recs]
+    )
+
+    # Individual stem slicing
+    def slice_and_display(stem_data, loop_choice, sensitivity, stem_name, manual_bpm, time_signature, 
+                         crossfade_ms, transpose_semitones, detected_key, pan_depth, level_depth, 
+                         modulation_rate, target_dbfs, attack_gain, sustain_gain, filter_type, 
+                         filter_freq, filter_depth):
+        if stem_data is None:
+            return [], "No stem data available"
+        
+        try:
+            files, img_path = slice_stem_real(
+                stem_data, loop_choice, sensitivity, stem_name,
+                manual_bpm, time_signature, crossfade_ms, transpose_semitones, detected_key,
+                pan_depth, level_depth, modulation_rate, target_dbfs,
+                attack_gain, sustain_gain, filter_type, filter_freq, filter_depth
+            )
+            
+            # Return only WAV files for gallery display
+            wav_files = [f[0] for f in files if f[1] == "WAV"]
+            return wav_files + [img_path], f"Generated {len(wav_files)} slices for {stem_name}"
+        except Exception as e:
+            return [], f"Error: {str(e)}"
+
+    slice_vocals_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            vocals_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="vocals", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    slice_drums_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            drums_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="drums", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    slice_bass_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            bass_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="bass", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    slice_other_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            other_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="other", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    slice_guitar_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            guitar_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="guitar", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    slice_piano_btn.click(
+        fn=slice_and_display,
+        inputs=[
+            piano_output, loop_options_radio, sensitivity_slider, gr.Textbox(value="piano", visible=False),
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[loop_gallery, gr.Textbox(label="Status")]
+    )
+
+    # Slice all stems and create ZIP
+    slice_all_btn.click(
+        fn=slice_all_and_zip,
+        inputs=[
+            vocals_output, drums_output, bass_output, other_output, guitar_output, piano_output,
+            loop_options_radio, sensitivity_slider,
+            bpm_input, time_sig_radio, crossfade_ms_slider, transpose_slider, detected_key_state,
+            pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
+            attack_gain_slider, sustain_gain_slider,
+            filter_type_radio, filter_freq_slider, filter_depth_slider
+        ],
+        outputs=[download_zip_file]
+    ).then(
+        fn=lambda: gr.update(visible=True),
+        inputs=None,
+        outputs=[download_zip_file]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()