| |
| """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") |
| |
| 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() |
|
|
