Upload 19 files

DEPLOY_HF.md

@@ -87,7 +87,8 @@ If you hit the 10 MB file limit, make sure you did **not** commit `venv/` or any
 
 ## Using it
 
-1. Upload a video.
+1. Upload a video. (Longer than the limit? Open **✂️ Trim** and choose a
+   segment — over-length clips are trimmed automatically.)
 2. In **"What to blur?"** type the regions, e.g. `face. license plate.`
 3. Click **Preview Detection** to confirm the right regions are caught.
 4. Click **Process Video**, then download the result.

README.md

@@ -37,8 +37,9 @@ Full step-by-step with troubleshooting: see **[`DEPLOY_HF.md`](DEPLOY_HF.md)**.
 
 > ZeroGPU gives each request the GPU for a limited time, so this app defaults to
 > a reduced processing resolution (480p), fast models (Grounding DINO *tiny* +
-> SAM 2 *small*), and a short per-clip length cap. Raise these for a paid GPU —
-> see "Tuning" below.
+> SAM 2 *small*), and a short per-clip length cap. **Longer videos aren't
+> rejected** — use the **✂️ Trim** panel to pick a segment (over-length clips
+> are trimmed automatically). Raise these for a paid GPU — see "Tuning" below.
 
 ---
 

app.py

@@ -12,6 +12,7 @@ import os
 import sys
 import time
 import tempfile
+import subprocess
 from pathlib import Path
 
 # ─── ZeroGPU / Hugging Face Spaces support ─────────────────────
@@ -259,6 +260,47 @@ CUSTOM_CSS = """
 
 # ─── Processing Functions ──────────────────────────────────────
 
+def trim_clip(video_path, start, length):
+    """Cut [start, start+length] seconds from a video with ffmpeg.
+
+    Returns the path to a new .mp4. Re-encodes (fast preset) so the cut is
+    frame-accurate. This is CPU-only work (no GPU needed).
+    """
+    start = max(0.0, float(start))
+    length = max(0.1, float(length))
+    out_dir = tempfile.mkdtemp(prefix="trim_")
+    out_path = os.path.join(out_dir, f"trimmed_{Path(video_path).stem}.mp4")
+    cmd = [
+        "ffmpeg", "-y",
+        "-ss", str(start),
+        "-i", video_path,
+        "-t", str(length),
+        "-c:v", "libx264", "-preset", "veryfast", "-crf", "20",
+        "-c:a", "aac",
+        "-movflags", "+faststart",
+        out_path,
+    ]
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0 or not os.path.exists(out_path):
+        raise RuntimeError((proc.stderr or "ffmpeg failed")[-400:])
+    return out_path
+
+
+def preview_trim(video_file, trim_start, trim_length):
+    """Produce a preview of the trimmed segment so the user can confirm it."""
+    if video_file is None:
+        gr.Warning("⚠️ Please upload a video first!")
+        return None
+    try:
+        video_path = video_file if isinstance(video_file, str) else video_file.name
+        cap = getattr(config, "max_video_duration", 600)
+        length = min(float(trim_length) if trim_length else cap, cap)
+        return trim_clip(video_path, trim_start, length)
+    except Exception as e:
+        gr.Warning(f"Trim error: {e}")
+        return None
+
+
 @spaces.GPU(duration=PROCESS_DURATION)
 def process_video(
     video_file,
@@ -270,6 +312,9 @@ def process_video(
     keyframe_interval,
     detection_threshold,
     model_quality,
+    trim_enable,
+    trim_start,
+    trim_length,
     progress=gr.Progress()
 ):
     """Main video processing function"""
@@ -302,26 +347,33 @@ def process_video(
         else:
             video_path = video_file.name if hasattr(video_file, 'name') else str(video_file)
 
-        # Generate output path
-        output_dir = tempfile.mkdtemp(prefix="blur_output_")
-        output_name = f"blurred_{Path(video_path).stem}.mp4"
-        output_path = os.path.join(output_dir, output_name)
-
-        # Enforce a max duration so a single GPU call fits inside the
-        # ZeroGPU time budget (long clips would otherwise time out).
+        # ── Trim (for long videos) ──
+        # Trim when the user asked to, OR automatically when the clip is longer
+        # than the cap — so long videos are handled instead of rejected.
         max_secs = getattr(config, "max_video_duration", 600)
         try:
-            info = pipeline.video_processor.get_video_info(video_path)
-            if info.duration and info.duration > max_secs:
-                msg = (
-                    f"⏱️ Video is {info.duration:.0f}s but the limit here is "
-                    f"{max_secs}s. Please trim it, or raise max_video_duration "
-                    f"/ use a larger GPU."
-                )
-                gr.Warning(msg)
-                return None, "❌ " + msg
+            _info = pipeline.video_processor.get_video_info(video_path)
+            duration = _info.duration or 0.0
         except Exception:
-            pass  # if probing fails, let the pipeline surface the real error
+            duration = 0.0
+
+        should_trim = bool(trim_enable) or (duration and duration > max_secs)
+        if should_trim:
+            length = min(float(trim_length) if trim_length else max_secs, max_secs)
+            start = max(0.0, float(trim_start) if trim_start else 0.0)
+            if duration and start >= duration:
+                start = 0.0
+            gradio_progress(0.02, f"✂️ Trimming to {start:.0f}–{start + length:.0f}s...")
+            try:
+                video_path = trim_clip(video_path, start, length)
+            except Exception as e:
+                gr.Warning(f"Trim failed: {e}")
+                return None, f"❌ Trim failed: {e}"
+
+        # Generate output path (from the possibly-trimmed video)
+        output_dir = tempfile.mkdtemp(prefix="blur_output_")
+        output_name = f"blurred_{Path(video_path).stem}.mp4"
+        output_path = os.path.join(output_dir, output_name)
 
         # Process
         result_path = pipeline.process_video(
@@ -377,9 +429,18 @@ def preview_detection(video_file, text_prompt, frame_slider):
 
 
 def get_video_info_text(video_file):
-    """Get video info when uploaded"""
+    """Get video info when uploaded, and set up the trim controls."""
+    cap = getattr(config, "max_video_duration", 600)
+
     if video_file is None:
-        return "No video uploaded", gr.Slider(maximum=0, value=0)
+        return (
+            "No video uploaded",
+            gr.Slider(maximum=0, value=0),          # frame_slider
+            gr.Checkbox(value=False),               # trim_enable
+            gr.Slider(maximum=1, value=0),          # trim_start
+            gr.Slider(maximum=cap, value=cap),      # trim_length
+            "",                                     # trim_info
+        )
 
     try:
         video_path = video_file if isinstance(video_file, str) else video_file.name
@@ -395,10 +456,37 @@ def get_video_info_text(video_file):
         )
 
         max_frame = max(0, info.total_frames - 1)
-        return text, gr.Slider(maximum=max_frame, value=0)
+        dur = info.duration or 0.0
+        too_long = bool(dur and dur > cap)
+        length_default = min(cap, dur) if dur else cap
+
+        trim_info = ""
+        if too_long:
+            trim_info = (
+                f"⏱️ This clip is **{dur:.0f}s**, longer than the **{cap}s** limit. "
+                f"It will be trimmed automatically — set the start below to choose "
+                f"which part to keep (defaults to the first {cap}s), and optionally "
+                f"**Preview trimmed clip** to check it."
+            )
+
+        return (
+            text,
+            gr.Slider(maximum=max_frame, value=0),                       # frame_slider
+            gr.Checkbox(value=too_long),                                 # trim_enable (auto-on if long)
+            gr.Slider(maximum=max(0.1, dur), value=0),                   # trim_start
+            gr.Slider(maximum=cap, value=length_default),                # trim_length
+            trim_info,                                                   # trim_info
+        )
 
     except Exception as e:
-        return f"❌ Error reading video: {e}", gr.Slider(maximum=0, value=0)
+        return (
+            f"❌ Error reading video: {e}",
+            gr.Slider(maximum=0, value=0),
+            gr.Checkbox(value=False),
+            gr.Slider(maximum=1, value=0),
+            gr.Slider(maximum=cap, value=cap),
+            "",
+        )
 
 
 # ─── Build UI ──────────────────────────────────────────────────
@@ -416,7 +504,7 @@ def create_app():
         limits_note = (
             f"<p style='font-size:0.8em;color:#8a8aa8;'>Running on ZeroGPU · "
             f"processed at {config.video.max_resolution}p · clips up to "
-            f"{config.max_video_duration}s</p>"
+            f"{config.max_video_duration}s (longer videos can be trimmed)</p>"
         )
 
     with gr.Blocks(
@@ -449,6 +537,35 @@ def create_app():
                 # Video Info
                 video_info_text = gr.Markdown("No video uploaded")
 
+                # ── Trim controls (for long videos) ──
+                with gr.Accordion("✂️ Trim (for long videos)", open=False):
+                    trim_info = gr.Markdown("")
+                    trim_enable = gr.Checkbox(
+                        label="Trim this video before processing",
+                        value=False,
+                        info=(
+                            f"Clips here are limited to {config.max_video_duration}s. "
+                            "Turn this on to process only a chosen segment. Long videos "
+                            "are trimmed automatically."
+                        ),
+                    )
+                    with gr.Row():
+                        trim_start = gr.Slider(
+                            minimum=0, maximum=60, value=0, step=0.5,
+                            label="Start (seconds)",
+                        )
+                        trim_length = gr.Slider(
+                            minimum=1, maximum=config.max_video_duration,
+                            value=config.max_video_duration, step=1,
+                            label=f"Clip length (max {config.max_video_duration}s)",
+                        )
+                    trim_preview_btn = gr.Button(
+                        "✂️ Preview trimmed clip", variant="secondary"
+                    )
+                    trim_preview_video = gr.Video(
+                        label="Trimmed preview", interactive=False
+                    )
+
                 # Prompt Input — this is where the user WRITES the regions to blur
                 text_prompt = gr.Textbox(
                     label="✏️ What to blur? (Text Prompt)",
@@ -591,16 +708,27 @@ def create_app():
             ### Running on ZeroGPU
             - The first run loads the models onto the GPU, so it's a bit slower; later runs are faster.
             - Each run gets the GPU for a limited time, so clips are processed at a reduced resolution and capped in length by default for speed.
+            - **Long video?** Open **✂️ Trim** to pick a segment. Videos over the limit are trimmed automatically (to the first part, or your chosen start).
             - Want longer / higher-res? Upgrade the Space GPU and raise `max_video_duration`, `max_resolution` and the `@spaces.GPU(duration=...)` budget.
             """)
 
         # ── Event Handlers ──
 
-        # Video upload → show info
+        # Video upload → show info + set up trim controls
         video_input.change(
             fn=get_video_info_text,
             inputs=[video_input],
-            outputs=[video_info_text, frame_slider]
+            outputs=[
+                video_info_text, frame_slider,
+                trim_enable, trim_start, trim_length, trim_info,
+            ]
+        )
+
+        # Trim preview button
+        trim_preview_btn.click(
+            fn=preview_trim,
+            inputs=[video_input, trim_start, trim_length],
+            outputs=[trim_preview_video]
         )
 
         # Preview button
@@ -616,7 +744,8 @@ def create_app():
             inputs=[
                 video_input, text_prompt, blur_type, blur_strength,
                 edge_feather, processing_mode, keyframe_interval,
-                detection_threshold, model_quality
+                detection_threshold, model_quality,
+                trim_enable, trim_start, trim_length
             ],
             outputs=[video_output, status_text]
         )