CenaForge: primeira versão pública

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

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+29
View File
@@ -0,0 +1,29 @@
# Clipador do CenaForge. O setup.bat copia este arquivo para clipper/.env e preenche a chave.
# Gere uma chave à mão com: python -c "import secrets; print(secrets.token_urlsafe(48))"
CLIPPER_SERVICE_KEY=
# Porta (faixa 4500–4599 do CenaForge). Escuta só em 127.0.0.1.
CLIPPER_PORT=4520
# A qualidade de gravação agora é por canal/sessão (painel, "Configuração do corte" → Gravação; padrão: a melhor
# disponível). CLIPPER_QUALITY não é mais lida.
# Tamanho de cada bloco gravado (segundos). Menor = cortes saem mais cedo; maior = menos arquivos.
CLIPPER_SEGMENT_S=30
# De quanto em quanto tempo checar se um canal monitorado entrou ao vivo (segundos).
CLIPPER_POLL_S=60
# Blocos gravados mais velhos que isto (horas) são apagados se nenhum corte precisar deles. 0 = nunca apagar.
CLIPPER_KEEP_HOURS=6
# Idioma da transcrição (serviço de voz).
CLIPPER_LANGUAGE=pt-BR
# Encoder dos cortes: auto (NVENC se houver, senão libx264) | libx264 | h264_nvenc
CLIPPER_ENCODER=auto
# Juiz dos candidatos: IA que confirma o momento e escreve título/legenda, pelas CLIs já logadas no PC
# (as mesmas da página Agente). codex (padrão, GPT) | claude | off (só a heurística do chat/áudio).
# São só os valores iniciais: o provedor, o modelo e a nota mínima se trocam na página Clipador do painel.
CLIPPER_JUDGE_PROVIDER=codex
# Vazio = padrão do provedor (codex: gpt-6-luna, rápido e barato; claude: haiku).
CLIPPER_JUDGE_MODEL=
# Nota mínima (0–10) do juiz para o corte ser renderizado.
CLIPPER_JUDGE_MIN_SCORE=6
# Pastas opcionais para isolar uma instância de teste (vazio = padrão). Precisam ficar dentro do repositório,
# porque blocos e cortes vão para o banco com caminho relativo ao repo. Ex.: output/face-live-test/data
# CLIPPER_DATA_DIR=data/clipper (banco, blocos gravados, modelos do rastreio, arquivos do juiz)
# CLIPPER_OUTPUT_DIR=output/clipper (cortes prontos, prévias e projetos do editor)
+552
View File
@@ -0,0 +1,552 @@
# Clipador — cortes automáticos de live
Serviço local do CenaForge (`127.0.0.1:4520`, faixa 4500–4599) que assiste lives da **Twitch, YouTube e Kick**,
lê o **chat em tempo real**, transcreve a fala com o **Whisper** (serviço de voz, 4510), pede a uma **IA pela CLI**
(Codex/GPT por padrão, ou Claude) que confirme o momento e gera **cortes com legenda queimada**: verticais 1080×1920
(Shorts/Reels/TikTok, padrão) ou horizontais 1920×1080 (YouTube "tela grande", mostrando o próprio jogo).
O painel (`/clipper`) mostra a fila para aprovar. As contas que recebem os cortes de cada canal são ligadas na
página **Contas**, como as histórias.
> **Publicação nas redes (YouTube, TikTok, Instagram) é a próxima etapa.** Hoje "Aprovar" só marca o corte.
## Como funciona
```
Streamlink ─► bomba (Python) ─► FFmpeg -f segment: blocos .ts de 30 s + segments.csv data/clipper/sessions/<id>/
Chat (IRC anônimo da Twitch · websocket da Kick) ─► tabela chat (hora real de cada mensagem)
Cada bloco novo ─► volume por segundo (RMS) + Whisper com tempo por palavra (POST /v1/transcribe, X-Detail: words)
A cada 15 s ─► pontuação do chat/áudio (app/scoring.py) ─┐
A cada 3 min ─► VARREDURA da IA: frames + fala + chat ──┴► candidato ─► ANALISTA (vê frames) ─► EDITOR ─► render
Contexto (app/intel.py): jogo pela categoria + tela + perfil pesquisado na web · webcam achada pela IA · emotes
output/clipper/<sessão>/clip-<id>.mp4 (layout.py)
```
1. **Chat aponta.** Cada mensagem pesa 1; risada (`KKKK`, `KEKW`, `ICANT`, `PepeLaugh`…), susto (`caralho`,
`HUH`, `monkaW`…), hype (`POG`, `W`, `GG`…) somam peso, e pedido de clipe (`clip`, `clipa`) soma 3.
A empolgação de cada segundo é comparada com o **normal recente da própria live** (mediana dos últimos 3 min):
canal grande tem muita mensagem o tempo todo, o que conta é o pico relativo. O mínimo de mensagens nos 8 s do
pico é **proporcional ao chat** (3× a mediana recente, entre 4 e 12) e exige ≥ 2 mensagens de reação (texto ou
emote) — chat de 0,15 msg/s (skipnho) nunca chegava às 12 fixas. Ignora o 1º minuto da gravação.
**Emotes** (Twitch nativos pela tag do IRC, 7TV/BTTV/FFZ do canal e globais, emojis, Kick) contam como reação e
têm **peso aprendido por canal** (tabela `emotes`): sobe nos cortes que você aprova, desce nos rejeitados (a
decisão da IA também conta, com metade do peso).
2. **O corte começa antes da reação.** O chat reage depois do acontecimento: do pico, o código volta até onde a
reação começou e pega mais 14 s antes; termina 6 s depois do pico. Ajusta início/fim a pausas da fala (não corta
no meio da frase) e limita à duração da configuração do corte (`duration`, padrão **60–90 s**; o candidato já
nasce nessa duração, crescendo para trás a partir do fim da reação).
3. **Chat fraco ou sem chat**: o volume (gritos/risadas) e palavras de reação também propõem momentos.
4. **Varredura da IA** (live pequena, reação que não vira mensagem): a cada `scanIntervalS` (180 s) de gravação a IA
assiste a janela — 7 frames, fala, chat, perfil do jogo, resumos das janelas anteriores — e propõe 0–2 momentos.
Medido: ~7 s por janela com `gpt-6-luna` (~20 chamadas/h). Proposta com nota < 4 nem vai aos juízes.
5. **Dois juízes** para cada candidato (chat, áudio ou varredura):
- **Analista** (vê 6 frames do trecho + fala + chat + glossário de gírias): `situation` (lag_ou_bug, jogada,
falha_engracada, morte, susto, treta, conversa_engracada, historia, informacao_do_jogo, reacao, outro),
o que aconteceu, o que a tela/fala/chat mostram, confiança 0–1, início da AÇÃO e fim da reação.
- **Editor** (só texto + a análise): manter/descartar, nota, início/fim, título e legenda fiéis à situação.
Pode voltar até `duration.backtrackS` (padrão **120 s**) antes do candidato: o comentário vem depois da ação.
O analista recebe 6 quadros (8 quando o trecho passa de 80 s, o normal com cortes de 60–90 s) de 20 s antes do
candidato até 15 s depois; a transcrição vai da volta inteira (até 2 min antes) até 15 s depois.
Medido no corte do lag (skipnho): título antigo "Jogando três jogos ao mesmo tempo…" → "O lag jogou ele em três
lugares ao mesmo tempo" (situation `lag_ou_bug`, confiança 0,93; chat "server chinês?" entendido como lag), início
recuado 35 s até "o jogo voltou a lagar". ~18 s pelos dois juízes.
Abaixo da nota mínima (padrão 6) o corte fica como **descartado pela IA** — visível, e dá para forçar o render.
6. **Ao vivo**, um pico só é fechado quando passaram 18 s depois dele (pico ainda crescendo não vira corte cedo) e a
fala do trecho já foi transcrita.
Tempo: `t` = soma das durações dos blocos. A mensagem do chat é convertida pela hora em que cada bloco terminou de
chegar (`wall_end`), então a pausa do Streamlink ao filtrar anúncio da Twitch não desalinha chat e vídeo.
**Cartão da sessão no painel:** o relógio da gravação corre segundo a segundo a partir do último `durationS`, com
teto de 45 s além dele (passou disso, mostra "aguardando o bloco"); "Agora na live" mostra a contagem para o próximo
resumo da varredura, com o intervalo vindo de `GET /v1/status` → `judge.options.scanIntervalS`.
## Contexto do jogo
- Categoria da plataforma (Streamlink `--json`, `metadata.category`) no início e a cada 10 min (troca registrada em
`games_json`). Sem categoria (YouTube/VOD), o jogo vem da tela (`screen_game` da varredura). A IA também diz o que
vê na tela; divergência (categoria "ROB RUN", tela "GTA V") vai para o contexto dos juízes.
- **Perfil do jogo** pesquisado na web pela CLI (`codex --search`), guardado por jogo (tabela `games`): resumo,
mecânicas, o que rende corte, o que não rende, gírias, novidades, fontes. Medido: ~15–35 s por jogo.
- Correção manual: `PUT /v1/sessions/{id}/game` (trava a troca automática).
## Configuração do corte (layout, câmera, legenda)
Por canal (padrão do streamer), por sessão e por corte (`settings` do projeto de edição) — cada camada sobrescreve
campo a campo (padrão ← canal ← sessão ← projeto) — `app/layout.py`:
- `format.aspect`: `vertical` (padrão, 1080×1920, Shorts/Reels/TikTok) ou `horizontal` (1920×1080, YouTube "tela
grande"). No **horizontal** o vídeo mostra o quadro original inteiro (16:9 preenche; outra proporção ganha faixas
pretas em vez de ser cortada) ou, se `layout.game` estiver marcado, essa região recortada para preencher 1920×1080
sem distorcer; `cam_only` continua valendo (câmera em tela cheia); `auto`, `blur`, `cam_top` e `game_only` viram
"quadro inteiro" (`resolved_mode` = `full`). Textos: o ASS do horizontal usa um quadro lógico de **2560×1440**
(o libass reduz para 1920×1080), então os mesmos tamanhos em px do JSON saem a **75 %**: legenda 84 → 63 px,
gancho 68 → 51 px, crédito 44 → 33 px, chat 34 → 25,5 px. Posições 0–1 continuam relativas ao quadro. Legenda
automática (`caption.y: null`) a 85 % da altura (terço de baixo); crédito no canto direito (em cima ou embaixo).
- `layout.mode`: `auto` (câmera em cima se houver câmera marcada), `blur`, `cam_top` (webcam no terço de cima, jogo
embaixo recortado no centro), `game_only`, `cam_only` (a câmera do streamer ocupa a tela inteira; sem câmera
marcada cai em `blur`); `cam`/`game` = retângulos 0–1 do quadro original; `camHeight`.
- `caption`: fonte, tamanho, cor, cor da palavra falada, contorno, posição (`y`; automático = emenda câmera/jogo),
maiúsculas, palavras por bloco. `credit`: liga/desliga, topo/rodapé (no `cam_top` desce para o pé da câmera).
- `duration`: `minS` (5–120, padrão 60), `maxS` (15–180, padrão 90), `minS` < `maxS`, e `backtrackS` (0–120, padrão
120 = a IA pode voltar até 2 min para pegar o contexto). Para Shorts de terceiros, um canal pode baixar para ≤ 60 s.
**Todo corte automático sai com duração final ≥ `minS` + 1 s** (pedido do dono: "se o mínimo é 60 tem que ser 60;
sempre 1 s a mais"; no código, +0,1 s de folga de quadro: `layout.min_target`) e ≤ `maxS`, medida no arquivo. Vale
para a heurística (candidato), a varredura, os juízes, o projeto da IA (depois de silêncios e aparos) e o "IA
sugere"; faltando material, o corte cresce para trás (contexto) e, no começo da gravação, para a frente
(`scoring.fit_window`). Gravação menor que o mínimo: não inventa vídeo, o projeto registra "curto: só havia X s".
"Cortar agora" e a edição à mão continuam livres.
- `hook`: estilo do gancho que o projeto da IA põe no começo: `style` (`plain` | `banner`), `bg` (cor da tarja),
`color` (texto), `font`, `anim` (`pop` | `fade` | `none` | `slide`) e `seconds` (1–8). Padrão: **tarja** verde-limão
`#00FF00`, texto branco com contorno preto em Luckiest Guy, `slide`, 3 s. A tarja cobre o começo do corte: o
segundo a mais do mínimo é essa abertura (vem da própria gravação, de preferência antes da ação; não há tela parada
nem atraso do conteúdo). Se a legenda automática estiver perto de 20 % da altura, a tarja vai para o outro lado.
- **Fontes**: `caption.font`, `hook.font` e `font` dos textos aceitam as do Windows (Arial Black, Arial, Impact,
Verdana, Segoe UI Black, Trebuchet MS) e as **empacotadas** em `assets/fonts/` (Luckiest Guy — Apache-2.0; Bangers,
Anton, Bebas Neue, Poppins ExtraBold — OFL-1.1), baixadas do google/fonts num commit fixo, com sha256 em
`assets/fonts/fonts.lock.json` e a licença ao lado de cada arquivo. O serviço confere o sha256 ao carregar e, quando
o ASS usa uma delas, passa a pasta ao libass (`ass=…:fontsdir='…'`). Acentos do português conferidos.
- **Webcam achada sem IA** nos 2 primeiros blocos da sessão: YuNet procura o rosto em 12 quadros espalhados e
`reaction.locate_cam` acha a câmera (ver "Rastreio de reação"); salva como padrão do canal (ou da sessão). A IA (3
frames, ~5 s) só entra se o local não achar rosto e a visão estiver ligada, ou com `POST …/detect-cam?ai=true`.
`cam_json.source` diz quem achou: `yunet` | `ai` | `manual`.
- Prévia: `POST /v1/sessions/{id}/preview` gera a imagem no formato efetivo (1080×1920 ou 1920×1080) sem salvar;
`GET …/frame` dá o quadro para desenhar.
## Qualidade de gravação (`capture`)
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` (`CLIPPER_QUALITY`) e nunca passava de 720p. Agora é o grupo `capture` da
configuração do corte (padrão ← canal ← sessão; `app/capture.py`):
- `capture.quality`: `best` (**padrão**: a maior resolução que a live oferece) ou um **teto** — `1440p`, `1080p`,
`720p`, `480p` (a maior variante que não passa dele). Vale na próxima gravação ou retomada: a captura em andamento
não troca de qualidade. `CLIPPER_QUALITY` não é mais lida.
- **Escolha** pelos sinônimos do próprio Streamlink: `best` (ignora `audio_only` e as variantes verticais
`*_portrait`); teto = `--stream-sorting-excludes >{teto}60` + `best,worst-unfiltered` (sem nada abaixo do teto, pega
a menor variante que existe: nunca falha por causa da qualidade). Twitch com `best`/`1440p`:
`--twitch-supported-codecs h264,h265` (o 2K da transmissão aprimorada vem em HEVC; com h265 pedido as variantes
paisagem continuaram H.264). AV1 não é pedido (FFmpeg sem libdav1d).
- **Sem opção de 30/60 qps**: a variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives) e o
corte sai em 30 qps de qualquer jeito; pedir 30 qps custaria resolução.
- **O que foi gravado**: o `ffprobe` do 1º bloco de cada execução (início ou retomada) vai para `sessions.capture_json`
(migração v9) e sai em `GET /v1/sessions/{id}` como `capture`: `quality` (pedida), `width`, `height`, `fps`,
`codec`, `kbps`, `gbPerHour`, `fromIdx`, `runs` (últimas 10 execuções) e `mixed` (blocos em mais de uma
resolução). Sessões de antes ficam `null` (eram ≤ 720p). As rotas de settings devolvem `captureQualities`
(rótulo, teto, GB/h e dica de cada opção).
Nomes de stream medidos com `streamlink --json` (17/11/2026; 143 lives da Twitch, 5 da Kick, 22 do YouTube):
| Plataforma | Nomes | `best` |
|---|---|---|
| Twitch | `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`, `360p30`, `160p30`, `audio_only`; em 9 canais `1920p60_portrait`, `1280p60_portrait`, `852p30_portrait`… (a de 1080×1920 em HEVC) | `1080p60` (ou `936p60`/`1080p`) |
| Kick | `1080p60`, `720p60`, `480p`, `360p`, `160p` | `1080p60` |
| YouTube | `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p` (o HLS do Streamlink para em 1080p, até em live "4K") | `1080p` |
Nenhuma live 2K no ar nas 3 plataformas no dia: o 1440p foi medido com blocos 1440p60 gerados a partir do 1080p60 real.
**Custo medido** (17/11/2026, trecho real do skipnho gravado ao mesmo tempo em 720p60 e 1080p60, no formato do serviço;
2K = 1080p60 ampliado para 2560×1440 a ~10 Mbps, em H.264 e em HEVC; CPU de 32 threads + RTX 2060 SUPER):
| Etapa | 720p60 | 1080p60 | 1440p60 H.264 | 1440p60 HEVC |
|---|---|---|---|---|
| Bloco de 30 s | 12,8 MB | 29,9 MB | 40,9 MB | 39,3 MB |
| Disco por hora | 1,5 GB | 3,6 GB | 4,9 GB | 4,7 GB |
| Render de 60 s, vertical / horizontal (NVENC) | 6,3 / 6,2 s | 6,5 / 6,4 s | 6,5 / 6,4 s | 6,7 / 6,7 s |
| Render de 60 s, vertical / horizontal (libx264) | 4,6 / 3,3 s | — | — | 6,2 / 5,4 s |
| Proxy 480p de 90 s | 2,5 s | 3,1 s | 3,8 s | 5,2 s |
| 8 frames do analista (a varredura usa 7) | 0,9 s | 1,4 s | 1,9 s | 2,3 s |
| Achar a câmera (YuNet, 12 quadros) | 1,5 s | 2,3 s | 3,0 s | 3,5 s |
| Rastreio do rosto, bloco de 30 s (só o FFmpeg) | 1,7 s (0,4 s) | 1,7 s (0,7 s) | 1,9 s (1,0 s) | 2,1 s (1,5 s) |
| Áudio do bloco (volume + Whisper) | 0,06 s | 0,07 s | 0,07 s | 0,08 s |
Disco por hora pelas playlistas mestras da Twitch (`BANDWIDTH`, mediana de 62–69 lives): 1080p60 7,1 Mbps
(4,6–9,1) ≈ **3,2 GB/h** (até 4,1); 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h. 2K estimado em
~4,5 GB/h. Com `CLIPPER_KEEP_HOURS` = 6, uma live longa em 1080p60 guarda até ~19–25 GB de blocos (antes ~9 GB);
o padrão continua 6. Nenhuma etapa ficou inviável: tudo que não precisa de 2K já reduz a escala (frames do juiz
768 px, YuNet 1280 px, rastreio ~384 px, proxy 480p); o custo extra é decodificar a fonte maior.
**Nitidez**: a câmera recortada no vertical (`cam_top`) gravada em 1080p60 sai mais nítida que em 720p60, no mesmo
trecho: variância do Laplaciano 130 → 149, energia de alta frequência 3,24 → 3,91 (+21 %). O 2K ampliado não ganha
nada (mesma informação do 1080p), como esperado. Retângulos `cam`/`game` são 0–1 e valem em qualquer resolução;
nenhum filtro do render assume 720p (os `scale=` são para o tamanho de saída; NVENC/x264 por qualidade, sem teto
de bitrate).
## Editor de cortes (`/clipper/edit/<id>`)
**Um caminho só de render:** todo corte é renderizado a partir de um **projeto de edição** (JSON versionado,
tabela `edits`; migrações v4 e v7), seja ele feito pela IA ou por você.
**A IA entrega o corte quase pronto.** Depois dos juízes, o render gera o projeto (`editor.auto_project`) com o que
o pipeline já sabe:
- **trecho:** do início da ação (`action_start_s` − 0,8 s) ao fim da reação (+0,8 s), sem cortar no meio de
palavra e limitado a `duration.maxS`;
- **silêncios:** vãos ≥ 2 s sem fala, quietos (< −38 dBFS) e longe do pico (±3 s) saem do corte;
- **legenda:** palavras do Whisper no estilo da configuração do corte, preset `pop` (tempo saneado no render: ver
"Tempo da legenda");
- **gancho:** o `hook` do analista nos primeiros 2,8 s, só se for curto (≤ 8 palavras e ≤ 48 caracteres) e sem tempo
da gravação (frase como "Aos 5085s, ele…" é recusada; `editor.pick_hook`); senão, o título do editor. Um
"aos/em NNN s" que sobrar é tirado, e texto acima de 60 caracteres é cortado em palavra inteira (nunca no meio);
- **zoom:** punch-in de 1,25× no `peak_s`, no rosto quando a câmera está em cima;
- **capa:** quadro do pico com o gancho;
- **layout e formato:** os da sessão/canal (o projeto pode trocar o formato só deste corte em `settings.format`).
O projeto fica marcado `meta.origin = "ai"` (com data, modelo e passos). O que a IA gerou fica guardado em
`ai_project_json` ("Projeto da IA" no editor volta a ele, e dá para desfazer). Se você salvar no editor, a origem
vira `user`. Nova avaliação dos juízes refaz só o projeto de origem `ai`; o seu nunca é apagado.
O painel abre o editor em **tela cheia**:
- barra superior com fila, título, origem, estado do salvamento, **Salvar projeto** (Ctrl+S; também salva sozinho),
botões para **minimizar** cada painel (camadas, transcrição/chat, propriedades), "IA sugere", atalhos e Exportar;
- **Camadas** à esquerda (textos, legenda, zoom, câmera, vídeo, áudio, narração, música, chat na tela, barra, capa),
transcrição/chat ao lado, **Fonte · Programa** no centro (gravação original e o 9:16) e **Propriedades** à direita;
- timeline na largura toda, com uma trilha por camada: C1 legenda, V3 textos, V2 zoom, **CAM câmera** (layout de
cada trecho), V1 vídeo (miniaturas), A1 áudio (forma de onda, "MUDO"), A2 narração, A3 música, CH chat.
Tudo cabe em 100vh, e cada painel rola sozinho. O desenho segue o padrão dos editores de vídeo (tokens `nle-*` em
`panel/src/app/globals.css`); fluxos secundários (exportar, IA, narração, atalhos) abrem em modal.
**Mexer com a mão:**
| Onde | Gesto | Efeito |
|---|---|---|
| Timeline, palavra da legenda | arrastar o corpo | move a palavra (ou o grupo selecionado) no tempo, sem passar pelas vizinhas |
| Timeline, palavra da legenda | puxar a borda esquerda ou direita | apara: encurta ou estica só aquele lado (o áudio não muda) |
| Timeline, clipe de vídeo/áudio | puxar as bordas · arrastar o corpo | estica/encolhe o trecho · desliza o trecho sobre a gravação |
| Timeline, clipe | lâmina (C) ou **Ctrl+Shift+clique** · S ou **Ctrl+K** | divide onde clicar · divide no playhead |
| Timeline, texto/zoom/narração | arrastar corpo e bordas | move e muda a duração |
| Programa (vídeo 9:16) | arrastar texto, gancho, legenda ou chat | muda a posição na tela (`x`/`y`); com um zoom selecionado, o clique põe o foco |
| Fonte | alternador Câmera / Área do jogo; arrastar o retângulo move, as alças redimensionam, arrastar em área vazia desenha outro, setas e Shift+setas pelo teclado | grava `settings.layout.cam`/`game` só deste corte ("Usar esta câmera nos próximos cortes da sessão" grava na sessão) |
| Transcrição | selecionar palavras → Tirar, Manter, **Editar** (troca o texto e reparte o tempo), **Ocultar** (só da legenda), Ênfase | corte pelo texto e correção da legenda |
O arraste de mover só começa depois de 4 px: um clique simples nunca tira o bloco do lugar.
### Tempo e modelo do projeto
- **Tempo da sessão:** `cuts`, palavras, textos, zoom, narração e capa. Remover um pedaço do meio não desloca o
que está ancorado no conteúdo.
- **Tempo de saída:** só o gancho.
| Campo | O que é |
|---|---|
| `source` | Janela carregada da gravação (`lo`/`hi`, até 10 min). |
| `settings` | Configuração do corte só deste corte (mesma validação de `layout.validate`), por cima de canal/sessão: layout, câmera, legenda, crédito e **`format.aspect`** (o corte pode sair horizontal num canal vertical e vice-versa). Projeto salvo antes do formato (sem `format`) segue o canal/sessão; sem nada, vertical. |
| `cuts` | Trechos mantidos, cada um com `mode` próprio (troca de layout por trecho, inclusive `cam_only`) e `muted` (trecho sem o áudio da live). Trechos encostados só se juntam com o mesmo `mode` e o mesmo `muted`. |
| `captions` | Preset `classic`, `pop`, `karaoke`, `single` ou `minimal`; `style` (mesma validação de `layout.validate`); `emphColor`; palavras editáveis (`emph`, `hidden`). |
| `overlays` | `hook`, `text` (posição `x` e `y`, 0–1; `x` ausente = centro) e `zoom` (escala, foco e rampa). `hook`/`text` têm ainda, opcionais: `style` (`plain` padrão, ou `banner` = tarja na largura toda, centrada em `y`, texto em maiúsculas em até 2 linhas — a fonte diminui em vez de cortar palavra), `bg` (cor da tarja), `color`, `font` (uma de `fonts`) e `anim` `slide` (tarja atravessa a tela em 0,24 s; texto entra deslizando com desfoque de 90 a 430 ms e assenta nítido). Projeto sem esses campos renderiza idêntico ao de antes. |
| `overlays` (`kind: "inset"`) | **Camada inserida** (recorte da tela em destaque): `start`/`end` (tempo da sessão), `src` `{x, y, w, h}` (recorte do quadro ORIGINAL, 0–1), `x`/`y` (centro na tela de saída, 0–1), `size` (largura, 0,1–1 da largura; a altura sai da proporção do `src`), `border` (`#RRGGBB` ou null), `borderW` (px no quadro lógico, 0–40, padrão 6), `radius` (px, 0–200, padrão 18), `shadow` (padrão true), `anim` (`pop` padrão, `fade`, `slide`, `none`) e `keys` opcionais `[{t, x, y, size, ease}]` para andar/crescer (mesma interpolação do reenquadramento). No máximo 12. Ordem no array = empilhamento (a última por cima); ficam acima do vídeo e do zoom e abaixo de legenda, gancho, textos e chat. |
| `reframe` | **Reenquadramento do jogo no tempo** (opcional; ausente = como antes): `{keys: [{t, cx, cy, w, ease}]}`, no máximo 60. `t` = tempo da sessão; `cx`/`cy` = centro da janela e `w` = largura (0,05–1), frações do quadro ORIGINAL. A altura sai da proporção da área do jogo do layout daquele trecho (parte de baixo no `cam_top`; a tela toda no `game_only`, `blur` e horizontal), então nunca distorce; zoom que não cabe encolhe a janela, e a janela é presa dentro do quadro (desloca, não deforma). `ease` = como chega ao key seguinte: `smooth`, `linear` ou `hold` (segura e salta no key seguinte); antes do 1º e depois do último, segura. Com keys, `layout.game` é ignorado (keys absolutos no quadro original). Não vale para `cam_only`. A capa usa a janela parada do instante dela. |
| `chat` | Chat da live na tela: `enabled`, `x`, `y` (base do bloco), `width`, `lines` (1–10), `size`, `showUser`. Cada mensagem fica até chegar a próxima (no máximo 9 s). |
| `progress` | Barra de progresso. |
| `audio` | Volume da live; `narration` (TTS, com a live abaixada por baixo); `music` (só de `assets/`, com ducking por `sidechaincompress`); `sfx`. |
| `cover` | Capa. Com `atStart`, a capa também entra nos 2 primeiros quadros do vídeo (0 s), para a rede usar como miniatura. |
| `meta` | Origem do projeto. |
### Render
`editor_render.py`:
- um `-ss` antes do `-i` para a janela inteira;
- `trim`/`atrim` por trecho e layout por trecho (`layout.layout_chain`);
- `concat`, depois `zoompan` (expressão do tempo), depois `ass` (legenda animada, gancho, textos, barra e
crédito), depois `fps=30` e `yuv420p`;
- áudio com `afade` de 20 ms nas emendas, `adelay`/`amix` para narração e efeitos, música em loop;
- saída MP4 no formato do corte (1080×1920 ou 1920×1080), 30 fps, H.264 + AAC 48 kHz; o `zoompan` e a capa no
início usam o mesmo tamanho. O formato do arquivo fica em `clips.aspect` (migração v8) e sai no JSON do corte.
### Reenquadramento e camadas inseridas (`app/reframe.py`)
Pedido do dono (17/11/2026, corte 61 em câmera-em-cima: o inventário ocupava a tela e saía só o miolo):
- **Reenquadramento**: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro do trecho, `in`, que começa em 1) viram o quadro inteiro com interpolação **subpixel**, depois `scale` para a área do jogo. Os keys estão em tempo da sessão e cada trecho do corte usa o próprio início, então `cuts` não desalinha. Medido: janela a < 4 px do esperado em todos os quadros testados; zoom suave sem passo para trás nem tremida (protótipo: desvio da aceleração 0,12 px). `scale` com `eval=frame` + `crop` fixo falhou no encoder e arredonda a posição a pixel inteiro. Grafo > 20 000 caracteres (muitos keys) vai por arquivo (`-/filter_complex`).
- **Camadas inseridas**: o vídeo original de cada trecho é duplicado e concatenado (`[vraw]`); cada camada faz `crop` → `scale` → `alphamerge` (máscara dos cantos) → por cima de UMA imagem de decoração (sombra borrada + borda, gerada com numpy/OpenCV) → `scale` por quadro só se o tamanho muda (keys, pop) → `fade` de alfa → um `overlay` (expressão por quadro só se a posição muda: keys, slide).
- **Medido** (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 era 28,2 s).
- No 9:16 com câmera em cima, a área do jogo é 1080×1268 (proporção 0,85): um inventário de 16:10 não cabe inteiro sem faixas; a janela mostra no máximo 0,48 da largura (uma coluna grande, ex.: a bolsa). No 16:9 cabe.
- A IA ainda NÃO propõe reenquadramento nem camadas: o analista não devolve região da tela (precisaria de caixa na imagem, que hoje não é confiável).
### Tempo da legenda (fala rápida)
Pedido do dono (16/11/2026): "com fala rápida a legenda sai fora do tempo e fica uma em cima da outra". Causa
medida na cópia do banco (3 projetos, sessão 3 do skipnho): **63 de 286** eventos de legenda começavam antes do fim
do anterior: o fim de cada 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. O Whisper também devolve palavras de 0 s (380 de 15 583) e
palavras que começam no mesmo instante. Agora (`app/subtitles.py`, usado pelo render do editor e pelo do worker,
nos dois formatos):
- `clean_words`: ordena, dá 60 ms mínimos por palavra, empurra 40 ms a que começa junto com a anterior e corta o fim
de cada palavra no início da seguinte;
- `group_words`: até `maxWords` e um limite de caracteres; quebra em pausa > 0,6 s ou bloco > 3,2 s; com fala muito
rápida (bloco cheio durando < 0,7 s) aceita **uma** palavra a mais, se couber, para o bloco não piscar;
- `caption_blocks`: o fim de um bloco é cortado no início do seguinte: **nunca dois blocos na tela**. O bloco entra
no início da sua 1ª palavra e a palavra destacada troca no início de cada palavra (sem atraso em relação ao áudio);
- a ênfase marcada no editor é casada nos tempos originais, antes do saneamento.
Medido depois: **0 de 299** eventos sobrepostos; deslocamento máximo do início de uma palavra = 140 ms (só em
sequências de várias palavras que o Whisper pôs no mesmo instante; nas demais, 0); 3–7 blocos de 4 palavras por
corte (fala rápida). O vertical com fala normal sai idêntico ao de antes (MD5 dos quadros conferido).
Validação forte (`editor.validate_project`): limites de duração (3–180 s) e de quantidade, texto escapado no ASS,
áudio só de `assets/` ou dos TTS gerados pelo editor, e nada vira comando de shell.
### Medido (cópia do banco, sessão 3 do skipnho, 16/11/2026)
| Operação | Tempo |
|---|---|
| Proxy 480p de 120 s | 4,3 s |
| Forma de onda | 0,2 s |
| Re-transcrição de 13 s (Whisper) | 0,7 s |
| TTS | 2,4 s |
| IA sugere (`gpt-6-luna`) | 6,0 s |
| Prévia real de 5 s | 0,8–1,3 s |
| Export de 55,6 s | ~9 s |
| Corte 10 pelos juízes até o vídeo pelo projeto da IA | 24 s |
### Limitações
- A prévia do navegador é aproximada (canvas); a exata é "Prévia real".
- A tarja do gancho no layout câmera-em-cima fica sobre o painel da câmera nos primeiros segundos (a legenda fica na
emenda); ajuste `y` no editor se preferir.
- Camadas inseridas não entram na capa (a capa usa só o reenquadramento parado).
- A prévia do editor (canvas) segue o formato do corte (9:16 ou 16:9, quadro lógico de `frames`), mas é aproximada:
a exata é a "Prévia real" ou o export.
- `clips.aspect` é gravado no render: antes do 1º render o corte informa `vertical` (padrão), mesmo num canal
horizontal.
- A varredura da IA limita o fim do momento ao fim da janela varrida: perto do fim da janela, a proposta pode sair
mais curta que `minS` (os juízes ainda podem recuar o início).
- Emoji sai monocromático (libass).
- Sem B-roll e sem segunda trilha de vídeo: um pedaço não pode ser arrastado para outra camada nem tocar fora da
ordem da gravação (a timeline é o tempo da sessão).
- Código novo de render (`cam_only`, `muted`, `chat`, `cover.atStart`, texto com `x`) só vale depois de reiniciar o
serviço; um serviço antigo rejeita o projeto com `cam_only`.
- A forma de onda e o proxy cobrem só a janela carregada ("+30 s antes/depois" gera outra).
- O corte usa os blocos `.ts`: depois de `CLIPPER_KEEP_HOURS` sem trabalho pendente, a edição daquele trecho
deixa de ser possível.
- Nova avaliação dos juízes (rejudge) troca o trecho de um projeto de origem `ai` (ele é refeito), mas não o de
um projeto seu.
## Rastreio de reação (rosto do streamer)
`app/face.py` (E/S) + `app/reaction.py` (lógica pura). Plano: `doc/PLANO_RASTREIO_REACAO.md`; números:
`doc/FACE_BAKEOFF.md`. Opção `faceTrack` (padrão ligada; `PUT /v1/judge`, interruptor no painel) — roda no PC, sem IA.
- **Câmera**: YuNet (`face_detection_yunet_2026may.onnx`) em 12 quadros; `locate_cam` agrupa pelo centro do grupo (1
rosto de tolerância), exige presença em ≥ 50 % dos quadros e confiança média do grupo ≥ 0,7 (webcam real dá
0,92–0,94; objeto parado que engana o YuNet, ~0,63) e expande o rosto (3,2× largura, 3,6× altura, folga na
testa). Câmera em tela cheia (rosto > 40 % da altura) não vira layout. Sem rosto enquanto grava: tenta de novo em 5 min.
- **Rastreio**: thread `face` do motor, um bloco por vez (sessões gravando primeiro; sessões antigas com blocos
ainda no disco também). FFmpeg recorta a câmera +10 %, ~384 px, 6 qps, `rgb24` por pipe → MediaPipe Face
Landmarker (VIDEO, um por bloco) → série por segundo na tabela `face_track` (status `done`/`no_cam`/`error`).
`cx`/`cy`/`size` gravados no **quadro inteiro**. Medido: ~1,5 s de CPU por bloco de 30 s. Sem MediaPipe, cai no
OpenSeeFace (só posição, sem expressões). Câmera trocada (detecção ou layout) → a série da sessão é refeita sozinha.
- **Sinal**: z robusto de cada expressão contra o normal dos últimos 180 s do próprio streamer; rótulos risada,
grito, susto, confuso, choque, raiva. Movimento só rotula (susto) e só com rosto em ≥ 80 % do segundo.
- **Cortes**: momentos do chat/áudio ganham `reasons.face` e até +0,6 na nota; fonte nova `face` só com z ≥ 6 **e**
apoio (áudio suavizado ≥ 1,5 ou ≥ 2 mensagens de reação). Com câmera e rastreio ligado, a decisão do corte espera
o rosto do trecho (no máximo 2 blocos atrás da transcrição). O analista recebe a linha "Rosto do streamer: …".
- **Modelos**: `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`; o `setup.ps1` (passo 6b)
baixa; o serviço baixa sob demanda se faltar (fora da thread do chat). Falha de modelo não marca blocos: nova
tentativa em 5 min.
- **API**: `GET /v1/sessions/{id}/face?from=&to=` (série, `signal`, picos, câmera, progresso) e `POST …/face/reset`.
## Juiz de IA (pela CLI, sem chave de API)
Usa as CLIs já logadas no PC — as mesmas da página Agente:
| Provedor | Comando | Modelo padrão | Lista de modelos |
|---|---|---|---|
| `codex` (padrão) | `codex exec --ephemeral --sandbox read-only --output-schema … -o … -` | `gpt-6-luna` (rápido e barato) | `~/.codex/models_cache.json` (só `visibility: list`) |
| `claude` | `claude -p --json-schema … --no-session-persistence` (imagens pela ferramenta Read; web por WebSearch) | `haiku` | `haiku`, `sonnet`, `opus` |
| `off` | — | — | só a heurística |
Codex: imagens com `-i` (uma por flag, antes de `-`), busca na web com `--search` (opção global, antes de `exec`).
Provedor, modelo do editor, **modelo do analista** (`analystModel`, vazio = o mesmo), nota mínima, varredura
(`scanEnabled`, `scanIntervalS`), visão (`vision`), detecção de câmera (`camDetect`) e rastreio de reação (`faceTrack`) se trocam no painel (`PUT /v1/judge`) e ficam na tabela `settings` do banco — sem
reiniciar. O `.env` só dá os valores iniciais. Medido (16/11/2026): `gpt-6-luna` respondeu em ~7 s por candidato.
Falha do juiz não perde o momento: o corte segue pela heurística e o erro fica em `judge.error`.
## Instalação e subida
- `setup.bat` cria `clipper/.venv` (Python 3.12 via uv), instala `requirements.txt` (Streamlink 8.6.3) e gera
`clipper/.env` com chave nova.
- `start.bat` / `pnpm dev` sobem voz + Clipador + painel. Sem `clipper/.venv` ou sem chave, o Clipador é pulado com aviso.
- Só o serviço: `cd clipper && .venv\Scripts\python -m uvicorn app.main:build --factory --host 127.0.0.1 --port 4520`
- Testes: `cd clipper && .venv\Scripts\python -m pytest`
- Mudança de **código** em `clipper/app/` só vale depois de reiniciar o serviço (o `pnpm dev` não usa `--reload`).
Provedor/modelo do juiz não precisam: mudam pelo painel na hora.
Precisa do FFmpeg com `libass` (legenda) — o build `essentials` do gyan.dev tem. NVENC é usado quando existe.
## Configuração (`clipper/.env`)
| Variável | Padrão | O que faz |
|---|---|---|
| `CLIPPER_SERVICE_KEY` | (setup) | chave exigida em toda rota, exceto `GET /health` |
| `CLIPPER_PORT` | 4520 | faixa 4500–4599 |
| ~~`CLIPPER_QUALITY`~~ | — | não é mais lida: a qualidade é `capture.quality` por canal/sessão (padrão `best`) |
| `CLIPPER_SEGMENT_S` | 30 | tamanho do bloco gravado |
| `CLIPPER_POLL_S` | 60 | intervalo para checar se um canal monitorado entrou ao vivo |
| `CLIPPER_KEEP_HOURS` | 6 | apaga blocos mais velhos que isto se nenhum corte pendente precisar (0 = nunca) |
| `CLIPPER_LANGUAGE` | `pt-BR` | idioma da transcrição |
| `CLIPPER_ENCODER` | `auto` | `auto` (NVENC se houver) · `libx264` · `h264_nvenc` |
| `CLIPPER_JUDGE_PROVIDER` / `_MODEL` / `_MIN_SCORE` | `codex` / (padrão) / 6 | valores iniciais do juiz |
| `CLIPPER_DATA_DIR` | `data/clipper` | banco, blocos gravados, modelos do rastreio e arquivos do juiz; para isolar uma instância de teste (relativo ao repo ou absoluto, **dentro** do repo) |
| `CLIPPER_OUTPUT_DIR` | `output/clipper` | cortes prontos, prévias e projetos do editor (mesma regra; fora de `output/` o painel não serve os arquivos) |
Instância de teste isolada (não toca no banco nem nos blocos do serviço do usuário): defina `CLIPPER_PORT=4521`,
`CLIPPER_DATA_DIR=output/<teste>/data` e `CLIPPER_OUTPUT_DIR=output/<teste>/clips` no ambiente (o ambiente vence o
`clipper/.env`) e suba o uvicorn com essa porta. Atenção: o serviço de voz é compartilhado e guarda a transcrição pela
chave `clipper-<sessão>-<bloco>`; num banco novo as sessões recomeçam do 1 e colidiriam com as do banco real — suba o
`sqlite_sequence` de `sessions` (ex.: 90000) antes da primeira sessão.
## API (todas com `X-Service-Key`)
| Rota | O que faz |
|---|---|
| `GET /health` | sem chave |
| `GET /v1/status` | ferramentas, voz, juiz, gravações ativas |
| `GET/PUT /v1/judge` | provedor, modelos (editor/analista), nota mínima, varredura, visão, câmera (+ lista de modelos) |
| `GET/PUT /v1/channels/{id}/settings` · `GET/PUT /v1/sessions/{id}/settings` | configuração do corte: `own`, `effective`, `defaults` (com `format`, `duration` e `hook`), `modes`, `fonts`, `fontFiles` (`{família: "assets/fonts/…ttf"}` das empacotadas, relativo à raiz do repositório), `hookStyles`, `hookAnims`, `aspects`, `frames` (`{vertical, horizontal: {width, height, canvasWidth, canvasHeight}}`, para o painel desenhar a prévia) e `captureQualities` (`[{id, label, maxHeight, gbPerHour, gbPerHourMax, hint}]`) |
| `GET /v1/sessions/{id}/frame?t=` · `POST …/preview` · `POST …/detect-cam[?ai=true]` | quadro para o editor, prévia do layout, achar webcam (local primeiro) |
| `GET /v1/sessions/{id}/face?from=&to=` · `POST …/face/reset` | série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal`) e picos; refazer o rastreio |
| `PUT /v1/sessions/{id}/game` · `GET /v1/games` · `POST /v1/games/{id}/research` · `PUT /v1/games/{id}` · `POST /v1/games/{id}/refine` · `DELETE /v1/games/{id}/notes/{n}` | jogo da sessão, perfis pesquisados, edição à mão e pedidos à IA |
| `GET /v1/emotes?channel=twitch-<login>` | emotes do canal, usos e peso aprendido |
| `GET/POST /v1/channels` · `PATCH/DELETE /v1/channels/{id}` · `POST /v1/channels/{id}/check` | canais (`monitor` grava sozinho ao entrar ao vivo; `authorized` = streamer autorizou) |
| `GET/POST /v1/sessions` · `GET/DELETE /v1/sessions/{id}` · `POST …/stop` | gravar live ou processar VOD pelo link; cada sessão traz `capture` (resolução, qps, codec e taxa gravados de fato; `null` = sessão antiga) |
| `GET /v1/sessions/{id}/timeline` | mensagens/s, razão do chat e volume por segundo |
| `POST /v1/sessions/{id}/clips` | **cortar agora**: `{lastS}` ou `{startS,endS}`; corte manual nunca é descartado pela IA |
| `GET /v1/clips?status=&session=` · `GET/PATCH /v1/clips/{id}` · `POST …/render` · `POST …/rejudge` | fila de cortes; cada corte traz `aspect` (`vertical` ou `horizontal`) = formato em que o arquivo foi renderizado |
| `DELETE /v1/clips/{id}[?confirmPublished=true]` | **apagar um corte**: linha, projeto de edição e arquivos (ver "Apagar cortes"). 200 `{id, sessionId, status, removedFiles, left: [{file, reason}]}`; 404 `not_found`; 409 `busy_candidate` / `busy_rendering` / `published` / `changed` (`{error, code}`) |
| `POST /v1/clips/delete` `{ids: [..≤500]}` ou `{statuses: [...], sessionId?}`, `confirmPublished?` | **apagar em lote** (selecionados ou a aba inteira, até 500 por chamada, do mais novo para o mais velho). 200 `{requested, remaining, deleted: [como acima], failed: [{id, code, reason}]}`; 400 sem `ids` nem `statuses` (ou os dois, ou `sessionId` com `ids`); 422 acima de 500 ids ou estado inválido |
| `GET/PUT/DELETE /v1/clips/{id}/edit` (PUT com `rev`; 409 se outro salvou) · `POST …/proxy` `{lo,hi}` · `GET …/waveform?lo=&hi=` | editor: projeto, prévia 480p e forma de onda |
| `POST /v1/clips/{id}/preview-render` `{fromS,durationS≤10,project?}` · `POST …/export` | prévia real de poucos segundos (no formato do corte; com `cover.atStart` e `fromS` = 0 a capa entra nos 2 primeiros quadros, como no export); exportar (volta para a fila de render → `ready`) |
| `POST /v1/clips/{id}/retranscribe` `{startS,endS≤90 s}` · `POST …/tts` `{text,voice,speed}` · `POST …/suggest` | Whisper de novo; narração (WAV em `edit-<id>/tts-*.wav`); IA sugere gancho, título, início/fim, trechos mortos e zooms |
Origem do corte (`source`): `chat`, `audio`, `ai` (varredura), `face` (reação no rosto com apoio do áudio/chat), `manual`.
Estados do corte: `candidate` (esperando IA) → `pending` (fila de render) → `rendering` → `ready` → `approved`/`rejected`;
`discarded` (IA descartou) e `error`. `published` é só uma marcação manual até existir a etapa de publicação nas redes.
### Apagar cortes (`app/clip_delete.py`)
Pedido do dono (17/11/2026): apagar um corte, vários ou todos de uma aba, inclusive "Descartados pela IA" e "Para
aprovar". No painel, tudo discreto (o dono reprovou uma barra presa no topo): "Apagar" em cada cartão (confirmação no
próprio cartão); no canto da linha das abas, "Selecionar" e o menu "⋯" com "Apagar todos desta aba (N)" (modal com a
contagem; com a fila filtrada por sessão, vale só para aquela sessão e o modal diz isso); a caixa de cada cartão só
aparece no hover/foco ou no modo de seleção; com algo marcado, uma pílula flutuante no canto inferior direito
("N selecionados · Selecionar todos · Apagar · ✕"; Esc sai do modo). O painel manda os **ids que está mostrando** (não `statuses`):
corte que chegar depois da confirmação não é apagado junto.
- **O que some:** a linha em `clips`, o projeto (`edits`) e os arquivos: `clip-<id>.mp4`/`.jpg`/`-cover.jpg` e restos do
render (`clip-<id>.*`, `clip-<id>-*`) em `output/clipper/<sessão>/`, a pasta do editor `edit-<id>/` (proxy, forma de
onda, TTS, prévias) e os quadros do juiz `data/clipper/sessions/<sessão>/frames/clip<id>-*.jpg`. Os blocos gravados
(`.ts`) ficam: são da sessão.
- **Só dentro das pastas do Clipador** (`CLIPPER_OUTPUT_DIR`, `CLIPPER_DATA_DIR`): cada caminho é resolvido antes;
caminho de fora (inclusive `clips.file` apontando para fora, ou pasta da sessão trocada por junção) não é tocado e
volta em `left` com "fora das pastas do Clipador". Link ou junção dentro da pasta do editor: some só o link, o alvo
fica. Arquivo em uso também volta em `left`.
- **Recusa:** `candidate` (a IA está avaliando) e `rendering` (inclusive o `pending` que o motor acabou de pegar:
`Engine.render_clip` confere sob o mesmo trinco que o corte ainda existe). `published` só com `confirmPublished`
(o vídeo já foi postado; hoje ninguém marca `published`, mas a etapa de publicação vai precisar do registro).
- **O momento apagado não volta.** Sem o corte, a regra anti-duplicado (que compara com cortes em qualquer estado,
inclusive descartados) deixaria a IA recriar o mesmo momento na passada seguinte da live ou na passada final da
sessão. Fica uma marca mínima na tabela `deleted_clips` (migração **v10**: id, sessão, pico, trecho final, janela
original do candidato, estado, origem, título, data), que entra na conta como se o corte existisse: no candidato
(`find_new_clips`), na varredura da IA (`mark_spans`) e no trecho final depois do juiz para quem foi apagado num
estado de `VETO_STATUSES` ("Duplicado do corte N (que você apagou)"; descartado pela IA apagado não veta, como
antes). A marca some com a sessão (`ON DELETE CASCADE`).
- **Nada mais quebra:** o peso aprendido dos emotes (`clips.learned`) mora na tabela `emotes` e fica; `judge.duplicateOf`
de outros cortes é só texto (nada lê o id de volta); a memória da varredura (`sessions.memory_json`) não guarda id de
corte; apagar o último pendente deixa a sessão terminar (`finish_if_done`); `prune` deixa de segurar os blocos dele.
- Testes: `tests/test_clip_delete.py`.
## Armadilhas já resolvidas
- **Legenda sumia do vídeo**: com `-ss` depois do `-i`, o filtro `ass` via o tempo do bloco (não do corte) e a legenda
saía deslocada. `-ss` vai antes do `-i` (`app/media.py`).
- **`.upper()` na linha ASS** transformava a tag `\c` em `\C` (inválida). Maiúsculas só no texto.
- **Falsos positivos com chat calmo**: 3 mensagens com um emote `clip5k1hmm` davam razão 2,35. Regras: palavra inteira
para "clip", mínimo de mensagens no pico (hoje proporcional ao chat, entre 4 e 12), 60 s de aquecimento (teste de regressão em `tests/test_scoring.py`).
- **Chat pequeno sem corte nenhum** (skipnho, 0,15 msg/s): mínimo fixo de 12 mensagens → proporcional + varredura.
- **Título preso à transcrição** ("jogando três jogos" num momento de lag): dois juízes, frames e glossário do chat.
- **Crédito em cima do rosto** no layout câmera-em-cima: desce para o pé do painel da câmera.
- `codex.cmd` (lote do npm) não roda bem sem shell: o juiz chama o `codex.js` pelo Node, como o painel.
- Matar o serviço à força não deixou `streamlink`/`ffmpeg` órfãos no teste, mas em queda o banco marca as sessões
em andamento como `interrupted` na próxima subida.
- **Palavra com duração zero do Whisper** (ex.: "queria" 1020,10–1020,10 no skipnho) derrubava a validação do
projeto do editor: agora ganha 50 ms.
- **Capa sem imagem**: o mjpeg do FFmpeg 7.1 recusa yuv420p marcado como faixa "tv" (bloco do libx264); o quadro
intermediário da capa é PNG.
- **Gancho cortado no meio**: o `hook` do analista às vezes é uma frase descritiva ("Aos 5085s, ele solta que…",
corte 25 do skipnho); o projeto da IA só usa se for curto (≤ 8 palavras, ≤ 48 caracteres) e sem tempo da gravação,
senão usa o título do editor; resto de "aos NNN s" é tirado e o texto é cortado em palavra inteira (`pick_hook`).
- **Live no ar foi para "processando" depois de reiniciar o serviço** (16/11/2026, sessão 3): a retomada da subida
fazia UMA checagem; o `streamlink --json` falhou (timeout/erro eram engolidos e pareciam "offline") e a sessão foi
encerrada. Agora `Engine.live_check` separa `live`, `offline` ("No playable streams…") e `unknown` (timeout, erro,
JSON inválido; motivo e fim do stderr vão para o log), e `keep_live` tenta de novo com espera crescente
(0, 10, 20, 40, 60, 90, 120 s ≈ 5,7 min). Enquanto tenta, a sessão fica `interrupted` ("Retomar gravação" no
painel); só processa depois de esgotar as tentativas ou de ver `offline` 2 vezes seguidas. Se você retomar,
processar ou apagar no meio, a thread para sem mexer. O mesmo vale para a **captura que cai no meio da live**
(antes ia direto para `processing`): ela vira `interrupted` e passa pelo mesmo `keep_live`; 3 retomadas seguidas
sem nenhum bloco novo desistem.
- **Cortes presos em "renderizando"** (17/11/2026, sessão 3: 10 cortes, ids 42–58): o serviço subiu com uma versão
intermediária da legenda que dava `KeyError` quando o saneamento mudava alguma palavra (o corte 40, com 0 palavras
mudadas, saiu; os 10 presos tinham de 6 a 20). A exceção não prevista escapava do render, o laço reiniciava e o corte
ficava em `rendering` para sempre. Agora qualquer falha no render vira `error` com a mensagem e a fila segue; um
`rendering` que este processo não está renderizando há mais de 5 min volta para `pending` (na 3ª vez, `error`).
- **O mesmo momento virando vários cortes** (sessão 3: pico 1149 s → cortes 42, 47, 49, 51, 52, em cima do 9, já
pronto): a checagem comparava o candidato (em volta do pico) só com o trecho final dos cortes, mas o juiz recua o
trecho (1012–1100); na passada seguinte o mesmo pico já não sobrepunha e era criado de novo. Agora (`worker.py`):
o candidato guarda a janela original (`reasons.candidateStartS/EndS`) e não nasce se o pico estiver a ≤ 10 s de
outro corte, ou se sobrepuser o trecho final ou a janela original de um corte em qualquer estado (inclusive
descartado). Depois do juiz, o trecho final é conferido contra os cortes mantidos (pendente, renderizando, pronto,
aprovado, publicado): mesmo momento (pico a ≤ 10 s ou ≥ 60 % do mais curto coberto) = descartado como
"Duplicado do corte N" (`judge.duplicateOf`). Vale para chat, áudio, rosto e varredura; "cortar agora" (manual)
só ganha o aviso `judge.warning`. Antes de cada render, pendentes que já são o mesmo momento de um corte pronto,
aprovado, publicado ou rejeitado, de um corte apagado que estava num desses estados, ou de um pendente mais antigo
saem da fila como "Duplicado do corte N (que você rejeitou/apagou)" — o mesmo conjunto do veto depois do juiz;
descartado pela IA não veta (nunca sai um manual ou um que você exportou do editor). Cortes duplicados que JÁ estão
prontos não são mexidos: rejeite à mão.
- **Testes chamavam a CLI de IA de verdade**: o juiz falso dos testes não cobria o analista; agora `FakeJudge.ask`
falha sempre (caminho de "IA fora" que o serviço já trata).
- **Cortes mais curtos que o mínimo** (sessão 3, mínimo 60: cortes 43 = 54,6 s, 44 = 55,0 s, 55 = 46,8 s, 58 = 57,7 s,
61 = 43,8 s): o projeto da IA ADIANTAVA o início para o `action_start_s` do analista quando ele vinha depois do
início do juiz ("início no começo da ação"), e nada reimpunha o mínimo depois. Também: o juiz limitava o fim em
`hi` sem recuar o início, a varredura idem, e `fit_length` podia passar do máximo. Agora todos passam por
`fit_window` com mínimo + 1 s, e o início só adianta se o mínimo continuar.
- **Fonte empacotada ignorada pelo libass**: o `fontsdir` NÃO lê subpastas (medido: `fonts/` não achava nada,
`fonts/bangers/` achava). A pasta é plana. No Windows o caminho vai absoluto, entre aspas, com `:` escapado. A
Poppins ExtraBold só é achada pelo nome de família ID 1 ("Poppins ExtraBold"), não por "Poppins".
- **Corte que atravessa blocos de resoluções ou codecs diferentes** (retomada em outra qualidade, ou a fonte mudou
no meio): o vídeo parava na emenda sem erro (medido em 17/11/2026: corte de 35 s com 20 s de vídeo; 15 s na troca
H.264 → HEVC). Agora `uniform_segments` (`editor_render.py`) converte os blocos do trecho num intermediário
uniforme (maior tamanho do trecho, 30 qps) só nesse caso, no render e no proxy; trecho com blocos iguais segue
pelo caminho de sempre. A qualidade pode ser trocada também numa retomada. O proxy faz `fps` antes do `scale`.
- **"Não está gerando os clipes"** (17/11/2026, sessão 3, 9000–10560 s): diagnóstico numa cópia do banco. A live
esfriou: chat de 0,27–0,39 msg/s e 56–78 reações a cada 500 s (7000–8000 s) caiu para 0,04–0,10 msg/s e 2–10
reações (9000–10000 s); a heurística não achou NENHUM pico entre 8872 e 10350 s, nem com as regras antigas
(15–59 s, só sobreposição); a varredura descreveu cada janela como "sem confronto ou reação marcante"; e o juiz deu
3,2–4,2 aos candidatos 65–67 (mínimo 6). Regras atuais × antigas em 7200–10560 s: 1 × 4 candidatos, mas os 3 a
mais eram rosto fraco (nota 2,5) ou a cena do corte 61, rejeitado; zona proibida 34 % × 24 %. Afrouxar o
anti-duplicado não traria corte novo, então ficou como está. Mudanças: rejeitado também veta o trecho final depois
do juiz ("Duplicado do corte N (que você rejeitou)"); a varredura grava `proposals`/`created` em cada janela da
memória (e no log), porque antes não dava para saber se ela não propôs nada ou se foi barrada.
- **Legenda uma em cima da outra com fala rápida**: o fim de um bloco passava do início do seguinte e o libass
empilhava os dois. Blocos agora nunca se sobrepõem e as palavras são saneadas (ver "Tempo da legenda").
- **Quadro errado ao buscar dentro de um bloco `.ts`** (17/11/2026): o demuxer mpegts do FFmpeg trata todo pacote
como ponto de busca; `-ss` antes do `-i` caía num quadro P. No H.264 saía o próximo quadro-chave (até 2 s depois);
no **HEVC** (2K da Twitch) saía um quadro **cinza** — frames do juiz, capa e YuNet (a câmera não era achada). Um
2º `-ss` depois do `-i` também erra com áudio no bloco (7,5 s virou 6,06 s). Agora `media.seek_args`: busca 4 s
antes, `-copyts -start_at_zero` e `select='gte(t,alvo)'` (usado por `grab_frame` e `face.grab_bgr`). Render e
proxy (concat demuxer) já buscavam certo.
- **Rastreio do rosto com resolução trocada no meio da sessão**: o tamanho do quadro era medido uma vez por sessão;
uma retomada em outra qualidade recortaria a câmera no lugar errado. Agora é medido por bloco.
## Limites conhecidos
- **Direitos autorais**: cortar lives de terceiros sem autorização pode render strike/derrubada da conta. Cada corte
leva o crédito do canal no vídeo e na legenda; marque `authorized` nos canais que autorizaram.
- Chat do **YouTube** ainda não é lido (exige a API do YouTube); a sessão segue pelo áudio e pela transcrição.
- Chat da **Kick** usa o websocket público do site (não oficial; o Cloudflare às vezes bloqueia o id da sala).
- VOD não tem chat (o replay de chat da Twitch não é API pública): só áudio + transcrição.
- A webcam é tratada como retângulo fixo (overlay do streamer); se ele mover a câmera no meio da live, ajuste no editor.
- O analista pode errar a situação quando tela, fala e chat não batem (ex.: corte 10 do skipnho: chat "live
travando", analista concluiu "pegadinha na conversa") — a confiança e o motivo ficam no corte para você conferir.
View File
+150
View File
@@ -0,0 +1,150 @@
"""Qualidade de gravação da live (grupo `capture` da configuração do corte) e o que foi gravado de fato.
Pedido do dono (17/11/2026): "pegar a live na melhor resolução; a live tem 2K, e isso é configurável".
Antes a captura pedia `720p60,720p,480p,best` e nunca passava de 720p, mesmo com a fonte em 1080p ou 1440p.
`capture.quality`:
- `best` (padrão): a maior resolução que a live oferece;
- `1440p` | `1080p` | `720p` | `480p`: TETO — a maior variante que não passa dele.
Nomes de stream medidos com `streamlink --json` (17/11/2026, 143 lives da Twitch, 5 da Kick, 22 do YouTube):
- Twitch: `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`,
`360p30`, `160p30`, `audio_only` e, em 9 canais, variantes VERTICAIS `1920p60_portrait`, `1280p30_portrait`…
(a de 1080×1920 vem em HEVC). Nenhuma live com 1440p no momento, nem pedindo h265/av1;
- Kick: `1080p60`, `720p60`, `480p`, `360p`, `160p`;
- YouTube (pelo HLS do Streamlink, até lives "4K"): `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p`.
Como a escolha é feita: pelos sinônimos `best`/`worst` do próprio Streamlink, que ordenam por peso
(`1440p60` = 1500, `1080p60` = 1140, `1080p` = 1080, `936p60` = 996…) e ignoram nomes de peso 0 (`audio_only`,
`*_portrait`, `source`). O teto vira `--stream-sorting-excludes >{teto}p60`; se nada sobrar abaixo do teto, a reserva
`worst-unfiltered` pega a menor variante de vídeo que existe (a mais perto do teto) — a captura nunca falha por
causa da qualidade escolhida.
FPS: não há opção de 30/60 qps. A variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives; a
Kick também), então pedir 30 qps custaria resolução; e o corte sai em 30 qps de qualquer jeito.
2K na Twitch (transmissão aprimorada) vem em HEVC: com `best` ou `1440p` a captura pede `--twitch-supported-codecs
h264,h265`. Medido: com h265 pedido, as variantes paisagem das lives continuaram H.264 (só a vertical vira HEVC).
AV1 não é pedido: o FFmpeg instalado não tem decodificador libdav1d.
"""
from __future__ import annotations
import logging
from dataclasses import dataclass
from pathlib import Path
from . import media
from .layout import CAPTURE_QUALITIES as QUALITIES
log = logging.getLogger("cenaforge_clipper.capture")
DEFAULT_QUALITY = "best"
CEILING_HEIGHT = {"1440p": 1440, "1080p": 1080, "720p": 720, "480p": 480}
# Twitch: 2K só aparece pedindo HEVC. Abaixo disso, o padrão do Streamlink (h264) basta.
TWITCH_HEVC_QUALITIES = ("best", "1440p")
# Disco por hora (GB) de cada opção. Medido nas playlistas mestras da Twitch (BANDWIDTH, mediana de 62–69 lives,
# 17/11/2026): 1080p60 7,1 Mbps (4,6–9,1) ≈ 3,2 GB/h; 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h.
# Gravação real (skipnho): 720p60 12,7 MB por bloco de 30 s (1,53 GB/h); 1080p60 29,9 MB (3,58 GB/h).
# 2K: nenhuma live achada — estimativa de ~10 Mbps (≈ 4,5 GB/h).
OPTIONS = [
{"id": "best", "label": "Melhor disponível", "maxHeight": None, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "A maior resolução que a live oferece (2K, se o canal transmitir em 2K)."},
{"id": "1440p", "label": "Até 2K (1440p)", "maxHeight": 1440, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "Igual a \"Melhor\" hoje; não passa de 2K se o canal transmitir em 4K."},
{"id": "1080p", "label": "Até Full HD (1080p)", "maxHeight": 1080, "gbPerHour": 3.2, "gbPerHourMax": 4.1,
"hint": "Mesma nitidez do corte final (1080 px de largura)."},
{"id": "720p", "label": "Até HD (720p)", "maxHeight": 720, "gbPerHour": 1.5, "gbPerHourMax": 2.7,
"hint": "Como era antes: metade do disco, câmera recortada mais borrada."},
{"id": "480p", "label": "Até 480p", "maxHeight": 480, "gbPerHour": 0.65, "gbPerHourMax": 0.7,
"hint": "Só para economizar disco: o corte sai visivelmente borrado."},
]
@dataclass(frozen=True)
class StreamChoice:
"""Opções extras do Streamlink + a lista de streams (primeiro que existir), em argumentos separados."""
options: tuple[str, ...]
streams: str
def args(self, url: str) -> list[str]:
return [*self.options, url, self.streams]
def normalize_quality(value: object) -> str:
return value if isinstance(value, str) and value in QUALITIES else DEFAULT_QUALITY
def stream_choice(quality: str, platform: str) -> StreamChoice:
"""Lista de preferência do Streamlink para a opção `quality` na plataforma (`twitch` | `kick` | `youtube`)."""
quality = normalize_quality(quality)
options: list[str] = []
if platform == "twitch" and quality in TWITCH_HEVC_QUALITIES:
options += ["--twitch-supported-codecs", "h264,h265"]
if quality == "best":
return StreamChoice(tuple(options), "best")
# Teto: exclui do `best` tudo que pesa mais que "<teto>p60" (1080p60 fica; 1440p30 e 1440p60 saem). Sem nada
# abaixo do teto, `best` some e `worst-unfiltered` entrega a menor variante de vídeo (a mais perto do teto).
options += ["--stream-sorting-excludes", f">{quality}60"]
return StreamChoice(tuple(options), "best,worst-unfiltered")
def probe_block(ffprobe: str, file: Path) -> dict:
"""Resolução, qps, codec e taxa reais de um bloco gravado (`ffprobe`). Levanta `media.MediaError`."""
out = media.run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries",
"stream=codec_name,width,height,avg_frame_rate,r_frame_rate:format=duration,size",
"-of", "default=nw=1", str(file)], 30).decode("utf-8", errors="replace")
info: dict[str, str] = {}
for line in out.splitlines():
if "=" in line:
key, value = line.split("=", 1)
info.setdefault(key.strip(), value.strip())
try:
width, height = int(info["width"]), int(info["height"])
except (KeyError, ValueError) as exc:
raise media.MediaError(f"sem vídeo em {file.name}") from exc
fps = _rate(info.get("avg_frame_rate")) or _rate(info.get("r_frame_rate"))
try:
duration, size = float(info.get("duration") or 0), float(info.get("size") or file.stat().st_size)
except (ValueError, OSError):
duration, size = 0.0, 0.0
kbps = round(size * 8 / duration / 1000) if duration > 1 else None
return {"width": width, "height": height, "fps": round(fps) if fps else None,
"codec": info.get("codec_name") or "", "kbps": kbps,
"gbPerHour": round(kbps * 3600 / 8 / 1e6, 2) if kbps else None}
def _rate(raw: str | None) -> float:
if not raw or raw in ("0/0", "N/A"):
return 0.0
try:
if "/" in raw:
num, den = raw.split("/", 1)
return float(num) / float(den) if float(den) else 0.0
return float(raw)
except ValueError:
return 0.0
MAX_RUNS = 10
def record_run(previous: dict | None, quality: str, from_idx: int, probed: dict, at: str) -> dict:
"""`sessions.capture_json` depois do 1º bloco de uma execução da captura (início ou retomada).
Topo = a execução atual (o painel mostra "gravando em 2560×1440 · 60 qps"); `runs` guarda as últimas
`MAX_RUNS` execuções; `mixed` = a sessão tem blocos em mais de uma resolução (retomada com outra qualidade)."""
runs = [r for r in (previous or {}).get("runs", []) if isinstance(r, dict) and r.get("fromIdx") != from_idx]
run = {"fromIdx": from_idx, "quality": quality, **{k: probed.get(k) for k in ("width", "height", "fps", "codec")}}
runs = (runs + [run])[-MAX_RUNS:]
sizes = {(r.get("width"), r.get("height")) for r in runs}
return {"quality": quality, **probed, "fromIdx": from_idx, "at": at, "runs": runs, "mixed": len(sizes) > 1}
def label(info: dict | None) -> str:
""""2560×1440 · 60 qps" (texto do log; o painel monta o seu)."""
if not info or not info.get("width"):
return "resolução desconhecida"
fps = f" · {info['fps']} qps" if info.get("fps") else ""
return f"{info['width']}×{info['height']}{fps}"
+165
View File
@@ -0,0 +1,165 @@
"""Leitura do chat ao vivo, em tempo real, para medir a reação do público.
- Twitch: IRC anônimo (irc.chat.twitch.tv:6697, apelido `justinfanNNNN`): só leitura, sem conta nem token.
- Kick: websocket público do Pusher usado pelo site (`chatrooms.<id>.v2`). Não é API oficial: pode mudar
sem aviso e o Cloudflare às vezes bloqueia a consulta do id da sala.
- YouTube: ler o chat exige a API do YouTube (cota) — ainda não suportado; a sessão segue pelo áudio.
Cada leitor roda numa thread, reconecta sozinho e entrega lotes de (instante, usuário, texto) com o relógio
de parede; quem chama converte para o tempo da gravação.
"""
from __future__ import annotations
import json
import logging
import random
import re
import socket
import ssl
import threading
import time
from typing import Callable
import httpx
from .emotes import parse_twitch_tag
log = logging.getLogger("cenaforge_clipper.chat")
# (hora real, usuário, texto, emotes nativos recortados do texto)
OnMessages = Callable[[list[tuple[float, str, str, list[str]]]], None]
_PRIVMSG = re.compile(r"^(?:@(\S+) )?:([^!\s]+)!\S+ PRIVMSG #\S+ :(.*)$")
_ROOM_ID = re.compile(r"(?:^@|;)room-id=(\d+)")
KICK_PUSHER = "wss://ws-us2.pusher.com/app/32cbd69e4b950bf97679?protocol=7&client=js&version=8.4.0&flash=false"
class ChatReader:
def __init__(self, platform: str, channel: str, on_messages: OnMessages):
self.platform, self.channel, self.on_messages = platform, channel, on_messages
self.status = "off"
self.received = 0
self.room_id: str | None = None # id numérico do canal na Twitch (para emotes 7TV/BTTV/FFZ)
self._stop = threading.Event()
self._thread: threading.Thread | None = None
def start(self) -> None:
if self.platform == "youtube" or not self.channel:
self.status = "unsupported"
return
target = {"twitch": self._run_twitch, "kick": self._run_kick}[self.platform]
self._thread = threading.Thread(target=self._loop, args=(target,), name=f"chat-{self.channel}", daemon=True)
self._thread.start()
def stop(self) -> None:
self._stop.set()
def _loop(self, target: Callable[[], None]) -> None:
delay = 2.0
while not self._stop.is_set():
try:
self.status = "connecting"
target()
delay = 2.0
except Exception as exc: # noqa: BLE001 - rede caiu: reconecta com espera crescente
self.status = f"error: {type(exc).__name__}: {str(exc)[:120]}"
log.warning("chat %s/%s: %s", self.platform, self.channel, self.status)
self._stop.wait(delay)
delay = min(60.0, delay * 2)
self.status = "off"
def _deliver(self, batch: list[tuple[float, str, str]]) -> None:
if batch:
self.received += len(batch)
self.on_messages(batch)
# ---------- Twitch (IRC) ----------
def _run_twitch(self) -> None:
context = ssl.create_default_context()
with socket.create_connection(("irc.chat.twitch.tv", 6697), timeout=30) as raw:
with context.wrap_socket(raw, server_hostname="irc.chat.twitch.tv") as sock:
sock.settimeout(1.0)
nick = f"justinfan{random.randint(10000, 99999)}"
# Tags trazem os emotes nativos (com posição no texto) e o room-id do canal.
sock.sendall(f"CAP REQ :twitch.tv/tags\r\nNICK {nick}\r\nJOIN #{self.channel}\r\n".encode())
buffer, batch, last_flush, last_data = b"", [], time.monotonic(), time.monotonic()
while not self._stop.is_set():
try:
chunk = sock.recv(65536)
if not chunk:
raise ConnectionError("conexão fechada pela Twitch")
buffer += chunk
last_data = time.monotonic()
except TimeoutError:
pass
except socket.timeout:
pass
*lines, buffer = buffer.split(b"\r\n")
for line in lines:
text = line.decode("utf-8", errors="replace")
if text.startswith("PING"):
sock.sendall(("PONG" + text[4:] + "\r\n").encode())
elif " 366 " in text or " JOIN #" in text:
self.status = "connected"
elif match := _PRIVMSG.match(text):
tags, body = _parse_tags(match.group(1) or ""), match.group(3)
self.room_id = self.room_id or tags.get("room-id")
batch.append((time.time(), match.group(2), body[:300],
parse_twitch_tag(tags.get("emotes", ""), body)))
elif room := _ROOM_ID.search(text):
self.room_id = self.room_id or room.group(1)
if time.monotonic() - last_flush >= 1.0:
self._deliver(batch)
batch, last_flush = [], time.monotonic()
if time.monotonic() - last_data > 360: # a Twitch manda PING a cada ~5 min
raise ConnectionError("sem dados há 6 min")
# ---------- Kick (Pusher, não oficial) ----------
def _run_kick(self) -> None:
from websockets.sync.client import connect # import tardio: só quem usa Kick precisa
response = httpx.get(
f"https://kick.com/api/v2/channels/{self.channel}",
headers={"User-Agent": "Mozilla/5.0", "Accept": "application/json"},
timeout=20,
follow_redirects=True,
)
if response.status_code != 200:
raise ConnectionError(f"kick.com respondeu {response.status_code} ao buscar a sala do chat")
room = response.json()["chatroom"]["id"]
with connect(KICK_PUSHER, open_timeout=20) as ws:
ws.send(json.dumps({"event": "pusher:subscribe", "data": {"auth": "", "channel": f"chatrooms.{room}.v2"}}))
batch, last_flush = [], time.monotonic()
while not self._stop.is_set():
try:
raw = ws.recv(timeout=1.0)
except TimeoutError:
raw = None
if raw:
event = json.loads(raw)
name = event.get("event", "")
if name == "pusher_internal:subscription_succeeded":
self.status = "connected"
elif name == "pusher:ping":
ws.send(json.dumps({"event": "pusher:pong", "data": {}}))
elif name.endswith("ChatMessageEvent"):
data = json.loads(event.get("data") or "{}")
user = (data.get("sender") or {}).get("username", "")
# Emotes da Kick chegam como [emote:123:NOME]: fica só o nome, que é o que carrega a reação.
content = data.get("content", "")
kick_emotes = re.findall(r"\[emote:\d+:([^\]]+)\]", content)
text = re.sub(r"\[emote:\d+:([^\]]+)\]", r"\1", content)
batch.append((time.time(), user, text[:300], kick_emotes))
if time.monotonic() - last_flush >= 1.0:
self._deliver(batch)
batch, last_flush = [], time.monotonic()
def _parse_tags(raw: str) -> dict[str, str]:
"""`color=#F00;emotes=25:0-4;room-id=123` → dict. Só usamos ids e posições (sem desescapar valores)."""
tags: dict[str, str] = {}
for item in raw.split(";"):
if "=" in item:
key, value = item.split("=", 1)
tags[key] = value
return tags
+268
View File
@@ -0,0 +1,268 @@
"""Apagar cortes: um, vários ou todos de uma aba (rotas `DELETE /v1/clips/{id}` e `POST /v1/clips/delete`).
O que some com o corte: a linha em `clips`, o projeto de edição (`edits`) e os arquivos dele — vídeo, capa,
miniatura e restos do render em `output/clipper/<sessão>/clip-<id>*`, a pasta do editor `edit-<id>/` (proxy,
forma de onda, narração, prévias) e os quadros que o juiz viu (`<sessão>/frames/clip<id>-*.jpg`). Só apaga
dentro das pastas do Clipador (`CLIPPER_OUTPUT_DIR` e `CLIPPER_DATA_DIR`): o caminho é resolvido antes, link
ou junção nunca é seguido (some só o próprio link) e caminho de fora fica onde está, com o motivo na resposta.
Regras:
- `candidate` (a IA está avaliando) e `rendering` (o FFmpeg está trabalhando) são recusados: o laço do motor
escreveria num corte que não existe mais. Um `pending` que o motor acabou de pegar para renderizar também.
- `published` só com `confirmPublished`: o vídeo já foi postado e a cópia local é o único registro dele aqui.
- **O momento apagado não volta.** A regra anti-duplicado (`worker.find_new_clips`, varredura da IA) compara o
candidato com os cortes existentes, inclusive descartados. Sem o corte, a passada seguinte de uma live em
andamento (ou a passada final da sessão inteira) recriaria o mesmo momento. Por isso fica uma marca mínima em
`deleted_clips` (migração v10): pico, trecho final e janela original do candidato. Ela entra na mesma conta
dos cortes existentes e some junto com a sessão. Apagado que estava pronto, aprovado, rejeitado etc.
(`worker.VETO_STATUSES`) também veta o trecho final depois do juiz ("Duplicado do corte N (que você apagou)");
descartado pela IA não veta, como antes.
- O aprendizado já feito (peso dos emotes, `clips.learned`) fica: ele mora na tabela `emotes`, não no corte.
`judge.duplicateOf` de outros cortes é só texto informativo (nada no código lê esse id de volta).
"""
from __future__ import annotations
import json
import logging
import os
from pathlib import Path
from .config import REPO_ROOT
from .db import loads, now
log = logging.getLogger("cenaforge_clipper.delete")
MAX_BATCH = 500 # mesmo teto da listagem (GET /v1/clips?limit=500), que é o que o painel mostra
# Estados em que o motor ainda está mexendo no corte: recusa com motivo (código, texto para o painel).
BUSY = {
"candidate": ("busy_candidate", "a IA está avaliando este corte"),
"rendering": ("busy_rendering", "está renderizando"),
}
PUBLISHED = ("published", "está publicado: confirme para apagar a cópia local")
NOT_FOUND = ("not_found", "corte não encontrado")
CHANGED = ("changed", "mudou de estado agora há pouco; tente de novo")
class DeleteRefused(Exception):
def __init__(self, code: str, message: str, status: int = 409):
super().__init__(message)
self.code, self.message, self.status = code, message, status
# ---------------------------------------------------------------- marca do momento apagado
def marks(db, session_id: int) -> list[dict]:
"""Momentos apagados da sessão no mesmo formato das linhas de `clips` que o anti-duplicado lê (`id` = o do corte
apagado, que nunca volta a ser usado; `status` = o estado em que ele foi apagado; `peak_s`, `start_s`, `end_s`;
`reasons_json` com a janela original do candidato) e `deleted: True`."""
out = []
for r in db.all("SELECT * FROM deleted_clips WHERE session_id = ?", session_id):
reasons = ({"candidateStartS": r["candidate_start_s"], "candidateEndS": r["candidate_end_s"]}
if r["candidate_start_s"] is not None and r["candidate_end_s"] is not None else {})
out.append({"id": r["clip_id"], "session_id": r["session_id"], "status": r["status"], "peak_s": r["peak_s"],
"start_s": r["start_s"], "end_s": r["end_s"], "title": r["title"],
"reasons_json": json.dumps(reasons), "deleted": True})
return out
def mark_spans(db, session_id: int, lo: float, hi: float) -> list[tuple[float, float, str]]:
"""Trechos apagados que tocam [lo, hi], para a varredura da IA não propor o mesmo momento de novo."""
spans = []
for m in marks(db, session_id):
reasons = loads(m["reasons_json"], {})
a = min(m["start_s"], reasons.get("candidateStartS", m["start_s"]))
b = max(m["end_s"], reasons.get("candidateEndS", m["end_s"]))
if b > lo and a < hi:
spans.append((a, b, "apagado"))
return spans
# ---------------------------------------------------------------- arquivos do corte
def _roots(engine) -> list[Path]:
return [engine.settings.clips_dir.resolve(), engine.settings.data_dir.resolve()]
def _inside(path: Path, roots: list[Path]) -> bool:
try:
resolved = path.resolve()
except OSError:
return False
return any(resolved.is_relative_to(r) for r in roots)
def _is_link(path: Path) -> bool:
return path.is_symlink() or path.is_junction()
def _rel(path: Path) -> str:
try:
return path.relative_to(REPO_ROOT).as_posix()
except ValueError:
return path.as_posix()
def _unlink_link(path: Path) -> None:
"""Remove só o link (símbolo ou junção), nunca o alvo."""
try:
os.unlink(path)
except (IsADirectoryError, PermissionError):
os.rmdir(path) # junção/link de pasta no Windows: rmdir tira o link e não toca no alvo
def _remove_tree(folder: Path, removed: list[str], left: list[dict]) -> None:
"""Apaga a pasta sem seguir link nem junção (o link some; o alvo fica)."""
with os.scandir(folder) as entries:
for entry in entries:
path = Path(entry.path)
try:
if entry.is_symlink() or entry.is_junction():
_unlink_link(path)
elif entry.is_dir(follow_symlinks=False):
_remove_tree(path, removed, left)
continue
else:
path.unlink()
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
try:
folder.rmdir()
except OSError as exc:
left.append({"file": _rel(folder), "reason": f"pasta não ficou vazia ({exc.__class__.__name__})"})
def clip_paths(engine, clip: dict, session: dict | None, cover: str | None) -> tuple[list[Path], list[Path]]:
"""(arquivos, pastas) que pertencem ao corte. Caminhos do banco são relativos à raiz do repositório."""
out_dir = engine.settings.clips_dir / str(clip["session_id"])
cid = clip["id"]
files: list[Path] = [REPO_ROOT / p for p in (clip.get("file"), clip.get("thumb"), cover) if p]
if out_dir.is_dir():
# vídeo, miniatura, capa (`-cover.jpg`) e restos do render (`.ass`, `.concat.txt`, `.tmp.mp4`, `.graph.txt`,
# `.uniform.mkv`, máscaras das camadas). `clip-1.*`/`clip-1-*` não pegam o `clip-12`.
files += sorted(out_dir.glob(f"clip-{cid}.*")) + sorted(out_dir.glob(f"clip-{cid}-*"))
if session and session.get("dir"):
frames = REPO_ROOT / session["dir"] / "frames"
if frames.is_dir():
files += sorted(frames.glob(f"clip{cid}-*.jpg")) # quadros que o analista/editor viram
folders = [out_dir / f"edit-{cid}"] # editor: proxy, forma de onda, TTS, prévias
return files, folders
def remove_files(engine, files: list[Path], folders: list[Path]) -> tuple[list[str], list[dict]]:
roots = _roots(engine)
removed: list[str] = []
left: list[dict] = []
seen: set[str] = set()
for path in files:
key = os.path.normcase(os.path.abspath(path))
if key in seen:
continue
seen.add(key)
if not (path.exists() or _is_link(path)):
continue
try:
if _is_link(path):
# O link pode apontar para fora: some só ele, e só se ele mesmo estiver dentro das pastas.
if not _inside(path.parent, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
_unlink_link(path)
elif not _inside(path, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
elif path.is_file():
path.unlink()
else:
continue
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
for folder in folders:
if _is_link(folder):
if _inside(folder.parent, roots):
_unlink_link(folder)
removed.append(_rel(folder))
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
elif folder.is_dir():
if _inside(folder, roots):
_remove_tree(folder, removed, left)
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
return removed, left
# ---------------------------------------------------------------- apagar
def delete_clip(engine, clip_id: int, confirm_published: bool = False) -> dict:
"""Apaga um corte. Recusa com `DeleteRefused` (código + motivo). Devolve o que foi apagado."""
db = engine.db
# engine.lock: o motor marca `_rendering` sob o mesmo trinco (render_clip), então um corte não começa a
# renderizar no meio da exclusão. db.lock: ler o estado e apagar sem outra thread escrever no meio.
with engine.lock, db.lock:
clip = db.get("SELECT * FROM clips WHERE id = ?", clip_id)
if not clip:
raise DeleteRefused(*NOT_FOUND, status=404)
status = clip["status"]
if status in BUSY:
raise DeleteRefused(*BUSY[status])
if clip_id in engine._rendering:
raise DeleteRefused(*BUSY["rendering"])
if status == "published" and not confirm_published:
raise DeleteRefused(*PUBLISHED)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
edit = db.get("SELECT cover FROM edits WHERE clip_id = ?", clip_id)
reasons = loads(clip.get("reasons_json"), {})
reasons = reasons if isinstance(reasons, dict) else {}
def number(key: str) -> float | None:
try:
return float(reasons[key])
except (KeyError, TypeError, ValueError):
return None
db.conn.execute("BEGIN")
try:
# A marca vem antes de apagar: o anti-duplicado nunca vê a sessão sem o corte e sem a marca.
db.conn.execute(
"INSERT OR REPLACE INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, candidate_start_s,"
" candidate_end_s, status, source, title, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(clip_id, clip["session_id"], clip["peak_s"], clip["start_s"], clip["end_s"], number("candidateStartS"),
number("candidateEndS"), status, clip["source"], (clip["title"] or "")[:100], now()))
db.conn.execute("DELETE FROM edits WHERE clip_id = ?", (clip_id,))
gone = db.conn.execute("DELETE FROM clips WHERE id = ? AND status = ?", (clip_id, status)).rowcount
if gone != 1:
raise DeleteRefused(*CHANGED)
db.conn.execute("COMMIT")
except BaseException:
db.conn.execute("ROLLBACK")
raise
# Arquivos fora do trinco (podem demorar); nada mais aponta para eles e o render não pega um id que sumiu.
files, folders = clip_paths(engine, clip, session, edit["cover"] if edit else None)
removed, left = remove_files(engine, files, folders)
log.info("corte %s apagado (%s): %d arquivos, %d ficaram", clip_id, status, len(removed), len(left))
return {"id": clip_id, "sessionId": clip["session_id"], "status": status, "removedFiles": len(removed),
"left": left}
def select_ids(db, session_id: int | None, statuses: list[str], limit: int = MAX_BATCH) -> tuple[list[int], int]:
"""Ids dos cortes nesses estados (e nessa sessão, se vier), do mais novo para o mais velho, até `limit`.
Devolve (ids, quantos ficaram de fora pelo limite)."""
sql = "SELECT id FROM clips WHERE status IN (" + ",".join("?" * len(statuses)) + ")"
params: list = list(statuses)
if session_id is not None:
sql += " AND session_id = ?"
params.append(session_id)
ids = [r["id"] for r in db.all(sql + " ORDER BY id DESC", *params)]
return ids[:limit], max(0, len(ids) - limit)
def delete_many(engine, ids: list[int], confirm_published: bool = False) -> dict:
"""Apaga vários. Cada um passa pelas mesmas regras; o que não pôde vai em `failed` com o motivo."""
deleted, failed = [], []
for clip_id in dict.fromkeys(ids): # sem repetir, na ordem pedida
try:
deleted.append(delete_clip(engine, clip_id, confirm_published))
except DeleteRefused as exc:
failed.append({"id": clip_id, "code": exc.code, "reason": exc.message})
return {"deleted": deleted, "failed": failed}
+130
View File
@@ -0,0 +1,130 @@
"""Configuração do Clipador, lida de clipper/.env (e do ambiente, que tem prioridade)."""
from __future__ import annotations
import os
import shutil
import sys
from dataclasses import dataclass
from pathlib import Path
CLIPPER_DIR = Path(__file__).resolve().parent.parent
REPO_ROOT = CLIPPER_DIR.parent
PORT_RANGE = (4500, 4599)
class ConfigError(RuntimeError):
"""Configuração inválida: o serviço não sobe."""
def read_env_file(path: Path) -> dict[str, str]:
if not path.is_file():
return {}
values: dict[str, str] = {}
for line in path.read_text(encoding="utf-8").splitlines():
if "=" not in line or line.lstrip().startswith("#"):
continue
name, value = line.split("=", 1)
values[name.strip()] = value.strip()
return values
def _find_tool(env_name: str, names: list[str], extra_dirs: list[Path]) -> str | None:
if os.environ.get(env_name):
return os.environ[env_name]
for directory in extra_dirs:
for name in names:
for ext in ("", ".exe"):
candidate = directory / f"{name}{ext}"
if candidate.is_file():
return str(candidate)
for name in names:
found = shutil.which(name)
if found:
return found
return None
@dataclass(frozen=True)
class Settings:
service_key: str
port: int
segment_s: int
poll_s: int
keep_hours: float
language: str
encoder: str
data_dir: Path
clips_dir: Path
ffmpeg: str | None
ffprobe: str | None
streamlink: str | None
voice_url: str | None
voice_key: str | None
judge_provider: str
judge_model: str
judge_min_score: float
@staticmethod
def load(env_file: Path | None = None, **overrides: object) -> "Settings":
env = {**read_env_file(env_file or CLIPPER_DIR / ".env"), **os.environ}
voice_env = read_env_file(REPO_ROOT / "voice" / ".env")
def num(name: str, default: float, minimum: float = 0) -> float:
raw = env.get(name, "")
try:
value = float(raw) if raw else default
except ValueError as exc:
raise ConfigError(f"{name} precisa ser número") from exc
if value < minimum:
raise ConfigError(f"{name} precisa ser >= {minimum}")
return value
port = int(num("CLIPPER_PORT", 4520, 1))
if not PORT_RANGE[0] <= port <= PORT_RANGE[1]:
raise ConfigError(f"CLIPPER_PORT={port} fora da faixa {PORT_RANGE[0]}–{PORT_RANGE[1]} do CenaForge")
venv_scripts = CLIPPER_DIR / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
def repo_dir(name: str, default: Path) -> Path:
"""Pasta opcional (CLIPPER_DATA_DIR/CLIPPER_OUTPUT_DIR) para isolar uma instância de teste. Precisa ficar
dentro do repositório: blocos e cortes são gravados no banco com caminho relativo ao repo."""
raw = env.get(name, "").strip()
if not raw:
return default
path = Path(raw)
path = (path if path.is_absolute() else REPO_ROOT / path).resolve()
if not path.is_relative_to(REPO_ROOT.resolve()):
raise ConfigError(f"{name} precisa ficar dentro do repositório ({REPO_ROOT})")
return REPO_ROOT / path.relative_to(REPO_ROOT.resolve())
settings = Settings(
service_key=env.get("CLIPPER_SERVICE_KEY", ""),
port=port,
# CLIPPER_QUALITY não é mais lida: a qualidade de gravação é `capture.quality` (canal/sessão, painel).
segment_s=int(num("CLIPPER_SEGMENT_S", 30, 5)),
poll_s=int(num("CLIPPER_POLL_S", 60, 15)),
keep_hours=num("CLIPPER_KEEP_HOURS", 6, 0),
language=env.get("CLIPPER_LANGUAGE", "pt-BR") or "pt-BR",
encoder=env.get("CLIPPER_ENCODER", "auto") or "auto",
data_dir=repo_dir("CLIPPER_DATA_DIR", REPO_ROOT / "data" / "clipper"),
# output/ é servido pelo painel (/api/files): os cortes prontos ficam lá.
clips_dir=repo_dir("CLIPPER_OUTPUT_DIR", REPO_ROOT / "output" / "clipper"),
ffmpeg=_find_tool("FFMPEG_BIN", ["ffmpeg"], []),
ffprobe=_find_tool("FFPROBE_BIN", ["ffprobe"], []),
streamlink=_find_tool("STREAMLINK_BIN", ["streamlink"], [venv_scripts]),
voice_url=f"http://127.0.0.1:{voice_env.get('VOICE_PORT') or '4510'}" if voice_env.get("VOICE_SERVICE_KEY") else None,
voice_key=voice_env.get("VOICE_SERVICE_KEY") or None,
# Valores iniciais do juiz; depois quem manda é o painel (tabela settings do banco do Clipador).
judge_provider=(env.get("CLIPPER_JUDGE_PROVIDER") or "codex").lower(),
judge_model=env.get("CLIPPER_JUDGE_MODEL", ""),
judge_min_score=num("CLIPPER_JUDGE_MIN_SCORE", 6, 0),
)
if settings.judge_provider not in ("codex", "claude", "off"):
raise ConfigError("CLIPPER_JUDGE_PROVIDER precisa ser codex, claude ou off")
if settings.encoder not in ("auto", "libx264", "h264_nvenc"):
raise ConfigError("CLIPPER_ENCODER precisa ser auto, libx264 ou h264_nvenc")
if overrides:
from dataclasses import replace
settings = replace(settings, **overrides) # type: ignore[arg-type]
return settings
+270
View File
@@ -0,0 +1,270 @@
"""Estado do Clipador em data/clipper/clipper.db (SQLite). Canais monitorados, sessões de gravação, blocos
gravados, chat e cortes. As contas (e o vínculo conta ↔ canal) ficam no banco do painel."""
from __future__ import annotations
import json
import sqlite3
import threading
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
SCHEMA = [
"""
CREATE TABLE channels (
id TEXT PRIMARY KEY,
platform TEXT NOT NULL CHECK (platform IN ('twitch', 'youtube', 'kick')),
channel TEXT NOT NULL,
url TEXT NOT NULL,
display_name TEXT NOT NULL,
monitor INTEGER NOT NULL DEFAULT 1,
authorized INTEGER NOT NULL DEFAULT 0,
threshold REAL,
created_at TEXT NOT NULL,
last_check_at TEXT,
last_status TEXT NOT NULL DEFAULT ''
);
CREATE TABLE sessions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id TEXT REFERENCES channels(id) ON DELETE SET NULL,
platform TEXT NOT NULL,
kind TEXT NOT NULL CHECK (kind IN ('live', 'vod')),
url TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('starting', 'recording', 'processing', 'done', 'stopped', 'error', 'interrupted')),
chat_status TEXT NOT NULL DEFAULT 'off',
dir TEXT NOT NULL,
duration_s REAL NOT NULL DEFAULT 0,
started_at TEXT NOT NULL,
ended_at TEXT,
error TEXT
);
CREATE TABLE segments (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
file TEXT NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
wall_end REAL NOT NULL,
analyzed INTEGER NOT NULL DEFAULT 0,
loudness_json TEXT,
words_json TEXT,
transcript_error TEXT,
deleted INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (session_id, idx)
);
CREATE TABLE chat (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
wall REAL NOT NULL,
user TEXT NOT NULL,
text TEXT NOT NULL
);
CREATE INDEX chat_session_wall ON chat (session_id, wall);
CREATE TABLE clips (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
score REAL NOT NULL,
source TEXT NOT NULL,
reasons_json TEXT NOT NULL DEFAULT '{}',
title TEXT NOT NULL DEFAULT '',
caption TEXT NOT NULL DEFAULT '',
transcript TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('candidate', 'discarded', 'pending', 'rendering', 'ready', 'approved', 'rejected', 'published', 'error')),
judge_json TEXT,
file TEXT,
thumb TEXT,
error TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v2: configurações trocadas pelo painel em tempo de execução (juiz: provedor, modelo, nota mínima).
"""
CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
""",
# v3: contexto do jogo, varredura da IA, emotes que aprendem e configuração do corte (layout/legenda).
"""
ALTER TABLE sessions ADD COLUMN game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN game_source TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN screen_game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN games_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN room_id TEXT;
ALTER TABLE sessions ADD COLUMN settings_json TEXT;
ALTER TABLE sessions ADD COLUMN scanned_until REAL NOT NULL DEFAULT 0;
ALTER TABLE sessions ADD COLUMN memory_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN cam_json TEXT;
ALTER TABLE clips ADD COLUMN learned INTEGER NOT NULL DEFAULT 0;
ALTER TABLE channels ADD COLUMN settings_json TEXT;
ALTER TABLE chat ADD COLUMN emotes TEXT;
CREATE TABLE games (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN ('pending', 'ready', 'error')),
profile_json TEXT,
error TEXT,
model TEXT,
researched_at TEXT
);
CREATE TABLE emotes (
channel_key TEXT NOT NULL,
name TEXT NOT NULL,
source TEXT NOT NULL,
uses INTEGER NOT NULL DEFAULT 0,
weight REAL NOT NULL DEFAULT 0,
first_seen TEXT NOT NULL,
last_seen TEXT NOT NULL,
PRIMARY KEY (channel_key, name)
);
""",
# v4: projeto do editor de cortes (JSON versionado por corte; `rev` sobe a cada gravação — autosave sem atropelar).
"""
CREATE TABLE edits (
clip_id INTEGER PRIMARY KEY REFERENCES clips(id) ON DELETE CASCADE,
project_json TEXT NOT NULL,
rev INTEGER NOT NULL DEFAULT 1,
cover TEXT,
exported_at TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v5: rastreio de reação (face.py) — série por segundo do rosto do streamer, uma linha por bloco gravado.
# status: done | no_cam | error. `data_json` = {cam, crop, fps, backend, seconds: [FaceSecond…]} (quadro inteiro).
"""
CREATE TABLE face_track (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
status TEXT NOT NULL CHECK (status IN ('done', 'no_cam', 'error')),
data_json TEXT,
error TEXT,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
# v6: perfil do jogo editável pelo painel. `notes_json` = pedidos que você fez à IA ([{text, at}]) — entram de
# novo em toda pesquisa, para "Pesquisar de novo" não apagar o que você acrescentou; `edited_at` = última edição
# à mão ou por pedido seu.
"""
ALTER TABLE games ADD COLUMN notes_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE games ADD COLUMN edited_at TEXT;
""",
# v7: a IA entrega o projeto de edição pronto. `origin` = quem fez a versão atual (ai = pipeline; user = você
# salvou no editor); `ai_project_json` guarda o que a IA gerou, para "voltar ao projeto da IA".
"""
ALTER TABLE edits ADD COLUMN origin TEXT NOT NULL DEFAULT 'ai' CHECK (origin IN ('ai', 'user'));
ALTER TABLE edits ADD COLUMN ai_project_json TEXT;
""",
# v8: formato em que o corte foi renderizado (`format.aspect` da configuração efetiva no render): o painel
# desenha o player na proporção certa. Cortes antigos foram todos verticais (1080×1920).
"""
ALTER TABLE clips ADD COLUMN aspect TEXT NOT NULL DEFAULT 'vertical' CHECK (aspect IN ('vertical', 'horizontal'));
""",
# v9: o que a captura gravou de fato (app/capture.py): qualidade pedida + resolução, qps, codec e taxa lidos do
# 1º bloco de cada execução (início ou retomada). Sessões antigas ficam NULL (gravadas com o teto antigo de 720p).
"""
ALTER TABLE sessions ADD COLUMN capture_json TEXT;
""",
# v10: marca mínima de cada corte apagado (app/clip_delete.py): pico, trecho final e janela original do
# candidato. A regra anti-duplicado conta com ela como se o corte ainda existisse, então apagar um descartado
# não faz a IA recriar o mesmo momento na passada seguinte da live (nem na passada final da sessão).
"""
CREATE TABLE deleted_clips (
clip_id INTEGER PRIMARY KEY,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
candidate_start_s REAL,
candidate_end_s REAL,
status TEXT NOT NULL,
source TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
deleted_at TEXT NOT NULL
);
CREATE INDEX deleted_clips_session ON deleted_clips (session_id);
""",
]
def now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
class Database:
def __init__(self, path: Path):
path.parent.mkdir(parents=True, exist_ok=True)
self.lock = threading.RLock()
self.conn = sqlite3.connect(path, check_same_thread=False, isolation_level=None)
self.conn.row_factory = sqlite3.Row
self.conn.executescript("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 3000;")
self._migrate()
# Sessões que estavam gravando quando o serviço caiu: a captura morreu junto. Ficam 'interrupted' e o motor
# tenta retomar as lives sozinho na subida (Engine.start → resume_interrupted); quem estava só processando
# volta a processar.
self.interrupted_on_start = [r["id"] for r in self.all(
"SELECT id FROM sessions WHERE status IN ('starting', 'recording') AND kind = 'live'")]
self.run("UPDATE sessions SET status = 'interrupted', ended_at = ?, chat_status = 'off' WHERE status IN ('starting', 'recording')", now())
# Antes as que estavam 'processing' também viravam 'interrupted' e paravam; processar não depende da captura.
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado).
self.run("UPDATE sessions SET chat_status = 'off' WHERE status NOT IN ('starting', 'recording') AND chat_status != 'off'")
self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
def _migrate(self) -> None:
version = self.conn.execute("PRAGMA user_version").fetchone()[0]
for v in range(version, len(SCHEMA)):
with self.lock:
self.conn.execute("BEGIN")
try:
for statement in _split(SCHEMA[v]):
self.conn.execute(statement)
self.conn.execute(f"PRAGMA user_version = {v + 1}")
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def run(self, sql: str, *params: Any) -> sqlite3.Cursor:
with self.lock:
return self.conn.execute(sql, params)
def many(self, sql: str, rows: list[tuple]) -> None:
with self.lock:
self.conn.execute("BEGIN")
try:
self.conn.executemany(sql, rows)
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def all(self, sql: str, *params: Any) -> list[dict]:
with self.lock:
return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
def get(self, sql: str, *params: Any) -> dict | None:
with self.lock:
row = self.conn.execute(sql, params).fetchone()
return dict(row) if row else None
def close(self) -> None:
with self.lock:
self.conn.close()
def _split(script: str) -> list[str]:
# executescript faria COMMIT implícito no meio da transação; executamos comando por comando.
return [s.strip() for s in script.split(";") if s.strip()]
def loads(raw: str | None, default: Any) -> Any:
try:
return json.loads(raw) if raw else default
except json.JSONDecodeError:
return default
+728
View File
@@ -0,0 +1,728 @@
"""Editor de cortes: o PROJETO DE EDIÇÃO de um corte (JSON versionado, tabela `edits`) e as contas de tempo.
Fonte da verdade do editor do painel (`/clipper/edit/<id>`). O servidor sabe renderizar o projeto com FFmpeg
(`editor_render.py`). Ideias tiradas do OpenCut (MIT; só o padrão, nenhum código copiado): trilhas por papel
(vídeo, legenda, textos, áudio), elementos com início/fim, desfazer por instantâneos e atalhos J/K/L/S.
Tempos:
- **tempo da sessão** (`t` da gravação): `cuts`, palavras da legenda, textos, zooms, narração e capa. Assim,
remover um pedaço do meio não desloca o que está ancorado no conteúdo (o zoom continua na reação);
- **tempo de saída** (segundos do MP4): só o gancho (`kind: "hook"`), que vale a partir do 1º quadro.
`to_output` converte; tudo que cai num trecho removido "gruda" no começo do próximo trecho mantido.
Validação forte (`validate_project`): nada do JSON vira comando de shell (FFmpeg recebe lista de argumentos e só
números formatados no filtro), texto é escapado no ASS, arquivos de áudio só de pastas permitidas, limites de
duração e de quantidade.
"""
from __future__ import annotations
import copy
import re
from dataclasses import dataclass
from pathlib import Path
from . import layout, reframe
from .scoring import ChatMessage, Word, fit_window
SCHEMA_VERSION = 1
MAX_WINDOW_S = 600.0 # janela da gravação que o editor carrega (proxy e forma de onda)
MIN_OUTPUT_S, MAX_OUTPUT_S = 3.0, 180.0
MIN_CUT_S = 0.2
MAX_CUTS = 60
MAX_WORDS = 4000
MAX_OVERLAYS = 40
MAX_NARRATION = 12
MAX_SFX = 20
CAPTION_PRESETS = ("classic", "pop", "karaoke", "single", "minimal")
TEXT_ANIMS = layout.HOOK_ANIMS # pop, fade, none, slide (tarja/texto entram deslizando com desfoque)
OVERLAY_KINDS = ("hook", "text", "zoom", "inset") # inset = recorte da tela em destaque
AUDIO_EXT = (".mp3", ".wav", ".ogg", ".m4a", ".opus", ".flac")
ID_RE = re.compile(r"^[A-Za-z0-9_-]{1,40}$")
VOICE_RE = re.compile(r"^[a-z0-9][a-z0-9-]{1,47}$")
TTS_FILE_RE = re.compile(r"^tts-[0-9a-f]{12}\.wav$")
CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
# Padrão de cada preset de legenda (camada por cima do estilo do canal/sessão; o projeto ainda pode sobrescrever).
PRESET_STYLE: dict[str, dict] = {
"classic": {},
"pop": {"maxWords": 3},
"karaoke": {"maxWords": 4, "size": 76},
"single": {"maxWords": 1, "size": 104},
"minimal": {"uppercase": False, "size": 64, "outlineWidth": 4, "maxWords": 4},
}
PRESET_LABEL = {
"classic": "Clássica (palavra falada em destaque)",
"pop": "Pop (palavra falada cresce e volta)",
"karaoke": "Karaokê (preenche palavra a palavra)",
"single": "Uma palavra por vez (entra com escala)",
"minimal": "Mínima (sem destaque, discreta)",
}
class EditError(ValueError):
"""Projeto inválido ou pedido impossível: vira 400 com a mensagem para o usuário."""
# ---------------------------------------------------------------- tempo
@dataclass(frozen=True)
class Piece:
"""Trecho mantido: [start, end] da sessão que entra no MP4 a partir de `out` (tempo de saída)."""
start: float
end: float
out: float
mode: str | None = None
muted: bool = False # trecho sem o som da live (a narração e a música continuam)
@property
def length(self) -> float:
return self.end - self.start
def pieces(cuts: list[dict]) -> list[Piece]:
out, acc = [], 0.0
for cut in cuts:
out.append(Piece(cut["start"], cut["end"], acc, cut.get("mode"), bool(cut.get("muted"))))
acc += cut["end"] - cut["start"]
return out
def output_duration(cuts: list[dict]) -> float:
return round(sum(c["end"] - c["start"] for c in cuts), 3)
def to_output(t: float, cuts: list[dict]) -> tuple[float, bool]:
"""Tempo da sessão → tempo de saída. Segundo valor: o instante está num trecho mantido?
Num trecho removido (ou antes do 1º), cai no começo do próximo trecho mantido."""
for p in pieces(cuts):
if t < p.start:
return round(p.out, 3), False
if t <= p.end:
return round(p.out + t - p.start, 3), True
return output_duration(cuts), False
def to_session(t_out: float, cuts: list[dict]) -> float:
"""Tempo de saída → tempo da sessão."""
ps = pieces(cuts)
for p in ps:
if t_out <= p.out + p.length:
return round(p.start + max(0.0, t_out - p.out), 3)
return ps[-1].end if ps else 0.0
def slice_pieces(cuts: list[dict], a: float, b: float) -> list[Piece]:
"""Trechos da sessão que formam a saída [a, b] (para a prévia real de poucos segundos)."""
out = []
for p in pieces(cuts):
lo, hi = max(a, p.out), min(b, p.out + p.length)
if hi - lo > 0.01:
out.append(Piece(p.start + lo - p.out, p.start + hi - p.out, lo - a, p.mode, p.muted))
return out
def normalize_cuts(cuts: list[dict]) -> list[dict]:
"""Ordena e junta trechos que se encostam/sobrepõem, se tiverem o mesmo layout e o mesmo "mudo"."""
merged: list[dict] = []
for cut in sorted(cuts, key=lambda c: c["start"]):
same = merged and cut.get("mode") == merged[-1].get("mode") and bool(cut.get("muted")) == bool(merged[-1].get("muted"))
if same and cut["start"] <= merged[-1]["end"] + 0.02:
merged[-1]["end"] = max(merged[-1]["end"], cut["end"])
else:
merged.append(dict(cut))
return merged
def output_words(project: dict) -> list[Word]:
"""Palavras visíveis da legenda em tempo de saída (palavra cujo meio caiu num trecho removido some)."""
cuts = project["cuts"]
out = []
for w in project["captions"]["words"]:
if w.get("hidden") or not w["w"].strip():
continue
mid = (w["s"] + w["e"]) / 2
t, inside = to_output(mid, cuts)
if not inside:
continue
for p in pieces(cuts):
if p.start <= mid <= p.end:
s = p.out + max(w["s"], p.start) - p.start
e = p.out + min(w["e"], p.end) - p.start
out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"]))
break
return out
def emphasized(project: dict) -> set[tuple[float, str]]:
return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
# ---------------------------------------------------------------- projeto
def default_window(clip: dict, session_duration: float) -> tuple[float, float]:
"""Janela inicial: 45 s antes e 20 s depois do corte (dá para voltar o começo sem gerar outra prévia)."""
lo = max(0.0, clip["start_s"] - 45)
hi = min(session_duration, clip["end_s"] + 20) if session_duration > 0 else clip["end_s"] + 20
return round(lo, 3), round(max(hi, clip["end_s"]), 3)
_SESSION_TIME_RE = re.compile(r"\b(?:aos|ao|em|no)\s+\d{2,}\s*s\b\s*[,:;—-]?\s*", re.IGNORECASE)
def pick_hook(raw: str | None, title: str | None) -> tuple[str, bool]:
"""Texto do gancho na tela. O do analista só serve se for curto e sem tempo da gravação (ele às vezes devolve
uma frase descritiva como "Aos 5085s, ele solta que…", que saía cortada no meio — medido no corte 25 do skipnho);
senão vale o título do editor, que já é escrito como gancho. Nunca corta no meio de uma palavra.
Devolve (texto, veio_do_analista)."""
raw = (raw or "").strip()
short = bool(raw) and len(raw.split()) <= 8 and len(raw) <= 48 and not re.search(r"\d{3,}\s*s\b", raw)
text = _SESSION_TIME_RE.sub("", raw if short else (title or raw or "")).strip()
if text:
text = text[0].upper() + text[1:]
if len(text) > 60:
text = text[:60].rsplit(" ", 1)[0].rstrip(" ,;:—-")
return text, short
def default_project(clip: dict, words: list[Word], session_duration: float) -> dict:
lo, hi = default_window(clip, session_duration)
analysis = ((clip.get("judge") or {}) if isinstance(clip.get("judge"), dict) else {}).get("analysis") or {}
hook, _ = pick_hook(analysis.get("hook"), clip.get("title"))
return {
"schema": SCHEMA_VERSION,
"source": {"sessionId": clip["session_id"], "lo": lo, "hi": hi},
"settings": {},
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
"captions": {
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in words if lo <= w.start <= hi][:MAX_WORDS],
},
"overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
"progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1.0, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": True, "t": round(clip.get("peak_s") or clip["start_s"], 3), "text": hook[:40]},
}
QUIET_DB = -38.0 # silêncio "de verdade": nem fala nem som do jogo (dBFS por segundo, volume medido no bloco)
AUTO_GAP_S = 2.0 # vão sem fala a partir do qual a IA corta (se também estiver quieto)
def auto_project(clip: dict, analysis: dict | None, words: list[Word], loudness: list[float | None],
session_duration: float, cfg: dict, *, model: str = "", generated_at: str = "") -> dict:
"""Projeto que a IA entrega pronto (o render automático usa ESTE projeto, o mesmo que o editor abre):
trecho pela análise (início da ação, fim da reação) encaixado nas palavras, silêncios longos E quietos
removidos (longe do pico), legenda do Whisper no estilo do corte (preset pop), gancho do analista nos
primeiros segundos, punch-in no pico e capa no pico. `loudness` = dBFS por segundo da sessão (índice = s)."""
p = default_project(clip, words, session_duration)
lo, hi = p["source"]["lo"], p["source"]["hi"]
dur = {**layout.DEFAULTS["duration"], **(cfg.get("duration") or {})}
max_s = float(dur["maxS"])
# Corte automático: duração FINAL (depois de silêncios e aparos) ≥ mínimo + 1 s. "Cortar agora" é livre.
manual = clip.get("source") == "manual"
min_s = 0.0 if manual else layout.min_target({"duration": dur})
steps: list[str] = []
start, end = float(clip["start_s"]), float(clip["end_s"])
a = analysis or {}
try:
act, react = float(a.get("action_start_s")), float(a.get("reaction_end_s"))
except (TypeError, ValueError):
act = react = None # type: ignore[assignment]
# Início no começo da ação. Medido (sessão 3, cortes 43, 44, 55, 58, 61): quando o analista punha a ação DEPOIS do
# início do juiz, o corte encolhia para 44–58 s com mínimo 60. Adiantar o início só vale se o mínimo continua.
if (act is not None and lo <= act < end - 5 and act >= start - 15 and abs(act - start) > 0.5
and end - max(lo, act - 0.8) >= min_s):
start = max(lo, act - 0.8)
steps.append(f"início no começo da ação ({act:.0f}s, analista)")
if react is not None and end < react <= min(hi, end + 8):
end = min(hi, react + 0.8)
steps.append(f"fim depois da reação ({react:.0f}s, analista)")
inside = sorted((w for w in words if lo <= w.start <= hi and w.word.strip()), key=lambda w: w.start)
for w in inside: # nunca corta no meio da palavra
if w.start < start < w.end:
start = max(lo, w.start - 0.1)
if w.start < end < w.end:
end = min(hi, w.end + 0.15)
if end - start > max_s:
end = start + max_s
steps.append(f"limitado a {max_s:.0f} s")
if end - start < min_s:
# Falta material: cresce para trás (contexto; é onde o gancho fica) e, no começo da gravação, para a frente.
before = end - start
start, end = fit_window(start, end, lo, hi, min_s, max_s, keep="start")
for w in inside: # o início novo também não corta palavra (só recua)
if w.start < start < w.end and end - (w.start - 0.1) <= max_s:
start = max(lo, w.start - 0.1)
steps.append(f"estendido de {before:.1f} s para {end - start:.1f} s (mínimo {min_s:.1f} s)")
if end - start < min_s - 0.01:
steps.append(f"curto: só havia {end - start:.1f} s de gravação em volta do momento (mínimo {min_s:.1f} s)")
cuts = [{"start": round(start, 3), "end": round(end, 3), "mode": None}]
peak = float(clip.get("peak_s") or (start + end) / 2)
def quiet(x: float, y: float) -> bool:
values = loudness[int(x): int(y) + 1]
return bool(values) and all(v is None or v < QUIET_DB for v in values)
removed = 0.0
spoken = [w for w in inside if start <= w.start <= end]
for w1, w2 in zip(spoken, spoken[1:]):
x, y = w1.end + 0.25, w2.start - 0.25
if w2.start - w1.end < AUTO_GAP_S or y - x < 0.5 or x - 3 <= peak <= y + 3 or not quiet(x, y):
continue
if output_duration(cuts) - (y - x) < min_s: # o corte final nunca fica abaixo do mínimo + 1 s
break
out, kept = [], cuts
for c in kept:
if y <= c["start"] or x >= c["end"]:
out.append(c)
continue
if x > c["start"]:
out.append({**c, "end": round(x, 3)})
if y < c["end"]:
out.append({**c, "start": round(y, 3)})
cuts = normalize_cuts(out)
removed += y - x
if removed:
steps.append(f"{removed:.1f} s de silêncio removidos")
p["cuts"] = cuts
p["captions"]["preset"] = "pop"
steps.append(f"legenda do Whisper ({len(spoken)} palavras, estilo pop)")
# Gancho: o do analista só se for curto (às vezes ele devolve uma frase descritiva — medido no corte 10 do
# skipnho); senão o título do editor, que já é escrito como gancho.
hook, short = pick_hook(a.get("hook"), clip.get("title"))
p["overlays"] = []
if hook:
# Estilo do gancho pela configuração do corte (grupo `hook`; padrão: tarja verde-limão que entra deslizando).
# Ele cobre o começo do corte — o segundo a mais do mínimo é justamente essa abertura (não há tela parada).
hk = {**layout.DEFAULTS["hook"], **(cfg.get("hook") or {})}
overlay = {"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": round(float(hk["seconds"]), 3),
"y": 0.2, "size": 68, "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
if hk["style"] == "banner":
overlay |= {"style": "banner", "bg": hk["bg"], "color": hk["color"], "font": hk["font"], "anim": hk["anim"],
"box": None, "size": 76}
# A tarja (até ~0,13 da altura no vertical) não pode cobrir a legenda automática: se a legenda estiver
# perto de 20 % da altura (câmera em cima com painel baixo, ou y escolhido), a tarja vai para o outro lado.
cap_y = layout.caption_y(cfg) / layout.canvas_size(cfg)[1]
if abs(cap_y - overlay["y"]) < 0.2:
overlay["y"] = round(cap_y - 0.22 if cap_y > 0.3 else min(0.85, cap_y + 0.22), 3)
else:
overlay |= {"color": hk["color"], "font": hk["font"], "anim": hk["anim"]}
p["overlays"].append(overlay)
steps.append(("gancho do analista" if short else "gancho = título do editor") + f" ({hk['style']})")
t_out, kept_peak = to_output(peak, cuts)
if kept_peak and t_out >= 1.5:
cut = next(c for c in cuts if c["start"] <= peak <= c["end"])
z_end = min(cut["end"], peak + 2.0)
if z_end - peak >= 0.8:
cam = layout.resolved_mode(cfg) == "cam_top"
# Câmera em cima: aproxima do rosto (centro do painel da câmera); senão, o centro da tela.
fy = round(cfg["layout"]["camHeight"] / 2, 3) if cam else 0.45
p["overlays"].append({"id": "zoom-peak", "kind": "zoom", "start": round(max(cut["start"], peak - 0.2), 3),
"end": round(z_end, 3), "scale": 1.25, "x": 0.5, "y": fy, "ramp": 0.15})
steps.append(f"zoom no pico ({peak:.0f}s)")
p["cover"] = {"enabled": True, "t": round(min(max(peak, lo), hi), 3), "text": hook[:40]}
p["meta"] = {"origin": "ai", "generatedAt": generated_at, "model": model or "", "steps": steps[:12]}
return p
def _num(value, name: str, lo: float, hi: float) -> float:
try:
v = float(value)
except (TypeError, ValueError) as exc:
raise EditError(f"{name} precisa ser número") from exc
if v != v or not lo <= v <= hi: # NaN ou fora da faixa
raise EditError(f"{name} vai de {lo:g} a {hi:g}")
return round(v, 3)
def _text(value, name: str, max_len: int, allow_empty: bool = True) -> str:
if not isinstance(value, str):
raise EditError(f"{name} precisa ser texto")
text = CONTROL_RE.sub(" ", value).replace("\r", "").strip()
if len(text) > max_len:
raise EditError(f"{name} passa de {max_len} caracteres")
if not text and not allow_empty:
raise EditError(f"{name} está vazio")
return text
def _hex(value, name: str) -> str:
if not isinstance(value, str) or not layout.HEX_RE.match(value):
raise EditError(f"{name} precisa ser cor #RRGGBB")
return value.upper()
def _list(value, name: str, limit: int) -> list:
if value is None:
return []
if not isinstance(value, list):
raise EditError(f"{name} precisa ser lista")
if len(value) > limit:
raise EditError(f"{name}: no máximo {limit}")
return value
def _id(value, name: str) -> str:
if not isinstance(value, str) or not ID_RE.match(value):
raise EditError(f"{name} precisa ser um id curto (letras, números, - e _)")
return value
def safe_audio_file(value, roots: list[Path], repo_root: Path, name: str) -> str:
"""Arquivo de áudio relativo ao repositório, dentro de uma das pastas permitidas e existente."""
if not isinstance(value, str) or not value or "\\" in value or value.startswith("/") or ".." in value.split("/"):
raise EditError(f"{name}: caminho inválido")
full = (repo_root / value).resolve()
if full.suffix.lower() not in AUDIO_EXT:
raise EditError(f"{name}: só áudio ({', '.join(AUDIO_EXT)})")
if not any(full.is_relative_to(r.resolve()) for r in roots):
raise EditError(f"{name}: arquivo fora das pastas permitidas")
if not full.is_file():
raise EditError(f"{name}: arquivo não encontrado")
return value
def validate_project(data: dict, *, session_id: int, session_duration: float, repo_root: Path,
tts_dir: Path, assets_dir: Path) -> dict:
"""Valida e normaliza o projeto inteiro. Levanta EditError com a 1ª falha (mensagem em português)."""
if not isinstance(data, dict):
raise EditError("projeto precisa ser um objeto")
if data.get("schema") != SCHEMA_VERSION:
raise EditError(f"versão do projeto não suportada (esperado schema {SCHEMA_VERSION})")
src = data.get("source") or {}
if src.get("sessionId") != session_id:
raise EditError("o projeto é de outra sessão")
limit = session_duration if session_duration > 0 else 1e9
lo = _num(src.get("lo"), "source.lo", 0, limit)
hi = _num(src.get("hi"), "source.hi", 0, limit)
if not 5 <= hi - lo <= MAX_WINDOW_S:
raise EditError(f"a janela da gravação precisa ter de 5 s a {MAX_WINDOW_S / 60:.0f} min")
# Configuração do corte própria do projeto (mesma validação da configuração de canal/sessão).
try:
own_settings = layout.validate(data.get("settings") or {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"configuração do corte: {exc}") from exc
raw_cuts = _list(data.get("cuts"), "cuts", MAX_CUTS)
if not raw_cuts:
raise EditError("o corte precisa de pelo menos um trecho")
cuts = []
for i, c in enumerate(raw_cuts):
if not isinstance(c, dict):
raise EditError(f"cuts[{i}] precisa ser objeto")
start, end = _num(c.get("start"), f"cuts[{i}].start", lo, hi), _num(c.get("end"), f"cuts[{i}].end", lo, hi)
if end - start < MIN_CUT_S:
raise EditError(f"cuts[{i}] precisa ter pelo menos {MIN_CUT_S:g} s")
mode = c.get("mode")
if mode is not None and mode not in layout.MODES:
raise EditError(f"cuts[{i}].mode precisa ser um de {', '.join(layout.MODES)} ou null")
cuts.append({"start": start, "end": end, "mode": mode, "muted": bool(c.get("muted", False))})
cuts = normalize_cuts(cuts)
total = output_duration(cuts)
if not MIN_OUTPUT_S <= total <= MAX_OUTPUT_S:
raise EditError(f"o corte editado precisa ter de {MIN_OUTPUT_S:g} a {MAX_OUTPUT_S:g} s (tem {total:.1f} s)")
cap = data.get("captions") or {}
preset = cap.get("preset", "classic")
if preset not in CAPTION_PRESETS:
raise EditError(f"captions.preset precisa ser um de {', '.join(CAPTION_PRESETS)}")
try:
style = layout.validate({"caption": cap.get("style") or {}}).get("caption", {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"estilo da legenda: {exc}") from exc
words = []
for i, w in enumerate(_list(cap.get("words"), "captions.words", MAX_WORDS)):
if not isinstance(w, dict):
raise EditError(f"captions.words[{i}] precisa ser objeto")
s, e = _num(w.get("s"), f"palavra {i} (início)", 0, limit), _num(w.get("e"), f"palavra {i} (fim)", 0, limit)
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms
e = round(s + 0.05, 3)
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
if w.get("emph"):
item["emph"] = True
if w.get("hidden"):
item["hidden"] = True
words.append(item)
words.sort(key=lambda w: w["s"])
captions = {"enabled": bool(cap.get("enabled", True)), "preset": preset, "style": style,
"emphColor": _hex(cap.get("emphColor", "#22E36B"), "captions.emphColor"), "words": words}
overlays, seen = [], set()
for i, o in enumerate(_list(data.get("overlays"), "overlays", MAX_OVERLAYS)):
if not isinstance(o, dict) or o.get("kind") not in OVERLAY_KINDS:
raise EditError(f"overlays[{i}].kind precisa ser um de {', '.join(OVERLAY_KINDS)}")
oid = _id(o.get("id"), f"overlays[{i}].id")
if oid in seen:
raise EditError(f"overlays: id repetido ({oid})")
seen.add(oid)
kind = o["kind"]
if kind == "hook": # tempo de saída
start, end = _num(o.get("start", 0), "gancho: início", 0, MAX_OUTPUT_S), _num(o.get("end"), "gancho: fim", 0, MAX_OUTPUT_S)
else: # tempo da sessão
start, end = _num(o.get("start"), f"overlays[{i}].start", lo, hi), _num(o.get("end"), f"overlays[{i}].end", lo, hi)
if end - start < 0.2:
raise EditError(f"overlays[{i}] precisa durar pelo menos 0,2 s")
item = {"id": oid, "kind": kind, "start": start, "end": end}
if kind == "inset":
item |= _inset(o, i, lo, hi)
elif kind == "zoom":
item |= {"scale": _num(o.get("scale", 1.3), "zoom: escala", 1.05, 2.5),
"x": _num(o.get("x", 0.5), "zoom: x", 0, 1), "y": _num(o.get("y", 0.5), "zoom: y", 0, 1),
"ramp": _num(o.get("ramp", 0.25), "zoom: rampa", 0, 1.5)}
else:
box = o.get("box")
style = o.get("style", "plain")
if style not in layout.HOOK_STYLES:
raise EditError(f"overlays[{i}].style precisa ser um de {', '.join(layout.HOOK_STYLES)}")
font = o.get("font")
if font is not None and font not in layout.FONTS:
raise EditError(f"overlays[{i}].font precisa ser uma de {', '.join(layout.FONTS)}")
bg = o.get("bg")
# Campos novos só entram no projeto quando usados: projeto antigo continua byte a byte igual.
if style != "plain":
item["style"] = style
if font is not None:
item["font"] = font
if bg not in (None, ""):
item["bg"] = _hex(bg, f"overlays[{i}].bg")
item |= {"text": _text(o.get("text", ""), f"overlays[{i}].text", 120, allow_empty=False),
"x": _num(o.get("x", 0.5), f"overlays[{i}].x", 0.05, 0.95),
"y": _num(o.get("y", 0.2), f"overlays[{i}].y", 0.04, 0.96),
"size": int(_num(o.get("size", 64), f"overlays[{i}].size", 24, 180)),
"color": _hex(o.get("color", "#FFFFFF"), f"overlays[{i}].color"),
"box": None if box in (None, "") else _hex(box, f"overlays[{i}].box"),
"anim": o.get("anim", "pop")}
if item["anim"] not in TEXT_ANIMS:
raise EditError(f"overlays[{i}].anim precisa ser um de {', '.join(TEXT_ANIMS)}")
overlays.append(item)
if sum(1 for o in overlays if o["kind"] == "inset") > reframe.MAX_INSETS:
raise EditError(f"no máximo {reframe.MAX_INSETS} camadas inseridas")
zooms = sorted((o for o in overlays if o["kind"] == "zoom"), key=lambda o: o["start"])
for a, b in zip(zooms, zooms[1:]):
if b["start"] < a["end"]:
raise EditError("dois zooms ao mesmo tempo: separe os trechos de zoom")
prog = data.get("progress") or {}
progress = {"enabled": bool(prog.get("enabled", False)), "color": _hex(prog.get("color", "#FF7A1A"), "progress.color"),
"height": int(_num(prog.get("height", 12), "progress.height", 4, 40))}
aud = data.get("audio") or {}
narration = []
for i, n in enumerate(_list(aud.get("narration"), "audio.narration", MAX_NARRATION)):
if not isinstance(n, dict):
raise EditError(f"audio.narration[{i}] precisa ser objeto")
file = safe_audio_file(n.get("file"), [tts_dir], repo_root, f"narração {i + 1}")
if not TTS_FILE_RE.match(Path(file).name):
raise EditError(f"narração {i + 1}: arquivo precisa ser gerado pelo editor (tts-*.wav)")
voice = n.get("voice", "")
if voice and not VOICE_RE.match(str(voice)):
raise EditError(f"narração {i + 1}: voz inválida")
narration.append({"id": _id(n.get("id"), f"narração {i + 1}"), "file": file,
"at": _num(n.get("at"), f"narração {i + 1}: instante", lo, hi),
"volume": _num(n.get("volume", 1.0), f"narração {i + 1}: volume", 0, 2),
"durationS": _num(n.get("durationS", 0), f"narração {i + 1}: duração", 0, 120),
"duck": _num(n.get("duck", 0.35), f"narração {i + 1}: volume do original por baixo", 0, 1),
"text": _text(n.get("text", ""), f"narração {i + 1}: texto", 300), "voice": str(voice)})
music = None
if aud.get("music"):
m = aud["music"]
if not isinstance(m, dict):
raise EditError("audio.music precisa ser objeto ou null")
music = {"file": safe_audio_file(m.get("file"), [assets_dir], repo_root, "música"),
"volume": _num(m.get("volume", 0.18), "música: volume", 0, 1), "duck": bool(m.get("duck", True))}
sfx = []
for i, x in enumerate(_list(aud.get("sfx"), "audio.sfx", MAX_SFX)):
if not isinstance(x, dict):
raise EditError(f"audio.sfx[{i}] precisa ser objeto")
sfx.append({"id": _id(x.get("id"), f"efeito {i + 1}"), "file": safe_audio_file(x.get("file"), [assets_dir], repo_root, f"efeito {i + 1}"),
"at": _num(x.get("at"), f"efeito {i + 1}: instante", lo, hi),
"volume": _num(x.get("volume", 0.8), f"efeito {i + 1}: volume", 0, 2)})
audio = {"volume": _num(aud.get("volume", 1.0), "audio.volume", 0, 2), "narration": narration, "music": music, "sfx": sfx}
cov = data.get("cover") or {}
cover = {"enabled": bool(cov.get("enabled", True)), "t": _num(cov.get("t", cuts[0]["start"]), "capa: instante", lo, hi),
"text": _text(cov.get("text", ""), "capa: texto", 60),
# Capa também nos 2 primeiros quadros do vídeo: as redes usam o quadro 0 como miniatura padrão.
"atStart": bool(cov.get("atStart", False))}
# Chat da live na tela: as últimas mensagens num bloco, na posição escolhida (x = borda esquerda, y = base).
ch = data.get("chat") or {}
if not isinstance(ch, dict):
raise EditError("chat precisa ser objeto")
chat = {"enabled": bool(ch.get("enabled", False)),
"x": _num(ch.get("x", 0.04), "chat: x", 0, 0.9), "y": _num(ch.get("y", 0.62), "chat: y", 0.1, 0.98),
"width": _num(ch.get("width", 0.6), "chat: largura", 0.25, 0.96),
"lines": int(_num(ch.get("lines", 5), "chat: linhas", 1, 10)),
"size": int(_num(ch.get("size", 34), "chat: tamanho", 18, 64)),
"showUser": bool(ch.get("showUser", True))}
raw_meta = data.get("meta") or {}
if not isinstance(raw_meta, dict):
raise EditError("meta precisa ser objeto")
origin = raw_meta.get("origin", "user")
if origin not in ("ai", "user"):
raise EditError("meta.origin precisa ser ai ou user")
meta = {"origin": origin, "generatedAt": _text(raw_meta.get("generatedAt", ""), "meta.generatedAt", 40),
"model": _text(raw_meta.get("model") or "", "meta.model", 80),
"steps": [_text(x, "meta.steps", 200) for x in _list(raw_meta.get("steps"), "meta.steps", 12)]}
project = {"schema": SCHEMA_VERSION, "source": {"sessionId": session_id, "lo": lo, "hi": hi}, "settings": own_settings,
"cuts": cuts, "captions": captions, "overlays": overlays, "progress": progress, "audio": audio,
"cover": cover, "chat": chat, "meta": meta}
# Reenquadramento do jogo no tempo: só entra no projeto quando há keys (projeto antigo continua igual).
keys = _reframe_keys(data.get("reframe"), lo, hi)
if keys:
project["reframe"] = {"keys": keys}
return project
def _keys(raw, name: str, lo: float, hi: float, fields: dict[str, tuple[float, float]]) -> list[dict]:
"""Keyframes {t (tempo da sessão), campos..., ease}: validados, ordenados, no máximo `reframe.MAX_KEYS`."""
out = []
for i, k in enumerate(_list(raw, name, reframe.MAX_KEYS)):
if not isinstance(k, dict):
raise EditError(f"{name}[{i}] precisa ser objeto")
item = {"t": _num(k.get("t"), f"{name}[{i}].t", lo, hi)}
for field, (a, b) in fields.items():
item[field] = _num(k.get(field), f"{name}[{i}].{field}", a, b)
ease = k.get("ease", "smooth")
if ease not in reframe.EASES:
raise EditError(f"{name}[{i}].ease precisa ser um de {', '.join(reframe.EASES)}")
item["ease"] = ease
out.append(item)
out.sort(key=lambda k: k["t"])
for a, b in zip(out, out[1:]):
if b["t"] - a["t"] < 0.02:
raise EditError(f"{name}: dois keyframes no mesmo instante ({a['t']:g} s)")
return out
def _reframe_keys(raw, lo: float, hi: float) -> list[dict]:
if raw in (None, {}):
return []
if not isinstance(raw, dict):
raise EditError("reframe precisa ser objeto {keys: [...]}")
return _keys(raw.get("keys"), "reframe.keys", lo, hi, {"cx": (0, 1), "cy": (0, 1), "w": (0.05, 1)})
def _inset(o: dict, i: int, lo: float, hi: float) -> dict:
"""Camada inserida: recorte `src` do quadro original posto em (x, y) com largura `size` da tela."""
name = f"overlays[{i}]"
try:
src = layout._rect(o.get("src"), f"{name}.src")
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(str(exc)) from exc
if src is None:
raise EditError(f"{name}.src precisa ser {{x, y, w, h}} (recorte do quadro original)")
border = o.get("border")
anim = o.get("anim", "pop")
if anim not in reframe.INSET_ANIMS:
raise EditError(f"{name}.anim precisa ser um de {', '.join(reframe.INSET_ANIMS)}")
return {"src": src, "x": _num(o.get("x", 0.5), f"{name}.x", 0, 1), "y": _num(o.get("y", 0.5), f"{name}.y", 0, 1),
"size": _num(o.get("size", 0.45), f"{name}.size", 0.1, 1),
"border": None if border in (None, "") else _hex(border, f"{name}.border"),
"borderW": int(_num(o.get("borderW", 6), f"{name}.borderW", 0, 40)),
"radius": int(_num(o.get("radius", 18), f"{name}.radius", 0, 200)),
"shadow": bool(o.get("shadow", True)), "anim": anim,
"keys": _keys(o.get("keys"), f"{name}.keys", lo, hi, {"x": (0, 1), "y": (0, 1), "size": (0.1, 1)})}
def effective_settings(base: dict, project: dict) -> dict:
"""Configuração do corte do render: padrão ← canal ← sessão ← projeto, mais o preset e o estilo da legenda."""
cfg = layout.merge(base, project.get("settings") or {})
cap = project["captions"]
cfg["caption"].update(PRESET_STYLE.get(cap["preset"], {}))
cfg["caption"].update(cap.get("style") or {})
cfg["caption"]["enabled"] = cap["enabled"]
return cfg
def retime(project: dict, start: float, end: float) -> dict:
"""O cartão do corte mudou início/fim (−30 s, +2 s…): estica/encolhe as pontas do projeto, mantém o meio."""
p = copy.deepcopy(project)
cuts = p["cuts"]
cuts[0]["start"] = min(start, cuts[0]["end"] - MIN_CUT_S)
cuts[-1]["end"] = max(end, cuts[-1]["start"] + MIN_CUT_S)
p["source"]["lo"] = min(p["source"]["lo"], cuts[0]["start"])
p["source"]["hi"] = max(p["source"]["hi"], cuts[-1]["end"])
return p
def span(project: dict) -> tuple[float, float]:
return project["cuts"][0]["start"], project["cuts"][-1]["end"]
# ---------------------------------------------------------------- IA sugere
SUGGEST_SYSTEM = """Você é EDITOR de cortes de lives de jogos em português do Brasil — verticais (Shorts/TikTok/Reels)
ou horizontais (YouTube, tela cheia do jogo), conforme o formato informado.
Recebe a transcrição palavra a palavra com tempos, o chat e a análise do momento. Devolva:
- hook: texto curto de gancho para os 2 primeiros segundos (até 8 palavras, sem hashtag, fiel ao que acontece);
- title: título do vídeo (até 70 caracteres, gancho + palavra de busca);
- start_s/end_s: início ideal (onde a AÇÃO começa, sem enrolação) e fim (depois da reação/pagamento);
- remove: trechos mortos DENTRO de [start_s, end_s] para cortar (silêncio longo, enrolação, fala sem relação),
sem quebrar o contexto nem cortar no meio de frase. Pode ser vazio;
- zooms: instantes de reação forte para um punch-in curto (0 a 3);
- reason: por que, em uma frase.
Tempos sempre em segundos da gravação (os mesmos da transcrição). Nunca invente o que não está na fala/chat/análise."""
SUGGEST_SCHEMA = {
"type": "object", "additionalProperties": False,
"required": ["hook", "title", "start_s", "end_s", "remove", "zooms", "reason"],
"properties": {
"hook": {"type": "string"}, "title": {"type": "string"},
"start_s": {"type": "number"}, "end_s": {"type": "number"},
"remove": {"type": "array", "items": {"type": "object", "additionalProperties": False,
"required": ["start_s", "end_s", "why"],
"properties": {"start_s": {"type": "number"}, "end_s": {"type": "number"},
"why": {"type": "string"}}}},
"zooms": {"type": "array", "items": {"type": "object", "additionalProperties": False, "required": ["t", "why"],
"properties": {"t": {"type": "number"}, "why": {"type": "string"}}}},
"reason": {"type": "string"},
},
}
def suggest_prompt(streamer: str, title: str, project: dict, chat: list[ChatMessage], analysis: dict | None,
transcript: str, chat_block: str, cfg: dict | None = None) -> str:
"""`cfg` = configuração efetiva do corte (duração e formato); sem ela, os padrões de `layout.DEFAULTS`."""
cfg = cfg or layout.merge()
lo, hi = project["source"]["lo"], project["source"]["hi"]
a, b = span(project)
dur = cfg["duration"]
fmt = "horizontal 16:9 (YouTube)" if layout.aspect(cfg) == "horizontal" else "vertical 9:16 (Shorts/TikTok/Reels)"
return (f"Canal: {streamer}\nTítulo atual do corte: {title or '(nenhum)'}\nFormato: {fmt}\n"
f"Janela disponível da gravação: {lo:.0f}s a {hi:.0f}s. Corte atual: {a:.0f}s a {b:.0f}s "
f"({output_duration(project['cuts']):.0f} s depois dos cortes internos).\n"
f"Duração final ideal: {dur['minS']:.0f} a {dur['maxS']:.0f} s.\n\n"
f"Transcrição (segundos da gravação):\n{transcript}\n\n{chat_block}\n\n"
+ (f"Análise do momento (1º juiz): {analysis}\n" if analysis else ""))
def clean_suggestion(data: dict, lo: float, hi: float, min_len: float = MIN_OUTPUT_S,
max_len: float = MAX_OUTPUT_S) -> dict:
"""Prende tudo dentro da janela e nos limites (a IA pode errar números). `min_len`/`max_len` = duração final do
corte (o editor passa mínimo + 1 s e máximo da configuração); os trechos a remover que levariam o corte abaixo do
mínimo ficam de fora."""
start, end = fit_window(float(data.get("start_s", lo)), float(data.get("end_s", hi)), lo, hi,
max(MIN_OUTPUT_S, min_len), max_len, keep="start")
remove = []
for r in (data.get("remove") or [])[:10]:
try:
a, b = max(float(r["start_s"]), start), min(float(r["end_s"]), end)
except (KeyError, TypeError, ValueError):
continue
if b - a >= 0.4 and (end - start) - sum(x["end"] - x["start"] for x in remove) - (b - a) >= min_len:
remove.append({"start": round(a, 2), "end": round(b, 2), "why": str(r.get("why", ""))[:160]})
zooms = []
for z in (data.get("zooms") or [])[:3]:
try:
t = float(z["t"])
except (KeyError, TypeError, ValueError):
continue
if start <= t <= end:
zooms.append({"t": round(t, 2), "why": str(z.get("why", ""))[:160]})
return {"hook": str(data.get("hook", "")).strip()[:80], "title": str(data.get("title", "")).strip()[:100],
"start": round(start, 2), "end": round(end, 2), "remove": remove, "zooms": zooms,
"reason": str(data.get("reason", ""))[:300]}
+465
View File
@@ -0,0 +1,465 @@
"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`)
e o render do projeto chamado pela fila do motor (worker.render_clip).
O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o
`rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do
editor em `output/clipper/<sessão>/edit-<corte>/` (proxy 480p, forma de onda, narração TTS, prévia real).
"""
from __future__ import annotations
import hashlib
import json
import logging
import threading
import time
import uuid
from pathlib import Path
import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from . import editor, editor_render, layout, media
from .config import REPO_ROOT
from .db import loads, now
from .judge import JudgeError, _chat_block, _transcript
from .scoring import Word
log = logging.getLogger("cenaforge_clipper.editor")
PREVIEW_MAX_S = 10.0
RETRANSCRIBE_MAX_S = 90.0
_locks: dict[str, threading.Lock] = {}
_locks_guard = threading.Lock()
def _lock(key: str) -> threading.Lock:
with _locks_guard:
return _locks.setdefault(key, threading.Lock())
class EditPut(BaseModel):
project: dict
rev: int = Field(default=0, ge=0)
class WindowIn(BaseModel):
lo: float = Field(ge=0)
hi: float = Field(ge=0)
class PreviewRenderIn(BaseModel):
fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S)
durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S)
project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo
class RangeIn(BaseModel):
startS: float = Field(ge=0)
endS: float = Field(ge=0)
class TtsIn(BaseModel):
text: str = Field(min_length=1, max_length=300)
voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$")
speed: float = Field(default=1.0, ge=0.5, le=2.0)
class SuggestIn(BaseModel):
project: dict | None = None
# ---------------------------------------------------------------- utilidades (também usadas pelo worker)
def edit_dir(engine, session_id: int, clip_id: int) -> Path:
return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}"
def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]:
return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)]
def validate_for(engine, clip: dict, session: dict, data: dict) -> dict:
return editor.validate_project(
data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT,
tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets")
def load_edit(engine, clip_id: int) -> dict | None:
row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id)
if row:
row["project"] = loads(row["project_json"], None)
return row
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
project = validate_for(engine, clip, session, edit["project"])
segments = session_segments(engine, clip["session_id"])
if engine._encoder is None:
engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder)
base = engine.intel.settings_for(session)
credit = engine.channel_label(session)
ffmpeg = engine.settings.ffmpeg or "ffmpeg"
# A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4.
cover: Path | None = None
if project["cover"]["enabled"]:
cover = out.parent / f"{out.stem}-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
cover = None
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover)
total = editor.output_duration(project["cuts"])
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"])
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
def chat_for(engine, project: dict) -> list | None:
"""Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede)."""
if not (project.get("chat") or {}).get("enabled"):
return None
lo = project["source"]["lo"]
return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"]
def _judge(clip: dict) -> dict:
data = loads(clip.get("judge_json"), None)
return data if isinstance(data, dict) else {}
def auto_for(engine, clip: dict, session: dict) -> dict:
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
judge = _judge(clip)
lo, hi = editor.default_window(clip, session["duration_s"])
rows = engine.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
clip["session_id"], lo, hi)
words = [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], [])]
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
def ensure_edit(engine, clip: dict, session: dict) -> dict:
"""Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um
agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto."""
row = load_edit(engine, clip["id"])
if row and row["project"]:
return row
project = validate_for(engine, clip, session, auto_for(engine, clip, session))
raw = json.dumps(project, ensure_ascii=False)
ts = now()
engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts)
start, end = editor.span(project)
engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"])
return load_edit(engine, clip["id"])
def retime_edit(engine, clip_id: int, start: float, end: float) -> None:
"""O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto."""
row = load_edit(engine, clip_id)
if not row or not row["project"]:
return
project = editor.retime(row["project"], start, end)
engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), now(), clip_id)
def _audio_library() -> list[dict]:
root = REPO_ROOT / "assets"
out = []
if root.is_dir():
for f in sorted(root.rglob("*")):
if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT:
out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem})
if len(out) >= 200:
break
return out
def _window_key(lo: float, hi: float) -> str:
return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}"
def _clean_old(folder: Path, prefix: str, keep: str) -> None:
for f in folder.glob(f"{prefix}-*"):
if f.name != keep:
f.unlink(missing_ok=True)
# ---------------------------------------------------------------- rotas
def register(app: FastAPI, engine, clip_view, get_clip) -> None:
"""`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir)."""
db, settings = engine.db, engine.settings
ffmpeg = settings.ffmpeg or "ffmpeg"
@app.exception_handler(editor.EditError)
async def edit_error(_request: Request, exc: editor.EditError):
return JSONResponse({"error": str(exc)}, status_code=400)
@app.exception_handler(media.MediaError)
async def media_error(_request: Request, exc: media.MediaError):
return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400)
def _context(clip_id: int) -> tuple[dict, dict]:
clip = get_clip(clip_id)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session:
raise editor.EditError("sessão do corte não existe mais")
return clip, session
def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]:
lo, hi = max(0.0, lo), min(hi, session["duration_s"])
if not 5 <= hi - lo <= editor.MAX_WINDOW_S:
raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação")
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi)
if not segs:
raise editor.EditError("não há gravação nessa janela")
if any(s["deleted"] for s in segs):
raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor")
return round(lo, 3), round(hi, 3)
def _words(session_id: int, lo: float, hi: float) -> list[Word]:
rows = db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
session_id, lo, hi)
return [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], []) if lo <= a <= hi]
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None
def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json"
return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None
@app.get("/v1/clips/{clip_id}/edit")
def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None):
"""Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA,
configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
view = clip_view(clip)
if row and row["project"]:
project, rev = row["project"], row["rev"]
ai_project = loads(row.get("ai_project_json"), None)
else:
project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo)
rev = 0
w_lo = project["source"]["lo"] if lo is None else lo
w_hi = project["source"]["hi"] if hi is None else hi
w_lo, w_hi = _check_window(session, w_lo, w_hi)
tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5))
chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)}
for m in tl["chat"] if w_lo <= m.t <= w_hi][:600]
per_s = [0] * int(w_hi - w_lo + 1)
for m in tl["chat"]:
if w_lo <= m.t <= w_hi:
per_s[int(m.t - w_lo)] += 1
loud = tl["loudness"][int(w_lo): int(w_hi) + 1]
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
return {
"clip": view, "project": project, "rev": rev, "saved": bool(row),
"origin": row["origin"] if row else "ai", "aiProject": ai_project,
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in _words(clip["session_id"], w_lo, w_hi)],
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
"audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi),
"waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S,
"judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured,
"limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S,
"previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S},
}
@app.put("/v1/clips/{clip_id}/edit")
def put_edit(clip_id: int, body: EditPut):
"""Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes)."""
clip, session = _context(clip_id)
project = validate_for(engine, clip, session, body.project)
ts = now()
with db.lock:
row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)
if row and body.rev != row["rev"]:
return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]},
status_code=409)
if row:
db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), ts, clip_id)
else:
ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False)
db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts)
rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"]
return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])}
@app.delete("/v1/clips/{clip_id}/edit", status_code=204)
def delete_edit(clip_id: int):
"""Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render)."""
get_clip(clip_id)
db.run("DELETE FROM edits WHERE clip_id = ?", clip_id)
@app.post("/v1/clips/{clip_id}/proxy")
def make_proxy(clip_id: int, body: WindowIn):
"""Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela."""
clip, session = _context(clip_id)
lo, hi = _check_window(session, body.lo, body.hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"proxy-{_window_key(lo, hi)}.mp4"
with _lock(f"proxy-{clip_id}"):
if not (folder / name).is_file():
t = time.monotonic()
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
_clean_old(folder, "proxy", name)
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word}
for w in _words(clip["session_id"], lo, hi)]}
@app.get("/v1/clips/{clip_id}/waveform")
def get_waveform(clip_id: int, lo: float, hi: float):
clip, session = _context(clip_id)
lo, hi = _check_window(session, lo, hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"waveform-{_window_key(lo, hi)}.json"
with _lock(f"wave-{clip_id}"):
peaks = _cached_wave(clip, lo, hi)
if peaks is None:
peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder)
folder.mkdir(parents=True, exist_ok=True)
(folder / name).write_text(json.dumps(peaks), encoding="utf-8")
_clean_old(folder, "waveform", name)
return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks}
@app.post("/v1/clips/{clip_id}/preview-render")
def preview_render(clip_id: int, body: PreviewRenderIn):
"""Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None)
if not data:
raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)")
project = validate_for(engine, clip, session, data)
total = editor.output_duration(project["cuts"])
a = min(body.fromS, max(0.0, total - 1))
b = min(total, a + body.durationS)
out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4"
segments = session_segments(engine, clip["session_id"])
base, credit = engine.intel.settings_for(session), engine.channel_label(session)
with _lock(f"preview-{clip_id}"):
t = time.monotonic()
# Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export.
cover = None
if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"):
cover = out.parent / "preview-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela
log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc)
cover = None
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
segments, project, base, credit, out, REPO_ROOT,
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover)
took = time.monotonic() - t
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
@app.post("/v1/clips/{clip_id}/export")
def export(clip_id: int):
"""Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
if not row or not row["project"]:
raise editor.EditError("nada para exportar: salve o projeto primeiro")
project = validate_for(engine, clip, session, row["project"])
start, end = editor.span(project)
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end)
if not segs or any(s["deleted"] for s in segs):
raise editor.EditError("os blocos gravados deste trecho já foram apagados")
words = editor.output_words(project)
ts = now()
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
engine.wake_clips.set()
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
@app.post("/v1/clips/{clip_id}/retranscribe")
def retranscribe(clip_id: int, body: RangeIn):
"""Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão."""
clip, session = _context(clip_id)
a, b = body.startS, min(body.endS, session["duration_s"])
if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S:
raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s")
if not engine.voice.configured:
raise editor.EditError("serviço de voz não instalado")
wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b,
edit_dir(engine, clip["session_id"], clip_id))
t = time.monotonic()
try:
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
"words": [{"s": round(w.start + a, 3), "e": round(w.end + a, 3), "w": w.word} for w in words]}
@app.post("/v1/clips/{clip_id}/tts")
def tts(clip_id: int, body: TtsIn):
"""Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-<corte>/tts-<hash>.wav."""
clip, _session = _context(clip_id)
voice = engine.voice
if not voice.configured:
raise editor.EditError("serviço de voz não instalado")
text = editor.CONTROL_RE.sub(" ", body.text).strip()
digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12]
folder = edit_dir(engine, clip["session_id"], clip_id)
out = folder / f"tts-{digest}.wav"
if not out.is_file():
try:
response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""},
json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice,
"params": {"speed": body.speed, "format": "wav"}})
except httpx.HTTPError as exc:
raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc
if response.status_code != 200:
try:
detail = response.json().get("error") or response.json().get("detail") or response.text
except ValueError:
detail = response.text
raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}")
folder.mkdir(parents=True, exist_ok=True)
out.write_bytes(response.content)
duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0
return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice}
@app.post("/v1/clips/{clip_id}/suggest")
def suggest(clip_id: int, body: SuggestIn):
"""IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom."""
clip, session = _context(clip_id)
if not engine.judge.enabled:
raise editor.EditError("IA desligada (página Clipador → Juiz)")
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None) or editor.default_project(
clip, [], session["duration_s"])
project = validate_for(engine, clip, session, data)
lo, hi = project["source"]["lo"], project["source"]["hi"]
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
words = [Word(w["s"], w["e"], w["w"]) for w in project["captions"]["words"]] or tl["words"]
view = clip_view(clip)
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
cfg = editor.effective_settings(engine.intel.settings_for(session), project)
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
_transcript(words, lo, hi), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
t = time.monotonic()
try:
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
except JudgeError as exc:
raise editor.EditError(f"IA: {exc}") from exc
# Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte.
return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1),
"model": engine.judge.describe().get("model")}
+721
View File
@@ -0,0 +1,721 @@
"""Render do projeto de edição (editor.py) com FFmpeg: legenda animada e textos em ASS, filtergraph com trechos,
layout por trecho, zoom (punch-in), narração/música/efeitos, proxy 480p, forma de onda e capa.
Regras herdadas do Clipador (gotchas 57/58/71): `-ss` ANTES do `-i`; maiúsculas só no texto (nunca nas tags);
cores `&H00BBGGRR&` na linha Style e `&HBBGGRR&` nas tags. Formato: o vídeo sai em `layout.frame_size` (1080×1920
ou 1920×1080) e os textos são contados no quadro lógico `layout.canvas_size` (no horizontal, 2560×1440). Subprocesso sem shell, argumentos em lista; no filtro
só entram números formatados aqui e nomes de arquivo relativos gerados por nós.
"""
from __future__ import annotations
import shutil
from array import array
from pathlib import Path
from . import layout, media, reframe
from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output
from .scoring import Word
from .subtitles import _escape, _ts, caption_blocks, clean_words
W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração
FPS = 30
PEAKS_PER_S = 50
COVER_BOX = "#E11D48" # mesma cor da caixa do gancho padrão
# ---------------------------------------------------------------- ASS (legenda animada + textos + barra)
def _wrap(text: str, size: int, width: int = W - 120) -> str:
"""Quebra manual (o cabeçalho usa WrapStyle 2 = sem quebra automática). Escapa cada pedaço."""
max_chars = max(6, int(width / (size * 0.58)))
lines, line = [], ""
for word in text.split():
if line and len(line) + 1 + len(word) > max_chars:
lines.append(line)
line = word
else:
line = f"{line} {word}".strip()
if line:
lines.append(line)
return "\\N".join(_escape(x) for x in lines[:4])
BANNER_MAX_LINES = 2
BANNER_SLIDE_MS = 240 # a tarja atravessa a tela
TEXT_SLIDE_MS = (90, 430) # o texto entra deslizando, borrado, e assenta nítido nesse intervalo
def _lines(text: str, size: int, width: int, char_w: float = 0.6) -> list[str]:
"""Quebra em linhas pela largura estimada (nunca no meio da palavra)."""
max_chars = max(4, int(width / (size * char_w)))
lines, line = [], ""
for word in text.split():
if line and len(line) + 1 + len(word) > max_chars:
lines.append(line)
line = word
else:
line = f"{line} {word}".strip()
if line:
lines.append(line)
return lines
def banner_layout(o: dict, canvas: tuple[int, int]) -> dict:
"""Geometria da tarja do gancho no quadro lógico: linhas (no máximo 2, sem cortar palavra: a fonte diminui até
caber), tamanho, topo e altura da faixa."""
cw, ch = canvas
text = o["text"].upper()
size = int(o["size"])
lines = _lines(text, size, int(cw * 0.9))
while len(lines) > BANNER_MAX_LINES and size > 24:
size = max(24, int(size * 0.9))
lines = _lines(text, size, int(cw * 0.9))
line_h = size * 1.18
pad = size * 0.42
height = int(round(len(lines) * line_h + 2 * pad))
cy = int(ch * o["y"])
top = max(0, min(ch - height, cy - height // 2))
return {"lines": lines, "size": size, "top": top, "height": height, "cy": top + height // 2}
def banner_events(o: dict, canvas: tuple[int, int]) -> list[tuple[int, str, str, tuple[float, float | None] | None]]:
"""Gancho em TARJA (referência do dono, 17/11/2026): faixa na largura toda, na cor `bg`, que atravessa a tela, e o
texto em maiúsculas (cor `color`, contorno preto grosso, fonte `font`) que entra deslizando com desfoque de
movimento e assenta nítido. Tudo em ASS (desenho \\p1, \\move e \\t com \\blur): sem filtro extra no FFmpeg.
Com contorno, o \\blur do libass desfoca só a borda e o preenchimento fica nítido (achado ao comparar com o modelo
do dono). Por isso, na ENTRADA (`slide`, até 430 ms) o texto vem em duas camadas: o preenchimento sem contorno, com
o desfoque animado, e o contorno, também borrado, que aparece junto. Do fim da entrada em diante entra o MESMO
evento assentado de antes (posição, quebra, tamanho, contorno), para a prévia do editor continuar batendo.
Devolve [(camada, estilo, texto ASS, janela)]; janela = None (o tempo todo do gancho) ou (início, fim) em segundos
relativos ao início do gancho (fim None = até o fim)."""
cw, _ = canvas
g = banner_layout(o, canvas)
bg = layout.ass_inline_color(o.get("bg") or layout.DEFAULTS["hook"]["bg"])
color = layout.ass_inline_color(o.get("color") or "#FFFFFF")
font = o.get("font") or layout.HOOK_FONT
slide = o.get("anim") == "slide"
out_fade = "\\fad(0,180)"
band_pos = (f"\\move({-cw},{g['top']},0,{g['top']},0,{BANNER_SLIDE_MS})" if slide else f"\\pos(0,{g['top']})")
band_anim = out_fade if slide else _anim(o.get("anim", "none")).replace("\\fscx70\\fscy70", "")
band = (f"{{\\an7{band_pos}\\p1\\bord0\\shad0\\1c{bg}{band_anim}}}"
f"m 0 0 l {cw} 0 {cw} {g['height']} 0 {g['height']}{{\\p0}}")
cx = cw // 2
a, b = TEXT_SLIDE_MS
border = max(3, int(round(g["size"] * 0.1)))
lines = "\\N".join(_escape(x) for x in g["lines"])
look = f"\\fn{font}\\fs{g['size']}\\1c{color}\\3c&H000000&\\4c&H000000&"
settled_tags = f"\\bord{border}\\shad{max(2, border // 2)}"
if not slide:
text = f"{{\\an5\\pos({cx},{g['cy']}){_anim(o.get('anim', 'none'))}{look}{settled_tags}}}{lines}"
return [(2, "Bar", band, None), (4, "Text", text, None)]
move = f"\\move({cx + int(cw * 0.55)},{g['cy']},{cx},{g['cy']},{a},{b})"
entry = (0.0, b / 1000)
# Preenchimento sem contorno: o desfoque pega a letra inteira (como no modelo).
fill = f"{{\\an5{move}\\blur18\\t({a},{b},\\blur0){look}\\bord0\\shad0}}{lines}"
# Contorno (e sombra) sem preenchimento, borrado e surgindo junto; por baixo do preenchimento.
outline = (f"{{\\an5{move}\\1a&HFF&\\3a&HC0&\\4a&HFF&\\blur18\\t({a},{b},\\blur0\\3a&H00&\\4a&H00&)"
f"{look}{settled_tags}}}{lines}")
# Assentado: o mesmo evento de antes, parado na posição final (a saída com \\fad continua no fim do gancho).
settled = f"{{\\an5\\pos({cx},{g['cy']}){out_fade}{look}{settled_tags}}}{lines}"
return [(2, "Bar", band, None), (5, "Text", fill, entry), (4, "Text", outline, entry), (4, "Text", settled, (b / 1000, None))]
def _anim(kind: str) -> str:
if kind == "pop":
return "\\fad(80,120)\\fscx70\\fscy70\\t(0,140,\\fscx108\\fscy108)\\t(140,220,\\fscx100\\fscy100)"
if kind == "fade":
return "\\fad(250,250)"
if kind == "slide":
return "\\blur14\\t(0,320,\\blur0)\\fad(0,180)"
return ""
CHAT_HOLD_S = 9.0 # quanto uma mensagem fica na tela se não chegar outra
CHAT_COLORS = ("#FF7A7A", "#7AD7FF", "#9BE77A", "#FFD36B", "#C9A2FF", "#FF9FD6")
def chat_events(project: dict, chat: list | None, total: float,
canvas: tuple[int, int] = (W, H)) -> list[tuple[float, float, str]]:
"""Chat da live na tela: (início, fim, texto ASS) em tempo de saída. A cada mensagem nova o bloco mostra as
últimas `lines` (uma linha por mensagem, cortada na largura do bloco), ancorado pela base em (x, y).
`canvas` = quadro lógico do ASS (largura, altura)."""
cw, ch = canvas
cfg = project.get("chat") or {}
if not cfg.get("enabled") or not chat:
return []
cuts = project["cuts"]
msgs = []
for m in chat:
t_out, inside = to_output(m.t, cuts)
if inside and m.text.strip():
msgs.append((t_out, m.user, " ".join(m.text.split())))
msgs.sort(key=lambda x: x[0])
max_chars = max(8, int(cw * cfg["width"] / (cfg["size"] * 0.54)))
pos = f"\\an1\\pos({int(cw * cfg['x'])},{int(ch * cfg['y'])})"
def line(user: str, text: str) -> str:
name = user[:16] if cfg["showUser"] and user else ""
room = max_chars - (len(name) + 2 if name else 0)
body = text if len(text) <= room else text[: max(1, room - 1)].rstrip() + "…"
if not name:
return _escape(body)
color = layout.ass_inline_color(CHAT_COLORS[sum(map(ord, user)) % len(CHAT_COLORS)])
return f"{{\\1c{color}}}{_escape(name)}:{{\\1c&HFFFFFF&}} {_escape(body)}"
out = []
for i, (t, _user, _text) in enumerate(msgs):
nxt = msgs[i + 1][0] if i + 1 < len(msgs) else total
end = min(total, nxt, t + CHAT_HOLD_S)
if end - t < 0.03:
continue
shown = [m for m in msgs[max(0, i - cfg["lines"] + 1): i + 1] if t - m[0] <= CHAT_HOLD_S * 2]
out.append((t, end, f"{{{pos}}}" + "\\N".join(line(u, x) for _, u, x in shown)))
return out
def build_project_ass(project: dict, cfg: dict, credit: str, t0: float = 0.0, t1: float | None = None,
chat: list | None = None) -> str:
"""ASS do projeto em tempo de saída. [t0, t1] recorta a janela (prévia real de poucos segundos).
`chat` = mensagens da sessão (ChatMessage) para o bloco de chat na tela, se o projeto pedir."""
cap, cred = cfg["caption"], cfg["credit"]
total = output_duration(project["cuts"])
t1 = total if t1 is None else min(t1, total)
length = t1 - t0
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
cw, ch = layout.canvas_size(cfg)
font, size, ow = cap["font"], cap["size"], cap["outlineWidth"]
header = f"""[Script Info]
ScriptType: v4.00+
PlayResX: {cw}
PlayResY: {ch}
WrapStyle: 2
ScaledBorderAndShadow: yes
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Caption,{font},{size},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
Style: Karaoke,{font},{size},{high},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
Style: Text,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,2,5,60,60,0,1
Style: Box,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H004D1DE1,&H00000000,-1,0,0,0,100,100,0,0,3,18,0,5,60,60,0,1
Style: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1
Style: Chat,Arial,{(project.get('chat') or {}).get('size', 34)},&H00FFFFFF,&H00FFFFFF,&H78000000,&H00000000,-1,0,0,0,100,100,0,0,3,5,0,1,0,0,0,1
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""
lines: list[str] = []
def event(layer: int, s: float, e: float, style: str, text: str) -> None:
s, e = max(s, t0) - t0, min(e, t1) - t0
if e - s > 0.01:
lines.append(f"Dialogue: {layer},{_ts(s)},{_ts(e)},{style},,0,0,0,,{text}")
if credit and cred["enabled"]:
event(1, 0, total, "Credit", _escape(credit))
if cap["enabled"]:
preset = project["captions"]["preset"]
emph = emphasized(project)
emph_c = layout.ass_inline_color(project["captions"]["emphColor"])
hi_c, base_c = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
pos = f"\\pos({cw // 2},{layout.caption_y(cfg)})"
# Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos
# ORIGINAIS. Depois as palavras são saneadas (ordem, sem sobreposição, duração mínima) — `clean_words` devolve
# a mesma quantidade, na mesma ordem — e os blocos abaixo nunca ficam dois na tela ao mesmo tempo.
raw = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end))
raw_emph = _match_emphasis(raw, project, emph)
words = clean_words(raw)
def txt(w: Word) -> str:
return _escape(w.word.upper() if cap["uppercase"] else w.word)
def key(w: Word) -> tuple[float, str]:
return round(w.start, 3), w.word # depois de clean_words, cada início é único
emph_keys = {key(words[i]) for i in raw_emph}
for group, g_end in caption_blocks(words, cap["maxWords"]):
if preset == "karaoke":
parts, cursor = [], group[0].start
for w in group:
gap = max(0, int(round((w.start - cursor) * 100)))
dur = max(1, int(round((w.end - w.start) * 100)))
color = f"\\1c{emph_c}" if key(w) in emph_keys else ""
parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}")
cursor = w.end
event(0, group[0].start, g_end, "Karaoke", f"{{{pos}}}" + " ".join(parts))
continue
for i, word in enumerate(group):
start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start:
continue
if preset == "single":
color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_c)
event(0, start, end, "Caption", f"{{{pos}{_anim('pop')}\\c{color}}}{txt(word)}")
continue
parts = []
for j, w in enumerate(group):
is_emph = key(w) in emph_keys
if preset == "minimal":
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
elif j == i:
color = emph_c if is_emph else hi_c
pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else ""
parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_c}\\fscx100\\fscy100}}")
else:
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else ""
event(0, start, end, "Caption", f"{{{pos}{intro}}}" + " ".join(parts))
cuts = project["cuts"]
for o in project["overlays"]:
if o["kind"] in ("zoom", "inset"):
continue
if o["kind"] == "hook":
s, e = o["start"], min(o["end"], total)
else:
s, e = to_output(o["start"], cuts)[0], to_output(o["end"], cuts)[0]
if o.get("style") == "banner":
for layer, style, text, window in banner_events(o, (cw, ch)):
a0, b0 = (s, e) if window is None else (s + window[0], e if window[1] is None else min(e, s + window[1]))
event(layer, a0, b0, style, text)
continue
style = "Box" if o["box"] else "Text"
x, y = int(cw * o.get("x", 0.5)), int(ch * o["y"])
if o["anim"] == "slide": # entra deslizando da direita, borrado, e assenta nítido
a, b = TEXT_SLIDE_MS
pos = f"\\move({x + int(cw * 0.5)},{y},{x},{y},{a},{b})"
else:
pos = f"\\pos({x},{y})"
tags = f"{pos}\\fs{o['size']}\\1c{layout.ass_inline_color(o['color'])}"
if o.get("font"):
tags += f"\\fn{o['font']}"
if o["box"]:
tags += f"\\3c{layout.ass_inline_color(o['box'])}"
event(2, s, e, style, f"{{{tags}{_anim(o['anim'])}}}{_wrap(o['text'], o['size'], cw - 120)}")
for s, e, text in chat_events(project, chat, total, (cw, ch)):
event(2, s, e, "Chat", text)
prog = project["progress"]
if prog["enabled"] and total > 0:
h = prog["height"]
a, b = 100 * t0 / total, 100 * t1 / total
draw = f"m 0 0 l {cw} 0 {cw} {h} 0 {h}"
lines.append(f"Dialogue: 3,{_ts(0)},{_ts(length)},Bar,,0,0,0,,"
f"{{\\an7\\pos(0,{ch - h})\\p1\\1c{layout.ass_inline_color(prog['color'])}\\fscx{a:.2f}"
f"\\t(0,{int(length * 1000)},\\fscx{b:.2f})}}{draw}{{\\p0}}")
return header + "\n".join(lines) + "\n"
def _match_emphasis(words: list[Word], project: dict, emph: set[tuple[float, str]]) -> set[int]:
"""Índices (em `words`, tempo de saída) das palavras marcadas com ênfase no projeto (tempo da sessão)."""
if not emph:
return set()
marked = [w for w in project["captions"]["words"] if not w.get("hidden") and w["w"].strip()]
out_times = {}
for w in marked:
if (round(w["s"], 3), w["w"]) in emph:
out_times[(round(to_output((w["s"] + w["e"]) / 2, project["cuts"])[0], 2), w["w"])] = True
result = set()
for i, w in enumerate(words):
mid = round((w.start + w.end) / 2, 2)
if any(abs(mid - t) <= 0.06 and text == w.word for (t, text) in out_times):
result.add(i)
return result
# ---------------------------------------------------------------- filtergraph
def zoom_filter(project: dict, t0: float = 0.0, size: tuple[int, int] = (W, H)) -> str | None:
"""zoompan com escala por expressão do tempo de saída (`it` + t0). Rampa suave na entrada e na saída.
`size` = tamanho do vídeo de saída (formato do corte)."""
zooms = [o for o in project["overlays"] if o["kind"] == "zoom"]
if not zooms:
return None
cuts = project["cuts"]
z_terms, x_terms, y_terms = [], [], []
for z in zooms:
a, b = to_output(z["start"], cuts)[0], to_output(z["end"], cuts)[0]
if b - a < 0.1:
continue
r = max(0.001, min(z["ramp"], (b - a) / 2))
env = f"clip((T-{a:.3f})/{r:.3f},0,1)*clip(({b:.3f}-T)/{r:.3f},0,1)"
z_terms.append(f"{z['scale'] - 1:.4f}*{env}")
x_terms.append(f"{z['x'] - 0.5:.4f}*{env}")
y_terms.append(f"{z['y'] - 0.5:.4f}*{env}")
if not z_terms:
return None
t = f"(it+{t0:.3f})"
zexpr = ("1+" + "+".join(z_terms)).replace("T", t)
fx = ("0.5+" + "+".join(x_terms)).replace("T", t)
fy = ("0.5+" + "+".join(y_terms)).replace("T", t)
# x/y = canto do recorte; o foco (fx, fy) fica no centro do recorte, preso dentro do quadro.
return (f"zoompan=z='{zexpr}':x='max(0,min(iw-iw/zoom,iw*({fx})-iw/zoom/2))'"
f":y='max(0,min(ih-ih/zoom,ih*({fy})-ih/zoom/2))':d=1:s={size[0]}x{size[1]}:fps={FPS}")
class AudioInput:
"""Entrada de áudio extra (narração, música, efeito): arquivo + onde entra (tempo de saída) + volume."""
def __init__(self, file: Path, at: float, volume: float, kind: str, trim_start: float = 0.0, duck: float = 1.0,
length: float = 0.0):
self.file, self.at, self.volume, self.kind = file, at, volume, kind
self.trim_start, self.duck, self.length = trim_start, duck, length
COVER_INTRO_S = 2 / FPS # capa nos 2 primeiros quadros (as redes usam o quadro 0 como miniatura padrão)
def build_filter(project: dict, cfg: dict, ps: list[Piece], in0: float, ass_name: str | None, extras: list[AudioInput],
has_audio: bool = True, t0: float = 0.0, original_volume: float = 1.0, cover_input: int | None = None,
ass_text: str | None = None, insets: list | None = None,
inset_inputs: list[dict] | None = None) -> str:
"""filter_complex completo. Entrada 0 = blocos concatenados começando em `in0` (tempo da sessão); entradas 1..N
= `extras` na ordem; `cover_input` = índice da entrada com a imagem da capa (vai por cima dos 2 primeiros
quadros); `ass_text` = conteúdo do ASS (com fonte empacotada, o filtro ganha `fontsdir`). `insets` =
`reframe.InsetPlan` das camadas inseridas e `inset_inputs` = índices das entradas PNG de cada uma. O
reenquadramento (`project.reframe`) entra por trecho no layout. Sem os dois, o grafo é o mesmo de antes.
Saídas [v] e [a]."""
n = len(ps)
out_len = sum(p.length for p in ps)
g: list[str] = []
g.append(f"[0:v]split={n}" + "".join(f"[sv{i}]" for i in range(n)) if n > 1 else "[0:v]null[sv0]")
if has_audio:
g.append(f"[0:a]asplit={n}" + "".join(f"[sa{i}]" for i in range(n)) if n > 1 else "[0:a]anull[sa0]")
for i, p in enumerate(ps):
a, b = p.start - in0, p.end - in0
g.append(f"[sv{i}]trim=start={a:.3f}:end={b:.3f},setpts=PTS-STARTPTS,fps={FPS}[tv{i}]")
src = f"tv{i}"
if insets: # as camadas recortam o quadro ORIGINAL: uma cópia do trecho vai para elas
g.append(f"[tv{i}]split=2[tl{i}][tr{i}]")
src = f"tl{i}"
g.append(layout.layout_chain(cfg, src, f"pv{i}", ",setsar=1", suffix=f"_{i}", mode=p.mode,
reframe=reframe.piece_reframe(project, p.start, p.end)))
fade = min(0.02, p.length / 4)
if has_audio:
g.append(f"[sa{i}]atrim=start={a:.3f}:end={b:.3f},asetpts=PTS-STARTPTS,"
f"aformat=sample_rates=48000:channel_layouts=stereo,"
f"afade=t=in:d={fade:.3f},afade=t=out:st={max(0.0, p.length - fade):.3f}:d={fade:.3f}"
+ (",volume=0" if p.muted else "") + f"[pa{i}]")
else:
g.append(f"aevalsrc=0|0:s=48000:d={p.length:.3f},aformat=channel_layouts=stereo[pa{i}]")
g.append("".join(f"[pv{i}][pa{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=1[vcat][acat]")
fw, fh = layout.frame_size(cfg)
zoom = zoom_filter(project, t0, (fw, fh))
last = "[v]" if cover_input is None else "[vbase]"
head = "[vcat]"
if insets:
# Vídeo (com zoom) → camadas inseridas (na ordem do projeto) → texto (ASS) por cima de tudo.
g.append("".join(f"[tr{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=0[vraw]" if n > 1 else "[tr0]null[vraw]")
g.append(f"[vcat]{zoom or 'null'}[vzoom]")
g += reframe.inset_graph(insets, inset_inputs or [], "vzoom", "vraw", t0, (fw, fh), "vins")
head, zoom = "[vins]", None
vchain = head + (f"{zoom}," if zoom else "") + (f"{layout.ass_filter(ass_name, ass_text)}," if ass_name else "") + f"fps={FPS},format=yuv420p{last}"
g.append(vchain)
if cover_input is not None:
g.append(f"[{cover_input}:v]scale={fw}:{fh},setsar=1,format=yuv420p[cv]")
g.append(f"[vbase][cv]overlay=enable='lt(t,{COVER_INTRO_S:.4f})':eof_action=pass,format=yuv420p[v]")
# Áudio: original (com volume e abaixado sob a narração) + narração + efeitos; música por baixo com ducking.
narr = [(k, x) for k, x in enumerate(extras, start=1) if x.kind == "narration"]
vol_expr = f"{original_volume:.3f}"
for _, x in narr:
end = x.at + (x.length or 0)
if x.duck < 1 and x.length:
vol_expr = f"{vol_expr}*if(between(t,{x.at:.3f},{end:.3f}),{x.duck:.3f},1)"
g.append(f"[acat]volume='{vol_expr}':eval=frame[aorig]")
voice_labels = ["[aorig]"]
music_label = None
for k, x in enumerate(extras, start=1):
chain = f"[{k}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo"
if x.trim_start > 0:
chain += f",atrim=start={x.trim_start:.3f},asetpts=PTS-STARTPTS"
chain += f",volume={x.volume:.3f}"
if x.kind == "music":
g.append(chain + f",atrim=end={out_len:.3f}[m{k}]")
music_label = f"[m{k}]"
continue
delay = int(round(max(0.0, x.at) * 1000))
g.append(chain + f",adelay=delays={delay}:all=1[x{k}]")
voice_labels.append(f"[x{k}]")
if len(voice_labels) > 1:
g.append("".join(voice_labels) + f"amix=inputs={len(voice_labels)}:duration=first:normalize=0[voice]")
else:
g.append("[aorig]anull[voice]")
if music_label:
music = next(x for x in extras if x.kind == "music")
if music.duck < 1: # duck guardado como 0 = sem ducking; < 1 = abaixa sob a voz
g.append("[voice]asplit=2[voice1][side]")
g.append(f"{music_label}[side]sidechaincompress=threshold=0.03:ratio=8:attack=20:release=350[mduck]")
g.append("[voice1][mduck]amix=inputs=2:duration=first:normalize=0[a]")
else:
g.append(f"[voice]{music_label}amix=inputs=2:duration=first:normalize=0[a]")
else:
g.append("[voice]anull[a]")
return ";".join(g)
# ---------------------------------------------------------------- execução
def _segments_for(segments: list[tuple[Path, float, float]], a: float, b: float) -> list[tuple[Path, float, float]]:
return [s for s in segments if s[2] > a and s[1] < b]
# ---------------------------------------------------------------- blocos de resolução/codec diferentes
# Uma retomada pode gravar em outra qualidade (ou o streamer muda a resolução da fonte). Medido (17/11/2026, blocos
# reais 720p60 + 1080p60 do skipnho): o concat demuxer + filter_complex corta o VÍDEO na emenda, sem erro — corte de
# 35 s saiu com 20 s de vídeo (troca de tamanho: o FFmpeg reinicia o grafo) ou 15 s (H.264 → HEVC). Nesse caso (e só
# nele) os blocos do trecho viram um intermediário uniforme: maior tamanho do trecho, 30 qps, quadro-chave a cada
# 0,5 s. Trecho com blocos iguais (o normal) segue pelo caminho de sempre, idêntico.
_STREAM_CACHE: dict[tuple[str, int, int], tuple[str, int, int, bool] | None] = {}
def _stream_key(ffprobe: str, file: Path) -> tuple[str, int, int, bool] | None:
"""(codec, largura, altura, tem áudio) do bloco, em cache pelo arquivo (caminho, tamanho, data)."""
try:
st = file.stat()
except OSError:
return None
key = (str(file), st.st_size, int(st.st_mtime))
if key not in _STREAM_CACHE:
if len(_STREAM_CACHE) > 4000:
_STREAM_CACHE.clear()
try:
out = media.run([ffprobe, "-v", "error", "-show_entries", "stream=codec_type,codec_name,width,height",
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace")
except media.MediaError:
_STREAM_CACHE[key] = None
return None
video, audio = None, False
for line in out.splitlines():
parts = [x.strip() for x in line.split(",")]
if "video" in parts and video is None:
nums = [int(x) for x in parts if x.isdigit()]
codec = next((x for x in parts if x and not x.isdigit() and x != "video"), "")
video = (codec, nums[0], nums[1]) if len(nums) >= 2 else None
elif "audio" in parts:
audio = True
_STREAM_CACHE[key] = (*video, audio) if video else None
return _STREAM_CACHE[key]
def _ffprobe_near(ffmpeg: str) -> str | None:
"""ffprobe ao lado do ffmpeg (mesma instalação) ou no PATH."""
sibling = Path(ffmpeg).with_name("ffprobe" + Path(ffmpeg).suffix)
return str(sibling) if sibling.is_file() else shutil.which("ffprobe")
def uniform_segments(ffmpeg: str, ffprobe: str | None, segs: list[tuple[Path, float, float]], work: Path,
stem: str) -> tuple[list[tuple[Path, float, float]], Path | None]:
"""Blocos do trecho num formato só. Devolve (blocos, intermediário criado ou None); quem chama apaga o arquivo."""
if not ffprobe or len(segs) < 2:
return segs, None
keys = [_stream_key(ffprobe, f) for f, _, _ in segs]
if any(k is None for k in keys) or len({k[:3] for k in keys}) == 1: # type: ignore[index]
return segs, None
w, h = max(((k[1], k[2]) for k in keys), key=lambda size: size[1]) # type: ignore[index]
out = work / f"{stem}.uniform.mkv"
args: list[str] = [ffmpeg, "-y", "-v", "error"]
graph: list[str] = []
for i, ((file, a, b), k) in enumerate(zip(segs, keys)):
args += ["-i", str(file)]
graph.append(f"[{i}:v]scale={w}:{h}:force_original_aspect_ratio=decrease,pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,"
f"setsar=1,fps={FPS},format=yuv420p[v{i}]")
graph.append(f"[{i}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo[a{i}]" if k[3] # type: ignore[index]
else f"aevalsrc=0|0:s=48000:d={b - a:.3f}[a{i}]")
graph.append("".join(f"[v{i}][a{i}]" for i in range(len(segs))) + f"concat=n={len(segs)}:v=1:a=1[v][a]")
media.run([*args, "-filter_complex", ";".join(graph), "-map", "[v]", "-map", "[a]", "-c:v", "libx264",
"-preset", "ultrafast", "-crf", "14", "-g", "15", "-c:a", "aac", "-b:a", "256k", str(out)], timeout=900)
return [(out, segs[0][1], segs[-1][2])], out
def _concat_input(work: Path, stem: str, segs: list[tuple[Path, float, float]], start: float, length: float) -> tuple[list[str], Path]:
concat = work / f"{stem}.concat.txt"
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _, _ in segs), encoding="utf-8")
offset = max(0.0, start - segs[0][1])
# -ss ANTES do -i (gotcha 57): os quadros chegam ao filtro com tempo 0 = `start`.
return ["-ss", f"{offset:.3f}", "-f", "concat", "-safe", "0", "-i", concat.name, "-t", f"{length:.3f}"], concat
def has_audio_stream(ffprobe: str | None, file: Path) -> bool:
if not ffprobe:
return True
try:
out = media.run([ffprobe, "-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0",
str(file)], 30)
except media.MediaError:
return True
return bool(out.strip())
def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segments: list[tuple[Path, float, float]],
project: dict, base_cfg: dict, credit: str, out_file: Path, repo_root: Path,
out_range: tuple[float, float] | None = None, timeout: float = 900, chat: list | None = None,
cover_file: Path | None = None) -> None:
"""Renderiza o projeto (ou só a saída [a, b] para a prévia real). `segments` = (arquivo, início, fim) da sessão.
`chat` = mensagens da sessão (para o chat na tela); `cover_file` = capa já renderizada, posta nos 2 primeiros
quadros quando o projeto pede (`cover.atStart`)."""
cfg = effective_settings(base_cfg, project)
total = output_duration(project["cuts"])
t0, t1 = out_range if out_range else (0.0, total)
ps = slice_pieces(project["cuts"], t0, t1) if out_range else pieces(project["cuts"])
if not ps:
raise media.MediaError("o trecho pedido está fora do corte")
in0, in1 = ps[0].start, ps[-1].end
segs = _segments_for(segments, in0, in1)
if not segs or segs[0][1] > in0 + 0.5 or segs[-1][2] < in1 - 0.5:
raise media.MediaError("os blocos gravados deste trecho não estão mais disponíveis")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
stem = out_file.stem
segs, uniform = uniform_segments(ffmpeg, ffprobe, segs, work, stem) # emenda de resolução/codec (retomada)
ass_file = work / f"{stem}.ass"
ass_text = build_project_ass(project, cfg, credit, t0, t1, chat)
ass_file.write_text(ass_text, encoding="utf-8")
input0, concat = _concat_input(work, stem, segs, in0, in1 - in0)
extras: list[AudioInput] = []
for n in project["audio"]["narration"]:
at = to_output(n["at"], project["cuts"])[0] - t0
if at + (n["durationS"] or 60) <= 0 or at >= t1 - t0:
continue
extras.append(AudioInput(repo_root / n["file"], max(0.0, at), n["volume"], "narration",
trim_start=max(0.0, -at), duck=n["duck"], length=n["durationS"]))
for x in project["audio"]["sfx"]:
at = to_output(x["at"], project["cuts"])[0] - t0
if 0 <= at < t1 - t0:
extras.append(AudioInput(repo_root / x["file"], at, x["volume"], "sfx"))
music = project["audio"]["music"]
if music:
extras.append(AudioInput(repo_root / music["file"], 0.0, music["volume"], "music", trim_start=t0,
duck=0.5 if music["duck"] else 1.0))
extra_args: list[str] = []
for x in extras:
extra_args += (["-stream_loop", "-1"] if x.kind == "music" else []) + ["-i", str(x.file)]
cover_input = None
if cover_file and cover_file.is_file() and project["cover"].get("atStart") and t0 <= 0.001:
cover_input = len(extras) + 1
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", "1", "-i", str(cover_file)]
# Camadas inseridas: tamanhos pela proporção do vídeo original e PNGs de máscara/borda/sombra, em loop.
plans, inset_inputs, helper_files = [], [], []
if any(o["kind"] == "inset" for o in project["overlays"]):
src_size = media.probe_size(ffprobe, segs[0][0]) if ffprobe else (1280, 720)
plans = reframe.plan_insets(project, lambda t: to_output(t, project["cuts"])[0], t0, t1,
layout.frame_size(cfg), layout.canvas_size(cfg)[0], src_size, work, stem)
next_input = len(extras) + 1 + (1 if cover_input is not None else 0)
for plan in plans:
idx = {}
for key, file in (("mask", plan.mask_file), ("decor", plan.decor_file)):
if file is None:
idx[key] = None
continue
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", f"{t1 - t0 + 1:.3f}", "-i", file.name]
idx[key] = next_input
next_input += 1
helper_files.append(file)
inset_inputs.append(idx)
graph = build_filter(project, cfg, ps, in0, ass_file.name, extras, has_audio_stream(ffprobe, segs[0][0]), t0,
project["audio"]["volume"], cover_input, ass_text, plans or None, inset_inputs)
tmp = work / f"{stem}.tmp.mp4"
graph_file = work / f"{stem}.graph.txt"
graph_args = ["-filter_complex", graph]
if len(graph) > 20000: # muitos keyframes: o grafo vai por arquivo (linha de comando do Windows tem limite)
graph_file.write_text(graph, encoding="utf-8")
graph_args = ["-/filter_complex", graph_file.name]
try:
media.run([ffmpeg, "-y", "-v", "error", *input0, *extra_args, *graph_args,
"-map", "[v]", "-map", "[a]", *encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000",
"-t", f"{t1 - t0:.3f}", "-movflags", "+faststart", tmp.name], timeout=timeout, cwd=work)
tmp.replace(out_file)
finally:
for f in (ass_file, concat, tmp, graph_file, *helper_files, *([uniform] if uniform else [])):
f.unlink(missing_ok=True)
def make_proxy(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, out_file: Path) -> None:
"""Vídeo leve (480p, 30 fps, quadro-chave a cada 0,5 s para pular rápido) da janela [lo, hi] para o navegador."""
segs = _segments_for(segments, lo, hi)
if not segs:
raise media.MediaError("nenhum bloco gravado cobre essa janela")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
segs, uniform = uniform_segments(ffmpeg, _ffprobe_near(ffmpeg), segs, work, out_file.stem)
input0, concat = _concat_input(work, out_file.stem, segs, lo, hi - lo)
tmp = work / f"{out_file.stem}.tmp.mp4"
try:
# fps ANTES do scale: com a fonte em 60 qps (1080p60/1440p60) metade dos quadros nem é escalada.
media.run([ffmpeg, "-y", "-v", "error", *input0, "-vf", f"fps={FPS},scale=-2:480", "-c:v", "libx264",
"-preset", "veryfast", "-crf", "30", "-g", "15", "-keyint_min", "15", "-pix_fmt", "yuv420p",
"-c:a", "aac", "-b:a", "96k", "-ac", "2", "-movflags", "+faststart", tmp.name], timeout=600, cwd=work)
tmp.replace(out_file)
finally:
concat.unlink(missing_ok=True)
tmp.unlink(missing_ok=True)
if uniform:
uniform.unlink(missing_ok=True)
def waveform(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, work: Path) -> list[float]:
"""Picos de volume (0–1) da janela, `PEAKS_PER_S` por segundo, para desenhar a forma de onda."""
segs = _segments_for(segments, lo, hi)
if not segs:
return []
work.mkdir(parents=True, exist_ok=True)
rate = 4000
input0, concat = _concat_input(work, "waveform", segs, lo, hi - lo)
try:
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(rate), "-f", "s16le", "-"], 300, cwd=work)
finally:
concat.unlink(missing_ok=True)
samples = array("h")
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
step = rate // PEAKS_PER_S
peaks = [max((abs(v) for v in samples[i: i + step]), default=0) / 32768 for i in range(0, len(samples), step)]
top = max(peaks, default=0) or 1
return [round(min(1.0, (p / top) ** 0.7), 3) for p in peaks]
def extract_wav(ffmpeg: str, segments: list[tuple[Path, float, float]], a: float, b: float, work: Path) -> bytes:
"""Áudio mono 16 kHz do trecho [a, b] da sessão, em WAV (para re-transcrever)."""
segs = _segments_for(segments, a, b)
if not segs:
raise media.MediaError("nenhum bloco gravado cobre esse trecho")
work.mkdir(parents=True, exist_ok=True)
input0, concat = _concat_input(work, "retranscribe", segs, a, b - a)
try:
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(media.SAMPLE_RATE), "-f", "s16le", "-"],
120, cwd=work)
finally:
concat.unlink(missing_ok=True)
return media.to_wav(pcm)
def render_cover(ffmpeg: str, segments: list[tuple[Path, float, float]], project: dict, base_cfg: dict, credit: str,
out_file: Path) -> Path:
"""Capa no formato do corte (1080×1920 ou 1920×1080; etapa 7): quadro do instante escolhido no layout do corte +
texto curto grande no centro."""
cfg = effective_settings(base_cfg, project)
cover = project["cover"]
mode = next((p.mode for p in pieces(project["cuts"]) if p.start <= cover["t"] <= p.end), None)
if mode and mode != "auto":
cfg["layout"]["mode"] = mode
work = out_file.parent
# Quadro intermediário em PNG: o mjpeg do FFmpeg 7.1 recusa yuv420p marcado como faixa "tv" (blocos do libx264).
frame = media.grab_frame(ffmpeg, segments, cover["t"], work / f"{out_file.stem}-src.png", width=0)
cap = {**cfg, "caption": {**cfg["caption"], "enabled": False}}
ass = build_project_ass({**project, "captions": {**project["captions"], "enabled": False}, "overlays": [],
"progress": {**project["progress"], "enabled": False}}, cap, credit, 0, 1)
if cover["text"]:
cw, ch = layout.canvas_size(cfg)
line = (f"Dialogue: 4,{_ts(0)},{_ts(1)},Box,,0,0,0,,{{\\pos({cw // 2},{int(ch * 0.5)})\\fs110\\3c{layout.ass_inline_color(COVER_BOX)}}}"
f"{_wrap(cover['text'].upper(), 110, cw - 120)}")
ass = ass + line + "\n"
try:
media.preview_still(ffmpeg, frame, cap, ass, out_file, reframe.static_reframe(project, cover["t"]))
finally:
frame.unlink(missing_ok=True)
return out_file
+158
View File
@@ -0,0 +1,158 @@
"""Emotes do chat: reconhecer, contar por canal e APRENDER quais indicam um bom momento.
Por quê: chat pequeno (3–5 pessoas) e público que reage com emote em vez de texto ("kkkk") faziam a heurística
não ver nada. Agora cada mensagem leva a lista de emotes, e cada canal tem um peso aprendido por emote.
De onde vêm:
- Twitch nativos: tag `emotes` do IRC (CAP twitch.tv/tags) com as posições na mensagem;
- 7TV, BTTV e FFZ do canal + globais: APIs públicas por `room-id` (o id do canal vem nas tags do IRC);
- emojis Unicode.
Cada fonte externa é opcional: a que falhar (404, lenta) é ignorada e tentada de novo na próxima hora.
Aprendizado (por canal, tabela `emotes`):
- `uses`: quantas vezes apareceu (contagem simples, para o painel);
- `weight`: sobe quando o emote aparece na reação de um corte aprovado/bem avaliado, desce quando o corte é
rejeitado/descartado. Entra no peso da mensagem na pontuação do chat.
"""
from __future__ import annotations
import logging
import re
import threading
import time
import httpx
log = logging.getLogger("cenaforge_clipper.emotes")
CATALOG_TTL_S = 3600
LEARN_UP, LEARN_DOWN = 0.3, 0.15
WEIGHT_MIN, WEIGHT_MAX = -1.0, 3.0
BASE_EMOTE_BONUS = 0.4 # mensagem com emote já é reação
BONUS_MIN, BONUS_MAX = -0.5, 3.0
# Faixas comuns de emoji (pictogramas, símbolos, bandeiras, rostos). Não é exaustivo, só precisa pegar os de reação.
EMOJI_RE = re.compile("[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U0001F1E6-\U0001F1FF]")
GLOBAL_URLS = {
"7tv": "https://7tv.io/v3/emote-sets/global",
"bttv": "https://api.betterttv.net/3/cached/emotes/global",
"ffz": "https://api.frankerfacez.com/v1/set/global",
}
CHANNEL_URLS = {
"7tv": "https://7tv.io/v3/users/twitch/{room}",
"bttv": "https://api.betterttv.net/3/cached/users/twitch/{room}",
"ffz": "https://api.frankerfacez.com/v1/room/id/{room}",
}
def parse_twitch_tag(tag_value: str, text: str) -> list[str]:
"""`emotes=25:0-4,12-16/1902:6-10` → nomes recortados do texto (posições em code points, como o str do Python)."""
names: list[str] = []
if not tag_value:
return names
for part in tag_value.split("/"):
if ":" not in part:
continue
_id, spans = part.split(":", 1)
for span in spans.split(","):
try:
a, b = (int(x) for x in span.split("-"))
except ValueError:
continue
if 0 <= a <= b < len(text):
names.append(text[a: b + 1])
return names
def _names_from(source: str, data) -> list[str]:
if source == "7tv":
emotes = data.get("emotes") or (data.get("emote_set") or {}).get("emotes") or []
return [e["name"] for e in emotes if isinstance(e, dict) and e.get("name")]
if source == "bttv":
items = data if isinstance(data, list) else (data.get("channelEmotes", []) + data.get("sharedEmotes", []))
return [e["code"] for e in items if isinstance(e, dict) and e.get("code")]
if source == "ffz":
return [e["name"] for s in (data.get("sets") or {}).values() for e in s.get("emoticons", []) if e.get("name")]
return []
class EmoteCatalog:
"""Nomes de emotes de terceiros (globais + do canal), com cache de 1 h por canal."""
def __init__(self, fetch=None):
self._fetch = fetch or self._http_json
self._lock = threading.Lock()
self._global: dict[str, str] = {}
self._global_at = 0.0
self._channels: dict[str, tuple[float, dict[str, str]]] = {}
@staticmethod
def _http_json(url: str):
response = httpx.get(url, timeout=20, headers={"User-Agent": "CenaForge-Clipador"})
if response.status_code != 200:
return None
return response.json()
def _load(self, urls: dict[str, str]) -> dict[str, str]:
found: dict[str, str] = {}
for source, url in urls.items():
try:
data = self._fetch(url)
except Exception as exc: # noqa: BLE001 - fonte externa opcional
log.info("emotes %s indisponível (%s)", source, type(exc).__name__)
continue
if data:
for name in _names_from(source, data):
found.setdefault(name, source)
return found
def cached(self, room_id: str | None) -> dict[str, str]:
"""O que já foi baixado, sem tocar na rede (usado na linha do chat, que não pode esperar API externa)."""
with self._lock:
merged = dict(self._global)
if room_id and room_id in self._channels:
merged.update(self._channels[room_id][1])
return merged
def names(self, room_id: str | None) -> dict[str, str]:
now = time.time()
with self._lock:
if now - self._global_at > CATALOG_TTL_S:
self._global, self._global_at = self._load(GLOBAL_URLS), now
merged = dict(self._global)
if room_id:
cached = self._channels.get(room_id)
if not cached or now - cached[0] > CATALOG_TTL_S:
cached = (now, self._load({k: v.format(room=room_id) for k, v in CHANNEL_URLS.items()}))
self._channels[room_id] = cached
merged.update(cached[1])
return merged
def extract(text: str, twitch_emotes: list[str], catalog: dict[str, str]) -> list[tuple[str, str]]:
"""(nome, fonte) de cada emote da mensagem: nativos da Twitch, de terceiros (palavra exata) e emojis."""
out: list[tuple[str, str]] = [(name, "twitch") for name in twitch_emotes]
seen = {name for name, _ in out}
for token in text.split():
if token in catalog and token not in seen:
out.append((token, catalog[token]))
seen.add(token)
for emoji in EMOJI_RE.findall(text):
if emoji not in seen:
out.append((emoji, "emoji"))
seen.add(emoji)
return out
def message_bonus(emotes: list[str], weights: dict[str, float]) -> float:
"""Bônus de peso da mensagem pelos emotes: base por ter emote + pesos aprendidos do canal."""
if not emotes:
return 0.0
learned = sum(max(WEIGHT_MIN, min(WEIGHT_MAX, weights.get(name, 0.0))) for name in set(emotes))
return max(BONUS_MIN, min(BONUS_MAX, BASE_EMOTE_BONUS + learned))
def learn_delta(positive: bool) -> float:
return LEARN_UP if positive else -LEARN_DOWN
+761
View File
@@ -0,0 +1,761 @@
"""Rastreio do rosto do streamer no Clipador: acha a câmera (YuNet), segue o rosto e as expressões (MediaPipe Face
Landmarker; plano B OpenSeeFace) bloco a bloco e grava a série por segundo em `face_track`.
A lógica de sinal (série por segundo, z relativo ao neutro do streamer, rótulos, `locate_cam`) é pura e mora em
`reaction.py`; aqui fica só E/S: modelos, FFmpeg, backends e banco. Decisões e números: doc/FACE_BAKEOFF.md.
- Modelos: baixados sob demanda (na primeira vez que o rastreio ou a detecção rodam, sempre fora da thread do chat)
para `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`. O `setup.ps1` (passo 6b) já
deixa tudo baixado; o download aqui é só a rede de segurança.
- Bloco: FFmpeg recorta a câmera (+10 % de margem), escala para ~384 px no maior lado, 6 qps, `rgb24` por pipe →
MediaPipe em modo VIDEO (um landmarker por bloco: timestamps sempre crescentes) → `reaction.per_second`.
- Coordenadas gravadas (`cx`, `cy`, `size`) já convertidas para o QUADRO INTEIRO (0..1; `size` = altura do rosto
como fração da altura do quadro): é o que o editor usa para reenquadrar a câmera.
- Câmera mudou (detecção nova ou layout editado) → a série da sessão é apagada e refeita sozinha.
Nada daqui importa cv2/mediapipe/numpy na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
"""
from __future__ import annotations
import hashlib
import json
import logging
import math
import subprocess
import threading
import time
from collections.abc import Callable, Iterator
from pathlib import Path
from typing import TYPE_CHECKING, Any, Protocol
from . import reaction
from .config import CLIPPER_DIR, REPO_ROOT
from .db import loads, now
from .media import NO_WINDOW, MediaError, run, seek_args
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.face")
LOCK_FILE = CLIPPER_DIR / "models.lock.json"
FPS = 6 # quadros por segundo no rastreio (bancada: 6 qps bastam para pegar a reação)
CROP_SIDE = 384 # maior lado do recorte que vai para o modelo (256–384 dá o mesmo sinal)
CROP_MARGIN = 0.10 # margem em volta da câmera (o streamer se inclina para fora do retângulo)
CAM_FRAMES = 12 # quadros espalhados para achar a câmera
DETECT_WIDTH = 1280 # largura do quadro inteiro para o YuNet
UNAVAILABLE_RETRY_S = 300 # backend sem modelo/biblioteca: tenta de novo daqui a 5 min (não marca blocos)
BASELINE_EXTRA_S = 240 # segundos antes da janela pedidos para o neutro do streamer (z relativo)
MAX_LAG_BLOCKS = 2 # a decisão do corte espera o rosto do trecho, no máximo 2 blocos atrás da transcrição
READ_TIMEOUT_S = 120.0 # prazo do FFmpeg para entregar um bloco de 30 s (medido: ~0,5 s)
MIN_FRAMES_RATIO = 0.9 # bloco com menos de 90 % dos quadros esperados (fps × duração) é erro, não série truncada
RESET_WAIT_S = 0.5 # o reset pedido pela API espera o bloco em andamento só isto; senão fica agendado para o laço
Detection = tuple[float, float, float, float, float] # x, y, w, h (px), score
class FaceError(RuntimeError):
"""Falha de um bloco (vídeo apagado, FFmpeg) ou da detecção da câmera."""
class FaceUnavailable(FaceError):
"""Backend indisponível (biblioteca ou modelo faltando, download/sha256 falhou): não é culpa do bloco."""
# ---------------------------------------------------------------------------------------------------------------
# Modelos (download sob demanda + sha256)
def sha256_of(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as fh:
for chunk in iter(lambda: fh.read(1 << 20), b""):
digest.update(chunk)
return digest.hexdigest()
def _http_download(url: str, dest: Path) -> None:
import httpx
with httpx.stream("GET", url, follow_redirects=True, timeout=60) as response:
response.raise_for_status()
with dest.open("wb") as fh:
for chunk in response.iter_bytes(1 << 16):
fh.write(chunk)
class ModelStore:
"""Pesos do `models.lock.json`: confere o sha256 (uma vez por processo) e baixa o que faltar."""
def __init__(self, models_dir: Path, lock_file: Path = LOCK_FILE,
fetch: Callable[[str, Path], None] | None = None):
lock = json.loads(lock_file.read_text(encoding="utf-8"))
self.dir = models_dir
self.models: dict[str, dict] = {m["id"]: m for m in lock["models"]}
self.fetch = fetch or _http_download
self._checked: set[str] = set()
self._lock = threading.Lock()
def path(self, model_id: str) -> Path:
info = self.models.get(model_id)
if info is None:
raise FaceUnavailable(f"modelo {model_id} não está no models.lock.json")
dest = self.dir / info["file"]
with self._lock:
if model_id in self._checked and dest.is_file():
return dest
if dest.is_file() and sha256_of(dest) == info["sha256"]:
self._checked.add(model_id)
return dest
# Ausente ou corrompido: baixa de novo (URL imutável do lock) e só aceita com o sha256 certo.
self.dir.mkdir(parents=True, exist_ok=True)
part = dest.with_name(dest.name + ".part")
try:
log.info("baixando o modelo %s (%s)", model_id, info["url"])
self.fetch(info["url"], part)
digest = sha256_of(part)
except Exception as exc: # noqa: BLE001 - qualquer falha de rede/disco vira "indisponível"
part.unlink(missing_ok=True)
raise FaceUnavailable(f"não deu para baixar o modelo {info['file']}: {exc}") from exc
if digest != info["sha256"]:
part.unlink(missing_ok=True)
raise FaceUnavailable(f"sha256 do modelo {info['file']} não confere (baixado {digest[:12]}…)")
part.replace(dest)
self._checked.add(model_id)
return dest
# ---------------------------------------------------------------------------------------------------------------
# Backends
class Detector(Protocol):
def detect(self, bgr: Any) -> list[Detection]: ...
class Tracker(Protocol):
name: str
def process(self, t: float, rgb: Any) -> reaction.FaceSample: ...
def close(self) -> None: ...
class YuNetDetector:
"""Rosto no quadro inteiro (`cv2.FaceDetectorYN`, variante 2026may de entrada dinâmica)."""
def __init__(self, model_path: Path, score: float = 0.6):
try:
import cv2
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("opencv não instalado (rode o setup.bat)") from exc
self._cv2, self._path, self._score = cv2, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
def detect(self, bgr: Any) -> list[Detection]:
h, w = bgr.shape[:2]
if self._det is None:
self._det = self._cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 50)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
_, faces = self._det.detect(bgr)
if faces is None:
return []
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
class MediaPipeTracker:
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco.
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
"""
name = "mediapipe"
def __init__(self, model_path: Path):
try:
import mediapipe as mp
import numpy as np
from mediapipe.tasks.python import vision
from mediapipe.tasks.python.core.base_options import BaseOptions
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("mediapipe não instalado (rode o setup.bat)") from exc
self._mp, self._np = mp, np
options = vision.FaceLandmarkerOptions(
base_options=BaseOptions(model_asset_path=str(model_path)),
running_mode=vision.RunningMode.VIDEO,
num_faces=1,
min_face_detection_confidence=0.5,
min_face_presence_confidence=0.5,
min_tracking_confidence=0.5,
output_face_blendshapes=True,
)
self._lm = vision.FaceLandmarker.create_from_options(options)
self._last_ms = -1
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
ms = max(self._last_ms + 1, int(round(t * 1000)))
self._last_ms = ms
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
result = self._lm.detect_for_video(image, ms)
if not result.face_landmarks:
return reaction.FaceSample(t, False)
xs = [p.x for p in result.face_landmarks[0]]
ys = [p.y for p in result.face_landmarks[0]]
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend)
def close(self) -> None:
self._lm.close()
class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
Reimplementação mínima do `tracker.py` do commit 50c0974 (BSD-2), igual à da bancada (`tools/face_bench.py`).
Só o canal de movimento sai daqui; usado quando o MediaPipe não carrega.
"""
name = "openseeface"
RES, OUT_RES, LOGIT = 224, 27, 16.0
def __init__(self, landmarks_path: Path, detector_path: Path, threshold: float = 0.6):
try:
import cv2
import numpy as np
import onnxruntime as ort
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("onnxruntime/opencv não instalados (rode o setup.bat)") from exc
self._cv2, self._np = cv2, np
opts = ort.SessionOptions()
opts.inter_op_num_threads, opts.intra_op_num_threads = 1, 1
providers = ["CPUExecutionProvider"]
self._lm = ort.InferenceSession(str(landmarks_path), sess_options=opts, providers=providers)
self._det = ort.InferenceSession(str(detector_path), sess_options=opts, providers=providers)
self._lm_input = self._lm.get_inputs()[0].name
mean, std = np.float32([0.485, 0.456, 0.406]), np.float32([0.229, 0.224, 0.225])
self._mean, self._scale = -(mean / std), 1.0 / (std * 255.0)
self._threshold = threshold
self._box: tuple[float, float, float, float] | None = None
def _norm(self, rgb: Any, size: int) -> Any:
im = self._cv2.resize(rgb.astype(self._np.float32), (size, size)) * self._scale + self._mean
return self._np.transpose(im[None], (0, 3, 1, 2)).astype(self._np.float32)
def _detect(self, rgb: Any) -> tuple[float, float, float, float] | None:
np = self._np
out, maxpool = (np.array(a) for a in self._det.run([], {"input": self._norm(rgb, 224)}))
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
y, x = divmod(int(np.argmax(out[0, 0])), 56)
if out[0, 0, y, x] < self._threshold:
return None
r = out[0, 1, y, x] * 112.0
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
return ((x * 4 - r) * sx, (y * 4 - r) * sy, 2 * r * sx, 2 * r * sy)
def _landmarks(self, rgb: Any, box: tuple[float, float, float, float]) -> tuple[float, Any]:
np = self._np
h, w = rgb.shape[:2]
x, y, bw, bh = box
x1, y1 = int(np.clip(x - bw * 0.1, 0, w - 1)), int(np.clip(y - bh * 0.125, 0, h - 1))
x2, y2 = int(np.clip(x + bw * 1.1, 0, w - 1)), int(np.clip(y + bh * 1.125, 0, h - 1))
if x2 - x1 < 4 or y2 - y1 < 4:
return 0.0, None
tensor = self._lm.run([], {self._lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
n, res = self.OUT_RES + 1, self.RES - 1
main = tensor[0:66].reshape(66, n * n)
idx = main.argmax(1)[:, None]
conf = np.take_along_axis(main, idx, 1)[:, 0]
def logit(v: Any) -> Any:
v = np.clip(v, 1e-7, 1 - 1e-7)
return np.log(v / (1 - v)) / self.LOGIT
off_y = np.take_along_axis(tensor[66:132].reshape(66, n * n), idx, 1)[:, 0]
off_x = np.take_along_axis(tensor[132:198].reshape(66, n * n), idx, 1)[:, 0]
m = idx[:, 0]
# No original a 1ª coluna dos pontos é y; aqui já sai (x, y).
py = y1 + (y2 - y1) / self.RES * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
px = x1 + (x2 - x1) / self.RES * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
return float(conf.mean()), np.stack([px, py], 1)
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
box = self._box or self._detect(rgb)
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if conf < self._threshold and self._box is not None:
box = self._detect(rgb) # caixa do quadro anterior se perdeu: detector neste mesmo quadro
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if pts is None or conf < self._threshold:
self._box = None
return reaction.FaceSample(t, False)
(x1, y1), (x2, y2) = pts.min(0), pts.max(0)
self._box = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
h, w = rgb.shape[:2]
return reaction.FaceSample(t, True, float(x1 + x2) / 2 / w, float(y1 + y2) / 2 / h, float(y2 - y1) / h, {})
def close(self) -> None:
self._box = None
# ---------------------------------------------------------------------------------------------------------------
# Vídeo (FFmpeg, sem shell, argumentos em lista)
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace").strip().splitlines()
if not out:
raise FaceError(f"sem vídeo em {file.name}")
w, h = out[0].split(",")[:2]
return int(w), int(h)
def _stop(proc: subprocess.Popen, grace: float = 10.0) -> None:
"""Espera o processo sair; se não sair, mata e ESPERA de novo (sem processo zumbi)."""
try:
proc.wait(timeout=grace)
except subprocess.TimeoutExpired:
proc.kill()
proc.wait(timeout=grace)
def read_crop(ffmpeg: str, file: Path, crop_px: tuple[int, int, int, int], out_size: tuple[int, int],
fps: int = FPS, timeout: float = READ_TIMEOUT_S) -> Iterator[tuple[float, Any]]:
"""Quadros RGB do recorte (x, y, w, h em px) a `fps` qps, um por vez (sem guardar o bloco na memória).
`fps` antes do `crop` reduz o trabalho do filtro. Devolve (segundos desde o início do bloco, H×W×3 uint8).
Prazo total `timeout`: passou, o FFmpeg é morto. stderr é drenado numa thread (FFmpeg tagarela não trava no
buffer do pipe). FFmpeg que sai com código ≠ 0 — inclusive morto pelo prazo — vira `FaceError`, mesmo depois de
ter entregado alguns quadros: bloco truncado não pode ser gravado como completo.
"""
x, y, w, h = crop_px
ow, oh = out_size
args = [ffmpeg, "-v", "error", "-i", str(file), "-vf", f"fps={fps},crop={w}:{h}:{x}:{y},scale={ow}:{oh}",
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
return _read_frames(args, out_size, fps, timeout, file.name)
def _read_frames(args: list[str], out_size: tuple[int, int], fps: int, timeout: float,
name: str) -> Iterator[tuple[float, Any]]:
"""Lê quadros rawvideo rgb24 do stdout de `args` (sem shell), com prazo e stderr drenado."""
import numpy as np
ow, oh = out_size
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=NO_WINDOW)
errors: list[bytes] = []
drain = threading.Thread(target=lambda: errors.append(proc.stderr.read()), daemon=True) # type: ignore[union-attr]
drain.start()
timed_out = threading.Event()
def kill() -> None:
timed_out.set()
proc.kill()
killer = threading.Timer(timeout, kill)
killer.daemon = True
killer.start()
size = ow * oh * 3
i = 0
try:
while True:
buf = proc.stdout.read(size) # type: ignore[union-attr]
if len(buf) < size:
break
yield i / fps, np.frombuffer(buf, np.uint8).reshape(oh, ow, 3).copy()
i += 1
finally:
killer.cancel()
proc.stdout.close() # type: ignore[union-attr]
_stop(proc)
drain.join(timeout=5)
if proc.stderr:
proc.stderr.close()
if timed_out.is_set():
raise FaceError(f"ffmpeg passou de {timeout:.0f} s lendo {name} ({i} quadros)")
if proc.returncode != 0:
tail = b"".join(errors).decode("utf-8", errors="replace").strip().splitlines()[-1:]
raise FaceError(f"ffmpeg saiu com código {proc.returncode} depois de {i} quadros: {' '.join(tail)}")
def grab_bgr(ffmpeg: str, file: Path, offset: float, width: int = DETECT_WIDTH) -> Any | None:
"""Um quadro BGR do bloco, escalado para `width` de largura (altura proporcional, par)."""
import numpy as np
before, select = seek_args(offset) # quadro exato (no HEVC a busca direta dava quadro cinza)
raw = run([ffmpeg, "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-frames:v", "1",
"-vf", f"{select},scale={width}:-2", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], 60)
h = len(raw) // (width * 3)
if h < 2:
return None
return np.frombuffer(raw[: width * h * 3], np.uint8).reshape(h, width, 3).copy()
# ---------------------------------------------------------------------------------------------------------------
# Geometria
def expand(rect: dict, margin: float = CROP_MARGIN) -> dict:
"""Retângulo 0..1 com margem em volta, recortado no quadro."""
mx, my = rect["w"] * margin, rect["h"] * margin
x0, y0 = max(0.0, rect["x"] - mx), max(0.0, rect["y"] - my)
x1, y1 = min(1.0, rect["x"] + rect["w"] + mx), min(1.0, rect["y"] + rect["h"] + my)
return {"x": round(x0, 4), "y": round(y0, 4), "w": round(x1 - x0, 4), "h": round(y1 - y0, 4)}
def crop_geometry(crop: dict, frame: tuple[int, int], side: int = CROP_SIDE) -> tuple[tuple[int, int, int, int],
tuple[int, int]]:
"""Recorte em px (valores pares) e tamanho de saída com o maior lado = `side`."""
fw, fh = frame
# Tudo par e dentro do quadro, mesmo com retângulo fora de 0..1 (layout antigo, arredondamento).
x = min(max(0, int(crop["x"] * fw)), fw - 2) // 2 * 2
y = min(max(0, int(crop["y"] * fh)), fh - 2) // 2 * 2
w = max(2, min(fw - x, int(round(crop["w"] * fw))) // 2 * 2)
h = max(2, min(fh - y, int(round(crop["h"] * fh))) // 2 * 2)
k = side / max(w, h)
return (x, y, w, h), (max(2, int(w * k) // 2 * 2), max(2, int(h * k) // 2 * 2))
def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.FaceSecond]:
"""Posição/tamanho do recorte → quadro inteiro (0..1). `size` vira fração da altura do quadro."""
for s in seconds:
if s.cx is not None:
s.cx = crop["x"] + s.cx * crop["w"]
if s.cy is not None:
s.cy = crop["y"] + s.cy * crop["h"]
if s.size is not None:
s.size = s.size * crop["h"]
return seconds
def same_rect(a: dict | None, b: dict | None, tol: float = 1e-3) -> bool:
if a is None or b is None:
return a is b
return all(abs(float(a[k]) - float(b[k])) <= tol for k in ("x", "y", "w", "h"))
# ---------------------------------------------------------------------------------------------------------------
# Serviço
class FaceService:
"""Câmera local, rastreio por bloco e leitura da série. Uma instância por motor (`Engine.face`)."""
def __init__(self, engine: Engine, store: ModelStore | None = None,
tracker_factory: Callable[[str | None], Tracker] | None = None,
detector_factory: Callable[[], Detector] | None = None,
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
grabber: Callable[..., Any] | None = None,
sizer: Callable[[Path], tuple[int, int]] | None = None):
self.e = engine
self.store = store or ModelStore(engine.settings.data_dir / "models")
# Recebe o backend que a sessão já usa (None = sessão nova) e devolve o rastreador.
self._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
self._detector_factory = detector_factory or (lambda: YuNetDetector(self.store.path("yunet")))
self._reader = reader or read_crop
self._grabber = grabber or grab_bgr
self._sizer = sizer or (lambda file: probe_size(self.e.settings.ffprobe or "ffprobe", file))
# Tamanho do quadro POR BLOCO: uma retomada pode gravar em outra resolução (outra qualidade de captura).
self._sizes: dict[str, tuple[int, int]] = {}
self._busy = threading.Lock() # um bloco por vez (o laço e um reset concorrente não se atropelam)
self._resets: set[int] = set() # resets pedidos com um bloco em andamento: o laço aplica no próximo passo
self._resets_lock = threading.Lock()
self._unavailable_until = 0.0
self.backend: str | None = None
self.last_error: str | None = None
self.params = reaction.ReactionParams()
# ---------- opções / backends
@property
def enabled(self) -> bool:
return bool(self.e.intel.opts.get("faceTrack", True))
def _default_tracker(self, backend: str | None = None) -> Tracker:
"""MediaPipe; o plano B OpenSeeFace só numa sessão que ainda não tem série. Uma sessão nunca mistura os
dois: sem blendshapes, o neutro do streamer ficaria zerado no meio da série e qualquer sorriso viraria pico."""
if backend == OpenSeeFaceTracker.name:
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
try:
return MediaPipeTracker(self.store.path("face_landmarker"))
except FaceUnavailable as first:
if backend == MediaPipeTracker.name:
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
log.warning("MediaPipe indisponível (%s): usando o plano B OpenSeeFace (sem expressões)", first)
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
def session_backend(self, session_id: int) -> str | None:
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
session_id)
return loads(row["data_json"], {}).get("backend") if row else None
# ---------- câmera da sessão
def cam_for(self, session: dict) -> tuple[dict | None, str, bool]:
"""(retângulo 0..1 da câmera, origem, decidido?). Layout do corte primeiro (o que o usuário vê e edita);
senão o que a detecção achou. Não decidido = a detecção ainda não rodou: o rastreio espera."""
layout_cam = self.e.intel.settings_for(session)["layout"]["cam"]
detected = loads(session.get("cam_json"), None) or {}
if layout_cam:
same = same_rect(detected.get("cam"), layout_cam)
return layout_cam, (detected.get("source") or "ai") if same else "manual", True
if detected.get("hasWebcam") and detected.get("cam"):
return detected["cam"], detected.get("source") or "ai", True
if detected:
return None, detected.get("source") or "", True
return None, "", False
def has_cam(self, session: dict) -> bool:
cam, _, decided = self.cam_for(session)
return decided and cam is not None
# ---------- laço (thread `face` do motor)
def run_forever(self, stop: threading.Event) -> None:
while not stop.is_set():
worked = False
if self.enabled and time.monotonic() >= self._unavailable_until:
try:
worked = self.step()
except FaceUnavailable as exc:
self.last_error = str(exc)[:300]
self._unavailable_until = time.monotonic() + UNAVAILABLE_RETRY_S
log.warning("rastreio de rosto indisponível: %s (nova tentativa em %d s)", exc, UNAVAILABLE_RETRY_S)
except Exception as exc: # noqa: BLE001 - qualquer outra falha não pode matar a thread do rastreio
self.last_error = str(exc)[:300]
log.exception("rastreio de rosto: erro inesperado no laço")
stop.wait(0.2 if worked else 10)
def step(self) -> bool:
"""Processa UM bloco pendente (sessões gravando/processando primeiro). True se trabalhou."""
db = self.e.db
self._apply_pending_resets()
sessions = db.all("SELECT * FROM sessions WHERE status != 'error' ORDER BY "
"CASE WHEN status IN ('recording', 'processing', 'starting') THEN 0 ELSE 1 END, id DESC")
for session in sessions:
cam, _source, decided = self.cam_for(session)
if not decided:
continue
self.sync_cam(session["id"], cam)
segment = db.get(
"SELECT s.* FROM segments s LEFT JOIN face_track f ON f.session_id = s.session_id AND f.idx = s.idx"
" WHERE s.session_id = ? AND s.deleted = 0 AND f.idx IS NULL ORDER BY s.idx LIMIT 1", session["id"])
if segment:
self.process_block(session, segment, cam)
return True
return False
def sync_cam(self, session_id: int, cam: dict | None) -> bool:
"""Câmera diferente da usada na série gravada → apaga a série (o laço refaz). True se apagou."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? ORDER BY idx DESC LIMIT 1", session_id)
if row is None or same_rect(loads(row["data_json"], {}).get("cam"), cam):
return False
log.info("sessão %s: câmera mudou, refazendo o rastreio do rosto", session_id)
self.reset(session_id)
return True
def reset(self, session_id: int, wait_s: float = RESET_WAIT_S) -> dict:
"""Apaga a série da sessão. Não prende a requisição HTTP atrás de um bloco em andamento: se o laço estiver
ocupado por mais de `wait_s`, o reset fica agendado e o laço aplica antes do próximo bloco."""
if not self._busy.acquire(timeout=wait_s):
with self._resets_lock:
self._resets.add(session_id)
return {"deleted": 0, "scheduled": True}
try:
with self._resets_lock:
self._resets.discard(session_id)
return {"deleted": self._delete(session_id), "scheduled": False}
finally:
self._busy.release()
def _delete(self, session_id: int) -> int:
return self.e.db.run("DELETE FROM face_track WHERE session_id = ?", session_id).rowcount
def _apply_pending_resets(self) -> None:
with self._resets_lock:
pending, self._resets = self._resets, set()
for session_id in pending:
with self._busy:
self._delete(session_id)
def process_block(self, session: dict, segment: dict, cam: dict | None) -> str:
"""Rastreia um bloco e grava a linha de `face_track`. Devolve o status gravado."""
sid, idx = segment["session_id"], segment["idx"]
if cam is None:
self._save(sid, idx, "no_cam", {"cam": None}, None)
return "no_cam"
first, last = math.ceil(segment["start_s"]), math.ceil(segment["end_s"])
with self._busy:
started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name
try:
file = REPO_ROOT / segment["file"]
crop = expand(cam)
px, out = crop_geometry(crop, self._frame_size(sid, file))
samples = [tracker.process(segment["start_s"] + t, rgb)
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)]
except FaceUnavailable:
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde
except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
log.warning("bloco %s/%s do rastreio falhou: %s", sid, idx, exc)
self._save(sid, idx, "error", {"cam": cam}, str(exc)[:300])
return "error"
finally:
tracker.close()
expected = (segment["end_s"] - segment["start_s"]) * FPS
if len(samples) < MIN_FRAMES_RATIO * expected - 2:
msg = f"bloco truncado: {len(samples)} de ~{expected:.0f} quadros"
self._save(sid, idx, "error", {"cam": cam}, msg)
return "error"
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first), crop)
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)}
self._save(sid, idx, "done", data, None)
self.last_error = None
return "done"
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file)
if key not in self._sizes:
if len(self._sizes) > 2000:
self._sizes.clear()
self._sizes[key] = self._sizer(file)
return self._sizes[key]
def _save(self, session_id: int, idx: int, status: str, data: dict, error: str | None) -> None:
self.e.db.run("INSERT INTO face_track (session_id, idx, status, data_json, error, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
" ON CONFLICT (session_id, idx) DO UPDATE SET status = excluded.status, data_json = excluded.data_json,"
" error = excluded.error, updated_at = excluded.updated_at",
session_id, idx, status, json.dumps(data, ensure_ascii=False), error, now())
# ---------- leitura
def tracked_until(self, session_id: int) -> float:
"""Até onde (s) a série está contínua desde o início (qualquer status conta: bloco sem câmera também
já foi "decidido")."""
until = 0.0
# Blocos apagados nunca ganham linha (o laço os ignora): pular, senão a série "trava" no primeiro apagado.
for row in self.e.db.all("SELECT s.start_s, s.end_s, f.idx AS done FROM segments s LEFT JOIN face_track f"
" ON f.session_id = s.session_id AND f.idx = s.idx WHERE s.session_id = ? AND s.deleted = 0"
" ORDER BY s.idx",
session_id):
if row["done"] is None:
break
until = row["end_s"]
return until
def dense(self, session_id: int, lo: float, hi: float) -> list[reaction.FaceSecond]:
"""Série contínua por segundo em [floor(lo), ceil(hi)) — índice i = segundo floor(lo) + i; segundos sem
dado (sem câmera, erro, ainda não rastreado) saem com `present` 0. É o formato que `reaction` espera."""
first, last = max(0, int(math.floor(lo))), max(0, int(math.ceil(hi)))
out = [reaction.FaceSecond(t) for t in range(first, last)]
if not out:
return out
rows = self.e.db.all(
"SELECT f.data_json FROM face_track f JOIN segments s ON s.session_id = f.session_id AND s.idx = f.idx"
" WHERE f.session_id = ? AND f.status = 'done' AND s.end_s >= ? AND s.start_s < ? ORDER BY f.idx",
session_id, first, last)
for row in rows:
for item in loads(row["data_json"], {}).get("seconds", []):
i = int(item["t"]) - first
if 0 <= i < len(out):
out[i] = reaction.FaceSecond.from_json(item)
return out
def for_scoring(self, session: dict, offset: int, duration: float) -> tuple[list[reaction.FaceSecond] | None, float]:
"""(série alinhada à janela da pontuação — t relativo a `offset` —, até onde o rastreio chegou).
`None` quando o rastreio está desligado ou a sessão não tem câmera: a pontuação segue como antes."""
if not self.enabled or not self.has_cam(session):
return None, 0.0
seconds = self.dense(session["id"], offset, duration)
for s in seconds:
s.t -= offset
return seconds, self.tracked_until(session["id"])
def must_wait(self, needed_until: float, face_until: float, analyzed_until: float) -> bool:
"""Espera o rosto do trecho antes de decidir o corte — mas nunca mais que `MAX_LAG_BLOCKS` blocos atrás da
transcrição (rastreio atrasado ou travado não segura os cortes)."""
if time.monotonic() < self._unavailable_until:
return False # backend fora do ar: esperar não adianta (sessão curta ficaria sem cortes até voltar)
lag = analyzed_until - face_until
return needed_until > face_until and lag <= MAX_LAG_BLOCKS * self.e.settings.segment_s
def summary(self, session: dict, lo: float, hi: float) -> str:
"""Linha "Rosto do streamer" do prompt do analista; "" quando não há câmera/rastreio nesse trecho."""
if not self.enabled or not self.has_cam(session):
return ""
# Plano B (OpenSeeFace) não mede expressão: os canais saem 0 e o texto diria "sem reação marcante" — falso.
if self.session_backend(session["id"]) == OpenSeeFaceTracker.name:
return ""
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
inside = [s for s in seconds if lo <= s.t <= hi]
if not inside or not any(s.smile is not None for s in inside):
return ""
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
def view(self, session: dict, lo: float, hi: float | None) -> dict:
"""Série por segundo para a API (o editor usa cx/cy/size, já no quadro inteiro, para reenquadrar)."""
sid = session["id"]
cam, source, decided = self.cam_for(session)
end = session["duration_s"] if hi is None else min(hi, session["duration_s"])
start = max(0.0, min(lo, end))
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
signal = reaction.reaction_signal(seconds, params=self.params)
moments = reaction.reaction_moments(seconds, self.params)
counts = {r["status"]: r["n"] for r in self.e.db.all(
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
rows = []
for s, z in zip(seconds, signal):
if s.t < start:
continue
item = s.to_json()
if z is not None:
item["signal"] = round(z, 2)
rows.append(item)
return {
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
"cam": cam, "camSource": source, "camDecided": decided, "backend": self.backend,
"lastError": self.last_error, "trackedUntilS": self.tracked_until(sid),
"blocks": {"total": total, "done": counts.get("done", 0), "noCam": counts.get("no_cam", 0),
"error": counts.get("error", 0)},
"fromS": start, "toS": end,
"seconds": rows,
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
}
# ---------- câmera local (YuNet + reaction.locate_cam)
def locate(self, session: dict) -> dict:
"""Acha a câmera olhando `CAM_FRAMES` quadros espalhados da gravação, sem IA."""
segments = self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])
if not segments:
raise FaceError("sem vídeo gravado (blocos apagados?)")
lo, hi = segments[0]["start_s"], segments[-1]["end_s"]
margin = min(30.0, (hi - lo) * 0.05)
span = max(0.0, hi - lo - 2 * margin)
times = [lo + margin + span * k / max(1, CAM_FRAMES - 1) for k in range(CAM_FRAMES)]
detector = self._detector_factory()
detections: list[list[Detection]] = []
size: tuple[int, int] | None = None
ffmpeg = self.e.settings.ffmpeg or "ffmpeg"
for t in times:
seg = next((s for s in segments if s["start_s"] <= t < s["end_s"]), segments[-1])
try:
bgr = self._grabber(ffmpeg, REPO_ROOT / seg["file"], t - seg["start_s"])
except (MediaError, OSError) as exc:
log.info("quadro %.0fs indisponível para achar a câmera: %s", t, exc)
continue
if bgr is None:
continue
size = (bgr.shape[1], bgr.shape[0])
detections.append(detector.detect(bgr))
if size is None or len(detections) < 3:
raise FaceError("poucos quadros legíveis para achar a câmera")
result = reaction.locate_cam(detections, size[0], size[1])
return result | {"source": "yunet", "frames": len(detections), "framesWithFace": sum(1 for d in detections if d),
"at": now()}
+77
View File
@@ -0,0 +1,77 @@
"""Hashtags da legenda de um corte (pedido do dono, 17/11/2026: "a IA colocar as # certas, como o jogo e a missão").
A legenda sai em três partes, sempre na mesma ordem:
texto (1–2 frases da IA, sem hashtags)
hashtags: canal → jogo (fixas, do perfil do jogo) → momento (da IA: missão, evento, modo, item, personagem)
🎥 Créditos: link do canal
As do canal e do jogo não dependem da IA acertar: vêm do nome do streamer e do perfil do jogo (seção "Hashtags",
preenchida pela pesquisa e editável no painel; sem ela, o nome do jogo vira a tag). As do momento são as que a IA
escolheu para o trecho. Repetidas saem (sem diferenciar maiúscula e acento) e o total fica em até 8.
"""
from __future__ import annotations
import re
import unicodedata
MAX_TAGS = 8
GAME_TAGS = 3
MOMENT_TAGS = 4
TAG_MAX_LEN = 30
_HASHTAG = re.compile(r"#[^\s#]+")
_WORD = re.compile(r"[^\W_]+|_", re.UNICODE)
def to_tag(text: object) -> str | None:
"""'ROB RUN' → '#ROBRUN', 'perseguição policial' → '#PerseguiçãoPolicial', '#Lamborghini' → '#Lamborghini'.
Sem letra (só número/símbolo) ou vazio → None."""
words = _WORD.findall(str(text or "").strip().lstrip("#"))
words = [w for w in words if w != "_"]
if not words:
return None
if len(words) == 1:
body = words[0]
else:
body = "".join(w[:1].upper() + w[1:] for w in words)
body = body[:TAG_MAX_LEN]
if not any(ch.isalpha() for ch in body):
return None
return f"#{body}"
def fold(tag: str) -> str:
"""Chave para comparar tags: sem #, sem acento, minúscula."""
plain = unicodedata.normalize("NFKD", tag.lstrip("#"))
return "".join(ch for ch in plain if not unicodedata.combining(ch)).casefold()
def split_hashtags(text: str) -> tuple[str, list[str]]:
"""Separa o texto das hashtags que vieram no meio dele (a IA às vezes põe mesmo pedindo para não pôr)."""
tags = _HASHTAG.findall(text or "")
clean = _HASHTAG.sub("", text or "")
clean = re.sub(r"[ \t]+", " ", clean)
clean = re.sub(r" *\n *", "\n", clean).strip()
return clean, tags
def compose(streamer: str, game: str, profile: dict | None, moment: list[str] | tuple[str, ...]) -> list[str]:
"""Hashtags finais: canal, jogo (do perfil; senão o nome do jogo) e as do momento, sem repetidas, até 8."""
game_tags = [t for t in (profile or {}).get("hashtags") or [] if t][:GAME_TAGS] or ([game] if game else [])
ordered = [streamer, *game_tags, *list(moment)[:MOMENT_TAGS]]
out: list[str] = []
seen: set[str] = set()
for raw in ordered:
tag = to_tag(raw)
if tag and fold(tag) not in seen:
seen.add(fold(tag))
out.append(tag)
if len(out) >= MAX_TAGS:
break
return out
def build_caption(text: str, tags: list[str], credit: str) -> str:
"""Texto, hashtags e crédito, separados por linha em branco (partes vazias somem)."""
return "\n\n".join(part for part in (text.strip(), " ".join(tags), credit.strip()) if part)
+507
View File
@@ -0,0 +1,507 @@
"""Inteligência do Clipador além da heurística: contexto do jogo, varredura da IA, webcam e emotes que aprendem.
Pedido do usuário (17/11/2026), depois de uma live com chat pequeno (skipnho, 0,15 msg/s) passar 15 min sem corte:
- a IA precisa saber QUE JOGO é (categoria da plataforma, título, chat e a própria tela) e conhecer o jogo
(pesquisa na web, guardada por jogo);
- a IA precisa VER a tela (frames) e procurar momentos sozinha, mesmo sem pico de chat (varredura);
- achar a webcam do streamer para o layout câmera-em-cima;
- emotes da Twitch/7TV/BTTV/FFZ contam como reação e ganham peso por canal conforme os cortes aprovados.
"""
from __future__ import annotations
import json
import logging
import re
import threading
import time
from pathlib import Path
from typing import TYPE_CHECKING
from . import clip_delete, layout
from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable
from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context
from .scoring import fit_window
from .sources import parse_source
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.intel")
# faceTrack: rastreio do rosto do streamer (face.py) — reforça/cria cortes e vai em texto para o analista.
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True}
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação
CAM_MAX_ATTEMPTS = 6 # falha sem rosto decidido (poucos quadros legíveis): no máximo isto de tentativas
GAME_CHECK_S = 600 # rechecar a categoria da live a cada 10 min (o streamer troca de jogo)
SCAN_FRAME_EVERY_S = 30
SCAN_MAX_FRAMES = 7
MEMORY_KEEP = 6
SCAN_MAX_MOMENTS = 2
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
class CamRetryLater(JudgeError):
"""Câmera local indisponível por um motivo passageiro (modelo/download): não é "sem câmera"."""
def game_id(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources")
def clean_profile(raw: dict) -> dict:
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
items, seen = [], set()
for item in raw.get(key) or []:
text = str(item or "").strip()[:300]
if key == "hashtags":
text = to_tag(text) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
continue
if text and text.lower() not in seen:
seen.add(text.lower())
items.append(text)
out[key] = items[:20]
return out
class Intel:
def __init__(self, engine: "Engine"):
self.e = engine
self.catalog = EmoteCatalog()
self._weights: dict[str, tuple[float, dict[str, float]]] = {}
self._rooms_ready: set[str] = set()
self._game_checked: dict[int, float] = {}
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória
self.last_scan_error: str | None = None
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
self.opts = dict(OPTION_DEFAULTS)
for key in OPTION_DEFAULTS:
if f"opt_{key}" in saved:
self.opts[key] = json.loads(saved[f"opt_{key}"])
# ---------------------------------------------------------------- opções (painel)
def set_options(self, values: dict) -> dict:
clean = {}
for key, value in values.items():
if key not in OPTION_DEFAULTS or value is None:
continue
if key == "scanIntervalS":
value = int(value)
if not 60 <= value <= 900:
raise JudgeError("intervalo da varredura vai de 60 a 900 s")
else:
value = bool(value)
clean[key] = value
self.opts.update(clean)
self.e.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
[(f"opt_{k}", json.dumps(v)) for k, v in clean.items()])
return dict(self.opts)
# ---------------------------------------------------------------- canal / configuração do corte
@staticmethod
def channel_key(session: dict) -> str:
source = parse_source(session["url"])
return source.channel_id if source.channel else ""
def settings_for(self, session: dict) -> dict:
channel = None
if session.get("channel_id"):
channel = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
return layout.merge(loads(channel["settings_json"], {}) if channel else {}, loads(session.get("settings_json"), {}))
# ---------------------------------------------------------------- emotes
def ingest_chat(self, session_id: int, channel_key: str, room_id: str | None,
batch: list[tuple[float, str, str, list[str]]]) -> None:
if room_id:
if room_id not in self._rooms_ready:
self.e.db.run("UPDATE sessions SET room_id = ? WHERE id = ? AND room_id IS NULL", room_id, session_id)
# Baixa o catálogo do canal fora da linha do chat (APIs externas podem demorar).
self._rooms_ready.add(room_id)
threading.Thread(target=self.catalog.names, args=(room_id,), daemon=True).start()
catalog = self.catalog.cached(room_id)
rows, seen = [], []
for wall, user, text, twitch_emotes in batch:
found = extract(text, twitch_emotes, catalog)
rows.append((session_id, wall, user, text, json.dumps([n for n, _ in found], ensure_ascii=False) if found else None))
seen.extend(found)
self.e.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, ?, ?, ?)", rows)
if channel_key and seen:
ts = now()
self.e.db.many(
"INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES (?, ?, ?, 1, 0, ?, ?)"
" ON CONFLICT (channel_key, name) DO UPDATE SET uses = uses + 1, last_seen = excluded.last_seen",
[(channel_key, name, source, ts, ts) for name, source in seen])
def weights(self, channel_key: str) -> dict[str, float]:
cached = self._weights.get(channel_key)
if cached and time.time() - cached[0] < 30:
return cached[1]
rows = self.e.db.all("SELECT name, weight FROM emotes WHERE channel_key = ? AND weight != 0", channel_key)
weights = {r["name"]: r["weight"] for r in rows}
self._weights[channel_key] = (time.time(), weights)
return weights
def bonus(self, emotes: list[str], channel_key: str) -> float:
return message_bonus(emotes, self.weights(channel_key)) if emotes else 0.0
def learn_from_clip(self, clip: dict, positive: bool, factor: float = 1.0, mark: bool = False) -> int:
"""Emotes da reação do corte (−10 s a +6 s do pico) ganham (aprovado) ou perdem (rejeitado) peso no canal."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session or (mark and clip.get("learned")):
return 0
key = self.channel_key(session)
if not key:
return 0
tl = self.e.load_timeline(session["id"], max(0.0, clip["peak_s"] - 120))
names = {e for m in tl["chat"] if clip["peak_s"] - 10 <= m.t <= clip["peak_s"] + 6 for e in m.emotes}
delta = learn_delta(positive) * factor
self.e.db.many("UPDATE emotes SET weight = MAX(-1.0, MIN(3.0, weight + ?)) WHERE channel_key = ? AND name = ?",
[(delta, key, n) for n in names])
if mark:
self.e.db.run("UPDATE clips SET learned = 1 WHERE id = ?", clip["id"])
self._weights.pop(key, None)
return len(names)
# ---------------------------------------------------------------- jogo
def check_game(self, session: dict, force: bool = False) -> None:
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo."""
if session["kind"] != "live":
return
last = self._game_checked.get(session["id"], 0)
if not force and time.time() - last < GAME_CHECK_S:
return
self._game_checked[session["id"]] = time.time()
meta = self.e.check_meta(session["url"])
if not meta:
return
if meta.get("title") and not session.get("title"):
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
category = (meta.get("category") or "").strip()
if category and category != session.get("game") and session.get("game_source") != "user":
self.set_game(session["id"], category, "platform")
def set_game(self, session_id: int, name: str, source: str) -> None:
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
return
history = loads(session["games_json"], [])
history.append({"game": name, "source": source, "atS": session["duration_s"], "at": now()})
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
gid = game_id(name)
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
def research_pending(self) -> None:
if not self.e.judge.enabled:
return # IA desligada: o jogo fica 'pending' até ligar (antes: um WARNING no log a cada 30 s)
for game in self.e.db.all("SELECT * FROM games WHERE status = 'pending' LIMIT 1"):
self.research(game["id"])
def research(self, gid: str) -> dict:
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo")
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
try:
profile = self.e.judge.research_game(game["name"], title, notes)
except (JudgeError, json.JSONDecodeError) as exc:
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
raise JudgeError(str(exc)) from exc
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?",
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid)
return profile
def save_profile(self, gid: str, profile: dict) -> dict:
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready')."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
clean = clean_profile(profile)
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?",
json.dumps(clean, ensure_ascii=False), now(), gid)
return clean
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA")
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]})
try:
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
except json.JSONDecodeError as exc:
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
reply = str(data.get("reply") or "").strip()[:600]
profile = clean_profile(data)
notes = loads(game.get("notes_json"), [])
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?,"
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False),
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid)
return profile, reply
def delete_note(self, gid: str, index: int) -> None:
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
game = self.e.db.get("SELECT notes_json FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
notes = loads(game["notes_json"], [])
if 0 <= index < len(notes):
notes.pop(index)
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
def profile(self, name: str) -> dict | None:
if not name:
return None
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name))
return loads(row["profile_json"], None) if row else None
def session_game(self, session: dict) -> tuple[str, dict | None]:
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
senão a categoria e, sem perfil dela, o jogo que a IA viu na tela."""
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
game, screen = session.get("game") or "", session.get("screen_game") or ""
profile = self.profile(game)
if profile or confirmed:
return game, profile
screen_profile = self.profile(screen) if screen.lower() not in ("", "desconhecido") else None
return (screen, screen_profile) if screen_profile else (game or ("" if screen.lower() == "desconhecido" else screen), None)
def context(self, session: dict) -> str:
memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
return game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed)
# ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
if not self.opts["vision"]:
return []
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
for s in self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])]
out_dir = self.e.repo_path(session["dir"]) / "frames"
frames = []
for t in times:
try:
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
log.info("frame %.0fs indisponível: %s", t, exc)
return frames
# ---------------------------------------------------------------- webcam
def maybe_detect_cam(self, session: dict) -> None:
"""Acha a câmera no início da sessão. A detecção local (YuNet) não precisa de IA, visão nem juiz ligados."""
if not self.opts["camDetect"] or time.time() < self._cam_retry_at.get(session["id"], 0.0):
return
saved = loads(session.get("cam_json"), None)
# Sem rosto na 1ª olhada (tela de "já volto" no começo da live): tenta de novo mais tarde enquanto grava.
# Falha sem rosto decidido (poucos quadros legíveis): tenta de novo pelo relógio, também em VOD/sessão parada.
due = saved and ((saved.get("retryAfterS") and session["duration_s"] >= saved["retryAfterS"])
or (saved.get("retryAt") is not None and time.time() >= saved["retryAt"]
and saved.get("attempts", 1) < CAM_MAX_ATTEMPTS))
if saved and not due:
return
analyzed = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 1", session["id"])["n"]
if analyzed < 2:
return
if self.settings_for(session)["layout"]["cam"]:
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
json.dumps({"skipped": "já definida", "source": "manual"}), session["id"])
return
try:
self.detect_cam(session["id"], apply=True)
except CamRetryLater as exc:
# Modelo indisponível/download falhou: nada a ver com a live. Não grava "sem câmera" (seria permanente e
# o rastreio marcaria tudo no_cam); tenta de novo em 5 min.
self._cam_retry_at[session["id"]] = time.time() + CAM_RETRY_S
log.warning("câmera da sessão %s: %s (nova tentativa em %d s)", session["id"], exc, CAM_RETRY_S)
except JudgeError as exc:
# Sem frame legível e sem IA: registra para não repetir a cada 30 s, com nova tentativa marcada
# (por tempo de gravação enquanto grava; pelo relógio em qualquer estado, até CAM_MAX_ATTEMPTS vezes).
attempts = (saved or {}).get("attempts", 0) + 1
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(
{"hasWebcam": False, "cam": None, "source": "yunet", "error": str(exc)[:200], "at": now(),
"retryAt": time.time() + CAM_RETRY_S, "attempts": attempts,
**({"retryAfterS": session["duration_s"] + CAM_RETRY_S} if session["status"] == "recording" else {})},
ensure_ascii=False), session["id"])
def detect_cam(self, session_id: int, apply: bool = False, use_ai: bool = False) -> dict:
"""Onde está a webcam. Primeiro local (YuNet + reaction.locate_cam, sem custo de IA); a IA só entra se o
local não achar rosto (e a IA estiver ligada com visão) ou se pedirem (`use_ai`). `cam_json.source` diz
quem achou: yunet | ai | manual."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session or session["duration_s"] < 5:
raise JudgeError("gravação curta demais para achar a câmera")
ai_ready = self.opts["vision"] and self.e.judge.enabled
local, local_error, transient = None, "", False
if not use_ai:
try:
local = self.e.face.locate(session)
except FaceUnavailable as exc: # modelo/biblioteca/download: passageiro, não é "sem câmera"
local_error, transient = str(exc), True
log.info("câmera local da sessão %s indisponível: %s", session_id, exc)
except FaceError as exc:
local_error = str(exc)
log.info("câmera local da sessão %s falhou: %s", session_id, exc)
if local is not None and (local["hasWebcam"] or not ai_ready):
result = local
if not local["hasWebcam"] and session["status"] == "recording":
result["retryAfterS"] = session["duration_s"] + CAM_RETRY_S
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
# Câmera em tela cheia (só o streamer) não vira layout câmera-em-cima; o rastreio usa o quadro inteiro.
if local["hasWebcam"] and not local["fullFrame"] and apply:
try:
rect = layout.validate({"layout": {"cam": local["cam"]}})["layout"]["cam"]
except layout.LayoutError:
rect = None
if rect:
self._apply_cam(session, rect)
return result
if not ai_ready:
if transient:
raise CamRetryLater(f"detector de rosto indisponível agora ({local_error}); tente de novo em instantes")
raise JudgeError(f"não deu para achar a câmera sem a IA ({local_error or 'sem rosto'}); ligue a visão ou marque à mão")
d = session["duration_s"]
frames = self.frames(session, [d * 0.25, d * 0.55, max(1.0, d - 8)], "cam")
if not frames:
raise JudgeError("sem frames (visão desligada ou blocos apagados)")
data = self.e.judge.detect_cam([p for _, p in frames])
rect = None
if data.get("has_webcam"):
try:
rect = layout.validate({"layout": {"cam": {k: data[k] for k in ("x", "y", "w", "h")}}})["layout"]["cam"]
except layout.LayoutError:
rect = None
result = {"hasWebcam": bool(data.get("has_webcam")), "cam": rect, "gameOnScreen": data.get("game_on_screen", ""),
"frame": self.e.rel(frames[-1][1]), "at": now(), "source": "ai"}
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
if rect and apply:
self._apply_cam(session, rect)
if result["gameOnScreen"] and result["gameOnScreen"].lower() not in ("desconhecido", "não identificável"):
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", result["gameOnScreen"][:120], session_id)
return result
def _apply_cam(self, session: dict, rect: dict) -> None:
"""Câmera achada vira padrão do canal (se o canal não tiver uma); sem canal, vale para a sessão."""
if session.get("channel_id"):
row = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
current = loads(row["settings_json"], {}) if row else {}
if row and not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(current), session["channel_id"])
return
current = loads(session.get("settings_json"), {})
if not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(current), session["id"])
# ---------------------------------------------------------------- varredura
def scan_due(self, session: dict, analyzed_until: float) -> tuple[float, float] | None:
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
if session["status"] == "recording" and session["kind"] == "vod":
return None # VOD baixa mais rápido que o tempo real: varre quando terminar
lo = session["scanned_until"]
hi = lo + self.opts["scanIntervalS"]
if hi <= analyzed_until:
return lo, hi
if session["status"] in ("processing", "stopped") and analyzed_until - lo >= 20:
return lo, analyzed_until # fim da gravação: varre o resto
return None
def scan_session(self, session: dict) -> int | None:
"""Varre a próxima janela pronta. None = nada a varrer agora; senão, quantos cortes criou."""
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
tl = self.e.load_timeline(session["id"], max(0.0, session["scanned_until"] - 200))
window = self.scan_due(session, tl["analyzedUntil"])
if not window:
return None
lo, hi = window
cfg = self.settings_for(session)
dur = cfg["duration"]
back_lo = max(0.0, lo - dur["backtrackS"])
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
frames = self.frames(session, times, "scan")
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all(
"SELECT start_s, end_s, title FROM clips WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], back_lo, hi)]
existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
tl["chat"], self.context(session), frames, existing, dur["minS"], dur["maxS"])
created = 0
try:
data = self.e.judge.scan(prompt, [p for _, p in frames])
self.last_scan_error = None
except (JudgeError, json.JSONDecodeError) as exc:
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
self.last_scan_error = str(exc)[:300]
log.warning("varredura %s %.0f–%.0fs falhou: %s", session["id"], lo, hi, exc)
data = {"moments": [], "summary": "", "screen_game": ""}
proposals = data.get("moments", [])[:SCAN_MAX_MOMENTS]
for moment in proposals:
if self._insert_scan_moment(session, moment, back_lo, hi, dur, existing):
created += 1
# Quantas propostas a IA fez e quantas viraram candidato (as outras: nota < SCAN_MIN_PROPOSAL, curtas ou em
# cima de um corte). Antes não ficava registrado (diagnóstico de 17/11/2026: impossível saber se a varredura
# não propôs nada ou se foi barrada).
log.info("varredura %s %.0f–%.0fs: %d proposta(s), %d candidato(s)", session["id"], lo, hi, len(proposals), created)
memory = loads(session.get("memory_json"), [])
if data.get("summary") or proposals:
memory.append({"fromS": lo, "toS": hi, "summary": str(data.get("summary") or "")[:240],
"proposals": len(proposals), "created": created})
screen = str(data.get("screen_game") or "")
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel"):
screen = ""
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?",
hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
if screen and not session.get("game"):
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela
return created
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
"""Momento proposto pela varredura vira CANDIDATO: passa pelos dois juízes (analista + editor) como os do chat."""
try:
# Mínimo + 1 s de verdade: se o fim bate no fim da janela, o início recua (fit_window).
start, end = fit_window(float(m["start_s"]), float(m["end_s"]), lo, hi,
layout.min_target({"duration": dur}), float(dur["maxS"]), keep="start")
score = max(0.0, min(10.0, float(m["score"])))
except (KeyError, TypeError, ValueError):
return False
if end - start < min(10.0, dur["minS"]) or score < SCAN_MIN_PROPOSAL:
return False
from .scoring import overlaps # import local: evita ciclo na carga do módulo
if any(overlaps(start, end, a, b) for a, b, _ in existing):
return False
ts = now()
reasons = {"via": "varredura", "scanFromS": lo, "scanToS": hi, "proposalScore": score,
"proposalTitle": str(m.get("title", ""))[:100], "proposalReason": str(m.get("reason", ""))[:300]}
self.e.db.run(
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
" VALUES (?, ?, ?, ?, ?, 'ai', ?, 'candidate', ?, ?)",
session["id"], round((start + end) / 2, 2), round(start, 2), round(end, 2), score,
json.dumps(reasons, ensure_ascii=False), ts, ts)
existing.append((start, end, ""))
return True
+640
View File
@@ -0,0 +1,640 @@
"""IA do Clipador pelas CLIs já logadas no PC (Codex/GPT por padrão, ou Claude) — sem chave de API.
Quatro usos, todos com saída JSON validada por schema:
1. **juiz** de candidato (chat/áudio apontaram): manter/descartar, nota, início/fim, título e legenda. Vê a
transcrição com bastante tempo para trás (o comentário vem DEPOIS da ação), o chat, os emotes, o perfil do
jogo e FRAMES da tela.
2. **varredura**: a cada poucos minutos de gravação a IA olha a janela inteira (fala + tela + chat) e propõe
momentos mesmo sem pico de chat — essencial em live pequena (3–5 pessoas) ou chat que reage pouco.
3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades.
4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima.
Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`) ou `claude`
(`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch).
"""
from __future__ import annotations
import json
import logging
import os
import re
import shutil
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from pathlib import Path
from . import layout
from .scoring import ChatMessage, Word, fit_window
log = logging.getLogger("cenaforge_clipper.judge")
PROVIDERS = ("codex", "claude", "off")
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku"}
CLAUDE_MODELS = [
{"id": "haiku", "label": "Haiku (mais barato)"},
{"id": "sonnet", "label": "Sonnet (equilíbrio)"},
{"id": "opus", "label": "Opus (mais capaz, mais caro)"},
]
CONTEXT_AFTER_S = 15.0
# Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min.
DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"])
DEFAULT_MAX_S = float(layout.DEFAULTS["duration"]["maxS"])
DEFAULT_BACKTRACK_S = float(layout.DEFAULTS["duration"]["backtrackS"])
TIMEOUT_S, RESEARCH_TIMEOUT_S = 240, 420
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
# Economia de tokens (medido em 17/11/2026, codex-cli 0.169.0): cada chamada do juiz é um processo novo e
# pagava ~77 mil caracteres fixos (~19 mil tokens) antes do prompt — instruções de agente de código (18 mil),
# ferramentas (46 mil: exec, plugins, computer-use) e listas de skills/apps. Uma live de 3,7 h = 150 chamadas.
# Sem busca na web o juiz não usa ferramenta nenhuma (as imagens vão por `-i`), então: o texto do juiz
# substitui as instruções de base e os recursos com ferramentas saem. Resultado: ~35 mil caracteres fixos.
# Com `--search` (pesquisa de jogo) só saem os extras; a web do Codex depende das ferramentas de execução.
CODEX_TOOL_FEATURES = ("plugins", "apps", "shell_tool", "unified_exec", "code_mode_host", "sleep_tool",
"skill_search", "tool_suggest", "in_app_browser", "browser_use")
CODEX_EXTRA_FEATURES = ("computer_use", "image_generation", "goals", "hooks")
CODEX_UNUSED_PLUGINS = ("computer-use@openai-bundled", "unified-computer-use@openai-bundled")
def codex_lean_overrides(search: bool, config_file: Path | None = None) -> list[str]:
"""Overrides `-c` só para esta chamada (a config global do Codex não muda)."""
features = CODEX_EXTRA_FEATURES + (() if search else CODEX_TOOL_FEATURES)
overrides = [f"features.{name}=false" for name in features]
try:
config = (config_file or Path.home() / ".codex" / "config.toml").read_text(encoding="utf-8")
except OSError:
config = ""
# `-c mcp_servers={}` não desliga (o Codex mescla tabelas): é preciso `enabled=false` por servidor.
for name in dict.fromkeys(re.findall(r'^\s*\[mcp_servers\.("?)([A-Za-z0-9_-]+)\1\]\s*$', config, re.M)):
overrides.append(f"mcp_servers.{name[1]}.enabled=false")
for plugin in CODEX_UNUSED_PLUGINS:
if f'[plugins."{plugin}"]' in config:
overrides.append(f'plugins."{plugin}".enabled=false')
return [arg for item in overrides for arg in ("-c", item)]
# ---------------------------------------------------------------- guia editorial (pesquisa de 16–17/11/2026)
CLIP_GUIDE = """O que faz um bom corte de live (pesquisa de mercado, 2026):
- Abre no momento forte: o espectador decide em 1–2 s. Nada de "como eu tava falando".
- Se explica sozinho: quem nunca viu a live entende em poucos segundos (contexto mínimo no começo).
- Rende corte: reação forte (susto, risada, raiva), jogada absurda/virada, falha engraçada, treta, história que
se desenrola, fala marcante, e INFORMAÇÃO NOVA DO JOGO (mecânica, segredo, novidade, comparação) — em
lançamentos (ex.: GTA 6) informação vale tanto quanto reação.
- Não rende: espera, menu/loading, leitura de doação/propaganda, conversa sem gancho, piada interna da live.
- TEMPO: o streamer costuma comentar DEPOIS da ação. Volte até o início da AÇÃO que motivou o comentário (pode
ser de 20 s a 2 min antes da fala, até o limite de volta informado) — o corte precisa mostrar a ação e a reação.
- Corte justo: termina logo depois do pagamento (reação/resolução)."""
# Gírias/memes do chat (BR/Twitch) que mudam o sentido do momento. O analista interpreta com o contexto.
CHAT_GLOSSARY = """Gírias comuns do chat (interprete pelo contexto):
- "server chinês", "ping", "lag", "travou/travando", "exit lag", "bugou", "rubberband", "teleportou" → o jogo ou a
live está travando/com atraso (personagem pulando de lugar, morrendo do nada) — a graça é o lag.
- "kkkk", "KEKW", "LUL", "OMEGALUL", "ICANT", "PepeLaugh" → risada; "?????" → confusão/não entenderam;
"F" → morte/perda/luto; "W"/"L" → vitória/derrota; "Pog/POGGERS" → impressionados; "monkaS/monkaW" → tensão;
"clipa/clip it" → pedido de corte; "hack/hackudo" → suspeita de trapaça; "gg" → fim de partida.
- Emotes próprios do canal (prefixo do streamer, ex.: skpPog) carregam a mesma reação do emote original."""
SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada",
"historia", "informacao_do_jogo", "reacao", "outro")
ANALYSIS_SCHEMA = {
"type": "object",
"properties": {
"situation": {"type": "string", "enum": list(SITUATIONS)},
"what_happened": {"type": "string"},
"screen": {"type": "string"},
"speech": {"type": "string"},
"chat_meaning": {"type": "string"},
"confidence": {"type": "number"},
"action_start_s": {"type": "number"},
"reaction_end_s": {"type": "number"},
"hook": {"type": "string"},
},
"required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence",
"action_start_s", "reaction_end_s", "hook"],
"additionalProperties": False,
}
ANALYST_SYSTEM = """Você é o ANALISTA de uma equipe de cortes de live. Não escreve título: descreve com fidelidade
O QUE ACONTECEU no trecho, para o editor decidir. Recebe contexto do jogo, transcrição com tempos, FRAMES da tela
com o instante de cada um e o chat.
Cruze as três fontes antes de concluir: a fala sozinha engana (ex.: "tô jogando três jogos… morri, morri" junto
de chat "server chinês?/kkkk" e a tela pulando = o jogo está travando e ele morre por causa do lag, não está
jogando três jogos). O chat reage alguns segundos depois do acontecimento.
""" + CHAT_GLOSSARY + """
Campos:
- situation: o tipo do momento (um da lista).
- what_happened: 2–3 frases factuais do que aconteceu, na ordem, sem exagero.
- screen: o que os frames mostram (cite o nº do frame) — ou "frames não ajudam".
- speech: o que a fala revela (cite o instante).
- chat_meaning: o que o chat está dizendo/rindo e por quê.
- confidence: 0–1, quanto você tem certeza da interpretação (baixe se as fontes não batem).
- action_start_s: instante (s da gravação) em que começa a AÇÃO que gerou a reação (pode ser antes da fala).
- reaction_end_s: instante em que a reação/pagamento termina.
- hook: o que prenderia alguém nos 2 primeiros segundos do corte.
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
VERDICT_SCHEMA = {
"type": "object",
"properties": {
"keep": {"type": "boolean"},
"score": {"type": "number"},
"start_s": {"type": "number"},
"end_s": {"type": "number"},
"title": {"type": "string"},
"caption": {"type": "string"},
"hashtags": {"type": "array", "items": {"type": "string"}},
"reason": {"type": "string"},
},
"required": ["keep", "score", "start_s", "end_s", "title", "caption", "hashtags", "reason"],
"additionalProperties": False,
}
# A varredura só aponta momentos (o juiz escreve título/legenda/hashtags depois): sem `keep` e sem `hashtags`.
_MOMENT = {
"type": "object",
"properties": {k: v for k, v in VERDICT_SCHEMA["properties"].items() if k not in ("keep", "hashtags")},
"required": ["score", "start_s", "end_s", "title", "caption", "reason"],
"additionalProperties": False,
}
SCAN_SCHEMA = {
"type": "object",
"properties": {
"screen_game": {"type": "string"},
"has_webcam": {"type": "boolean"},
"summary": {"type": "string"},
"moments": {"type": "array", "items": _MOMENT},
},
"required": ["screen_game", "has_webcam", "summary", "moments"],
"additionalProperties": False,
}
PROFILE_SCHEMA = {
"type": "object",
"properties": {
"name": {"type": "string"},
"summary": {"type": "string"},
"genre": {"type": "string"},
"mechanics": {"type": "array", "items": {"type": "string"}},
"clip_worthy": {"type": "array", "items": {"type": "string"}},
"avoid": {"type": "array", "items": {"type": "string"}},
"jargon": {"type": "array", "items": {"type": "string"}},
"news": {"type": "array", "items": {"type": "string"}},
"hashtags": {"type": "array", "items": {"type": "string"}},
"sources": {"type": "array", "items": {"type": "string"}},
},
"required": ["name", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources"],
"additionalProperties": False,
}
CAM_SCHEMA = {
"type": "object",
"properties": {
"has_webcam": {"type": "boolean"},
"x": {"type": "number"}, "y": {"type": "number"}, "w": {"type": "number"}, "h": {"type": "number"},
"game_on_screen": {"type": "string"},
},
"required": ["has_webcam", "x", "y", "w", "h", "game_on_screen"],
"additionalProperties": False,
}
JUDGE_SYSTEM = """Você é o EDITOR de cortes de live para Shorts, TikTok, Reels e YouTube, em português do Brasil.
Recebe um trecho candidato de uma live (contexto do jogo, transcrição com tempos, chat, emotes) e, quando houver,
a ANÁLISE do analista da equipe, que já cruzou tela, fala e chat. Confie na análise para entender O QUE
aconteceu; o seu trabalho é decidir se rende corte e escrever título e legenda FIÉIS a isso.
""" + CLIP_GUIDE + """
""" + CHAT_GLOSSARY + """
Título e legenda: descrevem a situação real (ex.: se a análise diz lag, o título é sobre o lag/travamento, não
sobre a frase solta da transcrição). Com confidence da análise < 0,5, seja descritivo e não invente detalhes.
Use action_start_s/reaction_end_s da análise como base para start_s/end_s."""
JUDGE_SYSTEM += """
Regras da resposta:
- keep=false para o que não rende; score de 0 a 10 (7+ = corte forte; abaixo de 5 = descartar).
- start_s e end_s em segundos da gravação, DENTRO da janela recebida e respeitando a duração mínima/máxima
informada; comece antes da ação (contexto) e termine logo depois da reação. Não corte no meio de uma frase.
- title: até 70 caracteres, chamativo mas verdadeiro, sem inventar o que não está na fala/tela.
- caption: 1–2 frases, SEM hashtags e sem link (o sistema acrescenta as hashtags do canal e do jogo e o crédito).
- hashtags: 2 a 4 tags DO MOMENTO, sem "#": a missão/atividade, o evento, o modo, o lugar, o item ou o personagem
que aparece NESTE trecho (ex.: nome da missão ou do assalto, "perseguição", "sorteio", "Lamborghini", "lag").
Prefira os termos do perfil do jogo (mecânicas, gírias) e o que o streamer e o chat falam. Nada genérico
("gameplay", "live", "viral"), nada que não aconteça aqui, e não repita o canal nem o nome do jogo.
- reason: uma frase dizendo por que manteve ou descartou (cite o que viu na tela, se ajudou).
- Não use ferramentas nem leia nada além do que foi entregue. Responda só com o JSON pedido."""
SCAN_SYSTEM = """Você é editor de cortes de live e está ASSISTINDO uma live por janelas de alguns minutos.
Recebe o contexto do jogo, a transcrição com tempos (segundos da gravação), frames da tela com o instante de
cada um, o chat (pode ser quase vazio: live pequena) e os cortes já feitos nessa região.
""" + CLIP_GUIDE + """
Tarefa: aponte de 0 a 2 momentos desta janela que dariam um bom corte SOZINHOS. Se nada rende, devolva
moments=[] (é o normal na maior parte do tempo — não force). Não repita um corte já feito.
- start_s/end_s dentro da janela recebida (pode começar até o limite de "volta" informado para pegar a ação),
com a duração mínima/máxima informada.
- screen_game: o jogo que aparece na tela (ou "desconhecido"); has_webcam: há câmera do streamer no quadro?
- summary: 1 frase do que está acontecendo na janela (vira memória para as próximas janelas).
- title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
PROFILE_SYSTEM = """Você pesquisa jogos para um editor de cortes de live em português do Brasil. Use a busca na
web para confirmar o que é o jogo (nome da categoria da Twitch pode ser abreviado ou ambíguo). Seja factual e
cite as fontes (URLs). Responda só com o JSON pedido, textos em português do Brasil.
- summary: 2–3 frases do que é o jogo e como se joga.
- mechanics: até 8 mecânicas/sistemas que aparecem em gameplay.
- clip_worthy: até 10 situações que rendem corte NESTE jogo (específicas, não genéricas).
- avoid: até 6 situações que parecem momento mas não rendem (menus, farm, fila...).
- jargon: até 12 termos/gírias que streamer e chat usam (para entender a transcrição).
- news: até 6 novidades recentes com mês/ano (lançamento, atualização, polêmica) que tornam informação valiosa.
- hashtags: 3 a 6 hashtags que o público usa para ESTE jogo no TikTok, Shorts e Reels (Brasil): o nome do jogo sem
espaço, abreviação conhecida, o modo/gênero quando for buscado (ex.: GTARP). A primeira é a principal do jogo.
Escreva com "#", sem inventar tag que ninguém usa.
- sources: até 5 URLs usadas.
Se vierem "pedidos do usuário", eles valem mais que a pesquisa: inclua o que ele pediu para acrescentar e respeite
o que ele mandou tirar ou corrigir (ele conhece o canal e o jogo)."""
REFINE_SYSTEM = """Você mantém o perfil de um jogo usado por um editor de cortes de live em português do Brasil.
Recebe o perfil ATUAL (JSON) e um PEDIDO do usuário (acrescentar, corrigir, tirar ou detalhar algo). Devolva o
perfil COMPLETO atualizado, no mesmo formato:
- mantenha tudo o que o pedido não mexe, com o mesmo texto;
- aplique o pedido no campo certo (situação que rende corte → clip_worthy; o que não rende → avoid; gíria → jargon;
mecânica → mechanics; novidade → news com mês/ano; hashtag do jogo → hashtags, com "#", a principal primeiro),
escrito no estilo dos itens que já estão lá;
- os limites de tamanho das listas podem crescer até 15 itens quando o usuário pedir para acrescentar;
- se precisar confirmar um fato, pode usar a busca na web e acrescentar a URL em sources;
- o usuário conhece o canal e o jogo: o que ele afirma vale, mesmo que você não ache na web;
- se vier uma SEÇÃO em foco, o pedido é sobre ela: mexa nela (outras só se o pedido disser);
- pode transformar um pedido genérico em itens concretos e úteis para o editor (ex.: "reação do streamer conta"
vira "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga");
- reply: 1–2 frases para o usuário dizendo o que você mudou (ou, se o pedido for uma pergunta, a resposta).
Textos em português do Brasil. Responda só com o JSON pedido."""
REFINE_SCHEMA = {
"type": "object",
"properties": {**PROFILE_SCHEMA["properties"], "reply": {"type": "string"}},
"required": [*PROFILE_SCHEMA["required"], "reply"],
"additionalProperties": False,
}
PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas",
"hashtags": "Hashtags",
"news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes"}
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e,
se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro:
x, y = canto superior esquerdo; w, h = largura e altura. Sem webcam: has_webcam=false e x=y=w=h=0.
game_on_screen: o jogo que aparece (ou "desconhecido"). Responda só com o JSON pedido."""
@dataclass(frozen=True)
class Verdict:
keep: bool
score: float
start_s: float
end_s: float
title: str
caption: str
reason: str
model: str
# Tags DO MOMENTO (sem "#"), escolhidas pela IA; as do canal e do jogo o sistema põe (app/hashtags.py).
hashtags: tuple[str, ...] = ()
class JudgeError(RuntimeError):
pass
# ---------------------------------------------------------------- prompts
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
confirmed: bool = False) -> str:
lines = [f"Título da live: {live_title or '(desconhecido)'}"]
if confirmed:
# O usuário confirmou no painel: não questionar (jogo novo/pouco conhecido lembra outros na tela).
lines.append(f"Jogo CONFIRMADO pelo usuário: {game}. A tela pode lembrar outro jogo parecido (ex.: GTA, "
f"Warzone) — não questione o jogo; use o perfil abaixo para entender o que acontece.")
else:
lines.append(f"Jogo pela categoria da plataforma: {game or '(desconhecida)'}")
if screen_game and screen_game.lower() not in (game or "").lower():
lines.append(f"Jogo que a IA viu na tela recentemente: {screen_game} (confira nos frames; a categoria pode estar errada)")
if profile:
lines.append(f"Perfil do jogo: {profile.get('summary', '')}")
for key, label in (("clip_worthy", "Rende corte neste jogo"), ("avoid", "Não rende"),
("mechanics", "Mecânicas/atividades (termos para as hashtags do momento)"),
("jargon", "Gírias/termos"), ("news", "Novidades")):
if profile.get(key):
lines.append(f"{label}: " + "; ".join(profile[key][:10]))
if history:
lines.append(f"O que aconteceu antes na live: {history}")
return "\n".join(lines)
def _transcript(words: list[Word], lo: float, hi: float) -> str:
lines, current, current_t = [], [], None
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start):
if current_t is None or word.start - current_t > 4 or len(current) >= 14:
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
current, current_t = [], word.start
current.append(word.word)
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
return "\n".join(lines) or "(sem fala transcrita)"
def _chat_block(chat: list[ChatMessage], lo: float, hi: float, focus: float | None, bucket_s: int = 5) -> str:
buckets: dict[int, int] = {}
emotes: dict[str, int] = {}
sample: list[str] = []
for message in chat:
if lo <= message.t <= hi:
b = int(message.t // bucket_s * bucket_s)
buckets[b] = buckets.get(b, 0) + 1
for e in set(message.emotes):
emotes[e] = emotes.get(e, 0) + 1
near = focus is None or focus - 10 <= message.t <= focus + 8
if near and len(sample) < 60:
sample.append(f"[{message.t:.0f}s] {message.text[:80]}")
rate = ", ".join(f"{t}s:{n}" for t, n in sorted(buckets.items())) or "sem chat"
top = ", ".join(f"{e}×{n}" for e, n in sorted(emotes.items(), key=lambda kv: -kv[1])[:12]) or "nenhum"
return (f"Mensagens do chat por {bucket_s} s: {rate}\nEmotes mais usados: {top}\n"
f"Amostra do chat:\n" + ("\n".join(sample) or "(sem chat)"))
def _frames_block(frames: list[tuple[float, Path]]) -> str:
if not frames:
return "Frames: (nenhum)"
return "Frames anexados, em ordem: " + ", ".join(f"#{i + 1} = {t:.0f}s" for i, (t, _) in enumerate(frames))
def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, peak_s: float,
words: list[Word], chat: list[ChatMessage], heuristic: dict, live_title: str = "", *,
context: str = "", frames: list[tuple[float, Path]] | None = None,
backtrack_s: float = DEFAULT_BACKTRACK_S, min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S,
face: str = "") -> str:
"""Prompt do juiz. Janela = candidato com `backtrack_s` para trás (a ação vem antes do comentário).
`face`: resumo do rosto do streamer na janela (face.FaceService.summary); vazio = sem câmera/rastreio."""
lo, hi = max(0.0, start_s - backtrack_s), end_s + CONTEXT_AFTER_S
return (
f"Canal: {streamer} ({platform})\n"
+ (context or f"Título da live: {live_title or '(desconhecido)'}") + "\n\n"
f"Janela disponível: {lo:.0f}s a {hi:.0f}s. Candidato da heurística: {start_s:.0f}s a {end_s:.0f}s; "
f"pico de reação em {peak_s:.0f}s. Duração do corte: {min_s:.0f} a {max_s:.0f} s.\n"
f"Sinais da heurística: {json.dumps(heuristic, ensure_ascii=False)}\n"
+ (f"Rosto do streamer (expressão medida na webcam, relativa ao normal dele): {face}\n" if face else "")
+ f"{_frames_block(frames or [])}\n\n"
f"Transcrição:\n{_transcript(words, lo, hi)}\n\n"
f"{_chat_block(chat, lo, hi, peak_s)}"
)
def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_lo: float, words: list[Word],
chat: list[ChatMessage], context: str, frames: list[tuple[float, Path]],
existing: list[tuple[float, float, str]], min_s: float, max_s: float) -> str:
done = "; ".join(f"{a:.0f}–{b:.0f}s ({t[:40]})" for a, b, t in existing) or "nenhum"
return (
f"Canal: {streamer} ({platform})\n{context}\n\n"
f"Janela nova: {lo:.0f}s a {hi:.0f}s (pode voltar até {back_lo:.0f}s para pegar o início de uma ação).\n"
f"Duração do corte: {min_s:.0f} a {max_s:.0f} s. Cortes já feitos aqui: {done}\n"
f"{_frames_block(frames)}\n\n"
f"Transcrição:\n{_transcript(words, back_lo, hi)}\n\n"
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10)}"
)
def _clean(data: dict, start_s: float, end_s: float, model: str, lo: float | None = None, hi: float | None = None,
min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S) -> Verdict:
# `hashtags` é opcional na leitura: resposta sem ele (modelo antigo/cache) segue com as tags do canal e do jogo.
missing = [k for k in VERDICT_SCHEMA["required"] if k not in data and k != "hashtags"]
if missing:
raise JudgeError(f"resposta sem os campos {missing}")
lo = max(0.0, start_s - DEFAULT_BACKTRACK_S) if lo is None else lo
hi = end_s + CONTEXT_AFTER_S if hi is None else hi
# Mínimo de verdade (pedido do dono, 17/11/2026): se o fim bate em `hi`, o início recua (antes ficava curto).
new_start, new_end = fit_window(float(data["start_s"]), float(data["end_s"]), lo, hi, min_s, max_s, keep="start")
if new_end - new_start < min(10.0, min_s): # resposta incoerente: fica com o candidato da heurística
new_start, new_end = start_s, end_s
return Verdict(
keep=bool(data["keep"]), score=max(0.0, min(10.0, float(data["score"]))),
start_s=round(new_start, 2), end_s=round(new_end, 2),
title=str(data["title"]).strip()[:100], caption=str(data["caption"]).strip()[:600],
reason=str(data["reason"]).strip()[:300], model=model,
hashtags=tuple(str(t).strip()[:40] for t in (data.get("hashtags") or [])[:6] if str(t).strip()),
)
# ---------------------------------------------------------------- executáveis das CLIs
def find_codex() -> list[str] | None:
"""Comando do Codex. No Windows o npm instala `codex.cmd` (lote não roda sem shell e escapa mal argumentos):
como no painel (agents.ts), rodamos o `codex.js` do pacote direto pelo Node."""
env = os.environ.get("CODEX_BIN")
if env:
return [shutil.which("node") or "node", env] if env.endswith(".js") else [env]
exe = shutil.which("codex.exe") if sys.platform == "win32" else shutil.which("codex")
if exe:
return [exe]
cmd = shutil.which("codex.cmd") or shutil.which("codex")
node = shutil.which("node")
if cmd and node:
js = Path(cmd).parent / "node_modules" / "@openai" / "codex" / "bin" / "codex.js"
if js.is_file():
return [node, str(js)]
return None
def find_claude() -> list[str] | None:
env = os.environ.get("CLAUDE_BIN")
if env:
return [env]
exe = shutil.which("claude.exe") if sys.platform == "win32" else shutil.which("claude")
return [exe] if exe else None
def codex_models(cache: Path | None = None) -> list[dict]:
"""Modelos que o Codex lista para esta conta (cache que a própria CLI mantém)."""
cache = cache or Path.home() / ".codex" / "models_cache.json"
try:
data = json.loads(cache.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError):
return [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
out = []
for m in data.get("models", []):
if isinstance(m, dict) and m.get("slug") and m.get("visibility", "list") == "list":
out.append({"id": m["slug"], "label": m.get("display_name") or m["slug"], "description": m.get("description", "")})
return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
# ---------------------------------------------------------------- IA
class Judge:
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = ""):
self.provider = provider if provider in PROVIDERS else "codex"
self.model = model or DEFAULT_MODELS.get(self.provider, "")
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor.
self.analyst_model = analyst_model
self.workdir = workdir
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None:
if provider not in PROVIDERS:
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
self.provider = provider
self.model = model.strip() or DEFAULT_MODELS.get(provider, "")
if analyst_model is not None:
self.analyst_model = analyst_model.strip()
@property
def enabled(self) -> bool:
return self.provider in ("codex", "claude")
def command(self) -> list[str] | None:
return find_codex() if self.provider == "codex" else find_claude() if self.provider == "claude" else None
def describe(self) -> dict:
cmd = self.command() if self.enabled else None
return {"provider": self.provider, "model": self.model if self.enabled else None,
"analystModel": (self.analyst_model or self.model) if self.enabled else None,
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None}
def models(self) -> dict:
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "defaults": DEFAULT_MODELS}
# ---------- usos
def analyze(self, prompt: str, images: list[Path]) -> dict:
"""1º juiz (ANALISTA): o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título."""
data = self.ask(ANALYST_SYSTEM, prompt, ANALYSIS_SCHEMA, images, model=self.analyst_model or self.model)
missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data]
if missing:
raise JudgeError(f"análise sem os campos {missing}")
data["confidence"] = max(0.0, min(1.0, float(data["confidence"])))
return data
def judge(self, prompt: str, start_s: float, end_s: float, images: list[Path] | None = None, *,
lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
max_s: float = DEFAULT_MAX_S) -> Verdict:
data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or [])
return _clean(data, start_s, end_s, f"{self.provider}:{self.model}", lo, hi, min_s, max_s)
def scan(self, prompt: str, images: list[Path]) -> dict:
data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images)
if not isinstance(data.get("moments"), list):
raise JudgeError("varredura sem a lista de momentos")
return data
def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict:
prompt = f"Categoria/jogo da live: {name}\nTítulo da live (pista extra): {live_title or '(nenhum)'}\n"
if notes:
prompt += "Pedidos do usuário (respeite):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
prompt += "Pesquise e devolva o perfil do jogo."
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S)
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> dict:
"""Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro
mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior."""
prompt = f"Jogo: {name}\nPerfil ATUAL:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
if section in PROFILE_SECTIONS:
prompt += f"SEÇÃO em foco: {section} ({PROFILE_SECTIONS[section]})\n"
if history:
prompt += "Conversa até aqui:\n" + "\n".join(
f"{'Usuário' if h.get('role') == 'user' else 'IA'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
prompt += f"PEDIDO do usuário:\n{instruction}\n\nDevolva o perfil completo atualizado e o reply."
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S)
def detect_cam(self, images: list[Path]) -> dict:
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images)
# ---------- execução
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
timeout: int = TIMEOUT_S, model: str | None = None) -> dict:
model = model or self.model
if self.provider == "codex":
return self._codex(system, prompt, schema, images, search, timeout, model)
if self.provider == "claude":
return self._claude(system, prompt, schema, images, search, timeout, model)
raise JudgeError("IA desligada")
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int) -> subprocess.CompletedProcess:
try:
result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd,
creationflags=NO_WINDOW)
except subprocess.TimeoutExpired as exc:
raise JudgeError(f"a CLI passou de {timeout} s") from exc
except OSError as exc:
raise JudgeError(f"não consegui rodar a CLI: {exc}") from exc
if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-2:]
raise JudgeError(f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}")
return result
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_codex()
if not cmd:
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)")
self.workdir.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(dir=self.workdir) as tmp:
schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json"
schema_file.write_text(json.dumps(schema), encoding="utf-8")
image_args = [arg for img in images for arg in ("-i", str(Path(img).resolve()))]
lean = codex_lean_overrides(search)
if search:
stdin = system + "\n\n---\n\n" + prompt
else:
# Sem ferramentas, o texto do juiz faz o papel das instruções de base do Codex (como o
# --system-prompt do Claude). String literal do TOML ('...'): o caminho do Windows não é escapado.
instructions = Path(tmp) / "instructions.md"
instructions.write_text(system, encoding="utf-8")
lean += ["-c", f"model_instructions_file='{instructions}'"]
stdin = prompt
# `--search` é opção global (antes de `exec`). Cada imagem com seu `-i`; o "-" (prompt pela entrada
# padrão) vem depois de uma opção de valor único para não ser lido como mais uma imagem.
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral",
"--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args,
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
self._run(args, stdin, Path(tmp), timeout)
try:
return json.loads(out.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise JudgeError("o Codex não devolveu o JSON pedido") from exc
def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_claude()
if not cmd:
raise JudgeError("Claude Code CLI não encontrado")
self.workdir.mkdir(parents=True, exist_ok=True)
tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else [])
extra: list[str] = []
if images:
# O Claude vê imagem lendo o arquivo (ferramenta Read): liberamos só a pasta das imagens.
for folder in sorted({str(Path(i).resolve().parent) for i in images}):
extra += ["--add-dir", folder]
prompt += "\n\nImagens (leia cada uma com a ferramenta Read, na ordem):\n" + "\n".join(
str(Path(i).resolve()) for i in images)
args = [*cmd, "-p", "--model", model, "--output-format", "json", "--json-schema", json.dumps(schema),
"--tools", ",".join(tools), *(["--allowedTools", ",".join(tools)] if tools else []), *extra,
# --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s).
"--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local",
"--system-prompt", system]
result = self._run(args, prompt, self.workdir, timeout)
try:
envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu JSON") from exc
if envelope.get("is_error"):
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
data = envelope.get("structured_output")
if not isinstance(data, dict):
try:
data = json.loads(envelope.get("result") or "")
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu o JSON pedido") from exc
return data
def analysis_block(analysis: dict) -> str:
"""Análise do 1º juiz no formato que o editor lê."""
return "Análise do ANALISTA (cruzou tela, fala e chat):\n" + json.dumps(analysis, ensure_ascii=False, indent=1)
+415
View File
@@ -0,0 +1,415 @@
"""Configuração do corte: formato (vertical/horizontal), layout, câmera do streamer, legenda, crédito e duração.
Fica por CANAL (padrão do streamer: a webcam dele mora sempre no mesmo canto) e pode ser sobrescrita por SESSÃO.
Efetiva = padrão ← canal ← sessão (campo a campo). O painel edita pelo modal de "Configuração do corte".
Formato (`format.aspect`):
- `vertical` (padrão): 1080×1920, para Shorts/Reels/TikTok;
- `horizontal`: 1920×1080, para o YouTube "tela grande" mostrando o próprio jogo.
Layouts no vertical (1080×1920):
- `blur`: vídeo 16:9 inteiro no meio, o próprio vídeo ampliado e desfocado no fundo (sem câmera definida);
- `cam_top`: webcam recortada em cima (`camHeight` da altura, padrão 1/3) + jogo embaixo, recortado no centro;
- `game_only`: só o jogo, recortado para preencher a tela (ou a região `game`, se definida);
- `cam_only`: a câmera do streamer em tela cheia.
No horizontal (1920×1080) só existem dois resultados: `cam_only` (câmera em tela cheia, se marcada) e "quadro
inteiro" (`full`, interno) para todos os outros modos — o quadro original inteiro, ou a região `game` se marcada.
Retângulos (`cam`, `game`) são normalizados 0–1 sobre o quadro original (x, y, w, h).
Textos (legenda, crédito, gancho, textos, chat, capa) são desenhados em ASS num QUADRO LÓGICO (`canvas_size`):
no vertical é o próprio 1080×1920; no horizontal é 2560×1440, que o libass reduz para 1920×1080 (escala 0,75).
Assim os mesmos tamanhos em px (legenda 84, gancho 68…) ficam proporcionais à altura menor do horizontal sem
mudar o JSON. Posições 0–1 continuam relativas ao quadro.
"""
from __future__ import annotations
import copy
import hashlib
import json
import logging
import re
from pathlib import Path
log = logging.getLogger("cenaforge_clipper.layout")
ASPECTS = ("vertical", "horizontal")
# Qualidades de gravação da live (grupo `capture`; regras e medições em app/capture.py).
CAPTURE_QUALITIES = ("best", "1440p", "1080p", "720p", "480p")
FRAME_SIZES = {"vertical": (1080, 1920), "horizontal": (1920, 1080)}
# Quadro lógico do ASS: no horizontal, 2560×1440 → o vídeo 1920×1080 mostra os textos a 75 %.
CANVAS_SIZES = {"vertical": (1080, 1920), "horizontal": (2560, 1440)}
W, H = FRAME_SIZES["vertical"] # compatibilidade: o quadro do vertical (padrão)
# cam_only = a câmera do streamer em tela cheia (sem o jogo), para o trecho em que a reação é o assunto.
MODES = ("auto", "blur", "cam_top", "game_only", "cam_only")
HEX_RE = re.compile(r"^#[0-9A-Fa-f]{6}$")
SYSTEM_FONTS = ("Arial Black", "Arial", "Impact", "Verdana", "Segoe UI Black", "Trebuchet MS")
# Fontes de vídeo curto EMPACOTADAS no repositório (assets/fonts, pasta plana: o fontsdir do libass não lê subpastas),
# com licença livre ao lado de cada arquivo e sha256 no fonts.lock.json. Pedido do dono (17/11/2026): escolher fonte
# na legenda, no gancho e nos textos.
FONTS_DIR = Path(__file__).resolve().parents[2] / "assets" / "fonts"
def _load_packaged_fonts(folder: Path) -> dict[str, str]:
"""{família: caminho relativo à raiz do repositório} das fontes do lock que existem e batem o sha256."""
try:
lock = json.loads((folder / "fonts.lock.json").read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
out = {}
for entry in lock.get("files", []):
file = folder.parent.parent / entry["path"]
try:
ok = hashlib.sha256(file.read_bytes()).hexdigest() == entry["sha256"]
except OSError:
ok = False
if ok:
out[entry["family"]] = entry["path"]
else:
log.warning("fonte %s ausente ou com sha256 diferente do lock: fora da lista", entry.get("path"))
return out
PACKAGED_FONTS = _load_packaged_fonts(FONTS_DIR)
FONTS = SYSTEM_FONTS + tuple(PACKAGED_FONTS)
HOOK_STYLES = ("plain", "banner")
HOOK_ANIMS = ("pop", "fade", "none", "slide")
# Gancho em tarja (referência do dono, 17/11/2026: tarja verde-limão atravessa a tela e o texto entra borrado e assenta
# nítido, letras brancas "cartoon" com contorno preto). Fonte padrão: Luckiest Guy, se estiver empacotada.
HOOK_FONT = "Luckiest Guy" if "Luckiest Guy" in PACKAGED_FONTS else "Arial Black"
# Margem do mínimo (pedido do dono, 17/11/2026: "se o mínimo é 60 tem que ser 60; o certo é sempre 1 s a mais").
# +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final.
DURATION_MARGIN_S = 1.0
DURATION_SLACK_S = 0.1
DEFAULTS: dict = {
"layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34},
"caption": {
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
},
"credit": {"enabled": True, "position": "top", "size": 44},
"duration": {"minS": 60, "maxS": 90, "backtrackS": 120},
"format": {"aspect": "vertical"},
# Gancho que o projeto da IA põe no começo do corte (o editor pode trocar por corte).
"hook": {"style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": HOOK_FONT, "anim": "slide", "seconds": 3.0},
# Qualidade de GRAVAÇÃO da live (app/capture.py): `best` = a maior que a live oferece; os outros são teto.
# Vale na próxima gravação ou retomada (a captura em andamento não troca de qualidade no meio).
"capture": {"quality": "best"},
}
class LayoutError(ValueError):
pass
def merge(*layers: dict | None) -> dict:
"""Mescla campo a campo (padrão ← canal ← sessão). Camadas vazias são ignoradas."""
out = copy.deepcopy(DEFAULTS)
for layer in layers:
for group, values in (layer or {}).items():
if group in out and isinstance(values, dict):
out[group].update({k: v for k, v in values.items() if k in out[group]})
return out
def _rect(value, name: str) -> dict | None:
if value is None:
return None
if not isinstance(value, dict) or set(value) != {"x", "y", "w", "h"}:
raise LayoutError(f"{name} precisa ser {{x, y, w, h}} (0–1) ou null")
r = {k: float(value[k]) for k in ("x", "y", "w", "h")}
if not (0 <= r["x"] < 1 and 0 <= r["y"] < 1 and 0.03 <= r["w"] <= 1 and 0.03 <= r["h"] <= 1
and r["x"] + r["w"] <= 1.0001 and r["y"] + r["h"] <= 1.0001):
raise LayoutError(f"{name} fora do quadro (valores 0–1, largura/altura ≥ 0,03)")
return {k: round(v, 4) for k, v in r.items()}
def validate(settings: dict) -> dict:
"""Valida uma camada parcial (canal ou sessão) e devolve só os campos conhecidos, normalizados."""
if not isinstance(settings, dict):
raise LayoutError("configuração precisa ser um objeto")
out: dict = {}
lay = settings.get("layout")
if lay is not None:
o: dict = {}
if "mode" in lay:
if lay["mode"] not in MODES:
raise LayoutError(f"layout.mode precisa ser um de {', '.join(MODES)}")
o["mode"] = lay["mode"]
if "cam" in lay:
o["cam"] = _rect(lay["cam"], "layout.cam")
if "game" in lay:
o["game"] = _rect(lay["game"], "layout.game")
if "camHeight" in lay:
o["camHeight"] = float(lay["camHeight"])
if not 0.2 <= o["camHeight"] <= 0.6:
raise LayoutError("layout.camHeight vai de 0,2 a 0,6")
out["layout"] = o
cap = settings.get("caption")
if cap is not None:
o = {}
for key in ("color", "highlight", "outline"):
if key in cap:
if not HEX_RE.match(str(cap[key])):
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
o[key] = str(cap[key]).upper()
if "font" in cap:
if cap["font"] not in FONTS:
raise LayoutError(f"caption.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = cap["font"]
for key, lo, hi in (("size", 40, 140), ("outlineWidth", 0, 14), ("maxWords", 1, 6)):
if key in cap:
o[key] = int(cap[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
if "y" in cap:
o["y"] = None if cap["y"] is None else float(cap["y"])
if o["y"] is not None and not 0.08 <= o["y"] <= 0.9:
raise LayoutError("caption.y vai de 0,08 a 0,9 (fração da altura) ou null = automático")
for key in ("enabled", "uppercase"):
if key in cap:
o[key] = bool(cap[key])
out["caption"] = o
cred = settings.get("credit")
if cred is not None:
o = {}
if "enabled" in cred:
o["enabled"] = bool(cred["enabled"])
if "position" in cred:
if cred["position"] not in ("top", "bottom"):
raise LayoutError("credit.position precisa ser top ou bottom")
o["position"] = cred["position"]
if "size" in cred:
o["size"] = int(cred["size"])
if not 24 <= o["size"] <= 80:
raise LayoutError("credit.size vai de 24 a 80")
out["credit"] = o
dur = settings.get("duration")
if dur is not None:
o = {}
for key, lo, hi in (("minS", 5, 120), ("maxS", 15, 180), ("backtrackS", 0, 120)):
if key in dur:
o[key] = float(dur[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"duration.{key} vai de {lo} a {hi}")
out["duration"] = o
if "duration" in out and out["duration"].get("minS", 0) >= out["duration"].get("maxS", 999):
raise LayoutError("duration.minS precisa ser menor que maxS")
hook = settings.get("hook")
if hook is not None:
if not isinstance(hook, dict):
raise LayoutError("hook precisa ser um objeto")
o = {}
if "style" in hook:
if hook["style"] not in HOOK_STYLES:
raise LayoutError(f"hook.style precisa ser um de {', '.join(HOOK_STYLES)}")
o["style"] = hook["style"]
for key in ("bg", "color"):
if key in hook:
if not HEX_RE.match(str(hook[key])):
raise LayoutError(f"hook.{key} precisa ser cor #RRGGBB")
o[key] = str(hook[key]).upper()
if "font" in hook:
if hook["font"] not in FONTS:
raise LayoutError(f"hook.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = hook["font"]
if "anim" in hook:
if hook["anim"] not in HOOK_ANIMS:
raise LayoutError(f"hook.anim precisa ser um de {', '.join(HOOK_ANIMS)}")
o["anim"] = hook["anim"]
if "seconds" in hook:
o["seconds"] = float(hook["seconds"])
if not 1 <= o["seconds"] <= 8:
raise LayoutError("hook.seconds vai de 1 a 8")
out["hook"] = o
fmt = settings.get("format")
if fmt is not None:
if not isinstance(fmt, dict):
raise LayoutError("format precisa ser um objeto")
o = {}
if "aspect" in fmt:
if fmt["aspect"] not in ASPECTS:
raise LayoutError(f"format.aspect precisa ser um de {', '.join(ASPECTS)}")
o["aspect"] = fmt["aspect"]
out["format"] = o
cap = settings.get("capture")
if cap is not None:
if not isinstance(cap, dict):
raise LayoutError("capture precisa ser um objeto")
o = {}
if "quality" in cap:
if cap["quality"] not in CAPTURE_QUALITIES:
raise LayoutError(f"capture.quality precisa ser um de {', '.join(CAPTURE_QUALITIES)}")
o["quality"] = cap["quality"]
out["capture"] = o
return out
def min_target(settings: dict) -> float:
"""Duração final mínima de um corte AUTOMÁTICO: `minS` + 1 s (+ folga de quadro), sem passar de `maxS`."""
dur = settings.get("duration") or DEFAULTS["duration"]
return round(min(float(dur["maxS"]), float(dur["minS"]) + DURATION_MARGIN_S + DURATION_SLACK_S), 3)
def font_files() -> dict[str, str]:
"""{família: caminho do arquivo relativo à raiz do repositório} das fontes empacotadas (o painel carrega o mesmo)."""
return dict(PACKAGED_FONTS)
def ass_filter(ass_name: str, ass_text: str | None = None) -> str:
"""`ass=<arquivo>`; com `:fontsdir=` (pasta das fontes empacotadas) só quando o ASS usa uma delas — assim o
filtro de projetos antigos (só fontes do Windows) fica idêntico ao de antes."""
if ass_text and PACKAGED_FONTS and any(f",{fam}," in ass_text or f"\\fn{fam}" in ass_text for fam in PACKAGED_FONTS):
# Caminho absoluto entre aspas, com ":" escapado (medido: sem aspas o FFmpeg recusa o grafo no Windows).
return f"ass={ass_name}:fontsdir='{FONTS_DIR.as_posix().replace(':', chr(92) + ':')}'"
return f"ass={ass_name}"
def aspect(settings: dict) -> str:
"""Formato do corte (`vertical` ou `horizontal`). Configuração sem o grupo `format` (antiga) = vertical."""
value = (settings.get("format") or {}).get("aspect", "vertical")
return value if value in ASPECTS else "vertical"
def frame_size(settings: dict) -> tuple[int, int]:
"""Tamanho do vídeo de saída (largura, altura)."""
return FRAME_SIZES[aspect(settings)]
def canvas_size(settings: dict) -> tuple[int, int]:
"""Quadro lógico do ASS (PlayResX, PlayResY): posições e tamanhos dos textos são contados nele."""
return CANVAS_SIZES[aspect(settings)]
def resolved_mode(settings: dict) -> str:
"""Modo efetivo do layout. No horizontal só há `cam_only` (com câmera marcada) e `full` (quadro inteiro)."""
mode = settings["layout"]["mode"]
if aspect(settings) == "horizontal":
return "cam_only" if mode == "cam_only" and settings["layout"]["cam"] else "full"
if mode == "auto":
return "cam_top" if settings["layout"]["cam"] else "blur"
if mode in ("cam_top", "cam_only") and not settings["layout"]["cam"]:
return "blur" # sem câmera marcada não dá para montar o layout com câmera
return mode
def _crop(rect: dict | None) -> str:
if not rect:
return "iw:ih:0:0"
return f"iw*{rect['w']}:ih*{rect['h']}:iw*{rect['x']}:ih*{rect['y']}"
def _fill(width: int, height: int) -> str:
"""Escala cobrindo e recorta no centro para width×height."""
return f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}"
def _fit(width: int, height: int) -> str:
"""Escala cabendo inteiro (sem cortar nem distorcer) e completa com faixas pretas até width×height."""
return (f"scale={width}:{height}:force_original_aspect_ratio=decrease:force_divisible_by=2,"
f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color=black")
def cam_panel_height(settings: dict) -> int:
"""Altura (px do vídeo vertical) do painel da câmera no `cam_top`."""
return int(round(H * settings["layout"]["camHeight"] / 2)) * 2
def layout_chain(settings: dict, src: str, dst: str, tail: str = "", suffix: str = "", mode: str | None = None,
reframe=None) -> str:
"""Trecho de filtergraph: [src] (quadro original) → [dst] no tamanho do formato (1080×1920 ou 1920×1080).
`tail` = filtros extras (com vírgula na frente) antes do rótulo final; `suffix` deixa os rótulos internos únicos
(vários trechos no mesmo grafo, no editor); `mode` sobrescreve o modo (troca de layout por trecho).
`reframe` = função (proporção da área do jogo → filtro, de `reframe.py`) que reenquadra o jogo no tempo: a janela
vira a área do jogo (parte de baixo no `cam_top`; a tela toda nos outros modos, inclusive `blur`) e `layout.game`
é ignorado. Não vale para `cam_only`."""
if mode and mode != "auto":
settings = {**settings, "layout": {**settings["layout"], "mode": mode}}
mode = resolved_mode(settings)
lay = settings["layout"]
s = suffix
if reframe is not None and mode != "cam_only":
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]{reframe(W / (H - top))},scale={W}:{H - top},setsar=1[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
fw, fh = frame_size(settings)
return f"[{src}]{reframe(fw / fh)},scale={fw}:{fh},setsar=1{tail}[{dst}]"
if aspect(settings) == "horizontal":
fw, fh = frame_size(settings)
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(fw, fh)}{tail}[{dst}]"
if lay["game"]: # região do jogo marcada: preenche a tela (recorta no centro, sem distorcer)
return f"[{src}]crop={_crop(lay['game'])},{_fill(fw, fh)}{tail}[{dst}]"
# Quadro original inteiro (16:9 já preenche; outra proporção ganha faixas pretas em vez de ser cortada).
return f"[{src}]{_fit(fw, fh)}{tail}[{dst}]"
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]crop={_crop(lay['game'])},{_fill(W, H - top)}[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
if mode == "game_only":
return f"[{src}]crop={_crop(lay['game'])},{_fill(W, H)}{tail}[{dst}]"
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(W, H)}{tail}[{dst}]"
return (
f"[{src}]split=2[bg{s}][fg{s}];"
f"[bg{s}]{_fill(W, H)},boxblur=25:2,eq=brightness=-0.08[bg2{s}];"
f"[fg{s}]scale=1080:-2[fg2{s}];"
f"[bg2{s}][fg2{s}]overlay=(W-w)/2:(H-h)/2-80{tail}[{dst}]"
)
def video_filter(settings: dict, ass_name: str | None, ass_text: str | None = None, reframe=None) -> str:
"""filter_complex de [0:v] → [v] no tamanho do formato, 30 fps, com a legenda (se houver). `ass_text` = conteúdo
do ASS (decide se o libass precisa da pasta das fontes empacotadas); `reframe` = ver `layout_chain`."""
tail = (f",{ass_filter(ass_name, ass_text)}" if ass_name else "") + ",fps=30,format=yuv420p"
return layout_chain(settings, "0:v", "v", tail, reframe=reframe)
def caption_y(settings: dict) -> int:
"""Centro vertical da legenda em px do quadro lógico do ASS (`canvas_size`). Automático: na emenda câmera/jogo
(cam_top) ou ~74 % da altura no vertical; no horizontal, 85 % da altura (terço de baixo, acima do rodapé)."""
y = settings["caption"]["y"]
_, ch = canvas_size(settings)
if y is not None:
return int(ch * y)
if aspect(settings) == "horizontal":
return int(ch * 0.85)
if resolved_mode(settings) == "cam_top":
return cam_panel_height(settings) + 40
return 1420
def credit_placement(settings: dict) -> tuple[int, int, int]:
"""(alinhamento ASS, margem lateral, margem vertical) do crédito do canal no quadro lógico.
Vertical: centralizado, abaixo da área do título das redes (topo) ou acima da barra (rodapé); com a câmera em
cima, desce para o pé do painel da câmera. Horizontal: no canto direito, para não cobrir o meio do jogo."""
cred = settings["credit"]
if aspect(settings) == "horizontal":
return (9, 48, 36) if cred["position"] == "top" else (3, 48, 36)
align, margin = (8, 170) if cred["position"] == "top" else (2, 90)
if cred["position"] == "top" and resolved_mode(settings) == "cam_top":
# Com a câmera em cima, o topo é o rosto do streamer: o crédito desce para o pé do painel da câmera.
margin = max(20, cam_panel_height(settings) - cred["size"] - 34)
return align, 40, margin
def ass_color(hex_rgb: str) -> str:
"""#RRGGBB → &H00BBGGRR& para a linha Style (ASS guarda em BGR, com alfa na frente)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H00{b}{g}{r}&".upper()
def ass_inline_color(hex_rgb: str) -> str:
"""#RRGGBB → &HBBGGRR& para a tag \\c dentro do texto (sem alfa)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H{b}{g}{r}&".upper()
+681
View File
@@ -0,0 +1,681 @@
"""API do Clipador (127.0.0.1:4520, faixa 4500–4599 do CenaForge). Toda rota, exceto GET /health, exige
`X-Service-Key` = CLIPPER_SERVICE_KEY (clipper/.env). Quem chama é o painel (panel/src/lib/clipper.ts)."""
from __future__ import annotations
import hmac
import logging
from contextlib import asynccontextmanager
from typing import Literal
from fastapi import FastAPI, Query, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from .config import ConfigError, Settings
import json
from pathlib import Path
from . import capture, layout, media
from .config import REPO_ROOT
from .db import Database, loads, now
from .judge import JudgeError
from .scoring import timeline as timeline_series
from .scoring import Word
from .sources import SourceError, parse_source
from .subtitles import build_ass
from .worker import Engine
from . import clip_delete, editor_api
VERSION = "1.0.0"
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
class UserError(Exception):
def __init__(self, message: str, status: int = 400):
super().__init__(message)
self.message, self.status = message, status
class ChannelIn(BaseModel):
url: str = Field(min_length=3, max_length=300)
displayName: str | None = Field(default=None, max_length=60)
monitor: bool = True
authorized: bool = False
class ChannelPatch(BaseModel):
displayName: str | None = Field(default=None, max_length=60)
monitor: bool | None = None
authorized: bool | None = None
class SessionIn(BaseModel):
url: str = Field(min_length=3, max_length=300)
class ManualClipIn(BaseModel):
"""Corte manual: os últimos `lastS` segundos gravados, ou o trecho [startS, endS]."""
lastS: float | None = Field(default=None, ge=5, le=180)
startS: float | None = Field(default=None, ge=0)
endS: float | None = Field(default=None, ge=0)
class JudgeIn(BaseModel):
provider: Literal["codex", "claude", "off"]
model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
minScore: float = Field(default=6, ge=0, le=10)
# Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer.
analystModel: str | None = Field(default=None, max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
# Varredura da IA (procura momentos sem pico de chat), visão (frames da tela) e detecção da webcam.
scanEnabled: bool | None = None
scanIntervalS: int | None = Field(default=None, ge=60, le=900)
vision: bool | None = None
camDetect: bool | None = None
# Rastreio do rosto do streamer (face.py): reforça/cria cortes e vai em texto para o analista.
faceTrack: bool | None = None
class GameIn(BaseModel):
name: str = Field(min_length=1, max_length=120)
class GameProfileIn(BaseModel):
"""Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve)."""
name: str = Field(default="", max_length=120)
summary: str = Field(default="", max_length=1500)
genre: str = Field(default="", max_length=120)
mechanics: list[str] = Field(default_factory=list, max_length=30)
clip_worthy: list[str] = Field(default_factory=list, max_length=30)
avoid: list[str] = Field(default_factory=list, max_length=30)
jargon: list[str] = Field(default_factory=list, max_length=40)
news: list[str] = Field(default_factory=list, max_length=30)
hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py)
sources: list[str] = Field(default_factory=list, max_length=20)
class ChatTurnIn(BaseModel):
role: Literal["user", "ai"]
text: str = Field(max_length=1500)
class GameRefineIn(BaseModel):
instruction: str = Field(min_length=3, max_length=1500)
search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo
section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources"] = ""
history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção
class PreviewIn(BaseModel):
t: float | None = Field(default=None, ge=0)
settings: dict = Field(default_factory=dict)
class ClipPatch(BaseModel):
status: Literal["approved", "rejected", "ready", "published"] | None = None
title: str | None = Field(default=None, max_length=100)
caption: str | None = Field(default=None, max_length=2200)
startS: float | None = Field(default=None, ge=0)
endS: float | None = Field(default=None, ge=0)
ClipStatusName = Literal["candidate", "discarded", "pending", "rendering", "ready", "approved", "rejected", "published", "error"]
class ClipsDeleteIn(BaseModel):
"""Apagar em lote: `ids` (os cortes escolhidos) OU `statuses` (+ `sessionId` opcional) = todos de uma aba.
`confirmPublished` libera apagar corte publicado (sem ele, o publicado é recusado com o motivo)."""
ids: list[int] | None = Field(default=None, min_length=1, max_length=clip_delete.MAX_BATCH)
statuses: list[ClipStatusName] | None = Field(default=None, min_length=1, max_length=9)
sessionId: int | None = Field(default=None, ge=1)
confirmPublished: bool = False
def clip_view(row: dict) -> dict:
return {
"id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"],
"endS": row["end_s"], "durationS": round(row["end_s"] - row["start_s"], 2), "score": row["score"],
"source": row["source"], "reasons": loads(row["reasons_json"], {}), "judge": loads(row["judge_json"], None),
"title": row["title"], "caption": row["caption"], "transcript": row["transcript"], "status": row["status"],
"file": row["file"], "thumb": row["thumb"], "error": row["error"],
# Formato em que o arquivo foi renderizado (vertical 1080×1920 · horizontal 1920×1080); antes do 1º render,
# e nos cortes de antes da migração v8, vale o padrão `vertical`.
"aspect": row.get("aspect") or "vertical",
"createdAt": row["created_at"], "updatedAt": row["updated_at"],
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
# Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export)
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
"origin": row.get("edit_origin")}
if row.get("edit_updated_at") else None),
}
def session_view(row: dict, engine: Engine) -> dict:
counts = {r["status"]: r["n"] for r in engine.db.all(
"SELECT status, COUNT(*) AS n FROM clips WHERE session_id = ? GROUP BY status", row["id"])}
seg = engine.db.get(
"SELECT COUNT(*) AS total, SUM(analyzed) AS analyzed, SUM(CASE WHEN transcript_error IS NOT NULL THEN 1 ELSE 0 END) AS errors"
" FROM segments WHERE session_id = ?", row["id"])
chat = engine.db.get("SELECT COUNT(*) AS n FROM chat WHERE session_id = ?", row["id"])["n"]
live_chat = engine.chat_status(row["id"])
return {
"id": row["id"], "channelId": row["channel_id"], "platform": row["platform"], "kind": row["kind"],
"url": row["url"], "title": row["title"], "status": row["status"],
"chatStatus": live_chat["status"] if live_chat else row["chat_status"], "chatMessages": chat,
"durationS": row["duration_s"], "startedAt": row["started_at"], "endedAt": row["ended_at"], "error": row["error"],
"segments": {"total": seg["total"] or 0, "analyzed": seg["analyzed"] or 0, "transcriptErrors": seg["errors"] or 0},
"clips": counts,
# Contexto do jogo: categoria da plataforma, o que a IA viu na tela, trocas e se você corrigiu à mão.
"game": row.get("game", ""), "gameSource": row.get("game_source", ""), "screenGame": row.get("screen_game", ""),
"gameHistory": loads(row.get("games_json"), []), "gameProfileReady": bool(engine.intel.profile(row.get("game", ""))),
"scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []),
"camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"),
"hasOwnSettings": bool(loads(row.get("settings_json"), {})),
# O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec,
# kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco.
"capture": loads(row.get("capture_json"), None),
}
def channel_view(row: dict) -> dict:
return {
"id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"],
"displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]),
"lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"],
}
def create_app(settings: Settings | None = None, engine: Engine | None = None, start_engine: bool = True) -> FastAPI:
settings = settings or Settings.load()
if not settings.service_key:
raise ConfigError("CLIPPER_SERVICE_KEY vazio: rode o setup.bat (ou preencha clipper/.env).")
db = engine.db if engine else Database(settings.data_dir / "clipper.db")
engine = engine or Engine(settings, db)
@asynccontextmanager
async def lifespan(_app: FastAPI):
if start_engine:
engine.start()
yield
engine.shutdown()
app = FastAPI(title="CenaForge Clipador", version=VERSION, docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
app.state.engine = engine
@app.middleware("http")
async def auth(request: Request, call_next):
if request.url.path != "/health":
given = request.headers.get("X-Service-Key", "")
if not hmac.compare_digest(given.encode(), settings.service_key.encode()):
return JSONResponse({"error": "Chave do serviço ausente ou inválida."}, status_code=401)
return await call_next(request)
@app.exception_handler(UserError)
async def user_error(_request: Request, exc: UserError):
return JSONResponse({"error": exc.message}, status_code=exc.status)
@app.exception_handler(SourceError)
async def source_error(_request: Request, exc: SourceError):
return JSONResponse({"error": str(exc)}, status_code=400)
@app.get("/health")
async def health():
return {"status": "ok", "version": VERSION}
@app.get("/v1/status")
def status():
return {
"version": VERSION,
"tools": {"streamlink": settings.streamlink, "ffmpeg": settings.ffmpeg},
"voice": {"configured": engine.voice.configured, "online": engine.voice.healthy()},
"judge": engine.judge_config(),
"recording": db.get("SELECT COUNT(*) AS n FROM sessions WHERE status IN ('starting', 'recording')")["n"],
# A qualidade de gravação agora é por canal/sessão (`capture.quality`); aqui vai o padrão do serviço.
"settings": {"quality": layout.DEFAULTS["capture"]["quality"], "segmentS": settings.segment_s, "pollS": settings.poll_s,
"keepHours": settings.keep_hours, "language": settings.language},
}
# ---------- juiz (IA pela CLI: Codex/GPT ou Claude)
@app.get("/v1/judge")
def get_judge():
return engine.judge_config() | {"models": engine.judge.models()}
@app.put("/v1/judge")
def put_judge(body: JudgeIn):
try:
engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS,
"vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack})
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel) | {
"models": engine.judge.models()}
except JudgeError as exc:
raise UserError(str(exc)) from exc
# ---------- configuração do corte (layout, câmera, legenda, crédito, duração)
def _settings_payload(own: dict, channel_layer: dict | None, session_layer: dict | None) -> dict:
return {"own": own, "effective": layout.merge(channel_layer, session_layer), "defaults": layout.DEFAULTS,
"modes": list(layout.MODES), "fonts": list(layout.FONTS), "aspects": list(layout.ASPECTS),
# Fontes empacotadas: {família: arquivo relativo à raiz do repositório} (o painel carrega a mesma).
# Qualidades de gravação (grupo `capture`): rótulo, teto e disco por hora medido/estimado.
"captureQualities": capture.OPTIONS,
"fontFiles": layout.font_files(), "hookStyles": list(layout.HOOK_STYLES), "hookAnims": list(layout.HOOK_ANIMS),
# Tamanho do vídeo e quadro lógico dos textos (ASS) de cada formato, para o painel desenhar a prévia.
"frames": {a: {"width": layout.FRAME_SIZES[a][0], "height": layout.FRAME_SIZES[a][1],
"canvasWidth": layout.CANVAS_SIZES[a][0], "canvasHeight": layout.CANVAS_SIZES[a][1]}
for a in layout.ASPECTS}}
@app.get("/v1/channels/{channel_id}/settings")
def get_channel_settings(channel_id: str):
row = db.get("SELECT settings_json FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
own = loads(row["settings_json"], {})
return _settings_payload(own, own, None)
@app.put("/v1/channels/{channel_id}/settings")
def put_channel_settings(channel_id: str, body: dict):
if not db.get("SELECT 1 FROM channels WHERE id = ?", channel_id):
raise UserError("Canal não encontrado.", 404)
try:
own = layout.validate(body)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(own), channel_id)
return _settings_payload(own, own, None)
def _session(session_id: int) -> dict:
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not row:
raise UserError("Sessão não encontrada.", 404)
return row
def _channel_layer(row: dict) -> dict | None:
if not row.get("channel_id"):
return None
ch = db.get("SELECT settings_json FROM channels WHERE id = ?", row["channel_id"])
return loads(ch["settings_json"], {}) if ch else None
@app.get("/v1/sessions/{session_id}/settings")
def get_session_settings(session_id: int):
row = _session(session_id)
own = loads(row["settings_json"], {})
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
@app.put("/v1/sessions/{session_id}/settings")
def put_session_settings(session_id: int, body: dict):
"""Configuração própria da sessão (sobrescreve a do canal campo a campo). Vale para os próximos renders."""
row = _session(session_id)
try:
own = layout.validate(body)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(own) if own else None, session_id)
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
def _frame(row: dict, t: float | None, name: str, width: int = 1280) -> tuple[float, Path]:
segments = [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
for s in db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", row["id"])]
if not segments:
raise UserError("Ainda não há vídeo gravado nesta sessão.")
at = segments[-1][2] - 3 if t is None else t
out = settings.clips_dir / str(row["id"]) / name
try:
media.grab_frame(settings.ffmpeg or "ffmpeg", segments, at, out, width)
except media.MediaError as exc:
raise UserError(str(exc)) from exc
return at, out
@app.get("/v1/sessions/{session_id}/frame")
def get_frame(session_id: int, t: float | None = None):
"""Quadro do vídeo original (1280 px) para o editor desenhar a câmera. Servido por /api/files."""
at, out = _frame(_session(session_id), t, "frame.jpg")
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "version": now()}
@app.post("/v1/sessions/{session_id}/preview")
def preview(session_id: int, body: PreviewIn):
"""Prévia (1080×1920 ou 1920×1080, pelo `format.aspect` efetivo) de como o corte vai ficar com a configuração enviada (sem salvar)."""
row = _session(session_id)
try:
layer = layout.validate(body.settings)
except (layout.LayoutError, TypeError, ValueError) as exc:
raise UserError(str(exc)) from exc
cfg = layout.merge(_channel_layer(row), loads(row["settings_json"], {}), layer)
at, frame = _frame(row, body.t, "preview-src.jpg", width=0)
# Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda.
sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
out = settings.clips_dir / str(row["id"]) / "preview.jpg"
try:
media.preview_still(settings.ffmpeg or "ffmpeg", frame, cfg, ass, out)
except media.MediaError as exc:
raise UserError(str(exc)) from exc
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "mode": layout.resolved_mode(cfg),
"version": now()}
@app.post("/v1/sessions/{session_id}/detect-cam")
def detect_cam(session_id: int, ai: bool = False):
"""Acha a webcam: primeiro local (YuNet em 12 quadros, sem IA); a IA olha 3 quadros se o local não achar
rosto ou com `?ai=true`. Aplica como padrão do canal (ou da sessão) se ainda não houver."""
_session(session_id)
try:
return engine.intel.detect_cam(session_id, apply=True, use_ai=ai)
except JudgeError as exc:
raise UserError(str(exc)) from exc
# ---------- rastreio de reação (rosto do streamer)
@app.get("/v1/sessions/{session_id}/face")
def get_face(session_id: int, from_: float = Query(default=0.0, alias="from", ge=0),
to: float | None = Query(default=None, ge=0)):
"""Série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal` = z da reação) e picos."""
if to is not None and to < from_:
raise UserError("`to` precisa ser maior que `from`.")
return engine.face.view(_session(session_id), from_, to)
@app.post("/v1/sessions/{session_id}/face/reset")
def reset_face(session_id: int):
"""Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco
em andamento não espera: responde 202 com `scheduled: true` e o laço apaga antes do próximo bloco."""
_session(session_id)
result = engine.face.reset(session_id)
return JSONResponse({"ok": True, **result}, status_code=202 if result["scheduled"] else 200)
# ---------- jogo
@app.put("/v1/sessions/{session_id}/game")
def put_game(session_id: int, body: GameIn):
"""Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais."""
_session(session_id)
engine.intel.set_game(session_id, body.name.strip(), "user")
return session_view(_session(session_id), engine)
@app.get("/v1/games")
def list_games():
return {"games": [{"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"],
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None)}
for g in db.all("SELECT * FROM games ORDER BY name")]}
@app.post("/v1/games/{game_id}/research")
def research_game(game_id: str):
"""Pesquisa (de novo) o jogo na web pela IA. Leva de 15 s a alguns minutos. Os pedidos guardados entram junto."""
try:
engine.intel.research(game_id)
except JudgeError as exc:
raise UserError(str(exc)) from exc
return list_games()
@app.put("/v1/games/{game_id}")
def put_game_profile(game_id: str, body: GameProfileIn):
"""Grava o perfil editado à mão. A IA passa a usar na hora."""
try:
engine.intel.save_profile(game_id, body.model_dump())
except JudgeError as exc:
raise UserError(str(exc), 404) from exc
return list_games()
@app.post("/v1/games/{game_id}/refine")
def refine_game(game_id: str, body: GameRefineIn):
"""Pede à IA para acrescentar/corrigir algo no perfil ("acrescente que ..."). O pedido fica guardado."""
try:
_, reply = engine.intel.refine(game_id, body.instruction.strip(), body.search, body.section,
[t.model_dump() for t in body.history])
except JudgeError as exc:
raise UserError(str(exc)) from exc
return {**list_games(), "reply": reply}
@app.delete("/v1/games/{game_id}/notes/{index}")
def delete_game_note(game_id: str, index: int):
"""Esquece um pedido guardado (não volta mais nas pesquisas; o perfil atual fica como está)."""
try:
engine.intel.delete_note(game_id, index)
except JudgeError as exc:
raise UserError(str(exc), 404) from exc
return list_games()
# ---------- emotes que o canal usa (e o peso que aprenderam)
@app.get("/v1/emotes")
def list_emotes(channel: str, limit: int = 60):
rows = db.all("SELECT * FROM emotes WHERE channel_key = ? ORDER BY uses DESC LIMIT ?", channel, max(1, min(limit, 300)))
return {"emotes": [{"name": r["name"], "source": r["source"], "uses": r["uses"], "weight": round(r["weight"], 2),
"lastSeen": r["last_seen"]} for r in rows]}
# ---------- canais
@app.get("/v1/channels")
def list_channels():
return {"channels": [channel_view(r) for r in db.all("SELECT * FROM channels ORDER BY display_name")]}
@app.post("/v1/channels", status_code=201)
def create_channel(body: ChannelIn):
source = parse_source(body.url)
if source.kind != "live" or not source.channel:
raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.")
if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id):
raise UserError("Esse canal já está na lista.", 409)
db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at)"
" VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
source.channel_id, source.platform, source.channel, source.url,
(body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now())
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id))
@app.patch("/v1/channels/{channel_id}")
def update_channel(channel_id: str, body: ChannelPatch):
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ? WHERE id = ?",
(body.displayName or row["display_name"]).strip(),
int(body.monitor if body.monitor is not None else row["monitor"]),
int(body.authorized if body.authorized is not None else row["authorized"]), channel_id)
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id))
@app.delete("/v1/channels/{channel_id}", status_code=204)
def delete_channel(channel_id: str):
for s in db.all("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel_id):
engine.stop_session(s["id"])
db.run("DELETE FROM channels WHERE id = ?", channel_id)
@app.post("/v1/channels/{channel_id}/check")
def check_channel(channel_id: str):
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
if not row:
raise UserError("Canal não encontrado.", 404)
live, title = engine.check_live(row["url"])
db.run("UPDATE channels SET last_check_at = ?, last_status = ? WHERE id = ?", now(), "ao vivo" if live else "offline", channel_id)
return {"live": live, "title": title}
# ---------- sessões
@app.get("/v1/sessions")
def list_sessions(limit: int = 30):
rows = db.all("SELECT * FROM sessions ORDER BY id DESC LIMIT ?", max(1, min(limit, 200)))
return {"sessions": [session_view(r, engine) for r in rows]}
@app.post("/v1/sessions", status_code=201)
def create_session(body: SessionIn):
source = parse_source(body.url)
channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None
try:
session_id = engine.start_session(body.url, channel["id"] if channel else None)
except RuntimeError as exc:
raise UserError(str(exc)) from exc
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.get("/v1/sessions/{session_id}")
def get_session(session_id: int):
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not row:
raise UserError("Sessão não encontrada.", 404)
return session_view(row, engine)
@app.get("/v1/sessions/{session_id}/timeline")
def get_timeline(session_id: int):
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
tl = engine.load_timeline(session_id)
return {"durationS": tl["duration"], **timeline_series(tl["duration"], tl["chat"], tl["loudness"], engine.params)}
@app.post("/v1/sessions/{session_id}/clips", status_code=201)
def manual_clip(session_id: int, body: ManualClipIn):
session = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
raise UserError("Sessão não encontrada.", 404)
duration = session["duration_s"]
if body.lastS is not None:
start, end = max(0.0, duration - body.lastS), duration
elif body.startS is not None and body.endS is not None:
start, end = body.startS, min(body.endS, duration)
else:
raise UserError("Informe lastS ou startS e endS.")
if end - start < 5:
raise UserError("Ainda não há gravação suficiente para esse corte.")
ts = now()
cur = db.run(
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
" VALUES (?, ?, ?, ?, 0, 'manual', '{}', 'candidate', ?, ?)", session_id, end, start, end, ts, ts)
engine.wake_clips.set()
return clip_view(_clip(int(cur.lastrowid)))
@app.post("/v1/sessions/{session_id}/stop")
def stop_session(session_id: int):
engine.stop_session(session_id)
return {"ok": True}
@app.post("/v1/sessions/{session_id}/resume")
def resume_session(session_id: int):
"""Volta a gravar uma live interrompida (ex.: o serviço reiniciou) ou parada, na mesma sessão."""
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
try:
engine.resume_session(session_id)
except RuntimeError as exc:
raise UserError(f"Não deu para retomar: {exc}.") from exc
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.post("/v1/sessions/{session_id}/finish")
def finish_session(session_id: int):
"""Encerra e processa o que foi gravado: varredura do restante, juízes e render dos cortes."""
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
raise UserError("Sessão não encontrada.", 404)
engine.finish_session(session_id)
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@app.delete("/v1/sessions/{session_id}", status_code=204)
def delete_session(session_id: int):
engine.delete_session(session_id)
# ---------- cortes
@app.get("/v1/clips")
def list_clips(status: str | None = None, session: int | None = None, limit: int = 100,
channel: str | None = None, ids: str | None = None):
"""Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`.
O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila."""
sql = "SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1"
params: list = []
if status:
sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")"
params += status.split(",")
if session:
sql += " AND c.session_id = ?"
params.append(session)
if channel:
channels = [c for c in channel.split(",") if c][:200]
sql += " AND s.channel_id IN (" + ",".join("?" * len(channels)) + ")"
params += channels
if ids:
try:
id_list = [int(i) for i in ids.split(",") if i][:500]
except ValueError as exc:
raise UserError("`ids` precisa ser uma lista de números separados por vírgula.") from exc
sql += " AND c.id IN (" + ",".join("?" * len(id_list)) + ")"
params += id_list
sql += " ORDER BY c.id DESC LIMIT ?"
params.append(max(1, min(limit, 500)))
return {"clips": [clip_view(r) for r in db.all(sql, *params)]}
def _clip(clip_id: int) -> dict:
row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", clip_id)
if not row:
raise UserError("Corte não encontrado.", 404)
return row
@app.post("/v1/clips/delete")
def delete_clips(body: ClipsDeleteIn):
"""Apaga vários cortes: os `ids` escolhidos, ou todos nos `statuses` (de uma sessão, com `sessionId`), até
`clip_delete.MAX_BATCH` por chamada. Cada um segue as regras de `DELETE /v1/clips/{id}`; a resposta diz o
que saiu (`deleted`) e o que não saiu e por quê (`failed`). `remaining` = quantos passaram do limite."""
if (body.ids is None) == (body.statuses is None):
raise UserError("Mande `ids` ou `statuses` (um dos dois).")
if body.ids is not None and body.sessionId is not None:
raise UserError("`sessionId` só vale junto com `statuses`.")
remaining = 0
if body.ids is not None:
if any(i < 1 for i in body.ids):
raise UserError("Id de corte inválido.")
ids = list(dict.fromkeys(body.ids))
else:
ids, remaining = clip_delete.select_ids(db, body.sessionId, list(dict.fromkeys(body.statuses)))
result = clip_delete.delete_many(engine, ids, body.confirmPublished)
if result["deleted"]:
engine.wake_clips.set() # a sessão pode ter acabado de ficar sem pendências (finish_if_done)
return {"requested": len(ids), "remaining": remaining, **result}
@app.delete("/v1/clips/{clip_id}")
def delete_clip(clip_id: int, confirmPublished: bool = False):
"""Apaga o corte, o projeto de edição e os arquivos dele (só dentro das pastas do Clipador). Recusa `candidate`
e `rendering` (409, o motor está mexendo nele) e `published` sem `?confirmPublished=true`. O momento fica
marcado: a IA não recria o mesmo corte (clip_delete.py)."""
try:
result = clip_delete.delete_clip(engine, clip_id, confirmPublished)
except clip_delete.DeleteRefused as exc:
message = "Corte não encontrado." if exc.code == "not_found" else f"Não deu para apagar: {exc.message}."
return JSONResponse({"error": message, "code": exc.code}, status_code=exc.status)
engine.wake_clips.set()
return result
@app.get("/v1/clips/{clip_id}")
def get_clip(clip_id: int):
return clip_view(_clip(clip_id))
@app.patch("/v1/clips/{clip_id}")
def update_clip(clip_id: int, body: ClipPatch):
row = _clip(clip_id)
start = body.startS if body.startS is not None else row["start_s"]
end = body.endS if body.endS is not None else row["end_s"]
if not 5 <= end - start <= 180:
raise UserError("O corte precisa ter entre 5 e 180 segundos.")
retime = (start, end) != (row["start_s"], row["end_s"])
status = body.status or row["status"]
if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"):
raise UserError("Só dá para aprovar um corte já renderizado.")
if retime:
status = "pending" # novo trecho → renderiza de novo
db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?",
body.title if body.title is not None else row["title"],
body.caption if body.caption is not None else row["caption"], start, end, status, now(), clip_id)
if retime:
editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto
engine.wake_clips.set()
if body.status in ("approved", "rejected") and body.status != row["status"]:
# Sua decisão é o sinal forte: emotes da reação deste corte ganham/perdem peso no canal (uma vez).
engine.intel.learn_from_clip(row, positive=body.status == "approved", mark=True)
return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/render")
def rerender(clip_id: int):
"""Força o render (ex.: corte que a IA descartou ou que deu erro)."""
_clip(clip_id)
db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id)
engine.wake_clips.set()
return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/rejudge")
def rejudge(clip_id: int):
_clip(clip_id)
db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id)
engine.wake_clips.set()
return clip_view(_clip(clip_id))
# Editor de cortes (/v1/clips/{id}/edit, proxy, waveform, export, preview-render, retranscribe, tts, suggest).
editor_api.register(app, engine, clip_view, _clip)
return app
def build() -> FastAPI: # pragma: no cover - ponto de entrada do uvicorn (--factory)
return create_app()
+188
View File
@@ -0,0 +1,188 @@
"""FFmpeg do Clipador: áudio dos blocos (volume por segundo + WAV para o Whisper), corte vertical e miniatura.
Subprocesso sempre sem shell, argumentos em lista, com timeout; código != 0 é falha."""
from __future__ import annotations
import io
import math
import subprocess
import sys
import wave
from array import array
from pathlib import Path
from . import layout
SAMPLE_RATE = 16_000
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
class MediaError(RuntimeError):
pass
def run(args: list[str], timeout: float, cwd: Path | None = None) -> bytes:
try:
result = subprocess.run(args, capture_output=True, timeout=timeout, cwd=cwd, creationflags=NO_WINDOW)
except subprocess.TimeoutExpired as exc:
raise MediaError(f"{Path(args[0]).name} passou de {timeout:.0f} s") from exc
if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-3:]
raise MediaError(f"{Path(args[0]).name} saiu com código {result.returncode}: {' | '.join(tail)}")
return result.stdout
def decode_pcm(ffmpeg: str, files: list[Path]) -> bytes:
"""Áudio mono 16 kHz s16le dos arquivos, em sequência."""
out = bytearray()
for file in files:
out += run([ffmpeg, "-v", "error", "-i", str(file), "-vn", "-ac", "1", "-ar", str(SAMPLE_RATE), "-f", "s16le", "-"], 120)
return bytes(out)
def loudness_per_second(pcm: bytes) -> list[float | None]:
"""RMS em dBFS por segundo (None = silêncio absoluto)."""
samples = array("h")
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
out: list[float | None] = []
for i in range(0, len(samples), SAMPLE_RATE):
chunk = samples[i: i + SAMPLE_RATE]
if len(chunk) < SAMPLE_RATE // 4:
break
rms = math.sqrt(sum(s * s for s in chunk) / len(chunk))
out.append(round(20 * math.log10(rms / 32768), 2) if rms > 0 else None)
return out
def to_wav(pcm: bytes) -> bytes:
buffer = io.BytesIO()
with wave.open(buffer, "wb") as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(SAMPLE_RATE)
wav.writeframes(pcm)
return buffer.getvalue()
def pick_encoder(ffmpeg: str, wanted: str) -> list[str]:
if wanted == "auto":
try:
encoders = run([ffmpeg, "-hide_banner", "-encoders"], 30).decode(errors="replace")
except MediaError:
encoders = ""
wanted = "h264_nvenc" if "h264_nvenc" in encoders else "libx264"
if wanted == "h264_nvenc":
return ["-c:v", "h264_nvenc", "-preset", "p5", "-rc", "vbr", "-cq", "23", "-b:v", "0"]
return ["-c:v", "libx264", "-preset", "veryfast", "-crf", "21"]
def render_vertical(ffmpeg: str, encoder: list[str], segments: list[tuple[Path, float]], start_s: float, end_s: float,
ass_text: str, out_file: Path, settings: dict | None = None) -> None:
"""`segments` = blocos (arquivo, início na sessão) que cobrem [start_s, end_s], em ordem.
`settings` = configuração do corte efetiva (layout.merge); define layout, câmera e legenda."""
if not segments:
raise MediaError("nenhum bloco gravado cobre o trecho")
work = out_file.parent
work.mkdir(parents=True, exist_ok=True)
stem = out_file.stem
# O filtro `ass` recebe o nome relativo (cwd = pasta do corte): caminho absoluto do Windows ("C:\...")
# exigiria escapar ":" e "\" dentro do filtergraph.
ass_file = work / f"{stem}.ass"
ass_file.write_text(ass_text, encoding="utf-8")
concat = work / f"{stem}.concat.txt"
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _ in segments), encoding="utf-8")
offset = start_s - segments[0][1]
tmp = work / f"{stem}.tmp.mp4"
try:
run(
# -ss ANTES do -i: os quadros entram no filtro já com tempo 0 = início do corte. Depois do -i o
# filtro `ass` veria o tempo do bloco e a legenda sairia deslocada (medido: sumia do vídeo).
[ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, offset):.3f}", "-f", "concat", "-safe", "0",
"-i", concat.name, "-t", f"{end_s - start_s:.3f}",
"-filter_complex", layout.video_filter(settings or layout.merge(), ass_file.name, ass_text),
"-map", "[v]", "-map", "0:a:0?",
*encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000", "-movflags", "+faststart", tmp.name],
timeout=600, cwd=work,
)
tmp.replace(out_file)
finally:
concat.unlink(missing_ok=True)
ass_file.unlink(missing_ok=True)
tmp.unlink(missing_ok=True)
def segment_at(segments: list[tuple[Path, float, float]], t: float) -> tuple[Path, float] | None:
"""Bloco (arquivo, deslocamento dentro dele) que contém o instante `t` da sessão."""
for file, start, end in segments:
if start <= t < end:
return file, t - start
if segments and t >= segments[-1][2]:
file, start, end = segments[-1]
return file, max(0.0, end - start - 0.5)
return None
# Busca num bloco .ts: o demuxer mpegts do FFmpeg trata todo pacote como ponto de busca, então `-ss` antes do `-i`
# cai num quadro P perto do alvo. Medido (17/11/2026): no H.264 sai o PRÓXIMO quadro-chave (até 2 s depois do
# pedido); no HEVC (2K da Twitch) sai um quadro CINZA (referências faltando) — frames do juiz, capa e YuNet
# estragados. Um 2º `-ss` depois do `-i` também erra quando o bloco tem áudio (a base de tempo vem do áudio; 7,5 s
# virou 6,06 s). Agora: busca rápida `SEEK_PREROLL_S` antes, tempo absoluto do bloco (`-copyts -start_at_zero`) e
# o 1º quadro com t ≥ alvo (`select`). GOP da Twitch = 2 s; o YouTube recomenda ≤ 4 s. O concat (render, proxy)
# não tem esse problema: não passa por aqui.
SEEK_PREROLL_S = 4.0
def seek_args(offset: float) -> tuple[list[str], str]:
"""(argumentos antes do `-i`, filtro `select` do quadro exato) para o instante `offset` s de um bloco .ts."""
offset = max(0.0, offset)
return (["-ss", f"{max(0.0, offset - SEEK_PREROLL_S):.3f}", "-copyts", "-start_at_zero"],
f"select='gte(t,{offset:.3f})'")
def grab_frame(ffmpeg: str, segments: list[tuple[Path, float, float]], t: float, out_file: Path, width: int = 768) -> Path:
"""Um quadro do instante `t` (sessão) em JPG. Para a IA olhar a tela e para o editor de layout."""
found = segment_at(segments, t)
if not found:
raise MediaError(f"nenhum bloco gravado em {t:.0f}s")
file, offset = found
out_file.parent.mkdir(parents=True, exist_ok=True)
before, select = seek_args(offset)
vf = select + (f",scale={width}:-2" if width else "")
run([ffmpeg, "-y", "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-vf", vf, "-frames:v", "1",
"-q:v", "4", str(out_file)], 60)
return out_file
def preview_still(ffmpeg: str, frame_file: Path, settings: dict, ass_text: str, out_file: Path, reframe=None) -> Path:
"""Prévia do layout num quadro só (imagem no formato do corte com câmera, jogo, legenda e crédito de exemplo).
`reframe` = reenquadramento parado do jogo (capa de um corte com keyframes; ver `reframe.static_reframe`)."""
work = out_file.parent
ass_file = work / f"{out_file.stem}.ass"
ass_file.write_text(ass_text, encoding="utf-8")
try:
run([ffmpeg, "-y", "-v", "error", "-loop", "1", "-t", "1", "-i", frame_file.name,
"-filter_complex", layout.video_filter(settings, ass_file.name, ass_text, reframe), "-map", "[v]",
"-frames:v", "1", "-q:v", "3", out_file.name], 60, cwd=work)
finally:
ass_file.unlink(missing_ok=True)
return out_file
def thumbnail(ffmpeg: str, video: Path, at_s: float, out_file: Path) -> None:
run([ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, at_s):.2f}", "-i", str(video), "-frames:v", "1",
"-vf", "scale=360:-2", "-q:v", "4", str(out_file)], 60)
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
"""(largura, altura) do vídeo; 1280×720 se não der para ler (as camadas inseridas usam a proporção)."""
try:
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(file)], 30).decode().strip().split(",")
return int(out[0]), int(out[1])
except (MediaError, ValueError, IndexError):
return 1280, 720
def probe_duration(ffprobe: str, file: Path) -> float:
out = run([ffprobe, "-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", str(file)], 30)
return float(out.decode().strip() or 0)
+514
View File
@@ -0,0 +1,514 @@
"""Rastreio de reação do streamer: lógica pura (sem E/S, sem numpy/opencv/mediapipe).
Recebe o que o detector/rastreador já mediu (rosto por quadro com os blendshapes do MediaPipe, ou caixas de
rosto do YuNet) e transforma em:
- uma série por segundo (`FaceSecond`) compacta, para gravar no banco e para o editor reenquadrar a câmera;
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela
recente, só com segundos em que o rosto aparece). Tem streamer que fica sorrindo o tempo todo, tem quem fale
de boca aberta: o que importa é o desvio do normal DELE, não o valor absoluto do blendshape;
- picos rotulados (risada, grito, susto, choque, confuso, raiva) com o início da reação, e um texto curto para o juiz;
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados.
Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
"""
from __future__ import annotations
import bisect
import math
import statistics
from dataclasses import dataclass, field, replace
# Canais com z (o piscar fica de fora: é ruído, não reação). `brow` = sobrancelha levantada (interna ou externa:
# na live real as duas sobem juntas); `surprise` = olho arregalado. `motion` só ajuda a ROTULAR (susto): fica fora da
# intensidade — na live real os maiores "picos" de movimento eram o rastreio perdendo o rosto, não reação.
SIGNAL_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow", "motion")
EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow")
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s)
SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
@dataclass(frozen=True)
class ReactionParams:
# --- série por segundo / sinal ---
min_present: float = 0.3 # fração mínima de quadros com rosto para o segundo contar
motion_min_present: float = 0.8 # movimento só vale com o rosto em ≥ 80 % do segundo (senão é o rastreio pulando)
baseline_s: int = 180 # janela do "neutro recente" do streamer
exclude_recent_s: int = 10 # os últimos segundos ficam fora do neutro (a própria reação não se anula)
min_baseline_n: int = 30 # menos segundos com rosto que isso na janela → usa todos os segundos com rosto da série
mad_floor: float = 0.05 # piso do desvio robusto de um canal sem piso próprio em `mad_floors`
# Pisos por canal, calibrados na live real (doc/FACE_BAKEOFF.md, sessão 3): no calmo o sorriso por segundo
# tem mediana ~0,10 e picos soltos de 0,38 (fala/tique) → piso 0,10; browInnerUp tem pico solto de 0,38 num
# segundo calmo contra 0,7–0,8 sustentado no lag → piso 0,10 e peso menor; browDown no calmo fica ≤ 0,07.
# `motion` em "tamanhos de rosto" por segundo.
mad_floors: dict[str, float] = field(default_factory=lambda: {
"smile": 0.10, "jaw": 0.05, "surprise": 0.06, "frown": 0.07, "brow": 0.10, "motion": 0.15,
})
weights: dict[str, float] = field(default_factory=lambda: {
"smile": 1.0, "jaw": 1.0, "surprise": 1.0, "frown": 0.8, "brow": 0.6, "motion": 0.7,
})
# --- picos ---
threshold: float = 3.0 # z mínimo do sinal para virar pico (igual ao `face_threshold` do plano)
strong_z: float = 6.0 # a partir daqui o texto diz "forte"
onset_z: float = 1.0 # o início/fim da reação é onde o sinal cai abaixo disto
max_onset_s: int = 10
min_gap_s: float = 4.0 # distância mínima entre dois picos
keep_neutral: bool = False # pico só de movimento (pegar a água, ajeitar a cadeira) vira "neutro" e sai
# --- rótulo ---
label_z: float = 2.0 # canal "ligado" no pico quando o z dele passa disto
smile_raw: float = 0.5 # sorriso alto em valor absoluto também conta (neutro sorridente saturado)
shout_jaw_raw: float = 0.2 # sobrancelha franzida COM boca aberta pelo menos isso = grito (senão, raiva)
raw_thresholds: dict[str, float] = field(default_factory=lambda: {
"smile": 0.4, "jaw": 0.35, "surprise": 0.35, "frown": 0.35, "brow": 0.35, "motion": 0.5,
}) # usados pelo `label` quando não há z (segundo isolado)
# --- câmera (locate_cam) ---
min_score: float = 0.6 # confiança mínima da detecção
# Confiança MÉDIA mínima do grupo que vira câmera. Teste ao vivo de 17/11: webcam real (skipnho) 0,92–0,94 em
# todo quadro; na lofigirl (sem webcam) a tela de um notebook desenhado, parada na borda, deu 0,61–0,66 em 8 de 12
# quadros e virou "câmera" de 24×34 px com o layout aplicado.
min_cam_score: float = 0.7
# Agrupa pelo CENTRO do grupo (média corrente) com tolerância em tamanhos de rosto: comparar com o 1º membro
# partiu o streamer em dois quando ele se inclinou (0,8 largura de rosto na bancada).
cluster_faces: float = 1.0 # distância máxima ao centro do grupo, em larguras (x) e alturas (y) de rosto
min_presence: float = 0.5 # grupo precisa aparecer em ≥ 50 % dos quadros
stable_faces: float = 0.6 # desvio-padrão máximo do centro do grupo, em tamanhos de rosto (bancada: 0,24)
full_frame_h: float = 0.4 # rosto mais alto que isso = câmera em tela cheia
expand_w: float = 3.2 # retângulo estimado = rosto × 3,2 na largura
expand_h: float = 3.6 # e × 3,6 na altura
shift_down: float = 0.45 # deslocado para baixo em "alturas de rosto" (ombros/peito aparecem na câmera)
edge_reach: float = 1.5 # borda da moldura vale se estiver até X larguras de rosto do lado estimado
headroom: float = 0.35 # a borda de cima nunca encosta no rosto: fica ≥ X alturas de rosto acima (testa/cabelo)
@dataclass(frozen=True)
class FaceSample:
"""Um quadro do rastreador. `cx`/`cy`/`size` normalizados (0..1) no recorte da câmera; `size` = altura do rosto."""
t: float
present: bool
cx: float = 0.0
cy: float = 0.0
size: float = 0.0
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
@dataclass
class FaceSecond:
"""Resumo de um segundo. Canais `None` quando o rosto não apareceu nesse segundo."""
t: int
present: float = 0.0 # fração dos quadros com rosto
cx: float | None = None
cy: float | None = None
size: float | None = None
smile: float | None = None
jaw: float | None = None
surprise: float | None = None
frown: float | None = None
brow: float | None = None
blink: float | None = None
motion: float | None = None
def to_json(self) -> dict:
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`."""
out: dict = {"t": self.t, "present": round(self.present, 3)}
for name in SECOND_FIELDS:
value = getattr(self, name)
if value is not None:
out[name] = round(value, 3)
return out
@classmethod
def from_json(cls, data: dict) -> FaceSecond:
return cls(int(data["t"]), float(data.get("present", 0.0)),
**{n: (float(data[n]) if data.get(n) is not None else None) for n in SECOND_FIELDS})
@dataclass
class ReactionMoment:
peak_s: int
onset_s: int # onde a reação começou (o que causou está logo antes)
end_s: int
intensity: float # z do sinal no pico
label: str
strong: bool
def to_json(self) -> dict:
return {"peakS": self.peak_s, "onsetS": self.onset_s, "endS": self.end_s,
"intensity": round(self.intensity, 2), "label": self.label, "strong": self.strong}
def seconds_to_json(seconds: list[FaceSecond]) -> list[dict]:
return [s.to_json() for s in seconds]
def seconds_from_json(data: list[dict]) -> list[FaceSecond]:
return [FaceSecond.from_json(d) for d in data]
# ---------------------------------------------------------------------------------------------------------------
# Série por segundo
def _mean(values: list[float]) -> float:
return sum(values) / len(values)
def _channels(blend: dict[str, float]) -> dict[str, float]:
"""Blendshapes do MediaPipe → canais de expressão (0..1).
Na live real (bancada) `eyeWide*` fica ~0 o tempo todo e `jawOpen` quase nunca passa de 0,1: a surpresa não
pode depender do olho arregalado: a sobrancelha levantada (`brow`, o maior entre a interna e a externa — na live
inteira as duas sobem juntas) é canal próprio e, com movimento da cabeça, já é susto. Marcou o lag: 0,27 de
média contra 0,02 no calmo.
"""
def g(name: str) -> float:
return float(blend.get(name, 0.0))
outer_up = (g("browOuterUpLeft") + g("browOuterUpRight")) / 2
return {
"smile": (g("mouthSmileLeft") + g("mouthSmileRight")) / 2,
"jaw": g("jawOpen"),
"surprise": (g("eyeWideLeft") + g("eyeWideRight")) / 2,
"frown": (g("browDownLeft") + g("browDownRight")) / 2,
"brow": max(g("browInnerUp"), outer_up),
"blink": (g("eyeBlinkLeft") + g("eyeBlinkRight")) / 2,
}
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> list[FaceSecond]:
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s).
Posição/tamanho/piscar = média; expressões = máximo do segundo (a reação dura menos que 1 s às vezes);
`motion` = caminho percorrido pelo centro (mais a variação de tamanho, quem se joga para a câmera) dividido
pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
"""
n = max(0, int(math.ceil(duration_s)))
first = int(math.floor(start_s))
buckets: list[list[FaceSample]] = [[] for _ in range(n)]
for sample in samples:
i = int(math.floor(sample.t)) - first
if 0 <= i < n:
buckets[i].append(sample)
out: list[FaceSecond] = []
previous: FaceSample | None = None # última amostra com rosto (para o movimento atravessar a virada do segundo)
for i, bucket in enumerate(buckets):
bucket.sort(key=lambda s: s.t)
second = FaceSecond(first + i, present=(sum(1 for s in bucket if s.present) / len(bucket)) if bucket else 0.0)
faces = [s for s in bucket if s.present and s.size > 0]
if faces:
channels = [_channels(s.blend) for s in faces]
second.cx = _mean([s.cx for s in faces])
second.cy = _mean([s.cy for s in faces])
second.size = _mean([s.size for s in faces])
for name in ("smile", "jaw", "surprise", "frown", "brow"):
setattr(second, name, max(c[name] for c in channels))
second.blink = _mean([c["blink"] for c in channels])
path = 0.0
for s in faces:
if previous is not None and s.t - previous.t <= 1.0:
scale = max(1e-6, (s.size + previous.size) / 2)
path += (math.hypot(s.cx - previous.cx, s.cy - previous.cy) + abs(s.size - previous.size)) / scale
previous = s
second.motion = path
out.append(second)
return out
# ---------------------------------------------------------------------------------------------------------------
# Sinal relativo ao neutro do streamer
def _has_face(second: FaceSecond, p: ReactionParams) -> bool:
return second.present >= p.min_present and second.smile is not None
def _robust(values: list[float], floor: float) -> tuple[float, float]:
"""Mediana e desvio robusto (1,4826 × MAD, com piso)."""
median = statistics.median(values)
mad = statistics.median([abs(v - median) for v in values])
return median, max(floor, 1.4826 * mad)
def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[dict[str, float] | None]:
"""z robusto de cada canal por segundo contra o neutro recente do próprio streamer; `None` sem rosto."""
p = params or ReactionParams()
face_idx = [i for i, s in enumerate(seconds) if _has_face(s, p)]
# Série antiga (sem o canal) → 0: o canal fica parado em vez de quebrar.
values = {name: [getattr(seconds[i], name) or 0.0 for i in face_idx] for name in SIGNAL_CHANNELS}
floors = {name: p.mad_floors.get(name, p.mad_floor) for name in SIGNAL_CHANNELS}
# O neutro anda devagar: recalcula a cada `BASELINE_STEP_S` (com cache pelos limites da janela), e a janela sai
# por bisect em `face_idx` — antes era O(n²) e uma live de horas levava segundos por chamada.
cache: dict[tuple[int, int], dict[str, tuple[float, float]]] = {}
out: list[dict[str, float] | None] = []
for t, second in enumerate(seconds):
if not _has_face(second, p):
out.append(None)
continue
anchor = t - t % BASELINE_STEP_S
lo = bisect.bisect_left(face_idx, anchor - p.baseline_s)
hi = bisect.bisect_left(face_idx, anchor - p.exclude_recent_s)
if hi - lo < p.min_baseline_n:
# Começo da gravação: ainda não há neutro suficiente; usa a série inteira (a mediana aguenta os picos).
lo, hi = 0, len(face_idx)
base = cache.get((lo, hi))
if base is None:
base = cache[(lo, hi)] = {name: _robust(values[name][lo:hi], floors[name]) for name in SIGNAL_CHANNELS}
z: dict[str, float] = {}
for name in SIGNAL_CHANNELS:
median, spread = base[name]
z[name] = ((getattr(second, name) or 0.0) - median) / spread
if second.present < p.motion_min_present:
z["motion"] = 0.0
out.append(z)
return out
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
if z is None:
return None
return max(0.0, max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS))
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
params: ReactionParams | None = None) -> list[float | None]:
"""Intensidade de reação por segundo (máximo ponderado dos z das expressões, ≥ 0); `None` sem rosto."""
p = params or ReactionParams()
if baseline_s is not None:
p = replace(p, baseline_s=baseline_s)
return [_signal_from_z(z, p) for z in channel_z(seconds, p)]
# ---------------------------------------------------------------------------------------------------------------
# Rótulo
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
"""Rótulo da expressão: risada, grito, susto, choque, confuso, raiva ou neutro.
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
absolutos (`raw_thresholds`).
Regras (calibradas na live real, doc/FACE_BAKEOFF.md):
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada,
jawOpen ≤ 0,1); sorriso alto em valor absoluto também conta quando outro canal de rosto sobe junto (no
streamer que já sorri o tempo todo o sorriso não tem para onde subir);
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real:
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**;
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
- **choque** = olho arregalado parado;
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
contra 0,02 no calmo).
"""
p = params or ReactionParams()
if second.smile is None:
return "neutro"
if z is not None:
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS}
else:
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
smiling_raw = second.smile >= p.smile_raw
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
return "risada"
if (on["surprise"] or on["brow"]) and on["motion"]:
return "susto"
if on["jaw"]:
return "grito"
if on["frown"]:
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva"
if on["surprise"]:
return "choque"
if on["brow"]:
return "confuso"
return "neutro"
# ---------------------------------------------------------------------------------------------------------------
# Picos e resumo para o juiz
def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[ReactionMoment]:
"""Picos do sinal (≥ `threshold`, do maior para o menor, a `min_gap_s` um do outro), em ordem de tempo.
A mesma reação num trecho contínuo acima de `onset_z` vira um pico só (risada de 5 s não conta duas vezes).
O rótulo vem do segundo do pico; se o pico for só movimento ("neutro"), olha os vizinhos (±1 s) — o grito pode
ter o máximo de boca um segundo antes do pulo. Sem rótulo de expressão o pico sai (salvo `keep_neutral`).
"""
p = params or ReactionParams()
zs = channel_z(seconds, p)
signal = [_signal_from_z(z, p) for z in zs]
values = [v if v is not None else -1.0 for v in signal]
# Trecho contínuo acima de `onset_z` de cada segundo: uma risada de 5 s é UM pico, não dois.
run = [0] * len(values)
current = 0
for i, v in enumerate(values):
if v >= p.onset_z and i > 0 and values[i - 1] >= p.onset_z:
run[i] = current
else:
current += 1
run[i] = current
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
chosen: list[tuple[int, str]] = []
for peak in candidates:
name = _peak_label(seconds, zs, peak, p)
if name == "neutro" and not p.keep_neutral:
continue
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento.
if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
continue
chosen.append((peak, name))
moments: list[ReactionMoment] = []
for peak, name in sorted(chosen):
begin = peak
while begin > 0 and peak - begin < p.max_onset_s and values[begin - 1] >= p.onset_z:
begin -= 1
end = peak
while end + 1 < len(values) and end - peak < p.max_onset_s and values[end + 1] >= p.onset_z:
end += 1
moments.append(ReactionMoment(seconds[peak].t, seconds[begin].t, seconds[end].t, values[peak], name,
values[peak] >= p.strong_z))
return moments
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str:
name = label(seconds[peak], zs[peak], p)
if name == "neutro":
for j in (peak - 1, peak + 1):
if 0 <= j < len(seconds) and zs[j] is not None:
other = label(seconds[j], zs[j], p)
if other != "neutro":
return other
return name
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
params: ReactionParams | None = None, max_items: int = 4,
moments: list[ReactionMoment] | None = None, relative: bool = True) -> str:
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho.
Passe a série inteira (ou bem mais que o trecho): o neutro do streamer vem do que veio antes.
Ex.: "risada forte em 12 s; susto em 15 s". `moments` (opcional): picos já calculados com `reaction_moments`
sobre a série inteira — evita recalcular a live toda a cada corte (~1 s por hora de live).
`relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
"""
p = params or ReactionParams()
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s)
inside = [s for s in seconds if start_s <= s.t <= end]
with_face = [s for s in inside if _has_face(s, p)]
if not with_face:
return "rosto do streamer não aparece no trecho"
parts = []
for m in (moments if moments is not None else reaction_moments(seconds, p)):
if start_s <= m.peak_s <= end:
when = f"{int(round(m.peak_s - start_s))} s" if relative else f"{m.peak_s:.0f}s"
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when}")
presence = len(with_face) / len(inside)
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
if presence < 0.7:
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
return text
# ---------------------------------------------------------------------------------------------------------------
# Onde está a câmera
def _rect(x: float, y: float, w: float, h: float) -> dict[str, float]:
return {"x": round(x, 4), "y": round(y, 4), "w": round(w, 4), "h": round(h, 4)}
def _clip_rect(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
x0, y0 = min(1.0, max(0.0, x0)), min(1.0, max(0.0, y0))
x1, y1 = min(1.0, max(0.0, x1)), min(1.0, max(0.0, y1))
return x0, y0, max(x0, x1), max(y0, y1)
def locate_cam(detections_per_frame: list[list[tuple[float, float, float, float, float]]], frame_w: float,
frame_h: float, edges: dict[str, list[float]] | None = None,
params: ReactionParams | None = None) -> dict:
"""Acha a câmera do streamer a partir das detecções de rosto de alguns quadros espalhados da live.
`detections_per_frame`: um item por quadro (lista vazia = nenhum rosto), cada detecção `(x, y, w, h, score)`
em pixels. `edges` (opcional): bordas persistentes da moldura da câmera, em fração do quadro —
`{"xs": [linhas verticais], "ys": [linhas horizontais]}` (ex.: média do gradiente entre os quadros).
A câmera é o grupo de rostos que aparece na mesma posição em ≥ `min_presence` dos quadros; rosto de jogo,
cutscene ou de outra pessoa passa por poucos quadros e é ignorado (na bancada, 6 rostos de uma tela de
carregamento apareceram em 2 de 12 quadros, sempre no mesmo lugar: é a presença que separa, não a posição).
Cada detecção entra no grupo cujo CENTRO (média corrente) esteja a até `cluster_faces` larguras/alturas de
rosto dela — o streamer que se inclina continua no mesmo grupo.
Retângulo: rosto expandido (≈3,2× largura, 3,6× altura, deslocado para baixo), com folga acima da testa.
Câmera sem moldura (streamer recortado sobre o jogo, o caso da bancada) só tem esse caminho; `edges` é opcional
e só ajusta os lados quando há moldura de verdade. Devolve
`{hasWebcam, cam: {x,y,w,h} | None, faceRect, confidence, fullFrame}` em frações 0..1.
"""
p = params or ReactionParams()
total = len(detections_per_frame)
empty = {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
if total == 0 or frame_w <= 0 or frame_h <= 0:
return empty
# Grupos por posição: cada um guarda (quadro, cx, cy, w, h, score) normalizados.
groups: list[list[tuple[int, float, float, float, float, float]]] = []
for frame, detections in enumerate(detections_per_frame):
for x, y, w, h, score in detections:
if score < p.min_score or w <= 0 or h <= 0:
continue
nw, nh = w / frame_w, h / frame_h
cx, cy = x / frame_w + nw / 2, y / frame_h + nh / 2
best, best_d = None, math.inf
for g in groups:
gx, gy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
dx, dy = abs(cx - gx) / gw, abs(cy - gy) / gh
if dx <= p.cluster_faces and dy <= p.cluster_faces and max(dx, dy) < best_d:
best, best_d = g, max(dx, dy)
if best is None:
groups.append([(frame, cx, cy, nw, nh, score)])
else:
best.append((frame, cx, cy, nw, nh, score))
candidates = []
for g in groups:
frames = len({d[0] for d in g})
ratio = frames / total
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
# Estabilidade em tamanhos de rosto: independe do zoom da câmera e da resolução.
spread = math.hypot(statistics.pstdev([d[1] for d in g]) / gw, statistics.pstdev([d[2] for d in g]) / gh)
if ratio >= p.min_presence and spread <= p.stable_faces and _mean([d[5] for d in g]) >= p.min_cam_score:
candidates.append((ratio, _mean([d[5] for d in g]), spread, g))
if not candidates:
return empty
ratio, score, spread, g = max(candidates, key=lambda c: (c[0], c[1]))
fw, fh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
fcx, fcy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
face_rect = _rect(*_xywh(*_clip_rect(fcx - fw / 2, fcy - fh / 2, fcx + fw / 2, fcy + fh / 2)))
confidence = round(min(1.0, ratio * score * (1.0 - 0.5 * spread / p.stable_faces)), 3)
if fh > p.full_frame_h:
return {"hasWebcam": True, "cam": _rect(0, 0, 1, 1), "faceRect": face_rect,
"confidence": confidence, "fullFrame": True}
# Estimativa pelo rosto: 3,2× a largura, 3,6× a altura, deslocado para baixo (ombros aparecem na câmera).
cw, ch = fw * p.expand_w, fh * p.expand_h
ccy = fcy + p.shift_down * fh
x0, x1 = fcx - cw / 2, fcx + cw / 2
y0, y1 = ccy - ch / 2, ccy + ch / 2
if edges:
reach_x, reach_y = p.edge_reach * fw, p.edge_reach * fh
x0 = _snap(x0, edges.get("xs", []), outside_of=fcx - fw / 2, reach=reach_x, side=-1)
x1 = _snap(x1, edges.get("xs", []), outside_of=fcx + fw / 2, reach=reach_x, side=1)
# Em cima, a borda só vale acima da folga da testa: moldura falsa (ex.: um banner) não corta a cabeça.
y0 = _snap(y0, edges.get("ys", []), outside_of=fcy - fh / 2 - p.headroom * fh, reach=reach_y, side=-1)
y1 = _snap(y1, edges.get("ys", []), outside_of=fcy + fh / 2, reach=reach_y, side=1)
cam = _rect(*_xywh(*_clip_rect(x0, y0, x1, y1)))
return {"hasWebcam": True, "cam": cam, "faceRect": face_rect, "confidence": confidence, "fullFrame": False}
def _xywh(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
return x0, y0, x1 - x0, y1 - y0
def _snap(estimate: float, lines: list[float], outside_of: float, reach: float, side: int) -> float:
"""Troca o lado estimado pela borda da moldura mais próxima dele, se houver uma além do rosto e a até `reach`."""
valid = [v for v in lines if (v <= outside_of if side < 0 else v >= outside_of) and abs(v - estimate) <= reach]
return min(valid, key=lambda v: abs(v - estimate)) if valid else estimate
+283
View File
@@ -0,0 +1,283 @@
"""Reenquadramento do jogo no tempo (câmera virtual com keyframes) e camadas inseridas (recorte da tela em destaque).
Pedido do dono (17/11/2026, corte 61 em câmera-em-cima): "na hora que ele abre o inventário preciso pegar um ângulo
melhor; se quero mostrar alguma coisa no canto da tela, criar camadas para isso".
**Reenquadramento** (`project.reframe.keys`): janela (centro `cx`, `cy` e largura `w`, frações do quadro ORIGINAL)
que vira a área do jogo do layout daquele instante. A altura sai da proporção da área de destino (parte de baixo no
`cam_top`; a tela toda nos outros), então nunca distorce. Enquanto houver keys, `layout.game` é ignorado (os keys são
absolutos no quadro original). Não vale para `cam_only`. Interpolação entre keys pelo `ease` do key de saída:
`smooth` (suave), `linear` ou `hold` (segura e salta no key seguinte). Antes do 1º e depois do último, segura.
No FFmpeg: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro `in`) viram o quadro
inteiro com interpolação SUBPIXEL, depois `scale` para a área de destino. Medido (protótipo, zoom de 1,0 → 0,4 em 4 s
num 1280×720): nenhum passo para trás entre quadros, desvio da aceleração 0,12 px (sem tremida), 0,38 s de render.
`scale` com `eval=frame` + `crop` de tamanho fixo, a alternativa, falhou no encoder (tamanho variável) e arredonda o
deslocamento a pixels inteiros.
**Camadas inseridas** (`overlays[]` com `kind: "inset"`): recorte `src` do quadro original, posto em `x`/`y` (centro) com
largura `size` da tela; borda, cantos arredondados, sombra e animação. Vêm do vídeo original (antes do layout), ficam
acima do vídeo/zoom e abaixo da legenda, gancho, textos e chat (o ASS vem depois). Ordem no array = empilhamento.
No FFmpeg: `crop` → `scale` (tamanho-base fixo) → `alphamerge` com a máscara dos cantos → por cima de UMA imagem
de decoração (sombra borrada + borda, gerada aqui com numpy/OpenCV) → `scale` por quadro só se o tamanho muda
(keys, pop) → `fade` de alfa → um `overlay` sobre o vídeo (expressão por quadro só se a posição muda: keys,
slide). Medido no corte 61 (60 s, NVENC): sem nada 6,1–6,2 s; com reenquadramento 7,1–9,5 s; com
reenquadramento + 2 camadas (pop e slide) 15,8–20,5 s (com sombra, borda e recorte postos separados: 28,2 s).
"""
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
FPS = 30
EASES = ("smooth", "linear", "hold")
INSET_ANIMS = ("pop", "fade", "slide", "none")
MAX_KEYS = 60
MAX_INSETS = 12
ANIM_S = 0.18 # entrada/saída de alfa das camadas
SLIDE_S = 0.35
SHADOW_ALPHA = 0.55
# ---------------------------------------------------------------- interpolação (Python e expressão do FFmpeg)
def _smooth(u: float) -> float:
return u * u * (3 - 2 * u)
def interp(keys: list[dict], t: float, field: str) -> float:
"""Valor de `field` no instante `t` (mesmo resultado da expressão do FFmpeg)."""
if t <= keys[0]["t"]:
return float(keys[0][field])
for a, b in zip(keys, keys[1:]):
if t < b["t"]:
ease = a.get("ease", "smooth")
if ease == "hold":
return float(a[field])
u = (t - a["t"]) / max(1e-3, b["t"] - a["t"])
u = _smooth(u) if ease == "smooth" else u
return float(a[field]) + (float(b[field]) - float(a[field])) * u
return float(keys[-1][field])
def piecewise(keys: list[dict], field: str, var: str) -> str:
"""Expressão do FFmpeg equivalente a `interp` (variável de tempo `var`, já entre parênteses)."""
expr = f"{float(keys[-1][field]):.5f}"
for a, b in reversed(list(zip(keys, keys[1:]))):
va, vb = float(a[field]), float(b[field])
ease = a.get("ease", "smooth")
if ease == "hold" or abs(vb - va) < 1e-9:
seg = f"{va:.5f}"
else:
u = f"clip(({var}-{a['t']:.4f})/{max(1e-3, b['t'] - a['t']):.4f},0,1)"
u = f"({u}*{u}*(3-2*{u}))" if ease == "smooth" else u
seg = f"({va:.5f}+{vb - va:.5f}*{u})"
expr = f"if(lt({var},{b['t']:.4f}),{seg},{expr})"
return expr
def keys_for_range(keys: list[dict], a: float, b: float) -> list[dict]:
"""Só os keys que influenciam [a, b] (o último antes de `a`, os de dentro e o primeiro depois de `b`)."""
if not keys:
return []
first = max([i for i, k in enumerate(keys) if k["t"] <= a], default=0)
last = min([i for i, k in enumerate(keys) if k["t"] >= b], default=len(keys) - 1)
return keys[first: last + 1]
# ---------------------------------------------------------------- reenquadramento
def window(keys: list[dict], t: float, src_w: float, src_h: float, dest_aspect: float) -> tuple[float, float, float, float]:
"""(x, y, largura, altura) em px do quadro original no instante `t` (presa dentro do quadro, sem deformar)."""
ww = min(src_w * interp(keys, t, "w"), src_h * dest_aspect)
wh = ww / dest_aspect
x = min(max(src_w * interp(keys, t, "cx") - ww / 2, 0.0), src_w - ww)
y = min(max(src_h * interp(keys, t, "cy") - wh / 2, 0.0), src_h - wh)
return x, y, ww, wh
def perspective_filter(keys: list[dict], piece_start: float, piece_end: float, dest_aspect: float) -> str:
"""`perspective` cujos 4 cantos são a janela no tempo da SESSÃO (o trecho começa em `piece_start`; o filtro conta
os quadros do trecho em `in`, que começa em 1, a 30 qps). Saída do tamanho da entrada; o layout escala para a área de destino."""
ks = keys_for_range(keys, piece_start, piece_end)
# `in` do perspective começa em 1 no 1º quadro (medido: com in/30 a janela ia 1 quadro adiantada).
var = f"({piece_start:.4f}+(in-1)/{FPS})"
a = f"{dest_aspect:.6f}"
ww = f"st(1,min(W*({piecewise(ks, 'w', var)}),H*{a}))"
left = f"{ww};st(2,clip(W*({piecewise(ks, 'cx', var)})-ld(1)/2,0,W-ld(1)))"
top = f"{ww};st(3,ld(1)/{a});st(4,clip(H*({piecewise(ks, 'cy', var)})-ld(3)/2,0,H-ld(3)))"
x_l, x_r = f"{left};ld(2)", f"{left};ld(2)+ld(1)"
y_t, y_b = f"{top};ld(4)", f"{top};ld(4)+ld(3)"
return (f"perspective=x0='{x_l}':y0='{y_t}':x1='{x_r}':y1='{y_t}':x2='{x_l}':y2='{y_b}':x3='{x_r}':y3='{y_b}'"
f":interpolation=linear:sense=source:eval=frame")
def piece_reframe(project: dict, piece_start: float, piece_end: float):
"""Função (proporção de destino → filtro) para `layout.layout_chain`, ou None sem reenquadramento."""
keys = (project.get("reframe") or {}).get("keys") or []
if not keys:
return None
return lambda dest_aspect: perspective_filter(keys, piece_start, piece_end, dest_aspect)
def static_reframe(project: dict, t: float):
"""Reenquadramento parado no instante `t` (capa): mesma janela, sem animação."""
keys = (project.get("reframe") or {}).get("keys") or []
if not keys:
return None
frozen = [{"t": 0.0, "cx": interp(keys, t, "cx"), "cy": interp(keys, t, "cy"), "w": interp(keys, t, "w"), "ease": "hold"}]
return lambda dest_aspect: perspective_filter(frozen, 0.0, 1.0, dest_aspect)
# ---------------------------------------------------------------- camadas inseridas
@dataclass
class InsetPlan:
"""Uma camada pronta para o grafo. A camada vira UMA imagem composta (sombra + borda + recorte) de tamanho
`decor_w`×`decor_h`, com o recorte em (`ox`, `oy`); só ela é posta sobre o vídeo (um overlay grande por camada).
Medido no corte 61 (60 s): com sombra, borda e recorte postos separados no quadro inteiro, 2 camadas levavam o
render de 7,1 s para 28,2 s."""
inset: dict
a: float # entrada (tempo de saída)
b: float # saída
base_w: int # recorte em px do vídeo (no maior tamanho dos keys)
base_h: int
ox: int # posição do recorte dentro da imagem composta
oy: int
decor_w: int
decor_h: int
mask_file: Path
decor_file: Path | None # sombra + borda (None = sem nenhuma das duas)
keys: list[dict] # keys em tempo de SAÍDA (x, y, size, ease)
@property
def dynamic_size(self) -> bool:
return self.inset["anim"] == "pop" or len({k["size"] for k in self.keys}) > 1
@property
def dynamic_pos(self) -> bool:
return self.inset["anim"] == "slide" or len({(k["x"], k["y"]) for k in self.keys}) > 1
def _rounded_alpha(w: int, h: int, radius: float):
import numpy as np
yy, xx = np.mgrid[0:h, 0:w].astype(np.float32) + 0.5
r = max(0.0, min(radius, w / 2, h / 2))
if r <= 0:
return np.ones((h, w), np.float32)
dx = np.maximum(np.maximum(r - xx, xx - (w - r)), 0)
dy = np.maximum(np.maximum(r - yy, yy - (h - r)), 0)
return np.clip(r - np.sqrt(dx * dx + dy * dy) + 0.5, 0, 1)
def _make_images(plan: InsetPlan, border_color: str | None, pad: int, shadow_pad: int, radius_px: float) -> None:
"""Máscara dos cantos (tamanho do recorte) e a imagem de decoração (sombra borrada + borda), em PNG."""
import cv2
import numpy as np
w, h = plan.base_w, plan.base_h
cv2.imwrite(str(plan.mask_file), (_rounded_alpha(w, h, radius_px) * 255).astype(np.uint8))
if plan.decor_file is None:
return
rgb = np.zeros((plan.decor_h, plan.decor_w, 3), np.float32)
alpha = np.zeros((plan.decor_h, plan.decor_w), np.float32)
bw, bh = w + 2 * pad, h + 2 * pad
outer = _rounded_alpha(bw, bh, radius_px + pad if radius_px else 0)
x0, y0 = plan.ox - pad, plan.oy - pad
if shadow_pad:
off = max(1, shadow_pad // 2)
shadow = np.zeros_like(alpha)
shadow[y0 + off: y0 + off + bh, x0 + off: x0 + off + bw] = outer
alpha = cv2.GaussianBlur(shadow, (0, 0), sigmaX=max(1.0, shadow_pad / 2.5)) * SHADOW_ALPHA
if pad and border_color:
color = np.array([int(border_color[i: i + 2], 16) for i in (5, 3, 1)], np.float32) # BGR
a_b = np.zeros_like(alpha)
a_b[y0: y0 + bh, x0: x0 + bw] = outer
rgb = (color * a_b[..., None] + rgb * (alpha * (1 - a_b))[..., None]) / np.maximum(
(a_b + alpha * (1 - a_b))[..., None], 1e-6)
alpha = a_b + alpha * (1 - a_b)
img = np.dstack([np.clip(rgb, 0, 255), alpha * 255]).astype(np.uint8)
cv2.imwrite(str(plan.decor_file), img)
def plan_insets(project: dict, cuts_to_output, t0: float, t1: float, frame: tuple[int, int], canvas_w: int,
src_size: tuple[int, int], work: Path, stem: str) -> list[InsetPlan]:
"""Camadas que aparecem na saída [t0, t1], com tamanhos em px e as imagens auxiliares geradas em `work`."""
fw, _fh = frame
k = fw / canvas_w # px do quadro lógico (borda, raio) → px do vídeo
plans = []
for n, o in enumerate(x for x in project["overlays"] if x["kind"] == "inset"):
a, b = cuts_to_output(o["start"]), cuts_to_output(o["end"])
if b - a < 0.05 or b <= t0 or a >= t1:
continue
keys = [{"t": cuts_to_output(x["t"]), "x": x["x"], "y": x["y"], "size": x["size"], "ease": x.get("ease", "smooth")}
for x in o.get("keys") or []] or [{"t": a, "x": o["x"], "y": o["y"], "size": o["size"], "ease": "hold"}]
top_size = max(x["size"] for x in keys)
src = o["src"]
base_w = max(8, int(round(top_size * fw / 2)) * 2)
base_h = max(8, int(round(base_w * (src["h"] * src_size[1]) / (src["w"] * src_size[0]) / 2)) * 2)
pad = int(round(o["borderW"] * k)) if o["border"] else 0
shadow_pad = max(6, int(round(0.03 * base_w))) if o["shadow"] else 0
decor = pad > 0 or shadow_pad > 0
margin = pad + shadow_pad
tag = f"{stem}-inset{n}"
plan = InsetPlan(o, a, b, base_w, base_h, margin, margin,
base_w + 2 * margin + shadow_pad // 2 if decor else base_w,
base_h + 2 * margin + shadow_pad // 2 if decor else base_h,
work / f"{tag}-mask.png", work / f"{tag}-decor.png" if decor else None, keys)
_make_images(plan, o["border"], pad, shadow_pad, o["radius"] * k)
plans.append(plan)
return plans
def inset_graph(plans: list[InsetPlan], inputs: list[dict], base: str, raw: str, t0: float, frame: tuple[int, int],
out: str) -> list[str]:
"""Trechos do filter_complex: [base] (vídeo já no layout) + camadas → [out]. `raw` = vídeo original concatenado;
`inputs[i]` = {"mask": idx, "decor": idx|None} das entradas PNG (em loop) de cada camada. Tamanho e posição só
viram expressão por quadro quando mudam (keys, pop, slide)."""
fw, fh = frame
g = [f"[{raw}]split={len(plans)}" + "".join(f"[ir{i}]" for i in range(len(plans))) if len(plans) > 1
else f"[{raw}]null[ir0]"]
cur = base
T = f"(t+{t0:.3f})"
for i, (p, idx) in enumerate(zip(plans, inputs)):
o, src = p.inset, p.inset["src"]
a, b = p.a - t0, p.b - t0 # tempo do grafo (a prévia começa em 0)
g.append(f"[ir{i}]crop=iw*{src['w']}:ih*{src['h']}:iw*{src['x']}:ih*{src['y']},scale={p.base_w}:{p.base_h},"
f"setsar=1,format=rgba[iv{i}]")
g.append(f"[{idx['mask']}:v]format=gray[im{i}]")
g.append(f"[iv{i}][im{i}]alphamerge[ia{i}]")
comp = f"ia{i}"
if idx.get("decor") is not None: # recorte por cima da sombra + borda (imagem pequena, uma vez por quadro)
g.append(f"[{idx['decor']}:v]format=rgba[id{i}]")
g.append(f"[id{i}][ia{i}]overlay={p.ox}:{p.oy}:format=rgb[ic{i}]")
comp = f"ic{i}"
chain = []
if p.dynamic_size:
k = f"(({piecewise(p.keys, 'size', T)})/{p.base_w / fw:.5f})"
if o["anim"] == "pop": # cresce de 82 % a 106 % e assenta em 100 %
k += (f"*if(lt({T}-{p.a:.3f},0.16),0.82+0.24*({T}-{p.a:.3f})/0.16,"
f"if(lt({T}-{p.a:.3f},0.28),1.06-0.06*({T}-{p.a:.3f}-0.16)/0.12,1))")
chain.append(f"scale=w='max(2,round({p.decor_w}*{k}))':h='max(2,round({p.decor_h}*{k}))':eval=frame")
elif p.keys[0]["size"] * fw < p.base_w - 1: # tamanho fixo menor que o maior dos keys (não acontece sem keys)
s = p.keys[0]["size"] * fw / p.base_w
chain.append(f"scale={max(2, round(p.decor_w * s))}:{max(2, round(p.decor_h * s))}")
if o["anim"] != "none":
chain.append(f"fade=t=in:st={max(0.0, a):.3f}:d={ANIM_S}:alpha=1")
chain.append(f"fade=t=out:st={max(0.0, b - ANIM_S):.3f}:d={ANIM_S}:alpha=1")
if chain:
g.append(f"[{comp}]" + ",".join(chain) + f"[if{i}]")
comp = f"if{i}"
fx, fy = (p.ox + p.base_w / 2) / p.decor_w, (p.oy + p.base_h / 2) / p.decor_h # centro do recorte na imagem
if p.dynamic_pos:
dx = ""
if o["anim"] == "slide": # entra pela direita
u = f"clip(({T}-{p.a:.3f})/{SLIDE_S},0,1)"
dx = f"+{fw * 0.7:.1f}*(1-{u}*{u}*(3-2*{u}))"
pos = (f"x='{fw}*({piecewise(p.keys, 'x', T)}){dx}-w*{fx:.5f}':"
f"y='{fh}*({piecewise(p.keys, 'y', T)})-h*{fy:.5f}':eval=frame")
else:
pos = f"x='{fw * p.keys[0]['x']:.2f}-w*{fx:.5f}':y='{fh * p.keys[0]['y']:.2f}-h*{fy:.5f}'"
nxt = out if i == len(plans) - 1 else f"li{i}"
g.append(f"[{cur}][{comp}]overlay={pos}:enable='between(t,{a:.3f},{b:.3f})'[{nxt}]")
cur = nxt
return g
+399
View File
@@ -0,0 +1,399 @@
"""Escolha dos melhores momentos. Funções puras (sem E/S): recebem a linha do tempo e devolvem os trechos.
Ideia central: o chat reage DEPOIS do momento. Medimos a "empolgação" do chat por segundo (mensagens com peso:
risada, susto, hype e pedido de clip valem mais), comparamos com o normal recente da própria live (chat grande
tem muita mensagem o tempo todo; o que importa é o pico relativo) e, achado o pico, voltamos no tempo até onde a
reação começou e pegamos alguns segundos antes disso: é ali que aconteceu a coisa.
Sem chat (VOD), o sinal vem do volume do áudio (gritos, risadas) e de palavras de reação na transcrição.
Rosto do streamer (opcional, `face`): a série por segundo do rastreio (reaction.py). Reforça momentos do chat/áudio
(`reasons.face` + bônus limitado na nota) e cria momentos de fonte "face" só quando o áudio ou o chat também se
mexem no mesmo trecho — rosto sozinho nunca vira corte. Sem `face`, o resultado é idêntico ao de antes.
"""
from __future__ import annotations
import math
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field, replace
from . import reaction
# Peso extra por categoria de reação. Uma mensagem pode somar mais de uma.
REACTION_PATTERNS: dict[str, tuple[re.Pattern[str], float]] = {
"risada": (re.compile(r"(k{3,}|kek|lul|lmao|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b)", re.I), 1.0),
"susto": (re.compile(r"(caralho|crlh|caraca|nossa|meu deus|mds|wtf|omg|que isso|q isso|monkas|monkaw|\bhuh+\b|"
r"😱|😳|\?{3,}|!{3,})", re.I), 1.0),
"hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥)", re.I), 0.7),
# Palavra inteira: "clip5k1hmm" (emote) casava com \bclip e dava peso de pedido de clipe.
"clip": (re.compile(r"\b(clip|clips|clipa|clipe|clipou|clipar|clip it|clipit)\b", re.I), 3.0),
}
# Palavras faladas que indicam reação (modo sem chat).
SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha)$", re.I)
@dataclass(frozen=True)
class Params:
pre_s: float = 14.0 # quanto antes do início da reação o corte começa
post_s: float = 6.0 # quanto depois do pico o corte termina
# Duração do candidato: o motor troca pelos valores da configuração do corte de cada sessão (`duration`);
# estes são os mesmos padrões de layout.DEFAULTS (pedido do dono, 16/11/2026: cortes de 60 a 90 s).
min_s: float = 60.0
max_s: float = 90.0
threshold: float = 2.2 # pico precisa ser X vezes o normal recente do chat
audio_threshold: float = 2.0 # modo sem chat: z-score mínimo
min_gap_s: float = 45.0 # distância mínima entre dois picos
smooth_s: int = 5
baseline_s: int = 180
onset_ratio: float = 1.3 # o início da reação é onde a razão cai abaixo disto
max_onset_s: float = 30.0
settle_s: float = 12.0 # ao vivo: espera este tanto depois do fim do corte antes de fechar o pico
min_rate: float = 0.2 # mensagens/s mínimas no denominador (live com chat parado não vira pico por 2 msgs)
min_peak_messages: int = 12 # teto do mínimo de mensagens nos 8 s do pico (chat grande)
min_peak_floor: int = 4 # piso do mínimo (chat pequeno): 3 mensagens soltas nunca viram pico
min_reactions: int = 2 # mensagens de reação (risada/susto/hype/clip) nos 8 s do pico
sparse_rate: float = 0.5 # msg/s abaixo disso o chat é "fraco" e o áudio também propõe momentos
warmup_s: int = 60 # começo da gravação: ainda não há "normal" do chat para comparar
# --- rosto do streamer (reaction.py) ---
face_threshold: float = 3.0 # z mínimo da reação no rosto para anotar/reforçar um momento
face_bonus: float = 0.08 # nota extra por unidade de z do rosto num momento do chat/áudio…
face_bonus_max: float = 0.6 # …limitada a isto (o rosto reforça, não manda)
# Momento NOVO de fonte "face" (calibrado na sessão 3: com z ≥ 3 e apoio fraco saíam 32 momentos em 72 min,
# mais que os 21 do chat): reação forte no rosto E apoio de verdade no mesmo trecho.
face_source_threshold: float = 6.0 # z mínimo (= "forte")
face_support_audio_z: float = 1.5 # sinal do áudio suavizado (3 s) acima disto…
face_support_reactions: int = 2 # …ou pelo menos isto de mensagens de reação (texto ou emote) no chat
face_chat_after_s: float = 10.0 # o chat reage depois: conta até X s após o pico do rosto
face_score_scale: float = 0.4 # nota do momento "face" = z do rosto (até 10) × isto, na escala da razão do chat
@dataclass(frozen=True)
class ChatMessage:
t: float
text: str
user: str = ""
emotes: tuple[str, ...] = () # emotes da mensagem (Twitch, 7TV, BTTV, FFZ, Kick, emoji)
bonus: float = 0.0 # peso extra pelos emotes (base + aprendido do canal; ver emotes.py)
@dataclass(frozen=True)
class Word:
start: float
end: float
word: str
@dataclass
class Moment:
peak_s: float
start_s: float
end_s: float
score: float
source: str # "chat" ou "audio"
reasons: dict = field(default_factory=dict)
def message_weight(text: str) -> tuple[float, list[str]]:
weight, tags = 1.0, []
for tag, (pattern, bonus) in REACTION_PATTERNS.items():
if pattern.search(text):
weight += bonus
tags.append(tag)
return weight, tags
def per_second(duration_s: float, chat: list[ChatMessage]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
series = [0.0] * n
for message in chat:
i = int(message.t)
if 0 <= i < n:
series[i] += message_weight(message.text)[0] + message.bonus
return series
def smooth(series: list[float], window: int) -> list[float]:
"""Média móvel para trás (só usa o passado: o valor em t não depende do futuro)."""
out, acc = [], 0.0
for i, value in enumerate(series):
acc += value
if i >= window:
acc -= series[i - window]
out.append(acc / min(i + 1, window))
return out
def chat_ratio(series: list[float], p: Params) -> list[float]:
"""Razão entre a empolgação suavizada e o normal recente (mediana dos últimos `baseline_s`, sem os últimos 10 s)."""
smoothed = smooth(series, p.smooth_s)
ratio = []
for t, value in enumerate(smoothed):
window = smoothed[max(0, t - p.baseline_s): max(0, t - 10)]
if len(window) < 30: # começo da gravação: usa o que tiver
window = smoothed[: t + 1]
base = max(p.min_rate, statistics.median(window) if window else p.min_rate)
ratio.append(value / base)
return ratio
def zscores(series: list[float]) -> list[float]:
values = [v for v in series if v is not None and not math.isnan(v)]
if len(values) < 10:
return [0.0] * len(series)
mean = statistics.fmean(values)
sd = statistics.pstdev(values) or 1.0
return [((v - mean) / sd) if v is not None and not math.isnan(v) else 0.0 for v in series]
def audio_signal(duration_s: float, loudness: list[float | None], words: list[Word]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
loud = (list(loudness) + [None] * n)[:n]
z = zscores([v if v is not None else float("nan") for v in loud])
signal = [max(0.0, v) for v in z]
for word in words:
i = int(word.start)
if 0 <= i < n and SPOKEN_REACTION.match(word.word.strip(" .,!?…").lower()):
signal[i] += 0.5
return smooth(signal, 3)
def pick_peaks(score: list[float], threshold: float, min_gap_s: float, limit_s: float | None = None) -> list[int]:
"""Picos acima do limiar, do maior para o menor, sem dois a menos de `min_gap_s`."""
# Escolhe olhando a série inteira e só depois descarta os não assentados (após `limit_s`): assim, ao vivo,
# um pico maior que ainda está crescendo segura os pontos menores do começo da mesma explosão.
candidates = sorted((i for i in range(len(score)) if score[i] >= threshold), key=lambda i: -score[i])
chosen: list[int] = []
for i in candidates:
if all(abs(i - j) >= min_gap_s for j in chosen):
chosen.append(i)
return sorted(i for i in chosen if limit_s is None or i < limit_s)
def onset(score: list[float], peak: int, below: float, max_back_s: float) -> int:
t = peak
while t > 0 and peak - t < max_back_s and score[t - 1] >= below:
t -= 1
return t
def snap_to_words(start: float, end: float, words: list[Word], gap: float = 0.35, reach: float = 4.0) -> tuple[float, float]:
"""Não corta no meio de uma frase: recua o início até uma pausa e estica o fim até uma pausa (até `reach` s)."""
if not words:
return start, end
ordered = sorted(words, key=lambda w: w.start)
# Começos de frase (palavra depois de uma pausa) perto do início pedido; prefere o mais próximo ANTES dele.
starts = [
w.start for i, w in enumerate(ordered)
if start - reach <= w.start <= start + 0.5 and (i == 0 or w.start - ordered[i - 1].end >= gap)
]
before = [s for s in starts if s <= start]
new_start = (max(before) if before else min(starts)) - 0.15 if starts else start
new_end = end
for i, word in enumerate(ordered):
if end - 0.5 <= word.end <= end + reach:
pause_after = ordered[i + 1].start - word.end if i + 1 < len(ordered) else gap
if pause_after >= gap:
new_end = word.end + 0.25
break
return max(0.0, new_start), max(new_end, new_start + 1)
def fit_window(start: float, end: float, lo: float, hi: float, min_len: float, max_len: float,
keep: str = "end") -> tuple[float, float]:
"""Encaixa [start, end] em [lo, hi] com duração entre `min_len` e `max_len`. Longo demais: corta o lado oposto a
`keep`. Curto demais: cresce PARA TRÁS primeiro (o contexto vem antes da reação) e, se bater em `lo` (começo da
gravação/janela), para a frente até `hi`. Se nem assim couber (material menor que o mínimo), devolve o que der —
quem chama decide o que fazer (não inventa vídeo). Arredonda para fora (centésimos), nunca encurta."""
start, end = max(lo, start), min(hi, end)
if end < start:
end = start
if end - start > max_len:
if keep == "start":
end = start + max_len
else:
start = end - max_len
if end - start < min_len:
start = max(lo, end - min_len)
if end - start < min_len:
end = min(hi, start + min_len)
return math.floor(start * 100) / 100, math.ceil(end * 100 - 1e-6) / 100
def fit_length(start: float, end: float, peak: float, p: Params, duration_s: float) -> tuple[float, float]:
"""Duração do candidato: começa pelo menos 2 s antes do pico e fica entre `min_s` e `max_s` (o motor passa o
mínimo da configuração + 1 s). Antes a ordem permitia passar do máximo e, no fim da gravação, ficar curto."""
start = max(0.0, min(start, peak - 2))
return fit_window(start, end, 0.0, max(duration_s, end), p.min_s, p.max_s, keep="end")
def chat_reasons(chat: list[ChatMessage], start: float, end: float) -> dict:
inside = [m for m in chat if start <= m.t <= end]
tags: Counter[str] = Counter()
phrases: Counter[str] = Counter()
emotes: Counter[str] = Counter()
for message in inside:
tags.update(message_weight(message.text)[1])
emotes.update(set(message.emotes))
normalized = re.sub(r"\s+", " ", message.text.strip())[:40]
if normalized:
phrases[normalized.lower()] += 1
return {
"messages": len(inside),
"tags": dict(tags.most_common()),
"topMessages": [text for text, _ in phrases.most_common(5)],
"emotes": dict(emotes.most_common(8)),
}
def find_moments(
duration_s: float,
chat: list[ChatMessage],
loudness: list[float | None],
words: list[Word],
params: Params | None = None,
live: bool = False,
face: list[reaction.FaceSecond] | None = None,
) -> list[Moment]:
"""Melhores momentos da linha do tempo. `live=True` só devolve picos já "assentados" (fim + settle_s <= duração).
Chat com movimento → picos do chat. Chat fraco (média < `sparse_rate` msg/s) → picos do chat E do áudio
(gritos/risadas/palavras de reação), sem sobrepor; o juiz de IA filtra. Sem chat → só áudio.
`face`: série do rosto alinhada à linha do tempo (índice = segundo; `None`/vazia = sem rosto).
"""
p = params or Params()
use_chat = len(chat) >= 30
moments = _chat_moments(duration_s, chat, loudness, words, p, live) if use_chat else []
sparse = duration_s > 0 and len(chat) / duration_s < p.sparse_rate
if not use_chat or sparse:
for m in _audio_moments(duration_s, loudness, words, p, live):
if not any(overlaps(m.start_s, m.end_s, c.start_s, c.end_s) for c in moments):
moments.append(m)
if face:
moments += _face_moments(duration_s, chat if use_chat else [], loudness, words, face, moments, p, live)
return sorted(moments, key=lambda m: m.peak_s)
def _face_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
face: list[reaction.FaceSecond], moments: list[Moment], p: Params, live: bool) -> list[Moment]:
"""Anota o rosto nos momentos do chat/áudio (bônus limitado) e devolve os momentos novos de fonte "face"."""
reactions = reaction.reaction_moments(face, replace(reaction.ReactionParams(), threshold=p.face_threshold))
if not reactions:
return []
for m in moments:
near = [r for r in reactions if m.start_s - 2 <= r.peak_s <= m.end_s + 3]
if near:
best = max(near, key=lambda r: r.intensity)
m.reasons["face"] = best.to_json()
m.score = round(m.score + min(p.face_bonus_max, p.face_bonus * best.intensity), 3)
n = max(0, int(math.ceil(duration_s)))
# Sinal do áudio suavizado (3 s, igual ao da fonte "audio"): o z cru de 1 segundo passa de 1 por acaso em ~16 %
# dos segundos e não serviria de apoio.
loud = audio_signal(duration_s, loudness, words)
reacting = [m.t for m in chat if message_weight(m.text)[1] or m.emotes]
limit = duration_s - p.post_s - p.settle_s if live else None
out: list[Moment] = []
for r in sorted(reactions, key=lambda r: -r.intensity):
if r.intensity < p.face_source_threshold or (limit is not None and r.peak_s >= limit):
continue
lo, hi = max(0, r.onset_s - 2), min(n, r.peak_s + 4)
audio = max(loud[lo:hi], default=0.0)
chat_hits = sum(1 for t in reacting if r.onset_s - 2 <= t <= r.peak_s + p.face_chat_after_s)
# Rosto sozinho não vira corte: precisa de apoio do áudio (gritou/riu alto) ou do chat no mesmo trecho.
if audio < p.face_support_audio_z and chat_hits < p.face_support_reactions:
continue
start, end = snap_to_words(r.onset_s - p.pre_s, max(r.end_s, r.peak_s) + p.post_s, words)
start, end = fit_length(start, end, r.peak_s, p, duration_s)
if any(overlaps(start, end, m.start_s, m.end_s) for m in moments + out):
continue
if any(abs(r.peak_s - m.peak_s) < p.min_gap_s for m in out):
continue
reasons = {"peakRatio": round(r.intensity, 2), "onsetS": r.onset_s, "face": r.to_json(),
"support": {"audioZ": round(audio, 2), "chatReactions": chat_hits}}
if chat:
reasons |= chat_reasons(chat, r.onset_s - 2, r.peak_s + 3)
out.append(Moment(float(r.peak_s), start, end, round(min(10.0, r.intensity) * p.face_score_scale, 3), "face",
reasons))
return out
def _required_messages(counts_8s: list[int], t: int, p: Params) -> int:
"""Mínimo de mensagens nos 8 s do pico, proporcional ao chat daquela live (mediana recente × 3).
Medido em 17/11/2026: chat de 0,15 msg/s (skipnho) nunca chegava às 12 mensagens fixas e a live inteira ficava
sem corte; chat de ~0,6 msg/s (alanzoka) com 3 mensagens soltas não pode virar pico. Fica entre 4 e 12.
"""
window = counts_8s[max(0, t - p.baseline_s): max(0, t - 10)] or counts_8s[: t + 1]
typical = statistics.median(window) if window else 0
return int(max(p.min_peak_floor, min(p.min_peak_messages, math.ceil(typical * 3))))
def _chat_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
p: Params, live: bool) -> list[Moment]:
score, threshold = chat_ratio(per_second(duration_s, chat), p), p.threshold
loud_z = zscores([v if v is not None else float("nan") for v in (list(loudness) + [None] * len(score))[: len(score)]])
score = [s + 0.15 * max(0.0, z) for s, z in zip(score, loud_z)] # grito junto com o pico do chat soma um pouco
# Falso positivo medido na live real: chat calmo + 3 mensagens (uma com "clip") já dava razão 2,35, e o
# começo da gravação (sem "normal" para comparar) virava pico. Exige gente reagindo (relativo ao chat) e aquecimento.
counts, reacts = [0] * len(score), [0] * len(score)
for message in chat:
i = int(message.t)
if 0 <= i < len(counts):
counts[i] += 1
# Reação = texto de reação OU emote (público pequeno reage com emote em vez de "kkkk").
reacts[i] += 1 if (message_weight(message.text)[1] or message.emotes) else 0
prefix, rprefix = [0], [0]
for c, r in zip(counts, reacts):
prefix.append(prefix[-1] + c)
rprefix.append(rprefix[-1] + r)
counts_8s = [prefix[t + 1] - prefix[max(0, t - 7)] for t in range(len(score))] # mensagens nos últimos 8 s
for t in range(len(score)):
required = _required_messages(counts_8s, t, p)
reactions = rprefix[t + 1] - rprefix[max(0, t - 7)]
# Chat pequeno junta 4 "oi" por acaso: além do volume, exige reação de verdade (ou volume dobrado).
enough = counts_8s[t] >= required and (reactions >= p.min_reactions or counts_8s[t] >= 2 * required)
if t < p.warmup_s or not enough:
score[t] = min(score[t], threshold - 0.01)
return _build(score, threshold, p.onset_ratio, "chat", duration_s, chat, words, p, live)
def _audio_moments(duration_s: float, loudness: list[float | None], words: list[Word], p: Params, live: bool) -> list[Moment]:
score = audio_signal(duration_s, loudness, words)
return _build(score, p.audio_threshold, 0.8, "audio", duration_s, [], words, p, live)
def _build(score: list[float], threshold: float, below: float, source: str, duration_s: float,
chat: list[ChatMessage], words: list[Word], p: Params, live: bool) -> list[Moment]:
limit = duration_s - p.post_s - p.settle_s if live else None
moments = []
for peak in pick_peaks(score, threshold, p.min_gap_s, limit):
begin = onset(score, peak, below, p.max_onset_s)
start, end = begin - p.pre_s, peak + p.post_s
start, end = snap_to_words(start, end, words)
start, end = fit_length(start, end, peak, p, duration_s)
reasons = {"peakRatio": round(score[peak], 2), "onsetS": begin}
if chat:
reasons |= chat_reasons(chat, begin - 2, peak + 3)
moments.append(Moment(float(peak), start, end, round(score[peak], 3), source, reasons))
return moments
def overlaps(a_start: float, a_end: float, b_start: float, b_end: float, tolerance: float = 5.0) -> bool:
return a_start < b_end - tolerance and b_start < a_end - tolerance
def timeline(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], params: Params | None = None) -> dict:
"""Séries por segundo para o gráfico do painel (mensagens/s, razão do chat, volume)."""
p = params or Params()
raw = per_second(duration_s, chat)
counts = [0] * len(raw)
for message in chat:
if 0 <= int(message.t) < len(counts):
counts[int(message.t)] += 1
return {
"messagesPerS": counts,
"ratio": [round(v, 2) for v in chat_ratio(raw, p)] if chat else [],
"loudnessDb": [None if v is None else round(v, 1) for v in loudness[: len(raw)]],
}
+78
View File
@@ -0,0 +1,78 @@
"""Reconhece a plataforma e o canal a partir do link colado (Twitch, YouTube, Kick)."""
from __future__ import annotations
import re
from dataclasses import dataclass
from urllib.parse import parse_qs, urlparse
PLATFORMS = ("twitch", "youtube", "kick")
_TWITCH_LOGIN = re.compile(r"^[a-z0-9_]{3,25}$")
_KICK_SLUG = re.compile(r"^[a-z0-9_-]{2,40}$")
_YT_HANDLE = re.compile(r"^@[A-Za-z0-9._-]{2,40}$")
_YT_VIDEO = re.compile(r"^[A-Za-z0-9_-]{11}$")
_TWITCH_RESERVED = {"videos", "directory", "settings", "p", "search", "downloads", "jobs", "turbo"}
class SourceError(ValueError):
"""Link que o Clipador não reconhece."""
@dataclass(frozen=True)
class Source:
platform: str
channel: str # login (Twitch), slug (Kick) ou @handle/ID do canal (YouTube); "" quando só há o vídeo
url: str # link normalizado que vai para o Streamlink
kind: str # "live" (canal) ou "vod" (vídeo gravado)
@property
def channel_id(self) -> str:
return f"{self.platform}-{self.channel.lstrip('@').lower()}"
def parse_source(raw: str) -> Source:
text = raw.strip()
if not text:
raise SourceError("Cole o link da live ou do vídeo.")
if "://" not in text:
text = "https://" + text
url = urlparse(text)
if url.scheme not in ("http", "https"):
raise SourceError("O link precisa começar com https://.")
host = (url.hostname or "").lower().removeprefix("www.").removeprefix("m.")
parts = [p for p in url.path.split("/") if p]
if host in ("twitch.tv", "go.twitch.tv"):
if len(parts) >= 2 and parts[0] == "videos" and parts[1].isdigit():
return Source("twitch", "", f"https://www.twitch.tv/videos/{parts[1]}", "vod")
if len(parts) >= 3 and parts[1] == "video" and parts[2].isdigit():
return Source("twitch", parts[0].lower(), f"https://www.twitch.tv/videos/{parts[2]}", "vod")
if parts and _TWITCH_LOGIN.fullmatch(parts[0].lower()) and parts[0].lower() not in _TWITCH_RESERVED:
login = parts[0].lower()
return Source("twitch", login, f"https://www.twitch.tv/{login}", "live")
raise SourceError("Link da Twitch não reconhecido (use twitch.tv/<canal> ou twitch.tv/videos/<id>).")
if host == "kick.com":
if len(parts) >= 3 and parts[1] == "videos":
return Source("kick", parts[0].lower(), f"https://kick.com/{parts[0].lower()}/videos/{parts[2]}", "vod")
if len(parts) == 1 and _KICK_SLUG.fullmatch(parts[0].lower()):
slug = parts[0].lower()
return Source("kick", slug, f"https://kick.com/{slug}", "live")
raise SourceError("Link da Kick não reconhecido (use kick.com/<canal>).")
if host in ("youtube.com", "youtu.be"):
if host == "youtu.be" and parts and _YT_VIDEO.fullmatch(parts[0]):
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[0]}", "vod")
video = parse_qs(url.query).get("v", [""])[0]
if parts[:1] == ["watch"] and _YT_VIDEO.fullmatch(video):
return Source("youtube", "", f"https://www.youtube.com/watch?v={video}", "vod")
if len(parts) >= 2 and parts[0] in ("live", "shorts") and _YT_VIDEO.fullmatch(parts[1]):
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[1]}", "vod")
if parts and _YT_HANDLE.fullmatch(parts[0]):
return Source("youtube", parts[0], f"https://www.youtube.com/{parts[0]}/live", "live")
if len(parts) >= 2 and parts[0] == "channel" and re.fullmatch(r"UC[A-Za-z0-9_-]{22}", parts[1]):
return Source("youtube", parts[1], f"https://www.youtube.com/channel/{parts[1]}/live", "live")
raise SourceError("Link do YouTube não reconhecido (use youtube.com/@canal ou o link do vídeo).")
raise SourceError("Plataforma não suportada: use Twitch, YouTube ou Kick.")
+146
View File
@@ -0,0 +1,146 @@
"""Legenda queimada no corte (formato ASS, lido pelo filtro `ass` do FFmpeg), no vertical ou no horizontal.
Estilo de corte de live: blocos curtos, grandes, com contorno, e a palavra falada no momento destacada.
Cores, fonte, tamanho, posição e palavras por bloco vêm da configuração do corte (layout.py, grupo `caption`).
O crédito do canal fica em cima ou embaixo (grupo `credit`) — sempre ligado por padrão: o corte é de terceiros.
Tempo da legenda (pedido do dono, 16/11/2026: "com fala rápida a legenda sai fora do tempo e fica uma em cima da
outra"). Medido na cópia do banco: 63 de 286 eventos de legenda dos projetos se sobrepunham — o fim de um bloco
(fim da última palavra, no mínimo +0,25 s) passava do início do bloco seguinte, e o libass EMPILHA dois eventos
ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
- `clean_words`: palavras ordenadas, sem sobreposição, duração mínima (o Whisper devolve palavra de 0 s) e nunca
duas começando no mesmo instante;
- `group_words`: até `maxWords` palavras e um limite de caracteres; bloco quebra em pausa > 0,6 s ou se passar de
3,2 s; com fala muito rápida (bloco cheio durando < 0,7 s) aceita UMA palavra a mais se couber nos caracteres,
para o bloco não piscar;
- `caption_blocks`: o fim de cada bloco é cortado no início do seguinte — nunca dois blocos na tela. O início do
bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
"""
from __future__ import annotations
from . import layout
from .scoring import Word
WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração
MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6
MIN_WORD_S = 0.06 # duração mínima de uma palavra na legenda
MIN_STEP_S = 0.04 # duas palavras nunca começam no mesmo instante (a palavra destacada precisa de tempo próprio)
MIN_HOLD_S = 0.25 # a última palavra do bloco fica pelo menos isto (se o próximo bloco não começar antes)
MAX_BLOCK_S = 3.2 # bloco mais longo que isto quebra (fala arrastada)
FAST_BLOCK_S = 0.7 # bloco cheio mais curto que isto = fala rápida: aceita uma palavra a mais
def _ts(seconds: float) -> str:
seconds = max(0.0, seconds)
cs = int(round(seconds * 100))
h, cs = divmod(cs, 360000)
m, cs = divmod(cs, 6000)
s, cs = divmod(cs, 100)
return f"{h}:{m:02d}:{s:02d}.{cs:02d}"
def _escape(text: str) -> str:
# Chaves abrem tags de estilo e \ vira comando no ASS: o texto falado nunca pode virar tag.
return text.replace("\\", "/").replace("{", "(").replace("}", ")").replace("\n", " ")
def clean_words(words: list[Word]) -> list[Word]:
"""Saneia os tempos das palavras: ordena, tira vazias, dá duração mínima, empurra a que começa junto com a
anterior e corta o fim de uma palavra no início da seguinte (sem sobreposição). Idempotente nos valores
(aplicar duas vezes dá o mesmo resultado); depois dela, (início, texto) identifica cada palavra."""
items = sorted((w for w in words if w.word.strip()), key=lambda w: (w.start, w.end))
out: list[Word] = []
for w in items:
start = w.start
if out and start < out[-1].start + MIN_STEP_S - 1e-6:
start = round(out[-1].start + MIN_STEP_S, 3)
end = max(w.end, round(start + MIN_WORD_S, 3))
if out and out[-1].end > start + 1e-9:
prev = out[-1]
out[-1] = Word(prev.start, start, prev.word)
text = w.word.strip()
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word
out.append(w if same else Word(start, end, text))
return out
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
"""Blocos da legenda (palavras já saneadas por `clean_words`)."""
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
groups: list[list[Word]] = []
for word in clean_words(words):
current = groups[-1] if groups else None
if current and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S:
fits = len(" ".join(w.word for w in current + [word])) <= max_chars
room = len(current) < max_words or (
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
max_words >= 2 and len(current) == max_words and word.end - current[0].start < FAST_BLOCK_S)
if fits and room:
current.append(word)
continue
groups.append([word])
return groups
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]:
"""(palavras do bloco, fim do bloco). O fim nunca passa do início do bloco seguinte: dois eventos de legenda
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro)."""
groups = group_words(words, max_words)
out = []
for k, group in enumerate(groups):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
if k + 1 < len(groups):
end = min(end, groups[k + 1][0].start)
out.append((group, round(end, 3)))
return out
def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str, settings: dict | None = None) -> str:
"""`words` com tempos da sessão; a saída usa tempos relativos ao início do corte."""
cfg = settings or layout.merge()
cap, cred = cfg["caption"], cfg["credit"]
duration = clip_end - clip_start
inside = [
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip())
for w in words
if w.end > clip_start and w.start < clip_end
]
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
width, height = layout.canvas_size(cfg)
header = f"""[Script Info]
ScriptType: v4.00+
PlayResX: {width}
PlayResY: {height}
WrapStyle: 2
ScaledBorderAndShadow: yes
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Caption,{cap['font']},{cap['size']},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{cap['outlineWidth']},3,5,60,60,0,1
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""
lines = []
if credit and cred["enabled"]:
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
if cap["enabled"]:
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}"
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
for group, g_end in caption_blocks(inside, cap["maxWords"]):
for i, word in enumerate(group):
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start:
continue
# Maiúsculas só no texto: as tags (\c) são sensíveis a caixa.
parts = []
for j, w in enumerate(group):
text = _escape(w.word.upper() if cap["uppercase"] else w.word)
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text)
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},Caption,,0,0,0,,{pos}{' '.join(parts)}")
return header + "\n".join(lines) + "\n"
File diff suppressed because it is too large Load Diff
+46
View File
@@ -0,0 +1,46 @@
{
"_comment": "Pesos do rastreio de reação do Clipador. Baixados para data/clipper/models/ pelo scripts/setup.ps1 (passo 6b) e conferidos pelo sha256. URLs imutáveis (commit fixo ou caminho versionado). Bancada: doc/FACE_BAKEOFF.md.",
"dir": "data/clipper/models",
"models": [
{
"id": "yunet",
"file": "face_detection_yunet_2026may.onnx",
"role": "achar a câmera (rosto no quadro inteiro), cv2.FaceDetectorYN; entrada dinâmica (OpenCV 5)",
"url": "https://media.githubusercontent.com/media/opencv/opencv_zoo/eb9f4f2d4b79b58e5513b5d25d5f0243a8357bf4/models/face_detection_yunet/face_detection_yunet_2026may.onnx",
"sha256": "ebafce4e3c118d6554634be5c27ab333b4c047a9a8c3faf1d7cf93101c22f0f0",
"size": 229738,
"license": "MIT",
"source": "github.com/opencv/opencv_zoo@eb9f4f2d4b79b58e5513b5d25d5f0243a8357bf4 (Git LFS)"
},
{
"id": "face_landmarker",
"file": "face_landmarker.task",
"role": "478 pontos + 52 blendshapes (MediaPipe Face Landmarker, float16 v1)",
"url": "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
"sha256": "64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff",
"size": 3758596,
"license": "Apache-2.0",
"source": "Google MediaPipe (caminho versionado float16/1)"
},
{
"id": "osf_landmarks",
"file": "osf_lm_model3_opt.onnx",
"role": "plano B: 66 pontos (OpenSeeFace modelo 3), sem blendshapes",
"url": "https://raw.githubusercontent.com/emilianavt/OpenSeeFace/50c09741897010faad721a218b2bbe14ecad6251/models/lm_model3_opt.onnx",
"sha256": "5aa0ab2594acaf2e1d3916a8de592cffeb1f1a7a7f778cad2f37948bff6549d1",
"size": 13500226,
"license": "BSD-2-Clause",
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
},
{
"id": "osf_detector",
"file": "osf_mnv3_detection_opt.onnx",
"role": "plano B: detector de rosto do OpenSeeFace (224×224)",
"url": "https://raw.githubusercontent.com/emilianavt/OpenSeeFace/50c09741897010faad721a218b2bbe14ecad6251/models/mnv3_detection_opt.onnx",
"sha256": "0e8e4806766d85ab067a52c7af0dcb59eb7f9dfe580b44f20a8e6ab712d89809",
"size": 568302,
"license": "BSD-2-Clause",
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
}
]
}
+3
View File
@@ -0,0 +1,3 @@
[pytest]
testpaths = tests
addopts = -q -p no:cacheprovider
+2
View File
@@ -0,0 +1,2 @@
-r requirements.txt
pytest==9.1.1
+17
View File
@@ -0,0 +1,17 @@
# Serviço Clipador do CenaForge (cortes de live). Versões fixas; suba com teste.
fastapi==0.159.1
uvicorn==0.54.0
pydantic==2.14.1
httpx==0.28.1
# Captura de live/VOD (Twitch, YouTube, Kick). O executável streamlink.exe fica em clipper/.venv/Scripts.
streamlink==8.6.3
# Chat da Kick (websocket do Pusher)
websockets==17.4
# Rastreio de reação (câmera + rosto). Bancada em doc/FACE_BAKEOFF.md; pesos em clipper/models.lock.json.
# O MediaPipe já traz o OpenCV (opencv-contrib-python, com cv2.FaceDetectorYN para o YuNet).
# NÃO instale opencv-python-headless junto: os dois brigam pelo mesmo módulo cv2.
mediapipe==1.2.3
opencv-contrib-python==5.0.0.93
numpy==2.5.5
# Plano B (OpenSeeFace só pelos .onnx, BSD-2) — sem blendshapes; fica instalado para o face.py.
onnxruntime==1.32.0
View File
+264
View File
@@ -0,0 +1,264 @@
"""Qualidade de gravação (`capture.quality`), escolha do stream no Streamlink, resolução gravada de fato, busca
exata de quadro em .ts (H.264 e HEVC) e render que atravessa blocos de resolução/codec diferentes."""
import json
import shutil
import subprocess
from pathlib import Path
import pytest
from app import capture, editor, editor_render, layout, media
from app.db import loads
from app.scoring import Word
from .test_sources_and_api import KEY, env, seed_session # noqa: F401 - fixture reaproveitada
FFMPEG = shutil.which("ffmpeg")
FFPROBE = shutil.which("ffprobe")
needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
def auth():
return {"X-Service-Key": KEY}
# ---------------------------------------------------------------- configuração (camadas e validação)
def test_capture_defaults_to_best_and_layers_field_by_field():
assert layout.merge()["capture"] == {"quality": "best"}
assert layout.merge({"capture": {"quality": "720p"}})["capture"]["quality"] == "720p"
# canal 720p, sessão 1080p: a sessão vence
assert layout.merge({"capture": {"quality": "720p"}}, {"capture": {"quality": "1080p"}})["capture"]["quality"] == "1080p"
# configuração antiga (sem o grupo) segue o padrão
assert layout.merge({"layout": {"mode": "blur"}})["capture"]["quality"] == "best"
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
def test_capture_validate_accepts_each_quality(quality):
assert layout.validate({"capture": {"quality": quality}}) == {"capture": {"quality": quality}}
@pytest.mark.parametrize("bad", [{"capture": {"quality": "4k"}}, {"capture": {"quality": "720p60"}},
{"capture": "best"}, {"capture": {"quality": None}}])
def test_capture_validate_rejects_unknown(bad):
with pytest.raises(layout.LayoutError):
layout.validate(bad)
def test_capture_options_match_the_contract():
assert [o["id"] for o in capture.OPTIONS] == list(capture.QUALITIES) == list(layout.CAPTURE_QUALITIES)
for option in capture.OPTIONS:
assert option["label"] and option["hint"] and option["gbPerHour"] > 0
assert option["maxHeight"] == capture.CEILING_HEIGHT.get(option["id"])
# ---------------------------------------------------------------- argumentos do Streamlink
@pytest.mark.parametrize("platform", ["twitch", "kick", "youtube"])
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
def test_stream_choice_per_option_and_platform(platform, quality):
choice = capture.stream_choice(quality, platform)
opts = list(choice.options)
hevc = platform == "twitch" and quality in ("best", "1440p")
assert ("--twitch-supported-codecs" in opts) == hevc
if hevc:
assert opts[opts.index("--twitch-supported-codecs") + 1] == "h264,h265" # sem av1: sem libdav1d no FFmpeg
if quality == "best":
assert choice.streams == "best" and "--stream-sorting-excludes" not in opts
else:
assert opts[opts.index("--stream-sorting-excludes") + 1] == f">{quality}60"
assert choice.streams == "best,worst-unfiltered" # reserva: nunca falha por causa do teto
url = "https://www.twitch.tv/x"
assert choice.args(url)[-2:] == [url, choice.streams]
def test_unknown_quality_falls_back_to_best():
assert capture.stream_choice("4k", "kick") == capture.stream_choice("best", "kick")
# Nomes medidos com `streamlink --json` (17/11/2026). O 2K da Twitch não estava no ar: lista do mesmo formato.
TWITCH = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60"]
TWITCH_PORTRAIT = TWITCH + ["284p30_portrait", "640p30_portrait", "852p30_portrait", "1280p60_portrait", "1920p60_portrait"]
TWITCH_936 = ["audio_only", "160p30", "360p30", "480p30", "720p60", "936p60"]
TWITCH_30 = ["audio_only", "160p30", "360p30", "480p30", "720p30", "1080p"]
TWITCH_2K = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60", "1440p60"]
KICK = ["160p", "360p", "480p", "720p60", "1080p60"]
YOUTUBE = ["144p", "240p", "360p", "480p", "720p", "1080p"]
YOUTUBE_60 = ["144p", "240p", "360p", "480p", "720p60", "1080p60"]
def _pick(names: list[str], choice: capture.StreamChoice) -> str | None:
"""Mesma escolha da CLI (1º nome da lista que existir), com o `Plugin.streams` de verdade do Streamlink."""
from streamlink import Streamlink
from streamlink.plugin import Plugin
from streamlink.stream.http import HTTPStream
class Fake(Plugin):
def _get_streams(self):
return {n: HTTPStream(self.session, f"https://e.invalid/{n}") for n in names}
opts = list(choice.options)
excludes = opts[opts.index("--stream-sorting-excludes") + 1].split(",") if "--stream-sorting-excludes" in opts else None
streams = Fake(Streamlink(), "https://e.invalid/").streams(sorting_excludes=excludes)
name = next((n for n in choice.streams.split(",") if n in streams), None)
return streams[name].url.rsplit("/", 1)[1] if name else None
@pytest.mark.parametrize("names,platform,expected", [
(TWITCH, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_PORTRAIT, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_936, "twitch", {"best": "936p60", "1440p": "936p60", "1080p": "936p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_30, "twitch", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p30", "480p": "480p30"}),
(TWITCH_2K, "twitch", {"best": "1440p60", "1440p": "1440p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(KICK, "kick", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
(YOUTUBE, "youtube", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p", "480p": "480p"}),
(YOUTUBE_60, "youtube", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
])
def test_preference_picks_largest_under_the_ceiling(names, platform, expected):
"""Medido nas lives reais com os mesmos argumentos (skipnho, kagura0mea, hpduketv, hotrodd, westcol): mesmo
resultado. Variantes verticais (`*_portrait`) e `audio_only` nunca são escolhidas."""
assert {q: _pick(names, capture.stream_choice(q, platform)) for q in capture.QUALITIES} == expected
def test_ceiling_with_nothing_below_takes_the_closest_above():
assert _pick(["audio_only", "1080p60"], capture.stream_choice("480p", "twitch")) == "1080p60"
assert _pick(["720p60", "1080p60"], capture.stream_choice("480p", "kick")) == "720p60"
# ---------------------------------------------------------------- resolução gravada de fato
def _make_ts(path: Path, size: str, seconds: float, codec: str = "libx264", rate: int = 60, lum: str | None = None) -> Path:
"""Bloco .ts sintético com GOP de 2 s (como a Twitch). `lum` = expressão do brilho no tempo (geq)."""
src = f"color=c=gray:s={size}:r={rate}:d={seconds}" + (f",geq=lum='{lum}':cb=128:cr=128" if lum else "")
codec_args = ["-c:v", codec, "-g", str(2 * rate), "-bf", "0"]
if codec == "libx265":
codec_args += ["-x265-params", f"keyint={2 * rate}:min-keyint={2 * rate}:open-gop=0:bframes=0:log-level=error"]
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", src, "-f", "lavfi", "-i",
f"sine=frequency=440:sample_rate=48000:duration={seconds}", *codec_args, "-pix_fmt", "yuv420p",
"-c:a", "aac", "-shortest", "-f", "mpegts", str(path)], check=True, capture_output=True)
return path
@needs_ffmpeg
def test_probe_block_reads_resolution_fps_codec(tmp_path):
info = capture.probe_block(FFPROBE, _make_ts(tmp_path / "a.ts", "320x180", 2))
assert (info["width"], info["height"], info["fps"], info["codec"]) == (320, 180, 60, "h264")
assert info["kbps"] and info["gbPerHour"] > 0
def test_record_run_keeps_runs_and_flags_mixed_resolution():
p1 = {"width": 1920, "height": 1080, "fps": 60, "codec": "h264", "kbps": 8000, "gbPerHour": 3.6}
first = capture.record_run(None, "best", 0, p1, "t1")
assert first["width"] == 1920 and first["quality"] == "best" and first["mixed"] is False and len(first["runs"]) == 1
same = capture.record_run(first, "best", 40, p1, "t2")
assert same["mixed"] is False and [r["fromIdx"] for r in same["runs"]] == [0, 40]
p2 = {**p1, "width": 1280, "height": 720}
mixed = capture.record_run(same, "720p", 80, p2, "t3")
assert mixed["height"] == 720 and mixed["fromIdx"] == 80 and mixed["mixed"] is True
assert capture.label(mixed) == "1280×720 · 60 qps"
@needs_ffmpeg
def test_capture_records_real_resolution_on_first_block(env, tmp_path, monkeypatch): # noqa: F811
from dataclasses import replace
from app.sources import parse_source
from app.worker import Capture
client, engine = env
sid = seed_session(engine, duration=60)
engine.db.run("DELETE FROM segments WHERE session_id = ?", sid)
engine.settings = replace(engine.settings, ffprobe=FFPROBE)
work = tmp_path / "cap"
work.mkdir()
_make_ts(work / "seg_00000.ts", "640x360", 2)
(work / "segments.csv").write_text("seg_00000.ts,0.000000,2.000000\n", encoding="utf-8")
cap = Capture(engine, sid, parse_source("https://www.twitch.tv/alanzoka"), work)
cap.quality = "1440p"
import app.worker as worker_module
monkeypatch.setattr(worker_module, "rel", lambda path: path.as_posix()) # bloco fora do repositório (tmp)
assert cap._collect(work / "segments.csv", 0) == 1
info = loads(engine.db.get("SELECT capture_json FROM sessions WHERE id = ?", sid)["capture_json"], None)
assert (info["quality"], info["width"], info["height"], info["fps"], info["fromIdx"]) == ("1440p", 640, 360, 60, 0)
view = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
assert view["capture"]["width"] == 640 and view["capture"]["mixed"] is False
def test_session_without_capture_info_reports_none(env): # noqa: F811
client, engine = env
sid = seed_session(engine, duration=60)
assert client.get(f"/v1/sessions/{sid}", headers=auth()).json()["capture"] is None
def test_engine_quality_follows_channel_then_session(env): # noqa: F811
client, engine = env
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
sid = seed_session(engine, duration=60)
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
assert engine.capture_quality(sid) == "best" # padrão novo
r = client.put("/v1/channels/twitch-alanzoka/settings", json={"capture": {"quality": "720p"}}, headers=auth())
assert r.status_code == 200 and r.json()["effective"]["capture"]["quality"] == "720p"
assert engine.capture_quality(sid) == "720p"
r = client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "1080p"}}, headers=auth())
assert r.json()["effective"]["capture"]["quality"] == "1080p"
assert engine.capture_quality(sid) == "1080p"
assert client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "8k"}}, headers=auth()).status_code == 400
def test_settings_route_lists_capture_qualities(env): # noqa: F811
client, engine = env
sid = seed_session(engine, duration=60)
body = client.get(f"/v1/sessions/{sid}/settings", headers=auth()).json()
assert [o["id"] for o in body["captureQualities"]] == list(capture.QUALITIES)
assert body["defaults"]["capture"] == {"quality": "best"}
# ---------------------------------------------------------------- busca exata de quadro em .ts
@needs_ffmpeg
@pytest.mark.parametrize("codec", ["libx264", "libx265"])
def test_grab_frame_is_exact_in_ts(tmp_path, codec):
"""Antes: `-ss` antes do `-i` num .ts dava o PRÓXIMO quadro-chave no H.264 e um quadro CINZA no HEVC."""
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
capture_output=True, text=True).stdout:
pytest.skip("FFmpeg sem libx265")
ts = _make_ts(tmp_path / "b.ts", "160x96", 12, codec=codec, rate=30, lum="min(235,16+T*18)")
for t in (3.0, 7.5, 9.3):
out = media.grab_frame(FFMPEG, [(ts, 0.0, 12.0)], t, tmp_path / f"f{t}.png", width=0)
raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(out), "-f", "rawvideo", "-pix_fmt", "gray", "-"],
capture_output=True, check=True).stdout
mean = sum(raw) / len(raw)
expected = t * 18 * 255 / 219 # Y de faixa limitada (16 + 18·t) → cinza de faixa cheia
assert abs(mean - expected) < 6, (t, mean, expected) # 6 ≈ 0,3 s; o próximo quadro-chave daria até 42
def test_seek_args_prerolls_and_selects_absolute_time():
assert media.seek_args(10.0) == (["-ss", "6.000", "-copyts", "-start_at_zero"], "select='gte(t,10.000)'")
assert media.seek_args(1.5) == (["-ss", "0.000", "-copyts", "-start_at_zero"], "select='gte(t,1.500)'")
# ---------------------------------------------------------------- render que atravessa a troca de resolução
@needs_ffmpeg
@pytest.mark.parametrize("second", [("640x360", "libx264"), ("960x540", "libx265")])
def test_render_across_resolution_change_keeps_whole_video(tmp_path, second):
"""Retomada em outra qualidade (ou fonte que muda de resolução). Antes o vídeo parava na emenda (corte de 35 s
com 20 s de vídeo; 15 s na troca H.264 → HEVC)."""
size, codec = second
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
capture_output=True, text=True).stdout:
pytest.skip("FFmpeg sem libx265")
a = _make_ts(tmp_path / "seg_00000.ts", "320x180", 4)
b = _make_ts(tmp_path / "seg_00001.ts", size, 4, codec=codec)
segs = [(a, 0.0, 4.0), (b, 4.0, 8.0)]
same, created = editor_render.uniform_segments(FFMPEG, FFPROBE, [(a, 0.0, 4.0), (a, 4.0, 8.0)], tmp_path, "x")
assert created is None and same == [(a, 0.0, 4.0), (a, 4.0, 8.0)] # blocos iguais: caminho de sempre
clip = {"session_id": 1, "start_s": 1.0, "end_s": 7.0, "peak_s": 4.0, "title": "Emenda"}
project = editor.validate_project(editor.default_project(clip, [Word(1.2, 1.5, "oi")], 8.0), session_id=1,
session_duration=8.0, repo_root=tmp_path, tts_dir=tmp_path, assets_dir=tmp_path)
project["cover"]["enabled"] = False
out = tmp_path / "clip.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], segs, project,
layout.merge(), "canal", out, tmp_path)
streams = json.loads(subprocess.run([FFPROBE, "-v", "error", "-select_streams", "v", "-show_entries",
"stream=duration,width,height", "-of", "json", str(out)],
capture_output=True, text=True, check=True).stdout)["streams"][0]
assert (streams["width"], streams["height"]) == (1080, 1920)
assert float(streams["duration"]) == pytest.approx(6.0, abs=0.15)
assert not list(tmp_path.glob("*.uniform.mkv")) # intermediário apagado
+291
View File
@@ -0,0 +1,291 @@
"""Apagar cortes (um, vários, por aba): regras de estado, arquivos só dentro das pastas do Clipador e a marca que
impede a IA de recriar o momento apagado."""
import json
import os
import sys
from pathlib import Path
import pytest
import app.clip_delete as clip_delete
import app.worker as worker_module
from app.scoring import Moment
from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
def add_clip(engine, sid, cid, status, peak=100.0, start=90.0, end=150.0, source="chat", reasons=None):
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, reasons_json, status, title, "
"created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, ?, ?, ?, 't', 'x', ?)",
cid, sid, peak, start, end, source, json.dumps(reasons or {}), status, worker_module.now())
def touch(path: Path, data: bytes = b"x") -> Path:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
return path
@pytest.fixture
def repo(env, tmp_path, monkeypatch): # noqa: F811
"""REPO_ROOT = tmp_path: os caminhos do banco (relativos à raiz) caem na pasta do teste."""
monkeypatch.setattr(clip_delete, "REPO_ROOT", tmp_path)
monkeypatch.setattr(worker_module, "REPO_ROOT", tmp_path)
client, engine = env
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET dir = ? WHERE id = ?", f"data/sessions/{sid}", sid)
return client, engine, sid, tmp_path
def clip_files(root: Path, sid: int, cid: int) -> dict[str, Path]:
out = root / "clips" / str(sid)
return {
"mp4": touch(out / f"clip-{cid}.mp4"), "jpg": touch(out / f"clip-{cid}.jpg"),
"cover": touch(out / f"clip-{cid}-cover.jpg"), "ass": touch(out / f"clip-{cid}.ass"),
"tmp": touch(out / f"clip-{cid}.tmp.mp4"), "proxy": touch(out / f"edit-{cid}" / "proxy-1000-2000.mp4"),
"tts": touch(out / f"edit-{cid}" / "tts-abcdef123456.wav"), "nested": touch(out / f"edit-{cid}" / "sub" / "a.json"),
"frame": touch(root / "data" / "sessions" / str(sid) / "frames" / f"clip{cid}-120.jpg"),
}
def set_files(engine, cid: int, sid: int, cover: bool = True) -> None:
engine.db.run("UPDATE clips SET file = ?, thumb = ? WHERE id = ?", f"clips/{sid}/clip-{cid}.mp4", f"clips/{sid}/clip-{cid}.jpg", cid)
engine.db.run("INSERT INTO edits (clip_id, project_json, rev, cover, created_at, updated_at) VALUES (?, '{}', 1, ?, 'x', 'x')",
cid, f"clips/{sid}/clip-{cid}-cover.jpg" if cover else None)
# ---------------------------------------------------------------- um corte
def test_delete_one_removes_row_edit_and_all_files(repo):
client, engine, sid, root = repo
add_clip(engine, sid, 1, "ready")
add_clip(engine, sid, 12, "ready", peak=400, start=380, end=450) # vizinho com id que começa igual
files = clip_files(root, sid, 1)
neighbor = clip_files(root, sid, 12)
set_files(engine, 1, sid)
session_file = touch(root / "data" / "sessions" / str(sid) / "seg_00001.ts")
r = client.delete("/v1/clips/1", headers=auth())
assert r.status_code == 200, r.text
body = r.json()
assert body["id"] == 1 and body["status"] == "ready" and body["left"] == []
assert body["removedFiles"] >= len(files)
assert not any(p.exists() for p in files.values())
assert not (root / "clips" / str(sid) / "edit-1").exists()
assert all(p.exists() for p in neighbor.values()) and session_file.exists() # nada do corte 12 nem da gravação
assert engine.db.get("SELECT 1 FROM clips WHERE id = 1") is None
assert engine.db.get("SELECT 1 FROM edits WHERE clip_id = 1") is None
assert client.get("/v1/clips/1", headers=auth()).status_code == 404
mark = engine.db.get("SELECT * FROM deleted_clips WHERE clip_id = 1")
assert mark["session_id"] == sid and mark["peak_s"] == 100 and mark["status"] == "ready"
def test_nonexistent_id_is_404_and_listed_as_not_found(repo):
client, engine, sid, _root = repo
r = client.delete("/v1/clips/999", headers=auth())
assert r.status_code == 404 and r.json()["code"] == "not_found"
r = client.post("/v1/clips/delete", json={"ids": [999]}, headers=auth())
assert r.status_code == 200 and r.json()["failed"] == [{"id": 999, "code": "not_found", "reason": "corte não encontrado"}]
def test_rendering_and_candidate_are_refused(repo):
client, engine, sid, root = repo
add_clip(engine, sid, 1, "rendering")
add_clip(engine, sid, 2, "candidate", peak=300, start=280, end=340)
add_clip(engine, sid, 3, "pending", peak=500, start=480, end=540)
mp4 = touch(root / "clips" / str(sid) / "clip-1.mp4")
r = client.delete("/v1/clips/1", headers=auth())
assert r.status_code == 409 and r.json()["code"] == "busy_rendering" and "renderizando" in r.json()["error"]
assert client.delete("/v1/clips/2", headers=auth()).json()["code"] == "busy_candidate"
engine._rendering.add(3) # o motor acabou de pegar o pendente para renderizar
assert client.delete("/v1/clips/3", headers=auth()).json()["code"] == "busy_rendering"
assert mp4.exists() and engine.db.get("SELECT COUNT(*) AS n FROM clips")["n"] == 3
assert engine.db.get("SELECT COUNT(*) AS n FROM deleted_clips")["n"] == 0
def test_published_needs_explicit_confirmation(repo):
client, engine, sid, _root = repo
add_clip(engine, sid, 1, "published")
r = client.delete("/v1/clips/1", headers=auth())
assert r.status_code == 409 and r.json()["code"] == "published"
assert client.post("/v1/clips/delete", json={"ids": [1]}, headers=auth()).json()["failed"][0]["code"] == "published"
assert client.delete("/v1/clips/1?confirmPublished=true", headers=auth()).status_code == 200
# ---------------------------------------------------------------- vários e por aba
def test_delete_many_reports_what_was_and_was_not_deleted(repo):
client, engine, sid, root = repo
for cid, st, peak in ((1, "discarded", 100), (2, "ready", 200), (3, "rendering", 300), (4, "rejected", 400), (5, "error", 500)):
add_clip(engine, sid, cid, st, peak=peak, start=peak - 10, end=peak + 50)
touch(root / "clips" / str(sid) / "clip-2.mp4")
r = client.post("/v1/clips/delete", json={"ids": [1, 2, 3, 4, 2, 999, 5]}, headers=auth())
assert r.status_code == 200, r.text
body = r.json()
assert body["requested"] == 6 and body["remaining"] == 0 # o 2 repetido conta uma vez
assert [d["id"] for d in body["deleted"]] == [1, 2, 4, 5]
assert {f["id"]: f["code"] for f in body["failed"]} == {3: "busy_rendering", 999: "not_found"}
assert [r["id"] for r in engine.db.all("SELECT id FROM clips")] == [3]
assert not (root / "clips" / str(sid) / "clip-2.mp4").exists()
def test_delete_whole_tab_respects_session_filter(repo):
client, engine, sid, _root = repo
other = seed_session(engine)
add_clip(engine, sid, 1, "discarded", peak=100)
add_clip(engine, sid, 2, "discarded", peak=200)
add_clip(engine, sid, 3, "ready", peak=300)
add_clip(engine, other, 4, "discarded", peak=100)
r = client.post("/v1/clips/delete", json={"statuses": ["discarded"], "sessionId": sid}, headers=auth())
body = r.json()
assert sorted(d["id"] for d in body["deleted"]) == [1, 2] and body["failed"] == []
assert sorted(r["id"] for r in engine.db.all("SELECT id FROM clips")) == [3, 4]
# Sem sessão: todas as sessões, inclusive "para aprovar".
r = client.post("/v1/clips/delete", json={"statuses": ["ready", "discarded"]}, headers=auth())
assert sorted(d["id"] for d in r.json()["deleted"]) == [3, 4]
assert engine.db.get("SELECT COUNT(*) AS n FROM clips")["n"] == 0
def test_batch_validation_and_limit(repo, monkeypatch):
client, engine, sid, _root = repo
assert client.post("/v1/clips/delete", json={}, headers=auth()).status_code == 400
assert client.post("/v1/clips/delete", json={"ids": [1], "statuses": ["ready"]}, headers=auth()).status_code == 400
assert client.post("/v1/clips/delete", json={"ids": [1], "sessionId": sid}, headers=auth()).status_code == 400
assert client.post("/v1/clips/delete", json={"ids": list(range(1, 502))}, headers=auth()).status_code == 422
assert client.post("/v1/clips/delete", json={"statuses": ["nada"]}, headers=auth()).status_code == 422
for cid in range(1, 6):
add_clip(engine, sid, cid, "discarded", peak=cid * 100)
monkeypatch.setattr(clip_delete, "MAX_BATCH", 3)
ids, remaining = clip_delete.select_ids(engine.db, None, ["discarded"], clip_delete.MAX_BATCH)
assert ids == [5, 4, 3] and remaining == 2
# ---------------------------------------------------------------- arquivos fora da pasta
def test_files_outside_clipper_folders_are_never_touched(repo):
client, engine, sid, root = repo
outside = touch(root / "outside" / "importante.mp4", b"nao apague")
add_clip(engine, sid, 1, "ready")
engine.db.run("UPDATE clips SET file = ?, thumb = ? WHERE id = 1", "outside/importante.mp4", "../fora.jpg")
fora = touch(root.parent / "fora.jpg", b"tambem nao")
try:
body = client.delete("/v1/clips/1", headers=auth()).json()
assert outside.read_bytes() == b"nao apague" and fora.read_bytes() == b"tambem nao"
assert {x["file"] for x in body["left"]} >= {"outside/importante.mp4"}
assert all("fora das pastas" in x["reason"] for x in body["left"])
finally:
fora.unlink(missing_ok=True)
@pytest.mark.skipif(sys.platform != "win32", reason="junção é do Windows")
def test_junction_inside_edit_folder_is_not_followed(repo):
import _winapi
client, engine, sid, root = repo
target = root / "outside" / "pasta"
keep = touch(target / "nao-apague.txt", b"alvo")
add_clip(engine, sid, 1, "ready")
edit = root / "clips" / str(sid) / "edit-1"
touch(edit / "proxy-1-2.mp4")
_winapi.CreateJunction(str(target), str(edit / "link"))
# A própria pasta da sessão nos cortes trocada por junção para fora: nada dela é apagado.
other = seed_session(engine)
elsewhere = root / "outside" / "sessao"
keep2 = touch(elsewhere / "clip-2.mp4", b"alvo2")
(root / "clips").mkdir(exist_ok=True)
_winapi.CreateJunction(str(elsewhere), str(root / "clips" / str(other)))
add_clip(engine, other, 2, "ready")
body = client.delete("/v1/clips/1", headers=auth()).json()
assert keep.read_bytes() == b"alvo" and not edit.exists() and body["left"] == []
body = client.post("/v1/clips/delete", json={"ids": [2]}, headers=auth()).json()
assert keep2.read_bytes() == b"alvo2" and body["deleted"][0]["left"][0]["reason"] == "fora das pastas do Clipador"
# ---------------------------------------------------------------- o momento apagado não volta
@pytest.mark.parametrize("session_status", ["recording", "stopped"])
def test_deleted_discard_is_not_recreated(repo, monkeypatch, session_status):
"""Ao vivo (passada da janela recente) e no fim (passada final da sessão inteira): o pico apagado não vira
candidato de novo, nem com o juiz tendo recuado o trecho para longe do pico."""
client, engine, sid, _root = repo
engine.db.run("UPDATE sessions SET status = ?, duration_s = 1300 WHERE id = ?", session_status, sid)
moment = Moment(peak_s=1149.0, start_s=1095.0, end_s=1155.0, score=5.0, source="chat", reasons={"onsetS": 1142})
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [moment])
analyzed = {"until": 1300.0}
real = engine.load_timeline
monkeypatch.setattr(engine, "load_timeline", lambda *a, **k: {**real(*a, **k), "duration": 1300.0,
"analyzedUntil": analyzed["until"]})
monkeypatch.setattr(engine.face, "for_scoring", lambda *a, **k: (None, 0.0))
session = lambda: engine.db.get("SELECT * FROM sessions WHERE id = ?", sid) # noqa: E731
assert engine.find_new_clips(session()) == 1
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
engine.db.run("UPDATE clips SET start_s = 1012, end_s = 1100, status = 'discarded' WHERE id = ?", clip["id"])
assert client.delete(f"/v1/clips/{clip['id']}", headers=auth()).status_code == 200
for _ in range(3):
assert engine.find_new_clips(session()) == 0
assert engine.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ?", sid)["n"] == 0
# Outro momento, longe do apagado, continua nascendo normalmente.
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [
Moment(peak_s=400.0, start_s=340.0, end_s=405.0, score=5.0, source="chat", reasons={})])
assert engine.find_new_clips(session()) == 1
def test_judge_backtrack_onto_deleted_kept_or_rejected_clip_is_vetoed(repo):
"""O juiz recua um candidato novo para cima de um corte que você apagou: pronto/rejeitado apagado veta (como
vetava enquanto existia); descartado pela IA apagado não veta (como não vetava)."""
from .test_render_and_duplicates import RecuoJudge
_client, engine, sid, _root = repo
engine.db.run("UPDATE sessions SET duration_s = 1300 WHERE id = ?", sid)
add_clip(engine, sid, 9, "rejected", peak=1084, start=1045, end=1100)
add_clip(engine, sid, 10, "discarded", peak=600, start=560, end=620)
clip_delete.delete_clip(engine, 9)
clip_delete.delete_clip(engine, 10)
engine.judge = RecuoJudge(back_to=1012)
add_clip(engine, sid, 42, "candidate", peak=1149, start=1095, end=1155)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 42"))
row = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 42")
judge = json.loads(row["judge_json"])
assert row["status"] == "discarded" and judge["duplicateOf"] == 9 and "que você apagou" in judge["reason"]
engine.judge = RecuoJudge(back_to=548)
add_clip(engine, sid, 43, "candidate", peak=660, start=630, end=690)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 43"))
assert engine.db.get("SELECT status FROM clips WHERE id = 43")["status"] == "pending"
def test_scan_does_not_propose_a_deleted_moment(repo):
_client, engine, sid, _root = repo
add_clip(engine, sid, 7, "discarded", peak=200, start=150, end=230, reasons={"candidateStartS": 180, "candidateEndS": 240})
clip_delete.delete_clip(engine, 7)
assert clip_delete.mark_spans(engine.db, sid, 0, 600) == [(150, 240, "apagado")]
assert clip_delete.mark_spans(engine.db, sid, 300, 600) == []
dur = {"minS": 60, "maxS": 90, "backtrackS": 120}
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
existing = clip_delete.mark_spans(engine.db, sid, 0, 600)
assert engine.intel._insert_scan_moment(session, {"start_s": 160, "end_s": 230, "score": 8}, 0, 600, dur, existing) is False
assert engine.intel._insert_scan_moment(session, {"start_s": 400, "end_s": 470, "score": 8}, 0, 600, dur, existing) is True
def test_render_skips_a_clip_deleted_after_the_queue_listed_it(repo, monkeypatch):
_client, engine, sid, root = repo
add_clip(engine, sid, 1, "pending")
stale = engine.db.get("SELECT * FROM clips WHERE id = 1") # a fila leu a lista…
clip_delete.delete_clip(engine, 1) # …e o corte foi apagado antes de o render começar
called = []
monkeypatch.setattr(engine, "_render_clip", lambda clip: called.append(clip["id"]))
engine.render_clip(stale)
assert called == [] and engine._rendering == set()
assert not (root / "clips" / str(sid) / "clip-1.mp4").exists()
def test_session_finishes_and_learning_stays_after_delete(repo):
client, engine, sid, _root = repo
engine.db.run("UPDATE sessions SET status = 'processing' WHERE id = ?", sid)
engine.db.run("INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES ('k', 'KEKW', 'twitch', 3, 0.6, 'x', 'x')")
add_clip(engine, sid, 1, "pending")
engine.db.run("UPDATE clips SET learned = 1 WHERE id = 1")
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
engine.finish_if_done(session)
assert engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"] == "processing" # pendente segura
assert client.delete("/v1/clips/1", headers=auth()).status_code == 200
engine.finish_if_done(session)
assert engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"] == "done"
assert engine.db.get("SELECT weight FROM emotes WHERE name = 'KEKW'")["weight"] == 0.6 # o aprendizado fica
# Apagar a sessão leva as marcas junto.
engine.delete_session(sid)
assert engine.db.get("SELECT COUNT(*) AS n FROM deleted_clips")["n"] == 0
+281
View File
@@ -0,0 +1,281 @@
"""Pedidos do dono de 17/11/2026: duração mínima de verdade (mínimo + 1 s em todo corte automático), gancho em tarja
animada e fontes empacotadas para escolher."""
import hashlib
import json
import re
import shutil
import subprocess
from pathlib import Path
import pytest
from app import editor, editor_render, layout
from app.config import REPO_ROOT
from app.judge import _clean
from app.scoring import ChatMessage, Params, Word, find_moments, fit_length, fit_window
from .test_editor import KEY, api, make_project, validate # noqa: F401 - api é fixture
from .test_scoring import burst, calm_chat
from .test_sources_and_api import env, seed_session # noqa: F401
FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe")
CFG = layout.merge()
TARGET = layout.min_target(CFG) # 60 + 1 + 0,1
EPS = 1e-6 # 61,1 em ponto flutuante
HORIZONTAL = {"format": {"aspect": "horizontal"}}
# ---------------------------------------------------------------- 1. duração mínima
def test_target_is_min_plus_one_second_and_never_above_max():
assert TARGET == 61.1
assert layout.min_target(layout.merge({"duration": {"minS": 89.5, "maxS": 90}})) == 90
def test_fit_window_grows_backwards_then_forwards_and_never_invents():
assert fit_window(100, 140, 0, 200, TARGET, 90) == (78.9, 140.0) # contexto antes
assert fit_window(5, 30, 0, 200, TARGET, 90) == (0.0, 61.1) # começo da gravação: cresce para a frente
assert fit_window(5, 30, 0, 40, TARGET, 90) == (0.0, 40.0) # gravação de 40 s: não inventa
assert fit_window(0, 200, 0, 300, TARGET, 90, keep="start") == (0.0, 90.0)
def test_candidate_from_heuristic_has_the_target_even_at_the_end_of_recording():
p = Params(min_s=TARGET, max_s=90.0)
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
m = find_moments(600, chat, [], [], p)[0]
assert m.end_s - m.start_s >= TARGET - EPS
start, end = fit_length(580, 600, 595, p, 600) # pico no fim da gravação: recua o início
assert end - start >= TARGET - EPS and end <= 600
def test_judge_answer_capped_by_window_end_still_has_the_minimum():
# O juiz pôs o início tarde demais: o fim bate em `hi`; antes saía curto (end − start < mínimo).
v = _clean({"keep": True, "score": 8, "start_s": 1100, "end_s": 1200, "title": "t", "caption": "c", "reason": "r"},
1095, 1155, "m", lo=975, hi=1170, min_s=TARGET, max_s=90)
assert v.end_s == 1170 and v.end_s - v.start_s >= TARGET - EPS
def test_scan_moment_has_the_minimum(env): # noqa: F811
_client, engine = env
sid = seed_session(engine)
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
ok = engine.intel._insert_scan_moment(session, {"start_s": 470, "end_s": 495, "score": 7, "title": "t", "reason": "r"},
300.0, 500.0, CFG["duration"], [])
clip = engine.db.get("SELECT start_s, end_s FROM clips WHERE session_id = ?", sid)
assert ok and clip["end_s"] - clip["start_s"] >= TARGET - EPS and clip["end_s"] <= 500
def _clip55():
"""Caso medido (corte 55 da sessão 3): juiz 7900–7960 (60 s) e analista com a ação em 7915 → saía 46,8 s."""
clip = {"session_id": 1, "start_s": 7900.0, "end_s": 7960.7, "peak_s": 7944.0, "title": "Pajé mão leve", "source": "chat"}
words = [Word(7880 + i * 0.9, 7880 + i * 0.9 + 0.5, f"p{i}") for i in range(100)]
return clip, {"action_start_s": 7915.0, "reaction_end_s": 7952.0, "hook": "Pajé mão leve"}, words
def test_auto_project_never_goes_below_the_minimum():
clip, analysis, words = _clip55()
p = editor.auto_project(clip, analysis, words, [-20.0] * 9000, 9000.0, CFG)
assert editor.output_duration(p["cuts"]) >= TARGET - EPS
# silêncios quietos longos: só sai o que não derruba o corte abaixo do mínimo
quiet = [-55.0] * 9000
sparse = [Word(7890 + i * 6, 7890 + i * 6 + 0.4, "x") for i in range(14)]
q = editor.auto_project({**clip, "peak_s": 7899.0}, None, sparse, quiet, 9000.0, CFG)
assert editor.output_duration(q["cuts"]) >= TARGET - EPS
# gravação curta demais: não inventa vídeo, registra o motivo
r = editor.auto_project({**clip, "start_s": 5.0, "end_s": 30.0, "peak_s": 20.0}, None, [], [], 40.0, CFG)
assert editor.output_duration(r["cuts"]) == 40.0 and any(s.startswith("curto:") for s in r["meta"]["steps"])
# "cortar agora" (manual) é livre
m = editor.auto_project({**clip, "source": "manual", "start_s": 7900.0, "end_s": 7930.0}, None, [], [], 9000.0, CFG)
assert editor.output_duration(m["cuts"]) == 30.0
def test_suggestion_respects_minimum_and_drops_removes_that_would_shrink_it():
s = editor.clean_suggestion({"start_s": 1100, "end_s": 1130, "remove": [{"start_s": 1110, "end_s": 1120, "why": "x"}],
"zooms": [], "hook": "h", "title": "t", "reason": "r"}, 1000, 1200, TARGET, 90)
assert s["end"] - s["start"] >= TARGET - EPS and s["remove"] == []
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
def test_auto_clip_file_is_at_least_min_plus_one_second(tmp_path):
"""Medido no arquivo (ffprobe): o projeto da IA do caso do corte 55 sai com ≥ 61 s."""
seg = tmp_path / "seg.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "testsrc2=size=320x180:rate=30:duration=100", "-f", "lavfi",
"-i", "sine=frequency=440:duration=100", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
"-c:a", "aac", "-shortest", str(seg)], check=True)
clip = {"session_id": 1, "start_s": 30.0, "end_s": 90.7, "peak_s": 74.0, "title": "Pajé mão leve", "source": "chat"}
analysis = {"action_start_s": 45.0, "reaction_end_s": 82.0, "hook": "Pajé mão leve"}
data = editor.auto_project(clip, analysis, [], [-20.0] * 100, 100.0, CFG)
p = validate(data, tmp_path, duration=100.0)
out = tmp_path / "auto.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 100.0)], p, CFG,
"twitch.tv/x", out, tmp_path)
duration = float(subprocess.run([FFPROBE, "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(out)],
capture_output=True, text=True, check=True).stdout)
assert duration >= CFG["duration"]["minS"] + 1
# ---------------------------------------------------------------- 2. gancho em tarja
def _banner(**over):
o = {"id": "hook", "kind": "hook", "text": "Carregando o dilera no PvP do Rob Run!", "start": 0, "end": 3, "y": 0.2,
"size": 76, "style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": layout.HOOK_FONT, "anim": "slide"}
o.update(over)
return o
def test_hook_config_validates_and_merges():
assert layout.DEFAULTS["hook"]["style"] == "banner" and layout.DEFAULTS["hook"]["anim"] == "slide"
assert layout.validate({"hook": {"style": "plain", "bg": "#123abc", "seconds": 2.5}})["hook"] == \
{"style": "plain", "bg": "#123ABC", "seconds": 2.5}
for bad in ({"style": "x"}, {"bg": "verde"}, {"font": "Comic Sans"}, {"anim": "spin"}, {"seconds": 20}):
with pytest.raises(layout.LayoutError):
layout.validate({"hook": bad})
def test_banner_overlay_validation_and_old_projects_untouched(tmp_path):
p = validate(make_project(overlays=[_banner()]), tmp_path)
o = p["overlays"][0]
assert (o["style"], o["bg"], o["font"], o["anim"]) == ("banner", "#00FF00", layout.HOOK_FONT, "slide")
old = validate(make_project(), tmp_path)["overlays"][0]
assert not {"style", "bg", "font"} & set(old) # projeto antigo: nenhum campo novo aparece
for bad in ({"style": "neon"}, {"font": "Comic Sans"}, {"bg": "verde"}, {"anim": "spin"}):
with pytest.raises(editor.EditError):
validate(make_project(overlays=[_banner(**bad)]), tmp_path)
@pytest.mark.parametrize("settings", [{}, CAM := {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}, HORIZONTAL])
def test_banner_ass_two_lines_animated_and_clear_of_captions(tmp_path, settings):
clip = {"session_id": 1, "start_s": 10.0, "end_s": 75.0, "peak_s": 50.0, "title": "Carregando o dilera no PvP do Rob Run!",
"source": "chat"}
cfg = layout.merge(settings)
data = editor.auto_project(clip, None, [Word(11, 11.4, "olha")], [], 100.0, cfg)
hook = data["overlays"][0]
assert hook["style"] == "banner" and hook["end"] == 3.0
p = validate(data, tmp_path)
ass = editor_render.build_project_ass(p, editor.effective_settings(cfg, p), "twitch.tv/x")
band = next(line for line in ass.splitlines() if ",Bar,," in line and "\\p1" in line and "&H00FF00&" in line)
text = next(line for line in ass.splitlines() if "CARREGANDO" in line)
assert "\\move(" in band and "\\move(" in text and "\\blur18" in text and "\\t(90,430,\\blur0)" in text
assert f"\\fn{layout.HOOK_FONT}" in text and text.count("\\N") <= 1 # no máximo 2 linhas, palavra inteira
g = editor_render.banner_layout(p["overlays"][0], layout.canvas_size(cfg))
cap_y = layout.caption_y(editor.effective_settings(cfg, p))
size = editor.effective_settings(cfg, p)["caption"]["size"]
assert cap_y + size < g["top"] or cap_y - size > g["top"] + g["height"] # a tarja não cobre a legenda
assert all(len(line) <= 40 for line in g["lines"])
def test_banner_shrinks_long_text_instead_of_cutting_words():
o = _banner(text="Uma frase bem comprida que não caberia em duas linhas no tamanho cheio do gancho {\\b1}", size=120)
g = editor_render.banner_layout(o, (1080, 1920))
assert len(g["lines"]) <= 2 and g["size"] < 120
assert " ".join(g["lines"]) == o["text"].upper() # nenhuma palavra cortada
events = editor_render.banner_events(o, (1080, 1920))
assert "{\\b1}" not in events[1][2] and "(/B1)" in events[1][2] # texto escapado
def _frame(video: Path, at: float, size: tuple[int, int]) -> bytes:
return subprocess.run([FFMPEG, "-v", "error", "-ss", f"{at:.2f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
"-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout[: size[0] * size[1] * 3]
def _green_rows(frame: bytes, w: int, h: int) -> list[int]:
rows = []
for y in range(0, h, 4):
px = [frame[(y * w + x) * 3: (y * w + x) * 3 + 3] for x in range(0, w, 40)]
if sum(1 for r, g, b in px if g > 200 and r < 80 and b < 80) > len(px) * 0.6:
rows.append(y)
return rows
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_real_render_banner(tmp_path, aspect):
seg = tmp_path / "dark.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "color=c=0x202060:size=640x360:rate=30:duration=6",
"-f", "lavfi", "-i", "sine=frequency=440:duration=6", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
"-c:a", "aac", "-shortest", str(seg)], check=True)
words = [{"s": 1.0 + i * 0.4, "e": 1.3 + i * 0.4, "w": w} for i, w in enumerate("tá escutando tiro não é".split())]
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, settings={"format": {"aspect": aspect}},
cuts=[{"start": 0, "end": 5, "mode": None}], overlays=[_banner(end=3)],
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words},
cover={"enabled": False, "t": 1})
p = validate(data, tmp_path, duration=6.0)
out = tmp_path / f"{aspect}.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 6.0)], p,
layout.merge(), "twitch.tv/x", out, tmp_path)
w, h = layout.FRAME_SIZES[aspect]
early, settled, after = _frame(out, 0.05, (w, h)), _frame(out, 1.5, (w, h)), _frame(out, 4.0, (w, h))
rows = _green_rows(settled, w, h)
assert rows and abs((min(rows) + max(rows)) / 2 / h - 0.2) < 0.05 # tarja assentada perto de 20 % da altura
assert len(_green_rows(early, w, h)) < len(rows) # no começo ela ainda está entrando
assert _green_rows(after, w, h) == [] # depois do gancho, some
# ---------------------------------------------------------------- 3. fontes empacotadas
def test_packaged_fonts_lock_files_and_licenses():
lock = json.loads((REPO_ROOT / "assets" / "fonts" / "fonts.lock.json").read_text(encoding="utf-8"))
families = [e["family"] for e in lock["files"]]
assert {"Luckiest Guy", "Bangers", "Anton", "Bebas Neue", "Poppins ExtraBold"} == set(families)
for e in lock["files"]:
assert hashlib.sha256((REPO_ROOT / e["path"]).read_bytes()).hexdigest() == e["sha256"]
assert (REPO_ROOT / e["licenseFile"]).is_file() and e["license"] in ("OFL-1.1", "Apache-2.0")
assert re.search(r"/google/fonts/[0-9a-f]{40}/", e["url"]) # URL presa a commit
assert Path(e["path"]).parent.as_posix() == "assets/fonts" # pasta plana (fontsdir não lê subpastas)
assert layout.font_files() == {e["family"]: e["path"] for e in lock["files"]}
assert set(families) <= set(layout.FONTS)
def test_packaged_fonts_have_portuguese_accents_and_matching_family_name():
ttlib = pytest.importorskip("fontTools.ttLib")
for family, path in layout.font_files().items():
font = ttlib.TTFont(REPO_ROOT / path)
cmap = font.getBestCmap()
assert all(ord(c) in cmap for c in "TÁ ESCUTANDO TIRO, NÃO É? ÇÃÕÂÊÔÍÓÚÀ".replace(" ", ""))
names = {r.nameID: r.toUnicode() for r in font["name"].names if r.platformID == 3}
assert family == names[1] # o nome usado no ASS é o da família (ID 1) do arquivo
def test_fontsdir_only_when_a_packaged_font_is_used():
assert layout.ass_filter("a.ass", "Style: Caption,Arial Black,84") == "ass=a.ass"
assert "fontsdir='" in layout.ass_filter("a.ass", "Style: Caption,Bangers,84")
assert "fontsdir='" in layout.ass_filter("a.ass", "{\\fnLuckiest Guy}OI")
def test_settings_route_lists_font_files(api): # noqa: F811
client, _engine, _root = api
body = client.get("/v1/sessions/1/settings", headers={"X-Service-Key": KEY}).json()
assert body["fontFiles"]["Bangers"] == "assets/fonts/Bangers-Regular.ttf" and "Bangers" in body["fonts"]
assert body["defaults"]["hook"]["style"] == "banner" and "slide" in body["hookAnims"]
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_packaged_font_is_really_used_in_render(tmp_path):
"""Mesmo texto acentuado com Bangers, com Arial Black e com uma família inexistente: Bangers sai diferente das
duas (o libass achou o arquivo empacotado)."""
words = [{"s": 0.0, "e": 0.9, "w": w} for w in ["TÁ"]] + [{"s": 0.95, "e": 1.9, "w": "ESCUTANDO"}]
def still(font: str) -> bytes:
p = validate(make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, cuts=[{"start": 0, "end": 3, "mode": None}],
overlays=[], captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": words}, progress={"enabled": False}, cover={"enabled": False, "t": 1}), tmp_path, duration=6.0)
cfg = editor.effective_settings(layout.merge(), p)
cfg["caption"]["font"] = font
ass = editor_render.build_project_ass(p, cfg, "")
(tmp_path / "f.ass").write_text(ass, encoding="utf-8")
frame = tmp_path / "f.png"
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", "color=c=0x303030:s=1080x1920:d=1", "-filter_complex",
f"[0:v]{layout.ass_filter('f.ass', ass)}[v]", "-map", "[v]", "-frames:v", "1", frame.name],
cwd=tmp_path, check=True)
return frame.read_bytes()
bangers, arial, missing = still("Bangers"), still("Arial Black"), still("Fonte Que Nao Existe")
assert bangers != arial and bangers != missing
def test_banner_entry_blurs_the_whole_letter_and_settles_identical():
"""Com contorno, o blur do libass só desfoca a borda: na entrada o preenchimento vem numa camada sem contorno
(borrada inteira, como no modelo do dono) e, do fim da entrada em diante, entra o evento assentado de sempre."""
events = editor_render.banner_events(_banner(), (1080, 1920))
fill, outline, settled = events[1], events[2], events[3]
assert r"\bord0" in fill[2] and r"\blur18\t(90,430,\blur0)" in fill[2] and fill[3] == (0.0, 0.43)
assert r"\1a&HFF&" in outline[2] and outline[0] < fill[0] # contorno sem preenchimento, por baixo
assert settled[3] == (0.43, None) and r"\move" not in settled[2] and r"\blur" not in settled[2]
assert r"\pos(540," in settled[2] and r"\bord8\shad4" in settled[2]
+313
View File
@@ -0,0 +1,313 @@
"""Editor de cortes: validador do projeto, contas de tempo, legenda animada (ASS), filtergraph e rotas."""
import json
import shutil
import subprocess
from pathlib import Path
import pytest
from fastapi.testclient import TestClient
from app import editor, editor_render, layout
from app.config import Settings
from app.db import Database
from app.main import create_app
from app.scoring import Word
from app.worker import Engine
from .test_sources_and_api import KEY, FakeJudge
FFMPEG = shutil.which("ffmpeg")
def make_project(**over) -> dict:
p = {
"schema": 1, "source": {"sessionId": 1, "lo": 0, "hi": 60}, "settings": {},
"cuts": [{"start": 10, "end": 20, "mode": None}, {"start": 25, "end": 30, "mode": "game_only"}],
"captions": {"enabled": True, "preset": "pop", "style": {}, "emphColor": "#22E36B",
"words": [{"s": 11, "e": 11.4, "w": "olha"}, {"s": 11.5, "e": 12, "w": "isso", "emph": True},
{"s": 21, "e": 22, "w": "removida"}, {"s": 26, "e": 26.5, "w": "voltou"}]},
"overlays": [{"id": "hook", "kind": "hook", "text": "ELE NÃO ACREDITOU", "start": 0, "end": 3, "y": 0.2, "size": 70,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"},
{"id": "z1", "kind": "zoom", "start": 12, "end": 15, "scale": 1.4, "x": 0.5, "y": 0.4, "ramp": 0.2}],
"progress": {"enabled": True, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": True, "t": 12, "text": "LAG"},
}
p.update(over)
return p
def validate(data, tmp_path: Path, duration=100.0):
return editor.validate_project(data, session_id=1, session_duration=duration, repo_root=tmp_path,
tts_dir=tmp_path / "tts", assets_dir=tmp_path / "assets")
def test_time_mapping():
cuts = [{"start": 10, "end": 20}, {"start": 25, "end": 30}]
assert editor.output_duration(cuts) == 15
assert editor.to_output(15, cuts) == (5, True)
assert editor.to_output(22, cuts) == (10, False) # trecho removido gruda no começo do próximo
assert editor.to_output(26, cuts) == (11, True)
assert editor.to_session(11, cuts) == 26
sl = editor.slice_pieces(cuts, 8, 12)
assert [(p.start, p.end, p.out) for p in sl] == [(18, 20, 0), (25, 27, 2)]
assert editor.normalize_cuts([{"start": 5, "end": 8}, {"start": 1, "end": 5.01}]) == [{"start": 1, "end": 8}]
def test_validate_accepts_and_normalizes(tmp_path):
p = validate(make_project(), tmp_path)
assert p["cuts"][1]["mode"] == "game_only" and p["captions"]["words"][1]["emph"] is True
assert editor.output_duration(p["cuts"]) == 15
@pytest.mark.parametrize("change,message", [
({"schema": 2}, "versão"),
({"cuts": []}, "pelo menos um trecho"),
({"cuts": [{"start": 10, "end": 11}]}, "de 3 a 180"),
({"cuts": [{"start": 10, "end": 70}]}, r"cuts\[0\]\.end vai de 0 a 60"), # fora da janela (hi = 60)
({"source": {"sessionId": 9, "lo": 0, "hi": 60}}, "outra sessão"),
({"source": {"sessionId": 1, "lo": 0, "hi": 900}}, "source.hi"), # além do fim da gravação
({"cuts": [{"start": 10, "end": 20, "mode": "rm -rf"}]}, "mode"),
({"overlays": [{"id": "a b", "kind": "text", "text": "x", "start": 10, "end": 12}]}, "id curto"),
({"overlays": [{"id": "z1", "kind": "zoom", "start": 10, "end": 14, "scale": 1.3},
{"id": "z2", "kind": "zoom", "start": 12, "end": 16, "scale": 1.3}]}, "dois zooms"),
({"overlays": [{"id": "t", "kind": "text", "text": "x" * 200, "start": 10, "end": 12}]}, "120"),
({"audio": {"music": {"file": "../voice/.env"}}}, "música"),
({"audio": {"music": {"file": "C:/Windows/win.ini"}}}, "música"),
({"audio": {"narration": [{"id": "n", "file": "output/x.wav", "at": 10}]}}, "narração"),
])
def test_validate_rejects(tmp_path, change, message):
with pytest.raises(editor.EditError, match=message):
validate(make_project(**change), tmp_path)
def test_zero_length_word_is_tolerated(tmp_path):
data = make_project()
data["captions"]["words"].append({"s": 13.0, "e": 13.0, "w": "queria"}) # Whisper real (corte 9 do skipnho)
words = validate(data, tmp_path)["captions"]["words"]
assert {"s": 13.0, "e": 13.05, "w": "queria"} in words
def test_window_limit(tmp_path):
with pytest.raises(editor.EditError, match="janela"):
validate(make_project(source={"sessionId": 1, "lo": 0, "hi": 900}), tmp_path, duration=2000)
def test_audio_only_from_allowed_folders(tmp_path):
(tmp_path / "assets").mkdir()
(tmp_path / "assets" / "beat.mp3").write_bytes(b"x")
(tmp_path / "tts").mkdir()
(tmp_path / "tts" / "tts-0123456789ab.wav").write_bytes(b"x")
p = validate(make_project(audio={"volume": 1, "music": {"file": "assets/beat.mp3", "volume": 0.2},
"narration": [{"id": "n1", "file": "tts/tts-0123456789ab.wav", "at": 12}]}), tmp_path)
assert p["audio"]["music"]["file"] == "assets/beat.mp3" and p["audio"]["narration"][0]["at"] == 12
def test_output_words_and_ass_presets(tmp_path):
p = validate(make_project(), tmp_path)
words = editor.output_words(p)
assert [w.word for w in words] == ["olha", "isso", "voltou"] # "removida" caiu no trecho cortado
assert words[2].start == 11.0 # 26 s da sessão = 10 s + 1 s
cfg = editor.effective_settings(layout.merge(), p)
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x")
assert "\\fscx118" in ass # pop na palavra falada
assert "&H6BE322&" in ass # cor da ênfase (#22E36B em BGR) na palavra marcada
assert "ELE NÃO ACREDITOU" in ass and "Box" in ass # gancho com caixa
assert "\\p1" in ass and "\\fscx100.00" in ass # barra de progresso até 100%
assert "\\C" not in ass # gotcha 58: tag nunca em maiúscula
for preset, mark in (("karaoke", "\\kf"), ("single", "\\fscx70"), ("minimal", "OLHA")):
q = json.loads(json.dumps(p))
q["captions"]["preset"] = preset
text = editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
assert mark in text if preset != "minimal" else mark not in text # mínima não usa maiúsculas
def test_ass_escapes_user_text(tmp_path):
p = make_project(overlays=[{"id": "t", "kind": "text", "text": "{\\b1}oi\\N", "start": 11, "end": 13}])
q = validate(p, tmp_path)
ass = editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
assert "{\\b1}" not in ass and "(/b1)oi/N" in ass
def test_filter_has_pieces_layouts_and_zoom(tmp_path):
p = validate(make_project(), tmp_path)
cfg = editor.effective_settings(layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}}), p)
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
assert "trim=start=0.000:end=10.000" in graph and "trim=start=15.000:end=20.000" in graph
assert "vstack" in graph and "[c_0]" in graph # 1º trecho câmera em cima (rótulos únicos por trecho)
assert "concat=n=2:v=1:a=1" in graph and "zoompan=z='1+0.4000*" in graph and "ass=e.ass" in graph
# Prévia real a partir de 8 s: o zoom continua no mesmo instante do corte (it + 8).
assert "(it+8.000)" in editor_render.zoom_filter(p, 8.0)
def test_suggestion_is_clamped():
s = editor.clean_suggestion({"hook": "x" * 200, "title": "t", "start_s": -50, "end_s": 999,
"remove": [{"start_s": 20, "end_s": 20.1, "why": ""}, {"start_s": 30, "end_s": 34, "why": "silêncio"}],
"zooms": [{"t": 40, "why": "grito"}, {"t": 500, "why": "fora"}], "reason": "r"}, 10, 80)
assert (s["start"], s["end"]) == (10, 80) and len(s["hook"]) == 80
assert s["remove"] == [{"start": 30, "end": 34, "why": "silêncio"}] and [z["t"] for z in s["zooms"]] == [40]
# ---------------------------------------------------------------- rotas e render real
def _lavfi_segments(folder: Path, n: int = 3, seconds: int = 4) -> list[Path]:
folder.mkdir(parents=True, exist_ok=True)
files = []
for i in range(n):
f = folder / f"seg_{i:05d}.ts"
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", f"testsrc2=s=640x360:r=30:d={seconds}",
"-f", "lavfi", "-i", f"sine=frequency={300 + 100 * i}:d={seconds}", "-c:v", "libx264", "-preset",
"ultrafast", "-g", "15", "-c:a", "aac", "-shortest", "-f", "mpegts", str(f)], check=True, capture_output=True)
files.append(f)
return files
@pytest.fixture
def api(tmp_path, monkeypatch):
import app.editor_api as editor_api
import app.worker as worker
monkeypatch.setattr(editor_api, "REPO_ROOT", tmp_path)
monkeypatch.setattr(worker, "REPO_ROOT", tmp_path)
settings = Settings.load(env_file=tmp_path / "none.env", service_key=KEY, data_dir=tmp_path / "data",
clips_dir=tmp_path / "output" / "clipper", judge_provider="codex", voice_url=None, voice_key=None)
db = Database(settings.data_dir / "clipper.db")
engine = Engine(settings, db, judge=FakeJudge())
client = TestClient(create_app(settings, engine, start_engine=False))
db.run("INSERT INTO sessions (id, platform, kind, url, status, dir, duration_s, started_at) "
"VALUES (1, 'twitch', 'live', 'https://www.twitch.tv/skipnho', 'done', 'data/s1', 12, 'x')")
words = [[1.0, 1.4, "olha"], [1.5, 2.0, "isso"], [9.0, 9.5, "fim"]]
for i in range(3):
db.run("INSERT INTO segments (session_id, idx, file, start_s, end_s, wall_end, analyzed, words_json) VALUES (1, ?, ?, ?, ?, 0, 1, ?)",
i, f"data/s1/seg_{i:05d}.ts", i * 4.0, i * 4.0 + 4, json.dumps([w for w in words if i * 4 <= w[0] < i * 4 + 4]))
db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, title, created_at, updated_at) "
"VALUES (7, 1, 5, 2, 10, 8, 'manual', 'ready', 'Título', 'x', 'x')")
return client, engine, tmp_path
def test_edit_routes_roundtrip(api):
client, engine, root = api
h = {"X-Service-Key": KEY}
r = client.get("/v1/clips/7/edit", headers=h)
assert r.status_code == 200, r.text
body = r.json()
assert body["rev"] == 0 and body["project"]["cuts"] == [{"start": 2.0, "end": 10.0, "mode": None}]
assert [w["w"] for w in body["words"]] == ["olha", "isso", "fim"] and body["window"] == {"lo": 0.0, "hi": 12.0}
project = body["project"]
project["cuts"] = [{"start": 0.0, "end": 3.0, "mode": None}, {"start": 6.0, "end": 10.0, "mode": None}]
saved = client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0})
assert saved.status_code == 200 and saved.json()["rev"] == 1 and saved.json()["durationS"] == 7
stale = client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0})
assert stale.status_code == 409 # autosave de outra aba não atropela
bad = client.put("/v1/clips/7/edit", headers=h, json={"project": {**project, "cuts": []}, "rev": 1})
assert bad.status_code == 400 and "trecho" in bad.json()["error"]
assert client.get("/v1/clips/7", headers=h).json()["edit"]["updatedAt"]
exp = client.post("/v1/clips/7/export", headers=h)
assert exp.status_code == 200 and exp.json()["status"] == "pending" and exp.json()["editedDurationS"] == 7
assert (exp.json()["startS"], exp.json()["endS"]) == (0.0, 10.0)
# Ajuste do cartão (−2 s no início não cabe: a sessão começa em 0) → as pontas do projeto acompanham.
client.patch("/v1/clips/7", headers=h, json={"endS": 11.0})
assert client.get("/v1/clips/7/edit", headers=h).json()["project"]["cuts"][-1]["end"] == 11.0
assert client.delete("/v1/clips/7/edit", headers=h).status_code == 204
assert client.get("/v1/clips/7", headers=h).json()["edit"] is None
def test_tts_and_suggest_need_services(api):
client, _engine, _root = api
h = {"X-Service-Key": KEY}
assert "voz" in client.post("/v1/clips/7/tts", headers=h, json={"text": "oi", "voice": "pt-br-x"}).json()["error"]
assert client.post("/v1/clips/7/tts", headers=h, json={"text": "oi", "voice": "../x"}).status_code == 422
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_real_render_proxy_and_waveform(api):
client, engine, root = api
_lavfi_segments(root / "data" / "s1")
h = {"X-Service-Key": KEY}
project = client.get("/v1/clips/7/edit", headers=h).json()["project"]
project["cuts"] = [{"start": 1.0, "end": 4.0, "mode": None}, {"start": 6.0, "end": 9.0, "mode": "game_only"}]
project["overlays"].append({"id": "z", "kind": "zoom", "start": 7, "end": 8.5, "scale": 1.5, "x": 0.5, "y": 0.5, "ramp": 0.2})
project["progress"]["enabled"] = True
assert client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0}).status_code == 200
proxy = client.post("/v1/clips/7/proxy", headers=h, json={"lo": 0, "hi": 12})
assert proxy.status_code == 200, proxy.text
wave = client.get("/v1/clips/7/waveform?lo=0&hi=12", headers=h).json()
assert 500 <= len(wave["peaks"]) <= 610 and max(wave["peaks"]) == 1.0
prev = client.post("/v1/clips/7/preview-render", headers=h, json={"fromS": 2, "durationS": 3})
assert prev.status_code == 200, prev.text
client.post("/v1/clips/7/export", headers=h)
engine.render_pending()
clip = client.get("/v1/clips/7", headers=h).json()
assert clip["status"] == "ready", clip["error"]
out = root / clip["file"]
assert clip["edit"]["cover"] and (root / clip["edit"]["cover"]).is_file() # capa (etapa 7) gerada no export
probe = subprocess.run([shutil.which("ffprobe") or "ffprobe", "-v", "error", "-show_entries", "stream=width,height:format=duration",
"-of", "json", str(out)], capture_output=True, text=True, check=True)
info = json.loads(probe.stdout)
assert {"width": 1080, "height": 1920} in [{k: s[k] for k in ("width", "height")} for s in info["streams"] if "width" in s]
assert abs(float(info["format"]["duration"]) - 6.0) < 0.25 # 3 s + 3 s, sem o meio removido
# ---------------------------------------------------------------- projeto entregue pela IA
def test_auto_project_uses_pipeline_knowledge():
clip = {"session_id": 1, "start_s": 100.0, "end_s": 140.0, "peak_s": 120.0, "title": "Título do juiz"}
analysis = {"action_start_s": 95.0, "reaction_end_s": 143.0, "hook": "Caiu a 1 m da chegada"}
words = [Word(94.0, 95.3, "olha"), Word(96.0, 96.4, "vai"), Word(103.0, 103.5, "silêncio"),
Word(110.0, 110.4, "depois"), Word(118.0, 118.5, "NÃO"), Word(141.0, 141.4, "kkkk")]
loudness = [-20.0] * 200
for t in range(103, 111):
loudness[t] = -55.0 # quieto entre 103,5 e 110 s → a IA corta; perto do pico (120 s) não corta
# Mínimo de 15 s (configuração do canal): sobra espaço para tirar o silêncio. Com o padrão novo (60 s) o corte de
# 50 s já está abaixo do mínimo e nenhum silêncio sai (conferido no fim).
cfg = layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}, "duration": {"minS": 15}})
p = editor.auto_project(clip, analysis, words, loudness, 300.0, cfg, model="m", generated_at="agora")
assert p["cuts"][0]["start"] == 93.9 # ação em 95 − 0,8 s caiu no meio de "olha" → recua para antes da palavra
assert p["cuts"][-1]["end"] == 143.8 # fim da reação + 0,8 s
assert len(p["cuts"]) == 2 and p["cuts"][0]["end"] == 103.75 and p["cuts"][1]["start"] == 109.75
hook = next(o for o in p["overlays"] if o["kind"] == "hook")
zoom = next(o for o in p["overlays"] if o["kind"] == "zoom")
assert hook["text"] == "Caiu a 1 m da chegada" and zoom["start"] == 119.8 and zoom["y"] == 0.17 # rosto (câmera em cima)
assert p["captions"]["preset"] == "pop" and p["meta"]["origin"] == "ai" and p["cover"]["t"] == 120.0
assert any("silêncio" in s for s in p["meta"]["steps"])
# Sem análise e sem som medido: trecho do juiz, gancho = título.
q = editor.auto_project(clip, None, words, [], 300.0, layout.merge())
# Mínimo de verdade (17/11/2026): o trecho de 40 s do juiz cresce PARA TRÁS até mínimo + 1 s (+0,1 de folga).
assert (q["cuts"][0]["start"], q["cuts"][-1]["end"]) == (78.9, 140.0)
assert editor.output_duration(q["cuts"]) >= 61.0 and any("estendido" in s for s in q["meta"]["steps"])
assert q["overlays"][0]["text"] == "Título do juiz"
# Gancho do analista longo (frase descritiva) → usa o título do editor.
long_hook = {"hook": "A provocação sobre ficar moscando começa e, logo depois, ele solta vários gritos"}
assert editor.auto_project(clip, long_hook, words, [], 300.0, layout.merge())["overlays"][0]["text"] == "Título do juiz"
default_min = editor.auto_project(clip, analysis, words, loudness, 300.0, layout.merge())
assert len(default_min["cuts"]) == 1 and not any("silêncio" in s for s in default_min["meta"]["steps"])
def test_render_always_goes_through_project(api):
"""Um caminho de render: corte sem projeto ganha o da IA (origem ai); salvar no editor vira origem user."""
client, engine, root = api
h = {"X-Service-Key": KEY}
body = client.get("/v1/clips/7/edit", headers=h).json()
assert body["origin"] == "ai" and body["aiProject"]["meta"]["origin"] == "ai" and not body["saved"]
if FFMPEG:
_lavfi_segments(root / "data" / "s1")
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 7")
engine.render_pending()
clip = client.get("/v1/clips/7", headers=h).json()
assert clip["status"] == "ready", clip["error"]
assert clip["edit"]["origin"] == "ai"
project = client.get("/v1/clips/7/edit", headers=h).json()
saved = client.put("/v1/clips/7/edit", headers=h, json={"project": project["project"], "rev": project["rev"]})
assert saved.status_code == 200
again = client.get("/v1/clips/7/edit", headers=h).json()
assert again["origin"] == "user" and again["aiProject"]["meta"]["origin"] == "ai"
def test_pick_hook_never_shows_session_time_or_cuts_a_word():
from app.editor import pick_hook
# Medido no corte 25 do skipnho: o analista devolveu uma frase com o tempo da gravação e ela saía cortada.
raw = "Aos 5085s, ele solta que não veio de família rica e imediatamente começa a se desculpar"
text, from_analyst = pick_hook(raw, "“Não vim de família rica” — e vêm os pedidos de desculpa")
assert not from_analyst and text == "“Não vim de família rica” — e vêm os pedidos de desculpa"
assert pick_hook("O lag jogou ele na água", "título") == ("O lag jogou ele na água", True)
long_title = "Ele tenta explicar o que aconteceu com o carro e acaba piorando tudo na frente do chat"
text, _ = pick_hook("", long_title)
assert len(text) <= 60 and long_title.startswith(text) and not text.endswith(" ")
assert pick_hook("Aos 120s, vem o susto", None)[0] == "Vem o susto"
+109
View File
@@ -0,0 +1,109 @@
"""Camadas novas do editor (17/11/2026): câmera em tela cheia por trecho, trecho mudo, texto com posição livre,
chat da live na tela e capa nos primeiros quadros."""
from pathlib import Path
from app import editor, editor_render, layout
from app.scoring import ChatMessage
from .test_editor import make_project, validate
CAM = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}
def test_old_projects_get_defaults_for_new_fields(tmp_path):
p = validate(make_project(), tmp_path)
assert p["chat"]["enabled"] is False and p["chat"]["lines"] == 5
assert p["cover"]["atStart"] is False
assert all(c["muted"] is False for c in p["cuts"])
assert p["overlays"][0]["x"] == 0.5
def test_cam_only_layout_fills_the_screen_with_the_camera():
cfg = layout.merge(CAM)
chain = layout.layout_chain(cfg, "in", "out", mode="cam_only")
assert "crop=iw*0.2:ih*0.25:iw*0.02:ih*0.45" in chain and "vstack" not in chain and "boxblur" not in chain
assert f"crop={layout.W}:{layout.H}" in chain
# sem câmera marcada não há o que mostrar: cai no desfoque
assert "boxblur" in layout.layout_chain(layout.merge(), "in", "out", mode="cam_only")
def test_cut_mode_and_mute_survive_and_do_not_merge(tmp_path):
cuts = [{"start": 10, "end": 15, "mode": "cam_only"}, {"start": 15, "end": 20, "mode": "cam_only", "muted": True},
{"start": 20, "end": 24, "mode": "cam_only", "muted": True}]
p = validate(make_project(cuts=cuts), tmp_path)
assert [(c["start"], c["end"], c["muted"]) for c in p["cuts"]] == [(10, 15, False), (15, 24, True)]
cfg = editor.effective_settings(layout.merge(CAM), p)
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, None, [])
first, second = graph.split("[pa0]")[0], graph.split("[pa0]")[1].split("[pa1]")[0]
assert "volume=0" not in first.split("[sa0]atrim")[1] # 1º trecho com som
assert second.rstrip().endswith("volume=0") # 2º trecho mudo
assert graph.count("crop=iw*0.2:ih*0.25") == 2 # câmera em tela cheia nos dois
def test_text_position_and_chat_block_in_ass(tmp_path):
data = make_project(chat={"enabled": True, "x": 0.05, "y": 0.6, "width": 0.5, "lines": 2, "size": 30})
data["overlays"][0]["x"] = 0.25
p = validate(data, tmp_path)
cfg = editor.effective_settings(layout.merge(), p)
chat = [ChatMessage(11.0, "KKKKKK", "ana"), ChatMessage(12.0, "server chinês? {\\b1}", "beto"),
ChatMessage(13.0, "terceira mensagem bem comprida que não cabe na largura do bloco de chat", "caio"),
ChatMessage(22.0, "fora do corte", "dani")]
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x", chat=chat)
assert f"\\pos({int(1080 * 0.25)},{int(1920 * 0.2)})" in ass # gancho na posição arrastada
chat_lines = [line for line in ass.splitlines() if ",Chat," in line]
assert len(chat_lines) == 3 and "fora do corte" not in ass
assert f"\\an1\\pos({int(1080 * 0.05)},{int(1920 * 0.6)})" in chat_lines[0]
assert "ana:" in chat_lines[0] and "\\N" not in chat_lines[0]
assert chat_lines[2].count("\\N") == 1 and "ana:" not in chat_lines[2] # só as 2 últimas
assert "{\\b1}" not in ass and "…" in chat_lines[2] # texto do chat nunca vira tag; linha longa é cortada
# desligado (padrão): nenhum evento de chat
off = editor_render.build_project_ass(validate(make_project(), tmp_path), cfg, "", chat=chat)
assert ",Chat,," not in off.split("[Events]")[1]
def test_cover_at_start_overlays_first_frames(tmp_path):
p = validate(make_project(cover={"enabled": True, "t": 12, "text": "LAG", "atStart": True}), tmp_path)
assert p["cover"]["atStart"] is True
cfg = editor.effective_settings(layout.merge(), p)
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
assert "[vbase]" in graph and "[1:v]scale=1080:1920" in graph and "overlay=enable='lt(t,0.0667)'" in graph
assert graph.rstrip().split(";")[-1] != "" and "[v]" in graph
plain = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
assert "[vbase]" not in plain
def test_real_render_with_new_layers(tmp_path):
"""Render de verdade (FFmpeg) com câmera inteira, trecho mudo, chat na tela e capa no início."""
import shutil
import subprocess
ffmpeg = shutil.which("ffmpeg")
if not ffmpeg:
import pytest
pytest.skip("sem ffmpeg")
seg = tmp_path / "seg0.ts"
subprocess.run([ffmpeg, "-v", "error", "-f", "lavfi", "-i", "testsrc2=size=640x360:rate=30:duration=8", "-f", "lavfi",
"-i", "sine=frequency=440:duration=8", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15", "-c:a", "aac", "-shortest",
str(seg)], check=True) # -g 15: quadro-chave a cada 0,5 s (senão não dá para saltar no .ts)
cuts = [{"start": 1, "end": 4, "mode": "cam_only"}, {"start": 4, "end": 7, "mode": None, "muted": True}]
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, cuts=cuts, overlays=[],
captions={"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B", "words": []},
cover={"enabled": True, "t": 2, "text": "CAPA", "atStart": True},
chat={"enabled": True, "lines": 3})
p = validate(data, tmp_path, duration=8.0)
base = layout.merge(CAM)
segments = [(seg, 0.0, 8.0)]
cover = editor_render.render_cover(ffmpeg, segments, p, base, "twitch.tv/x", tmp_path / "cover.jpg")
out = tmp_path / "out.mp4"
editor_render.render_project(ffmpeg, shutil.which("ffprobe"), ["-c:v", "libx264", "-preset", "ultrafast"], segments, p, base,
"twitch.tv/x", out, tmp_path, chat=[ChatMessage(2.0, "KKKK", "ana"), ChatMessage(5.0, "F", "beto")],
cover_file=cover)
probe = subprocess.run([shutil.which("ffprobe") or "ffprobe", "-v", "error", "-show_entries", "format=duration:stream=width,height",
"-of", "csv=p=0", str(out)], capture_output=True, text=True, check=True).stdout
assert "1080,1920" in probe and abs(float(probe.strip().splitlines()[-1]) - 6.0) < 0.2
# Trecho mudo: o volume médio da 2ª metade é silêncio; a 1ª tem o tom de teste.
def mean_db(start: float) -> float:
err = subprocess.run([ffmpeg, "-v", "info", "-ss", str(start), "-t", "2", "-i", str(out), "-af", "volumedetect", "-vn",
"-f", "null", "-"], capture_output=True, text=True).stderr
return float(err.split("mean_volume:")[1].split("dB")[0])
assert mean_db(0.5) > -40 and mean_db(3.6) < -70
+469
View File
@@ -0,0 +1,469 @@
"""Rastreio de reação (face.py) com backends falsos: sem rede, sem modelo, sem FFmpeg."""
import hashlib
import json
import pytest
from app import face as face_mod
from app.db import SCHEMA, Database
from app.face import FaceService, FaceUnavailable, ModelStore
from app.judge import build_prompt
from app.reaction import FaceSample
from tests.test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
CAM = {"x": 0.014, "y": 0.4, "w": 0.2, "h": 0.5}
class FakeTracker:
"""Rosto parado no meio do recorte; sorriso alto nos segundos de `laughs`; sem rosto nos de `gone`."""
name = "fake"
def __init__(self, laughs=(), gone=()):
self.laughs, self.gone, self.closed = set(laughs), set(gone), False
def process(self, t, rgb):
if int(t) in self.gone:
return FaceSample(t, False)
smile = 0.9 if int(t) in self.laughs else 0.05 + 0.05 * ((int(t * 6) % 3) / 2)
return FaceSample(t, True, 0.5, 0.4, 0.3, {"mouthSmileLeft": smile, "mouthSmileRight": smile})
def close(self):
self.closed = True
def fake_reader(_ffmpeg, _file, crop_px, out_size, fps=6):
for i in range(30 * fps):
yield i / fps, None
def make_service(engine, laughs=(), gone=(), tracker_factory=None):
service = FaceService(engine, store=object(), tracker_factory=tracker_factory or (lambda _backend=None: FakeTracker(laughs, gone)),
detector_factory=None, reader=fake_reader, grabber=None, sizer=lambda _f: (1280, 720))
engine.face = service
return service
def set_cam(engine, sid, cam=CAM, source="yunet"):
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
json.dumps({"hasWebcam": cam is not None, "cam": cam, "source": source}), sid)
def session(engine, sid):
return engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
# ---------------------------------------------------------------- banco / modelos
def test_migration_creates_face_track(tmp_path):
db = Database(tmp_path / "c.db")
assert db.conn.execute("PRAGMA user_version").fetchone()[0] == len(SCHEMA)
cols = {r["name"] for r in db.all("PRAGMA table_info(face_track)")}
assert {"session_id", "idx", "status", "data_json", "error", "updated_at"} <= cols
def _lock(tmp_path, content: bytes) -> object:
lock = tmp_path / "models.lock.json"
lock.write_text(json.dumps({"dir": "x", "models": [
{"id": "m", "file": "m.onnx", "url": "https://exemplo/m.onnx", "sha256": hashlib.sha256(content).hexdigest()}]}))
return lock
def test_model_store_downloads_lazily_and_checks_sha256(tmp_path):
calls = []
def fetch(url, dest):
calls.append(url)
dest.write_bytes(b"pesos certos")
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=fetch)
path = store.path("m")
assert path.read_bytes() == b"pesos certos" and calls == ["https://exemplo/m.onnx"]
assert store.path("m") == path and len(calls) == 1 # conferido uma vez; não baixa de novo
# Arquivo já presente e certo (setup.ps1 baixou): nenhum download.
fresh = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=lambda *_: pytest.fail("baixou"))
assert fresh.path("m") == path
def test_model_store_rejects_wrong_sha256_and_network_errors(tmp_path):
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"),
fetch=lambda _url, dest: dest.write_bytes(b"adulterado"))
with pytest.raises(FaceUnavailable, match="sha256"):
store.path("m")
assert not list((tmp_path / "models").iterdir()) # nem o .part fica
def offline(_url, _dest):
raise OSError("sem rede")
with pytest.raises(FaceUnavailable, match="baixar"):
ModelStore(tmp_path / "models", _lock(tmp_path, b"x"), fetch=offline).path("m")
with pytest.raises(FaceUnavailable):
store.path("nao-existe")
# ---------------------------------------------------------------- laço por bloco
def test_block_is_tracked_in_full_frame_coords(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(40, 45))
sid = seed_session(engine, duration=120)
assert service.step() is False # câmera ainda não decidida: espera a detecção
set_cam(engine, sid)
for _ in range(4):
assert service.step() is True
assert service.step() is False
rows = engine.db.all("SELECT * FROM face_track WHERE session_id = ? ORDER BY idx", sid)
assert [r["status"] for r in rows] == ["done"] * 4
data = json.loads(rows[1]["data_json"])
assert data["cam"] == CAM and data["backend"] == "fake" and data["frames"] == 180
seconds = data["seconds"]
assert [s["t"] for s in seconds] == list(range(30, 60)) # bloco 30–60 s, sem repetir segundos do vizinho
crop = face_mod.expand(CAM)
assert seconds[0]["cx"] == pytest.approx(crop["x"] + 0.5 * crop["w"], abs=1e-3) # quadro inteiro, não recorte
assert seconds[0]["size"] == pytest.approx(0.3 * crop["h"], abs=1e-3)
assert service.tracked_until(sid) == 120
dense = service.dense(sid, 0, 120)
assert len(dense) == 120 and dense[42].smile == pytest.approx(0.9)
def test_no_cam_and_backend_unavailable(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid, cam=None) # detecção rodou e não achou câmera
assert service.step() and service.step()
assert {r["status"] for r in engine.db.all("SELECT status FROM face_track WHERE session_id = ?", sid)} == {"no_cam"}
assert service.for_scoring(session(engine, sid), 0, 60) == (None, 0.0) # pontuação segue como antes
# Backend sem modelo/biblioteca: não marca o bloco (tenta de novo depois).
sid2 = seed_session(engine, duration=60)
set_cam(engine, sid2)
def broken(_backend=None):
raise FaceUnavailable("sem modelo")
service._tracker_factory = broken
with pytest.raises(FaceUnavailable):
service.step()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid2)["n"] == 0
def test_block_error_is_recorded(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=30)
set_cam(engine, sid)
def failing(*_a, **_k):
raise face_mod.FaceError("bloco apagado")
yield # pragma: no cover
service._reader = failing
assert service.step()
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
assert row["status"] == "error" and "apagado" in row["error"]
def test_camera_change_resets_the_track(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service.step()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track")["n"] == 2
# Você corrige a câmera no layout da sessão: a série é apagada e refeita com o retângulo novo.
new_cam = {"x": 0.7, "y": 0.6, "w": 0.25, "h": 0.35}
engine.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps({"layout": {"cam": new_cam}}), sid)
assert service.cam_for(session(engine, sid)) == (new_cam, "manual", True)
service.step()
rows = engine.db.all("SELECT data_json FROM face_track WHERE session_id = ?", sid)
assert len(rows) == 1 and json.loads(rows[0]["data_json"])["cam"] == new_cam
def test_find_new_clips_waits_for_face_at_most_two_blocks(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine) # pico do chat em 300 s, 600 s gravados, transcrição toda pronta
set_cam(engine, sid)
for _ in range(9): # rosto até 270 s: 11 blocos atrás da transcrição → não segura o corte
service.step()
assert service.must_wait(330, 270, 600) is False
assert service.must_wait(330, 270, 320) is True # rosto 1–2 blocos atrás: espera
while service.step():
pass
assert engine.find_new_clips(session(engine, sid)) == 1
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
reasons = json.loads(clip["reasons_json"])
assert clip["source"] == "chat" and reasons["face"]["label"] == "risada" and 300 <= reasons["face"]["peakS"] <= 306
def test_live_clip_waits_while_face_is_one_block_behind(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
for _ in range(10): # rosto até 300 s; o corte (≈ 286–306 s + folga) precisa até ~318 s
service.step()
engine.db.run("UPDATE segments SET analyzed = 0 WHERE session_id = ? AND idx >= 12", sid) # transcrição até 360 s
assert engine.find_new_clips(session(engine, sid)) == 0
service.step()
assert engine.find_new_clips(session(engine, sid)) == 1
def test_judge_prompt_gets_face_line(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
text = service.summary(session(engine, sid), 280, 330)
assert text.startswith("risada forte em 30")
prompt = build_prompt("x", "twitch", 290, 320, 305, [], [], {}, face=text)
assert "Rosto do streamer" in prompt and "risada forte em 30" in prompt
assert "Rosto do streamer" not in build_prompt("x", "twitch", 290, 320, 305, [], [], {})
engine.intel.opts["faceTrack"] = False
assert service.summary(session(engine, sid), 280, 330) == ""
class FakeOsfTracker(FakeTracker):
"""Plano B: rosto e posição, sem blendshapes (como o OpenSeeFace de verdade)."""
name = "openseeface"
def process(self, t, rgb):
return FaceSample(t, True, 0.5, 0.4, 0.3, {})
def test_openseeface_series_does_not_break_signal_nor_lie_to_the_judge(env): # noqa: F811
_client, engine = env
service = make_service(engine, tracker_factory=lambda _backend=None: FakeOsfTracker())
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
view = service.view(session(engine, sid), 0, None)
assert view["blocks"]["done"] > 0 and view["moments"] == []
assert all(r.get("signal", 0) == 0 for r in view["seconds"])
face, _until = service.for_scoring(session(engine, sid), 0, 300)
from app.scoring import find_moments
assert find_moments(300, [], [None] * 300, [], face=face) == []
# Sem expressões, "sem reação marcante" seria mentira para o analista: a linha não vai.
assert service.summary(session(engine, sid), 100, 200) == ""
# ---------------------------------------------------------------- câmera local
class FakeDetector:
def detect(self, bgr):
return [(18.0, 363.0, 85.0, 109.0, 0.92)]
class FakeFrame:
shape = (720, 1280, 3)
def test_detect_cam_local_first_without_ai(env): # noqa: F811
_client, engine = env
service = make_service(engine)
service._detector_factory = FakeDetector
service._grabber = lambda *_a, **_k: FakeFrame()
engine.judge.provider = "off" # sem IA nenhuma
sid = seed_session(engine)
result = engine.intel.detect_cam(sid, apply=True)
assert result["hasWebcam"] and result["source"] == "yunet" and result["frames"] == 12
cam = result["cam"]
assert cam["y"] < 363 / 720 - 0.5 * 109 / 720 # folga acima da testa
saved = json.loads(session(engine, sid)["settings_json"])
assert saved["layout"]["cam"] == cam # sem canal: vale para a sessão
assert json.loads(session(engine, sid)["cam_json"])["source"] == "yunet"
def test_detect_cam_no_face_falls_back_to_ai_or_records_retry(env): # noqa: F811
_client, engine = env
service = make_service(engine)
service._detector_factory = lambda: type("D", (), {"detect": lambda self, bgr: []})()
service._grabber = lambda *_a, **_k: FakeFrame()
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
calls = []
def ai_cam(images):
calls.append(len(images))
return {"has_webcam": True, "x": 0.01, "y": 0.5, "w": 0.2, "h": 0.4, "game_on_screen": ""}
engine.judge.detect_cam = ai_cam
engine.intel.frames = lambda _s, times, _tag: [(t, f"f{int(t)}.jpg") for t in times]
engine.intel.e.rel = lambda p: str(p)
result = engine.intel.detect_cam(sid)
assert result["source"] == "ai" and calls == [3] # local sem rosto → IA (ligada, com visão)
# Sem IA: fica registrado "sem câmera" e tenta de novo daqui a 5 min de gravação.
engine.judge.provider = "off"
engine.db.run("UPDATE sessions SET cam_json = NULL WHERE id = ?", sid)
engine.intel.maybe_detect_cam(session(engine, sid))
saved = json.loads(session(engine, sid)["cam_json"])
assert saved["hasWebcam"] is False and saved["source"] == "yunet" and saved["retryAfterS"] == 900
# ---------------------------------------------------------------- API
def test_face_api_and_reset(env): # noqa: F811
client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
r = client.get(f"/v1/sessions/{sid}/face?from=290&to=320", headers=auth())
assert r.status_code == 200
body = r.json()
assert body["cam"] == CAM and body["camSource"] == "yunet" and body["coords"] == "frame"
assert body["blocks"]["done"] == 20 and body["trackedUntilS"] == 600
assert [s["t"] for s in body["seconds"]][:2] == [290, 291] and body["seconds"][-1]["t"] == 319
assert 0 < body["seconds"][0]["cx"] < CAM["x"] + CAM["w"] and "signal" in body["seconds"][0]
assert [m["label"] for m in body["moments"]] == ["risada"]
assert client.get(f"/v1/sessions/{sid}/face?from=50&to=10", headers=auth()).status_code == 400
assert client.get("/v1/sessions/999/face", headers=auth()).status_code == 404
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
assert r.status_code == 200 and r.json() == {"ok": True, "deleted": 20, "scheduled": False}
assert client.get(f"/v1/sessions/{sid}/face", headers=auth()).json()["blocks"]["done"] == 0
def test_face_track_option_persists(env): # noqa: F811
client, engine = env
r = client.put("/v1/judge", json={"provider": "codex", "model": "", "minScore": 6, "faceTrack": False}, headers=auth())
assert r.status_code == 200 and r.json()["options"]["faceTrack"] is False
assert engine.face.enabled is False
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
assert saved["opt_faceTrack"] == "false"
# ---------------------------------------------------------------- correções da revisão (médios)
import sys # noqa: E402
import time # noqa: E402
def _fake_ffmpeg(code: str) -> list[str]:
"""Processo falso no lugar do FFmpeg (Python sem shell): `code` escreve quadros/stderr e sai."""
return [sys.executable, "-c", code]
def test_read_frames_ok_and_nonzero_exit_after_some_frames():
frame = 4 * 2 * 3
ok = face_mod._read_frames(_fake_ffmpeg(f"import sys; sys.stdout.buffer.write(b'x' * {frame * 3})"), (4, 2), 6, 30, "b")
assert len(list(ok)) == 3
# FFmpeg que cai no meio (2 quadros e código 1): erro, não bloco truncado gravado como completo.
code = f"import sys; sys.stdout.buffer.write(b'x' * {frame * 2}); sys.stdout.flush(); sys.exit(1)"
with pytest.raises(face_mod.FaceError, match="código 1 depois de 2 quadros"):
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
def test_read_frames_drains_big_stderr_and_has_a_deadline():
# ~360 KB no stderr (mais que o buffer do pipe) não trava; o erro traz a última linha.
code = "import sys; sys.stderr.write('ruido\\n' * 60000 + 'fim do erro\\n'); sys.exit(2)"
started = time.perf_counter()
with pytest.raises(face_mod.FaceError, match="fim do erro"):
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
# Processo que não entrega nada nem sai: morto pelo prazo.
with pytest.raises(face_mod.FaceError, match="passou de 1 s"):
list(face_mod._read_frames(_fake_ffmpeg("import time; time.sleep(60)"), (4, 2), 6, 1, "b"))
assert time.perf_counter() - started < 20
def test_truncated_block_is_error_not_done(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=30)
set_cam(engine, sid)
def short(*_a, **_k):
for i in range(60): # 10 s de 30
yield i / 6, None
service._reader = short
assert service.step()
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
assert row["status"] == "error" and "truncado" in row["error"]
def test_reset_does_not_block_while_a_block_is_running(env): # noqa: F811
client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service._busy.acquire() # um bloco "em andamento"
try:
started = time.perf_counter()
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
assert time.perf_counter() - started < 3
assert r.status_code == 202 and r.json()["scheduled"] is True
finally:
service._busy.release()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid)["n"] == 1
service.step() # o laço aplica o reset agendado antes do próximo bloco
rows = engine.db.all("SELECT idx FROM face_track WHERE session_id = ?", sid)
assert [r["idx"] for r in rows] == [0] # apagou e refez só o primeiro
def test_backend_is_fixed_per_session():
seen = []
class Store:
def path(self, model_id):
if model_id == "face_landmarker":
raise FaceUnavailable("sem mediapipe")
seen.append(model_id)
raise FaceUnavailable("sem pesos do plano B")
service = FaceService.__new__(FaceService)
service.store = Store()
# Sessão que começou no MediaPipe: espera ele voltar, não troca para o OpenSeeFace no meio.
with pytest.raises(FaceUnavailable, match="sem mediapipe"):
service._default_tracker("mediapipe")
assert seen == []
# Sessão nova: o plano B só entra aqui.
with pytest.raises(FaceUnavailable, match="plano B"):
service._default_tracker(None)
assert seen == ["osf_landmarks"]
def test_session_backend_comes_from_the_series(env): # noqa: F811
_client, engine = env
asked = []
def factory(backend=None):
asked.append(backend)
return FakeTracker()
service = make_service(engine, tracker_factory=factory)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service.step()
assert asked == [None, "fake"]
def test_crop_geometry_never_leaves_the_frame():
for crop in ({"x": 0.95, "y": 0.9, "w": 0.3, "h": 0.4}, {"x": -0.1, "y": -0.2, "w": 1.5, "h": 1.5},
{"x": 0.999, "y": 0.999, "w": 0.01, "h": 0.01}):
(x, y, w, h), (ow, oh) = face_mod.crop_geometry(crop, (1280, 720))
assert 0 <= x and 0 <= y and x + w <= 1280 and y + h <= 720 and w >= 2 and h >= 2
assert x % 2 == y % 2 == w % 2 == h % 2 == 0 and ow >= 2 and oh >= 2
def test_transient_detector_failure_is_not_saved_as_no_cam(env): # noqa: F811
_client, engine = env
service = make_service(engine)
def unavailable():
raise FaceUnavailable("download do YuNet falhou")
service._detector_factory = unavailable
engine.judge.provider = "off"
sid = seed_session(engine) # sessão 'processing' (não grava)
engine.intel.maybe_detect_cam(session(engine, sid))
assert session(engine, sid)["cam_json"] is None # nada permanente
assert engine.intel._cam_retry_at[sid] > time.time()
engine.intel.maybe_detect_cam(session(engine, sid)) # dentro da espera: nem tenta
# Falha não passageira (poucos quadros) em sessão parada: grava com nova tentativa pelo relógio.
engine.intel._cam_retry_at.clear()
service._detector_factory = FakeDetector
service._grabber = lambda *_a, **_k: None
engine.intel.maybe_detect_cam(session(engine, sid))
saved = json.loads(session(engine, sid)["cam_json"])
assert saved["hasWebcam"] is False and saved["retryAt"] > time.time() and saved["attempts"] == 1
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(saved | {"retryAt": 0}), sid)
service._grabber = lambda *_a, **_k: FakeFrame()
engine.intel.maybe_detect_cam(session(engine, sid))
assert json.loads(session(engine, sid)["cam_json"])["hasWebcam"] is True
+318
View File
@@ -0,0 +1,318 @@
"""Formato do corte (vertical 9:16 / horizontal 16:9), durações padrão novas (60–90 s, volta até 2 min) e tempo da
legenda com fala rápida (pedidos do dono, 16/11/2026)."""
import hashlib
import json
import re
import shutil
import sqlite3
import subprocess
from pathlib import Path
import pytest
from app import db as db_module
from app import editor, editor_render, layout, subtitles
from app.scoring import ChatMessage, Word
from .test_editor import KEY, _lavfi_segments, api, make_project, validate # noqa: F401 - api é fixture
FFMPEG = shutil.which("ffmpeg")
FFPROBE = shutil.which("ffprobe")
HORIZONTAL = {"format": {"aspect": "horizontal"}}
CAM = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}
# ---------------------------------------------------------------- configuração: format e duration
def test_format_validate_and_merge():
assert layout.DEFAULTS["format"] == {"aspect": "vertical"}
assert layout.merge()["format"]["aspect"] == "vertical"
assert layout.validate({"format": {"aspect": "horizontal"}}) == {"format": {"aspect": "horizontal"}}
assert layout.validate({"format": {}}) == {"format": {}}
for bad in ({"format": {"aspect": "quadrado"}}, {"format": "horizontal"}):
with pytest.raises(layout.LayoutError):
layout.validate(bad)
# padrão ← canal ← sessão ← projeto: a camada de cima vence; sem `format` (config antiga) = vertical.
cfg = layout.merge({"format": {"aspect": "horizontal"}}, {"caption": {"size": 90}})
assert layout.aspect(cfg) == "horizontal" and layout.frame_size(cfg) == (1920, 1080)
assert layout.aspect(layout.merge(cfg, {"format": {"aspect": "vertical"}})) == "vertical"
assert layout.aspect({"layout": {}}) == "vertical" and layout.frame_size(layout.merge()) == (1080, 1920)
def test_duration_defaults_and_limits():
assert layout.DEFAULTS["duration"] == {"minS": 60, "maxS": 90, "backtrackS": 120}
assert layout.validate({"duration": {"minS": 120, "maxS": 180, "backtrackS": 120}})["duration"]["minS"] == 120
for bad in ({"minS": 121}, {"minS": 4}, {"maxS": 181}, {"maxS": 14}, {"backtrackS": 121}, {"minS": 90, "maxS": 90},
{"minS": 100, "maxS": 90}):
with pytest.raises(layout.LayoutError):
layout.validate({"duration": bad})
def test_settings_routes_carry_format(api): # noqa: F811
client, engine, _root = api
h = {"X-Service-Key": KEY}
r = client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "horizontal"}})
assert r.status_code == 200, r.text
body = r.json()
assert body["own"] == {"format": {"aspect": "horizontal"}} and body["effective"]["format"]["aspect"] == "horizontal"
assert body["defaults"]["format"]["aspect"] == "vertical" and body["defaults"]["duration"]["maxS"] == 90
assert body["aspects"] == ["vertical", "horizontal"] and body["frames"]["horizontal"]["width"] == 1920
assert client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "x"}}).status_code == 400
# ---------------------------------------------------------------- layout horizontal
def test_horizontal_layout_modes():
plain = layout.merge(HORIZONTAL)
for mode in ("auto", "blur", "cam_top", "game_only"):
cfg = layout.merge(HORIZONTAL, CAM, {"layout": {"mode": mode}})
assert layout.resolved_mode(cfg) == "full"
chain = layout.layout_chain(cfg, "in", "out")
assert "vstack" not in chain and "boxblur" not in chain and "pad=1920:1080" in chain # quadro inteiro
cam_only = layout.merge(HORIZONTAL, CAM, {"layout": {"mode": "cam_only"}})
chain = layout.layout_chain(cam_only, "in", "out")
assert layout.resolved_mode(cam_only) == "cam_only" and "crop=iw*0.2:ih*0.25:iw*0.02:ih*0.45" in chain
assert "crop=1920:1080" in chain # câmera preenche 1920×1080 sem distorcer
# cam_only sem câmera marcada: quadro inteiro; região do jogo marcada: recorta e preenche.
assert layout.resolved_mode(layout.merge(HORIZONTAL, {"layout": {"mode": "cam_only"}})) == "full"
game = layout.merge(HORIZONTAL, {"layout": {"game": {"x": 0.1, "y": 0.1, "w": 0.8, "h": 0.8}}})
assert "crop=iw*0.8:ih*0.8:iw*0.1:ih*0.1,scale=1920:1080:force_original_aspect_ratio=increase,crop=1920:1080" in \
layout.layout_chain(game, "in", "out")
# troca de layout por trecho (editor) também respeita o formato
assert "crop=iw*0.2" in layout.layout_chain(layout.merge(HORIZONTAL, CAM), "in", "out", mode="cam_only")
assert layout.layout_chain(plain, "in", "out").startswith("[in]scale=1920:1080:force_original_aspect_ratio=decrease")
def test_horizontal_ass_positions_and_sizes(tmp_path):
data = make_project(settings=HORIZONTAL, chat={"enabled": True, "x": 0.02, "y": 0.9, "width": 0.3, "lines": 3})
p = validate(data, tmp_path)
cfg = editor.effective_settings(layout.merge(), p)
assert layout.aspect(cfg) == "horizontal"
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x", chat=[ChatMessage(11.0, "KKKK", "ana")])
assert "PlayResX: 2560" in ass and "PlayResY: 1440" in ass # quadro lógico (textos a 75 % no 1920×1080)
assert "\\pos(1280,1224)" in ass # legenda automática: centro, 85 % da altura
assert f"\\pos(1280,{int(1440 * 0.2)})" in ass # gancho (y relativo)
assert f"\\an1\\pos({int(2560 * 0.02)},{int(1440 * 0.9)})" in ass # chat (x/y relativos)
assert "m 0 0 l 2560 0 2560 12 0 12" in ass # barra de progresso na largura toda
credit = next(line for line in ass.splitlines() if line.startswith("Style: Credit"))
assert credit.endswith(",9,48,48,36,1") # crédito no canto superior direito
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
assert "s=1920x1080" in graph and "[1:v]scale=1920:1080" in graph # zoom e capa no tamanho do formato
# legenda com y escolhido: fração da altura do quadro lógico
q = validate(make_project(settings={**HORIZONTAL, "caption": {"y": 0.5}}), tmp_path)
assert "\\pos(1280,720)" in editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
def _golden_values() -> dict:
"""Mesmas entradas usadas para gravar tests/data/vertical_golden_sha256.json com o código de ANTES do formato."""
cam = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}, "game": {"x": 0.3, "y": 0.1, "w": 0.6, "h": 0.8}}}
g = {}
for base_name, base in (("nocam", {}), ("cam", cam)):
for mode in layout.MODES:
cfg = layout.merge(base, {"layout": {"mode": mode}})
g[f"chain-{base_name}-{mode}"] = layout.layout_chain(cfg, "in", "out", ",setsar=1", "_0")
g[f"vf-{base_name}-{mode}"] = layout.video_filter(cfg, "a.ass")
g[f"capy-{base_name}-{mode}"] = layout.caption_y(cfg)
return g, cam
def test_vertical_output_is_unchanged(tmp_path):
"""O vertical continua idêntico ao de antes do formato (filtergraph, legenda, textos, chat, capa)."""
expected = json.loads((Path(__file__).parent / "data" / "vertical_golden_sha256.json").read_text(encoding="utf-8"))
g, cam = _golden_values()
p = validate(make_project(chat={"enabled": True, "lines": 3}), tmp_path)
chat = [ChatMessage(11.0, "KKKKKK", "ana"), ChatMessage(13.0, "server chinês", "beto")]
for base_name, base in (("nocam", {}), ("cam", cam)):
for preset in editor.CAPTION_PRESETS:
q = json.loads(json.dumps(p))
q["captions"]["preset"] = preset
g[f"ass-{base_name}-{preset}"] = editor_render.build_project_ass(
q, editor.effective_settings(layout.merge(base), q), "twitch.tv/x", chat=chat)
cfg = editor.effective_settings(layout.merge(base), p)
g[f"filter-{base_name}"] = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
words = [Word(1.0, 1.3, "olha"), Word(1.4, 1.8, "isso"), Word(1.9, 2.3, "aqui"), Word(3.5, 3.9, "caiu"), Word(4.0, 4.6, "mano")]
g[f"subs-{base_name}"] = subtitles.build_ass(words, 0.5, 6.0, "twitch.tv/x", layout.merge(base))
got = {k: hashlib.sha256(str(v).encode("utf-8")).hexdigest() for k, v in g.items()}
assert set(got) == set(expected)
assert [k for k in expected if got[k] != expected[k]] == []
def test_old_project_without_format_stays_vertical(tmp_path):
p = validate(make_project(settings={"caption": {"size": 90}}), tmp_path)
assert "format" not in p["settings"]
cfg = editor.effective_settings(layout.merge(), p)
assert layout.aspect(cfg) == "vertical" and "PlayResY: 1920" in editor_render.build_project_ass(p, cfg, "")
# o projeto escolhe o formato por corte, por cima do canal/sessão
q = validate(make_project(settings={"format": {"aspect": "vertical"}}), tmp_path)
assert layout.aspect(editor.effective_settings(layout.merge(HORIZONTAL), q)) == "vertical"
with pytest.raises(editor.EditError):
validate(make_project(settings={"format": {"aspect": "4:3"}}), tmp_path)
# ---------------------------------------------------------------- render real
def _dark_segment(folder: Path, seconds: int = 8) -> Path:
"""Bloco de vídeo escuro (texto claro aparece com clareza) com tom de teste."""
seg = folder / "dark.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0x202020:size=640x360:rate=30:duration={seconds}",
"-f", "lavfi", "-i", f"sine=frequency=440:duration={seconds}", "-c:v", "libx264", "-preset", "ultrafast",
"-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
return seg
def _gray_frame(video: Path, at: float, w: int, h: int) -> bytes:
return subprocess.run([FFMPEG, "-v", "error", "-ss", f"{at:.2f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
"-pix_fmt", "gray", "-"], capture_output=True, check=True).stdout[: w * h]
def _bright(frame: bytes, w: int, x0: float, x1: float, y0: float, y1: float, h: int) -> int:
return sum(1 for y in range(int(y0 * h), int(y1 * h)) for x in range(int(x0 * w), int(x1 * w), 2)
if frame[y * w + x] > 200)
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
def test_real_horizontal_render(tmp_path):
"""Render de verdade em 1920×1080: legenda, gancho, chat, zoom, barra, crédito e capa no início."""
seg = _dark_segment(tmp_path)
words = [{"s": 1.2 + i * 0.3, "e": 1.45 + i * 0.3, "w": w} for i, w in enumerate("olha isso aqui caiu mano".split())]
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, settings=HORIZONTAL,
cuts=[{"start": 1, "end": 4, "mode": None}, {"start": 4, "end": 7, "mode": "cam_only"}],
overlays=[{"id": "hook", "kind": "hook", "text": "ELE NÃO ACREDITOU", "start": 0, "end": 2, "y": 0.2,
"size": 70, "color": "#FFFFFF", "box": "#E11D48", "anim": "none"},
{"id": "z", "kind": "zoom", "start": 5, "end": 6.5, "scale": 1.3, "x": 0.5, "y": 0.5, "ramp": 0.2}],
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words},
cover={"enabled": True, "t": 2, "text": "CAPA", "atStart": True},
chat={"enabled": True, "x": 0.02, "y": 0.6, "width": 0.3, "lines": 3, "size": 40})
p = validate(data, tmp_path, duration=8.0)
base = layout.merge(CAM)
segments = [(seg, 0.0, 8.0)]
cover = editor_render.render_cover(FFMPEG, segments, p, base, "twitch.tv/x", tmp_path / "cover.jpg")
out = tmp_path / "out.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], segments, p, base, "twitch.tv/x",
out, tmp_path, chat=[ChatMessage(1.5, "KKKK", "ana"), ChatMessage(5.0, "F", "beto")],
cover_file=cover)
probe = subprocess.run([FFPROBE, "-v", "error", "-show_entries", "format=duration:stream=width,height", "-of", "csv=p=0",
str(out)], capture_output=True, text=True, check=True).stdout
assert "1920,1080" in probe and abs(float(probe.strip().splitlines()[-1]) - 6.0) < 0.2
cover_probe = subprocess.run([FFPROBE, "-v", "error", "-show_entries", "stream=width,height", "-of", "csv=p=0", str(cover)],
capture_output=True, text=True, check=True).stdout
assert cover_probe.strip() == "1920,1080"
w, h = 1920, 1080
frame = _gray_frame(out, 1.0, w, h) # 1 s de saída = 2 s da sessão: gancho, legenda e chat na tela
assert _bright(frame, w, 0.25, 0.75, 0.15, 0.25, h) > 200 # gancho em cima
assert _bright(frame, w, 0.25, 0.75, 0.80, 0.90, h) > 200 # legenda no terço de baixo
assert _bright(frame, w, 0.0, 0.3, 0.50, 0.60, h) > 50 # chat à esquerda
assert _bright(frame, w, 0.7, 1.0, 0.0, 0.08, h) > 50 # crédito no canto de cima à direita
assert _bright(frame, w, 0.0, 1.0, 0.30, 0.45, h) < 50 # o meio do jogo fica limpo
# ---------------------------------------------------------------- aspect no corte + migração v8
def test_migration_v8_marks_old_clips_vertical(tmp_path):
path = tmp_path / "old.db"
conn = sqlite3.connect(path)
for script in db_module.SCHEMA[:7]:
for statement in db_module._split(script):
conn.execute(statement)
conn.execute("PRAGMA user_version = 7")
conn.execute("INSERT INTO sessions (id, platform, kind, url, status, dir, started_at) VALUES (1, 'twitch', 'live', 'u', 'done', 'd', 'x')")
conn.execute("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at) "
"VALUES (1, 5, 0, 10, 1, 'chat', 'ready', 'x', 'x')")
conn.commit()
conn.close()
database = db_module.Database(path)
assert database.get("PRAGMA user_version")["user_version"] == len(db_module.SCHEMA) >= 8 # v9 (capture_json) em cima
assert database.get("SELECT aspect FROM clips")["aspect"] == "vertical"
with pytest.raises(sqlite3.IntegrityError):
database.run("UPDATE clips SET aspect = 'quadrado'")
database.close()
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_clip_reports_rendered_aspect(api): # noqa: F811
client, engine, root = api
h = {"X-Service-Key": KEY}
assert client.get("/v1/clips/7", headers=h).json()["aspect"] == "vertical" # antes do render: padrão
_lavfi_segments(root / "data" / "s1")
client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "horizontal"}})
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 7")
engine.render_pending()
clip = client.get("/v1/clips/7", headers=h).json()
assert clip["status"] == "ready", clip["error"]
assert clip["aspect"] == "horizontal"
assert any(c["aspect"] == "horizontal" for c in client.get("/v1/clips", headers=h).json()["clips"])
probe = subprocess.run([FFPROBE or "ffprobe", "-v", "error", "-select_streams", "v", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(root / clip["file"])], capture_output=True, text=True, check=True).stdout
assert probe.strip() == "1920,1080"
# Prévia real do começo com capa no início: a capa é gerada também para a prévia.
project = client.get("/v1/clips/7/edit", headers=h).json()
project["project"]["cover"]["atStart"] = True
assert client.put("/v1/clips/7/edit", headers=h, json=project).status_code == 200
prev = client.post("/v1/clips/7/preview-render", headers=h, json={"fromS": 0, "durationS": 2})
assert prev.status_code == 200, prev.text
assert (root / "output" / "clipper" / "1" / "edit-7" / "preview-cover.jpg").is_file()
# O projeto escolhe o formato por corte: vertical por cima da sessão horizontal.
project = client.get("/v1/clips/7/edit", headers=h).json()
project["project"]["settings"] = {"format": {"aspect": "vertical"}}
assert client.put("/v1/clips/7/edit", headers=h, json=project).status_code == 200
client.post("/v1/clips/7/export", headers=h)
engine.render_pending()
assert client.get("/v1/clips/7", headers=h).json()["aspect"] == "vertical"
# ---------------------------------------------------------------- legenda com fala rápida
def _fast_words() -> list[Word]:
"""~7 palavras/s, com sobreposição (fim depois do início da seguinte), duração zero e duas no mesmo instante."""
out, t = [], 0.3
for i, text in enumerate("e aí mano olha isso que ele fez cara não acredito vai vai vai pega ele agora sim kkkk".split()):
dur = 0.0 if i % 5 == 3 else 0.22 # algumas de 0 s (Whisper)
out.append(Word(round(t, 3), round(t + dur, 3), text))
t += 0.14
out.append(Word(out[-1].start, out[-1].start + 0.2, "boa")) # mesmo instante da anterior
return out
def _caption_events(ass: str) -> list[tuple[float, float]]:
def ts(s: str) -> float:
hh, mm, ss = s.split(":")
return int(hh) * 3600 + int(mm) * 60 + float(ss)
rows = [line.split(",") for line in ass.splitlines() if re.match(r"Dialogue: 0,.*,(Caption|Karaoke),", line)]
return sorted((ts(r[1]), ts(r[2])) for r in rows)
def test_fast_speech_captions_never_overlap_and_stay_in_sync(tmp_path):
raw = _fast_words()
clean = subtitles.clean_words(raw)
assert all(b.start > a.start and a.end <= b.start + 1e-9 for a, b in zip(clean, clean[1:])) # ordem, sem sobreposição
assert all(w.end - w.start > 0 for w in clean)
assert subtitles.clean_words(clean) == clean # idempotente
# só a palavra que começava junto com a anterior foi empurrada (e no máximo 40 ms)
shifts = [round(c.start - r.start, 3) for r, c in zip(sorted(raw, key=lambda w: (w.start, w.end)), clean)]
assert [s for s in shifts if s] == [0.04]
blocks = subtitles.caption_blocks(raw, 3)
assert all(len(g) <= 4 for g, _ in blocks) and any(len(g) == 4 for g, _ in blocks) # fala rápida: +1 palavra
for (g1, end1), (g2, _) in zip(blocks, blocks[1:]):
assert end1 <= g2[0].start # um bloco sai antes do próximo entrar
# Render do editor (todos os presets, nos dois formatos) e do worker: nenhum par de eventos ao mesmo tempo, e
# cada bloco entra no início da sua 1ª palavra (no centésimo do ASS).
words = [{"s": w.start + 10, "e": w.end + 10, "w": w.word} for w in raw]
starts = {round(w.start, 2) for w in clean}
for settings in ({}, HORIZONTAL):
for preset in editor.CAPTION_PRESETS:
p = validate(make_project(settings=settings, cuts=[{"start": 10, "end": 20, "mode": None}], overlays=[],
captions={"enabled": True, "preset": preset, "style": {}, "emphColor": "#22E36B",
"words": words}), tmp_path)
events = _caption_events(editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), ""))
assert len(events) >= 5, preset
assert all(b[0] >= a[1] - 1e-6 for a, b in zip(events, events[1:])), preset
assert all(round(s, 2) in starts or any(abs(s - x) <= 0.011 for x in starts) for s, _ in events), preset
events = _caption_events(subtitles.build_ass(raw, 0.0, 10.0, "", layout.merge(settings)))
assert all(b[0] >= a[1] - 1e-6 for a, b in zip(events, events[1:]))
def test_emphasis_and_highlight_survive_word_cleaning(tmp_path):
words = [{"s": 11.0, "e": 11.3, "w": "olha"}, {"s": 11.0, "e": 11.2, "w": "isso", "emph": True},
{"s": 11.25, "e": 11.25, "w": "aqui"}]
p = validate(make_project(cuts=[{"start": 10, "end": 15, "mode": None}], overlays=[],
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words}),
tmp_path)
ass = editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), "")
assert "&H6BE322&" in ass # ênfase ainda casada com a palavra certa depois do saneamento
assert len(_caption_events(ass)) == 3
+54
View File
@@ -0,0 +1,54 @@
"""Hashtags da legenda: canal e jogo fixos (perfil), momento da IA, sem repetidas, até 8."""
from app.hashtags import build_caption, compose, fold, split_hashtags, to_tag
from app.intel import clean_profile
from app.judge import _clean
def test_to_tag_normalizes_names_and_phrases():
assert to_tag("ROB RUN") == "#ROBRUN"
assert to_tag("#Lamborghini") == "#Lamborghini"
assert to_tag("perseguição policial") == "#PerseguiçãoPolicial"
assert to_tag("Call of Duty: Warzone") == "#CallOfDutyWarzone"
assert to_tag(" ") is None and to_tag("#123") is None and to_tag("!!!") is None
def test_compose_puts_channel_then_game_then_moment_without_duplicates():
profile = {"hashtags": ["#ROBRUN", "#RobRunGame", "#jogodeassalto", "#quarta"]}
tags = compose("skipnho", "ROB RUN", profile, ["assalto ao banco", "RobRun", "Clã", "cla", "sorteio", "extra", "mais"])
# Jogo: até 3 do perfil; momento: até 4; "RobRun"/"cla" repetem (sem maiúscula/acento) e saem.
assert tags == ["#skipnho", "#ROBRUN", "#RobRunGame", "#jogodeassalto", "#AssaltoAoBanco", "#Clã"]
assert fold("#Clã") == fold("#CLA")
def test_compose_without_profile_uses_game_name_and_caps_at_eight():
assert compose("skipnho", "ROB RUN", None, []) == ["#skipnho", "#ROBRUN"]
many = compose("canal", "Jogo", {"hashtags": ["#a1", "#b2", "#c3"]}, [f"tag{i}" for i in range(10)])
assert len(many) == 8
def test_caption_layout_text_tags_credit():
text, inline = split_hashtags("O clã vai ao banco #skipnho e o plano dá errado. #assalto")
assert text == "O clã vai ao banco e o plano dá errado." and inline == ["#skipnho", "#assalto"]
caption = build_caption(text, ["#skipnho", "#ROBRUN"], "🎥 Créditos: https://twitch.tv/skipnho")
assert caption == "O clã vai ao banco e o plano dá errado.\n\n#skipnho #ROBRUN\n\n🎥 Créditos: https://twitch.tv/skipnho"
assert build_caption("", [], "🎥 Créditos: x") == "🎥 Créditos: x"
def test_profile_hashtags_are_cleaned():
profile = clean_profile({"name": "ROB RUN", "hashtags": ["rob run", "#ROBRUN", "#robrun", "#123", "GTA RP"]})
# "rob run" vira "#RobRun"; "#ROBRUN" e "#robrun" são a mesma tag (sem maiúscula) e saem.
assert profile["hashtags"] == ["#RobRun", "#GTARP"]
def test_api_accepts_hashtags_in_profile_edit_and_section_chat():
from app.main import GameProfileIn, GameRefineIn
assert GameProfileIn(hashtags=["#ROBRUN"]).hashtags == ["#ROBRUN"]
assert GameRefineIn(instruction="pesquise as hashtags", section="hashtags").section == "hashtags"
def test_verdict_reads_moment_hashtags_and_tolerates_old_answers():
base = {"keep": True, "score": 8, "start_s": 10, "end_s": 80, "title": "t", "caption": "c", "reason": "r"}
assert _clean({**base, "hashtags": ["assalto", " ", "Lamborghini"]}, 10, 80, "m", 0, 200, 30, 90).hashtags == ("assalto", "Lamborghini")
assert _clean(base, 10, 80, "m", 0, 200, 30, 90).hashtags == ()
+225
View File
@@ -0,0 +1,225 @@
import json
import pytest
from app import layout
from app.emotes import EmoteCatalog, extract, message_bonus, parse_twitch_tag
from app.judge import Judge
from app.scoring import ChatMessage, find_moments
from tests.test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
# ---------------------------------------------------------------- emotes
def test_parse_twitch_emote_tag_uses_codepoints():
text = "😂 Kappa oi LUL"
assert parse_twitch_tag("25:2-6/425618:11-13", text) == ["Kappa", "LUL"]
assert parse_twitch_tag("", text) == []
assert parse_twitch_tag("25:90-99", text) == [] # posição fora do texto não quebra
def test_extract_third_party_and_emoji():
found = extract("PepeLaugh mano 😂 Kappa", ["Kappa"], {"PepeLaugh": "bttv", "mano": "7tv"})
assert ("Kappa", "twitch") in found and ("PepeLaugh", "bttv") in found and ("😂", "emoji") in found
def test_message_bonus_learned_and_clamped():
assert message_bonus([], {}) == 0
assert message_bonus(["skpPog"], {}) == pytest.approx(0.4)
assert message_bonus(["skpPog"], {"skpPog": 2.0}) == pytest.approx(2.4)
assert message_bonus(["a", "b"], {"a": 3, "b": 3}) == 3.0
def test_catalog_tolerates_failing_sources():
def fetch(url):
if "7tv" in url:
raise TimeoutError
if "betterttv" in url and "users" in url:
return {"channelEmotes": [{"code": "skpPog"}], "sharedEmotes": [{"code": "PepeLaugh"}]}
if "betterttv" in url:
return [{"code": "FeelsGoodMan"}]
return None
catalog = EmoteCatalog(fetch)
names = catalog.names("123")
assert names["skpPog"] == "bttv" and "FeelsGoodMan" in names
assert catalog.cached("123")["PepeLaugh"] == "bttv"
assert catalog.cached("999").get("skpPog") is None
def test_emote_only_reactions_make_a_peak_in_small_chat():
# Live pequena: ninguém escreve "kkkk", só manda emote do canal.
calm = [ChatMessage(t * 7.0, "salve") for t in range(130)]
burst = [ChatMessage(500 + i, "skpPog", emotes=("skpPog",), bonus=0.4) for i in range(5)]
moments = [m for m in find_moments(900, calm + burst, [], []) if m.source == "chat"]
assert len(moments) == 1 and moments[0].reasons["emotes"] == {"skpPog": 5}
# ---------------------------------------------------------------- layout
def test_layout_validate_and_merge():
own = layout.validate({"layout": {"mode": "cam_top", "cam": {"x": 0.01, "y": 0.46, "w": 0.2, "h": 0.3}},
"caption": {"color": "#ffffff", "highlight": "#00ff88", "size": 90}})
cfg = layout.merge({"caption": {"size": 70}}, own)
assert cfg["caption"]["size"] == 90 and cfg["caption"]["highlight"] == "#00FF88"
assert layout.resolved_mode(cfg) == "cam_top"
for bad in ({"layout": {"mode": "x"}}, {"layout": {"cam": {"x": 0.9, "y": 0, "w": 0.5, "h": 0.3}}},
{"caption": {"color": "red"}}, {"duration": {"minS": 60, "maxS": 30}}):
with pytest.raises(layout.LayoutError):
layout.validate(bad)
def test_layout_filters():
cam = layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}})
f = layout.video_filter(cam, "c.ass")
assert "vstack" in f and "ass=c.ass" in f and "crop=iw*0.2:ih*0.3:iw*0:ih*0.5" in f
assert layout.caption_y(cam) == layout.cam_panel_height(cam) + 40 # legenda na emenda câmera/jogo
assert "boxblur" in layout.video_filter(layout.merge(), None) # sem câmera: layout desfocado
assert layout.ass_color("#FFE500") == "&H0000E5FF&" and layout.ass_inline_color("#FFE500") == "&H00E5FF&"
# ---------------------------------------------------------------- API + motor
def test_settings_api_channel_and_session(env): # noqa: F811
client, engine = env
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
r = client.put("/v1/channels/twitch-alanzoka/settings",
json={"layout": {"cam": {"x": 0.7, "y": 0.0, "w": 0.3, "h": 0.3}}}, headers=auth())
assert r.status_code == 200 and r.json()["effective"]["layout"]["cam"]["x"] == 0.7
assert client.put("/v1/channels/twitch-alanzoka/settings", json={"caption": {"size": 999}}, headers=auth()).status_code == 400
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
r = client.put(f"/v1/sessions/{sid}/settings", json={"caption": {"highlight": "#FF0000"}}, headers=auth())
eff = r.json()["effective"]
assert eff["caption"]["highlight"] == "#FF0000" and eff["layout"]["cam"]["x"] == 0.7 # sessão sobre o canal
def test_user_approval_teaches_emote_weights(env): # noqa: F811
client, engine = env
sid = seed_session(engine)
wall = engine.db.get("SELECT wall_end FROM segments WHERE session_id = ? AND idx = 10", sid)["wall_end"]
engine.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, 'u', 'skpPog', ?)",
[(sid, wall - 28 + i, json.dumps(["skpPog"])) for i in range(4)])
engine.db.run("INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen)"
" VALUES ('twitch-alanzoka', 'skpPog', 'bttv', 4, 0, 'x', 'x')")
engine.db.run("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at)"
" VALUES (?, 304, 290, 320, 5, 'chat', 'ready', 'x', 'x')", sid)
clip_id = engine.db.get("SELECT id FROM clips WHERE session_id = ?", sid)["id"]
client.patch(f"/v1/clips/{clip_id}", json={"status": "approved"}, headers=auth())
client.patch(f"/v1/clips/{clip_id}", json={"status": "approved"}, headers=auth()) # repetir não soma de novo
weight = engine.db.get("SELECT weight FROM emotes WHERE name = 'skpPog'")["weight"]
assert weight == pytest.approx(0.3)
emotes = client.get("/v1/emotes?channel=twitch-alanzoka", headers=auth()).json()["emotes"]
assert emotes[0]["name"] == "skpPog" and emotes[0]["weight"] == 0.3
class ScanJudge(Judge):
def __init__(self):
super().__init__("codex", "fake", __import__("pathlib").Path("."))
self.prompts = []
def scan(self, prompt, images):
self.prompts.append(prompt)
return {"screen_game": "ROB RUN", "has_webcam": True, "summary": "tiroteio na base",
"moments": [{"score": 8, "start_s": 100, "end_s": 140, "title": "Emboscada", "caption": "c #robrun",
"reason": "virada"},
{"score": 3, "start_s": 150, "end_s": 175, "title": "fraco", "caption": "", "reason": "morno"}]}
def test_scan_creates_clips_without_chat_peak(env): # noqa: F811
client, engine = env
engine.judge = ScanJudge()
engine.intel.opts["vision"] = False # sem ffmpeg nos testes
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'recording', game = 'ROB RUN' WHERE id = ?", sid)
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
assert engine.intel.scan_session(session) == 1 # a proposta nota 3 nem vai aos juízes
clips = client.get(f"/v1/clips?session={sid}", headers=auth()).json()["clips"]
assert len(clips) == 1 and clips[0]["status"] == "candidate" and clips[0]["source"] == "ai"
assert clips[0]["reasons"]["proposalTitle"] == "Emboscada"
s2 = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
assert s2["scannedUntilS"] == 180 and s2["screenGame"] == "ROB RUN" and s2["memory"][0]["summary"] == "tiroteio na base"
# janela seguinte também é varrida; a anterior não é repetida
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
engine.intel.scan_session(session)
assert "Janela nova: 180s a 360s" in engine.judge.prompts[-1]
def test_game_override_and_chat_ingest(env): # noqa: F811
client, engine = env
sid = seed_session(engine)
r = client.put(f"/v1/sessions/{sid}/game", json={"name": "GTA VI"}, headers=auth())
assert r.json()["game"] == "GTA VI" and r.json()["gameSource"] == "user"
assert client.get("/v1/games", headers=auth()).json()["games"][0]["status"] == "pending"
engine.intel.ingest_chat(sid, "twitch-alanzoka", None, [(20000.0, "u", "Kappa kkk 😂", ["Kappa"])])
row = engine.db.get("SELECT emotes FROM chat WHERE wall = 20000.0")
assert json.loads(row["emotes"]) == ["Kappa", "😂"]
uses = {r["name"]: r["uses"] for r in engine.db.all("SELECT name, uses FROM emotes")}
assert uses == {"Kappa": 1, "😂": 1}
def test_resume_and_finish_interrupted_session(env): # noqa: F811
client, engine = env
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
engine.check_live = lambda url: (False, "") # canal offline: não dá para retomar
r = client.post(f"/v1/sessions/{sid}/resume", headers=auth())
assert r.status_code == 400 and "não está ao vivo" in r.json()["error"]
started = []
engine.check_live = lambda url: (True, "título")
class FakeCapture:
def __init__(self, eng, session_id, source, workdir, start_idx=0):
started.append(start_idx)
self.chat = None
def start(self):
pass
import app.worker as worker_module
original = worker_module.Capture
worker_module.Capture = FakeCapture
try:
r = client.post(f"/v1/sessions/{sid}/resume", headers=auth())
finally:
worker_module.Capture = original
assert r.status_code == 200 and r.json()["status"] == "starting"
assert started == [20] # 20 blocos já existiam (0–19): continua a numeração
engine.captures.clear()
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
r = client.post(f"/v1/sessions/{sid}/finish", headers=auth())
assert r.json()["status"] == "processing"
def test_startup_marks_recording_as_interrupted_and_remembers(tmp_path):
from app.db import Database
db = Database(tmp_path / "c.db")
db.run("INSERT INTO sessions (platform, kind, url, status, chat_status, dir, started_at) VALUES"
" ('twitch', 'live', 'https://www.twitch.tv/x', 'recording', 'connected', '', 'x')")
db.run("INSERT INTO sessions (platform, kind, url, status, chat_status, dir, started_at) VALUES"
" ('twitch', 'live', 'https://www.twitch.tv/y', 'interrupted', 'connected', '', 'x')")
db.close()
db = Database(tmp_path / "c.db")
rows = db.all("SELECT status, chat_status FROM sessions ORDER BY id")
assert db.interrupted_on_start == [1]
assert rows == [{"status": "interrupted", "chat_status": "off"}, {"status": "interrupted", "chat_status": "off"}]
def test_confirmed_game_silences_screen_doubt(env): # noqa: F811
client, engine = env
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET game = 'ROB RUN', game_source = 'platform', screen_game = 'Call of Duty: Warzone' WHERE id = ?", sid)
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
assert "Warzone" in engine.intel.context(session) # sem confirmação: a dúvida vai para os juízes
client.put(f"/v1/sessions/{sid}/game", json={"name": "ROB RUN"}, headers=auth())
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
ctx = engine.intel.context(session)
assert "CONFIRMADO" in ctx and "visto na tela" not in ctx and "Call of Duty" not in ctx
engine.check_meta = lambda url: {"title": "", "category": "Grand Theft Auto V", "author": ""}
engine.intel.check_game(session, force=True) # checagem automática não troca jogo confirmado
assert engine.db.get("SELECT game_source FROM sessions WHERE id = ?", sid)["game_source"] == "user"
def test_research_pending_is_quiet_with_ai_off(env): # noqa: F811
"""IA desligada: o jogo fica 'pending' sem erro (antes o laço de contexto logava um WARNING a cada 30 s)."""
_client, engine = env
engine.judge = Judge("off", "", engine.settings.data_dir / "judge")
engine.db.run("INSERT INTO games (id, name, status) VALUES ('rob-run', 'ROB RUN', 'pending')")
engine.intel.research_pending()
assert engine.db.get("SELECT status FROM games WHERE id = 'rob-run'")["status"] == "pending"
+353
View File
@@ -0,0 +1,353 @@
import json
import random
import pytest
from app.reaction import (
FaceSample, FaceSecond, ReactionParams, label, locate_cam, per_second, reaction_moments, reaction_signal,
seconds_from_json, seconds_to_json, summarize,
)
FPS = 6
def neutral_blend(rng: random.Random, smile: float = 0.05) -> dict[str, float]:
"""Rosto parado: blendshapes baixos com ruído (fala/tique), sorriso no nível pedido."""
n = lambda base: max(0.0, min(1.0, base + rng.uniform(-0.03, 0.03))) # noqa: E731
return {
"mouthSmileLeft": n(smile), "mouthSmileRight": n(smile), "jawOpen": n(0.08),
"eyeWideLeft": n(0.05), "eyeWideRight": n(0.05), "browInnerUp": n(0.05),
"browOuterUpLeft": n(0.04), "browOuterUpRight": n(0.04), "browDownLeft": n(0.05), "browDownRight": n(0.05),
"eyeBlinkLeft": n(0.1), "eyeBlinkRight": n(0.1),
}
def track(duration: int, seed: int = 1, smile: float = 0.05, events: dict | None = None,
absent: range | None = None) -> list[FaceSample]:
"""Quadros a 6 qps. `events`: {segundo: função(blend, rng) → (blend, dx, dy)} para injetar reações."""
rng = random.Random(seed)
events = events or {}
out = []
for i in range(duration * FPS):
t = i / FPS
if absent is not None and int(t) in absent:
out.append(FaceSample(t, False))
continue
blend, dx, dy = neutral_blend(rng, smile), 0.0, 0.0
if int(t) in events:
blend, dx, dy = events[int(t)](blend, rng)
cx = 0.5 + rng.uniform(-0.005, 0.005) + dx
cy = 0.4 + rng.uniform(-0.005, 0.005) + dy
out.append(FaceSample(t, True, cx, cy, 0.3, blend))
return out
def laugh(blend, rng):
blend |= {"mouthSmileLeft": 0.9, "mouthSmileRight": 0.85, "jawOpen": 0.7}
return blend, 0.0, rng.uniform(-0.02, 0.02)
def scream(blend, rng):
blend |= {"mouthSmileLeft": 0.02, "mouthSmileRight": 0.02, "jawOpen": 0.85}
return blend, 0.0, 0.0
def startle(blend, rng):
blend |= {"eyeWideLeft": 0.8, "eyeWideRight": 0.8, "browInnerUp": 0.7, "browOuterUpLeft": 0.6,
"browOuterUpRight": 0.6}
return blend, rng.choice([-1, 1]) * 0.1, rng.uniform(-0.08, 0.08)
# --- série e sinal ------------------------------------------------------------------------------------------------
def test_per_second_shapes_and_none_without_face():
seconds = per_second(track(10, absent=range(4, 6)), 10)
assert [s.t for s in seconds] == list(range(10))
assert seconds[0].present == 1.0 and 0.0 <= seconds[0].smile <= 0.1 and seconds[0].size == 0.3
assert seconds[4].present == 0.0 and seconds[4].smile is None and seconds[4].cx is None
assert seconds[0].motion is not None and seconds[0].motion < 0.5
def test_json_roundtrip_is_compact_and_rounded():
seconds = per_second(track(5, absent=range(2, 3)), 5)
data = seconds_to_json(seconds)
assert "smile" not in data[2] and data[2]["present"] == 0.0
assert all(len(str(v).split(".")[-1]) <= 3 for d in data for v in d.values() if isinstance(v, float))
back = seconds_from_json(json.loads(json.dumps(data)))
assert back[2].smile is None and abs(back[0].cx - seconds[0].cx) < 1e-3
def test_neutral_with_noise_has_no_peak():
seconds = per_second(track(300, seed=3), 300)
assert reaction_moments(seconds) == []
signal = reaction_signal(seconds)
assert max(v for v in signal if v is not None) < ReactionParams().threshold
def test_laugh_is_a_peak_with_right_label_and_onset():
events = {t: laugh for t in range(200, 205)}
seconds = per_second(track(300, events=events), 300)
moments = reaction_moments(seconds)
assert len(moments) == 1
m = moments[0]
assert m.label == "risada" and 200 <= m.peak_s <= 204
assert m.onset_s == 200 # a reação começa exatamente onde o evento começou
assert m.end_s >= 204 and m.strong
def test_constant_smiling_streamer_is_not_a_false_positive():
# Streamer de "neutro sorridente": o sorriso alto é o normal dele, não reação.
seconds = per_second(track(300, seed=5, smile=0.65), 300)
assert reaction_moments(seconds) == []
# E uma risada de verdade nesse mesmo streamer ainda aparece (pela boca).
events = {t: (lambda b, r: (b | {"jawOpen": 0.7, "mouthSmileLeft": 0.8, "mouthSmileRight": 0.8}, 0.0, 0.0))
for t in range(150, 154)}
moments = reaction_moments(per_second(track(300, seed=5, smile=0.65, events=events), 300))
assert [m.label for m in moments] == ["risada"]
def test_scream_versus_laugh():
events = {t: scream for t in range(100, 103)} | {t: laugh for t in range(200, 203)}
moments = reaction_moments(per_second(track(300, events=events), 300))
assert [(m.label, 100 <= m.peak_s <= 102 or 200 <= m.peak_s <= 202) for m in moments] == [
("grito", True), ("risada", True)]
def test_startle_versus_shock():
still = lambda b, r: (startle(b, r)[0], 0.0, 0.0) # noqa: E731 — olhos/sobrancelha sem pulo da cabeça
events = {t: startle for t in range(100, 102)} | {t: still for t in range(200, 202)}
labels = [m.label for m in reaction_moments(per_second(track(300, events=events), 300))]
assert labels == ["susto", "choque"]
def test_seconds_without_face_are_none_and_never_peak():
# Rosto some exatamente na hora em que haveria uma "risada": não pode virar pico.
events = {t: laugh for t in range(150, 155)}
seconds = per_second(track(300, events=events, absent=range(148, 158)), 300)
signal = reaction_signal(seconds)
assert all(signal[t] is None for t in range(148, 158))
assert reaction_moments(seconds) == []
def test_label_without_z_uses_absolute_thresholds():
s = FaceSecond(0, 1.0, 0.5, 0.4, 0.3, smile=0.8, jaw=0.7, surprise=0.1, frown=0.0, blink=0.1, motion=0.1)
assert label(s) == "risada"
s.smile = 0.0
assert label(s) == "grito"
assert label(FaceSecond(1, 0.0)) == "neutro"
assert label(FaceSecond(2, 1.0, smile=0.0, jaw=0.0, surprise=0.0, frown=0.6, motion=0.0)) == "raiva"
def test_summarize_text_for_the_judge():
events = {t: laugh for t in range(200, 204)} | {t: startle for t in range(215, 217)}
seconds = per_second(track(300, events=events), 300)
text = summarize(seconds, 190, 230)
assert text.startswith("risada forte em 1") and "susto" in text and "; " in text
assert summarize(seconds, 20, 60) == "sem reação marcante no rosto"
gone = per_second(track(100, absent=range(0, 100)), 100)
assert summarize(gone, 0, 50) == "rosto do streamer não aparece no trecho"
# --- câmera -------------------------------------------------------------------------------------------------------
W, H = 1920, 1080
def cam_face(rng: random.Random) -> tuple[float, float, float, float, float]:
"""Rosto da câmera no canto inferior esquerdo, com tremida de poucos pixels."""
return (120 + rng.uniform(-4, 4), 700 + rng.uniform(-4, 4), 110, 130, 0.9)
def inside_unit(rect: dict) -> bool:
return (0 <= rect["x"] <= 1 and 0 <= rect["y"] <= 1 and rect["w"] > 0 and rect["h"] > 0
and rect["x"] + rect["w"] <= 1 + 1e-9 and rect["y"] + rect["h"] <= 1 + 1e-9)
def test_locate_cam_stable_corner():
rng = random.Random(1)
frames = [[cam_face(rng)] for _ in range(12)]
result = locate_cam(frames, W, H)
assert result["hasWebcam"] and not result["fullFrame"] and result["confidence"] > 0.7
cam, face = result["cam"], result["faceRect"]
assert inside_unit(cam) and inside_unit(face)
# O rosto fica dentro do retângulo da câmera, que está no canto inferior esquerdo.
assert cam["x"] <= face["x"] and cam["y"] <= face["y"]
assert face["x"] + face["w"] <= cam["x"] + cam["w"] and face["y"] + face["h"] <= cam["y"] + cam["h"]
assert cam["x"] < 0.1 and cam["y"] > 0.4 and cam["w"] < 0.3
def test_locate_cam_ignores_cutscene_face():
rng = random.Random(2)
frames = [[cam_face(rng)] for _ in range(12)]
frames[3].append((900, 300, 200, 240, 0.95)) # rosto do personagem na cutscene, só em 2 de 12 quadros
frames[4].append((905, 302, 198, 238, 0.95))
result = locate_cam(frames, W, H)
assert result["hasWebcam"] and result["faceRect"]["x"] < 0.1
# Só a cutscene (sem câmera): nada.
only = [[] for _ in range(12)]
only[3], only[4] = [(900, 300, 200, 240, 0.95)], [(905, 302, 198, 238, 0.95)]
assert locate_cam(only, W, H)["hasWebcam"] is False
def test_locate_cam_full_frame():
rng = random.Random(3)
frames = [[(760 + rng.uniform(-10, 10), 250, 420, 520, 0.95)] for _ in range(10)]
result = locate_cam(frames, W, H)
assert result["hasWebcam"] and result["fullFrame"] and result["cam"] == {"x": 0, "y": 0, "w": 1, "h": 1}
def test_locate_cam_no_face():
result = locate_cam([[] for _ in range(12)], W, H)
assert result == {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
assert locate_cam([], W, H)["hasWebcam"] is False
# Detecções fracas (score baixo) não contam.
assert locate_cam([[(120, 700, 110, 130, 0.3)] for _ in range(12)], W, H)["hasWebcam"] is False
def test_locate_cam_rect_clipped_and_snapped_to_frame_edges():
# Rosto colado no canto: a expansão passaria da borda do quadro e precisa ser recortada em 0..1.
frames = [[(10, 950, 110, 120, 0.9)] for _ in range(8)]
result = locate_cam(frames, W, H)
assert inside_unit(result["cam"]) and result["cam"]["x"] == 0
# Com bordas persistentes da moldura, o retângulo encaixa nelas.
rng = random.Random(4)
frames = [[cam_face(rng)] for _ in range(12)]
edges = {"xs": [0.02, 0.2, 0.7], "ys": [0.55, 0.95, 0.1]}
cam = locate_cam(frames, W, H, edges=edges)["cam"]
assert cam == {"x": 0.02, "y": 0.55, "w": 0.18, "h": 0.4}
# --- ajustes da bancada (números reais da sessão 3, doc/FACE_BAKEOFF.md) ------------------------------------------
def real_calm(n: int, seed: int = 7) -> list[FaceSecond]:
"""Neutro como o da live real: sorriso por segundo 0,02–0,25 (mediana ~0,1), boca ~0, olho arregalado ~0."""
rng = random.Random(seed)
return [FaceSecond(t, 1.0, 0.5, 0.4, 0.3, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.01),
surprise=rng.uniform(0.0, 0.004), frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.01, 0.05),
blink=0.1, motion=rng.uniform(0.02, 0.15)) for t in range(n)]
def test_real_calm_with_isolated_spikes_has_no_peak():
# No calmo real houve um segundo com sorriso 0,38 e outro com browInnerUp 0,38: não é reação.
seconds = real_calm(300)
seconds[200].smile = 0.38
seconds[250].brow = 0.38
assert reaction_moments(seconds) == []
def test_laugh_without_open_mouth_is_risada():
# Corte 10/12: sorriso 0,84–0,95 por vários segundos com jawOpen ≤ 0,11.
seconds = real_calm(300)
for t in range(200, 210):
seconds[t].smile, seconds[t].jaw = 0.9, 0.05
moments = reaction_moments(seconds)
assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 200 and moments[0].strong
def test_shout_is_jaw_and_brow_down_without_smile():
# Corte 10, 1628 s: jawOpen 0,42 + browDown forte, sorriso 0,06 naquele segundo.
seconds = real_calm(300)
seconds[200].smile, seconds[200].jaw, seconds[200].frown = 0.06, 0.42, 0.5
seconds[250].frown = 0.6 # franziu de boca fechada
labels = [(m.peak_s, m.label) for m in reaction_moments(seconds)]
assert labels == [(200, "grito"), (250, "raiva")]
def test_confused_brow_inner_up_without_smile():
# Corte 9 (lag): browInnerUp 0,7–0,8 por ~6 s, sorriso baixo, eyeWide ~0.
seconds = real_calm(300)
for t in range(200, 206):
seconds[t].brow = 0.78
moments = reaction_moments(seconds)
assert [m.label for m in moments] == ["confuso"] and moments[0].onset_s == 200
def test_surprise_does_not_need_eye_wide():
# Na live real eyeWide fica ~0: sobrancelha (interna OU externa) levantada é o canal `brow`; parada = confuso,
# com a cabeça se mexendo = susto. Olho arregalado parado continua sendo choque.
blend = {"browOuterUpLeft": 0.7, "browOuterUpRight": 0.7, "eyeWideLeft": 0.0, "eyeWideRight": 0.0}
second = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, blend)], 1)[0]
assert second.brow == pytest.approx(0.7) and second.surprise == 0.0
assert label(second) == "confuso"
second.motion = 0.9
assert label(second) == "susto"
eyes = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, {"eyeWideLeft": 0.8, "eyeWideRight": 0.8})], 1)[0]
assert label(eyes) == "choque"
def test_motion_alone_or_with_flickering_face_is_not_a_peak():
# Rastreio pulando (rosto em 1/3 do segundo) dava "susto" de intensidade 13 na live real.
seconds = real_calm(300)
seconds[200].present, seconds[200].motion, seconds[200].brow = 0.33, 3.0, 0.2
seconds[250].motion = 3.0 # só movimento, rosto inteiro: ajeitou a cadeira
assert reaction_moments(seconds) == []
def test_old_series_without_brow_still_works():
# Série gravada antes do canal `brow`: o canal fica parado, sem quebrar.
data = seconds_to_json(real_calm(60))
for d in data:
d.pop("brow", None)
assert all(v is not None for v in reaction_signal(seconds_from_json(data)))
def test_summarize_absolute_times_for_the_prompt():
seconds = real_calm(300)
for t in range(200, 205):
seconds[t].smile = 0.9
assert summarize(seconds, 190, 230, relative=False).startswith("risada forte em 20")
def test_locate_cam_leaning_streamer_stays_one_group():
# Câmera grande (rosto ~0,16 do quadro): ele se inclina 0,8 largura de rosto em metade dos quadros.
# Com distância fixa em fração do quadro (ou comparando com o 1º membro) o grupo se partia em dois.
rng = random.Random(9)
frames = []
for i in range(12):
lean = 0.8 * 300 if i % 2 else 0
frames.append([(200 + lean + rng.uniform(-4, 4), 600 + rng.uniform(-4, 4), 300, 340, 0.9)])
result = locate_cam(frames, W, H)
assert result["hasWebcam"] and result["confidence"] > 0.5 # partido em dois daria presença 0,5 → ≤ 0,45
face = result["faceRect"]
center = (face["x"] + face["w"] / 2) * W
assert 200 + 150 + 80 < center < 200 + 150 + 160 # média das duas posições (~350 + 120)
def test_locate_cam_frameless_keeps_forehead():
# Câmera sem moldura (streamer recortado sobre o jogo, banner logo abaixo): o retângulo vem do rosto e deixa
# folga acima da testa — a IA cortava a testa (topo em y 0,532 com o rosto começando em 0,504).
fw, fh = 1280, 720
frames = [[(80 + i % 3, 363, 85, 109, 0.92)] for i in range(12)] # rosto da bancada: x 0,066 y 0,504 h 0,152
result = locate_cam(frames, fw, fh)
cam, face = result["cam"], result["faceRect"]
assert face["y"] - cam["y"] >= 0.5 * face["h"] # testa e cabelo dentro
assert cam["y"] + cam["h"] >= face["y"] + face["h"] + face["h"] # ombros/peito abaixo do queixo
# Borda "falsa" logo acima da testa (ex.: banner) não corta a cabeça.
edges = {"xs": [], "ys": [face["y"] - 0.01]}
assert locate_cam(frames, fw, fh, edges=edges)["cam"]["y"] < face["y"] - 0.3 * face["h"]
def test_two_hours_of_series_is_fast():
# channel_z era O(n²): a API e a pontuação recalculam a live inteira. 2 h sintéticas precisam de < 1 s.
import time
seconds = real_calm(7200, seed=3)
for t in range(4000, 4006):
seconds[t].smile = 0.9
started = time.perf_counter()
moments = reaction_moments(seconds)
assert time.perf_counter() - started < 1.0
assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 4000
def test_locate_cam_ignores_static_low_score_object():
"""Teste ao vivo de 17/11 (lofigirl, sem webcam): a tela de um notebook desenhado na borda esquerda saiu como
rosto de 24×34 px com score 0,61–0,66 em 8 de 12 quadros e virou câmera. Webcam real: 0,92–0,94."""
fake = (0.0, 415.0, 24.0, 34.0, 0.63)
frames = [[fake], [fake], [fake, (726.0, 253.0, 73.0, 98.0, 0.604)], [], [fake], [], [fake], [fake],
[(606.0, 254.0, 155.0, 197.0, 0.615)], [fake], [], [fake, (605.0, 257.0, 154.0, 193.0, 0.61)]]
assert locate_cam(frames, 1280, 720)["hasWebcam"] is False
real = [[(109.0 + i % 3, 359.0, 82.0, 112.0, 0.93)] for i in range(12)]
assert locate_cam(real, 1280, 720)["hasWebcam"] is True
+252
View File
@@ -0,0 +1,252 @@
"""Reenquadramento do jogo no tempo (keyframes) e camadas inseridas (pedido do dono, 17/11/2026, corte 61)."""
import shutil
import subprocess
from pathlib import Path
import pytest
from app import editor, editor_render, layout, reframe
from .test_editor import make_project, validate
FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe")
needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
SRC_W, SRC_H = 1280, 720
DOT = (808.0, 308.0) # centro do quadrado branco de 16 px no vídeo de teste
def _project(**over):
base = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, cuts=[{"start": 0, "end": 4, "mode": None}],
overlays=[], captions={"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B",
"words": []},
progress={"enabled": False}, cover={"enabled": False, "t": 1})
base.update(over)
return base
# ---------------------------------------------------------------- interpolação e validação
def test_interpolation_semantics():
keys = [{"t": 1.0, "cx": 0.2, "ease": "linear"}, {"t": 3.0, "cx": 0.6, "ease": "hold"},
{"t": 5.0, "cx": 0.9, "ease": "smooth"}, {"t": 7.0, "cx": 0.1, "ease": "smooth"}]
assert reframe.interp(keys, 0.0, "cx") == 0.2 # antes do 1º: segura
assert reframe.interp(keys, 2.0, "cx") == pytest.approx(0.4) # linear
assert reframe.interp(keys, 4.99, "cx") == 0.6 and reframe.interp(keys, 5.0, "cx") == 0.9 # hold salta no key seguinte
assert reframe.interp(keys, 6.0, "cx") == pytest.approx(0.5) # smooth: meio exato no meio
assert reframe.interp(keys, 6.5, "cx") < 0.9 - 0.8 * 0.75 + 0.05 # smooth acelera no meio (mais que linear)
assert reframe.interp(keys, 9.0, "cx") == 0.1 # depois do último: segura
def test_window_keeps_aspect_and_stays_inside():
keys = [{"t": 0, "cx": 0.98, "cy": 0.02, "w": 0.4, "ease": "smooth"}]
x, y, w, h = reframe.window(keys, 0, SRC_W, SRC_H, 1080 / 1268)
assert w / h == pytest.approx(1080 / 1268) and x + w <= SRC_W + 1e-6 and y >= 0 and x >= 0
big = [{"t": 0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"}]
x, y, w, h = reframe.window(big, 0, SRC_W, SRC_H, 1080 / 1920) # zoom que não cabe: encolhe, não deforma
assert h == pytest.approx(SRC_H) and w == pytest.approx(SRC_H * 1080 / 1920)
def test_validation(tmp_path):
keys = [{"t": 3, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1, "cx": 0.2, "cy": 0.3, "w": 1, "ease": "hold"}]
p = validate(_project(reframe={"keys": keys}), tmp_path)
assert [k["t"] for k in p["reframe"]["keys"]] == [1, 3] and p["reframe"]["keys"][1]["ease"] == "smooth"
assert "reframe" not in validate(_project(), tmp_path) and "reframe" not in validate(_project(reframe={"keys": []}), tmp_path)
inset = {"id": "i", "kind": "inset", "start": 1, "end": 3, "src": {"x": 0.7, "y": 0.0, "w": 0.3, "h": 0.25},
"x": 0.5, "y": 0.3, "size": 0.5, "border": "#ffffff"}
q = validate(_project(overlays=[inset]), tmp_path)["overlays"][0]
assert q["border"] == "#FFFFFF" and q["borderW"] == 6 and q["radius"] == 18 and q["shadow"] is True and q["keys"] == []
bad = [
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.01}]}},
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5, "ease": "bounce"}]}},
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1.01, "cx": 0.5, "cy": 0.5, "w": 0.5}]}},
{"reframe": {"keys": [{"t": 1 + i * 0.05, "cx": 0.5, "cy": 0.5, "w": 0.5} for i in range(61)]}},
{"overlays": [{**inset, "src": {"x": 0.9, "y": 0, "w": 0.3, "h": 0.2}}]}, # fora do quadro
{"overlays": [{**inset, "size": 0.05}]},
{"overlays": [{**inset, "anim": "spin"}]},
{"overlays": [{**inset, "src": None}]},
{"overlays": [{**inset, "id": f"i{n}"} for n in range(13)]}, # mais de 12 camadas
]
for change in bad:
with pytest.raises(editor.EditError):
validate(_project(**change), tmp_path)
def test_old_project_graph_unchanged_and_inset_not_in_ass(tmp_path):
p = validate(make_project(), tmp_path)
cfg = editor.effective_settings(layout.merge(), p)
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
assert "perspective" not in graph and "[vraw]" not in graph and "split=2[tl" not in graph
inset = {"id": "i", "kind": "inset", "start": 11, "end": 13, "src": {"x": 0, "y": 0, "w": 0.3, "h": 0.3}}
q = validate(make_project(overlays=[inset]), tmp_path)
assert "Dialogue: 2" not in editor_render.build_project_ass(q, cfg, "")
# ---------------------------------------------------------------- render real
@pytest.fixture(scope="module")
def dot_video(tmp_path_factory):
if not FFMPEG:
pytest.skip("FFmpeg não instalado")
folder = tmp_path_factory.mktemp("reframe")
seg = folder / "dot.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0x101010:s={SRC_W}x{SRC_H}:r=30:d=8",
"-f", "lavfi", "-i", "sine=frequency=440:duration=8",
"-vf", "drawbox=x=800:y=300:w=16:h=16:color=white:t=fill", "-c:v", "libx264", "-preset", "ultrafast",
"-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
return seg
def _frames(video: Path, size: tuple[int, int]):
import numpy as np
raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(video), "-f", "rawvideo", "-pix_fmt", "gray", "-"],
capture_output=True, check=True).stdout
return np.frombuffer(raw, np.uint8).reshape(-1, size[1], size[0]).astype(float)
def _centroid(frame):
import numpy as np
m = np.where(frame > 128, frame, 0)
s = m.sum()
if not s:
return None
ys, xs = np.mgrid[0:frame.shape[0], 0:frame.shape[1]]
return (m * xs).sum() / s, (m * ys).sum() / s
def _expected(keys, t, dest):
x, y, w, h = reframe.window(keys, t, SRC_W, SRC_H, dest[0] / dest[1])
return (DOT[0] - x) / w * dest[0], (DOT[1] - y) / h * dest[1]
def _render(tmp_path, video, project, settings=None, name="out.mp4"):
p = validate(project, tmp_path, duration=8.0)
out = tmp_path / name
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "12"],
[(video, 0.0, 8.0)], p, layout.merge(settings or {}), "", out, tmp_path)
return p, out
@needs_ffmpeg
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_reframe_window_follows_keys_smoothly(tmp_path, dot_video, aspect):
keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"},
{"t": 2.0, "cx": 0.62, "cy": 0.42, "w": 0.3, "ease": "hold"},
{"t": 3.0, "cx": 0.66, "cy": 0.45, "w": 0.45, "ease": "linear"}]
settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only"}}
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings))
size = layout.FRAME_SIZES[aspect]
frames = _frames(out, size)
for n in (0, 15, 30, 45, 60, 75, 89, 91, 105): # quadro n = sessão n/30 (um trecho só)
got = _centroid(frames[n])
want = _expected(keys, n / 30, size)
assert got and abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (n, got, want)
xs = [_centroid(f)[0] for f in frames[1:60]]
steps = [b - a for a, b in zip(xs, xs[1:])]
assert all(s <= 0.05 for s in steps) or all(s >= -0.05 for s in steps) # sempre no mesmo sentido: sem tremida
jump_before, jump_after = _centroid(frames[89]), _centroid(frames[91]) # hold: salta no key de 3,0 s
assert abs(jump_after[0] - jump_before[0]) > 20
@needs_ffmpeg
def test_reframe_uses_session_time_across_cuts(tmp_path, dot_video):
keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "linear"}, {"t": 6.0, "cx": 0.66, "cy": 0.45, "w": 0.35}]
cuts = [{"start": 0.0, "end": 1.5, "mode": None}, {"start": 3.0, "end": 5.0, "mode": None}]
settings = {"layout": {"mode": "game_only"}}
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, cuts=cuts, settings=settings))
frames = _frames(out, (1080, 1920))
for out_t, session_t in ((0.5, 0.5), (2.0, 3.5), (3.0, 4.5)):
got, want = _centroid(frames[int(out_t * 30)]), _expected(keys, session_t, (1080, 1920))
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (out_t, got, want)
@needs_ffmpeg
def test_reframe_in_cam_top_uses_game_area_and_cover(tmp_path, dot_video):
keys = [{"t": 0.0, "cx": 0.62, "cy": 0.42, "w": 0.3}]
settings = {"layout": {"mode": "cam_top", "cam": {"x": 0.0, "y": 0.0, "w": 0.2, "h": 0.25}}}
p, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings))
top = layout.cam_panel_height(layout.merge(settings))
got = _centroid(_frames(out, (1080, 1920))[10][top:])
want = _expected(keys, 0, (1080, 1920 - top))
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4
cover = editor_render.render_cover(FFMPEG, [(dot_video, 0.0, 8.0)], {**p, "cover": {**p["cover"], "t": 1.0}},
layout.merge(settings), "", tmp_path / "cover.jpg")
assert cover.is_file()
@pytest.fixture(scope="module")
def color_video(tmp_path_factory):
if not FFMPEG:
pytest.skip("FFmpeg não instalado")
folder = tmp_path_factory.mktemp("insets")
seg = folder / "colors.ts"
boxes = ("drawbox=x=0:y=0:w=300:h=200:color=0x00FF00:t=fill,"
"drawbox=x=900:y=500:w=380:h=220:color=0x0000FF:t=fill")
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0xFF0000:s={SRC_W}x{SRC_H}:r=30:d=8",
"-f", "lavfi", "-i", "sine=frequency=440:duration=8", "-vf", boxes, "-c:v", "libx264",
"-preset", "ultrafast", "-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
return seg
def _rgb(video: Path, t: float, size: tuple[int, int]):
import numpy as np
raw = subprocess.run([FFMPEG, "-v", "error", "-ss", f"{t:.3f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
"-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout
return np.frombuffer(raw, np.uint8).reshape(size[1], size[0], 3).astype(int)
def _is(px, color, tol=60):
return all(abs(int(a) - b) < tol for a, b in zip(px, color))
@needs_ffmpeg
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_two_overlapping_insets_with_border_and_anim(tmp_path, color_video, aspect):
green = {"id": "g", "kind": "inset", "start": 0.5, "end": 3.5, "src": {"x": 0.0, "y": 0.0, "w": 0.2344, "h": 0.2778},
"x": 0.25, "y": 0.25, "size": 0.4, "border": "#FFFFFF", "borderW": 8, "radius": 20, "shadow": True, "anim": "fade"}
blue = {"id": "b", "kind": "inset", "start": 1.0, "end": 3.5, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056},
"x": 0.45, "y": 0.35, "size": 0.4, "border": "#FFFF00", "borderW": 8, "radius": 0, "shadow": False, "anim": "pop"}
settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}}
_, out = _render(tmp_path, color_video, _project(overlays=[green, blue], settings=settings))
w, h = size = layout.FRAME_SIZES[aspect]
frame = _rgb(out, 2.0, size)
gx, gy = int(0.25 * w), int(0.25 * h)
gw = 0.4 * w
gh = gw * (0.2778 * SRC_H) / (0.2344 * SRC_W)
bw = 0.4 * w
bh = bw * (0.3056 * SRC_H) / (0.2969 * SRC_W)
bx0, by0 = 0.45 * w - bw / 2, 0.35 * h - bh / 2
assert _is(frame[gy, int(gx - gw / 2 + 12)], (0, 255, 0)) # camada verde (dentro, longe da azul)
assert _is(frame[gy, int(gx - gw / 2 - 3)], (255, 255, 255)) # borda branca do lado de fora
assert _is(frame[int(by0 + bh / 2), int(0.45 * w)], (0, 0, 255)) # camada azul
ox, oy = int(bx0 + 15), int(by0 + 15) # canto da azul que cai em cima da verde: a azul (última) fica por cima
assert gx - gw / 2 < ox < gx + gw / 2 and gy - gh / 2 < oy < gy + gh / 2
assert _is(frame[oy, ox], (0, 0, 255))
assert _is(frame[int(0.9 * h), int(0.9 * w)], (255, 0, 0)) # fora das camadas: o jogo (vermelho)
early = _rgb(out, 0.56, size)[gy, int(gx - gw / 2 + 12)] # fade: no começo a verde ainda está entrando
assert not _is(early, (0, 255, 0), tol=30)
assert _is(_rgb(out, 3.8, size)[gy, gx], (255, 0, 0)) # depois do fim: some
@needs_ffmpeg
def test_inset_keys_move_it_in_session_time(tmp_path, color_video):
blue = {"id": "b", "kind": "inset", "start": 0.0, "end": 6.0, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056},
"x": 0.3, "y": 0.5, "size": 0.3, "border": None, "shadow": False, "anim": "none",
"keys": [{"t": 1.0, "x": 0.3, "y": 0.5, "size": 0.3, "ease": "linear"}, {"t": 5.0, "x": 0.7, "y": 0.5, "size": 0.3}]}
cuts = [{"start": 0.0, "end": 2.0, "mode": None}, {"start": 3.0, "end": 6.0, "mode": None}]
settings = {"layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}}
_, out = _render(tmp_path, color_video, _project(overlays=[blue], cuts=cuts, settings=settings))
frame = _rgb(out, 2.0, (1080, 1920)) # saída 2,0 s = sessão 3,0 s → x = 0,3 + 0,4 × (2/4) = 0,5
assert _is(frame[960, 540], (0, 0, 255)) and _is(frame[960, int(0.3 * 1080) - 120], (255, 0, 0))
@needs_ffmpeg
def test_sixty_keys_render_through_graph_file(tmp_path, dot_video):
"""60 keyframes num trecho: o grafo passa do limite da linha de comando e vai por arquivo (-/filter_complex)."""
keys = [{"t": i * 0.06, "cx": 0.5 + 0.1 * (i % 2), "cy": 0.5, "w": 0.4 + 0.3 * (i % 3) / 2, "ease": "linear"}
for i in range(60)]
p = validate(_project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}}), tmp_path, duration=8.0)
graph = editor_render.build_filter(p, editor.effective_settings(layout.merge(), p), editor.pieces(p["cuts"]), 0.0,
None, [])
assert len(graph) > 20000
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}}))
got, want = _centroid(_frames(out, (1080, 1920))[100]), _expected(keys, 100 / 30, (1080, 1920))
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4
assert not list(tmp_path.glob("*.graph.txt")) # arquivo temporário apagado
+190
View File
@@ -0,0 +1,190 @@
"""Bugs de produção de 16–17/11/2026 (sessão 3 do skipnho):
1. corte preso em 'rendering' quando o render levantava uma exceção não prevista (KeyError da legenda);
2. o mesmo momento virando vários cortes (pico 1149 → cortes 42, 47, 49, 51, 52 em cima do 9, já pronto)."""
import json
from datetime import datetime, timedelta, timezone
from pathlib import Path
import app.editor_api as editor_api
import app.worker as worker_module
from app.judge import Judge, Verdict
from app.scoring import Moment
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
class RecuoJudge(Judge):
"""Juiz falso (nunca chama a CLI): mantém e recua o início para `back_to`, como o juiz real fez no corte 42."""
def __init__(self, back_to: float | None = None):
super().__init__("codex", "fake", Path("."))
self.back_to = back_to
def analyze(self, prompt, images):
return {"situation": "lag_ou_bug", "confidence": 0.9, "action_start_s": 0, "reaction_end_s": 0, "hook": ""}
def judge(self, prompt, start_s, end_s, images=None, **_limits):
start = self.back_to if self.back_to is not None else start_s
return Verdict(True, 8.0, start, end_s, "O lag colocou ele em três lugares", "legenda", "motivo", "fake")
def add_clip(engine, sid, cid, status, peak, start, end, source="chat", reasons=None):
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, reasons_json, status, title, "
"created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, ?, ?, ?, 't', 'x', ?)",
cid, sid, peak, start, end, source, json.dumps(reasons or {}), status, worker_module.now())
def status(engine, cid):
return engine.db.get("SELECT status FROM clips WHERE id = ?", cid)["status"]
# ---------------------------------------------------------------- bug 1: render
def test_render_that_explodes_becomes_error_and_next_clip_runs(env, monkeypatch): # noqa: F811
_client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_clip(engine, sid, 1, "pending", 100, 90, 120)
add_clip(engine, sid, 2, "pending", 300, 290, 320)
def ensure_edit(eng, clip, session):
if clip["id"] == 1:
raise KeyError(2413111138480) # o erro medido na versão intermediária da legenda
return {"project": {}}
monkeypatch.setattr(editor_api, "ensure_edit", ensure_edit)
monkeypatch.setattr(editor_api, "render_clip_edit", lambda *a, **k: None)
engine.render_pending()
first = engine.db.get("SELECT status, error FROM clips WHERE id = 1")
assert first["status"] == "error" and "KeyError" in first["error"]
assert status(engine, 2) == "ready" and engine._rendering == set()
def test_orphan_rendering_goes_back_to_queue_then_error(env, monkeypatch): # noqa: F811
_client, engine = env
sid = seed_session(engine)
old = (datetime.now(timezone.utc) - timedelta(minutes=10)).isoformat(timespec="seconds")
add_clip(engine, sid, 1, "rendering", 100, 90, 120)
add_clip(engine, sid, 2, "rendering", 300, 290, 320) # recente: pode estar renderizando ainda
add_clip(engine, sid, 3, "rendering", 500, 490, 520)
engine.db.run("UPDATE clips SET updated_at = ? WHERE id IN (1, 3)", old)
engine._rendering.add(3) # este processo está renderizando o 3 agora
engine.recover_orphan_renders()
assert [status(engine, c) for c in (1, 2, 3)] == ["pending", "rendering", "rendering"]
for _ in range(worker_module.MAX_RENDER_ATTEMPTS - 1):
engine.db.run("UPDATE clips SET status = 'rendering', updated_at = ? WHERE id = 1", old)
engine.recover_orphan_renders()
assert status(engine, 1) == "error"
# ---------------------------------------------------------------- bug 2: duplicados
def test_judge_backtrack_onto_ready_clip_is_discarded_as_duplicate(env): # noqa: F811
_client, engine = env
sid = seed_session(engine, duration=1300)
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
engine.judge = RecuoJudge(back_to=1012)
add_clip(engine, sid, 42, "candidate", 1149, 1095, 1155)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 42"))
row = engine.db.get("SELECT status, start_s, judge_json FROM clips WHERE id = 42")
judge = json.loads(row["judge_json"])
assert row["status"] == "discarded" and judge["duplicateOf"] == 9 and "Duplicado do corte 9" in judge["reason"]
# "cortar agora" nunca é bloqueado: só avisa
add_clip(engine, sid, 43, "candidate", 1080, 1040, 1100, source="manual")
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 43"))
manual = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 43")
assert manual["status"] == "pending" and json.loads(manual["judge_json"])["warning"] == "mesmo momento do corte 9"
def test_repeated_passes_never_recreate_the_same_peak(env, monkeypatch): # noqa: F811
_client, engine = env
sid = seed_session(engine, duration=1300)
engine.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ?", sid)
moment = Moment(peak_s=1149.0, start_s=1095.0, end_s=1155.0, score=5.0, source="chat", reasons={"onsetS": 1142})
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [moment])
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
assert json.loads(clip["reasons_json"])["candidateStartS"] == 1095.0 # janela original guardada
# O juiz recuou o corte para 1012–1100: o candidato do mesmo pico já não sobrepõe o trecho final…
engine.db.run("UPDATE clips SET start_s = 1012, end_s = 1100, status = 'discarded' WHERE id = ?", clip["id"])
for _ in range(3): # …mas passadas seguidas não recriam (nem com o corte descartado)
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
assert engine.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ?", sid)["n"] == 1
# Corte antigo sem janela guardada: o pico igual também bloqueia.
engine.db.run("UPDATE clips SET reasons_json = '{}' WHERE id = ?", clip["id"])
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
def test_startup_queue_drops_pending_duplicates(env): # noqa: F811
"""Caso real da sessão 3: 42, 47, 51 e 52 (pico 1149, recuados para 1012–1100) em cima do 9, pronto."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
for cid, start, end in ((42, 1012.2, 1099.68), (47, 1012.2, 1099.68), (51, 1012.86, 1099.68), (52, 1012.86, 1102.86)):
add_clip(engine, sid, cid, "pending", 1149, start, end)
add_clip(engine, sid, 53, "pending", 7850, 7793.484, 7860.114) # momento próprio (o 54 parecido foi descartado)
add_clip(engine, sid, 54, "discarded", 7928, 7792.57, 7852.57)
add_clip(engine, sid, 70, "pending", 1150, 1012, 1100, source="manual") # seu: nunca sai da fila
dropped = engine.discard_pending_duplicates()
assert sorted(dropped) == [(42, 9), (47, 9), (51, 9), (52, 9)]
assert status(engine, 53) == "pending" and status(engine, 70) == "pending"
assert json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = 47")["judge_json"])["duplicateOf"] == 9
def test_same_moment_rule():
a = {"peak_s": 1084, "start_s": 1045, "end_s": 1100}
assert worker_module.same_moment(a, {"peak_s": 1149, "start_s": 1012, "end_s": 1100}) # cobre 100 % do 9
assert worker_module.same_moment(a, {"peak_s": 1090, "start_s": 1200, "end_s": 1260}) # mesmo pico
# momentos vizinhos de 60–90 s que só encostam não são duplicados
assert not worker_module.same_moment({"peak_s": 1221, "start_s": 1184, "end_s": 1239},
{"peak_s": 1287, "start_s": 1253, "end_s": 1308})
assert not worker_module.same_moment({"peak_s": 100, "start_s": 40, "end_s": 130},
{"peak_s": 170, "start_s": 100, "end_s": 190}) # 30 s de 90 s = 33 %
# ---------------------------------------------------------------- 17/11/2026: "não está gerando os clipes"
def test_rejected_moment_vetoes_judge_backtrack(env): # noqa: F811
"""Caso 61/64 da sessão 3: o juiz recua o candidato (pico 8909) para a cena de um corte que você rejeitou."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
add_clip(engine, sid, 64, "candidate", 8909, 8878.0, 8939.1)
engine.judge = RecuoJudge(back_to=8790)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 64"))
row = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 64")
judge = json.loads(row["judge_json"])
assert row["status"] == "discarded" and judge["duplicateOf"] == 61 and "que você rejeitou" in judge["reason"]
# descartado pela IA NÃO veta o trecho final de outro momento (só o candidato do mesmo pico)
engine.db.run("UPDATE clips SET status = 'discarded' WHERE id = 61")
add_clip(engine, sid, 65, "candidate", 8909, 8878.0, 8939.1)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 65"))
assert status(engine, 65) == "pending"
def test_scan_memory_records_proposals_and_created(env): # noqa: F811
from .test_intel import ScanJudge
_client, engine = env
engine.judge = ScanJudge() # 2 propostas: nota 8 (vira candidato) e nota 3 (barrada)
engine.intel.opts["vision"] = False
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
assert engine.intel.scan_session(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
memory = json.loads(engine.db.get("SELECT memory_json FROM sessions WHERE id = ?", sid)["memory_json"])
assert memory[-1]["proposals"] == 2 and memory[-1]["created"] == 1 and memory[-1]["summary"] == "tiroteio na base"
def test_queue_cleanup_uses_the_same_veto_as_the_judge(env): # noqa: F811
"""Fila antes do render: pendente igual a rejeitado ou a apagado-que-estava-pronto sai; igual a descartado pela IA
fica; manual nunca sai."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
add_clip(engine, sid, 70, "pending", 8820, 8790.0, 8858.0) # = rejeitado
add_clip(engine, sid, 71, "discarded", 5000, 4970.0, 5030.0)
add_clip(engine, sid, 72, "pending", 5004, 4968.0, 5032.0) # = descartado pela IA: fica
engine.db.run("INSERT INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, status, source, deleted_at)"
" VALUES (80, ?, 3000, 2970, 3040, 'ready', 'chat', 'x')", sid)
add_clip(engine, sid, 73, "pending", 3002, 2968.0, 3038.0) # = apagado que estava pronto
add_clip(engine, sid, 74, "pending", 8818, 8790.0, 8850.0, source="manual") # manual: nunca sai
assert sorted(engine.discard_pending_duplicates()) == [(70, 61), (73, 80)]
reasons = {cid: json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = ?", cid)["judge_json"])["reason"]
for cid in (70, 73)}
assert "que você rejeitou" in reasons[70] and "que você apagou" in reasons[73]
assert status(engine, 72) == "pending" and status(engine, 74) == "pending"
+166
View File
@@ -0,0 +1,166 @@
"""Retomada de live depois de reinício ou de queda da captura (bug de 16/11/2026, sessão 3 do skipnho): a 1ª
checagem logo depois do reinício falhou e a live, que estava no ar, foi direto para o processamento."""
import subprocess
from types import SimpleNamespace
import pytest
import app.worker as worker_module
from app.worker import LiveCheck
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
class FakeCapture:
started: list[int] = []
def __init__(self, eng, session_id, source, workdir, start_idx=0):
FakeCapture.started.append(start_idx)
self.chat = None
def start(self):
pass
@pytest.fixture
def live(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
engine.resume_delays = (0.0,) * 7
FakeCapture.started = []
monkeypatch.setattr(worker_module, "Capture", FakeCapture)
return engine, sid
def scripted(engine, results):
calls = []
def check(url):
calls.append(url)
return results[min(len(calls), len(results)) - 1]
engine.live_check = check
return calls
def status(engine, sid):
return engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"]
def test_startup_resume_retries_until_the_check_works(live):
engine, sid = live
unknown = LiveCheck("unknown", reason="streamlink --json passou de 60 s")
calls = scripted(engine, [unknown, unknown, unknown, LiveCheck("live", {"title": "t"})])
engine.resume_interrupted([sid])
assert len(calls) == 4 and FakeCapture.started == [20] # retomou na mesma sessão, continuando a numeração
assert status(engine, sid) == "starting" # gravando de novo, não processando
def test_startup_resume_gives_up_only_after_all_attempts(live):
engine, sid = live
calls = scripted(engine, [LiveCheck("unknown", reason="erro")])
seen = []
original = engine.live_check
def check(url):
seen.append(status(engine, sid)) # enquanto tenta, a sessão continua 'interrupted'
return original(url)
engine.live_check = check
engine.resume_interrupted([sid])
assert len(calls) == len(engine.resume_delays) and set(seen) == {"interrupted"}
assert FakeCapture.started == [] and status(engine, sid) == "processing"
def test_offline_confirmed_twice_finishes_early(live):
engine, sid = live
calls = scripted(engine, [LiveCheck("offline", reason="No playable streams")])
engine.resume_interrupted([sid])
assert len(calls) == 2 and status(engine, sid) == "processing"
# "offline" isolado entre falhas de checagem não conta como confirmação
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
off, unk = LiveCheck("offline"), LiveCheck("unknown")
calls = scripted(engine, [off, unk, off, unk, off, unk, off])
engine.resume_interrupted([sid])
assert len(calls) == 7
def test_owner_action_in_the_middle_wins(live):
engine, sid = live
def check(url):
engine.db.run("UPDATE sessions SET status = 'processing' WHERE id = ?", sid) # você clicou "Processar"
return LiveCheck("live", {"title": "t"})
engine.live_check = check
assert engine.keep_live(sid, "teste") is False
assert FakeCapture.started == [] and status(engine, sid) == "processing"
def test_capture_drop_mid_live_reconnects(live):
engine, sid = live
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
scripted(engine, [LiveCheck("unknown"), LiveCheck("live", {"title": "t"})])
started = []
engine.keep_live = lambda session_id, why: started.append(why) # a thread chamaria keep_live
engine.capture_dropped(sid, got_video=True)
import time
for _ in range(50):
if started:
break
time.sleep(0.02)
assert status(engine, sid) == "interrupted" and started == ["captura caiu"]
# Retomadas seguidas sem nenhum bloco novo: desiste depois de MAX_EMPTY_RESUMES e processa.
for _ in range(worker_module.MAX_EMPTY_RESUMES):
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
engine.capture_dropped(sid, got_video=False)
assert status(engine, sid) == "processing"
def _fake_run(monkeypatch, stdout=b"", stderr=b"", code=0, exc=None):
def run(*_args, **_kwargs):
if exc:
raise exc
return SimpleNamespace(stdout=stdout, stderr=stderr, returncode=code)
monkeypatch.setattr(worker_module.subprocess, "run", run)
@pytest.mark.parametrize("kwargs,state", [
({"stdout": b'{"streams": {"best": {}}, "metadata": {"title": "oi", "category": "GTA"}}'}, "live"),
({"stdout": b'{"error": "No playable streams found on this URL: https://www.twitch.tv/x"}', "code": 1}, "offline"),
({"exc": subprocess.TimeoutExpired("streamlink", 60)}, "unknown"),
({"exc": OSError("não achou")}, "unknown"),
({"stdout": b"<html>erro</html>", "stderr": b"error: rede", "code": 1}, "unknown"),
({"stdout": b'{"error": "Unable to open URL: https://gql.twitch.tv (503 Server Error)"}', "code": 1}, "unknown"),
])
def test_live_check_tells_offline_from_check_failure(env, monkeypatch, caplog, kwargs, state): # noqa: F811
_client, engine = env
from dataclasses import replace
engine.settings = replace(engine.settings, streamlink="streamlink")
_fake_run(monkeypatch, **kwargs)
result = engine.live_check("https://www.twitch.tv/x")
assert result.state == state
if state == "live":
assert result.meta["category"] == "GTA" and engine.check_live("u") == (True, "oi")
else:
assert engine.check_meta("u") is None # quem só quer saber "está ao vivo?" continua recebendo None
if state == "unknown":
assert "checagem da live" in caplog.text and result.reason # motivo registrado no log
@pytest.mark.skipif(not __import__("shutil").which("ffmpeg"), reason="FFmpeg não instalado")
def test_capture_that_stops_by_itself_goes_to_reconnect(env, tmp_path, monkeypatch): # noqa: F811
"""Captura de live que para sem stop() (aqui o "streamlink" sai na hora) não processa direto: vai para a
retomada com novas tentativas."""
import shutil
import sys
from dataclasses import replace
from app.sources import parse_source
_client, engine = env
sid = seed_session(engine)
engine.settings = replace(engine.settings, streamlink=sys.executable, ffmpeg=shutil.which("ffmpeg"))
dropped = []
monkeypatch.setattr(engine, "capture_dropped", lambda session_id, got_video: dropped.append((session_id, got_video)))
capture = worker_module.Capture(engine, sid, parse_source("https://www.twitch.tv/alanzoka"), tmp_path / "cap", start_idx=20)
capture.thread.start() # sem o chat (não abre conexão)
capture.thread.join(timeout=60)
assert dropped == [(sid, False)]
+196
View File
@@ -0,0 +1,196 @@
import random
from app.scoring import ChatMessage, Params, Word, find_moments, message_weight, overlaps, snap_to_words
from app.subtitles import build_ass, group_words
def calm_chat(duration: int, rate: float = 3.0, seed: int = 1) -> list[ChatMessage]:
rng = random.Random(seed)
out = []
for t in range(duration):
for _ in range(int(rate) + (1 if rng.random() < rate % 1 else 0)):
out.append(ChatMessage(t + rng.random(), rng.choice(["oi", "salve", "boa noite", "eae", "kappa"])))
return out
def burst(at: int, seconds: int, per_s: int, text: str) -> list[ChatMessage]:
return [ChatMessage(at + s + i / per_s, text) for s in range(seconds) for i in range(per_s)]
def test_message_weight_counts_reactions():
assert message_weight("oi")[0] == 1.0
weight, tags = message_weight("KKKKKKK clipa isso")
assert "risada" in tags and "clip" in tags and weight == 5.0
def test_finds_peak_after_the_event_and_cuts_before_it():
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
moments = find_moments(600, chat, [], [])
assert len(moments) == 1
m = moments[0]
assert 300 <= m.peak_s <= 310
assert m.start_s < 300 - 5 # o corte começa ANTES da reação (é ali que aconteceu)
assert m.end_s >= m.peak_s
assert Params().min_s <= m.end_s - m.start_s <= Params().max_s
assert m.source == "chat" and m.reasons["tags"].get("risada")
def test_big_chat_needs_relative_peak():
# Chat enorme o tempo todo (canal grande) não vira corte sem um pico relativo.
assert find_moments(600, calm_chat(600, rate=40), [], []) == []
def test_two_peaks_far_apart_both_found_and_close_ones_merged():
chat = calm_chat(900) + burst(200, 6, 25, "caralho") + burst(215, 4, 25, "kkkkk") + burst(600, 6, 25, "POGGERS")
peaks = [m.peak_s for m in find_moments(900, chat, [], [])]
assert len(peaks) == 2
assert 195 <= peaks[0] <= 225 and 595 <= peaks[1] <= 610
def test_live_mode_waits_for_settle():
chat = calm_chat(316) + burst(300, 8, 25, "KKKK")
assert find_moments(316, chat, [], [], live=True) == [] # pico perto demais do fim da gravação
chat = calm_chat(400) + burst(300, 8, 25, "KKKK")
assert len(find_moments(400, chat, [], [], live=True)) == 1
def test_live_mode_does_not_cut_a_burst_that_is_still_growing():
# Explosão começa em 300 e só atinge o máximo em 312; com 326 s gravados o máximo ainda não assentou,
# e o começo da explosão (já "assentado") não pode virar corte sozinho.
chat = calm_chat(326) + burst(300, 6, 10, "kkk") + burst(306, 8, 40, "KKKKKKK")
assert find_moments(326, chat, [], [], live=True) == []
def test_audio_mode_without_chat():
loud = [-40.0] * 600
for t in range(400, 406):
loud[t] = -8.0
moments = find_moments(600, [], loud, [])
assert len(moments) == 1 and moments[0].source == "audio" and 395 <= moments[0].peak_s <= 410
def test_snap_to_words_avoids_cutting_mid_sentence():
words = [Word(10.0, 10.4, "olha"), Word(10.5, 10.9, "isso"), Word(12.0, 12.3, "não"), Word(12.35, 12.8, "acredito"),
Word(20.0, 20.5, "mano")]
start, end = snap_to_words(12.2, 12.5, words)
assert start <= 12.0 and end >= 12.8
def test_overlaps():
assert overlaps(0, 30, 20, 50)
assert not overlaps(0, 30, 27, 60) # tolerância de 5 s
def test_ass_groups_words_and_escapes_tags():
words = [Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "{isso}"), Word(1.7, 2.0, "aqui"), Word(5.0, 5.4, "gente")]
groups = group_words(words)
assert [len(g) for g in groups] == [3, 1]
ass = build_ass(words, 0.5, 6.0, "twitch.tv/alanzoka")
assert "Credit" in ass and "twitch.tv/alanzoka" in ass
assert "{isso}" not in ass and "(ISSO)" in ass # chave do texto falado não vira tag ASS
assert "0:00:00.50" in ass # "olha" em 1.0 s da sessão = 0.5 s do corte
def test_params_default_follows_cut_settings_defaults():
# Pedido do dono (16/11/2026): cortes de 60 a 90 s por padrão — a heurística segue a configuração do corte.
from app.layout import DEFAULTS
assert (Params().min_s, Params().max_s) == (DEFAULTS["duration"]["minS"], DEFAULTS["duration"]["maxS"]) == (60, 90)
def test_regression_calm_chat_has_no_false_positives():
# Medido na live real (16/11/2026): ~0,6 msg/s, 3 mensagens com um emote "clip5k1hmm" viravam corte,
# e o começo da gravação também.
chat = calm_chat(180, rate=0.6)
chat += [ChatMessage(100.2, "l i b e r t e s é!"), ChatMessage(100.5, "clip5k1hmm"), ChatMessage(101.0, "ff")]
chat += [ChatMessage(3 + i * 0.3, "130") for i in range(5)]
assert message_weight("clip5k1hmm")[0] == 1.0
assert message_weight("CLIP IT")[1] == ["clip"]
assert find_moments(180, chat, [], []) == []
def test_ass_keeps_tags_lowercase_when_uppercasing_text():
ass = build_ass([Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "isso")], 0.0, 5.0, "")
assert r"{\c&H00E5FF&}OLHA{\c&HFFFFFF&} ISSO" in ass and r"\C&" not in ass
def test_regression_sparse_chat_still_finds_reactions():
# Medido em 17/11/2026 (skipnho): 0,15 msg/s; reação de 6 mensagens em 8 s nunca passava do mínimo fixo de 12.
chat = calm_chat(900, rate=0.15, seed=3)
chat += [ChatMessage(500 + i, t) for i, t in enumerate(["KKKKKK", "kkkkkkk", "caralho", "KKKKK", "que isso", "kkkk"])]
moments = [m for m in find_moments(900, chat, [], []) if m.source == "chat"]
assert len(moments) == 1 and 495 <= moments[0].peak_s <= 510
def test_sparse_chat_also_uses_audio():
chat = calm_chat(600, rate=0.15, seed=4)
loud = [-40.0] * 600
for t in range(300, 306):
loud[t] = -6.0
moments = find_moments(600, chat, loud, [])
assert any(m.source == "audio" and 295 <= m.peak_s <= 312 for m in moments)
# ---------------------------------------------------------------- rosto do streamer (reaction.py)
from app.reaction import FaceSecond # noqa: E402
def calm_face(n: int, seed: int = 11) -> list[FaceSecond]:
rng = random.Random(seed)
return [FaceSecond(t, 1.0, 0.1, 0.5, 0.15, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.01),
surprise=0.002, frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.01, 0.05), blink=0.1,
motion=rng.uniform(0.02, 0.15)) for t in range(n)]
def laugh_at(face: list[FaceSecond], start: int, seconds: int = 6) -> list[FaceSecond]:
for t in range(start, start + seconds):
face[t].smile = 0.9
return face
def noisy_loudness(n: int, seed: int = 2) -> list[float]:
rng = random.Random(seed)
return [-30.0 + rng.uniform(-1.5, 1.5) for _ in range(n)]
def test_face_none_or_empty_keeps_old_behavior():
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
loud = noisy_loudness(600)
base = find_moments(600, chat, loud, [])
for face in (None, [], [FaceSecond(t) for t in range(600)]): # sem rosto em nenhum segundo
again = find_moments(600, chat, loud, [], face=face)
assert [(m.peak_s, m.start_s, m.end_s, m.score, m.source, m.reasons) for m in again] == \
[(m.peak_s, m.start_s, m.end_s, m.score, m.source, m.reasons) for m in base]
def test_face_reinforces_chat_moment_with_limited_bonus():
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
base = find_moments(600, chat, [], [])[0]
m = find_moments(600, chat, [], [], face=laugh_at(calm_face(600), 296))[0]
assert (m.peak_s, m.start_s, m.end_s, m.source) == (base.peak_s, base.start_s, base.end_s, "chat")
assert m.reasons["face"]["label"] == "risada" and m.reasons["face"]["onsetS"] == 296
assert 0 < m.score - base.score <= Params().face_bonus_max + 1e-9
def test_face_alone_never_becomes_a_clip():
# Risada no rosto sem áudio nem chat se mexendo: não vira corte (o rosto reforça, não manda).
face = laugh_at(calm_face(600), 300)
assert find_moments(600, [], noisy_loudness(600), [], face=face) == []
def test_face_with_audio_support_creates_face_moment():
loud = noisy_loudness(600)
for t in range(299, 305):
loud[t] = -28.5 # um pouco acima do normal: sozinho não chega a pico de áudio
assert find_moments(600, [], loud, []) == []
moments = find_moments(600, [], loud, [], face=laugh_at(calm_face(600), 300))
assert len(moments) == 1
m = moments[0]
assert m.source == "face" and 300 <= m.peak_s <= 305 and m.reasons["face"]["label"] == "risada"
assert m.start_s < 300 - 5 and m.reasons["support"]["audioZ"] >= 1.0 and m.score > 0
def test_face_moment_respects_live_settle():
loud = noisy_loudness(316)
for t in range(299, 305):
loud[t] = -28.5
assert find_moments(316, [], loud, [], live=True, face=laugh_at(calm_face(316), 300)) == []
+255
View File
@@ -0,0 +1,255 @@
import json
from pathlib import Path
import pytest
from fastapi.testclient import TestClient
from app.config import Settings
from app.db import Database
from app.judge import Judge, JudgeError, Verdict, _clean, build_prompt
from app.main import create_app
from app.scoring import ChatMessage, Word
from app.sources import SourceError, parse_source
from app.worker import Engine, wall_to_t
KEY = "k" * 40
@pytest.mark.parametrize("url,platform,channel,kind", [
("https://www.twitch.tv/alanzoka", "twitch", "alanzoka", "live"),
("twitch.tv/Alanzoka?x=1", "twitch", "alanzoka", "live"),
("https://www.twitch.tv/videos/123456789", "twitch", "", "vod"),
("https://kick.com/gaules", "kick", "gaules", "live"),
("https://www.youtube.com/@canal", "youtube", "@canal", "live"),
("https://youtu.be/dQw4w9WgXcQ", "youtube", "", "vod"),
("https://www.youtube.com/watch?v=dQw4w9WgXcQ", "youtube", "", "vod"),
])
def test_parse_source(url, platform, channel, kind):
source = parse_source(url)
assert (source.platform, source.channel, source.kind) == (platform, channel, kind)
@pytest.mark.parametrize("url", ["", "https://vimeo.com/1", "https://www.twitch.tv/directory", "ftp://twitch.tv/x"])
def test_parse_source_rejects(url):
with pytest.raises(SourceError):
parse_source(url)
def test_wall_to_t_maps_by_segment_arrival():
# Bloco 0 (0–30 s) chegou às 1000; bloco 1 (30–60 s) chegou às 1060 (pausa de 30 s: anúncio filtrado).
segments = [{"idx": 0, "start_s": 0.0, "end_s": 30.0, "wall_end": 1000.0},
{"idx": 1, "start_s": 30.0, "end_s": 60.0, "wall_end": 1060.0}]
assert wall_to_t(990.0, segments) == 20.0
assert wall_to_t(960.0, segments) is None # antes de a gravação começar
assert wall_to_t(1010.0, segments) == 30.0 # durante a pausa: cai no começo do bloco seguinte
assert wall_to_t(1050.0, segments) == 50.0
assert wall_to_t(1065.0, segments) == 65.0
def test_judge_prompt_and_clean():
words = [Word(100.0, 100.4, "não"), Word(100.5, 101.0, "acredito")]
chat = [ChatMessage(104.0, "KKKKK"), ChatMessage(105.0, "clipa")]
prompt = build_prompt("alanzoka", "twitch", 90, 120, 104, words, chat, {"peakRatio": 4.2})
assert "[100s] não acredito" in prompt and "KKKKK" in prompt and "alanzoka" in prompt
verdict = _clean({"keep": True, "score": 14, "start_s": 0, "end_s": 500, "title": "t", "caption": "c", "reason": "r"},
200, 230, "m")
# Padrão novo (16/11/2026): pode voltar até 2 min antes do candidato (a ação vem antes do comentário), nunca
# além; duração de 60 a 90 s.
assert verdict.score == 10.0 and verdict.start_s == 80 and verdict.end_s == 170
assert "Duração do corte: 60 a 90 s" in prompt and "Janela disponível: 0s a 135s" in prompt
old = _clean({"keep": True, "score": 8, "start_s": 0, "end_s": 500, "title": "t", "caption": "c", "reason": "r"},
90, 120, "m", lo=30, hi=135, min_s=15, max_s=59)
assert (old.start_s, old.end_s) == (30, 89) # configuração antiga (15–59 s) continua valendo se o canal pedir
longer = _clean({"keep": True, "score": 8, "start_s": 70, "end_s": 160, "title": "t", "caption": "c", "reason": "r"},
90, 120, "m", lo=30, hi=135, max_s=90)
assert (longer.start_s, longer.end_s) == (70, 135) # duração máxima configurável (até 180 s)
class FakeJudge(Judge):
def __init__(self, keep=True, score=8.0):
super().__init__("codex", "fake", Path("."))
self.keep, self.score_value, self.calls = keep, score, 0
def ask(self, system, prompt, schema, images, **_kwargs):
# Nunca chama a CLI de verdade nos testes (gastaria a cota do dono): analista, varredura e "IA sugere"
# seguem o caminho de falha da IA, que o serviço já trata.
raise JudgeError("IA falsa nos testes")
def judge(self, prompt, start_s, end_s, images=None, **_limits):
self.calls += 1
return Verdict(self.keep, self.score_value, start_s, end_s, "Título da IA", "legenda #cortes", "motivo", "fake")
@pytest.fixture
def env(tmp_path):
settings = Settings.load(env_file=tmp_path / "none.env", service_key=KEY, data_dir=tmp_path / "data",
clips_dir=tmp_path / "clips", judge_provider="codex", voice_url=None, voice_key=None)
db = Database(settings.data_dir / "clipper.db")
engine = Engine(settings, db, judge=FakeJudge())
app = create_app(settings, engine, start_engine=False)
return TestClient(app), engine
def auth():
return {"X-Service-Key": KEY}
def test_auth_required(env):
client, _ = env
assert client.get("/health").status_code == 200
assert client.get("/v1/channels").status_code == 401
assert client.get("/v1/channels", headers={"X-Service-Key": "errada"}).status_code == 401
def test_channel_crud(env):
client, _ = env
r = client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
assert r.status_code == 201 and r.json()["id"] == "twitch-alanzoka" and r.json()["displayName"] == "alanzoka"
assert client.post("/v1/channels", json={"url": "twitch.tv/alanzoka"}, headers=auth()).status_code == 409
assert client.post("/v1/channels", json={"url": "https://www.twitch.tv/videos/1"}, headers=auth()).status_code == 400
r = client.patch("/v1/channels/twitch-alanzoka", json={"monitor": False, "displayName": "Alanzoka"}, headers=auth())
assert r.json()["monitor"] is False and r.json()["displayName"] == "Alanzoka"
assert client.delete("/v1/channels/twitch-alanzoka", headers=auth()).status_code == 204
assert client.get("/v1/channels", headers=auth()).json()["channels"] == []
def seed_session(engine: Engine, duration: int = 600, burst_at: int = 300) -> int:
db = engine.db
cur = db.run("INSERT INTO sessions (platform, kind, url, status, dir, started_at, duration_s) VALUES"
" ('twitch', 'live', 'https://www.twitch.tv/alanzoka', 'processing', '', '2026-11-16T00:00:00+00:00', ?)",
duration)
sid = cur.lastrowid
base_wall = 10_000.0
for i in range(duration // 30):
db.run("INSERT INTO segments (session_id, idx, file, start_s, end_s, wall_end, analyzed, loudness_json, words_json)"
" VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)",
sid, i, f"x/seg_{i:05d}.ts", i * 30.0, (i + 1) * 30.0, base_wall + (i + 1) * 30.0,
json.dumps([-30.0] * 30), json.dumps([[i * 30 + 1.0, i * 30 + 1.5, "fala"]]))
rows = []
for t in range(duration):
rows.append((sid, base_wall + t + 0.5, "u", "salve"))
rows.append((sid, base_wall + t + 0.7, "u", "oi"))
for s in range(8):
for k in range(25):
rows.append((sid, base_wall + burst_at + s + k / 25, "u", "KKKKKKK"))
db.many("INSERT INTO chat (session_id, wall, user, text) VALUES (?, ?, ?, ?)", rows)
return sid
def test_pipeline_finds_judges_and_lists_clip(env):
client, engine = env
sid = seed_session(engine)
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
assert engine.find_new_clips(session) == 1
assert engine.find_new_clips(session) == 0 # não repete o mesmo trecho
engine.judge_candidates()
clip = client.get("/v1/clips", headers=auth()).json()["clips"][0]
assert clip["status"] == "pending" and clip["title"] == "Título da IA"
assert "twitch.tv/alanzoka" in clip["caption"] # crédito do canal sempre na legenda
assert clip["judge"]["score"] == 8.0
# aprovar antes do render é recusado
assert client.patch(f"/v1/clips/{clip['id']}", json={"status": "approved"}, headers=auth()).status_code == 400
# mudar o trecho volta para a fila de render
r = client.patch(f"/v1/clips/{clip['id']}", json={"startS": clip["startS"] - 3}, headers=auth())
assert r.json()["status"] == "pending"
tl = client.get(f"/v1/sessions/{sid}/timeline", headers=auth()).json()
assert tl["durationS"] == 600 and max(tl["messagesPerS"]) >= 25
def test_judge_config_persists(env, tmp_path):
client, engine = env
r = client.get("/v1/judge", headers=auth()).json()
assert r["provider"] == "codex" and "codex" in r["models"]
r = client.put("/v1/judge", json={"provider": "claude", "model": "", "minScore": 7}, headers=auth())
assert r.status_code == 200 and r.json()["model"] == "haiku" and r.json()["minScore"] == 7
assert client.put("/v1/judge", json={"provider": "gpt", "model": ""}, headers=auth()).status_code == 422
assert client.put("/v1/judge", json={"provider": "codex", "model": "x; rm -rf"}, headers=auth()).status_code == 422
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
assert saved == {"judge_provider": "claude", "judge_model": "haiku", "judge_min_score": "7.0", "judge_analyst_model": ""}
def test_manual_clip_is_never_discarded(env):
client, engine = env
engine.judge = FakeJudge(keep=False, score=1)
sid = seed_session(engine)
r = client.post(f"/v1/sessions/{sid}/clips", json={"lastS": 40}, headers=auth())
assert r.status_code == 201 and r.json()["startS"] == 560
engine.judge_candidates()
clip = client.get(f"/v1/clips/{r.json()['id']}", headers=auth()).json()
assert clip["status"] == "pending" and (clip["startS"], clip["endS"]) == (560, 600)
def test_codex_models_reads_cache(tmp_path):
from app.judge import codex_models
cache = tmp_path / "m.json"
cache.write_text(json.dumps({"models": [{"slug": "gpt-6-luna", "display_name": "GPT-6-Luna", "visibility": "list"},
{"slug": "hidden", "visibility": "hide"}]}))
assert [m["id"] for m in codex_models(cache)] == ["gpt-6-luna"]
assert codex_models(tmp_path / "nao-existe.json")[0]["id"] == "gpt-6-luna"
def test_codex_lean_overrides(tmp_path):
from app.judge import codex_lean_overrides
config = tmp_path / "config.toml"
config.write_text('[mcp_servers.node_repl]\ncommand = "x"\n[mcp_servers.node_repl.env]\n'
'[plugins."computer-use@openai-bundled"]\nenabled = true\n')
plain = codex_lean_overrides(False, config)
assert plain.count("-c") == len(plain) // 2
assert "features.shell_tool=false" in plain and "features.computer_use=false" in plain
# Um servidor por nome (a subtabela .env não vira outro servidor) e o plugin presente no config.
assert plain.count("mcp_servers.node_repl.enabled=false") == 1
assert 'plugins."computer-use@openai-bundled".enabled=false' in plain
assert not any("unified-computer-use" in a for a in plain)
# Com busca na web, as ferramentas de execução ficam (a web do Codex depende delas).
searching = codex_lean_overrides(True, config)
assert "features.shell_tool=false" not in searching and "features.computer_use=false" in searching
assert codex_lean_overrides(False, tmp_path / "nao-existe.toml")[-1] == "features.browser_use=false"
def test_judge_discard_keeps_record(env):
client, engine = env
engine.judge = FakeJudge(keep=False, score=3)
sid = seed_session(engine)
engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid))
engine.judge_candidates()
clip = client.get("/v1/clips?status=discarded", headers=auth()).json()["clips"][0]
assert clip["judge"]["keep"] is False
r = client.post(f"/v1/clips/{clip['id']}/render", headers=auth())
assert r.json()["status"] == "pending"
def test_data_and_output_dirs_can_be_isolated(tmp_path, monkeypatch):
"""CLIPPER_DATA_DIR/CLIPPER_OUTPUT_DIR: instância de teste isolada; padrão igual ao de antes; fora do repo = erro."""
from app.config import REPO_ROOT, ConfigError
for name in ("CLIPPER_DATA_DIR", "CLIPPER_OUTPUT_DIR"):
monkeypatch.delenv(name, raising=False)
s = Settings.load(env_file=tmp_path / "none.env")
assert s.data_dir == REPO_ROOT / "data" / "clipper" and s.clips_dir == REPO_ROOT / "output" / "clipper"
monkeypatch.setenv("CLIPPER_DATA_DIR", "output/x-test/data")
monkeypatch.setenv("CLIPPER_OUTPUT_DIR", str(REPO_ROOT / "output" / "x-test" / "clips"))
s = Settings.load(env_file=tmp_path / "none.env")
assert s.data_dir == REPO_ROOT / "output" / "x-test" / "data"
assert (s.data_dir / "sessions" / "1").relative_to(REPO_ROOT).as_posix() == "output/x-test/data/sessions/1"
assert s.clips_dir == REPO_ROOT / "output" / "x-test" / "clips"
monkeypatch.setenv("CLIPPER_DATA_DIR", str(tmp_path / "fora"))
with pytest.raises(ConfigError):
Settings.load(env_file=tmp_path / "none.env")
def test_list_clips_filters_by_channel_and_ids(env):
"""Filtros usados pelo despachante de publicação do painel: fonte (`channel`) e lista de `ids`."""
client, engine = env
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
other = seed_session(engine)
for s in (sid, other):
engine.db.run("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at)"
" VALUES (?, 10, 0, 20, 5, 'manual', 'ready', 'x', 'x')", s)
mine = client.get("/v1/clips?status=ready,approved&channel=twitch-alanzoka", headers=auth()).json()["clips"]
assert [c["channelId"] for c in mine] == ["twitch-alanzoka"]
all_ids = [c["id"] for c in client.get("/v1/clips", headers=auth()).json()["clips"]]
picked = client.get(f"/v1/clips?ids={all_ids[0]}", headers=auth()).json()["clips"]
assert [c["id"] for c in picked] == [all_ids[0]]
assert client.get("/v1/clips?ids=1,abc", headers=auth()).status_code == 400
+562
View File
@@ -0,0 +1,562 @@
"""Bancada de rastreio de rosto do Clipador (Fase 0 do doc/PLANO_RASTREIO_REACAO.md).
Compara, numa sessão já gravada:
1. YuNet no quadro inteiro para achar a câmera (12 quadros espalhados);
2. MediaPipe Face Landmarker (blendshapes) × OpenSeeFace (só os .onnx) no recorte da câmera,
em trechos de 30 s a 6 qps.
Uso (venv do Clipador):
clipper\\.venv\\Scripts\\python.exe clipper\\tools\\face_bench.py --session 3
Lê o banco só em modo leitura (o serviço do usuário pode estar rodando). Saídas em output/face-bench/.
Não é usado pelo serviço; a integração fica em clipper/app/face.py (Fase 2).
"""
from __future__ import annotations
import argparse
import csv
import json
import sqlite3
import statistics
import subprocess
import time
from dataclasses import dataclass, field
from pathlib import Path
import cv2
import numpy as np
ROOT = Path(__file__).resolve().parents[2]
MODELS = ROOT / "data" / "clipper" / "models"
YUNET = "face_detection_yunet_2026may.onnx"
YUNET_OLD = "face_detection_yunet_2023mar.onnx"
LANDMARKER = "face_landmarker.task"
OSF_LM = "osf_lm_model3_opt.onnx"
OSF_DET = "osf_mnv3_detection_opt.onnx"
BLENDS = (
"jawOpen", "mouthSmileLeft", "mouthSmileRight", "eyeWideLeft", "eyeWideRight",
"browInnerUp", "browDownLeft", "browDownRight",
)
FPS = 6
WINDOW_S = 30.0
CROP_SIDE = 384 # maior lado do recorte da câmera que vai para os modelos
# ---------------------------------------------------------------- vídeo
def ffmpeg_bin() -> str:
return "ffmpeg"
@dataclass
class Block:
path: Path
start: float
end: float
def load_blocks(session_dir: Path) -> list[Block]:
blocks = []
with open(session_dir / "segments.csv", newline="", encoding="utf-8") as fh:
for name, start, end in csv.reader(fh):
blocks.append(Block(session_dir / name, float(start), float(end)))
return blocks
def probe_size(path: Path) -> tuple[int, int]:
out = subprocess.run(
["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(path)],
capture_output=True, text=True, check=True,
).stdout.strip().splitlines()[0]
w, h = out.split(",")[:2]
return int(w), int(h)
def grab_frame(blocks: list[Block], t: float, size: tuple[int, int]) -> np.ndarray | None:
"""Um quadro BGR no tempo t (s da sessão)."""
block = next((b for b in blocks if b.start <= t < b.end), None)
if block is None:
return None
w, h = size
raw = subprocess.run(
[ffmpeg_bin(), "-v", "error", "-ss", f"{t - block.start:.3f}", "-i", str(block.path),
"-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"],
capture_output=True, check=True,
).stdout
if len(raw) < w * h * 3:
return None
return np.frombuffer(raw[: w * h * 3], np.uint8).reshape(h, w, 3).copy()
def read_window(blocks: list[Block], t0: float, length: float, crop_px: tuple[int, int, int, int],
out_size: tuple[int, int]) -> list[tuple[float, np.ndarray]]:
"""Quadros RGB do recorte (x, y, w, h em px) a FPS qps, de t0 a t0+length, atravessando blocos."""
x, y, cw, ch = crop_px
ow, oh = out_size
frames: list[tuple[float, np.ndarray]] = []
t1 = t0 + length
for b in blocks:
a, z = max(t0, b.start), min(t1, b.end)
if z <= a:
continue
raw = subprocess.run(
[ffmpeg_bin(), "-v", "error", "-ss", f"{a - b.start:.3f}", "-t", f"{z - a:.3f}", "-i", str(b.path),
"-vf", f"fps={FPS},crop={cw}:{ch}:{x}:{y},scale={ow}:{oh}",
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
capture_output=True, check=True,
).stdout
n = len(raw) // (ow * oh * 3)
arr = np.frombuffer(raw[: n * ow * oh * 3], np.uint8).reshape(n, oh, ow, 3)
for i in range(n):
frames.append((a + i / FPS, arr[i].copy()))
return frames
# ---------------------------------------------------------------- câmera (YuNet)
def make_yunet(name: str, size: tuple[int, int]):
return cv2.FaceDetectorYN.create(str(MODELS / name), "", size, 0.6, 0.3, 50)
def iou(a: dict, b: dict) -> float:
ax2, ay2, bx2, by2 = a["x"] + a["w"], a["y"] + a["h"], b["x"] + b["w"], b["y"] + b["h"]
iw = max(0.0, min(ax2, bx2) - max(a["x"], b["x"]))
ih = max(0.0, min(ay2, by2) - max(a["y"], b["y"]))
inter = iw * ih
union = a["w"] * a["h"] + b["w"] * b["h"] - inter
return inter / union if union > 0 else 0.0
def clamp_rect(r: dict) -> dict:
x, y = max(0.0, r["x"]), max(0.0, r["y"])
x2, y2 = min(1.0, r["x"] + r["w"]), min(1.0, r["y"] + r["h"])
return {"x": round(x, 4), "y": round(y, 4), "w": round(x2 - x, 4), "h": round(y2 - y, 4)}
def face_to_cam(face: dict) -> dict:
"""Retângulo da câmera estimado só pelo rosto (≈3,2× largura, 3,6× altura, rosto no terço de cima)."""
cx, cy = face["x"] + face["w"] / 2, face["y"] + face["h"] / 2
w, h = face["w"] * 3.2, face["h"] * 3.6
return clamp_rect({"x": cx - w / 2, "y": cy - h * 0.38, "w": w, "h": h})
def locate_cam(blocks, size, duration, ai_cam, out_dir: Path) -> dict:
fw, fh = size
times = [30 + i * (duration - 60) / 11 for i in range(12)]
det = make_yunet(YUNET, size)
# A 2023mar (entrada fixa) não está no models.lock.json; só entra na comparação se estiver na pasta.
det_old = make_yunet(YUNET_OLD, size) if (MODELS / YUNET_OLD).exists() else None
rows, thumbs, ms, ms_old = [], [], [], []
for t in times:
img = grab_frame(blocks, t, size)
if img is None:
continue
t_a = time.perf_counter()
_, faces = det.detect(img)
ms.append((time.perf_counter() - t_a) * 1000)
faces_old = faces
if det_old is not None:
t_a = time.perf_counter()
_, faces_old = det_old.detect(img)
ms_old.append((time.perf_counter() - t_a) * 1000)
found = []
for f in (faces if faces is not None else []):
found.append({"x": float(f[0]) / fw, "y": float(f[1]) / fh, "w": float(f[2]) / fw,
"h": float(f[3]) / fh, "score": round(float(f[14]), 3)})
rows.append({"t": round(t, 1), "faces": found,
"old_same": (faces_old is not None) == (faces is not None)})
thumbs.append((t, img, found))
# Agrupa rostos pela posição: entra no grupo de centroide mais próximo se estiver a menos de 1 largura
# (e 1 altura) de rosto dele. Comparar com o 1º membro (versão anterior) partia o streamer inclinado em 2.
clusters: list[list[dict]] = []
def centroid(cl):
return (statistics.mean(m["x"] + m["w"] / 2 for m in cl), statistics.mean(m["y"] + m["h"] / 2 for m in cl),
statistics.mean(m["w"] for m in cl), statistics.mean(m["h"] for m in cl))
for r in rows:
for f in r["faces"]:
c = (f["x"] + f["w"] / 2, f["y"] + f["h"] / 2)
best_cl, best_d = None, 1.0
for cl in clusters:
gx, gy, gw, gh = centroid(cl)
dx, dy = abs(c[0] - gx) / gw, abs(c[1] - gy) / gh
if dx < 1.0 and dy < 1.0 and max(dx, dy) < best_d:
best_cl, best_d = cl, max(dx, dy)
if best_cl is not None:
best_cl.append({**f, "t": r["t"]})
else:
clusters.append([{**f, "t": r["t"]}])
clusters.sort(key=lambda cl: len({m["t"] for m in cl}), reverse=True)
best = clusters[0] if clusters else []
result: dict = {
"frames": len(rows),
"framesWithFace": sum(1 for r in rows if r["faces"]),
"yunetMsPerFrame": round(statistics.mean(ms), 1) if ms else None,
"yunet2023marMsPerFrame": round(statistics.mean(ms_old), 1) if ms_old else None,
"variantsAgree": all(r["old_same"] for r in rows),
"clusters": [{"n": len({m["t"] for m in cl}),
"cx": round(statistics.median(m["x"] + m["w"] / 2 for m in cl), 3),
"cy": round(statistics.median(m["y"] + m["h"] / 2 for m in cl), 3)} for cl in clusters],
"rows": rows,
}
if best:
med = {k: statistics.median(m[k] for m in best) for k in ("x", "y", "w", "h")}
cxs = [m["x"] + m["w"] / 2 for m in best]
cys = [m["y"] + m["h"] / 2 for m in best]
cam = face_to_cam(med)
inside = clamp_rect({"x": max(med["x"], ai_cam["x"]), "y": max(med["y"], ai_cam["y"]),
"w": min(med["x"] + med["w"], ai_cam["x"] + ai_cam["w"]) - max(med["x"], ai_cam["x"]),
"h": min(med["y"] + med["h"], ai_cam["y"] + ai_cam["h"]) - max(med["y"], ai_cam["y"])})
result.update({
"presence": round(len({m["t"] for m in best}) / max(1, len(rows)), 3),
"face": {k: round(v, 4) for k, v in med.items()},
"facePx": round(med["h"] * fh),
"jitterCx": round(statistics.pstdev(cxs) / med["w"], 3),
"jitterCy": round(statistics.pstdev(cys) / med["h"], 3),
"cam": cam,
"iouWithAi": round(iou(cam, ai_cam), 3),
"faceInsideAi": round(max(0.0, inside["w"]) * max(0.0, inside["h"]) / (med["w"] * med["h"]), 3),
})
# Folha de contato: verde = YuNet, azul = câmera da IA, amarelo = câmera estimada pelo rosto.
tiles = []
for t, img, found in thumbs:
tile = img.copy()
for f in found:
cv2.rectangle(tile, (int(f["x"] * fw), int(f["y"] * fh)),
(int((f["x"] + f["w"]) * fw), int((f["y"] + f["h"]) * fh)), (0, 255, 0), 3)
for rect, color in ((ai_cam, (255, 120, 0)), (result.get("cam"), (0, 220, 255))):
if rect:
cv2.rectangle(tile, (int(rect["x"] * fw), int(rect["y"] * fh)),
(int((rect["x"] + rect["w"]) * fw), int((rect["y"] + rect["h"]) * fh)), color, 3)
tile = cv2.resize(tile, (480, 270))
cv2.putText(tile, f"t={t:.0f}s", (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
tiles.append(tile)
save_grid(tiles, 4, out_dir / "cam_sheet.png")
return result
def save_grid(tiles: list[np.ndarray], cols: int, path: Path) -> None:
if not tiles:
return
h, w = tiles[0].shape[:2]
rows = (len(tiles) + cols - 1) // cols
sheet = np.zeros((rows * h, cols * w, 3), np.uint8)
for i, tile in enumerate(tiles):
r, c = divmod(i, cols)
sheet[r * h:(r + 1) * h, c * w:(c + 1) * w] = tile
cv2.imwrite(str(path), sheet)
# ---------------------------------------------------------------- MediaPipe
@dataclass
class Sample:
t: float
present: bool
ms: float
box: tuple[float, float, float, float] | None = None # x, y, w, h em px do recorte
points: np.ndarray | None = None
blend: dict = field(default_factory=dict)
def run_mediapipe(frames: list[tuple[float, np.ndarray]]) -> list[Sample]:
import mediapipe as mp
from mediapipe.tasks.python.core.base_options import BaseOptions
from mediapipe.tasks.python import vision
options = vision.FaceLandmarkerOptions(
base_options=BaseOptions(model_asset_path=str(MODELS / LANDMARKER)),
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,
)
out: list[Sample] = []
with vision.FaceLandmarker.create_from_options(options) as lm:
for t, rgb in frames:
h, w = rgb.shape[:2]
image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.ascontiguousarray(rgb))
t_a = time.perf_counter()
res = lm.detect_for_video(image, int(round(t * 1000)))
ms = (time.perf_counter() - t_a) * 1000
if not res.face_landmarks:
out.append(Sample(t, False, ms))
continue
pts = np.array([(p.x * w, p.y * h) for p in res.face_landmarks[0]], np.float32)
x1, y1 = pts.min(0)
x2, y2 = pts.max(0)
blend = {c.category_name: float(c.score) for c in res.face_blendshapes[0] if c.category_name in BLENDS}
out.append(Sample(t, True, ms, (float(x1), float(y1), float(x2 - x1), float(y2 - y1)), pts, blend))
return out
# ---------------------------------------------------------------- OpenSeeFace (pré/pós mínimo do tracker.py)
class OsfTracker:
"""Reimplementação mínima de emilianavt/OpenSeeFace tracker.py (BSD-2), modelo 3, sem olhar/3D.
Detector mnv3 (224×224, saída 56×56 com raio) quando não há rosto; depois reaproveita a caixa dos
pontos do quadro anterior, como o original. Pontos no formato 66 do OpenSeeFace (≈ iBUG 68 sem 60/64).
"""
RES = 224
OUT_RES = 27
LOGIT = 16.0
def __init__(self, threads: int = 1, threshold: float = 0.6, det_threshold: float = 0.6):
import onnxruntime as ort
opts = ort.SessionOptions()
opts.inter_op_num_threads = 1
opts.intra_op_num_threads = threads
opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
prov = ["CPUExecutionProvider"]
self.lm = ort.InferenceSession(str(MODELS / OSF_LM), sess_options=opts, providers=prov)
self.det = ort.InferenceSession(str(MODELS / OSF_DET), sess_options=opts, providers=prov)
self.lm_input = self.lm.get_inputs()[0].name
mean = np.float32([0.485, 0.456, 0.406])
std = np.float32([0.229, 0.224, 0.225])
self.mean = -(mean / std)
self.scale = 1.0 / (std * 255.0)
self.threshold = threshold
self.det_threshold = det_threshold
self.face: tuple[float, float, float, float] | None = None
self.misses = 0
def _norm(self, rgb: np.ndarray, size: int) -> np.ndarray:
im = cv2.resize(rgb.astype(np.float32), (size, size), interpolation=cv2.INTER_LINEAR)
im = im * self.scale + self.mean
return np.transpose(im[None], (0, 3, 1, 2)).astype(np.float32)
def detect(self, rgb: np.ndarray) -> tuple[float, float, float, float] | None:
out, maxpool = self.det.run([], {"input": self._norm(rgb, 224)})
out, maxpool = np.array(out), np.array(maxpool)
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
best = int(np.argmax(out[0, 0]))
y, x = divmod(best, 56)
if out[0, 0, y, x] < self.det_threshold:
return None
r = out[0, 1, y, x] * 112.0
x, y = x * 4, y * 4
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
return ((x - r) * sx, (y - r) * sy, 2 * r * sx, 2 * r * sy)
def landmarks(self, rgb: np.ndarray, box) -> tuple[float, np.ndarray]:
h, w = rgb.shape[:2]
x, y, bw, bh = box
x1 = int(np.clip(x - int(bw * 0.1), 0, w - 1))
y1 = int(np.clip(y - int(bh * 0.125), 0, h - 1))
x2 = int(np.clip(x + bw + int(bw * 0.1), 0, w - 1))
y2 = int(np.clip(y + bh + int(bh * 0.125), 0, h - 1))
if x2 - x1 < 4 or y2 - y1 < 4:
return 0.0, np.zeros((66, 3), np.float32)
sx, sy = (x2 - x1) / self.RES, (y2 - y1) / self.RES
tensor = self.lm.run([], {self.lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
n = self.OUT_RES + 1
res = 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]
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]
def logit(p):
p = np.clip(p, 1e-7, 1 - 1e-7)
return np.log(p / (1 - p)) / self.LOGIT
m = idx[:, 0]
# No original a 1ª coluna é y e a 2ª é x; aqui já devolvemos (x, y, conf).
py = y1 + sy * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
px = x1 + sx * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
pts = np.stack([px, py, conf], 1).astype(np.float32)
pts[np.isnan(pts).any(axis=1)] = 0
return float(conf.mean()), pts
def step(self, rgb: np.ndarray) -> tuple[float, np.ndarray] | None:
box = self.face if self.face is not None else self.detect(rgb)
if box is None:
return None
conf, pts = self.landmarks(rgb, box)
if conf < self.threshold and self.face is not None:
# caixa antiga perdida: tenta o detector neste mesmo quadro
box = self.detect(rgb)
if box is None:
self.face = None
return None
conf, pts = self.landmarks(rgb, box)
if conf < self.threshold:
self.face = None
return None
x1, y1 = pts[:, :2].min(0)
x2, y2 = pts[:, :2].max(0)
self.face = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
return conf, pts
def run_osf(frames: list[tuple[float, np.ndarray]]) -> list[Sample]:
tr = OsfTracker()
out = []
for t, rgb in frames:
t_a = time.perf_counter()
got = tr.step(rgb)
ms = (time.perf_counter() - t_a) * 1000
if got is None:
out.append(Sample(t, False, ms))
continue
conf, pts = got
xy = pts[:, :2]
x1, y1 = xy.min(0)
x2, y2 = xy.max(0)
# boca aberta: lábios internos (60–62 em cima, 63–65 embaixo no layout de 66) / altura do rosto
mouth = float(abs(xy[[63, 64, 65], 1].mean() - xy[[60, 61, 62], 1].mean()) / max(1.0, y2 - y1))
out.append(Sample(t, True, ms, (float(x1), float(y1), float(x2 - x1), float(y2 - y1)), xy,
{"mouthOpen": mouth, "conf": conf}))
return out
# ---------------------------------------------------------------- métricas
def summarize(samples: list[Sample]) -> dict:
ms = sorted(s.ms for s in samples)
present = [s for s in samples if s.present]
out = {
"frames": len(samples),
"presentPct": round(100 * len(present) / max(1, len(samples)), 1),
"msMean": round(statistics.mean(ms), 2) if ms else None,
"msP95": round(ms[int(0.95 * (len(ms) - 1))], 2) if ms else None,
"facePxMedian": round(statistics.median(s.box[3] for s in present), 1) if present else None,
}
return out
def per_second(samples: list[Sample], keys) -> list[dict]:
by: dict[int, list[Sample]] = {}
for s in samples:
by.setdefault(int(s.t), []).append(s)
rows = []
for sec in sorted(by):
ss = [s for s in by[sec] if s.present]
row = {"t": sec, "present": round(len(ss) / len(by[sec]), 2)}
for k in keys:
vals = [s.blend.get(k, 0.0) for s in ss]
row[k] = round(max(vals), 3) if vals else None
rows.append(row)
return rows
def blend_stats(samples: list[Sample], keys, t_from=None, t_to=None) -> dict:
ss = [s for s in samples if s.present and (t_from is None or t_from <= s.t <= t_to)]
out = {}
for k in keys:
vals = [s.blend.get(k, 0.0) for s in ss]
out[k] = {"mean": round(statistics.mean(vals), 3), "p90": round(float(np.percentile(vals, 90)), 3),
"max": round(max(vals), 3)} if vals else None
return out
def draw_sheet(frames, mp_samples, osf_samples, path: Path, n: int = 10) -> None:
idxs = np.linspace(0, len(frames) - 1, n).astype(int)
tiles = []
for i in idxs:
t, rgb = frames[i]
img = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
m, o = mp_samples[i], osf_samples[i]
if m.present:
for p in m.points[::3]:
cv2.circle(img, (int(p[0]), int(p[1])), 1, (0, 255, 0), -1)
x, y, w, h = m.box
cv2.rectangle(img, (int(x), int(y)), (int(x + w), int(y + h)), (0, 255, 0), 1)
if o.present:
for p in o.points:
cv2.circle(img, (int(p[0]), int(p[1])), 2, (0, 0, 255), -1)
label = f"t={t:.1f} jaw={m.blend.get('jawOpen', 0):.2f} sm={max(m.blend.get('mouthSmileLeft', 0), m.blend.get('mouthSmileRight', 0)):.2f}"
cv2.putText(img, label, (4, 14), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
tiles.append(img)
save_grid(tiles, 5, path)
# ---------------------------------------------------------------- principal
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument("--session", type=int, default=3)
ap.add_argument("--out", default=str(ROOT / "output" / "face-bench"))
args = ap.parse_args()
out_dir = Path(args.out)
out_dir.mkdir(parents=True, exist_ok=True)
con = sqlite3.connect(f"file:{ROOT / 'data' / 'clipper' / 'clipper.db'}?mode=ro", uri=True)
cam_json = json.loads(con.execute("select cam_json from sessions where id=?", (args.session,)).fetchone()[0])
ai_cam = cam_json["cam"]
clips = con.execute("select id, peak_s, start_s, end_s, title from clips where session_id=? order by peak_s",
(args.session,)).fetchall()
loud = {r[0]: json.loads(r[1]) for r in con.execute(
"select idx, loudness_json from segments where session_id=? and loudness_json is not null", (args.session,))}
con.close()
session_dir = ROOT / "data" / "clipper" / "sessions" / str(args.session)
blocks = load_blocks(session_dir)
duration = blocks[-1].end
size = probe_size(blocks[0].path)
print(f"sessão {args.session}: {len(blocks)} blocos, {duration:.0f} s, {size[0]}x{size[1]}")
report: dict = {"session": args.session, "frameSize": size, "aiCam": ai_cam,
"clips": [{"id": c[0], "peak": c[1], "start": c[2], "end": c[3]} for c in clips]}
cam = locate_cam(blocks, size, duration, ai_cam, out_dir)
report["camera"] = cam
print("câmera:", {k: v for k, v in cam.items() if k != "rows"})
# Trecho calmo: bloco com menor volume (p90) a ≥ 120 s de qualquer corte, longe das pontas.
peaks = [c[1] for c in clips]
calm_idx = min((i for i in loud if 2 <= i < len(blocks) - 2
and all(abs(blocks[i].start + 15 - p) >= 120 for p in peaks)),
key=lambda i: float(np.percentile(loud[i], 90)))
windows = [("calmo", blocks[calm_idx].start, None)]
for cid, peak, start, end, _title in clips:
if peak + 10 > duration: # corte novo além dos blocos lidos no início (o serviço continua gravando)
continue
windows.append((f"corte{cid}", max(0.0, peak - 20), peak))
# Recorte: câmera local (+10 % de margem); comparação extra com o retângulo da IA.
fw, fh = size
crops = {"local": cam.get("cam") or ai_cam, "ai": ai_cam}
report["windows"] = []
for name, t0, peak in windows:
for crop_name, rect in crops.items():
mx, my = rect["w"] * 0.1, rect["h"] * 0.1
r = clamp_rect({"x": rect["x"] - mx, "y": rect["y"] - my, "w": rect["w"] + 2 * mx, "h": rect["h"] + 2 * my})
px = (int(r["x"] * fw) // 2 * 2, int(r["y"] * fh) // 2 * 2, int(r["w"] * fw) // 2 * 2, int(r["h"] * fh) // 2 * 2)
k = CROP_SIDE / max(px[2], px[3])
out_size = (int(px[2] * k) // 2 * 2, int(px[3] * k) // 2 * 2)
t_a = time.perf_counter()
frames = read_window(blocks, t0, WINDOW_S, px, out_size)
decode_s = time.perf_counter() - t_a
mp_s = run_mediapipe(frames)
entry = {"window": name, "crop": crop_name, "t0": t0, "peak": peak, "cropPx": px, "inputSize": out_size,
"decodeS": round(decode_s, 2), "mediapipe": summarize(mp_s)}
if crop_name == "local":
osf_s = run_osf(frames)
entry["openseeface"] = summarize(osf_s)
entry["mpBlend"] = blend_stats(mp_s, BLENDS)
entry["osfMouth"] = blend_stats(osf_s, ("mouthOpen",))
if peak is not None:
entry["mpBlendNearPeak"] = blend_stats(mp_s, BLENDS, peak - 4, peak + 4)
entry["osfMouthNearPeak"] = blend_stats(osf_s, ("mouthOpen",), peak - 4, peak + 4)
entry["mpPerSecond"] = per_second(mp_s, BLENDS)
entry["osfPerSecond"] = per_second(osf_s, ("mouthOpen",))
draw_sheet(frames, mp_s, osf_s, out_dir / f"track_{name}.png")
report["windows"].append(entry)
print(name, crop_name, "MP", entry["mediapipe"], "OSF", entry.get("openseeface"))
(out_dir / "results.json").write_text(json.dumps(report, ensure_ascii=False, indent=1), encoding="utf-8")
print("resultado:", out_dir / "results.json")
if __name__ == "__main__":
main()