#!/usr/bin/env python3 """Build standalone LGPL macOS FFprobe from checksum-pinned official source.""" import argparse import hashlib import json import os from pathlib import Path, PurePosixPath import platform import re import shlex import shutil import subprocess import tarfile import tempfile from fetch_ffprobe import download, sha256 from macos_binary import validate_macos SCRIPTS = Path(__file__).resolve().parent IMAGE = "ghcr.io/rust-cross/cargo-zigbuild@sha256:9b4f6b3eb9e8f9fefb3960fe288ddba576627d66d9eff851ce7f62d2455564a5" TARGETS = {"aarch64-apple-darwin": "aarch64", "x86_64-apple-darwin": "x86_64"} RECIPE_FILES = ("build_macos_ffprobe.py", "ffprobe-macos-cc.py", "fetch_ffprobe.py", "macos_binary.py") FLAGS = [ "--target-os=darwin", "--enable-cross-compile", "--cc=python3 /work/cc.py", "--ar=zig ar", "--ranlib=zig ranlib", "--disable-autodetect", "--disable-network", "--disable-protocols", "--enable-protocol=file", "--disable-programs", "--enable-ffprobe", "--disable-doc", "--disable-debug", "--disable-asm", "--disable-encoders", "--disable-muxers", "--disable-filters", "--disable-avdevice", "--disable-shared", "--enable-static", "--disable-stripping", ] def regular_under(root, relative): path = PurePosixPath(relative) if (not path.parts or path.is_absolute() or any(p in ("", ".", "..") for p in relative.split("/")) or "\\" in relative or ":" in relative): raise ValueError("Unsafe FFprobe cache receipt path") current = root for part in path.parts: current /= part if current.is_symlink(): raise ValueError("Symlinked FFprobe cache input") if not current.is_file(): raise ValueError(f"Missing cached FFprobe input: {relative}") return current def recipe_digest(pin, target): identity = json.dumps({"pin": pin, "target": target, "image": IMAGE, "flags": FLAGS}, sort_keys=True).encode() for name in RECIPE_FILES: identity += (SCRIPTS / name).read_bytes() return hashlib.sha256(identity).hexdigest() def extract_source(archive, directory, release): with tarfile.open(archive, "r:xz") as source: for member in source.getmembers(): parts = PurePosixPath(member.name).parts if (not parts or parts[0] != f"ffmpeg-{release}" or ".." in parts or "\\" in member.name or not (member.isfile() or member.isdir())): raise ValueError(f"Unsafe FFmpeg source member: {member.name}") source.extractall(directory, filter="data") return directory / f"ffmpeg-{release}" def build(target, cache, pin): if target not in TARGETS or not re.fullmatch(r"\d+\.\d+(?:\.\d+)?", pin["release"]): raise ValueError("Unsupported macOS FFprobe target or source version") if pin["asset"] != f"ffmpeg-{pin['release']}.tar.xz" or not re.fullmatch(r"[a-f0-9]{64}", pin["sha256"]): raise ValueError("FFprobe requires an exact official source archive and SHA-256") identity = recipe_digest(pin, target) cache = Path(cache).resolve() folder = cache / target / identity binary, notices = folder / "ffprobe", folder / "licenses" if folder.exists(): if folder.is_symlink() or folder.parent.is_symlink(): raise ValueError("Symlinked FFprobe cache") receipt = json.loads(regular_under(folder, "licenses/provenance.json").read_text()) if (receipt["recipe_sha256"] != identity or receipt["source_sha256"] != pin["sha256"] or "ffprobe" not in receipt["files"] or "licenses/COPYING.LGPLv2.1" not in receipt["files"] or f"licenses/{pin['asset']}" not in receipt["files"]): raise ValueError("Invalid FFprobe cache receipt") for name, digest in receipt["files"].items(): if sha256(regular_under(folder, name)) != digest: raise ValueError("Corrupt macOS FFprobe cache; remove it and retry") validate_macos(binary, target) print(f"Using verified macOS FFprobe cache: {binary}", flush=True) return binary, notices engine = os.environ.get("CROSS_CONTAINER_ENGINE") if engine is None: engine = "podman" if shutil.which("podman") else "docker" if engine not in ("podman", "docker"): raise ValueError("Use podman or docker for the macOS FFprobe source build") cache.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix=".source-", dir=cache) as temporary: work = Path(temporary) archive = work / pin["asset"] url = f"https://ffmpeg.org/releases/{pin['asset']}" print(f"Downloading pinned FFmpeg source: {url}", flush=True) download(url, archive) if sha256(archive) != pin["sha256"]: raise ValueError("FFmpeg source SHA-256 mismatch") source = extract_source(archive, work, pin["release"]) shutil.copyfile(SCRIPTS / "ffprobe-macos-cc.py", work / "cc.py") configure = ["./configure", "--arch=" + TARGETS[target], *FLAGS] command = [ engine, "run", "--rm", "--network=none", "--user", f"{os.getuid()}:{os.getgid()}", ] if engine == "podman": command.append("--userns=keep-id") command += [ "-v", f"{work}:/work", "-w", f"/work/ffmpeg-{pin['release']}", "-e", "ZIG_GLOBAL_CACHE_DIR=/work/zig-cache", "-e", f"FFPROBE_ARCH={TARGETS[target]}", IMAGE, "sh", "-c", shlex.join(configure) + " && make -j16 ffprobe", ] print(f"Building LGPL FFprobe for {target}", flush=True) subprocess.run(command, check=True, timeout=1500) configuration = (source / "config.h").read_text() for feature in ("GPL", "GPLV3", "NONFREE"): if f"#define CONFIG_{feature} 0" not in configuration: raise ValueError(f"Unexpected FFmpeg license configuration: {feature}") checks = validate_macos(source / "ffprobe", target) stage = work / "payload" staged_notices = stage / "licenses" staged_notices.mkdir(parents=True) shutil.copyfile(source / "ffprobe", stage / "ffprobe") (stage / "ffprobe").chmod(0o755) for name in ("COPYING.LGPLv2.1", "LICENSE.md"): shutil.copyfile(source / name, staged_notices / name) shutil.copyfile(archive, staged_notices / pin["asset"]) for name in RECIPE_FILES: shutil.copyfile(SCRIPTS / name, staged_notices / name) (staged_notices / "ffprobe-pins.json").write_text(json.dumps({target: pin}, indent=2) + "\n") (staged_notices / "BUILDING.txt").write_text( "FFprobe is a separate LGPL-2.1-or-later executable built from unmodified FFmpeg source.\n" "The complete source archive and build scripts are included here.\n" "On a Linux host with Python 3.11+ and Podman/Docker, reproduce with:\n" f"python3 build_macos_ffprobe.py --target {target} --pins ffprobe-pins.json --cache ./build-cache\n" "The container image is pinned by digest in the build script.\n" "Only local-file input is enabled; no separate third-party codec libraries are bundled.\n" ) native_version = None if platform.system() == "Darwin" and platform.machine().lower() == ( "arm64" if target.startswith("aarch64") else "x86_64"): result = subprocess.run([str(stage / "ffprobe"), "-version"], check=True, capture_output=True, text=True, timeout=30) native_version = result.stdout.splitlines()[0] if not native_version.startswith("ffprobe version "): raise ValueError("Executable did not identify itself as FFprobe") receipt = { "provider": "https://ffmpeg.org", "release": pin["release"], "target": target, "url": url, "source_sha256": pin["sha256"], "recipe_sha256": identity, "image": IMAGE, "configure": configure, "checks": checks, "native_version_check": native_version, "files": {p.relative_to(stage).as_posix(): sha256(p) for p in stage.rglob("*") if p.is_file()}, } (staged_notices / "provenance.json").write_text(json.dumps(receipt, indent=2) + "\n") folder.parent.mkdir(parents=True, exist_ok=True) stage.rename(folder) return binary, notices def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--target", required=True, choices=TARGETS) parser.add_argument("--cache", type=Path, required=True) parser.add_argument("--pins", type=Path, required=True) args = parser.parse_args() build(args.target, args.cache, json.loads(args.pins.read_text())[args.target]) if __name__ == "__main__": main()