Update app.py

app.py

@@ -112,8 +112,21 @@ def analyze_and_separate(file_input, url_input):
     except Exception as e:
         raise gr.Error(f"Process Failed: {str(e)}")
 
-def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
-    """Phase 2: Package & Export"""
+def package_and_export(
+    track_folder_str,
+    bpm,
+    start_offset_sec,   # kept for compatibility, but not used for loop starts anymore
+    cover_art,
+    # --- new loop engine params (you can wire these into UI later) ---
+    loops_per_stem=12,
+    bar_lengths=(1, 2, 4, 8),
+    hop_bars=1,
+    top_k=30,
+    fade_ms=12,
+    loudness_mode="none",     # "none" | "peak" | "rms"
+    target_dbfs=-14.0
+):
+    """Phase 2: Package & Export (real loop engine)"""
     try:
         track_folder = Path(track_folder_str)
         stems = {
@@ -125,64 +138,78 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
             "Vocals": track_folder / "vocals.wav"
         }
 
-        # 1. Save Full Stems
+        # Cleanup Output
+        if OUTPUT_DIR.exists():
+            shutil.rmtree(OUTPUT_DIR)
+        (OUTPUT_DIR / "Stems").mkdir(parents=True, exist_ok=True)
+        (OUTPUT_DIR / "Loops").mkdir(parents=True, exist_ok=True)
+
+        # 1) Save Full Stems
         for name, path in stems.items():
             if path.exists():
                 shutil.copy(path, OUTPUT_DIR / "Stems" / f"{bpm}BPM_Full_{name}.wav")
 
-        # 2. Create Loops
-        ms_per_beat = (60 / bpm) * 1000
-        eight_bars_ms = ms_per_beat * 4 * 8
-        start_ms = start_offset_sec * 1000
-        
-        created_loops = {} 
+        # 2) Build bar grid from the *master beat grid source*
+        # Use drums if present (best for beat tracking), otherwise "other", otherwise any existing stem.
+        grid_source = stems["Drums"] if stems["Drums"].exists() else (
+            stems["Synths"] if stems["Synths"].exists() else next((p for p in stems.values() if p.exists()), None)
+        )
+        if grid_source is None:
+            raise FileNotFoundError("No stems found to build beat/bar grid.")
 
-        def make_loop(src, name):
-            if not src.exists(): return None
-            audio = AudioSegment.from_wav(str(src))
-            end_ms = start_ms + eight_bars_ms
-            if len(audio) < end_ms:
-                s = 0
-                e = min(len(audio), eight_bars_ms)
-            else:
-                s, e = start_ms, end_ms
-            loop = audio[s:int(e)].fade_in(15).fade_out(15).normalize()
-            out_path = OUTPUT_DIR / "Loops" / f"{bpm}BPM_{name}.wav"
-            loop.export(out_path, format="wav")
-            return out_path
+        bar_starts_ms = detect_bar_grid(str(grid_source), bpm=bpm, max_seconds=240)
 
-        created_loops['melody'] = make_loop(stems['Synths'], "SynthLoop")
-        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
+        # 3) Create quantized multi-loops per stem
+        all_exported_loops = {}
+        loops_dir = OUTPUT_DIR / "Loops"
+
+        for stem_name, stem_path in stems.items():
+            exported = make_quantized_loops(
+                stem_path=stem_path,
+                stem_name=stem_name,
+                bpm=int(bpm),
+                bar_starts_ms=bar_starts_ms,
+                bar_lengths=list(bar_lengths),
+                hop_bars=int(hop_bars),
+                max_loops_per_stem=int(loops_per_stem),
+                top_k=int(top_k),
+                fade_ms=int(fade_ms),
+                loudness_mode=str(loudness_mode),
+                target_dbfs=float(target_dbfs),
+                out_dir=loops_dir
+            )
+            all_exported_loops[stem_name] = exported
+
+        # Pick a melody-ish loop for video (prefer Synths, fallback Piano/Guitar)
+        video_loop = None
+        for key in ("Synths", "Piano", "Guitar"):
+            if all_exported_loops.get(key):
+                video_loop = all_exported_loops[key][0]
+                break
+
+        # 4) Generate Video (optional)
         video_path = None
-        if cover_art and created_loops['melody']:
+        if cover_art and video_loop:
             print("Rendering Video...")
             vid_out = OUTPUT_DIR / "Promo_Video.mp4"
-            audio_clip = AudioFileClip(str(created_loops['melody']))
+            audio_clip = AudioFileClip(str(video_loop))
             duration = audio_clip.duration
-            
+
             img = ImageClip(cover_art).resize(width=1080)
-            
-            # Zoom Animation (Full Color)
-            img = img.resize(lambda t : 1 + 0.02*t) 
+            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)
-            
+
             final_clip = CompositeVideoClip([img], size=(1080, 1920))
             final_clip.duration = duration
             final_clip.audio = audio_clip
             final_clip.fps = 24
-            
+
             final_clip.write_videofile(str(vid_out), codec="libx264", audio_codec="aac", logger=None)
             video_path = str(vid_out)
 
-        # 4. Zip
+        # 5) Zip
         zip_file = "NightPulse_Pack.zip"
         with zipfile.ZipFile(zip_file, 'w') as zf:
             for root, dirs, files in os.walk(OUTPUT_DIR):
@@ -190,13 +217,14 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
                     file_path = Path(root) / file
                     arcname = file_path.relative_to(OUTPUT_DIR)
                     zf.write(file_path, arcname)
-                    
+
         return zip_file, video_path
 
     except Exception as e:
         raise gr.Error(f"Packaging Failed: {str(e)}")
 
 
+
 # --- GUI (Blocks) ---
 with gr.Blocks(title="Night Pulse | Studio Pro") as app:
     gr.Markdown("# 🎛️ Night Pulse | Studio Command Center")