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:
@@ -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}"
|
||||
@@ -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
|
||||
@@ -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}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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]}
|
||||
@@ -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")}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()}
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)]],
|
||||
}
|
||||
@@ -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.")
|
||||
@@ -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
Reference in New Issue
Block a user