| |
| """Check a suite's media folder against MEDIA_STANDARD.md (v2, 2026-10-16: above 1080p, ray or path tracing only). |
| |
| Usage: python3 check_media.py <suite_dir> [--teaser-only] |
| |
| Layout: <suite_dir>/<task_id>/{video.mp4, poster.png, meta.json} or {still.png, meta.json}, |
| plus an optional <suite_dir>/teaser.mp4. Needs ffprobe and ffmpeg on PATH. Exit code 1 if anything fails. |
| """ |
| import json |
| import re |
| import subprocess |
| import sys |
| from pathlib import Path |
|
|
| META_KEYS = ("suite", "task", "source", "renderer", "rendering", "width", "height", "fps", "speed", "success_check") |
| RENDERINGS = ("path-tracing", "ray-tracing") |
| |
| RASTER = re.compile(r"\b(raster\w*|opengl|egl|osmesa|eevee|workbench|pyrender|mujoco[ _-]?(?:native|viewer|renderer)|default[ _-]?shader)\b", re.I) |
|
|
|
|
| def size_problem(name, w, h): |
| """Addendum 2: masters, posters and stills must be larger than 1920x1080; 2560x1440 is the target.""" |
| if w <= 1920 or h <= 1080: |
| return f"{name}: {w}x{h} is not above 1920x1080 (render at 2560x1440)" |
| return None |
| SOURCES = ("oracle", "agent-success:", "official-demo:", "scene-orbit") |
|
|
|
|
| def probe(path): |
| out = subprocess.run( |
| ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", |
| "stream=codec_name,pix_fmt,width,height,r_frame_rate,avg_frame_rate,bit_rate:format=duration,bit_rate", |
| "-of", "json", str(path)], capture_output=True, text=True) |
| if out.returncode: |
| return None |
| d = json.loads(out.stdout) |
| s = (d.get("streams") or [{}])[0] |
| f = d.get("format") or {} |
| s["duration"] = float(f.get("duration") or 0) |
| s["bit_rate"] = int(s.get("bit_rate") or f.get("bit_rate") or 0) |
| return s |
|
|
|
|
| def rate(text): |
| num, _, den = (text or "0/1").partition("/") |
| return float(num) / float(den or 1) if float(den or 1) else 0.0 |
|
|
|
|
| def encoder_crf(path): |
| """CRF recorded by x264/x265 in the stream's SEI text, or None for other encoders.""" |
| with open(path, "rb") as fh: |
| head = fh.read(4 << 20) |
| i = head.find(b"crf=") |
| if i < 0 or (b"x264" not in head and b"x265" not in head): |
| return None |
| try: |
| return float(head[i + 4:i + 12].split(b" ")[0]) |
| except ValueError: |
| return None |
|
|
|
|
| def black_bars(path, duration, width, height): |
| """Detect letterboxing or pillarboxing in the middle of the clip (a warning: dark scenes can trip it).""" |
| out = subprocess.run( |
| ["ffmpeg", "-hide_banner", "-ss", str(max(0.0, duration / 2 - 0.5)), "-i", str(path), "-frames:v", "12", |
| "-vf", "cropdetect=24:2:0", "-f", "null", "-"], capture_output=True, text=True) |
| crops = [ln.rsplit("crop=", 1)[1].strip() for ln in out.stderr.splitlines() if "crop=" in ln] |
| if not crops: |
| return False |
| w, h = (int(v) for v in crops[-1].split(":")[:2]) |
| return w < 0.96 * width or h < 0.96 * height |
|
|
|
|
| def check_video(path, teaser, problems, warnings): |
| s = probe(path) |
| if not s: |
| problems.append(f"{path.name}: unreadable") |
| return None |
| w, h, fps = int(s.get("width") or 0), int(s.get("height") or 0), rate(s.get("r_frame_rate")) |
| if (p := size_problem(path.name, w, h)): |
| problems.append(p) |
| elif w < 2560 or h < 1440: |
| warnings.append(f"{path.name}: {w}x{h} is below the 2560x1440 target") |
| if h and abs(w / h - 16 / 9) > 0.02: |
| problems.append(f"{path.name}: aspect {w}x{h} is not 16:9") |
| if fps < 29.9: |
| problems.append(f"{path.name}: {fps:.2f} fps is below 30") |
| if abs(rate(s.get("avg_frame_rate")) - fps) > 0.5: |
| warnings.append(f"{path.name}: frame rate looks variable") |
| if s.get("codec_name") not in ("h264", "hevc"): |
| problems.append(f"{path.name}: codec {s.get('codec_name')} (use H.264 or H.265)") |
| if s.get("pix_fmt") not in ("yuv420p", "yuvj420p"): |
| warnings.append(f"{path.name}: pixel format {s.get('pix_fmt')} (yuv420p plays everywhere)") |
| crf = encoder_crf(path) |
| if crf is not None: |
| if crf > 18.05: |
| problems.append(f"{path.name}: encoded at CRF {crf:g}; masters need CRF 18 or lower") |
| else: |
| |
| |
| floor = 2e6 * (w * h * max(fps, 1)) / (1920 * 1080 * 30) |
| if s["bit_rate"] and s["bit_rate"] < floor: |
| warnings.append(f"{path.name}: {s['bit_rate'] / 1e6:.1f} Mbps; if this is a re-encode, deliver the original") |
| lo, hi = (10, 40) if teaser else (5, 60) |
| if not lo <= s["duration"] <= hi: |
| warnings.append(f"{path.name}: {s['duration']:.1f} s (expected {lo}-{hi} s)") |
| if w and h and black_bars(path, s["duration"], w, h): |
| warnings.append(f"{path.name}: black bars detected; check by eye") |
| return w, h, fps |
|
|
|
|
| def check_image(path, problems): |
| s = probe(path) |
| if not s: |
| problems.append(f"{path.name}: unreadable") |
| return |
| w, h = int(s.get("width") or 0), int(s.get("height") or 0) |
| if (p := size_problem(path.name, w, h)): |
| problems.append(p) |
| if path.suffix.lower() != ".png": |
| problems.append(f"{path.name}: use PNG for stills and posters") |
|
|
|
|
| def check_task(d): |
| problems, warnings = [], [] |
| video, still, poster, meta = d / "video.mp4", d / "still.png", d / "poster.png", d / "meta.json" |
| dims = None |
| if video.exists(): |
| dims = check_video(video, False, problems, warnings) |
| if poster.exists(): |
| check_image(poster, problems) |
| else: |
| problems.append("poster.png missing") |
| elif still.exists(): |
| check_image(still, problems) |
| warnings.append("still only: a video is preferred") |
| else: |
| problems.append("neither video.mp4 nor still.png") |
| if not meta.exists(): |
| problems.append("meta.json missing") |
| else: |
| try: |
| m = json.loads(meta.read_text()) |
| except ValueError: |
| problems.append("meta.json is not valid JSON") |
| m = {} |
| missing = [k for k in META_KEYS if k not in m] |
| if missing: |
| problems.append(f"meta.json lacks {', '.join(missing)}") |
| if m.get("source") and not str(m["source"]).startswith(SOURCES): |
| problems.append(f"meta.json source '{m['source']}' is not oracle / agent-success:* / official-demo:* / scene-orbit") |
| if "rendering" in m and m.get("rendering") not in RENDERINGS: |
| problems.append(f"meta.json rendering '{m.get('rendering')}' is not path-tracing or ray-tracing (addendum 2)") |
| if RASTER.search(str(m.get("renderer", ""))): |
| problems.append(f"meta.json renderer '{m.get('renderer')}' is a rasterizer; render with ray or path tracing (addendum 2)") |
| if m.get("success_check") is False and m.get("source") != "scene-orbit": |
| problems.append("meta.json says the replay did not succeed; never publish it as a solved run") |
| kind = str(m.get("source", "")).split(":")[0] |
| if (still.exists() and not video.exists() or kind in ("scene-orbit", "still")) and not str(m.get("why_no_video", "")).strip(): |
| problems.append("a still or an orbit needs \"why_no_video\" in meta.json (addendum 1)") |
| if dims and m.get("width") and (m.get("width"), m.get("height")) != dims[:2]: |
| warnings.append(f"meta.json size {m.get('width')}x{m.get('height')} differs from the file {dims[0]}x{dims[1]}") |
| return problems, warnings |
|
|
|
|
| def check_highlights(root): |
| """<suite>/highlights.json: at least 5 hard tasks, each with a video where the robot moves; the teaser among them.""" |
| problems = [] |
| path = root / "highlights.json" |
| if not path.exists(): |
| return ["no highlights.json: list at least 5 hard tasks with the robot moving (addendum 1)"] |
| try: |
| h = json.loads(path.read_text()) |
| except ValueError: |
| return ["highlights.json is not valid JSON"] |
| ids = [str(x) for x in h.get("highlights") or []] |
| for t in ids: |
| d = root / t |
| m = json.loads((d / "meta.json").read_text()) if (d / "meta.json").exists() else {} |
| kind = str(m.get("source", "")).split(":")[0] |
| if not d.is_dir(): |
| problems.append(f"highlight {t}: no such task") |
| elif not (d / "video.mp4").exists() or kind in ("scene-orbit", "still"): |
| problems.append(f"highlight {t}: needs a video where the robot moves") |
| if h.get("teaser") and h["teaser"] not in ids: |
| problems.append("the teaser must be one of the highlights") |
| if len(set(ids)) < 5 and not str(h.get("why_fewer", "")).strip(): |
| problems.append(f"{len(set(ids))} highlights: list at least 5, or say why in why_fewer") |
| return problems |
|
|
|
|
| def main(): |
| if len(sys.argv) < 2: |
| sys.exit(__doc__) |
| root = Path(sys.argv[1]) |
| failed = 0 |
| teaser = root / "teaser.mp4" |
| if teaser.exists(): |
| problems, warnings = [], [] |
| check_video(teaser, True, problems, warnings) |
| failed += bool(problems) |
| print(("FAIL" if problems else "WARN" if warnings else "PASS"), "teaser", *(problems + warnings), sep=" ") |
| else: |
| print("WARN teaser teaser.mp4 missing") |
| hp = check_highlights(root) |
| failed += bool(hp) |
| print("FAIL" if hp else "PASS", "highlights", *hp, sep=" ") |
| if "--teaser-only" not in sys.argv: |
| tasks = sorted(p for p in root.iterdir() if p.is_dir() and not p.name.startswith((".", "_"))) |
| for d in tasks: |
| problems, warnings = check_task(d) |
| failed += bool(problems) |
| print(("FAIL" if problems else "WARN" if warnings else "PASS"), d.name, *(problems + warnings), sep=" ") |
| print(f"\n{len(tasks)} tasks, {failed} failing") |
| sys.exit(1 if failed else 0) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
