primocode 10.16.0 → 10.17.0

package/editor/helpers/portao.py

@@ -0,0 +1,427 @@
+"""Quality gate for a rendered video: the edit is only delivered when this prints "PASSOU".
+
+Checks the exported file (not the studio):
+  1. black frames (0.1 s or more anywhere, the very first 0.1 s excepted);
+  2. loudness: integrated -14 LUFS with 1.5 of margin, true peak under -1 dBTP;
+  3. breaths: no silence of 0.25 s or more (helpers/respiros.py). The silence after the last spoken word does not
+     count when the project has a still end (`segura_fim`) or a closing card (`cartao_final`): it is the end of the
+     video, not a breath;
+  4. text outside the Reels safe zone (x 140-940, y 230-1530 on 1080x1920) or touching the edge of the frame,
+     read with the same reader as conferir_dados.py (Apple Vision on the Mac, Tesseract elsewhere). The stretches
+     of `prova`, `contida`, `comparar` and `tela_verde` blocks are not read: the text there is on the person's own
+     footage (a screen recording), not text of the edit. Without a reader the check says so and does not block;
+  4b. (PrimoCode) text glued to the face: in the full-screen stretches (the person fills the frame) a line of text
+     closer than ROSTO_PX to the face box fails (the box from the hair line down to just under the mouth: the chin is
+     where the captions sit by design). The face is found in the same frames the reader reads, with the YuNet
+     detector of face_layout.py (the face as it is on screen: zoom and camera included). Without the detector the
+     check says so and does not block;
+  5. a sheet of frames with the safe zone box drawn on it, saved next to the report;
+  6. (PrimoCode) the loudnorm of every step (cut, clean voice, soundtrack) stayed LINEAR: the dynamic mode is a
+     compressor ffmpeg turns on silently and the voice pumps (helpers/ganho_por_trecho.py prevents it);
+  7. (PrimoCode) no sample at the digital ceiling (|x| >= 0.999) in the exported audio.
+
+Usage:
+    uv run python helpers/portao.py <final.mp4> --projeto <PROJ> [--fps 3] [--folha <png>] [--ajustar-volume] [--json]
+
+`--ajustar-volume`: when only the loudness is off, rewrites the audio to -14 LUFS (two passes, the picture is not
+re-encoded), keeps the original as `<nome>_antes_do_volume.mp4` and measures again. No new render needed.
+Exit code 0 when everything passes, 1 when something failed, 2 on error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import conferir_dados as cd  # noqa: E402
+import corte_por_onda as onda  # noqa: E402
+import respiros  # noqa: E402
+from common import fmt_time, probe_video, require_binary  # noqa: E402
+
+ALVO_LUFS, MARGEM_LUFS, PICO_MAX_DB = -14.0, 1.5, -1.0
+PRETO_MIN_S = 0.1
+PRETO_INICIO_S = 0.1       # black this short at the very start (the first frame) is the video opening
+BLOCOS_DE_MATERIAL = ("prova", "contida", "comparar", "tela_verde")   # footage of the person: its text is not ours
+ZONA = (140, 230, 940, 1530)          # x0, y0, x1, y1 on 1080x1920
+BORDA_PX = 24                         # text closer than this to the edge of the frame is "touching"
+CONF_MIN = 0.5
+FOLGA_PX = 6                          # the reader's box is not exact
+ROSTO_PX = 40                         # text closer than this to the face box is "glued to the face" (px on 1920 high)
+CENAS_COM_ROSTO = ("tela_cheia",)     # stretches where the person fills the frame (moldura/prova/...: the face is small or not ours)
+
+
+def distancia_ao_rosto(caixa: tuple[float, float, float, float], rosto: tuple[float, float, float, float]) -> float:
+    """Gap in px between a text box and the face box, both (x0, y0, x1, y1). Negative when they overlap (the depth of
+    the overlap on the shallower axis)."""
+    dx = max(rosto[0] - caixa[2], caixa[0] - rosto[2])
+    dy = max(rosto[1] - caixa[3], caixa[1] - rosto[3])
+    if dx < 0 and dy < 0:
+        return max(dx, dy)
+    return max(dx, dy) if (dx < 0 or dy < 0) else (dx * dx + dy * dy) ** 0.5
+
+
+def colado_no_rosto(caixa, rosto, h: int = 1920, px: float = ROSTO_PX) -> bool:
+    """True when the text box is closer than `px` (scaled to the video height) to the face box."""
+    return rosto is not None and distancia_ao_rosto(caixa, rosto) < px * h / 1920
+
+
+def rostos_dos_quadros(pasta: Path, n: int, w: int, h: int) -> dict[int, tuple[float, float, float, float] | None] | None:
+    """The face box (px) in each extracted frame f_00001.jpg..., with the YuNet detector of face_layout.py. None when the
+    detector is not available here (no OpenCV or no model)."""
+    try:
+        import cv2  # noqa: PLC0415
+        import face_layout as fl  # noqa: PLC0415
+        fl._cv2()
+    except Exception:  # noqa: BLE001
+        return None
+    out: dict[int, tuple[float, float, float, float] | None] = {}
+    for k in range(n):
+        img = cv2.imread(str(pasta / f"f_{k + 1:05d}.jpg"))
+        f = fl.detect_array(img) if img is not None else None
+        out[k] = caixa_do_rosto(f, w, h) if f else None
+    return out
+
+
+QUEIXO = 0.08    # the face box for the rule ends this far (fraction of the face height) under the mouth line
+
+
+def caixa_do_rosto(f: dict, w: int, h: int) -> tuple[float, float, float, float]:
+    """The face box (px) the text has to keep away from: the YuNet box from its top (hair line) down to just under the
+    mouth. The chin under the mouth is where the captions of the edit sit by design (face_layout: they miss the eyes and
+    the mouth), so it is not part of it."""
+    y0, y1 = f["y0"] * h, f["y1"] * h
+    boca = f.get("mouth_y")
+    if boca is not None:
+        y1 = min(y1, boca * h + QUEIXO * (y1 - y0))
+    return (f["x0"] * w, y0, f["x1"] * w, y1)
+
+
+def zona_para(w: int, h: int) -> tuple[int, int, int, int] | None:
+    """The safe zone scaled to the video size; only defined for vertical 9:16 (other formats have wider margins)."""
+    if abs(w / h - 9 / 16) > 0.02:
+        return None
+    k = w / 1080
+    return tuple(round(v * k) for v in ZONA)  # type: ignore[return-value]
+
+
+def quadros_pretos(video: Path, dur: float) -> list[tuple[float, float]]:
+    r = subprocess.run(["ffmpeg", "-nostdin", "-v", "info", "-i", str(video), "-vf",
+                        f"blackdetect=d={PRETO_MIN_S - 0.02:.2f}:pix_th=0.06", "-an", "-f", "null", "-"],
+                       capture_output=True, text=True)
+    out = []
+    for m in re.finditer(r"black_start:([\d.]+)\s+black_end:([\d.]+)", r.stderr):
+        a, b = float(m[1]), float(m[2])
+        if a < 0.05 and b - a <= PRETO_INICIO_S + 0.05:
+            continue
+        out.append((a, b))
+    return out
+
+
+def volume(video: Path, completo: bool = False) -> dict:
+    r = subprocess.run(["ffmpeg", "-nostdin", "-v", "info", "-i", str(video), "-vn", "-af",
+                        "loudnorm=I=-14:TP=-1.5:LRA=11:print_format=json", "-f", "null", "-"],
+                       capture_output=True, text=True)
+    m = re.search(r"\{[^{}]*\"input_i\"[^{}]*\}", r.stderr, re.S)
+    if not m:
+        raise RuntimeError("não consegui medir o volume (o arquivo tem áudio?)")
+    d = json.loads(m.group(0))
+    out = {"lufs": float(d["input_i"]), "pico_db": float(d["input_tp"])}
+    if completo:
+        out["_loudnorm"] = d
+    return out
+
+
+def ajustar_volume(video: Path) -> Path:
+    """Two-pass loudnorm to -14 LUFS (true peak -1.5), picture copied. The original stays next to it."""
+    d = volume(video, completo=True)["_loudnorm"]
+    antes = video.with_name(video.stem + "_antes_do_volume" + video.suffix)
+    novo = video.with_name(video.stem + "_novo_volume" + video.suffix)
+    af = ("loudnorm=I=-14:TP=-1.5:LRA=11:linear=true:"
+          f"measured_I={d['input_i']}:measured_TP={d['input_tp']}:measured_LRA={d['input_lra']}:"
+          f"measured_thresh={d['input_thresh']}:offset={d['target_offset']}")
+    r = subprocess.run(["ffmpeg", "-nostdin", "-v", "error", "-y", "-i", str(video), "-map", "0:v", "-map", "0:a",
+                        "-c:v", "copy", "-af", af, "-ar", "48000", "-c:a", "aac", "-b:a", "192k",
+                        "-movflags", "+faststart", str(novo)], capture_output=True, text=True)
+    if r.returncode != 0 or not novo.is_file():
+        raise RuntimeError("não consegui ajustar o volume: " + r.stderr[-300:])
+    if not antes.exists():
+        video.rename(antes)
+    else:
+        video.unlink()
+    novo.rename(video)
+    return antes
+
+
+def texto_fora(video: Path, w: int, h: int, fps: float, ignorar: list[tuple[float, float]] | None = None,
+               com_rosto: list[tuple[float, float]] | None = None) -> dict:
+    """Lines of text outside the safe zone, touching the edge or glued to the face (in `com_rosto` stretches).
+    {'leitor': ..., 'achados': [...], 'rosto': True | False | None}."""
+    zona = zona_para(w, h)
+    motor = cd.leitor()
+    if motor is None:
+        return {"leitor": None, "achados": [], "zona": zona, "ignorado": ignorar or [], "rosto": None}
+    info = probe_video(video)
+    fps_video = float(info.get("fps") or 30.0)
+    dur = float(info["duration"])
+    n_total = int(dur * fps - 1e-6) + 1
+    achados: list[dict] = []
+    with tempfile.TemporaryDirectory(prefix="portao-") as tmp:
+        pasta = Path(tmp)
+        n = cd.extrair(video, pasta, 0, n_total, fps, fps_video, True, "")
+        bruto = cd.ler_pasta(motor, pasta) if n else {}
+        rostos = rostos_dos_quadros(pasta, n, w, h) if (n and com_rosto) else None
+    ignorar = ignorar or []
+    com_rosto = com_rosto or []
+    for k in range(n):
+        t = k / fps
+        if any(x - 0.05 <= t <= y + 0.05 for x, y in ignorar):
+            continue
+        for it in bruto.get(f"f_{k + 1:05d}.jpg", []):
+            if float(it.get("c", 1)) < CONF_MIN or len(re.sub(r"\W", "", str(it.get("t", "")))) < 2:
+                continue
+            x0, y1 = float(it["x"]) * w, (1 - float(it["y"]) - float(it["h"])) * h
+            x1, y2 = x0 + float(it["w"]) * w, y1 + float(it["h"]) * h
+            motivo = None
+            if x0 < BORDA_PX or y1 < BORDA_PX or x1 > w - BORDA_PX or y2 > h - BORDA_PX:
+                motivo = "encostado na borda"
+            elif zona and (x0 < zona[0] - FOLGA_PX or x1 > zona[2] + FOLGA_PX
+                           or y1 < zona[1] - FOLGA_PX or y2 > zona[3] + FOLGA_PX):
+                motivo = "fora da zona segura"
+            elif rostos and any(x - 0.05 <= t <= y + 0.05 for x, y in com_rosto) and \
+                    colado_no_rosto((x0 + FOLGA_PX, y1 + FOLGA_PX, x1 - FOLGA_PX, y2 - FOLGA_PX), rostos.get(k), h):
+                motivo = f"colado no rosto (a menos de {round(ROSTO_PX * h / 1920)} px)"
+            if motivo:
+                achados.append({"t": round(t, 2), "texto": str(it["t"]).strip(), "motivo": motivo,
+                                "caixa": [round(x0), round(y1), round(x1 - x0), round(y2 - y1)]})
+    # the same line seen in a row of samples is one finding
+    juntos: list[dict] = []
+    for a in sorted(achados, key=lambda a: (a["texto"], a["t"])):
+        if juntos and juntos[-1]["texto"] == a["texto"] and a["t"] - juntos[-1]["ate"] <= 1.5 / fps + 1e-6:
+            juntos[-1]["ate"] = a["t"]
+        else:
+            juntos.append(dict(a, ate=a["t"]))
+    return {"leitor": motor[0], "achados": sorted(juntos, key=lambda a: a["t"]), "zona": zona, "ignorado": ignorar,
+            "rosto": (rostos is not None) if com_rosto else None}
+
+
+def faixas_de_material(cfg: dict, projeto: Path | None, dur: float, cenas=BLOCOS_DE_MATERIAL) -> list[tuple[float, float]]:
+    """Time ranges (s) of the blocks that show the person's own footage (or of the `cenas` asked). A time written as a
+    word is looked up in the words of the cut; without the transcript only the blocks written in seconds are found."""
+    import camera_viva as cv  # noqa: PLC0415
+    ws: list[dict] = []
+    vdur = dur
+    if projeto:
+        try:
+            edit = (projeto / cfg.get("edit", "../edit")).resolve()
+            ws = cv.palavras_do_corte(edit)
+            vdur = float(json.loads((edit / "cut_timeline.json").read_text(encoding="utf-8"))["duration"])
+        except Exception:  # noqa: BLE001
+            ws = []
+    out = []
+    for b in cfg.get("blocos") or []:
+        if not isinstance(b, dict) or b.get("cena") not in cenas:
+            continue
+        de = cv.tempo_do_campo(b.get("de", 0.0), ws)
+        ate = cv.tempo_do_campo(b["ate"], ws, de or 0.0) if "ate" in b else vdur
+        if de is not None and ate is not None:
+            out.append((de, ate))
+    return out
+
+
+def faixas_com_rosto(cfg: dict, projeto: Path | None, dur: float) -> list[tuple[float, float]]:
+    """Time ranges (s) where the person fills the frame: everything outside the blocks that are not `tela_cheia`
+    (moldura, prova, contida, comparar, tela_verde). There the face box is the one that matters for the text."""
+    outros = sorted(faixas_de_material(cfg, projeto, dur, cenas=("moldura", "prova", "contida", "comparar", "tela_verde")))
+    return livres_entre(outros, dur)
+
+
+def livres_entre(ocupados: list[tuple[float, float]], dur: float) -> list[tuple[float, float]]:
+    """[0, dur] minus the sorted `ocupados` ranges."""
+    out, t = [], 0.0
+    for de, ate in sorted(ocupados):
+        if de > t + 0.05:
+            out.append((t, de))
+        t = max(t, ate)
+    if t < dur - 0.05:
+        out.append((t, dur))
+    return out
+
+
+def fim_da_fala(cfg: dict, dur: float) -> float | None:
+    """Where the voice ends in the final video: the duration minus the still end and the closing card. None when
+    the project has neither (then the last silence counts like any other)."""
+    segura = float(cfg.get("segura_fim") or 0)
+    cf = cfg.get("cartao_final") or {}
+    cartao = float(cf.get("segundos", 1.8)) if cf.get("ligado") else 0.0
+    return dur - segura - cartao if (segura > 0 or cartao > 0) else None
+
+
+def folha(video: Path, w: int, h: int, tempos: list[float], saida: Path) -> Path:
+    from PIL import Image, ImageDraw  # noqa: PLC0415
+    import contact_sheet as cs  # noqa: PLC0415
+    tw = 270
+    th = round(tw * h / w)
+    quadros = cs.extract_frames(video, tempos, width=tw, height=th)
+    zona = zona_para(w, h)
+    for im in quadros:
+        d = ImageDraw.Draw(im)
+        if zona:
+            k = tw / w
+            d.rectangle([round(v * k) for v in zona], outline=(255, 60, 60), width=2)
+    rotulos = [fmt_time(t) for t in tempos]
+    cs.build_sheet(quadros, rotulos, 6, f"{video.name} · caixa vermelha = zona segura").save(saida)
+    return saida
+
+
+def modos_do_volume(video: Path, projeto: Path | None, cfg: dict) -> list[tuple[str, str]]:
+    """PrimoCode: o modo de cada loudnorm do caminho (corte, voz limpa, trilha). Dinâmico é um compressor que o
+    ffmpeg liga calado quando o ganho linear passaria do pico: a voz bombeia. Lista (etapa, modo)."""
+    out: list[tuple[str, str]] = []
+    def ler(p: Path) -> dict:
+        try:
+            return json.loads(p.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return {}
+    edit = None
+    if projeto and cfg.get("edit"):
+        edit = (projeto / cfg["edit"]).resolve()
+    if edit and edit.is_dir():
+        m = ler(edit / "cut_timeline.json").get("loudnorm_modo")
+        if m:
+            out.append(("corte", m))
+        m = (ler(edit / "verify" / "voz_limpa.json").get("relatorio") or {}).get("loudnorm_modo")
+        if m:
+            out.append(("voz limpa", m))
+    m = ler(video.with_name(video.name + ".trilha.json")).get("ajuste")
+    if m:
+        out.append(("trilha", m))
+    return out
+
+
+def amostras_clipadas(video: Path) -> int:
+    """PrimoCode: amostras no teto digital (|x| >= 0,999) no áudio exportado. Uma já é estalo."""
+    import numpy as np
+    raw = subprocess.run(["ffmpeg", "-nostdin", "-v", "error", "-i", str(video), "-vn", "-f", "f32le", "-acodec",
+                          "pcm_f32le", "-ar", "48000", "-"], capture_output=True).stdout
+    if not raw:
+        return 0
+    x = np.frombuffer(raw[: len(raw) // 4 * 4], dtype=np.float32)
+    return int(np.count_nonzero(np.abs(x) >= 0.999))
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Portão de qualidade do vídeo exportado: só entrega com PASSOU.")
+    ap.add_argument("video", type=Path)
+    ap.add_argument("--projeto", type=Path, help="a pasta do projeto (lê o segura_fim e guarda a folha em renders/)")
+    ap.add_argument("--fps", type=float, default=3.0, help="quadros lidos por segundo para o texto (3)")
+    ap.add_argument("--folha", type=Path, help="PNG da folha de quadros (padrão: <projeto>/renders/portao.png)")
+    ap.add_argument("--ajustar-volume", action="store_true",
+                    help="se só o volume estiver fora, regrava o áudio em -14 LUFS (sem novo render) e mede de novo")
+    ap.add_argument("--json", action="store_true")
+    a = ap.parse_args(argv)
+    if not a.video.is_file():
+        print(f"ERRO: não achei {a.video}", file=sys.stderr)
+        return 2
+    try:
+        require_binary("ffmpeg")
+        info = probe_video(a.video)
+        W, H = int(info.get("display_width") or info["width"]), int(info.get("display_height") or info["height"])
+        dur = float(info["duration"])
+        cfg = {}
+        if a.projeto and (a.projeto / "projeto.json").is_file():
+            cfg = json.loads((a.projeto / "projeto.json").read_text(encoding="utf-8"))
+        pretos = quadros_pretos(a.video, dur)
+        vol = volume(a.video)
+        volume_ajustado = None
+        if a.ajustar_volume and (abs(vol["lufs"] - ALVO_LUFS) > MARGEM_LUFS or vol["pico_db"] > PICO_MAX_DB):
+            volume_ajustado = ajustar_volume(a.video)
+            vol = volume(a.video)
+        db = onda.envelope(a.video, None)
+        th = onda.threshold(db)
+        resp = respiros.find(db, th, respiros.MIN_S)
+        fim_voz = fim_da_fala(cfg, dur)
+        resp_fim = []
+        if fim_voz is not None:                 # silence after the last word is the still end / the card, not a breath
+            resp_fim = [r for r in resp if r[0] >= fim_voz - 0.3]
+            resp = [r for r in resp if r not in resp_fim]
+        txt = texto_fora(a.video, W, H, a.fps, faixas_de_material(cfg, a.projeto, dur), faixas_com_rosto(cfg, a.projeto, dur))
+        modos = modos_do_volume(a.video, a.projeto, cfg)
+        clip = amostras_clipadas(a.video)
+    except (RuntimeError, OSError, ValueError) as e:
+        print(f"ERRO: {e}", file=sys.stderr)
+        return 2
+
+    falhas: list[str] = []
+    if pretos:
+        falhas.append("quadro preto: " + ", ".join(f"{fmt_time(x)} a {fmt_time(y)}" for x, y in pretos))
+    if abs(vol["lufs"] - ALVO_LUFS) > MARGEM_LUFS:
+        falhas.append(f"volume {vol['lufs']:.1f} LUFS (o alvo é {ALVO_LUFS:.0f}, margem {MARGEM_LUFS:g}): "
+                      "ajuste o ganho do arquivo e confira de novo")
+    if vol["pico_db"] > PICO_MAX_DB:
+        falhas.append(f"pico {vol['pico_db']:.1f} dBTP (o limite é {PICO_MAX_DB:g}): baixe o ganho ou use o limitador")
+    dinamicos = [e for e, m in modos if str(m).lower() not in ("linear",)]
+    if dinamicos:
+        falhas.append("volume em modo dinâmico (" + ", ".join(dinamicos) + "): o loudnorm comprimiu a voz; rode o "
+                      "helpers/ganho_por_trecho.py no edl_manual.json, refaça o corte e renderize")
+    if clip:
+        falhas.append(f"clipou: {clip} amostra(s) no teto digital; baixe o ganho do trecho ou o volume dos sons")
+    if resp:
+        falhas.append("respiro: " + ", ".join(f"{fmt_time(x)} ({y - x:.2f} s)" for x, y in resp))
+    for f in txt["achados"]:
+        falhas.append(f"texto {f['motivo']}: \"{f['texto'][:40]}\" em {fmt_time(f['t'])}"
+                      + (f" a {fmt_time(f['ate'])}" if f["ate"] > f["t"] else ""))
+    saida = a.folha or ((a.projeto / "renders" / "portao.png") if a.projeto else a.video.with_name("portao.png"))
+    tempos = sorted({round(min(dur - 0.05, x), 2) for x in
+                     [0.1] + [f["t"] for f in txt["achados"]][:6] + [i * dur / 11 for i in range(1, 12)]})[:18]
+    try:
+        saida.parent.mkdir(parents=True, exist_ok=True)
+        folha(a.video, W, H, tempos, saida)
+    except Exception as e:  # noqa: BLE001  (the sheet is a help to the eye, it never fails the gate)
+        saida = None
+        print(f"aviso: não montei a folha de quadros ({e})", file=sys.stderr)
+
+    if txt.get("rosto") is False:
+        print("aviso: o rosto não foi conferido (sem o detector YuNet aqui); texto colado no rosto não reprova", file=sys.stderr)
+    rel = {"passou": not falhas, "falhas": falhas, "duracao": round(dur, 2), "volume": vol, "rosto_conferido": txt.get("rosto"),
+           "modos_do_volume": dict(modos), "amostras_clipadas": clip,
+           "limiar_respiro_db": th, "leitor_de_texto": txt["leitor"], "folha": str(saida) if saida else None}
+    if a.json:
+        print(json.dumps(rel, ensure_ascii=False))
+        return 0 if not falhas else 1
+    print(f"portão · {a.video.name} · {dur:.1f} s · {W}x{H}")
+    print(f"  quadro preto: {'nenhum' if not pretos else len(pretos)}")
+    print(f"  volume: {vol['lufs']:.1f} LUFS, pico {vol['pico_db']:.1f} dBTP"
+          + (f" (ajustado; o original ficou em {volume_ajustado.name})" if volume_ajustado else ""))
+    print("  ajuste de volume: " + (", ".join(f"{e} {m}" for e, m in modos) if modos else "sem registro")
+          + f" · amostras clipadas: {clip}")
+    print(f"  respiros de 0,25 s ou mais: {'nenhum' if not resp else len(resp)}"
+          + (f" (o silêncio do fim, {resp_fim[-1][1] - resp_fim[0][0]:.1f} s, é o fim parado ou o cartão e não conta)" if resp_fim else ""))
+    if txt["leitor"] is None:
+        print("  texto na tela: NÃO conferido (sem leitor de texto neste computador; olhe a folha de quadros)")
+    elif txt["zona"] is None:
+        print(f"  texto na tela: só a borda foi conferida (formato {W}x{H}; a zona segura vale para 9:16)")
+    else:
+        print(f"  texto fora da zona segura, na borda ou colado no rosto: {'nenhum' if not txt['achados'] else len(txt['achados'])} "
+              f"(leitor {txt['leitor']})"
+              + (f"; sem ler as telas gravadas em {', '.join(fmt_time(x) + '-' + fmt_time(y) for x, y in txt['ignorado'])}"
+                 if txt.get("ignorado") else ""))
+    if saida:
+        print(f"  folha de quadros: {saida}")
+    if falhas:
+        print("REPROVOU:")
+        for f in falhas:
+            print(f"  - {f}")
+        print("Conserte o que está acima, renderize de novo e rode o portão outra vez. Não entregue assim.")
+        return 1
+    print("PASSOU")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())