| |
| """Download source videos and reconstruct annotation-aligned Sekai2 clips.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import shutil |
| import subprocess |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| DEFAULT_FORMAT = ( |
| "bestvideo[height<=720][fps<=30]+bestaudio/" |
| "best[height<=720][fps<=30]" |
| ) |
|
|
|
|
| def run(command: list[str]) -> None: |
| subprocess.run(command, check=True) |
|
|
|
|
| def read_rows(path: Path, clip_ids: set[str], dataset: str | None, limit: int | None): |
| rows = [] |
| with path.open(encoding="utf-8-sig", newline="") as handle: |
| for row in csv.DictReader(handle): |
| if dataset and row["dataset"] != dataset: |
| continue |
| if clip_ids and row["clip_id"] not in clip_ids: |
| continue |
| rows.append(row) |
| if limit is not None and len(rows) >= limit: |
| break |
| if clip_ids: |
| found = {row["clip_id"] for row in rows} |
| missing = sorted(clip_ids - found) |
| if missing: |
| raise ValueError(f"clip_id not found: {missing}") |
| return rows |
|
|
|
|
| def find_cached_source(cache_dir: Path, video_id: str) -> Path | None: |
| candidates = [ |
| path |
| for path in cache_dir.glob(video_id + ".*") |
| if path.suffix not in {".json", ".part", ".ytdl"} |
| ] |
| return sorted(candidates)[0] if candidates else None |
|
|
|
|
| def download_source( |
| row: dict[str, str], cache_dir: Path, yt_dlp: str, format_selector: str |
| ) -> Path: |
| existing = find_cached_source(cache_dir, row["video_id"]) |
| if existing: |
| return existing |
| template = str(cache_dir / (row["video_id"] + ".%(ext)s")) |
| command = [ |
| yt_dlp, |
| "--no-playlist", |
| "--no-part", |
| "--write-info-json", |
| "--merge-output-format", |
| "mkv", |
| "-f", |
| format_selector, |
| "-o", |
| template, |
| row["url"], |
| ] |
| run(command) |
| downloaded = find_cached_source(cache_dir, row["video_id"]) |
| if downloaded is None: |
| raise RuntimeError(f"yt-dlp produced no media file for {row['video_id']}") |
| return downloaded |
|
|
|
|
| def reconstruct_one(row: dict[str, str], source: Path, output: Path, ffmpeg: str) -> None: |
| output.parent.mkdir(parents=True, exist_ok=True) |
| command = [ |
| ffmpeg, |
| "-y", |
| "-nostdin", |
| "-loglevel", |
| "error", |
| "-i", |
| str(source), |
| |
| "-ss", |
| row["start_time"], |
| "-t", |
| row["duration"], |
| "-map", |
| "0:v:0", |
| "-map", |
| "0:a:0?", |
| "-vf", |
| ( |
| f"fps={row['fps']}," |
| f"scale={row['frame_width']}:{row['frame_height']}:flags=lanczos" |
| ), |
| "-frames:v", |
| row["num_frames"], |
| "-fps_mode", |
| "cfr", |
| "-c:v", |
| "libx264", |
| "-preset", |
| "medium", |
| "-crf", |
| "18", |
| "-pix_fmt", |
| "yuv420p", |
| "-c:a", |
| "aac", |
| "-ar", |
| "48000", |
| "-ac", |
| "2", |
| "-movflags", |
| "+faststart", |
| str(output), |
| ] |
| run(command) |
|
|
|
|
| def probe_video(path: Path, ffprobe: str) -> dict[str, object]: |
| command = [ |
| ffprobe, |
| "-v", |
| "error", |
| "-select_streams", |
| "v:0", |
| "-count_frames", |
| "-show_entries", |
| "stream=width,height,avg_frame_rate,nb_read_frames", |
| "-of", |
| "json", |
| str(path), |
| ] |
| output = subprocess.run(command, check=True, capture_output=True, text=True).stdout |
| return json.loads(output)["streams"][0] |
|
|
|
|
| def validate_encoded(row: dict[str, str], output: Path, ffprobe: str) -> None: |
| stream = probe_video(output, ffprobe) |
| numerator, denominator = map(int, stream["avg_frame_rate"].split("/")) |
| fps = numerator / denominator |
| expected = { |
| "width": int(row["frame_width"]), |
| "height": int(row["frame_height"]), |
| "frames": int(row["num_frames"]), |
| } |
| actual = { |
| "width": int(stream["width"]), |
| "height": int(stream["height"]), |
| "frames": int(stream["nb_read_frames"]), |
| } |
| if actual != expected or abs(fps - float(row["fps"])) > 1e-6: |
| raise RuntimeError( |
| f"encoded verification failed for {output}: expected={expected}, " |
| f"actual={actual}, fps={fps}" |
| ) |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("manifest", type=Path) |
| parser.add_argument("--output-dir", type=Path, required=True) |
| parser.add_argument("--cache-dir", type=Path, required=True) |
| parser.add_argument("--clip-id", action="append", default=[]) |
| parser.add_argument("--dataset", choices=("sekai", "sekai2")) |
| parser.add_argument("--limit", type=int) |
| parser.add_argument("--format", default=DEFAULT_FORMAT) |
| parser.add_argument("--yt-dlp", default="yt-dlp") |
| parser.add_argument("--ffmpeg", default="ffmpeg") |
| parser.add_argument("--ffprobe", default="ffprobe") |
| parser.add_argument( |
| "--remove-source", |
| action="store_true", |
| help="Delete each cached source after all selected clips are reconstructed.", |
| ) |
| args = parser.parse_args() |
|
|
| for executable in (args.yt_dlp, args.ffmpeg, args.ffprobe): |
| if shutil.which(executable) is None: |
| raise RuntimeError(f"required executable not found: {executable}") |
|
|
| rows = read_rows(args.manifest, set(args.clip_id), args.dataset, args.limit) |
| if not rows: |
| raise RuntimeError("no perspective rows selected") |
| args.cache_dir.mkdir(parents=True, exist_ok=True) |
|
|
| grouped: dict[str, list[dict[str, str]]] = defaultdict(list) |
| for row in rows: |
| grouped[row["video_id"]].append(row) |
|
|
| for video_rows in grouped.values(): |
| source = download_source(video_rows[0], args.cache_dir, args.yt_dlp, args.format) |
| for row in video_rows: |
| output = args.output_dir / row["dataset"] / row["clip_id"] |
| reconstruct_one(row, source, output, args.ffmpeg) |
| validate_encoded(row, output, args.ffprobe) |
| print(f"OK {row['clip_id']} -> {output}") |
| if args.remove_source: |
| source.unlink() |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
