visualize_force.py

#!/usr/bin/env python3
"""Render a force review video from one MCAP, replicating the official
FusionX Tactile Foxglove panel (touchtronixrobotics.fusionx-tactile-panel
v0.2.4 .foxe) and the fusionx_foxglove_annotated.json layout.

Layout (1920x1080):
  top 71.5%:    [ FusionX Tactile panel | head camera / wrist lh + rh ]
  bottom 28.5%: semantic state timeline (contact / target / subtask)
The layout's 3D hand-pose panels are not reproduced.

Tactile rendering matches the extension exactly: per-finger 4x3 pixel grids
(LH little-ring-middle-index at columns 1/5/9/13, RH index..little at
5/9/13/17, thumb at row 6), colour hsl(240*(1-v/vmax), 90%, 50%) with a
fixed 0-20 N scale in force-pixels mode (0-255 in raw mode), sample-and-hold
of the latest message like the live panel (no interpolation).

All streams are aligned on MCAP log_time, so tactile, cameras, and
annotations share one clock (fixes the per-stream offset in visualize.py).

Usage: visualize_force.py <recording_dir> [--mode auto|force-pixels|raw]
       [--start S] [--duration S] [--fps N] [--out PATH]
"""

from __future__ import annotations

import argparse
import colorsys
import json
import subprocess
import sys
from pathlib import Path

import cv2
import numpy as np
from mcap.reader import make_reader

FINGERS = ("thumb", "index", "middle", "ring", "little")
HEAD_TOPIC = "/camera/head/rgb/h264"
WRIST_TOPICS = {"lh": "/camera/wrist/lh/h264", "rh": "/camera/wrist/rh/h264"}
MONO_TOPICS = {"lh": "/camera/head/mono_left/h264", "rh": "/camera/head/mono_right/h264"}
TACTILE_TOPICS = {"lh": "/glove/lh/tactile", "rh": "/glove/rh/tactile"}
STATE_TOPIC = "/annotations/semantic/state"

CANVAS_W, CANVAS_H = 1920, 1080
TOP_H = 772          # 71.45% column split from the annotated layout
HEAD_H = 574         # 74.36% split of the camera column
PANEL_W = CANVAS_W // 2


def hex_bgr(h: str) -> tuple[int, int, int]:
    h = h.lstrip("#")
    return (int(h[4:6], 16), int(h[2:4], 16), int(h[0:2], 16))


# Extension colours (dist/extension.js)
PANEL_BG = hex_bgr("#0b1118")
SVG_BG = hex_bgr("#111821")
CELL_STROKE = hex_bgr("#263241")
INK = hex_bgr("#edf2f7")
MUTED = hex_bgr("#78889b")
FAINT = hex_bgr("#aab4c3")
SCALE_INK = hex_bgr("#d9e2ec")
BEND_TRACK = hex_bgr("#202b38")
BEND_FILL = hex_bgr("#00c800")
BEND_INK = hex_bgr("#c8c8c8")
BTN_ACTIVE = hex_bgr("#2563eb")
BTN_IDLE = hex_bgr("#202b38")
BTN_BORDER = hex_bgr("#3b4858")
CAM_BG = hex_bgr("#0e0e0e")

# State-timeline categorical palette (dataviz reference palette, dark steps,
# fixed order; values beyond the list reuse it cyclically but every segment
# is also direct-labelled so colour is never the only identity)
TRACK_COLORS = [hex_bgr(c) for c in (
    "#3987e5", "#d95926", "#199e70", "#c98500",
    "#d55181", "#008300", "#9085e9", "#e66767",
)]

FONT = cv2.FONT_HERSHEY_SIMPLEX


def heat_color(value: float, vmax: float) -> tuple[int, int, int]:
    # extension: fill = hsl(240*(1-clamp(v/vmax)) 90% 50%)
    hue = 240.0 * (1.0 - min(max(value / vmax, 0.0), 1.0))
    r, g, b = colorsys.hls_to_rgb(hue / 360.0, 0.5, 0.9)
    return (int(b * 255), int(g * 255), int(r * 255))


def put_text(img, text, x, y, px, color, weight=1):
    scale = px / 22.0
    cv2.putText(img, text, (int(x), int(y)), FONT, scale, color, weight, cv2.LINE_AA)


def text_w(text, px, weight=1):
    return cv2.getTextSize(text, FONT, px / 22.0, weight)[0][0]


# ---------------------------------------------------------------------------
# MCAP extraction
# ---------------------------------------------------------------------------

def decode_varint(buf: bytes, i: int) -> tuple[int, int]:
    x = s = 0
    while True:
        b = buf[i]
        i += 1
        x |= (b & 0x7F) << s
        if not (b & 0x80):
            return x, i
        s += 7


def proto_bytes_field(buf: bytes, field_no: int) -> bytes:
    i, n = 0, len(buf)
    while i < n:
        key, i = decode_varint(buf, i)
        fn, wt = key >> 3, key & 7
        if wt == 2:
            ln, i = decode_varint(buf, i)
            if fn == field_no:
                return buf[i : i + ln]
            i += ln
        elif wt == 0:
            _, i = decode_varint(buf, i)
        elif wt == 1:
            i += 8
        elif wt == 5:
            i += 4
        else:
            raise ValueError(f"bad wire type {wt}")
    return b""


def parse_tactile(obj: dict) -> dict:
    adc = np.zeros((5, 12), np.float32)
    for i, name in enumerate(FINGERS):
        row = (obj.get("finger_pressure") or {}).get(name) or []
        adc[i, : min(12, len(row))] = row[:12]
    force = None
    pix = obj.get("finger_force_N_pixels")
    if pix:
        force = np.zeros((5, 12), np.float32)
        for i in range(min(5, len(pix))):
            force[i, : min(12, len(pix[i]))] = pix[i][:12]
    palm = np.zeros(60, np.float32)
    raw_palm = obj.get("palm_pressure") or []
    palm[: min(60, len(raw_palm))] = raw_palm[:60]
    bend = np.zeros(5, np.float32)
    raw_bend = obj.get("finger_bend") or []
    bend[: min(5, len(raw_bend))] = raw_bend[:5]
    return {"adc": adc, "force": force, "palm": palm, "bend": bend,
            "sample_idx": int(obj.get("sample_idx", -1))}


def parse_state(obj: dict) -> tuple[str | None, str | None, str | None]:
    aa = obj.get("atomic_actions") or []
    st = obj.get("subtasks") or []
    contact = aa[0].get("contact_state_start") if aa else None
    target = aa[0].get("target_object") if aa else None
    subtask = st[0].get("description") if st else None
    return contact, target, subtask


def extract(mcap: Path, tmp_dir: Path) -> dict:
    with open(mcap, "rb") as f:
        summary = make_reader(f).get_summary()
    available = {ch.topic for ch in (summary.channels or {}).values()} if summary else set()

    cams = {"head": (HEAD_TOPIC, "Head Camera")}
    for side in ("lh", "rh"):
        if WRIST_TOPICS[side] in available:
            cams[f"wrist_{side}"] = (WRIST_TOPICS[side], f"Wrist {side.upper()}")
        elif MONO_TOPICS[side] in available:
            cams[f"wrist_{side}"] = (MONO_TOPICS[side], f"Head mono {'L' if side == 'lh' else 'R'}")
    topic_to_cam = {t: k for k, (t, _) in cams.items()}

    writers = {k: (tmp_dir / f"_{k}.h264").open("wb") for k in cams}
    cam_times = {k: [] for k in cams}
    tactile = {h: {"t": [], "samples": []} for h in ("lh", "rh")}
    states = []

    topics = [t for t, _ in cams.values()] + list(TACTILE_TOPICS.values())
    if STATE_TOPIC in available:
        topics.append(STATE_TOPIC)

    print(f"reading {mcap.name} ...", flush=True)
    with open(mcap, "rb") as f:
        for _sch, ch, msg in make_reader(f).iter_messages(topics=topics):
            t = msg.log_time / 1e9
            if ch.topic in topic_to_cam:
                payload = proto_bytes_field(msg.data, 3)
                if payload:
                    key = topic_to_cam[ch.topic]
                    writers[key].write(payload)
                    cam_times[key].append(t)
            elif ch.topic == STATE_TOPIC:
                states.append((t, *parse_state(json.loads(msg.data))))
            else:
                hand = "lh" if ch.topic == TACTILE_TOPICS["lh"] else "rh"
                tactile[hand]["t"].append(t)
                tactile[hand]["samples"].append(parse_tactile(json.loads(msg.data)))
    for w in writers.values():
        w.close()

    out = {"cams": {}, "tactile": {}, "states": states}
    for k, (topic, label) in cams.items():
        raw = tmp_dir / f"_{k}.h264"
        mp4 = tmp_dir / f"_{k}.mp4"
        subprocess.run(
            ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
             "-fflags", "+genpts", "-r", "30", "-f", "h264", "-i", str(raw),
             "-c", "copy", str(mp4)],
            check=True,
        )
        raw.unlink()
        out["cams"][k] = {"mp4": mp4, "times": np.asarray(cam_times[k]), "label": label}
        print(f"  {label:12s} {len(cam_times[k])} frames", flush=True)
    for h in ("lh", "rh"):
        has_force = any(s["force"] is not None for s in tactile[h]["samples"])
        out["tactile"][h] = {
            "t": np.asarray(tactile[h]["t"]),
            "samples": tactile[h]["samples"],
            "has_force": has_force,
        }
        print(f"  {h} tactile   {len(tactile[h]['t'])} samples  force {'yes' if has_force else 'no'}", flush=True)
    print(f"  state       {len(states)} messages", flush=True)
    return out


# ---------------------------------------------------------------------------
# FusionX Tactile panel (faithful to dist/extension.js)
# ---------------------------------------------------------------------------

def sensor_cells(hand: str, sample: dict, mode: str):
    long_names = ["little", "ring", "middle", "index"] if hand == "lh" else ["index", "middle", "ring", "little"]
    anchors = {n: (1, (1 if hand == "lh" else 5) + 4 * k) for k, n in enumerate(long_names)}
    anchors["thumb"] = (6, 17 if hand == "lh" else 1)
    cells = []
    for fi, name in enumerate(FINGERS):
        row0, col0 = anchors[name]
        values = sample["force"][fi] if mode == "force-pixels" else sample["adc"][fi]
        for n, v in enumerate(values):
            cells.append((row0 + n // 3, col0 + n % 3, float(v)))
    if mode == "raw":
        base = 1 if hand == "lh" else 5
        for r, v in enumerate(sample["palm"]):
            cells.append((6 + r // 15, base + r % 15, float(v)))
    return cells


def draw_heatmap(img, x0, y0, bw, bh, hand: str, sample: dict | None, mode: str):
    sc = min(bw / 28.0, bh / 12.0)
    ox = x0 + (bw - 28 * sc) / 2
    oy = y0 + (bh - 12 * sc) / 2
    cv2.rectangle(img, (int(ox), int(oy)), (int(ox + 28 * sc), int(oy + 12 * sc)), SVG_BG, -1)
    if sample is None:
        msg = f"Waiting for {TACTILE_TOPICS[hand]}"
        put_text(img, msg, ox + 14 * sc - text_w(msg, 15) / 2, oy + 6 * sc, 15, FAINT)
        return
    if mode == "force-pixels" and sample["force"] is None:
        msg = "Pixel force unavailable in this recording"
        put_text(img, msg, ox + 14 * sc - text_w(msg, 15) / 2, oy + 6 * sc, 15, FAINT)
        return

    vmax = 255.0 if mode == "raw" else 20.0
    shift = 7 if hand == "lh" else 0
    for row, col, v in sensor_cells(hand, sample, mode):
        cx, cy = ox + (col + shift) * sc, oy + row * sc
        p0, p1 = (int(cx), int(cy)), (int(cx + 0.9 * sc), int(cy + 0.9 * sc))
        cv2.rectangle(img, p0, p1, heat_color(v, vmax), -1)
        cv2.rectangle(img, p0, p1, CELL_STROKE, 1)
    # colour scale: 11 blocks, red (vmax) on top -> blue (0) at bottom
    sx = ox + (4.5 if hand == "lh" else 22.5) * sc
    for n in range(11):
        sy = oy + (1 + 0.8 * n) * sc
        r, g, b = colorsys.hls_to_rgb(n / 10.0 * 240.0 / 360.0, 0.5, 0.9)
        cv2.rectangle(img, (int(sx), int(sy)), (int(sx + sc), int(sy + 0.82 * sc)),
                      (int(b * 255), int(g * 255), int(r * 255)), -1)
    tx = ox + (0.5 if hand == "lh" else 24.0) * sc
    put_text(img, "255 ADC" if mode == "raw" else "20 N", tx, oy + 1.6 * sc, 0.65 * sc, SCALE_INK)
    put_text(img, "0", tx, oy + 9.3 * sc, 0.65 * sc, SCALE_INK)
    if mode == "raw":
        px = ox + ((15.5 if hand == "lh" else 12.5) + shift) * sc
        put_text(img, "palm", px - text_w("palm", 0.65 * sc) / 2, oy + 11 * sc, 0.65 * sc, SCALE_INK)


def draw_bend(img, x0, y0, bw, bh, hand: str, sample: dict):
    sc = min(bw / 28.0, bh / 10.0)
    ox = x0 + (bw - 28 * sc) / 2
    oy = y0 + (bh - 10 * sc) / 2
    cv2.rectangle(img, (int(ox), int(oy)), (int(ox + 28 * sc), int(oy + 10 * sc)), SVG_BG, -1)
    for t, name in enumerate(FINGERS):
        c = (25.5 - 4 * t) if hand == "lh" else (2.5 + 4 * t)
        bx = ox + (c - 1) * sc
        h = min(max(float(sample["bend"][t]) / 255.0, 0.0), 1.0) * 7.5 * sc
        cv2.rectangle(img, (int(bx), int(oy + 2 * sc)), (int(bx + 2 * sc), int(oy + 9.5 * sc)), BEND_TRACK, -1)
        if h > 0:
            cv2.rectangle(img, (int(bx), int(oy + 9.5 * sc - h)), (int(bx + 2 * sc), int(oy + 9.5 * sc)), BEND_FILL, -1)
        letter = name[0].upper()
        put_text(img, letter, ox + c * sc - text_w(letter, 0.8 * sc) / 2, oy + 1.35 * sc, 0.8 * sc, BEND_INK)


def draw_tactile_panel(img, x0, y0, w, h, samples: dict, mode: str, t_sec: float):
    cv2.rectangle(img, (x0, y0), (x0 + w, y0 + h), PANEL_BG, -1)
    pad = 12
    put_text(img, "FusionX Tactile", x0 + pad, y0 + 26, 17, INK, 2)
    stamp = f"t = {t_sec:6.2f} s"
    put_text(img, stamp, x0 + w - pad - text_w(stamp, 14), y0 + 26, 14, MUTED)
    # mode buttons
    by = y0 + 38
    bw = (w - 2 * pad - 8) // 2
    for i, (m, label) in enumerate((("raw", "Raw ADC"), ("force-pixels", "Pixel Force"))):
        bx = x0 + pad + i * (bw + 8)
        cv2.rectangle(img, (bx, by), (bx + bw, by + 30), BTN_ACTIVE if m == mode else BTN_IDLE, -1)
        cv2.rectangle(img, (bx, by), (bx + bw, by + 30), BTN_BORDER, 1)
        put_text(img, label, bx + (bw - text_w(label, 14)) / 2, by + 20, 14, INK)

    sec_y = by + 42
    sec_h = h - (sec_y - y0) - 8
    half = w // 2
    cv2.line(img, (x0 + half, sec_y), (x0 + half, y0 + h - 8), BTN_BORDER, 1)
    for i, hand in enumerate(("lh", "rh")):
        hx = x0 + i * half + (8 if i else pad)
        hw = half - pad - 8
        title = f"{'Left' if hand == 'lh' else 'Right'} Hand"
        put_text(img, title, hx + (hw - text_w(title, 15, 2)) / 2, sec_y + 18, 15, INK, 2)
        heat_h = int(hw * 12 / 28)
        bend_h = int(hw * 10 / 28)
        avail = sec_h - 28 - 24 - 14
        if heat_h + bend_h > avail:
            k = avail / (heat_h + bend_h)
            heat_h, bend_h = int(heat_h * k), int(bend_h * k)
        draw_heatmap(img, hx, sec_y + 28, hw, heat_h, hand, samples[hand], mode)
        if samples[hand] is not None:
            draw_bend(img, hx, sec_y + 38 + heat_h, hw, bend_h, hand, samples[hand])
            foot = f"{TACTILE_TOPICS[hand]}  sample {samples[hand]['sample_idx']}"
        else:
            foot = TACTILE_TOPICS[hand]
        put_text(img, foot, hx + hw - text_w(foot, 12), y0 + h - 16, 12, MUTED)


# ---------------------------------------------------------------------------
# State timeline (StateTransitions panel paths)
# ---------------------------------------------------------------------------

TRACKS = (("contact", 1), ("target", 2), ("subtask", 3))


def build_segments(states, t0, t1):
    """Per track: list of (start, end, value) merged over consecutive equal values."""
    tracks = []
    for _, idx in TRACKS:
        segs = []
        for t, *vals in states:
            v = vals[idx - 1]
            if segs and segs[-1][2] == v:
                segs[-1][1] = t
            else:
                if segs:
                    segs[-1][1] = t
                segs.append([t, t1, v])
        tracks.append([(max(s, t0), min(e, t1), v) for s, e, v in segs
                       if v is not None and e > t0 and s < t1])
    return tracks


def render_timeline_bg(w, h, tracks, t0, t1):
    img = np.full((h, w, 3), PANEL_BG, np.uint8)
    label_w, right = 90, 16
    span = max(t1 - t0, 1e-9)

    def tx(t):
        return label_w + (t - t0) / span * (w - label_w - right)

    color_maps = []
    row_h = (h - 34) // len(TRACKS)
    for ti, (name, _) in enumerate(TRACKS):
        cmap = {}
        color_maps.append(cmap)
        y = 10 + ti * row_h
        put_text(img, name, 12, y + row_h // 2 + 5, 14, FAINT)
        bar_y, bar_h = y + 6, row_h - 18
        cv2.rectangle(img, (label_w, bar_y), (w - right, bar_y + bar_h), SVG_BG, -1)
        for s, e, v in tracks[ti]:
            if v not in cmap:
                cmap[v] = TRACK_COLORS[len(cmap) % len(TRACK_COLORS)]
            x0, x1 = int(tx(s)), int(tx(e))
            cv2.rectangle(img, (x0, bar_y), (max(x1 - 2, x0 + 1), bar_y + bar_h), cmap[v], -1)
            label = str(v)
            if text_w(label, 13) < x1 - x0 - 10:
                put_text(img, label, x0 + 6, bar_y + bar_h // 2 + 5, 13, INK, 1)
    axis_y = h - 18
    step = max(10, int(round(span / 8 / 10)) * 10)
    t = 0
    while t <= span:
        x = int(tx(t0 + t))
        cv2.line(img, (x, axis_y - 4), (x, axis_y), MUTED, 1)
        put_text(img, f"{t:d}s", x + 3, axis_y + 12, 12, MUTED)
        t += step
    return img, tx


# ---------------------------------------------------------------------------
# Cameras
# ---------------------------------------------------------------------------

class CamReader:
    def __init__(self, mp4: Path, times: np.ndarray, label: str):
        self.cap = cv2.VideoCapture(str(mp4))
        self.times = times
        self.label = label
        self.idx = -1
        self.frame = None

    def at(self, t: float):
        while self.idx + 1 < len(self.times) and self.times[self.idx + 1] <= t:
            ok, frame = self.cap.read()
            if not ok:
                break
            self.idx += 1
            self.frame = frame
        return self.frame

    def release(self):
        self.cap.release()


def blit_camera(canvas, x0, y0, bw, bh, frame, label):
    cv2.rectangle(canvas, (x0, y0), (x0 + bw, y0 + bh), CAM_BG, -1)
    if frame is not None:
        fh, fw = frame.shape[:2]
        s = min(bw / fw, bh / fh)
        nw, nh = int(fw * s), int(fh * s)
        ox, oy = x0 + (bw - nw) // 2, y0 + (bh - nh) // 2
        canvas[oy : oy + nh, ox : ox + nw] = cv2.resize(frame, (nw, nh), interpolation=cv2.INTER_AREA)
    else:
        put_text(canvas, "waiting", x0 + bw / 2 - text_w("waiting", 16) / 2, y0 + bh / 2, 16, MUTED)
    tw = text_w(label, 14)
    cv2.rectangle(canvas, (x0 + 8, y0 + 8), (x0 + 20 + tw, y0 + 32), (0, 0, 0), -1)
    put_text(canvas, label, x0 + 14, y0 + 25, 14, INK)


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def ffmpeg_writer(dest: Path, w: int, h: int, fps: float) -> subprocess.Popen:
    return subprocess.Popen(
        ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
         "-f", "rawvideo", "-pix_fmt", "bgr24", "-s", f"{w}x{h}", "-r", str(fps), "-i", "-",
         "-c:v", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-crf", "20",
         "-movflags", "+faststart", str(dest)],
        stdin=subprocess.PIPE,
    )


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("recording_dir", nargs="?", default=".")
    ap.add_argument("--mode", choices=("auto", "force-pixels", "raw"), default="auto")
    ap.add_argument("--start", type=float, default=0.0, help="offset into recording, seconds")
    ap.add_argument("--duration", type=float, default=None, help="seconds to render")
    ap.add_argument("--fps", type=float, default=30.0)
    ap.add_argument("--out", type=Path, default=None)
    args = ap.parse_args()

    root = Path(args.recording_dir).resolve()
    root = root.parent if root.is_file() else root
    mcaps = sorted(root.glob("*.mcap"))
    if not mcaps:
        sys.exit(f"no .mcap found in {root}")
    out_dir = root / "output"
    out_dir.mkdir(exist_ok=True)
    dest = args.out or out_dir / "force_video.mp4"

    streams = extract(mcaps[0], out_dir)

    firsts = [c["times"][0] for c in streams["cams"].values() if len(c["times"])]
    lasts = [c["times"][-1] for c in streams["cams"].values() if len(c["times"])]
    for h in ("lh", "rh"):
        t = streams["tactile"][h]["t"]
        if t.size:
            firsts.append(t[0])
            lasts.append(t[-1])
    t0, t1 = min(firsts), max(lasts)
    t0 += args.start
    if args.duration is not None:
        t1 = min(t1, t0 + args.duration)
    n_frames = max(1, int(round((t1 - t0) * args.fps)))

    if args.mode == "auto":
        mode = "force-pixels" if any(streams["tactile"][h]["has_force"] for h in ("lh", "rh")) else "raw"
    else:
        mode = args.mode
    print(f"rendering {n_frames} frames ({(t1 - t0):.1f}s) mode={mode} -> {dest.name}", flush=True)

    cams = {k: CamReader(c["mp4"], c["times"], c["label"]) for k, c in streams["cams"].items()}
    tl_h = CANVAS_H - TOP_H
    if streams["states"]:
        seg_tracks = build_segments(streams["states"], t0, t1)
        timeline_bg, tl_tx = render_timeline_bg(CANVAS_W, tl_h, seg_tracks, t0, t1)
    else:
        timeline_bg, tl_tx = np.full((tl_h, CANVAS_W, 3), PANEL_BG, np.uint8), None
        put_text(timeline_bg, "no semantic annotations in this recording",
                 CANVAS_W / 2 - text_w("no semantic annotations in this recording", 15) / 2,
                 tl_h / 2, 15, MUTED)

    proc = ffmpeg_writer(dest, CANVAS_W, CANVAS_H, args.fps)
    canvas = np.zeros((CANVAS_H, CANVAS_W, 3), np.uint8)
    wrist_w, wrist_h = PANEL_W // 2, TOP_H - HEAD_H
    tac = streams["tactile"]
    for i in range(n_frames):
        t = t0 + i / args.fps
        samples = {}
        for h in ("lh", "rh"):
            j = int(np.searchsorted(tac[h]["t"], t, "right")) - 1
            samples[h] = tac[h]["samples"][j] if j >= 0 else None
        draw_tactile_panel(canvas, 0, 0, PANEL_W, TOP_H, samples, mode, t - t0)
        blit_camera(canvas, PANEL_W, 0, PANEL_W, HEAD_H, cams["head"].at(t), cams["head"].label)
        for k, key in enumerate(("wrist_lh", "wrist_rh")):
            if key in cams:
                blit_camera(canvas, PANEL_W + k * wrist_w, HEAD_H, wrist_w, wrist_h,
                            cams[key].at(t), cams[key].label)
            else:
                blit_camera(canvas, PANEL_W + k * wrist_w, HEAD_H, wrist_w, wrist_h, None, key)
        canvas[TOP_H:] = timeline_bg
        if tl_tx is not None:
            x = int(tl_tx(t))
            cv2.line(canvas, (x, TOP_H + 4), (x, CANVAS_H - 20), INK, 2)
        proc.stdin.write(canvas.tobytes())
        if i % 900 == 0:
            print(f"  frame {i}/{n_frames}", flush=True)
    proc.stdin.close()
    if proc.wait() != 0:
        raise RuntimeError("ffmpeg encode failed")
    for c in cams.values():
        c.release()
    for k in streams["cams"]:
        streams["cams"][k]["mp4"].unlink(missing_ok=True)
    print(f"wrote {dest}  {dest.stat().st_size / 1e6:.1f} MB", flush=True)


if __name__ == "__main__":
    main()