renoise-kit 0.5.0__py3-none-any.whl

rn/compare.py

@@ -0,0 +1,115 @@
+"""rn compare: two videos side by side at the same times (a cut against its reference, or two versions of a cut).
+Measurement only: it shows where they differ in picture and cut timing, never which is better."""
+from __future__ import annotations
+
+import math
+import tempfile
+from pathlib import Path
+
+from .ff import RnError, probe, run, source_fps
+from .frames import _compose, _save_under, _timecode, extract
+
+PER_PAGE = 6  # times per page: A on the top row, B underneath
+CUT_TOLERANCE = 0.25  # seconds: a cut in B this close to one in A counts as the same cut
+
+
+def _video(path: str) -> dict:
+    info = probe(path)
+    if not info['video'] or info['video']['still']:
+        raise RnError(f'{path}: not a video')
+    return info
+
+
+def match_cuts(a: list[float], b: list[float], tolerance: float = CUT_TOLERANCE) -> dict:
+    """Pairs each cut in A with the nearest unused cut in B within `tolerance`; offset = B - A in seconds."""
+    unused = list(b)
+    pairs = []
+    for t in a:
+        near = min(unused, key=lambda u: abs(u - t), default=None)
+        if near is not None and abs(near - t) <= tolerance:
+            unused.remove(near)
+            pairs.append({'a': t, 'b': near, 'offset': round(near - t, 4)})
+        else:
+            pairs.append({'a': t, 'b': None, 'offset': None})
+    matched = [p['offset'] for p in pairs if p['offset'] is not None]
+    return {'pairs': pairs, 'only_b': unused, 'matched': len(matched),
+            'mean_abs_offset': round(sum(abs(o) for o in matched) / len(matched), 4) if matched else None}
+
+
+def compare_command(path_a: str, path_b: str, *, out: str | None, count: int | None, seconds: list[float] | None, width: int,
+                    max_kb: int, cuts: bool, video: str | None) -> dict:
+    from PIL import Image, ImageOps
+
+    info_a, info_b = _video(path_a), _video(path_b)
+    fps_a, fps_b = source_fps(info_a), source_fps(info_b)
+    frames_a, frames_b = info_a['video']['frames'], info_b['video']['frames']
+    length = max(float(frames_a / fps_a), float(frames_b / fps_b))
+    if seconds:
+        times = sorted({t for t in seconds if 0 <= t < length})
+    else:
+        n = max(1, count or 12)
+        times = [round(k * length / n, 3) for k in range(n)]
+    if not times:
+        raise RnError(f'no times inside the longer video ({length:.2f}s)')
+    index_a = {t: math.floor(t * float(fps_a) + 1e-6) for t in times}
+    index_b = {t: math.floor(t * float(fps_b) + 1e-6) for t in times}
+
+    base = Path(out) if out else Path('sheets') / f'compare-{Path(path_a).stem}-{Path(path_b).stem}.jpg'
+    base.parent.mkdir(parents=True, exist_ok=True)
+    pages = []
+    with tempfile.TemporaryDirectory() as tmp:
+        (Path(tmp) / 'a').mkdir()
+        (Path(tmp) / 'b').mkdir()
+        images = {}
+        for side, path, indices, frames in (('a', path_a, index_a, frames_a), ('b', path_b, index_b, frames_b)):
+            wanted = [i for i in indices.values() if i < frames]
+            if wanted:  # the shorter video may have no frame at any of the chosen times
+                images.update({(side, i): Image.open(p).convert('RGB') for i, p in extract(path, wanted, Path(tmp) / side, width=width)})
+        tile_h = max(image.height for image in images.values())
+        blank = Image.new('RGB', (width, tile_h))
+        page_count = math.ceil(len(times) / PER_PAGE)
+        for page in range(page_count):
+            part = times[page * PER_PAGE:(page + 1) * PER_PAGE]
+            row_a = [ImageOps.pad(images[('a', index_a[t])], (width, tile_h)) if ('a', index_a[t]) in images else blank for t in part]
+            row_b = [ImageOps.pad(images[('b', index_b[t])], (width, tile_h)) if ('b', index_b[t]) in images else blank for t in part]
+            labels = [f'A #{index_a[t]}  {_timecode(index_a[t], fps_a)}' for t in part] + \
+                     [f'B #{index_b[t]}  {_timecode(index_b[t], fps_b)}' for t in part]
+            target = base if page_count == 1 else base.with_name(f'{base.stem}-p{page + 1}{base.suffix or ".jpg"}')
+            title = f'top A {Path(path_a).name} ({fps_a}fps {frames_a}f)   bottom B {Path(path_b).name} ({fps_b}fps {frames_b}f)'
+            size = _save_under(_compose([], fps_a, len(part), title, row_a + row_b, labels), target, max_kb)
+            pages.append({'path': str(target), 'times': part, 'bytes': size})
+
+    result: dict = {'a': {'path': path_a, 'fps': str(fps_a), 'frames': frames_a, 'duration': round(float(frames_a / fps_a), 4)},
+                    'b': {'path': path_b, 'fps': str(fps_b), 'frames': frames_b, 'duration': round(float(frames_b / fps_b), 4)},
+                    'pages': pages}
+    if cuts:
+        from .cuts import detect
+        cuts_a = [c['time'] for c in detect(str(Path(path_a).resolve()))['cuts']]
+        cuts_b = [c['time'] for c in detect(str(Path(path_b).resolve()))['cuts']]
+        result['cuts'] = {'a': cuts_a, 'b': cuts_b, **match_cuts(cuts_a, cuts_b)}
+    if video:
+        # Same height side by side, A's sound; the shorter one holds its last frame.
+        height = min(720, info_a['video']['height']) // 2 * 2
+        run(['ffmpeg', '-i', path_a, '-i', path_b, '-filter_complex',
+             f'[0:v]scale=-2:{height},setsar=1[a];[1:v]scale=-2:{height},setsar=1[b];[a][b]hstack=inputs=2[v]',
+             '-map', '[v]', *(['-map', '0:a:0', '-c:a', 'aac'] if info_a['audio'] else []), '-c:v', 'libx264', '-preset', 'veryfast',
+             '-crf', '23', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', '-y', video])
+        result['video'] = video
+    return result
+
+
+def summary_lines(result: dict) -> list[str]:
+    a, b = result['a'], result['b']
+    lines = [f'A {a["path"]}  {a["fps"]}fps {a["frames"]}f {a["duration"]}s   B {b["path"]}  {b["fps"]}fps {b["frames"]}f {b["duration"]}s']
+    lines += [f'{p["path"]}  t={p["times"]}  {p["bytes"] // 1024} KB' for p in result['pages']]
+    if 'cuts' in result:
+        c = result['cuts']
+        lines.append(f'cuts A {len(c["a"])}, B {len(c["b"])}: {c["matched"]} matched within {CUT_TOLERANCE}s'
+                     + (f', mean |offset| {c["mean_abs_offset"]}s' if c['mean_abs_offset'] is not None else ''))
+        lines += [f'  A {p["a"]}s -> B {p["b"]}s ({p["offset"]:+}s)' if p['b'] is not None else f'  A {p["a"]}s -> no cut in B'
+                  for p in c['pairs']]
+        if c['only_b']:
+            lines.append(f'  only in B: {c["only_b"]}')
+    if 'video' in result:
+        lines.append(f'side by side: {result["video"]}  (A left, B right)')
+    return lines

rn/cuts.py

@@ -0,0 +1,81 @@
+"""rn cuts: shot boundaries of a video, by decoded frame index. Measurement only: it reports where the picture
+changes, never where to cut. Continuous camera moves and morphs score low; the suspect list is for a human-style look."""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
+from .ff import RnError, probe, run, source_fps
+
+DEFAULT_THRESHOLD = 0.3
+_FRAME = re.compile(r'^frame:(\d+)')
+_SCORE = re.compile(r'lavfi\.scene_score=([0-9.]+)')
+
+
+def scene_scores(path: str | Path) -> list[float]:
+    """ffmpeg's scene-change score (0..1) for every decoded frame, in decode order (frame 0 scores 0)."""
+    result = run(['ffmpeg', '-i', str(path), '-an', '-vf', "select='gte(scene,0)',metadata=print:key=lavfi.scene_score:file=-",
+                  '-f', 'null', '-'])
+    scores: list[float] = []
+    for line in result.stdout.splitlines():
+        if (match := _FRAME.match(line)) and int(match.group(1)) == len(scores):
+            scores.append(0.0)
+        elif (match := _SCORE.search(line)) and scores:
+            scores[-1] = float(match.group(1))
+    if not scores:
+        raise RnError(f'{path}: no frames decoded')
+    return scores
+
+
+@lru_cache(maxsize=32)
+def detect(path: str, threshold: float = DEFAULT_THRESHOLD, min_gap: float = 0.3) -> dict:
+    info = probe(path)
+    if not info['video'] or info['video']['still']:
+        raise RnError(f'{path}: not a video')
+    fps = source_fps(info)
+    scores = scene_scores(path)
+    gap = max(1, round(min_gap * fps))
+    cuts, suspects = [], []
+    for index, score in enumerate(scores):
+        if index == 0:
+            continue
+        entry = {'frame': index, 'time': round(float(index / fps), 4), 'score': round(score, 3)}
+        if score >= threshold:
+            # A flash or a two-frame dissolve scores twice in a row; keep the stronger of close neighbours. The weaker
+            # stays a suspect: it may be a real 1-2 frame insert or a burst of micro-cuts.
+            if cuts and index - cuts[-1]['frame'] < gap:
+                if score > cuts[-1]['score']:
+                    cuts[-1], entry = entry, cuts[-1]
+                suspects.append(entry)
+                continue
+            cuts.append(entry)
+        elif score >= threshold / 2:
+            suspects.append(entry)
+    suspects.sort(key=lambda s: s['frame'])
+    edges = [0, *(c['frame'] for c in cuts), len(scores)]
+    shots = [{'shot': i, 'start_frame': a, 'end_frame': b, 'start': round(float(a / fps), 4), 'end': round(float(b / fps), 4),
+              'duration': round(float((b - a) / fps), 4)} for i, (a, b) in enumerate(zip(edges, edges[1:]))]
+    return {'path': str(path), 'fps': str(fps), 'frames': len(scores), 'threshold': threshold, 'cuts': cuts,
+            'suspects': suspects, 'shots': shots}
+
+
+def shot_span(path: str | Path, shot: int) -> tuple[float, float]:
+    """Seconds [start, end) of shot `shot` (0-based) with the default detector; used by EDL {"shot": n} positions."""
+    shots = detect(str(Path(path).resolve()))['shots']
+    if not 0 <= shot < len(shots):
+        raise RnError(f'{path}: shot {shot} does not exist (rn cuts found {len(shots)} shots: 0..{len(shots) - 1})')
+    return shots[shot]['start'], shots[shot]['end']
+
+
+def cuts_command(path: str, *, threshold: float, min_gap: float, sheet: str | None, max_kb: int) -> dict:
+    result = dict(detect(str(Path(path).resolve()), threshold, min_gap))
+    result['path'] = path
+    if sheet:
+        from .frames import sheet_command
+        # Both sides of every cut and suspect, so a look confirms or rejects each one.
+        indices = sorted({i for c in result['cuts'] + result['suspects'] for i in (c['frame'] - 1, c['frame'])})
+        if indices:
+            result['sheet'] = sheet_command([path], out=sheet, every=None, rate=None, indices=indices, seconds=None, count=None,
+                                            width=192, columns=6, max_kb=max_kb)['pages']
+    return result

rn/editops.py

@@ -0,0 +1,252 @@
+"""rn edit: change an EDL by operations on clip ids instead of rewriting its JSON. Each operation is checked by laying the
+whole edit out again (as rn assemble --dry-run would) and only then written back, so a bad step never lands.
+
+The main track always plays back to back, so removing or trimming a clip there ripples everything after it; overlays and
+audio anchored by clip id ({"clip": "id"}) follow, ones placed at fixed seconds do not.
+"""
+from __future__ import annotations
+
+import json
+import os
+from fractions import Fraction
+from pathlib import Path
+
+from .edl import Clip, load
+from .ff import RnError
+
+
+def _read(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text())
+    except FileNotFoundError:
+        raise RnError(f'no such file: {path}') from None
+    except json.JSONDecodeError as error:
+        raise RnError(f'{path}: invalid JSON: {error}') from None
+
+
+def _write_checked(path: Path, raw: dict) -> dict:
+    """Lays the edited JSON out next to the original (relative paths resolve the same), then replaces it."""
+    trial = path.with_name(f'.{path.stem}.rn-edit.json')
+    trial.write_text(json.dumps(raw, indent=2, ensure_ascii=False) + '\n')
+    try:
+        summary = load(trial).summary()
+    except RnError:
+        trial.unlink()
+        raise
+    os.replace(trial, path)
+    return summary
+
+
+def _containers(raw: dict) -> list[tuple[str, list]]:
+    tracks = raw.get('tracks') or []
+    return [*((f'tracks[{t}]', track.get('clips', [])) for t, track in enumerate(tracks)), ('audio', raw.get('audio') or [])]
+
+
+def _locate(raw: dict, ref: str) -> tuple[str, list, int]:
+    """A clip by id, or by position as "track:index" (e.g. 0:3) / "audio:index"."""
+    if ':' in ref:
+        name, _, index = ref.partition(':')
+        lists = dict(_containers(raw))
+        key = 'audio' if name == 'audio' else f'tracks[{name}]'
+        if key not in lists or not index.isdigit() or int(index) >= len(lists[key]):
+            raise RnError(f'{ref}: no such clip (positions are "track:index" or "audio:index")')
+        return key, lists[key], int(index)
+    for key, items in _containers(raw):
+        for i, item in enumerate(items):
+            if isinstance(item, dict) and item.get('id') == ref:
+                return key, items, i
+    raise RnError(f'no clip with id "{ref}" (rn edit <edl> ids gives every clip one)')
+
+
+def _all_ids(raw: dict) -> set[str]:
+    return {item.get('id') for _, items in _containers(raw) for item in items if isinstance(item, dict) and item.get('id')}
+
+
+def _fresh(raw: dict, base: str) -> str:
+    taken = _all_ids(raw)
+    n = 2
+    while f'{base}-{n}' in taken:
+        n += 1
+    return f'{base}-{n}'
+
+
+def _parsed(path: Path, key: str, index: int) -> tuple[Clip, Fraction]:
+    edit = load(path)
+    where = f'{key}.clips[{index}]'
+    clip = next((c for c in edit.base + edit.overlays if c.where == where), None)
+    if clip is None:
+        raise RnError(f'{where}: only video, image, sequence and colour clips can be split')
+    return clip, edit.fps
+
+
+def ids_op(path: Path) -> dict:
+    raw = _read(path)
+    taken, added = _all_ids(raw), []
+    for key, items in _containers(raw):
+        prefix = 'a' if key == 'audio' else ('c' if key == 'tracks[0]' else 'o')
+        n = 1
+        for item in items:
+            if isinstance(item, dict) and not item.get('id'):
+                while f'{prefix}{n}' in taken:
+                    n += 1
+                item['id'] = f'{prefix}{n}'
+                taken.add(item['id'])
+                added.append(item['id'])
+    summary = _write_checked(path, raw)
+    return {'op': 'ids', 'added': added, 'timeline': summary}
+
+
+def _assign(target: dict, dotted: str, value) -> None:
+    *parents, last = dotted.split('.')
+    for name in parents:
+        target = target.setdefault(name, {})
+        if not isinstance(target, dict):
+            raise RnError(f'{dotted}: {name} is not an object')
+    target[last] = value
+
+
+def set_op(path: Path, ref: str, assignments: list[str], unset: list[str]) -> dict:
+    """key=value with value as JSON when it parses (numbers, objects, true) and as a string otherwise; dotted keys reach
+    into objects (meta.label=hero, transition.duration=0.3)."""
+    raw = _read(path)
+    _, items, index = _locate(raw, ref)
+    item = items[index]
+    for assignment in assignments:
+        key, sep, text = assignment.partition('=')
+        if not sep or not key:
+            raise RnError(f'{assignment}: expected key=value')
+        try:
+            value = json.loads(text)
+        except json.JSONDecodeError:
+            value = text
+        _assign(item, key, value)
+    for key in unset:
+        *parents, last = key.split('.')
+        target = item
+        for name in parents:
+            target = target.get(name, {}) if isinstance(target, dict) else {}
+        if isinstance(target, dict):
+            target.pop(last, None)
+    return {'op': 'set', 'clip': ref, 'timeline': _write_checked(path, raw)}
+
+
+def split_op(path: Path, ref: str, at: float, new_id: str | None) -> dict:
+    """Cuts a clip at timeline second `at` into two that play exactly as the one did."""
+    raw = _read(path)
+    key, items, index = _locate(raw, ref)
+    if key == 'audio':
+        raise RnError(f'{ref}: audio items are split by giving two items in/out ranges')
+    original = items[index]
+    for blocked in ('keys', 'ranges'):
+        if blocked in original:
+            raise RnError(f'{ref}: has "{blocked}", which are relative to the clip; split it by hand')
+    clip, fps = _parsed(path, key, index)
+    k = round(at * fps) - clip.timeline_start
+    if not 0 < k < clip.frames:
+        raise RnError(f'{ref}: {at}s is not inside the clip (timeline frames {clip.timeline_start}..{clip.timeline_start + clip.frames - 1})')
+    head_s, tail_s = float(k / fps), float((clip.frames - k) / fps)
+    first, second = dict(original), {k2: v for k2, v in original.items() if k2 not in ('transition', 'fade_in')}
+    first.pop('fade_out', None)
+    first.pop('until', None)
+    if clip.kind in ('video', 'sequence', 'edit'):
+        cut = round(clip.start_s + head_s * clip.speed, 6)
+        second['in'] = cut
+        if 'duration' in original or 'until' in original:
+            first['duration'] = round(head_s, 6)
+            if 'duration' in original:
+                second['duration'] = round(tail_s, 6)
+        else:
+            first['out'] = cut
+    else:  # stills, colours and held frames: durations only
+        first['duration'] = round(head_s, 6)
+        first.pop('out', None)
+        if 'until' not in original:
+            second['duration'] = round(tail_s, 6)
+            second.pop('out', None)
+    if key != 'tracks[0]':
+        second['at'] = round(float((clip.timeline_start + k) / fps), 6)
+    if original.get('id'):
+        second['id'] = new_id or _fresh(raw, original['id'])
+    elif new_id:
+        second['id'] = new_id
+    items[index:index + 1] = [first, second]
+    return {'op': 'split', 'clip': ref, 'into': [first.get('id'), second.get('id')], 'timeline': _write_checked(path, raw)}
+
+
+def delete_op(path: Path, ref: str, lift: bool) -> dict:
+    """Removes a clip. On the main track the rest ripples left; --lift leaves a background-coloured gap instead."""
+    raw = _read(path)
+    key, items, index = _locate(raw, ref)
+    if lift:
+        if key != 'tracks[0]':
+            raise RnError('--lift is for the main track (overlays and audio leave no gap to fill)')
+        clip, fps = _parsed(path, key, index)
+        gap = {'color': (raw.get('output') or {}).get('background', '#000000'), 'duration': round(float(clip.frames / fps), 6)}
+        items[index] = gap
+    else:
+        del items[index]
+    return {'op': 'delete', 'clip': ref, 'lift': lift, 'timeline': _write_checked(path, raw)}
+
+
+def _destination(raw: dict, before: str | None, after: str | None, track: str | None) -> tuple[list, int]:
+    if sum(x is not None for x in (before, after, track)) != 1:
+        raise RnError('give exactly one of --before ID, --after ID or --track N|audio')
+    if track is not None:
+        if track == 'audio':
+            return raw.setdefault('audio', []), len(raw['audio'])
+        if not track.isdigit():
+            raise RnError('--track: a track number (0 = main) or "audio"')
+        tracks = raw.setdefault('tracks', [])
+        number = int(track)
+        if number == len(tracks):
+            tracks.append({'clips': []})
+        if number >= len(tracks):
+            raise RnError(f'--track {number}: tracks are 0..{len(tracks) - 1}; {len(tracks)} adds one')
+        return tracks[number].setdefault('clips', []), len(tracks[number]['clips'])
+    _, items, index = _locate(raw, before or after)
+    return items, index + (1 if after else 0)
+
+
+def insert_op(path: Path, clip_json: str, before: str | None, after: str | None, track: str | None) -> dict:
+    """Adds a clip given as JSON (or @file.json)."""
+    text = Path(clip_json[1:]).read_text() if clip_json.startswith('@') else clip_json
+    try:
+        clip = json.loads(text)
+    except json.JSONDecodeError as error:
+        raise RnError(f'--clip: invalid JSON: {error}') from None
+    if not isinstance(clip, dict):
+        raise RnError('--clip: one clip object')
+    raw = _read(path)
+    items, index = _destination(raw, before, after, track)
+    items.insert(index, clip)
+    return {'op': 'insert', 'clip': clip.get('id'), 'timeline': _write_checked(path, raw)}
+
+
+def move_op(path: Path, ref: str, before: str | None, after: str | None, track: str | None) -> dict:
+    raw = _read(path)
+    _, items, index = _locate(raw, ref)
+    clip = items.pop(index)
+    marker = object()  # keep the clip's slot while the destination is looked up, so --before its neighbour works
+    items.insert(index, marker)
+    target, position = _destination(raw, before, after, track)
+    target.insert(position, clip)
+    for container in (items, target):
+        if marker in container:
+            container.remove(marker)
+    return {'op': 'move', 'clip': ref, 'timeline': _write_checked(path, raw)}
+
+
+def summary_lines(result: dict) -> list[str]:
+    head = {'ids': lambda r: f'ids added: {", ".join(r["added"]) or "none (every clip has one)"}',
+            'set': lambda r: f'set {r["clip"]}',
+            'split': lambda r: f'split {r["clip"]} into {r["into"][0]} + {r["into"][1]}',
+            'delete': lambda r: f'deleted {r["clip"]}' + (' (lifted: gap kept)' if r['lift'] else ''),
+            'insert': lambda r: f'inserted {r["clip"] or "clip"}',
+            'move': lambda r: f'moved {r["clip"]}'}[result['op']](result)
+    out = result['timeline']['output']
+    lines = [head, f'timeline {out["width"]}x{out["height"]} {out["fps"]}fps  {out["frames"]} frames  {out["duration"]}s']
+    lines += [f'  {c["id"] or c["where"]}: frames {c["start_frame"]}..{c["start_frame"] + c["frames"] - 1}' for c in result['timeline']['base']]
+    lines += [f'  {c["id"] or c["where"]}: overlay frames {c["start_frame"]}..{c["start_frame"] + c["frames"] - 1}'
+              for c in result['timeline']['overlays']]
+    lines += [f'warning: {w}' for w in result['timeline']['warnings']]
+    return lines