polysync 0.1.0__tar.gz → 0.2.0__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polysync"
-version = "0.1.0"
+version = "0.2.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.2.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.2.0"
 __all__ = [
     "compute_sync", "SyncResult", "SyncError",
     "read_sidecar", "write_sidecar", "sidecar_path", "SCHEMA_VERSION",

polysync-0.2.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.1.0 → polysync-0.2.0}/src/polysync/edit/render_cuts.py

@@ -2,21 +2,30 @@
 
 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
 from pathlib import Path
 
+from .grade import resolve_lut, parse_rotate, segment_filter
+
 
 def render_cuts(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
-                width=1920, height=1080, fps=30, run=True):
+                width=1920, height=1080, fps=30, lut=None, log=None,
+                rotate=None, fill=False, 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
+    lut_path = resolve_lut(lut, log)
+    rot = parse_rotate(rotate)
 
     cmd = ["ffmpeg", "-nostdin", "-y"]
     for src, dlt in zip(inputs, deltas):
@@ -24,14 +33,11 @@ def render_cuts(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
             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)
-        )
+    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)
@@ -63,9 +69,16 @@ def main(argv=None):
     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)")
     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)
+                width=args.width, height=args.height, fps=args.fps,
+                lut=args.lut, log=args.log, rotate=args.rotate, fill=args.fill)
 
 
 if __name__ == "__main__":

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

@@ -11,6 +11,8 @@ import json
 import subprocess
 from pathlib import Path
 
+from .grade import resolve_lut, parse_rotate, _transpose_chain
+
 POSITIONS = {
     "bottom-right": ("W-w-{m}", "H-h-{m}"),
     "top-right":    ("W-w-{m}", "{m}"),
@@ -41,7 +43,7 @@ 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, run=True):
     plan = json.loads(Path(edl_path).read_text())
     inputs = plan["inputs"]
     deltas = plan.get("deltas", [0.0] * len(inputs))
@@ -49,6 +51,9 @@ def render_pip(edl_path, out, encoder="hevc_videotoolbox", bitrate="12M",
     audio_src = plan["audio_source"]
     K = len(inputs)
     coverage = plan.get("coverage", [[0.0, plan["duration_sec"]]] * K)
+    lut_path = resolve_lut(lut, log)
+    rot = parse_rotate(rotate)
+    grade = ("lut3d=%s," % lut_path) if lut_path else ""
 
     W, H = width, height
     pw = pip_width
@@ -70,10 +75,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 +88,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)
@@ -130,11 +137,16 @@ 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")
     args = ap.parse_args(argv)
     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)
 
 
 if __name__ == "__main__":

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

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

@@ -15,6 +15,7 @@ src/polysync.egg-info/requires.txt
 src/polysync.egg-info/top_level.txt
 src/polysync/edit/__init__.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