feat: auto-trim long uploads and add audio re-encode fallback

- extract_frames accepts max_duration_s; pipeline now silently trims
to first 15 s instead of rejecting clips up to 60 s
- on_video_upload shows a trim notice when the uploaded clip exceeds
the processing window
- attach_audio falls back to AAC re-encode when stream-copy fails
(fixes silent mux failure for sources with MP4-incompatible audio
codecs like raw PCM in .mov or Opus in .webm)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

app.py

@@ -46,6 +46,11 @@ from pipeline.video import (
     attach_audio, extract_first_frame, extract_frames, frames_to_video, probe,
 )
 
+# Working window the pipeline actually inpaints. Longer uploads are
+# accepted (up to UPLOAD_DURATION_S in on_video_upload) and silently
+# trimmed to this length during frame extraction.
+PROCESS_DURATION_S = 15.0
+
 # ---------------------------------------------------------------------------
 # CSS — dark premium theme
 # ---------------------------------------------------------------------------
@@ -319,28 +324,34 @@ def on_video_upload(video_path: str | None):
         meta = probe(video_path)
 
         # ── Input validation — guard against disk exhaustion on ZeroGPU ──
-        MAX_DURATION_S = 15.0
+        # UPLOAD_DURATION_S is the upper bound we accept; longer clips are
+        # silently auto-trimmed to PROCESS_DURATION_S during frame
+        # extraction (see run_pipeline → extract_frames).
+        UPLOAD_DURATION_S = 60.0
         MAX_PIXELS = 1920 * 1080
         # Max frames caps videos where ffprobe returns N/A for duration
         # (VFR/container-less formats). duration_s would be 0.0 after our guard,
         # so the duration check alone would pass an arbitrarily long clip.
-        MAX_FRAMES = round(MAX_DURATION_S * max(meta.fps, 1.0))
-        if meta.duration_s > MAX_DURATION_S:
+        MAX_FRAMES = round(UPLOAD_DURATION_S * max(meta.fps, 1.0))
+        if meta.duration_s > UPLOAD_DURATION_S:
             return (
                 gr.update(), gr.update(), None,
-                f"❌ Clip too long ({meta.duration_s:.1f}s). Max {MAX_DURATION_S:.0f} seconds.",
+                f"❌ Clip too long ({meta.duration_s:.1f}s). "
+                f"Max {UPLOAD_DURATION_S:.0f}s; only the first "
+                f"{PROCESS_DURATION_S:.0f}s would be processed anyway.",
             )
         if meta.frame_count > MAX_FRAMES:
             return (
                 gr.update(), gr.update(), None,
                 f"❌ Clip too long ({meta.frame_count} frames at {meta.fps:.2f} fps). "
-                f"Max {MAX_DURATION_S:.0f} seconds.",
+                f"Max {UPLOAD_DURATION_S:.0f} seconds.",
             )
         if meta.width * meta.height > MAX_PIXELS:
             return (
                 gr.update(), gr.update(), None,
                 f"❌ Resolution too high ({meta.width}×{meta.height}). Max 1920×1080.",
             )
+        will_trim = meta.duration_s > PROCESS_DURATION_S
 
         # Extract first frame — mkstemp so the fd is closed before FFmpeg writes
         fd, tmp_path = tempfile.mkstemp(suffix=".png", prefix="wm_frame_")
@@ -366,11 +377,17 @@ def on_video_upload(video_path: str | None):
             "layers": [],
             "composite": None,
         }
+        trim_note = (
+            f"\n\n⚠️ Clip is {meta.duration_s:.1f}s — only the first "
+            f"{PROCESS_DURATION_S:.0f}s will be processed."
+            if will_trim else ""
+        )
         return (
             gr.update(value=editor_val),
             gr.update(value=None),
             _meta_to_dict(meta),
-            f"✓ Loaded — {meta_str}\n\nNow draw over the watermark with the brush tool.",
+            f"✓ Loaded — {meta_str}{trim_note}"
+            f"\n\nNow draw over the watermark with the brush tool.",
         )
     except Exception as e:
         return gr.update(), gr.update(), None, f"❌ Error: {e}"
@@ -549,7 +566,10 @@ def run_pipeline(
 
         # ── Extract frames (CFR-forced for VFR safety) ─────────────────
         progress(0.10, desc="Extracting frames…")
-        frame_paths = extract_frames(safe_video, ws.frames_dir, fps=meta.fps)
+        frame_paths = extract_frames(
+            safe_video, ws.frames_dir, fps=meta.fps,
+            max_duration_s=PROCESS_DURATION_S,
+        )
         total = len(frame_paths)
 
         # ── GPU: inpaint + composite + save ────────────────────────────

pipeline/video.py

@@ -158,6 +158,7 @@ def extract_frames(
     out_dir: str | Path,
     pattern: str = "%06d.png",
     fps: float | None = None,
+    max_duration_s: float | None = None,
 ) -> List[Path]:
     """
     Extract every frame from *video_path* as PNG images into *out_dir*.
@@ -177,6 +178,9 @@ def extract_frames(
     fps : float, optional
         If given, force constant-rate output at this rate. Pass
         ``VideoMeta.fps`` to guarantee A/V sync on reassembly.
+    max_duration_s : float, optional
+        If given, only extract the first *max_duration_s* seconds of video
+        (FFmpeg ``-t`` flag). Shorter sources pass through unchanged.
 
     Returns
     -------
@@ -191,6 +195,8 @@ def extract_frames(
         "-y",
         "-i", str(video_path),
     ]
+    if max_duration_s is not None:
+        cmd += ["-t", f"{max_duration_s:.6g}"]
     if fps is not None:
         # Force constant frame rate; handles VFR sources without re-encoding
         # by inserting duplicate frames where the source skips.
@@ -364,18 +370,31 @@ def attach_audio(
         shutil.copy2(str(silent_video), str(out_path))
         return out_path
 
-    cmd = [
+    base_cmd = [
         "ffmpeg",
         "-y",
         "-i", str(silent_video),   # stream 0: video
         "-i", str(source_video),   # stream 1: audio donor
-        "-c", "copy",
-        "-map", "0:v:0",
-        "-map", "1:a:0",
-        "-shortest",               # trim to shorter stream (video)
-        str(out_path),
     ]
-    _run(cmd)
+    map_flags = ["-map", "0:v:0", "-map", "1:a:0", "-shortest"]
+    out = [str(out_path)]
+
+    # First try stream-copy (no re-encode) — fast and lossless when the
+    # source audio codec is MP4-compatible (AAC, MP3, AC3, etc.).
+    try:
+        _run(base_cmd + ["-c", "copy"] + map_flags + out)
+        return out_path
+    except RuntimeError:
+        # Stream-copy failed — most likely the source audio codec is
+        # incompatible with MP4 (e.g. PCM in .mov, Opus in .webm).
+        # Fall back to re-encoding audio only; video remains stream-copied.
+        if out_path.exists():
+            try:
+                out_path.unlink()
+            except OSError:
+                pass
+
+    _run(base_cmd + ["-c:v", "copy", "-c:a", "aac", "-b:a", "192k"] + map_flags + out)
     return out_path