Update app.py

app.py

@@ -1,181 +1,153 @@
 #!/usr/bin/env python3
 """
-FFmpeg Split-Screen Service - HuggingFace Space
-Accepts video URLs, processes split-screen, returns download link
+HuggingFace FFmpeg Space
+Clips and merges main video + gameplay into 9:16 split-screen
+65% main / 35% gameplay, no gap, audio sync fixed
 """
 
 from flask import Flask, request, jsonify, send_file
-import subprocess, os, uuid, threading, glob, shutil, requests, time
+import subprocess, os, uuid, threading, json
+import urllib.request as ur
 
 app = Flask(__name__)
-
-WORK_DIR    = "/tmp/clipbot"
-OUTPUT_DIR  = "/tmp/clipbot/output"
-GAMEPLAY_DIR = "/tmp/clipbot/gameplay"
-
+JOBS = {}
+OUTPUT_DIR = "/tmp/outputs"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
-os.makedirs(GAMEPLAY_DIR, exist_ok=True)
 
-JOBS = {}
 
-GAMEPLAY_URLS = [
-    # Add your gameplay clip direct URLs here (e.g. from HuggingFace dataset or GitHub releases)
-    # "https://your-hf-space.hf.space/gameplay/1.mp4",
-]
-
-def download_file(url, dest):
-    """Download a file from URL to dest path."""
-    r = requests.get(url, stream=True, timeout=120)
-    r.raise_for_status()
-    with open(dest, 'wb') as f:
-        for chunk in r.iter_content(chunk_size=8192):
-            f.write(chunk)
-    return dest
-
-
-def run_ffmpeg(main_path, gameplay_path, output_path, dur=58):
-    """Run split-screen FFmpeg command."""
-    filter_complex = (
-        "[0:v]scale=1080:960:force_original_aspect_ratio=increase,"
-        "crop=1080:960,setsar=1[top];"
-        "[1:v]scale=1080:960:force_original_aspect_ratio=increase,"
-        "crop=1080:960,setsar=1[bot];"
-        "[top][bot]vstack=inputs=2[stacked];"
-        "[stacked]drawbox=x=0:y=956:w=1080:h=8:color=white@0.9:t=fill[out]"
-    )
+def run_ffmpeg(job_id, video_id, main_url, gameplay_url, duration=58):
+    try:
+        work_dir = f"/tmp/job_{job_id}"
+        os.makedirs(work_dir, exist_ok=True)
+
+        main_path     = f"{work_dir}/main.mp4"
+        gameplay_path = f"{work_dir}/gameplay.mp4"
+        output_path   = f"{OUTPUT_DIR}/{video_id}_final.mp4"
+
+        # Download main video
+        print(f"[HF] Downloading main: {main_url[:80]}")
+        req = ur.Request(main_url, headers={"User-Agent": "Mozilla/5.0"})
+        with ur.urlopen(req, timeout=120) as r:
+            with open(main_path, "wb") as f: f.write(r.read())
+
+        # Download gameplay
+        print(f"[HF] Downloading gameplay: {gameplay_url[:80]}")
+        req2 = ur.Request(gameplay_url, headers={"User-Agent": "Mozilla/5.0"})
+        with ur.urlopen(req2, timeout=120) as r:
+            with open(gameplay_path, "wb") as f: f.write(r.read())
+
+        # Canvas: 1080x1920 (9:16)
+        # Main:     65% = 1248px height
+        # Gameplay: 35% = 672px height
+        # No gap, no divider
+        canvas_w = 1080
+        canvas_h = 1920
+        main_h   = 1248  # 65%
+        game_h   = 672   # 35%
+
+        cmd = [
+            "ffmpeg", "-y",
+            "-i", main_path,
+            "-stream_loop", "-1", "-i", gameplay_path,
+            "-filter_complex",
+            (
+                # Scale main to fill top 65% (crop width to 1080)
+                f"[0:v]trim=0:{duration},setpts=PTS-STARTPTS,"
+                f"scale={canvas_w}:{main_h}:force_original_aspect_ratio=increase,"
+                f"crop={canvas_w}:{main_h}[main];"
+
+                # Scale gameplay to fill bottom 35%
+                f"[1:v]trim=0:{duration},setpts=PTS-STARTPTS,"
+                f"scale={canvas_w}:{game_h}:force_original_aspect_ratio=increase,"
+                f"crop={canvas_w}:{game_h}[game];"
+
+                # Stack vertically with NO gap
+                f"[main][game]vstack=inputs=2[outv];"
+
+                # Audio from main only
+                f"[0:a]atrim=0:{duration},asetpts=PTS-STARTPTS[outa]"
+            ),
+            "-map", "[outv]",
+            "-map", "[outa]",
+            "-c:v", "libx264",
+            "-preset", "ultrafast",
+            "-crf", "26",
+            "-c:a", "aac",
+            "-b:a", "128k",
+            "-pix_fmt", "yuv420p",
+            "-t", str(duration),
+            # Fix audio/video sync - write headers first
+            "-avoid_negative_ts", "make_zero",
+            "-async", "1",
+            "-movflags", "+faststart",
+            output_path
+        ]
+
+        print(f"[HF] Running FFmpeg...")
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+
+        if result.returncode != 0:
+            print(f"[HF] FFmpeg error: {result.stderr[-500:]}")
+            JOBS[job_id] = {"status": "error", "error": result.stderr[-300:]}
+            return
+
+        # Clean up temp files
+        import shutil
+        shutil.rmtree(work_dir, ignore_errors=True)
+
+        size = os.path.getsize(output_path)
+        print(f"[HF] Done! {size/1024/1024:.1f}MB")
+        JOBS[job_id] = {
+            "status": "done",
+            "videoId": video_id,
+            "downloadUrl": f"/download/{video_id}_final.mp4",
+            "size": size
+        }
+
+    except Exception as e:
+        import traceback
+        JOBS[job_id] = {"status": "error", "error": traceback.format_exc()}
+        print(f"[HF] Exception: {traceback.format_exc()}")
+
 
-    cmd = [
-        "ffmpeg", "-y",
-        "-ss", "0", "-t", str(dur), "-i", main_path,
-        "-stream_loop", "-1", "-t", str(dur), "-i", gameplay_path,
-        "-filter_complex", filter_complex,
-        "-map", "[out]", "-map", "0:a",
-        "-t", str(dur),
-        "-c:v", "libx264", "-preset", "ultrafast", "-crf", "26",
-        "-c:a", "aac", "-b:a", "128k", "-ar", "44100",
-        "-movflags", "+faststart", "-pix_fmt", "yuv420p",
-        output_path
-    ]
-    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
-    return result
-
-
-# ── /clip ───────────────────────────────────────────────────
 @app.route("/clip", methods=["POST"])
 def clip():
-    """
-    Accepts:
-      - mainVideoUrl: direct URL to main video file
-      - gameplayUrl: direct URL to gameplay clip (optional, picks random if not provided)
-      - videoId: unique identifier
-      - duration: max seconds (default 58)
-    Returns job_id immediately, poll /job/<id> for result
-    """
     data         = request.json
-    video_id     = data.get("videoId", str(uuid.uuid4()))
+    video_id     = data.get("videoId")
     main_url     = data.get("mainVideoUrl")
     gameplay_url = data.get("gameplayUrl")
-    dur          = min(int(data.get("duration", 58)), 58)
-
-    if not main_url:
-        return jsonify({"error": "mainVideoUrl is required"}), 400
+    duration     = int(data.get("duration", 58))
 
     job_id = str(uuid.uuid4())
     JOBS[job_id] = {"status": "running", "videoId": video_id}
 
-    def run():
-        work = f"/tmp/job_{job_id}"
-        os.makedirs(work, exist_ok=True)
-        try:
-            # Download main video
-            main_path = f"{work}/main.mp4"
-            download_file(main_url, main_path)
-
-            # Download or pick gameplay
-            gameplay_path = f"{work}/gameplay.mp4"
-            if gameplay_url:
-                download_file(gameplay_url, gameplay_path)
-            else:
-                # Pick from local gameplay dir
-                files = glob.glob(f"{GAMEPLAY_DIR}/*.mp4")
-                if not files:
-                    JOBS[job_id] = {"status": "error", "error": "No gameplay clips available"}
-                    return
-                import random
-                shutil.copy(random.choice(files), gameplay_path)
-
-            output_path = f"{OUTPUT_DIR}/{video_id}_final.mp4"
-            result = run_ffmpeg(main_path, gameplay_path, output_path, dur)
-
-            if result.returncode == 0 and os.path.exists(output_path):
-                JOBS[job_id] = {
-                    "status": "done",
-                    "videoId": video_id,
-                    "downloadUrl": f"/download/{video_id}_final.mp4",
-                    "outputPath": output_path
-                }
-            else:
-                JOBS[job_id] = {"status": "error", "error": result.stderr[-500:]}
-
-        except Exception as e:
-            JOBS[job_id] = {"status": "error", "error": str(e)}
-        finally:
-            shutil.rmtree(work, ignore_errors=True)
-
-    threading.Thread(target=run, daemon=True).start()
+    t = threading.Thread(
+        target=run_ffmpeg,
+        args=(job_id, video_id, main_url, gameplay_url, duration),
+        daemon=True
+    )
+    t.start()
+
     return jsonify({"job_id": job_id, "status": "started", "videoId": video_id})
 
 
-# ── /job/<id> ───────────────────────────────────────────────
 @app.route("/job/<job_id>", methods=["GET"])
 def job_status(job_id):
     return jsonify(JOBS.get(job_id, {"status": "not_found"}))
 
 
-# ── /download/<filename> ─────────────────────────────────────
 @app.route("/download/<filename>", methods=["GET"])
-def download_file_route(filename):
+def download(filename):
     path = f"{OUTPUT_DIR}/{filename}"
     if not os.path.exists(path):
-        return jsonify({"error": "File not found"}), 404
-    return send_file(path, as_attachment=True, mimetype="video/mp4")
+        return jsonify({"error": "Not found"}), 404
+    return send_file(path, mimetype="video/mp4", as_attachment=False)
 
 
-# ── /upload_gameplay ─────────────────────────────────────────
-@app.route("/upload_gameplay", methods=["POST"])
-def upload_gameplay():
-    """Upload a gameplay clip to the space."""
-    if 'file' not in request.files:
-        return jsonify({"error": "No file provided"}), 400
-    f = request.files['file']
-    filename = f"gameplay_{uuid.uuid4().hex[:8]}.mp4"
-    f.save(f"{GAMEPLAY_DIR}/{filename}")
-    return jsonify({"status": "done", "filename": filename})
-
-
-# ── /health ────���─────────────────────────────────────────────
 @app.route("/health", methods=["GET"])
 def health():
-    # Check ffmpeg available
-    ffmpeg_ok = subprocess.run(["ffmpeg", "-version"], capture_output=True).returncode == 0
-    return jsonify({
-        "status": "ok",
-        "ffmpeg": ffmpeg_ok,
-        "gameplay_clips": len(glob.glob(f"{GAMEPLAY_DIR}/*.mp4")),
-        "active_jobs": len([j for j in JOBS.values() if j.get("status") == "running"])
-    })
-
-
-# ── Cleanup old files every hour ────────────────────────────
-def cleanup_loop():
-    while True:
-        time.sleep(3600)
-        now = time.time()
-        for f in glob.glob(f"{OUTPUT_DIR}/*.mp4"):
-            if now - os.path.getmtime(f) > 7200:  # 2 hours
-                os.remove(f)
-
-threading.Thread(target=cleanup_loop, daemon=True).start()
+    return jsonify({"status": "ok", "jobs": len(JOBS)})
+
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True, threaded=True)
+    app.run(host="0.0.0.0", port=7860)