polysync 0.1.0__py3-none-any.whl

polysync/__init__.py

@@ -0,0 +1,19 @@
+"""polysync — multicam audio sync + director-style auto-edit.
+
+Align N recordings of one event by audio cross-correlation (envelope-based,
+robust at low SNR), emit reversible `.sync.json` sidecars (originals are never
+re-encoded), then auto-cut / picture-in-picture them into a single MP4.
+
+Public API:
+    from polysync import compute_sync, SyncResult, SyncError
+    from polysync.sidecar import read_sidecar, write_sidecar
+"""
+from .sync import compute_sync, SyncResult, SyncError
+from .sidecar import read_sidecar, write_sidecar, sidecar_path, SCHEMA_VERSION
+
+__version__ = "0.1.0"
+__all__ = [
+    "compute_sync", "SyncResult", "SyncError",
+    "read_sidecar", "write_sidecar", "sidecar_path", "SCHEMA_VERSION",
+    "__version__",
+]

polysync/audio.py

@@ -0,0 +1,130 @@
+"""Shared audio primitives — the pieces sync, verify, and edit all need.
+
+Everything here is either pure numpy/scipy (unit-testable without media) or a
+thin ffmpeg/ffprobe wrapper. Keeping these in one place is the whole reason
+polysync is a package and not three copy-pasted scripts.
+"""
+import subprocess
+from pathlib import Path
+
+import numpy as np
+from scipy import signal
+
+
+def loudest_audio_stream(video_path):
+    """Return the index N of the audio stream (`0:a:N`) with the highest mean
+    volume, probed over a 60 s window mid-file.
+
+    Why this matters: pro cameras often record multiple audio tracks where the
+    first one is dead. Sony FX6 MXF clips carry 4 mono PCM tracks and commonly
+    leave a:0 / a:1 silent (~-90 dB) with the real room mic on a:2 / a:3.
+    Hard-coding `0:a:0` would cross-correlate silence and fail to sync, so pick
+    the loudest track instead. Single-stream files (most MP4 cams) short-circuit
+    to a:0.
+    """
+    video_path = Path(video_path)
+    streams = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "a",
+         "-show_entries", "stream=index", "-of", "csv=p=0", str(video_path)],
+        check=True, capture_output=True, text=True,
+    ).stdout.strip().splitlines()
+    if len(streams) <= 1:
+        return 0
+    best_idx, best_db = 0, -1e9
+    for ch in range(len(streams)):
+        err = subprocess.run(
+            ["ffmpeg", "-nostdin", "-hide_banner", "-ss", "300", "-t", "60",
+             "-i", str(video_path), "-map", "0:a:%d" % ch,
+             "-af", "volumedetect", "-f", "null", "-"],
+            capture_output=True, text=True,
+        ).stderr
+        for line in err.splitlines():
+            if "mean_volume" in line:
+                try:
+                    db = float(line.split("mean_volume:")[1].strip().split()[0])
+                except (IndexError, ValueError):
+                    db = -1e9
+                if db > best_db:
+                    best_db, best_idx = db, ch
+                break
+    print("  [%s] loudest audio stream: a:%d (%.1f dB)"
+          % (video_path.name, best_idx, best_db))
+    return best_idx
+
+
+def extract_pcm(video_path, dst, sr, stream=None):
+    """Extract one audio track as mono signed-16 PCM at `sr` Hz.
+
+    `stream` is the `0:a:N` index; if None, auto-select the loudest track.
+    No `-itsoffset` is ever applied here — offsets are pure metadata and are
+    handled by index arithmetic / `-itsoffset` at consume time downstream.
+    """
+    video_path = Path(video_path)
+    ch = loudest_audio_stream(video_path) if stream is None else stream
+    subprocess.run(
+        ["ffmpeg", "-nostdin", "-y", "-i", str(video_path),
+         "-map", "0:a:%d" % ch, "-ac", "1", "-ar", str(sr),
+         "-f", "s16le", str(dst)],
+        check=True, stderr=subprocess.DEVNULL,
+    )
+
+
+def read_pcm(path):
+    """Read a raw s16le file into a float32 array."""
+    return np.fromfile(str(path), dtype=np.int16).astype(np.float32)
+
+
+def media_duration(path):
+    """Container duration in seconds, via ffprobe."""
+    out = subprocess.run(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=nw=1:nk=1", str(path)],
+        check=True, capture_output=True, text=True,
+    )
+    return float(out.stdout.strip())
+
+
+def frame_rms(x, sr, hop_ms=10, win_ms=50):
+    """Sliding-window RMS of `x`. Returns (rms_per_frame, frame_sr_hz).
+
+    Uses a cumulative-sum trick so it's O(n) regardless of window size. This is
+    the shared primitive behind both the sync envelope (log of this, high-passed)
+    and the edit per-second loudness.
+    """
+    hop = int(sr * hop_ms / 1000)
+    win = int(sr * win_ms / 1000)
+    n = (len(x) - win) // hop + 1
+    if n <= 0:
+        return np.zeros(0, dtype=np.float32), sr / hop
+    sq = x.astype(np.float64) ** 2
+    csq = np.concatenate([[0.0], np.cumsum(sq)])
+    out = np.empty(n, dtype=np.float32)
+    for i in range(n):
+        s = i * hop
+        out[i] = np.sqrt(max(1e-9, (csq[s + win] - csq[s]) / win))
+    return out, sr / hop
+
+
+def log_envelope(x, sr, hop_ms=10, win_ms=50, highpass_hz=0.05):
+    """Log-energy envelope, high-passed to strip slow gain/drift offsets.
+
+    This is what sync cross-correlates: it captures dialogue/music dynamics
+    that BOTH mics hear regardless of their frequency response — the reason
+    the matcher is robust even when the two cameras have very different mics.
+    """
+    rms, fsr = frame_rms(x, sr, hop_ms, win_ms)
+    env = np.log(rms + 1e-3)
+    if highpass_hz:
+        env = highpass(env, fsr, highpass_hz)
+    return env, fsr
+
+
+def highpass(x, fs, cut_hz=0.05):
+    sos = signal.butter(2, cut_hz, btype="high", fs=fs, output="sos")
+    return signal.sosfiltfilt(sos, x).astype(np.float32)
+
+
+def normalize(x):
+    x = x - x.mean()
+    s = x.std()
+    return x / s if s > 0 else x

polysync/cli.py

@@ -0,0 +1,79 @@
+"""`polysync` command-line entry point.
+
+    polysync sync        REFERENCE SOURCE [--partial]
+    polysync verify      REFERENCE SOURCE SIDECAR [--apply-drift]
+    polysync edit        IN1 IN2 ... --out edl.json [--mode rotation|greedy]
+    polysync render-cuts EDL --out out.mp4
+    polysync render-pip  EDL --out out.mp4 [--pip bottom-right]
+"""
+import argparse
+import sys
+
+from . import __version__
+from .sync import sync_files, SyncError
+from .verify import verify_files
+from .edit import autoedit, render_cuts, render_pip
+
+USAGE = __doc__
+
+
+def _cmd_sync(argv):
+    ap = argparse.ArgumentParser(prog="polysync sync")
+    ap.add_argument("reference", help="Reference recording (defines the timeline)")
+    ap.add_argument("source", help="Source to align to the reference")
+    ap.add_argument("--partial", action="store_true",
+                    help="Lenient mode for a source covering only part of the "
+                         "reference's span; degrades gracefully, writes only the "
+                         "source sidecar.")
+    args = ap.parse_args(argv)
+    try:
+        sync_files(args.reference, args.source, partial=args.partial)
+    except SyncError as e:
+        print("ERROR: %s" % e, file=sys.stderr)
+        return 1
+    return 0
+
+
+def _cmd_verify(argv):
+    ap = argparse.ArgumentParser(prog="polysync verify")
+    ap.add_argument("reference")
+    ap.add_argument("source")
+    ap.add_argument("sidecar", help="The source's <source>.sync.json")
+    ap.add_argument("--apply-drift", action="store_true")
+    ap.add_argument("--step", type=float, default=600.0,
+                    help="Probe spacing in seconds (default 10 min)")
+    args = ap.parse_args(argv)
+    try:
+        passed, _ = verify_files(args.reference, args.source, args.sidecar,
+                                 step=args.step, apply_drift=args.apply_drift)
+    except ValueError as e:
+        print("ERROR: %s" % e, file=sys.stderr)
+        return 2
+    return 0 if passed else 1
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        print(USAGE)
+        return 0
+    if argv[0] in ("-V", "--version"):
+        print("polysync %s" % __version__)
+        return 0
+
+    cmd, rest = argv[0], argv[1:]
+    dispatch = {
+        "sync": _cmd_sync,
+        "verify": _cmd_verify,
+        "edit": lambda a: autoedit.main(a) or 0,
+        "render-cuts": lambda a: render_cuts.main(a) or 0,
+        "render-pip": lambda a: render_pip.main(a) or 0,
+    }
+    if cmd not in dispatch:
+        print("Unknown command %r.\n%s" % (cmd, USAGE), file=sys.stderr)
+        return 2
+    return dispatch[cmd](rest)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

polysync/edit/__init__.py

@@ -0,0 +1,9 @@
+"""Director-style multicam auto-edit on top of polysync sidecars.
+
+autoedit  — build an EDL (which cam is on screen each second) from synced inputs
+render_cuts — render the EDL to one MP4 (hard cuts)
+render_pip  — render the EDL with a picture-in-picture inset
+"""
+from .autoedit import build_edl
+
+__all__ = ["build_edl"]

polysync/edit/autoedit.py

@@ -0,0 +1,321 @@
+"""Build a director-style EDL from N synced camera angles.
+
+Inputs are ORIGINAL untouched media; each should have a `<input>.sync.json`
+sidecar (from `polysync sync`). Sidecars give per-cam `delta_seconds` and
+`overlap_in_reference`. Missing sidecar => cam assumed at delta=0, full coverage.
+
+Decisions are audio-energy-driven only: per second, the cam whose mic is
+loudest relative to the others (active-speaker proxy) wins, subject to dwell
+hysteresis and coverage. No face/framing detection.
+"""
+import argparse
+import json
+import tempfile
+import warnings
+from pathlib import Path
+
+import numpy as np
+
+from .. import audio
+from ..sidecar import read_sidecar, SCHEMA_VERSION
+
+SR = 16000
+FRAME_HZ = 1.0
+ENV_HOP_MS = 100
+ENV_WIN_MS = 200
+
+
+def _per_sec_envelope(x):
+    """Log-RMS envelope of `x` collapsed to one value per reference second."""
+    rms, fsr = audio.frame_rms(x, SR, hop_ms=ENV_HOP_MS, win_ms=ENV_WIN_MS)
+    env = np.log(rms + 1e-3)
+    return env, fsr
+
+
+def _lift_to_reference(env, env_sr, delta_sec, total_ref_sec):
+    """Lift a cam-local per-frame envelope into the reference timeline at 1 Hz.
+
+    Reference second t reads the cam's local second (t - delta_sec). Seconds
+    outside the cam's recorded range become -inf so the editor never picks them.
+    """
+    n_per = int(env_sr / FRAME_HZ)
+    take = (len(env) // n_per) * n_per
+    local = env[:take].reshape(-1, n_per).mean(axis=1) if take else np.zeros(0)
+    out = np.full(total_ref_sec, -np.inf, dtype=np.float32)
+    for t in range(total_ref_sec):
+        tl = int(t - delta_sec)
+        if 0 <= tl < len(local):
+            out[t] = local[tl]
+    return out
+
+
+def _coverage_from_sidecar(input_path, total):
+    _, ovl, _ = read_sidecar(input_path)
+    if ovl is None:
+        return (0.0, float(total))
+    return (max(0.0, ovl[0]), min(float(total), ovl[1]))
+
+
+def _parse_coverage_flag(values, k_total, total):
+    cov = [(0.0, float(total))] * k_total
+    for v in (values or []):
+        parts = v.split(":")
+        if len(parts) != 3:
+            raise SystemExit("--coverage expects CAM:START:END, got %r" % v)
+        k = int(parts[0])
+        if not (0 <= k < k_total):
+            raise SystemExit("--coverage cam %d out of range" % k)
+        cov[k] = (float(parts[1]), float(parts[2]))
+    return cov
+
+
+def _covered_at(cov, t):
+    return [k for k, (s, e) in enumerate(cov) if s <= t < e]
+
+
+def rotation_edit(scores, coverage, min_dwell=8, max_dwell=15,
+                  opening_dwell=10, seed=42):
+    """Alternate among covered cams with varying dwell; force a switch when the
+    active cam leaves coverage."""
+    T, K = scores.shape
+    rng = np.random.default_rng(seed)
+    seq = np.full(T, -1, dtype=np.int32)
+
+    def best_at(t, candidates, win=opening_dwell):
+        end = min(T, t + win)
+        return max(candidates,
+                   key=lambda k: scores[t:end, k].mean() if end > t else scores[t, k])
+
+    # The overlap window often starts a few seconds in (no cam covers t=0).
+    # Open at the first covered second; leading seconds are backfilled below.
+    cur_set = _covered_at(coverage, 0)
+    t_open = 0
+    if not cur_set:
+        t_open = next((t for t in range(T) if _covered_at(coverage, t)), -1)
+        if t_open < 0:
+            raise SystemExit("No camera is covered at any time")
+        cur_set = _covered_at(coverage, t_open)
+    cur = best_at(t_open, cur_set)
+    t = t_open
+    while t < T:
+        dwell = int(rng.integers(min_dwell, max_dwell + 1))
+        end = t
+        while end < t + dwell and end < T:
+            if cur not in _covered_at(coverage, end):
+                break
+            seq[end] = cur
+            end += 1
+        if end >= T:
+            break
+        cands = [k for k in _covered_at(coverage, end) if k != cur]
+        if not cands:
+            cands = _covered_at(coverage, end)
+            if not cands:
+                seq[end] = cur
+                t = end + 1
+                continue
+        upcoming = min(T, end + 6)
+        cur = max(cands, key=lambda k: scores[end:upcoming, k].mean()
+                  if upcoming > end else scores[end, k])
+        t = end
+    for t in range(T):
+        if seq[t] == -1:
+            cands = _covered_at(coverage, t)
+            seq[t] = cands[0] if cands else 0
+    return seq
+
+
+def greedy_edit(scores, coverage, min_dwell=4, max_dwell=18, lookahead=4,
+                switch_threshold=0.0, opening_dwell=8):
+    """Greedy hard-cut editor with min/max dwell hysteresis."""
+    T, K = scores.shape
+
+    def win_mean(t, k, w):
+        end = min(T, t + w)
+        return scores[t:end, k].mean() if end > t else scores[t, k]
+
+    seq = np.full(T, -1, dtype=np.int32)
+    cands0 = _covered_at(coverage, 0)
+    t_open = 0
+    if not cands0:
+        t_open = next((t for t in range(T) if _covered_at(coverage, t)), -1)
+        if t_open < 0:
+            raise SystemExit("No camera is covered at any time")
+        cands0 = _covered_at(coverage, t_open)
+    seq[t_open] = max(cands0, key=lambda k: win_mean(t_open, k, opening_dwell))
+    streak = 1
+    for t in range(t_open + 1, T):
+        cur = seq[t - 1]
+        if cur not in _covered_at(coverage, t):
+            cands = [k for k in _covered_at(coverage, t) if k != cur] or _covered_at(coverage, t)
+            if not cands:
+                seq[t] = cur; streak += 1; continue
+            seq[t] = max(cands, key=lambda k: win_mean(t, k, lookahead))
+            streak = 1; continue
+        if streak < min_dwell:
+            seq[t] = cur; streak += 1; continue
+        cands = [k for k in _covered_at(coverage, t) if k != cur]
+        if not cands:
+            seq[t] = cur; streak += 1; continue
+        if streak >= max_dwell:
+            seq[t] = max(cands, key=lambda k: win_mean(t, k, lookahead))
+            streak = 1; continue
+        cur_s = win_mean(t, cur, lookahead)
+        best_k = max(cands, key=lambda k: win_mean(t, k, lookahead))
+        if win_mean(t, best_k, lookahead) > cur_s + switch_threshold:
+            seq[t] = best_k; streak = 1
+        else:
+            seq[t] = cur; streak += 1
+    # Backfill any leading uncovered seconds (before t_open) with a covered cam.
+    for t in range(T):
+        if seq[t] == -1:
+            cands = _covered_at(coverage, t)
+            seq[t] = cands[0] if cands else 0
+    return seq
+
+
+def edl_from_seq(seq):
+    edl = []
+    i = 0
+    while i < len(seq):
+        j = i
+        while j < len(seq) and seq[j] == seq[i]:
+            j += 1
+        edl.append({"start": float(i), "end": float(j), "cam": int(seq[i])})
+        i = j
+    return edl
+
+
+def build_edl(inputs, mode="rotation", audio_source=None, min_dwell=8,
+              max_dwell=15, switch_threshold=0.0, seed=42, coverage_flags=None,
+              verbose=True):
+    """Compute the EDL plan dict for a list of input paths."""
+    inputs = [Path(p) for p in inputs]
+    K = len(inputs)
+
+    deltas, cov_from_sc, has_sc = [], [], []
+    for p in inputs:
+        d, ovl, has = read_sidecar(p)
+        deltas.append(d); cov_from_sc.append(ovl); has_sc.append(has)
+    missing = [p.name for p, h in zip(inputs, has_sc) if not h]
+    if missing and verbose:
+        print("WARN: no sidecar for %s; assuming delta=0, full coverage. "
+              "Run `polysync sync` first if these should be offset." % missing)
+
+    durations, envs = [], []
+    with tempfile.TemporaryDirectory() as td:
+        td = Path(td)
+        for i, p in enumerate(inputs):
+            out = td / ("%d.pcm" % i)
+            audio.extract_pcm(p, out, SR)
+            x = audio.read_pcm(out)
+            durations.append(len(x) / SR)
+            envs.append(_per_sec_envelope(x))
+
+    cov_ends = [ovl[1] for ovl in cov_from_sc if ovl is not None]
+    total = int(max(cov_ends)) if cov_ends else int(min(durations))
+
+    per_sec = np.full((total, K), -np.inf, dtype=np.float32)
+    for k, (env, esr) in enumerate(envs):
+        per_sec[:, k] = _lift_to_reference(env, esr, deltas[k], total)
+
+    coverage = [_coverage_from_sidecar(p, total) for p in inputs]
+    if coverage_flags:
+        overrides = _parse_coverage_flag(coverage_flags, K, total)
+        for v in coverage_flags:
+            k = int(v.split(":")[0])
+            coverage[k] = overrides[k]
+
+    if verbose:
+        print("Cameras (%d):" % K)
+        for k, p in enumerate(inputs):
+            s, e = coverage[k]
+            print("  cam%d: %s  coverage [%.1f .. %.1f]s" % (k, p.name, s, e))
+
+    finite = np.where(np.isfinite(per_sec), per_sec, np.nan)
+    if K > 1:
+        scores = np.full_like(per_sec, -np.inf)
+        with warnings.catch_warnings():  # all-nan seconds -> nan, handled below
+            warnings.simplefilter("ignore", RuntimeWarning)
+            for k in range(K):
+                others = np.nanmean(np.delete(finite, k, axis=1), axis=1)
+                diff = finite[:, k] - others
+                scores[:, k] = np.where(np.isfinite(diff), diff, -np.inf)
+    else:
+        scores = per_sec.copy()
+
+    if audio_source is None:
+        spread = []
+        for k in range(K):
+            v = finite[:, k]
+            v = v[np.isfinite(v)]
+            spread.append(0.0 if len(v) == 0 else
+                          float(np.percentile(v, 90) - np.percentile(v, 10)))
+        cov_pct = np.array([(coverage[k][1] - coverage[k][0]) / max(1, total)
+                            for k in range(K)])
+        audio_src = int(np.argmax(np.array(spread) + 0.5 * cov_pct))
+    else:
+        audio_src = audio_source
+
+    if K == 1:
+        seq = np.zeros(total, dtype=np.int32)
+    elif mode == "rotation":
+        seq = rotation_edit(scores, coverage, min_dwell=min_dwell,
+                            max_dwell=max_dwell, seed=seed)
+    else:
+        seq = greedy_edit(scores, coverage, min_dwell=min_dwell,
+                          max_dwell=max_dwell, switch_threshold=switch_threshold)
+    edl = edl_from_seq(seq)
+
+    return {
+        "_about": ("EDL produced by polysync.edit.autoedit. Times are in the "
+                   "reference timeline. deltas[k] is the per-input offset; "
+                   "render scripts apply ffmpeg -itsoffset deltas[k] so they "
+                   "read original (un-trimmed) files."),
+        "schema_version": SCHEMA_VERSION,
+        "inputs": [str(p) for p in inputs],
+        "deltas": [float(d) for d in deltas],
+        "duration_sec": total,
+        "audio_source": audio_src,
+        "coverage": [list(c) for c in coverage],
+        "edl": edl,
+    }
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="polysync edit",
+                                 description="Build a multicam auto-edit EDL.")
+    ap.add_argument("inputs", type=Path, nargs="+",
+                    help="Synced video files (camera 0, 1, ...)")
+    ap.add_argument("--audio-source", type=int, default=None,
+                    help="Cam index to use as master audio (default: highest "
+                         "dynamic-range covered cam)")
+    ap.add_argument("--mode", choices=["rotation", "greedy"], default="rotation")
+    ap.add_argument("--min-dwell", type=int, default=8)
+    ap.add_argument("--max-dwell", type=int, default=15)
+    ap.add_argument("--switch-threshold", type=float, default=0.0)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--coverage", action="append", default=None,
+                    help="Override per-cam coverage CAM:START:END (repeatable)")
+    ap.add_argument("--out", type=Path, required=True, help="output EDL json")
+    args = ap.parse_args(argv)
+
+    plan = build_edl(
+        args.inputs, mode=args.mode, audio_source=args.audio_source,
+        min_dwell=args.min_dwell, max_dwell=args.max_dwell,
+        switch_threshold=args.switch_threshold, seed=args.seed,
+        coverage_flags=args.coverage,
+    )
+    args.out.write_text(json.dumps(plan, indent=2))
+    edl, total = plan["edl"], plan["duration_sec"]
+    print("\nEDL: %d segments; audio_source=cam%d; saved %s"
+          % (len(edl), plan["audio_source"], args.out))
+    counts = {}
+    for row in edl:
+        counts[row["cam"]] = counts.get(row["cam"], 0) + (row["end"] - row["start"])
+    for k, dur in sorted(counts.items()):
+        print("  cam%d: %.0fs on screen (%.0f%%)" % (k, dur, 100 * dur / total))
+
+
+if __name__ == "__main__":
+    main()

polysync/edit/render_cuts.py

@@ -0,0 +1,72 @@
+"""Render an autoedit EDL into one MP4 with hard cuts (no transitions / PiP).
+
+Applies each input's `delta` via `ffmpeg -itsoffset` so EDL times (reference
+timeline) work directly inside the filter graph — originals are read untouched.
+"""
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+
+def render_cuts(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
+                width=1920, height=1080, fps=30, run=True):
+    plan = json.loads(Path(edl_path).read_text())
+    inputs = plan["inputs"]
+    deltas = plan.get("deltas", [0.0] * len(inputs))
+    edl = plan["edl"]
+    audio_src = plan["audio_source"]
+    W, H = width, height
+
+    cmd = ["ffmpeg", "-nostdin", "-y"]
+    for src, dlt in zip(inputs, deltas):
+        if abs(dlt) > 1e-9:
+            cmd.extend(["-itsoffset", "%.6f" % dlt])
+        cmd.extend(["-i", src])
+
+    filters = []
+    for i, row in enumerate(edl):
+        filters.append(
+            "[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,"
+            "scale=%d:%d:force_original_aspect_ratio=decrease,"
+            "pad=%d:%d:(ow-iw)/2:(oh-ih)/2,setsar=1,fps=%d[v%d]"
+            % (row["cam"], row["start"], row["end"], W, H, W, H, fps, i)
+        )
+    concat = "".join("[v%d]" % i for i in range(len(edl)))
+    filters.append("%sconcat=n=%d:v=1:a=0[vout]" % (concat, len(edl)))
+    fc = ";".join(filters)
+
+    audio_offset = edl[0]["start"] if edl else 0.0
+    duration = plan["duration_sec"]
+    fc += (";[%d:a:0]atrim=start=%s:duration=%s,asetpts=PTS-STARTPTS[aout]"
+           % (audio_src, audio_offset, duration))
+    cmd.extend([
+        "-filter_complex", fc,
+        "-map", "[vout]", "-map", "[aout]",
+        "-t", str(duration),
+        "-c:v", encoder, "-b:v", bitrate, "-tag:v", "hvc1",
+        "-c:a", "aac", "-b:a", "192k",
+        "-movflags", "+faststart", str(out),
+    ])
+    if run:
+        print(" ".join(cmd))
+        subprocess.run(cmd, check=True)
+    return cmd
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="polysync render-cuts")
+    ap.add_argument("edl", type=Path)
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--encoder", default="hevc_videotoolbox")
+    ap.add_argument("--bitrate", default="12M")
+    ap.add_argument("--width", type=int, default=1920)
+    ap.add_argument("--height", type=int, default=1080)
+    ap.add_argument("--fps", type=int, default=30)
+    args = ap.parse_args(argv)
+    render_cuts(args.edl, args.out, encoder=args.encoder, bitrate=args.bitrate,
+                width=args.width, height=args.height, fps=args.fps)
+
+
+if __name__ == "__main__":
+    main()