CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
View File
+150
View File
@@ -0,0 +1,150 @@
"""Qualidade de gravação da live (grupo `capture` da configuração do corte) e o que foi gravado de fato.
Pedido do dono (17/11/2026): "pegar a live na melhor resolução; a live tem 2K, e isso é configurável".
Antes a captura pedia `720p60,720p,480p,best` e nunca passava de 720p, mesmo com a fonte em 1080p ou 1440p.
`capture.quality`:
- `best` (padrão): a maior resolução que a live oferece;
- `1440p` | `1080p` | `720p` | `480p`: TETO — a maior variante que não passa dele.
Nomes de stream medidos com `streamlink --json` (17/11/2026, 143 lives da Twitch, 5 da Kick, 22 do YouTube):
- Twitch: `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`,
`360p30`, `160p30`, `audio_only` e, em 9 canais, variantes VERTICAIS `1920p60_portrait`, `1280p30_portrait`…
(a de 1080×1920 vem em HEVC). Nenhuma live com 1440p no momento, nem pedindo h265/av1;
- Kick: `1080p60`, `720p60`, `480p`, `360p`, `160p`;
- YouTube (pelo HLS do Streamlink, até lives "4K"): `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p`.
Como a escolha é feita: pelos sinônimos `best`/`worst` do próprio Streamlink, que ordenam por peso
(`1440p60` = 1500, `1080p60` = 1140, `1080p` = 1080, `936p60` = 996…) e ignoram nomes de peso 0 (`audio_only`,
`*_portrait`, `source`). O teto vira `--stream-sorting-excludes >{teto}p60`; se nada sobrar abaixo do teto, a reserva
`worst-unfiltered` pega a menor variante de vídeo que existe (a mais perto do teto) — a captura nunca falha por
causa da qualidade escolhida.
FPS: não há opção de 30/60 qps. A variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives; a
Kick também), então pedir 30 qps custaria resolução; e o corte sai em 30 qps de qualquer jeito.
2K na Twitch (transmissão aprimorada) vem em HEVC: com `best` ou `1440p` a captura pede `--twitch-supported-codecs
h264,h265`. Medido: com h265 pedido, as variantes paisagem das lives continuaram H.264 (só a vertical vira HEVC).
AV1 não é pedido: o FFmpeg instalado não tem decodificador libdav1d.
"""
from __future__ import annotations
import logging
from dataclasses import dataclass
from pathlib import Path
from . import media
from .layout import CAPTURE_QUALITIES as QUALITIES
log = logging.getLogger("cenaforge_clipper.capture")
DEFAULT_QUALITY = "best"
CEILING_HEIGHT = {"1440p": 1440, "1080p": 1080, "720p": 720, "480p": 480}
# Twitch: 2K só aparece pedindo HEVC. Abaixo disso, o padrão do Streamlink (h264) basta.
TWITCH_HEVC_QUALITIES = ("best", "1440p")
# Disco por hora (GB) de cada opção. Medido nas playlistas mestras da Twitch (BANDWIDTH, mediana de 62–69 lives,
# 17/11/2026): 1080p60 7,1 Mbps (4,6–9,1) ≈ 3,2 GB/h; 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h.
# Gravação real (skipnho): 720p60 12,7 MB por bloco de 30 s (1,53 GB/h); 1080p60 29,9 MB (3,58 GB/h).
# 2K: nenhuma live achada — estimativa de ~10 Mbps (≈ 4,5 GB/h).
OPTIONS = [
{"id": "best", "label": "Melhor disponível", "maxHeight": None, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "A maior resolução que a live oferece (2K, se o canal transmitir em 2K)."},
{"id": "1440p", "label": "Até 2K (1440p)", "maxHeight": 1440, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "Igual a \"Melhor\" hoje; não passa de 2K se o canal transmitir em 4K."},
{"id": "1080p", "label": "Até Full HD (1080p)", "maxHeight": 1080, "gbPerHour": 3.2, "gbPerHourMax": 4.1,
"hint": "Mesma nitidez do corte final (1080 px de largura)."},
{"id": "720p", "label": "Até HD (720p)", "maxHeight": 720, "gbPerHour": 1.5, "gbPerHourMax": 2.7,
"hint": "Como era antes: metade do disco, câmera recortada mais borrada."},
{"id": "480p", "label": "Até 480p", "maxHeight": 480, "gbPerHour": 0.65, "gbPerHourMax": 0.7,
"hint": "Só para economizar disco: o corte sai visivelmente borrado."},
]
@dataclass(frozen=True)
class StreamChoice:
"""Opções extras do Streamlink + a lista de streams (primeiro que existir), em argumentos separados."""
options: tuple[str, ...]
streams: str
def args(self, url: str) -> list[str]:
return [*self.options, url, self.streams]
def normalize_quality(value: object) -> str:
return value if isinstance(value, str) and value in QUALITIES else DEFAULT_QUALITY
def stream_choice(quality: str, platform: str) -> StreamChoice:
"""Lista de preferência do Streamlink para a opção `quality` na plataforma (`twitch` | `kick` | `youtube`)."""
quality = normalize_quality(quality)
options: list[str] = []
if platform == "twitch" and quality in TWITCH_HEVC_QUALITIES:
options += ["--twitch-supported-codecs", "h264,h265"]
if quality == "best":
return StreamChoice(tuple(options), "best")
# Teto: exclui do `best` tudo que pesa mais que "<teto>p60" (1080p60 fica; 1440p30 e 1440p60 saem). Sem nada
# abaixo do teto, `best` some e `worst-unfiltered` entrega a menor variante de vídeo (a mais perto do teto).
options += ["--stream-sorting-excludes", f">{quality}60"]
return StreamChoice(tuple(options), "best,worst-unfiltered")
def probe_block(ffprobe: str, file: Path) -> dict:
"""Resolução, qps, codec e taxa reais de um bloco gravado (`ffprobe`). Levanta `media.MediaError`."""
out = media.run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries",
"stream=codec_name,width,height,avg_frame_rate,r_frame_rate:format=duration,size",
"-of", "default=nw=1", str(file)], 30).decode("utf-8", errors="replace")
info: dict[str, str] = {}
for line in out.splitlines():
if "=" in line:
key, value = line.split("=", 1)
info.setdefault(key.strip(), value.strip())
try:
width, height = int(info["width"]), int(info["height"])
except (KeyError, ValueError) as exc:
raise media.MediaError(f"sem vídeo em {file.name}") from exc
fps = _rate(info.get("avg_frame_rate")) or _rate(info.get("r_frame_rate"))
try:
duration, size = float(info.get("duration") or 0), float(info.get("size") or file.stat().st_size)
except (ValueError, OSError):
duration, size = 0.0, 0.0
kbps = round(size * 8 / duration / 1000) if duration > 1 else None
return {"width": width, "height": height, "fps": round(fps) if fps else None,
"codec": info.get("codec_name") or "", "kbps": kbps,
"gbPerHour": round(kbps * 3600 / 8 / 1e6, 2) if kbps else None}
def _rate(raw: str | None) -> float:
if not raw or raw in ("0/0", "N/A"):
return 0.0
try:
if "/" in raw:
num, den = raw.split("/", 1)
return float(num) / float(den) if float(den) else 0.0
return float(raw)
except ValueError:
return 0.0
MAX_RUNS = 10
def record_run(previous: dict | None, quality: str, from_idx: int, probed: dict, at: str) -> dict:
"""`sessions.capture_json` depois do 1º bloco de uma execução da captura (início ou retomada).
Topo = a execução atual (o painel mostra "gravando em 2560×1440 · 60 qps"); `runs` guarda as últimas
`MAX_RUNS` execuções; `mixed` = a sessão tem blocos em mais de uma resolução (retomada com outra qualidade)."""
runs = [r for r in (previous or {}).get("runs", []) if isinstance(r, dict) and r.get("fromIdx") != from_idx]
run = {"fromIdx": from_idx, "quality": quality, **{k: probed.get(k) for k in ("width", "height", "fps", "codec")}}
runs = (runs + [run])[-MAX_RUNS:]
sizes = {(r.get("width"), r.get("height")) for r in runs}
return {"quality": quality, **probed, "fromIdx": from_idx, "at": at, "runs": runs, "mixed": len(sizes) > 1}
def label(info: dict | None) -> str:
""""2560×1440 · 60 qps" (texto do log; o painel monta o seu)."""
if not info or not info.get("width"):
return "resolução desconhecida"
fps = f" · {info['fps']} qps" if info.get("fps") else ""
return f"{info['width']}×{info['height']}{fps}"
+165
View File
@@ -0,0 +1,165 @@
"""Leitura do chat ao vivo, em tempo real, para medir a reação do público.
- Twitch: IRC anônimo (irc.chat.twitch.tv:6697, apelido `justinfanNNNN`): só leitura, sem conta nem token.
- Kick: websocket público do Pusher usado pelo site (`chatrooms.<id>.v2`). Não é API oficial: pode mudar
sem aviso e o Cloudflare às vezes bloqueia a consulta do id da sala.
- YouTube: ler o chat exige a API do YouTube (cota) — ainda não suportado; a sessão segue pelo áudio.
Cada leitor roda numa thread, reconecta sozinho e entrega lotes de (instante, usuário, texto) com o relógio
de parede; quem chama converte para o tempo da gravação.
"""
from __future__ import annotations
import json
import logging
import random
import re
import socket
import ssl
import threading
import time
from typing import Callable
import httpx
from .emotes import parse_twitch_tag
log = logging.getLogger("cenaforge_clipper.chat")
# (hora real, usuário, texto, emotes nativos recortados do texto)
OnMessages = Callable[[list[tuple[float, str, str, list[str]]]], None]
_PRIVMSG = re.compile(r"^(?:@(\S+) )?:([^!\s]+)!\S+ PRIVMSG #\S+ :(.*)$")
_ROOM_ID = re.compile(r"(?:^@|;)room-id=(\d+)")
KICK_PUSHER = "wss://ws-us2.pusher.com/app/32cbd69e4b950bf97679?protocol=7&client=js&version=8.4.0&flash=false"
class ChatReader:
def __init__(self, platform: str, channel: str, on_messages: OnMessages):
self.platform, self.channel, self.on_messages = platform, channel, on_messages
self.status = "off"
self.received = 0
self.room_id: str | None = None # id numérico do canal na Twitch (para emotes 7TV/BTTV/FFZ)
self._stop = threading.Event()
self._thread: threading.Thread | None = None
def start(self) -> None:
if self.platform == "youtube" or not self.channel:
self.status = "unsupported"
return
target = {"twitch": self._run_twitch, "kick": self._run_kick}[self.platform]
self._thread = threading.Thread(target=self._loop, args=(target,), name=f"chat-{self.channel}", daemon=True)
self._thread.start()
def stop(self) -> None:
self._stop.set()
def _loop(self, target: Callable[[], None]) -> None:
delay = 2.0
while not self._stop.is_set():
try:
self.status = "connecting"
target()
delay = 2.0
except Exception as exc: # noqa: BLE001 - rede caiu: reconecta com espera crescente
self.status = f"error: {type(exc).__name__}: {str(exc)[:120]}"
log.warning("chat %s/%s: %s", self.platform, self.channel, self.status)
self._stop.wait(delay)
delay = min(60.0, delay * 2)
self.status = "off"
def _deliver(self, batch: list[tuple[float, str, str]]) -> None:
if batch:
self.received += len(batch)
self.on_messages(batch)
# ---------- Twitch (IRC) ----------
def _run_twitch(self) -> None:
context = ssl.create_default_context()
with socket.create_connection(("irc.chat.twitch.tv", 6697), timeout=30) as raw:
with context.wrap_socket(raw, server_hostname="irc.chat.twitch.tv") as sock:
sock.settimeout(1.0)
nick = f"justinfan{random.randint(10000, 99999)}"
# Tags trazem os emotes nativos (com posição no texto) e o room-id do canal.
sock.sendall(f"CAP REQ :twitch.tv/tags\r\nNICK {nick}\r\nJOIN #{self.channel}\r\n".encode())
buffer, batch, last_flush, last_data = b"", [], time.monotonic(), time.monotonic()
while not self._stop.is_set():
try:
chunk = sock.recv(65536)
if not chunk:
raise ConnectionError("conexão fechada pela Twitch")
buffer += chunk
last_data = time.monotonic()
except TimeoutError:
pass
except socket.timeout:
pass
*lines, buffer = buffer.split(b"\r\n")
for line in lines:
text = line.decode("utf-8", errors="replace")
if text.startswith("PING"):
sock.sendall(("PONG" + text[4:] + "\r\n").encode())
elif " 366 " in text or " JOIN #" in text:
self.status = "connected"
elif match := _PRIVMSG.match(text):
tags, body = _parse_tags(match.group(1) or ""), match.group(3)
self.room_id = self.room_id or tags.get("room-id")
batch.append((time.time(), match.group(2), body[:300],
parse_twitch_tag(tags.get("emotes", ""), body)))
elif room := _ROOM_ID.search(text):
self.room_id = self.room_id or room.group(1)
if time.monotonic() - last_flush >= 1.0:
self._deliver(batch)
batch, last_flush = [], time.monotonic()
if time.monotonic() - last_data > 360: # a Twitch manda PING a cada ~5 min
raise ConnectionError("sem dados há 6 min")
# ---------- Kick (Pusher, não oficial) ----------
def _run_kick(self) -> None:
from websockets.sync.client import connect # import tardio: só quem usa Kick precisa
response = httpx.get(
f"https://kick.com/api/v2/channels/{self.channel}",
headers={"User-Agent": "Mozilla/5.0", "Accept": "application/json"},
timeout=20,
follow_redirects=True,
)
if response.status_code != 200:
raise ConnectionError(f"kick.com respondeu {response.status_code} ao buscar a sala do chat")
room = response.json()["chatroom"]["id"]
with connect(KICK_PUSHER, open_timeout=20) as ws:
ws.send(json.dumps({"event": "pusher:subscribe", "data": {"auth": "", "channel": f"chatrooms.{room}.v2"}}))
batch, last_flush = [], time.monotonic()
while not self._stop.is_set():
try:
raw = ws.recv(timeout=1.0)
except TimeoutError:
raw = None
if raw:
event = json.loads(raw)
name = event.get("event", "")
if name == "pusher_internal:subscription_succeeded":
self.status = "connected"
elif name == "pusher:ping":
ws.send(json.dumps({"event": "pusher:pong", "data": {}}))
elif name.endswith("ChatMessageEvent"):
data = json.loads(event.get("data") or "{}")
user = (data.get("sender") or {}).get("username", "")
# Emotes da Kick chegam como [emote:123:NOME]: fica só o nome, que é o que carrega a reação.
content = data.get("content", "")
kick_emotes = re.findall(r"\[emote:\d+:([^\]]+)\]", content)
text = re.sub(r"\[emote:\d+:([^\]]+)\]", r"\1", content)
batch.append((time.time(), user, text[:300], kick_emotes))
if time.monotonic() - last_flush >= 1.0:
self._deliver(batch)
batch, last_flush = [], time.monotonic()
def _parse_tags(raw: str) -> dict[str, str]:
"""`color=#F00;emotes=25:0-4;room-id=123` → dict. Só usamos ids e posições (sem desescapar valores)."""
tags: dict[str, str] = {}
for item in raw.split(";"):
if "=" in item:
key, value = item.split("=", 1)
tags[key] = value
return tags
+268
View File
@@ -0,0 +1,268 @@
"""Apagar cortes: um, vários ou todos de uma aba (rotas `DELETE /v1/clips/{id}` e `POST /v1/clips/delete`).
O que some com o corte: a linha em `clips`, o projeto de edição (`edits`) e os arquivos dele — vídeo, capa,
miniatura e restos do render em `output/clipper/<sessão>/clip-<id>*`, a pasta do editor `edit-<id>/` (proxy,
forma de onda, narração, prévias) e os quadros que o juiz viu (`<sessão>/frames/clip<id>-*.jpg`). Só apaga
dentro das pastas do Clipador (`CLIPPER_OUTPUT_DIR` e `CLIPPER_DATA_DIR`): o caminho é resolvido antes, link
ou junção nunca é seguido (some só o próprio link) e caminho de fora fica onde está, com o motivo na resposta.
Regras:
- `candidate` (a IA está avaliando) e `rendering` (o FFmpeg está trabalhando) são recusados: o laço do motor
escreveria num corte que não existe mais. Um `pending` que o motor acabou de pegar para renderizar também.
- `published` só com `confirmPublished`: o vídeo já foi postado e a cópia local é o único registro dele aqui.
- **O momento apagado não volta.** A regra anti-duplicado (`worker.find_new_clips`, varredura da IA) compara o
candidato com os cortes existentes, inclusive descartados. Sem o corte, a passada seguinte de uma live em
andamento (ou a passada final da sessão inteira) recriaria o mesmo momento. Por isso fica uma marca mínima em
`deleted_clips` (migração v10): pico, trecho final e janela original do candidato. Ela entra na mesma conta
dos cortes existentes e some junto com a sessão. Apagado que estava pronto, aprovado, rejeitado etc.
(`worker.VETO_STATUSES`) também veta o trecho final depois do juiz ("Duplicado do corte N (que você apagou)");
descartado pela IA não veta, como antes.
- O aprendizado já feito (peso dos emotes, `clips.learned`) fica: ele mora na tabela `emotes`, não no corte.
`judge.duplicateOf` de outros cortes é só texto informativo (nada no código lê esse id de volta).
"""
from __future__ import annotations
import json
import logging
import os
from pathlib import Path
from .config import REPO_ROOT
from .db import loads, now
log = logging.getLogger("cenaforge_clipper.delete")
MAX_BATCH = 500 # mesmo teto da listagem (GET /v1/clips?limit=500), que é o que o painel mostra
# Estados em que o motor ainda está mexendo no corte: recusa com motivo (código, texto para o painel).
BUSY = {
"candidate": ("busy_candidate", "a IA está avaliando este corte"),
"rendering": ("busy_rendering", "está renderizando"),
}
PUBLISHED = ("published", "está publicado: confirme para apagar a cópia local")
NOT_FOUND = ("not_found", "corte não encontrado")
CHANGED = ("changed", "mudou de estado agora há pouco; tente de novo")
class DeleteRefused(Exception):
def __init__(self, code: str, message: str, status: int = 409):
super().__init__(message)
self.code, self.message, self.status = code, message, status
# ---------------------------------------------------------------- marca do momento apagado
def marks(db, session_id: int) -> list[dict]:
"""Momentos apagados da sessão no mesmo formato das linhas de `clips` que o anti-duplicado lê (`id` = o do corte
apagado, que nunca volta a ser usado; `status` = o estado em que ele foi apagado; `peak_s`, `start_s`, `end_s`;
`reasons_json` com a janela original do candidato) e `deleted: True`."""
out = []
for r in db.all("SELECT * FROM deleted_clips WHERE session_id = ?", session_id):
reasons = ({"candidateStartS": r["candidate_start_s"], "candidateEndS": r["candidate_end_s"]}
if r["candidate_start_s"] is not None and r["candidate_end_s"] is not None else {})
out.append({"id": r["clip_id"], "session_id": r["session_id"], "status": r["status"], "peak_s": r["peak_s"],
"start_s": r["start_s"], "end_s": r["end_s"], "title": r["title"],
"reasons_json": json.dumps(reasons), "deleted": True})
return out
def mark_spans(db, session_id: int, lo: float, hi: float) -> list[tuple[float, float, str]]:
"""Trechos apagados que tocam [lo, hi], para a varredura da IA não propor o mesmo momento de novo."""
spans = []
for m in marks(db, session_id):
reasons = loads(m["reasons_json"], {})
a = min(m["start_s"], reasons.get("candidateStartS", m["start_s"]))
b = max(m["end_s"], reasons.get("candidateEndS", m["end_s"]))
if b > lo and a < hi:
spans.append((a, b, "apagado"))
return spans
# ---------------------------------------------------------------- arquivos do corte
def _roots(engine) -> list[Path]:
return [engine.settings.clips_dir.resolve(), engine.settings.data_dir.resolve()]
def _inside(path: Path, roots: list[Path]) -> bool:
try:
resolved = path.resolve()
except OSError:
return False
return any(resolved.is_relative_to(r) for r in roots)
def _is_link(path: Path) -> bool:
return path.is_symlink() or path.is_junction()
def _rel(path: Path) -> str:
try:
return path.relative_to(REPO_ROOT).as_posix()
except ValueError:
return path.as_posix()
def _unlink_link(path: Path) -> None:
"""Remove só o link (símbolo ou junção), nunca o alvo."""
try:
os.unlink(path)
except (IsADirectoryError, PermissionError):
os.rmdir(path) # junção/link de pasta no Windows: rmdir tira o link e não toca no alvo
def _remove_tree(folder: Path, removed: list[str], left: list[dict]) -> None:
"""Apaga a pasta sem seguir link nem junção (o link some; o alvo fica)."""
with os.scandir(folder) as entries:
for entry in entries:
path = Path(entry.path)
try:
if entry.is_symlink() or entry.is_junction():
_unlink_link(path)
elif entry.is_dir(follow_symlinks=False):
_remove_tree(path, removed, left)
continue
else:
path.unlink()
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
try:
folder.rmdir()
except OSError as exc:
left.append({"file": _rel(folder), "reason": f"pasta não ficou vazia ({exc.__class__.__name__})"})
def clip_paths(engine, clip: dict, session: dict | None, cover: str | None) -> tuple[list[Path], list[Path]]:
"""(arquivos, pastas) que pertencem ao corte. Caminhos do banco são relativos à raiz do repositório."""
out_dir = engine.settings.clips_dir / str(clip["session_id"])
cid = clip["id"]
files: list[Path] = [REPO_ROOT / p for p in (clip.get("file"), clip.get("thumb"), cover) if p]
if out_dir.is_dir():
# vídeo, miniatura, capa (`-cover.jpg`) e restos do render (`.ass`, `.concat.txt`, `.tmp.mp4`, `.graph.txt`,
# `.uniform.mkv`, máscaras das camadas). `clip-1.*`/`clip-1-*` não pegam o `clip-12`.
files += sorted(out_dir.glob(f"clip-{cid}.*")) + sorted(out_dir.glob(f"clip-{cid}-*"))
if session and session.get("dir"):
frames = REPO_ROOT / session["dir"] / "frames"
if frames.is_dir():
files += sorted(frames.glob(f"clip{cid}-*.jpg")) # quadros que o analista/editor viram
folders = [out_dir / f"edit-{cid}"] # editor: proxy, forma de onda, TTS, prévias
return files, folders
def remove_files(engine, files: list[Path], folders: list[Path]) -> tuple[list[str], list[dict]]:
roots = _roots(engine)
removed: list[str] = []
left: list[dict] = []
seen: set[str] = set()
for path in files:
key = os.path.normcase(os.path.abspath(path))
if key in seen:
continue
seen.add(key)
if not (path.exists() or _is_link(path)):
continue
try:
if _is_link(path):
# O link pode apontar para fora: some só ele, e só se ele mesmo estiver dentro das pastas.
if not _inside(path.parent, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
_unlink_link(path)
elif not _inside(path, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
elif path.is_file():
path.unlink()
else:
continue
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
for folder in folders:
if _is_link(folder):
if _inside(folder.parent, roots):
_unlink_link(folder)
removed.append(_rel(folder))
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
elif folder.is_dir():
if _inside(folder, roots):
_remove_tree(folder, removed, left)
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
return removed, left
# ---------------------------------------------------------------- apagar
def delete_clip(engine, clip_id: int, confirm_published: bool = False) -> dict:
"""Apaga um corte. Recusa com `DeleteRefused` (código + motivo). Devolve o que foi apagado."""
db = engine.db
# engine.lock: o motor marca `_rendering` sob o mesmo trinco (render_clip), então um corte não começa a
# renderizar no meio da exclusão. db.lock: ler o estado e apagar sem outra thread escrever no meio.
with engine.lock, db.lock:
clip = db.get("SELECT * FROM clips WHERE id = ?", clip_id)
if not clip:
raise DeleteRefused(*NOT_FOUND, status=404)
status = clip["status"]
if status in BUSY:
raise DeleteRefused(*BUSY[status])
if clip_id in engine._rendering:
raise DeleteRefused(*BUSY["rendering"])
if status == "published" and not confirm_published:
raise DeleteRefused(*PUBLISHED)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
edit = db.get("SELECT cover FROM edits WHERE clip_id = ?", clip_id)
reasons = loads(clip.get("reasons_json"), {})
reasons = reasons if isinstance(reasons, dict) else {}
def number(key: str) -> float | None:
try:
return float(reasons[key])
except (KeyError, TypeError, ValueError):
return None
db.conn.execute("BEGIN")
try:
# A marca vem antes de apagar: o anti-duplicado nunca vê a sessão sem o corte e sem a marca.
db.conn.execute(
"INSERT OR REPLACE INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, candidate_start_s,"
" candidate_end_s, status, source, title, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(clip_id, clip["session_id"], clip["peak_s"], clip["start_s"], clip["end_s"], number("candidateStartS"),
number("candidateEndS"), status, clip["source"], (clip["title"] or "")[:100], now()))
db.conn.execute("DELETE FROM edits WHERE clip_id = ?", (clip_id,))
gone = db.conn.execute("DELETE FROM clips WHERE id = ? AND status = ?", (clip_id, status)).rowcount
if gone != 1:
raise DeleteRefused(*CHANGED)
db.conn.execute("COMMIT")
except BaseException:
db.conn.execute("ROLLBACK")
raise
# Arquivos fora do trinco (podem demorar); nada mais aponta para eles e o render não pega um id que sumiu.
files, folders = clip_paths(engine, clip, session, edit["cover"] if edit else None)
removed, left = remove_files(engine, files, folders)
log.info("corte %s apagado (%s): %d arquivos, %d ficaram", clip_id, status, len(removed), len(left))
return {"id": clip_id, "sessionId": clip["session_id"], "status": status, "removedFiles": len(removed),
"left": left}
def select_ids(db, session_id: int | None, statuses: list[str], limit: int = MAX_BATCH) -> tuple[list[int], int]:
"""Ids dos cortes nesses estados (e nessa sessão, se vier), do mais novo para o mais velho, até `limit`.
Devolve (ids, quantos ficaram de fora pelo limite)."""
sql = "SELECT id FROM clips WHERE status IN (" + ",".join("?" * len(statuses)) + ")"
params: list = list(statuses)
if session_id is not None:
sql += " AND session_id = ?"
params.append(session_id)
ids = [r["id"] for r in db.all(sql + " ORDER BY id DESC", *params)]
return ids[:limit], max(0, len(ids) - limit)
def delete_many(engine, ids: list[int], confirm_published: bool = False) -> dict:
"""Apaga vários. Cada um passa pelas mesmas regras; o que não pôde vai em `failed` com o motivo."""
deleted, failed = [], []
for clip_id in dict.fromkeys(ids): # sem repetir, na ordem pedida
try:
deleted.append(delete_clip(engine, clip_id, confirm_published))
except DeleteRefused as exc:
failed.append({"id": clip_id, "code": exc.code, "reason": exc.message})
return {"deleted": deleted, "failed": failed}
+130
View File
@@ -0,0 +1,130 @@
"""Configuração do Clipador, lida de clipper/.env (e do ambiente, que tem prioridade)."""
from __future__ import annotations
import os
import shutil
import sys
from dataclasses import dataclass
from pathlib import Path
CLIPPER_DIR = Path(__file__).resolve().parent.parent
REPO_ROOT = CLIPPER_DIR.parent
PORT_RANGE = (4500, 4599)
class ConfigError(RuntimeError):
"""Configuração inválida: o serviço não sobe."""
def read_env_file(path: Path) -> dict[str, str]:
if not path.is_file():
return {}
values: dict[str, str] = {}
for line in path.read_text(encoding="utf-8").splitlines():
if "=" not in line or line.lstrip().startswith("#"):
continue
name, value = line.split("=", 1)
values[name.strip()] = value.strip()
return values
def _find_tool(env_name: str, names: list[str], extra_dirs: list[Path]) -> str | None:
if os.environ.get(env_name):
return os.environ[env_name]
for directory in extra_dirs:
for name in names:
for ext in ("", ".exe"):
candidate = directory / f"{name}{ext}"
if candidate.is_file():
return str(candidate)
for name in names:
found = shutil.which(name)
if found:
return found
return None
@dataclass(frozen=True)
class Settings:
service_key: str
port: int
segment_s: int
poll_s: int
keep_hours: float
language: str
encoder: str
data_dir: Path
clips_dir: Path
ffmpeg: str | None
ffprobe: str | None
streamlink: str | None
voice_url: str | None
voice_key: str | None
judge_provider: str
judge_model: str
judge_min_score: float
@staticmethod
def load(env_file: Path | None = None, **overrides: object) -> "Settings":
env = {**read_env_file(env_file or CLIPPER_DIR / ".env"), **os.environ}
voice_env = read_env_file(REPO_ROOT / "voice" / ".env")
def num(name: str, default: float, minimum: float = 0) -> float:
raw = env.get(name, "")
try:
value = float(raw) if raw else default
except ValueError as exc:
raise ConfigError(f"{name} precisa ser número") from exc
if value < minimum:
raise ConfigError(f"{name} precisa ser >= {minimum}")
return value
port = int(num("CLIPPER_PORT", 4520, 1))
if not PORT_RANGE[0] <= port <= PORT_RANGE[1]:
raise ConfigError(f"CLIPPER_PORT={port} fora da faixa {PORT_RANGE[0]}–{PORT_RANGE[1]} do CenaForge")
venv_scripts = CLIPPER_DIR / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
def repo_dir(name: str, default: Path) -> Path:
"""Pasta opcional (CLIPPER_DATA_DIR/CLIPPER_OUTPUT_DIR) para isolar uma instância de teste. Precisa ficar
dentro do repositório: blocos e cortes são gravados no banco com caminho relativo ao repo."""
raw = env.get(name, "").strip()
if not raw:
return default
path = Path(raw)
path = (path if path.is_absolute() else REPO_ROOT / path).resolve()
if not path.is_relative_to(REPO_ROOT.resolve()):
raise ConfigError(f"{name} precisa ficar dentro do repositório ({REPO_ROOT})")
return REPO_ROOT / path.relative_to(REPO_ROOT.resolve())
settings = Settings(
service_key=env.get("CLIPPER_SERVICE_KEY", ""),
port=port,
# CLIPPER_QUALITY não é mais lida: a qualidade de gravação é `capture.quality` (canal/sessão, painel).
segment_s=int(num("CLIPPER_SEGMENT_S", 30, 5)),
poll_s=int(num("CLIPPER_POLL_S", 60, 15)),
keep_hours=num("CLIPPER_KEEP_HOURS", 6, 0),
language=env.get("CLIPPER_LANGUAGE", "pt-BR") or "pt-BR",
encoder=env.get("CLIPPER_ENCODER", "auto") or "auto",
data_dir=repo_dir("CLIPPER_DATA_DIR", REPO_ROOT / "data" / "clipper"),
# output/ é servido pelo painel (/api/files): os cortes prontos ficam lá.
clips_dir=repo_dir("CLIPPER_OUTPUT_DIR", REPO_ROOT / "output" / "clipper"),
ffmpeg=_find_tool("FFMPEG_BIN", ["ffmpeg"], []),
ffprobe=_find_tool("FFPROBE_BIN", ["ffprobe"], []),
streamlink=_find_tool("STREAMLINK_BIN", ["streamlink"], [venv_scripts]),
voice_url=f"http://127.0.0.1:{voice_env.get('VOICE_PORT') or '4510'}" if voice_env.get("VOICE_SERVICE_KEY") else None,
voice_key=voice_env.get("VOICE_SERVICE_KEY") or None,
# Valores iniciais do juiz; depois quem manda é o painel (tabela settings do banco do Clipador).
judge_provider=(env.get("CLIPPER_JUDGE_PROVIDER") or "codex").lower(),
judge_model=env.get("CLIPPER_JUDGE_MODEL", ""),
judge_min_score=num("CLIPPER_JUDGE_MIN_SCORE", 6, 0),
)
if settings.judge_provider not in ("codex", "claude", "off"):
raise ConfigError("CLIPPER_JUDGE_PROVIDER precisa ser codex, claude ou off")
if settings.encoder not in ("auto", "libx264", "h264_nvenc"):
raise ConfigError("CLIPPER_ENCODER precisa ser auto, libx264 ou h264_nvenc")
if overrides:
from dataclasses import replace
settings = replace(settings, **overrides) # type: ignore[arg-type]
return settings
+270
View File
@@ -0,0 +1,270 @@
"""Estado do Clipador em data/clipper/clipper.db (SQLite). Canais monitorados, sessões de gravação, blocos
gravados, chat e cortes. As contas (e o vínculo conta ↔ canal) ficam no banco do painel."""
from __future__ import annotations
import json
import sqlite3
import threading
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
SCHEMA = [
"""
CREATE TABLE channels (
id TEXT PRIMARY KEY,
platform TEXT NOT NULL CHECK (platform IN ('twitch', 'youtube', 'kick')),
channel TEXT NOT NULL,
url TEXT NOT NULL,
display_name TEXT NOT NULL,
monitor INTEGER NOT NULL DEFAULT 1,
authorized INTEGER NOT NULL DEFAULT 0,
threshold REAL,
created_at TEXT NOT NULL,
last_check_at TEXT,
last_status TEXT NOT NULL DEFAULT ''
);
CREATE TABLE sessions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id TEXT REFERENCES channels(id) ON DELETE SET NULL,
platform TEXT NOT NULL,
kind TEXT NOT NULL CHECK (kind IN ('live', 'vod')),
url TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('starting', 'recording', 'processing', 'done', 'stopped', 'error', 'interrupted')),
chat_status TEXT NOT NULL DEFAULT 'off',
dir TEXT NOT NULL,
duration_s REAL NOT NULL DEFAULT 0,
started_at TEXT NOT NULL,
ended_at TEXT,
error TEXT
);
CREATE TABLE segments (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
file TEXT NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
wall_end REAL NOT NULL,
analyzed INTEGER NOT NULL DEFAULT 0,
loudness_json TEXT,
words_json TEXT,
transcript_error TEXT,
deleted INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (session_id, idx)
);
CREATE TABLE chat (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
wall REAL NOT NULL,
user TEXT NOT NULL,
text TEXT NOT NULL
);
CREATE INDEX chat_session_wall ON chat (session_id, wall);
CREATE TABLE clips (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
score REAL NOT NULL,
source TEXT NOT NULL,
reasons_json TEXT NOT NULL DEFAULT '{}',
title TEXT NOT NULL DEFAULT '',
caption TEXT NOT NULL DEFAULT '',
transcript TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('candidate', 'discarded', 'pending', 'rendering', 'ready', 'approved', 'rejected', 'published', 'error')),
judge_json TEXT,
file TEXT,
thumb TEXT,
error TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v2: configurações trocadas pelo painel em tempo de execução (juiz: provedor, modelo, nota mínima).
"""
CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
""",
# v3: contexto do jogo, varredura da IA, emotes que aprendem e configuração do corte (layout/legenda).
"""
ALTER TABLE sessions ADD COLUMN game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN game_source TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN screen_game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN games_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN room_id TEXT;
ALTER TABLE sessions ADD COLUMN settings_json TEXT;
ALTER TABLE sessions ADD COLUMN scanned_until REAL NOT NULL DEFAULT 0;
ALTER TABLE sessions ADD COLUMN memory_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN cam_json TEXT;
ALTER TABLE clips ADD COLUMN learned INTEGER NOT NULL DEFAULT 0;
ALTER TABLE channels ADD COLUMN settings_json TEXT;
ALTER TABLE chat ADD COLUMN emotes TEXT;
CREATE TABLE games (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN ('pending', 'ready', 'error')),
profile_json TEXT,
error TEXT,
model TEXT,
researched_at TEXT
);
CREATE TABLE emotes (
channel_key TEXT NOT NULL,
name TEXT NOT NULL,
source TEXT NOT NULL,
uses INTEGER NOT NULL DEFAULT 0,
weight REAL NOT NULL DEFAULT 0,
first_seen TEXT NOT NULL,
last_seen TEXT NOT NULL,
PRIMARY KEY (channel_key, name)
);
""",
# v4: projeto do editor de cortes (JSON versionado por corte; `rev` sobe a cada gravação — autosave sem atropelar).
"""
CREATE TABLE edits (
clip_id INTEGER PRIMARY KEY REFERENCES clips(id) ON DELETE CASCADE,
project_json TEXT NOT NULL,
rev INTEGER NOT NULL DEFAULT 1,
cover TEXT,
exported_at TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v5: rastreio de reação (face.py) — série por segundo do rosto do streamer, uma linha por bloco gravado.
# status: done | no_cam | error. `data_json` = {cam, crop, fps, backend, seconds: [FaceSecond…]} (quadro inteiro).
"""
CREATE TABLE face_track (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
status TEXT NOT NULL CHECK (status IN ('done', 'no_cam', 'error')),
data_json TEXT,
error TEXT,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
# v6: perfil do jogo editável pelo painel. `notes_json` = pedidos que você fez à IA ([{text, at}]) — entram de
# novo em toda pesquisa, para "Pesquisar de novo" não apagar o que você acrescentou; `edited_at` = última edição
# à mão ou por pedido seu.
"""
ALTER TABLE games ADD COLUMN notes_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE games ADD COLUMN edited_at TEXT;
""",
# v7: a IA entrega o projeto de edição pronto. `origin` = quem fez a versão atual (ai = pipeline; user = você
# salvou no editor); `ai_project_json` guarda o que a IA gerou, para "voltar ao projeto da IA".
"""
ALTER TABLE edits ADD COLUMN origin TEXT NOT NULL DEFAULT 'ai' CHECK (origin IN ('ai', 'user'));
ALTER TABLE edits ADD COLUMN ai_project_json TEXT;
""",
# v8: formato em que o corte foi renderizado (`format.aspect` da configuração efetiva no render): o painel
# desenha o player na proporção certa. Cortes antigos foram todos verticais (1080×1920).
"""
ALTER TABLE clips ADD COLUMN aspect TEXT NOT NULL DEFAULT 'vertical' CHECK (aspect IN ('vertical', 'horizontal'));
""",
# v9: o que a captura gravou de fato (app/capture.py): qualidade pedida + resolução, qps, codec e taxa lidos do
# 1º bloco de cada execução (início ou retomada). Sessões antigas ficam NULL (gravadas com o teto antigo de 720p).
"""
ALTER TABLE sessions ADD COLUMN capture_json TEXT;
""",
# v10: marca mínima de cada corte apagado (app/clip_delete.py): pico, trecho final e janela original do
# candidato. A regra anti-duplicado conta com ela como se o corte ainda existisse, então apagar um descartado
# não faz a IA recriar o mesmo momento na passada seguinte da live (nem na passada final da sessão).
"""
CREATE TABLE deleted_clips (
clip_id INTEGER PRIMARY KEY,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
candidate_start_s REAL,
candidate_end_s REAL,
status TEXT NOT NULL,
source TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
deleted_at TEXT NOT NULL
);
CREATE INDEX deleted_clips_session ON deleted_clips (session_id);
""",
]
def now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
class Database:
def __init__(self, path: Path):
path.parent.mkdir(parents=True, exist_ok=True)
self.lock = threading.RLock()
self.conn = sqlite3.connect(path, check_same_thread=False, isolation_level=None)
self.conn.row_factory = sqlite3.Row
self.conn.executescript("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 3000;")
self._migrate()
# Sessões que estavam gravando quando o serviço caiu: a captura morreu junto. Ficam 'interrupted' e o motor
# tenta retomar as lives sozinho na subida (Engine.start → resume_interrupted); quem estava só processando
# volta a processar.
self.interrupted_on_start = [r["id"] for r in self.all(
"SELECT id FROM sessions WHERE status IN ('starting', 'recording') AND kind = 'live'")]
self.run("UPDATE sessions SET status = 'interrupted', ended_at = ?, chat_status = 'off' WHERE status IN ('starting', 'recording')", now())
# Antes as que estavam 'processing' também viravam 'interrupted' e paravam; processar não depende da captura.
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado).
self.run("UPDATE sessions SET chat_status = 'off' WHERE status NOT IN ('starting', 'recording') AND chat_status != 'off'")
self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
def _migrate(self) -> None:
version = self.conn.execute("PRAGMA user_version").fetchone()[0]
for v in range(version, len(SCHEMA)):
with self.lock:
self.conn.execute("BEGIN")
try:
for statement in _split(SCHEMA[v]):
self.conn.execute(statement)
self.conn.execute(f"PRAGMA user_version = {v + 1}")
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def run(self, sql: str, *params: Any) -> sqlite3.Cursor:
with self.lock:
return self.conn.execute(sql, params)
def many(self, sql: str, rows: list[tuple]) -> None:
with self.lock:
self.conn.execute("BEGIN")
try:
self.conn.executemany(sql, rows)
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def all(self, sql: str, *params: Any) -> list[dict]:
with self.lock:
return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
def get(self, sql: str, *params: Any) -> dict | None:
with self.lock:
row = self.conn.execute(sql, params).fetchone()
return dict(row) if row else None
def close(self) -> None:
with self.lock:
self.conn.close()
def _split(script: str) -> list[str]:
# executescript faria COMMIT implícito no meio da transação; executamos comando por comando.
return [s.strip() for s in script.split(";") if s.strip()]
def loads(raw: str | None, default: Any) -> Any:
try:
return json.loads(raw) if raw else default
except json.JSONDecodeError:
return default
+728
View File
@@ -0,0 +1,728 @@
"""Editor de cortes: o PROJETO DE EDIÇÃO de um corte (JSON versionado, tabela `edits`) e as contas de tempo.
Fonte da verdade do editor do painel (`/clipper/edit/<id>`). O servidor sabe renderizar o projeto com FFmpeg
(`editor_render.py`). Ideias tiradas do OpenCut (MIT; só o padrão, nenhum código copiado): trilhas por papel
(vídeo, legenda, textos, áudio), elementos com início/fim, desfazer por instantâneos e atalhos J/K/L/S.
Tempos:
- **tempo da sessão** (`t` da gravação): `cuts`, palavras da legenda, textos, zooms, narração e capa. Assim,
remover um pedaço do meio não desloca o que está ancorado no conteúdo (o zoom continua na reação);
- **tempo de saída** (segundos do MP4): só o gancho (`kind: "hook"`), que vale a partir do 1º quadro.
`to_output` converte; tudo que cai num trecho removido "gruda" no começo do próximo trecho mantido.
Validação forte (`validate_project`): nada do JSON vira comando de shell (FFmpeg recebe lista de argumentos e só
números formatados no filtro), texto é escapado no ASS, arquivos de áudio só de pastas permitidas, limites de
duração e de quantidade.
"""
from __future__ import annotations
import copy
import re
from dataclasses import dataclass
from pathlib import Path
from . import layout, reframe
from .scoring import ChatMessage, Word, fit_window
SCHEMA_VERSION = 1
MAX_WINDOW_S = 600.0 # janela da gravação que o editor carrega (proxy e forma de onda)
MIN_OUTPUT_S, MAX_OUTPUT_S = 3.0, 180.0
MIN_CUT_S = 0.2
MAX_CUTS = 60
MAX_WORDS = 4000
MAX_OVERLAYS = 40
MAX_NARRATION = 12
MAX_SFX = 20
CAPTION_PRESETS = ("classic", "pop", "karaoke", "single", "minimal")
TEXT_ANIMS = layout.HOOK_ANIMS # pop, fade, none, slide (tarja/texto entram deslizando com desfoque)
OVERLAY_KINDS = ("hook", "text", "zoom", "inset") # inset = recorte da tela em destaque
AUDIO_EXT = (".mp3", ".wav", ".ogg", ".m4a", ".opus", ".flac")
ID_RE = re.compile(r"^[A-Za-z0-9_-]{1,40}$")
VOICE_RE = re.compile(r"^[a-z0-9][a-z0-9-]{1,47}$")
TTS_FILE_RE = re.compile(r"^tts-[0-9a-f]{12}\.wav$")
CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
# Padrão de cada preset de legenda (camada por cima do estilo do canal/sessão; o projeto ainda pode sobrescrever).
PRESET_STYLE: dict[str, dict] = {
"classic": {},
"pop": {"maxWords": 3},
"karaoke": {"maxWords": 4, "size": 76},
"single": {"maxWords": 1, "size": 104},
"minimal": {"uppercase": False, "size": 64, "outlineWidth": 4, "maxWords": 4},
}
PRESET_LABEL = {
"classic": "Clássica (palavra falada em destaque)",
"pop": "Pop (palavra falada cresce e volta)",
"karaoke": "Karaokê (preenche palavra a palavra)",
"single": "Uma palavra por vez (entra com escala)",
"minimal": "Mínima (sem destaque, discreta)",
}
class EditError(ValueError):
"""Projeto inválido ou pedido impossível: vira 400 com a mensagem para o usuário."""
# ---------------------------------------------------------------- tempo
@dataclass(frozen=True)
class Piece:
"""Trecho mantido: [start, end] da sessão que entra no MP4 a partir de `out` (tempo de saída)."""
start: float
end: float
out: float
mode: str | None = None
muted: bool = False # trecho sem o som da live (a narração e a música continuam)
@property
def length(self) -> float:
return self.end - self.start
def pieces(cuts: list[dict]) -> list[Piece]:
out, acc = [], 0.0
for cut in cuts:
out.append(Piece(cut["start"], cut["end"], acc, cut.get("mode"), bool(cut.get("muted"))))
acc += cut["end"] - cut["start"]
return out
def output_duration(cuts: list[dict]) -> float:
return round(sum(c["end"] - c["start"] for c in cuts), 3)
def to_output(t: float, cuts: list[dict]) -> tuple[float, bool]:
"""Tempo da sessão → tempo de saída. Segundo valor: o instante está num trecho mantido?
Num trecho removido (ou antes do 1º), cai no começo do próximo trecho mantido."""
for p in pieces(cuts):
if t < p.start:
return round(p.out, 3), False
if t <= p.end:
return round(p.out + t - p.start, 3), True
return output_duration(cuts), False
def to_session(t_out: float, cuts: list[dict]) -> float:
"""Tempo de saída → tempo da sessão."""
ps = pieces(cuts)
for p in ps:
if t_out <= p.out + p.length:
return round(p.start + max(0.0, t_out - p.out), 3)
return ps[-1].end if ps else 0.0
def slice_pieces(cuts: list[dict], a: float, b: float) -> list[Piece]:
"""Trechos da sessão que formam a saída [a, b] (para a prévia real de poucos segundos)."""
out = []
for p in pieces(cuts):
lo, hi = max(a, p.out), min(b, p.out + p.length)
if hi - lo > 0.01:
out.append(Piece(p.start + lo - p.out, p.start + hi - p.out, lo - a, p.mode, p.muted))
return out
def normalize_cuts(cuts: list[dict]) -> list[dict]:
"""Ordena e junta trechos que se encostam/sobrepõem, se tiverem o mesmo layout e o mesmo "mudo"."""
merged: list[dict] = []
for cut in sorted(cuts, key=lambda c: c["start"]):
same = merged and cut.get("mode") == merged[-1].get("mode") and bool(cut.get("muted")) == bool(merged[-1].get("muted"))
if same and cut["start"] <= merged[-1]["end"] + 0.02:
merged[-1]["end"] = max(merged[-1]["end"], cut["end"])
else:
merged.append(dict(cut))
return merged
def output_words(project: dict) -> list[Word]:
"""Palavras visíveis da legenda em tempo de saída (palavra cujo meio caiu num trecho removido some)."""
cuts = project["cuts"]
out = []
for w in project["captions"]["words"]:
if w.get("hidden") or not w["w"].strip():
continue
mid = (w["s"] + w["e"]) / 2
t, inside = to_output(mid, cuts)
if not inside:
continue
for p in pieces(cuts):
if p.start <= mid <= p.end:
s = p.out + max(w["s"], p.start) - p.start
e = p.out + min(w["e"], p.end) - p.start
out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"]))
break
return out
def emphasized(project: dict) -> set[tuple[float, str]]:
return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
# ---------------------------------------------------------------- projeto
def default_window(clip: dict, session_duration: float) -> tuple[float, float]:
"""Janela inicial: 45 s antes e 20 s depois do corte (dá para voltar o começo sem gerar outra prévia)."""
lo = max(0.0, clip["start_s"] - 45)
hi = min(session_duration, clip["end_s"] + 20) if session_duration > 0 else clip["end_s"] + 20
return round(lo, 3), round(max(hi, clip["end_s"]), 3)
_SESSION_TIME_RE = re.compile(r"\b(?:aos|ao|em|no)\s+\d{2,}\s*s\b\s*[,:;—-]?\s*", re.IGNORECASE)
def pick_hook(raw: str | None, title: str | None) -> tuple[str, bool]:
"""Texto do gancho na tela. O do analista só serve se for curto e sem tempo da gravação (ele às vezes devolve
uma frase descritiva como "Aos 5085s, ele solta que…", que saía cortada no meio — medido no corte 25 do skipnho);
senão vale o título do editor, que já é escrito como gancho. Nunca corta no meio de uma palavra.
Devolve (texto, veio_do_analista)."""
raw = (raw or "").strip()
short = bool(raw) and len(raw.split()) <= 8 and len(raw) <= 48 and not re.search(r"\d{3,}\s*s\b", raw)
text = _SESSION_TIME_RE.sub("", raw if short else (title or raw or "")).strip()
if text:
text = text[0].upper() + text[1:]
if len(text) > 60:
text = text[:60].rsplit(" ", 1)[0].rstrip(" ,;:—-")
return text, short
def default_project(clip: dict, words: list[Word], session_duration: float) -> dict:
lo, hi = default_window(clip, session_duration)
analysis = ((clip.get("judge") or {}) if isinstance(clip.get("judge"), dict) else {}).get("analysis") or {}
hook, _ = pick_hook(analysis.get("hook"), clip.get("title"))
return {
"schema": SCHEMA_VERSION,
"source": {"sessionId": clip["session_id"], "lo": lo, "hi": hi},
"settings": {},
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
"captions": {
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in words if lo <= w.start <= hi][:MAX_WORDS],
},
"overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
"progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1.0, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": True, "t": round(clip.get("peak_s") or clip["start_s"], 3), "text": hook[:40]},
}
QUIET_DB = -38.0 # silêncio "de verdade": nem fala nem som do jogo (dBFS por segundo, volume medido no bloco)
AUTO_GAP_S = 2.0 # vão sem fala a partir do qual a IA corta (se também estiver quieto)
def auto_project(clip: dict, analysis: dict | None, words: list[Word], loudness: list[float | None],
session_duration: float, cfg: dict, *, model: str = "", generated_at: str = "") -> dict:
"""Projeto que a IA entrega pronto (o render automático usa ESTE projeto, o mesmo que o editor abre):
trecho pela análise (início da ação, fim da reação) encaixado nas palavras, silêncios longos E quietos
removidos (longe do pico), legenda do Whisper no estilo do corte (preset pop), gancho do analista nos
primeiros segundos, punch-in no pico e capa no pico. `loudness` = dBFS por segundo da sessão (índice = s)."""
p = default_project(clip, words, session_duration)
lo, hi = p["source"]["lo"], p["source"]["hi"]
dur = {**layout.DEFAULTS["duration"], **(cfg.get("duration") or {})}
max_s = float(dur["maxS"])
# Corte automático: duração FINAL (depois de silêncios e aparos) ≥ mínimo + 1 s. "Cortar agora" é livre.
manual = clip.get("source") == "manual"
min_s = 0.0 if manual else layout.min_target({"duration": dur})
steps: list[str] = []
start, end = float(clip["start_s"]), float(clip["end_s"])
a = analysis or {}
try:
act, react = float(a.get("action_start_s")), float(a.get("reaction_end_s"))
except (TypeError, ValueError):
act = react = None # type: ignore[assignment]
# Início no começo da ação. Medido (sessão 3, cortes 43, 44, 55, 58, 61): quando o analista punha a ação DEPOIS do
# início do juiz, o corte encolhia para 44–58 s com mínimo 60. Adiantar o início só vale se o mínimo continua.
if (act is not None and lo <= act < end - 5 and act >= start - 15 and abs(act - start) > 0.5
and end - max(lo, act - 0.8) >= min_s):
start = max(lo, act - 0.8)
steps.append(f"início no começo da ação ({act:.0f}s, analista)")
if react is not None and end < react <= min(hi, end + 8):
end = min(hi, react + 0.8)
steps.append(f"fim depois da reação ({react:.0f}s, analista)")
inside = sorted((w for w in words if lo <= w.start <= hi and w.word.strip()), key=lambda w: w.start)
for w in inside: # nunca corta no meio da palavra
if w.start < start < w.end:
start = max(lo, w.start - 0.1)
if w.start < end < w.end:
end = min(hi, w.end + 0.15)
if end - start > max_s:
end = start + max_s
steps.append(f"limitado a {max_s:.0f} s")
if end - start < min_s:
# Falta material: cresce para trás (contexto; é onde o gancho fica) e, no começo da gravação, para a frente.
before = end - start
start, end = fit_window(start, end, lo, hi, min_s, max_s, keep="start")
for w in inside: # o início novo também não corta palavra (só recua)
if w.start < start < w.end and end - (w.start - 0.1) <= max_s:
start = max(lo, w.start - 0.1)
steps.append(f"estendido de {before:.1f} s para {end - start:.1f} s (mínimo {min_s:.1f} s)")
if end - start < min_s - 0.01:
steps.append(f"curto: só havia {end - start:.1f} s de gravação em volta do momento (mínimo {min_s:.1f} s)")
cuts = [{"start": round(start, 3), "end": round(end, 3), "mode": None}]
peak = float(clip.get("peak_s") or (start + end) / 2)
def quiet(x: float, y: float) -> bool:
values = loudness[int(x): int(y) + 1]
return bool(values) and all(v is None or v < QUIET_DB for v in values)
removed = 0.0
spoken = [w for w in inside if start <= w.start <= end]
for w1, w2 in zip(spoken, spoken[1:]):
x, y = w1.end + 0.25, w2.start - 0.25
if w2.start - w1.end < AUTO_GAP_S or y - x < 0.5 or x - 3 <= peak <= y + 3 or not quiet(x, y):
continue
if output_duration(cuts) - (y - x) < min_s: # o corte final nunca fica abaixo do mínimo + 1 s
break
out, kept = [], cuts
for c in kept:
if y <= c["start"] or x >= c["end"]:
out.append(c)
continue
if x > c["start"]:
out.append({**c, "end": round(x, 3)})
if y < c["end"]:
out.append({**c, "start": round(y, 3)})
cuts = normalize_cuts(out)
removed += y - x
if removed:
steps.append(f"{removed:.1f} s de silêncio removidos")
p["cuts"] = cuts
p["captions"]["preset"] = "pop"
steps.append(f"legenda do Whisper ({len(spoken)} palavras, estilo pop)")
# Gancho: o do analista só se for curto (às vezes ele devolve uma frase descritiva — medido no corte 10 do
# skipnho); senão o título do editor, que já é escrito como gancho.
hook, short = pick_hook(a.get("hook"), clip.get("title"))
p["overlays"] = []
if hook:
# Estilo do gancho pela configuração do corte (grupo `hook`; padrão: tarja verde-limão que entra deslizando).
# Ele cobre o começo do corte — o segundo a mais do mínimo é justamente essa abertura (não há tela parada).
hk = {**layout.DEFAULTS["hook"], **(cfg.get("hook") or {})}
overlay = {"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": round(float(hk["seconds"]), 3),
"y": 0.2, "size": 68, "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
if hk["style"] == "banner":
overlay |= {"style": "banner", "bg": hk["bg"], "color": hk["color"], "font": hk["font"], "anim": hk["anim"],
"box": None, "size": 76}
# A tarja (até ~0,13 da altura no vertical) não pode cobrir a legenda automática: se a legenda estiver
# perto de 20 % da altura (câmera em cima com painel baixo, ou y escolhido), a tarja vai para o outro lado.
cap_y = layout.caption_y(cfg) / layout.canvas_size(cfg)[1]
if abs(cap_y - overlay["y"]) < 0.2:
overlay["y"] = round(cap_y - 0.22 if cap_y > 0.3 else min(0.85, cap_y + 0.22), 3)
else:
overlay |= {"color": hk["color"], "font": hk["font"], "anim": hk["anim"]}
p["overlays"].append(overlay)
steps.append(("gancho do analista" if short else "gancho = título do editor") + f" ({hk['style']})")
t_out, kept_peak = to_output(peak, cuts)
if kept_peak and t_out >= 1.5:
cut = next(c for c in cuts if c["start"] <= peak <= c["end"])
z_end = min(cut["end"], peak + 2.0)
if z_end - peak >= 0.8:
cam = layout.resolved_mode(cfg) == "cam_top"
# Câmera em cima: aproxima do rosto (centro do painel da câmera); senão, o centro da tela.
fy = round(cfg["layout"]["camHeight"] / 2, 3) if cam else 0.45
p["overlays"].append({"id": "zoom-peak", "kind": "zoom", "start": round(max(cut["start"], peak - 0.2), 3),
"end": round(z_end, 3), "scale": 1.25, "x": 0.5, "y": fy, "ramp": 0.15})
steps.append(f"zoom no pico ({peak:.0f}s)")
p["cover"] = {"enabled": True, "t": round(min(max(peak, lo), hi), 3), "text": hook[:40]}
p["meta"] = {"origin": "ai", "generatedAt": generated_at, "model": model or "", "steps": steps[:12]}
return p
def _num(value, name: str, lo: float, hi: float) -> float:
try:
v = float(value)
except (TypeError, ValueError) as exc:
raise EditError(f"{name} precisa ser número") from exc
if v != v or not lo <= v <= hi: # NaN ou fora da faixa
raise EditError(f"{name} vai de {lo:g} a {hi:g}")
return round(v, 3)
def _text(value, name: str, max_len: int, allow_empty: bool = True) -> str:
if not isinstance(value, str):
raise EditError(f"{name} precisa ser texto")
text = CONTROL_RE.sub(" ", value).replace("\r", "").strip()
if len(text) > max_len:
raise EditError(f"{name} passa de {max_len} caracteres")
if not text and not allow_empty:
raise EditError(f"{name} está vazio")
return text
def _hex(value, name: str) -> str:
if not isinstance(value, str) or not layout.HEX_RE.match(value):
raise EditError(f"{name} precisa ser cor #RRGGBB")
return value.upper()
def _list(value, name: str, limit: int) -> list:
if value is None:
return []
if not isinstance(value, list):
raise EditError(f"{name} precisa ser lista")
if len(value) > limit:
raise EditError(f"{name}: no máximo {limit}")
return value
def _id(value, name: str) -> str:
if not isinstance(value, str) or not ID_RE.match(value):
raise EditError(f"{name} precisa ser um id curto (letras, números, - e _)")
return value
def safe_audio_file(value, roots: list[Path], repo_root: Path, name: str) -> str:
"""Arquivo de áudio relativo ao repositório, dentro de uma das pastas permitidas e existente."""
if not isinstance(value, str) or not value or "\\" in value or value.startswith("/") or ".." in value.split("/"):
raise EditError(f"{name}: caminho inválido")
full = (repo_root / value).resolve()
if full.suffix.lower() not in AUDIO_EXT:
raise EditError(f"{name}: só áudio ({', '.join(AUDIO_EXT)})")
if not any(full.is_relative_to(r.resolve()) for r in roots):
raise EditError(f"{name}: arquivo fora das pastas permitidas")
if not full.is_file():
raise EditError(f"{name}: arquivo não encontrado")
return value
def validate_project(data: dict, *, session_id: int, session_duration: float, repo_root: Path,
tts_dir: Path, assets_dir: Path) -> dict:
"""Valida e normaliza o projeto inteiro. Levanta EditError com a 1ª falha (mensagem em português)."""
if not isinstance(data, dict):
raise EditError("projeto precisa ser um objeto")
if data.get("schema") != SCHEMA_VERSION:
raise EditError(f"versão do projeto não suportada (esperado schema {SCHEMA_VERSION})")
src = data.get("source") or {}
if src.get("sessionId") != session_id:
raise EditError("o projeto é de outra sessão")
limit = session_duration if session_duration > 0 else 1e9
lo = _num(src.get("lo"), "source.lo", 0, limit)
hi = _num(src.get("hi"), "source.hi", 0, limit)
if not 5 <= hi - lo <= MAX_WINDOW_S:
raise EditError(f"a janela da gravação precisa ter de 5 s a {MAX_WINDOW_S / 60:.0f} min")
# Configuração do corte própria do projeto (mesma validação da configuração de canal/sessão).
try:
own_settings = layout.validate(data.get("settings") or {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"configuração do corte: {exc}") from exc
raw_cuts = _list(data.get("cuts"), "cuts", MAX_CUTS)
if not raw_cuts:
raise EditError("o corte precisa de pelo menos um trecho")
cuts = []
for i, c in enumerate(raw_cuts):
if not isinstance(c, dict):
raise EditError(f"cuts[{i}] precisa ser objeto")
start, end = _num(c.get("start"), f"cuts[{i}].start", lo, hi), _num(c.get("end"), f"cuts[{i}].end", lo, hi)
if end - start < MIN_CUT_S:
raise EditError(f"cuts[{i}] precisa ter pelo menos {MIN_CUT_S:g} s")
mode = c.get("mode")
if mode is not None and mode not in layout.MODES:
raise EditError(f"cuts[{i}].mode precisa ser um de {', '.join(layout.MODES)} ou null")
cuts.append({"start": start, "end": end, "mode": mode, "muted": bool(c.get("muted", False))})
cuts = normalize_cuts(cuts)
total = output_duration(cuts)
if not MIN_OUTPUT_S <= total <= MAX_OUTPUT_S:
raise EditError(f"o corte editado precisa ter de {MIN_OUTPUT_S:g} a {MAX_OUTPUT_S:g} s (tem {total:.1f} s)")
cap = data.get("captions") or {}
preset = cap.get("preset", "classic")
if preset not in CAPTION_PRESETS:
raise EditError(f"captions.preset precisa ser um de {', '.join(CAPTION_PRESETS)}")
try:
style = layout.validate({"caption": cap.get("style") or {}}).get("caption", {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"estilo da legenda: {exc}") from exc
words = []
for i, w in enumerate(_list(cap.get("words"), "captions.words", MAX_WORDS)):
if not isinstance(w, dict):
raise EditError(f"captions.words[{i}] precisa ser objeto")
s, e = _num(w.get("s"), f"palavra {i} (início)", 0, limit), _num(w.get("e"), f"palavra {i} (fim)", 0, limit)
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms
e = round(s + 0.05, 3)
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
if w.get("emph"):
item["emph"] = True
if w.get("hidden"):
item["hidden"] = True
words.append(item)
words.sort(key=lambda w: w["s"])
captions = {"enabled": bool(cap.get("enabled", True)), "preset": preset, "style": style,
"emphColor": _hex(cap.get("emphColor", "#22E36B"), "captions.emphColor"), "words": words}
overlays, seen = [], set()
for i, o in enumerate(_list(data.get("overlays"), "overlays", MAX_OVERLAYS)):
if not isinstance(o, dict) or o.get("kind") not in OVERLAY_KINDS:
raise EditError(f"overlays[{i}].kind precisa ser um de {', '.join(OVERLAY_KINDS)}")
oid = _id(o.get("id"), f"overlays[{i}].id")
if oid in seen:
raise EditError(f"overlays: id repetido ({oid})")
seen.add(oid)
kind = o["kind"]
if kind == "hook": # tempo de saída
start, end = _num(o.get("start", 0), "gancho: início", 0, MAX_OUTPUT_S), _num(o.get("end"), "gancho: fim", 0, MAX_OUTPUT_S)
else: # tempo da sessão
start, end = _num(o.get("start"), f"overlays[{i}].start", lo, hi), _num(o.get("end"), f"overlays[{i}].end", lo, hi)
if end - start < 0.2:
raise EditError(f"overlays[{i}] precisa durar pelo menos 0,2 s")
item = {"id": oid, "kind": kind, "start": start, "end": end}
if kind == "inset":
item |= _inset(o, i, lo, hi)
elif kind == "zoom":
item |= {"scale": _num(o.get("scale", 1.3), "zoom: escala", 1.05, 2.5),
"x": _num(o.get("x", 0.5), "zoom: x", 0, 1), "y": _num(o.get("y", 0.5), "zoom: y", 0, 1),
"ramp": _num(o.get("ramp", 0.25), "zoom: rampa", 0, 1.5)}
else:
box = o.get("box")
style = o.get("style", "plain")
if style not in layout.HOOK_STYLES:
raise EditError(f"overlays[{i}].style precisa ser um de {', '.join(layout.HOOK_STYLES)}")
font = o.get("font")
if font is not None and font not in layout.FONTS:
raise EditError(f"overlays[{i}].font precisa ser uma de {', '.join(layout.FONTS)}")
bg = o.get("bg")
# Campos novos só entram no projeto quando usados: projeto antigo continua byte a byte igual.
if style != "plain":
item["style"] = style
if font is not None:
item["font"] = font
if bg not in (None, ""):
item["bg"] = _hex(bg, f"overlays[{i}].bg")
item |= {"text": _text(o.get("text", ""), f"overlays[{i}].text", 120, allow_empty=False),
"x": _num(o.get("x", 0.5), f"overlays[{i}].x", 0.05, 0.95),
"y": _num(o.get("y", 0.2), f"overlays[{i}].y", 0.04, 0.96),
"size": int(_num(o.get("size", 64), f"overlays[{i}].size", 24, 180)),
"color": _hex(o.get("color", "#FFFFFF"), f"overlays[{i}].color"),
"box": None if box in (None, "") else _hex(box, f"overlays[{i}].box"),
"anim": o.get("anim", "pop")}
if item["anim"] not in TEXT_ANIMS:
raise EditError(f"overlays[{i}].anim precisa ser um de {', '.join(TEXT_ANIMS)}")
overlays.append(item)
if sum(1 for o in overlays if o["kind"] == "inset") > reframe.MAX_INSETS:
raise EditError(f"no máximo {reframe.MAX_INSETS} camadas inseridas")
zooms = sorted((o for o in overlays if o["kind"] == "zoom"), key=lambda o: o["start"])
for a, b in zip(zooms, zooms[1:]):
if b["start"] < a["end"]:
raise EditError("dois zooms ao mesmo tempo: separe os trechos de zoom")
prog = data.get("progress") or {}
progress = {"enabled": bool(prog.get("enabled", False)), "color": _hex(prog.get("color", "#FF7A1A"), "progress.color"),
"height": int(_num(prog.get("height", 12), "progress.height", 4, 40))}
aud = data.get("audio") or {}
narration = []
for i, n in enumerate(_list(aud.get("narration"), "audio.narration", MAX_NARRATION)):
if not isinstance(n, dict):
raise EditError(f"audio.narration[{i}] precisa ser objeto")
file = safe_audio_file(n.get("file"), [tts_dir], repo_root, f"narração {i + 1}")
if not TTS_FILE_RE.match(Path(file).name):
raise EditError(f"narração {i + 1}: arquivo precisa ser gerado pelo editor (tts-*.wav)")
voice = n.get("voice", "")
if voice and not VOICE_RE.match(str(voice)):
raise EditError(f"narração {i + 1}: voz inválida")
narration.append({"id": _id(n.get("id"), f"narração {i + 1}"), "file": file,
"at": _num(n.get("at"), f"narração {i + 1}: instante", lo, hi),
"volume": _num(n.get("volume", 1.0), f"narração {i + 1}: volume", 0, 2),
"durationS": _num(n.get("durationS", 0), f"narração {i + 1}: duração", 0, 120),
"duck": _num(n.get("duck", 0.35), f"narração {i + 1}: volume do original por baixo", 0, 1),
"text": _text(n.get("text", ""), f"narração {i + 1}: texto", 300), "voice": str(voice)})
music = None
if aud.get("music"):
m = aud["music"]
if not isinstance(m, dict):
raise EditError("audio.music precisa ser objeto ou null")
music = {"file": safe_audio_file(m.get("file"), [assets_dir], repo_root, "música"),
"volume": _num(m.get("volume", 0.18), "música: volume", 0, 1), "duck": bool(m.get("duck", True))}
sfx = []
for i, x in enumerate(_list(aud.get("sfx"), "audio.sfx", MAX_SFX)):
if not isinstance(x, dict):
raise EditError(f"audio.sfx[{i}] precisa ser objeto")
sfx.append({"id": _id(x.get("id"), f"efeito {i + 1}"), "file": safe_audio_file(x.get("file"), [assets_dir], repo_root, f"efeito {i + 1}"),
"at": _num(x.get("at"), f"efeito {i + 1}: instante", lo, hi),
"volume": _num(x.get("volume", 0.8), f"efeito {i + 1}: volume", 0, 2)})
audio = {"volume": _num(aud.get("volume", 1.0), "audio.volume", 0, 2), "narration": narration, "music": music, "sfx": sfx}
cov = data.get("cover") or {}
cover = {"enabled": bool(cov.get("enabled", True)), "t": _num(cov.get("t", cuts[0]["start"]), "capa: instante", lo, hi),
"text": _text(cov.get("text", ""), "capa: texto", 60),
# Capa também nos 2 primeiros quadros do vídeo: as redes usam o quadro 0 como miniatura padrão.
"atStart": bool(cov.get("atStart", False))}
# Chat da live na tela: as últimas mensagens num bloco, na posição escolhida (x = borda esquerda, y = base).
ch = data.get("chat") or {}
if not isinstance(ch, dict):
raise EditError("chat precisa ser objeto")
chat = {"enabled": bool(ch.get("enabled", False)),
"x": _num(ch.get("x", 0.04), "chat: x", 0, 0.9), "y": _num(ch.get("y", 0.62), "chat: y", 0.1, 0.98),
"width": _num(ch.get("width", 0.6), "chat: largura", 0.25, 0.96),
"lines": int(_num(ch.get("lines", 5), "chat: linhas", 1, 10)),
"size": int(_num(ch.get("size", 34), "chat: tamanho", 18, 64)),
"showUser": bool(ch.get("showUser", True))}
raw_meta = data.get("meta") or {}
if not isinstance(raw_meta, dict):
raise EditError("meta precisa ser objeto")
origin = raw_meta.get("origin", "user")
if origin not in ("ai", "user"):
raise EditError("meta.origin precisa ser ai ou user")
meta = {"origin": origin, "generatedAt": _text(raw_meta.get("generatedAt", ""), "meta.generatedAt", 40),
"model": _text(raw_meta.get("model") or "", "meta.model", 80),
"steps": [_text(x, "meta.steps", 200) for x in _list(raw_meta.get("steps"), "meta.steps", 12)]}
project = {"schema": SCHEMA_VERSION, "source": {"sessionId": session_id, "lo": lo, "hi": hi}, "settings": own_settings,
"cuts": cuts, "captions": captions, "overlays": overlays, "progress": progress, "audio": audio,
"cover": cover, "chat": chat, "meta": meta}
# Reenquadramento do jogo no tempo: só entra no projeto quando há keys (projeto antigo continua igual).
keys = _reframe_keys(data.get("reframe"), lo, hi)
if keys:
project["reframe"] = {"keys": keys}
return project
def _keys(raw, name: str, lo: float, hi: float, fields: dict[str, tuple[float, float]]) -> list[dict]:
"""Keyframes {t (tempo da sessão), campos..., ease}: validados, ordenados, no máximo `reframe.MAX_KEYS`."""
out = []
for i, k in enumerate(_list(raw, name, reframe.MAX_KEYS)):
if not isinstance(k, dict):
raise EditError(f"{name}[{i}] precisa ser objeto")
item = {"t": _num(k.get("t"), f"{name}[{i}].t", lo, hi)}
for field, (a, b) in fields.items():
item[field] = _num(k.get(field), f"{name}[{i}].{field}", a, b)
ease = k.get("ease", "smooth")
if ease not in reframe.EASES:
raise EditError(f"{name}[{i}].ease precisa ser um de {', '.join(reframe.EASES)}")
item["ease"] = ease
out.append(item)
out.sort(key=lambda k: k["t"])
for a, b in zip(out, out[1:]):
if b["t"] - a["t"] < 0.02:
raise EditError(f"{name}: dois keyframes no mesmo instante ({a['t']:g} s)")
return out
def _reframe_keys(raw, lo: float, hi: float) -> list[dict]:
if raw in (None, {}):
return []
if not isinstance(raw, dict):
raise EditError("reframe precisa ser objeto {keys: [...]}")
return _keys(raw.get("keys"), "reframe.keys", lo, hi, {"cx": (0, 1), "cy": (0, 1), "w": (0.05, 1)})
def _inset(o: dict, i: int, lo: float, hi: float) -> dict:
"""Camada inserida: recorte `src` do quadro original posto em (x, y) com largura `size` da tela."""
name = f"overlays[{i}]"
try:
src = layout._rect(o.get("src"), f"{name}.src")
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(str(exc)) from exc
if src is None:
raise EditError(f"{name}.src precisa ser {{x, y, w, h}} (recorte do quadro original)")
border = o.get("border")
anim = o.get("anim", "pop")
if anim not in reframe.INSET_ANIMS:
raise EditError(f"{name}.anim precisa ser um de {', '.join(reframe.INSET_ANIMS)}")
return {"src": src, "x": _num(o.get("x", 0.5), f"{name}.x", 0, 1), "y": _num(o.get("y", 0.5), f"{name}.y", 0, 1),
"size": _num(o.get("size", 0.45), f"{name}.size", 0.1, 1),
"border": None if border in (None, "") else _hex(border, f"{name}.border"),
"borderW": int(_num(o.get("borderW", 6), f"{name}.borderW", 0, 40)),
"radius": int(_num(o.get("radius", 18), f"{name}.radius", 0, 200)),
"shadow": bool(o.get("shadow", True)), "anim": anim,
"keys": _keys(o.get("keys"), f"{name}.keys", lo, hi, {"x": (0, 1), "y": (0, 1), "size": (0.1, 1)})}
def effective_settings(base: dict, project: dict) -> dict:
"""Configuração do corte do render: padrão ← canal ← sessão ← projeto, mais o preset e o estilo da legenda."""
cfg = layout.merge(base, project.get("settings") or {})
cap = project["captions"]
cfg["caption"].update(PRESET_STYLE.get(cap["preset"], {}))
cfg["caption"].update(cap.get("style") or {})
cfg["caption"]["enabled"] = cap["enabled"]
return cfg
def retime(project: dict, start: float, end: float) -> dict:
"""O cartão do corte mudou início/fim (−30 s, +2 s…): estica/encolhe as pontas do projeto, mantém o meio."""
p = copy.deepcopy(project)
cuts = p["cuts"]
cuts[0]["start"] = min(start, cuts[0]["end"] - MIN_CUT_S)
cuts[-1]["end"] = max(end, cuts[-1]["start"] + MIN_CUT_S)
p["source"]["lo"] = min(p["source"]["lo"], cuts[0]["start"])
p["source"]["hi"] = max(p["source"]["hi"], cuts[-1]["end"])
return p
def span(project: dict) -> tuple[float, float]:
return project["cuts"][0]["start"], project["cuts"][-1]["end"]
# ---------------------------------------------------------------- IA sugere
SUGGEST_SYSTEM = """Você é EDITOR de cortes de lives de jogos em português do Brasil — verticais (Shorts/TikTok/Reels)
ou horizontais (YouTube, tela cheia do jogo), conforme o formato informado.
Recebe a transcrição palavra a palavra com tempos, o chat e a análise do momento. Devolva:
- hook: texto curto de gancho para os 2 primeiros segundos (até 8 palavras, sem hashtag, fiel ao que acontece);
- title: título do vídeo (até 70 caracteres, gancho + palavra de busca);
- start_s/end_s: início ideal (onde a AÇÃO começa, sem enrolação) e fim (depois da reação/pagamento);
- remove: trechos mortos DENTRO de [start_s, end_s] para cortar (silêncio longo, enrolação, fala sem relação),
sem quebrar o contexto nem cortar no meio de frase. Pode ser vazio;
- zooms: instantes de reação forte para um punch-in curto (0 a 3);
- reason: por que, em uma frase.
Tempos sempre em segundos da gravação (os mesmos da transcrição). Nunca invente o que não está na fala/chat/análise."""
SUGGEST_SCHEMA = {
"type": "object", "additionalProperties": False,
"required": ["hook", "title", "start_s", "end_s", "remove", "zooms", "reason"],
"properties": {
"hook": {"type": "string"}, "title": {"type": "string"},
"start_s": {"type": "number"}, "end_s": {"type": "number"},
"remove": {"type": "array", "items": {"type": "object", "additionalProperties": False,
"required": ["start_s", "end_s", "why"],
"properties": {"start_s": {"type": "number"}, "end_s": {"type": "number"},
"why": {"type": "string"}}}},
"zooms": {"type": "array", "items": {"type": "object", "additionalProperties": False, "required": ["t", "why"],
"properties": {"t": {"type": "number"}, "why": {"type": "string"}}}},
"reason": {"type": "string"},
},
}
def suggest_prompt(streamer: str, title: str, project: dict, chat: list[ChatMessage], analysis: dict | None,
transcript: str, chat_block: str, cfg: dict | None = None) -> str:
"""`cfg` = configuração efetiva do corte (duração e formato); sem ela, os padrões de `layout.DEFAULTS`."""
cfg = cfg or layout.merge()
lo, hi = project["source"]["lo"], project["source"]["hi"]
a, b = span(project)
dur = cfg["duration"]
fmt = "horizontal 16:9 (YouTube)" if layout.aspect(cfg) == "horizontal" else "vertical 9:16 (Shorts/TikTok/Reels)"
return (f"Canal: {streamer}\nTítulo atual do corte: {title or '(nenhum)'}\nFormato: {fmt}\n"
f"Janela disponível da gravação: {lo:.0f}s a {hi:.0f}s. Corte atual: {a:.0f}s a {b:.0f}s "
f"({output_duration(project['cuts']):.0f} s depois dos cortes internos).\n"
f"Duração final ideal: {dur['minS']:.0f} a {dur['maxS']:.0f} s.\n\n"
f"Transcrição (segundos da gravação):\n{transcript}\n\n{chat_block}\n\n"
+ (f"Análise do momento (1º juiz): {analysis}\n" if analysis else ""))
def clean_suggestion(data: dict, lo: float, hi: float, min_len: float = MIN_OUTPUT_S,
max_len: float = MAX_OUTPUT_S) -> dict:
"""Prende tudo dentro da janela e nos limites (a IA pode errar números). `min_len`/`max_len` = duração final do
corte (o editor passa mínimo + 1 s e máximo da configuração); os trechos a remover que levariam o corte abaixo do
mínimo ficam de fora."""
start, end = fit_window(float(data.get("start_s", lo)), float(data.get("end_s", hi)), lo, hi,
max(MIN_OUTPUT_S, min_len), max_len, keep="start")
remove = []
for r in (data.get("remove") or [])[:10]:
try:
a, b = max(float(r["start_s"]), start), min(float(r["end_s"]), end)
except (KeyError, TypeError, ValueError):
continue
if b - a >= 0.4 and (end - start) - sum(x["end"] - x["start"] for x in remove) - (b - a) >= min_len:
remove.append({"start": round(a, 2), "end": round(b, 2), "why": str(r.get("why", ""))[:160]})
zooms = []
for z in (data.get("zooms") or [])[:3]:
try:
t = float(z["t"])
except (KeyError, TypeError, ValueError):
continue
if start <= t <= end:
zooms.append({"t": round(t, 2), "why": str(z.get("why", ""))[:160]})
return {"hook": str(data.get("hook", "")).strip()[:80], "title": str(data.get("title", "")).strip()[:100],
"start": round(start, 2), "end": round(end, 2), "remove": remove, "zooms": zooms,
"reason": str(data.get("reason", ""))[:300]}
+465
View File
@@ -0,0 +1,465 @@
"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`)
e o render do projeto chamado pela fila do motor (worker.render_clip).
O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o
`rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do
editor em `output/clipper/<sessão>/edit-<corte>/` (proxy 480p, forma de onda, narração TTS, prévia real).
"""
from __future__ import annotations
import hashlib
import json
import logging
import threading
import time
import uuid
from pathlib import Path
import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from . import editor, editor_render, layout, media
from .config import REPO_ROOT
from .db import loads, now
from .judge import JudgeError, _chat_block, _transcript
from .scoring import Word
log = logging.getLogger("cenaforge_clipper.editor")
PREVIEW_MAX_S = 10.0
RETRANSCRIBE_MAX_S = 90.0
_locks: dict[str, threading.Lock] = {}
_locks_guard = threading.Lock()
def _lock(key: str) -> threading.Lock:
with _locks_guard:
return _locks.setdefault(key, threading.Lock())
class EditPut(BaseModel):
project: dict
rev: int = Field(default=0, ge=0)
class WindowIn(BaseModel):
lo: float = Field(ge=0)
hi: float = Field(ge=0)
class PreviewRenderIn(BaseModel):
fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S)
durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S)
project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo
class RangeIn(BaseModel):
startS: float = Field(ge=0)
endS: float = Field(ge=0)
class TtsIn(BaseModel):
text: str = Field(min_length=1, max_length=300)
voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$")
speed: float = Field(default=1.0, ge=0.5, le=2.0)
class SuggestIn(BaseModel):
project: dict | None = None
# ---------------------------------------------------------------- utilidades (também usadas pelo worker)
def edit_dir(engine, session_id: int, clip_id: int) -> Path:
return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}"
def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]:
return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)]
def validate_for(engine, clip: dict, session: dict, data: dict) -> dict:
return editor.validate_project(
data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT,
tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets")
def load_edit(engine, clip_id: int) -> dict | None:
row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id)
if row:
row["project"] = loads(row["project_json"], None)
return row
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
project = validate_for(engine, clip, session, edit["project"])
segments = session_segments(engine, clip["session_id"])
if engine._encoder is None:
engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder)
base = engine.intel.settings_for(session)
credit = engine.channel_label(session)
ffmpeg = engine.settings.ffmpeg or "ffmpeg"
# A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4.
cover: Path | None = None
if project["cover"]["enabled"]:
cover = out.parent / f"{out.stem}-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
cover = None
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover)
total = editor.output_duration(project["cuts"])
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"])
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
def chat_for(engine, project: dict) -> list | None:
"""Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede)."""
if not (project.get("chat") or {}).get("enabled"):
return None
lo = project["source"]["lo"]
return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"]
def _judge(clip: dict) -> dict:
data = loads(clip.get("judge_json"), None)
return data if isinstance(data, dict) else {}
def auto_for(engine, clip: dict, session: dict) -> dict:
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
judge = _judge(clip)
lo, hi = editor.default_window(clip, session["duration_s"])
rows = engine.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
clip["session_id"], lo, hi)
words = [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], [])]
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
def ensure_edit(engine, clip: dict, session: dict) -> dict:
"""Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um
agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto."""
row = load_edit(engine, clip["id"])
if row and row["project"]:
return row
project = validate_for(engine, clip, session, auto_for(engine, clip, session))
raw = json.dumps(project, ensure_ascii=False)
ts = now()
engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts)
start, end = editor.span(project)
engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"])
return load_edit(engine, clip["id"])
def retime_edit(engine, clip_id: int, start: float, end: float) -> None:
"""O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto."""
row = load_edit(engine, clip_id)
if not row or not row["project"]:
return
project = editor.retime(row["project"], start, end)
engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), now(), clip_id)
def _audio_library() -> list[dict]:
root = REPO_ROOT / "assets"
out = []
if root.is_dir():
for f in sorted(root.rglob("*")):
if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT:
out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem})
if len(out) >= 200:
break
return out
def _window_key(lo: float, hi: float) -> str:
return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}"
def _clean_old(folder: Path, prefix: str, keep: str) -> None:
for f in folder.glob(f"{prefix}-*"):
if f.name != keep:
f.unlink(missing_ok=True)
# ---------------------------------------------------------------- rotas
def register(app: FastAPI, engine, clip_view, get_clip) -> None:
"""`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir)."""
db, settings = engine.db, engine.settings
ffmpeg = settings.ffmpeg or "ffmpeg"
@app.exception_handler(editor.EditError)
async def edit_error(_request: Request, exc: editor.EditError):
return JSONResponse({"error": str(exc)}, status_code=400)
@app.exception_handler(media.MediaError)
async def media_error(_request: Request, exc: media.MediaError):
return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400)
def _context(clip_id: int) -> tuple[dict, dict]:
clip = get_clip(clip_id)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session:
raise editor.EditError("sessão do corte não existe mais")
return clip, session
def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]:
lo, hi = max(0.0, lo), min(hi, session["duration_s"])
if not 5 <= hi - lo <= editor.MAX_WINDOW_S:
raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação")
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi)
if not segs:
raise editor.EditError("não há gravação nessa janela")
if any(s["deleted"] for s in segs):
raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor")
return round(lo, 3), round(hi, 3)
def _words(session_id: int, lo: float, hi: float) -> list[Word]:
rows = db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
session_id, lo, hi)
return [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], []) if lo <= a <= hi]
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None
def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json"
return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None
@app.get("/v1/clips/{clip_id}/edit")
def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None):
"""Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA,
configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
view = clip_view(clip)
if row and row["project"]:
project, rev = row["project"], row["rev"]
ai_project = loads(row.get("ai_project_json"), None)
else:
project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo)
rev = 0
w_lo = project["source"]["lo"] if lo is None else lo
w_hi = project["source"]["hi"] if hi is None else hi
w_lo, w_hi = _check_window(session, w_lo, w_hi)
tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5))
chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)}
for m in tl["chat"] if w_lo <= m.t <= w_hi][:600]
per_s = [0] * int(w_hi - w_lo + 1)
for m in tl["chat"]:
if w_lo <= m.t <= w_hi:
per_s[int(m.t - w_lo)] += 1
loud = tl["loudness"][int(w_lo): int(w_hi) + 1]
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
return {
"clip": view, "project": project, "rev": rev, "saved": bool(row),
"origin": row["origin"] if row else "ai", "aiProject": ai_project,
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in _words(clip["session_id"], w_lo, w_hi)],
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
"audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi),
"waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S,
"judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured,
"limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S,
"previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S},
}
@app.put("/v1/clips/{clip_id}/edit")
def put_edit(clip_id: int, body: EditPut):
"""Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes)."""
clip, session = _context(clip_id)
project = validate_for(engine, clip, session, body.project)
ts = now()
with db.lock:
row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)
if row and body.rev != row["rev"]:
return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]},
status_code=409)
if row:
db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), ts, clip_id)
else:
ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False)
db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts)
rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"]
return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])}
@app.delete("/v1/clips/{clip_id}/edit", status_code=204)
def delete_edit(clip_id: int):
"""Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render)."""
get_clip(clip_id)
db.run("DELETE FROM edits WHERE clip_id = ?", clip_id)
@app.post("/v1/clips/{clip_id}/proxy")
def make_proxy(clip_id: int, body: WindowIn):
"""Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela."""
clip, session = _context(clip_id)
lo, hi = _check_window(session, body.lo, body.hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"proxy-{_window_key(lo, hi)}.mp4"
with _lock(f"proxy-{clip_id}"):
if not (folder / name).is_file():
t = time.monotonic()
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
_clean_old(folder, "proxy", name)
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word}
for w in _words(clip["session_id"], lo, hi)]}
@app.get("/v1/clips/{clip_id}/waveform")
def get_waveform(clip_id: int, lo: float, hi: float):
clip, session = _context(clip_id)
lo, hi = _check_window(session, lo, hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"waveform-{_window_key(lo, hi)}.json"
with _lock(f"wave-{clip_id}"):
peaks = _cached_wave(clip, lo, hi)
if peaks is None:
peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder)
folder.mkdir(parents=True, exist_ok=True)
(folder / name).write_text(json.dumps(peaks), encoding="utf-8")
_clean_old(folder, "waveform", name)
return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks}
@app.post("/v1/clips/{clip_id}/preview-render")
def preview_render(clip_id: int, body: PreviewRenderIn):
"""Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None)
if not data:
raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)")
project = validate_for(engine, clip, session, data)
total = editor.output_duration(project["cuts"])
a = min(body.fromS, max(0.0, total - 1))
b = min(total, a + body.durationS)
out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4"
segments = session_segments(engine, clip["session_id"])
base, credit = engine.intel.settings_for(session), engine.channel_label(session)
with _lock(f"preview-{clip_id}"):
t = time.monotonic()
# Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export.
cover = None
if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"):
cover = out.parent / "preview-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela
log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc)
cover = None
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
segments, project, base, credit, out, REPO_ROOT,
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover)
took = time.monotonic() - t
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
@app.post("/v1/clips/{clip_id}/export")
def export(clip_id: int):
"""Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
if not row or not row["project"]:
raise editor.EditError("nada para exportar: salve o projeto primeiro")
project = validate_for(engine, clip, session, row["project"])
start, end = editor.span(project)
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end)
if not segs or any(s["deleted"] for s in segs):
raise editor.EditError("os blocos gravados deste trecho já foram apagados")
words = editor.output_words(project)
ts = now()
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
engine.wake_clips.set()
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
@app.post("/v1/clips/{clip_id}/retranscribe")
def retranscribe(clip_id: int, body: RangeIn):
"""Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão."""
clip, session = _context(clip_id)
a, b = body.startS, min(body.endS, session["duration_s"])
if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S:
raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s")
if not engine.voice.configured:
raise editor.EditError("serviço de voz não instalado")
wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b,
edit_dir(engine, clip["session_id"], clip_id))
t = time.monotonic()
try:
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
"words": [{"s": round(w.start + a, 3), "e": round(w.end + a, 3), "w": w.word} for w in words]}
@app.post("/v1/clips/{clip_id}/tts")
def tts(clip_id: int, body: TtsIn):
"""Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-<corte>/tts-<hash>.wav."""
clip, _session = _context(clip_id)
voice = engine.voice
if not voice.configured:
raise editor.EditError("serviço de voz não instalado")
text = editor.CONTROL_RE.sub(" ", body.text).strip()
digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12]
folder = edit_dir(engine, clip["session_id"], clip_id)
out = folder / f"tts-{digest}.wav"
if not out.is_file():
try:
response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""},
json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice,
"params": {"speed": body.speed, "format": "wav"}})
except httpx.HTTPError as exc:
raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc
if response.status_code != 200:
try:
detail = response.json().get("error") or response.json().get("detail") or response.text
except ValueError:
detail = response.text
raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}")
folder.mkdir(parents=True, exist_ok=True)
out.write_bytes(response.content)
duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0
return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice}
@app.post("/v1/clips/{clip_id}/suggest")
def suggest(clip_id: int, body: SuggestIn):
"""IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom."""
clip, session = _context(clip_id)
if not engine.judge.enabled:
raise editor.EditError("IA desligada (página Clipador → Juiz)")
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None) or editor.default_project(
clip, [], session["duration_s"])
project = validate_for(engine, clip, session, data)
lo, hi = project["source"]["lo"], project["source"]["hi"]
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
words = [Word(w["s"], w["e"], w["w"]) for w in project["captions"]["words"]] or tl["words"]
view = clip_view(clip)
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
cfg = editor.effective_settings(engine.intel.settings_for(session), project)
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
_transcript(words, lo, hi), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
t = time.monotonic()
try:
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
except JudgeError as exc:
raise editor.EditError(f"IA: {exc}") from exc
# Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte.
return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1),
"model": engine.judge.describe().get("model")}
+721
View File
@@ -0,0 +1,721 @@
"""Render do projeto de edição (editor.py) com FFmpeg: legenda animada e textos em ASS, filtergraph com trechos,
layout por trecho, zoom (punch-in), narração/música/efeitos, proxy 480p, forma de onda e capa.
Regras herdadas do Clipador (gotchas 57/58/71): `-ss` ANTES do `-i`; maiúsculas só no texto (nunca nas tags);
cores `&H00BBGGRR&` na linha Style e `&HBBGGRR&` nas tags. Formato: o vídeo sai em `layout.frame_size` (1080×1920
ou 1920×1080) e os textos são contados no quadro lógico `layout.canvas_size` (no horizontal, 2560×1440). Subprocesso sem shell, argumentos em lista; no filtro
só entram números formatados aqui e nomes de arquivo relativos gerados por nós.
"""
from __future__ import annotations
import shutil
from array import array
from pathlib import Path
from . import layout, media, reframe
from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output
from .scoring import Word
from .subtitles import _escape, _ts, caption_blocks, clean_words
W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração
FPS = 30
PEAKS_PER_S = 50
COVER_BOX = "#E11D48" # mesma cor da caixa do gancho padrão
# ---------------------------------------------------------------- ASS (legenda animada + textos + barra)
def _wrap(text: str, size: int, width: int = W - 120) -> str:
"""Quebra manual (o cabeçalho usa WrapStyle 2 = sem quebra automática). Escapa cada pedaço."""
max_chars = max(6, int(width / (size * 0.58)))
lines, line = [], ""
for word in text.split():
if line and len(line) + 1 + len(word) > max_chars:
lines.append(line)
line = word
else:
line = f"{line} {word}".strip()
if line:
lines.append(line)
return "\\N".join(_escape(x) for x in lines[:4])
BANNER_MAX_LINES = 2
BANNER_SLIDE_MS = 240 # a tarja atravessa a tela
TEXT_SLIDE_MS = (90, 430) # o texto entra deslizando, borrado, e assenta nítido nesse intervalo
def _lines(text: str, size: int, width: int, char_w: float = 0.6) -> list[str]:
"""Quebra em linhas pela largura estimada (nunca no meio da palavra)."""
max_chars = max(4, int(width / (size * char_w)))
lines, line = [], ""
for word in text.split():
if line and len(line) + 1 + len(word) > max_chars:
lines.append(line)
line = word
else:
line = f"{line} {word}".strip()
if line:
lines.append(line)
return lines
def banner_layout(o: dict, canvas: tuple[int, int]) -> dict:
"""Geometria da tarja do gancho no quadro lógico: linhas (no máximo 2, sem cortar palavra: a fonte diminui até
caber), tamanho, topo e altura da faixa."""
cw, ch = canvas
text = o["text"].upper()
size = int(o["size"])
lines = _lines(text, size, int(cw * 0.9))
while len(lines) > BANNER_MAX_LINES and size > 24:
size = max(24, int(size * 0.9))
lines = _lines(text, size, int(cw * 0.9))
line_h = size * 1.18
pad = size * 0.42
height = int(round(len(lines) * line_h + 2 * pad))
cy = int(ch * o["y"])
top = max(0, min(ch - height, cy - height // 2))
return {"lines": lines, "size": size, "top": top, "height": height, "cy": top + height // 2}
def banner_events(o: dict, canvas: tuple[int, int]) -> list[tuple[int, str, str, tuple[float, float | None] | None]]:
"""Gancho em TARJA (referência do dono, 17/11/2026): faixa na largura toda, na cor `bg`, que atravessa a tela, e o
texto em maiúsculas (cor `color`, contorno preto grosso, fonte `font`) que entra deslizando com desfoque de
movimento e assenta nítido. Tudo em ASS (desenho \\p1, \\move e \\t com \\blur): sem filtro extra no FFmpeg.
Com contorno, o \\blur do libass desfoca só a borda e o preenchimento fica nítido (achado ao comparar com o modelo
do dono). Por isso, na ENTRADA (`slide`, até 430 ms) o texto vem em duas camadas: o preenchimento sem contorno, com
o desfoque animado, e o contorno, também borrado, que aparece junto. Do fim da entrada em diante entra o MESMO
evento assentado de antes (posição, quebra, tamanho, contorno), para a prévia do editor continuar batendo.
Devolve [(camada, estilo, texto ASS, janela)]; janela = None (o tempo todo do gancho) ou (início, fim) em segundos
relativos ao início do gancho (fim None = até o fim)."""
cw, _ = canvas
g = banner_layout(o, canvas)
bg = layout.ass_inline_color(o.get("bg") or layout.DEFAULTS["hook"]["bg"])
color = layout.ass_inline_color(o.get("color") or "#FFFFFF")
font = o.get("font") or layout.HOOK_FONT
slide = o.get("anim") == "slide"
out_fade = "\\fad(0,180)"
band_pos = (f"\\move({-cw},{g['top']},0,{g['top']},0,{BANNER_SLIDE_MS})" if slide else f"\\pos(0,{g['top']})")
band_anim = out_fade if slide else _anim(o.get("anim", "none")).replace("\\fscx70\\fscy70", "")
band = (f"{{\\an7{band_pos}\\p1\\bord0\\shad0\\1c{bg}{band_anim}}}"
f"m 0 0 l {cw} 0 {cw} {g['height']} 0 {g['height']}{{\\p0}}")
cx = cw // 2
a, b = TEXT_SLIDE_MS
border = max(3, int(round(g["size"] * 0.1)))
lines = "\\N".join(_escape(x) for x in g["lines"])
look = f"\\fn{font}\\fs{g['size']}\\1c{color}\\3c&H000000&\\4c&H000000&"
settled_tags = f"\\bord{border}\\shad{max(2, border // 2)}"
if not slide:
text = f"{{\\an5\\pos({cx},{g['cy']}){_anim(o.get('anim', 'none'))}{look}{settled_tags}}}{lines}"
return [(2, "Bar", band, None), (4, "Text", text, None)]
move = f"\\move({cx + int(cw * 0.55)},{g['cy']},{cx},{g['cy']},{a},{b})"
entry = (0.0, b / 1000)
# Preenchimento sem contorno: o desfoque pega a letra inteira (como no modelo).
fill = f"{{\\an5{move}\\blur18\\t({a},{b},\\blur0){look}\\bord0\\shad0}}{lines}"
# Contorno (e sombra) sem preenchimento, borrado e surgindo junto; por baixo do preenchimento.
outline = (f"{{\\an5{move}\\1a&HFF&\\3a&HC0&\\4a&HFF&\\blur18\\t({a},{b},\\blur0\\3a&H00&\\4a&H00&)"
f"{look}{settled_tags}}}{lines}")
# Assentado: o mesmo evento de antes, parado na posição final (a saída com \\fad continua no fim do gancho).
settled = f"{{\\an5\\pos({cx},{g['cy']}){out_fade}{look}{settled_tags}}}{lines}"
return [(2, "Bar", band, None), (5, "Text", fill, entry), (4, "Text", outline, entry), (4, "Text", settled, (b / 1000, None))]
def _anim(kind: str) -> str:
if kind == "pop":
return "\\fad(80,120)\\fscx70\\fscy70\\t(0,140,\\fscx108\\fscy108)\\t(140,220,\\fscx100\\fscy100)"
if kind == "fade":
return "\\fad(250,250)"
if kind == "slide":
return "\\blur14\\t(0,320,\\blur0)\\fad(0,180)"
return ""
CHAT_HOLD_S = 9.0 # quanto uma mensagem fica na tela se não chegar outra
CHAT_COLORS = ("#FF7A7A", "#7AD7FF", "#9BE77A", "#FFD36B", "#C9A2FF", "#FF9FD6")
def chat_events(project: dict, chat: list | None, total: float,
canvas: tuple[int, int] = (W, H)) -> list[tuple[float, float, str]]:
"""Chat da live na tela: (início, fim, texto ASS) em tempo de saída. A cada mensagem nova o bloco mostra as
últimas `lines` (uma linha por mensagem, cortada na largura do bloco), ancorado pela base em (x, y).
`canvas` = quadro lógico do ASS (largura, altura)."""
cw, ch = canvas
cfg = project.get("chat") or {}
if not cfg.get("enabled") or not chat:
return []
cuts = project["cuts"]
msgs = []
for m in chat:
t_out, inside = to_output(m.t, cuts)
if inside and m.text.strip():
msgs.append((t_out, m.user, " ".join(m.text.split())))
msgs.sort(key=lambda x: x[0])
max_chars = max(8, int(cw * cfg["width"] / (cfg["size"] * 0.54)))
pos = f"\\an1\\pos({int(cw * cfg['x'])},{int(ch * cfg['y'])})"
def line(user: str, text: str) -> str:
name = user[:16] if cfg["showUser"] and user else ""
room = max_chars - (len(name) + 2 if name else 0)
body = text if len(text) <= room else text[: max(1, room - 1)].rstrip() + "…"
if not name:
return _escape(body)
color = layout.ass_inline_color(CHAT_COLORS[sum(map(ord, user)) % len(CHAT_COLORS)])
return f"{{\\1c{color}}}{_escape(name)}:{{\\1c&HFFFFFF&}} {_escape(body)}"
out = []
for i, (t, _user, _text) in enumerate(msgs):
nxt = msgs[i + 1][0] if i + 1 < len(msgs) else total
end = min(total, nxt, t + CHAT_HOLD_S)
if end - t < 0.03:
continue
shown = [m for m in msgs[max(0, i - cfg["lines"] + 1): i + 1] if t - m[0] <= CHAT_HOLD_S * 2]
out.append((t, end, f"{{{pos}}}" + "\\N".join(line(u, x) for _, u, x in shown)))
return out
def build_project_ass(project: dict, cfg: dict, credit: str, t0: float = 0.0, t1: float | None = None,
chat: list | None = None) -> str:
"""ASS do projeto em tempo de saída. [t0, t1] recorta a janela (prévia real de poucos segundos).
`chat` = mensagens da sessão (ChatMessage) para o bloco de chat na tela, se o projeto pedir."""
cap, cred = cfg["caption"], cfg["credit"]
total = output_duration(project["cuts"])
t1 = total if t1 is None else min(t1, total)
length = t1 - t0
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
cw, ch = layout.canvas_size(cfg)
font, size, ow = cap["font"], cap["size"], cap["outlineWidth"]
header = f"""[Script Info]
ScriptType: v4.00+
PlayResX: {cw}
PlayResY: {ch}
WrapStyle: 2
ScaledBorderAndShadow: yes
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Caption,{font},{size},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
Style: Karaoke,{font},{size},{high},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
Style: Text,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,2,5,60,60,0,1
Style: Box,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H004D1DE1,&H00000000,-1,0,0,0,100,100,0,0,3,18,0,5,60,60,0,1
Style: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1
Style: Chat,Arial,{(project.get('chat') or {}).get('size', 34)},&H00FFFFFF,&H00FFFFFF,&H78000000,&H00000000,-1,0,0,0,100,100,0,0,3,5,0,1,0,0,0,1
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""
lines: list[str] = []
def event(layer: int, s: float, e: float, style: str, text: str) -> None:
s, e = max(s, t0) - t0, min(e, t1) - t0
if e - s > 0.01:
lines.append(f"Dialogue: {layer},{_ts(s)},{_ts(e)},{style},,0,0,0,,{text}")
if credit and cred["enabled"]:
event(1, 0, total, "Credit", _escape(credit))
if cap["enabled"]:
preset = project["captions"]["preset"]
emph = emphasized(project)
emph_c = layout.ass_inline_color(project["captions"]["emphColor"])
hi_c, base_c = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
pos = f"\\pos({cw // 2},{layout.caption_y(cfg)})"
# Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos
# ORIGINAIS. Depois as palavras são saneadas (ordem, sem sobreposição, duração mínima) — `clean_words` devolve
# a mesma quantidade, na mesma ordem — e os blocos abaixo nunca ficam dois na tela ao mesmo tempo.
raw = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end))
raw_emph = _match_emphasis(raw, project, emph)
words = clean_words(raw)
def txt(w: Word) -> str:
return _escape(w.word.upper() if cap["uppercase"] else w.word)
def key(w: Word) -> tuple[float, str]:
return round(w.start, 3), w.word # depois de clean_words, cada início é único
emph_keys = {key(words[i]) for i in raw_emph}
for group, g_end in caption_blocks(words, cap["maxWords"]):
if preset == "karaoke":
parts, cursor = [], group[0].start
for w in group:
gap = max(0, int(round((w.start - cursor) * 100)))
dur = max(1, int(round((w.end - w.start) * 100)))
color = f"\\1c{emph_c}" if key(w) in emph_keys else ""
parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}")
cursor = w.end
event(0, group[0].start, g_end, "Karaoke", f"{{{pos}}}" + " ".join(parts))
continue
for i, word in enumerate(group):
start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start:
continue
if preset == "single":
color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_c)
event(0, start, end, "Caption", f"{{{pos}{_anim('pop')}\\c{color}}}{txt(word)}")
continue
parts = []
for j, w in enumerate(group):
is_emph = key(w) in emph_keys
if preset == "minimal":
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
elif j == i:
color = emph_c if is_emph else hi_c
pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else ""
parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_c}\\fscx100\\fscy100}}")
else:
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else ""
event(0, start, end, "Caption", f"{{{pos}{intro}}}" + " ".join(parts))
cuts = project["cuts"]
for o in project["overlays"]:
if o["kind"] in ("zoom", "inset"):
continue
if o["kind"] == "hook":
s, e = o["start"], min(o["end"], total)
else:
s, e = to_output(o["start"], cuts)[0], to_output(o["end"], cuts)[0]
if o.get("style") == "banner":
for layer, style, text, window in banner_events(o, (cw, ch)):
a0, b0 = (s, e) if window is None else (s + window[0], e if window[1] is None else min(e, s + window[1]))
event(layer, a0, b0, style, text)
continue
style = "Box" if o["box"] else "Text"
x, y = int(cw * o.get("x", 0.5)), int(ch * o["y"])
if o["anim"] == "slide": # entra deslizando da direita, borrado, e assenta nítido
a, b = TEXT_SLIDE_MS
pos = f"\\move({x + int(cw * 0.5)},{y},{x},{y},{a},{b})"
else:
pos = f"\\pos({x},{y})"
tags = f"{pos}\\fs{o['size']}\\1c{layout.ass_inline_color(o['color'])}"
if o.get("font"):
tags += f"\\fn{o['font']}"
if o["box"]:
tags += f"\\3c{layout.ass_inline_color(o['box'])}"
event(2, s, e, style, f"{{{tags}{_anim(o['anim'])}}}{_wrap(o['text'], o['size'], cw - 120)}")
for s, e, text in chat_events(project, chat, total, (cw, ch)):
event(2, s, e, "Chat", text)
prog = project["progress"]
if prog["enabled"] and total > 0:
h = prog["height"]
a, b = 100 * t0 / total, 100 * t1 / total
draw = f"m 0 0 l {cw} 0 {cw} {h} 0 {h}"
lines.append(f"Dialogue: 3,{_ts(0)},{_ts(length)},Bar,,0,0,0,,"
f"{{\\an7\\pos(0,{ch - h})\\p1\\1c{layout.ass_inline_color(prog['color'])}\\fscx{a:.2f}"
f"\\t(0,{int(length * 1000)},\\fscx{b:.2f})}}{draw}{{\\p0}}")
return header + "\n".join(lines) + "\n"
def _match_emphasis(words: list[Word], project: dict, emph: set[tuple[float, str]]) -> set[int]:
"""Índices (em `words`, tempo de saída) das palavras marcadas com ênfase no projeto (tempo da sessão)."""
if not emph:
return set()
marked = [w for w in project["captions"]["words"] if not w.get("hidden") and w["w"].strip()]
out_times = {}
for w in marked:
if (round(w["s"], 3), w["w"]) in emph:
out_times[(round(to_output((w["s"] + w["e"]) / 2, project["cuts"])[0], 2), w["w"])] = True
result = set()
for i, w in enumerate(words):
mid = round((w.start + w.end) / 2, 2)
if any(abs(mid - t) <= 0.06 and text == w.word for (t, text) in out_times):
result.add(i)
return result
# ---------------------------------------------------------------- filtergraph
def zoom_filter(project: dict, t0: float = 0.0, size: tuple[int, int] = (W, H)) -> str | None:
"""zoompan com escala por expressão do tempo de saída (`it` + t0). Rampa suave na entrada e na saída.
`size` = tamanho do vídeo de saída (formato do corte)."""
zooms = [o for o in project["overlays"] if o["kind"] == "zoom"]
if not zooms:
return None
cuts = project["cuts"]
z_terms, x_terms, y_terms = [], [], []
for z in zooms:
a, b = to_output(z["start"], cuts)[0], to_output(z["end"], cuts)[0]
if b - a < 0.1:
continue
r = max(0.001, min(z["ramp"], (b - a) / 2))
env = f"clip((T-{a:.3f})/{r:.3f},0,1)*clip(({b:.3f}-T)/{r:.3f},0,1)"
z_terms.append(f"{z['scale'] - 1:.4f}*{env}")
x_terms.append(f"{z['x'] - 0.5:.4f}*{env}")
y_terms.append(f"{z['y'] - 0.5:.4f}*{env}")
if not z_terms:
return None
t = f"(it+{t0:.3f})"
zexpr = ("1+" + "+".join(z_terms)).replace("T", t)
fx = ("0.5+" + "+".join(x_terms)).replace("T", t)
fy = ("0.5+" + "+".join(y_terms)).replace("T", t)
# x/y = canto do recorte; o foco (fx, fy) fica no centro do recorte, preso dentro do quadro.
return (f"zoompan=z='{zexpr}':x='max(0,min(iw-iw/zoom,iw*({fx})-iw/zoom/2))'"
f":y='max(0,min(ih-ih/zoom,ih*({fy})-ih/zoom/2))':d=1:s={size[0]}x{size[1]}:fps={FPS}")
class AudioInput:
"""Entrada de áudio extra (narração, música, efeito): arquivo + onde entra (tempo de saída) + volume."""
def __init__(self, file: Path, at: float, volume: float, kind: str, trim_start: float = 0.0, duck: float = 1.0,
length: float = 0.0):
self.file, self.at, self.volume, self.kind = file, at, volume, kind
self.trim_start, self.duck, self.length = trim_start, duck, length
COVER_INTRO_S = 2 / FPS # capa nos 2 primeiros quadros (as redes usam o quadro 0 como miniatura padrão)
def build_filter(project: dict, cfg: dict, ps: list[Piece], in0: float, ass_name: str | None, extras: list[AudioInput],
has_audio: bool = True, t0: float = 0.0, original_volume: float = 1.0, cover_input: int | None = None,
ass_text: str | None = None, insets: list | None = None,
inset_inputs: list[dict] | None = None) -> str:
"""filter_complex completo. Entrada 0 = blocos concatenados começando em `in0` (tempo da sessão); entradas 1..N
= `extras` na ordem; `cover_input` = índice da entrada com a imagem da capa (vai por cima dos 2 primeiros
quadros); `ass_text` = conteúdo do ASS (com fonte empacotada, o filtro ganha `fontsdir`). `insets` =
`reframe.InsetPlan` das camadas inseridas e `inset_inputs` = índices das entradas PNG de cada uma. O
reenquadramento (`project.reframe`) entra por trecho no layout. Sem os dois, o grafo é o mesmo de antes.
Saídas [v] e [a]."""
n = len(ps)
out_len = sum(p.length for p in ps)
g: list[str] = []
g.append(f"[0:v]split={n}" + "".join(f"[sv{i}]" for i in range(n)) if n > 1 else "[0:v]null[sv0]")
if has_audio:
g.append(f"[0:a]asplit={n}" + "".join(f"[sa{i}]" for i in range(n)) if n > 1 else "[0:a]anull[sa0]")
for i, p in enumerate(ps):
a, b = p.start - in0, p.end - in0
g.append(f"[sv{i}]trim=start={a:.3f}:end={b:.3f},setpts=PTS-STARTPTS,fps={FPS}[tv{i}]")
src = f"tv{i}"
if insets: # as camadas recortam o quadro ORIGINAL: uma cópia do trecho vai para elas
g.append(f"[tv{i}]split=2[tl{i}][tr{i}]")
src = f"tl{i}"
g.append(layout.layout_chain(cfg, src, f"pv{i}", ",setsar=1", suffix=f"_{i}", mode=p.mode,
reframe=reframe.piece_reframe(project, p.start, p.end)))
fade = min(0.02, p.length / 4)
if has_audio:
g.append(f"[sa{i}]atrim=start={a:.3f}:end={b:.3f},asetpts=PTS-STARTPTS,"
f"aformat=sample_rates=48000:channel_layouts=stereo,"
f"afade=t=in:d={fade:.3f},afade=t=out:st={max(0.0, p.length - fade):.3f}:d={fade:.3f}"
+ (",volume=0" if p.muted else "") + f"[pa{i}]")
else:
g.append(f"aevalsrc=0|0:s=48000:d={p.length:.3f},aformat=channel_layouts=stereo[pa{i}]")
g.append("".join(f"[pv{i}][pa{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=1[vcat][acat]")
fw, fh = layout.frame_size(cfg)
zoom = zoom_filter(project, t0, (fw, fh))
last = "[v]" if cover_input is None else "[vbase]"
head = "[vcat]"
if insets:
# Vídeo (com zoom) → camadas inseridas (na ordem do projeto) → texto (ASS) por cima de tudo.
g.append("".join(f"[tr{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=0[vraw]" if n > 1 else "[tr0]null[vraw]")
g.append(f"[vcat]{zoom or 'null'}[vzoom]")
g += reframe.inset_graph(insets, inset_inputs or [], "vzoom", "vraw", t0, (fw, fh), "vins")
head, zoom = "[vins]", None
vchain = head + (f"{zoom}," if zoom else "") + (f"{layout.ass_filter(ass_name, ass_text)}," if ass_name else "") + f"fps={FPS},format=yuv420p{last}"
g.append(vchain)
if cover_input is not None:
g.append(f"[{cover_input}:v]scale={fw}:{fh},setsar=1,format=yuv420p[cv]")
g.append(f"[vbase][cv]overlay=enable='lt(t,{COVER_INTRO_S:.4f})':eof_action=pass,format=yuv420p[v]")
# Áudio: original (com volume e abaixado sob a narração) + narração + efeitos; música por baixo com ducking.
narr = [(k, x) for k, x in enumerate(extras, start=1) if x.kind == "narration"]
vol_expr = f"{original_volume:.3f}"
for _, x in narr:
end = x.at + (x.length or 0)
if x.duck < 1 and x.length:
vol_expr = f"{vol_expr}*if(between(t,{x.at:.3f},{end:.3f}),{x.duck:.3f},1)"
g.append(f"[acat]volume='{vol_expr}':eval=frame[aorig]")
voice_labels = ["[aorig]"]
music_label = None
for k, x in enumerate(extras, start=1):
chain = f"[{k}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo"
if x.trim_start > 0:
chain += f",atrim=start={x.trim_start:.3f},asetpts=PTS-STARTPTS"
chain += f",volume={x.volume:.3f}"
if x.kind == "music":
g.append(chain + f",atrim=end={out_len:.3f}[m{k}]")
music_label = f"[m{k}]"
continue
delay = int(round(max(0.0, x.at) * 1000))
g.append(chain + f",adelay=delays={delay}:all=1[x{k}]")
voice_labels.append(f"[x{k}]")
if len(voice_labels) > 1:
g.append("".join(voice_labels) + f"amix=inputs={len(voice_labels)}:duration=first:normalize=0[voice]")
else:
g.append("[aorig]anull[voice]")
if music_label:
music = next(x for x in extras if x.kind == "music")
if music.duck < 1: # duck guardado como 0 = sem ducking; < 1 = abaixa sob a voz
g.append("[voice]asplit=2[voice1][side]")
g.append(f"{music_label}[side]sidechaincompress=threshold=0.03:ratio=8:attack=20:release=350[mduck]")
g.append("[voice1][mduck]amix=inputs=2:duration=first:normalize=0[a]")
else:
g.append(f"[voice]{music_label}amix=inputs=2:duration=first:normalize=0[a]")
else:
g.append("[voice]anull[a]")
return ";".join(g)
# ---------------------------------------------------------------- execução
def _segments_for(segments: list[tuple[Path, float, float]], a: float, b: float) -> list[tuple[Path, float, float]]:
return [s for s in segments if s[2] > a and s[1] < b]
# ---------------------------------------------------------------- blocos de resolução/codec diferentes
# Uma retomada pode gravar em outra qualidade (ou o streamer muda a resolução da fonte). Medido (17/11/2026, blocos
# reais 720p60 + 1080p60 do skipnho): o concat demuxer + filter_complex corta o VÍDEO na emenda, sem erro — corte de
# 35 s saiu com 20 s de vídeo (troca de tamanho: o FFmpeg reinicia o grafo) ou 15 s (H.264 → HEVC). Nesse caso (e só
# nele) os blocos do trecho viram um intermediário uniforme: maior tamanho do trecho, 30 qps, quadro-chave a cada
# 0,5 s. Trecho com blocos iguais (o normal) segue pelo caminho de sempre, idêntico.
_STREAM_CACHE: dict[tuple[str, int, int], tuple[str, int, int, bool] | None] = {}
def _stream_key(ffprobe: str, file: Path) -> tuple[str, int, int, bool] | None:
"""(codec, largura, altura, tem áudio) do bloco, em cache pelo arquivo (caminho, tamanho, data)."""
try:
st = file.stat()
except OSError:
return None
key = (str(file), st.st_size, int(st.st_mtime))
if key not in _STREAM_CACHE:
if len(_STREAM_CACHE) > 4000:
_STREAM_CACHE.clear()
try:
out = media.run([ffprobe, "-v", "error", "-show_entries", "stream=codec_type,codec_name,width,height",
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace")
except media.MediaError:
_STREAM_CACHE[key] = None
return None
video, audio = None, False
for line in out.splitlines():
parts = [x.strip() for x in line.split(",")]
if "video" in parts and video is None:
nums = [int(x) for x in parts if x.isdigit()]
codec = next((x for x in parts if x and not x.isdigit() and x != "video"), "")
video = (codec, nums[0], nums[1]) if len(nums) >= 2 else None
elif "audio" in parts:
audio = True
_STREAM_CACHE[key] = (*video, audio) if video else None
return _STREAM_CACHE[key]
def _ffprobe_near(ffmpeg: str) -> str | None:
"""ffprobe ao lado do ffmpeg (mesma instalação) ou no PATH."""
sibling = Path(ffmpeg).with_name("ffprobe" + Path(ffmpeg).suffix)
return str(sibling) if sibling.is_file() else shutil.which("ffprobe")
def uniform_segments(ffmpeg: str, ffprobe: str | None, segs: list[tuple[Path, float, float]], work: Path,
stem: str) -> tuple[list[tuple[Path, float, float]], Path | None]:
"""Blocos do trecho num formato só. Devolve (blocos, intermediário criado ou None); quem chama apaga o arquivo."""
if not ffprobe or len(segs) < 2:
return segs, None
keys = [_stream_key(ffprobe, f) for f, _, _ in segs]
if any(k is None for k in keys) or len({k[:3] for k in keys}) == 1: # type: ignore[index]
return segs, None
w, h = max(((k[1], k[2]) for k in keys), key=lambda size: size[1]) # type: ignore[index]
out = work / f"{stem}.uniform.mkv"
args: list[str] = [ffmpeg, "-y", "-v", "error"]
graph: list[str] = []
for i, ((file, a, b), k) in enumerate(zip(segs, keys)):
args += ["-i", str(file)]
graph.append(f"[{i}:v]scale={w}:{h}:force_original_aspect_ratio=decrease,pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,"
f"setsar=1,fps={FPS},format=yuv420p[v{i}]")
graph.append(f"[{i}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo[a{i}]" if k[3] # type: ignore[index]
else f"aevalsrc=0|0:s=48000:d={b - a:.3f}[a{i}]")
graph.append("".join(f"[v{i}][a{i}]" for i in range(len(segs))) + f"concat=n={len(segs)}:v=1:a=1[v][a]")
media.run([*args, "-filter_complex", ";".join(graph), "-map", "[v]", "-map", "[a]", "-c:v", "libx264",
"-preset", "ultrafast", "-crf", "14", "-g", "15", "-c:a", "aac", "-b:a", "256k", str(out)], timeout=900)
return [(out, segs[0][1], segs[-1][2])], out
def _concat_input(work: Path, stem: str, segs: list[tuple[Path, float, float]], start: float, length: float) -> tuple[list[str], Path]:
concat = work / f"{stem}.concat.txt"
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _, _ in segs), encoding="utf-8")
offset = max(0.0, start - segs[0][1])
# -ss ANTES do -i (gotcha 57): os quadros chegam ao filtro com tempo 0 = `start`.
return ["-ss", f"{offset:.3f}", "-f", "concat", "-safe", "0", "-i", concat.name, "-t", f"{length:.3f}"], concat
def has_audio_stream(ffprobe: str | None, file: Path) -> bool:
if not ffprobe:
return True
try:
out = media.run([ffprobe, "-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0",
str(file)], 30)
except media.MediaError:
return True
return bool(out.strip())
def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segments: list[tuple[Path, float, float]],
project: dict, base_cfg: dict, credit: str, out_file: Path, repo_root: Path,
out_range: tuple[float, float] | None = None, timeout: float = 900, chat: list | None = None,
cover_file: Path | None = None) -> None:
"""Renderiza o projeto (ou só a saída [a, b] para a prévia real). `segments` = (arquivo, início, fim) da sessão.
`chat` = mensagens da sessão (para o chat na tela); `cover_file` = capa já renderizada, posta nos 2 primeiros
quadros quando o projeto pede (`cover.atStart`)."""
cfg = effective_settings(base_cfg, project)
total = output_duration(project["cuts"])
t0, t1 = out_range if out_range else (0.0, total)
ps = slice_pieces(project["cuts"], t0, t1) if out_range else pieces(project["cuts"])
if not ps:
raise media.MediaError("o trecho pedido está fora do corte")
in0, in1 = ps[0].start, ps[-1].end
segs = _segments_for(segments, in0, in1)
if not segs or segs[0][1] > in0 + 0.5 or segs[-1][2] < in1 - 0.5:
raise media.MediaError("os blocos gravados deste trecho não estão mais disponíveis")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
stem = out_file.stem
segs, uniform = uniform_segments(ffmpeg, ffprobe, segs, work, stem) # emenda de resolução/codec (retomada)
ass_file = work / f"{stem}.ass"
ass_text = build_project_ass(project, cfg, credit, t0, t1, chat)
ass_file.write_text(ass_text, encoding="utf-8")
input0, concat = _concat_input(work, stem, segs, in0, in1 - in0)
extras: list[AudioInput] = []
for n in project["audio"]["narration"]:
at = to_output(n["at"], project["cuts"])[0] - t0
if at + (n["durationS"] or 60) <= 0 or at >= t1 - t0:
continue
extras.append(AudioInput(repo_root / n["file"], max(0.0, at), n["volume"], "narration",
trim_start=max(0.0, -at), duck=n["duck"], length=n["durationS"]))
for x in project["audio"]["sfx"]:
at = to_output(x["at"], project["cuts"])[0] - t0
if 0 <= at < t1 - t0:
extras.append(AudioInput(repo_root / x["file"], at, x["volume"], "sfx"))
music = project["audio"]["music"]
if music:
extras.append(AudioInput(repo_root / music["file"], 0.0, music["volume"], "music", trim_start=t0,
duck=0.5 if music["duck"] else 1.0))
extra_args: list[str] = []
for x in extras:
extra_args += (["-stream_loop", "-1"] if x.kind == "music" else []) + ["-i", str(x.file)]
cover_input = None
if cover_file and cover_file.is_file() and project["cover"].get("atStart") and t0 <= 0.001:
cover_input = len(extras) + 1
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", "1", "-i", str(cover_file)]
# Camadas inseridas: tamanhos pela proporção do vídeo original e PNGs de máscara/borda/sombra, em loop.
plans, inset_inputs, helper_files = [], [], []
if any(o["kind"] == "inset" for o in project["overlays"]):
src_size = media.probe_size(ffprobe, segs[0][0]) if ffprobe else (1280, 720)
plans = reframe.plan_insets(project, lambda t: to_output(t, project["cuts"])[0], t0, t1,
layout.frame_size(cfg), layout.canvas_size(cfg)[0], src_size, work, stem)
next_input = len(extras) + 1 + (1 if cover_input is not None else 0)
for plan in plans:
idx = {}
for key, file in (("mask", plan.mask_file), ("decor", plan.decor_file)):
if file is None:
idx[key] = None
continue
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", f"{t1 - t0 + 1:.3f}", "-i", file.name]
idx[key] = next_input
next_input += 1
helper_files.append(file)
inset_inputs.append(idx)
graph = build_filter(project, cfg, ps, in0, ass_file.name, extras, has_audio_stream(ffprobe, segs[0][0]), t0,
project["audio"]["volume"], cover_input, ass_text, plans or None, inset_inputs)
tmp = work / f"{stem}.tmp.mp4"
graph_file = work / f"{stem}.graph.txt"
graph_args = ["-filter_complex", graph]
if len(graph) > 20000: # muitos keyframes: o grafo vai por arquivo (linha de comando do Windows tem limite)
graph_file.write_text(graph, encoding="utf-8")
graph_args = ["-/filter_complex", graph_file.name]
try:
media.run([ffmpeg, "-y", "-v", "error", *input0, *extra_args, *graph_args,
"-map", "[v]", "-map", "[a]", *encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000",
"-t", f"{t1 - t0:.3f}", "-movflags", "+faststart", tmp.name], timeout=timeout, cwd=work)
tmp.replace(out_file)
finally:
for f in (ass_file, concat, tmp, graph_file, *helper_files, *([uniform] if uniform else [])):
f.unlink(missing_ok=True)
def make_proxy(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, out_file: Path) -> None:
"""Vídeo leve (480p, 30 fps, quadro-chave a cada 0,5 s para pular rápido) da janela [lo, hi] para o navegador."""
segs = _segments_for(segments, lo, hi)
if not segs:
raise media.MediaError("nenhum bloco gravado cobre essa janela")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
segs, uniform = uniform_segments(ffmpeg, _ffprobe_near(ffmpeg), segs, work, out_file.stem)
input0, concat = _concat_input(work, out_file.stem, segs, lo, hi - lo)
tmp = work / f"{out_file.stem}.tmp.mp4"
try:
# fps ANTES do scale: com a fonte em 60 qps (1080p60/1440p60) metade dos quadros nem é escalada.
media.run([ffmpeg, "-y", "-v", "error", *input0, "-vf", f"fps={FPS},scale=-2:480", "-c:v", "libx264",
"-preset", "veryfast", "-crf", "30", "-g", "15", "-keyint_min", "15", "-pix_fmt", "yuv420p",
"-c:a", "aac", "-b:a", "96k", "-ac", "2", "-movflags", "+faststart", tmp.name], timeout=600, cwd=work)
tmp.replace(out_file)
finally:
concat.unlink(missing_ok=True)
tmp.unlink(missing_ok=True)
if uniform:
uniform.unlink(missing_ok=True)
def waveform(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, work: Path) -> list[float]:
"""Picos de volume (0–1) da janela, `PEAKS_PER_S` por segundo, para desenhar a forma de onda."""
segs = _segments_for(segments, lo, hi)
if not segs:
return []
work.mkdir(parents=True, exist_ok=True)
rate = 4000
input0, concat = _concat_input(work, "waveform", segs, lo, hi - lo)
try:
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(rate), "-f", "s16le", "-"], 300, cwd=work)
finally:
concat.unlink(missing_ok=True)
samples = array("h")
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
step = rate // PEAKS_PER_S
peaks = [max((abs(v) for v in samples[i: i + step]), default=0) / 32768 for i in range(0, len(samples), step)]
top = max(peaks, default=0) or 1
return [round(min(1.0, (p / top) ** 0.7), 3) for p in peaks]
def extract_wav(ffmpeg: str, segments: list[tuple[Path, float, float]], a: float, b: float, work: Path) -> bytes:
"""Áudio mono 16 kHz do trecho [a, b] da sessão, em WAV (para re-transcrever)."""
segs = _segments_for(segments, a, b)
if not segs:
raise media.MediaError("nenhum bloco gravado cobre esse trecho")
work.mkdir(parents=True, exist_ok=True)
input0, concat = _concat_input(work, "retranscribe", segs, a, b - a)
try:
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(media.SAMPLE_RATE), "-f", "s16le", "-"],
120, cwd=work)
finally:
concat.unlink(missing_ok=True)
return media.to_wav(pcm)
def render_cover(ffmpeg: str, segments: list[tuple[Path, float, float]], project: dict, base_cfg: dict, credit: str,
out_file: Path) -> Path:
"""Capa no formato do corte (1080×1920 ou 1920×1080; etapa 7): quadro do instante escolhido no layout do corte +
texto curto grande no centro."""
cfg = effective_settings(base_cfg, project)
cover = project["cover"]
mode = next((p.mode for p in pieces(project["cuts"]) if p.start <= cover["t"] <= p.end), None)
if mode and mode != "auto":
cfg["layout"]["mode"] = mode
work = out_file.parent
# Quadro intermediário em PNG: o mjpeg do FFmpeg 7.1 recusa yuv420p marcado como faixa "tv" (blocos do libx264).
frame = media.grab_frame(ffmpeg, segments, cover["t"], work / f"{out_file.stem}-src.png", width=0)
cap = {**cfg, "caption": {**cfg["caption"], "enabled": False}}
ass = build_project_ass({**project, "captions": {**project["captions"], "enabled": False}, "overlays": [],
"progress": {**project["progress"], "enabled": False}}, cap, credit, 0, 1)
if cover["text"]:
cw, ch = layout.canvas_size(cfg)
line = (f"Dialogue: 4,{_ts(0)},{_ts(1)},Box,,0,0,0,,{{\\pos({cw // 2},{int(ch * 0.5)})\\fs110\\3c{layout.ass_inline_color(COVER_BOX)}}}"
f"{_wrap(cover['text'].upper(), 110, cw - 120)}")
ass = ass + line + "\n"
try:
media.preview_still(ffmpeg, frame, cap, ass, out_file, reframe.static_reframe(project, cover["t"]))
finally:
frame.unlink(missing_ok=True)
return out_file
+158
View File
@@ -0,0 +1,158 @@
"""Emotes do chat: reconhecer, contar por canal e APRENDER quais indicam um bom momento.
Por quê: chat pequeno (3–5 pessoas) e público que reage com emote em vez de texto ("kkkk") faziam a heurística
não ver nada. Agora cada mensagem leva a lista de emotes, e cada canal tem um peso aprendido por emote.
De onde vêm:
- Twitch nativos: tag `emotes` do IRC (CAP twitch.tv/tags) com as posições na mensagem;
- 7TV, BTTV e FFZ do canal + globais: APIs públicas por `room-id` (o id do canal vem nas tags do IRC);
- emojis Unicode.
Cada fonte externa é opcional: a que falhar (404, lenta) é ignorada e tentada de novo na próxima hora.
Aprendizado (por canal, tabela `emotes`):
- `uses`: quantas vezes apareceu (contagem simples, para o painel);
- `weight`: sobe quando o emote aparece na reação de um corte aprovado/bem avaliado, desce quando o corte é
rejeitado/descartado. Entra no peso da mensagem na pontuação do chat.
"""
from __future__ import annotations
import logging
import re
import threading
import time
import httpx
log = logging.getLogger("cenaforge_clipper.emotes")
CATALOG_TTL_S = 3600
LEARN_UP, LEARN_DOWN = 0.3, 0.15
WEIGHT_MIN, WEIGHT_MAX = -1.0, 3.0
BASE_EMOTE_BONUS = 0.4 # mensagem com emote já é reação
BONUS_MIN, BONUS_MAX = -0.5, 3.0
# Faixas comuns de emoji (pictogramas, símbolos, bandeiras, rostos). Não é exaustivo, só precisa pegar os de reação.
EMOJI_RE = re.compile("[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U0001F1E6-\U0001F1FF]")
GLOBAL_URLS = {
"7tv": "https://7tv.io/v3/emote-sets/global",
"bttv": "https://api.betterttv.net/3/cached/emotes/global",
"ffz": "https://api.frankerfacez.com/v1/set/global",
}
CHANNEL_URLS = {
"7tv": "https://7tv.io/v3/users/twitch/{room}",
"bttv": "https://api.betterttv.net/3/cached/users/twitch/{room}",
"ffz": "https://api.frankerfacez.com/v1/room/id/{room}",
}
def parse_twitch_tag(tag_value: str, text: str) -> list[str]:
"""`emotes=25:0-4,12-16/1902:6-10` → nomes recortados do texto (posições em code points, como o str do Python)."""
names: list[str] = []
if not tag_value:
return names
for part in tag_value.split("/"):
if ":" not in part:
continue
_id, spans = part.split(":", 1)
for span in spans.split(","):
try:
a, b = (int(x) for x in span.split("-"))
except ValueError:
continue
if 0 <= a <= b < len(text):
names.append(text[a: b + 1])
return names
def _names_from(source: str, data) -> list[str]:
if source == "7tv":
emotes = data.get("emotes") or (data.get("emote_set") or {}).get("emotes") or []
return [e["name"] for e in emotes if isinstance(e, dict) and e.get("name")]
if source == "bttv":
items = data if isinstance(data, list) else (data.get("channelEmotes", []) + data.get("sharedEmotes", []))
return [e["code"] for e in items if isinstance(e, dict) and e.get("code")]
if source == "ffz":
return [e["name"] for s in (data.get("sets") or {}).values() for e in s.get("emoticons", []) if e.get("name")]
return []
class EmoteCatalog:
"""Nomes de emotes de terceiros (globais + do canal), com cache de 1 h por canal."""
def __init__(self, fetch=None):
self._fetch = fetch or self._http_json
self._lock = threading.Lock()
self._global: dict[str, str] = {}
self._global_at = 0.0
self._channels: dict[str, tuple[float, dict[str, str]]] = {}
@staticmethod
def _http_json(url: str):
response = httpx.get(url, timeout=20, headers={"User-Agent": "CenaForge-Clipador"})
if response.status_code != 200:
return None
return response.json()
def _load(self, urls: dict[str, str]) -> dict[str, str]:
found: dict[str, str] = {}
for source, url in urls.items():
try:
data = self._fetch(url)
except Exception as exc: # noqa: BLE001 - fonte externa opcional
log.info("emotes %s indisponível (%s)", source, type(exc).__name__)
continue
if data:
for name in _names_from(source, data):
found.setdefault(name, source)
return found
def cached(self, room_id: str | None) -> dict[str, str]:
"""O que já foi baixado, sem tocar na rede (usado na linha do chat, que não pode esperar API externa)."""
with self._lock:
merged = dict(self._global)
if room_id and room_id in self._channels:
merged.update(self._channels[room_id][1])
return merged
def names(self, room_id: str | None) -> dict[str, str]:
now = time.time()
with self._lock:
if now - self._global_at > CATALOG_TTL_S:
self._global, self._global_at = self._load(GLOBAL_URLS), now
merged = dict(self._global)
if room_id:
cached = self._channels.get(room_id)
if not cached or now - cached[0] > CATALOG_TTL_S:
cached = (now, self._load({k: v.format(room=room_id) for k, v in CHANNEL_URLS.items()}))
self._channels[room_id] = cached
merged.update(cached[1])
return merged
def extract(text: str, twitch_emotes: list[str], catalog: dict[str, str]) -> list[tuple[str, str]]:
"""(nome, fonte) de cada emote da mensagem: nativos da Twitch, de terceiros (palavra exata) e emojis."""
out: list[tuple[str, str]] = [(name, "twitch") for name in twitch_emotes]
seen = {name for name, _ in out}
for token in text.split():
if token in catalog and token not in seen:
out.append((token, catalog[token]))
seen.add(token)
for emoji in EMOJI_RE.findall(text):
if emoji not in seen:
out.append((emoji, "emoji"))
seen.add(emoji)
return out
def message_bonus(emotes: list[str], weights: dict[str, float]) -> float:
"""Bônus de peso da mensagem pelos emotes: base por ter emote + pesos aprendidos do canal."""
if not emotes:
return 0.0
learned = sum(max(WEIGHT_MIN, min(WEIGHT_MAX, weights.get(name, 0.0))) for name in set(emotes))
return max(BONUS_MIN, min(BONUS_MAX, BASE_EMOTE_BONUS + learned))
def learn_delta(positive: bool) -> float:
return LEARN_UP if positive else -LEARN_DOWN
+761
View File
@@ -0,0 +1,761 @@
"""Rastreio do rosto do streamer no Clipador: acha a câmera (YuNet), segue o rosto e as expressões (MediaPipe Face
Landmarker; plano B OpenSeeFace) bloco a bloco e grava a série por segundo em `face_track`.
A lógica de sinal (série por segundo, z relativo ao neutro do streamer, rótulos, `locate_cam`) é pura e mora em
`reaction.py`; aqui fica só E/S: modelos, FFmpeg, backends e banco. Decisões e números: doc/FACE_BAKEOFF.md.
- Modelos: baixados sob demanda (na primeira vez que o rastreio ou a detecção rodam, sempre fora da thread do chat)
para `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`. O `setup.ps1` (passo 6b) já
deixa tudo baixado; o download aqui é só a rede de segurança.
- Bloco: FFmpeg recorta a câmera (+10 % de margem), escala para ~384 px no maior lado, 6 qps, `rgb24` por pipe →
MediaPipe em modo VIDEO (um landmarker por bloco: timestamps sempre crescentes) → `reaction.per_second`.
- Coordenadas gravadas (`cx`, `cy`, `size`) já convertidas para o QUADRO INTEIRO (0..1; `size` = altura do rosto
como fração da altura do quadro): é o que o editor usa para reenquadrar a câmera.
- Câmera mudou (detecção nova ou layout editado) → a série da sessão é apagada e refeita sozinha.
Nada daqui importa cv2/mediapipe/numpy na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
"""
from __future__ import annotations
import hashlib
import json
import logging
import math
import subprocess
import threading
import time
from collections.abc import Callable, Iterator
from pathlib import Path
from typing import TYPE_CHECKING, Any, Protocol
from . import reaction
from .config import CLIPPER_DIR, REPO_ROOT
from .db import loads, now
from .media import NO_WINDOW, MediaError, run, seek_args
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.face")
LOCK_FILE = CLIPPER_DIR / "models.lock.json"
FPS = 6 # quadros por segundo no rastreio (bancada: 6 qps bastam para pegar a reação)
CROP_SIDE = 384 # maior lado do recorte que vai para o modelo (256–384 dá o mesmo sinal)
CROP_MARGIN = 0.10 # margem em volta da câmera (o streamer se inclina para fora do retângulo)
CAM_FRAMES = 12 # quadros espalhados para achar a câmera
DETECT_WIDTH = 1280 # largura do quadro inteiro para o YuNet
UNAVAILABLE_RETRY_S = 300 # backend sem modelo/biblioteca: tenta de novo daqui a 5 min (não marca blocos)
BASELINE_EXTRA_S = 240 # segundos antes da janela pedidos para o neutro do streamer (z relativo)
MAX_LAG_BLOCKS = 2 # a decisão do corte espera o rosto do trecho, no máximo 2 blocos atrás da transcrição
READ_TIMEOUT_S = 120.0 # prazo do FFmpeg para entregar um bloco de 30 s (medido: ~0,5 s)
MIN_FRAMES_RATIO = 0.9 # bloco com menos de 90 % dos quadros esperados (fps × duração) é erro, não série truncada
RESET_WAIT_S = 0.5 # o reset pedido pela API espera o bloco em andamento só isto; senão fica agendado para o laço
Detection = tuple[float, float, float, float, float] # x, y, w, h (px), score
class FaceError(RuntimeError):
"""Falha de um bloco (vídeo apagado, FFmpeg) ou da detecção da câmera."""
class FaceUnavailable(FaceError):
"""Backend indisponível (biblioteca ou modelo faltando, download/sha256 falhou): não é culpa do bloco."""
# ---------------------------------------------------------------------------------------------------------------
# Modelos (download sob demanda + sha256)
def sha256_of(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as fh:
for chunk in iter(lambda: fh.read(1 << 20), b""):
digest.update(chunk)
return digest.hexdigest()
def _http_download(url: str, dest: Path) -> None:
import httpx
with httpx.stream("GET", url, follow_redirects=True, timeout=60) as response:
response.raise_for_status()
with dest.open("wb") as fh:
for chunk in response.iter_bytes(1 << 16):
fh.write(chunk)
class ModelStore:
"""Pesos do `models.lock.json`: confere o sha256 (uma vez por processo) e baixa o que faltar."""
def __init__(self, models_dir: Path, lock_file: Path = LOCK_FILE,
fetch: Callable[[str, Path], None] | None = None):
lock = json.loads(lock_file.read_text(encoding="utf-8"))
self.dir = models_dir
self.models: dict[str, dict] = {m["id"]: m for m in lock["models"]}
self.fetch = fetch or _http_download
self._checked: set[str] = set()
self._lock = threading.Lock()
def path(self, model_id: str) -> Path:
info = self.models.get(model_id)
if info is None:
raise FaceUnavailable(f"modelo {model_id} não está no models.lock.json")
dest = self.dir / info["file"]
with self._lock:
if model_id in self._checked and dest.is_file():
return dest
if dest.is_file() and sha256_of(dest) == info["sha256"]:
self._checked.add(model_id)
return dest
# Ausente ou corrompido: baixa de novo (URL imutável do lock) e só aceita com o sha256 certo.
self.dir.mkdir(parents=True, exist_ok=True)
part = dest.with_name(dest.name + ".part")
try:
log.info("baixando o modelo %s (%s)", model_id, info["url"])
self.fetch(info["url"], part)
digest = sha256_of(part)
except Exception as exc: # noqa: BLE001 - qualquer falha de rede/disco vira "indisponível"
part.unlink(missing_ok=True)
raise FaceUnavailable(f"não deu para baixar o modelo {info['file']}: {exc}") from exc
if digest != info["sha256"]:
part.unlink(missing_ok=True)
raise FaceUnavailable(f"sha256 do modelo {info['file']} não confere (baixado {digest[:12]}…)")
part.replace(dest)
self._checked.add(model_id)
return dest
# ---------------------------------------------------------------------------------------------------------------
# Backends
class Detector(Protocol):
def detect(self, bgr: Any) -> list[Detection]: ...
class Tracker(Protocol):
name: str
def process(self, t: float, rgb: Any) -> reaction.FaceSample: ...
def close(self) -> None: ...
class YuNetDetector:
"""Rosto no quadro inteiro (`cv2.FaceDetectorYN`, variante 2026may de entrada dinâmica)."""
def __init__(self, model_path: Path, score: float = 0.6):
try:
import cv2
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("opencv não instalado (rode o setup.bat)") from exc
self._cv2, self._path, self._score = cv2, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
def detect(self, bgr: Any) -> list[Detection]:
h, w = bgr.shape[:2]
if self._det is None:
self._det = self._cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 50)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
_, faces = self._det.detect(bgr)
if faces is None:
return []
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
class MediaPipeTracker:
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco.
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
"""
name = "mediapipe"
def __init__(self, model_path: Path):
try:
import mediapipe as mp
import numpy as np
from mediapipe.tasks.python import vision
from mediapipe.tasks.python.core.base_options import BaseOptions
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("mediapipe não instalado (rode o setup.bat)") from exc
self._mp, self._np = mp, np
options = vision.FaceLandmarkerOptions(
base_options=BaseOptions(model_asset_path=str(model_path)),
running_mode=vision.RunningMode.VIDEO,
num_faces=1,
min_face_detection_confidence=0.5,
min_face_presence_confidence=0.5,
min_tracking_confidence=0.5,
output_face_blendshapes=True,
)
self._lm = vision.FaceLandmarker.create_from_options(options)
self._last_ms = -1
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
ms = max(self._last_ms + 1, int(round(t * 1000)))
self._last_ms = ms
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
result = self._lm.detect_for_video(image, ms)
if not result.face_landmarks:
return reaction.FaceSample(t, False)
xs = [p.x for p in result.face_landmarks[0]]
ys = [p.y for p in result.face_landmarks[0]]
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend)
def close(self) -> None:
self._lm.close()
class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
Reimplementação mínima do `tracker.py` do commit 50c0974 (BSD-2), igual à da bancada (`tools/face_bench.py`).
Só o canal de movimento sai daqui; usado quando o MediaPipe não carrega.
"""
name = "openseeface"
RES, OUT_RES, LOGIT = 224, 27, 16.0
def __init__(self, landmarks_path: Path, detector_path: Path, threshold: float = 0.6):
try:
import cv2
import numpy as np
import onnxruntime as ort
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("onnxruntime/opencv não instalados (rode o setup.bat)") from exc
self._cv2, self._np = cv2, np
opts = ort.SessionOptions()
opts.inter_op_num_threads, opts.intra_op_num_threads = 1, 1
providers = ["CPUExecutionProvider"]
self._lm = ort.InferenceSession(str(landmarks_path), sess_options=opts, providers=providers)
self._det = ort.InferenceSession(str(detector_path), sess_options=opts, providers=providers)
self._lm_input = self._lm.get_inputs()[0].name
mean, std = np.float32([0.485, 0.456, 0.406]), np.float32([0.229, 0.224, 0.225])
self._mean, self._scale = -(mean / std), 1.0 / (std * 255.0)
self._threshold = threshold
self._box: tuple[float, float, float, float] | None = None
def _norm(self, rgb: Any, size: int) -> Any:
im = self._cv2.resize(rgb.astype(self._np.float32), (size, size)) * self._scale + self._mean
return self._np.transpose(im[None], (0, 3, 1, 2)).astype(self._np.float32)
def _detect(self, rgb: Any) -> tuple[float, float, float, float] | None:
np = self._np
out, maxpool = (np.array(a) for a in self._det.run([], {"input": self._norm(rgb, 224)}))
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
y, x = divmod(int(np.argmax(out[0, 0])), 56)
if out[0, 0, y, x] < self._threshold:
return None
r = out[0, 1, y, x] * 112.0
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
return ((x * 4 - r) * sx, (y * 4 - r) * sy, 2 * r * sx, 2 * r * sy)
def _landmarks(self, rgb: Any, box: tuple[float, float, float, float]) -> tuple[float, Any]:
np = self._np
h, w = rgb.shape[:2]
x, y, bw, bh = box
x1, y1 = int(np.clip(x - bw * 0.1, 0, w - 1)), int(np.clip(y - bh * 0.125, 0, h - 1))
x2, y2 = int(np.clip(x + bw * 1.1, 0, w - 1)), int(np.clip(y + bh * 1.125, 0, h - 1))
if x2 - x1 < 4 or y2 - y1 < 4:
return 0.0, None
tensor = self._lm.run([], {self._lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
n, res = self.OUT_RES + 1, self.RES - 1
main = tensor[0:66].reshape(66, n * n)
idx = main.argmax(1)[:, None]
conf = np.take_along_axis(main, idx, 1)[:, 0]
def logit(v: Any) -> Any:
v = np.clip(v, 1e-7, 1 - 1e-7)
return np.log(v / (1 - v)) / self.LOGIT
off_y = np.take_along_axis(tensor[66:132].reshape(66, n * n), idx, 1)[:, 0]
off_x = np.take_along_axis(tensor[132:198].reshape(66, n * n), idx, 1)[:, 0]
m = idx[:, 0]
# No original a 1ª coluna dos pontos é y; aqui já sai (x, y).
py = y1 + (y2 - y1) / self.RES * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
px = x1 + (x2 - x1) / self.RES * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
return float(conf.mean()), np.stack([px, py], 1)
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
box = self._box or self._detect(rgb)
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if conf < self._threshold and self._box is not None:
box = self._detect(rgb) # caixa do quadro anterior se perdeu: detector neste mesmo quadro
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if pts is None or conf < self._threshold:
self._box = None
return reaction.FaceSample(t, False)
(x1, y1), (x2, y2) = pts.min(0), pts.max(0)
self._box = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
h, w = rgb.shape[:2]
return reaction.FaceSample(t, True, float(x1 + x2) / 2 / w, float(y1 + y2) / 2 / h, float(y2 - y1) / h, {})
def close(self) -> None:
self._box = None
# ---------------------------------------------------------------------------------------------------------------
# Vídeo (FFmpeg, sem shell, argumentos em lista)
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace").strip().splitlines()
if not out:
raise FaceError(f"sem vídeo em {file.name}")
w, h = out[0].split(",")[:2]
return int(w), int(h)
def _stop(proc: subprocess.Popen, grace: float = 10.0) -> None:
"""Espera o processo sair; se não sair, mata e ESPERA de novo (sem processo zumbi)."""
try:
proc.wait(timeout=grace)
except subprocess.TimeoutExpired:
proc.kill()
proc.wait(timeout=grace)
def read_crop(ffmpeg: str, file: Path, crop_px: tuple[int, int, int, int], out_size: tuple[int, int],
fps: int = FPS, timeout: float = READ_TIMEOUT_S) -> Iterator[tuple[float, Any]]:
"""Quadros RGB do recorte (x, y, w, h em px) a `fps` qps, um por vez (sem guardar o bloco na memória).
`fps` antes do `crop` reduz o trabalho do filtro. Devolve (segundos desde o início do bloco, H×W×3 uint8).
Prazo total `timeout`: passou, o FFmpeg é morto. stderr é drenado numa thread (FFmpeg tagarela não trava no
buffer do pipe). FFmpeg que sai com código ≠ 0 — inclusive morto pelo prazo — vira `FaceError`, mesmo depois de
ter entregado alguns quadros: bloco truncado não pode ser gravado como completo.
"""
x, y, w, h = crop_px
ow, oh = out_size
args = [ffmpeg, "-v", "error", "-i", str(file), "-vf", f"fps={fps},crop={w}:{h}:{x}:{y},scale={ow}:{oh}",
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
return _read_frames(args, out_size, fps, timeout, file.name)
def _read_frames(args: list[str], out_size: tuple[int, int], fps: int, timeout: float,
name: str) -> Iterator[tuple[float, Any]]:
"""Lê quadros rawvideo rgb24 do stdout de `args` (sem shell), com prazo e stderr drenado."""
import numpy as np
ow, oh = out_size
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=NO_WINDOW)
errors: list[bytes] = []
drain = threading.Thread(target=lambda: errors.append(proc.stderr.read()), daemon=True) # type: ignore[union-attr]
drain.start()
timed_out = threading.Event()
def kill() -> None:
timed_out.set()
proc.kill()
killer = threading.Timer(timeout, kill)
killer.daemon = True
killer.start()
size = ow * oh * 3
i = 0
try:
while True:
buf = proc.stdout.read(size) # type: ignore[union-attr]
if len(buf) < size:
break
yield i / fps, np.frombuffer(buf, np.uint8).reshape(oh, ow, 3).copy()
i += 1
finally:
killer.cancel()
proc.stdout.close() # type: ignore[union-attr]
_stop(proc)
drain.join(timeout=5)
if proc.stderr:
proc.stderr.close()
if timed_out.is_set():
raise FaceError(f"ffmpeg passou de {timeout:.0f} s lendo {name} ({i} quadros)")
if proc.returncode != 0:
tail = b"".join(errors).decode("utf-8", errors="replace").strip().splitlines()[-1:]
raise FaceError(f"ffmpeg saiu com código {proc.returncode} depois de {i} quadros: {' '.join(tail)}")
def grab_bgr(ffmpeg: str, file: Path, offset: float, width: int = DETECT_WIDTH) -> Any | None:
"""Um quadro BGR do bloco, escalado para `width` de largura (altura proporcional, par)."""
import numpy as np
before, select = seek_args(offset) # quadro exato (no HEVC a busca direta dava quadro cinza)
raw = run([ffmpeg, "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-frames:v", "1",
"-vf", f"{select},scale={width}:-2", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], 60)
h = len(raw) // (width * 3)
if h < 2:
return None
return np.frombuffer(raw[: width * h * 3], np.uint8).reshape(h, width, 3).copy()
# ---------------------------------------------------------------------------------------------------------------
# Geometria
def expand(rect: dict, margin: float = CROP_MARGIN) -> dict:
"""Retângulo 0..1 com margem em volta, recortado no quadro."""
mx, my = rect["w"] * margin, rect["h"] * margin
x0, y0 = max(0.0, rect["x"] - mx), max(0.0, rect["y"] - my)
x1, y1 = min(1.0, rect["x"] + rect["w"] + mx), min(1.0, rect["y"] + rect["h"] + my)
return {"x": round(x0, 4), "y": round(y0, 4), "w": round(x1 - x0, 4), "h": round(y1 - y0, 4)}
def crop_geometry(crop: dict, frame: tuple[int, int], side: int = CROP_SIDE) -> tuple[tuple[int, int, int, int],
tuple[int, int]]:
"""Recorte em px (valores pares) e tamanho de saída com o maior lado = `side`."""
fw, fh = frame
# Tudo par e dentro do quadro, mesmo com retângulo fora de 0..1 (layout antigo, arredondamento).
x = min(max(0, int(crop["x"] * fw)), fw - 2) // 2 * 2
y = min(max(0, int(crop["y"] * fh)), fh - 2) // 2 * 2
w = max(2, min(fw - x, int(round(crop["w"] * fw))) // 2 * 2)
h = max(2, min(fh - y, int(round(crop["h"] * fh))) // 2 * 2)
k = side / max(w, h)
return (x, y, w, h), (max(2, int(w * k) // 2 * 2), max(2, int(h * k) // 2 * 2))
def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.FaceSecond]:
"""Posição/tamanho do recorte → quadro inteiro (0..1). `size` vira fração da altura do quadro."""
for s in seconds:
if s.cx is not None:
s.cx = crop["x"] + s.cx * crop["w"]
if s.cy is not None:
s.cy = crop["y"] + s.cy * crop["h"]
if s.size is not None:
s.size = s.size * crop["h"]
return seconds
def same_rect(a: dict | None, b: dict | None, tol: float = 1e-3) -> bool:
if a is None or b is None:
return a is b
return all(abs(float(a[k]) - float(b[k])) <= tol for k in ("x", "y", "w", "h"))
# ---------------------------------------------------------------------------------------------------------------
# Serviço
class FaceService:
"""Câmera local, rastreio por bloco e leitura da série. Uma instância por motor (`Engine.face`)."""
def __init__(self, engine: Engine, store: ModelStore | None = None,
tracker_factory: Callable[[str | None], Tracker] | None = None,
detector_factory: Callable[[], Detector] | None = None,
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
grabber: Callable[..., Any] | None = None,
sizer: Callable[[Path], tuple[int, int]] | None = None):
self.e = engine
self.store = store or ModelStore(engine.settings.data_dir / "models")
# Recebe o backend que a sessão já usa (None = sessão nova) e devolve o rastreador.
self._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
self._detector_factory = detector_factory or (lambda: YuNetDetector(self.store.path("yunet")))
self._reader = reader or read_crop
self._grabber = grabber or grab_bgr
self._sizer = sizer or (lambda file: probe_size(self.e.settings.ffprobe or "ffprobe", file))
# Tamanho do quadro POR BLOCO: uma retomada pode gravar em outra resolução (outra qualidade de captura).
self._sizes: dict[str, tuple[int, int]] = {}
self._busy = threading.Lock() # um bloco por vez (o laço e um reset concorrente não se atropelam)
self._resets: set[int] = set() # resets pedidos com um bloco em andamento: o laço aplica no próximo passo
self._resets_lock = threading.Lock()
self._unavailable_until = 0.0
self.backend: str | None = None
self.last_error: str | None = None
self.params = reaction.ReactionParams()
# ---------- opções / backends
@property
def enabled(self) -> bool:
return bool(self.e.intel.opts.get("faceTrack", True))
def _default_tracker(self, backend: str | None = None) -> Tracker:
"""MediaPipe; o plano B OpenSeeFace só numa sessão que ainda não tem série. Uma sessão nunca mistura os
dois: sem blendshapes, o neutro do streamer ficaria zerado no meio da série e qualquer sorriso viraria pico."""
if backend == OpenSeeFaceTracker.name:
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
try:
return MediaPipeTracker(self.store.path("face_landmarker"))
except FaceUnavailable as first:
if backend == MediaPipeTracker.name:
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
log.warning("MediaPipe indisponível (%s): usando o plano B OpenSeeFace (sem expressões)", first)
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
def session_backend(self, session_id: int) -> str | None:
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
session_id)
return loads(row["data_json"], {}).get("backend") if row else None
# ---------- câmera da sessão
def cam_for(self, session: dict) -> tuple[dict | None, str, bool]:
"""(retângulo 0..1 da câmera, origem, decidido?). Layout do corte primeiro (o que o usuário vê e edita);
senão o que a detecção achou. Não decidido = a detecção ainda não rodou: o rastreio espera."""
layout_cam = self.e.intel.settings_for(session)["layout"]["cam"]
detected = loads(session.get("cam_json"), None) or {}
if layout_cam:
same = same_rect(detected.get("cam"), layout_cam)
return layout_cam, (detected.get("source") or "ai") if same else "manual", True
if detected.get("hasWebcam") and detected.get("cam"):
return detected["cam"], detected.get("source") or "ai", True
if detected:
return None, detected.get("source") or "", True
return None, "", False
def has_cam(self, session: dict) -> bool:
cam, _, decided = self.cam_for(session)
return decided and cam is not None
# ---------- laço (thread `face` do motor)
def run_forever(self, stop: threading.Event) -> None:
while not stop.is_set():
worked = False
if self.enabled and time.monotonic() >= self._unavailable_until:
try:
worked = self.step()
except FaceUnavailable as exc:
self.last_error = str(exc)[:300]
self._unavailable_until = time.monotonic() + UNAVAILABLE_RETRY_S
log.warning("rastreio de rosto indisponível: %s (nova tentativa em %d s)", exc, UNAVAILABLE_RETRY_S)
except Exception as exc: # noqa: BLE001 - qualquer outra falha não pode matar a thread do rastreio
self.last_error = str(exc)[:300]
log.exception("rastreio de rosto: erro inesperado no laço")
stop.wait(0.2 if worked else 10)
def step(self) -> bool:
"""Processa UM bloco pendente (sessões gravando/processando primeiro). True se trabalhou."""
db = self.e.db
self._apply_pending_resets()
sessions = db.all("SELECT * FROM sessions WHERE status != 'error' ORDER BY "
"CASE WHEN status IN ('recording', 'processing', 'starting') THEN 0 ELSE 1 END, id DESC")
for session in sessions:
cam, _source, decided = self.cam_for(session)
if not decided:
continue
self.sync_cam(session["id"], cam)
segment = db.get(
"SELECT s.* FROM segments s LEFT JOIN face_track f ON f.session_id = s.session_id AND f.idx = s.idx"
" WHERE s.session_id = ? AND s.deleted = 0 AND f.idx IS NULL ORDER BY s.idx LIMIT 1", session["id"])
if segment:
self.process_block(session, segment, cam)
return True
return False
def sync_cam(self, session_id: int, cam: dict | None) -> bool:
"""Câmera diferente da usada na série gravada → apaga a série (o laço refaz). True se apagou."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? ORDER BY idx DESC LIMIT 1", session_id)
if row is None or same_rect(loads(row["data_json"], {}).get("cam"), cam):
return False
log.info("sessão %s: câmera mudou, refazendo o rastreio do rosto", session_id)
self.reset(session_id)
return True
def reset(self, session_id: int, wait_s: float = RESET_WAIT_S) -> dict:
"""Apaga a série da sessão. Não prende a requisição HTTP atrás de um bloco em andamento: se o laço estiver
ocupado por mais de `wait_s`, o reset fica agendado e o laço aplica antes do próximo bloco."""
if not self._busy.acquire(timeout=wait_s):
with self._resets_lock:
self._resets.add(session_id)
return {"deleted": 0, "scheduled": True}
try:
with self._resets_lock:
self._resets.discard(session_id)
return {"deleted": self._delete(session_id), "scheduled": False}
finally:
self._busy.release()
def _delete(self, session_id: int) -> int:
return self.e.db.run("DELETE FROM face_track WHERE session_id = ?", session_id).rowcount
def _apply_pending_resets(self) -> None:
with self._resets_lock:
pending, self._resets = self._resets, set()
for session_id in pending:
with self._busy:
self._delete(session_id)
def process_block(self, session: dict, segment: dict, cam: dict | None) -> str:
"""Rastreia um bloco e grava a linha de `face_track`. Devolve o status gravado."""
sid, idx = segment["session_id"], segment["idx"]
if cam is None:
self._save(sid, idx, "no_cam", {"cam": None}, None)
return "no_cam"
first, last = math.ceil(segment["start_s"]), math.ceil(segment["end_s"])
with self._busy:
started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name
try:
file = REPO_ROOT / segment["file"]
crop = expand(cam)
px, out = crop_geometry(crop, self._frame_size(sid, file))
samples = [tracker.process(segment["start_s"] + t, rgb)
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)]
except FaceUnavailable:
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde
except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
log.warning("bloco %s/%s do rastreio falhou: %s", sid, idx, exc)
self._save(sid, idx, "error", {"cam": cam}, str(exc)[:300])
return "error"
finally:
tracker.close()
expected = (segment["end_s"] - segment["start_s"]) * FPS
if len(samples) < MIN_FRAMES_RATIO * expected - 2:
msg = f"bloco truncado: {len(samples)} de ~{expected:.0f} quadros"
self._save(sid, idx, "error", {"cam": cam}, msg)
return "error"
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first), crop)
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)}
self._save(sid, idx, "done", data, None)
self.last_error = None
return "done"
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file)
if key not in self._sizes:
if len(self._sizes) > 2000:
self._sizes.clear()
self._sizes[key] = self._sizer(file)
return self._sizes[key]
def _save(self, session_id: int, idx: int, status: str, data: dict, error: str | None) -> None:
self.e.db.run("INSERT INTO face_track (session_id, idx, status, data_json, error, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
" ON CONFLICT (session_id, idx) DO UPDATE SET status = excluded.status, data_json = excluded.data_json,"
" error = excluded.error, updated_at = excluded.updated_at",
session_id, idx, status, json.dumps(data, ensure_ascii=False), error, now())
# ---------- leitura
def tracked_until(self, session_id: int) -> float:
"""Até onde (s) a série está contínua desde o início (qualquer status conta: bloco sem câmera também
já foi "decidido")."""
until = 0.0
# Blocos apagados nunca ganham linha (o laço os ignora): pular, senão a série "trava" no primeiro apagado.
for row in self.e.db.all("SELECT s.start_s, s.end_s, f.idx AS done FROM segments s LEFT JOIN face_track f"
" ON f.session_id = s.session_id AND f.idx = s.idx WHERE s.session_id = ? AND s.deleted = 0"
" ORDER BY s.idx",
session_id):
if row["done"] is None:
break
until = row["end_s"]
return until
def dense(self, session_id: int, lo: float, hi: float) -> list[reaction.FaceSecond]:
"""Série contínua por segundo em [floor(lo), ceil(hi)) — índice i = segundo floor(lo) + i; segundos sem
dado (sem câmera, erro, ainda não rastreado) saem com `present` 0. É o formato que `reaction` espera."""
first, last = max(0, int(math.floor(lo))), max(0, int(math.ceil(hi)))
out = [reaction.FaceSecond(t) for t in range(first, last)]
if not out:
return out
rows = self.e.db.all(
"SELECT f.data_json FROM face_track f JOIN segments s ON s.session_id = f.session_id AND s.idx = f.idx"
" WHERE f.session_id = ? AND f.status = 'done' AND s.end_s >= ? AND s.start_s < ? ORDER BY f.idx",
session_id, first, last)
for row in rows:
for item in loads(row["data_json"], {}).get("seconds", []):
i = int(item["t"]) - first
if 0 <= i < len(out):
out[i] = reaction.FaceSecond.from_json(item)
return out
def for_scoring(self, session: dict, offset: int, duration: float) -> tuple[list[reaction.FaceSecond] | None, float]:
"""(série alinhada à janela da pontuação — t relativo a `offset` —, até onde o rastreio chegou).
`None` quando o rastreio está desligado ou a sessão não tem câmera: a pontuação segue como antes."""
if not self.enabled or not self.has_cam(session):
return None, 0.0
seconds = self.dense(session["id"], offset, duration)
for s in seconds:
s.t -= offset
return seconds, self.tracked_until(session["id"])
def must_wait(self, needed_until: float, face_until: float, analyzed_until: float) -> bool:
"""Espera o rosto do trecho antes de decidir o corte — mas nunca mais que `MAX_LAG_BLOCKS` blocos atrás da
transcrição (rastreio atrasado ou travado não segura os cortes)."""
if time.monotonic() < self._unavailable_until:
return False # backend fora do ar: esperar não adianta (sessão curta ficaria sem cortes até voltar)
lag = analyzed_until - face_until
return needed_until > face_until and lag <= MAX_LAG_BLOCKS * self.e.settings.segment_s
def summary(self, session: dict, lo: float, hi: float) -> str:
"""Linha "Rosto do streamer" do prompt do analista; "" quando não há câmera/rastreio nesse trecho."""
if not self.enabled or not self.has_cam(session):
return ""
# Plano B (OpenSeeFace) não mede expressão: os canais saem 0 e o texto diria "sem reação marcante" — falso.
if self.session_backend(session["id"]) == OpenSeeFaceTracker.name:
return ""
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
inside = [s for s in seconds if lo <= s.t <= hi]
if not inside or not any(s.smile is not None for s in inside):
return ""
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
def view(self, session: dict, lo: float, hi: float | None) -> dict:
"""Série por segundo para a API (o editor usa cx/cy/size, já no quadro inteiro, para reenquadrar)."""
sid = session["id"]
cam, source, decided = self.cam_for(session)
end = session["duration_s"] if hi is None else min(hi, session["duration_s"])
start = max(0.0, min(lo, end))
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
signal = reaction.reaction_signal(seconds, params=self.params)
moments = reaction.reaction_moments(seconds, self.params)
counts = {r["status"]: r["n"] for r in self.e.db.all(
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
rows = []
for s, z in zip(seconds, signal):
if s.t < start:
continue
item = s.to_json()
if z is not None:
item["signal"] = round(z, 2)
rows.append(item)
return {
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
"cam": cam, "camSource": source, "camDecided": decided, "backend": self.backend,
"lastError": self.last_error, "trackedUntilS": self.tracked_until(sid),
"blocks": {"total": total, "done": counts.get("done", 0), "noCam": counts.get("no_cam", 0),
"error": counts.get("error", 0)},
"fromS": start, "toS": end,
"seconds": rows,
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
}
# ---------- câmera local (YuNet + reaction.locate_cam)
def locate(self, session: dict) -> dict:
"""Acha a câmera olhando `CAM_FRAMES` quadros espalhados da gravação, sem IA."""
segments = self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])
if not segments:
raise FaceError("sem vídeo gravado (blocos apagados?)")
lo, hi = segments[0]["start_s"], segments[-1]["end_s"]
margin = min(30.0, (hi - lo) * 0.05)
span = max(0.0, hi - lo - 2 * margin)
times = [lo + margin + span * k / max(1, CAM_FRAMES - 1) for k in range(CAM_FRAMES)]
detector = self._detector_factory()
detections: list[list[Detection]] = []
size: tuple[int, int] | None = None
ffmpeg = self.e.settings.ffmpeg or "ffmpeg"
for t in times:
seg = next((s for s in segments if s["start_s"] <= t < s["end_s"]), segments[-1])
try:
bgr = self._grabber(ffmpeg, REPO_ROOT / seg["file"], t - seg["start_s"])
except (MediaError, OSError) as exc:
log.info("quadro %.0fs indisponível para achar a câmera: %s", t, exc)
continue
if bgr is None:
continue
size = (bgr.shape[1], bgr.shape[0])
detections.append(detector.detect(bgr))
if size is None or len(detections) < 3:
raise FaceError("poucos quadros legíveis para achar a câmera")
result = reaction.locate_cam(detections, size[0], size[1])
return result | {"source": "yunet", "frames": len(detections), "framesWithFace": sum(1 for d in detections if d),
"at": now()}
+77
View File
@@ -0,0 +1,77 @@
"""Hashtags da legenda de um corte (pedido do dono, 17/11/2026: "a IA colocar as # certas, como o jogo e a missão").
A legenda sai em três partes, sempre na mesma ordem:
texto (1–2 frases da IA, sem hashtags)
hashtags: canal → jogo (fixas, do perfil do jogo) → momento (da IA: missão, evento, modo, item, personagem)
🎥 Créditos: link do canal
As do canal e do jogo não dependem da IA acertar: vêm do nome do streamer e do perfil do jogo (seção "Hashtags",
preenchida pela pesquisa e editável no painel; sem ela, o nome do jogo vira a tag). As do momento são as que a IA
escolheu para o trecho. Repetidas saem (sem diferenciar maiúscula e acento) e o total fica em até 8.
"""
from __future__ import annotations
import re
import unicodedata
MAX_TAGS = 8
GAME_TAGS = 3
MOMENT_TAGS = 4
TAG_MAX_LEN = 30
_HASHTAG = re.compile(r"#[^\s#]+")
_WORD = re.compile(r"[^\W_]+|_", re.UNICODE)
def to_tag(text: object) -> str | None:
"""'ROB RUN' → '#ROBRUN', 'perseguição policial' → '#PerseguiçãoPolicial', '#Lamborghini' → '#Lamborghini'.
Sem letra (só número/símbolo) ou vazio → None."""
words = _WORD.findall(str(text or "").strip().lstrip("#"))
words = [w for w in words if w != "_"]
if not words:
return None
if len(words) == 1:
body = words[0]
else:
body = "".join(w[:1].upper() + w[1:] for w in words)
body = body[:TAG_MAX_LEN]
if not any(ch.isalpha() for ch in body):
return None
return f"#{body}"
def fold(tag: str) -> str:
"""Chave para comparar tags: sem #, sem acento, minúscula."""
plain = unicodedata.normalize("NFKD", tag.lstrip("#"))
return "".join(ch for ch in plain if not unicodedata.combining(ch)).casefold()
def split_hashtags(text: str) -> tuple[str, list[str]]:
"""Separa o texto das hashtags que vieram no meio dele (a IA às vezes põe mesmo pedindo para não pôr)."""
tags = _HASHTAG.findall(text or "")
clean = _HASHTAG.sub("", text or "")
clean = re.sub(r"[ \t]+", " ", clean)
clean = re.sub(r" *\n *", "\n", clean).strip()
return clean, tags
def compose(streamer: str, game: str, profile: dict | None, moment: list[str] | tuple[str, ...]) -> list[str]:
"""Hashtags finais: canal, jogo (do perfil; senão o nome do jogo) e as do momento, sem repetidas, até 8."""
game_tags = [t for t in (profile or {}).get("hashtags") or [] if t][:GAME_TAGS] or ([game] if game else [])
ordered = [streamer, *game_tags, *list(moment)[:MOMENT_TAGS]]
out: list[str] = []
seen: set[str] = set()
for raw in ordered:
tag = to_tag(raw)
if tag and fold(tag) not in seen:
seen.add(fold(tag))
out.append(tag)
if len(out) >= MAX_TAGS:
break
return out
def build_caption(text: str, tags: list[str], credit: str) -> str:
"""Texto, hashtags e crédito, separados por linha em branco (partes vazias somem)."""
return "\n\n".join(part for part in (text.strip(), " ".join(tags), credit.strip()) if part)
+507
View File
@@ -0,0 +1,507 @@
"""Inteligência do Clipador além da heurística: contexto do jogo, varredura da IA, webcam e emotes que aprendem.
Pedido do usuário (17/11/2026), depois de uma live com chat pequeno (skipnho, 0,15 msg/s) passar 15 min sem corte:
- a IA precisa saber QUE JOGO é (categoria da plataforma, título, chat e a própria tela) e conhecer o jogo
(pesquisa na web, guardada por jogo);
- a IA precisa VER a tela (frames) e procurar momentos sozinha, mesmo sem pico de chat (varredura);
- achar a webcam do streamer para o layout câmera-em-cima;
- emotes da Twitch/7TV/BTTV/FFZ contam como reação e ganham peso por canal conforme os cortes aprovados.
"""
from __future__ import annotations
import json
import logging
import re
import threading
import time
from pathlib import Path
from typing import TYPE_CHECKING
from . import clip_delete, layout
from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable
from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context
from .scoring import fit_window
from .sources import parse_source
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.intel")
# faceTrack: rastreio do rosto do streamer (face.py) — reforça/cria cortes e vai em texto para o analista.
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True}
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação
CAM_MAX_ATTEMPTS = 6 # falha sem rosto decidido (poucos quadros legíveis): no máximo isto de tentativas
GAME_CHECK_S = 600 # rechecar a categoria da live a cada 10 min (o streamer troca de jogo)
SCAN_FRAME_EVERY_S = 30
SCAN_MAX_FRAMES = 7
MEMORY_KEEP = 6
SCAN_MAX_MOMENTS = 2
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
class CamRetryLater(JudgeError):
"""Câmera local indisponível por um motivo passageiro (modelo/download): não é "sem câmera"."""
def game_id(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources")
def clean_profile(raw: dict) -> dict:
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
items, seen = [], set()
for item in raw.get(key) or []:
text = str(item or "").strip()[:300]
if key == "hashtags":
text = to_tag(text) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
continue
if text and text.lower() not in seen:
seen.add(text.lower())
items.append(text)
out[key] = items[:20]
return out
class Intel:
def __init__(self, engine: "Engine"):
self.e = engine
self.catalog = EmoteCatalog()
self._weights: dict[str, tuple[float, dict[str, float]]] = {}
self._rooms_ready: set[str] = set()
self._game_checked: dict[int, float] = {}
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória
self.last_scan_error: str | None = None
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
self.opts = dict(OPTION_DEFAULTS)
for key in OPTION_DEFAULTS:
if f"opt_{key}" in saved:
self.opts[key] = json.loads(saved[f"opt_{key}"])
# ---------------------------------------------------------------- opções (painel)
def set_options(self, values: dict) -> dict:
clean = {}
for key, value in values.items():
if key not in OPTION_DEFAULTS or value is None:
continue
if key == "scanIntervalS":
value = int(value)
if not 60 <= value <= 900:
raise JudgeError("intervalo da varredura vai de 60 a 900 s")
else:
value = bool(value)
clean[key] = value
self.opts.update(clean)
self.e.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
[(f"opt_{k}", json.dumps(v)) for k, v in clean.items()])
return dict(self.opts)
# ---------------------------------------------------------------- canal / configuração do corte
@staticmethod
def channel_key(session: dict) -> str:
source = parse_source(session["url"])
return source.channel_id if source.channel else ""
def settings_for(self, session: dict) -> dict:
channel = None
if session.get("channel_id"):
channel = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
return layout.merge(loads(channel["settings_json"], {}) if channel else {}, loads(session.get("settings_json"), {}))
# ---------------------------------------------------------------- emotes
def ingest_chat(self, session_id: int, channel_key: str, room_id: str | None,
batch: list[tuple[float, str, str, list[str]]]) -> None:
if room_id:
if room_id not in self._rooms_ready:
self.e.db.run("UPDATE sessions SET room_id = ? WHERE id = ? AND room_id IS NULL", room_id, session_id)
# Baixa o catálogo do canal fora da linha do chat (APIs externas podem demorar).
self._rooms_ready.add(room_id)
threading.Thread(target=self.catalog.names, args=(room_id,), daemon=True).start()
catalog = self.catalog.cached(room_id)
rows, seen = [], []
for wall, user, text, twitch_emotes in batch:
found = extract(text, twitch_emotes, catalog)
rows.append((session_id, wall, user, text, json.dumps([n for n, _ in found], ensure_ascii=False) if found else None))
seen.extend(found)
self.e.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, ?, ?, ?)", rows)
if channel_key and seen:
ts = now()
self.e.db.many(
"INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES (?, ?, ?, 1, 0, ?, ?)"
" ON CONFLICT (channel_key, name) DO UPDATE SET uses = uses + 1, last_seen = excluded.last_seen",
[(channel_key, name, source, ts, ts) for name, source in seen])
def weights(self, channel_key: str) -> dict[str, float]:
cached = self._weights.get(channel_key)
if cached and time.time() - cached[0] < 30:
return cached[1]
rows = self.e.db.all("SELECT name, weight FROM emotes WHERE channel_key = ? AND weight != 0", channel_key)
weights = {r["name"]: r["weight"] for r in rows}
self._weights[channel_key] = (time.time(), weights)
return weights
def bonus(self, emotes: list[str], channel_key: str) -> float:
return message_bonus(emotes, self.weights(channel_key)) if emotes else 0.0
def learn_from_clip(self, clip: dict, positive: bool, factor: float = 1.0, mark: bool = False) -> int:
"""Emotes da reação do corte (−10 s a +6 s do pico) ganham (aprovado) ou perdem (rejeitado) peso no canal."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session or (mark and clip.get("learned")):
return 0
key = self.channel_key(session)
if not key:
return 0
tl = self.e.load_timeline(session["id"], max(0.0, clip["peak_s"] - 120))
names = {e for m in tl["chat"] if clip["peak_s"] - 10 <= m.t <= clip["peak_s"] + 6 for e in m.emotes}
delta = learn_delta(positive) * factor
self.e.db.many("UPDATE emotes SET weight = MAX(-1.0, MIN(3.0, weight + ?)) WHERE channel_key = ? AND name = ?",
[(delta, key, n) for n in names])
if mark:
self.e.db.run("UPDATE clips SET learned = 1 WHERE id = ?", clip["id"])
self._weights.pop(key, None)
return len(names)
# ---------------------------------------------------------------- jogo
def check_game(self, session: dict, force: bool = False) -> None:
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo."""
if session["kind"] != "live":
return
last = self._game_checked.get(session["id"], 0)
if not force and time.time() - last < GAME_CHECK_S:
return
self._game_checked[session["id"]] = time.time()
meta = self.e.check_meta(session["url"])
if not meta:
return
if meta.get("title") and not session.get("title"):
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
category = (meta.get("category") or "").strip()
if category and category != session.get("game") and session.get("game_source") != "user":
self.set_game(session["id"], category, "platform")
def set_game(self, session_id: int, name: str, source: str) -> None:
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
return
history = loads(session["games_json"], [])
history.append({"game": name, "source": source, "atS": session["duration_s"], "at": now()})
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
gid = game_id(name)
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
def research_pending(self) -> None:
if not self.e.judge.enabled:
return # IA desligada: o jogo fica 'pending' até ligar (antes: um WARNING no log a cada 30 s)
for game in self.e.db.all("SELECT * FROM games WHERE status = 'pending' LIMIT 1"):
self.research(game["id"])
def research(self, gid: str) -> dict:
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo")
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
try:
profile = self.e.judge.research_game(game["name"], title, notes)
except (JudgeError, json.JSONDecodeError) as exc:
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
raise JudgeError(str(exc)) from exc
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?",
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid)
return profile
def save_profile(self, gid: str, profile: dict) -> dict:
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready')."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
clean = clean_profile(profile)
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?",
json.dumps(clean, ensure_ascii=False), now(), gid)
return clean
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA")
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]})
try:
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
except json.JSONDecodeError as exc:
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
reply = str(data.get("reply") or "").strip()[:600]
profile = clean_profile(data)
notes = loads(game.get("notes_json"), [])
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?,"
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False),
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid)
return profile, reply
def delete_note(self, gid: str, index: int) -> None:
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
game = self.e.db.get("SELECT notes_json FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
notes = loads(game["notes_json"], [])
if 0 <= index < len(notes):
notes.pop(index)
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
def profile(self, name: str) -> dict | None:
if not name:
return None
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name))
return loads(row["profile_json"], None) if row else None
def session_game(self, session: dict) -> tuple[str, dict | None]:
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
senão a categoria e, sem perfil dela, o jogo que a IA viu na tela."""
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
game, screen = session.get("game") or "", session.get("screen_game") or ""
profile = self.profile(game)
if profile or confirmed:
return game, profile
screen_profile = self.profile(screen) if screen.lower() not in ("", "desconhecido") else None
return (screen, screen_profile) if screen_profile else (game or ("" if screen.lower() == "desconhecido" else screen), None)
def context(self, session: dict) -> str:
memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
return game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed)
# ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
if not self.opts["vision"]:
return []
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
for s in self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])]
out_dir = self.e.repo_path(session["dir"]) / "frames"
frames = []
for t in times:
try:
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
log.info("frame %.0fs indisponível: %s", t, exc)
return frames
# ---------------------------------------------------------------- webcam
def maybe_detect_cam(self, session: dict) -> None:
"""Acha a câmera no início da sessão. A detecção local (YuNet) não precisa de IA, visão nem juiz ligados."""
if not self.opts["camDetect"] or time.time() < self._cam_retry_at.get(session["id"], 0.0):
return
saved = loads(session.get("cam_json"), None)
# Sem rosto na 1ª olhada (tela de "já volto" no começo da live): tenta de novo mais tarde enquanto grava.
# Falha sem rosto decidido (poucos quadros legíveis): tenta de novo pelo relógio, também em VOD/sessão parada.
due = saved and ((saved.get("retryAfterS") and session["duration_s"] >= saved["retryAfterS"])
or (saved.get("retryAt") is not None and time.time() >= saved["retryAt"]
and saved.get("attempts", 1) < CAM_MAX_ATTEMPTS))
if saved and not due:
return
analyzed = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 1", session["id"])["n"]
if analyzed < 2:
return
if self.settings_for(session)["layout"]["cam"]:
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
json.dumps({"skipped": "já definida", "source": "manual"}), session["id"])
return
try:
self.detect_cam(session["id"], apply=True)
except CamRetryLater as exc:
# Modelo indisponível/download falhou: nada a ver com a live. Não grava "sem câmera" (seria permanente e
# o rastreio marcaria tudo no_cam); tenta de novo em 5 min.
self._cam_retry_at[session["id"]] = time.time() + CAM_RETRY_S
log.warning("câmera da sessão %s: %s (nova tentativa em %d s)", session["id"], exc, CAM_RETRY_S)
except JudgeError as exc:
# Sem frame legível e sem IA: registra para não repetir a cada 30 s, com nova tentativa marcada
# (por tempo de gravação enquanto grava; pelo relógio em qualquer estado, até CAM_MAX_ATTEMPTS vezes).
attempts = (saved or {}).get("attempts", 0) + 1
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(
{"hasWebcam": False, "cam": None, "source": "yunet", "error": str(exc)[:200], "at": now(),
"retryAt": time.time() + CAM_RETRY_S, "attempts": attempts,
**({"retryAfterS": session["duration_s"] + CAM_RETRY_S} if session["status"] == "recording" else {})},
ensure_ascii=False), session["id"])
def detect_cam(self, session_id: int, apply: bool = False, use_ai: bool = False) -> dict:
"""Onde está a webcam. Primeiro local (YuNet + reaction.locate_cam, sem custo de IA); a IA só entra se o
local não achar rosto (e a IA estiver ligada com visão) ou se pedirem (`use_ai`). `cam_json.source` diz
quem achou: yunet | ai | manual."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session or session["duration_s"] < 5:
raise JudgeError("gravação curta demais para achar a câmera")
ai_ready = self.opts["vision"] and self.e.judge.enabled
local, local_error, transient = None, "", False
if not use_ai:
try:
local = self.e.face.locate(session)
except FaceUnavailable as exc: # modelo/biblioteca/download: passageiro, não é "sem câmera"
local_error, transient = str(exc), True
log.info("câmera local da sessão %s indisponível: %s", session_id, exc)
except FaceError as exc:
local_error = str(exc)
log.info("câmera local da sessão %s falhou: %s", session_id, exc)
if local is not None and (local["hasWebcam"] or not ai_ready):
result = local
if not local["hasWebcam"] and session["status"] == "recording":
result["retryAfterS"] = session["duration_s"] + CAM_RETRY_S
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
# Câmera em tela cheia (só o streamer) não vira layout câmera-em-cima; o rastreio usa o quadro inteiro.
if local["hasWebcam"] and not local["fullFrame"] and apply:
try:
rect = layout.validate({"layout": {"cam": local["cam"]}})["layout"]["cam"]
except layout.LayoutError:
rect = None
if rect:
self._apply_cam(session, rect)
return result
if not ai_ready:
if transient:
raise CamRetryLater(f"detector de rosto indisponível agora ({local_error}); tente de novo em instantes")
raise JudgeError(f"não deu para achar a câmera sem a IA ({local_error or 'sem rosto'}); ligue a visão ou marque à mão")
d = session["duration_s"]
frames = self.frames(session, [d * 0.25, d * 0.55, max(1.0, d - 8)], "cam")
if not frames:
raise JudgeError("sem frames (visão desligada ou blocos apagados)")
data = self.e.judge.detect_cam([p for _, p in frames])
rect = None
if data.get("has_webcam"):
try:
rect = layout.validate({"layout": {"cam": {k: data[k] for k in ("x", "y", "w", "h")}}})["layout"]["cam"]
except layout.LayoutError:
rect = None
result = {"hasWebcam": bool(data.get("has_webcam")), "cam": rect, "gameOnScreen": data.get("game_on_screen", ""),
"frame": self.e.rel(frames[-1][1]), "at": now(), "source": "ai"}
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
if rect and apply:
self._apply_cam(session, rect)
if result["gameOnScreen"] and result["gameOnScreen"].lower() not in ("desconhecido", "não identificável"):
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", result["gameOnScreen"][:120], session_id)
return result
def _apply_cam(self, session: dict, rect: dict) -> None:
"""Câmera achada vira padrão do canal (se o canal não tiver uma); sem canal, vale para a sessão."""
if session.get("channel_id"):
row = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
current = loads(row["settings_json"], {}) if row else {}
if row and not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(current), session["channel_id"])
return
current = loads(session.get("settings_json"), {})
if not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(current), session["id"])
# ---------------------------------------------------------------- varredura
def scan_due(self, session: dict, analyzed_until: float) -> tuple[float, float] | None:
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
if session["status"] == "recording" and session["kind"] == "vod":
return None # VOD baixa mais rápido que o tempo real: varre quando terminar
lo = session["scanned_until"]
hi = lo + self.opts["scanIntervalS"]
if hi <= analyzed_until:
return lo, hi
if session["status"] in ("processing", "stopped") and analyzed_until - lo >= 20:
return lo, analyzed_until # fim da gravação: varre o resto
return None
def scan_session(self, session: dict) -> int | None:
"""Varre a próxima janela pronta. None = nada a varrer agora; senão, quantos cortes criou."""
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
tl = self.e.load_timeline(session["id"], max(0.0, session["scanned_until"] - 200))
window = self.scan_due(session, tl["analyzedUntil"])
if not window:
return None
lo, hi = window
cfg = self.settings_for(session)
dur = cfg["duration"]
back_lo = max(0.0, lo - dur["backtrackS"])
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
frames = self.frames(session, times, "scan")
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all(
"SELECT start_s, end_s, title FROM clips WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], back_lo, hi)]
existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
tl["chat"], self.context(session), frames, existing, dur["minS"], dur["maxS"])
created = 0
try:
data = self.e.judge.scan(prompt, [p for _, p in frames])
self.last_scan_error = None
except (JudgeError, json.JSONDecodeError) as exc:
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
self.last_scan_error = str(exc)[:300]
log.warning("varredura %s %.0f–%.0fs falhou: %s", session["id"], lo, hi, exc)
data = {"moments": [], "summary": "", "screen_game": ""}
proposals = data.get("moments", [])[:SCAN_MAX_MOMENTS]
for moment in proposals:
if self._insert_scan_moment(session, moment, back_lo, hi, dur, existing):
created += 1
# Quantas propostas a IA fez e quantas viraram candidato (as outras: nota < SCAN_MIN_PROPOSAL, curtas ou em
# cima de um corte). Antes não ficava registrado (diagnóstico de 17/11/2026: impossível saber se a varredura
# não propôs nada ou se foi barrada).
log.info("varredura %s %.0f–%.0fs: %d proposta(s), %d candidato(s)", session["id"], lo, hi, len(proposals), created)
memory = loads(session.get("memory_json"), [])
if data.get("summary") or proposals:
memory.append({"fromS": lo, "toS": hi, "summary": str(data.get("summary") or "")[:240],
"proposals": len(proposals), "created": created})
screen = str(data.get("screen_game") or "")
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel"):
screen = ""
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?",
hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
if screen and not session.get("game"):
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela
return created
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
"""Momento proposto pela varredura vira CANDIDATO: passa pelos dois juízes (analista + editor) como os do chat."""
try:
# Mínimo + 1 s de verdade: se o fim bate no fim da janela, o início recua (fit_window).
start, end = fit_window(float(m["start_s"]), float(m["end_s"]), lo, hi,
layout.min_target({"duration": dur}), float(dur["maxS"]), keep="start")
score = max(0.0, min(10.0, float(m["score"])))
except (KeyError, TypeError, ValueError):
return False
if end - start < min(10.0, dur["minS"]) or score < SCAN_MIN_PROPOSAL:
return False
from .scoring import overlaps # import local: evita ciclo na carga do módulo
if any(overlaps(start, end, a, b) for a, b, _ in existing):
return False
ts = now()
reasons = {"via": "varredura", "scanFromS": lo, "scanToS": hi, "proposalScore": score,
"proposalTitle": str(m.get("title", ""))[:100], "proposalReason": str(m.get("reason", ""))[:300]}
self.e.db.run(
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
" VALUES (?, ?, ?, ?, ?, 'ai', ?, 'candidate', ?, ?)",
session["id"], round((start + end) / 2, 2), round(start, 2), round(end, 2), score,
json.dumps(reasons, ensure_ascii=False), ts, ts)
existing.append((start, end, ""))
return True
+640
View File
@@ -0,0 +1,640 @@
"""IA do Clipador pelas CLIs já logadas no PC (Codex/GPT por padrão, ou Claude) — sem chave de API.
Quatro usos, todos com saída JSON validada por schema:
1. **juiz** de candidato (chat/áudio apontaram): manter/descartar, nota, início/fim, título e legenda. Vê a
transcrição com bastante tempo para trás (o comentário vem DEPOIS da ação), o chat, os emotes, o perfil do
jogo e FRAMES da tela.
2. **varredura**: a cada poucos minutos de gravação a IA olha a janela inteira (fala + tela + chat) e propõe
momentos mesmo sem pico de chat — essencial em live pequena (3–5 pessoas) ou chat que reage pouco.
3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades.
4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima.
Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`) ou `claude`
(`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch).
"""
from __future__ import annotations
import json
import logging
import os
import re
import shutil
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from pathlib import Path
from . import layout
from .scoring import ChatMessage, Word, fit_window
log = logging.getLogger("cenaforge_clipper.judge")
PROVIDERS = ("codex", "claude", "off")
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku"}
CLAUDE_MODELS = [
{"id": "haiku", "label": "Haiku (mais barato)"},
{"id": "sonnet", "label": "Sonnet (equilíbrio)"},
{"id": "opus", "label": "Opus (mais capaz, mais caro)"},
]
CONTEXT_AFTER_S = 15.0
# Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min.
DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"])
DEFAULT_MAX_S = float(layout.DEFAULTS["duration"]["maxS"])
DEFAULT_BACKTRACK_S = float(layout.DEFAULTS["duration"]["backtrackS"])
TIMEOUT_S, RESEARCH_TIMEOUT_S = 240, 420
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
# Economia de tokens (medido em 17/11/2026, codex-cli 0.169.0): cada chamada do juiz é um processo novo e
# pagava ~77 mil caracteres fixos (~19 mil tokens) antes do prompt — instruções de agente de código (18 mil),
# ferramentas (46 mil: exec, plugins, computer-use) e listas de skills/apps. Uma live de 3,7 h = 150 chamadas.
# Sem busca na web o juiz não usa ferramenta nenhuma (as imagens vão por `-i`), então: o texto do juiz
# substitui as instruções de base e os recursos com ferramentas saem. Resultado: ~35 mil caracteres fixos.
# Com `--search` (pesquisa de jogo) só saem os extras; a web do Codex depende das ferramentas de execução.
CODEX_TOOL_FEATURES = ("plugins", "apps", "shell_tool", "unified_exec", "code_mode_host", "sleep_tool",
"skill_search", "tool_suggest", "in_app_browser", "browser_use")
CODEX_EXTRA_FEATURES = ("computer_use", "image_generation", "goals", "hooks")
CODEX_UNUSED_PLUGINS = ("computer-use@openai-bundled", "unified-computer-use@openai-bundled")
def codex_lean_overrides(search: bool, config_file: Path | None = None) -> list[str]:
"""Overrides `-c` só para esta chamada (a config global do Codex não muda)."""
features = CODEX_EXTRA_FEATURES + (() if search else CODEX_TOOL_FEATURES)
overrides = [f"features.{name}=false" for name in features]
try:
config = (config_file or Path.home() / ".codex" / "config.toml").read_text(encoding="utf-8")
except OSError:
config = ""
# `-c mcp_servers={}` não desliga (o Codex mescla tabelas): é preciso `enabled=false` por servidor.
for name in dict.fromkeys(re.findall(r'^\s*\[mcp_servers\.("?)([A-Za-z0-9_-]+)\1\]\s*$', config, re.M)):
overrides.append(f"mcp_servers.{name[1]}.enabled=false")
for plugin in CODEX_UNUSED_PLUGINS:
if f'[plugins."{plugin}"]' in config:
overrides.append(f'plugins."{plugin}".enabled=false')
return [arg for item in overrides for arg in ("-c", item)]
# ---------------------------------------------------------------- guia editorial (pesquisa de 16–17/11/2026)
CLIP_GUIDE = """O que faz um bom corte de live (pesquisa de mercado, 2026):
- Abre no momento forte: o espectador decide em 1–2 s. Nada de "como eu tava falando".
- Se explica sozinho: quem nunca viu a live entende em poucos segundos (contexto mínimo no começo).
- Rende corte: reação forte (susto, risada, raiva), jogada absurda/virada, falha engraçada, treta, história que
se desenrola, fala marcante, e INFORMAÇÃO NOVA DO JOGO (mecânica, segredo, novidade, comparação) — em
lançamentos (ex.: GTA 6) informação vale tanto quanto reação.
- Não rende: espera, menu/loading, leitura de doação/propaganda, conversa sem gancho, piada interna da live.
- TEMPO: o streamer costuma comentar DEPOIS da ação. Volte até o início da AÇÃO que motivou o comentário (pode
ser de 20 s a 2 min antes da fala, até o limite de volta informado) — o corte precisa mostrar a ação e a reação.
- Corte justo: termina logo depois do pagamento (reação/resolução)."""
# Gírias/memes do chat (BR/Twitch) que mudam o sentido do momento. O analista interpreta com o contexto.
CHAT_GLOSSARY = """Gírias comuns do chat (interprete pelo contexto):
- "server chinês", "ping", "lag", "travou/travando", "exit lag", "bugou", "rubberband", "teleportou" → o jogo ou a
live está travando/com atraso (personagem pulando de lugar, morrendo do nada) — a graça é o lag.
- "kkkk", "KEKW", "LUL", "OMEGALUL", "ICANT", "PepeLaugh" → risada; "?????" → confusão/não entenderam;
"F" → morte/perda/luto; "W"/"L" → vitória/derrota; "Pog/POGGERS" → impressionados; "monkaS/monkaW" → tensão;
"clipa/clip it" → pedido de corte; "hack/hackudo" → suspeita de trapaça; "gg" → fim de partida.
- Emotes próprios do canal (prefixo do streamer, ex.: skpPog) carregam a mesma reação do emote original."""
SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada",
"historia", "informacao_do_jogo", "reacao", "outro")
ANALYSIS_SCHEMA = {
"type": "object",
"properties": {
"situation": {"type": "string", "enum": list(SITUATIONS)},
"what_happened": {"type": "string"},
"screen": {"type": "string"},
"speech": {"type": "string"},
"chat_meaning": {"type": "string"},
"confidence": {"type": "number"},
"action_start_s": {"type": "number"},
"reaction_end_s": {"type": "number"},
"hook": {"type": "string"},
},
"required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence",
"action_start_s", "reaction_end_s", "hook"],
"additionalProperties": False,
}
ANALYST_SYSTEM = """Você é o ANALISTA de uma equipe de cortes de live. Não escreve título: descreve com fidelidade
O QUE ACONTECEU no trecho, para o editor decidir. Recebe contexto do jogo, transcrição com tempos, FRAMES da tela
com o instante de cada um e o chat.
Cruze as três fontes antes de concluir: a fala sozinha engana (ex.: "tô jogando três jogos… morri, morri" junto
de chat "server chinês?/kkkk" e a tela pulando = o jogo está travando e ele morre por causa do lag, não está
jogando três jogos). O chat reage alguns segundos depois do acontecimento.
""" + CHAT_GLOSSARY + """
Campos:
- situation: o tipo do momento (um da lista).
- what_happened: 2–3 frases factuais do que aconteceu, na ordem, sem exagero.
- screen: o que os frames mostram (cite o nº do frame) — ou "frames não ajudam".
- speech: o que a fala revela (cite o instante).
- chat_meaning: o que o chat está dizendo/rindo e por quê.
- confidence: 0–1, quanto você tem certeza da interpretação (baixe se as fontes não batem).
- action_start_s: instante (s da gravação) em que começa a AÇÃO que gerou a reação (pode ser antes da fala).
- reaction_end_s: instante em que a reação/pagamento termina.
- hook: o que prenderia alguém nos 2 primeiros segundos do corte.
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
VERDICT_SCHEMA = {
"type": "object",
"properties": {
"keep": {"type": "boolean"},
"score": {"type": "number"},
"start_s": {"type": "number"},
"end_s": {"type": "number"},
"title": {"type": "string"},
"caption": {"type": "string"},
"hashtags": {"type": "array", "items": {"type": "string"}},
"reason": {"type": "string"},
},
"required": ["keep", "score", "start_s", "end_s", "title", "caption", "hashtags", "reason"],
"additionalProperties": False,
}
# A varredura só aponta momentos (o juiz escreve título/legenda/hashtags depois): sem `keep` e sem `hashtags`.
_MOMENT = {
"type": "object",
"properties": {k: v for k, v in VERDICT_SCHEMA["properties"].items() if k not in ("keep", "hashtags")},
"required": ["score", "start_s", "end_s", "title", "caption", "reason"],
"additionalProperties": False,
}
SCAN_SCHEMA = {
"type": "object",
"properties": {
"screen_game": {"type": "string"},
"has_webcam": {"type": "boolean"},
"summary": {"type": "string"},
"moments": {"type": "array", "items": _MOMENT},
},
"required": ["screen_game", "has_webcam", "summary", "moments"],
"additionalProperties": False,
}
PROFILE_SCHEMA = {
"type": "object",
"properties": {
"name": {"type": "string"},
"summary": {"type": "string"},
"genre": {"type": "string"},
"mechanics": {"type": "array", "items": {"type": "string"}},
"clip_worthy": {"type": "array", "items": {"type": "string"}},
"avoid": {"type": "array", "items": {"type": "string"}},
"jargon": {"type": "array", "items": {"type": "string"}},
"news": {"type": "array", "items": {"type": "string"}},
"hashtags": {"type": "array", "items": {"type": "string"}},
"sources": {"type": "array", "items": {"type": "string"}},
},
"required": ["name", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources"],
"additionalProperties": False,
}
CAM_SCHEMA = {
"type": "object",
"properties": {
"has_webcam": {"type": "boolean"},
"x": {"type": "number"}, "y": {"type": "number"}, "w": {"type": "number"}, "h": {"type": "number"},
"game_on_screen": {"type": "string"},
},
"required": ["has_webcam", "x", "y", "w", "h", "game_on_screen"],
"additionalProperties": False,
}
JUDGE_SYSTEM = """Você é o EDITOR de cortes de live para Shorts, TikTok, Reels e YouTube, em português do Brasil.
Recebe um trecho candidato de uma live (contexto do jogo, transcrição com tempos, chat, emotes) e, quando houver,
a ANÁLISE do analista da equipe, que já cruzou tela, fala e chat. Confie na análise para entender O QUE
aconteceu; o seu trabalho é decidir se rende corte e escrever título e legenda FIÉIS a isso.
""" + CLIP_GUIDE + """
""" + CHAT_GLOSSARY + """
Título e legenda: descrevem a situação real (ex.: se a análise diz lag, o título é sobre o lag/travamento, não
sobre a frase solta da transcrição). Com confidence da análise < 0,5, seja descritivo e não invente detalhes.
Use action_start_s/reaction_end_s da análise como base para start_s/end_s."""
JUDGE_SYSTEM += """
Regras da resposta:
- keep=false para o que não rende; score de 0 a 10 (7+ = corte forte; abaixo de 5 = descartar).
- start_s e end_s em segundos da gravação, DENTRO da janela recebida e respeitando a duração mínima/máxima
informada; comece antes da ação (contexto) e termine logo depois da reação. Não corte no meio de uma frase.
- title: até 70 caracteres, chamativo mas verdadeiro, sem inventar o que não está na fala/tela.
- caption: 1–2 frases, SEM hashtags e sem link (o sistema acrescenta as hashtags do canal e do jogo e o crédito).
- hashtags: 2 a 4 tags DO MOMENTO, sem "#": a missão/atividade, o evento, o modo, o lugar, o item ou o personagem
que aparece NESTE trecho (ex.: nome da missão ou do assalto, "perseguição", "sorteio", "Lamborghini", "lag").
Prefira os termos do perfil do jogo (mecânicas, gírias) e o que o streamer e o chat falam. Nada genérico
("gameplay", "live", "viral"), nada que não aconteça aqui, e não repita o canal nem o nome do jogo.
- reason: uma frase dizendo por que manteve ou descartou (cite o que viu na tela, se ajudou).
- Não use ferramentas nem leia nada além do que foi entregue. Responda só com o JSON pedido."""
SCAN_SYSTEM = """Você é editor de cortes de live e está ASSISTINDO uma live por janelas de alguns minutos.
Recebe o contexto do jogo, a transcrição com tempos (segundos da gravação), frames da tela com o instante de
cada um, o chat (pode ser quase vazio: live pequena) e os cortes já feitos nessa região.
""" + CLIP_GUIDE + """
Tarefa: aponte de 0 a 2 momentos desta janela que dariam um bom corte SOZINHOS. Se nada rende, devolva
moments=[] (é o normal na maior parte do tempo — não force). Não repita um corte já feito.
- start_s/end_s dentro da janela recebida (pode começar até o limite de "volta" informado para pegar a ação),
com a duração mínima/máxima informada.
- screen_game: o jogo que aparece na tela (ou "desconhecido"); has_webcam: há câmera do streamer no quadro?
- summary: 1 frase do que está acontecendo na janela (vira memória para as próximas janelas).
- title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
PROFILE_SYSTEM = """Você pesquisa jogos para um editor de cortes de live em português do Brasil. Use a busca na
web para confirmar o que é o jogo (nome da categoria da Twitch pode ser abreviado ou ambíguo). Seja factual e
cite as fontes (URLs). Responda só com o JSON pedido, textos em português do Brasil.
- summary: 2–3 frases do que é o jogo e como se joga.
- mechanics: até 8 mecânicas/sistemas que aparecem em gameplay.
- clip_worthy: até 10 situações que rendem corte NESTE jogo (específicas, não genéricas).
- avoid: até 6 situações que parecem momento mas não rendem (menus, farm, fila...).
- jargon: até 12 termos/gírias que streamer e chat usam (para entender a transcrição).
- news: até 6 novidades recentes com mês/ano (lançamento, atualização, polêmica) que tornam informação valiosa.
- hashtags: 3 a 6 hashtags que o público usa para ESTE jogo no TikTok, Shorts e Reels (Brasil): o nome do jogo sem
espaço, abreviação conhecida, o modo/gênero quando for buscado (ex.: GTARP). A primeira é a principal do jogo.
Escreva com "#", sem inventar tag que ninguém usa.
- sources: até 5 URLs usadas.
Se vierem "pedidos do usuário", eles valem mais que a pesquisa: inclua o que ele pediu para acrescentar e respeite
o que ele mandou tirar ou corrigir (ele conhece o canal e o jogo)."""
REFINE_SYSTEM = """Você mantém o perfil de um jogo usado por um editor de cortes de live em português do Brasil.
Recebe o perfil ATUAL (JSON) e um PEDIDO do usuário (acrescentar, corrigir, tirar ou detalhar algo). Devolva o
perfil COMPLETO atualizado, no mesmo formato:
- mantenha tudo o que o pedido não mexe, com o mesmo texto;
- aplique o pedido no campo certo (situação que rende corte → clip_worthy; o que não rende → avoid; gíria → jargon;
mecânica → mechanics; novidade → news com mês/ano; hashtag do jogo → hashtags, com "#", a principal primeiro),
escrito no estilo dos itens que já estão lá;
- os limites de tamanho das listas podem crescer até 15 itens quando o usuário pedir para acrescentar;
- se precisar confirmar um fato, pode usar a busca na web e acrescentar a URL em sources;
- o usuário conhece o canal e o jogo: o que ele afirma vale, mesmo que você não ache na web;
- se vier uma SEÇÃO em foco, o pedido é sobre ela: mexa nela (outras só se o pedido disser);
- pode transformar um pedido genérico em itens concretos e úteis para o editor (ex.: "reação do streamer conta"
vira "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga");
- reply: 1–2 frases para o usuário dizendo o que você mudou (ou, se o pedido for uma pergunta, a resposta).
Textos em português do Brasil. Responda só com o JSON pedido."""
REFINE_SCHEMA = {
"type": "object",
"properties": {**PROFILE_SCHEMA["properties"], "reply": {"type": "string"}},
"required": [*PROFILE_SCHEMA["required"], "reply"],
"additionalProperties": False,
}
PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas",
"hashtags": "Hashtags",
"news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes"}
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e,
se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro:
x, y = canto superior esquerdo; w, h = largura e altura. Sem webcam: has_webcam=false e x=y=w=h=0.
game_on_screen: o jogo que aparece (ou "desconhecido"). Responda só com o JSON pedido."""
@dataclass(frozen=True)
class Verdict:
keep: bool
score: float
start_s: float
end_s: float
title: str
caption: str
reason: str
model: str
# Tags DO MOMENTO (sem "#"), escolhidas pela IA; as do canal e do jogo o sistema põe (app/hashtags.py).
hashtags: tuple[str, ...] = ()
class JudgeError(RuntimeError):
pass
# ---------------------------------------------------------------- prompts
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
confirmed: bool = False) -> str:
lines = [f"Título da live: {live_title or '(desconhecido)'}"]
if confirmed:
# O usuário confirmou no painel: não questionar (jogo novo/pouco conhecido lembra outros na tela).
lines.append(f"Jogo CONFIRMADO pelo usuário: {game}. A tela pode lembrar outro jogo parecido (ex.: GTA, "
f"Warzone) — não questione o jogo; use o perfil abaixo para entender o que acontece.")
else:
lines.append(f"Jogo pela categoria da plataforma: {game or '(desconhecida)'}")
if screen_game and screen_game.lower() not in (game or "").lower():
lines.append(f"Jogo que a IA viu na tela recentemente: {screen_game} (confira nos frames; a categoria pode estar errada)")
if profile:
lines.append(f"Perfil do jogo: {profile.get('summary', '')}")
for key, label in (("clip_worthy", "Rende corte neste jogo"), ("avoid", "Não rende"),
("mechanics", "Mecânicas/atividades (termos para as hashtags do momento)"),
("jargon", "Gírias/termos"), ("news", "Novidades")):
if profile.get(key):
lines.append(f"{label}: " + "; ".join(profile[key][:10]))
if history:
lines.append(f"O que aconteceu antes na live: {history}")
return "\n".join(lines)
def _transcript(words: list[Word], lo: float, hi: float) -> str:
lines, current, current_t = [], [], None
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start):
if current_t is None or word.start - current_t > 4 or len(current) >= 14:
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
current, current_t = [], word.start
current.append(word.word)
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
return "\n".join(lines) or "(sem fala transcrita)"
def _chat_block(chat: list[ChatMessage], lo: float, hi: float, focus: float | None, bucket_s: int = 5) -> str:
buckets: dict[int, int] = {}
emotes: dict[str, int] = {}
sample: list[str] = []
for message in chat:
if lo <= message.t <= hi:
b = int(message.t // bucket_s * bucket_s)
buckets[b] = buckets.get(b, 0) + 1
for e in set(message.emotes):
emotes[e] = emotes.get(e, 0) + 1
near = focus is None or focus - 10 <= message.t <= focus + 8
if near and len(sample) < 60:
sample.append(f"[{message.t:.0f}s] {message.text[:80]}")
rate = ", ".join(f"{t}s:{n}" for t, n in sorted(buckets.items())) or "sem chat"
top = ", ".join(f"{e}×{n}" for e, n in sorted(emotes.items(), key=lambda kv: -kv[1])[:12]) or "nenhum"
return (f"Mensagens do chat por {bucket_s} s: {rate}\nEmotes mais usados: {top}\n"
f"Amostra do chat:\n" + ("\n".join(sample) or "(sem chat)"))
def _frames_block(frames: list[tuple[float, Path]]) -> str:
if not frames:
return "Frames: (nenhum)"
return "Frames anexados, em ordem: " + ", ".join(f"#{i + 1} = {t:.0f}s" for i, (t, _) in enumerate(frames))
def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, peak_s: float,
words: list[Word], chat: list[ChatMessage], heuristic: dict, live_title: str = "", *,
context: str = "", frames: list[tuple[float, Path]] | None = None,
backtrack_s: float = DEFAULT_BACKTRACK_S, min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S,
face: str = "") -> str:
"""Prompt do juiz. Janela = candidato com `backtrack_s` para trás (a ação vem antes do comentário).
`face`: resumo do rosto do streamer na janela (face.FaceService.summary); vazio = sem câmera/rastreio."""
lo, hi = max(0.0, start_s - backtrack_s), end_s + CONTEXT_AFTER_S
return (
f"Canal: {streamer} ({platform})\n"
+ (context or f"Título da live: {live_title or '(desconhecido)'}") + "\n\n"
f"Janela disponível: {lo:.0f}s a {hi:.0f}s. Candidato da heurística: {start_s:.0f}s a {end_s:.0f}s; "
f"pico de reação em {peak_s:.0f}s. Duração do corte: {min_s:.0f} a {max_s:.0f} s.\n"
f"Sinais da heurística: {json.dumps(heuristic, ensure_ascii=False)}\n"
+ (f"Rosto do streamer (expressão medida na webcam, relativa ao normal dele): {face}\n" if face else "")
+ f"{_frames_block(frames or [])}\n\n"
f"Transcrição:\n{_transcript(words, lo, hi)}\n\n"
f"{_chat_block(chat, lo, hi, peak_s)}"
)
def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_lo: float, words: list[Word],
chat: list[ChatMessage], context: str, frames: list[tuple[float, Path]],
existing: list[tuple[float, float, str]], min_s: float, max_s: float) -> str:
done = "; ".join(f"{a:.0f}–{b:.0f}s ({t[:40]})" for a, b, t in existing) or "nenhum"
return (
f"Canal: {streamer} ({platform})\n{context}\n\n"
f"Janela nova: {lo:.0f}s a {hi:.0f}s (pode voltar até {back_lo:.0f}s para pegar o início de uma ação).\n"
f"Duração do corte: {min_s:.0f} a {max_s:.0f} s. Cortes já feitos aqui: {done}\n"
f"{_frames_block(frames)}\n\n"
f"Transcrição:\n{_transcript(words, back_lo, hi)}\n\n"
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10)}"
)
def _clean(data: dict, start_s: float, end_s: float, model: str, lo: float | None = None, hi: float | None = None,
min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S) -> Verdict:
# `hashtags` é opcional na leitura: resposta sem ele (modelo antigo/cache) segue com as tags do canal e do jogo.
missing = [k for k in VERDICT_SCHEMA["required"] if k not in data and k != "hashtags"]
if missing:
raise JudgeError(f"resposta sem os campos {missing}")
lo = max(0.0, start_s - DEFAULT_BACKTRACK_S) if lo is None else lo
hi = end_s + CONTEXT_AFTER_S if hi is None else hi
# Mínimo de verdade (pedido do dono, 17/11/2026): se o fim bate em `hi`, o início recua (antes ficava curto).
new_start, new_end = fit_window(float(data["start_s"]), float(data["end_s"]), lo, hi, min_s, max_s, keep="start")
if new_end - new_start < min(10.0, min_s): # resposta incoerente: fica com o candidato da heurística
new_start, new_end = start_s, end_s
return Verdict(
keep=bool(data["keep"]), score=max(0.0, min(10.0, float(data["score"]))),
start_s=round(new_start, 2), end_s=round(new_end, 2),
title=str(data["title"]).strip()[:100], caption=str(data["caption"]).strip()[:600],
reason=str(data["reason"]).strip()[:300], model=model,
hashtags=tuple(str(t).strip()[:40] for t in (data.get("hashtags") or [])[:6] if str(t).strip()),
)
# ---------------------------------------------------------------- executáveis das CLIs
def find_codex() -> list[str] | None:
"""Comando do Codex. No Windows o npm instala `codex.cmd` (lote não roda sem shell e escapa mal argumentos):
como no painel (agents.ts), rodamos o `codex.js` do pacote direto pelo Node."""
env = os.environ.get("CODEX_BIN")
if env:
return [shutil.which("node") or "node", env] if env.endswith(".js") else [env]
exe = shutil.which("codex.exe") if sys.platform == "win32" else shutil.which("codex")
if exe:
return [exe]
cmd = shutil.which("codex.cmd") or shutil.which("codex")
node = shutil.which("node")
if cmd and node:
js = Path(cmd).parent / "node_modules" / "@openai" / "codex" / "bin" / "codex.js"
if js.is_file():
return [node, str(js)]
return None
def find_claude() -> list[str] | None:
env = os.environ.get("CLAUDE_BIN")
if env:
return [env]
exe = shutil.which("claude.exe") if sys.platform == "win32" else shutil.which("claude")
return [exe] if exe else None
def codex_models(cache: Path | None = None) -> list[dict]:
"""Modelos que o Codex lista para esta conta (cache que a própria CLI mantém)."""
cache = cache or Path.home() / ".codex" / "models_cache.json"
try:
data = json.loads(cache.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError):
return [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
out = []
for m in data.get("models", []):
if isinstance(m, dict) and m.get("slug") and m.get("visibility", "list") == "list":
out.append({"id": m["slug"], "label": m.get("display_name") or m["slug"], "description": m.get("description", "")})
return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
# ---------------------------------------------------------------- IA
class Judge:
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = ""):
self.provider = provider if provider in PROVIDERS else "codex"
self.model = model or DEFAULT_MODELS.get(self.provider, "")
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor.
self.analyst_model = analyst_model
self.workdir = workdir
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None:
if provider not in PROVIDERS:
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
self.provider = provider
self.model = model.strip() or DEFAULT_MODELS.get(provider, "")
if analyst_model is not None:
self.analyst_model = analyst_model.strip()
@property
def enabled(self) -> bool:
return self.provider in ("codex", "claude")
def command(self) -> list[str] | None:
return find_codex() if self.provider == "codex" else find_claude() if self.provider == "claude" else None
def describe(self) -> dict:
cmd = self.command() if self.enabled else None
return {"provider": self.provider, "model": self.model if self.enabled else None,
"analystModel": (self.analyst_model or self.model) if self.enabled else None,
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None}
def models(self) -> dict:
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "defaults": DEFAULT_MODELS}
# ---------- usos
def analyze(self, prompt: str, images: list[Path]) -> dict:
"""1º juiz (ANALISTA): o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título."""
data = self.ask(ANALYST_SYSTEM, prompt, ANALYSIS_SCHEMA, images, model=self.analyst_model or self.model)
missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data]
if missing:
raise JudgeError(f"análise sem os campos {missing}")
data["confidence"] = max(0.0, min(1.0, float(data["confidence"])))
return data
def judge(self, prompt: str, start_s: float, end_s: float, images: list[Path] | None = None, *,
lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
max_s: float = DEFAULT_MAX_S) -> Verdict:
data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or [])
return _clean(data, start_s, end_s, f"{self.provider}:{self.model}", lo, hi, min_s, max_s)
def scan(self, prompt: str, images: list[Path]) -> dict:
data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images)
if not isinstance(data.get("moments"), list):
raise JudgeError("varredura sem a lista de momentos")
return data
def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict:
prompt = f"Categoria/jogo da live: {name}\nTítulo da live (pista extra): {live_title or '(nenhum)'}\n"
if notes:
prompt += "Pedidos do usuário (respeite):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
prompt += "Pesquise e devolva o perfil do jogo."
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S)
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> dict:
"""Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro
mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior."""
prompt = f"Jogo: {name}\nPerfil ATUAL:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
if section in PROFILE_SECTIONS:
prompt += f"SEÇÃO em foco: {section} ({PROFILE_SECTIONS[section]})\n"
if history:
prompt += "Conversa até aqui:\n" + "\n".join(
f"{'Usuário' if h.get('role') == 'user' else 'IA'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
prompt += f"PEDIDO do usuário:\n{instruction}\n\nDevolva o perfil completo atualizado e o reply."
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S)
def detect_cam(self, images: list[Path]) -> dict:
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images)
# ---------- execução
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
timeout: int = TIMEOUT_S, model: str | None = None) -> dict:
model = model or self.model
if self.provider == "codex":
return self._codex(system, prompt, schema, images, search, timeout, model)
if self.provider == "claude":
return self._claude(system, prompt, schema, images, search, timeout, model)
raise JudgeError("IA desligada")
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int) -> subprocess.CompletedProcess:
try:
result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd,
creationflags=NO_WINDOW)
except subprocess.TimeoutExpired as exc:
raise JudgeError(f"a CLI passou de {timeout} s") from exc
except OSError as exc:
raise JudgeError(f"não consegui rodar a CLI: {exc}") from exc
if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-2:]
raise JudgeError(f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}")
return result
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_codex()
if not cmd:
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)")
self.workdir.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(dir=self.workdir) as tmp:
schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json"
schema_file.write_text(json.dumps(schema), encoding="utf-8")
image_args = [arg for img in images for arg in ("-i", str(Path(img).resolve()))]
lean = codex_lean_overrides(search)
if search:
stdin = system + "\n\n---\n\n" + prompt
else:
# Sem ferramentas, o texto do juiz faz o papel das instruções de base do Codex (como o
# --system-prompt do Claude). String literal do TOML ('...'): o caminho do Windows não é escapado.
instructions = Path(tmp) / "instructions.md"
instructions.write_text(system, encoding="utf-8")
lean += ["-c", f"model_instructions_file='{instructions}'"]
stdin = prompt
# `--search` é opção global (antes de `exec`). Cada imagem com seu `-i`; o "-" (prompt pela entrada
# padrão) vem depois de uma opção de valor único para não ser lido como mais uma imagem.
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral",
"--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args,
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
self._run(args, stdin, Path(tmp), timeout)
try:
return json.loads(out.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise JudgeError("o Codex não devolveu o JSON pedido") from exc
def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_claude()
if not cmd:
raise JudgeError("Claude Code CLI não encontrado")
self.workdir.mkdir(parents=True, exist_ok=True)
tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else [])
extra: list[str] = []
if images:
# O Claude vê imagem lendo o arquivo (ferramenta Read): liberamos só a pasta das imagens.
for folder in sorted({str(Path(i).resolve().parent) for i in images}):
extra += ["--add-dir", folder]
prompt += "\n\nImagens (leia cada uma com a ferramenta Read, na ordem):\n" + "\n".join(
str(Path(i).resolve()) for i in images)
args = [*cmd, "-p", "--model", model, "--output-format", "json", "--json-schema", json.dumps(schema),
"--tools", ",".join(tools), *(["--allowedTools", ",".join(tools)] if tools else []), *extra,
# --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s).
"--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local",
"--system-prompt", system]
result = self._run(args, prompt, self.workdir, timeout)
try:
envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu JSON") from exc
if envelope.get("is_error"):
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
data = envelope.get("structured_output")
if not isinstance(data, dict):
try:
data = json.loads(envelope.get("result") or "")
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu o JSON pedido") from exc
return data
def analysis_block(analysis: dict) -> str:
"""Análise do 1º juiz no formato que o editor lê."""
return "Análise do ANALISTA (cruzou tela, fala e chat):\n" + json.dumps(analysis, ensure_ascii=False, indent=1)
+415
View File
@@ -0,0 +1,415 @@
"""Configuração do corte: formato (vertical/horizontal), layout, câmera do streamer, legenda, crédito e duração.
Fica por CANAL (padrão do streamer: a webcam dele mora sempre no mesmo canto) e pode ser sobrescrita por SESSÃO.
Efetiva = padrão ← canal ← sessão (campo a campo). O painel edita pelo modal de "Configuração do corte".
Formato (`format.aspect`):
- `vertical` (padrão): 1080×1920, para Shorts/Reels/TikTok;
- `horizontal`: 1920×1080, para o YouTube "tela grande" mostrando o próprio jogo.
Layouts no vertical (1080×1920):
- `blur`: vídeo 16:9 inteiro no meio, o próprio vídeo ampliado e desfocado no fundo (sem câmera definida);
- `cam_top`: webcam recortada em cima (`camHeight` da altura, padrão 1/3) + jogo embaixo, recortado no centro;
- `game_only`: só o jogo, recortado para preencher a tela (ou a região `game`, se definida);
- `cam_only`: a câmera do streamer em tela cheia.
No horizontal (1920×1080) só existem dois resultados: `cam_only` (câmera em tela cheia, se marcada) e "quadro
inteiro" (`full`, interno) para todos os outros modos — o quadro original inteiro, ou a região `game` se marcada.
Retângulos (`cam`, `game`) são normalizados 0–1 sobre o quadro original (x, y, w, h).
Textos (legenda, crédito, gancho, textos, chat, capa) são desenhados em ASS num QUADRO LÓGICO (`canvas_size`):
no vertical é o próprio 1080×1920; no horizontal é 2560×1440, que o libass reduz para 1920×1080 (escala 0,75).
Assim os mesmos tamanhos em px (legenda 84, gancho 68…) ficam proporcionais à altura menor do horizontal sem
mudar o JSON. Posições 0–1 continuam relativas ao quadro.
"""
from __future__ import annotations
import copy
import hashlib
import json
import logging
import re
from pathlib import Path
log = logging.getLogger("cenaforge_clipper.layout")
ASPECTS = ("vertical", "horizontal")
# Qualidades de gravação da live (grupo `capture`; regras e medições em app/capture.py).
CAPTURE_QUALITIES = ("best", "1440p", "1080p", "720p", "480p")
FRAME_SIZES = {"vertical": (1080, 1920), "horizontal": (1920, 1080)}
# Quadro lógico do ASS: no horizontal, 2560×1440 → o vídeo 1920×1080 mostra os textos a 75 %.
CANVAS_SIZES = {"vertical": (1080, 1920), "horizontal": (2560, 1440)}
W, H = FRAME_SIZES["vertical"] # compatibilidade: o quadro do vertical (padrão)
# cam_only = a câmera do streamer em tela cheia (sem o jogo), para o trecho em que a reação é o assunto.
MODES = ("auto", "blur", "cam_top", "game_only", "cam_only")
HEX_RE = re.compile(r"^#[0-9A-Fa-f]{6}$")
SYSTEM_FONTS = ("Arial Black", "Arial", "Impact", "Verdana", "Segoe UI Black", "Trebuchet MS")
# Fontes de vídeo curto EMPACOTADAS no repositório (assets/fonts, pasta plana: o fontsdir do libass não lê subpastas),
# com licença livre ao lado de cada arquivo e sha256 no fonts.lock.json. Pedido do dono (17/11/2026): escolher fonte
# na legenda, no gancho e nos textos.
FONTS_DIR = Path(__file__).resolve().parents[2] / "assets" / "fonts"
def _load_packaged_fonts(folder: Path) -> dict[str, str]:
"""{família: caminho relativo à raiz do repositório} das fontes do lock que existem e batem o sha256."""
try:
lock = json.loads((folder / "fonts.lock.json").read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
out = {}
for entry in lock.get("files", []):
file = folder.parent.parent / entry["path"]
try:
ok = hashlib.sha256(file.read_bytes()).hexdigest() == entry["sha256"]
except OSError:
ok = False
if ok:
out[entry["family"]] = entry["path"]
else:
log.warning("fonte %s ausente ou com sha256 diferente do lock: fora da lista", entry.get("path"))
return out
PACKAGED_FONTS = _load_packaged_fonts(FONTS_DIR)
FONTS = SYSTEM_FONTS + tuple(PACKAGED_FONTS)
HOOK_STYLES = ("plain", "banner")
HOOK_ANIMS = ("pop", "fade", "none", "slide")
# Gancho em tarja (referência do dono, 17/11/2026: tarja verde-limão atravessa a tela e o texto entra borrado e assenta
# nítido, letras brancas "cartoon" com contorno preto). Fonte padrão: Luckiest Guy, se estiver empacotada.
HOOK_FONT = "Luckiest Guy" if "Luckiest Guy" in PACKAGED_FONTS else "Arial Black"
# Margem do mínimo (pedido do dono, 17/11/2026: "se o mínimo é 60 tem que ser 60; o certo é sempre 1 s a mais").
# +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final.
DURATION_MARGIN_S = 1.0
DURATION_SLACK_S = 0.1
DEFAULTS: dict = {
"layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34},
"caption": {
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
},
"credit": {"enabled": True, "position": "top", "size": 44},
"duration": {"minS": 60, "maxS": 90, "backtrackS": 120},
"format": {"aspect": "vertical"},
# Gancho que o projeto da IA põe no começo do corte (o editor pode trocar por corte).
"hook": {"style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": HOOK_FONT, "anim": "slide", "seconds": 3.0},
# Qualidade de GRAVAÇÃO da live (app/capture.py): `best` = a maior que a live oferece; os outros são teto.
# Vale na próxima gravação ou retomada (a captura em andamento não troca de qualidade no meio).
"capture": {"quality": "best"},
}
class LayoutError(ValueError):
pass
def merge(*layers: dict | None) -> dict:
"""Mescla campo a campo (padrão ← canal ← sessão). Camadas vazias são ignoradas."""
out = copy.deepcopy(DEFAULTS)
for layer in layers:
for group, values in (layer or {}).items():
if group in out and isinstance(values, dict):
out[group].update({k: v for k, v in values.items() if k in out[group]})
return out
def _rect(value, name: str) -> dict | None:
if value is None:
return None
if not isinstance(value, dict) or set(value) != {"x", "y", "w", "h"}:
raise LayoutError(f"{name} precisa ser {{x, y, w, h}} (0–1) ou null")
r = {k: float(value[k]) for k in ("x", "y", "w", "h")}
if not (0 <= r["x"] < 1 and 0 <= r["y"] < 1 and 0.03 <= r["w"] <= 1 and 0.03 <= r["h"] <= 1
and r["x"] + r["w"] <= 1.0001 and r["y"] + r["h"] <= 1.0001):
raise LayoutError(f"{name} fora do quadro (valores 0–1, largura/altura ≥ 0,03)")
return {k: round(v, 4) for k, v in r.items()}
def validate(settings: dict) -> dict:
"""Valida uma camada parcial (canal ou sessão) e devolve só os campos conhecidos, normalizados."""
if not isinstance(settings, dict):
raise LayoutError("configuração precisa ser um objeto")
out: dict = {}
lay = settings.get("layout")
if lay is not None:
o: dict = {}
if "mode" in lay:
if lay["mode"] not in MODES:
raise LayoutError(f"layout.mode precisa ser um de {', '.join(MODES)}")
o["mode"] = lay["mode"]
if "cam" in lay:
o["cam"] = _rect(lay["cam"], "layout.cam")
if "game" in lay:
o["game"] = _rect(lay["game"], "layout.game")
if "camHeight" in lay:
o["camHeight"] = float(lay["camHeight"])
if not 0.2 <= o["camHeight"] <= 0.6:
raise LayoutError("layout.camHeight vai de 0,2 a 0,6")
out["layout"] = o
cap = settings.get("caption")
if cap is not None:
o = {}
for key in ("color", "highlight", "outline"):
if key in cap:
if not HEX_RE.match(str(cap[key])):
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
o[key] = str(cap[key]).upper()
if "font" in cap:
if cap["font"] not in FONTS:
raise LayoutError(f"caption.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = cap["font"]
for key, lo, hi in (("size", 40, 140), ("outlineWidth", 0, 14), ("maxWords", 1, 6)):
if key in cap:
o[key] = int(cap[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
if "y" in cap:
o["y"] = None if cap["y"] is None else float(cap["y"])
if o["y"] is not None and not 0.08 <= o["y"] <= 0.9:
raise LayoutError("caption.y vai de 0,08 a 0,9 (fração da altura) ou null = automático")
for key in ("enabled", "uppercase"):
if key in cap:
o[key] = bool(cap[key])
out["caption"] = o
cred = settings.get("credit")
if cred is not None:
o = {}
if "enabled" in cred:
o["enabled"] = bool(cred["enabled"])
if "position" in cred:
if cred["position"] not in ("top", "bottom"):
raise LayoutError("credit.position precisa ser top ou bottom")
o["position"] = cred["position"]
if "size" in cred:
o["size"] = int(cred["size"])
if not 24 <= o["size"] <= 80:
raise LayoutError("credit.size vai de 24 a 80")
out["credit"] = o
dur = settings.get("duration")
if dur is not None:
o = {}
for key, lo, hi in (("minS", 5, 120), ("maxS", 15, 180), ("backtrackS", 0, 120)):
if key in dur:
o[key] = float(dur[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"duration.{key} vai de {lo} a {hi}")
out["duration"] = o
if "duration" in out and out["duration"].get("minS", 0) >= out["duration"].get("maxS", 999):
raise LayoutError("duration.minS precisa ser menor que maxS")
hook = settings.get("hook")
if hook is not None:
if not isinstance(hook, dict):
raise LayoutError("hook precisa ser um objeto")
o = {}
if "style" in hook:
if hook["style"] not in HOOK_STYLES:
raise LayoutError(f"hook.style precisa ser um de {', '.join(HOOK_STYLES)}")
o["style"] = hook["style"]
for key in ("bg", "color"):
if key in hook:
if not HEX_RE.match(str(hook[key])):
raise LayoutError(f"hook.{key} precisa ser cor #RRGGBB")
o[key] = str(hook[key]).upper()
if "font" in hook:
if hook["font"] not in FONTS:
raise LayoutError(f"hook.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = hook["font"]
if "anim" in hook:
if hook["anim"] not in HOOK_ANIMS:
raise LayoutError(f"hook.anim precisa ser um de {', '.join(HOOK_ANIMS)}")
o["anim"] = hook["anim"]
if "seconds" in hook:
o["seconds"] = float(hook["seconds"])
if not 1 <= o["seconds"] <= 8:
raise LayoutError("hook.seconds vai de 1 a 8")
out["hook"] = o
fmt = settings.get("format")
if fmt is not None:
if not isinstance(fmt, dict):
raise LayoutError("format precisa ser um objeto")
o = {}
if "aspect" in fmt:
if fmt["aspect"] not in ASPECTS:
raise LayoutError(f"format.aspect precisa ser um de {', '.join(ASPECTS)}")
o["aspect"] = fmt["aspect"]
out["format"] = o
cap = settings.get("capture")
if cap is not None:
if not isinstance(cap, dict):
raise LayoutError("capture precisa ser um objeto")
o = {}
if "quality" in cap:
if cap["quality"] not in CAPTURE_QUALITIES:
raise LayoutError(f"capture.quality precisa ser um de {', '.join(CAPTURE_QUALITIES)}")
o["quality"] = cap["quality"]
out["capture"] = o
return out
def min_target(settings: dict) -> float:
"""Duração final mínima de um corte AUTOMÁTICO: `minS` + 1 s (+ folga de quadro), sem passar de `maxS`."""
dur = settings.get("duration") or DEFAULTS["duration"]
return round(min(float(dur["maxS"]), float(dur["minS"]) + DURATION_MARGIN_S + DURATION_SLACK_S), 3)
def font_files() -> dict[str, str]:
"""{família: caminho do arquivo relativo à raiz do repositório} das fontes empacotadas (o painel carrega o mesmo)."""
return dict(PACKAGED_FONTS)
def ass_filter(ass_name: str, ass_text: str | None = None) -> str:
"""`ass=<arquivo>`; com `:fontsdir=` (pasta das fontes empacotadas) só quando o ASS usa uma delas — assim o
filtro de projetos antigos (só fontes do Windows) fica idêntico ao de antes."""
if ass_text and PACKAGED_FONTS and any(f",{fam}," in ass_text or f"\\fn{fam}" in ass_text for fam in PACKAGED_FONTS):
# Caminho absoluto entre aspas, com ":" escapado (medido: sem aspas o FFmpeg recusa o grafo no Windows).
return f"ass={ass_name}:fontsdir='{FONTS_DIR.as_posix().replace(':', chr(92) + ':')}'"
return f"ass={ass_name}"
def aspect(settings: dict) -> str:
"""Formato do corte (`vertical` ou `horizontal`). Configuração sem o grupo `format` (antiga) = vertical."""
value = (settings.get("format") or {}).get("aspect", "vertical")
return value if value in ASPECTS else "vertical"
def frame_size(settings: dict) -> tuple[int, int]:
"""Tamanho do vídeo de saída (largura, altura)."""
return FRAME_SIZES[aspect(settings)]
def canvas_size(settings: dict) -> tuple[int, int]:
"""Quadro lógico do ASS (PlayResX, PlayResY): posições e tamanhos dos textos são contados nele."""
return CANVAS_SIZES[aspect(settings)]
def resolved_mode(settings: dict) -> str:
"""Modo efetivo do layout. No horizontal só há `cam_only` (com câmera marcada) e `full` (quadro inteiro)."""
mode = settings["layout"]["mode"]
if aspect(settings) == "horizontal":
return "cam_only" if mode == "cam_only" and settings["layout"]["cam"] else "full"
if mode == "auto":
return "cam_top" if settings["layout"]["cam"] else "blur"
if mode in ("cam_top", "cam_only") and not settings["layout"]["cam"]:
return "blur" # sem câmera marcada não dá para montar o layout com câmera
return mode
def _crop(rect: dict | None) -> str:
if not rect:
return "iw:ih:0:0"
return f"iw*{rect['w']}:ih*{rect['h']}:iw*{rect['x']}:ih*{rect['y']}"
def _fill(width: int, height: int) -> str:
"""Escala cobrindo e recorta no centro para width×height."""
return f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}"
def _fit(width: int, height: int) -> str:
"""Escala cabendo inteiro (sem cortar nem distorcer) e completa com faixas pretas até width×height."""
return (f"scale={width}:{height}:force_original_aspect_ratio=decrease:force_divisible_by=2,"
f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color=black")
def cam_panel_height(settings: dict) -> int:
"""Altura (px do vídeo vertical) do painel da câmera no `cam_top`."""
return int(round(H * settings["layout"]["camHeight"] / 2)) * 2
def layout_chain(settings: dict, src: str, dst: str, tail: str = "", suffix: str = "", mode: str | None = None,
reframe=None) -> str:
"""Trecho de filtergraph: [src] (quadro original) → [dst] no tamanho do formato (1080×1920 ou 1920×1080).
`tail` = filtros extras (com vírgula na frente) antes do rótulo final; `suffix` deixa os rótulos internos únicos
(vários trechos no mesmo grafo, no editor); `mode` sobrescreve o modo (troca de layout por trecho).
`reframe` = função (proporção da área do jogo → filtro, de `reframe.py`) que reenquadra o jogo no tempo: a janela
vira a área do jogo (parte de baixo no `cam_top`; a tela toda nos outros modos, inclusive `blur`) e `layout.game`
é ignorado. Não vale para `cam_only`."""
if mode and mode != "auto":
settings = {**settings, "layout": {**settings["layout"], "mode": mode}}
mode = resolved_mode(settings)
lay = settings["layout"]
s = suffix
if reframe is not None and mode != "cam_only":
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]{reframe(W / (H - top))},scale={W}:{H - top},setsar=1[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
fw, fh = frame_size(settings)
return f"[{src}]{reframe(fw / fh)},scale={fw}:{fh},setsar=1{tail}[{dst}]"
if aspect(settings) == "horizontal":
fw, fh = frame_size(settings)
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(fw, fh)}{tail}[{dst}]"
if lay["game"]: # região do jogo marcada: preenche a tela (recorta no centro, sem distorcer)
return f"[{src}]crop={_crop(lay['game'])},{_fill(fw, fh)}{tail}[{dst}]"
# Quadro original inteiro (16:9 já preenche; outra proporção ganha faixas pretas em vez de ser cortada).
return f"[{src}]{_fit(fw, fh)}{tail}[{dst}]"
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]crop={_crop(lay['game'])},{_fill(W, H - top)}[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
if mode == "game_only":
return f"[{src}]crop={_crop(lay['game'])},{_fill(W, H)}{tail}[{dst}]"
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(W, H)}{tail}[{dst}]"
return (
f"[{src}]split=2[bg{s}][fg{s}];"
f"[bg{s}]{_fill(W, H)},boxblur=25:2,eq=brightness=-0.08[bg2{s}];"
f"[fg{s}]scale=1080:-2[fg2{s}];"
f"[bg2{s}][fg2{s}]overlay=(W-w)/2:(H-h)/2-80{tail}[{dst}]"
)
def video_filter(settings: dict, ass_name: str | None, ass_text: str | None = None, reframe=None) -> str:
"""filter_complex de [0:v] → [v] no tamanho do formato, 30 fps, com a legenda (se houver). `ass_text` = conteúdo
do ASS (decide se o libass precisa da pasta das fontes empacotadas); `reframe` = ver `layout_chain`."""
tail = (f",{ass_filter(ass_name, ass_text)}" if ass_name else "") + ",fps=30,format=yuv420p"
return layout_chain(settings, "0:v", "v", tail, reframe=reframe)
def caption_y(settings: dict) -> int:
"""Centro vertical da legenda em px do quadro lógico do ASS (`canvas_size`). Automático: na emenda câmera/jogo
(cam_top) ou ~74 % da altura no vertical; no horizontal, 85 % da altura (terço de baixo, acima do rodapé)."""
y = settings["caption"]["y"]
_, ch = canvas_size(settings)
if y is not None:
return int(ch * y)
if aspect(settings) == "horizontal":
return int(ch * 0.85)
if resolved_mode(settings) == "cam_top":
return cam_panel_height(settings) + 40
return 1420
def credit_placement(settings: dict) -> tuple[int, int, int]:
"""(alinhamento ASS, margem lateral, margem vertical) do crédito do canal no quadro lógico.
Vertical: centralizado, abaixo da área do título das redes (topo) ou acima da barra (rodapé); com a câmera em
cima, desce para o pé do painel da câmera. Horizontal: no canto direito, para não cobrir o meio do jogo."""
cred = settings["credit"]
if aspect(settings) == "horizontal":
return (9, 48, 36) if cred["position"] == "top" else (3, 48, 36)
align, margin = (8, 170) if cred["position"] == "top" else (2, 90)
if cred["position"] == "top" and resolved_mode(settings) == "cam_top":
# Com a câmera em cima, o topo é o rosto do streamer: o crédito desce para o pé do painel da câmera.
margin = max(20, cam_panel_height(settings) - cred["size"] - 34)
return align, 40, margin
def ass_color(hex_rgb: str) -> str:
"""#RRGGBB → &H00BBGGRR& para a linha Style (ASS guarda em BGR, com alfa na frente)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H00{b}{g}{r}&".upper()
def ass_inline_color(hex_rgb: str) -> str:
"""#RRGGBB → &HBBGGRR& para a tag \\c dentro do texto (sem alfa)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H{b}{g}{r}&".upper()
+681
View File
@@ -0,0 +1,681 @@
"""API do Clipador (127.0.0.1:4520, faixa 4500–4599 do CenaForge). Toda rota, exceto GET /health, exige
`X-Service-Key` = CLIPPER_SERVICE_KEY (clipper/.env). Quem chama é o painel (panel/src/lib/clipper.ts)."""
from __future__ import annotations
import hmac
import logging
from contextlib import asynccontextmanager
from typing import Literal
from fastapi import FastAPI, Query, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from .config import ConfigError, Settings
import json
from pathlib import Path
from . import capture, layout, media
from .config import REPO_ROOT
from .db import Database, loads, now
from .judge import JudgeError
from .scoring import timeline as timeline_series
from .scoring import Word
from .sources import SourceError, parse_source
from .subtitles import build_ass
from .worker import Engine
from . import clip_delete, editor_api
VERSION = "1.0.0"
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
class UserError(Exception):
def __init__(self, message: str, status: int = 400):
super().__init__(message)
self.message, self.status = message, status
class ChannelIn(BaseModel):
url: str = Field(min_length=3, max_length=300)
displayName: str | None = Field(default=None, max_length=60)
monitor: bool = True
authorized: bool = False
class ChannelPatch(BaseModel):
displayName: str | None = Field(default=None, max_length=60)
monitor: bool | None = None
authorized: bool | None = None
class SessionIn(BaseModel):
url: str = Field(min_length=3, max_length=300)
class ManualClipIn(BaseModel):
"""Corte manual: os últimos `lastS` segundos gravados, ou o trecho [startS, endS]."""
lastS: float | None = Field(default=None, ge=5, le=180)
startS: float | None = Field(default=None, ge=0)
endS: float | None = Field(default=None, ge=0)
class JudgeIn(BaseModel):
provider: Literal["codex", "claude", "off"]
model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
minScore: float = Field(default=6, ge=0, le=10)
# Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer.
analystModel: str | None = Field(default=None, max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
# Varredura da IA (procura momentos sem pico de chat), visão (frames da tela) e detecção da webcam.
scanEnabled: bool | None = None
scanIntervalS: int | None = Field(default=None, ge=60, le=900)
vision: bool | None = None
camDetect: bool | None = None
# Rastreio do rosto do streamer (face.py): reforça/cria cortes e vai em texto para o analista.
faceTrack: bool | None = None
class GameIn(BaseModel):
name: str = Field(min_length=1, max_length=120)
class GameProfileIn(BaseModel):
"""Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve)."""
name: str = Field(default="", max_length=120)
summary: str = Field(default="", max_length=1500)
genre: str = Field(default="", max_length=120)
mechanics: list[str] = Field(default_factory=list, max_length=30)
clip_worthy: list[str] = Field(default_factory=list, max_length=30)
avoid: list[str] = Field(default_factory=list, max_length=30)
jargon: list[str] = Field(default_factory=list, max_length=40)
news: list[str] = Field(default_factory=list, max_length=30)
hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py)
sources: list[str] = Field(default_factory=list, max_length=20)
class ChatTurnIn(BaseModel):
role: Literal["user", "ai"]
text: str = Field(max_length=1500)
class GameRefineIn(BaseModel):
instruction: str = Field(min_length=3, max_length=1500)
search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo
section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources"] = ""
history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção
class PreviewIn(BaseModel):
t: float | None = Field(default=None, ge=0)
settings: dict = Field(default_factory=dict)
class ClipPatch(BaseModel):
status: Literal["approved", "rejected", "ready", "published"] | None = None
title: str | None = Field(default=None, max_length=100)
caption: str | None = Field(default=None, max_length=2200)
startS: float | None = Field(default=None, ge=0)
endS: float | None = Field(default=None, ge=0)
ClipStatusName = Literal["candidate", "discarded", "pending", "rendering", "ready", "approved", "rejected", "published", "error"]
class ClipsDeleteIn(BaseModel):
"""Apagar em lote: `ids` (os cortes escolhidos) OU `statuses` (+ `sessionId` opcional) = todos de uma aba.
`confirmPublished` libera apagar corte publicado (sem ele, o publicado é recusado com o motivo)."""
ids: list[int] | None = Field(default=None, min_length=1, max_length=clip_delete.MAX_BATCH)
statuses: list[ClipStatusName] | None = Field(default=None, min_length=1, max_length=9)
sessionId: int | None = Field(default=None, ge=1)
confirmPublished: bool = False
def clip_view(row: dict) -> dict:
return {
"id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"],
"endS": row["end_s"], "durationS": round(row["end_s"] - row["start_s"], 2), "score": row["score"],
"source": row["source"], "reasons": loads(row["reasons_json"], {}), "judge": loads(row["judge_json"], None),
"title": row["title"], "caption": row["caption"], "transcript": row["transcript"], "status": row["status"],
"file": row["file"], "thumb": row["thumb"], "error": row["error"],
# Formato em que o arquivo foi renderizado (vertical 1080×1920 · horizontal 1920×1080); antes do 1º render,
# e nos cortes de antes da migração v8, vale o padrão `vertical`.
"aspect": row.get("aspect") or "vertical",
"createdAt": row["created_at"], "updatedAt": row["updated_at"],
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
# Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export)
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
"origin": row.get("edit_origin")}
if row.get("edit_updated_at") else None),
}
def session_view(row: dict, engine: Engine) -> dict:
counts = {r["status"]: r["n"] for r in engine.db.all(
"SELECT status, COUNT(*) AS n FROM clips WHERE session_id = ? GROUP BY status", row["id"])}
seg = engine.db.get(
"SELECT COUNT(*) AS total, SUM(analyzed) AS analyzed, SUM(CASE WHEN transcript_error IS NOT NULL THEN 1 ELSE 0 END) AS errors"
" FROM segments WHERE session_id = ?", row["id"])
chat = engine.db.get("SELECT COUNT(*) AS n FROM chat WHERE session_id = ?", row["id"])["n"]
live_chat = engine.chat_status(row["id"])
return {
"id": row["id"], "channelId": row["channel_id"], "platform": row["platform"], "kind": row["kind"],
"url": row["url"], "title": row["title"], "status": row["status"],
"chatStatus": live_chat["status"] if live_chat else row["chat_status"], "chatMessages": chat,
"durationS": row["duration_s"], "startedAt": row["started_at"], "endedAt": row["ended_at"], "error": row["error"],
"segments": {"total": seg["total"] or 0, "analyzed": seg["analyzed"] or 0, "transcriptErrors": seg["errors"] or 0},
"clips": counts,
# Contexto do jogo: categoria da plataforma, o que a IA viu na tela, trocas e se você corrigiu à mão.
"game": row.get("game", ""), "gameSource": row.get("game_source", ""), "screenGame": row.get("screen_game", ""),
"gameHistory": loads(row.get("games_json"), []), "gameProfileReady": bool(engine.intel.profile(row.get("game", ""))),
"scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []),
"camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"),
"hasOwnSettings": bool(loads(row.get("settings_json"), {})),
# O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec,
# kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco.
"capture": loads(row.get("capture_json"), None),
}
def channel_view(row: dict) -> dict:
return {
"id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"],
"displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]),
"lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"],
}
def create_app(settings: Settings | None = None, engine: Engine | None = None, start_engine: bool = True) -> FastAPI:
settings = settings or Settings.load()
if not settings.service_key:
raise ConfigError("CLIPPER_SERVICE_KEY vazio: rode o setup.bat (ou preencha clipper/.env).")
db = engine.db if engine else Database(settings.data_dir / "clipper.db")
engine = engine or Engine(settings, db)
@asynccontextmanager
async def lifespan(_app: FastAPI):
if start_engine:
engine.start()
yield
engine.shutdown()
app = FastAPI(title="CenaForge Clipador", version=VERSION, docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
app.state.engine = engine
@app.middleware("http")
async def auth(request: Request, call_next):
if request.url.path != "/health":
given = request.headers.get("X-Service-Key", "")
if not hmac.compare_digest(given.encode(), settings.service_key.encode()):
return JSONResponse({"error": "Chave do serviço ausente ou inválida."}, status_code=401)
return await call_next(request)
@app.exception_handler(UserError)
async def user_error(_request: Request, exc: UserError):
return JSONResponse({"error": exc.message}, status_code=exc.status)
@app.exception_handler(SourceError)
async def source_error(_request: Request, exc: SourceError):
return JSONResponse({"error": str(exc)}, status_code=400)
@app.get("/health")
async def health():
return {"status": "ok", "version": VERSION}
@app.get("/v1/status")
def status():
return {
"version": VERSION,
"tools": {"streamlink": settings.streamlink, "ffmpeg": settings.ffmpeg},
"voice": {"configured": engine.voice.configured, "online": engine.voice.healthy()},
"judge": engine.judge_config(),
"recording": db.get("SELECT COUNT(*) AS n FROM sessions WHERE status IN ('starting', 'recording')")["n"],
# A qualidade de gravação agora é por canal/sessão (`capture.quality`); aqui vai o padrão do serviço.
"settings": {"quality": layout.DEFAULTS["capture"]["quality"], "segmentS": settings.segment_s, "pollS": settings.poll_s,
"keepHours": settings.keep_hours, "language": settings.language},
}
# ---------- juiz (IA pela CLI: Codex/GPT ou Claude)
@app.get("/v1/judge")
def get_judge():
return engine.judge_config() | {"models": engine.judge.models()}
@app.put("/v1/judge")
def put_judge(body: JudgeIn):
try:
engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS,
"vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack})
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel) | {
"models": engine.judge.models()}
except JudgeError as exc:
raise UserError(str(exc)) from exc
# ---------- configuração do corte (layout, câmera, legenda, crédito, duração)
def _settings_payload(own: dict, channel_layer: dict | None, session_layer: dict | None) -> dict:
return {"own": own, "effective": layout.merge(channel_layer, session_layer), "defaults": layout.DEFAULTS,
"modes": list(layout.MODES), "fonts": list(layout.FONTS), "aspects": list(layout.ASPECTS),
# Fontes empacotadas: {família: arquivo relativo à raiz do repositório} (o painel carrega a mesma).
# Qualidades de gravação (grupo `capture`): rótulo, teto e disco por hora medido/estimado.
"captureQualities": capture.OPTIONS,
"fontFiles": layout.font_files(), "hookStyles": list(layout.HOOK_STYLES), "hookAnims": list(layout.HOOK_ANIMS),
# Tamanho do vídeo e quadro lógico dos textos (ASS) de cada formato, para o painel desenhar a prévia.
"frames": {a: {"width": layout.FRAME_SIZES[a][0], "height": layout.FRAME_SIZES[a][1],
"canvasWidth": layout.CANVAS_SIZES[a][0], "canvasHeight": layout.CANVAS_SIZES[a][1]}
for a in layout.ASPECTS}}
@app.get("/v1/channels/{channel_id}/settings")
def get_channel_settings(channel_id: str):
row = db.get("SELECT settings_json FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
own = loads(row["settings_json"], {})
return _settings_payload(own, own, None)
@app.put("/v1/channels/{channel_id}/settings")
def put_channel_settings(channel_id: str, body: dict):
if not db.get("SELECT 1 FROM channels WHERE id = ?", channel_id):
raise UserError("Canal não encontrado.", 404)
try:
own = layout.validate(body)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(own), channel_id)
return _settings_payload(own, own, None)
def _session(session_id: int) -> dict:
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not row:
raise UserError("Sessão não encontrada.", 404)
return row
def _channel_layer(row: dict) -> dict | None:
if not row.get("channel_id"):
return None
ch = db.get("SELECT settings_json FROM channels WHERE id = ?", row["channel_id"])
return loads(ch["settings_json"], {}) if ch else None
@app.get("/v1/sessions/{session_id}/settings")
def get_session_settings(session_id: int):
row = _session(session_id)
own = loads(row["settings_json"], {})
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
@app.put("/v1/sessions/{session_id}/settings")
def put_session_settings(session_id: int, body: dict):
"""Configuração própria da sessão (sobrescreve a do canal campo a campo). Vale para os próximos renders."""
row = _session(session_id)
try:
own = layout.validate(body)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(own) if own else None, session_id)
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
def _frame(row: dict, t: float | None, name: str, width: int = 1280) -> tuple[float, Path]:
segments = [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
for s in db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", row["id"])]
if not segments:
raise UserError("Ainda não há vídeo gravado nesta sessão.")
at = segments[-1][2] - 3 if t is None else t
out = settings.clips_dir / str(row["id"]) / name
try:
media.grab_frame(settings.ffmpeg or "ffmpeg", segments, at, out, width)
except media.MediaError as exc:
raise UserError(str(exc)) from exc
return at, out
@app.get("/v1/sessions/{session_id}/frame")
def get_frame(session_id: int, t: float | None = None):
"""Quadro do vídeo original (1280 px) para o editor desenhar a câmera. Servido por /api/files."""
at, out = _frame(_session(session_id), t, "frame.jpg")
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "version": now()}
@app.post("/v1/sessions/{session_id}/preview")
def preview(session_id: int, body: PreviewIn):
"""Prévia (1080×1920 ou 1920×1080, pelo `format.aspect` efetivo) de como o corte vai ficar com a configuração enviada (sem salvar)."""
row = _session(session_id)
try:
layer = layout.validate(body.settings)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
cfg = layout.merge(_channel_layer(row), loads(row["settings_json"], {}), layer)
at, frame = _frame(row, body.t, "preview-src.jpg", width=0)
# Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda.
sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
out = settings.clips_dir / str(row["id"]) / "preview.jpg"
try:
media.preview_still(settings.ffmpeg or "ffmpeg", frame, cfg, ass, out)
except media.MediaError as exc:
raise UserError(str(exc)) from exc
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "mode": layout.resolved_mode(cfg),
"version": now()}
@app.post("/v1/sessions/{session_id}/detect-cam")
def detect_cam(session_id: int, ai: bool = False):
"""Acha a webcam: primeiro local (YuNet em 12 quadros, sem IA); a IA olha 3 quadros se o local não achar
rosto ou com `?ai=true`. Aplica como padrão do canal (ou da sessão) se ainda não houver."""
_session(session_id)
try:
return engine.intel.detect_cam(session_id, apply=True, use_ai=ai)
except JudgeError as exc:
raise UserError(str(exc)) from exc
# ---------- rastreio de reação (rosto do streamer)
@app.get("/v1/sessions/{session_id}/face")
def get_face(session_id: int, from_: float = Query(default=0.0, alias="from", ge=0),
to: float | None = Query(default=None, ge=0)):
"""Série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal` = z da reação) e picos."""
if to is not None and to < from_:
raise UserError("`to` precisa ser maior que `from`.")
return engine.face.view(_session(session_id), from_, to)
@app.post("/v1/sessions/{session_id}/face/reset")
def reset_face(session_id: int):
"""Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco
em andamento não espera: responde 202 com `scheduled: true` e o laço apaga antes do próximo bloco."""
_session(session_id)
result = engine.face.reset(session_id)
return JSONResponse({"ok": True, **result}, status_code=202 if result["scheduled"] else 200)
# ---------- jogo
@app.put("/v1/sessions/{session_id}/game")
def put_game(session_id: int, body: GameIn):
"""Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais."""
_session(session_id)
engine.intel.set_game(session_id, body.name.strip(), "user")
return session_view(_session(session_id), engine)
@app.get("/v1/games")
def list_games():
return {"games": [{"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"],
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None)}
for g in db.all("SELECT * FROM games ORDER BY name")]}
@app.post("/v1/games/{game_id}/research")
def research_game(game_id: str):
"""Pesquisa (de novo) o jogo na web pela IA. Leva de 15 s a alguns minutos. Os pedidos guardados entram junto."""
try:
engine.intel.research(game_id)
except JudgeError as exc:
raise UserError(str(exc)) from exc
return list_games()
@app.put("/v1/games/{game_id}")
def put_game_profile(game_id: str, body: GameProfileIn):
"""Grava o perfil editado à mão. A IA passa a usar na hora."""
try:
engine.intel.save_profile(game_id, body.model_dump())
except JudgeError as exc:
raise UserError(str(exc), 404) from exc
return list_games()
@app.post("/v1/games/{game_id}/refine")
def refine_game(game_id: str, body: GameRefineIn):
"""Pede à IA para acrescentar/corrigir algo no perfil ("acrescente que ..."). O pedido fica guardado."""
try:
_, reply = engine.intel.refine(game_id, body.instruction.strip(), body.search, body.section,
[t.model_dump() for t in body.history])
except JudgeError as exc:
raise UserError(str(exc)) from exc
return {**list_games(), "reply": reply}
@app.delete("/v1/games/{game_id}/notes/{index}")
def delete_game_note(game_id: str, index: int):
"""Esquece um pedido guardado (não volta mais nas pesquisas; o perfil atual fica como está)."""
try:
engine.intel.delete_note(game_id, index)
except JudgeError as exc:
raise UserError(str(exc), 404) from exc
return list_games()
# ---------- emotes que o canal usa (e o peso que aprenderam)
@app.get("/v1/emotes")
def list_emotes(channel: str, limit: int = 60):
rows = db.all("SELECT * FROM emotes WHERE channel_key = ? ORDER BY uses DESC LIMIT ?", channel, max(1, min(limit, 300)))
return {"emotes": [{"name": r["name"], "source": r["source"], "uses": r["uses"], "weight": round(r["weight"], 2),
"lastSeen": r["last_seen"]} for r in rows]}
# ---------- canais
@app.get("/v1/channels")
def list_channels():
return {"channels": [channel_view(r) for r in db.all("SELECT * FROM channels ORDER BY display_name")]}
@app.post("/v1/channels", status_code=201)
def create_channel(body: ChannelIn):
source = parse_source(body.url)
if source.kind != "live" or not source.channel:
raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.")
if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id):
raise UserError("Esse canal já está na lista.", 409)
db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at)"
" VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
source.channel_id, source.platform, source.channel, source.url,
(body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now())
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id))
@app.patch("/v1/channels/{channel_id}")
def update_channel(channel_id: str, body: ChannelPatch):
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ? WHERE id = ?",
(body.displayName or row["display_name"]).strip(),
int(body.monitor if body.monitor is not None else row["monitor"]),
int(body.authorized if body.authorized is not None else row["authorized"]), channel_id)
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id))
@app.delete("/v1/channels/{channel_id}", status_code=204)
def delete_channel(channel_id: str):
for s in db.all("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel_id):
engine.stop_session(s["id"])
db.run("DELETE FROM channels WHERE id = ?", channel_id)
@app.post("/v1/channels/{channel_id}/check")
def check_channel(channel_id: str):
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
live, title = engine.check_live(row["url"])
db.run("UPDATE channels SET last_check_at = ?, last_status = ? WHERE id = ?", now(), "ao vivo" if live else "offline", channel_id)
return {"live": live, "title": title}
# ---------- sessões
@app.get("/v1/sessions")
def list_sessions(limit: int = 30):
rows = db.all("SELECT * FROM sessions ORDER BY id DESC LIMIT ?", max(1, min(limit, 200)))
return {"sessions": [session_view(r, engine) for r in rows]}
@app.post("/v1/sessions", status_code=201)
def create_session(body: SessionIn):
source = parse_source(body.url)
channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None
try:
session_id = engine.start_session(body.url, channel["id"] if channel else None)
except RuntimeError as exc:
raise UserError(str(exc)) from exc
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.get("/v1/sessions/{session_id}")
def get_session(session_id: int):
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not row:
raise UserError("Sessão não encontrada.", 404)
return session_view(row, engine)
@app.get("/v1/sessions/{session_id}/timeline")
def get_timeline(session_id: int):
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
tl = engine.load_timeline(session_id)
return {"durationS": tl["duration"], **timeline_series(tl["duration"], tl["chat"], tl["loudness"], engine.params)}
@app.post("/v1/sessions/{session_id}/clips", status_code=201)
def manual_clip(session_id: int, body: ManualClipIn):
session = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
raise UserError("Sessão não encontrada.", 404)
duration = session["duration_s"]
if body.lastS is not None:
start, end = max(0.0, duration - body.lastS), duration
elif body.startS is not None and body.endS is not None:
start, end = body.startS, min(body.endS, duration)
else:
raise UserError("Informe lastS ou startS e endS.")
if end - start < 5:
raise UserError("Ainda não há gravação suficiente para esse corte.")
ts = now()
cur = db.run(
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
" VALUES (?, ?, ?, ?, 0, 'manual', '{}', 'candidate', ?, ?)", session_id, end, start, end, ts, ts)
engine.wake_clips.set()
return clip_view(_clip(int(cur.lastrowid)))
@app.post("/v1/sessions/{session_id}/stop")
def stop_session(session_id: int):
engine.stop_session(session_id)
return {"ok": True}
@app.post("/v1/sessions/{session_id}/resume")
def resume_session(session_id: int):
"""Volta a gravar uma live interrompida (ex.: o serviço reiniciou) ou parada, na mesma sessão."""
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
try:
engine.resume_session(session_id)
except RuntimeError as exc:
raise UserError(f"Não deu para retomar: {exc}.") from exc
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.post("/v1/sessions/{session_id}/finish")
def finish_session(session_id: int):
"""Encerra e processa o que foi gravado: varredura do restante, juízes e render dos cortes."""
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
engine.finish_session(session_id)
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.delete("/v1/sessions/{session_id}", status_code=204)
def delete_session(session_id: int):
engine.delete_session(session_id)
# ---------- cortes
@app.get("/v1/clips")
def list_clips(status: str | None = None, session: int | None = None, limit: int = 100,
channel: str | None = None, ids: str | None = None):
"""Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`.
O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila."""
sql = "SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1"
params: list = []
if status:
sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")"
params += status.split(",")
if session:
sql += " AND c.session_id = ?"
params.append(session)
if channel:
channels = [c for c in channel.split(",") if c][:200]
sql += " AND s.channel_id IN (" + ",".join("?" * len(channels)) + ")"
params += channels
if ids:
try:
id_list = [int(i) for i in ids.split(",") if i][:500]
except ValueError as exc:
raise UserError("`ids` precisa ser uma lista de números separados por vírgula.") from exc
sql += " AND c.id IN (" + ",".join("?" * len(id_list)) + ")"
params += id_list
sql += " ORDER BY c.id DESC LIMIT ?"
params.append(max(1, min(limit, 500)))
return {"clips": [clip_view(r) for r in db.all(sql, *params)]}
def _clip(clip_id: int) -> dict:
row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", clip_id)
if not row:
raise UserError("Corte não encontrado.", 404)
return row
@app.post("/v1/clips/delete")
def delete_clips(body: ClipsDeleteIn):
"""Apaga vários cortes: os `ids` escolhidos, ou todos nos `statuses` (de uma sessão, com `sessionId`), até
`clip_delete.MAX_BATCH` por chamada. Cada um segue as regras de `DELETE /v1/clips/{id}`; a resposta diz o
que saiu (`deleted`) e o que não saiu e por quê (`failed`). `remaining` = quantos passaram do limite."""
if (body.ids is None) == (body.statuses is None):
raise UserError("Mande `ids` ou `statuses` (um dos dois).")
if body.ids is not None and body.sessionId is not None:
raise UserError("`sessionId` só vale junto com `statuses`.")
remaining = 0
if body.ids is not None:
if any(i < 1 for i in body.ids):
raise UserError("Id de corte inválido.")
ids = list(dict.fromkeys(body.ids))
else:
ids, remaining = clip_delete.select_ids(db, body.sessionId, list(dict.fromkeys(body.statuses)))
result = clip_delete.delete_many(engine, ids, body.confirmPublished)
if result["deleted"]:
engine.wake_clips.set() # a sessão pode ter acabado de ficar sem pendências (finish_if_done)
return {"requested": len(ids), "remaining": remaining, **result}
@app.delete("/v1/clips/{clip_id}")
def delete_clip(clip_id: int, confirmPublished: bool = False):
"""Apaga o corte, o projeto de edição e os arquivos dele (só dentro das pastas do Clipador). Recusa `candidate`
e `rendering` (409, o motor está mexendo nele) e `published` sem `?confirmPublished=true`. O momento fica
marcado: a IA não recria o mesmo corte (clip_delete.py)."""
try:
result = clip_delete.delete_clip(engine, clip_id, confirmPublished)
except clip_delete.DeleteRefused as exc:
message = "Corte não encontrado." if exc.code == "not_found" else f"Não deu para apagar: {exc.message}."
return JSONResponse({"error": message, "code": exc.code}, status_code=exc.status)
engine.wake_clips.set()
return result
@app.get("/v1/clips/{clip_id}")
def get_clip(clip_id: int):
return clip_view(_clip(clip_id))
@app.patch("/v1/clips/{clip_id}")
def update_clip(clip_id: int, body: ClipPatch):
row = _clip(clip_id)
start = body.startS if body.startS is not None else row["start_s"]
end = body.endS if body.endS is not None else row["end_s"]
if not 5 <= end - start <= 180:
raise UserError("O corte precisa ter entre 5 e 180 segundos.")
retime = (start, end) != (row["start_s"], row["end_s"])
status = body.status or row["status"]
if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"):
raise UserError("Só dá para aprovar um corte já renderizado.")
if retime:
status = "pending" # novo trecho → renderiza de novo
db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?",
body.title if body.title is not None else row["title"],
body.caption if body.caption is not None else row["caption"], start, end, status, now(), clip_id)
if retime:
editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto
engine.wake_clips.set()
if body.status in ("approved", "rejected") and body.status != row["status"]:
# Sua decisão é o sinal forte: emotes da reação deste corte ganham/perdem peso no canal (uma vez).
engine.intel.learn_from_clip(row, positive=body.status == "approved", mark=True)
return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/render")
def rerender(clip_id: int):
"""Força o render (ex.: corte que a IA descartou ou que deu erro)."""
_clip(clip_id)
db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id)
engine.wake_clips.set()
return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/rejudge")
def rejudge(clip_id: int):
_clip(clip_id)
db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id)
engine.wake_clips.set()
return clip_view(_clip(clip_id))
# Editor de cortes (/v1/clips/{id}/edit, proxy, waveform, export, preview-render, retranscribe, tts, suggest).
editor_api.register(app, engine, clip_view, _clip)
return app
def build() -> FastAPI: # pragma: no cover - ponto de entrada do uvicorn (--factory)
return create_app()
+188
View File
@@ -0,0 +1,188 @@
"""FFmpeg do Clipador: áudio dos blocos (volume por segundo + WAV para o Whisper), corte vertical e miniatura.
Subprocesso sempre sem shell, argumentos em lista, com timeout; código != 0 é falha."""
from __future__ import annotations
import io
import math
import subprocess
import sys
import wave
from array import array
from pathlib import Path
from . import layout
SAMPLE_RATE = 16_000
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
class MediaError(RuntimeError):
pass
def run(args: list[str], timeout: float, cwd: Path | None = None) -> bytes:
try:
result = subprocess.run(args, capture_output=True, timeout=timeout, cwd=cwd, creationflags=NO_WINDOW)
except subprocess.TimeoutExpired as exc:
raise MediaError(f"{Path(args[0]).name} passou de {timeout:.0f} s") from exc
if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-3:]
raise MediaError(f"{Path(args[0]).name} saiu com código {result.returncode}: {' | '.join(tail)}")
return result.stdout
def decode_pcm(ffmpeg: str, files: list[Path]) -> bytes:
"""Áudio mono 16 kHz s16le dos arquivos, em sequência."""
out = bytearray()
for file in files:
out += run([ffmpeg, "-v", "error", "-i", str(file), "-vn", "-ac", "1", "-ar", str(SAMPLE_RATE), "-f", "s16le", "-"], 120)
return bytes(out)
def loudness_per_second(pcm: bytes) -> list[float | None]:
"""RMS em dBFS por segundo (None = silêncio absoluto)."""
samples = array("h")
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
out: list[float | None] = []
for i in range(0, len(samples), SAMPLE_RATE):
chunk = samples[i: i + SAMPLE_RATE]
if len(chunk) < SAMPLE_RATE // 4:
break
rms = math.sqrt(sum(s * s for s in chunk) / len(chunk))
out.append(round(20 * math.log10(rms / 32768), 2) if rms > 0 else None)
return out
def to_wav(pcm: bytes) -> bytes:
buffer = io.BytesIO()
with wave.open(buffer, "wb") as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(SAMPLE_RATE)
wav.writeframes(pcm)
return buffer.getvalue()
def pick_encoder(ffmpeg: str, wanted: str) -> list[str]:
if wanted == "auto":
try:
encoders = run([ffmpeg, "-hide_banner", "-encoders"], 30).decode(errors="replace")
except MediaError:
encoders = ""
wanted = "h264_nvenc" if "h264_nvenc" in encoders else "libx264"
if wanted == "h264_nvenc":
return ["-c:v", "h264_nvenc", "-preset", "p5", "-rc", "vbr", "-cq", "23", "-b:v", "0"]
return ["-c:v", "libx264", "-preset", "veryfast", "-crf", "21"]
def render_vertical(ffmpeg: str, encoder: list[str], segments: list[tuple[Path, float]], start_s: float, end_s: float,
ass_text: str, out_file: Path, settings: dict | None = None) -> None:
"""`segments` = blocos (arquivo, início na sessão) que cobrem [start_s, end_s], em ordem.
`settings` = configuração do corte efetiva (layout.merge); define layout, câmera e legenda."""
if not segments:
raise MediaError("nenhum bloco gravado cobre o trecho")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
stem = out_file.stem
# O filtro `ass` recebe o nome relativo (cwd = pasta do corte): caminho absoluto do Windows ("C:\...")
# exigiria escapar ":" e "\" dentro do filtergraph.
ass_file = work / f"{stem}.ass"
ass_file.write_text(ass_text, encoding="utf-8")
concat = work / f"{stem}.concat.txt"
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _ in segments), encoding="utf-8")
offset = start_s - segments[0][1]
tmp = work / f"{stem}.tmp.mp4"
try:
run(
# -ss ANTES do -i: os quadros entram no filtro já com tempo 0 = início do corte. Depois do -i o
# filtro `ass` veria o tempo do bloco e a legenda sairia deslocada (medido: sumia do vídeo).
[ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, offset):.3f}", "-f", "concat", "-safe", "0",
"-i", concat.name, "-t", f"{end_s - start_s:.3f}",
"-filter_complex", layout.video_filter(settings or layout.merge(), ass_file.name, ass_text),
"-map", "[v]", "-map", "0:a:0?",
*encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000", "-movflags", "+faststart", tmp.name],
timeout=600, cwd=work,
)
tmp.replace(out_file)
finally:
concat.unlink(missing_ok=True)
ass_file.unlink(missing_ok=True)
tmp.unlink(missing_ok=True)
def segment_at(segments: list[tuple[Path, float, float]], t: float) -> tuple[Path, float] | None:
"""Bloco (arquivo, deslocamento dentro dele) que contém o instante `t` da sessão."""
for file, start, end in segments:
if start <= t < end:
return file, t - start
if segments and t >= segments[-1][2]:
file, start, end = segments[-1]
return file, max(0.0, end - start - 0.5)
return None
# Busca num bloco .ts: o demuxer mpegts do FFmpeg trata todo pacote como ponto de busca, então `-ss` antes do `-i`
# cai num quadro P perto do alvo. Medido (17/11/2026): no H.264 sai o PRÓXIMO quadro-chave (até 2 s depois do
# pedido); no HEVC (2K da Twitch) sai um quadro CINZA (referências faltando) — frames do juiz, capa e YuNet
# estragados. Um 2º `-ss` depois do `-i` também erra quando o bloco tem áudio (a base de tempo vem do áudio; 7,5 s
# virou 6,06 s). Agora: busca rápida `SEEK_PREROLL_S` antes, tempo absoluto do bloco (`-copyts -start_at_zero`) e
# o 1º quadro com t ≥ alvo (`select`). GOP da Twitch = 2 s; o YouTube recomenda ≤ 4 s. O concat (render, proxy)
# não tem esse problema: não passa por aqui.
SEEK_PREROLL_S = 4.0
def seek_args(offset: float) -> tuple[list[str], str]:
"""(argumentos antes do `-i`, filtro `select` do quadro exato) para o instante `offset` s de um bloco .ts."""
offset = max(0.0, offset)
return (["-ss", f"{max(0.0, offset - SEEK_PREROLL_S):.3f}", "-copyts", "-start_at_zero"],
f"select='gte(t,{offset:.3f})'")
def grab_frame(ffmpeg: str, segments: list[tuple[Path, float, float]], t: float, out_file: Path, width: int = 768) -> Path:
"""Um quadro do instante `t` (sessão) em JPG. Para a IA olhar a tela e para o editor de layout."""
found = segment_at(segments, t)
if not found:
raise MediaError(f"nenhum bloco gravado em {t:.0f}s")
file, offset = found
out_file.parent.mkdir(parents=True, exist_ok=True)
before, select = seek_args(offset)
vf = select + (f",scale={width}:-2" if width else "")
run([ffmpeg, "-y", "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-vf", vf, "-frames:v", "1",
"-q:v", "4", str(out_file)], 60)
return out_file
def preview_still(ffmpeg: str, frame_file: Path, settings: dict, ass_text: str, out_file: Path, reframe=None) -> Path:
"""Prévia do layout num quadro só (imagem no formato do corte com câmera, jogo, legenda e crédito de exemplo).
`reframe` = reenquadramento parado do jogo (capa de um corte com keyframes; ver `reframe.static_reframe`)."""
work = out_file.parent
ass_file = work / f"{out_file.stem}.ass"
ass_file.write_text(ass_text, encoding="utf-8")
try:
run([ffmpeg, "-y", "-v", "error", "-loop", "1", "-t", "1", "-i", frame_file.name,
"-filter_complex", layout.video_filter(settings, ass_file.name, ass_text, reframe), "-map", "[v]",
"-frames:v", "1", "-q:v", "3", out_file.name], 60, cwd=work)
finally:
ass_file.unlink(missing_ok=True)
return out_file
def thumbnail(ffmpeg: str, video: Path, at_s: float, out_file: Path) -> None:
run([ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, at_s):.2f}", "-i", str(video), "-frames:v", "1",
"-vf", "scale=360:-2", "-q:v", "4", str(out_file)], 60)
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
"""(largura, altura) do vídeo; 1280×720 se não der para ler (as camadas inseridas usam a proporção)."""
try:
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(file)], 30).decode().strip().split(",")
return int(out[0]), int(out[1])
except (MediaError, ValueError, IndexError):
return 1280, 720
def probe_duration(ffprobe: str, file: Path) -> float:
out = run([ffprobe, "-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", str(file)], 30)
return float(out.decode().strip() or 0)
+514
View File
@@ -0,0 +1,514 @@
"""Rastreio de reação do streamer: lógica pura (sem E/S, sem numpy/opencv/mediapipe).
Recebe o que o detector/rastreador já mediu (rosto por quadro com os blendshapes do MediaPipe, ou caixas de
rosto do YuNet) e transforma em:
- uma série por segundo (`FaceSecond`) compacta, para gravar no banco e para o editor reenquadrar a câmera;
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela
recente, só com segundos em que o rosto aparece). Tem streamer que fica sorrindo o tempo todo, tem quem fale
de boca aberta: o que importa é o desvio do normal DELE, não o valor absoluto do blendshape;
- picos rotulados (risada, grito, susto, choque, confuso, raiva) com o início da reação, e um texto curto para o juiz;
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados.
Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
"""
from __future__ import annotations
import bisect
import math
import statistics
from dataclasses import dataclass, field, replace
# Canais com z (o piscar fica de fora: é ruído, não reação). `brow` = sobrancelha levantada (interna ou externa:
# na live real as duas sobem juntas); `surprise` = olho arregalado. `motion` só ajuda a ROTULAR (susto): fica fora da
# intensidade — na live real os maiores "picos" de movimento eram o rastreio perdendo o rosto, não reação.
SIGNAL_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow", "motion")
EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow")
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s)
SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
@dataclass(frozen=True)
class ReactionParams:
# --- série por segundo / sinal ---
min_present: float = 0.3 # fração mínima de quadros com rosto para o segundo contar
motion_min_present: float = 0.8 # movimento só vale com o rosto em ≥ 80 % do segundo (senão é o rastreio pulando)
baseline_s: int = 180 # janela do "neutro recente" do streamer
exclude_recent_s: int = 10 # os últimos segundos ficam fora do neutro (a própria reação não se anula)
min_baseline_n: int = 30 # menos segundos com rosto que isso na janela → usa todos os segundos com rosto da série
mad_floor: float = 0.05 # piso do desvio robusto de um canal sem piso próprio em `mad_floors`
# Pisos por canal, calibrados na live real (doc/FACE_BAKEOFF.md, sessão 3): no calmo o sorriso por segundo
# tem mediana ~0,10 e picos soltos de 0,38 (fala/tique) → piso 0,10; browInnerUp tem pico solto de 0,38 num
# segundo calmo contra 0,7–0,8 sustentado no lag → piso 0,10 e peso menor; browDown no calmo fica ≤ 0,07.
# `motion` em "tamanhos de rosto" por segundo.
mad_floors: dict[str, float] = field(default_factory=lambda: {
"smile": 0.10, "jaw": 0.05, "surprise": 0.06, "frown": 0.07, "brow": 0.10, "motion": 0.15,
})
weights: dict[str, float] = field(default_factory=lambda: {
"smile": 1.0, "jaw": 1.0, "surprise": 1.0, "frown": 0.8, "brow": 0.6, "motion": 0.7,
})
# --- picos ---
threshold: float = 3.0 # z mínimo do sinal para virar pico (igual ao `face_threshold` do plano)
strong_z: float = 6.0 # a partir daqui o texto diz "forte"
onset_z: float = 1.0 # o início/fim da reação é onde o sinal cai abaixo disto
max_onset_s: int = 10
min_gap_s: float = 4.0 # distância mínima entre dois picos
keep_neutral: bool = False # pico só de movimento (pegar a água, ajeitar a cadeira) vira "neutro" e sai
# --- rótulo ---
label_z: float = 2.0 # canal "ligado" no pico quando o z dele passa disto
smile_raw: float = 0.5 # sorriso alto em valor absoluto também conta (neutro sorridente saturado)
shout_jaw_raw: float = 0.2 # sobrancelha franzida COM boca aberta pelo menos isso = grito (senão, raiva)
raw_thresholds: dict[str, float] = field(default_factory=lambda: {
"smile": 0.4, "jaw": 0.35, "surprise": 0.35, "frown": 0.35, "brow": 0.35, "motion": 0.5,
}) # usados pelo `label` quando não há z (segundo isolado)
# --- câmera (locate_cam) ---
min_score: float = 0.6 # confiança mínima da detecção
# Confiança MÉDIA mínima do grupo que vira câmera. Teste ao vivo de 17/11: webcam real (skipnho) 0,92–0,94 em
# todo quadro; na lofigirl (sem webcam) a tela de um notebook desenhado, parada na borda, deu 0,61–0,66 em 8 de 12
# quadros e virou "câmera" de 24×34 px com o layout aplicado.
min_cam_score: float = 0.7
# Agrupa pelo CENTRO do grupo (média corrente) com tolerância em tamanhos de rosto: comparar com o 1º membro
# partiu o streamer em dois quando ele se inclinou (0,8 largura de rosto na bancada).
cluster_faces: float = 1.0 # distância máxima ao centro do grupo, em larguras (x) e alturas (y) de rosto
min_presence: float = 0.5 # grupo precisa aparecer em ≥ 50 % dos quadros
stable_faces: float = 0.6 # desvio-padrão máximo do centro do grupo, em tamanhos de rosto (bancada: 0,24)
full_frame_h: float = 0.4 # rosto mais alto que isso = câmera em tela cheia
expand_w: float = 3.2 # retângulo estimado = rosto × 3,2 na largura
expand_h: float = 3.6 # e × 3,6 na altura
shift_down: float = 0.45 # deslocado para baixo em "alturas de rosto" (ombros/peito aparecem na câmera)
edge_reach: float = 1.5 # borda da moldura vale se estiver até X larguras de rosto do lado estimado
headroom: float = 0.35 # a borda de cima nunca encosta no rosto: fica ≥ X alturas de rosto acima (testa/cabelo)
@dataclass(frozen=True)
class FaceSample:
"""Um quadro do rastreador. `cx`/`cy`/`size` normalizados (0..1) no recorte da câmera; `size` = altura do rosto."""
t: float
present: bool
cx: float = 0.0
cy: float = 0.0
size: float = 0.0
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
@dataclass
class FaceSecond:
"""Resumo de um segundo. Canais `None` quando o rosto não apareceu nesse segundo."""
t: int
present: float = 0.0 # fração dos quadros com rosto
cx: float | None = None
cy: float | None = None
size: float | None = None
smile: float | None = None
jaw: float | None = None
surprise: float | None = None
frown: float | None = None
brow: float | None = None
blink: float | None = None
motion: float | None = None
def to_json(self) -> dict:
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`."""
out: dict = {"t": self.t, "present": round(self.present, 3)}
for name in SECOND_FIELDS:
value = getattr(self, name)
if value is not None:
out[name] = round(value, 3)
return out
@classmethod
def from_json(cls, data: dict) -> FaceSecond:
return cls(int(data["t"]), float(data.get("present", 0.0)),
**{n: (float(data[n]) if data.get(n) is not None else None) for n in SECOND_FIELDS})
@dataclass
class ReactionMoment:
peak_s: int
onset_s: int # onde a reação começou (o que causou está logo antes)
end_s: int
intensity: float # z do sinal no pico
label: str
strong: bool
def to_json(self) -> dict:
return {"peakS": self.peak_s, "onsetS": self.onset_s, "endS": self.end_s,
"intensity": round(self.intensity, 2), "label": self.label, "strong": self.strong}
def seconds_to_json(seconds: list[FaceSecond]) -> list[dict]:
return [s.to_json() for s in seconds]
def seconds_from_json(data: list[dict]) -> list[FaceSecond]:
return [FaceSecond.from_json(d) for d in data]
# ---------------------------------------------------------------------------------------------------------------
# Série por segundo
def _mean(values: list[float]) -> float:
return sum(values) / len(values)
def _channels(blend: dict[str, float]) -> dict[str, float]:
"""Blendshapes do MediaPipe → canais de expressão (0..1).
Na live real (bancada) `eyeWide*` fica ~0 o tempo todo e `jawOpen` quase nunca passa de 0,1: a surpresa não
pode depender do olho arregalado: a sobrancelha levantada (`brow`, o maior entre a interna e a externa — na live
inteira as duas sobem juntas) é canal próprio e, com movimento da cabeça, já é susto. Marcou o lag: 0,27 de
média contra 0,02 no calmo.
"""
def g(name: str) -> float:
return float(blend.get(name, 0.0))
outer_up = (g("browOuterUpLeft") + g("browOuterUpRight")) / 2
return {
"smile": (g("mouthSmileLeft") + g("mouthSmileRight")) / 2,
"jaw": g("jawOpen"),
"surprise": (g("eyeWideLeft") + g("eyeWideRight")) / 2,
"frown": (g("browDownLeft") + g("browDownRight")) / 2,
"brow": max(g("browInnerUp"), outer_up),
"blink": (g("eyeBlinkLeft") + g("eyeBlinkRight")) / 2,
}
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> list[FaceSecond]:
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s).
Posição/tamanho/piscar = média; expressões = máximo do segundo (a reação dura menos que 1 s às vezes);
`motion` = caminho percorrido pelo centro (mais a variação de tamanho, quem se joga para a câmera) dividido
pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
"""
n = max(0, int(math.ceil(duration_s)))
first = int(math.floor(start_s))
buckets: list[list[FaceSample]] = [[] for _ in range(n)]
for sample in samples:
i = int(math.floor(sample.t)) - first
if 0 <= i < n:
buckets[i].append(sample)
out: list[FaceSecond] = []
previous: FaceSample | None = None # última amostra com rosto (para o movimento atravessar a virada do segundo)
for i, bucket in enumerate(buckets):
bucket.sort(key=lambda s: s.t)
second = FaceSecond(first + i, present=(sum(1 for s in bucket if s.present) / len(bucket)) if bucket else 0.0)
faces = [s for s in bucket if s.present and s.size > 0]
if faces:
channels = [_channels(s.blend) for s in faces]
second.cx = _mean([s.cx for s in faces])
second.cy = _mean([s.cy for s in faces])
second.size = _mean([s.size for s in faces])
for name in ("smile", "jaw", "surprise", "frown", "brow"):
setattr(second, name, max(c[name] for c in channels))
second.blink = _mean([c["blink"] for c in channels])
path = 0.0
for s in faces:
if previous is not None and s.t - previous.t <= 1.0:
scale = max(1e-6, (s.size + previous.size) / 2)
path += (math.hypot(s.cx - previous.cx, s.cy - previous.cy) + abs(s.size - previous.size)) / scale
previous = s
second.motion = path
out.append(second)
return out
# ---------------------------------------------------------------------------------------------------------------
# Sinal relativo ao neutro do streamer
def _has_face(second: FaceSecond, p: ReactionParams) -> bool:
return second.present >= p.min_present and second.smile is not None
def _robust(values: list[float], floor: float) -> tuple[float, float]:
"""Mediana e desvio robusto (1,4826 × MAD, com piso)."""
median = statistics.median(values)
mad = statistics.median([abs(v - median) for v in values])
return median, max(floor, 1.4826 * mad)
def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[dict[str, float] | None]:
"""z robusto de cada canal por segundo contra o neutro recente do próprio streamer; `None` sem rosto."""
p = params or ReactionParams()
face_idx = [i for i, s in enumerate(seconds) if _has_face(s, p)]
# Série antiga (sem o canal) → 0: o canal fica parado em vez de quebrar.
values = {name: [getattr(seconds[i], name) or 0.0 for i in face_idx] for name in SIGNAL_CHANNELS}
floors = {name: p.mad_floors.get(name, p.mad_floor) for name in SIGNAL_CHANNELS}
# O neutro anda devagar: recalcula a cada `BASELINE_STEP_S` (com cache pelos limites da janela), e a janela sai
# por bisect em `face_idx` — antes era O(n²) e uma live de horas levava segundos por chamada.
cache: dict[tuple[int, int], dict[str, tuple[float, float]]] = {}
out: list[dict[str, float] | None] = []
for t, second in enumerate(seconds):
if not _has_face(second, p):
out.append(None)
continue
anchor = t - t % BASELINE_STEP_S
lo = bisect.bisect_left(face_idx, anchor - p.baseline_s)
hi = bisect.bisect_left(face_idx, anchor - p.exclude_recent_s)
if hi - lo < p.min_baseline_n:
# Começo da gravação: ainda não há neutro suficiente; usa a série inteira (a mediana aguenta os picos).
lo, hi = 0, len(face_idx)
base = cache.get((lo, hi))
if base is None:
base = cache[(lo, hi)] = {name: _robust(values[name][lo:hi], floors[name]) for name in SIGNAL_CHANNELS}
z: dict[str, float] = {}
for name in SIGNAL_CHANNELS:
median, spread = base[name]
z[name] = ((getattr(second, name) or 0.0) - median) / spread
if second.present < p.motion_min_present:
z["motion"] = 0.0
out.append(z)
return out
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
if z is None:
return None
return max(0.0, max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS))
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
params: ReactionParams | None = None) -> list[float | None]:
"""Intensidade de reação por segundo (máximo ponderado dos z das expressões, ≥ 0); `None` sem rosto."""
p = params or ReactionParams()
if baseline_s is not None:
p = replace(p, baseline_s=baseline_s)
return [_signal_from_z(z, p) for z in channel_z(seconds, p)]
# ---------------------------------------------------------------------------------------------------------------
# Rótulo
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
"""Rótulo da expressão: risada, grito, susto, choque, confuso, raiva ou neutro.
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
absolutos (`raw_thresholds`).
Regras (calibradas na live real, doc/FACE_BAKEOFF.md):
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada,
jawOpen ≤ 0,1); sorriso alto em valor absoluto também conta quando outro canal de rosto sobe junto (no
streamer que já sorri o tempo todo o sorriso não tem para onde subir);
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real:
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**;
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
- **choque** = olho arregalado parado;
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
contra 0,02 no calmo).
"""
p = params or ReactionParams()
if second.smile is None:
return "neutro"
if z is not None:
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS}
else:
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
smiling_raw = second.smile >= p.smile_raw
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
return "risada"
if (on["surprise"] or on["brow"]) and on["motion"]:
return "susto"
if on["jaw"]:
return "grito"
if on["frown"]:
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva"
if on["surprise"]:
return "choque"
if on["brow"]:
return "confuso"
return "neutro"
# ---------------------------------------------------------------------------------------------------------------
# Picos e resumo para o juiz
def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[ReactionMoment]:
"""Picos do sinal (≥ `threshold`, do maior para o menor, a `min_gap_s` um do outro), em ordem de tempo.
A mesma reação num trecho contínuo acima de `onset_z` vira um pico só (risada de 5 s não conta duas vezes).
O rótulo vem do segundo do pico; se o pico for só movimento ("neutro"), olha os vizinhos (±1 s) — o grito pode
ter o máximo de boca um segundo antes do pulo. Sem rótulo de expressão o pico sai (salvo `keep_neutral`).
"""
p = params or ReactionParams()
zs = channel_z(seconds, p)
signal = [_signal_from_z(z, p) for z in zs]
values = [v if v is not None else -1.0 for v in signal]
# Trecho contínuo acima de `onset_z` de cada segundo: uma risada de 5 s é UM pico, não dois.
run = [0] * len(values)
current = 0
for i, v in enumerate(values):
if v >= p.onset_z and i > 0 and values[i - 1] >= p.onset_z:
run[i] = current
else:
current += 1
run[i] = current
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
chosen: list[tuple[int, str]] = []
for peak in candidates:
name = _peak_label(seconds, zs, peak, p)
if name == "neutro" and not p.keep_neutral:
continue
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento.
if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
continue
chosen.append((peak, name))
moments: list[ReactionMoment] = []
for peak, name in sorted(chosen):
begin = peak
while begin > 0 and peak - begin < p.max_onset_s and values[begin - 1] >= p.onset_z:
begin -= 1
end = peak
while end + 1 < len(values) and end - peak < p.max_onset_s and values[end + 1] >= p.onset_z:
end += 1
moments.append(ReactionMoment(seconds[peak].t, seconds[begin].t, seconds[end].t, values[peak], name,
values[peak] >= p.strong_z))
return moments
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str:
name = label(seconds[peak], zs[peak], p)
if name == "neutro":
for j in (peak - 1, peak + 1):
if 0 <= j < len(seconds) and zs[j] is not None:
other = label(seconds[j], zs[j], p)
if other != "neutro":
return other
return name
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
params: ReactionParams | None = None, max_items: int = 4,
moments: list[ReactionMoment] | None = None, relative: bool = True) -> str:
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho.
Passe a série inteira (ou bem mais que o trecho): o neutro do streamer vem do que veio antes.
Ex.: "risada forte em 12 s; susto em 15 s". `moments` (opcional): picos já calculados com `reaction_moments`
sobre a série inteira — evita recalcular a live toda a cada corte (~1 s por hora de live).
`relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
"""
p = params or ReactionParams()
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s)
inside = [s for s in seconds if start_s <= s.t <= end]
with_face = [s for s in inside if _has_face(s, p)]
if not with_face:
return "rosto do streamer não aparece no trecho"
parts = []
for m in (moments if moments is not None else reaction_moments(seconds, p)):
if start_s <= m.peak_s <= end:
when = f"{int(round(m.peak_s - start_s))} s" if relative else f"{m.peak_s:.0f}s"
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when}")
presence = len(with_face) / len(inside)
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
if presence < 0.7:
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
return text
# ---------------------------------------------------------------------------------------------------------------
# Onde está a câmera
def _rect(x: float, y: float, w: float, h: float) -> dict[str, float]:
return {"x": round(x, 4), "y": round(y, 4), "w": round(w, 4), "h": round(h, 4)}
def _clip_rect(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
x0, y0 = min(1.0, max(0.0, x0)), min(1.0, max(0.0, y0))
x1, y1 = min(1.0, max(0.0, x1)), min(1.0, max(0.0, y1))
return x0, y0, max(x0, x1), max(y0, y1)
def locate_cam(detections_per_frame: list[list[tuple[float, float, float, float, float]]], frame_w: float,
frame_h: float, edges: dict[str, list[float]] | None = None,
params: ReactionParams | None = None) -> dict:
"""Acha a câmera do streamer a partir das detecções de rosto de alguns quadros espalhados da live.
`detections_per_frame`: um item por quadro (lista vazia = nenhum rosto), cada detecção `(x, y, w, h, score)`
em pixels. `edges` (opcional): bordas persistentes da moldura da câmera, em fração do quadro —
`{"xs": [linhas verticais], "ys": [linhas horizontais]}` (ex.: média do gradiente entre os quadros).
A câmera é o grupo de rostos que aparece na mesma posição em ≥ `min_presence` dos quadros; rosto de jogo,
cutscene ou de outra pessoa passa por poucos quadros e é ignorado (na bancada, 6 rostos de uma tela de
carregamento apareceram em 2 de 12 quadros, sempre no mesmo lugar: é a presença que separa, não a posição).
Cada detecção entra no grupo cujo CENTRO (média corrente) esteja a até `cluster_faces` larguras/alturas de
rosto dela — o streamer que se inclina continua no mesmo grupo.
Retângulo: rosto expandido (≈3,2× largura, 3,6× altura, deslocado para baixo), com folga acima da testa.
Câmera sem moldura (streamer recortado sobre o jogo, o caso da bancada) só tem esse caminho; `edges` é opcional
e só ajusta os lados quando há moldura de verdade. Devolve
`{hasWebcam, cam: {x,y,w,h} | None, faceRect, confidence, fullFrame}` em frações 0..1.
"""
p = params or ReactionParams()
total = len(detections_per_frame)
empty = {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
if total == 0 or frame_w <= 0 or frame_h <= 0:
return empty
# Grupos por posição: cada um guarda (quadro, cx, cy, w, h, score) normalizados.
groups: list[list[tuple[int, float, float, float, float, float]]] = []
for frame, detections in enumerate(detections_per_frame):
for x, y, w, h, score in detections:
if score < p.min_score or w <= 0 or h <= 0:
continue
nw, nh = w / frame_w, h / frame_h
cx, cy = x / frame_w + nw / 2, y / frame_h + nh / 2
best, best_d = None, math.inf
for g in groups:
gx, gy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
dx, dy = abs(cx - gx) / gw, abs(cy - gy) / gh
if dx <= p.cluster_faces and dy <= p.cluster_faces and max(dx, dy) < best_d:
best, best_d = g, max(dx, dy)
if best is None:
groups.append([(frame, cx, cy, nw, nh, score)])
else:
best.append((frame, cx, cy, nw, nh, score))
candidates = []
for g in groups:
frames = len({d[0] for d in g})
ratio = frames / total
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
# Estabilidade em tamanhos de rosto: independe do zoom da câmera e da resolução.
spread = math.hypot(statistics.pstdev([d[1] for d in g]) / gw, statistics.pstdev([d[2] for d in g]) / gh)
if ratio >= p.min_presence and spread <= p.stable_faces and _mean([d[5] for d in g]) >= p.min_cam_score:
candidates.append((ratio, _mean([d[5] for d in g]), spread, g))
if not candidates:
return empty
ratio, score, spread, g = max(candidates, key=lambda c: (c[0], c[1]))
fw, fh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
fcx, fcy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
face_rect = _rect(*_xywh(*_clip_rect(fcx - fw / 2, fcy - fh / 2, fcx + fw / 2, fcy + fh / 2)))
confidence = round(min(1.0, ratio * score * (1.0 - 0.5 * spread / p.stable_faces)), 3)
if fh > p.full_frame_h:
return {"hasWebcam": True, "cam": _rect(0, 0, 1, 1), "faceRect": face_rect,
"confidence": confidence, "fullFrame": True}
# Estimativa pelo rosto: 3,2× a largura, 3,6× a altura, deslocado para baixo (ombros aparecem na câmera).
cw, ch = fw * p.expand_w, fh * p.expand_h
ccy = fcy + p.shift_down * fh
x0, x1 = fcx - cw / 2, fcx + cw / 2
y0, y1 = ccy - ch / 2, ccy + ch / 2
if edges:
reach_x, reach_y = p.edge_reach * fw, p.edge_reach * fh
x0 = _snap(x0, edges.get("xs", []), outside_of=fcx - fw / 2, reach=reach_x, side=-1)
x1 = _snap(x1, edges.get("xs", []), outside_of=fcx + fw / 2, reach=reach_x, side=1)
# Em cima, a borda só vale acima da folga da testa: moldura falsa (ex.: um banner) não corta a cabeça.
y0 = _snap(y0, edges.get("ys", []), outside_of=fcy - fh / 2 - p.headroom * fh, reach=reach_y, side=-1)
y1 = _snap(y1, edges.get("ys", []), outside_of=fcy + fh / 2, reach=reach_y, side=1)
cam = _rect(*_xywh(*_clip_rect(x0, y0, x1, y1)))
return {"hasWebcam": True, "cam": cam, "faceRect": face_rect, "confidence": confidence, "fullFrame": False}
def _xywh(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
return x0, y0, x1 - x0, y1 - y0
def _snap(estimate: float, lines: list[float], outside_of: float, reach: float, side: int) -> float:
"""Troca o lado estimado pela borda da moldura mais próxima dele, se houver uma além do rosto e a até `reach`."""
valid = [v for v in lines if (v <= outside_of if side < 0 else v >= outside_of) and abs(v - estimate) <= reach]
return min(valid, key=lambda v: abs(v - estimate)) if valid else estimate
+283
View File
@@ -0,0 +1,283 @@
"""Reenquadramento do jogo no tempo (câmera virtual com keyframes) e camadas inseridas (recorte da tela em destaque).
Pedido do dono (17/11/2026, corte 61 em câmera-em-cima): "na hora que ele abre o inventário preciso pegar um ângulo
melhor; se quero mostrar alguma coisa no canto da tela, criar camadas para isso".
**Reenquadramento** (`project.reframe.keys`): janela (centro `cx`, `cy` e largura `w`, frações do quadro ORIGINAL)
que vira a área do jogo do layout daquele instante. A altura sai da proporção da área de destino (parte de baixo no
`cam_top`; a tela toda nos outros), então nunca distorce. Enquanto houver keys, `layout.game` é ignorado (os keys são
absolutos no quadro original). Não vale para `cam_only`. Interpolação entre keys pelo `ease` do key de saída:
`smooth` (suave), `linear` ou `hold` (segura e salta no key seguinte). Antes do 1º e depois do último, segura.
No FFmpeg: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro `in`) viram o quadro
inteiro com interpolação SUBPIXEL, depois `scale` para a área de destino. Medido (protótipo, zoom de 1,0 → 0,4 em 4 s
num 1280×720): nenhum passo para trás entre quadros, desvio da aceleração 0,12 px (sem tremida), 0,38 s de render.
`scale` com `eval=frame` + `crop` de tamanho fixo, a alternativa, falhou no encoder (tamanho variável) e arredonda o
deslocamento a pixels inteiros.
**Camadas inseridas** (`overlays[]` com `kind: "inset"`): recorte `src` do quadro original, posto em `x`/`y` (centro) com
largura `size` da tela; borda, cantos arredondados, sombra e animação. Vêm do vídeo original (antes do layout), ficam
acima do vídeo/zoom e abaixo da legenda, gancho, textos e chat (o ASS vem depois). Ordem no array = empilhamento.
No FFmpeg: `crop` → `scale` (tamanho-base fixo) → `alphamerge` com a máscara dos cantos → por cima de UMA imagem
de decoração (sombra borrada + borda, gerada aqui com numpy/OpenCV) → `scale` por quadro só se o tamanho muda
(keys, pop) → `fade` de alfa → um `overlay` sobre o vídeo (expressão por quadro só se a posição muda: keys,
slide). Medido no corte 61 (60 s, NVENC): sem nada 6,1–6,2 s; com reenquadramento 7,1–9,5 s; com
reenquadramento + 2 camadas (pop e slide) 15,8–20,5 s (com sombra, borda e recorte postos separados: 28,2 s).
"""
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
FPS = 30
EASES = ("smooth", "linear", "hold")
INSET_ANIMS = ("pop", "fade", "slide", "none")
MAX_KEYS = 60
MAX_INSETS = 12
ANIM_S = 0.18 # entrada/saída de alfa das camadas
SLIDE_S = 0.35
SHADOW_ALPHA = 0.55
# ---------------------------------------------------------------- interpolação (Python e expressão do FFmpeg)
def _smooth(u: float) -> float:
return u * u * (3 - 2 * u)
def interp(keys: list[dict], t: float, field: str) -> float:
"""Valor de `field` no instante `t` (mesmo resultado da expressão do FFmpeg)."""
if t <= keys[0]["t"]:
return float(keys[0][field])
for a, b in zip(keys, keys[1:]):
if t < b["t"]:
ease = a.get("ease", "smooth")
if ease == "hold":
return float(a[field])
u = (t - a["t"]) / max(1e-3, b["t"] - a["t"])
u = _smooth(u) if ease == "smooth" else u
return float(a[field]) + (float(b[field]) - float(a[field])) * u
return float(keys[-1][field])
def piecewise(keys: list[dict], field: str, var: str) -> str:
"""Expressão do FFmpeg equivalente a `interp` (variável de tempo `var`, já entre parênteses)."""
expr = f"{float(keys[-1][field]):.5f}"
for a, b in reversed(list(zip(keys, keys[1:]))):
va, vb = float(a[field]), float(b[field])
ease = a.get("ease", "smooth")
if ease == "hold" or abs(vb - va) < 1e-9:
seg = f"{va:.5f}"
else:
u = f"clip(({var}-{a['t']:.4f})/{max(1e-3, b['t'] - a['t']):.4f},0,1)"
u = f"({u}*{u}*(3-2*{u}))" if ease == "smooth" else u
seg = f"({va:.5f}+{vb - va:.5f}*{u})"
expr = f"if(lt({var},{b['t']:.4f}),{seg},{expr})"
return expr
def keys_for_range(keys: list[dict], a: float, b: float) -> list[dict]:
"""Só os keys que influenciam [a, b] (o último antes de `a`, os de dentro e o primeiro depois de `b`)."""
if not keys:
return []
first = max([i for i, k in enumerate(keys) if k["t"] <= a], default=0)
last = min([i for i, k in enumerate(keys) if k["t"] >= b], default=len(keys) - 1)
return keys[first: last + 1]
# ---------------------------------------------------------------- reenquadramento
def window(keys: list[dict], t: float, src_w: float, src_h: float, dest_aspect: float) -> tuple[float, float, float, float]:
"""(x, y, largura, altura) em px do quadro original no instante `t` (presa dentro do quadro, sem deformar)."""
ww = min(src_w * interp(keys, t, "w"), src_h * dest_aspect)
wh = ww / dest_aspect
x = min(max(src_w * interp(keys, t, "cx") - ww / 2, 0.0), src_w - ww)
y = min(max(src_h * interp(keys, t, "cy") - wh / 2, 0.0), src_h - wh)
return x, y, ww, wh
def perspective_filter(keys: list[dict], piece_start: float, piece_end: float, dest_aspect: float) -> str:
"""`perspective` cujos 4 cantos são a janela no tempo da SESSÃO (o trecho começa em `piece_start`; o filtro conta
os quadros do trecho em `in`, que começa em 1, a 30 qps). Saída do tamanho da entrada; o layout escala para a área de destino."""
ks = keys_for_range(keys, piece_start, piece_end)
# `in` do perspective começa em 1 no 1º quadro (medido: com in/30 a janela ia 1 quadro adiantada).
var = f"({piece_start:.4f}+(in-1)/{FPS})"
a = f"{dest_aspect:.6f}"
ww = f"st(1,min(W*({piecewise(ks, 'w', var)}),H*{a}))"
left = f"{ww};st(2,clip(W*({piecewise(ks, 'cx', var)})-ld(1)/2,0,W-ld(1)))"
top = f"{ww};st(3,ld(1)/{a});st(4,clip(H*({piecewise(ks, 'cy', var)})-ld(3)/2,0,H-ld(3)))"
x_l, x_r = f"{left};ld(2)", f"{left};ld(2)+ld(1)"
y_t, y_b = f"{top};ld(4)", f"{top};ld(4)+ld(3)"
return (f"perspective=x0='{x_l}':y0='{y_t}':x1='{x_r}':y1='{y_t}':x2='{x_l}':y2='{y_b}':x3='{x_r}':y3='{y_b}'"
f":interpolation=linear:sense=source:eval=frame")
def piece_reframe(project: dict, piece_start: float, piece_end: float):
"""Função (proporção de destino → filtro) para `layout.layout_chain`, ou None sem reenquadramento."""
keys = (project.get("reframe") or {}).get("keys") or []
if not keys:
return None
return lambda dest_aspect: perspective_filter(keys, piece_start, piece_end, dest_aspect)
def static_reframe(project: dict, t: float):
"""Reenquadramento parado no instante `t` (capa): mesma janela, sem animação."""
keys = (project.get("reframe") or {}).get("keys") or []
if not keys:
return None
frozen = [{"t": 0.0, "cx": interp(keys, t, "cx"), "cy": interp(keys, t, "cy"), "w": interp(keys, t, "w"), "ease": "hold"}]
return lambda dest_aspect: perspective_filter(frozen, 0.0, 1.0, dest_aspect)
# ---------------------------------------------------------------- camadas inseridas
@dataclass
class InsetPlan:
"""Uma camada pronta para o grafo. A camada vira UMA imagem composta (sombra + borda + recorte) de tamanho
`decor_w`×`decor_h`, com o recorte em (`ox`, `oy`); só ela é posta sobre o vídeo (um overlay grande por camada).
Medido no corte 61 (60 s): com sombra, borda e recorte postos separados no quadro inteiro, 2 camadas levavam o
render de 7,1 s para 28,2 s."""
inset: dict
a: float # entrada (tempo de saída)
b: float # saída
base_w: int # recorte em px do vídeo (no maior tamanho dos keys)
base_h: int
ox: int # posição do recorte dentro da imagem composta
oy: int
decor_w: int
decor_h: int
mask_file: Path
decor_file: Path | None # sombra + borda (None = sem nenhuma das duas)
keys: list[dict] # keys em tempo de SAÍDA (x, y, size, ease)
@property
def dynamic_size(self) -> bool:
return self.inset["anim"] == "pop" or len({k["size"] for k in self.keys}) > 1
@property
def dynamic_pos(self) -> bool:
return self.inset["anim"] == "slide" or len({(k["x"], k["y"]) for k in self.keys}) > 1
def _rounded_alpha(w: int, h: int, radius: float):
import numpy as np
yy, xx = np.mgrid[0:h, 0:w].astype(np.float32) + 0.5
r = max(0.0, min(radius, w / 2, h / 2))
if r <= 0:
return np.ones((h, w), np.float32)
dx = np.maximum(np.maximum(r - xx, xx - (w - r)), 0)
dy = np.maximum(np.maximum(r - yy, yy - (h - r)), 0)
return np.clip(r - np.sqrt(dx * dx + dy * dy) + 0.5, 0, 1)
def _make_images(plan: InsetPlan, border_color: str | None, pad: int, shadow_pad: int, radius_px: float) -> None:
"""Máscara dos cantos (tamanho do recorte) e a imagem de decoração (sombra borrada + borda), em PNG."""
import cv2
import numpy as np
w, h = plan.base_w, plan.base_h
cv2.imwrite(str(plan.mask_file), (_rounded_alpha(w, h, radius_px) * 255).astype(np.uint8))
if plan.decor_file is None:
return
rgb = np.zeros((plan.decor_h, plan.decor_w, 3), np.float32)
alpha = np.zeros((plan.decor_h, plan.decor_w), np.float32)
bw, bh = w + 2 * pad, h + 2 * pad
outer = _rounded_alpha(bw, bh, radius_px + pad if radius_px else 0)
x0, y0 = plan.ox - pad, plan.oy - pad
if shadow_pad:
off = max(1, shadow_pad // 2)
shadow = np.zeros_like(alpha)
shadow[y0 + off: y0 + off + bh, x0 + off: x0 + off + bw] = outer
alpha = cv2.GaussianBlur(shadow, (0, 0), sigmaX=max(1.0, shadow_pad / 2.5)) * SHADOW_ALPHA
if pad and border_color:
color = np.array([int(border_color[i: i + 2], 16) for i in (5, 3, 1)], np.float32) # BGR
a_b = np.zeros_like(alpha)
a_b[y0: y0 + bh, x0: x0 + bw] = outer
rgb = (color * a_b[..., None] + rgb * (alpha * (1 - a_b))[..., None]) / np.maximum(
(a_b + alpha * (1 - a_b))[..., None], 1e-6)
alpha = a_b + alpha * (1 - a_b)
img = np.dstack([np.clip(rgb, 0, 255), alpha * 255]).astype(np.uint8)
cv2.imwrite(str(plan.decor_file), img)
def plan_insets(project: dict, cuts_to_output, t0: float, t1: float, frame: tuple[int, int], canvas_w: int,
src_size: tuple[int, int], work: Path, stem: str) -> list[InsetPlan]:
"""Camadas que aparecem na saída [t0, t1], com tamanhos em px e as imagens auxiliares geradas em `work`."""
fw, _fh = frame
k = fw / canvas_w # px do quadro lógico (borda, raio) → px do vídeo
plans = []
for n, o in enumerate(x for x in project["overlays"] if x["kind"] == "inset"):
a, b = cuts_to_output(o["start"]), cuts_to_output(o["end"])
if b - a < 0.05 or b <= t0 or a >= t1:
continue
keys = [{"t": cuts_to_output(x["t"]), "x": x["x"], "y": x["y"], "size": x["size"], "ease": x.get("ease", "smooth")}
for x in o.get("keys") or []] or [{"t": a, "x": o["x"], "y": o["y"], "size": o["size"], "ease": "hold"}]
top_size = max(x["size"] for x in keys)
src = o["src"]
base_w = max(8, int(round(top_size * fw / 2)) * 2)
base_h = max(8, int(round(base_w * (src["h"] * src_size[1]) / (src["w"] * src_size[0]) / 2)) * 2)
pad = int(round(o["borderW"] * k)) if o["border"] else 0
shadow_pad = max(6, int(round(0.03 * base_w))) if o["shadow"] else 0
decor = pad > 0 or shadow_pad > 0
margin = pad + shadow_pad
tag = f"{stem}-inset{n}"
plan = InsetPlan(o, a, b, base_w, base_h, margin, margin,
base_w + 2 * margin + shadow_pad // 2 if decor else base_w,
base_h + 2 * margin + shadow_pad // 2 if decor else base_h,
work / f"{tag}-mask.png", work / f"{tag}-decor.png" if decor else None, keys)
_make_images(plan, o["border"], pad, shadow_pad, o["radius"] * k)
plans.append(plan)
return plans
def inset_graph(plans: list[InsetPlan], inputs: list[dict], base: str, raw: str, t0: float, frame: tuple[int, int],
out: str) -> list[str]:
"""Trechos do filter_complex: [base] (vídeo já no layout) + camadas → [out]. `raw` = vídeo original concatenado;
`inputs[i]` = {"mask": idx, "decor": idx|None} das entradas PNG (em loop) de cada camada. Tamanho e posição só
viram expressão por quadro quando mudam (keys, pop, slide)."""
fw, fh = frame
g = [f"[{raw}]split={len(plans)}" + "".join(f"[ir{i}]" for i in range(len(plans))) if len(plans) > 1
else f"[{raw}]null[ir0]"]
cur = base
T = f"(t+{t0:.3f})"
for i, (p, idx) in enumerate(zip(plans, inputs)):
o, src = p.inset, p.inset["src"]
a, b = p.a - t0, p.b - t0 # tempo do grafo (a prévia começa em 0)
g.append(f"[ir{i}]crop=iw*{src['w']}:ih*{src['h']}:iw*{src['x']}:ih*{src['y']},scale={p.base_w}:{p.base_h},"
f"setsar=1,format=rgba[iv{i}]")
g.append(f"[{idx['mask']}:v]format=gray[im{i}]")
g.append(f"[iv{i}][im{i}]alphamerge[ia{i}]")
comp = f"ia{i}"
if idx.get("decor") is not None: # recorte por cima da sombra + borda (imagem pequena, uma vez por quadro)
g.append(f"[{idx['decor']}:v]format=rgba[id{i}]")
g.append(f"[id{i}][ia{i}]overlay={p.ox}:{p.oy}:format=rgb[ic{i}]")
comp = f"ic{i}"
chain = []
if p.dynamic_size:
k = f"(({piecewise(p.keys, 'size', T)})/{p.base_w / fw:.5f})"
if o["anim"] == "pop": # cresce de 82 % a 106 % e assenta em 100 %
k += (f"*if(lt({T}-{p.a:.3f},0.16),0.82+0.24*({T}-{p.a:.3f})/0.16,"
f"if(lt({T}-{p.a:.3f},0.28),1.06-0.06*({T}-{p.a:.3f}-0.16)/0.12,1))")
chain.append(f"scale=w='max(2,round({p.decor_w}*{k}))':h='max(2,round({p.decor_h}*{k}))':eval=frame")
elif p.keys[0]["size"] * fw < p.base_w - 1: # tamanho fixo menor que o maior dos keys (não acontece sem keys)
s = p.keys[0]["size"] * fw / p.base_w
chain.append(f"scale={max(2, round(p.decor_w * s))}:{max(2, round(p.decor_h * s))}")
if o["anim"] != "none":
chain.append(f"fade=t=in:st={max(0.0, a):.3f}:d={ANIM_S}:alpha=1")
chain.append(f"fade=t=out:st={max(0.0, b - ANIM_S):.3f}:d={ANIM_S}:alpha=1")
if chain:
g.append(f"[{comp}]" + ",".join(chain) + f"[if{i}]")
comp = f"if{i}"
fx, fy = (p.ox + p.base_w / 2) / p.decor_w, (p.oy + p.base_h / 2) / p.decor_h # centro do recorte na imagem
if p.dynamic_pos:
dx = ""
if o["anim"] == "slide": # entra pela direita
u = f"clip(({T}-{p.a:.3f})/{SLIDE_S},0,1)"
dx = f"+{fw * 0.7:.1f}*(1-{u}*{u}*(3-2*{u}))"
pos = (f"x='{fw}*({piecewise(p.keys, 'x', T)}){dx}-w*{fx:.5f}':"
f"y='{fh}*({piecewise(p.keys, 'y', T)})-h*{fy:.5f}':eval=frame")
else:
pos = f"x='{fw * p.keys[0]['x']:.2f}-w*{fx:.5f}':y='{fh * p.keys[0]['y']:.2f}-h*{fy:.5f}'"
nxt = out if i == len(plans) - 1 else f"li{i}"
g.append(f"[{cur}][{comp}]overlay={pos}:enable='between(t,{a:.3f},{b:.3f})'[{nxt}]")
cur = nxt
return g
+399
View File
@@ -0,0 +1,399 @@
"""Escolha dos melhores momentos. Funções puras (sem E/S): recebem a linha do tempo e devolvem os trechos.
Ideia central: o chat reage DEPOIS do momento. Medimos a "empolgação" do chat por segundo (mensagens com peso:
risada, susto, hype e pedido de clip valem mais), comparamos com o normal recente da própria live (chat grande
tem muita mensagem o tempo todo; o que importa é o pico relativo) e, achado o pico, voltamos no tempo até onde a
reação começou e pegamos alguns segundos antes disso: é ali que aconteceu a coisa.
Sem chat (VOD), o sinal vem do volume do áudio (gritos, risadas) e de palavras de reação na transcrição.
Rosto do streamer (opcional, `face`): a série por segundo do rastreio (reaction.py). Reforça momentos do chat/áudio
(`reasons.face` + bônus limitado na nota) e cria momentos de fonte "face" só quando o áudio ou o chat também se
mexem no mesmo trecho — rosto sozinho nunca vira corte. Sem `face`, o resultado é idêntico ao de antes.
"""
from __future__ import annotations
import math
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field, replace
from . import reaction
# Peso extra por categoria de reação. Uma mensagem pode somar mais de uma.
REACTION_PATTERNS: dict[str, tuple[re.Pattern[str], float]] = {
"risada": (re.compile(r"(k{3,}|kek|lul|lmao|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b)", re.I), 1.0),
"susto": (re.compile(r"(caralho|crlh|caraca|nossa|meu deus|mds|wtf|omg|que isso|q isso|monkas|monkaw|\bhuh+\b|"
r"😱|😳|\?{3,}|!{3,})", re.I), 1.0),
"hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥)", re.I), 0.7),
# Palavra inteira: "clip5k1hmm" (emote) casava com \bclip e dava peso de pedido de clipe.
"clip": (re.compile(r"\b(clip|clips|clipa|clipe|clipou|clipar|clip it|clipit)\b", re.I), 3.0),
}
# Palavras faladas que indicam reação (modo sem chat).
SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha)$", re.I)
@dataclass(frozen=True)
class Params:
pre_s: float = 14.0 # quanto antes do início da reação o corte começa
post_s: float = 6.0 # quanto depois do pico o corte termina
# Duração do candidato: o motor troca pelos valores da configuração do corte de cada sessão (`duration`);
# estes são os mesmos padrões de layout.DEFAULTS (pedido do dono, 16/11/2026: cortes de 60 a 90 s).
min_s: float = 60.0
max_s: float = 90.0
threshold: float = 2.2 # pico precisa ser X vezes o normal recente do chat
audio_threshold: float = 2.0 # modo sem chat: z-score mínimo
min_gap_s: float = 45.0 # distância mínima entre dois picos
smooth_s: int = 5
baseline_s: int = 180
onset_ratio: float = 1.3 # o início da reação é onde a razão cai abaixo disto
max_onset_s: float = 30.0
settle_s: float = 12.0 # ao vivo: espera este tanto depois do fim do corte antes de fechar o pico
min_rate: float = 0.2 # mensagens/s mínimas no denominador (live com chat parado não vira pico por 2 msgs)
min_peak_messages: int = 12 # teto do mínimo de mensagens nos 8 s do pico (chat grande)
min_peak_floor: int = 4 # piso do mínimo (chat pequeno): 3 mensagens soltas nunca viram pico
min_reactions: int = 2 # mensagens de reação (risada/susto/hype/clip) nos 8 s do pico
sparse_rate: float = 0.5 # msg/s abaixo disso o chat é "fraco" e o áudio também propõe momentos
warmup_s: int = 60 # começo da gravação: ainda não há "normal" do chat para comparar
# --- rosto do streamer (reaction.py) ---
face_threshold: float = 3.0 # z mínimo da reação no rosto para anotar/reforçar um momento
face_bonus: float = 0.08 # nota extra por unidade de z do rosto num momento do chat/áudio…
face_bonus_max: float = 0.6 # …limitada a isto (o rosto reforça, não manda)
# Momento NOVO de fonte "face" (calibrado na sessão 3: com z ≥ 3 e apoio fraco saíam 32 momentos em 72 min,
# mais que os 21 do chat): reação forte no rosto E apoio de verdade no mesmo trecho.
face_source_threshold: float = 6.0 # z mínimo (= "forte")
face_support_audio_z: float = 1.5 # sinal do áudio suavizado (3 s) acima disto…
face_support_reactions: int = 2 # …ou pelo menos isto de mensagens de reação (texto ou emote) no chat
face_chat_after_s: float = 10.0 # o chat reage depois: conta até X s após o pico do rosto
face_score_scale: float = 0.4 # nota do momento "face" = z do rosto (até 10) × isto, na escala da razão do chat
@dataclass(frozen=True)
class ChatMessage:
t: float
text: str
user: str = ""
emotes: tuple[str, ...] = () # emotes da mensagem (Twitch, 7TV, BTTV, FFZ, Kick, emoji)
bonus: float = 0.0 # peso extra pelos emotes (base + aprendido do canal; ver emotes.py)
@dataclass(frozen=True)
class Word:
start: float
end: float
word: str
@dataclass
class Moment:
peak_s: float
start_s: float
end_s: float
score: float
source: str # "chat" ou "audio"
reasons: dict = field(default_factory=dict)
def message_weight(text: str) -> tuple[float, list[str]]:
weight, tags = 1.0, []
for tag, (pattern, bonus) in REACTION_PATTERNS.items():
if pattern.search(text):
weight += bonus
tags.append(tag)
return weight, tags
def per_second(duration_s: float, chat: list[ChatMessage]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
series = [0.0] * n
for message in chat:
i = int(message.t)
if 0 <= i < n:
series[i] += message_weight(message.text)[0] + message.bonus
return series
def smooth(series: list[float], window: int) -> list[float]:
"""Média móvel para trás (só usa o passado: o valor em t não depende do futuro)."""
out, acc = [], 0.0
for i, value in enumerate(series):
acc += value
if i >= window:
acc -= series[i - window]
out.append(acc / min(i + 1, window))
return out
def chat_ratio(series: list[float], p: Params) -> list[float]:
"""Razão entre a empolgação suavizada e o normal recente (mediana dos últimos `baseline_s`, sem os últimos 10 s)."""
smoothed = smooth(series, p.smooth_s)
ratio = []
for t, value in enumerate(smoothed):
window = smoothed[max(0, t - p.baseline_s): max(0, t - 10)]
if len(window) < 30: # começo da gravação: usa o que tiver
window = smoothed[: t + 1]
base = max(p.min_rate, statistics.median(window) if window else p.min_rate)
ratio.append(value / base)
return ratio
def zscores(series: list[float]) -> list[float]:
values = [v for v in series if v is not None and not math.isnan(v)]
if len(values) < 10:
return [0.0] * len(series)
mean = statistics.fmean(values)
sd = statistics.pstdev(values) or 1.0
return [((v - mean) / sd) if v is not None and not math.isnan(v) else 0.0 for v in series]
def audio_signal(duration_s: float, loudness: list[float | None], words: list[Word]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
loud = (list(loudness) + [None] * n)[:n]
z = zscores([v if v is not None else float("nan") for v in loud])
signal = [max(0.0, v) for v in z]
for word in words:
i = int(word.start)
if 0 <= i < n and SPOKEN_REACTION.match(word.word.strip(" .,!?…").lower()):
signal[i] += 0.5
return smooth(signal, 3)
def pick_peaks(score: list[float], threshold: float, min_gap_s: float, limit_s: float | None = None) -> list[int]:
"""Picos acima do limiar, do maior para o menor, sem dois a menos de `min_gap_s`."""
# Escolhe olhando a série inteira e só depois descarta os não assentados (após `limit_s`): assim, ao vivo,
# um pico maior que ainda está crescendo segura os pontos menores do começo da mesma explosão.
candidates = sorted((i for i in range(len(score)) if score[i] >= threshold), key=lambda i: -score[i])
chosen: list[int] = []
for i in candidates:
if all(abs(i - j) >= min_gap_s for j in chosen):
chosen.append(i)
return sorted(i for i in chosen if limit_s is None or i < limit_s)
def onset(score: list[float], peak: int, below: float, max_back_s: float) -> int:
t = peak
while t > 0 and peak - t < max_back_s and score[t - 1] >= below:
t -= 1
return t
def snap_to_words(start: float, end: float, words: list[Word], gap: float = 0.35, reach: float = 4.0) -> tuple[float, float]:
"""Não corta no meio de uma frase: recua o início até uma pausa e estica o fim até uma pausa (até `reach` s)."""
if not words:
return start, end
ordered = sorted(words, key=lambda w: w.start)
# Começos de frase (palavra depois de uma pausa) perto do início pedido; prefere o mais próximo ANTES dele.
starts = [
w.start for i, w in enumerate(ordered)
if start - reach <= w.start <= start + 0.5 and (i == 0 or w.start - ordered[i - 1].end >= gap)
]
before = [s for s in starts if s <= start]
new_start = (max(before) if before else min(starts)) - 0.15 if starts else start
new_end = end
for i, word in enumerate(ordered):
if end - 0.5 <= word.end <= end + reach:
pause_after = ordered[i + 1].start - word.end if i + 1 < len(ordered) else gap
if pause_after >= gap:
new_end = word.end + 0.25
break
return max(0.0, new_start), max(new_end, new_start + 1)
def fit_window(start: float, end: float, lo: float, hi: float, min_len: float, max_len: float,
keep: str = "end") -> tuple[float, float]:
"""Encaixa [start, end] em [lo, hi] com duração entre `min_len` e `max_len`. Longo demais: corta o lado oposto a
`keep`. Curto demais: cresce PARA TRÁS primeiro (o contexto vem antes da reação) e, se bater em `lo` (começo da
gravação/janela), para a frente até `hi`. Se nem assim couber (material menor que o mínimo), devolve o que der —
quem chama decide o que fazer (não inventa vídeo). Arredonda para fora (centésimos), nunca encurta."""
start, end = max(lo, start), min(hi, end)
if end < start:
end = start
if end - start > max_len:
if keep == "start":
end = start + max_len
else:
start = end - max_len
if end - start < min_len:
start = max(lo, end - min_len)
if end - start < min_len:
end = min(hi, start + min_len)
return math.floor(start * 100) / 100, math.ceil(end * 100 - 1e-6) / 100
def fit_length(start: float, end: float, peak: float, p: Params, duration_s: float) -> tuple[float, float]:
"""Duração do candidato: começa pelo menos 2 s antes do pico e fica entre `min_s` e `max_s` (o motor passa o
mínimo da configuração + 1 s). Antes a ordem permitia passar do máximo e, no fim da gravação, ficar curto."""
start = max(0.0, min(start, peak - 2))
return fit_window(start, end, 0.0, max(duration_s, end), p.min_s, p.max_s, keep="end")
def chat_reasons(chat: list[ChatMessage], start: float, end: float) -> dict:
inside = [m for m in chat if start <= m.t <= end]
tags: Counter[str] = Counter()
phrases: Counter[str] = Counter()
emotes: Counter[str] = Counter()
for message in inside:
tags.update(message_weight(message.text)[1])
emotes.update(set(message.emotes))
normalized = re.sub(r"\s+", " ", message.text.strip())[:40]
if normalized:
phrases[normalized.lower()] += 1
return {
"messages": len(inside),
"tags": dict(tags.most_common()),
"topMessages": [text for text, _ in phrases.most_common(5)],
"emotes": dict(emotes.most_common(8)),
}
def find_moments(
duration_s: float,
chat: list[ChatMessage],
loudness: list[float | None],
words: list[Word],
params: Params | None = None,
live: bool = False,
face: list[reaction.FaceSecond] | None = None,
) -> list[Moment]:
"""Melhores momentos da linha do tempo. `live=True` só devolve picos já "assentados" (fim + settle_s <= duração).
Chat com movimento → picos do chat. Chat fraco (média < `sparse_rate` msg/s) → picos do chat E do áudio
(gritos/risadas/palavras de reação), sem sobrepor; o juiz de IA filtra. Sem chat → só áudio.
`face`: série do rosto alinhada à linha do tempo (índice = segundo; `None`/vazia = sem rosto).
"""
p = params or Params()
use_chat = len(chat) >= 30
moments = _chat_moments(duration_s, chat, loudness, words, p, live) if use_chat else []
sparse = duration_s > 0 and len(chat) / duration_s < p.sparse_rate
if not use_chat or sparse:
for m in _audio_moments(duration_s, loudness, words, p, live):
if not any(overlaps(m.start_s, m.end_s, c.start_s, c.end_s) for c in moments):
moments.append(m)
if face:
moments += _face_moments(duration_s, chat if use_chat else [], loudness, words, face, moments, p, live)
return sorted(moments, key=lambda m: m.peak_s)
def _face_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
face: list[reaction.FaceSecond], moments: list[Moment], p: Params, live: bool) -> list[Moment]:
"""Anota o rosto nos momentos do chat/áudio (bônus limitado) e devolve os momentos novos de fonte "face"."""
reactions = reaction.reaction_moments(face, replace(reaction.ReactionParams(), threshold=p.face_threshold))
if not reactions:
return []
for m in moments:
near = [r for r in reactions if m.start_s - 2 <= r.peak_s <= m.end_s + 3]
if near:
best = max(near, key=lambda r: r.intensity)
m.reasons["face"] = best.to_json()
m.score = round(m.score + min(p.face_bonus_max, p.face_bonus * best.intensity), 3)
n = max(0, int(math.ceil(duration_s)))
# Sinal do áudio suavizado (3 s, igual ao da fonte "audio"): o z cru de 1 segundo passa de 1 por acaso em ~16 %
# dos segundos e não serviria de apoio.
loud = audio_signal(duration_s, loudness, words)
reacting = [m.t for m in chat if message_weight(m.text)[1] or m.emotes]
limit = duration_s - p.post_s - p.settle_s if live else None
out: list[Moment] = []
for r in sorted(reactions, key=lambda r: -r.intensity):
if r.intensity < p.face_source_threshold or (limit is not None and r.peak_s >= limit):
continue
lo, hi = max(0, r.onset_s - 2), min(n, r.peak_s + 4)
audio = max(loud[lo:hi], default=0.0)
chat_hits = sum(1 for t in reacting if r.onset_s - 2 <= t <= r.peak_s + p.face_chat_after_s)
# Rosto sozinho não vira corte: precisa de apoio do áudio (gritou/riu alto) ou do chat no mesmo trecho.
if audio < p.face_support_audio_z and chat_hits < p.face_support_reactions:
continue
start, end = snap_to_words(r.onset_s - p.pre_s, max(r.end_s, r.peak_s) + p.post_s, words)
start, end = fit_length(start, end, r.peak_s, p, duration_s)
if any(overlaps(start, end, m.start_s, m.end_s) for m in moments + out):
continue
if any(abs(r.peak_s - m.peak_s) < p.min_gap_s for m in out):
continue
reasons = {"peakRatio": round(r.intensity, 2), "onsetS": r.onset_s, "face": r.to_json(),
"support": {"audioZ": round(audio, 2), "chatReactions": chat_hits}}
if chat:
reasons |= chat_reasons(chat, r.onset_s - 2, r.peak_s + 3)
out.append(Moment(float(r.peak_s), start, end, round(min(10.0, r.intensity) * p.face_score_scale, 3), "face",
reasons))
return out
def _required_messages(counts_8s: list[int], t: int, p: Params) -> int:
"""Mínimo de mensagens nos 8 s do pico, proporcional ao chat daquela live (mediana recente × 3).
Medido em 17/11/2026: chat de 0,15 msg/s (skipnho) nunca chegava às 12 mensagens fixas e a live inteira ficava
sem corte; chat de ~0,6 msg/s (alanzoka) com 3 mensagens soltas não pode virar pico. Fica entre 4 e 12.
"""
window = counts_8s[max(0, t - p.baseline_s): max(0, t - 10)] or counts_8s[: t + 1]
typical = statistics.median(window) if window else 0
return int(max(p.min_peak_floor, min(p.min_peak_messages, math.ceil(typical * 3))))
def _chat_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
p: Params, live: bool) -> list[Moment]:
score, threshold = chat_ratio(per_second(duration_s, chat), p), p.threshold
loud_z = zscores([v if v is not None else float("nan") for v in (list(loudness) + [None] * len(score))[: len(score)]])
score = [s + 0.15 * max(0.0, z) for s, z in zip(score, loud_z)] # grito junto com o pico do chat soma um pouco
# Falso positivo medido na live real: chat calmo + 3 mensagens (uma com "clip") já dava razão 2,35, e o
# começo da gravação (sem "normal" para comparar) virava pico. Exige gente reagindo (relativo ao chat) e aquecimento.
counts, reacts = [0] * len(score), [0] * len(score)
for message in chat:
i = int(message.t)
if 0 <= i < len(counts):
counts[i] += 1
# Reação = texto de reação OU emote (público pequeno reage com emote em vez de "kkkk").
reacts[i] += 1 if (message_weight(message.text)[1] or message.emotes) else 0
prefix, rprefix = [0], [0]
for c, r in zip(counts, reacts):
prefix.append(prefix[-1] + c)
rprefix.append(rprefix[-1] + r)
counts_8s = [prefix[t + 1] - prefix[max(0, t - 7)] for t in range(len(score))] # mensagens nos últimos 8 s
for t in range(len(score)):
required = _required_messages(counts_8s, t, p)
reactions = rprefix[t + 1] - rprefix[max(0, t - 7)]
# Chat pequeno junta 4 "oi" por acaso: além do volume, exige reação de verdade (ou volume dobrado).
enough = counts_8s[t] >= required and (reactions >= p.min_reactions or counts_8s[t] >= 2 * required)
if t < p.warmup_s or not enough:
score[t] = min(score[t], threshold - 0.01)
return _build(score, threshold, p.onset_ratio, "chat", duration_s, chat, words, p, live)
def _audio_moments(duration_s: float, loudness: list[float | None], words: list[Word], p: Params, live: bool) -> list[Moment]:
score = audio_signal(duration_s, loudness, words)
return _build(score, p.audio_threshold, 0.8, "audio", duration_s, [], words, p, live)
def _build(score: list[float], threshold: float, below: float, source: str, duration_s: float,
chat: list[ChatMessage], words: list[Word], p: Params, live: bool) -> list[Moment]:
limit = duration_s - p.post_s - p.settle_s if live else None
moments = []
for peak in pick_peaks(score, threshold, p.min_gap_s, limit):
begin = onset(score, peak, below, p.max_onset_s)
start, end = begin - p.pre_s, peak + p.post_s
start, end = snap_to_words(start, end, words)
start, end = fit_length(start, end, peak, p, duration_s)
reasons = {"peakRatio": round(score[peak], 2), "onsetS": begin}
if chat:
reasons |= chat_reasons(chat, begin - 2, peak + 3)
moments.append(Moment(float(peak), start, end, round(score[peak], 3), source, reasons))
return moments
def overlaps(a_start: float, a_end: float, b_start: float, b_end: float, tolerance: float = 5.0) -> bool:
return a_start < b_end - tolerance and b_start < a_end - tolerance
def timeline(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], params: Params | None = None) -> dict:
"""Séries por segundo para o gráfico do painel (mensagens/s, razão do chat, volume)."""
p = params or Params()
raw = per_second(duration_s, chat)
counts = [0] * len(raw)
for message in chat:
if 0 <= int(message.t) < len(counts):
counts[int(message.t)] += 1
return {
"messagesPerS": counts,
"ratio": [round(v, 2) for v in chat_ratio(raw, p)] if chat else [],
"loudnessDb": [None if v is None else round(v, 1) for v in loudness[: len(raw)]],
}
+78
View File
@@ -0,0 +1,78 @@
"""Reconhece a plataforma e o canal a partir do link colado (Twitch, YouTube, Kick)."""
from __future__ import annotations
import re
from dataclasses import dataclass
from urllib.parse import parse_qs, urlparse
PLATFORMS = ("twitch", "youtube", "kick")
_TWITCH_LOGIN = re.compile(r"^[a-z0-9_]{3,25}$")
_KICK_SLUG = re.compile(r"^[a-z0-9_-]{2,40}$")
_YT_HANDLE = re.compile(r"^@[A-Za-z0-9._-]{2,40}$")
_YT_VIDEO = re.compile(r"^[A-Za-z0-9_-]{11}$")
_TWITCH_RESERVED = {"videos", "directory", "settings", "p", "search", "downloads", "jobs", "turbo"}
class SourceError(ValueError):
"""Link que o Clipador não reconhece."""
@dataclass(frozen=True)
class Source:
platform: str
channel: str # login (Twitch), slug (Kick) ou @handle/ID do canal (YouTube); "" quando só há o vídeo
url: str # link normalizado que vai para o Streamlink
kind: str # "live" (canal) ou "vod" (vídeo gravado)
@property
def channel_id(self) -> str:
return f"{self.platform}-{self.channel.lstrip('@').lower()}"
def parse_source(raw: str) -> Source:
text = raw.strip()
if not text:
raise SourceError("Cole o link da live ou do vídeo.")
if "://" not in text:
text = "https://" + text
url = urlparse(text)
if url.scheme not in ("http", "https"):
raise SourceError("O link precisa começar com https://.")
host = (url.hostname or "").lower().removeprefix("www.").removeprefix("m.")
parts = [p for p in url.path.split("/") if p]
if host in ("twitch.tv", "go.twitch.tv"):
if len(parts) >= 2 and parts[0] == "videos" and parts[1].isdigit():
return Source("twitch", "", f"https://www.twitch.tv/videos/{parts[1]}", "vod")
if len(parts) >= 3 and parts[1] == "video" and parts[2].isdigit():
return Source("twitch", parts[0].lower(), f"https://www.twitch.tv/videos/{parts[2]}", "vod")
if parts and _TWITCH_LOGIN.fullmatch(parts[0].lower()) and parts[0].lower() not in _TWITCH_RESERVED:
login = parts[0].lower()
return Source("twitch", login, f"https://www.twitch.tv/{login}", "live")
raise SourceError("Link da Twitch não reconhecido (use twitch.tv/<canal> ou twitch.tv/videos/<id>).")
if host == "kick.com":
if len(parts) >= 3 and parts[1] == "videos":
return Source("kick", parts[0].lower(), f"https://kick.com/{parts[0].lower()}/videos/{parts[2]}", "vod")
if len(parts) == 1 and _KICK_SLUG.fullmatch(parts[0].lower()):
slug = parts[0].lower()
return Source("kick", slug, f"https://kick.com/{slug}", "live")
raise SourceError("Link da Kick não reconhecido (use kick.com/<canal>).")
if host in ("youtube.com", "youtu.be"):
if host == "youtu.be" and parts and _YT_VIDEO.fullmatch(parts[0]):
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[0]}", "vod")
video = parse_qs(url.query).get("v", [""])[0]
if parts[:1] == ["watch"] and _YT_VIDEO.fullmatch(video):
return Source("youtube", "", f"https://www.youtube.com/watch?v={video}", "vod")
if len(parts) >= 2 and parts[0] in ("live", "shorts") and _YT_VIDEO.fullmatch(parts[1]):
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[1]}", "vod")
if parts and _YT_HANDLE.fullmatch(parts[0]):
return Source("youtube", parts[0], f"https://www.youtube.com/{parts[0]}/live", "live")
if len(parts) >= 2 and parts[0] == "channel" and re.fullmatch(r"UC[A-Za-z0-9_-]{22}", parts[1]):
return Source("youtube", parts[1], f"https://www.youtube.com/channel/{parts[1]}/live", "live")
raise SourceError("Link do YouTube não reconhecido (use youtube.com/@canal ou o link do vídeo).")
raise SourceError("Plataforma não suportada: use Twitch, YouTube ou Kick.")
+146
View File
@@ -0,0 +1,146 @@
"""Legenda queimada no corte (formato ASS, lido pelo filtro `ass` do FFmpeg), no vertical ou no horizontal.
Estilo de corte de live: blocos curtos, grandes, com contorno, e a palavra falada no momento destacada.
Cores, fonte, tamanho, posição e palavras por bloco vêm da configuração do corte (layout.py, grupo `caption`).
O crédito do canal fica em cima ou embaixo (grupo `credit`) — sempre ligado por padrão: o corte é de terceiros.
Tempo da legenda (pedido do dono, 16/11/2026: "com fala rápida a legenda sai fora do tempo e fica uma em cima da
outra"). Medido na cópia do banco: 63 de 286 eventos de legenda dos projetos se sobrepunham — o fim de um bloco
(fim da última palavra, no mínimo +0,25 s) passava do início do bloco seguinte, e o libass EMPILHA dois eventos
ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
- `clean_words`: palavras ordenadas, sem sobreposição, duração mínima (o Whisper devolve palavra de 0 s) e nunca
duas começando no mesmo instante;
- `group_words`: até `maxWords` palavras e um limite de caracteres; bloco quebra em pausa > 0,6 s ou se passar de
3,2 s; com fala muito rápida (bloco cheio durando < 0,7 s) aceita UMA palavra a mais se couber nos caracteres,
para o bloco não piscar;
- `caption_blocks`: o fim de cada bloco é cortado no início do seguinte — nunca dois blocos na tela. O início do
bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
"""
from __future__ import annotations
from . import layout
from .scoring import Word
WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração
MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6
MIN_WORD_S = 0.06 # duração mínima de uma palavra na legenda
MIN_STEP_S = 0.04 # duas palavras nunca começam no mesmo instante (a palavra destacada precisa de tempo próprio)
MIN_HOLD_S = 0.25 # a última palavra do bloco fica pelo menos isto (se o próximo bloco não começar antes)
MAX_BLOCK_S = 3.2 # bloco mais longo que isto quebra (fala arrastada)
FAST_BLOCK_S = 0.7 # bloco cheio mais curto que isto = fala rápida: aceita uma palavra a mais
def _ts(seconds: float) -> str:
seconds = max(0.0, seconds)
cs = int(round(seconds * 100))
h, cs = divmod(cs, 360000)
m, cs = divmod(cs, 6000)
s, cs = divmod(cs, 100)
return f"{h}:{m:02d}:{s:02d}.{cs:02d}"
def _escape(text: str) -> str:
# Chaves abrem tags de estilo e \ vira comando no ASS: o texto falado nunca pode virar tag.
return text.replace("\\", "/").replace("{", "(").replace("}", ")").replace("\n", " ")
def clean_words(words: list[Word]) -> list[Word]:
"""Saneia os tempos das palavras: ordena, tira vazias, dá duração mínima, empurra a que começa junto com a
anterior e corta o fim de uma palavra no início da seguinte (sem sobreposição). Idempotente nos valores
(aplicar duas vezes dá o mesmo resultado); depois dela, (início, texto) identifica cada palavra."""
items = sorted((w for w in words if w.word.strip()), key=lambda w: (w.start, w.end))
out: list[Word] = []
for w in items:
start = w.start
if out and start < out[-1].start + MIN_STEP_S - 1e-6:
start = round(out[-1].start + MIN_STEP_S, 3)
end = max(w.end, round(start + MIN_WORD_S, 3))
if out and out[-1].end > start + 1e-9:
prev = out[-1]
out[-1] = Word(prev.start, start, prev.word)
text = w.word.strip()
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word
out.append(w if same else Word(start, end, text))
return out
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
"""Blocos da legenda (palavras já saneadas por `clean_words`)."""
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
groups: list[list[Word]] = []
for word in clean_words(words):
current = groups[-1] if groups else None
if current and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S:
fits = len(" ".join(w.word for w in current + [word])) <= max_chars
room = len(current) < max_words or (
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
max_words >= 2 and len(current) == max_words and word.end - current[0].start < FAST_BLOCK_S)
if fits and room:
current.append(word)
continue
groups.append([word])
return groups
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]:
"""(palavras do bloco, fim do bloco). O fim nunca passa do início do bloco seguinte: dois eventos de legenda
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro)."""
groups = group_words(words, max_words)
out = []
for k, group in enumerate(groups):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
if k + 1 < len(groups):
end = min(end, groups[k + 1][0].start)
out.append((group, round(end, 3)))
return out
def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str, settings: dict | None = None) -> str:
"""`words` com tempos da sessão; a saída usa tempos relativos ao início do corte."""
cfg = settings or layout.merge()
cap, cred = cfg["caption"], cfg["credit"]
duration = clip_end - clip_start
inside = [
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip())
for w in words
if w.end > clip_start and w.start < clip_end
]
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
width, height = layout.canvas_size(cfg)
header = f"""[Script Info]
ScriptType: v4.00+
PlayResX: {width}
PlayResY: {height}
WrapStyle: 2
ScaledBorderAndShadow: yes
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Caption,{cap['font']},{cap['size']},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{cap['outlineWidth']},3,5,60,60,0,1
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""
lines = []
if credit and cred["enabled"]:
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
if cap["enabled"]:
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}"
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
for group, g_end in caption_blocks(inside, cap["maxWords"]):
for i, word in enumerate(group):
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start:
continue
# Maiúsculas só no texto: as tags (\c) são sensíveis a caixa.
parts = []
for j, w in enumerate(group):
text = _escape(w.word.upper() if cap["uppercase"] else w.word)
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text)
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},Caption,,0,0,0,,{pos}{' '.join(parts)}")
return header + "\n".join(lines) + "\n"
File diff suppressed because it is too large Load Diff