Update scripts/reconstruct_media.py

scripts/reconstruct_media.py

@@ -9,31 +9,12 @@ from __future__ import annotations
 
 import argparse
 import csv
-import subprocess
 from pathlib import Path
 
 
 VIDEO_EXTENSIONS = (".mp4", ".mov", ".mkv", ".avi", ".webm")
 
 
-def build_resize_filter(mode: str, width: str, height: str) -> str:
-    w = int(width)
-    h = int(height)
-    if mode == "stretch":
-        return f"scale={w}:{h}"
-    if mode == "pad_to_square":
-        return (
-            f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
-            f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2"
-        )
-    if mode == "center_crop":
-        return (
-            f"scale={w}:{h}:force_original_aspect_ratio=increase,"
-            f"crop={w}:{h}:(iw-{w})/2:(ih-{h})/2"
-        )
-    raise ValueError(f"Unsupported resize_mode: {mode}")
-
-
 def find_source_video(source_root: Path, source_dataset: str, source_video_id: str) -> Path:
     dataset_root = source_root / source_dataset
     candidates = []
@@ -49,7 +30,58 @@ def find_source_video(source_root: Path, source_dataset: str, source_video_id: s
     )
 
 
-def reconstruct_row(row: dict[str, str], source_root: Path, output_root: Path, dry_run: bool) -> None:
+def reconstruct_with_opencv(row: dict[str, str], input_video: Path, output_path: Path) -> None:
+    try:
+        import cv2
+    except ImportError as exc:
+        raise RuntimeError(
+            "OpenCV is required for reconstruction. Install opencv-python."
+        ) from exc
+
+    fps = float(row.get("fps", "4"))
+    width = int(row["target_width"])
+    height = int(row["target_height"])
+    cap = cv2.VideoCapture(str(input_video))
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open source video: {input_video}")
+
+    try:
+        raw_fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration = frame_count / raw_fps if raw_fps > 0 else 0
+        target_frame_count = int(duration * fps)
+        if target_frame_count <= 0:
+            raise RuntimeError(f"Invalid target frame count for {input_video}")
+
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
+        if not writer.isOpened():
+            raise RuntimeError(f"Failed to open output video writer: {output_path}")
+        try:
+            for i in range(target_frame_count):
+                target_time = i / fps
+                raw_frame_idx = int(round(target_time * raw_fps))
+                if raw_frame_idx >= frame_count:
+                    raw_frame_idx = frame_count - 1
+                cap.set(cv2.CAP_PROP_POS_FRAMES, raw_frame_idx)
+                success, frame = cap.read()
+                if not success:
+                    continue
+                if frame.shape[1] != width or frame.shape[0] != height:
+                    frame = cv2.resize(frame, (width, height))
+                writer.write(frame)
+        finally:
+            writer.release()
+    finally:
+        cap.release()
+
+
+def reconstruct_row(
+    row: dict[str, str],
+    source_root: Path,
+    output_root: Path,
+    dry_run: bool,
+) -> None:
     if row.get("source_dataset") == "Self-recorded":
         return
     input_video = find_source_video(source_root, row["source_dataset"], row["source_video_id"])
@@ -59,33 +91,12 @@ def reconstruct_row(row: dict[str, str], source_root: Path, output_root: Path, d
     output_path = output_root / rel_output
     output_path.parent.mkdir(parents=True, exist_ok=True)
 
-    resize_filter = build_resize_filter(
-        row.get("resize_mode", "stretch"),
-        row["target_width"],
-        row["target_height"],
-    )
-    command = ["ffmpeg", "-y"]
-    start = row.get("source_start_sec", "").strip()
-    end = row.get("source_end_sec", "").strip()
-    if start:
-        command.extend(["-ss", start])
-    if end:
-        command.extend(["-to", end])
-    command.extend(
-        [
-            "-i",
-            str(input_video),
-            "-vf",
-            resize_filter,
-            "-r",
-            row.get("fps", "4"),
-            "-an",
-            str(output_path),
-        ]
+    print(
+        f"opencv {input_video} -> {output_path} "
+        f"resize={row['target_width']}x{row['target_height']} fps={row.get('fps', '4')}"
     )
-    print(" ".join(command))
     if not dry_run:
-        subprocess.run(command, check=True)
+        reconstruct_with_opencv(row, input_video, output_path)
 
 
 def main() -> int:
@@ -98,8 +109,13 @@ def main() -> int:
 
     source_root = Path(args.source_root)
     output_root = Path(args.output_root)
+    seen_outputs: set[str] = set()
     with Path(args.manifest).open(newline="", encoding="utf-8") as handle:
         for row in csv.DictReader(handle):
+            output_key = row.get("expected_local_output_path", "")
+            if output_key in seen_outputs:
+                continue
+            seen_outputs.add(output_key)
             reconstruct_row(row, source_root, output_root, args.dry_run)
     return 0