extraction 1 process

app.py

@@ -40,7 +40,7 @@ DEFAULT_SPLIT_CFG = {
     "jump_meanabs_threshold": 18.0,
     "progress_every": 0,
 }
-ENABLE_MOTION_SEGMENTATION = os.getenv("ENABLE_MOTION_SEGMENTATION", "1").strip().lower() in {
+ENABLE_MOTION_SEGMENTATION = os.getenv("ENABLE_MOTION_SEGMENTATION", "0").strip().lower() in {
     "1",
     "true",
     "yes",
@@ -102,18 +102,6 @@ def _format_idx_list(indices, max_items=40):
     return f"{head} ... {tail} (len={len(values)})"
 
 
-def _format_float_list(values, max_items=12, precision=3):
-    if not values:
-        return "[]"
-    vals = [float(v) for v in values]
-    if len(vals) <= max_items:
-        return "[" + ", ".join(f"{v:.{precision}f}" for v in vals) + "]"
-    half = max_items // 2
-    head = ", ".join(f"{v:.{precision}f}" for v in vals[:half])
-    tail = ", ".join(f"{v:.{precision}f}" for v in vals[-half:])
-    return f"[{head}, ... {tail}] (len={len(vals)})"
-
-
 def _sample_uniform_items(items, n):
     n = max(1, int(n))
     if len(items) <= n:
@@ -243,15 +231,38 @@ def _probe_duration_ffprobe(video_path):
     return float(duration)
 
 
-def _sample_timestamps(duration, n):
-    if duration is None or duration <= 0:
-        return []
-    n = max(1, int(n))
-    if n == 1:
-        return [0.0]
-    # Stay slightly below duration to avoid requesting a frame past the stream end.
-    max_t = max(0.0, float(duration) - 1e-3)
-    return np.linspace(0.0, max_t, n).tolist()
+def _probe_video_size_ffprobe(video_path):
+    ffprobe = shutil.which("ffprobe")
+    if ffprobe is None:
+        return None
+
+    cmd = [
+        ffprobe,
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=width,height",
+        "-of",
+        "csv=p=0:s=x",
+        video_path,
+    ]
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
+    if proc.returncode != 0:
+        return None
+
+    line = next((txt.strip() for txt in proc.stdout.splitlines() if txt.strip()), "")
+    if "x" not in line:
+        return None
+    left, right = line.split("x", 1)
+    if not left.isdigit() or not right.isdigit():
+        return None
+
+    width, height = int(left), int(right)
+    if width <= 0 or height <= 0:
+        return None
+    return width, height
 
 
 def _extract_bgr_with_ffmpeg_disk(video_path, n):
@@ -351,62 +362,83 @@ def _extract_bgr_with_ffmpeg(video_path, n):
         _log_timing_summary(f"Frame extraction ({video_name})", timing, wall_time=timing["wall"])
         return frames
 
-    with timer("sample_timestamps", timing):
-        timestamps = _sample_timestamps(duration, n)
-    if not timestamps:
+    with timer("probe_video_size", timing):
+        video_size = _probe_video_size_ffprobe(video_path)
+    if video_size is None:
+        LOGGER.warning("Frame extraction | ffprobe size unavailable, fallback to disk extraction")
+        with timer("fallback_disk_extract", timing):
+            frames = _extract_bgr_with_ffmpeg_disk(video_path, n)
         timing["wall"] = time.perf_counter() - wall_t0
         _log_timing_summary(f"Frame extraction ({video_name})", timing, wall_time=timing["wall"])
-        return []
+        return frames
+
+    width, height = video_size
+    frame_size = int(width) * int(height) * 3
+    if frame_size <= 0:
+        LOGGER.warning("Frame extraction | invalid frame size, fallback to disk extraction")
+        with timer("fallback_disk_extract", timing):
+            frames = _extract_bgr_with_ffmpeg_disk(video_path, n)
+        timing["wall"] = time.perf_counter() - wall_t0
+        _log_timing_summary(f"Frame extraction ({video_name})", timing, wall_time=timing["wall"])
+        return frames
+
+    sample_fps = max(1e-6, float(n) / float(duration))
 
     LOGGER.info(
-        (
-            "Frame extraction (memory/timestamps) | video=%s duration=%.3fs n_samples=%d "
-            "sampled_timestamps=%s"
-        ),
+        "Frame extraction (single ffmpeg/rawvideo) | video=%s duration=%.3fs n_samples=%d fps=%.6f size=%dx%d",
         video_name,
         duration,
-        len(timestamps),
-        _format_float_list(timestamps, max_items=10, precision=2),
+        n,
+        sample_fps,
+        width,
+        height,
     )
 
-    frames = []
-    for ts in timestamps:
-        cmd = [
-            ffmpeg,
-            "-hide_banner",
-            "-loglevel",
-            "error",
-            "-ss",
-            f"{float(ts):.6f}",
-            "-i",
-            video_path,
-            "-frames:v",
-            "1",
-            "-f",
-            "image2pipe",
-            "-vcodec",
-            "mjpeg",
-            "-",
-        ]
-        with timer("ffmpeg_extract_one", timing):
-            proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
-        if proc.returncode != 0 or not proc.stdout:
-            LOGGER.warning(
-                "Frame extraction timestamp failed | video=%s ts=%.3fs err=%s",
-                video_name,
-                float(ts),
-                (proc.stderr.decode("utf-8", errors="ignore").strip() if proc.stderr else "no stderr"),
-            )
-            continue
+    cmd = [
+        ffmpeg,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        video_path,
+        "-vf",
+        f"fps={sample_fps:.8f}",
+        "-frames:v",
+        str(n),
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "bgr24",
+        "-",
+    ]
+    with timer("ffmpeg_extract_rawvideo", timing):
+        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+    if proc.returncode != 0 or not proc.stdout:
+        LOGGER.warning(
+            "Frame extraction rawvideo failed | video=%s err=%s",
+            video_name,
+            (proc.stderr.decode("utf-8", errors="ignore").strip() if proc.stderr else "no stderr"),
+        )
+        with timer("fallback_disk_extract", timing):
+            frames = _extract_bgr_with_ffmpeg_disk(video_path, n)
+        timing["wall"] = time.perf_counter() - wall_t0
+        _log_timing_summary(f"Frame extraction ({video_name})", timing, wall_time=timing["wall"])
+        return frames
 
-        with timer("decode_one", timing):
-            encoded = np.frombuffer(proc.stdout, dtype=np.uint8)
-            frame = cv2.imdecode(encoded, cv2.IMREAD_COLOR)
-        if frame is not None:
-            frames.append(frame)
+    with timer("decode_rawvideo", timing):
+        raw = proc.stdout
+        frame_count = len(raw) // frame_size
+        usable_bytes = frame_count * frame_size
+        if frame_count > 0 and usable_bytes:
+            arr = np.frombuffer(raw[:usable_bytes], dtype=np.uint8).reshape(frame_count, height, width, 3)
+            frames = [arr[idx].copy() for idx in range(frame_count)]
+        else:
+            frames = []
+    if len(frames) > n:
+        frames = _sample_uniform_items(frames, n)
 
     if not frames:
-        LOGGER.warning("Frame extraction | timestamp mode returned 0 frame, fallback to disk extraction")
+        LOGGER.warning("Frame extraction | rawvideo mode returned 0 frame, fallback to disk extraction")
         with timer("fallback_disk_extract", timing):
             frames = _extract_bgr_with_ffmpeg_disk(video_path, n)
 
@@ -414,7 +446,7 @@ def _extract_bgr_with_ffmpeg(video_path, n):
         "Frame extraction done | video=%s extracted=%d requested=%d",
         video_name,
         len(frames),
-        len(timestamps),
+        n,
     )
     timing["wall"] = time.perf_counter() - wall_t0
     _log_timing_summary(f"Frame extraction ({video_name})", timing, wall_time=timing["wall"])

docker-compose.yml

@@ -10,7 +10,7 @@ services:
       STREAMLIT_SERVER_ADDRESS: "0.0.0.0"
       STREAMLIT_SERVER_PORT: "7860"
       STREAMLIT_BROWSER_GATHER_USAGE_STATS: "false"
-      ENABLE_MOTION_SEGMENTATION: "1"
+      ENABLE_MOTION_SEGMENTATION: "0"
       FAST_N_SAMPLES: "12"
       INFER_BATCH_SIZE: "16"
       MODEL_IMGSZ: "1024"