primocode 11.3.3 → 11.5.0

package/editor/helpers/som_edit2.py

@@ -0,0 +1,119 @@
+"""Edit 2.0, peça 4: o som. Voz limpa (DeepFilterNet), -14 LUFS (ffmpeg-normalize), medida (pyloudnorm).
+
+- `limpar_voz`: DeepFilterNet roda em ambiente à parte (~/.primocode/editor/df-venv, `instalar_df.sh`); sem ele
+  a função diz que não limpou (nunca finge) e o `denoise.py` de antes segue valendo.
+- `normalizar`: ffmpeg-normalize (EBU R128, 2 passadas) em -14 LUFS, pico -1 dBTP, imagem copiada.
+- `medir_lufs`: pyloudnorm (BS.1770) sobre o áudio do arquivo final; é o número do antes/depois.
+- O ducking da trilha é o `sidechaincompress` do ffmpeg, que o `mixar_trilha.py` já usa (nada novo aqui).
+
+Uso:
+    uv run python helpers/som_edit2.py medir <video>
+    uv run python helpers/som_edit2.py limpar <video> <saida.mp4>
+    uv run python helpers/som_edit2.py normalizar <video> <saida.mp4> [--alvo -14]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+HELPERS = Path(__file__).resolve().parent
+DF_PY = Path(os.environ.get("PRIMOCODE_DF_PYTHON") or Path.home() / ".primocode" / "editor" / "df-venv" / "bin" / "python")
+ALVO_LUFS = -14.0
+PICO_DBTP = -1.0
+
+
+def _ffmpeg(*args: str) -> None:
+    r = subprocess.run(["ffmpeg", "-hide_banner", "-nostdin", "-v", "error", "-y", *args], capture_output=True, text=True)
+    if r.returncode != 0:
+        raise RuntimeError(f"ffmpeg falhou: {r.stderr[-300:]}")
+
+
+def df_disponivel() -> bool:
+    return DF_PY.exists()
+
+
+def medir_lufs(video: Path) -> dict:
+    """LUFS integrado (pyloudnorm, BS.1770) e pico de amostra do áudio do arquivo."""
+    import numpy as np  # noqa: PLC0415
+    import pyloudnorm as pyln  # noqa: PLC0415
+
+    sr = 48000
+    r = subprocess.run(["ffmpeg", "-hide_banner", "-nostdin", "-v", "error", "-i", str(video), "-vn", "-ac", "2", "-ar", str(sr),
+                        "-f", "f32le", "-"], capture_output=True)
+    if r.returncode != 0:
+        raise RuntimeError(f"ffmpeg falhou: {r.stderr.decode('utf-8', 'replace')[-300:]}")
+    dados = np.frombuffer(r.stdout, dtype="<f4").astype("float64").reshape(-1, 2)
+    if len(dados) < sr * 0.4:
+        return {"lufs": None, "pico_db": None, "motivo": "áudio curto demais para medir"}
+    lufs = pyln.Meter(sr).integrated_loudness(dados)
+    if not np.isfinite(lufs):   # silêncio total: -inf não vira JSON
+        return {"lufs": None, "pico_db": round(20 * np.log10(max(float(np.max(np.abs(dados))), 1e-9)), 2), "motivo": "silêncio (abaixo do portão)"}
+    pico = float(np.max(np.abs(dados)))
+    return {"lufs": round(float(lufs), 2), "pico_db": round(20 * np.log10(max(pico, 1e-9)), 2)}
+
+
+def limpar_voz(video: Path, saida: Path) -> dict:
+    """Voz do vídeo passada pelo DeepFilterNet; imagem copiada. -> {"limpou": bool, "motivo": str}"""
+    if not df_disponivel():
+        return {"limpou": False, "motivo": f"DeepFilterNet não instalado ({DF_PY}); rode helpers/instalar_df.sh"}
+    with tempfile.TemporaryDirectory() as tmp:
+        ent, sai = Path(tmp) / "e.wav", Path(tmp) / "s.wav"
+        _ffmpeg("-i", str(video), "-vn", "-ac", "1", "-ar", "48000", str(ent))
+        r = subprocess.run([str(DF_PY), str(HELPERS / "df_limpar.py"), str(ent), str(sai)], capture_output=True, text=True)
+        if r.returncode != 0 or not sai.exists():
+            return {"limpou": False, "motivo": f"DeepFilterNet falhou: {r.stderr[-200:]}"}
+        _ffmpeg("-i", str(video), "-i", str(sai), "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac",
+                "-b:a", "192k", "-shortest", str(saida))
+    return {"limpou": True, "motivo": "DeepFilterNet"}
+
+
+def normalizar(video: Path, saida: Path, alvo: float = ALVO_LUFS, pico: float = PICO_DBTP) -> dict:
+    """ffmpeg-normalize em 2 passadas. Devolve o comando usado e a medida de depois."""
+    exe = Path(sys.executable).parent / "ffmpeg-normalize"
+    cmd = [str(exe) if exe.exists() else "ffmpeg-normalize", str(video), "-nt", "ebu", "-t", str(alvo), "-tp", str(pico),
+           "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", "-ar", "48000", "-f", "-o", str(saida)]
+    r = subprocess.run(cmd, capture_output=True, text=True)
+    if r.returncode != 0 or not saida.exists():
+        raise RuntimeError(f"ffmpeg-normalize falhou: {(r.stderr or r.stdout)[-300:]}")
+    m = medir_lufs(saida)
+    corrigido = False
+    # o loudnorm do ffmpeg-normalize pode errar uns 0,5 LU depois do AAC: um acerto de ganho (só áudio, imagem copiada)
+    if m.get("lufs") is not None and abs(m["lufs"] - alvo) > 0.3 and (m["pico_db"] + (alvo - m["lufs"])) <= pico:
+        ajuste = alvo - m["lufs"]
+        tmp = saida.with_name(saida.stem + "_ajuste" + saida.suffix)
+        _ffmpeg("-i", str(saida), "-c:v", "copy", "-af", f"volume={ajuste:.2f}dB", "-c:a", "aac", "-b:a", "192k", str(tmp))
+        tmp.replace(saida)
+        m, corrigido = medir_lufs(saida), True
+    return {"alvo_lufs": alvo, "pico_dbtp": pico, "ajuste_de_ganho": corrigido, **m}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    sp = ap.add_subparsers(dest="cmd", required=True)
+    m = sp.add_parser("medir")
+    m.add_argument("video", type=Path)
+    for nome in ("limpar", "normalizar"):
+        p = sp.add_parser(nome)
+        p.add_argument("video", type=Path)
+        p.add_argument("saida", type=Path)
+        if nome == "normalizar":
+            p.add_argument("--alvo", type=float, default=ALVO_LUFS)
+    a = ap.parse_args()
+    if a.cmd == "medir":
+        out = medir_lufs(a.video)
+    elif a.cmd == "limpar":
+        out = limpar_voz(a.video, a.saida)
+    else:
+        out = normalizar(a.video, a.saida, a.alvo)
+    print(json.dumps(out, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/transcribe.py

@@ -135,12 +135,21 @@ def check_name_clash(out_path: Path, video: Path) -> None:
 # ---------------------------------------------------------------- engines
 
 def default_engine() -> str:
+    # Edit 2.0: WhisperX (palavra alinhada) quando instalado; PRIMOCODE_MOTOR_PALAVRAS=antigo volta ao de antes.
+    if os.environ.get("PRIMOCODE_MOTOR_PALAVRAS") != "antigo":
+        try:
+            import importlib.util
+            if importlib.util.find_spec("whisperx"):
+                return "whisperx"
+        except Exception:
+            pass
     return "mlx" if sys.platform == "darwin" and platform.machine() == "arm64" else "faster-whisper"
 
 
 def engine_label(engine: str, model: str) -> str:
     name = Path(model).name if ("/" in model or os.sep in model) else model
-    return f"{'mlx-whisper' if engine == 'mlx' else 'faster-whisper'}/{name}"
+    rotulo = {"mlx": "mlx-whisper", "whisperx": "whisperx", "whisper.cpp": "whisper.cpp"}.get(engine, "faster-whisper")
+    return f"{rotulo}/{name}"
 
 
 def _mlx_model_path(model: str) -> str:
@@ -208,8 +217,27 @@ def _run_faster(audio: np.ndarray, model: str, language: str | None, prompt: str
     return segments, getattr(info, "language", None)
 
 
+MOTOR_USADO = [""]  # o motor que de fato respondeu (o pedido pode ter caído no próximo)
+
+
+def _motor_antigo() -> str:
+    return "mlx" if sys.platform == "darwin" and platform.machine() == "arm64" else "faster-whisper"
+
+
 def run_whisper(audio: np.ndarray, engine: str, model: str, language: str | None,
                 prompt: str | None) -> tuple[list[dict], str | None]:
+    if engine in ("whisperx", "whisper.cpp"):
+        import motor_palavras as mp  # noqa: PLC0415
+        cadeia = [engine] + [e for e in ("whisper.cpp",) if e != engine]
+        for e in cadeia:
+            try:
+                fn = mp.run_whisperx if e == "whisperx" else mp.run_whisper_cpp
+                res = fn(audio, model, language, prompt)
+                MOTOR_USADO[0] = e
+                return res
+            except Exception as exc:  # cai para o próximo e diz por quê, sem fingir
+                print(f"AVISO: motor {e} falhou ({str(exc)[:120]}); tentando o próximo", file=sys.stderr, flush=True)
+        engine = _motor_antigo()
     if engine == "mlx":
         return _run_mlx(audio, model, language, prompt)
     return _run_faster(audio, model, language, prompt)
@@ -651,6 +679,7 @@ def transcribe_one(video: Path | str, edit_dir: Path | str | None = None, langua
         "duration": round(duration, 3),
         "language": detected_lang or language or "",
         "engine": engine_label(engine, model),
+        "motor_usado": MOTOR_USADO[0] or engine,
         "words": out_words,
         "segments": segments,
         "prompt": prompt,
@@ -707,7 +736,7 @@ def main() -> None:
     ap.add_argument("--prompt", default=None,
                     help="palavras que aparecem no vídeo, para o Whisper acertar a grafia (ex.: \"Kiwify, Hubla\")")
     ap.add_argument("--no-prompt", action="store_true", help="não usa o prompt padrão com vícios de fala")
-    ap.add_argument("--engine", choices=("auto", "mlx", "faster-whisper"), default="auto",
+    ap.add_argument("--engine", choices=("auto", "whisperx", "whisper.cpp", "mlx", "faster-whisper"), default="auto",
                     help="motor (padrão: mlx no Mac Apple Silicon, faster-whisper nos outros)")
     args = ap.parse_args()
 

package/editor/pyproject.toml

@@ -17,7 +17,16 @@ dependencies = [
     # onnxruntime (usado pelo faster-whisper e pela tela verde) parou de publicar pacote para Mac Intel e
     # macOS 13 na 1.24.
     "onnxruntime<1.24; sys_platform == 'darwin' and (platform_machine == 'x86_64' or platform_release < '23')",
+    # Edit 2.0 (licenças em LICENSES/edit2-terceiros.md)
+    "whisperx>=3.8",          # BSD-2: palavra a palavra alinhada (diarização não é usada)
+    "silero-vad>=6.2",        # MIT: fala vs silêncio
+    "auto-editor>=29",        # Unlicense: 1º passe do corte (chamado por linha de comando)
+    "mediapipe>=0.10",        # Apache-2.0: rosto
+    "pysubs2>=1.8",           # MIT: legenda ASS
+    "pyloudnorm>=0.1",        # MIT: mede LUFS
+    "ffmpeg-normalize>=1.30", # MIT: fecha em -14 LUFS
 ]
 
 [tool.uv]
 package = false
+

package/editor/references/edit2.md

@@ -0,0 +1,22 @@
+# Edit 2.0: o pipeline curto
+
+Um comando, do bruto ao vídeo final (vertical 1080x1920 por padrão):
+
+```
+uv run --directory '<SKILL>' python helpers/edit2.py '<VIDEO>' '<PASTA_DE_TRABALHO>' -o '<SAIDA.mp4>' \
+  --tirar 8.09-8.59 [--look agencia] [--grao 5] [--zoom 1.12]
+```
+
+Passos (cada um é um helper que dá para rodar sozinho): `transcribe.py` (WhisperX) → `primeiro_passe.py` (silero-vad +
+auto-editor, bordas nas palavras) → `corte_por_onda.py` + `render_cut.py` → `som_edit2.py limpar` (DeepFilterNet) →
+`rastrear_rosto.py` (MediaPipe) + `enquadrar_camera.py` + `look_ffmpeg.py` + legenda, numa passada de vídeo →
+`som_edit2.py normalizar` (-14 LUFS) e `medir`.
+
+O relatório fica em `<PASTA>/edit/relatorio_edit2.json`: `antes` e `depois` (duração, cortes, LUFS, % com rosto
+enquadrado e desvio do centro). Nota: quando a fonte já é um rosto centrado, o % enquadrado dá 100 antes e depois;
+o que mostra o ganho é o desvio do centro.
+
+Instalação: `uv sync` na pasta da skill traz WhisperX, silero-vad, auto-editor, MediaPipe, pysubs2, pyloudnorm e
+ffmpeg-normalize. O DeepFilterNet pede numpy<2 e torch antigo e fica à parte: `helpers/instalar_df.sh`
+(cria `~/.primocode/editor/df-venv`). Sem ele a voz segue como veio e o relatório diz `limpou: false`.
+`PRIMOCODE_MOTOR_PALAVRAS=antigo` volta ao motor de transcrição de antes; `PRIMOCODE_ROSTO=yunet` volta ao detector de rosto de antes.