Update app.py

app.py

@@ -534,4 +534,359 @@ def slice_stem_real(
                 try:
                     current_index = pitch_classes.index(root)
                     new_index = (current_index + transpose_semitones) % 12
-                    new_key_root = pitch_classes
+                    new_key_root = pitch_classes[new_index]
+                    key_tag = f"{new_key_root}{mode}Shift"
+                except ValueError:
+                    key_tag = f"Shifted{transpose_semitones}" # Fallback
+        
+        # --- 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:
+                y_mono_for_midi = librosa.to_mono(y)
+                # Use piptrack for pitch detection
+                pitches, magnitudes = librosa.piptrack(y=y_mono_for_midi, sr=sample_rate)
+                
+                # Get the dominant pitch at each frame
+                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
+                hop_length = 512 # Default hop for piptrack
+                
+                while i < len(main_pitch_line):
+                    current_freq = main_pitch_line[i]
+                    current_midi = freq_to_midi(current_freq)
+                    if current_midi == 0: # Skip silence/unpitched
+                        i += 1
+                        continue
+
+                    # Find end of this note
+                    j = i
+                    while j < len(main_pitch_line) and freq_to_midi(main_pitch_line[j]) == current_midi:
+                        j += 1
+
+                    duration_frames = j - i
+                    # Only add notes that are long enough (e.g., > 2 frames)
+                    if duration_frames >= 2:
+                        start_sec = librosa.frames_to_time(i, sr=sample_rate, hop_length=hop_length)
+                        duration_sec = librosa.frames_to_time(duration_frames, sr=sample_rate, hop_length=hop_length)
+                        notes_list.append((current_midi, start_sec, duration_sec))
+                    
+                    i = j
+
+                if notes_list:
+                    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)
+
+            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 / manual_bpm * beats_per_bar * bars) * sample_rate)
+            fade_samples = int((crossfade_ms / 1000.0) * 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, 16)):  # Limit to 16 loops
+                    start_sample = i * loop_duration_samples
+                    end_sample = min(start_sample + loop_duration_samples, len(y))
+                    slice_data = y[start_sample:end_sample]
+
+                    # Apply crossfade
+                    slice_data = apply_crossfade(slice_data, fade_samples)
+
+                    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)
+
+        elif "One-Shots" in loop_choice:
+            loop_type_tag = "OneShot"
+            y_mono_for_onsets = librosa.to_mono(y)
+            
+            # IMPLEMENTED: Use sensitivity to find onsets
+            # Adjust 'wait' and 'delta' based on sensitivity (0-1)
+            # Higher sensitivity = lower delta, shorter wait
+            delta = 0.5 * (1.0 - sensitivity) # 0.0 -> 0.5
+            wait_sec = 0.1 * (1.0 - sensitivity) # 0.0 -> 0.1
+            wait_samples = int(wait_sec * sample_rate / 512) # in frames
+            
+            onset_frames = librosa.onset.onset_detect(
+                y=y_mono_for_onsets, 
+                sr=sample_rate, 
+                units='frames', 
+                backtrack=True,
+                delta=delta,
+                wait=wait_samples
+            )
+            onset_samples = librosa.frames_to_samples(onset_frames)
+            
+            # Add end of file as the last "onset"
+            onset_samples = np.append(onset_samples, len(y))
+
+            for i in range(min(len(onset_samples) - 1, 40)):  # Limit to 40 slices
+                start_sample = onset_samples[i]
+                end_sample = onset_samples[i+1]
+                slice_data = y[start_sample:end_sample]
+                
+                if len(slice_data) < 100: # Skip tiny fragments
+                    continue
+
+                # IMPLEMENTED: Apply attack/sustain envelope
+                slice_data = apply_envelope(slice_data, sample_rate, attack_gain, sustain_gain)
+                
+                # Apply short fade-out to prevent clicks
+                slice_data = apply_crossfade(slice_data, int(0.005 * sample_rate)) # 5ms fade
+
+                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)
+
+        # --- 8. VISUALIZATION GENERATION ---
+        img_path = generate_waveform_preview(y, sample_rate, stem_name, loops_dir)
+
+        # Clean up the temp dir for the *next* run
+        # Gradio File components need the files to exist, so we don't delete loops_dir yet
+        # A more robust solution would use gr.TempFile() or manage cleanup
+        
+        return output_files, img_path
+
+    except Exception as e:
+        print(f"Error processing stem {stem_name}: {e}")
+        import traceback
+        traceback.print_exc()
+        return [], None # Return empty on error
+
+
+def slice_all_and_zip(
+    vocals_audio: Optional[Tuple[int, np.ndarray]],
+    drums_audio: Optional[Tuple[int, np.ndarray]],
+    bass_audio: Optional[Tuple[int, np.ndarray]],
+    other_audio: Optional[Tuple[int, np.ndarray]],
+    guitar_audio: Optional[Tuple[int, np.ndarray]],
+    piano_audio: Optional[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,
+    progress: gr.Progress
+) -> Optional[str]:
+    """Slices all available stems and packages them into a ZIP file."""
+    try:
+        stems_to_process = {
+            "vocals": vocals_audio, "drums": drums_audio, "bass": bass_audio,
+            "other": other_audio, "guitar": guitar_audio, "piano": piano_audio
+        }
+
+        # 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")
+        
+        all_sliced_files = []
+
+        # Use progress tracker
+        progress(0, desc="Starting...")
+        
+        num_stems = len(valid_stems)
+        for i, (name, data) in enumerate(valid_stems.items()):
+            progress((i+1)/num_stems, desc=f"Slicing {name}...")
+            
+            # 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
+            )
+            all_sliced_files.extend(sliced_files)
+
+        progress(0.9, desc="Zipping files...")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for file_path in all_sliced_files:
+                if not file_path: continue
+                # Create a sane folder structure in the ZIP
+                file_type = os.path.splitext(file_path)[1][1:].upper() # WAV or MID
+                arcname = os.path.join(file_type, os.path.basename(file_path))
+                zf.write(file_path, arcname)
+        
+        progress(1.0, desc="Done!")
+        
+        # Clean up individual slice files (but not the zip dir)
+        for file_path in all_sliced_files:
+            if file_path and os.path.exists(file_path):
+                os.remove(file_path)
+
+        return zip_path
+
+    except Exception as e:
+        print(f"Error creating ZIP: {e}")
+        import traceback
+        traceback.print_exc()
+        raise gr.Error(f"Error creating ZIP: {str(e)}")
+
+# --- GRADIO INTERFACE ---
+
+with gr.Blocks(theme=gr.themes.Soft(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="---")
+
+    # Outputs for each stem (as gr.Audio tuples)
+    vocals_audio = gr.Audio(visible=False, type="numpy")
+    drums_audio = gr.Audio(visible=False, type="numpy")
+    bass_audio = gr.Audio(visible=False, type="numpy")
+    other_audio = gr.Audio(visible=False, type="numpy")
+    guitar_audio = gr.Audio(visible=False, type="numpy")
+    piano_audio = gr.Audio(visible=False, type="numpy")
+    
+    stem_audio_outputs = [vocals_audio, drums_audio, bass_audio, other_audio, guitar_audio, piano_audio]
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            # --- INPUT COLUMN ---
+            gr.Markdown("### 1. Upload & Analyze")
+            audio_input = gr.Audio(label="Upload Song", type="filepath")
+            separate_button = gr.Button("Separate Stems & Analyze", variant="primary")
+            
+            with gr.Accordion("Global Musical Settings", open=True):
+                manual_bpm_input = gr.Number(label="BPM", value=120.0, step=0.1, interactive=True)
+                key_display = gr.Textbox(label="Detected Key", value="Unknown Key", interactive=False)
+                harmonic_recs_display = gr.Textbox(label="Harmonic Recommendations", value="---", interactive=False)
+                transpose_semitones = gr.Slider(label="Transpose (Semitones)", minimum=-12, maximum=12, value=0, step=1)
+                time_signature = gr.Radio(label="Time Signature", choices=["4/4", "3/4"], value="4/4")
+
+            with gr.Accordion("Global Slicing Settings", open=True):
+                loop_choice = gr.Radio(label="Loop Type", choices=["1 Bar Loops", "2 Bar Loops", "4 Bar Loops", "One-Shots"], value="4 Bar Loops")
+                sensitivity = gr.Slider(label="One-Shot Sensitivity", minimum=0.0, maximum=1.0, value=0.5, info="Higher = more slices")
+                crossfade_ms = gr.Slider(label="Loop Crossfade (ms)", minimum=0, maximum=50, value=10, step=1)
+            
+            with gr.Accordion("Global FX Settings", open=False):
+                target_dbfs = gr.Slider(label="Normalize Peak to (dBFS)", minimum=-24.0, maximum=-0.0, value=-1.0, step=0.1, info="-0.0 = Off")
+                
+                gr.Markdown("---")
+                gr.Markdown("**LFO Modulation (Pan/Level)**")
+                modulation_rate = gr.Radio(label="Modulation Rate", choices=["1/2", "1/4", "1/8", "1/16"], value="1/4")
+                pan_depth = gr.Slider(label="Pan Depth (%)", minimum=0, maximum=100, value=0, step=1)
+                level_depth = gr.Slider(label="Level Depth (%)", minimum=0, maximum=100, value=0, step=1, info="Tremolo effect")
+                
+                gr.Markdown("---")
+                gr.Markdown("**LFO Modulation (Filter)**")
+                filter_type = gr.Radio(label="Filter Type", choices=["None", "Low-pass", "High-pass"], value="None")
+                filter_freq = gr.Slider(label="Filter Base Freq (Hz)", minimum=20, maximum=10000, value=5000, step=100)
+                filter_depth = gr.Slider(label="Filter Mod Depth (Hz)", minimum=0, maximum=10000, value=0, step=100, info="LFO amount")
+                
+                gr.Markdown("---")
+                gr.Markdown("**One-Shot Shaping**")
+                attack_gain = gr.Slider(label="Attack Gain (dB)", minimum=-24.0, maximum=6.0, value=0.0, step=0.5, info="Gain at start of transient")
+                sustain_gain = gr.Slider(label="Sustain Gain (dB)", minimum=-24.0, maximum=6.0, value=0.0, step=0.5, info="Gain for note body")
+
+            gr.Markdown("### 3. Generate Pack")
+            slice_all_button = gr.Button("SLICE ALL & GENERATE PACK", variant="primary")
+            zip_file_output = gr.File(label="Download Your Loop Pack")
+
+        with gr.Column(scale=2):
+            # --- OUTPUT COLUMN ---
+            gr.Markdown("### 2. Review Stems & Slices")
+            with gr.Tabs():
+                # Create a tab for each stem
+                for i, name in enumerate(STEM_NAMES):
+                    with gr.Tab(name.capitalize()):
+                        with gr.Row():
+                            # The (hidden) audio output for this stem
+                            stem_audio_component = stem_audio_outputs[i]
+                            
+                            # Visible components
+                            preview_image = gr.Image(label="Processed Waveform", interactive=False)
+                            slice_files = gr.Files(label="Generated Slices & MIDI", interactive=False)
+                        
+                        # Add a button to slice just this one stem
+                        slice_one_button = gr.Button(f"Slice This {name.capitalize()} Stem")
+                        
+                        # Gather all global settings as inputs
+                        all_settings = [
+                            loop_choice, sensitivity, manual_bpm_input, time_signature, crossfade_ms,
+                            transpose_semitones, detected_key_state, pan_depth, level_depth, modulation_rate,
+                            target_dbfs, attack_gain, sustain_gain, filter_type, filter_freq, filter_depth
+                        ]
+                        
+                        # Wire up the "Slice One" button
+                        slice_one_button.click(
+                            fn=slice_stem_real,
+                            inputs=[stem_audio_component, gr.State(value=name)] + all_settings,
+                            outputs=[slice_files, preview_image]
+                        )
+
+    # --- EVENT LISTENERS ---
+
+    # 1. "Separate Stems" button click
+    separate_button.click(
+        fn=separate_stems,
+        inputs=[audio_input],
+        outputs=stem_audio_outputs + [detected_bpm_state, detected_key_state, harmonic_recs_state]
+    )
+
+    # 2. When BPM state changes, update the visible input box
+    detected_bpm_state.change(
+        fn=lambda x: x,
+        inputs=[detected_bpm_state],
+        outputs=[manual_bpm_input]
+    )
+    
+    # 3. When Key state changes, update the visible text boxes
+    detected_key_state.change(
+        fn=lambda x: x,
+        inputs=[detected_key_state],
+        outputs=[key_display]
+    )
+    harmonic_recs_state.change(
+        fn=lambda x: x,
+        inputs=[harmonic_recs_state],
+        outputs=[harmonic_recs_display]
+    )
+
+    # 4. "SLICE ALL" button click
+    slice_all_button.click(
+        fn=slice_all_and_zip,
+        inputs=stem_audio_outputs + all_settings,
+        outputs=[zip_file_output]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(debug=True)