polysync 0.1.0__tar.gz → 0.3.0__tar.gz

{polysync-0.1.0/src/polysync.egg-info → polysync-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysync
-Version: 0.1.0
+Version: 0.3.0
 Summary: Multicam audio sync and director-style auto-edit — align N angles of one event by audio cross-correlation, then cut/PiP them into one MP4. Reversible sidecars, never re-encodes the originals.
 Author: 王建硕 (Jian Shuo Wang)
 License: MIT

{polysync-0.1.0 → polysync-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polysync"
-version = "0.1.0"
+version = "0.3.0"
 description = "Multicam audio sync and director-style auto-edit — align N angles of one event by audio cross-correlation, then cut/PiP them into one MP4. Reversible sidecars, never re-encodes the originals."
 readme = "README.md"
 requires-python = ">=3.9"

{polysync-0.1.0 → polysync-0.3.0}/src/polysync/__init__.py

@@ -11,7 +11,7 @@ Public API:
 from .sync import compute_sync, SyncResult, SyncError
 from .sidecar import read_sidecar, write_sidecar, sidecar_path, SCHEMA_VERSION
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 __all__ = [
     "compute_sync", "SyncResult", "SyncError",
     "read_sidecar", "write_sidecar", "sidecar_path", "SCHEMA_VERSION",

polysync-0.3.0/src/polysync/edit/audiomix.py

@@ -0,0 +1,124 @@
+"""Speaker-gated ("ducked") audio mix for multicam interviews.
+
+The default render takes a single camera's mic as the soundtrack. With close,
+bleeding mics that's noisy: every mic also picks up the *other* speaker plus room
+tone, so a constant sum sounds muddy and loudness-normalization pumps the bleed
+up during pauses. This builds a cleaner track instead: per moment, keep only the
+ACTIVE speaker's mic at full level and duck the rest.
+
+Who's active is decided by each mic's energy relative to ITS OWN baseline (not
+absolute level) — that's what tracks the talker despite a louder close mic
+bleeding. Far/room mics (e.g. a wide establishing cam) are auto-excluded: any
+mic whose overall level is >`exclude_db` below the loudest is dropped as an
+audio candidate so the reverby room mic is never selected.
+
+`build_ducked_audio` returns a finished wav (gated → high-pass → light denoise →
+loudness-normalized). The renderers use it in place of the single-cam audio when
+`--duck-audio` is passed.
+"""
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+from .. import audio
+
+
+def _aligned_mic(path, delta, sr, n):
+    """Extract a cam's loudest mic at `sr`, shifted into the reference timeline
+    (so index t corresponds to reference second t/sr), length `n` samples."""
+    with tempfile.NamedTemporaryFile(suffix=".pcm", delete=False) as tf:
+        tmp = tf.name
+    audio.extract_pcm(path, tmp, sr)          # loudest stream, mono
+    x = audio.read_pcm(tmp)
+    Path(tmp).unlink(missing_ok=True)
+    pad = int(round(delta * sr))
+    if pad > 0:
+        x = np.concatenate([np.zeros(pad, np.float32), x])
+    elif pad < 0:
+        x = x[-pad:]
+    if len(x) < n:
+        x = np.pad(x, (0, n - len(x)))
+    return x[:n]
+
+
+def build_ducked_audio(inputs, deltas, coverage, duration, out_path, sr=48000,
+                       duck_db=-18.0, frame_ms=100.0, margin=0.20,
+                       exclude_db=14.0, audio_cams=None, verbose=True):
+    """Write a speaker-gated, cleaned wav to `out_path`. Returns out_path.
+
+    `audio_cams` (list of cam indices) explicitly picks which mics to gate among
+    — use it to exclude a wide/room mic that sits at a similar LEVEL to a real
+    speaker mic (level alone can't tell a close lav from a near room mic). If
+    None, fall back to dropping any mic >`exclude_db` below the loudest.
+    """
+    n = int(duration * sr)
+    mics = [_aligned_mic(p, d, sr, n) for p, d in zip(inputs, deltas)]
+
+    lvl = np.array([20 * np.log10(np.sqrt(np.mean(m ** 2)) + 1e-6) for m in mics])
+    if audio_cams:
+        keep = [k for k in audio_cams if 0 <= k < len(mics)]
+    else:
+        keep = [k for k in range(len(mics)) if lvl[k] >= lvl.max() - exclude_db]
+    if verbose:
+        print("  mic levels(dB): %s; audio candidates: %s"
+              % ([round(float(x), 1) for x in lvl], keep))
+
+    hop = int(frame_ms / 1000 * sr)
+    nf = n // hop
+
+    def frame_logE(x):
+        return np.array([np.log(np.sqrt(np.mean(x[i*hop:(i+1)*hop] ** 2) + 1) + 1)
+                         for i in range(nf)])
+
+    # coverage mask per cam (frames where the cam has valid footage in ref time)
+    cov = np.zeros((len(mics), nf), dtype=bool)
+    for k in range(len(mics)):
+        s, e = coverage[k] if k < len(coverage) else (0.0, duration)
+        cov[k, max(0, int(s/ (frame_ms/1000))): int(e/(frame_ms/1000))] = True
+
+    # baseline-normalized energy per candidate
+    norm = np.full((len(mics), nf), -1e9)
+    for k in keep:
+        E = frame_logE(mics[k])
+        base = np.median(E[cov[k]]) if cov[k].any() else np.median(E)
+        norm[k] = np.where(cov[k], E - base, -1e9)
+
+    # active cam per frame = argmax normalized among covered candidates
+    active = np.full(nf, keep[0], dtype=int)
+    for f in range(nf):
+        vals = [(norm[k, f], k) for k in keep if cov[k, f]]
+        if vals:
+            active[f] = max(vals)[1]
+
+    # gain mask per cam (active=1 else duck), smoothed to crossfade
+    duck = 10 ** (duck_db / 20.0)
+    out = np.zeros(n, dtype=np.float32)
+    ker = np.ones(int(0.2 * sr)) / int(0.2 * sr)
+    for k in range(len(mics)):
+        if k not in keep:
+            continue
+        gf = np.where(active == k, 1.0, duck)
+        gs = np.repeat(gf, hop)
+        gs = np.pad(gs, (0, n - len(gs)), mode="edge")
+        gs = np.convolve(gs, ker, "same")
+        out += mics[k] * gs
+
+    pk = np.max(np.abs(out))
+    if pk > 0:
+        out *= 0.95 * 32767 / pk
+    with tempfile.NamedTemporaryFile(suffix=".pcm", delete=False) as tf:
+        raw = tf.name
+    out.astype(np.int16).tofile(raw)
+
+    # high-pass rumble, light FFT denoise, loudness-normalize -> finished wav
+    subprocess.run(
+        ["ffmpeg", "-nostdin", "-y", "-hide_banner", "-loglevel", "error",
+         "-f", "s16le", "-ar", str(sr), "-ac", "1", "-i", raw,
+         "-af", "highpass=f=70,afftdn=nr=10,loudnorm=I=-16:TP=-1.5:LRA=11",
+         "-ar", str(sr), "-ac", "2", str(out_path)],
+        check=True,
+    )
+    Path(raw).unlink(missing_ok=True)
+    return out_path

polysync-0.3.0/src/polysync/edit/grade.py

@@ -0,0 +1,110 @@
+"""Color grading + orientation helpers for the renderers.
+
+Raw camera footage almost never renders correctly straight off the card. Two
+things bite every time and are handled here:
+
+1. **Log color.** Sony cameras (FX3/FX6) shoot S-Log3 / S-Gamut3.Cine by default
+   — flat, grey, low-contrast. It MUST be converted to Rec.709 with a LUT or it
+   looks broken. Check the `.XML` sidecar's `CaptureGammaEquation` (`s-log3-cine`)
+   or run `ffprobe ... color_transfer`. `--log slog3` generates and applies the
+   conversion LUT for you.
+2. **Orientation.** Phones / vertically-mounted cameras record rotated. Some
+   (FX3) write a rotation flag and ffmpeg auto-rotates; others (FX6 turned on its
+   side) write NO flag and come out lying down. `--rotate cam:deg` fixes those.
+
+Performance note baked into `segment_filter`: the LUT is applied AFTER the
+downscale, not before. A 3D LUT on 4K (8 MP) is ~4x slower than on 1080p — and
+the result is visually identical. Always scale, then grade.
+"""
+import os
+import tempfile
+
+import numpy as np
+
+
+def make_slog3_709_lut(path, size=33):
+    """Write a Sony S-Log3 / S-Gamut3.Cine -> Rec.709 3D LUT (.cube) to `path`."""
+    def slog3_to_lin(n):  # n in [0,1] == 10-bit code value / 1023
+        cv = n * 1023.0
+        return np.where(
+            cv >= 171.2102946929,
+            (10 ** ((cv - 420.0) / 261.5)) * 0.19 - 0.01,
+            (cv - 95.0) * 0.01125000 / (171.2102946929 - 95.0),
+        )
+    # S-Gamut3.Cine -> Rec.709 (linear) matrix, D65
+    M = np.array([[1.6269, -0.3576, -0.2693],
+                  [-0.0928, 1.3478, -0.2550],
+                  [0.0387, -0.1622, 1.1235]])
+    def oetf709(L):
+        L = np.clip(L, 0, 1)
+        return np.where(L < 0.018, 4.5 * L, 1.099 * np.power(L, 0.45) - 0.099)
+    lines = ["TITLE \"SLog3 SGamut3Cine to Rec709\"", f"LUT_3D_SIZE {size}",
+             "DOMAIN_MIN 0 0 0", "DOMAIN_MAX 1 1 1"]
+    for b in range(size):
+        for g in range(size):
+            for r in range(size):
+                lin = slog3_to_lin(np.array([r, g, b]) / (size - 1))
+                out = oetf709(M @ lin)
+                lines.append("%.6f %.6f %.6f" % (out[0], out[1], out[2]))
+    with open(path, "w") as f:
+        f.write("\n".join(lines) + "\n")
+    return path
+
+
+# Built-in log profiles -> on-the-fly LUT generators. Cached in tempdir so
+# repeated render calls in one session don't regenerate.
+_BUILTIN = {"slog3": make_slog3_709_lut}
+
+
+def resolve_lut(lut=None, log=None):
+    """Return a .cube path: explicit `lut` file wins; else generate from `log`."""
+    if lut:
+        return lut
+    if not log:
+        return None
+    key = log.lower()
+    if key not in _BUILTIN:
+        raise SystemExit("unknown --log %r (known: %s)" % (log, ", ".join(_BUILTIN)))
+    cache = os.path.join(tempfile.gettempdir(), "polysync_%s_709.cube" % key)
+    if not os.path.exists(cache):
+        _BUILTIN[key](cache)
+    return cache
+
+
+def parse_rotate(values):
+    """Parse repeatable `--rotate cam:deg` into {cam_index: degrees}. Degrees in
+    {90, 180, 270, -90}. 90 = clockwise."""
+    out = {}
+    for v in (values or []):
+        cam, _, deg = v.partition(":")
+        out[int(cam)] = int(deg)
+    return out
+
+
+def _transpose_chain(deg):
+    """ffmpeg filter fragment to rotate `deg` clockwise (90/180/270/-90)."""
+    deg = deg % 360
+    if deg == 90:
+        return "transpose=1,"
+    if deg == 270:
+        return "transpose=2,"
+    if deg == 180:
+        return "transpose=1,transpose=1,"
+    return ""
+
+
+def segment_filter(cam, start, end, idx, W, H, fps, rotate_deg=0, lut=None,
+                   pip=False):
+    """Build one segment's video filter chain. Order: trim -> rotate -> scale ->
+    crop/pad -> LUT (after downscale, for speed) -> sar -> fps. With `pip=True`
+    the frame fills (crop) instead of pad — used for main/inset tiles."""
+    rot = _transpose_chain(rotate_deg)
+    if pip:
+        fit = ("scale=%d:%d:force_original_aspect_ratio=increase,crop=%d:%d"
+               % (W, H, W, H))
+    else:
+        fit = ("scale=%d:%d:force_original_aspect_ratio=decrease,"
+               "pad=%d:%d:(ow-iw)/2:(oh-ih)/2" % (W, H, W, H))
+    grade = ("lut3d=%s," % lut) if lut else ""
+    return ("[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,%s%s,%ssetsar=1,"
+            "fps=%d[v%d]" % (cam, start, end, rot, fit, grade, fps, idx))

polysync-0.3.0/src/polysync/edit/render_cuts.py

@@ -0,0 +1,112 @@
+"""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.
+
+Raw footage usually needs `--log slog3` (Sony S-Log3 -> Rec.709 grade) and, for
+vertically-shot cameras with no rotation flag, `--rotate cam:90`. For vertical
+delivery (小红书 / Reels / Shorts) pass `--width 1080 --height 1920 --fill`.
+"""
+import argparse
+import json
+import subprocess
+import tempfile
+from pathlib import Path
+
+from .grade import resolve_lut, parse_rotate, segment_filter
+from .audiomix import build_ducked_audio
+
+
+def render_cuts(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
+                width=1920, height=1080, fps=30, lut=None, log=None,
+                rotate=None, fill=False, duck_audio=False, duck_db=-18.0,
+                audio_cams=None, 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"]
+    duration = plan["duration_sec"]
+    W, H = width, height
+    lut_path = resolve_lut(lut, log)
+    rot = parse_rotate(rotate)
+
+    # Speaker-gated soundtrack: build a cleaned wav up front, use it as the audio.
+    ducked_wav = None
+    if duck_audio:
+        coverage = plan.get("coverage", [[0.0, duration]] * len(inputs))
+        ducked_wav = str(Path(tempfile.mkdtemp()) / "ducked.wav")
+        build_ducked_audio(inputs, deltas, coverage, duration, ducked_wav,
+                           duck_db=duck_db, audio_cams=audio_cams)
+
+    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])
+    if ducked_wav:
+        cmd.extend(["-i", ducked_wav])           # extra input, already ref-aligned
+
+    filters = [
+        segment_filter(row["cam"], row["start"], row["end"], i, W, H, fps,
+                       rotate_deg=rot.get(row["cam"], 0), lut=lut_path, pip=fill)
+        for i, row in enumerate(edl)
+    ]
+    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)
+
+    cmd.extend(["-filter_complex", fc, "-map", "[vout]"])
+    if ducked_wav:
+        cmd.extend(["-map", "%d:a:0" % len(inputs)])
+    else:
+        audio_offset = edl[0]["start"] if edl else 0.0
+        fc2 = ("[%d:a:0]atrim=start=%s:duration=%s,asetpts=PTS-STARTPTS[aout]"
+               % (audio_src, audio_offset, duration))
+        cmd[cmd.index("-filter_complex") + 1] = fc + ";" + fc2
+        cmd.extend(["-map", "[aout]"])
+    cmd.extend([
+        "-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)
+    ap.add_argument("--lut", help="3D LUT (.cube) applied after downscale")
+    ap.add_argument("--log", help="built-in log->Rec.709 grade (e.g. slog3)")
+    ap.add_argument("--rotate", action="append",
+                    help="per-cam rotation CAM:DEG (90=CW), repeatable")
+    ap.add_argument("--fill", action="store_true",
+                    help="crop to fill instead of letterbox-pad (use for vertical)")
+    ap.add_argument("--duck-audio", action="store_true",
+                    help="speaker-gated soundtrack: keep the active speaker's mic, "
+                         "duck the rest (cleaner than a single-cam mic for interviews)")
+    ap.add_argument("--duck-db", type=float, default=-18.0,
+                    help="level of ducked (inactive) mics, dB (default -18)")
+    ap.add_argument("--audio-cams",
+                    help="comma-separated cam indices to gate among (e.g. 0,1) — "
+                         "exclude wide/room mics; default = auto by level")
+    args = ap.parse_args(argv)
+    cams = [int(x) for x in args.audio_cams.split(",")] if args.audio_cams else None
+    render_cuts(args.edl, args.out, encoder=args.encoder, bitrate=args.bitrate,
+                width=args.width, height=args.height, fps=args.fps,
+                lut=args.lut, log=args.log, rotate=args.rotate, fill=args.fill,
+                duck_audio=args.duck_audio, duck_db=args.duck_db, audio_cams=cams)
+
+
+if __name__ == "__main__":
+    main()

{polysync-0.1.0 → polysync-0.3.0}/src/polysync/edit/render_pip.py

@@ -9,8 +9,12 @@ Per-segment EDL rows may carry a `pip` field (cam index) to override the picker.
 import argparse
 import json
 import subprocess
+import tempfile
 from pathlib import Path
 
+from .grade import resolve_lut, parse_rotate, _transpose_chain
+from .audiomix import build_ducked_audio
+
 POSITIONS = {
     "bottom-right": ("W-w-{m}", "H-h-{m}"),
     "top-right":    ("W-w-{m}", "{m}"),
@@ -41,14 +45,25 @@ def pick_pip(row, K, coverage, mode="next"):
 def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
                width=1920, height=1080, fps=30, pip="bottom-right",
                pip_width=480, pip_margin=24, border_px=4, pip_pick="next",
-               run=True):
+               lut=None, log=None, rotate=None, duck_audio=False, duck_db=-18.0,
+               audio_cams=None, 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"]
+    duration = plan["duration_sec"]
     K = len(inputs)
-    coverage = plan.get("coverage", [[0.0, plan["duration_sec"]]] * K)
+    coverage = plan.get("coverage", [[0.0, duration]] * K)
+    lut_path = resolve_lut(lut, log)
+    rot = parse_rotate(rotate)
+    grade = ("lut3d=%s," % lut_path) if lut_path else ""
+
+    ducked_wav = None
+    if duck_audio:
+        ducked_wav = str(Path(tempfile.mkdtemp()) / "ducked.wav")
+        build_ducked_audio(inputs, deltas, coverage, duration, ducked_wav,
+                           duck_db=duck_db, audio_cams=audio_cams)
 
     W, H = width, height
     pw = pip_width
@@ -63,6 +78,8 @@ def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
         if abs(dlt) > 1e-9:
             cmd.extend(["-itsoffset", "%.6f" % dlt])
         cmd.extend(["-i", src])
+    if ducked_wav:
+        cmd.extend(["-i", ducked_wav])           # extra input, already ref-aligned
 
     filters = []
     for i, row in enumerate(edl):
@@ -70,10 +87,11 @@ def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
         s, e = row["start"], row["end"]
         main_label = "m%d" % i if K > 1 else "v%d" % i
         filters.append(
-            "[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,"
+            "[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,%s"
             "scale=%d:%d:force_original_aspect_ratio=decrease,"
-            "pad=%d:%d:(ow-iw)/2:(oh-ih)/2,setsar=1,fps=%d[%s]"
-            % (cam, s, e, W, H, W, H, fps, main_label)
+            "pad=%d:%d:(ow-iw)/2:(oh-ih)/2,%ssetsar=1,fps=%d[%s]"
+            % (cam, s, e, _transpose_chain(rot.get(cam, 0)),
+               W, H, W, H, grade, fps, main_label)
         )
         if K == 1:
             continue
@@ -82,10 +100,11 @@ def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
             filters.append("[m%d]copy[v%d]" % (i, i))
             continue
         chain = (
-            "[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,"
+            "[%d:v]trim=start=%s:end=%s,setpts=PTS-STARTPTS,%s"
             "scale=%d:%d:force_original_aspect_ratio=decrease,"
-            "pad=%d:%d:(ow-iw)/2:(oh-ih)/2,"
-            % (pip_cam, s, e, pw, ph, pw, ph)
+            "pad=%d:%d:(ow-iw)/2:(oh-ih)/2,%s"
+            % (pip_cam, s, e, _transpose_chain(rot.get(pip_cam, 0)),
+               pw, ph, pw, ph, grade)
         )
         if bw > 0:
             chain += "pad=%d:%d:%d:%d:white," % (pw + 2 * bw, ph + 2 * bw, bw, bw)
@@ -96,14 +115,19 @@ def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
 
     concat = "".join("[v%d]" % i for i in range(len(edl)))
     filters.append("%sconcat=n=%d:v=1:a=0[vout]" % (concat, len(edl)))
-    audio_offset = edl[0]["start"] if edl else 0.0
-    dur = plan["duration_sec"]
+    dur = duration
     fc = ";".join(filters)
-    fc += (";[%d:a:0]atrim=start=%s:duration=%s,asetpts=PTS-STARTPTS[aout]"
-           % (audio_src, audio_offset, dur))
+    cmd.extend(["-filter_complex", None, "-map", "[vout]"])  # fc filled below
+    if ducked_wav:
+        cmd[cmd.index("-filter_complex") + 1] = fc
+        cmd.extend(["-map", "%d:a:0" % K])
+    else:
+        audio_offset = edl[0]["start"] if edl else 0.0
+        fc += (";[%d:a:0]atrim=start=%s:duration=%s,asetpts=PTS-STARTPTS[aout]"
+               % (audio_src, audio_offset, dur))
+        cmd[cmd.index("-filter_complex") + 1] = fc
+        cmd.extend(["-map", "[aout]"])
     cmd.extend([
-        "-filter_complex", fc,
-        "-map", "[vout]", "-map", "[aout]",
         "-t", str(dur),
         "-c:v", encoder, "-b:v", bitrate, "-tag:v", "hvc1",
         "-c:a", "aac", "-b:a", "192k",
@@ -130,11 +154,24 @@ def main(argv=None):
     ap.add_argument("--pip-margin", type=int, default=24)
     ap.add_argument("--border-px", type=int, default=4)
     ap.add_argument("--pip-pick", choices=["next", "second-best"], default="next")
+    ap.add_argument("--lut", help="3D LUT (.cube) applied after downscale")
+    ap.add_argument("--log", help="built-in log->Rec.709 grade (e.g. slog3)")
+    ap.add_argument("--rotate", action="append",
+                    help="per-cam rotation CAM:DEG (90=CW), repeatable")
+    ap.add_argument("--duck-audio", action="store_true",
+                    help="speaker-gated soundtrack (keep active speaker's mic, duck rest)")
+    ap.add_argument("--duck-db", type=float, default=-18.0,
+                    help="level of ducked (inactive) mics, dB (default -18)")
+    ap.add_argument("--audio-cams",
+                    help="comma-separated cam indices to gate among (e.g. 0,1)")
     args = ap.parse_args(argv)
+    cams = [int(x) for x in args.audio_cams.split(",")] if args.audio_cams else None
     render_pip(args.edl, args.out, encoder=args.encoder, bitrate=args.bitrate,
                width=args.width, height=args.height, fps=args.fps, pip=args.pip,
                pip_width=args.pip_width, pip_margin=args.pip_margin,
-               border_px=args.border_px, pip_pick=args.pip_pick)
+               border_px=args.border_px, pip_pick=args.pip_pick,
+               lut=args.lut, log=args.log, rotate=args.rotate,
+               duck_audio=args.duck_audio, duck_db=args.duck_db, audio_cams=cams)
 
 
 if __name__ == "__main__":

{polysync-0.1.0 → polysync-0.3.0/src/polysync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysync
-Version: 0.1.0
+Version: 0.3.0
 Summary: Multicam audio sync and director-style auto-edit — align N angles of one event by audio cross-correlation, then cut/PiP them into one MP4. Reversible sidecars, never re-encodes the originals.
 Author: 王建硕 (Jian Shuo Wang)
 License: MIT

{polysync-0.1.0 → polysync-0.3.0}/src/polysync.egg-info/SOURCES.txt

@@ -14,7 +14,9 @@ src/polysync.egg-info/entry_points.txt
 src/polysync.egg-info/requires.txt
 src/polysync.egg-info/top_level.txt
 src/polysync/edit/__init__.py
+src/polysync/edit/audiomix.py
 src/polysync/edit/autoedit.py
+src/polysync/edit/grade.py
 src/polysync/edit/render_cuts.py
 src/polysync/edit/render_pip.py
 tests/test_sync_synthetic.py

polysync-0.1.0/src/polysync/edit/render_cuts.py

@@ -1,72 +0,0 @@
-"""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()