Update app.py

app.py

@@ -16,7 +16,7 @@ import json
 from datetime import datetime
 import pyloudnorm as pyln
 
-# --- OPTIONAL: MIDI IMPORT (Graceful Fail) ---
+# --- OPTIONAL: MIDI IMPORT ---
 try:
     from basic_pitch.inference import predict_and_save
     MIDI_AVAILABLE = True
@@ -24,17 +24,15 @@ except ImportError:
     MIDI_AVAILABLE = False
     print("WARNING: 'basic-pitch' not installed. MIDI extraction will be disabled.")
 
-# --- PATCH FOR PILLOW 10.0+ vs MOVIEPY 1.0.3 COMPATIBILITY ---
+# --- PATCH FOR PILLOW 10.0+ ---
 import PIL.Image
 if not hasattr(PIL.Image, 'ANTIALIAS'):
     PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
-# -------------------------------------------------------------
 
-# --- Configuration ---
+# --- CONFIG ---
 OUTPUT_DIR = Path("nightpulse_output")
 TEMP_DIR = Path("temp_processing")
 
-
 # -----------------------------
 # Startup Checks
 # -----------------------------
@@ -46,55 +44,41 @@ def check_ffmpeg():
 
 check_ffmpeg()
 
-
 # -----------------------------
-# Key Detection Engine
+# Key Detection
 # -----------------------------
 def detect_key(audio_path):
-    """
-    Estimates key (e.g., 'Cmaj', 'F#min') using Chroma features.
-    """
     try:
         y, sr = librosa.load(str(audio_path), sr=None, duration=60)
         chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
         chroma_vals = np.sum(chroma, axis=1)
-        
-        # Krumhansl-Schmuckler Profiles
         maj_profile = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88]
         min_profile = [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]
         pitches = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
-        
         best_score = -1
         best_key = "Unknown"
-        
         for i in range(12):
             p_maj = np.roll(maj_profile, i)
             p_min = np.roll(min_profile, i)
-            
             score_maj = np.corrcoef(chroma_vals, p_maj)[0, 1]
             score_min = np.corrcoef(chroma_vals, p_min)[0, 1]
-            
             if score_maj > best_score:
                 best_score = score_maj
                 best_key = f"{pitches[i]}maj"
             if score_min > best_score:
                 best_score = score_min
                 best_key = f"{pitches[i]}min"
-                
         return best_key
     except Exception:
         return "Unknown"
 
-
 # -----------------------------
-# Cloud Import
+# Helpers
 # -----------------------------
 def download_from_url(url):
     if not url: return None
-    print(f"Fetching URL: {url}")
     if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR, ignore_errors=True)
     TEMP_DIR.mkdir(parents=True, exist_ok=True)
-
     ydl_opts = {
         "format": "bestaudio/best",
         "outtmpl": str(TEMP_DIR / "%(title)s.%(ext)s"),
@@ -106,10 +90,6 @@ def download_from_url(url):
         filename = ydl.prepare_filename(info)
         return str(Path(filename).with_suffix(".wav"))
 
-
-# -----------------------------
-# File Helpers
-# -----------------------------
 def safe_copy_to_temp(audio_file: str) -> str:
     src = Path(audio_file)
     TEMP_DIR.mkdir(parents=True, exist_ok=True)
@@ -127,106 +107,61 @@ def ensure_wav(input_path: str) -> str:
     AudioSegment.from_file(str(p)).export(str(out), format="wav")
     return str(out)
 
-
 # -----------------------------
 # Demucs + MIDI
 # -----------------------------
 def run_demucs(cmd):
     p = subprocess.run(cmd, capture_output=True, text=True)
-    if p.returncode != 0:
-        raise gr.Error(f"Demucs Error:\n{p.stderr[-2000:]}")
+    if p.returncode != 0: raise gr.Error(f"Demucs Error:\n{p.stderr[-2000:]}")
     return p.stdout
 
 def extract_midi(audio_path, out_path):
-    """Uses basic-pitch to convert audio to MIDI."""
     if not MIDI_AVAILABLE: return
-    # basic-pitch expects output directory, not filename
     out_dir = out_path.parent
     name = out_path.stem
-    predict_and_save(
-        [str(audio_path)],
-        str(out_dir),
-        True, False, False, # save_midi, save_model_outputs, save_notes
-        sonify_midi=False,
-        save_midi_path=str(out_path) # Some versions allow direct path
-    )
-    # Cleanup: basic-pitch might name it slightly differently, ensure standard name
+    predict_and_save([str(audio_path)], str(out_dir), True, False, False, sonify_midi=False, save_midi_path=str(out_path))
     expected = out_dir / f"{name}_basic_pitch.mid"
-    if expected.exists():
-        shutil.move(expected, out_path)
-
+    if expected.exists(): shutil.move(expected, out_path)
 
 # -----------------------------
-# Audio Processing (LUFS + One Shots)
+# Audio Processing
 # -----------------------------
-def rms_dbfs(seg): return seg.dBFS
-
 def apply_loudness(seg: AudioSegment, mode: str, target: float = -14.0) -> AudioSegment:
     mode = (mode or "none").lower().strip()
     if mode == "none": return seg
     if mode == "peak": return seg.normalize()
-    
     if mode == "rms":
         change = target - seg.dBFS
         return seg.apply_gain(change)
-
     if mode == "lufs":
-        # Export to buffer for pyloudnorm
         samples = np.array(seg.get_array_of_samples())
-        if seg.channels == 2:
-            samples = samples.reshape((-1, 2))
-        
-        # Convert to float [-1, 1]
+        if seg.channels == 2: samples = samples.reshape((-1, 2))
         samples_float = samples.astype(np.float64) / 32768.0
-        
         meter = pyln.Meter(seg.frame_rate) 
         loudness = meter.integrated_loudness(samples_float)
-        
-        if loudness == -float('inf'): return seg # Silence check
-        
-        # Calculate gain needed
-        gain_db = target - loudness
-        # Apply safely
-        gain_db = max(min(gain_db, 20.0), -20.0) # Safety clamp
+        if loudness == -float('inf'): return seg
+        gain_db = max(min(target - loudness, 20.0), -20.0)
         return seg.apply_gain(gain_db)
-        
     return seg
 
 def extract_one_shots(drum_stem_path, bpm, out_dir, loudness_mode, target_dbfs):
-    """Extracts Kick/Snare hits from the drum stem."""
     y, sr = librosa.load(str(drum_stem_path), sr=None)
     onset_frames = librosa.onset.onset_detect(y=y, sr=sr, backtrack=True)
     onset_times = librosa.frames_to_time(onset_frames, sr=sr)
-    
     audio = AudioSegment.from_wav(str(drum_stem_path))
     hits = []
-    
-    # Slice hits (take 250ms or until next hit)
     for i in range(len(onset_times)):
         start_ms = int(onset_times[i] * 1000)
-        if i < len(onset_times) - 1:
-            end_ms = int(onset_times[i+1] * 1000)
-            dur = min(end_ms - start_ms, 450) # Cap at 450ms for one shots
-        else:
-            dur = 450
-            
+        dur = min(int(onset_times[i+1] * 1000) - start_ms, 450) if i < len(onset_times) - 1 else 450
         hit = audio[start_ms : start_ms + dur]
-        
-        # Filter tiny noises
         if hit.rms > 100 and len(hit) > 30:
-            hit = hit.fade_out(10) # Quick fade to prevent clicking
-            hits.append(hit)
-            
-    # Save top 32 unique-ish hits
-    # Sort by loudness to get main hits first
+            hits.append(hit.fade_out(10))
     hits.sort(key=lambda x: x.rms, reverse=True)
     hits = hits[:32]
-    
     for i, hit in enumerate(hits):
         hit = apply_loudness(hit, mode=loudness_mode, target=target_dbfs)
         hit.export(out_dir / f"DrumShot_{i+1:02d}.wav", format="wav")
 
-
 # -----------------------------
 # Loop Engine
 # -----------------------------
@@ -236,18 +171,14 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
     if not stem_path.exists(): return []
     audio = AudioSegment.from_wav(str(stem_path))
     ms_per_bar = (240000.0 / bpm) 
-
-    # Seam Logic
     trim_win = 8
     extra_ms = (seam_ms if loop_seam else 0) + (trim_win * 2)
-
     grid = bar_starts_ms[::max(1, int(hop_bars))] if bar_starts_ms else []
     candidates = []
 
     for bar_len in bar_lengths:
         t_dur = int(ms_per_bar * bar_len)
         x_dur = t_dur + extra_ms
-        
         for start_ms in grid:
             if start_ms + x_dur > len(audio): continue
             seg = audio[start_ms : start_ms + x_dur]
@@ -256,8 +187,6 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
 
     candidates.sort(key=lambda x: x[0], reverse=True)
     if top_k > 0: candidates = candidates[:int(top_k)]
-    
-    # De-dup
     selected = []
     used_bars = []
     for score, start, blen in candidates:
@@ -271,12 +200,8 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
     for i, (_, start, blen) in enumerate(selected, 1):
         t_dur = int(ms_per_bar * blen)
         x_dur = t_dur + extra_ms
-        
         loop = audio[start : start + x_dur]
-        
-        # Process
         loop = loop[trim_win : -trim_win] if len(loop) > trim_win*2 else loop
-        
         if loop_seam and len(loop) > seam_ms*2:
             head = loop[:seam_ms]
             tail = loop[-seam_ms:]
@@ -285,81 +210,63 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
         else:
             loop = loop[:t_dur]
             if fade_ms > 0: loop = loop.fade_in(fade_ms).fade_out(fade_ms)
-            
-        loop = loop[:t_dur] # Hard quantize
+        loop = loop[:t_dur] 
         loop = apply_loudness(loop, mode=loudness_mode, target=target_dbfs)
-        
         fname = f"{bpm}BPM_{key}_{stem_name}_L{blen}bars_{i:02d}.wav"
         out_path = out_dir / fname
         loop.export(out_path, format="wav")
         exported.append(out_path)
-        
     return exported
 
-
 # -----------------------------
 # Phase 1: Analyze
 # -----------------------------
 def analyze_and_separate(file_in, url_in, mode, manual_bpm):
     if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR, ignore_errors=True)
     TEMP_DIR.mkdir(parents=True, exist_ok=True)
-    
     fpath = download_from_url(url_in) if url_in else file_in
     if not fpath: raise gr.Error("No Audio Source")
-    
     fpath = safe_copy_to_temp(fpath)
     fpath = ensure_wav(fpath)
     
-    # Key & BPM
     bpm = manual_bpm if manual_bpm else int(librosa.beat.beat_track(y=librosa.load(fpath, duration=60)[0])[0])
     key = detect_key(fpath)
-    print(f"Detected: {bpm} BPM, Key: {key}")
     
-    # Separate
     cmd = [sys.executable, "-m", "demucs", "-n", "htdemucs_6s" if mode=="6stem" else "htdemucs", "--out", str(TEMP_DIR), fpath]
     if mode == "2stem": cmd += ["--two-stems", "vocals"]
-    
     run_demucs(cmd)
     
-    # Map
     track_dir = next((TEMP_DIR / ("htdemucs_6s" if mode=="6stem" else "htdemucs")).iterdir())
-    
-    # Smart Defaults
-    all_stems = [f.stem for f in track_dir.glob("*.wav")]
     stem_map = {
         "Drums": track_dir/"drums.wav", "Bass": track_dir/"bass.wav",
         "Vocals": track_dir/"vocals.wav", "Other": track_dir/"other.wav",
         "Piano": track_dir/"piano.wav", "Guitar": track_dir/"guitar.wav",
         "Instrumental": track_dir/"no_vocals.wav"
     }
+    valid = [k for k,v in stem_map.items() if v.exists()]
+    loops_def = [s for s in valid if s != "Vocals"]
     
-    # Filter non-existent
-    valid_stems = [k for k,v in stem_map.items() if v.exists()]
+    # UI Updates for Checkboxes
+    cb_export = gr.CheckboxGroup(choices=valid, value=valid)
+    cb_loops = gr.CheckboxGroup(choices=valid, value=loops_def)
     
-    # UI Updates
-    loops_def = [s for s in valid_stems if s != "Vocals"]
+    # Previews
+    p_d = str(stem_map["Drums"]) if "Drums" in valid else None
+    p_b = str(stem_map["Bass"]) if "Bass" in valid else None
+    p_v = str(stem_map["Vocals"]) if "Vocals" in valid else None
     
-    return (
-        str(stem_map["Drums"]) if "Drums" in valid_stems else None,
-        str(stem_map["Bass"]) if "Bass" in valid_stems else None,
-        str(stem_map["Vocals"]) if "Vocals" in valid_stems else None,
-        bpm, key, str(track_dir), mode,
-        gr.CheckboxGroup(choices=valid_stems, value=valid_stems), # Exports
-        gr.CheckboxGroup(choices=valid_stems, value=loops_def)    # Loops
-    )
-
+    return (p_d, p_b, p_v, f"**Detected:** {bpm} BPM | **Key:** {key}", bpm, key, str(track_dir), mode, cb_export, cb_loops)
 
 # -----------------------------
-# Phase 2: Package
+# Phase 2: Package (With Smart Video Resize)
 # -----------------------------
 def package_and_export(track_folder, bpm, key, stem_mode, art, 
                        ex_stems, loop_stems, do_midi, do_oneshots, do_vocal_chops,
                        loops_per, bars, hop, topk, fadems, loopseam, seamms, mingap,
-                       loud_mode, loud_target, v_mode, v_grid, v_max, v_min, v_max_len, v_sil, v_sil_len):
+                       loud_mode, loud_target, vid_fmt):
     
     if not track_folder: raise gr.Error("Run Phase 1 First.")
     
-    # Setup Dirs
     if OUTPUT_DIR.exists(): shutil.rmtree(OUTPUT_DIR, ignore_errors=True)
     for d in ["Stems", "Loops", "MIDI", "OneShots", "Vocal_Chops"]:
         (OUTPUT_DIR / d).mkdir(parents=True, exist_ok=True)
@@ -372,87 +279,92 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
         "Instrumental": t_dir/"no_vocals.wav"
     }
     
-    # 1. Full Stems
+    # Exports (Stems, MIDI, Shots, Loops)
     for s in ex_stems:
         if stems.get(s, Path("x")).exists():
             shutil.copy(stems[s], OUTPUT_DIR/"Stems"/f"{bpm}BPM_{key}_{s}.wav")
-            
-    # 2. MIDI (Melodic only)
     if do_midi and MIDI_AVAILABLE:
         for s in ["Bass", "Piano", "Guitar", "Other"]:
-            if s in stems and stems[s].exists():
-                extract_midi(stems[s], OUTPUT_DIR/"MIDI"/f"{bpm}BPM_{key}_{s}.mid")
-
-    # 3. One Shots (Drums)
+            if stems.get(s, Path("x")).exists(): extract_midi(stems[s], OUTPUT_DIR/"MIDI"/f"{bpm}BPM_{key}_{s}.mid")
     if do_oneshots and stems["Drums"].exists():
         extract_one_shots(stems["Drums"], bpm, OUTPUT_DIR/"OneShots", loud_mode, loud_target)
-        
-    # 4. Loops
-    grid_src = stems["Drums"] if stems["Drums"].exists() else next((stems[k] for k in stems if stems[k].exists()), None)
     
-    # Get Grid
+    grid_src = stems["Drums"] if stems["Drums"].exists() else next((stems[k] for k in stems if stems[k].exists()), None)
     y, sr = librosa.load(str(grid_src), sr=22050, duration=240)
     _, beats = librosa.beat.beat_track(y=y, sr=sr)
     beat_times = librosa.frames_to_time(beats, sr=sr)
-    if len(beat_times) < 8:
-         # Fallback to calculated grid
-         bar_starts = [int(i * (240000/bpm)) for i in range(int((len(y)/sr)/(240/bpm)))]
-    else:
-        bar_starts = [int(t*1000) for t in beat_times[::4]]
-        
+    bar_starts = [int(t*1000) for t in beat_times[::4]] if len(beat_times) >= 8 else [int(i * (240000/bpm)) for i in range(int((len(y)/sr)/(240/bpm)))]
     bar_ints = sorted([int(b) for b in bars])
     
     all_loops = {}
     for s in loop_stems:
-        if s == "Vocals" and do_vocal_chops: continue # Handled separately
+        if s == "Vocals" and do_vocal_chops: continue
         if stems.get(s, Path("x")).exists():
             exported = make_quantized_loops(stems[s], s, bpm, key, bar_starts, bar_ints, hop, loops_per, topk, 
                                             fadems, loopseam, seamms, mingap, loud_mode, loud_target, OUTPUT_DIR/"Loops")
             all_loops[s] = exported
 
-    # 5. Vocal Chops (Simplified logic for brevity, uses same engine as before effectively)
     if do_vocal_chops and stems["Vocals"].exists():
-        # Re-using quantization engine if "Loop" mode, or custom chop if needed.
-        # For "Ultimate" script, we treat chops as loops but strictly processed.
         exported = make_quantized_loops(stems["Vocals"], "Vocals_Chop", bpm, key, bar_starts, [1, 2], 1, 30, 0, 
                                         fadems, False, 0, 0, loud_mode, loud_target, OUTPUT_DIR/"Vocal_Chops")
         all_loops["Vocals"] = exported
 
-    # 6. Video (Progress Bar)
+    # --- SMART VIDEO ENGINE ---
     vid_path = None
     if art and any(all_loops.values()):
-        # Find audio
         for k in ["Other", "Synths", "Piano", "Guitar", "Instrumental", "Bass", "Drums"]:
             if all_loops.get(k): 
                 a_path = all_loops[k][0]
                 break
         
-        print("Rendering Social Video...")
+        print(f"Rendering Video ({vid_fmt})...")
+        # Define Resolution
+        res_map = {
+            "9:16 (TikTok/Reels)": (1080, 1920),
+            "16:9 (YouTube)": (1920, 1080),
+            "1:1 (Square)": (1080, 1080)
+        }
+        w, h = res_map.get(vid_fmt, (1080, 1920))
+        
         clip = AudioFileClip(str(a_path))
-        w, h = 1080, 1920
         
-        # Background
-        bg = ImageClip(art).resize(width=w)
-        # Slight zoom effect
-        bg = bg.resize(lambda t: 1 + 0.02*t).set_position("center").set_duration(clip.duration)
+        # Load & Smart Crop
+        bg_clip = ImageClip(art)
+        img_w, img_h = bg_clip.size
+        
+        # Calculate aspect ratios
+        target_aspect = w / h
+        img_aspect = img_w / img_h
+        
+        if img_aspect > target_aspect:
+            # Image is wider than target: resize by height, crop width
+            new_h = h
+            new_w = int(img_w * (h / img_h))
+            bg_clip = bg_clip.resize(height=h)
+            # Center crop
+            crop_x = (new_w - w) // 2
+            bg_clip = bg_clip.crop(x1=crop_x, width=w)
+        else:
+            # Image is taller/narrower: resize by width, crop height
+            new_w = w
+            new_h = int(img_h * (w / img_w))
+            bg_clip = bg_clip.resize(width=w)
+            crop_y = (new_h - h) // 2
+            bg_clip = bg_clip.crop(y1=crop_y, height=h)
+
+        # Add zoom effect
+        bg_clip = bg_clip.resize(lambda t: 1 + 0.02*t).set_position("center").set_duration(clip.duration)
         
         # Progress Bar
-        bar_h = 20
-        # ColorClip is usually safe, but let's use a solid color ImageClip to be safe with v1.0.3
-        bar = ColorClip(size=(w, bar_h), color=(255,255,255)).set_opacity(0.8)
-        # Animate width by masking or resizing. Resizing is easiest for MP 1.0.3
-        # We start at width 0. We can't resize 0. So we assume full width and use a mask? 
-        # Easier: moving position.
-        # Make a bar of full width, move it from x = -1080 to x = 0
-        bar = bar.set_position(lambda t: (int(-w + w*(t/clip.duration)), h - 100))
+        bar = ColorClip(size=(w, 20), color=(255,255,255)).set_opacity(0.8)
+        bar = bar.set_position(lambda t: (int(-w + w*(t/clip.duration)), h - 50))
         bar = bar.set_duration(clip.duration)
         
-        final = CompositeVideoClip([bg, bar], size=(w,h))
+        final = CompositeVideoClip([bg_clip, bar], size=(w,h))
         final.audio = clip
         vid_path = str(OUTPUT_DIR/"Promo.mp4")
         final.write_videofile(vid_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
 
-    # Zip
     z_path = "NightPulse_Ultimate.zip"
     with zipfile.ZipFile(z_path, "w") as zf:
         for r, _, fs in os.walk(OUTPUT_DIR):
@@ -460,58 +372,66 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
             
     return z_path, vid_path
 
-
 # -----------------------------
-# UI
+# UI Layout
 # -----------------------------
 with gr.Blocks(title="Night Pulse | Ultimate") as app:
     gr.Markdown("# 🎹 Night Pulse | Studio Ultimate")
     
+    # Hidden State
     folder = gr.State()
     bpm_st = gr.State()
     key_st = gr.State()
     mode_st = gr.State()
 
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 1. Source")
-            mode = gr.Dropdown([("2 Stems", "2stem"), ("4 Stems", "4stem"), ("6 Stems", "6stem")], value="6stem", label="Model")
-            mbpm = gr.Number(label="Manual BPM (Optional)")
-            
+        # --- COL 1: CONFIGURATION ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Setup & Source")
             with gr.Tabs():
-                with gr.Tab("Link"): url = gr.Textbox(label="URL")
-                with gr.Tab("File"): file = gr.Audio(type="filepath", label="Upload")
+                with gr.Tab("Link"): url = gr.Textbox(label="YouTube/SC URL")
+                with gr.Tab("File"): file = gr.Audio(type="filepath", label="Upload File")
             
-            art = gr.Image(type="filepath", label="Cover Art (9:16)")
-            btn1 = gr.Button("Phase 1: Analyze & Separate", variant="primary")
+            mode = gr.Dropdown([("2 Stems (Vox+Inst)", "2stem"), ("4 Stems (Basic)", "4stem"), ("6 Stems (Full)", "6stem")], value="6stem", label="Separation Model")
+            mbpm = gr.Number(label="Manual BPM (Optional)")
             
-        with gr.Column():
-            gr.Markdown("### 2. Preview")
-            p1 = gr.Audio(label="Drums")
-            p2 = gr.Audio(label="Bass")
-            p3 = gr.Audio(label="Vocals")
+            gr.Markdown("#### Extraction Targets")
+            with gr.Row():
+                do_midi = gr.Checkbox(label="MIDI", value=True)
+                do_oneshots = gr.Checkbox(label="Drum Shots", value=True)
+                do_vox = gr.Checkbox(label="Vocal Chops", value=True)
+
+            btn1 = gr.Button("🚀 Phase 1: Analyze & Separate", variant="primary", scale=2)
+
+        # --- COL 2: REFINEMENT (Dynamic) ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 2. Select & Refine")
             info = gr.Markdown("Waiting for analysis...")
+            
+            # Dynamic checkboxes
+            ex_stems = gr.CheckboxGroup(label="Export Full Stems")
+            lp_stems = gr.CheckboxGroup(label="Generate Loops For")
+            
+            gr.Markdown("#### Preview")
+            with gr.Row():
+                p1 = gr.Audio(label="Drums", show_label=True)
+                p2 = gr.Audio(label="Bass", show_label=True)
+                p3 = gr.Audio(label="Vocals", show_label=True)
 
     gr.Markdown("---")
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 3. Selection")
-            ex_stems = gr.CheckboxGroup(label="Export Full Stems")
-            lp_stems = gr.CheckboxGroup(label="Generate Loops For")
-            
-            gr.Markdown("### 4. Extra Processing")
-            do_midi = gr.Checkbox(label="Extract MIDI (Melody/Bass)", value=True)
-            do_oneshots = gr.Checkbox(label="Extract Drum One-Shots", value=True)
-            do_vox = gr.Checkbox(label="Vocal Chops", value=True)
-
-        with gr.Column():
-            gr.Markdown("### 5. Engine Settings")
-            loops_per = gr.Slider(1, 40, 12, 1, label="Loops Count")
-            bars = gr.CheckboxGroup(["1","2","4","8"], ["4","8"], label="Lengths")
-            hop = gr.Slider(1, 8, 1, 1, label="Hop")
-            topk = gr.Slider(0, 100, 30, 1, label="Top K")
+        # --- COL 3: EXPORT SETTINGS ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Loop Engine & Video")
+            with gr.Row():
+                loops_per = gr.Slider(1, 40, 12, 1, label="Loops Count")
+                hop = gr.Slider(1, 8, 1, 1, label="Hop (Bars)")
+            bars = gr.CheckboxGroup(["1","2","4","8"], ["4","8"], label="Loop Lengths")
             
+            art = gr.Image(type="filepath", label="Cover Art (Auto-Resize)")
+            vid_fmt = gr.Dropdown(["9:16 (TikTok/Reels)", "16:9 (YouTube)", "1:1 (Square)"], value="9:16 (TikTok/Reels)", label="Video Format")
+
             with gr.Accordion("Advanced Audio", open=False):
                 l_mode = gr.Dropdown(["none", "peak", "rms", "lufs"], "lufs", label="Norm Mode")
                 l_target = gr.Slider(-24, -5, -14, 1, label="Target Level")
@@ -519,25 +439,26 @@ with gr.Blocks(title="Night Pulse | Ultimate") as app:
                 seam = gr.Checkbox(True, label="Loop Seam")
                 seamms = gr.Slider(0, 100, 20, label="Seam ms")
                 mingap = gr.Slider(0,16,4, label="De-Dup Gap")
+                topk = gr.Slider(0, 100, 30, 1, label="Top K")
 
-            btn2 = gr.Button("Phase 2: Package Ultimate Pack", variant="primary")
+            btn2 = gr.Button("📦 Phase 2: Package Ultimate Pack", variant="primary")
 
-    with gr.Row():
-        z_out = gr.File(label="Zip Pack")
-        v_out = gr.Video(label="Social Video")
+        # --- COL 4: OUTPUT ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 4. Final Downloads")
+            z_out = gr.File(label="Complete Pack (Zip)")
+            v_out = gr.Video(label="Social Media Promo")
 
     # Wire up
     def p1_wrap(f, u, m, b):
         d, ba, v, bpm, key, pth, md, c1, c2 = analyze_and_separate(f, u, m, b)
-        return d, ba, v, f"**Detected:** {bpm} BPM | **Key:** {key}", bpm, key, pth, md, c1, c2
+        return d, ba, v, f"### 🎵 Detected: {bpm} BPM | Key: {key}", bpm, key, pth, md, c1, c2
         
     btn1.click(p1_wrap, [file, url, mode, mbpm], [p1, p2, p3, info, bpm_st, key_st, folder, mode_st, ex_stems, lp_stems])
     
     btn2.click(package_and_export, 
                [folder, bpm_st, key_st, mode_st, art, ex_stems, lp_stems, do_midi, do_oneshots, do_vox,
-                loops_per, bars, hop, topk, fadems, seam, seamms, mingap, l_mode, l_target, 
-                # Vocal settings (dummy values for now to keep UI clean, can be expanded)
-                gr.State("grid"), gr.State("1beat"), gr.State(64), gr.State(100), gr.State(1000), gr.State(-30), gr.State(100)], 
+                loops_per, bars, hop, topk, fadems, seam, seamms, mingap, l_mode, l_target, vid_fmt], 
                [z_out, v_out])
 
 if __name__ == "__main__":