primocode 10.15.2 → 10.17.0

package/editor/helpers/fetch_images.py

@@ -0,0 +1,423 @@
+"""Search and download free images for inserts (Contract 8).
+
+Sources:
+  - wikimedia (default): Wikimedia Commons API, no key. By default only images with no strings
+    attached for a paid ad: CC0 and public domain. `--allow-attribution` also accepts CC BY (the
+    post must credit the author); `--allow-sharealike` also accepts CC BY-SA (credit, and the
+    adapted work falls under the same license). "No restrictions" (Flickr Commons) is not a
+    license and is refused, and so is any file with Restrictions metadata (trademark,
+    personality, insignia). Results are ranked CC0/PD first, then CC BY, then CC BY-SA, and an
+    image that needs credit but has no known author is skipped.
+  - pexels: only when PEXELS_API_KEY is set (environment or .env in the skill root). Without
+    the key it says so and uses Wikimedia instead.
+
+Downloads go to <edit>/assets/ and every image is appended to <edit>/assets/credits.json
+(a JSON list with url, author, license, attribution_required, share_alike and credit_line, the
+ready "Foto: autor, licença, link" text when credit is required). Re-running the same search does
+not download the same image twice.
+
+Usage:
+    uv run python helpers/fetch_images.py "<busca>" --edit-dir DIR [--source wikimedia|pexels]
+        [--count 3] [--orientation portrait|landscape] [--min-width 800] [--allow-attribution]
+        [--allow-sharealike] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import io
+import json
+import os
+import re
+import sys
+import unicodedata
+from pathlib import Path
+
+import requests
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import SKILL_ROOT, load_json, now_iso, save_json  # noqa: E402
+
+USER_AGENT = "editor-video/0.1 (suporte@sistemajarvis.com)"
+COMMONS_API = "https://commons.wikimedia.org/w/api.php"
+PEXELS_API = "https://api.pexels.com/v1/search"
+TIMEOUT = 25
+ALLOWED_MIME = {"image/jpeg", "image/png", "image/webp"}
+
+
+class FetchError(Exception):
+    pass
+
+
+class EnvFileError(Exception):
+    """The skill's .env exists but cannot be read (message in PT-BR)."""
+
+
+# ---------------------------------------------------------------- small helpers
+
+_ENV_TIP_SHOWN = False
+
+
+def _decode_env(raw: bytes) -> str:
+    if raw.startswith((b"\xff\xfe", b"\xfe\xff")):
+        return raw.decode("utf-16")            # PowerShell 5.1 `echo KEY=... > .env`
+    try:
+        return raw.decode("utf-8-sig")          # Notepad's "UTF-8 with BOM" too
+    except UnicodeDecodeError:
+        if b"\x00" in raw[:64]:
+            try:
+                return raw.decode("utf-16-le")
+            except UnicodeDecodeError:
+                pass
+        try:
+            return raw.decode("cp1252")
+        except UnicodeDecodeError:
+            raise EnvFileError("não consegui ler o arquivo .env da skill. Salve o .env como UTF-8 "
+                               "(no Bloco de Notas: Salvar como > Codificação: UTF-8) e tente de novo.")
+
+
+def read_env_key(name: str) -> str | None:
+    """Key from the environment, else from .env in the skill root (never other folders).
+
+    Accepts UTF-8 (with or without BOM) and UTF-16 files, `export KEY=...`, quotes and an inline
+    ` # comment` after an unquoted value. Raises EnvFileError when the file cannot be decoded."""
+    global _ENV_TIP_SHOWN
+    val = os.environ.get(name)
+    if val and val.strip():
+        return val.strip()
+    env_file = SKILL_ROOT / ".env"
+    if not env_file.is_file():
+        return None
+    try:
+        raw = env_file.read_bytes()
+    except OSError:
+        return None
+    for line in _decode_env(raw).splitlines():
+        line = line.strip().lstrip("\ufeff")
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        if k.strip().removeprefix("export ").strip() != name:
+            continue
+        v = v.strip()
+        if v[:1] in ("'", '"'):
+            end = v.find(v[0], 1)
+            v = v[1:end] if end > 0 else v[1:]
+        else:
+            v = re.split(r"\s+#", v, maxsplit=1)[0].strip()
+        if os.name == "posix" and not _ENV_TIP_SHOWN:
+            try:
+                if env_file.stat().st_mode & 0o077:
+                    print(f"dica: outros usuários deste computador conseguem ler o .env com a sua chave. "
+                          f"Para proteger: chmod 600 \"{env_file}\"", file=sys.stderr)
+            except OSError:
+                pass
+            _ENV_TIP_SHOWN = True
+        return v or None
+    return None
+
+
+def slugify(text: str, limit: int = 40) -> str:
+    t = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode("ascii").lower()
+    t = re.sub(r"[^a-z0-9]+", "-", t).strip("-")
+    return (t[:limit].rstrip("-")) or "imagem"
+
+
+def strip_html(value: str | None) -> str:
+    if not value:
+        return ""
+    text = re.sub(r"<[^>]+>", " ", str(value))
+    return " ".join(html.unescape(text).split())
+
+
+def orientation_ok(w: int, h: int, orientation: str | None) -> bool:
+    if not orientation or not w or not h:
+        return True
+    if orientation == "portrait":
+        return h > w * 1.05
+    if orientation == "landscape":
+        return w > h * 1.05
+    return True
+
+
+LICENSE_RANK = {"free": 0, "attribution": 1, "sharealike": 2}
+
+
+def license_class(short: str) -> str | None:
+    """"free" (CC0, public domain), "attribution" (CC BY), "sharealike" (CC BY-SA) or None (no
+    commercial use, no derivatives, GFDL, fair use, "No restrictions", unknown)."""
+    s = short.lower().strip()
+    if not s:
+        return None
+    parts = set(re.split(r"[\s\-/_.,]+", s))
+    if parts & {"nc", "nd"} or "fair use" in s or "commercial" in s or "gfdl" in s:
+        return None
+    if s.startswith("cc0") or "public domain" in s or s.startswith("pd") or s.startswith("cc-pd"):
+        return "free"
+    if s.startswith(("cc by", "cc-by")) or "attribution" in s:
+        return "sharealike" if ("sa" in parts or "sharealike" in s or "share alike" in s) else "attribution"
+    return None
+
+
+def license_ok(short: str, allow_attribution: bool = False, allow_sharealike: bool = False) -> bool:
+    """Whether a license may go into a paid ad: CC0/PD always; CC BY and CC BY-SA only when allowed."""
+    cls = license_class(short)
+    return cls == "free" or (cls == "attribution" and (allow_attribution or allow_sharealike)) \
+        or (cls == "sharealike" and allow_sharealike)
+
+
+def credit_line(item: dict) -> str:
+    return f"Foto: {item['author']}, {item['license']}, {item['url']}"
+
+
+def load_credits(path: Path) -> list:
+    data = load_json(path, default=[])
+    if isinstance(data, dict):
+        data = data.get("items", [])
+    return data if isinstance(data, list) else []
+
+
+# ---------------------------------------------------------------- sources
+
+def search_wikimedia(query: str, want: int, orientation: str | None, min_width: int,
+                     allow_attribution: bool = False, allow_sharealike: bool = False) -> list[dict]:
+    params = {
+        "action": "query", "format": "json", "generator": "search",
+        "gsrsearch": f"{query} filetype:bitmap", "gsrnamespace": 6, "gsrlimit": 50,
+        "prop": "imageinfo", "iiprop": "url|size|mime|extmetadata", "iiurlwidth": 1920,
+        "iiextmetadatafilter": "LicenseShortName|Artist|LicenseUrl|UsageTerms|AttributionRequired|Restrictions",
+    }
+    try:
+        r = requests.get(COMMONS_API, params=params, headers={"User-Agent": USER_AGENT}, timeout=TIMEOUT)
+        r.raise_for_status()
+        data = r.json()
+    except (requests.RequestException, ValueError) as e:
+        raise FetchError(f"não consegui falar com o Wikimedia Commons ({e.__class__.__name__}). Confira a internet.")
+    pages = sorted((data.get("query") or {}).get("pages", {}).values(), key=lambda p: p.get("index", 0))
+    out = []
+    for p in pages:
+        info = (p.get("imageinfo") or [{}])[0]
+        meta = {k: (v or {}).get("value", "") for k, v in (info.get("extmetadata") or {}).items()}
+        w, h = int(info.get("width") or 0), int(info.get("height") or 0)
+        lic = strip_html(meta.get("LicenseShortName"))
+        if info.get("mime") not in ALLOWED_MIME or w < min_width:
+            continue
+        if not orientation_ok(w, h, orientation) or not license_ok(lic, allow_attribution, allow_sharealike):
+            continue
+        if strip_html(meta.get("Restrictions")):      # trademarked, personality, insignia...
+            continue
+        url = info.get("thumburl") or info.get("url")
+        if not url:
+            continue
+        cls = license_class(lic)
+        author = strip_html(meta.get("Artist"))
+        if cls != "free" and not author:
+            continue                                   # credit required but nobody to credit
+        lic_url = strip_html(meta.get("LicenseUrl"))
+        if lic_url.startswith("//"):
+            lic_url = "https:" + lic_url
+        out.append({
+            "source": "wikimedia",
+            "id": f"commons-{p.get('pageid')}",
+            "title": str(p.get("title", "")).removeprefix("File:"),
+            "download_url": url,
+            "url": info.get("descriptionurl") or url,
+            "author": author or "desconhecido",
+            "license": lic,
+            "license_url": lic_url,
+            "license_class": cls,
+            "attribution_required": cls != "free" or str(meta.get("AttributionRequired", "")).lower() == "true",
+            "share_alike": cls == "sharealike",
+            "orig_width": w, "orig_height": h,
+        })
+    out.sort(key=lambda it: LICENSE_RANK.get(it["license_class"], 9))   # stable: search order inside each class
+    return out[:max(want * 3, want)]
+
+
+def search_pexels(query: str, want: int, orientation: str | None, key: str) -> list[dict]:
+    params = {"query": query, "per_page": min(80, max(want * 3, 10)), "locale": "pt-BR"}
+    if orientation in ("portrait", "landscape"):
+        params["orientation"] = orientation
+    try:
+        r = requests.get(PEXELS_API, params=params, timeout=TIMEOUT,
+                         headers={"Authorization": key, "User-Agent": USER_AGENT})
+    except requests.RequestException as e:
+        raise FetchError(f"não consegui falar com o Pexels ({e.__class__.__name__}). Confira a internet.")
+    if r.status_code in (401, 403):
+        raise FetchError("o Pexels recusou a chave PEXELS_API_KEY. Confira se ela está certa.")
+    if r.status_code == 429:
+        raise FetchError("limite de buscas do Pexels atingido. Tente mais tarde ou use --source wikimedia.")
+    try:
+        r.raise_for_status()
+        photos = r.json().get("photos", [])
+    except (requests.RequestException, ValueError) as e:
+        raise FetchError(f"resposta inválida do Pexels ({e.__class__.__name__}).")
+    out = []
+    for ph in photos:
+        src = ph.get("src") or {}
+        url = src.get("large2x") or src.get("large") or src.get("original")
+        if not url:
+            continue
+        out.append({
+            "source": "pexels", "id": f"pexels-{ph.get('id')}", "title": ph.get("alt") or "",
+            "download_url": url, "url": ph.get("url") or url,
+            "author": ph.get("photographer") or "desconhecido",
+            "license": "Pexels License", "license_url": "https://www.pexels.com/license/",
+            "license_class": "free", "attribution_required": False, "share_alike": False,
+            "orig_width": int(ph.get("width") or 0), "orig_height": int(ph.get("height") or 0),
+        })
+    return out
+
+
+# ---------------------------------------------------------------- download
+
+def download(item: dict, dest_dir: Path, base_name: str) -> dict:
+    try:
+        r = requests.get(item["download_url"], headers={"User-Agent": USER_AGENT}, timeout=TIMEOUT)
+        r.raise_for_status()
+    except requests.RequestException as e:
+        raise FetchError(f"falha ao baixar {item['url']} ({e.__class__.__name__})")
+    try:
+        img = Image.open(io.BytesIO(r.content))
+        img.load()
+    except Exception:
+        raise FetchError(f"o arquivo baixado não é uma imagem válida: {item['url']}")
+    fmt = (img.format or "").upper()
+    if fmt == "PNG":
+        ext, data = ".png", r.content
+    elif fmt == "JPEG" and img.mode in ("RGB", "L"):
+        ext, data = ".jpg", r.content
+    else:
+        buf = io.BytesIO()
+        rgb = img.convert("RGBA")
+        bg = Image.new("RGB", rgb.size, (255, 255, 255))
+        bg.paste(rgb, mask=rgb.getchannel("A"))
+        bg.save(buf, "JPEG", quality=93)
+        ext, data = ".jpg", buf.getvalue()
+    path = dest_dir / f"{base_name}{ext}"
+    tmp = path.with_name(".tmp-" + path.name)
+    tmp.write_bytes(data)
+    tmp.replace(path)
+    return {"file": path.name, "width": img.width, "height": img.height}
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Busca e baixa imagens livres para os inserts (Wikimedia Commons ou Pexels).")
+    ap.add_argument("query", help="o que buscar (em inglês costuma achar mais, ex: \"leather handbag\")")
+    ap.add_argument("--edit-dir", required=True, help="pasta edit da sessão")
+    ap.add_argument("--source", choices=("wikimedia", "pexels"), default="wikimedia")
+    ap.add_argument("--count", type=int, default=3, help="quantas imagens baixar (padrão 3)")
+    ap.add_argument("--orientation", choices=("portrait", "landscape"), help="retrato ou paisagem")
+    ap.add_argument("--min-width", type=int, default=800, help="largura mínima da original (padrão 800)")
+    ap.add_argument("--allow-attribution", action="store_true",
+                    help="aceita também CC BY (o autor precisa ser creditado no texto do post)")
+    ap.add_argument("--allow-sharealike", action="store_true",
+                    help="aceita também CC BY-SA (crédito e a peça fica sob a mesma licença; evite em anúncio)")
+    ap.add_argument("--json", action="store_true", help="imprime o resultado em JSON")
+    args = ap.parse_args(argv)
+
+    if not args.query.strip():
+        print("erro: a busca está vazia", file=sys.stderr)
+        return 2
+    if not 1 <= args.count <= 20:
+        print("erro: --count precisa ficar entre 1 e 20", file=sys.stderr)
+        return 2
+    edit = Path(args.edit_dir).resolve()
+    if not edit.is_dir():
+        print(f"erro: pasta edit não encontrada: {edit}", file=sys.stderr)
+        return 2
+    assets = edit / "assets"
+    try:
+        assets.mkdir(exist_ok=True)
+    except OSError as e:
+        print(f"erro: não consegui criar {assets}: {e}", file=sys.stderr)
+        return 2
+    credits_path = assets / "credits.json"
+    credits = load_credits(credits_path)
+
+    source = args.source
+    key = None
+    if source == "pexels":
+        try:
+            key = read_env_key("PEXELS_API_KEY")
+        except EnvFileError as e:
+            print(f"erro: {e}", file=sys.stderr)
+            return 2
+        if not key:
+            print("aviso: PEXELS_API_KEY não configurada (é opcional). Buscando no Wikimedia Commons.")
+            source = "wikimedia"
+
+    try:
+        if source == "pexels":
+            found = search_pexels(args.query, args.count, args.orientation, key or "")
+        else:
+            found = search_wikimedia(args.query, args.count, args.orientation, args.min_width,
+                                     args.allow_attribution, args.allow_sharealike)
+    except FetchError as e:
+        print(f"erro: {e}", file=sys.stderr)
+        return 1
+
+    if not found:
+        hint = "" if (args.allow_attribution or source == "pexels") else \
+            " Se aceitar dar crédito ao autor no texto do post, rode de novo com --allow-attribution."
+        print(f"nenhuma imagem livre (CC0 ou domínio público) para \"{args.query}\". Tente outras palavras (em inglês "
+              f"costuma achar mais)" + (" ou tire o --orientation." if args.orientation else ".") + hint)
+        return 1
+
+    by_url = {c.get("url"): c for c in credits if isinstance(c, dict)}
+    results, errors = [], []
+    slug = slugify(args.query)
+    for item in found:
+        if len(results) >= args.count:
+            break
+        known = by_url.get(item["url"])
+        if known and (assets / str(known.get("file", "")).removeprefix("assets/")).exists():
+            results.append(dict(known, reused=True))
+            continue
+        base = f"{slug}-{re.sub(r'[^a-z0-9]+', '', item['id'].lower())}"
+        try:
+            got = download(item, assets, base)
+        except FetchError as e:
+            errors.append(str(e))
+            continue
+        entry = {
+            "file": f"assets/{got['file']}", "source": item["source"], "query": args.query,
+            "title": item["title"], "url": item["url"], "download_url": item["download_url"],
+            "author": item["author"], "license": item["license"], "license_url": item["license_url"],
+            "attribution_required": item["attribution_required"], "share_alike": item.get("share_alike", False),
+            "credit_line": credit_line(item) if item["attribution_required"] else None,
+            "width": got["width"], "height": got["height"], "added_at": now_iso(),
+        }
+        credits.append(entry)
+        by_url[item["url"]] = entry
+        save_json(credits_path, credits)
+        results.append(entry)
+
+    if args.json:
+        print(json.dumps({"query": args.query, "source": source, "images": results, "errors": errors},
+                         ensure_ascii=False, indent=2))
+    else:
+        for e in results:
+            tag = " (já estava baixada)" if e.get("reused") else ""
+            print(f"ok: {e['file']}  {e['width']}x{e['height']}  {e['license']}  por {e['author']}{tag}")
+            if e.get("share_alike"):
+                print(f"   exige crédito e a peça fica sob a mesma licença (ShareAlike). Crédito: {e.get('credit_line') or credit_line(e)}")
+            elif e.get("attribution_required"):
+                print(f"   exige crédito no texto do post: {e.get('credit_line') or credit_line(e)}")
+        for msg in errors:
+            print(f"aviso: {msg}")
+        if results and len(results) < args.count and not (args.allow_attribution or args.allow_sharealike) and source == "wikimedia":
+            print(f"aviso: só {len(results)} de {args.count} com licença livre (CC0 ou domínio público). Para ver mais, "
+                  f"--allow-attribution aceita CC BY, com crédito ao autor no texto do post.")
+        if results:
+            print(f"créditos em {credits_path}")
+    if not results:
+        print("erro: nenhuma imagem baixada", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/ganho_por_trecho.py

@@ -0,0 +1,214 @@
+"""Ganho por trecho medido, ANTES do render_cut: a voz chega perto do alvo e o loudnorm fica linear.
+
+Escrito pelo PrimoCode em cima do EDIT IA PRO (SHK Soluções Digitais, com autorização por escrito, 19/10/2026).
+
+O problema que resolve. Uma gravação de celular com a voz em -38 LUFS precisa de +24 dB para chegar em -14. O
+loudnorm do render_cut (duas passadas, `linear=true`) só fica linear quando o pico real medido mais o ganho que ele
+aplica não passa de -1 dBTP; com a voz baixa e os picos soltos, ele cai sozinho no modo DINÂMICO (um compressor que
+bombeia a voz) sem avisar. Antes isso era um `gain_db` posto à mão em cada trecho do EDL.
+
+O que faz:
+1. mede cada trecho do EDL (ffmpeg ebur128 com passa-alta de 80 Hz: o ronco da sala não conta como voz), com o
+   `gain_db` que o trecho já tem (o relativo que o voice_levels/montar_corte pôs continua valendo);
+2. mede o corte inteiro do jeito que o render_cut vai juntar (os trechos em sequência, com o ganho atual) e acha a
+   referência integrada;
+3. soma a todos os trechos o mesmo ganho base = ALVO_PRE - referência. Assim a voz chega uns 1,5 dB ACIMA de -14 e
+   o loudnorm só abaixa (abaixar é sempre linear). O limitador por trecho do render_cut (alimiter em -1 dBFS, ataque
+   5 ms, liga quando gain_db > 0) segura os picos que o ganho empurra;
+4. trecho que ficou 3 dB ou mais fora da referência ganha a diferença (até 9 dB), para a voz não pular de volume
+   entre tomadas; trechos que continuam a mesma fala (mesma fonte, encostados) ficam com o MESMO ganho (senão o
+   render_cut põe um fade de 30 ms no meio da palavra);
+5. grava o `gain_db` em cada trecho (com `ganho_auto` e `nivel_lufs`, só para ler) e um relatório em
+   <edit>/verify/ganho_por_trecho.json.
+
+Uso:
+    python helpers/ganho_por_trecho.py <edit>/edl_manual.json [--alvo -12.5] [--dry-run] [--json]
+
+Rodar de novo é seguro: o ganho é recalculado a partir do nível medido com o ganho que já está lá.
+Saída 0 quando gravou (ou nada a mudar), 2 em erro de entrada.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import probe_video  # noqa: E402
+import render_cut as rc  # noqa: E402
+
+ALVO_PRE = -12.5      # LUFS integrado do corte antes do loudnorm (o loudnorm de -14 só abaixa)
+DESVIO_MIN = 3.0      # dB: trecho mais longe que isso da referência é corrigido sozinho
+DESVIO_MAX = 9.0      # dB: teto da correção relativa
+GANHO_MAX = 32.0
+GANHO_MIN = -12.0
+CURTO_S = 1.0         # trecho mais curto que isso não tem leitura integrada confiável: fica com o ganho base
+GRUDADO_S = 0.02      # dois trechos da mesma fonte a menos disso são a mesma fala
+
+
+def erro(msg: str, code: int = 2):
+    print(f"erro: {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+def resolver_fonte(edl_path: Path, edl: dict, chave: str) -> Path:
+    bruto = (edl.get("sources") or {}).get(chave)
+    if not bruto:
+        erro(f"a fonte '{chave}' não está em sources")
+    p = Path(bruto)
+    for c in (p, edl_path.parent / p, edl_path.parent.parent / p):
+        if c.exists():
+            return c.resolve()
+    erro(f"não achei o arquivo da fonte '{chave}': {bruto}")
+
+
+def ebur128(args: list[str]) -> tuple[float | None, float | None]:
+    r = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-nostdin", *args, "-f", "null", "-"],
+                       capture_output=True, text=True)
+    txt = r.stderr
+    resumo = txt[txt.rfind("Summary:"):] if "Summary:" in txt else txt
+    mi = re.search(r"I:\s+(-?[\d.]+|-inf)\s+LUFS", resumo)
+    mp = re.search(r"Peak:\s+(-?[\d.]+|-inf)\s+dBFS", resumo)
+    def num(m):
+        if not m or "inf" in m.group(1):
+            return None
+        v = float(m.group(1))
+        return None if v <= -69.9 else v
+    return num(mi), num(mp)
+
+
+
+
+_CANAIS: dict[str, str] = {}
+
+
+def filtro(src: Path) -> str:
+    """Os canais viram estéreo do mesmo jeito que o render_cut faz (mono vai cheio nos dois lados: +3 LU sobre o
+    mono), e o passa-alta de 80 Hz tira o ronco da sala da leitura."""
+    k = str(src)
+    if k not in _CANAIS:
+        _CANAIS[k] = rc.channel_filter(rc.channel_mode(src, probe_video(src)))
+    return f"aresample=48000,{_CANAIS[k]},highpass=f=80"
+
+
+def medir_trecho(src: Path, ini: float, fim: float, ganho: float) -> tuple[float | None, float | None]:
+    af = f"{filtro(src)},volume={ganho:.2f}dB,ebur128=peak=true"
+    return ebur128(["-ss", f"{ini:.3f}", "-t", f"{max(0.05, fim - ini):.3f}", "-i", str(src), "-vn", "-af", af])
+
+
+def medir_corte(trechos: list[dict]) -> tuple[float | None, float | None]:
+    """O corte como o render_cut junta: cada trecho com o seu ganho, em sequência."""
+    entradas, cadeias, rotulos = [], [], []
+    fontes = {}
+    for t in trechos:
+        if str(t["src"]) not in fontes:
+            fontes[str(t["src"])] = len(fontes)
+            entradas += ["-i", str(t["src"])]
+    for i, t in enumerate(trechos):
+        k = fontes[str(t["src"])]
+        cadeias.append(f"[{k}:a]atrim=start={t['start']:.3f}:end={t['end']:.3f},asetpts=PTS-STARTPTS,"
+                       f"{filtro(t['src'])},volume={t['ganho']:.2f}dB[a{i}]")
+        rotulos.append(f"[a{i}]")
+    grafo = ";".join(cadeias) + ";" + "".join(rotulos) + f"concat=n={len(trechos)}:v=0:a=1,ebur128=peak=true[o]"
+    return ebur128([*entradas, "-filter_complex", grafo, "-map", "[o]"])
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("edl", type=Path)
+    ap.add_argument("--alvo", type=float, default=ALVO_PRE, help="LUFS do corte antes do loudnorm (padrão -12.5)")
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--json", action="store_true")
+    a = ap.parse_args()
+    if not a.edl.exists():
+        erro(f"não achei {a.edl}")
+    edl = json.loads(a.edl.read_text(encoding="utf-8"))
+    ranges = edl.get("ranges") or []
+    if not ranges:
+        erro("o EDL não tem trechos")
+
+    trechos = []
+    for r in ranges:
+        src = resolver_fonte(a.edl, edl, r["source"])
+        ganho = float(r.get("gain_db") or 0.0)
+        if r.get("ganho_auto") is not None:     # rodada anterior: volta ao ganho relativo que havia antes
+            ganho -= float(r["ganho_auto"])
+        nivel, pico = medir_trecho(src, float(r["start"]), float(r["end"]), ganho)
+        trechos.append(dict(id=r["id"], src=src, start=float(r["start"]), end=float(r["end"]), ganho=ganho,
+                            nivel=nivel, pico=pico, dur=float(r["end"]) - float(r["start"])))
+
+    ref, pico_ref = medir_corte(trechos)
+    if ref is None:
+        validos = sorted((t["nivel"], t["dur"]) for t in trechos if t["nivel"] is not None)
+        if not validos:
+            erro("não consegui medir a voz de nenhum trecho (áudio mudo?)")
+        meio, acc = sum(d for _, d in validos) / 2, 0.0
+        for n, d in validos:
+            acc += d
+            if acc >= meio:
+                ref = n
+                break
+    base = a.alvo - ref
+
+    for t in trechos:
+        rel = 0.0
+        if t["nivel"] is not None and t["dur"] >= CURTO_S:
+            d = ref - t["nivel"]
+            if abs(d) >= DESVIO_MIN:
+                rel = max(-DESVIO_MAX, min(DESVIO_MAX, d))
+        t["rel"] = rel
+        t["novo"] = max(GANHO_MIN, min(GANHO_MAX, t["ganho"] + base + rel))
+
+    # a mesma fala (mesma fonte, encostada) leva o mesmo ganho: a média ponderada pela duração
+    grupos, atual = [], [trechos[0]]
+    for t in trechos[1:]:
+        ant = atual[-1]
+        if t["src"] == ant["src"] and abs(t["start"] - ant["end"]) <= GRUDADO_S:
+            atual.append(t)
+        else:
+            grupos.append(atual)
+            atual = [t]
+    grupos.append(atual)
+    for g in grupos:
+        if len(g) > 1:
+            m = sum(t["novo"] * t["dur"] for t in g) / max(1e-6, sum(t["dur"] for t in g))
+            for t in g:
+                t["novo"] = m
+
+    por_id = {t["id"]: t for t in trechos}
+    for r in ranges:
+        t = por_id[r["id"]]
+        r["gain_db"] = round(t["novo"], 1)
+        r["ganho_auto"] = round(t["novo"] - t["ganho"], 1)
+        r["nivel_lufs"] = None if t["nivel"] is None else round(t["nivel"], 1)
+
+    rel = {"alvo_pre_lufs": a.alvo, "referencia_lufs": round(ref, 2),
+           "pico_ref_dbfs": None if pico_ref is None else round(pico_ref, 2),
+           "ganho_base_db": round(base, 2),
+           "trechos": [{"id": t["id"], "nivel_lufs": None if t["nivel"] is None else round(t["nivel"], 1),
+                        "pico_dbfs": None if t["pico"] is None else round(t["pico"], 1),
+                        "ganho_antes": round(t["ganho"], 1), "correcao_relativa": round(t["rel"], 1),
+                        "gain_db": round(t["novo"], 1)} for t in trechos]}
+    if not a.dry_run:
+        a.edl.write_text(json.dumps(edl, ensure_ascii=False, indent=1), encoding="utf-8")
+        ver = a.edl.parent / "verify"
+        ver.mkdir(exist_ok=True)
+        (ver / "ganho_por_trecho.json").write_text(json.dumps(rel, ensure_ascii=False, indent=1), encoding="utf-8")
+    if a.json:
+        print(json.dumps(rel, ensure_ascii=False))
+    else:
+        print(f"voz do corte em {ref:.1f} LUFS; ganho base {base:+.1f} dB para chegar em {a.alvo:.1f} antes do loudnorm")
+        for t in trechos:
+            extra = f" (fora da referência: {t['rel']:+.1f} dB)" if t["rel"] else ""
+            nv = "curto" if t["nivel"] is None else f"{t['nivel']:.1f} LUFS"
+            print(f"  {t['id']}: {nv} -> gain_db {t['novo']:+.1f}{extra}")
+        if not a.dry_run:
+            print(f"gravado: {a.edl}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())