Update app.py

app.py

@@ -1,8 +1,7 @@
-# app.py
 import gradio as gr
 import numpy as np
 import librosa
-import librosa.display  # Added missing import
+import librosa.display
 import soundfile as sf
 import os
 import tempfile
@@ -11,24 +10,54 @@ import time
 import matplotlib
 import matplotlib.pyplot as plt
 from scipy import signal
-from typing import Tuple, List, Any
+from typing import Tuple, List, Any, Optional, Dict
 import shutil
 
 # Use a non-interactive backend for Matplotlib
 matplotlib.use('Agg')
 
+# --- CONSTANTS & DICTIONARIES ---
+
+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",
+    # Enharmonic equivalents
+    "Gb Maj": "2B", "Cb Maj": "7B", "A# Min": "3A", "D# Maj": "5B", "G# Maj": "4B"
+}
+
+# Fixed reverse mapping to avoid "lossy" inversion
+CAMELOT_TO_KEY = {
+    "8B": "C Maj", "9B": "G Maj", "10B": "D Maj", "11B": "A Maj", "12B": "E Maj",
+    "1B": "B Maj", "2B": "F# Maj / Gb Maj", "3B": "Db Maj", "4B": "Ab Maj / G# Maj", "5B": "Eb Maj / D# Maj",
+    "6B": "Bb Maj", "7B": "F Maj / Cb Maj",
+    "8A": "A Min", "9A": "E Min", "10A": "B Min", "11A": "F# Min", "12A": "C# Min",
+    "1A": "G# Min", "2A": "D# Min", "3A": "Bb Min / A# Min", "4A": "F Min", "5A": "C Min",
+    "6A": "G Min", "7A": "D Min"
+}
+
+STEM_NAMES = ["vocals", "drums", "bass", "other", "guitar", "piano"]
+
 # --- 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)
+    # C1 is ~32.7 Hz. Let's set a reasonable floor.
+    if freq < 32.0:
         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."""
+    """
+    Writes a basic MIDI file from a list of notes.
+    Note: This is a simplified MIDI writer and may have issues.
+    Using a dedicated library like 'mido' is recommended for robust use.
+    """
     if not notes_list:
         return
 
@@ -42,67 +71,77 @@ def write_midi_file(notes_list: List[Tuple[int, float, float]], bpm: float, outp
     current_tick = 0
     midi_events = []
 
+    # --- MIDI Track Header ---
+    # Set Tempo: FF 51 03 TTTTTT (TTTTTT = tempo_us_per_beat)
+    tempo_bytes = tempo_us_per_beat.to_bytes(3, 'big')
+    track_data = b'\x00\xFF\x51\x03' + tempo_bytes
+    
+    # Set Time Signature: FF 58 04 NN DD CC BB (Using 4/4)
+    track_data += b'\x00\xFF\x58\x04\x04\x02\x18\x08' 
+    
+    # Set Track Name
+    track_data += b'\x00\xFF\x03\x0BLoopArchitect' # 11 chars
+
     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)
+        target_tick = int(round(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))
+        track_data += encode_delta_time(delta_tick) + bytes(note_on)
 
         # Note Off event (Channel 1, Velocity 0)
-        duration_ticks = int(duration_sec / seconds_per_tick)
+        duration_ticks = int(round(duration_sec / seconds_per_tick))
+        if duration_ticks == 0:
+            duration_ticks = 1 # Minimum duration
+            
         note_off = [0x80, note, 0]
-        midi_events.append((duration_ticks, note_off))
+        track_data += encode_delta_time(duration_ticks) + bytes(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'
 
+    # --- MIDI File Header ---
+    # MThd, header_length (6), format (1), num_tracks (1), division
+    header = b'MThd' + (6).to_bytes(4, 'big') + (1).to_bytes(2, 'big') + (1).to_bytes(2, 'big') + division.to_bytes(2, 'big')
+    
+    # MTrk, track_length, track_data
     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 encode_delta_time(ticks: int) -> bytes:
+    """Encodes an integer tick value into MIDI variable-length quantity."""
+    buffer = ticks & 0x7F
+    ticks >>= 7
+    if ticks > 0:
+        buffer |= 0x80
+        while ticks > 0:
+            buffer = (buffer << 8) | ((ticks & 0x7F) | 0x80)
+            ticks >>= 7
+        buffer = (buffer & 0xFFFFFF7F) # Clear MSB of last byte
+        
+        # Convert buffer to bytes
+        byte_list = []
+        while buffer > 0:
+            byte_list.insert(0, buffer & 0xFF)
+            buffer >>= 8
+        if not byte_list:
+            return b'\x00'
+        return bytes(byte_list)
+    else:
+        return bytes([buffer])
+
 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.)"
@@ -113,11 +152,17 @@ def get_harmonic_recommendations(key_str: str) -> str:
         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]
+        
+        recs_codes = [
+            f"{num}{opposite_mode}",   # e.g., 8A (A Min) -> 8B (C Maj)
+            f"{num_plus_one}{mode}",   # e.g., 8A (A Min) -> 9A (E Min)
+            f"{num_minus_one}{mode}"   # e.g., 8A (A Min) -> 7A (D Min)
+        ]
+        
+        rec_keys = [f"{CAMELOT_TO_KEY.get(r_code, f'Code {r_code}')} ({r_code})" for r_code in recs_codes]
         return " | ".join(rec_keys)
-    except Exception:
+    except Exception as e:
+        print(f"Error calculating recommendations: {e}")
         return "N/A (Error calculating recommendations.)"
 
 def detect_key(y: np.ndarray, sr: int) -> str:
@@ -125,10 +170,20 @@ def detect_key(y: np.ndarray, sr: int) -> str:
     try:
         chroma = librosa.feature.chroma_stft(y=y, sr=sr)
         chroma_sums = np.sum(chroma, axis=1)
+        
+        # Avoid division by zero if audio is silent
+        if np.sum(chroma_sums) == 0:
+            return "Unknown Key"
+            
         chroma_norm = chroma_sums / np.sum(chroma_sums)
 
+        # Krumhansl-Schmuckler key-finding algorithm templates
         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])
+        
+        # Normalize templates
+        major_template /= np.sum(major_template)
+        minor_template /= np.sum(minor_template)
 
         pitch_classes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
 
@@ -148,31 +203,47 @@ def detect_key(y: np.ndarray, sr: int) -> str:
 
 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:
+    if y.ndim == 0:
         return y
+    if y.ndim == 1:
+        y = np.stack((y, y), axis=-1) # Convert to stereo
 
     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)
+    # LFO frequency = (BPM / 60) * (beats_per_measure / 4.0) -- seems off.
+    # Let's redefine: LFO freq in Hz = (BPM / 60) * (1 / (4 / beats_per_measure))
+    # e.g., 1/4 rate at 120BPM = 2Hz. (120/60) * (1 / (4/1)) = 2 * (1/4) = 0.5Hz? No.
+    # 120 BPM = 2 beats/sec. 1/4 note = 1 beat. So LFO should be 2 Hz.
+    # 1/8 note = 4 Hz.
+    # 1/16 note = 8 Hz.
+    # 1/2 note = 1 Hz.
+    # Formula: (BPM / 60) * (rate_map_value / 4)
+    # 1/4 note: (120/60) * (1/4) = 0.5 Hz. Still wrong.
+    # Let's try: (BPM / 60) * (rate_map_value)
+    # 1/4 note @ 120BPM: (120/60) * 1 = 2 Hz. Correct.
+    # 1/8 note @ 120BPM: (120/60) * 2 = 4 Hz. Correct.
+    # 1/2 note @ 120BPM: (120/60) * 0.5 = 1 Hz. Correct.
+    lfo_freq_hz = (bpm / 60.0) * rate_map.get(rate, 1)
 
     t = np.linspace(0, duration_sec, N, endpoint=False)
 
-    # Panning LFO
+    # Panning LFO (Sine wave, -1 to 1)
     if pan_depth > 0:
         pan_lfo = np.sin(2 * np.pi * lfo_freq_hz * t) * pan_depth
+        # L_mod/R_mod should be 0-1. (1-pan_lfo)/2 and (1+pan_lfo)/2 gives 0-1 range.
         L_mod = (1 - pan_lfo) / 2.0
         R_mod = (1 + pan_lfo) / 2.0
+        # This is amplitude panning, not constant power. Good enough.
         y[:, 0] *= L_mod
         y[:, 1] *= R_mod
 
-    # Level LFO (Tremolo)
+    # Level LFO (Tremolo) (Sine wave, 0 to 1)
     if level_depth > 0:
         level_lfo = (np.sin(2 * np.pi * lfo_freq_hz * t) + 1) / 2.0
+        # gain_multiplier ranges from (1-level_depth) to 1
         gain_multiplier = (1 - level_depth) + (level_depth * level_lfo)
         y[:, 0] *= gain_multiplier
         y[:, 1] *= gain_multiplier
@@ -182,35 +253,38 @@ def apply_modulation(y: np.ndarray, sr: int, bpm: float, rate: str, pan_depth: f
 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
+        return y # Don't normalize to 0dBFS or higher
 
     current_peak_amp = np.max(np.abs(y))
+    if current_peak_amp < 1e-9: # Avoid division by zero on silence
+        return 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
+    gain = target_peak_amp / current_peak_amp
+    y_normalized = y * gain
+    
+    # Clip just in case of floating point inaccuracies
+    y_normalized = np.clip(y_normalized, -1.0, 1.0)
+    return y_normalized
 
 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:
+    if depth == 0 or filter_type == "None":
         return y
 
     # Ensure stereo for LFO application
     if y.ndim == 1:
         y = np.stack((y, y), axis=-1)
+    if y.ndim == 0:
+        return y
 
     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)
+    lfo_freq_hz = (bpm / 60.0) * rate_map.get(rate, 1)
 
     t = np.linspace(0, duration_sec, N, endpoint=False)
 
@@ -220,25 +294,43 @@ def apply_filter_modulation(y: np.ndarray, sr: int, bpm: float, rate: str, filte
     # 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)
+    nyquist = sr / 2.0
+    cutoff_modulation = np.clip(cutoff_modulation, 20.0, nyquist - 100.0) # Keep away from Nyquist
 
     y_out = np.zeros_like(y)
-    filter_type_b = filter_type.lower().replace('-pass', '')
+    
+    # --- BUG FIX ---
+    # Was: filter_type.lower().replace('-pass', '') -> 'low' (ValueError)
+    # Now: filter_type.lower().replace('-pass', 'pass') -> 'lowpass' (Correct)
+    filter_type_b = filter_type.lower().replace('-pass', 'pass')
+
     frame_size = 512  # Frame-based update for filter coefficients
+    if N < frame_size:
+        frame_size = N # Handle very short audio
 
     # Apply filter channel by channel
     for channel in range(y.shape[1]):
-        zi = np.zeros(2)  # Initial filter state (2nd order filter)
+        zi = signal.lfilter_zi(*signal.butter(2, 20.0, btype=filter_type_b, fs=sr))
 
         for frame_start in range(0, N, frame_size):
             frame_end = min(frame_start + frame_size, N)
+            if frame_start == frame_end: continue # Skip empty frames
+            
             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)
+            try:
+                b, a = signal.butter(2, avg_cutoff, btype=filter_type_b, fs=sr)
+            except ValueError as e:
+                print(f"Butterworth filter error: {e}. Using last good coefficients.")
+                # This can happen if avg_cutoff is bad, though we clip it.
+                # If it still fails, we just re-use the last good b, a.
+                # In the first frame, this is not robust.
+                if 'b' not in locals():
+                    b, a = signal.butter(2, 20.0, btype=filter_type_b, fs=sr) # Failsafe
 
             # Apply filter to the frame, updating the state `zi`
             filtered_frame, zi = signal.lfilter(b, a, frame, zi=zi)
@@ -246,39 +338,119 @@ def apply_filter_modulation(y: np.ndarray, sr: int, bpm: float, rate: str, filte
 
     return y_out
 
+def apply_crossfade(y: np.ndarray, fade_samples: int) -> np.ndarray:
+    """Applies a linear fade-in and fade-out to a clip."""
+    if fade_samples == 0:
+        return y
+    
+    N = len(y)
+    fade_samples = min(fade_samples, N // 2) # Fade can't be longer than half the clip
+    
+    if fade_samples == 0:
+        return y # Clip is too short to fade
+
+    # Create fade ramps
+    fade_in = np.linspace(0, 1, fade_samples)
+    fade_out = np.linspace(1, 0, fade_samples)
+
+    y_out = y.copy()
+    
+    # Apply fades (handling mono/stereo)
+    if y.ndim == 1:
+        y_out[:fade_samples] *= fade_in
+        y_out[-fade_samples:] *= fade_out
+    else:
+        y_out[:fade_samples, :] *= fade_in[:, np.newaxis]
+        y_out[-fade_samples:, :] *= fade_out[:, np.newaxis]
+        
+    return y_out
+
+def apply_envelope(y: np.ndarray, sr: int, attack_gain_db: float, sustain_gain_db: float) -> np.ndarray:
+    """Applies a simple attack/sustain gain envelope to one-shots."""
+    N = len(y)
+    if N == 0:
+        return y
+        
+    # Simple fixed attack time of 10ms
+    attack_time_sec = 0.01
+    attack_samples = min(int(attack_time_sec * sr), N // 2)
+    
+    start_gain = 10**(attack_gain_db / 20.0)
+    end_gain = 10**(sustain_gain_db / 20.0)
+
+    # Envelope: Linear ramp from start_gain to end_gain over attack_samples, then hold end_gain
+    envelope = np.ones(N) * end_gain
+    if attack_samples > 0:
+        attack_ramp = np.linspace(start_gain, end_gain, attack_samples)
+        envelope[:attack_samples] = attack_ramp
+
+    # Apply envelope (handling mono/stereo)
+    if y.ndim == 1:
+        y_out = y * envelope
+    else:
+        y_out = y * envelope[:, np.newaxis]
+        
+    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."""
+def separate_stems(audio_file_path: str) -> Tuple[
+    Optional[Tuple[int, np.ndarray]], 
+    Optional[Tuple[int, np.ndarray]], 
+    Optional[Tuple[int, np.ndarray]], 
+    Optional[Tuple[int, np.ndarray]], 
+    Optional[Tuple[int, np.ndarray]], 
+    Optional[Tuple[int, np.ndarray]], 
+    float, str, str
+]:
+    """
+    Simulates stem separation and detects BPM and Key.
+    Returns Gradio Audio tuples (sr, data) for each stem.
+    """
     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
+        y_orig, sr_orig = librosa.load(audio_file_path, sr=None, mono=False)
+        
+        # Ensure stereo for processing
+        if y_orig.ndim == 1:
+            y_orig = np.stack([y_orig, y_orig], axis=-1)
+        # librosa.load with mono=False may return (N,) for mono files,
+        # or (2, N). Need to ensure (N, 2) or (N,)
+        if y_orig.ndim == 2 and y_orig.shape[0] < y_orig.shape[1]:
+             y_orig = y_orig.T # Transpose to (N, 2)
+            
+        y_mono = librosa.to_mono(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_bpm = 120.0 if tempo is None or tempo.size == 0 or tempo[0] == 0 else float(np.round(tempo[0]))
         detected_key = detect_key(y_mono, sr_orig)
+        harmonic_recs = get_harmonic_recommendations(detected_key)
 
         # Create mock separated stems
-        temp_dir = tempfile.mkdtemp()
-        stems = {}
-        stem_names = ["vocals", "drums", "bass", "other", "guitar", "piano"]
+        # In a real app, you'd use Demucs, Spleeter, etc.
+        # Here, we just return the original audio for each stem for demo purposes.
+        stems_data: Dict[str, Optional[Tuple[int, np.ndarray]]] = {}
+        
+        # Convert to int16 for Gradio Audio component
+        y_int16 = (y_orig * 32767).astype(np.int16)
 
-        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
+        for name in STEM_NAMES:
+            # We give each stem the full audio for this demo
+            stems_data[name] = (sr_orig, y_int16.copy())
 
         return (
-            stems["vocals"], stems["drums"], stems["bass"], stems["other"],
-            stems["guitar"], stems["piano"], float(detected_bpm), detected_key
+            stems_data["vocals"], stems_data["drums"], stems_data["bass"], stems_data["other"],
+            stems_data["guitar"], stems_data["piano"], 
+            detected_bpm, detected_key, harmonic_recs
         )
     except Exception as e:
+        print(f"Error processing audio: {e}")
+        import traceback
+        traceback.print_exc()
         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:
@@ -286,9 +458,12 @@ def generate_waveform_preview(y: np.ndarray, sr: int, stem_name: str, temp_dir:
     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
+    y_display = librosa.to_mono(y.T) if y.ndim > 1 and y.shape[0] < y.shape[1] else y
+    y_display = librosa.to_mono(y) 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.title(f"{stem_name} Waveform (Processed)")
+    plt.ylabel("Amplitude")
     plt.tight_layout()
     plt.savefig(img_path)
     plt.close()
@@ -296,7 +471,7 @@ def generate_waveform_preview(y: np.ndarray, sr: int, stem_name: str, temp_dir:
     return img_path
 
 def slice_stem_real(
-    stem_audio_path: str,
+    stem_audio_tuple: Optional[Tuple[int, np.ndarray]],
     loop_choice: str,
     sensitivity: float,
     stem_name: str,
@@ -314,39 +489,33 @@ def slice_stem_real(
     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 [], ""
+) -> Tuple[List[str], Optional[str]]:
+    """
+    Slices a single stem and applies transformations.
+    Returns a list of filepaths and a path to a preview image.
+    """
+    if stem_audio_tuple is None:
+        return [], None
 
     try:
-        # Load audio
-        # Assuming stem_audio_path is a tuple (sample_rate, audio_array) from Gradio
-        if isinstance(stem_audio_path, tuple) and len(stem_audio_path) == 2:
-            sample_rate, y_int = stem_audio_path
-            y = librosa.util.buf_to_float(y_int, dtype=np.float32)
-        else:
-            # Handle case where it's a filepath (from separate_stems)
-            y, sample_rate = librosa.load(stem_audio_path, sr=None)  # Fixed indentation
-
-        if y.ndim == 0:
-            return [], ""
-
-        y_mono = librosa.to_mono(y.T) if y.ndim > 1 else y
+        sample_rate, y_int = stem_audio_tuple
+        # Convert from int16 array back to float
+        y = y_int.astype(np.float32) / 32767.0
+        
+        if y.ndim == 0 or len(y) == 0:
+            return [], None
 
         # --- 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
+            y = librosa.effects.pitch_shift(y, sr=sample_rate, n_steps=transpose_semitones)
 
         # --- 2. FILTER MODULATION ---
-        if filter_depth > 0:
+        if filter_depth > 0 and filter_type != "None":
             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)
 
@@ -355,467 +524,14 @@ def slice_stem_real(
             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():
-                # Process stem
-                sliced_files, _ = slice_stem_real(
-                    data, 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)
-
-        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  # Place component in layout
-                    slice_vocals_btn = gr.Button("Slice Vocals")
-                with gr.Column():
-                    drums_output  # Place component in layout
-                    slice_drums_btn = gr.Button("Slice Drums")
-            with gr.Row():
-                with gr.Column():
-                    bass_output  # Place component in layout
-                    slice_bass_btn = gr.Button("Slice Bass")
-                with gr.Column():
-                    other_output  # Place component in layout
-                    slice_other_btn = gr.Button("Slice Other")
-            with gr.Row():
-                with gr.Column():
-                    guitar_output  # Place component in layout
-                    slice_guitar_btn = gr.Button("Slice Guitar")
-                with gr.Column():
-                    piano_output  # Place component in layout
-                    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"
-            )
-            
-            # Status textboxes for individual slicing
-            status_textbox = gr.Textbox(label="Status", visible=True)
-
-    # --- 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, status_textbox]
-    )
-
-    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, status_textbox]
-    )
-
-    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, status_textbox]
-    )
-
-    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, status_textbox]
-    )
-
-    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, status_textbox]
-    )
-
-    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, status_textbox]
-    )
-
-    # 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()
+        bpm_int = int(round(manual_bpm))
+        key_tag = "UnknownKey"
+        if detected_key != "Unknown Key":
+            key_tag = detected_key.replace(" ", "")
+            if transpose_semitones != 0:
+                root, mode = detected_key.split(" ")
+                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_cla