Update app.py

app.py

@@ -1,5 +1,5 @@
-# app.py — FLUX-only with temporal chaining + Aggressive follow + Video stitching (backend + ffmpeg)
-import os, json, uuid, re, tempfile, subprocess, shlex
+# app.py — FLUX-only with temporal chaining + Aggressive follow + Video stitching (backend + robust ffmpeg concat)
+import os, json, uuid, re, tempfile, subprocess, shlex, shutil, json as _json
 from datetime import datetime
 
 import gradio as gr
@@ -403,7 +403,7 @@ def generate_keyframe_image(
     return saved_path
 
 # =========================
-# Video stitching helpers (backend per pair + ffmpeg concat)
+# Video stitching helpers (backend per pair + robust ffmpeg concat)
 # =========================
 def _pair_clip_path(pid: str, i: int, j: int) -> str:
     return os.path.join(project_dir(pid), "clips", f"pair_{i:02d}_to_{j:02d}.mp4")
@@ -411,7 +411,7 @@ def _pair_clip_path(pid: str, i: int, j: int) -> str:
 def _final_stitched_path(pid: str) -> str:
     return os.path.join(project_dir(pid), "clips", "final_stitched.mp4")
 
-def _call_i2v_backend(img_a_path: str, img_b_path: str, prompt: str, seed: int | None, endpoint: str) -> bytes:
+def _call_i2v_backend(img_a_path: str, img_b_path: str, prompt: str, seed, endpoint: str) -> bytes:
     """
     Calls Modal backend with two images to get a transition clip (mp4 bytes).
     """
@@ -419,7 +419,10 @@ def _call_i2v_backend(img_a_path: str, img_b_path: str, prompt: str, seed: int |
     if prompt:
         params["prompt"] = prompt
     if seed is not None:
-        params["seed"] = str(int(seed))
+        try:
+            params["seed"] = str(int(seed))
+        except Exception:
+            pass
 
     with open(img_a_path, "rb") as fa, open(img_b_path, "rb") as fb:
         files = {
@@ -431,7 +434,7 @@ def _call_i2v_backend(img_a_path: str, img_b_path: str, prompt: str, seed: int |
         raise gr.Error(f"I2V backend error {r.status_code}: {r.text[:400]}")
     return r.content
 
-def _build_all_pair_videos_backend(pid: str, shots: list, endpoint: str, prompt: str, seed: int | None) -> list[str]:
+def _build_all_pair_videos_backend(pid: str, shots: list, endpoint: str, prompt: str, seed) -> list[str]:
     out_paths = []
     for k in range(len(shots) - 1):
         a = shots[k].get("image_path")
@@ -445,35 +448,138 @@ def _build_all_pair_videos_backend(pid: str, shots: list, endpoint: str, prompt:
         out_paths.append(outp)
     return out_paths
 
-def _ffmpeg_concat_videos(mp4_paths: list[str], out_path: str) -> None:
+# ---------- robust concat (normalize + concat demuxer; fallback re-encode once)
+def _ffprobe_stream(path):
+    ffmpeg = imageio_ffmpeg.get_ffmpeg_exe()
+    ffprobe = ffmpeg.replace("ffmpeg", "ffprobe")
+    cmd = [
+        ffprobe,
+        "-v", "error",
+        "-select_streams", "v:0",
+        "-show_entries", "stream=width,height,avg_frame_rate,pix_fmt,codec_name",
+        "-of", "json",
+        path,
+    ]
+    try:
+        out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        data = _json.loads(out.decode("utf-8"))
+        return (data.get("streams") or [{}])[0]
+    except Exception:
+        return {}
+
+def _ffmpeg_safe_concat(mp4_paths: list[str], out_path: str, fps: int = 24, size=None):
     if not mp4_paths:
-        raise gr.Error("No clips to concatenate.")
+        raise gr.Error("No clips to stitch.")
 
-    # Create a concat list file
-    list_txt = tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt")
-    try:
+    clips_dir = os.path.dirname(out_path)
+    os.makedirs(clips_dir, exist_ok=True)
+    log_path = os.path.join(clips_dir, "ffmpeg_concat.log")
+    ffmpeg = imageio_ffmpeg.get_ffmpeg_exe()
+
+    # Determine reference WxH
+    ref_w, ref_h = None, None
+    if size and isinstance(size, (tuple, list)) and len(size) == 2:
+        ref_w, ref_h = int(size[0]), int(size[1])
+    else:
         for p in mp4_paths:
-            if not os.path.exists(p):
-                raise gr.Error(f"Missing clip: {p}")
-            list_txt.write(f"file '{p}'\n")
-        list_txt.flush(); list_txt.close()
-
-        ffmpeg = imageio_ffmpeg.get_ffmpeg_exe()
-
-        # Try stream copy (fast)
-        cmd_copy = f"{shlex.quote(ffmpeg)} -y -f concat -safe 0 -i {shlex.quote(list_txt.name)} -c copy {shlex.quote(out_path)}"
-        rc = subprocess.call(cmd_copy, shell=True)
-        if rc == 0 and os.path.exists(out_path) and os.path.getsize(out_path) > 0:
-            return
-
-        # Fallback re-encode
-        cmd_reenc = f"{shlex.quote(ffmpeg)} -y -f concat -safe 0 -i {shlex.quote(list_txt.name)} -c:v libx264 -pix_fmt yuv420p -preset medium -crf 18 -an {shlex.quote(out_path)}"
-        rc2 = subprocess.call(cmd_reenc, shell=True)
-        if rc2 != 0 or not os.path.exists(out_path) or os.path.getsize(out_path) == 0:
-            raise gr.Error("ffmpeg concat failed (copy and re-encode).")
+            st = _ffprobe_stream(p)
+            if st.get("width") and st.get("height"):
+                ref_w, ref_h = int(st["width"]), int(st["height"])
+                break
+        if ref_w and ref_h:
+            if ref_w % 2: ref_w += 1
+            if ref_h % 2: ref_h += 1
+
+    norm_paths = []
+    tmpdir = tempfile.mkdtemp(prefix="norm_")
+    try:
+        # Normalize each clip to consistent fps/size/codec/pixfmt
+        for i, inp in enumerate(mp4_paths):
+            if not os.path.exists(inp):
+                continue
+            norm = os.path.join(tmpdir, f"norm_{i:03d}.mp4")
+
+            vf = []
+            if ref_w and ref_h:
+                vf.append(f"scale=w={ref_w}:h={ref_h}:force_original_aspect_ratio=decrease")
+                vf.append(f"pad={ref_w}:{ref_h}:(ow-iw)/2:(oh-ih)/2:color=black")
+            vf.append(f"fps={int(fps)}")
+            vf_arg = ",".join(vf)
+
+            cmd = [
+                ffmpeg, "-y", "-i", inp,
+                "-vf", vf_arg,
+                "-an",
+                "-c:v", "libx264",
+                "-pix_fmt", "yuv420p",
+                "-profile:v", "main",
+                "-preset", "veryfast",
+                "-crf", "18",
+                "-movflags", "+faststart",
+                norm
+            ]
+            with open(log_path, "ab") as lg:
+                lg.write(("NORMALIZE: " + " ".join(cmd) + "\n").encode())
+                subprocess.check_call(cmd, stdout=lg, stderr=lg)
+            norm_paths.append(norm)
+
+        if not norm_paths:
+            raise gr.Error("No inputs could be normalized for concat.")
+
+        # concat demuxer (stream copy)
+        listfile = os.path.join(tmpdir, "list.txt")
+        with open(listfile, "w") as f:
+            for p in norm_paths:
+                f.write(f"file '{p}'\n")
+
+        cmd_concat_copy = [
+            ffmpeg, "-y",
+            "-f", "concat", "-safe", "0", "-i", listfile,
+            "-c", "copy",
+            out_path
+        ]
+        try:
+            with open(log_path, "ab") as lg:
+                lg.write(("CONCAT_COPY: " + " ".join(cmd_concat_copy) + "\n").encode())
+                subprocess.check_call(cmd_concat_copy, stdout=lg, stderr=lg)
+            return out_path
+        except subprocess.CalledProcessError:
+            pass  # fallback
+
+        # filter_complex concat (re-encode once)
+        cmd = [ffmpeg, "-y"]
+        for p in norm_paths:
+            cmd += ["-i", p]
+        n = len(norm_paths)
+        inputs = "".join([f"[{i}:v]" for i in range(n)])
+        filtergraph = f"{inputs}concat=n={n}:v=1:a=0[outv]"
+        cmd += [
+            "-filter_complex", filtergraph,
+            "-map", "[outv]",
+            "-an",
+            "-c:v", "libx264",
+            "-pix_fmt", "yuv420p",
+            "-profile:v", "main",
+            "-preset", "veryfast",
+            "-crf", "18",
+            "-r", str(int(fps)),
+            "-movflags", "+faststart",
+            out_path
+        ]
+        with open(log_path, "ab") as lg:
+            lg.write(("CONCAT_REENC: " + " ".join(cmd) + "\n").encode())
+            subprocess.check_call(cmd, stdout=lg, stderr=lg)
+        return out_path
+
+    except subprocess.CalledProcessError:
+        raise gr.Error("ffmpeg concat failed (copy and re-encode). See logs at: " + log_path)
+    except Exception as e:
+        raise gr.Error(f"Concat error: {e}")
     finally:
-        try: os.unlink(list_txt.name)
-        except: pass
+        try:
+            shutil.rmtree(tmpdir)
+        except Exception:
+            pass
 
 # =========================
 # Shots <-> DataFrame utils
@@ -723,7 +829,7 @@ with gr.Blocks() as demo:
 
     approve_next_btn.click(on_approve_next, inputs=[project, current_idx, prompt_box, out_img], outputs=[project, current_idx, shot_info_md, prompt_box, prev_img, out_img, kf_status])
 
-    # ---- Videos tab handlers (backend + ffmpeg)
+    # ---- Videos tab handlers (backend + robust ffmpeg)
     def on_build_pairs(p, fps, hold, xfade):
         if p is None:
             raise gr.Error("No project.")
@@ -764,7 +870,7 @@ with gr.Blocks() as demo:
         if not pair_paths:
             raise gr.Error("No pair clips found. Click 'Build pair clips' first.")
         outp = _final_stitched_path(pid)
-        _ffmpeg_concat_videos(pair_paths, outp)
+        _ffmpeg_safe_concat(pair_paths, outp, fps=int(fps), size=None)  # set size=(640,640) to force letterbox
         return {"pair_clips": pair_paths, "final": outp}
 
     build_final_btn.click(