Initial release

.gitattributes

@@ -0,0 +1,2 @@
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.mov filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,13 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright (c) 2026 The VSTAT Authors
+
+Annotations and self-recorded videos in this dataset are licensed under
+CC BY 4.0: https://creativecommons.org/licenses/by/4.0/
+
+Synthetic Blender-rendered videos are licensed under CC BY 4.0.
+
+YouTube videos referenced via URL/timestamp are NOT redistributed and
+remain under the original uploaders' licenses (typically Standard YouTube
+License). Users must download YouTube clips themselves and comply with
+YouTube's Terms of Service.

README.md

@@ -0,0 +1,212 @@
+---
+license: cc-by-4.0
+language:
+- en
+tags:
+- video
+- multimodal
+- benchmark
+- video-question-answering
+- visual-state-tracking
+size_categories:
+- 1K<n<10K
+---
+
+# VSTAT: Visual State Tracking Benchmark
+
+VSTAT is a video-based benchmark for evaluating the **visual state tracking**
+capability of Multimodal Large Language Models (MLLMs). It contains 813 video
+clips paired with 1,479 questions whose answers cannot be inferred from any
+single keyframe or short segment.
+
+## Dataset Composition
+
+| Split          | Videos | Questions |
+|----------------|-------:|----------:|
+| synthetic      |    450 |       550 |
+| self_recorded  |     80 |       100 |
+| youtube        |    283 |       830 |
+| **Total**      |  **813** |  **1,479** |
+
+## Files
+
+- `vstat_qa_clean.json` — all 1,479 question-answer pairs with taxonomy labels
+- `youtube_metadata.json` — YouTube URLs + start/end timestamps (one entry per chunk)
+- `youtube_resolutions.json` — per-clip target (W, H, fps) used by the
+  downloader to reproduce the official release pixel layout
+- `redactions.json` — declarative privacy-redaction regions applied after trim
+- `croissant.json` — Croissant 1.0 metadata (with RAI extension)
+- `scripts/download_youtube.py` — fetches & trims the 283 YouTube clips
+- `scripts/redact.sh` — applies the privacy black-boxes from `redactions.json`
+- `scripts/build_resolution_map.py` — utility to (re)build `youtube_resolutions.json`
+  from a reference render
+- `videos/synthetic/<category>/<id>.mp4` — Blender-rendered videos (hosted)
+- `videos/self_recorded/<category>/<id>.mp4` — author-recorded clips, hands only,
+  audio removed (hosted)
+- `videos/youtube/<category>/<id>.mp4` — **NOT redistributed**; you must
+  download these yourself with the provided script (see *Quick start* below)
+
+## Quick start
+
+### 1. Get the repo
+
+Pick whichever method you prefer:
+
+```bash
+# A. huggingface-cli (recommended, supports LFS)
+pip install -U "huggingface_hub[cli]"
+huggingface-cli download VSTAT-NeurIPS2026/VSTAT \
+  --repo-type=dataset \
+  --local-dir vstat
+cd vstat
+
+# B. git clone (requires git-lfs installed)
+git lfs install
+git clone https://huggingface.co/datasets/VSTAT-NeurIPS2026/VSTAT vstat
+cd vstat
+```
+
+After this, you have all annotations and the synthetic + self_recorded
+videos. The YouTube clips are still missing — fetch them next.
+
+### 2. Download and redact the YouTube clips
+
+The downloader reads `youtube_metadata.json` and downloads each source
+video once with `yt-dlp`, then trims it into the chunks expected by
+`vstat_qa_clean.json`. Pass `--resolution-map youtube_resolutions.json`
+so each chunk lands at the exact `(width, height, fps)` of the official
+release. After trimming, `scripts/redact.sh` applies the privacy
+black-boxes (matches `redactions.json`) to the affected clips in place.
+
+> **Important — reproducing the official release.** The benchmark
+> numbers in our paper were obtained on the clips produced by exactly
+> this two-step pipeline (`download_youtube.py --resolution-map …` →
+> `redact.sh`). The downloader picks the smallest YouTube format that
+> matches each clip's target dimensions and frame rate so the trim
+> avoids any resampling drift. Skip the resolution map only for
+> ablations on input resolution.
+
+```bash
+# Install dependencies
+pip install -U yt-dlp
+# macOS:    brew install ffmpeg
+# Ubuntu:   sudo apt install ffmpeg
+
+# 1. Fetch and trim every YouTube clip to its release-spec dims
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json
+
+# 2. Apply privacy redactions in place (idempotent)
+bash scripts/redact.sh
+```
+
+Common flags for the downloader:
+
+```bash
+# Faster: 4 parallel downloads
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --workers 4
+
+# Test on a few videos first
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --limit 5
+
+# Keep the full source videos around (faster re-trim, more disk)
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --keep-fulls
+
+# Print plan without doing anything
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --dry-run
+
+# Cap source download size (default uncapped — required for portrait sources)
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --source-cap 1080
+```
+
+Re-running the downloader is safe: it skips clips that already exist
+on disk and writes a `download_report.json` listing any failures (rare,
+usually due to YouTube link rot — affected clips can be reported to
+the authors via the dataset issue tracker). Re-running `redact.sh` is
+also idempotent and replaces any earlier redaction with the canonical
+set defined in `redactions.json`.
+
+### 3. Load the data
+
+```python
+import json
+
+with open("vstat_qa_clean.json") as f:
+    data = json.load(f)
+
+for cat, entries in data["data"].items():
+    for e in entries:
+        print(e["video_id"], e["video_path"], e["video_source"])
+```
+
+Each entry has these fields:
+
+| Field                      | Description                                                 |
+|----------------------------|-------------------------------------------------------------|
+| `video_id`                 | Unique identifier (e.g. `0001_pt1_q1`)                      |
+| `video_path`               | Relative path under `videos/`                               |
+| `video_source`             | `synthetic` / `self_recorded` / `youtube`                   |
+| `source_task`              | Coarse category (e.g. `basketball`, `dice`, `shell_game`)   |
+| `question`                 | Question text. For MCQ items, choices are inline `(A)(B)…`  |
+| `answer_type`              | `mcq` or `numeric`                                          |
+| `answer`                   | Letter (`A`/`B`/`C`/`D`) for MCQ; integer for numeric       |
+| `choices`                  | List of MCQ option strings (empty for numeric)              |
+| `answer_index`             | 0-based index into `choices` (null for numeric)             |
+| `perceptual_complexity`    | List of perceptual challenge tags (see Taxonomy)            |
+| `state_element_type`       | `count` / `location` / `attribute`                          |
+| `state_structure`          | `atomic` / `sequence` / `set` / `dictionary`                |
+| `youtube_url`, `youtube_id`, `start_time`, `end_time`, `start_sec`, `end_sec` | Present only for `video_source == "youtube"` |
+
+### 4. Run an evaluation
+
+A minimal MCQ scoring loop (numeric questions are scored with mean
+relative accuracy in our paper; see Section 3.1 for details):
+
+```python
+def score(entry, model_pred):
+    if entry["answer_type"] == "mcq":
+        return int(model_pred.strip().upper() == entry["answer"])
+    # numeric
+    try:
+        return int(int(model_pred) == int(entry["answer"]))
+    except ValueError:
+        return 0
+```
+
+## Taxonomy
+
+Each question is annotated with:
+
+- `perceptual_complexity` (multi-label, paper Section 2.2):
+  `action_ambiguity`, `camera_motion`, `homogeneity`,
+  `multi_entity_attribution`, `occlusion`, `symbolic_decoding`
+- `state_element_type` (single label): `count`, `location`, `attribute`
+- `state_structure` (single label): `atomic`, `sequence`, `set`, `dictionary`
+
+## License
+
+- Annotations and self-recorded / synthetic videos: **CC BY 4.0**
+- YouTube videos: NOT redistributed; subject to original uploader's license
+- See `LICENSE` for full terms
+
+## Privacy & consent
+
+- Self-recorded videos contain only the authors' hands; no faces, voices,
+  or other identifiable persons. Audio tracks were stripped before release.
+- Authors consented to public release of their hand footage.
+- For YouTube clips, only URLs and timestamps are redistributed; original
+  uploaders retain control over their content. The `redact.sh` step
+  applies black-boxes over scoreboards / on-screen text in a small
+  number of clips per `redactions.json`, matching the official release.
+
+## Citation
+
+```bibtex
+@inproceedings{vstat2026,
+  title={Benchmarking State Tracking in Multimodal Video Understanding},
+  author={Anonymous},
+  booktitle={NeurIPS 2026 Datasets and Benchmarks Track},
+  year={2026}
+}
+```
+
+*This is a NeurIPS 2026 anonymous submission. Author names will be added upon acceptance.*

croissant.json

@@ -0,0 +1,318 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "citeAs": "cr:citeAs",
+    "column": "cr:column",
+    "conformsTo": "dct:conformsTo",
+    "cr": "http://mlcommons.org/croissant/",
+    "rai": "http://mlcommons.org/croissant/RAI/",
+    "data": {
+      "@id": "cr:data",
+      "@type": "@json"
+    },
+    "dataType": {
+      "@id": "cr:dataType",
+      "@type": "@vocab"
+    },
+    "dct": "http://purl.org/dc/terms/",
+    "examples": {
+      "@id": "cr:examples",
+      "@type": "@json"
+    },
+    "extract": "cr:extract",
+    "field": "cr:field",
+    "fileProperty": "cr:fileProperty",
+    "fileObject": "cr:fileObject",
+    "fileSet": "cr:fileSet",
+    "format": "cr:format",
+    "includes": "cr:includes",
+    "isLiveDataset": "cr:isLiveDataset",
+    "jsonPath": "cr:jsonPath",
+    "key": "cr:key",
+    "md5": "cr:md5",
+    "parentField": "cr:parentField",
+    "path": "cr:path",
+    "recordSet": "cr:recordSet",
+    "references": "cr:references",
+    "regex": "cr:regex",
+    "repeated": "cr:repeated",
+    "replace": "cr:replace",
+    "sc": "https://schema.org/",
+    "separator": "cr:separator",
+    "source": "cr:source",
+    "subField": "cr:subField",
+    "transform": "cr:transform",
+    "prov": "http://www.w3.org/ns/prov#"
+  },
+  "@type": "sc:Dataset",
+  "conformsTo": [
+    "http://mlcommons.org/croissant/1.0",
+    "http://mlcommons.org/croissant/RAI/1.0"
+  ],
+  "name": "VSTAT",
+  "alternateName": "Visual State Tracking Benchmark",
+  "description": "VSTAT is a video-based benchmark designed to diagnose visual state tracking in Multimodal Large Language Models (MLLMs). It contains 813 video clips drawn from synthetic (rendered with Blender), self-recorded, and YouTube sources, paired with 1479 questions whose answers cannot be inferred from any single keyframe or short segment, requiring continuous perception and integration of events across the entire video stream. Each question is annotated with perceptual complexity (occlusion, camera_motion, homogeneity, symbolic_decoding, multi_entity_attribution, action_ambiguity) and state complexity (element_type in count/location/attribute and structure in atomic/sequence/set/dictionary).",
+  "version": "1.0",
+  "datePublished": "2026-05-04",
+  "license": "https://creativecommons.org/licenses/by/4.0/",
+  "citeAs": "@inproceedings{vstat2026, title={Benchmarking State Tracking in Multimodal Video Understanding}, author={Anonymous}, booktitle={NeurIPS 2026 Datasets and Benchmarks Track}, year={2026}}",
+  "url": "https://huggingface.co/datasets/VSTAT-NeurIPS2026/VSTAT",
+  "keywords": [
+    "video understanding",
+    "multimodal large language models",
+    "visual state tracking",
+    "video question answering",
+    "benchmark"
+  ],
+  "isLiveDataset": true,
+  "rai:dataCollection": "Videos were collected from three sources: (1) 450 synthetic clips rendered in Blender across 9 procedural environments; (2) 80 clips self-recorded by the authors (only authors' hands appear; no other identifiable persons); (3) 283 clips collected from publicly available YouTube videos. For YouTube videos, only URLs and timestamps are redistributed; users must download the videos themselves using the provided script.",
+  "rai:dataCollectionType": [
+    "Synthetic data",
+    "Manual Human Curator",
+    "Web-Scraping (URLs only)"
+  ],
+  "rai:dataCollectionRawData": "MP4 video files (synthetic and self-recorded); URL+timestamp metadata for YouTube clips.",
+  "rai:dataCollectionTimeframe": "2025-10 to 2026-04",
+  "rai:dataAnnotationProtocol": "Each video-question pair was authored by the research team. Questions are designed to require visual state tracking that cannot be solved from a single keyframe. Questions and answers underwent multi-round human-in-the-loop review.",
+  "rai:dataAnnotationPlatform": "Custom internal spreadsheet-based review with shared annotator pool.",
+  "rai:dataAnnotationAnalysis": "Each question was independently verified by a human author (not the original writer) for answerability. Questions humans could not answer were excluded. Answers also cross-checked against video evidence to ensure correctness.",
+  "rai:dataReleaseMaintenancePlan": "Annotations and synthetic/self-recorded videos will be hosted on a public platform (e.g., Hugging Face Datasets). YouTube URLs will be re-validated periodically; broken links will be flagged in a public errata. Versioned releases will follow semantic versioning.",
+  "rai:personalSensitiveInformation": "Self-recorded videos include only the authors' hands performing tasks; no faces, voices, or other identifiable personal information are included. Authors consented to public release. Synthetic videos contain no personal information. YouTube videos may incidentally depict identifiable persons in public sporting or performance contexts; the dataset only redistributes URLs/timestamps, never the video content.",
+  "rai:dataConsent": "All identifiable persons in self-recorded videos are authors of this dataset and have consented to public release. YouTube content is referenced under fair use for academic research; no YouTube content is redistributed.",
+  "rai:dataUseCases": "Intended for evaluating the visual state tracking capability of MLLMs. Proper use cases include benchmarking video-language models, diagnosing perception vs. reasoning failures, and studying continuous video understanding.",
+  "rai:dataBiases": "Synthetic videos use a fixed set of 9 Blender environments with limited visual diversity. Self-recorded clips reflect the authors' physical setup and lighting conditions.",
+  "rai:dataLimitations": "(1) YouTube clip availability depends on uploader retention; some links may rot over time. (2) Question difficulty is calibrated by author judgment rather than psychometric methods. (3) The benchmark currently focuses on English-language questions only.",
+  "distribution": [
+    {
+      "@type": "cr:FileObject",
+      "@id": "annotations-json",
+      "name": "vstat_qa_clean.json",
+      "description": "All 1479 questions with per-entry video paths, answer, video_source, perceptual_complexity, state_element_type, state_structure, and source_task labels.",
+      "contentUrl": "https://huggingface.co/datasets/VSTAT-NeurIPS2026/VSTAT/resolve/main/vstat_qa_clean.json",
+      "encodingFormat": "application/json",
+      "sha256": "9f0bf313e4a14106a88bccaf5d649f9721924ff802d252f45eff515727bcb139",
+      "contentSize": "1281200 B"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "videos-synthetic",
+      "name": "videos-synthetic",
+      "description": "450 Blender-rendered video clips.",
+      "encodingFormat": "video/mp4",
+      "includes": "videos/synthetic/*/*.mp4"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "videos-self-recorded",
+      "name": "videos-self-recorded",
+      "description": "80 author-recorded clips (hands-only, no other identifiable persons).",
+      "encodingFormat": "video/mp4",
+      "includes": "videos/self_recorded/*/*.mp4"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "youtube-metadata",
+      "name": "youtube_metadata.json",
+      "description": "Per-chunk YouTube URLs and timestamps. VSTAT does NOT host these videos.",
+      "contentUrl": "https://huggingface.co/datasets/VSTAT-NeurIPS2026/VSTAT/resolve/main/youtube_metadata.json",
+      "encodingFormat": "application/json"
+    }
+  ],
+  "recordSet": [
+    {
+      "@type": "cr:RecordSet",
+      "@id": "questions",
+      "name": "questions",
+      "description": "One record per video-question pair (1479 total).",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "questions/video_id",
+          "name": "video_id",
+          "description": "Identifier for the video-question pair.",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].video_id"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/video_path",
+          "name": "video_path",
+          "description": "Relative path to the MP4 file.",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].video_path"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/video_source",
+          "name": "video_source",
+          "description": "Source of the video: synthetic | self_recorded | youtube.",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].video_source"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/source_task",
+          "name": "source_task",
+          "description": "The task category (e.g., basketball, dice, shell_game).",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].source_task"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/question",
+          "name": "question",
+          "description": "The question text. For MCQ, choices are inline (A)(B)(C)(D).",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].question"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/answer_type",
+          "name": "answer_type",
+          "description": "mcq | numeric.",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].answer_type"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/answer",
+          "name": "answer",
+          "description": "Ground-truth answer. For MCQ: a letter (A/B/C/D/E). For numeric: int.",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].answer"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/choices",
+          "name": "choices",
+          "description": "List of MCQ option strings (omitted for numeric).",
+          "dataType": "sc:Text",
+          "repeated": true,
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].choices"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/answer_index",
+          "name": "answer_index",
+          "description": "0-based index into choices for the correct MCQ answer.",
+          "dataType": "sc:Integer",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].answer_index"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/perceptual_complexity",
+          "name": "perceptual_complexity",
+          "description": "Multi-label perceptual complexity tags (paper Section 2.2).",
+          "dataType": "sc:Text",
+          "repeated": true,
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].perceptual_complexity"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/state_element_type",
+          "name": "state_element_type",
+          "description": "count | location | attribute (paper Section 2.2).",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].state_element_type"
+            }
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "questions/state_structure",
+          "name": "state_structure",
+          "description": "atomic | sequence | set | dictionary (paper Section 2.2).",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "annotations-json"
+            },
+            "extract": {
+              "jsonPath": "$.data.*[*].state_structure"
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "rai:hasSyntheticData": true,
+  "rai:dataSocialImpact": "Positive impact: VSTAT will facilitate research on visual state tracking in MLLMs, contributing to more reliable multimodal AI systems for real-world applications such as robotics, sports analytics, and instructional video understanding. It enables fine-grained diagnosis of perception vs. reasoning failures and provides an in-the-wild evaluation alternative to benchmarks dominated by single-keyframe shortcuts. Potential negative impact: (1) Overfitting to the benchmark's specific question formats could lead to brittle models that do not generalize; (2) Like any video benchmark, results may be misinterpreted as a measure of general video understanding when VSTAT specifically targets state tracking. Mitigations: (a) The dataset is intended for evaluation only, not training; (b) Per-question taxonomy labels (perceptual_complexity, state_element_type, state_structure) enable fine-grained reporting that surfaces failure modes rather than a single aggregate number; (c) Documented limitations and biases in this Croissant file and the accompanying paper; (d) CC BY 4.0 license requires attribution for derived analyses; (e) YouTube clips are referenced via URL only — original uploaders retain control over their content.",
+  "rai:dataSources": "VSTAT is not derived from any pre-existing dataset. Source provenance: (1) Synthetic split (450 clips): custom procedural scenes generated in Blender; per-video random seeds and full simulation parameters stored alongside each clip (see videos/synthetic/<category>/<id>.json in the per-video metadata); (2) Self-recorded split (80 clips): original footage captured by the authors of this submission; not previously released; (3) YouTube split (283 clips): publicly available YouTube videos referenced by URL and timestamp (see youtube_metadata.json). The dataset does not redistribute the YouTube videos themselves; users download via the provided script. Each YouTube clip remains under its original uploader's license.",
+  "rai:dataProvenance": "Collection activities: (a) Synthetic videos rendered at 24 FPS for ~20 seconds via custom Blender scripts authored by the research team; per-clip random seeds documented in per-video JSONs. (b) Self-recorded videos captured by authors with consumer cameras in their own work environment; only authors' hands appear, no other identifiable persons. (c) YouTube clips identified by authors browsing for procedural/dynamic content matching the perceptual challenge taxonomy; long videos manually segmented into shorter chunks with start/end timestamps. Preprocessing activities: synthetic videos saved as MP4; YouTube clips referenced by URL+timestamp without modification (no re-encoding). Annotation activities: questions authored by the research team using a shared spreadsheet-based platform. Each question independently verified by a different team member for answerability; questions that humans could not answer were excluded (397 of 1877 candidate items removed by this filter). Each question labeled with perceptual_complexity (multi-label), state_element_type (single label), and state_structure (single label) per the taxonomy described in the paper Section 2.2. No external annotators or paid crowd workers were involved."
+}

redactions.json

@@ -0,0 +1,37 @@
+{
+  "description": "Per-source-video privacy redactions applied to YouTube clips. Coordinates are in the OUTPUT resolution (640x360, the official VSTAT release spec). Each redaction draws a solid black box (drawbox filter, t=fill) over the listed region in every chunk of the matching source video.",
+  "coordinate_space": "640x360 (post-scale)",
+  "redactions": [
+    {
+      "match": {"category": "tennis", "local_id": "0001"},
+      "boxes": [
+        {"x": 32, "y": 306, "w": 134, "h": 38}
+      ]
+    },
+    {
+      "match": {"category": "tennis", "local_id": "0002"},
+      "boxes": [
+        {"x": 32, "y": 306, "w": 134, "h": 38}
+      ]
+    },
+    {
+      "match": {"category": "basketball", "local_id": "0002"},
+      "boxes": [
+        {"x": 98, "y": 323, "w": 443, "h": 37}
+      ]
+    },
+    {
+      "match": {"category": "basketball", "local_id": "0003"},
+      "boxes": [
+        {"x": 22, "y": 285, "w": 125, "h": 63}
+      ]
+    },
+    {
+      "match": {"category": "soccer", "local_id": "0002"},
+      "boxes": [
+        {"x": 0,   "y": 0,   "w": 122, "h": 19},
+        {"x": 140, "y": 320, "w": 360, "h": 40}
+      ]
+    }
+  ]
+}

scripts/build_resolution_map.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Build a per-clip resolution map from an existing render of `videos/youtube/`.
+
+Walks a reference directory laid out like `<ref>/<category>/<file>.mp4`,
+runs ffprobe on each clip, and writes a JSON map keyed by
+`videos/youtube/<category>/<file>.mp4` (matching `video_path` in
+`youtube_metadata.json`). The map is consumed by `download_youtube.py
+--resolution-map` to reproduce the exact width/height/fps of each clip.
+
+Usage:
+    python scripts/build_resolution_map.py ~/Desktop/ytb/processed
+    python scripts/build_resolution_map.py REF_DIR -o youtube_resolutions.json
+"""
+from __future__ import annotations
+import argparse
+import json
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+
+def probe(path: Path) -> dict | None:
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-select_streams", "v:0",
+             "-show_entries", "stream=width,height,r_frame_rate",
+             "-show_entries", "format=duration",
+             "-of", "json", str(path)],
+            capture_output=True, text=True, check=True, timeout=30,
+        ).stdout
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return None
+    try:
+        info = json.loads(out)
+    except json.JSONDecodeError:
+        return None
+    s = (info.get("streams") or [{}])[0]
+    f = info.get("format", {})
+    fr = s.get("r_frame_rate", "0/1")
+    try:
+        n, d = (int(x) for x in fr.split("/"))
+        fps = round(n / d, 4) if d else None
+    except ValueError:
+        fps = None
+    if not (s.get("width") and s.get("height")):
+        return None
+    return {
+        "width": int(s["width"]),
+        "height": int(s["height"]),
+        "fps": fps,
+        "duration": round(float(f["duration"]), 4) if f.get("duration") else None,
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("ref_dir", help="reference directory (e.g. ~/Desktop/ytb/processed)")
+    ap.add_argument("-o", "--out", default="youtube_resolutions.json",
+                    help="output JSON path (default: youtube_resolutions.json)")
+    ap.add_argument("--workers", type=int, default=8)
+    args = ap.parse_args()
+
+    ref = Path(args.ref_dir).expanduser()
+    if not ref.is_dir():
+        sys.exit(f"ERROR: {ref} is not a directory")
+
+    paths = sorted(ref.glob("*/*.mp4"))
+    print(f"probing {len(paths)} files under {ref}…", file=sys.stderr)
+
+    out: dict[str, dict] = {}
+    bad: list[str] = []
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
+        for p, info in zip(paths, ex.map(probe, paths)):
+            key = f"videos/youtube/{p.parent.name}/{p.name}"
+            if info is None:
+                bad.append(key)
+                continue
+            out[key] = info
+
+    out_path = Path(args.out)
+    out_path.write_text(json.dumps(out, indent=2, sort_keys=True))
+    print(f"wrote {out_path} ({len(out)} entries; {len(bad)} probe failures)",
+          file=sys.stderr)
+    if bad:
+        print("  failures:", *bad[:10], "…" if len(bad) > 10 else "", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/download_youtube.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+"""
+VSTAT — YouTube clip downloader
+
+Reads `youtube_metadata.json` and, for each entry, downloads the source
+YouTube video (with yt-dlp) and extracts the specified time range
+(with ffmpeg) into the `videos/youtube/<category>/<id>.mp4` path
+expected by `vstat_qa_clean.json`.
+
+Resolution handling:
+    --height H            scale every clip to height H, width preserves aspect
+                          (default 360 → 640x360 for 16:9; ≈202x360 for 9:16).
+    --resolution-map FILE preferred per-clip exact-match mode. Reads a JSON
+                          map (built by `scripts/build_resolution_map.py`)
+                          keyed by `videos/youtube/<cat>/<file>.mp4` with
+                          {"width", "height", "fps"} per entry, and scales
+                          each trim to exactly W×H@fps.
+    --reference-dir DIR   live alternative to --resolution-map: for each
+                          clip we probe DIR/<cat>/<file>.mp4 directly. Use
+                          --resolution-map when possible (no per-run probe).
+    --source-cap N        in reference mode, cap yt-dlp source download to
+                          height ≤ N. Default is uncapped so portrait
+                          sources (whose pixel height is the long side) are
+                          still selectable; ffmpeg always downscales the
+                          source to the exact per-clip target.
+
+Usage:
+    python download_youtube.py
+    python download_youtube.py --metadata youtube_metadata.json --out videos/youtube
+    python download_youtube.py --workers 4
+    python download_youtube.py --keep-fulls   # keep full source videos in cache/
+    python download_youtube.py --dry-run
+
+    # Reproduce per-video resolutions from a saved map (preferred):
+    python scripts/build_resolution_map.py ~/Desktop/ytb/processed \
+        -o youtube_resolutions.json
+    python download_youtube.py --resolution-map youtube_resolutions.json
+
+    # Or probe a reference tree live:
+    python download_youtube.py --reference-dir ~/Desktop/ytb/processed
+
+Requirements:
+    yt-dlp  (pip install -U yt-dlp)
+    ffmpeg  (system: brew install ffmpeg / apt install ffmpeg)
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from pathlib import Path
+
+# ---------- helpers ----------
+
+def have(cmd: str) -> bool:
+    return shutil.which(cmd) is not None
+
+def hms_to_sec(s) -> float | None:
+    if s is None:
+        return None
+    s = str(s).strip()
+    if not s or s.lower() in ("none", "null", "n/a"):
+        return None
+    parts = s.split(":")
+    try:
+        parts = [float(p) for p in parts]
+    except ValueError:
+        return None
+    if len(parts) == 3:  return parts[0]*3600 + parts[1]*60 + parts[2]
+    if len(parts) == 2:  return parts[0]*60 + parts[1]
+    if len(parts) == 1:  return parts[0]
+    return None
+
+def log(msg: str, prefix: str = ""):
+    print(f"{prefix}{msg}", flush=True)
+
+def probe_resolution(path: Path) -> tuple[int, int, float] | None:
+    """Return (width, height, fps) of `path`'s first video stream, or None."""
+    if not path.exists():
+        return None
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-select_streams", "v:0",
+             "-show_entries", "stream=width,height,r_frame_rate",
+             "-of", "default=nw=1:nk=1", str(path)],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip().splitlines()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+    if len(out) < 3:
+        return None
+    try:
+        w, h = int(out[0]), int(out[1])
+        n, d = out[2].split("/")
+        fps = float(n) / float(d) if float(d) else 0.0
+    except (ValueError, ZeroDivisionError):
+        return None
+    return w, h, fps
+
+# ---------- core operations ----------
+
+def download_full(youtube_url: str, dst: Path, max_height: int | None = 360,
+                  max_fps: int | None = None,
+                  retries: int = 3) -> tuple[bool, str]:
+    """Download the full source video to dst (mp4).
+
+    If max_height is given, picks the best stream with pixel height <=
+    max_height. If max_height is None, picks bestvideo+bestaudio with no
+    cap — required when the target is a portrait clip whose source is
+    served by YouTube at a height (long side) larger than the clip target.
+
+    If max_fps is given, also constrains source fps <= max_fps. Important
+    when the target clip is e.g. 30fps but YouTube has a 60fps version of
+    the source: ffmpeg's fps-drop chooses different keyframes than the
+    reference pipeline, causing visible per-frame drift. Matching source
+    fps eliminates that drift.
+
+    Idempotent — skips if dst already exists."""
+    if dst.exists() and dst.stat().st_size > 0:
+        return True, "cached"
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    h = f"[height<={max_height}]" if max_height is not None else ""
+    f = f"[fps<={max_fps}]" if max_fps is not None else ""
+    if not h and not f:
+        fmt = (
+            "bestvideo[ext=mp4]+bestaudio[ext=m4a]/"
+            "best[ext=mp4]/"
+            "bestvideo+bestaudio/best"
+        )
+    else:
+        fmt = (
+            f"bestvideo[ext=mp4]{h}{f}+bestaudio[ext=m4a]/"
+            f"best[ext=mp4]{h}{f}/"
+            f"bestvideo{h}{f}+bestaudio/"
+            f"best{h}{f}/best{h}/best"
+        )
+    cmd = [
+        "yt-dlp",
+        "-f", fmt,
+        "--merge-output-format", "mp4",
+        "--no-playlist",
+        "-q",
+        "--no-warnings",
+        "-o", str(dst),
+        youtube_url,
+    ]
+    last_err = ""
+    for attempt in range(1, retries + 1):
+        res = subprocess.run(cmd, capture_output=True, text=True)
+        if res.returncode == 0 and dst.exists() and dst.stat().st_size > 0:
+            return True, f"downloaded (attempt {attempt})"
+        last_err = (res.stderr or res.stdout or "")[:200]
+        time.sleep(2 * attempt)
+    return False, f"yt-dlp failed: {last_err}"
+
+def trim_clip(src: Path, dst: Path, start_sec: float, end_sec: float | None,
+              target_height: int = 360,
+              target_width: int | None = None,
+              target_fps: float | None = None,
+              source_dims: tuple[int, int] | None = None) -> tuple[bool, str]:
+    """Cut [start, end) from src to dst, re-encoded to H.264.
+
+    If source_dims == (target_width, target_height), no scale/crop filter
+    is applied — letting ffmpeg do a straight decode→encode preserves frame
+    alignment with reference pipelines that also avoided rescaling.
+    Otherwise we centre-crop to the target's aspect ratio and scale to W×H."""
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists() and dst.stat().st_size > 0:
+        return True, "cached"
+    skip_scale = (
+        target_width is not None
+        and source_dims is not None
+        and source_dims == (target_width, target_height)
+    )
+    vf_parts: list[str] = []
+    if target_width and not skip_scale:
+        # Center-crop source to the target's aspect ratio first, then scale.
+        # When source aspect already matches target aspect the crop is a
+        # no-op (the crop expression yields the full source dims). When
+        # they differ — e.g. landscape source → square output — this
+        # matches ytb/processed which centre-crops before resizing.
+        W, H = target_width, target_height
+        vf_parts.append(f"crop=min(iw\\,ih*{W}/{H}):min(ih\\,iw*{H}/{W})")
+        vf_parts.append(f"scale={W}:{H}")
+    elif not target_width:
+        vf_parts.append(f"scale=-2:{target_height}")
+    if target_fps and target_fps > 0 and not skip_scale:
+        vf_parts.append(f"fps={target_fps}")
+    vf = ",".join(vf_parts)
+    # Match ytb/processed pipeline: -ss BEFORE -i (fast seek), default video
+    # encoder (libx264 preset=medium crf=23 profile=high, ffmpeg's defaults),
+    # no -movflags +faststart, audio dropped (-an) since the original scraper
+    # pulled video-only mp4 in most cases.
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", "-nostdin",
+           "-ss", f"{start_sec:.3f}",
+           "-i", str(src)]
+    if end_sec is not None and end_sec > start_sec:
+        cmd += ["-t", f"{end_sec - start_sec:.3f}"]
+    if vf:
+        cmd += ["-vf", vf]
+    cmd += ["-an", str(dst)]
+    res = subprocess.run(cmd, capture_output=True, text=True)
+    ok = res.returncode == 0 and dst.exists() and dst.stat().st_size > 0
+    return ok, "trimmed" if ok else f"ffmpeg failed: {(res.stderr or '')[:200]}"
+
+# ---------- pipeline ----------
+
+def process_video_group(
+    yt_id: str,
+    yt_url: str,
+    chunks: list[dict],
+    out_root: Path,
+    cache_dir: Path,
+    keep_fulls: bool,
+    dry_run: bool,
+    target_height: int = 360,
+    reference_dir: Path | None = None,
+    resolution_map: dict[str, dict] | None = None,
+    source_cap: int | None = None,
+) -> dict:
+    """Download one YouTube video then trim all its chunks.
+
+    Per-clip target (W, H, fps) lookup precedence:
+      1. resolution_map[<video_path>]            (preferred — saved JSON)
+      2. probe of reference_dir/<rel>.mp4         (live ffprobe fallback)
+      3. (None, target_height, None)              (default --height behaviour)
+
+    Source download (per yt_id):
+      - default mode (no map / no ref): cap at --height (legacy behaviour).
+      - reference mode: cap at source_cap if set, else uncapped (so portrait
+        sources whose pixel height is much larger than the clip target are
+        still selectable). ffmpeg downscales to the exact target W×H."""
+    full_path = cache_dir / f"{yt_id}.mp4"
+    result = {"youtube_id": yt_id, "url": yt_url,
+              "n_chunks": len(chunks), "ok": 0, "fail": 0, "errors": []}
+
+    ref_mode = resolution_map is not None or reference_dir is not None
+
+    # Resolve per-clip resolution targets.
+    per_clip: list[tuple[dict, int | None, int, float | None]] = []
+    for ch in chunks:
+        ref_w = ref_h = None
+        ref_fps = None
+        vp = ch["video_path"]
+        if resolution_map is not None and vp in resolution_map:
+            entry = resolution_map[vp]
+            ref_w = int(entry["width"])
+            ref_h = int(entry["height"])
+            ref_fps = float(entry["fps"]) if entry.get("fps") else None
+        elif reference_dir is not None:
+            rel = vp.replace("videos/youtube/", "")
+            probed = probe_resolution(reference_dir / rel)
+            if probed is not None:
+                ref_w, ref_h, ref_fps = probed
+        if ref_h is not None:
+            per_clip.append((ch, ref_w, ref_h, ref_fps))
+        else:
+            per_clip.append((ch, None, target_height, None))
+
+    # Source download cap.
+    if ref_mode:
+        if source_cap is not None:
+            dl_cap = source_cap
+        else:
+            # Pick the smallest YouTube tier that still fits all per-clip
+            # target heights for this yt_id. Picking a tier larger than
+            # needed forces ffmpeg to downscale and introduces sub-pixel
+            # drift in action scenes (basketball, soccer); matching the
+            # tier exactly lets us trim without rescaling.
+            target_heights = [h for _, _, h, _ in per_clip if h]
+            dl_cap = max(target_heights) if target_heights else target_height
+    else:
+        dl_cap = target_height
+    # FPS cap: ceil of max per-clip target fps, so yt-dlp picks a source
+    # whose native fps matches the trim — avoids drift from frame-dropping
+    # a 60fps source down to a 30fps target.
+    fps_cap: int | None = None
+    if ref_mode:
+        target_fpses = [fps for _, _, _, fps in per_clip if fps and fps > 0]
+        if target_fpses:
+            import math
+            fps_cap = math.ceil(max(target_fpses))
+
+    if dry_run:
+        cap_str = f"<= {dl_cap}p" if dl_cap is not None else "uncapped"
+        fps_str = f", <= {fps_cap}fps" if fps_cap is not None else ""
+        log(f"[DRY] would download {yt_url} (source {cap_str}{fps_str}) -> {full_path} "
+            f"({len(chunks)} chunks)")
+        for ch, w, h, fps in per_clip:
+            tgt = f"{w or '-2'}×{h}" + (f"@{fps:.3f}fps" if fps else "")
+            log(f"  [DRY]   {ch['video_path']} -> {tgt}")
+        return result
+
+    ok, msg = download_full(yt_url, full_path, max_height=dl_cap, max_fps=fps_cap)
+    if not ok:
+        result["fail"] = len(chunks)
+        result["errors"].append(f"download: {msg}")
+        log(f"[FAIL] {yt_id}: {msg}")
+        return result
+    cap_str = f"<= {dl_cap}p" if dl_cap is not None else "uncapped"
+    log(f"[OK ] downloaded {yt_id} ({msg}); trimming {len(chunks)} chunks "
+        f"(source {cap_str})")
+
+    src_probe = probe_resolution(full_path)
+    src_dims = (src_probe[0], src_probe[1]) if src_probe else None
+
+    for ch, ref_w, ref_h, ref_fps in per_clip:
+        rel = ch["video_path"]                          # videos/youtube/<cat>/<id>.mp4
+        dst = out_root / rel.replace("videos/youtube/", "")
+        start = ch.get("start_sec")
+        end   = ch.get("end_sec")
+        if start is None:
+            start = hms_to_sec(ch.get("start_time")) or 0.0
+        if end is None:
+            end = hms_to_sec(ch.get("end_time"))
+        ok, msg = trim_clip(
+            full_path, dst, start, end,
+            target_height=ref_h,
+            target_width=ref_w,
+            target_fps=ref_fps,
+            source_dims=src_dims,
+        )
+        if ok:
+            result["ok"] += 1
+        else:
+            result["fail"] += 1
+            result["errors"].append(f"{rel}: {msg}")
+            log(f"  [FAIL] {rel}: {msg}")
+
+    # Optionally drop the full video to save space.
+    if not keep_fulls:
+        try:
+            full_path.unlink()
+        except FileNotFoundError:
+            pass
+
+    return result
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--metadata", default="youtube_metadata.json",
+                    help="path to youtube_metadata.json")
+    ap.add_argument("--out", default="videos/youtube",
+                    help="output root for trimmed clips (videos/youtube)")
+    ap.add_argument("--cache", default=".cache/full_videos",
+                    help="where to cache downloaded full videos")
+    ap.add_argument("--workers", type=int, default=2,
+                    help="parallel YouTube downloads (1 video at a time per worker)")
+    ap.add_argument("--height", type=int, default=360,
+                    help="target video height in pixels; both yt-dlp format "
+                         "selection and ffmpeg re-encode use this. VSTAT's "
+                         "original release used 360 (640x360). Default: 360")
+    ap.add_argument("--resolution-map", default=None,
+                    help="path to a JSON resolution map "
+                         "(see scripts/build_resolution_map.py). Each entry "
+                         "is keyed by `videos/youtube/<cat>/<file>.mp4` with "
+                         "{'width','height','fps'}. Clips found in the map "
+                         "are scaled to that exact W×H@fps; others fall "
+                         "back to --height.")
+    ap.add_argument("--reference-dir", default=None,
+                    help="live alternative to --resolution-map: directory "
+                         "laid out like videos/youtube/. Each run re-probes "
+                         "with ffprobe. Prefer --resolution-map.")
+    ap.add_argument("--source-cap", type=int, default=None,
+                    help="in reference mode, cap source-download height to N "
+                         "(default uncapped — required for portrait sources).")
+    ap.add_argument("--keep-fulls", action="store_true",
+                    help="keep full source videos in cache after trimming")
+    ap.add_argument("--limit", type=int, default=None,
+                    help="only process the first N YouTube videos (debug)")
+    ap.add_argument("--filter-id", action="append", default=None,
+                    help="only process given youtube_id (repeatable)")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="don't download or trim — just print what would happen")
+    args = ap.parse_args()
+
+    if not have("yt-dlp"):
+        sys.exit("ERROR: yt-dlp not installed. Run: pip install -U yt-dlp")
+    if not have("ffmpeg"):
+        sys.exit("ERROR: ffmpeg not installed. Run: brew install ffmpeg  (or apt install ffmpeg)")
+    if args.reference_dir and not have("ffprobe"):
+        sys.exit("ERROR: --reference-dir requires ffprobe (ships with ffmpeg).")
+
+    reference_dir = Path(args.reference_dir).expanduser() if args.reference_dir else None
+    if reference_dir is not None and not reference_dir.is_dir():
+        sys.exit(f"ERROR: --reference-dir {reference_dir} is not a directory")
+
+    resolution_map: dict[str, dict] | None = None
+    if args.resolution_map:
+        rm_path = Path(args.resolution_map).expanduser()
+        if not rm_path.is_file():
+            sys.exit(f"ERROR: --resolution-map {rm_path} not found")
+        with open(rm_path) as fh:
+            resolution_map = json.load(fh)
+        log(f"Loaded resolution map: {len(resolution_map)} entries from {rm_path}")
+
+    meta_path = Path(args.metadata)
+    if not meta_path.exists():
+        sys.exit(f"ERROR: {meta_path} not found")
+
+    with open(meta_path) as f:
+        meta = json.load(f)
+    videos = meta.get("videos", meta if isinstance(meta, list) else [])
+    log(f"Loaded {len(videos)} chunk entries from {meta_path}")
+
+    # Group chunks by youtube_id (so each source video downloads once)
+    groups: dict[str, list[dict]] = defaultdict(list)
+    for v in videos:
+        yid = v.get("youtube_id")
+        if not yid:
+            continue
+        if args.filter_id and yid not in args.filter_id:
+            continue
+        groups[yid].append(v)
+
+    yt_ids = sorted(groups.keys())
+    if args.limit:
+        yt_ids = yt_ids[:args.limit]
+    log(f"Unique YouTube source videos: {len(yt_ids)}")
+
+    out_root  = Path(args.out)
+    cache_dir = Path(args.cache)
+    out_root.mkdir(parents=True, exist_ok=True)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    # Run with a worker pool
+    results: list[dict] = []
+    t0 = time.time()
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
+        futures = []
+        for yid in yt_ids:
+            chunks = groups[yid]
+            yt_url = chunks[0]["youtube_url"]
+            futures.append(ex.submit(
+                process_video_group,
+                yid, yt_url, chunks, out_root, cache_dir,
+                args.keep_fulls, args.dry_run, args.height,
+                reference_dir, resolution_map, args.source_cap,
+            ))
+        for fut in concurrent.futures.as_completed(futures):
+            results.append(fut.result())
+
+    elapsed = time.time() - t0
+    total_ok   = sum(r["ok"]   for r in results)
+    total_fail = sum(r["fail"] for r in results)
+    n_failed_videos = sum(1 for r in results if r["fail"] > 0)
+
+    print()
+    print("=" * 60)
+    print(f"DONE in {elapsed:.1f}s")
+    print(f"  YouTube videos processed: {len(results)}")
+    print(f"  Chunks OK:                {total_ok}")
+    print(f"  Chunks FAILED:            {total_fail}")
+    print(f"  Videos with failures:     {n_failed_videos}")
+    print("=" * 60)
+
+    # Write a summary report alongside the metadata
+    report = {
+        "elapsed_seconds": elapsed,
+        "n_videos":   len(results),
+        "n_chunks_ok": total_ok,
+        "n_chunks_failed": total_fail,
+        "failures": [
+            {"youtube_id": r["youtube_id"], "url": r["url"], "errors": r["errors"]}
+            for r in results if r["fail"] > 0
+        ],
+    }
+    rp = Path("download_report.json")
+    with open(rp, "w") as f:
+        json.dump(report, f, indent=2, ensure_ascii=False)
+    log(f"\nReport -> {rp}")
+
+    if total_fail:
+        log("Some clips failed. Re-run the script to retry only the failed ones "
+            "(successful clips are skipped automatically).")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

scripts/redact.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+#
+# VSTAT — Apply privacy redactions (black boxes) to YouTube clips.
+#
+# Coordinates are in 640x360 (post-scale) space, matching the official
+# VSTAT release. After this script runs, every redaction-target chunk
+# lives at the canonical `videos/youtube/<cat>/<id>_pt*.mp4` path with
+# the black boxes baked in. Any leftover `*_redacted.mp4` siblings from
+# earlier runs are removed.
+#
+# Usage (run from vstat/ root):
+#   ./scripts/redact.sh
+#   ./scripts/redact.sh --dry-run
+#
+
+set -eo pipefail
+
+DRY=0
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY=1 ;;
+    -h|--help) sed -n '2,15p' "$0"; exit 0 ;;
+    *) echo "Unknown arg: $arg" >&2; exit 1 ;;
+  esac
+done
+
+# Format:  "<canonical-glob>|<ffmpeg drawbox filter>"
+RULES=(
+  # tennis 0001
+  "videos/youtube/tennis/0001_pt*.mp4|drawbox=x=32:y=306:w=134:h=38:color=black:t=fill"
+  # tennis 0002
+  "videos/youtube/tennis/0002_pt*.mp4|drawbox=x=32:y=306:w=134:h=38:color=black:t=fill"
+  # basketball 0002
+  "videos/youtube/basketball/0002_pt*.mp4|drawbox=x=98:y=323:w=443:h=37:color=black:t=fill"
+  # basketball 0003
+  "videos/youtube/basketball/0003_pt*.mp4|drawbox=x=22:y=285:w=125:h=63:color=black:t=fill"
+  # soccer 0002 (two boxes)
+  "videos/youtube/soccer/0002_pt*.mp4|drawbox=x=0:y=0:w=122:h=19:color=black:t=fill,drawbox=x=140:y=320:w=360:h=40:color=black:t=fill"
+)
+
+if ! command -v ffmpeg >/dev/null 2>&1; then
+  echo "ERROR: ffmpeg not installed. brew install ffmpeg / apt install ffmpeg" >&2
+  exit 1
+fi
+
+# Expand a canonical glob to the union of canonical paths it covers,
+# accounting for files that currently live with `_redacted` suffix.
+# Compatible with bash 3.2 (macOS default) — no associative arrays.
+canonical_paths_for_glob() {
+  glob="$1"
+  dir=$(dirname "$glob")
+  pat=$(basename "$glob")                          # 0001_pt*.mp4
+  shopt -s nullglob
+  results=""
+  for f in "$dir"/$pat "$dir"/${pat%.mp4}_redacted.mp4; do
+    [ -e "$f" ] || continue
+    case "$f" in
+      *_redacted.mp4) base="${f%_redacted.mp4}.mp4" ;;
+      *)              base="$f" ;;
+    esac
+    results="${results}${base}"$'\n'
+  done
+  shopt -u nullglob
+  printf '%s' "$results" | sort -u | sed '/^$/d'
+}
+
+total=0; ok=0; fail=0; missing=0
+
+for rule in "${RULES[@]}"; do
+  glob="${rule%%|*}"
+  filt="${rule#*|}"
+  echo
+  echo "=== $glob ==="
+  echo "    filter: $filt"
+
+  paths=$(canonical_paths_for_glob "$glob")
+  if [ -z "$paths" ]; then
+    echo "    (no matching files)"
+    continue
+  fi
+
+  while IFS= read -r canon; do
+    [ -z "$canon" ] && continue
+    total=$((total+1))
+    redacted_sibling="${canon%.mp4}_redacted.mp4"
+
+    # Pick input: prefer existing _redacted sibling, fall back to canonical.
+    if [ -f "$redacted_sibling" ]; then
+      input="$redacted_sibling"
+    elif [ -f "$canon" ]; then
+      input="$canon"
+    else
+      echo "  ! missing both $canon and $redacted_sibling"
+      missing=$((missing+1))
+      continue
+    fi
+
+    if [ "$DRY" -eq 1 ]; then
+      echo "  [DRY] $input  =[$filt]=>  $canon"
+      ok=$((ok+1))
+      continue
+    fi
+
+    # Write to a temp file then atomically swap.
+    # `-nostdin` is REQUIRED here: without it ffmpeg consumes characters
+    # from the surrounding `while read` loop's stdin, mangling later paths.
+    tmp="${canon%.mp4}.redact.tmp.mp4"
+    if ! ffmpeg -y -loglevel error -nostdin -i "$input" -vf "$filt" -c:a copy "$tmp"; then
+      echo "  ! ffmpeg failed: $input"
+      fail=$((fail+1))
+      continue
+    fi
+    if cp -f "$tmp" "$canon" && rm -f "$tmp"; then
+      :
+    else
+      echo "  ! could not write $canon (kept tmp at $tmp)"
+      fail=$((fail+1))
+      continue
+    fi
+    # Drop misleading `_redacted.mp4` sibling now that the canonical file
+    # holds the actually-redacted content.
+    if [ -f "$redacted_sibling" ] && [ "$redacted_sibling" != "$canon" ]; then
+      rm -f "$redacted_sibling" 2>/dev/null || true
+    fi
+    ok=$((ok+1))
+    echo "  -> $canon"
+  done <<< "$paths"
+done
+
+echo
+echo "============================================================"
+echo "  total: $total   ok: $ok   fail: $fail   missing: $missing"
+echo "============================================================"
+[ "$fail" -eq 0 ] && [ "$missing" -eq 0 ]

videos/self_recorded/book/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e23199e689bed794b92b70b163cd0cfb0d13517a76f576b6d410f4be00dc009
+size 8819418

videos/self_recorded/book/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edbd5f88761b0c984054ced5ed4bd76b701aac7437c3c80001cc7574575a0088
+size 8739866

videos/self_recorded/book/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:042b5afa19aaec02e6bd25d1646007f68db69b6f97f5b6921dd91124d4c4bc47
+size 9093355

videos/self_recorded/book/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bf84cea1bb608d6061be02b5b26e70e5bfb41b0fef4ad957741c256760762ed
+size 7567652

videos/self_recorded/book/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cead3f7cd00547801bbe03a387a7ae0a4adbe15a8c070e1f7be070337ad77976
+size 11909270

videos/self_recorded/book/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a160b3ad466b7cf2b3c83e39c13f4161099ef2087c22ccb3350b448aad11b938
+size 9852910

videos/self_recorded/book/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da759ccd0794e5d55812c9ac4bb796a115da820230fcfae0cb4886c36bec58fc
+size 11537660

videos/self_recorded/book/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb275d1a1ad0230adb6c71812a1c792c25706745297b89937bdc696695ba802e
+size 12228041

videos/self_recorded/book/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9752f371e1d844c55c6f41076f5ae66b32f6161ebc61e1113d725144c75770d5
+size 11899390

videos/self_recorded/book/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df0bbc76c936cc57730cb8066ed34f57d7c411b20fa207817a2c45a3ae078a6e
+size 12259720

videos/self_recorded/cup_stacking/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8ea24a5232de154a0b42dac03d8ec8320d28a3646c0f2c84e941052905a57c3
+size 7853078

videos/self_recorded/cup_stacking/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87117666ed8c705e9b3816f51f4777e1964b19e27ee8407442a741c736f041ba
+size 6253120

videos/self_recorded/cup_stacking/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8cf6c140fd3292ca9f1b1383b8b22487012f6e139fca28f4d5ed682f1e92ff4
+size 11822179

videos/self_recorded/cup_stacking/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11c9aad87be2ac680fdd440ad0e8528b56cd3c2644902c0b46f57cbe9ddc341b
+size 10320277

videos/self_recorded/cup_stacking/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8fddf7ab1eb08252448caef9497995d97ebbf24fbcd185f6d8ee11e2158c687
+size 10564190

videos/self_recorded/cup_stacking/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1f597b2b1943a6bc2c748e15f6ba36bb08937f4367a220572345a144702f909
+size 11151561

videos/self_recorded/cup_stacking/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e685de2092186f6f762c566f2b347c06e5f21cb1a5a605b0422a35eef80f85c
+size 10928178

videos/self_recorded/cup_stacking/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bff79786e04265e1dc0ff3007689609063b41a570e12fdbb06acc4ed0528efaa
+size 11099668

videos/self_recorded/cup_stacking/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38af26c6b13133b5cb85cc08b261c3e854bd262023e63c926db0b62afbb9a081
+size 11809239

videos/self_recorded/cup_stacking/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f243f31fe60a1118a3f2bb07928b930eed9600bcd54c8bf147ce27bf5c554aa
+size 10751368

videos/self_recorded/keyboard/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29906936a7eb6aa473aaffdcad313b2274c47dd3a38fbdd5e3a5184d947f7e77
+size 3833649

videos/self_recorded/keyboard/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1958f375f9c19bc3a8a06279562772fe74b29b6975834e1ce7af349fb2960ddd
+size 3930910

videos/self_recorded/keyboard/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5fb2600aadf15301ab14491aabee2a65c28f0155729ac786689dc67bd6ce6e5
+size 4514933

videos/self_recorded/keyboard/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b661d65184e101d63bfc16ae4654aac45ea2179756877629f73d9671aa735ff
+size 6691558

videos/self_recorded/keyboard/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd87bde34474ae539e31280edd8a0d6e66c56969e086b78a07ca29e06ee56872
+size 5103554

videos/self_recorded/keyboard/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1ed94f1b83df3b27f9acf0aef97dd8347f3e2cd7cc0b7b9b8e4125168b5c7a0
+size 3997713

videos/self_recorded/keyboard/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f46486bbcf9dc3f7e3af168655909c5ef7da73e235ec2c28aff23ff1fabb53c
+size 7412067

videos/self_recorded/keyboard/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7c41db184fe0e8fda6d61296228b70ce82f39ca05bfdd2649dd070d1655c743
+size 3656426

videos/self_recorded/keyboard/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f18b2035ae10fdd5297bf6727a7ce2a76dbc6a420124cac4b698b66bc277b469
+size 4440764

videos/self_recorded/keyboard/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c46b378728f8450feec02eeed2dfd35dfe0b255416d67a6244b117278d94eecc
+size 6633008

videos/self_recorded/morse/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c61400e0b40885eb4c01ffa9a5613395119debd0088dafba6282b29164ecc647
+size 7293389

videos/self_recorded/morse/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:662e8f3b6fd3a7ace6bd54bf96f55ad5431e7f828bb0b056667a678f74b2e731
+size 6930512

videos/self_recorded/morse/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4caa204c75dbc00c4950f518b6621bb30a6cfcf5700a01b6efa3543549432d2d
+size 6719657

videos/self_recorded/morse/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4dab31c514a425b01970ba9446c58aeefe8d720b6229602ad425ebfa5dd2a87
+size 6384910

videos/self_recorded/morse/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d63f6239d244eb6b071903e54efeacb21df52c4a086fae62f2d242adea43b5e
+size 6691792

videos/self_recorded/morse/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6b96c1e8b573f20191eeb048fc82f1ea3727b1de7efb31b03c958e304b44a22
+size 8573960

videos/self_recorded/morse/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a598e3cc6ef698ddf1a0b9903d5b54e1bf91343583b15f847fcf597fbdaa06d
+size 5335238

videos/self_recorded/morse/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ac791f8f173fd0448915a557695ca2db71a90660b483abe87bac5ba8573d35c
+size 6388731

videos/self_recorded/morse/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0462fa4c2091227e6718fed1cc1c373d59631eb448825e9ea2ef27fd57cb8ae9
+size 6846647

videos/self_recorded/morse/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:644ee0ef91b0068e8147e4dab2a18a70a194ca39457f3a01b45755c7cdc09bb6
+size 7409935

videos/self_recorded/numberpad/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8742b4eb0a5ac7306b7cc243ab989389f04e64f3bacccdabd2bd8afd73f25b8d
+size 7297044

videos/self_recorded/numberpad/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a92a5cd88e5444e55e6d0659607eeb11cf223047ed6977bf910e60050b6fa09
+size 4085420