#!/usr/bin/env python3 """Extract every frame from the released 1 FPS videos, without media hosting.""" import argparse import json import shutil import struct import subprocess import tempfile from concurrent.futures import ThreadPoolExecutor from fractions import Fraction from pathlib import Path def relative_file(root, value): path = Path(value) if path.is_absolute() or ".." in path.parts or "\\" in value: raise ValueError(f"Expected a relative media path: {value}") resolved = (root / path).resolve() if not resolved.is_relative_to(root.resolve()) or not resolved.is_file(): raise ValueError(f"Missing media or path outside the dataset: {value}") return resolved def validate_video(path, expected): result = subprocess.run( ["ffprobe", "-v", "error", "-analyzeduration", "0", "-probesize", "32768", "-show_entries", "stream=codec_type,avg_frame_rate,r_frame_rate,nb_frames,duration,start_time", "-of", "json", str(path)], check=True, capture_output=True, text=True, timeout=120, ) streams = json.loads(result.stdout)["streams"] if len(streams) != 1 or streams[0]["codec_type"] != "video": raise ValueError(f"Expected one video stream without audio: {path.name}") stream = streams[0] if (Fraction(stream["avg_frame_rate"]) != 1 or Fraction(stream["r_frame_rate"]) != 1 or int(stream["nb_frames"]) != expected or abs(float(stream["duration"]) - expected) > 0.001 or abs(float(stream["start_time"])) > 0.001): raise ValueError(f"Expected a zero-based 1 FPS/{expected}-frame video: {path.name}") def decode_video(source, dest, expected): """Decode a validated video into ordered PNGs, replacing its frame cache.""" dest.parent.mkdir(parents=True, exist_ok=True) names = [f"frame_{i:03d}.png" for i in range(expected)] with tempfile.TemporaryDirectory(prefix=source.stem + "-", dir=dest.parent) as temp: temp = Path(temp) subprocess.run( ["ffmpeg", "-nostdin", "-v", "error", "-xerror", "-threads", "1", "-i", str(source), "-map", "0:v:0", "-vsync", "0", "-threads", "1", "-start_number", "0", str(temp / "frame_%03d.png")], check=True, capture_output=True, timeout=300, ) actual = sorted(p.name for p in temp.glob("*.png")) if actual != names or any((temp / name).stat().st_size == 0 for name in names): raise ValueError(f"Decoded frame count mismatch: {source.name}") if dest.exists(): shutil.rmtree(dest) temp.rename(dest) return expected def validate_frame_cache(root, record, video_info): """Check registered frame paths, order, byte sizes and PNG dimensions.""" video = video_info["path"] n = video_info["n_frames"] if (record["video"] != video or record["n_frames"] != n or record["fps"] != 1 or type(record["width"]) is not int or record["width"] <= 0 or type(record["height"]) is not int or record["height"] <= 0 or len(record["frames"]) != n): raise ValueError(f"Frame manifest does not match the video: {video}") directory = Path("runtime/frames") / Path(video).stem expected = [f"frame_{i:03d}.png" for i in range(n)] if sorted(p.name for p in (root / directory).glob("*.png")) != expected: raise ValueError(f"Cached frame count or filenames are incorrect: {video}") for i, frame in enumerate(record["frames"]): if frame["index"] != i or frame["path"] != str(directory / expected[i]): raise ValueError(f"Cached frame order is incorrect: {video}") path = relative_file(root, frame["path"]) if path.stat().st_size != frame["bytes"]: raise ValueError(f"Cached frame byte size mismatch: {frame['path']}") with path.open("rb") as handle: header = handle.read(24) if (len(header) != 24 or header[:8] != b"\x89PNG\r\n\x1a\n" or header[12:16] != b"IHDR" or struct.unpack(">II", header[16:24]) != (record["width"], record["height"])): raise ValueError(f"Cached PNG dimensions differ from frames.jsonl: {frame['path']}") def extract(root, output_dir, videos=None, workers=4): """Validate and decode registered videos; no QA or remote services required.""" protected = (root / "runtime/frames").resolve() output = output_dir.resolve() if output.is_relative_to(protected) or protected.is_relative_to(output): raise ValueError("Decoded MP4 frames must not overwrite the original-resolution benchmark frames") records = [json.loads(line) for line in (root / "media.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()] inventory = {record["path"]: record for record in records} if not inventory or len(inventory) != len(records): raise ValueError("Media inventory must be nonempty and contain unique paths") selected = list(dict.fromkeys(videos)) if videos else list(inventory) unknown = set(selected) - set(inventory) if unknown: raise ValueError(f"Videos absent from media.jsonl: {sorted(unknown)}") stems = [Path(path).stem for path in selected] if len(set(stems)) != len(stems): raise ValueError("Video filenames must have unique stems for frame directories") # Check destinations before starting any decode or replacing any frame cache. for relative in selected: source = relative_file(root, relative) dest = output_dir / source.stem if dest.is_symlink(): raise ValueError(f"Frame output must not be a symlink: {dest.name}") resolved = dest.resolve() if root.resolve().is_relative_to(resolved) or (root / "media").resolve().is_relative_to(resolved): raise ValueError("Frame output must not replace the dataset or media directory") def process(relative): source = relative_file(root, relative) record = inventory[relative] if record["fps"] != 1 or type(record["n_frames"]) is not int or record["n_frames"] < 1: raise ValueError(f"Expected 1 FPS and a positive frame count: {relative}") if source.stat().st_size != record["bytes"]: raise ValueError(f"Video byte size mismatch: {relative}") validate_video(source, record["n_frames"]) return decode_video(source, output_dir / source.stem, record["n_frames"]) with ThreadPoolExecutor(max_workers=workers) as pool: counts = list(pool.map(process, selected)) return {"videos": len(selected), "frames": sum(counts)} def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--data-root", type=Path, default=Path(__file__).resolve().parent) parser.add_argument("--output-dir", type=Path, help="Output directory; default: DATA_ROOT/runtime/decoded_frames") parser.add_argument("--video", action="append", help="A video path from media.jsonl, e.g. media/0000.mp4; repeat to select more") parser.add_argument("--workers", type=int, default=4) args = parser.parse_args() if args.workers < 1: parser.error("--workers must be positive") root = args.data_root.resolve() output = args.output_dir.resolve() if args.output_dir else root / "runtime/decoded_frames" print(json.dumps(extract(root, output, args.video, args.workers))) if __name__ == "__main__": main()