#!/usr/bin/env python3 """Shared ffmpeg command validator: synthetic media, execution, static checks, metrics. Used by the audit, the baselines and the fine-tuned eval so every number comes from the same code path. Requires ffmpeg on PATH. """ import os import re import shlex import shutil import subprocess import tempfile VIDEO_EXT = {".mp4", ".mkv", ".avi", ".mov", ".webm", ".flv", ".m4v", ".mpg", ".mpeg", ".ts", ".wmv", ".3gp"} AUDIO_EXT = {".wav", ".mp3", ".m4a", ".aac", ".flac", ".ogg", ".opus", ".wma", ".aiff", ".amr"} IMAGE_EXT = {".png", ".jpg", ".jpeg", ".bmp", ".webp", ".tiff", ".tif", ".ppm", ".pgm", ".pam"} SUB_EXT = {".srt", ".ass", ".ssa", ".vtt", ".ttml"} LAVFI_SOURCES = {"testsrc", "testsrc2", "sine", "color", "anullsrc", "mandelbrot", "smptebars", "smptehdbars", "rgbtestsrc", "life", "cellauto", "haldclutsrc", "nullsrc", "gradients", "qrencodesrc", "zeroes", "srtpacketsrc", "vignette", "aevalsrc", "avectorscope", "showwaves", "showwavespic", "showspectrum", "showcqt"} STATIC_ONLY_MARKERS = [ "nvenc", "qsv", "v4l2", "rtsp", "srt:", "udp:", "rtp:", "videotoolbox", "vaapi", "d3d11va", "dxva2", "mediacodec", "cuda", "cuvid", "mmal", "omx", "dshow", "avfoundation", "x11grab", "gdigrab", ":video=", ":audio=", ] HEAVY = ("minterpolate", "loop=loop=-1", "framerate=240", "fps=240") _cap_cache = {} def _run(cmd, timeout): return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout) def capabilities(): """Cached sets of real ffmpeg filters, encoders and muxers.""" if "filters" not in _cap_cache: filt = _run(["ffmpeg", "-hide_banner", "-filters"], 15).stdout.decode(errors="replace") _cap_cache["filters"] = set(re.findall(r"^ [A-Z0-9\.]+\s+(\w+)", filt, re.M)) if "encoders" not in _cap_cache: enc = _run(["ffmpeg", "-hide_banner", "-encoders"], 15).stdout.decode(errors="replace") _cap_cache["encoders"] = set(re.findall(r"^ [AVS\.]{6}\s+(\S+)", enc, re.M)) if "muxers" not in _cap_cache: mux = _run(["ffmpeg", "-hide_banner", "-muxers"], 15).stdout.decode(errors="replace") _cap_cache["muxers"] = set(re.findall(r"^ [A-Z0-9\.]+\s+(\w+)", mux, re.M)) return _cap_cache def ext_of(fn): m = re.search(r"\.([A-Za-z0-9]{1,6})$", fn) return ("." + m.group(1).lower()) if m else "" def is_sequence(fn): return bool(re.search(r"%0?\d*d", fn)) def is_glob(fn): return bool(re.search(r"[\*\?]", fn)) def seq_dir(fn): return os.path.dirname(fn) or "." def is_lavfi_source(tok): return tok.split("=")[0].split(":")[0] in LAVFI_SOURCES def command_inputs(cmd): """Positional inputs + filenames embedded in filter args.""" try: toks = shlex.split(cmd) except ValueError: return [] ins, i = [], 1 while i < len(toks): t = toks[i] if t == "-i" and i + 1 < len(toks): ins.append(toks[i + 1]) i += 2 continue i += 1 files = [] for m in re.finditer(r"(?:subtitles|ass)=([^:'\"\s]+\.(?:srt|ass|ssa|vtt))|" r"(?:textfile|fontfile|filename)=([\w./\-]+\.\w+)", cmd): files.append(m.group(1) or m.group(2)) out = [] for fn in ins + files: if not fn or fn.startswith("-") or is_lavfi_source(fn) or ":" in fn: continue if "." not in fn and "%" not in fn and "*" not in fn and "/" not in fn: continue if fn not in out: out.append(fn) return out def make_input_file(path, is_concat=False): """Create a tiny synthetic media file at `path` based on its extension.""" os.makedirs(os.path.dirname(path) or ".", exist_ok=True) ext = ext_of(path) try: if ext == ".txt" and is_concat: with open(path, "w") as f: f.write("file 'video.mp4'\n") return os.path.exists(path) if is_glob(path): d = seq_dir(path) os.makedirs(d, exist_ok=True) e = ext_of(path) or ".jpg" for k in range(1, 4): _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc=size=64x64:rate=1", "-frames:v", "1", os.path.join(d, f"synthimg_{k:03d}{e}")], 15) return len(os.listdir(d)) >= 3 if ext in SUB_EXT or ext == ".txt": with open(path, "w") as f: f.write("1\n00:00:00,000 --> 00:00:00,500\nhello world\n\nsample text\n") return os.path.exists(path) if is_sequence(path) or ext in IMAGE_EXT: args = ["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc=duration=0.5:size=64x64:rate=5"] if is_sequence(path): args.append(path) else: args += ["-frames:v", "1", path] _run(args, 15) if is_sequence(path): import glob as _g base = re.sub(r"%0?\d*d", "*", os.path.basename(path)) return len(_g.glob(os.path.join(seq_dir(path), base))) >= 1 return os.path.exists(path) if ext in (".mpg", ".mpeg"): _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc=duration=12:size=640x480:rate=10", "-f", "lavfi", "-i", "sine=duration=12", "-map", "0:v", "-map", "1:a", "-c:v", "mpeg2video", "-c:a", "mp2", "-pix_fmt", "yuvj420p", path], 60) return os.path.exists(path) if ext == ".opus": _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=3", "-c:a", "libopus", path], 30) return os.path.exists(path) if ext in AUDIO_EXT: _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=12:frequency=440", "-ar", "44100", "-ac", "1", path], 30) return os.path.exists(path) if ext in VIDEO_EXT or ext == "": sub_fmt = {".mp4": "mov_text", ".m4v": "mov_text", ".mov": "mov_text", ".mkv": "srt", ".webm": "webvtt"}.get(ext) srt = os.path.join(os.path.dirname(path) or ".", "_synth.srt") with open(srt, "w") as f: f.write("1\n00:00:00,000 --> 00:00:11,500\nhello world\n\n2\n" "00:00:05,000 --> 00:00:11,500\nsecond line\n\n") args = ["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc=duration=12:size=640x480:rate=10", "-f", "lavfi", "-i", "sine=duration=12:frequency=440"] maps = ["-map", "0:v", "-map", "1:a"] if sub_fmt: args += ["-i", srt] maps += ["-map", "2:s", "-c:s", sub_fmt] args += maps + ["-pix_fmt", "yuvj420p", "-shortest", path] _run(args, 60) return os.path.exists(path) return False except Exception: return False class MediaPool: """Creates synthetic inputs on demand, keyed by referenced filename.""" def __init__(self, base_dir): self.base = base_dir self.made = {} def get(self, fn, is_concat=False): if fn in self.made: return self.made[fn] if is_glob(fn) or is_sequence(fn): path = os.path.join(self.base, "_pat", os.path.basename(fn)) else: path = os.path.join(self.base, re.sub(r"[^\w.\-]", "_", fn)) ok = make_input_file(path, is_concat=is_concat) self.made[fn] = path if ok else None return self.made[fn] def is_static_only(cmd): text = cmd if any(m in text for m in STATIC_ONLY_MARKERS): return True try: toks = shlex.split(cmd) except ValueError: return False return any(not t.startswith("-") and t.split("=")[0].split(":")[0] in LAVFI_SOURCES for t in toks) and any(t == "-f" and i + 1 < len(toks) and toks[i + 1] == "lavfi" for i, t in enumerate(toks)) and False def static_validate(cmd): """Problems that mean the command cannot work on any ffmpeg build (empty = OK).""" caps = capabilities() problems = [] for m in re.finditer(r"-v(?:f)?\s+(?:(['\"])(.*?)\1|(\S+))|-af\s+(?:(['\"])(.*?)\4|(\S+))|" r"-filter_complex\s+(?:(['\"])(.*?)\7|(\S+))", cmd): chain = next((g for g in m.groups() if g), "") for part in re.split(r"[,;]", chain): n = part.strip().split("=")[0].split("[")[0].strip() if n and re.fullmatch(r"[a-z0-9_]+", n) and n not in caps["filters"]: problems.append(f"filter not found: {n}") for m in re.finditer(r"(?:-c:v|-c:a|-vcodec|-acodec)\s+(\S+)", cmd): enc = m.group(1) if enc not in ("copy", "none") and enc not in caps["encoders"]: problems.append(f"encoder not found: {enc}") return problems def run_command(cmd, pool, timeout=12): """Run the command verbatim in a temp dir with synthetic inputs. Returns dict.""" static_only = any(m in cmd for m in STATIC_ONLY_MARKERS) inputs = command_inputs(cmd) if static_only: probs = static_validate(cmd) return {"mode": "static", "ok": not probs, "reason": "; ".join(probs) or "static checks passed"} with tempfile.TemporaryDirectory(dir="/tmp") as td: try: missing = [] for fn in inputs: is_concat = "-f concat" in cmd and ext_of(fn) == ".txt" src = pool.get(fn, is_concat=is_concat) if src is None: missing.append(fn) continue if is_sequence(fn) or is_glob(fn): d = seq_dir(fn) os.makedirs(os.path.join(td, d), exist_ok=True) for f in os.listdir(os.path.dirname(src)): shutil.copy(os.path.join(os.path.dirname(src), f), os.path.join(td, d, os.path.basename(f))) else: dst = os.path.join(td, os.path.basename(fn)) if os.path.abspath(src) != os.path.abspath(dst): shutil.copy(src, dst) if missing: probs = static_validate(cmd) if probs: return {"mode": "static", "ok": False, "reason": "static: " + "; ".join(probs)} return {"mode": "static", "ok": True, "reason": "input not creatable: " + ",".join(missing[:3])} p = _run(["/bin/sh", "-lc", f"cd {td} && timeout {timeout} {cmd}"], timeout + 4) err = p.stderr.decode(errors="replace").strip().splitlines() if p.returncode == 0: return {"mode": "run", "ok": True, "reason": ""} reason = err[-1] if err else f"exit {p.returncode}" if p.returncode == 124 or "timeout" in reason.lower(): if any(h in cmd for h in HEAVY): probs = static_validate(cmd) return {"mode": "static", "ok": not probs, "reason": "heavy filter: " + ("; ".join(probs) or "static checks passed")} return {"mode": "run", "ok": False, "reason": "timeout"} return {"mode": "run", "ok": False, "reason": reason[:300]} except Exception as e: return {"mode": "run", "ok": False, "reason": f"harness error: {e}"} # ---------------------------------------------------------------- metrics def normalize_cmd(s): s = s.strip().lower() s = s.replace('"', "'").replace("`", "") s = re.sub(r"\s+", " ", s) s = re.sub(r"\s*=\s*", "=", s) return s.strip() def token_f1(ref, pred): r, p = ref.split(), pred.split() common = {} for t in r: common[t] = max(common.get(t, 0), p.count(t)) tp = sum(min(r.count(t), p.count(t)) for t in set(r)) prec = tp / len(p) if p else 0.0 rec = tp / len(r) if r else 0.0 return 2 * prec * rec / (prec + rec) if (prec + rec) else 0.0 def extract_filters(cmd): out = set() for m in re.finditer(r"-v(?:f)?\s+(?:(['\"])(.*?)\1|(\S+))|-af\s+(?:(['\"])(.*?)\4|(\S+))|" r"-filter_complex\s+(?:(['\"])(.*?)\7|(\S+))", cmd): chain = next((g for g in m.groups() if g), "") for part in re.split(r"[,;]", chain): n = part.strip().split("=")[0].split("[")[0].strip() if n and re.fullmatch(r"[a-z0-9_]+", n): out.add(n) return out def extract_flags(cmd): try: toks = shlex.split(cmd) except ValueError: return set() return {t.split("=")[0] for t in toks if t.startswith("-") and len(t) > 1 and not re.fullmatch(r"-[\d.]+", t)} # core options that ffmpeg 7.x -h full does not list but always accept CORE_OPTS = { "i", "f", "map", "map_chapters", "c", "c:v", "c:a", "c:s", "vf", "af", "filter_complex", "ss", "to", "t", "b", "b:v", "b:a", "ar", "ac", "vn", "an", "sn", "dn", "y", "n", "pix_fmt", "r", "s", "shortest", "vcodec", "acodec", "scodec", "frames", "q", "crf", "preset", "profile", "level", "metadata", "aspect", "hwaccel", "itsoffset", "loop", "update", "nostdin", "hide_banner", "v", "stats", "filter_threads", "max_muxing_queue_size", "movflags", "hls_time", "hls_playlist_type", "hls_segment_filename", "segment_time", "map_metadata", "map_channel", "vol", "sample_fmt", "channel_layout", "rc", } def hallucinated_items(cmd): """Flags/filters in cmd that do not exist in this ffmpeg build.""" caps = capabilities() bad = [] for f in extract_filters(cmd): if f not in caps["filters"]: bad.append(f"filter:{f}") for fl in extract_flags(cmd): base = fl.lstrip("-") if base not in _cap_cache.get("options", set()) and base not in CORE_OPTS: bad.append(f"flag:{fl}") return bad def load_options(): opts = set() p = _run(["ffmpeg", "-h", "full"], 15) for m in re.finditer(r"^\s*(-{1,2}[\w:\-]+)", p.stdout.decode(errors="replace"), re.M): opts.add(m.group(1).lstrip("-")) _cap_cache["options"] = opts return opts def format_ok(pred): if "\n" in pred.strip() or "\r" in pred.strip(): return False s = pred.strip() return bool(re.match(r"^ffmpeg(\s|$)", s)) and "```" not in s and len(s) > len("ffmpeg") def classify_category(cmd): text = cmd if any(m in text for m in ("rtsp", "udp:", "rtp:", "srt:", "http://", "https://", "m3u8", "-hls")): return "streaming" if "concat" in text: return "concat" if "-ss" in text or "-to" in text or re.search(r"\s-t\s", text): return "trim" try: toks = shlex.split(text) except ValueError: toks = text.split() if "-af" in toks: return "audio filter" if "-vf" in toks or "filter_complex" in text: return "video filter" return "conversion"