polysync 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysync
-Version: 0.2.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.2.0 → polysync-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polysync"
-version = "0.2.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.2.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.2.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.2.0 → polysync-0.3.0}/src/polysync/edit/render_cuts.py

@@ -10,28 +10,42 @@ 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, run=True):
+                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,
@@ -42,13 +56,16 @@ def render_cuts(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
     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]"])
+    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([
-        "-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",
@@ -75,10 +92,20 @@ def main(argv=None):
                     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)
+                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__":

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

@@ -9,9 +9,11 @@ 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}"),
@@ -43,18 +45,26 @@ 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",
-               lut=None, log=None, rotate=None, 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
     ph = round(pw * 9 / 16)
@@ -68,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):
@@ -103,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",
@@ -141,12 +158,20 @@ def main(argv=None):
     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,
-               lut=args.lut, log=args.log, rotate=args.rotate)
+               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.2.0 → polysync-0.3.0/src/polysync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysync
-Version: 0.2.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.2.0 → polysync-0.3.0}/src/polysync.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ 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