primocode 10.16.0 → 10.17.0

package/editor/helpers/camera_viva.py

@@ -0,0 +1,426 @@
+"""Live camera by default: writes in projeto.json the base zoom that alternates sentence by sentence and the
+punch-ins on the words that carry the emphasis.
+
+Reads the words of the cut (`<EDIT>/transcripts/cut.json`, with the start measured on the wave when
+`palavras_onda.json` exists), the cuts (`cut_timeline.json`) and the loudness of the audio. Then, in the stretches
+of the video that have no block yet (or only a plain `tela_cheia`):
+
+  - one `tela_cheia` block per sentence, base zoom alternating between 1.0 and 1.12 (a long sentence is split at a
+    comma or at a cut, so something changes on screen every 2 to 4 s);
+  - one `zooms` punch-in on the face (1.25 over the 1.0 base, 1.3 over the 1.12 base) on the emphasis word of the
+    sentence: a number, a negation, or the loudest word. At least MIN_GAP_S between two punch-ins.
+
+A scene of `cenas_proprias` with `"sobre_a_pessoa": true` (a small card above the head of the person, who stays on
+screen) marks a stretch where the camera does NOT come closer: there the base zoom stays 1.0 and no punch-in is
+written, so the head cannot rise under the card. Its "de" and "ate" are seconds or a word ("ate" missing = to the end).
+(PrimoCode) The pieces that sit over the head (`lettering`, `rotulo`, `carimbo`) get the same calm stretch: with the
+1.12 base zoom the head rose under the title and the text ended up glued to the forehead. Under a big title on top
+(a `lettering` that is not "base"/"meio", with the captions out of the stretch) the block is 1.12 with
+`"foco_y": 0.62`: the face goes DOWN in the frame and the top opens for the text.
+
+It only uses what the build already does (`zooms` in `tela_cheia`, references/enquadramento.md). Blocks written by
+hand that are not a plain `tela_cheia` (`prova`, `contida`, `moldura`, `tela_verde`, `comparar`, or a `tela_cheia`
+with its own `zooms`, `acompanhar` or `"camera_viva": false`) are left exactly as they are. Everything written here
+carries `"auto": "camera_viva"`: running again replaces only that, and `--desfazer` removes it.
+
+Usage:
+    uv run python helpers/camera_viva.py <PROJ> [--desfazer] [--min-gap 2.5] [--json]
+Exit code 0 when projeto.json was written (or nothing had to change), 2 on error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import unicodedata
+from pathlib import Path
+
+MARCA = "camera_viva"
+ZOOM_A, ZOOM_B = 1.0, 1.12
+PUNCH_A, PUNCH_B = 1.25, 1.3
+MIN_GAP_S = 2.5
+LONGA_S = 4.5          # a sentence longer than this is split in two
+CURTA_S = 1.2          # a sentence shorter than this joins the next one
+PUNCH_FICA_S = 0.6     # how long the punch-in stays after the word ends
+SNAP_S = 0.25          # a sentence start this close to a cut moves to the cut
+FOCO_TITULO = 0.62     # (PrimoCode) under a big title on top: the face center goes this low in the frame (build: foco_y)
+
+NEGACOES = {"nao", "nunca", "nem", "nada", "ninguem", "jamais", "nenhum", "nenhuma", "sem", "zero"}
+NUMEROS = {"um", "uma", "dois", "duas", "tres", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez", "onze",
+           "doze", "treze", "catorze", "quatorze", "quinze", "vinte", "trinta", "quarenta", "cinquenta", "sessenta",
+           "setenta", "oitenta", "noventa", "cem", "cento", "duzentos", "trezentos", "quinhentos", "mil", "milhao",
+           "milhoes", "bilhao", "bilhoes", "dobro", "triplo", "metade", "primeiro", "primeira", "segundo", "segunda",
+           "terceiro", "terceira"}
+ARTIGOS_NUM = {"um", "uma"}       # "um" and "uma" are almost always the article: they only count with energy
+FRACAS = {"a", "o", "as", "os", "de", "da", "do", "das", "dos", "e", "que", "em", "no", "na", "nos", "nas", "um",
+          "uma", "por", "pra", "para", "com", "se", "eu", "ele", "ela", "voce", "me", "te", "foi", "era", "isso",
+          "esse", "essa", "este", "esta", "meu", "minha", "seu", "sua", "la", "ja", "mas", "ou", "como", "so", "ai",
+          "ne", "tem", "ter", "vai", "vou", "ao", "aos", "quando", "porque", "quem", "tudo", "cada", "mesma", "mesmo"}
+
+
+class Erro(Exception):
+    pass
+
+
+def norm(s: str) -> str:
+    s = unicodedata.normalize("NFD", str(s).lower())
+    return re.sub(r"[^a-z0-9%$]", "", "".join(c for c in s if unicodedata.category(c) != "Mn"))
+
+
+def ler_json(p: Path):
+    with open(p, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def palavras_do_corte(edit: Path) -> list[dict]:
+    """Words of the cut with the start measured on the wave when palavras_onda.json matches the transcript."""
+    p = edit / "transcripts" / "cut.json"
+    if not p.is_file():
+        raise Erro(f"falta {p}: termine o corte primeiro (render_cut.py e a transcrição do cut.mp4)")
+    ws = [dict(text=w["text"].strip(), start=float(w["start"]), end=float(w["end"]))
+          for w in ler_json(p)["words"] if w["text"].strip()]
+    po = edit / "palavras_onda.json"
+    if po.is_file():
+        try:
+            lista = ler_json(po).get("palavras") or []
+        except (ValueError, AttributeError):
+            lista = []
+        por_hora: dict[float, list[dict]] = {}
+        for r in lista:
+            try:
+                por_hora.setdefault(round(float(r["whisper"]), 2), []).append(r)
+            except (KeyError, TypeError, ValueError):
+                continue
+        for w in ws:
+            for r in por_hora.get(round(w["start"], 2), []):
+                if norm(r.get("text", "")) == norm(w["text"]) and abs(float(r["start"]) - w["start"]) <= 0.45:
+                    w["start"] = round(float(r["start"]), 3)
+                    w["end"] = round(max(w["end"], w["start"] + 0.05), 3)
+                    break
+    return ws
+
+
+def frases(ws: list[dict], cortes: list[float]) -> list[list[int]]:
+    """Indexes of the words of each sentence: split on . ! ? and a long sentence split again at a comma or a cut."""
+    out, atual = [], []
+    for i, w in enumerate(ws):
+        atual.append(i)
+        if re.search(r"[.!?…]$", w["text"]):
+            out.append(atual)
+            atual = []
+    if atual:
+        out.append(atual)
+
+    def dur(f):
+        return ws[f[-1]]["end"] - ws[f[0]]["start"]
+
+    partidas = []
+    for f in out:
+        fila = [f]
+        while fila:
+            g = fila.pop(0)
+            if dur(g) <= LONGA_S or len(g) < 4:
+                partidas.append(g)
+                continue
+            meio = (ws[g[0]]["start"] + ws[g[-1]]["end"]) / 2
+            cand = [k for k in range(1, len(g) - 1) if ws[g[k - 1]]["text"].endswith((",", ";", ":"))]
+            cand += [k for k in range(1, len(g) - 1)
+                     if any(abs(c - ws[g[k]]["start"]) <= SNAP_S for c in cortes)]
+            cand = [k for k in cand if ws[g[k]]["start"] - ws[g[0]]["start"] >= CURTA_S
+                    and ws[g[-1]]["end"] - ws[g[k]]["start"] >= CURTA_S]
+            if not cand:
+                partidas.append(g)
+                continue
+            k = min(cand, key=lambda k: abs(ws[g[k]]["start"] - meio))
+            fila = [g[:k], g[k:]] + fila
+    juntas: list[list[int]] = []
+    for f in partidas:                       # a very short sentence rides with the one before it
+        if juntas and (dur(f) < CURTA_S or dur(juntas[-1]) < CURTA_S) and dur(juntas[-1]) + dur(f) <= LONGA_S:
+            juntas[-1] = juntas[-1] + f
+        else:
+            juntas.append(f)
+    return juntas
+
+
+def energia(db, w: dict) -> float:
+    """Loudness of a word: the 90th percentile of the wave (10 ms windows) between its start and its end."""
+    if db is None:
+        return 0.0
+    import numpy as np  # noqa: PLC0415
+    a, b = int(w["start"] * 100), max(int(w["end"] * 100), int(w["start"] * 100) + 1)
+    seg = db[a:b]
+    return float(np.percentile(seg, 90)) if len(seg) else -99.0
+
+
+def enfase(ws: list[dict], f: list[int], db) -> tuple[int, str] | None:
+    """(index, reason) of the emphasis word of a sentence: number, negation, or the loudest content word."""
+    en = {i: energia(db, ws[i]) for i in f}
+    nums = [i for i in f if re.search(r"\d", ws[i]["text"]) or "%" in ws[i]["text"] or "$" in ws[i]["text"]
+            or (norm(ws[i]["text"]) in NUMEROS and norm(ws[i]["text"]) not in ARTIGOS_NUM)]
+    if nums:
+        return max(nums, key=lambda i: en[i]), "número"
+    negs = [i for i in f if norm(ws[i]["text"]) in NEGACOES]
+    if negs:
+        return max(negs, key=lambda i: en[i]), "negação"
+    fortes = [i for i in f if norm(ws[i]["text"]) not in FRACAS and len(norm(ws[i]["text"])) >= 3]
+    if not fortes:
+        return None
+    return max(fortes, key=lambda i: en[i]), "palavra mais forte"
+
+
+def tempo_do_campo(v, ws: list[dict], depois: float = 0.0) -> float | None:
+    """Seconds of a "de"/"ate" of a hand-written block: a number, or the first time the word(s) are said."""
+    if isinstance(v, (int, float)):
+        return float(v)
+    alvo = [norm(x) for x in str(v).split() if norm(x)]
+    if not alvo:
+        return None
+    for i in range(len(ws) - len(alvo) + 1):
+        if ws[i]["start"] >= depois - 1e-3 and [norm(w["text"]) for w in ws[i:i + len(alvo)]] == alvo:
+            return ws[i]["start"]
+    return None
+
+
+def trechos_sobre_a_pessoa(cfg: dict, ws: list[dict], vdur: float) -> list[tuple[float, float]]:
+    """Stretches (de, ate) of the `cenas_proprias` marked "sobre_a_pessoa": true, merged. "de" and "ate" are seconds or a
+    word (`de_depois_de` / `ate_depois_de` choose the repetition); no "ate" = to the end of the video."""
+    out = []
+    for i, c in enumerate(cfg.get("cenas_proprias") or []):
+        if not isinstance(c, dict) or c.get("sobre_a_pessoa") is not True:
+            continue
+        nome = c.get("arquivo") or f"cena própria {i + 1}"
+        de = tempo_do_campo(c.get("de", 0.0), ws, float(c.get("de_depois_de", c.get("depois_de", 0.0)) or 0.0))
+        if de is None:
+            raise Erro(f'{nome}: não achei a palavra "{c.get("de")}" (do "de") na fala; escreva em segundos')
+        ate = vdur
+        if c.get("ate") is not None:
+            ate = tempo_do_campo(c["ate"], ws, max(de, float(c.get("ate_depois_de", 0.0) or 0.0)))
+            if ate is None:
+                raise Erro(f'{nome}: não achei a palavra "{c["ate"]}" (do "ate") na fala; escreva em segundos')
+        de, ate = max(0.0, de), min(vdur, ate)
+        if ate > de + 0.05:
+            out.append((de, ate))
+    out.sort()
+    juntos: list[tuple[float, float]] = []
+    for de, ate in out:
+        if juntos and de <= juntos[-1][1] + 0.05:
+            juntos[-1] = (juntos[-1][0], max(juntos[-1][1], ate))
+        else:
+            juntos.append((de, ate))
+    return juntos
+
+
+def mesclar(trechos: list[tuple[float, float]]) -> list[tuple[float, float]]:
+    """Ranges sorted and merged where they touch."""
+    out: list[tuple[float, float]] = []
+    for a, b in sorted(trechos):
+        if out and a <= out[-1][1] + 0.05:
+            out[-1] = (out[-1][0], max(out[-1][1], b))
+        else:
+            out.append((a, b))
+    return out
+
+
+def plano(cfg: dict, ws: list[dict], cortes: list[float], vdur: float, db=None, min_gap: float = MIN_GAP_S) -> dict:
+    """The new "blocos" of the project and a short report. Pure: reads nothing from disk."""
+    manuais, simples = [], []
+    for b in cfg.get("blocos") or []:
+        if not isinstance(b, dict) or b.get("auto") == MARCA:
+            continue
+        b = dict(b)
+        if isinstance(b.get("zooms"), list):          # punch-ins from a previous run inside a hand-written block
+            b["zooms"] = [z for z in b["zooms"] if not (isinstance(z, dict) and z.get("auto") == MARCA)]
+            if not b["zooms"]:
+                del b["zooms"]
+                if b.pop("_zoom_auto", None):
+                    b.pop("zoom", None)
+        de = tempo_do_campo(b.get("de", 0.0), ws)
+        ate = tempo_do_campo(b["ate"], ws, de or 0.0) if "ate" in b else vdur
+        if de is None or ate is None:
+            raise Erro(f'bloco {b.get("cena")}: não achei a palavra de "de"/"ate" na fala; escreva em segundos')
+        plain = (b.get("cena") == "tela_cheia" and not b.get("zooms") and not b.get("acompanhar")
+                 and b.get("camera_viva", True) is not False and not b.get("borrar"))
+        (simples if plain else manuais).append((de, min(ate, vdur), b))
+    manuais.sort(key=lambda x: x[0])
+
+    # the stretches that are free for the live camera: everything outside the hand-written blocks that stay
+    livres, t = [], 0.0
+    for de, ate, _ in manuais:
+        if de > t + 0.05:
+            livres.append((t, de))
+        t = max(t, ate)
+    if t < vdur - 0.05:
+        livres.append((t, vdur))
+
+    # lettering, rótulo e carimbo ficam em cima da cabeça: ali a aproximação no rosto empurraria a cabeça para baixo do texto
+    ocupado: list[tuple[float, float]] = []
+    titulos: list[tuple[float, float]] = []
+    for an in cfg.get("animacoes") or []:
+        if not isinstance(an, dict) or an.get("tipo") not in ("lettering", "rotulo", "carimbo"):
+            continue
+        ini = tempo_do_campo(an["em"], ws, float(an.get("depois_de") or 0.0)) if an.get("em") is not None else None
+        if ini is None:
+            continue
+        fim = tempo_do_campo(an["sai"], ws, ini) if an.get("sai") is not None else None
+        ocupado.append((ini - 0.1, fim if fim is not None else ini + 2.5))
+        # o título grande no alto (lettering que não pediu "base"/"meio", com a legenda fora do trecho): a câmera abre
+        # espaço em cima, com o rosto mais baixo no quadro (zoom 1,12 com o foco embaixo), em vez de subir a cabeça
+        leg = cfg.get("legenda") if isinstance(cfg.get("legenda"), dict) else {}
+        junto = an.get("legenda_junto")
+        if junto is None:
+            junto = leg.get("estilo") == "discreta"
+        if an.get("tipo") == "lettering" and an.get("posicao") not in ("base", "meio") and not junto:
+            titulos.append(ocupado[-1])
+
+    fs = frases(ws, cortes)
+    limites = []                                   # where each sentence starts on screen
+    for f in fs:
+        s = ws[f[0]]["start"]
+        c = min(cortes, key=lambda c: abs(c - s), default=None)
+        limites.append(round(c if c is not None and abs(c - s) <= SNAP_S else max(0.0, s - 0.04), 3))
+    if limites:
+        limites[0] = 0.0
+
+    sobre = trechos_sobre_a_pessoa(cfg, ws, vdur)  # the camera stays at 1.0 and does not come closer here
+    # PrimoCode: o mesmo vale para o lettering, o rótulo e o carimbo: o zoom de base 1,12 também sobe a cabeça (o título
+    # ficava colado na testa). Nesses trechos a câmera fica em 1,0 e parada; a peça é o que muda na tela.
+    calmos = mesclar(sobre + [(max(0.0, a), min(vdur, b)) for a, b in ocupado if b - a > 0.05])
+    avisos = []
+    for de, ate, b in manuais:
+        for sd, sa in sobre:
+            if b.get("cena") == "tela_cheia" and de < sa - 0.05 and ate > sd + 0.05:
+                avisos.append(f'tela_cheia seu de {de:.1f} a {ate:.1f} s cruza a cena sobre_a_pessoa de {sd:.1f} a {sa:.1f} s: '
+                              f'tire o zoom dali, senão a cabeça sobe sob o cartão')
+
+    def pedacos(la: float, lb: float) -> list[tuple[float, float, bool]]:
+        """The free stretch cut at the edges of the calm stretches (sobre_a_pessoa, lettering): [(de, ate, calmo)]"""
+        out, t = [], la
+        for sd, sa in calmos:
+            lo, hi = max(sd, la), min(sa, lb)
+            if hi - lo <= 0.05:
+                continue
+            if lo - t > 0.05:
+                out.append((t, lo, False))
+                t = lo
+            out.append((t, hi, True))
+            t = hi
+        if lb - t > 0.05:
+            out.append((t, lb, False))
+        elif out:
+            out[-1] = (out[-1][0], lb, out[-1][2])
+        return out
+
+    autos, punches, ultima_base, ultimo_punch = [], [], ZOOM_B, -99.0
+    for la, lb in livres:
+        for pa, pb, sob in pedacos(la, lb):
+            pontos = [pa] + ([] if sob else [x for x in limites if pa + CURTA_S * 0.8 <= x <= pb - CURTA_S * 0.8]) + [pb]
+            if sob:     # o trecho calmo troca de enquadramento só onde começa ou acaba um título no alto
+                pontos = sorted(set(pontos + [round(x, 3) for t in titulos for x in t if pa + 0.3 < x < pb - 0.3]))
+            for a, b in zip(pontos, pontos[1:]):
+                titulo = sob and any(x - 0.01 <= (a + b) / 2 <= y + 0.01 for x, y in titulos) and \
+                    not any(x < b - 0.05 and a + 0.05 < y for x, y in sobre)
+                base = ZOOM_B if titulo else (ZOOM_A if sob or ultima_base == ZOOM_B else ZOOM_B)
+                ultima_base = base
+                bloco = dict(cena="tela_cheia", de=round(a, 3), ate=round(b, 3), zoom=base, auto=MARCA)
+                if titulo:
+                    bloco["foco_y"] = FOCO_TITULO
+                dentro = [f for f in fs if a - 0.05 <= ws[f[0]]["start"] < b - 0.05]
+                cands = [] if sob else [e for e in (enfase(ws, f, db) for f in dentro) if e]
+                ordem = {"número": 0, "negação": 1, "palavra mais forte": 2}
+                cands.sort(key=lambda e: (ordem[e[1]], -energia(db, ws[e[0]])))
+                for i, motivo in cands:
+                    t0 = ws[i]["start"]
+                    if t0 - ultimo_punch < min_gap or t0 < a + 0.45 or b - t0 < PUNCH_FICA_S + 0.25:
+                        continue
+                    t1 = round(min(ws[i]["end"] + PUNCH_FICA_S, b - 0.05), 3)
+                    if any(x < t1 and t0 - 0.1 < y for x, y in ocupado):
+                        continue
+                    bloco["zooms"] = [dict(em=round(t0, 3), ate=t1, escala=PUNCH_A if base == ZOOM_A else PUNCH_B,
+                                           som=False, auto=MARCA)]
+                    punches.append(dict(em=round(t0, 2), palavra=ws[i]["text"], motivo=motivo))
+                    ultimo_punch = t0
+                    break
+                autos.append((a, bloco))
+    if autos and autos[-1][1]["ate"] >= vdur - 0.05:
+        del autos[-1][1]["ate"]                    # the last block goes to the end (and holds on the still end)
+
+    blocos = [b for _, _, b in manuais]
+    todos = sorted([(de, b) for de, _, b in manuais] + autos, key=lambda x: x[0])
+    # the card of a sobre_a_pessoa scene coming and going is also something that changes on screen
+    cartoes = {round(x, 2) for d, a in calmos for x in (d, a) if 0.05 < x < vdur - 0.05}
+    trocas = sorted({round(de, 2) for de, _ in todos} | {p["em"] for p in punches} | cartoes)
+    # inside a sobre_a_pessoa stretch the camera stays still on purpose: the card is what changes there (main() says how long)
+    dentro = lambda x, y: any(x >= sd - 0.01 and y <= sa + 0.01 for sd, sa in calmos)  # noqa: E731
+    maior = max((y - x for x, y in zip([0.0] + trocas, trocas + [vdur]) if not dentro(x, y)), default=0.0)
+    return dict(blocos=[b for _, b in todos], frases=len(fs), blocos_auto=len(autos), punches=punches,
+                mantidos=len(blocos), simples_trocados=len(simples), maior_intervalo=round(maior, 2),
+                sobre_a_pessoa=[[round(d, 2), round(a, 2)] for d, a in sobre], avisos=avisos)
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Câmera viva: zoom de base alternando por frase e aproximação no rosto "
+                                             "nas palavras de ênfase, escritos no projeto.json.")
+    ap.add_argument("projeto", type=Path, help="a pasta do projeto (<PROJ>)")
+    ap.add_argument("--desfazer", action="store_true", help="tira tudo o que a câmera viva escreveu (vídeo calmo)")
+    ap.add_argument("--min-gap", type=float, default=MIN_GAP_S, help="segundos entre duas aproximações (2,5)")
+    ap.add_argument("--json", action="store_true")
+    a = ap.parse_args(argv)
+    try:
+        pj = a.projeto / "projeto.json"
+        if not pj.is_file():
+            raise Erro(f"não achei {pj}: crie o projeto com o build.py novo")
+        cfg = ler_json(pj)
+        if a.desfazer:
+            antes = cfg.get("blocos") or []
+            cfg["blocos"] = [b for b in antes if not (isinstance(b, dict) and b.get("auto") == MARCA)]
+            for b in cfg["blocos"]:
+                if isinstance(b, dict) and isinstance(b.get("zooms"), list):
+                    b["zooms"] = [z for z in b["zooms"] if not (isinstance(z, dict) and z.get("auto") == MARCA)]
+            pj.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+            print(f"câmera viva: tirei {len(antes) - len(cfg['blocos'])} bloco(s). Rode o build de novo.")
+            return 0
+        edit = (a.projeto / cfg.get("edit", "../edit")).resolve()
+        tl = edit / "cut_timeline.json"
+        if not tl.is_file():
+            raise Erro(f"falta {tl}: termine o corte primeiro")
+        tl = ler_json(tl)
+        vdur = float(tl["duration"])
+        cortes = sorted(float(s["out_start"]) for s in tl["segments"] if s["out_start"] > 0.01)
+        ws = palavras_do_corte(edit)
+        db = None
+        video = edit / cfg.get("video", "cut.mp4")
+        if video.is_file():
+            try:
+                sys.path.insert(0, str(Path(__file__).resolve().parent))
+                import corte_por_onda as onda  # noqa: E402, PLC0415
+                db = onda.envelope(video, None)
+            except Exception as e:  # noqa: BLE001  (without the wave the emphasis is number, negation, first strong word)
+                print(f"aviso: não medi a onda ({e}); a ênfase fica por número e negação", file=sys.stderr)
+        r = plano(cfg, ws, cortes, vdur, db, a.min_gap)
+        cfg["blocos"] = r["blocos"]
+        pj.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    except Erro as e:
+        print(f"ERRO: {e}", file=sys.stderr)
+        return 2
+    if a.json:
+        print(json.dumps({k: v for k, v in r.items() if k != "blocos"}, ensure_ascii=False))
+        return 0
+    print(f"câmera viva: {r['blocos_auto']} trecho(s) de tela cheia alternando {ZOOM_A:g} e {ZOOM_B:g}, "
+          f"{len(r['punches'])} aproximação(ões) no rosto; {r['mantidos']} bloco(s) seu(s) mantido(s).")
+    for p in r["punches"]:
+        print(f"  {p['em']:6.2f} s  \"{p['palavra']}\"  ({p['motivo']})")
+    for d, a in r["sobre_a_pessoa"]:
+        print(f"  {d:6.2f} a {a:.2f} s  sobre a pessoa: zoom 1,0 e sem aproximação (a cabeça não sobe sob o cartão)"
+              + (f"; são {a - d:.1f} s com a câmera parada: o cartão precisa mudar de estado a cada 2 a 4 s" if a - d > 4.0 else ""))
+    for aviso in r["avisos"]:
+        print(f"  aviso: {aviso}")
+    print(f"  maior intervalo sem mudança de câmera: {r['maior_intervalo']:.1f} s"
+          + ("  (acima de 4 s: ponha uma peça ou cena nesse trecho)" if r["maior_intervalo"] > 4.0 else ""))
+    print("  rode o build de novo (amostra ou completo) para ver no estúdio.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())