Update app.py

app.py

@@ -17,7 +17,7 @@ TEMP_DIR = Path("temp_processing")
 # --- Core Logic Functions ---
 
 def analyze_and_separate(audio_file):
-    """Phase 1: Separate Stems and return file paths for preview"""
+    """Phase 1: Separate 6 Stems (Drums, Bass, Guitar, Piano, Vocals, Other)"""
     try:
         if not audio_file:
             raise ValueError("No audio file provided.")
@@ -38,56 +38,65 @@ def analyze_and_separate(audio_file):
         bpm = int(round(tempo[0])) if np.ndim(tempo) > 0 else int(round(tempo))
         print(f"Detected BPM: {bpm}")
 
-        # 2. Demucs Separation
-        print("Separating stems...")
+        # 2. Demucs Separation (Using 6-Stem Model)
+        print("Separating stems (6-Stem Model)...")
+        # We use '-n htdemucs_6s' to get Guitar and Piano separation
         subprocess.run([
-            sys.executable, "-m", "demucs", "-n", "htdemucs", "--out", str(TEMP_DIR), audio_file
+            sys.executable, "-m", "demucs", "-n", "htdemucs_6s", "--out", str(TEMP_DIR), audio_file
         ], check=True, capture_output=True)
 
         # 3. Locate Stems
-        demucs_out = TEMP_DIR / "htdemucs"
+        demucs_out = TEMP_DIR / "htdemucs_6s" # Note the folder name change
         track_folder = next(demucs_out.iterdir(), None)
         if not track_folder: raise FileNotFoundError("Demucs failed to output files.")
         
+        # Map all 6 stems (Demucs outputs specific names)
+        # Note: If a stem (like guitar) is silent, Demucs still creates the file.
         drums = track_folder / "drums.wav"
         bass = track_folder / "bass.wav"
-        melody = track_folder / "other.wav"
+        guitar = track_folder / "guitar.wav"
+        piano = track_folder / "piano.wav"
         vocals = track_folder / "vocals.wav"
+        other = track_folder / "other.wav"
         
         # Return paths to the UI and the BPM
-        return str(drums), str(bass), str(melody), str(vocals), bpm, str(track_folder)
+        return str(drums), str(bass), str(guitar), str(piano), str(other), str(vocals), bpm, str(track_folder)
 
     except Exception as e:
         raise gr.Error(f"Separation Failed: {str(e)}")
 
 def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
-    """Phase 2: Chop Loops, Generate Video (Zoom Effect), Zip"""
+    """Phase 2: Chop Loops, Generate Video, Zip"""
     try:
         track_folder = Path(track_folder_str)
-        drums = track_folder / "drums.wav"
-        bass = track_folder / "bass.wav"
-        melody = track_folder / "other.wav"
-        vocals = track_folder / "vocals.wav"
-
-        # 1. Save Full Stems
-        for stem, name in [(drums, "Drums"), (bass, "Bass"), (melody, "Melody"), (vocals, "Vocals")]:
-            if stem.exists():
-                shutil.copy(stem, OUTPUT_DIR / "Stems" / f"{bpm}BPM_Full_{name}.wav")
+        # Re-map paths
+        stems = {
+            "Drums": track_folder / "drums.wav",
+            "Bass": track_folder / "bass.wav",
+            "Guitar": track_folder / "guitar.wav",
+            "Piano": track_folder / "piano.wav",
+            "Synths": track_folder / "other.wav",
+            "Vocals": track_folder / "vocals.wav"
+        }
+
+        # 1. Save Full Stems (Copy to Stems folder)
+        for name, path in stems.items():
+            if path.exists():
+                shutil.copy(path, OUTPUT_DIR / "Stems" / f"{bpm}BPM_Full_{name}.wav")
 
         # 2. Create Loops (With User Offset)
         ms_per_beat = (60 / bpm) * 1000
         eight_bars_ms = ms_per_beat * 4 * 8
         start_ms = start_offset_sec * 1000
         
-        created_loops = {} # Store paths for video generation
+        created_loops = {} 
 
         def make_loop(src, name):
             if not src.exists(): return None
             audio = AudioSegment.from_wav(str(src))
             
-            # Use User Offset
             end_ms = start_ms + eight_bars_ms
-            if len(audio) < end_ms: # Fallback if offset is too late
+            if len(audio) < end_ms:
                 s = 0
                 e = min(len(audio), eight_bars_ms)
             else:
@@ -98,11 +107,15 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
             loop.export(out_path, format="wav")
             return out_path
 
-        created_loops['drums'] = make_loop(drums, "DrumLoop")
-        created_loops['bass'] = make_loop(bass, "BassLoop")
-        created_loops['melody'] = make_loop(melody, "MelodyLoop")
+        # Generate loops for all 6 stems
+        created_loops['melody'] = make_loop(stems['Synths'], "SynthLoop") # Primary logic for video
+        make_loop(stems['Drums'], "DrumLoop")
+        make_loop(stems['Bass'], "BassLoop")
+        make_loop(stems['Guitar'], "GuitarLoop")
+        make_loop(stems['Piano'], "PianoLoop")
+        make_loop(stems['Vocals'], "VocalChop")
         
-        # 3. Generate Video (Slow Zoom Effect)
+        # 3. Generate Video (Using the Synth/Other loop as the audio base)
         video_path = None
         if cover_art and created_loops['melody']:
             print("Rendering Dynamic Video...")
@@ -110,31 +123,16 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
             audio_clip = AudioFileClip(str(created_loops['melody']))
             duration = audio_clip.duration
             
-            # Load Image
+            # Load and Resize Image
             img = ImageClip(cover_art).resize(width=1080)
             
-            # THE ZOOM EFFECT: Resize image from 1.0x to 1.1x over time
-            # We crop the center to handle the zoom so it doesn't change output size
-            w, h = img.size
-            
-            def zoom_effect(t):
-                # Zoom factor goes from 1.0 to 1.15
-                scale = 1 + 0.15 * (t / duration)
-                return scale
-                
-            # Apply zoom (this is a bit heavy, simple resize is safer for CPU)
-            # Alternative: Simple Pan or just Static if Pillow is tricky.
-            # Let's do a simple resize animation
-            img = img.resize(lambda t : 1 + 0.04*t) # Slow 4% zoom
+            # Simple Zoom Animation (Resize from 1.0 to 1.05)
+            # We use a lambda function for the resize filter
+            img = img.resize(lambda t : 1 + 0.02*t) 
             img = img.set_position(('center', 'center'))
             img = img.set_duration(duration)
             img = img.set_audio(audio_clip)
             
-            # Composite to ensure frame size stays constant (1080 width)
-            # Note: resizing makes it grow, we need to crop or center. 
-            # For simplicity in v1, we let it grow slightly or stick to static if 'resize' fails.
-            # We will use the simple robust method:
-            
             final_clip = CompositeVideoClip([img], size=(1080, 1920))
             final_clip.duration = duration
             final_clip.audio = audio_clip
@@ -160,9 +158,9 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
 
 # --- GUI (Blocks) ---
 
-with gr.Blocks(title="Night Pulse | Command Center", theme=gr.themes.Base()) as app:
-    gr.Markdown("# 🎛️ Night Pulse Audio | Command Center")
-    gr.Markdown("Transform Suno tracks into commercial sample packs.")
+with gr.Blocks(title="Night Pulse | Command Center (6-Stem)", theme=gr.themes.Base()) as app:
+    gr.Markdown("# 🎛️ Night Pulse | 6-Stem Command Center")
+    gr.Markdown("Deconstruct audio into 6 stems: Drums, Bass, Guitar, Piano, Vocals, Synths.")
     
     # State storage
     stored_folder = gr.State()
@@ -172,34 +170,38 @@ with gr.Blocks(title="Night Pulse | Command Center", theme=gr.themes.Base()) as
         with gr.Column(scale=1):
             input_audio = gr.Audio(type="filepath", label="1. Upload Master Track")
             input_art = gr.Image(type="filepath", label="Cover Art (9:16)")
-            btn_analyze = gr.Button("🔍 Phase 1: Deconstruct & Analyze", variant="primary")
+            btn_analyze = gr.Button("🔍 Phase 1: Separate (6 Stems)", variant="primary")
             
         with gr.Column(scale=1):
             gr.Markdown("### 2. Stem Preview")
-            # Audio Players
-            p_drums = gr.Audio(label="Drums Stem")
-            p_bass = gr.Audio(label="Bass Stem")
-            p_melody = gr.Audio(label="Melody Stem")
-            p_vocals = gr.Audio(label="Vocals Stem")
+            with gr.Row():
+                p_drums = gr.Audio(label="Drums")
+                p_bass = gr.Audio(label="Bass")
+            with gr.Row():
+                p_guitar = gr.Audio(label="Guitar")
+                p_piano = gr.Audio(label="Piano")
+            with gr.Row():
+                p_other = gr.Audio(label="Synths/Other")
+                p_vocals = gr.Audio(label="Vocals")
     
     gr.Markdown("---")
     
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 3. Loop Settings")
-            slider_start = gr.Slider(minimum=0, maximum=120, value=15, label="Loop Start Time (Seconds)", info="Where should the 8-bar loop start?")
+            gr.Markdown("### 3. Loop Logic")
+            slider_start = gr.Slider(minimum=0, maximum=120, value=15, label="Loop Start Time (Seconds)", info="Select the start point for the 8-bar loop cut.")
             btn_package = gr.Button("📦 Phase 2: Package & Export", variant="primary")
         
         with gr.Column():
             gr.Markdown("### 4. Final Output")
             out_zip = gr.File(label="Download Pack (ZIP)")
-            out_video = gr.Video(label="Promo Video (Dynamic)")
+            out_video = gr.Video(label="Promo Video")
 
     # Events
     btn_analyze.click(
         fn=analyze_and_separate,
         inputs=[input_audio],
-        outputs=[p_drums, p_bass, p_melody, p_vocals, stored_bpm, stored_folder]
+        outputs=[p_drums, p_bass, p_guitar, p_piano, p_other, p_vocals, stored_bpm, stored_folder]
     )
     
     btn_package.click(