Compare commits

..
25 Commits
Author SHA1 Message Date
MateuusandClaude Opus 5.5 d9bf411e7a Clipador: chat da Kick pelo Centrifugo (a chave fixa do Pusher parou de valer)
A Kick passou a escolher o provedor de tempo real por canal (POST web.kick.com/api/v1/realtime/channels/<id>/chat/
connection) e hoje responde Centrifugo; o Pusher com a chave antiga recusava com "App key not in this cluster" e o
chat de toda fonte da Kick ficava em erro. Agora: token de convidado (/v1/realtime/auth/connection, sem login) →
connect → subscribe chatrooms.<sala>.v2; ping {} respondido; token expira e o laço reconecta. Se a Kick indicar
Pusher, usa a chave e o cluster que ela informar. Testado ao vivo no chat de kick.com/peusantista.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 05:46:13 -03:00
MateuusandClaude Opus 5.5 dbb5e8ef92 Sincronização: detecção do jogo + revisão/final, dublagem, falantes, expressões e Equipe de IA
Conflitos resolvidos juntando os dois lados:
- db.py: v16 (detecção do jogo) e v17 (Equipe de IA) em sequência.
- judge.py: a varredura exige os campos das duas frentes (screen_game_confidence/screen_evidence e lines).
- proxy do painel: libera judge/report e sessions/id/game/detect.
- skill: detecção do jogo vira a 1.55.0 (gotcha 180 → 186), acima da 1.54.0 das cinco frentes.

Suíte do Clipador inteira passa; painel: tsc + 119 testes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 05:11:47 -03:00
MateuusandClaude Opus 5.5 b923132a69 Cartoon: estudo de handoff do personagem (.studies) e AGENTS.md
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 05:08:57 -03:00
MateuusandClaude Opus 5.5 215faa331c Skill cenaforge: detecção do jogo (edição de outra sessão, commitada na sincronização)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 05:08:57 -03:00
MateuusandClaude Opus 5.5 44bb961d1a Clipador: detecção do jogo cruzando categoria e tela (confiança, evidência e sugestão de troca)
Trabalho de outra sessão, commitado na sincronização de 18/11/2026 (doc/clipador/DETECCAO-JOGO.md).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 05:08:57 -03:00
MateuusandClaude Opus 5.5 96619c223b Doc: migrações corretas em FALANTES.md (v15) e EQUIPE-IA.md (v16 = detecção do jogo)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:53:58 -03:00
MateuusandClaude Opus 5.5 b11090ffa3 Skill cenaforge 1.54.0: Clipador (revisão × final, dublagem, falantes, expressões, Equipe de IA)
Dois arquivos novos em references/ (clipper-video.md, clipper-ai-team.md), banco em v17,
seção de expressões, gotchas 180–185 e ponteiros em panel/publishing/ai/tools.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:53:34 -03:00
Mateuus e4a5bc026c Cartoon: corpo contínuo sem juntas e novas mãos em 2 camadas 2026-11-18 04:50:20 -03:00
MateuusandClaude Opus 5.5 08ab68d16e Clipador: v16 = detecção do jogo (colunas da sessão em andamento na pasta principal)
O banco real já foi migrado com essa v16 (game_status, game_detect_json) pelo código ainda não commitado da frente de
detecção do jogo. A v16 sem efeito do main passa a ser exatamente essa migração, para o banco real e o main ficarem
coerentes e o merge daquela frente ser trivial. A Equipe de IA continua na v17.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:49:25 -03:00
MateuusandClaude Opus 5.5 7bf9fddab6 Integração: Equipe de IA + expressões (v16 fica sem efeito: as expressões não precisaram de migração)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:47:16 -03:00
Mateuus 22673c4b5f Merge branch 'clipper/roles' into clipper/integ 2026-11-18 04:45:34 -03:00
MateuusandClaude Opus 5.5 76b722c499 Doc: Equipe de IA (doc/clipador/EQUIPE-IA.md) e contrato por papel em doc/ia.md
- EQUIPE-IA.md: papéis e configuração (judge.roles, migração), juiz de contexto e as regras
  de decisão pelo código, linha do tempo JSON + mosaico, medição (ai_calls, owner_label,
  GET /v1/judge/report) e o medido no corte 291 (analista −45%, varredura −38%, editor −20%;
  ≈ −29% por hora já com o juiz; 1 chamada real do juiz no Codex: 9.624 tokens de entrada).
- doc/ia.md: reserva por papel, codex exec --json e leitura de uso por CLI.
- README do Clipador: rotas /v1/judge e /v1/judge/report.
- judge.describe: uma checagem por provedor para todas as cadeias (o painel lê o status a
  cada poucos segundos); sem analista, o editor recebe as imagens no modo escolhido.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:44:56 -03:00
MateuusandClaude Opus 5.5 26c9afa13a Painel: Equipe de IA no lugar do provedor único, juiz de contexto no modal e medição
- Ajustes → Juiz: "Usar IA" + um cartão por papel (varredura, analista, editor, juiz) com
  provedor, modelo do provedor escolhido, raciocínio (Codex), imagens (mosaico/quadros/nenhuma),
  liga/desliga (o editor não desliga), instruções padrão só leitura (fonte PT/EN) e instruções
  do administrador; regras do juiz (checagens críticas, ajustar trecho, frase de contexto,
  desconto por checagem). Opção "Linha do tempo em JSON" para comparar com o formato antigo.
- Cartão de medição (GET judge/report, liberado no proxy): chamadas e tokens por hora por
  papel, aprovação, descartes do juiz e concordância juiz x dono.
- Modal do corte: veredito do juiz de contexto em português (decisão, o que um espectador
  frio entende, frase de contexto, checagens) e "Sua avaliação" (bom/ruim/sem contexto);
  botão "Sem contexto" ao rejeitar; lista marca "descartado pelo juiz".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:38:34 -03:00
MateuusandClaude Opus 5.5 cb8450399d Clipador: Equipe de IA (papéis com IA própria), juiz de contexto e linha do tempo JSON
- roles.py: varredura, analista, editor e juiz, cada um com provedor, modelo, raciocínio
  (Codex), liga/desliga (o editor não desliga) e instruções do administrador somadas às
  padrão; gravado em settings `judge.roles`, com migração automática da configuração antiga
  (provedor/modelo único vira o de todos; o modelo do analista é respeitado). A reserva vale
  por papel.
- Juiz de contexto (só texto): vê só o que vai no corte (+20 s antes/15 s depois marcados
  out=1), escreve o que um espectador frio entende e responde sim/não; context_judge.decide
  decide pelo código: aprova, ajusta o trecho e confere uma vez de novo, frase de contexto
  na tela (vira o texto de abertura do projeto) ou descarta com motivo em português
  (forçável). Corte manual só recebe aviso.
- timeline.py: linha do tempo JSON curta (fala com falante, chat, rosto, volume e a frase
  de tela que a varredura/analista escrevem ao ver os quadros, em scene_notes); mosaico 4x2
  (media.mosaic) no lugar dos quadros soltos; perfil do jogo enxuto. O formato antigo fica
  atrás da opção timelineJson.
- Medição (F0): ai_calls por chamada (papel, IA, tamanho do prompt/imagens, tokens quando a
  CLI informa: codex --json, claude e gemini), avaliação do dono (owner_label: bom/ruim/sem
  contexto) e GET /v1/judge/report (taxa de aprovação, decisões do juiz, concordância).
- Banco v17 (v16 fica reservada às expressões, como marcador sem efeito).
- Testes: test_roles.py e test_context_judge.py; os testes bloqueiam qualquer CLI de IA real.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:36:25 -03:00
Mateuus 393d1f74b2 Merge branch 'clipper/expressions' into clipper/integ 2026-11-18 04:19:30 -03:00
MateuusandClaude Opus 5.5 44f78bd483 Clipador: mapa de expressões do streamer (expressões novas, pose e corpo)
- Expressões novas dos blendshapes que já vinham do MediaPipe: gargalhada, alegria
  (no mapa), medo, espanto, nojo, tristeza, tensão e bocejo (que deixou de contar
  como grito); raiva também por olhos semicerrados + lábios apertados. Canais novos
  opcionais na série (brow_inner, mouth_frown, squint, press, stretch, upper_lip,
  pucker), z relativo ao neutro do próprio streamer só com os segundos que têm o campo.
- Pose da cabeça pela matriz de transformação facial (yaw/pitch/roll) e balanço/aceno
  por zigue-zague; YuNet nos quadros sem rosto dá a caixa da cabeça (streamer de perfil).
- Corpo mesmo sem expressão: balançando, acenando, agitado, chegou perto e saiu do
  quadro, sem contar rastreio perdido como movimento.
- API /face com expr/body por segundo e lista do corpo; linha do juiz com o corpo;
  painel com os rótulos novos e o "Mapa de expressões" no modal do corte.
- Calibrado nas sessões 7, 8, 11 e 15 (doc/clipador/EXPRESSOES.md); intensidade dos
  picos inalterada (canais novos só rotulam). Testes em tests/test_expressions.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:16:25 -03:00
MateuusandClaude Opus 5.5 5be6c09c16 Doc: pesquisa e proposta do juiz de contexto e da linha do tempo em JSON (doc/clipador/PESQUISA-JUIZ.md)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:05:31 -03:00
MateuusandClaude Opus 5.5 1ea8445808 Painel: libera POST clips/id/translate e GET sessions/id/speakers no proxy do Clipador
O botão "Traduzir a fala" recebia 404 (rota não liberada) e a rota de vozes da sessão é nova.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:00:29 -03:00
MateuusandClaude Opus 5.5 439e111052 Integração: falantes + dublagem + vídeo final
- editor_api: importa dub e speakers juntos.
- voice_chunks (falantes) vira a migração v15, depois da v14 do vídeo final (antes era criada fora das migrações).
- dub.voice_for: qualquer voz que não é o streamer (other1, other2…) usa a segunda voz da dublagem.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:59:44 -03:00
MateuusandClaude Opus 5.5 377536f778 Clipador: quem fala cada palavra (streamer × outra pessoa) e legenda em duas linhas
A fala de colegas no Discord e de outros jogadores saía na legenda como se fosse do
streamer. Agora cada palavra tem falante:

- voz: cada trecho de fala vira uma impressão de voz (WeSpeaker ResNet34-LM, ONNX,
  pesos CC-BY-4.0) na análise do bloco (~0,2 s de CPU por bloco); as vozes da sessão
  são agrupadas sob demanda (0,05 s) e a do streamer é a que mexe a boca na webcam
  (YuNet, nova série `mouth` no rastreio) ou a mais alta no áudio. Sem prova, tudo
  continua como do streamer.
- dados: `scoring.Word.speaker`; `words_json` aceita o 4º elemento; tabela
  `voice_chunks` (CREATE TABLE IF NOT EXISTS, fora da lista de migrações).
- legenda: streamer na posição normal e outra pessoa logo abaixo, em outra cor
  (`caption.otherColor`/`otherSize`); blocos nunca misturam falantes; os dois juntos
  = duas linhas; gancho desvia as duas; vertical e horizontal.
- tradução com `speaker` por linha; juízes recebem a transcrição marcada.
- painel: cor da outra pessoa na configuração, falante na transcrição do editor
  (com correção manual), prévia em duas linhas e "O que falam" no modal.
- doc/clipador/FALANTES.md com abordagem, licenças e qualidade medida na sessão 15.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:57:00 -03:00
MateuusandClaude Opus 5.5 e96e180da5 Integração: vídeo final ao aprovar + dublagem em português
Conflito em editor_api.render_clip_edit (as duas frentes mexeram na chamada de render): passa a tradução, `dev`
e o dublador juntos. review_layers: a dublagem sai das frases traduzidas, então sem frase (fonte em português) não
houve dublagem e o vídeo de revisão já é o final.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:49:39 -03:00
Mateuus 06f463e684 Merge branch 'clipper/final' into clipper/integ 2026-11-18 03:45:49 -03:00
MateuusandClaude Opus 5.5 7a428ee5da Clipador: dublagem em português por TTS no vídeo de revisão (dev.dub)
- app/dub.py: frases traduzidas → uma fala TTS por frase no serviço de voz
  (POST /v1/synthesize, WAV), cache em disco por (voz, velocidade, texto),
  encaixe sem sincronia labial (velocidade natural, escorre até 1,5 s sem
  acumular atraso, acelera no máximo 1,2× e corta com fade só se preciso,
  nunca duas falas juntas), frase partida no meio vira uma fala só, voz
  reserva offline e faixa única do trecho nivelada pelo volume do corte.
- editor_render.render_project: o áudio original abaixa (dubDuck, rampa
  de 0,15 s) só onde há dublagem; nada muda com dev=False. Devolve resumo.
- layout: dev.dubVoice, dev.dubVoiceOther (speaker "other") e dev.dubDuck.
- editor_api: prévia e render da fila passam o dublador; translation_for
  também traduz quando só a dublagem está ligada.
- Painel: switch "Dublagem em português (teste)", vozes TTS prontas (sem
  clone) e volume do original.
- doc/clipador/DUBLAGEM.md e tests/test_dub.py (TTS falso).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:45:14 -03:00
MateuusandClaude Opus 5.5 dc0917b114 Clipador: vídeo final sem camadas de teste ao aprovar; publicação só usa o final
Pedido do dono: o vídeo da fila é de revisão (com as camadas `dev`, ex.: tradução);
ao aprovar, o serviço renderiza de novo sem elas, e só esse vai para as redes.

- db v14: clips.review_dev_json (camadas que entraram na revisão) e final_status/
  final_file/final_thumb/final_cover/final_error/final_at; backfill dos cortes antigos.
- Motor: queue_final/drop_final/render_final; fila renderiza finais primeiro com
  render_clip_edit(dev=False) em clip-<id>-final.mp4; revisão sem camada de teste
  vira o final sem render novo; prune guarda os blocos de quem ainda precisa do final.
- API: clip traz review.devLayers, final e publishFile; aprovar enfileira o final;
  desaprovar, mudar trecho, exportar, re-render e rejudge derrubam o final;
  POST /v1/clips/{id}/final (tentar de novo).
- Painel: etiqueta na lista, player Final/Revisão e estado do final no modal
  (gerando/pronto/erro com "Tentar de novo"), aviso no "Publicar"; o despachante
  relê o corte antes de enviar e espera o final (clipPublishFile), nunca a revisão.
- Testes: clipper/tests/test_final_render.py e testes do despachante no painel.
- Doc: doc/clipador/REVISAO.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:27:26 -03:00
MateuusandClaude Opus 5.5 ad36f0faf4 Cartoon: foco da cena segue a narração e personagens no barco quando há água
- focusOf ignora objeto procurado, não encontrado ou só "parecido" (não mostra pronto o que o texto nega)
- stageFocus: com chão de água e arca em cena, quem aparece fica dentro do barco
- assunto grande mais à frente (z 0,35) e maior (arca 1,35; demais 1,4)
- Noé e a Arca ep01: tomadas regeradas e narração em velocidade 1,1
- .gitignore: worktrees temporárias dos subagentes

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:25:39 -03:00
151 changed files with 19470 additions and 7498 deletions
+33
View File
@@ -7,6 +7,39 @@ Versão semântica da **skill** (não do projeto):
Mantido pelo subagente `cenaforge-skill-updater`. Entradas mais novas no topo. Mantido pelo subagente `cenaforge-skill-updater`. Entradas mais novas no topo.
## 1.55.0 — 18/11/2026
Clipador: detecção automática do jogo da live.
- `references/clipper.md`: banco em v17 (v16 = detecção do jogo); seção nova "Detecção do jogo da live" (pistas e pesos,
estados `user|agreed|probable|conflict|unknown`, regras de troca e de sugestão, "Detectar agora", API, painel);
`GAME_CHECK_S` 600 → 180; juiz com `screen_game_confidence`/`screen_evidence` e `Judge.detect_game`; "Testes e evidência".
- `references/gotchas.md`: 186 (jogo não detectado: serviço sem reiniciar, jogo não cadastrado, sem IA/visão, `game_id` ×
`slug`, e proxy do painel sem `game/detect`).
- `SKILL.md`: versão, `description`, linha do Clipador em "Onde mexer", faixa de itens.
- Evidência (reexecutada): suíte do Clipador exit 0 com 440 testes (15 em `test_game_detect.py`); `npx tsc --noEmit -p panel`
exit 0. Conferidos no código: `db.py` v16, rotas `PUT …/game` e `POST …/game/detect`, `session_view`, constantes de `intel.py`.
Não verificado: IA real, painel no navegador, banco real em v16. Corrigido depois: `ALLOWED` de
`panel/src/lib/clipper.ts` agora libera `sessions/<id>/game/detect` (`game(\/detect)?`).
- Sincronização com a 1.54.0 (outra sessão): versão renumerada, item de gotchas 180 → 186, banco descrito em v17.
## 1.54.0 — 18/11/2026
Clipador: vídeo de revisão × final, dublagem, falantes, expressões e Equipe de IA.
- `references/clipper-video.md` (novo): revisão × final (grupo `dev`, `dev_flags`, migração v14, `publishFile`, `POST /v1/clips/{id}/final`,
quando o final some), dublagem (`dev.dub*`, `dub.py`, cache, encaixe sem sincronia labial, tempos medidos) e falantes (WeSpeaker
ResNet34-LM CC-BY-4.0 + boca/volume, migração v15, legenda em duas linhas, `GET /v1/sessions/{id}/speakers`).
- `references/clipper-ai-team.md` (novo): papéis (`judge.roles`), juiz de contexto (7 checagens, o código decide), linha do tempo JSON +
mosaico 4×2 (`timelineJson`), medição F0 (`ai_calls`, `scene_notes`, v17, `GET /v1/judge/report`, rótulo "sem contexto"), tokens medidos.
- `references/clipper.md`: banco em v17 (v16 só citada: detecção do jogo, doc ainda fora desta branch); 4 linhas novas em "Onde mexer";
seção de expressões/pose/corpo em "Rastreio de reação" (calibração, canais novos só rotulam); `dev.translation` no lugar de
`caption.translation`; fontes em teste; bloco de evidência.
- `references/gotchas.md`: 180 (publicar só o final), 181 (proxy 404), 182 (falantes), 183 (dublagem), 184 (worktree no Windows), 185 (serviços do usuário).
- `references/panel.md`, `publishing.md`, `ai.md`, `tools.md`: ponteiros e linha do peso WeSpeaker. `SKILL.md`: versão, `description`, invariante de publicação, faixa de itens.
- Evidência: conferido no código (`db.py` v14–v17, `layout.py` `dev`/`DEFAULTS`, rotas em `main.py`, regex `ALLOWED`, `models.lock.json`,
`OPTION_DEFAULTS.timelineJson`); `onnxruntime` 1.32.0 e `mediapipe` 1.2.3 no `clipper/.venv`. Suíte do Clipador (inteira) e painel
(`tsc` + 119 testes) **informados pelo coordenador, não reexecutados**. Medidas de tempo/tokens/estabilidade vêm de `doc/clipador/`.
Não verificado: serviços reais com o código novo, UI no navegador, IA/TTS reais além dos cortes citados.
## 1.53.0 — 18/11/2026 ## 1.53.0 — 18/11/2026
IA: monitor de uso do limite e 4º provedor (Antigravity CLI). IA: monitor de uso do limite e 4º provedor (Antigravity CLI).
File diff suppressed because one or more lines are too long
@@ -15,6 +15,7 @@ headless). Não duplique aqui; este arquivo diz onde mexer e o que não quebrar.
| API | `panel/src/app/api/ai/route.ts` (`GET/PUT /api/ai`), `.../ai/[provider]/route.ts` (`POST {action: install\|login\|verify\|test\|resume\|usage}`, `PUT/DELETE` = chave) | guarda `Origin`/JSON (gotchas, item 125) | | API | `panel/src/app/api/ai/route.ts` (`GET/PUT /api/ai`), `.../ai/[provider]/route.ts` (`POST {action: install\|login\|verify\|test\|resume\|usage}`, `PUT/DELETE` = chave) | guarda `Origin`/JSON (gotchas, item 125) |
| Tela | `panel/src/components/ai-settings.tsx` em `panel/src/app/settings/ai/page.tsx`; seletor de provedor em `agent-console.tsx` e `story-composer.tsx` | — | | Tela | `panel/src/components/ai-settings.tsx` em `panel/src/app/settings/ai/page.tsx`; seletor de provedor em `agent-console.tsx` e `story-composer.tsx` | — |
| Subpáginas de Configurações | `panel/src/app/settings/{ai,publishing,apps,browser,modes}/page.tsx` + `layout.tsx`; seções em `SETTINGS_SECTIONS` de `components/settings-shell.tsx` (o menu lateral `sidebar-nav.tsx` as lê como `children`); `/settings` redireciona para `/settings/ai` | seção nova = entrada em `SETTINGS_SECTIONS` + pasta | | Subpáginas de Configurações | `panel/src/app/settings/{ai,publishing,apps,browser,modes}/page.tsx` + `layout.tsx`; seções em `SETTINGS_SECTIONS` de `components/settings-shell.tsx` (o menu lateral `sidebar-nav.tsx` as lê como `children`); `/settings` redireciona para `/settings/ai` | seção nova = entrada em `SETTINGS_SECTIONS` + pasta |
| Papéis do juiz (varredura/analista/editor/juiz de contexto, cada um com provedor+modelo+raciocínio+instruções; reserva por papel) | `clipper/app/roles.py`, `judge.py` (`Judge.ask(role=…)`), `panel/src/components/clipper-ai-team.tsx` — [clipper-ai-team.md](clipper-ai-team.md) | `clipper/tests/test_roles.py` |
| Juiz do Clipador (3 provedores, reserva por chamada) | `clipper/app/judge.py` (`_gemini`, `find_gemini`, `parse_gemini_output`), leitura de settings e cofre `clipper/app/ai_settings.py` (DPAPI por `ctypes`), `main.py`, `config.py`, `intel.py` | `clipper/tests/test_ai_fallback.py`, `conftest.py`, `clipper/README.md` | | Juiz do Clipador (3 provedores, reserva por chamada) | `clipper/app/judge.py` (`_gemini`, `find_gemini`, `parse_gemini_output`), leitura de settings e cofre `clipper/app/ai_settings.py` (DPAPI por `ctypes`), `main.py`, `config.py`, `intel.py` | `clipper/tests/test_ai_fallback.py`, `conftest.py`, `clipper/README.md` |
## Regras ## Regras
@@ -0,0 +1,74 @@
# Clipador — Equipe de IA: papéis, juiz de contexto, linha do tempo JSON e medição (18/11/2026)
Fontes do contrato: `doc/clipador/EQUIPE-IA.md` (o que foi feito, F0 + F1) e `doc/clipador/PESQUISA-JUIZ.md` (pesquisa; F2
OCR do HUD/YAMNet e F3 VLM local **não** entraram — são só candidatas). Visão geral: [clipper.md](clipper.md); provedores e
reserva: [ai.md](ai.md). Migração v17 (`ai_calls`, `scene_notes`, `clips.owner_label/owner_note`).
## Papéis (`clipper/app/roles.py`, `settings` chave `judge.roles`)
| `id` | Faz | Imagem | Desligável |
|---|---|---|---|
| `scan` (varredura) | assiste por janelas, propõe momentos, descreve os quadros (`lines`) | mosaico 4×2 (padrão), soltos ou nenhuma | sim (`scanEnabled`) |
| `analyst` | diz O QUE aconteceu no candidato | idem | sim (o editor passa a receber imagens) |
| `editor` | decide corte, trecho, título, legenda, hashtags | só se o analista falhou/está off | **não** |
| `judge` | só texto: o corte faz sentido para quem nunca viu a live? | nunca | sim |
- Cada papel: `enabled`, `provider`, `model` (`""` = padrão do provedor), `effort` (só Codex; `""` = low; juiz começa em
`medium`), `extra` = **instruções do administrador** (≤ 2.000 caracteres, entram DEPOIS das padrão, que ficam no código e o
painel mostra só para leitura: `GET /v1/judge` → `roleDefaults.<papel>.pt|en`). Juiz também: `critical`
(`setup`,`payoff`,`standalone`), `allowFix`, `allowContextLine`, `penalty` (0,5). Validação: `roles.normalize_roles`.
- Banco sem `judge.roles` migra sozinho (o provedor/modelo único vira o de todos; `judge_analyst_model` fica no analista).
`judge_provider = "off"` continua = equipe inteira desligada. `PUT /v1/judge` sem `roles` (painel antigo) vale para todos.
Reserva por papel: `fallback_chain(primary)` começa na IA do papel. Tradução, perfil do jogo e câmera usam a IA do **editor**.
## Juiz de contexto (`context_judge.py`, `judge.check_context`)
Roda depois que o editor MANTEVE (nota ≥ mínima). Vê só o que vai no corte + 20 s antes/15 s depois marcados `out=1`, título,
legenda, abertura, `what_happened` e linha do jogo. Escreve `viewer_summary` e responde 7 checagens: `setup`, `payoff`,
`standalone` (críticas) · `who_what`, `intelligible`, `faithful`, `strong_open`. **O código decide** (`context_judge.decide`):
1. crítica falha + `fix` (e `allowFix`) → recalcula com `fit_window`; mudou ≥ 1 s = **ajusta** e confere **uma** vez; falhou = descarta;
2. crítica falha sem ajuste → **descarta** com motivo em português;
3. `standalone`/`who_what` falhos + `context_line` curta (≤ 10 palavras, ≤ 60 caracteres) → aprova e a frase vira o texto de abertura;
4. não críticas falhas tiram `penalty` da nota; abaixo da mínima → descarta;
5. corte manual: só **avisa** (`decision: "warn"`); falha da IA do juiz: vale o editor (`context: {error}`).
Gravado em `judge_json.context`; descartado pelo juiz = `status = discarded` + `judge_json.discardedBy = "context"` (aparece em
"Descartados"; **Forçar render** funciona). Fonte em inglês: `CONTEXT_SCHEMA_EN` com bloco `pt`. Fora do F1: 2ª opinião
com outro provedor, few-shot do dono, "testar nos últimos 10 cortes".
## Linha do tempo JSON e mosaico (`timeline.py`, `media.mosaic`)
- JSON Lines com chaves curtas: `t,d` · `v` (o que está na tela, ≤ 12 palavras; vem de `lines` da varredura/analista e fica em
`scene_notes`) · `sp` (fala literal ≤ 25 palavras; `[other1]` = outra pessoa) · `face` (rótulo de `reaction.label` com
intensidade ≥ 3) · `lvl` (só se ≥ 6 ou ≤ 1) · `chat`. Entrada nova a cada pausa > 1,2 s (se a atual tem ≥ 4 s), troca de
falante ou 8 s. Orçamento de caracteres por papel (analista 9.000, editor 7.000, juiz 6.000, varredura 9.000): passou, a
fala encurta (25 → 12 → 6 palavras). Perfil do jogo enxuto (`judge.lean_profile`).
- Imagens: 8 quadros de 384×216 numa grade 4×2 = 1 imagem 1536×432; falhou = quadros soltos.
- Opção **`timelineJson`** (`PUT /v1/judge`, padrão ligada): desligada = formato antigo (transcrição + chat + quadros de
768 px). Cada chamada grava o modo em `ai_calls.mode` (`timeline+mosaic`, `legacy+frames`…) — é como se compara.
- **Medido** (corte 291, sessão 15, tfue, IA falsa que guarda o prompt; fórmulas de imagem da pesquisa): analista 5.638 →
3.104 tokens (−45 %), editor 2.795 → 2.250 (−20 %), varredura 5.330 → 3.311 (−38 %), juiz novo ≈ 1.420. Por hora (tfue):
≈ 317 mil → ≈ 224 mil **com** o juiz (−29 %). **Uma** chamada real do juiz (Codex `gpt-6-luna`, esforço médio): 9.624 de
entrada, 1.400 de saída, 27 s ⇒ o **fixo da CLI do Codex ≈ 8 mil tokens por chamada** é o maior item e o próximo alvo
(gotchas, item 136; [token-economy.md](token-economy.md)).
## Medição (F0)
- `ai_calls` (v17): por tentativa — `role`, `purpose`, `provider`, `model`, `ok/error`, `ms`, tamanhos de prompt/imagem,
`tokens_in/out/cached` (quando a CLI informa: `codex exec --json`, `claude --output-format json`, `gemini -o json`),
`session_id`, `clip_id`, `mode`. O `codex exec` agora roda com `--json` (a resposta continua em `-o`).
- Avaliação do dono: `clips.owner_label` (`good|bad|no_context`) + `owner_note`. `PATCH /v1/clips/{id}` com
`{"label": "no_context"}` (vale para qualquer corte, não muda o estado) ou `{"status": "rejected", "label": "no_context"}`
(botão **Sem contexto** no modal). Sem rótulo: aprovado/publicado = bom, rejeitado = ruim.
- `GET /v1/judge/report?days=7` (ou `?session=N`): chamadas por papel × IA × modo, tokens por hora, cortes, juiz
(aprovou/ajustou/descartou/avisou/erro), concordância e κ de Cohen. Painel: Ajustes → Juiz → Medição. Rota na regex
`ALLOWED` do painel (`judge(\/report)?`).
## Onde está cada coisa
`roles.py` (papéis, validação, migração) · `judge.py` (`Judge.ask(role=…)`, `check_context`, `build_*_prompt`, `lean_profile`,
`codex_usage`/`claude_usage`/`gemini_usage`, `scope`) · `context_judge.py` · `timeline.py` · `worker.py` (`judge_clip`:
analista → editor → juiz; `_context_check`; `record_ai_call`) · `intel.py` (`visual`, varredura, `timelineJson`) · `report.py`.
Painel: `clipper-ai-team.tsx` (cartões e medição), `clipper-judge.tsx`, `clipper-clip-parts.tsx` (`ContextVerdict`,
`OwnerLabelControl`). Testes: `test_roles.py`, `test_context_judge.py`; `conftest._no_real_ai_cli` bloqueia qualquer CLI real.
@@ -0,0 +1,92 @@
# Clipador — vídeo de revisão × final, dublagem e falantes (18/11/2026)
Fontes do contrato (leia antes de mexer, não duplique aqui): `doc/clipador/REVISAO.md`, `DUBLAGEM.md`, `FALANTES.md`.
Visão geral do serviço: [clipper.md](clipper.md). Só vale depois de reiniciar o Clipador (gotchas, item 144).
## Revisão × final (`doc/clipador/REVISAO.md`, migração v14)
Regra do dono: o vídeo que a equipe aprova tem camadas **só de desenvolvimento**; ao aprovar, o Clipador renderiza de novo
**sem elas** e só esse vai para as redes.
```
fila de render ─► clip-<id>.mp4 REVISÃO (dev=True) ─► Aprovar ─► clip-<id>-final.mp4 (+ -final.jpg, -final-cover.jpg) (dev=False)
review_dev_json = [] ? ─► o de revisão JÁ É o final (sem render novo; final.reused = true)
```
- **Camadas `dev`** (grupo `dev` da configuração do corte, `layout.py`): `translation` (português embaixo da legenda) e
`dub` (dublagem). `layout.dev_flags(cfg, dev=False)` desliga todas. `caption.translation` é legado: conta como
`dev.translation`.
- Render da fila = `worker._render_clip` → `editor_api.render_clip_edit(..., dev=True)`; grava `clips.review_dev_json`
(camadas que entraram de fato, `editor_api.review_layers`). Final: `Engine.render_pending` (finais primeiro, até 3 por
volta), mesmo projeto de edição, `dev=False`, não grava `review_dev_json`.
- Banco v14: `clips.review_dev_json` (`[]` = nenhuma; NULL = desconhecido), `final_status` (`pending|rendering|ready|error`;
NULL = sem final), `final_file/thumb/cover/error/at`. Falha no final = `error` + `final_error`; o corte segue aprovado e
nada é publicado. Serviço caído no meio: `rendering` volta a `pending` na subida.
- **O final some** (`drop_final`) ao: desfazer aprovação/rejeitar; mudar `startS/endS` de aprovado; `POST /export`,
`/render`, `/rejudge`; qualquer render de revisão novo. Desaprovar durante o render do final descarta o resultado.
`clip_delete` apaga `clip-<id>-*` e recusa enquanto o final renderiza.
- API: cada corte traz `review: {devLayers}`, `final: {status,file,thumb,cover,error,at,reused} | null` e `publishFile`
(= `final.file` se `approved|published` com final `ready`; senão `null`). `file`/`thumb` continuam os de revisão.
`POST /v1/clips/{id}/final` (re)gera ("Tentar de novo"; 409 se não aprovado). Rota na regex `ALLOWED` e em `METHODS`
(`panel/src/lib/clipper.ts`).
- **Publicação (painel):** `clipPublishFile(clip)` em `panel/src/lib/publishing-rules.ts` devolve `publishFile` ou o motivo
de esperar; **nunca** `file` quando o Clipador manda o campo (Clipador antigo, sem `publishFile`, segue com `file`).
`sendDue` (`publishing.ts`) relê o corte (`clipFinalForJob`): sem final pronto o job espera ("Esperando o vídeo final…");
com final, troca `file` (e a capa) e envia. Capa: a do final primeiro. Regras gerais: [publishing.md](publishing.md).
- `prune` (`CLIPPER_KEEP_HOURS`) guarda o trecho de quem ainda vai precisar do final (aprovado com final pendente/erro;
pronto com camada de teste ou desconhecida). Corte sem camada de teste não segura blocos.
- Painel: etiqueta `revisão · teste` / `gerando final` / `final` / `final com erro` na lista; modal com player
**Final / Revisão**, "Tentar de novo" e "Gerar vídeo final"; aviso no diálogo Publicar. Teste:
`clipper/tests/test_final_render.py`, `publishing-rules.test.ts`, `publishing-db.test.ts`.
- Sem tradução (fonte em português) não há dublagem nem tradução: o de revisão já é o final.
## Dublagem em português (`dub.py`, `doc/clipador/DUBLAGEM.md`)
Para fonte em inglês, só no vídeo de revisão, para a equipe entender o contexto. **Sem sincronia labial** (pedido do dono).
| Chave (`dev.*`) | Padrão | O quê |
|---|---|---|
| `dub` | `false` | liga a dublagem no vídeo de revisão (aba Legenda → "Dublagem em português (teste)") |
| `dubVoice` | `pt-br-antonio` | voz do streamer (Edge, online) |
| `dubVoiceOther` | `kokoro-pm-alex` | voz das falas `speaker: "other…"` (Kokoro, offline) |
| `dubDuck` | `0.25` | volume do áudio original enquanto a dublagem toca (0–1) |
- **Só vozes TTS prontas**; nunca clonar a voz do streamer (terceiro sem consentimento); o painel não lista clonadas.
- Frases de `clips.translation_json` → tempo de saída → `POST /v1/synthesize` do serviço de voz (`format: "wav"`,
`speed: 1.05`; voz que falha cai em `pt-br-faber`). Cache `data/clipper/dub/` por (voz, velocidade, texto), −16 LUFS,
48 kHz mono, 30 dias sem uso apaga. Encaixe `fit`: fala em velocidade natural, pode escorrer até 1,5 s sobre a próxima
frase (sem acumular); só então acelera até 1,2× e, se ainda não couber, corta com fade. Original abaixa para `dubDuck`
(rampa 0,15 s) só onde há dublagem; dublagem 6 dB acima do volume médio do corte (−20…+3 dB).
- Prévia do editor e render da fila usam o mesmo caminho (`dub.for_engine`). Serviço de voz fora = sai sem dublagem.
- **Medido** (corte 259 do tfue, 54,5 s, 25 frases, NVENC, informado em `DUBLAGEM.md`): sem dublagem 5,8 s; 1ª vez
+29 a +41 s (~1,6 s/frase, 3 em paralelo; 6 não ajudam); cache pronto +0,3 s; prévia de 5 s com cache 1,2 s. Conversa
densa: o português fica bem mais longo (9 das 25 falas terminaram cortadas com fade). Teste: `test_dub.py` (TTS falso).
## Quem fala (`speakers.py`, `voiceprint.py`, `doc/clipador/FALANTES.md`, migração v15)
O áudio da live é um canal só: streamer, colegas no Discord e voz do jogo misturados. **As outras vozes NÃO estão na
câmera**; a webcam só ajuda a confirmar qual voz é o streamer.
- **Impressão de voz:** WeSpeaker ResNet34-LM (`models.lock.json` id `wespeaker_r34`, pesos **CC-BY-4.0**, atribuição
"WeSpeaker, wenet-e2e", 26,5 MB, sha256 no lock) no `onnxruntime` (sem PyTorch; fbank reimplementado em numpy). Nada de
pyannote/SpeechBrain/NeMo/Resemblyzer (pedem PyTorch). 3D-Speaker CAM++ ficou fora: licença dos pesos não conferida.
- Etapas: `speakers.index_block` (logo após o Whisper, 0,19 s de CPU por bloco de 30 s) → `face.MouthMeter` (YuNet, boca na
webcam, +0,5 s por bloco) → `speakers.build_model` sob demanda (0,05 s em 72 min; refeito na leitura, o rótulo melhora
sozinho com a live). Tabela `voice_chunks (session_id, idx, data_json, updated_at)` = **migração v15** (~0,6 MB/h).
- Regras: trechos ≤ 3 s, fecham em `. ? !`; voz = grupo com ≥ 15 s de fala (cosseno ≥ 0,5). Streamer = a voz que bate com a
boca (t de Welch ≥ 3) **e/ou** a mais forte (≥ 3 dB acima da 2ª). **Discordam ou nenhuma decide → ninguém vira
"outro"** (tudo do streamer, como antes). Trecho só vira `otherN` com folga (cosseno ≥ 0,30 e ≥ 0,10 acima do streamer).
- Dados: `scoring.Word.speaker` (`""`/`"streamer"` ou `"other1"…`); `segments.words_json` aceita o 4º elemento; o projeto do
editor ganha `sp` por palavra (projeto antigo sem `sp` sai igual); `translation_json` por linha tem `speaker` e frases
nunca misturam falantes (tradução antiga sem `speaker` é refeita). `GET /v1/sessions/{id}/speakers` mostra as vozes e
o porquê. Opção `speakers` (`intel.opts`, padrão ligada) desliga tudo.
- **Legenda em duas linhas:** streamer na posição normal; outra pessoa logo abaixo (`caption.otherColor` `#5CE1FF`,
`caption.otherSize` vazio = 85 % de `size`); no horizontal a linha do streamer sobe. Estilos `CaptionOther`/`KaraokeOther`
só entram no ASS quando há outra pessoa: corte só com o streamer sai byte a byte igual (teste dourado do vertical).
Editor: botão **Outra pessoa / É o streamer** corrige palavras selecionadas.
- **Juízes:** `judge._transcript` marca `[Tfue]`/`[other1]` e manda "Never attribute to Tfue what someone else said".
- **Medido** (sessão 15, tfue, 144 blocos, só leitura; em `FALANTES.md`): 3 vozes; volume do streamer +7,5 dB sobre os
colegas; boca sozinha **não** resolve (webcam de perfil, AUC 0,55–0,64), quem decide é o volume; estabilidade 84 % aos
5 min, 98 % aos 10, 99 % aos 40. Conferência visual às cegas fraca (rosto de 45 px). Sem gabarito de áudio.
- Limites: troca de falante sem pausa nem pontuação fica com um rótulo; primeiros minutos (< 15 s de fala por voz) sem
atribuição; vozes de NPC também viram "outra pessoa"; modelo indisponível = blocos sem impressão (não refeitos).
+94 -11
View File
@@ -12,7 +12,7 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
| O quê | Onde | | O quê | Onde |
|---|---| |---|---|
| Banco do Clipador | `data/clipper/clipper.db` (`PRAGMA user_version` 13, `SCHEMA` em `clipper/app/db.py`: v1 tabelas, v2 `settings`, v3 jogo/varredura/emotes/configuração do corte — colunas novas em `sessions`, `channels.settings_json`, `chat.emotes`, `clips.learned`, tabelas `games` e `emotes`; v4 `edits` (`clip_id`, `project_json`, `rev`, `cover`, `exported_at`, `created_at`, `updated_at`); v5 `face_track`; v6 `games.notes_json`/`games.edited_at`; v7 `edits.origin` (`ai`/`user`) + `edits.ai_project_json`; v8 `clips.aspect` (`vertical`/`horizontal`, padrão `vertical`, gravado no render); v9 `sessions.capture_json` (o que a captura gravou de fato; sessões antigas `NULL`); v10 tabela `deleted_clips` (marca do corte apagado, `ON DELETE CASCADE` com a sessão); v11 `channels.monitor_paused_at`/`monitor_paused_session`/`language` e `sessions.language`, padrão `''` = `CLIPPER_LANGUAGE`; v12 `games.profile_ai_json` (perfil em inglês), `translated_at`, `aliases_json`; v13 `clips.translation_json`, fala do corte em frases + português). Migra ao subir o serviço. **Nunca altere uma migração já aplicada** (o banco real estava em v4 quando a v7 nasceu): coluna nova = `ALTER` numa versão nova | | Banco do Clipador | `data/clipper/clipper.db` (`PRAGMA user_version` 17, `SCHEMA` em `clipper/app/db.py`: v1 tabelas, v2 `settings`, v3 jogo/varredura/emotes/configuração do corte — colunas novas em `sessions`, `channels.settings_json`, `chat.emotes`, `clips.learned`, tabelas `games` e `emotes`; v4 `edits` (`clip_id`, `project_json`, `rev`, `cover`, `exported_at`, `created_at`, `updated_at`); v5 `face_track`; v6 `games.notes_json`/`games.edited_at`; v7 `edits.origin` (`ai`/`user`) + `edits.ai_project_json`; v8 `clips.aspect` (`vertical`/`horizontal`, padrão `vertical`, gravado no render); v9 `sessions.capture_json` (o que a captura gravou de fato; sessões antigas `NULL`); v10 tabela `deleted_clips` (marca do corte apagado, `ON DELETE CASCADE` com a sessão); v11 `channels.monitor_paused_at`/`monitor_paused_session`/`language` e `sessions.language`, padrão `''` = `CLIPPER_LANGUAGE`; v12 `games.profile_ai_json` (perfil em inglês), `translated_at`, `aliases_json`; v13 `clips.translation_json`, fala do corte em frases + português; v14 vídeo de revisão × final (`clips.review_dev_json`, `final_status/file/thumb/cover/error/at`); v15 `voice_chunks` (impressão de voz); v16 detecção do jogo (`sessions.game_status`, `game_detect_json`; vem de outra frente, o doc `DETECCAO-JOGO.md` ainda não está nesta branch); v17 `ai_calls`, `scene_notes`, `clips.owner_label/owner_note`). Detalhes de v14–v15 em [clipper-video.md](clipper-video.md), de v17 em [clipper-ai-team.md](clipper-ai-team.md). Migra ao subir o serviço. **Nunca altere uma migração já aplicada** (o banco real estava em v4 quando a v7 nasceu): coluna nova = `ALTER` numa versão nova |
| Blocos gravados (`.ts` de 30 s + `segments.csv`) e frames | `data/clipper/sessions/<id>/` (frames em `frames/`) | | Blocos gravados (`.ts` de 30 s + `segments.csv`) e frames | `data/clipper/sessions/<id>/` (frames em `frames/`) |
| Pesos do rastreio de reação (YuNet, MediaPipe, OpenSeeFace) | `data/clipper/models/`, fixados (URL imutável + sha256) em `clipper/models.lock.json` | | Pesos do rastreio de reação (YuNet, MediaPipe, OpenSeeFace) | `data/clipper/models/`, fixados (URL imutável + sha256) em `clipper/models.lock.json` |
| Cortes prontos | `output/clipper/<sessão>/clip-<id>.mp4` + `clip-<id>.jpg` | | Cortes prontos | `output/clipper/<sessão>/clip-<id>.mp4` + `clip-<id>.jpg` |
@@ -31,13 +31,19 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
| Apagar cortes (`delete_clip`, `delete_many`, `select_ids`, `MAX_BATCH` 500, recusas `BUSY`/`PUBLISHED`/`CHANGED`, marca `marks`/`mark_spans`, arquivos só dentro das pastas do Clipador) | `clipper/app/clip_delete.py`; rotas em `main.py` (`ClipsDeleteIn`); marca lida em `worker.py` (veto depois do juiz) e na varredura (`intel.py`) | `clipper/tests/test_clip_delete.py`; `METHODS` em `panel/src/lib/clipper.ts`; seção "Apagar cortes" abaixo | | Apagar cortes (`delete_clip`, `delete_many`, `select_ids`, `MAX_BATCH` 500, recusas `BUSY`/`PUBLISHED`/`CHANGED`, marca `marks`/`mark_spans`, arquivos só dentro das pastas do Clipador) | `clipper/app/clip_delete.py`; rotas em `main.py` (`ClipsDeleteIn`); marca lida em `worker.py` (veto depois do juiz) e na varredura (`intel.py`) | `clipper/tests/test_clip_delete.py`; `METHODS` em `panel/src/lib/clipper.ts`; seção "Apagar cortes" abaixo |
| Parar à mão e pausa do monitor (`Engine.stop_session(id, pause_monitor=True)`, `StopIn.pauseMonitor`), idioma por fonte/sessão (`check_language`, visões de fonte/sessão/corte com `language` resolvido; Whisper e `judge.output_language_note`) | `clipper/app/worker.py`, `main.py`, `db.py` (v11), `judge.py`; painel `ACCOUNT_LANGUAGES` em `panel/src/lib/languages.ts` | `clipper/tests/test_monitor_pause_and_language.py` (9); seção "Parar é parar e idioma" abaixo | | Parar à mão e pausa do monitor (`Engine.stop_session(id, pause_monitor=True)`, `StopIn.pauseMonitor`), idioma por fonte/sessão (`check_language`, visões de fonte/sessão/corte com `language` resolvido; Whisper e `judge.output_language_note`) | `clipper/app/worker.py`, `main.py`, `db.py` (v11), `judge.py`; painel `ACCOUNT_LANGUAGES` em `panel/src/lib/languages.ts` | `clipper/tests/test_monitor_pause_and_language.py` (9); seção "Parar é parar e idioma" abaixo |
| Fonte em outro idioma (inglês): prompts `*_EN`, schemas com bloco `pt`, `lang_key`, `translate_lines`, `translate_clip`, `voice_language`, `phrases`, legenda `Trans` | `clipper/app/judge.py`, `intel.py` (`Intel.lang`), `worker.py`, `subtitles.py`, `scoring.py`, `layout.py`, `editor_render.py`, `editor_api.py` (`translation_for`), `main.py`; painel `clipper-client.ts`, `clipper-clip-dialog.tsx`, `clipper-clip-parts.tsx`, `clipper-clip-table.tsx`, `clipper-session-detail.tsx`, `clipper-cut-settings.tsx` | `clipper/tests/test_english_source.py` (9); seção "Fonte em inglês" abaixo | | Fonte em outro idioma (inglês): prompts `*_EN`, schemas com bloco `pt`, `lang_key`, `translate_lines`, `translate_clip`, `voice_language`, `phrases`, legenda `Trans` | `clipper/app/judge.py`, `intel.py` (`Intel.lang`), `worker.py`, `subtitles.py`, `scoring.py`, `layout.py`, `editor_render.py`, `editor_api.py` (`translation_for`), `main.py`; painel `clipper-client.ts`, `clipper-clip-dialog.tsx`, `clipper-clip-parts.tsx`, `clipper-clip-table.tsx`, `clipper-session-detail.tsx`, `clipper-cut-settings.tsx` | `clipper/tests/test_english_source.py` (9); seção "Fonte em inglês" abaixo |
| Vídeo de revisão × final (`dev_flags`, `render_clip_edit(dev=…)`, `review_layers`, `render_final`, `drop_final`, rota `POST /v1/clips/{id}/final`, `publishFile`) | `clipper/app/layout.py`, `editor_api.py`, `worker.py`, `main.py`; painel `panel/src/lib/publishing-rules.ts` (`clipPublishFile`), `publishing.ts` (`sendDue`), `clipper-clip-dialog.tsx`, `clipper-clip-table.tsx` | `clipper/tests/test_final_render.py`, `publishing-rules.test.ts`, `publishing-db.test.ts`; seção em [clipper-video.md](clipper-video.md) |
| Dublagem em português (`dev.dub*`, TTS, cache, encaixe, `duck`) | `clipper/app/dub.py` + `editor_render.py` (mistura) + serviço de voz `POST /v1/synthesize` | `clipper/tests/test_dub.py`; [clipper-video.md](clipper-video.md) |
| Falantes (streamer × `otherN`): impressão de voz, boca, legenda em duas linhas, `GET /v1/sessions/{id}/speakers` | `clipper/app/speakers.py`, `voiceprint.py`, `face.py` (`MouthMeter`), `subtitles.py`, `judge.py` (`_transcript`); peso `wespeaker_r34` em `clipper/models.lock.json` | `clipper/tests/test_speakers.py`; [clipper-video.md](clipper-video.md) |
| Expressões, pose da cabeça e corpo do streamer; mapa de expressões | lógica `clipper/app/reaction.py` (`label`, `body_moments`, `expression_map`, `extra_weights`), E/S `face.py` (`pose_from_matrix`, reserva do YuNet); painel `clipper-face-map.tsx` | `clipper/tests/test_expressions.py`; seção "Expressões" em "Rastreio de reação" abaixo |
| Equipe de IA: papéis (`judge.roles`), juiz de contexto, linha do tempo JSON + mosaico (`timelineJson`), medição (`ai_calls`, `GET /v1/judge/report`), rótulo do dono | `clipper/app/roles.py`, `context_judge.py`, `timeline.py`, `report.py`, `judge.py`, `worker.py`, `intel.py`; painel `clipper-ai-team.tsx`, `clipper-judge.tsx`, `clipper-clip-parts.tsx` | `clipper/tests/test_roles.py`, `test_context_judge.py`; [clipper-ai-team.md](clipper-ai-team.md) |
| Chat (IRC anônimo da Twitch com `CAP REQ :twitch.tv/tags` → emotes nativos e `room-id`; Pusher da Kick, emotes `[emote:id:NOME]`) | `clipper/app/chat.py` | — | | Chat (IRC anônimo da Twitch com `CAP REQ :twitch.tv/tags` → emotes nativos e `room-id`; Pusher da Kick, emotes `[emote:id:NOME]`) | `clipper/app/chat.py` | — |
| Heurística: pesos, base de 3 min, mínimo proporcional (`_required_messages`), reações (`min_reactions`), chat fraco (`sparse_rate` 0,5 msg/s), momentos do chat/áudio/rosto (`_chat_moments`/`_audio_moments`/`_face_moments`; `face_*` em `Params`), `pick_peaks`, `fit_window` (duração de todo corte automático) | `Params` e funções em `clipper/app/scoring.py`; alvo `min_target` em `layout.py` | `clipper/tests/test_scoring.py` (regressões de falso positivo, chat fraco e rosto), `test_duration_banner_fonts.py` | | Heurística: pesos, base de 3 min, mínimo proporcional (`_required_messages`), reações (`min_reactions`), chat fraco (`sparse_rate` 0,5 msg/s), momentos do chat/áudio/rosto (`_chat_moments`/`_audio_moments`/`_face_moments`; `face_*` em `Params`), `pick_peaks`, `fit_window` (duração de todo corte automático) | `Params` e funções em `clipper/app/scoring.py`; alvo `min_target` em `layout.py` | `clipper/tests/test_scoring.py` (regressões de falso positivo, chat fraco e rosto), `test_duration_banner_fonts.py` |
| Rastreio de reação — E/S: backends (MediaPipe; plano B OpenSeeFace), download sob demanda com sha256, recorte FFmpeg 6 qps, laço `face` | `clipper/app/face.py` (`for_scoring`, `must_wait`, `view`, `reset`); laço `_face_loop` e uso de `must_wait` na decisão do corte em `worker.py`; bancada `clipper/tools/face_bench.py` | `clipper/tests/test_face.py`, `clipper/models.lock.json`, `doc/FACE_BAKEOFF.md` | | Rastreio de reação — E/S: backends (MediaPipe; plano B OpenSeeFace), download sob demanda com sha256, recorte FFmpeg 6 qps, laço `face` | `clipper/app/face.py` (`for_scoring`, `must_wait`, `view`, `reset`); laço `_face_loop` e uso de `must_wait` na decisão do corte em `worker.py`; bancada `clipper/tools/face_bench.py` | `clipper/tests/test_face.py`, `clipper/models.lock.json`, `doc/FACE_BAKEOFF.md` |
| Rastreio de reação — lógica pura: sinal por segundo contra o neutro do streamer, rótulos, `reaction_moments`, `summarize` (linha do analista), `locate_cam` (câmera pelo rosto) | `ReactionParams` e funções em `clipper/app/reaction.py` | `clipper/tests/test_reaction.py` | | Rastreio de reação — lógica pura: sinal por segundo contra o neutro do streamer, rótulos, `reaction_moments`, `summarize` (linha do analista), `locate_cam` (câmera pelo rosto) | `ReactionParams` e funções em `clipper/app/reaction.py` | `clipper/tests/test_reaction.py` |
| Emotes: catálogo 7TV/BTTV/FFZ (canal + global, TTL 1 h, fonte que falha é ignorada), emojis, peso aprendido (`LEARN_UP`/`LEARN_DOWN` 0,3/0,15) | `clipper/app/emotes.py`; ingestão e aprendizado em `clipper/app/intel.py` (`ingest_chat`, `learn_from_clip`) | `clipper/tests/test_intel.py` | | Emotes: catálogo 7TV/BTTV/FFZ (canal + global, TTL 1 h, fonte que falha é ignorada), emojis, peso aprendido (`LEARN_UP`/`LEARN_DOWN` 0,3/0,15) | `clipper/app/emotes.py`; ingestão e aprendizado em `clipper/app/intel.py` (`ingest_chat`, `learn_from_clip`) | `clipper/tests/test_intel.py` |
| Contexto do jogo (categoria a cada `GAME_CHECK_S` 600, `screen_game`, perfil pela web; `clean_profile`, `save_profile`, `refine`, `delete_note`; perfis bilíngues, `add_game`, `delete_game`, `translate`, aliases, `import_seeds` de `clipper/app/seeds/games/*.json`; contrato em `doc/clipador/JOGOS.md`), varredura (`SCAN_*`), webcam (`detect_cam`: YuNet local primeiro, IA só se não achar ou `use_ai`; `CAM_RETRY_S` 300), opções `OPTION_DEFAULTS` (inclui `faceTrack`) | `clipper/app/intel.py` | README do Clipador | | Detecção do jogo da live (`check_game` a cada `GAME_CHECK_S` 180, `detect_game`, `detect_game_now`, `note_screen`, `canon`, `gather_evidence`; regra pura `Evidence`/`fuse`/`count_mentions`/`is_generic`; `sessions.game_status`/`game_detect_json`) | `clipper/app/game_detect.py` (regra) + `intel.py` (pistas e aplicação); `judge.py` (`GAME_SYSTEM`/`GAME_SCHEMA`, `Judge.detect_game`); `main.py` (`session_view`: `gameStatus`, `gameDetect`; `PUT …/game`, `POST …/game/detect`); painel `clipper-games.tsx` (`SessionGame`), `clipper-client.ts` (`GameStatus`, `GameDetect`, `GAME_CLUE_LABEL`, `gameNeedsReview`) — seção "Detecção do jogo da live" abaixo | `clipper/tests/test_game_detect.py`; `doc/clipador/DETECCAO-JOGO.md`; `ALLOWED` em `panel/src/lib/clipper.ts` (gotchas, item 180) |
| Juízes (analista + editor), prompts, glossário `CHAT_GLOSSARY`, linha "Rosto do streamer: …" do analista, schemas, chamada da CLI, pesquisa e refino do jogo (`PROFILE_SYSTEM`/`research_game`, `REFINE_SYSTEM`/`refine_game`), câmera | `clipper/app/judge.py`; montagem dos 6 frames do analista (8 se o trecho passa de 80 s) em `worker.py` | README do Clipador | | Contexto do jogo (`screen_game` da varredura, perfil pela web; `clean_profile`, `save_profile`, `refine`, `delete_note`; perfis bilíngues, `add_game`, `delete_game`, `translate`, aliases, `import_seeds` de `clipper/app/seeds/games/*.json`; contrato em `doc/clipador/JOGOS.md`), varredura (`SCAN_*`), webcam (`detect_cam`: YuNet local primeiro, IA só se não achar ou `use_ai`; `CAM_RETRY_S` 300), opções `OPTION_DEFAULTS` (inclui `faceTrack`) | `clipper/app/intel.py` | README do Clipador |
| Juízes (analista + editor), prompts, glossário `CHAT_GLOSSARY`, linha "Rosto do streamer: …" do analista, schemas, chamada da CLI, pesquisa e refino do jogo (`PROFILE_SYSTEM`/`research_game`, `REFINE_SYSTEM`/`refine_game`), câmera, detecção do jogo pela tela (`SCAN_SCHEMA` exige `screen_game_confidence` high\|medium\|low e `screen_evidence`; `Judge.detect_game(images, live_title)` com 3 frames) | `clipper/app/judge.py`; montagem dos 6 frames do analista (8 se o trecho passa de 80 s) em `worker.py` | README do Clipador |
| Hashtags da legenda (`to_tag`, `fold`, `split_hashtags`, `compose`, `build_caption`; `MAX_TAGS` 8, `GAME_TAGS` 3, `MOMENT_TAGS` 4) | `clipper/app/hashtags.py`; uso em `judge_clip` de `worker.py`; campo `hashtags` em `judge.py` (`VERDICT_SCHEMA`, `PROFILE_SCHEMA`, `Verdict.hashtags`) e `PROFILE_LISTS`/`clean_profile`/`Intel.session_game` em `intel.py` — ver "Hashtags da legenda" abaixo | `clipper/tests/test_hashtags.py` | | Hashtags da legenda (`to_tag`, `fold`, `split_hashtags`, `compose`, `build_caption`; `MAX_TAGS` 8, `GAME_TAGS` 3, `MOMENT_TAGS` 4) | `clipper/app/hashtags.py`; uso em `judge_clip` de `worker.py`; campo `hashtags` em `judge.py` (`VERDICT_SCHEMA`, `PROFILE_SCHEMA`, `Verdict.hashtags`) e `PROFILE_LISTS`/`clean_profile`/`Intel.session_game` em `intel.py` — ver "Hashtags da legenda" abaixo | `clipper/tests/test_hashtags.py` |
| Configuração do corte: camadas padrão ← canal ← sessão ← projeto (`DEFAULTS`, `merge`, `validate`), `format.aspect` (`ASPECTS`, `FRAME_SIZES`, `CANVAS_SIZES`, `aspect()`), `MODES` (5 modos, inclui `cam_only`), `resolved_mode` (queda para `blur` sem câmera; `full` no horizontal), retângulos, legenda, crédito, `duration` (`min_target`), `hook` (`HOOK_STYLES`, `HOOK_ANIMS`, `HOOK_FONT`), `capture`; fontes empacotadas (`PACKAGED_FONTS`, `font_files`, `ass_filter` = `ass=` com `fontsdir` só se o ASS usar uma delas); cadeia de layout reutilizável `layout_chain(settings, src, dst, tail, suffix, mode)` (usada por `video_filter` e pelo editor) | `clipper/app/layout.py`; rotas de settings em `main.py` (devolvem `aspects`, `frames`, `fontFiles`, `hookStyles`, `hookAnims` e `captureQualities`) | `clipper/tests/test_format_and_captions.py` (o vertical precisa continuar batendo com `clipper/tests/data/vertical_golden_sha256.json`); modo novo também em `LayoutMode`/`MODE_LABEL` de `panel/src/components/clipper-client.ts` e `resolvedMode` de `clip-editor-model.ts`; grupo novo também em `CutSettings` (`Aspect`, `aspectOf`, `withFormat` para serviço antigo) | | Configuração do corte: camadas padrão ← canal ← sessão ← projeto (`DEFAULTS`, `merge`, `validate`), `format.aspect` (`ASPECTS`, `FRAME_SIZES`, `CANVAS_SIZES`, `aspect()`), `MODES` (5 modos, inclui `cam_only`), `resolved_mode` (queda para `blur` sem câmera; `full` no horizontal), retângulos, legenda, crédito, `duration` (`min_target`), `hook` (`HOOK_STYLES`, `HOOK_ANIMS`, `HOOK_FONT`), `capture`; fontes empacotadas (`PACKAGED_FONTS`, `font_files`, `ass_filter` = `ass=` com `fontsdir` só se o ASS usar uma delas); cadeia de layout reutilizável `layout_chain(settings, src, dst, tail, suffix, mode)` (usada por `video_filter` e pelo editor) | `clipper/app/layout.py`; rotas de settings em `main.py` (devolvem `aspects`, `frames`, `fontFiles`, `hookStyles`, `hookAnims` e `captureQualities`) | `clipper/tests/test_format_and_captions.py` (o vertical precisa continuar batendo com `clipper/tests/data/vertical_golden_sha256.json`); modo novo também em `LayoutMode`/`MODE_LABEL` de `panel/src/components/clipper-client.ts` e `resolvedMode` de `clip-editor-model.ts`; grupo novo também em `CutSettings` (`Aspect`, `aspectOf`, `withFormat` para serviço antigo) |
| Projeto de edição: modelo, tempo sessão↔saída, `normalize_cuts`, `validate_project`, `auto_project` (projeto da IA), `pick_hook` (texto do gancho), `CAPTION_PRESETS`, `SUGGEST_SCHEMA`/`clean_suggestion` | `clipper/app/editor.py` | `clipper/tests/test_editor.py`, `clipper/tests/test_editor_layers.py`; tipos espelhados em `panel/src/components/clip-editor-model.ts` | | Projeto de edição: modelo, tempo sessão↔saída, `normalize_cuts`, `validate_project`, `auto_project` (projeto da IA), `pick_hook` (texto do gancho), `CAPTION_PRESETS`, `SUGGEST_SCHEMA`/`clean_suggestion` | `clipper/app/editor.py` | `clipper/tests/test_editor.py`, `clipper/tests/test_editor_layers.py`; tipos espelhados em `panel/src/components/clip-editor-model.ts` |
@@ -81,7 +87,10 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
`chat_meaning`, `confidence` (0–1) e início/fim da ação. **EDITOR** vê só texto + a análise e escreve título, `chat_meaning`, `confidence` (0–1) e início/fim da ação. **EDITOR** vê só texto + a análise e escreve título,
legenda, nota e corte. Os dois podem recuar até `duration.backtrackS` (padrão 120 s) antes do candidato. legenda, nota e corte. Os dois podem recuar até `duration.backtrackS` (padrão 120 s) antes do candidato.
- `PUT /v1/judge`: provedor, `model` (editor), `analystModel` (vazio = o mesmo), `minScore`, `scanEnabled`, - `PUT /v1/judge`: provedor, `model` (editor), `analystModel` (vazio = o mesmo), `minScore`, `scanEnabled`,
`scanIntervalS`, `vision`, `camDetect`, `faceTrack`. Fica na tabela `settings`, sem reiniciar; o `.env` só dá o valor inicial. `scanIntervalS`, `vision`, `camDetect`, `faceTrack`, `timelineJson`, `roles`. Fica na tabela `settings`, sem reiniciar; o `.env` só dá o valor inicial.
- **Equipe de IA (18/11/2026):** hoje são quatro papéis (varredura, analista, editor e o **juiz de contexto**), cada um com
provedor + modelo + raciocínio + instruções do administrador (`judge.roles`), e a IA lê a live como linha do tempo JSON
(`timelineJson`). Tudo em [clipper-ai-team.md](clipper-ai-team.md); o texto acima descreve o fluxo base analista → editor.
- Codex: cada imagem com seu `-i`, todas antes do `-` final; `--search` é opção **global** (antes de `exec`). - Codex: cada imagem com seu `-i`, todas antes do `-` final; `--search` é opção **global** (antes de `exec`).
- Custo fixo: cada chamada é um processo novo (2 por candidato). `codex_lean_overrides(search, config_file=None)` em - Custo fixo: cada chamada é um processo novo (2 por candidato). `codex_lean_overrides(search, config_file=None)` em
`judge.py` enxuga o Codex; o Claude leva `--setting-sources project,local`. Números e limites em `judge.py` enxuga o Codex; o Claude leva `--setting-sources project,local`. Números e limites em
@@ -147,8 +156,9 @@ montada por `build_caption(text, tags, credit)` (partes separadas por linha em b
- Webcam: `POST /v1/sessions/{id}/detect-cam` (YuNet local em 12 quadros, sem IA; a IA olha 3 frames só se o local - Webcam: `POST /v1/sessions/{id}/detect-cam` (YuNet local em 12 quadros, sem IA; a IA olha 3 frames só se o local
não achar rosto e `vision` estiver ligada, ou com `?ai=true`) ou automática nos 2 primeiros blocos, se `camDetect`. não achar rosto e `vision` estiver ligada, ou com `?ai=true`) ou automática nos 2 primeiros blocos, se `camDetect`.
`cam_json.source` = `yunet` | `ai` | `manual`. Prévia sem salvar (no formato efetivo): `POST …/preview`; quadro: `GET …/frame?t=`. `cam_json.source` = `yunet` | `ai` | `manual`. Prévia sem salvar (no formato efetivo): `POST …/preview`; quadro: `GET …/frame?t=`.
- Jogo da sessão: `PUT /v1/sessions/{id}/game` trava a troca automática. Emotes do canal: - Jogo da sessão: `PUT /v1/sessions/{id}/game` confirma o jogo (`game_source = user`; a troca automática vira só
`GET /v1/emotes?channel=twitch-<login>`. sugestão) e `POST …/game/detect` roda a detecção ("Detectar agora"); regras em "Detecção do jogo da live". Emotes do
canal: `GET /v1/emotes?channel=twitch-<login>`.
- Timeouts do proxy do painel: 8 min para `games/*/(research|refine)`, 5 min para - Timeouts do proxy do painel: 8 min para `games/*/(research|refine)`, 5 min para
`clips/*/(proxy|preview-render|retranscribe|tts|suggest|waveform)`, 3 min para `detect-cam|preview|check`, 30 s para `clips/*/(proxy|preview-render|retranscribe|tts|suggest|waveform)`, 3 min para `detect-cam|preview|check`, 30 s para
`sessions/*/face(/reset)`, 2 min o resto. `sessions/*/face(/reset)`, 2 min o resto.
@@ -234,6 +244,26 @@ medições em `doc/FACE_BAKEOFF.md`. Roda no PC, sem IA. Opção `faceTrack` (pa
(gotchas, item 92). Não baixe esse piso sem medir. (gotchas, item 92). Não baixe esse piso sem medir.
- **Sinal:** z robusto de cada canal contra o neutro dos últimos 180 s do próprio streamer; rótulos `risada`, `grito`, - **Sinal:** z robusto de cada canal contra o neutro dos últimos 180 s do próprio streamer; rótulos `risada`, `grito`,
`susto`, `choque`, `raiva`, `confuso`. Ajuste por `ReactionParams` (pisos por canal, pesos, limiares). `susto`, `choque`, `raiva`, `confuso`. Ajuste por `ReactionParams` (pisos por canal, pesos, limiares).
- **Expressões, cabeça e corpo** (18/11/2026; `doc/clipador/EXPRESSOES.md`, sem migração: os campos novos vão no
`data_json` de `face_track`, séries antigas continuam valendo):
- Rótulos novos só a partir de blendshapes que já vinham: `gargalhada` (risada + cabeça ≥ 20° para trás), `alegria` (só no
mapa), `medo`, `nojo`, `tristeza`, `espanto`, `tenso`, `bocejo`. Além dos antigos (`risada`, `grito`, `susto`, `choque`,
`raiva`, `confuso`). Pose (yaw/pitch/roll) vem da matriz de transformação facial do MediaPipe
(`output_facial_transformation_matrixes=True`, `face.pose_from_matrix`).
- **Reserva do YuNet:** quando o MediaPipe perde o rosto (streamer de perfil), o YuNet roda **só nesse quadro** (5,3 ms) e dá a
caixa da cabeça → corpo: `balançando`, `acenando`, `agitado`, `chegou perto`, `saiu do quadro` (`reaction.body_moments`;
"saiu" só com o campo `head`). Rastreio perdido nunca vira movimento.
- **Canais novos só dão nome, não criam picos:** `ReactionParams.extra_weights` = 0 (a intensidade alimenta nota e fonte
`face`; mexer sem conjunto aprovado/rejeitado maior seria chute). Ligar um canal = dar peso lá e medir de novo. Única mudança
nos picos: bocejo deixou de contar como grito.
- **Calibração (dados reais, 4 sessões):** bocejos eram os maiores "gritos" (jawOpen ≥ 0,6 por 3 s); `noseSneerLeft/Right`,
`cheekSquintLeft/Right`, `cheekPuff` são sempre ~0 no MediaPipe (nojo usa o lábio de cima); mão no rosto ainda engana a
boca (tristeza/espanto/medo/raiva no mapa); cadeira vazia pode gerar "rosto fantasma"; balançar a 6 qps é movimento, não
"não" literal. Série de 1,7 h: ~1,4 MB/h no banco; análise ~1 s.
- API: `GET /v1/sessions/{id}/face` ganha `expr`/`body` por segundo e `body: [{startS,endS,peakS,label,value}]`; a linha
"Rosto do streamer" do analista leva até 2 movimentos do corpo (com rosto de perfil: "sem expressão legível… saiu do quadro").
Painel: **Mapa de expressões** no modal do corte (`clipper-face-map.tsx`), chip `FaceSignal` com os rótulos novos.
- **Não verificado:** serviço real rodando o código novo; painel no navegador (só `tsc`); câmera escura/minúscula além da do tfue.
- **Cortes:** rosto **reforça, não manda.** `reasons.face` + bônus ≤ 0,6 em momentos do chat/áudio; fonte `face` só - **Cortes:** rosto **reforça, não manda.** `reasons.face` + bônus ≤ 0,6 em momentos do chat/áudio; fonte `face` só
com z ≥ 6 **e** apoio (áudio suavizado ≥ 1,5 ou ≥ 2 mensagens de reação). A decisão do corte espera o rosto do com z ≥ 6 **e** apoio (áudio suavizado ≥ 1,5 ou ≥ 2 mensagens de reação). 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: …" — exceto trecho (no máximo 2 blocos atrás da transcrição). O analista recebe a linha "Rosto do streamer: …" — exceto
@@ -365,16 +395,18 @@ Fonte do contrato: `doc/clipador/IDIOMAS.md`; README do Clipador, "Idioma por fo
`clips.translation_json` `{language, startS, endS, model, lines: [{s, e, text, pt}]}`; frases de `subtitles.phrases` `clips.translation_json` `{language, startS, endS, model, lines: [{s, e, text, pt}]}`; frases de `subtitles.phrases`
(pausa > 0,7 s, fim de frase com 4+ palavras, 16 palavras ou 6 s) traduzidas por `Judge.translate_lines`. (pausa > 0,7 s, fim de frase com 4+ palavras, 16 palavras ou 6 s) traduzidas por `Judge.translate_lines`.
`POST /v1/clips/{id}/translate` refaz (409 em fonte PT); `clip_view.translation`. `POST /v1/clips/{id}/translate` refaz (409 em fonte PT); `clip_view.translation`.
- **Legenda em português no vídeo (só para desenvolver):** `caption.translation` (padrão `false`) → estilo ASS `Trans` - **Legenda em português no vídeo (só para desenvolver):** `dev.translation` (padrão `false`; `caption.translation` é o legado, ainda lido) → estilo ASS `Trans`
(metade do tamanho, `&H00FFE79B`, `n8` + `\q0`) sob a legenda, seguindo o desvio do gancho; só entra no ASS quando (metade do tamanho, `&H00FFE79B`) sob a legenda, seguindo o desvio do gancho; só entra no ASS quando ligado **e** há
ligado **e** há tradução (sem isso o ASS é idêntico ao de antes). `editor_api.translation_for` alimenta render e prévia. tradução (sem isso o ASS é idêntico ao de antes). `editor_api.translation_for` alimenta render e prévia. Entra só no
**Nunca publicar com isto ligado.** **vídeo de revisão**: o final, gerado ao aprovar, sai sem ela ([clipper-video.md](clipper-video.md); dublagem: mesma seção).
- **Heurística:** `scoring.py` (`REACTION_PATTERNS`, `SPOKEN_REACTION`) reconhece reação em inglês (lmao, lol, 💀, 😭, no - **Heurística:** `scoring.py` (`REACTION_PATTERNS`, `SPOKEN_REACTION`) reconhece reação em inglês (lmao, lol, 💀, 😭, no
way, bruh, holy, clutch, goated, clip that…). `judge.output_language_note` agora é vazio também para inglês. way, bruh, holy, clutch, goated, clip that…). `judge.output_language_note` agora é vazio também para inglês.
- **Voz:** `worker.VOICE_LANGUAGES`/`voice_language()` converte `en-US` → `en` e `es-419` → `es` antes do Whisper (gotchas, item 173). - **Voz:** `worker.VOICE_LANGUAGES`/`voice_language()` converte `en-US` → `en` e `es-419` → `es` antes do Whisper (gotchas, item 173).
- **Começar uma fonte gringa:** Fontes → idioma English (US); jogo com perfil em inglês e gírias do público gringo - **Começar uma fonte gringa:** Fontes → idioma English (US); jogo com perfil em inglês e gírias do público gringo
(Jogos → "acrescente as gírias…", ou `POST /v1/games/{id}/translate` se o perfil só existe em português); ligar (Jogos → "acrescente as gírias…", ou `POST /v1/games/{id}/translate` se o perfil só existe em português); ligar
"Tradução em português embaixo (teste)" na configuração do corte do canal enquanto estiver testando. "Tradução em português embaixo (teste)" (e, se quiser, "Dublagem em português (teste)") na configuração do corte do
canal enquanto estiver testando. Fontes em teste (18/11/2026): twitch-tfue (ROB RUN) e twitch-maxylobes (GTA V Chaos
Mod, en-US, `dev.translation` + `dev.dub` ligados).
- **Painel:** modal do corte com bloco "Em português" (título, legenda, "O que ele fala" frase a frase, botão "Traduzir a - **Painel:** modal do corte com bloco "Em português" (título, legenda, "O que ele fala" frase a frase, botão "Traduzir a
fala"); lista com título traduzido (🇧🇷); resumo da sessão em português; switch em `clipper-cut-settings.tsx`; Fontes: a fala"); lista com título traduzido (🇧🇷); resumo da sessão em português; switch em `clipper-cut-settings.tsx`; Fontes: a
coluna "Ao vivo" mostra "gravando #N" da sessão ativa e checagem do monitor com mais de 10 min vira "ao vivo há X" coluna "Ao vivo" mostra "gravando #N" da sessão ativa e checagem do monitor com mais de 10 min vira "ao vivo há X"
@@ -384,6 +416,41 @@ Fonte do contrato: `doc/clipador/IDIOMAS.md`; README do Clipador, "Idioma por fo
`judge.pt` em português, 27 frases traduzidas e vídeo 1080×1920 com inglês em cima e português embaixo. Não verificado `judge.pt` em português, 27 frases traduzidas e vídeo 1080×1920 com inglês em cima e português embaixo. Não verificado
por mim: o render real (só a suíte foi reexecutada); qualidade da tradução fora desse corte; espanhol ponta a ponta. por mim: o render real (só a suíte foi reexecutada); qualidade da tradução fora desse corte; espanhol ponta a ponta.
## Detecção do jogo da live (18/11/2026)
Fonte do contrato: `doc/clipador/DETECCAO-JOGO.md`; seção "Contexto do jogo" de `clipper/README.md`. Decisão do dono:
ninguém precisa lembrar de dizer o jogo; o Clipador descobre sozinho e o usuário só confirma ou corrige.
- **Quando:** `Intel.check_game` a cada `GAME_CHECK_S` 180 s grava a categoria/título em `sessions.game_detect_json`
(`platform`) e chama `detect_game`. A varredura e "Detectar agora" gravam a tela com `note_screen` (vale
`SCREEN_FRESH_S` 900 s). Chat e fala: últimos `CHAT_WINDOW_S` 360 s e 12 blocos (`SPEECH_SEGMENTS`).
- **Pistas** (`game_detect.Evidence`; peso por fonte `SOURCE_WEIGHT`: categoria 0,55, tela 0,5, chat e fala 0,35,
título 0,25; tela multiplica pela confiança high 1 / medium 0,7 / low 0,4). Cada fonte conta uma vez por jogo.
`fuse` junta os pesos por ruído-ou e decide `status`:
`agreed` (≥ 2 fontes e nota ≥ 0,6), `probable` (nota ≥ 0,34), `conflict` (2º colocado ≥ 0,34, vantagem < 0,25 e com
fonte forte = categoria ou tela), `unknown`. Chat só conta com ≥ 2 mensagens citando o jogo.
- **Estados em `sessions.game_status`:** `user` (você confirmou) | `agreed` | `probable` | `conflict` | `unknown` (`''` =
sessão antiga, ainda não checada).
- **Regras de troca** (`detect_game`):
- Jogo confirmado por você (`game_source = user`) **nunca** muda sozinho; se as pistas concordam em outro jogo por 2
checagens seguidas vira `suggestion` e o painel pergunta.
- Sem confirmação, trocar de jogo exige a categoria apoiando **ou** a mesma resposta em 2 checagens seguidas
(`state.pending.n`); "Detectar agora" (`immediate`) pula a espera.
- Conflito categoria × tela mantém o jogo atual e o painel pergunta (um botão por candidato).
- Categoria genérica ("Just Chatting", "IRL", "Só Bate-papo"…, `GENERIC_CATEGORIES`) não é jogo: fica registrada, não conta.
- **Nomes:** `canon(name)` resolve categoria "Grand Theft Auto VI" e tela "GTA 6" para o mesmo id quando o jogo (ou um
alias) está cadastrado. `count_mentions` casa palavra inteira e confere duas leituras do texto: sem acento (`slug`) e
como `intel.game_id` gerou o id, que **não** tira acento (`Pokémon` → `pok-mon`).
- **"Detectar agora"** (`POST /v1/sessions/{id}/game/detect`, `detect_game_now`): a IA vê 3 frames (−120, −60 e −6 s) e
o título; sem IA ou sem visão (`vision`) responde erro de usuário. Leva de 10 s a 1 min. Resposta `{result, session}`.
- **API:** `session_view` ganhou `gameStatus` e `gameDetect` `{checkedAt, candidates, suggestion, platform, screen}`.
`PUT …/game` confirma à mão e roda a detecção (limpa a sugestão).
- **Painel:** `SessionGame` em `clipper-games.tsx`: selo do estado, botão "Detectar agora", aviso de conflito, aviso de
sugestão e "Como o jogo foi descoberto"; `gameNeedsReview` (`clipper-client.ts`) é o que `clipper-session-detail.tsx` e
`clipper-sessions-page.tsx` usam para chamar a atenção (serviço antigo sem `gameStatus`: cai no cálculo por `screenGame`).
- **Limites:** chat e fala só reconhecem jogos já cadastrados em Jogos (`_mention_forms` lê a tabela `games`); sem IA/visão
não há pista de tela. Só vale com o serviço reiniciado (migração v16; gotchas, item 180).
## Perfil do jogo (aba Jogos) ## Perfil do jogo (aba Jogos)
Fonte do contrato: `doc/clipador/JOGOS.md`; seção "Contexto do jogo" de `clipper/README.md`. Toda rota abaixo devolve a Fonte do contrato: `doc/clipador/JOGOS.md`; seção "Contexto do jogo" de `clipper/README.md`. Toda rota abaixo devolve a
@@ -453,6 +520,22 @@ missão logo depois do gatilho de fim. Busca por nome casa `id` **ou** alias (ca
## Testes e evidência ## Testes e evidência
Detecção do jogo da live (18/11/2026): suíte inteira do Clipador (`cd clipper; .venv\Scripts\python -m pytest`) →
exit 0, 440 testes (pontos contados na saída; o `pytest.ini` usa `-q` e não imprime a linha final; reexecutado nesta
manutenção); `tests/test_game_detect.py` tem 15 testes (o lote informou 14); `npx tsc --noEmit -p panel` → exit 0
(reexecutado). Não verificado: IA real em `Judge.detect_game` e nos prompts com os campos novos; o painel no navegador;
banco real em v16 (o serviço precisa reiniciar); o botão "Detectar agora" contra o serviço — o proxy do painel não tem
`game/detect` no `ALLOWED` (gotchas, item 186; já corrigido).
Bloco de 18/11/2026 (revisão × final, dublagem, falantes, expressões, Equipe de IA e proxy): **informado pelo coordenador**
(não reexecutado por mim): suíte inteira do Clipador passa; painel `tsc` + 119 testes. Testes novos: `test_final_render.py`,
`test_dub.py`, `test_speakers.py`, `test_expressions.py`, `test_roles.py`, `test_context_judge.py`. Medidas citadas (tempo da
dublagem, custo da voz, estabilidade dos falantes, tokens por hora) vêm dos docs de `doc/clipador/` e estão nas seções
próprias. Não verificado: serviços reais com o código novo (precisam reiniciar), UI no navegador, juiz/dublagem/voz com IA e
TTS reais além dos cortes citados, banco real em v17. `onnxruntime` 1.32.0 e `mediapipe` 1.2.3 reconferidos no `clipper/.venv`.
O proxy do painel liberou `POST clips/{id}/translate` e `GET sessions/{id}/speakers` (sem isso o botão "Traduzir a fala"
dava 404; regex `ALLOWED` + `METHODS` em `panel/src/lib/clipper.ts`).
Fonte em inglês (18/11/2026): `pnpm test:clipper` → **346 passed** (reexecutado nesta manutenção, 101 s); `test_english_source.py` Fonte em inglês (18/11/2026): `pnpm test:clipper` → **346 passed** (reexecutado nesta manutenção, 101 s); `test_english_source.py`
novo (9 testes) e ajustes em `test_monitor_pause_and_language.py`, `test_render_and_duplicates.py`, `test_intel.py`. Não novo (9 testes) e ajustes em `test_monitor_pause_and_language.py`, `test_render_and_duplicates.py`, `test_intel.py`. Não
verificado: IA real com prompts em inglês (só o corte 259 informado), painel no navegador, `pnpm typecheck`, banco real em v13 verificado: IA real com prompts em inglês (só o corte 259 informado), painel no navegador, `pnpm typecheck`, banco real em v13
+41 -1
View File
@@ -3,7 +3,7 @@
Cada item: **sintoma → causa → correção → onde está tratado**. Observadas na implementação da Cada item: **sintoma → causa → correção → onde está tratado**. Observadas na implementação da
prova de conceito com Godot 4.7.2 / FFmpeg 7.1.1 / pnpm 11.22 (16/11/2026). Registro formal em prova de conceito com Godot 4.7.2 / FFmpeg 7.1.1 / pnpm 11.22 (16/11/2026). Registro formal em
`doc/TEST_RESULT.md`: itens 1–5, 7, 13–15, 17 e 18; itens 30–33 estão em `voice/README.md` `doc/TEST_RESULT.md`: itens 1–5, 7, 13–15, 17 e 18; itens 30–33 estão em `voice/README.md`
("GPU e CPU"); itens 57–61 estão em `clipper/README.md` ("Armadilhas já resolvidas"); itens 74–76, 87–90 e 103–108 também estão lá e o 78 na seção "Limitações" do editor; itens 79, 81–84 e 92–95 estão em `doc/FACE_BAKEOFF.md` (o 93 também em "Variáveis" de `clipper/README.md`) (o 80, no comentário de `clipper/requirements.txt`); itens 168–172 (IA) seguem `doc/ia.md`; itens 118–128 (publicação) seguem `doc/publicacao/` e o código; itens 151–154 foram informados em 17/11/2026 (parte conferida no código); itens 129–132 foram informados em 17/11/2026 e conferidos no código (`doc_main.gd`, `doc/godot/cenas.md`) e no banco (`agent_runs` 5, 7 e 8); itens 62–67, 77, 85–86, 91, 99–102, 109–112 e as ampliações do 52, do 44, 77, 86 e 87 foram informados em 16–17/11/2026 (não estão em `doc/TEST_RESULT.md`); os demais vieram de erros de compilação ou instalação durante a implementação. ("GPU e CPU"); itens 57–61 estão em `clipper/README.md` ("Armadilhas já resolvidas"); itens 74–76, 87–90 e 103–108 também estão lá e o 78 na seção "Limitações" do editor; itens 79, 81–84 e 92–95 estão em `doc/FACE_BAKEOFF.md` (o 93 também em "Variáveis" de `clipper/README.md`) (o 80, no comentário de `clipper/requirements.txt`); itens 168–172 (IA) seguem `doc/ia.md`; itens 118–128 (publicação) seguem `doc/publicacao/` e o código; itens 151–154 foram informados em 17/11/2026 (parte conferida no código); o 180 (detecção do jogo) foi informado em 18/11/2026 e conferido no código; itens 129–132 foram informados em 17/11/2026 e conferidos no código (`doc_main.gd`, `doc/godot/cenas.md`) e no banco (`agent_runs` 5, 7 e 8); itens 62–67, 77, 85–86, 91, 99–102, 109–112 e as ampliações do 52, do 44, 77, 86 e 87 foram informados em 16–17/11/2026 (não estão em `doc/TEST_RESULT.md`); os demais vieram de erros de compilação ou instalação durante a implementação.
Ao descobrir uma nova, registre aqui via `cenaforge-skill-updater`. Os números são estáveis Ao descobrir uma nova, registre aqui via `cenaforge-skill-updater`. Os números são estáveis
(outros textos os citam): item novo entra na seção do assunto com o próximo número livre. (outros textos os citam): item novo entra na seção do assunto com o próximo número livre.
@@ -508,6 +508,35 @@ Observadas em 17/11/2026 (diagnóstico da sessão 3, cartão da sessão, apagar
**Só vale depois de reiniciar o Clipador (porta 4520)**: o código é lido na partida. Detalhes em **Só vale depois de reiniciar o Clipador (porta 4520)**: o código é lido na partida. Detalhes em
[token-economy.md](token-economy.md). Onde: `clipper/app/judge.py`. [token-economy.md](token-economy.md). Onde: `clipper/app/judge.py`.
Observadas em 18/11/2026 (revisão × final, falantes, dublagem, trabalho em worktree):
180. **Corte aprovado "não publica" e o job fica parado.** Causa: a publicação só usa o vídeo FINAL (`publishFile`); enquanto
`final_status` não é `ready` o job mostra "Esperando o vídeo final…" (final `pending`/`rendering`, ou `error`).
Correção: olhe `final` no corte (`GET /v1/clips`, campos `final` e `publishFile`); `error` → "Tentar de novo" = `POST /v1/clips/{id}/final`.
Nunca troque para `file` (é o de revisão, com camadas de teste). Corte antigo publicado com tradução e sem final: gere
com `POST /final` antes de mandar a outra rede. Onde: `clipPublishFile` (`panel/src/lib/publishing-rules.ts`),
`sendDue` (`publishing.ts`); doc `doc/clipador/REVISAO.md`.
181. **Botão "Traduzir a fala" (e a lista de vozes) dava 404.** Causa: a rota existia no Clipador, mas a regex `ALLOWED` do
proxy do painel não liberava `clips/{id}/translate` nem `sessions/{id}/speakers`. Correção: liberadas em `ALLOWED` +
`METHODS`. Rota nova do Clipador = regex, método e timeout em `panel/src/lib/clipper.ts` no mesmo commit.
182. **Fala do colega aparece como do streamer (ou tudo em uma linha só).** Causa esperada, não bug: sem atribuição nos
primeiros minutos (< 15 s de fala por voz); volume e boca **discordam** ou nenhum decide → ninguém vira "outro"; webcam
de perfil não separa pela boca; o código novo só roda depois de reiniciar o Clipador. Correção: confira
`GET /v1/sessions/{id}/speakers` (vozes e por quê); corrija à mão no editor (**Outra pessoa / É o streamer**).
Onde: `clipper/app/speakers.py`; `doc/clipador/FALANTES.md`.
183. **Dublagem soa corrida, emendada ou cortada no fim.** Causa: o português sai bem mais longo que o inglês; o encaixe
deixa a fala escorrer até 1,5 s sobre a próxima frase, acelera até 1,2× e por fim corta com fade (medido: 9 de 25 falas
cortadas no corte 259). Não é falha; **não** acelere além disso nem clone a voz do streamer. A 1ª renderização sintetiza
(~1,6 s por frase); depois o cache (`data/clipper/dub/`) deixa +0,3 s. Onde: `clipper/app/dub.py` (`fit`).
184. **Worktree de isolamento do harness falha no Windows.** Causa: diferença de caixa da letra do drive (`f:` × `F:`).
Correção: criar a worktree à mão em `F:/Projects/cf-wt/<nome>` (`git worktree add`). Para rodar testes nela: copiar
`clipper/tests/data/vertical_golden_sha256.json` (ignorado no git, o teste dourado do vertical precisa dele) e criar
um junction `panel/node_modules` apontando para o da pasta principal (sem isso `tsc` e os testes do painel não rodam).
185. **Serviço "não pegou" ou "caiu e não voltou".** Os serviços (painel, voz, Clipador, Publicador) são do usuário, subidos
por `pnpm dev`: agente **não** sobe nem encerra. O `scripts/dev.ts` pula um serviço se a porta já está ocupada e só
reinicia sozinho a voz (quando `voice/.env` muda); serviço que cai não volta. Peça ao usuário para reiniciar o `pnpm
dev` (com a suíte verde: item 87) e compare o início do processo com o arquivo (item 143).
## Publicação (Publicador + despachante do painel) ## Publicação (Publicador + despachante do painel)
Regras de projeto informadas em 17/11/2026 (código em `panel/src/lib/publishing*.ts` e `publisher/app/`); nenhuma Regras de projeto informadas em 17/11/2026 (código em `panel/src/lib/publishing*.ts` e `publisher/app/`); nenhuma
@@ -798,6 +827,17 @@ observada num envio real ainda. Contexto em [publishing.md](publishing.md).
sessão gravando era a do Tfue. Correção: a coluna mostra "gravando #N" da sessão ativa e trata checagem com mais de sessão gravando era a do Tfue. Correção: a coluna mostra "gravando #N" da sessão ativa e trata checagem com mais de
10 min como "ao vivo há X" apagado. Onde: `panel/src/components/clipper-channels.tsx`. 10 min como "ao vivo há X" apagado. Onde: `panel/src/components/clipper-channels.tsx`.
186. **Clipador: o jogo da sessão não é detectado, fica `unknown`, ou "Detectar agora" falha.** Conferido no código em
18/11/2026. Causas, por ordem: (a) serviço sem reiniciar (item 144): a migração v16 não roda, `game_status` e
`gameDetect` não existem e `POST …/game/detect` dá 404; reinicie (é do usuário) e confira `PRAGMA user_version` = 16.
(b) Chat e fala só reconhecem jogos **já cadastrados** em Jogos (nome, id ou alias): jogo novo só aparece por
categoria ou tela até ser cadastrado. (c) Sem IA ou sem visão ligada não há pista de tela e "Detectar agora" devolve
erro de usuário ("precisa da IA ligada e da visão ligada"). (d) Categoria genérica ("Just Chatting", "IRL") não conta
como jogo. (e) `intel.game_id()` não tira acento (`Pokémon` → `pok-mon`) e `game_detect.slug` tira: `count_mentions`
confere as duas leituras; ao mexer em um dos dois, mantenha as duas.
Onde:
`clipper/app/game_detect.py`, `intel.py`, `judge.py`, `main.py`, `db.py` (v16); teste `clipper/tests/test_game_detect.py`.
## IA: provedores, login e reserva ## IA: provedores, login e reserva
Itens 168–172 e 175–179 informados em 18/11/2026 e conferidos contra `doc/ia.md` e o código. Contexto em [ai.md](ai.md). Itens 168–172 e 175–179 informados em 18/11/2026 e conferidos contra `doc/ia.md` e o código. Contexto em [ai.md](ai.md).
+2 -2
View File
@@ -355,12 +355,12 @@ sidebar (`sidebar-nav.tsx`) mostra os mesmos subitens quando o Clipador está at
| Rota | Conteúdo | Arquivos | | Rota | Conteúdo | Arquivos |
|---|---|---| |---|---|---|
| `/clipper` Cortes | lista `ClipTable` (uma linha por corte; ações rápidas Aprovar/Rejeitar/Publicar), filtros na URL (`?stage ?source ?session ?lang`), modal `ClipDialog` por `?clip=ID` com anterior/próximo; em fonte inglesa, bloco "Em português" e título traduzido na lista ([clipper.md](clipper.md#fonte-em-inglês-18112026)) | `clipper-clips-page.tsx`, `clipper-clip-table.tsx`, `clipper-clip-dialog.tsx`, `clipper-clip-parts.tsx`; ordenar/apagar/selecionar em utilitários de `clipper-queue.tsx` | | `/clipper` Cortes | lista `ClipTable` (uma linha por corte; ações rápidas Aprovar/Rejeitar/Publicar), filtros na URL (`?stage ?source ?session ?lang`), modal `ClipDialog` por `?clip=ID` com anterior/próximo; em fonte inglesa, bloco "Em português" e título traduzido na lista ([clipper.md](clipper.md#fonte-em-inglês-18112026)); etiquetas e player **Final / Revisão** do vídeo final, **Mapa de expressões**, "O que falam" por falante, botão **Sem contexto** e veredito do juiz de contexto ([clipper-video.md](clipper-video.md), [clipper-ai-team.md](clipper-ai-team.md)) | `clipper-clips-page.tsx`, `clipper-clip-table.tsx`, `clipper-clip-dialog.tsx`, `clipper-clip-parts.tsx`; ordenar/apagar/selecionar em utilitários de `clipper-queue.tsx` |
| `/clipper/sessions` | lista de sessões; "Gravar pelo link" em diálogo (`RecordForm`) | `clipper-sessions-page.tsx` | | `/clipper/sessions` | lista de sessões; "Gravar pelo link" em diálogo (`RecordForm`) | `clipper-sessions-page.tsx` |
| `/clipper/sessions/[id]` | saúde, resumo da IA, tiles, gráfico do chat, emotes, configuração do corte | `clipper-session-detail.tsx` | | `/clipper/sessions/[id]` | saúde, resumo da IA, tiles, gráfico do chat, emotes, configuração do corte | `clipper-session-detail.tsx` |
| `/clipper/sources` | fontes em tabela, "Adicionar fonte" em diálogo, monitor ligado/**pausado** + Religar, idioma da live, canais de publicação; coluna "Ao vivo" = "gravando #N" (sessão ativa) ou "ao vivo há X" apagado se a checagem tem > 10 min (gotchas, item 174) | `clipper-channels.tsx` | | `/clipper/sources` | fontes em tabela, "Adicionar fonte" em diálogo, monitor ligado/**pausado** + Religar, idioma da live, canais de publicação; coluna "Ao vivo" = "gravando #N" (sessão ativa) ou "ao vivo há X" apagado se a checagem tem > 10 min (gotchas, item 174) | `clipper-channels.tsx` |
| `/clipper/games` | jogos em tabela (nome, gênero, estado, missões, última pesquisa/edição), "Adicionar jogo" em diálogo, `?game=ID` abre o modal do jogo e emotes do canal | `clipper-games-page.tsx`, `clipper-game-dialog.tsx` (modal), `clipper-game-parts.tsx` (seções, `AiChat`, editor à mão), `clipper-games.tsx` | | `/clipper/games` | jogos em tabela (nome, gênero, estado, missões, última pesquisa/edição), "Adicionar jogo" em diálogo, `?game=ID` abre o modal do jogo e emotes do canal | `clipper-games-page.tsx`, `clipper-game-dialog.tsx` (modal), `clipper-game-parts.tsx` (seções, `AiChat`, editor à mão), `clipper-games.tsx` |
| `/clipper/settings` | abas Juiz (IA) / Serviço / Idiomas e públicos | `clipper-settings-page.tsx`, `clipper-judge.tsx` | | `/clipper/settings` | abas Juiz (IA) / Serviço / Idiomas e públicos; em Juiz, a **Equipe de IA** (um cartão por papel: provedor, modelo, raciocínio, instruções do administrador, mosaico/`timelineJson`) e a **Medição** ([clipper-ai-team.md](clipper-ai-team.md)) | `clipper-settings-page.tsx`, `clipper-judge.tsx`, `clipper-ai-team.tsx` |
| `/clipper/edit/[clipId]` | editor em tela cheia, **fora** do grupo `(studio)` | ver "Editor de cortes" | | `/clipper/edit/[clipId]` | editor em tela cheia, **fora** do grupo `(studio)` | ver "Editor de cortes" |
`clipper-studio.tsx` foi **apagado**; `clipper-queue.tsx` virou só utilitários da lista (a lista é `ClipTable`); `clipper-studio.tsx` foi **apagado**; `clipper-queue.tsx` virou só utilitários da lista (a lista é `ClipTable`);
@@ -74,6 +74,9 @@ No texto visível do Clipador "Canais" virou **"Fontes"**; código, tabelas e ro
- Encerrar fonte/história cancela os jobs não enviados (`unlinked`); religar zera `linked_at` (a automática não pega - Encerrar fonte/história cancela os jobs não enviados (`unlinked`); religar zera `linked_at` (a automática não pega
cortes do intervalo desligado). Cancelar no meio de um ciclo vale (UPDATEs condicionais; se o Publicador já criou o cortes do intervalo desligado). Cancelar no meio de um ciclo vale (UPDATEs condicionais; se o Publicador já criou o
envio, o painel cancela lá). Aprovação automática é registrada em `clip_auto_approvals` antes do PATCH no Clipador. envio, o painel cancela lá). Aprovação automática é registrada em `clip_auto_approvals` antes do PATCH no Clipador.
- **Só o vídeo FINAL sai** (18/11/2026): corte de fonte com camadas de teste (tradução, dublagem) tem um vídeo de revisão e, ao
aprovar, um final sem elas. `clipPublishFile` (`publishing-rules.ts`) devolve `publishFile` ou o motivo de esperar; `sendDue`
relê o corte e deixa o job em "Esperando o vídeo final…" até estar pronto; nunca use `file`. Detalhes: [clipper-video.md](clipper-video.md), gotchas 180.
- **Botão "Publicar" do corte** (`POST /api/publishing/clips/<id>`, corpo `{accountId, platforms[], timing?: "now"|"best_slot"}`, - **Botão "Publicar" do corte** (`POST /api/publishing/clips/<id>`, corpo `{accountId, platforms[], timing?: "now"|"best_slot"}`,
resposta `{jobs, skipped[{platform, reason}], placed}`; `publishClip`; `timing` também aceita `"at"`, ver abaixo): serve para corte aprovado cuja fonte **não** está resposta `{jobs, skipped[{platform, reason}], placed}`; `publishClip`; `timing` também aceita `"at"`, ver abaixo): serve para corte aprovado cuja fonte **não** está
ligada a canal (`account_channels`) ou para outra rede. O clique é a aprovação humana. `timing` omitido = o do canal. ligada a canal (`account_channels`) ou para outra rede. O clique é a aprovação humana. `timing` omitido = o do canal.
@@ -142,6 +142,7 @@ no `clipper/.venv` em 16/11/2026 (`importlib.metadata`). Evidência (`doc/FACE_B
| mediapipe (Face Landmarker `face_landmarker.task` float16/1) | 1.2.3 | Apache-2.0 | 478 pontos + 52 blendshapes; 5–7 ms/quadro na bancada; bloco de 30 s em 1,71 s ao vivo (com gravação + transcrição juntas) | | mediapipe (Face Landmarker `face_landmarker.task` float16/1) | 1.2.3 | Apache-2.0 | 478 pontos + 52 blendshapes; 5–7 ms/quadro na bancada; bloco de 30 s em 1,71 s ao vivo (com gravação + transcrição juntas) |
| opencv-contrib-python (`cv2.FaceDetectorYN`) + YuNet `face_detection_yunet_2026may.onnx` | 5.0.0.93 (`cv2` 5.0.0) | Apache-2.0 / MIT (peso) | acha a câmera pelo rosto no quadro inteiro (piso de confiança 0,7: gotchas, item 92). Sem `opencv-python-headless` junto (gotchas, item 80) | | opencv-contrib-python (`cv2.FaceDetectorYN`) + YuNet `face_detection_yunet_2026may.onnx` | 5.0.0.93 (`cv2` 5.0.0) | Apache-2.0 / MIT (peso) | acha a câmera pelo rosto no quadro inteiro (piso de confiança 0,7: gotchas, item 92). Sem `opencv-python-headless` junto (gotchas, item 80) |
| numpy | 2.5.5 | BSD | séries e recorte | | numpy | 2.5.5 | BSD | séries e recorte |
| onnxruntime + WeSpeaker ResNet34-LM `wespeaker_voxceleb_resnet34_LM.onnx` (`wespeaker_r34` no lock, commit `f0c48c2…`) | 1.32.0 (onnxruntime reconferido em 18/11/2026) | CC-BY-4.0 (pesos; atribuição "WeSpeaker, wenet-e2e") | impressão de voz: quem fala cada palavra (streamer × `otherN`); 0,19 s de CPU por bloco de 30 s. Medido em `doc/clipador/FALANTES.md` (sessão 15, informado; **não reexecutado** aqui). Quadro: [clipper-video.md](clipper-video.md) |
| onnxruntime + OpenSeeFace `osf_lm_model3_opt.onnx` / `osf_mnv3_detection_opt.onnx` | 1.32.0 | MIT / BSD-2-Clause (pesos) | plano B (só posição, sem expressões; sem linha de rosto ao analista). Pesos reais no `face.py` em 17/11/2026: rosto 96,7–100 %, 12,3–13,9 ms/quadro (MediaPipe no mesmo trecho: 94,4–100 %, 9,8–13,2) | | onnxruntime + OpenSeeFace `osf_lm_model3_opt.onnx` / `osf_mnv3_detection_opt.onnx` | 1.32.0 | MIT / BSD-2-Clause (pesos) | plano B (só posição, sem expressões; sem linha de rosto ao analista). Pesos reais no `face.py` em 17/11/2026: rosto 96,7–100 %, 12,3–13,9 ms/quadro (MediaPipe no mesmo trecho: 94,4–100 %, 9,8–13,2) |
Pesos fixados em `clipper/models.lock.json` (commit/caminho versionado + sha256), baixados em `data/clipper/models/`. Pesos fixados em `clipper/models.lock.json` (commit/caminho versionado + sha256), baixados em `data/clipper/models/`.
+3
View File
@@ -45,3 +45,6 @@ voice/vendor/
# Publicador: venv local # Publicador: venv local
publisher/.venv/ publisher/.venv/
# Worktrees temporárias dos subagentes do Claude Code
.claude/worktrees/
@@ -0,0 +1,109 @@
# Tarefa: subir o personagem cartoon (corpo e MÃOS) ao nível de uma ilustração de referência
Você vai trabalhar num **workspace isolado** (pasta `workspace/` deste pacote), sem acesso ao projeto
original. Responda e comente em **português do Brasil**; nomes de código (variáveis, funções, tipos,
arquivos) em **inglês**.
## Contexto
Temos um gerador de vídeos curtos verticais (9:16) em estilo "cartoon explicativo". Cada personagem é um
**componente React que desenha SVG puro** (`workspace/src/CharacterFigure.tsx`). Ele não é uma imagem pronta:
é montado por peças a partir de uma ficha de aparência (`CharacterLook`, em `src/character.ts`) e animado por
um **rig** de parâmetros contínuos (`src/rig.ts`: rosto `FaceParams` e corpo `BodyParams`, braços e pernas em
dois segmentos). As poses e ações (`src/motion.ts`) mexem nesses parâmetros quadro a quadro, e a boca segue a
fala (`src/lipsync.ts`). O vídeo final é renderizado quadro a quadro pela Remotion (Chrome headless), então
**tudo precisa ser função pura dos parâmetros** (nada de aleatório sem semente, nada de relógio).
O mesmo personagem aparece em close (só rosto e tronco), meio corpo e corpo inteiro, de frente para a câmera.
## Referência (o NÍVEL de acabamento que queremos)
Pasta `referencia/`: quadros de um vídeo de outra série (1080×1920) e recortes ampliados em
`referencia/recortes/` (mãos segurando, joinha, mão com prancheta, apontando, close de mãos, braços cruzados,
rosto). `00-video-inteiro-…png` mostra o vídeo todo.
**Copie a qualidade, não o conteúdo.** Não reproduza aqueles personagens, nomes, roupas, logotipos ou cenas.
O que importa nelas:
- **Proporção:** cabeça grande (≈ 1/3 da altura no corpo inteiro), pescoço visível e proporcional, ombros
largos e arredondados, tronco em "pera".
- **Sombreado cel em 2 tons**, luz de um lado só, sombra levemente fria, **sem contorno preto** (a borda é o
tom mais escuro da própria cor).
- **Rosto:** orelha com dobra interna; nariz como curva simples; rugas da testa como arcos suaves no tom da
pele; sobrancelha como forma cheia; pálpebra pesada; olhos com esclera branca; óculos de aro grosso com
reflexo.
- **Roupa com construção:** gola, zíper ou botões, costuras, 2–3 dobras (manga, cotovelo, barriga), barra;
pano pendurado (toalha) com dobras e sombra própria.
- **MÃOS (o problema principal):** formas macias e orgânicas, dedos de comprimentos diferentes que afinam na
ponta, nós em arco, polegar nascendo da base da palma, unhas visíveis quando a vista mostra, mão grande
(≈ do nariz ao queixo). Segurando objeto: o polegar por cima e os dedos por trás (objeto entre as camadas da
mão). Objeto largo (livro, camisa dobrada) com as duas mãos pelas bordas. Joinha com o punho de lado e os
dedos dobrados em fileira. A **mão sai de dentro da manga**: a manga termina numa borda com espessura e
abertura escura, o pulso afina e entra nela, e a manga faz sombra no pulso.
## Onde estamos (pasta `nosso/`)
- `01-folha-antes.png` → `02-folha-atual.png`: em cima a referência, embaixo o nosso, nos mesmos 6
enquadramentos. Melhoramos muito, mas um olhar rápido ainda separa os dois.
- `03-maos-ref-antes-depois.png`, `04-formas-de-mao-3-rotacoes.png`: estado atual das mãos (biblioteca
`src/hands.tsx` com formas `relaxed`, `open`, `point`, `thumbs_up`, `grip`, `pinch_edge`, `pinch_low`,
`fist`, `on_face`, giradas pelo pulso).
- `05-poses-camadas.png`: a ordem das camadas do braço (`src/limbs.ts`, `armLayer`) para a mão nunca sumir
atrás do corpo.
- `08-folha-de-poses-do-workspace.png`: saída do script deste workspace (12 poses).
O que o dono do projeto ainda reprova:
1. **Mãos** ainda parecem recortadas/coladas: formas duras, sombra em cunha, dedos "salsicha". Exemplos na
folha 08:
- braços cruzados viram um losango de dedos;
- no apontar, a mão some;
- o martelo e o ramo atravessam a túnica, e o cabo não fica claramente dentro do punho;
- no pensar e no tapar a boca, a mão parece um bloco.
2. A **emenda pulso → manga** às vezes mostra corte ou degrau quando o braço gira.
3. O **corpo inteiro** ainda parece "boneco de recorte" perto da referência:
- pouco volume na roupa;
- pernas e braços muito retos;
- sapato simples;
- sobrancelhas claras viram mancha (veja o idoso de barba branca).
4. Falta **textura de ilustração**: a referência tem degradê suave dentro das áreas e um leve granulado. A
sombra cel deve continuar, mas com transição menos "vetor de ícone".
## O que fazer
1. Estude a referência (abra as imagens) e liste, por item acima, o que muda no desenho.
2. Reescreva o que precisar em `src/CharacterFigure.tsx`, `src/hands.tsx` e `src/limbs.ts` (e, se
necessário, presets de pose em `src/rig.ts`) para chegar ao nível da referência. Pode criar arquivos novos
em `src/`.
3. Use `npx tsx render-sheet.tsx` (corpo inteiro) e `npx tsx render-sheet.tsx close` (close) para gerar
`out/sheet-*.svg`/`.png` e **olhe as imagens a cada rodada**. Acrescente poses ao `CELLS` do script se
precisar (ex.: apontar para o outro lado, acenar com a outra mão, mãos na cintura, segurando celular).
4. Pare quando, lado a lado com os recortes da referência, a mão e o corpo não se separarem pela qualidade do
desenho.
### Regras que NÃO podem quebrar (o projeto real depende delas)
- **Mesma interface pública:**
- `CharacterFigure({ look, expression?, pose?, item?, t?, state?, shadeSide?, gesture? })`;
- viewBox `0 0 200 440` com os pés em (100, 440);
- `HandsInsert({ look, item?, t?, shadeSide? })` desenha o close de mãos num viewBox 1080×1080.
- **Tipos e campos:** `CharacterLook`, `FaceParams`, `BodyParams` e os nomes de poses e expressões continuam
existindo. Campo novo só **opcional**, porque personagens já salvos precisam continuar abrindo.
- **Rig:** o desenho continua dirigido pelo rig. Expressões, poses, fala (boca) e movimento (andar, acenar,
martelar, pular, sentar) precisam funcionar; a sombra acompanha a cabeça virando (`headTurn`) e as dobras
acompanham o braço.
- **Sem dependências novas no desenho:** só React e SVG, sem imagens rasterizadas e sem bibliotecas novas.
- **Sem custo alto de render:** nada de `feGaussianBlur` ou filtros SVG pesados repetidos por quadro (o vídeo
renderiza 30 quadros por segundo; hoje um trecho de 4 s leva ~4 s). Degradê linear ou radial e textura
barata são aceitos.
- **Função pura e camadas:**
- nada de `Math.random()` nem relógio; mesmos parâmetros = mesmo desenho;
- braço, mão e objeto na mão nunca somem atrás do tronco, da barba ou de acessório quando o personagem está
de frente; mantenha a lógica de `armLayer` (ou melhore-a).
## Entrega
- A pasta `workspace/src/` com os arquivos alterados ou novos (vou copiá-los de volta para o projeto).
- `out/sheet-full.png` e `out/sheet-close.png` finais, e uma folha **referência × seu resultado** (os recortes
da referência ao lado das mesmas situações no seu desenho).
- Um resumo curto: o que mudou em cada arquivo, campos novos (se houver) e o que ainda não ficou igual.
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.6 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.0 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.3 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 286 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 621 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.3 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 709 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 497 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.8 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.1 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 843 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.1 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 867 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 689 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 930 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 899 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 143 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 246 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 333 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 180 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 220 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 241 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 342 KiB

@@ -0,0 +1,16 @@
# Workspace isolado do personagem cartoon
Cópia mínima do desenho do personagem do CenaForge (`src/`), sem Remotion e sem o resto do projeto.
`src/spec.ts` aqui é uma versão reduzida, só com os tipos que o desenho usa.
```sh
npm install
npx tsx render-sheet.tsx # out/sheet-full.svg + out/sheet-full.png (12 poses, corpo inteiro)
npx tsx render-sheet.tsx close # out/sheet-close.svg + .png (rosto e tronco ampliados)
npx tsc --noEmit # tipos
```
O PNG sai pelo `@resvg/resvg-js`. Se ele não instalar, abra o `.svg` no navegador ou converta com um Chrome
headless: `chrome --headless --screenshot=out.png --window-size=2160,1520 file:///.../out/sheet-full.svg`.
A tarefa está em `../PROMPT.md`.
Binary file not shown.

After

Width:  |  Height:  |  Size: 967 KiB

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 2.4 MiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 788 KiB

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 465 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 873 KiB

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 465 KiB

@@ -0,0 +1,847 @@
{
"name": "cenaforge-personagem-sandbox",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "cenaforge-personagem-sandbox",
"dependencies": {
"react": "19.3.0",
"react-dom": "19.3.0"
},
"devDependencies": {
"@resvg/resvg-js": "2.6.2",
"@types/react": "19.3.0",
"@types/react-dom": "19.3.0",
"tsx": "4.23.15",
"typescript": "5.9.3"
}
},
"node_modules/@esbuild/aix-ppc64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
"integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
"cpu": [
"ppc64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"aix"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-arm": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
"integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
"cpu": [
"arm"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
"integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/android-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
"integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/darwin-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
"integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/darwin-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
"integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/freebsd-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
"integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/freebsd-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
"integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-arm": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
"integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
"cpu": [
"arm"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
"integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-ia32": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
"integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
"cpu": [
"ia32"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-loong64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
"integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
"cpu": [
"loong64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-mips64el": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
"integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
"cpu": [
"mips64el"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-ppc64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
"integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
"cpu": [
"ppc64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-riscv64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
"integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
"cpu": [
"riscv64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-s390x": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
"integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
"cpu": [
"s390x"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/linux-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
"integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/netbsd-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
"integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"netbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/netbsd-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
"integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"netbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/openbsd-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
"integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/openbsd-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
"integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/openharmony-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
"integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openharmony"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/sunos-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
"integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"sunos"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-arm64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
"integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-ia32": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
"integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
"cpu": [
"ia32"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/win32-x64": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
"integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
"cpu": [
"x64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@resvg/resvg-js": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js/-/resvg-js-2.6.2.tgz",
"integrity": "sha512-xBaJish5OeGmniDj9cW5PRa/PtmuVU3ziqrbr5xJj901ZDN4TosrVaNZpEiLZAxdfnhAe7uQ7QFWfjPe9d9K2Q==",
"dev": true,
"license": "MPL-2.0",
"engines": {
"node": ">= 10"
},
"optionalDependencies": {
"@resvg/resvg-js-android-arm-eabi": "2.6.2",
"@resvg/resvg-js-android-arm64": "2.6.2",
"@resvg/resvg-js-darwin-arm64": "2.6.2",
"@resvg/resvg-js-darwin-x64": "2.6.2",
"@resvg/resvg-js-linux-arm-gnueabihf": "2.6.2",
"@resvg/resvg-js-linux-arm64-gnu": "2.6.2",
"@resvg/resvg-js-linux-arm64-musl": "2.6.2",
"@resvg/resvg-js-linux-x64-gnu": "2.6.2",
"@resvg/resvg-js-linux-x64-musl": "2.6.2",
"@resvg/resvg-js-win32-arm64-msvc": "2.6.2",
"@resvg/resvg-js-win32-ia32-msvc": "2.6.2",
"@resvg/resvg-js-win32-x64-msvc": "2.6.2"
}
},
"node_modules/@resvg/resvg-js-android-arm-eabi": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-android-arm-eabi/-/resvg-js-android-arm-eabi-2.6.2.tgz",
"integrity": "sha512-FrJibrAk6v29eabIPgcTUMPXiEz8ssrAk7TXxsiZzww9UTQ1Z5KAbFJs+Z0Ez+VZTYgnE5IQJqBcoSiMebtPHA==",
"cpu": [
"arm"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-android-arm64": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-android-arm64/-/resvg-js-android-arm64-2.6.2.tgz",
"integrity": "sha512-VcOKezEhm2VqzXpcIJoITuvUS/fcjIw5NA/w3tjzWyzmvoCdd+QXIqy3FBGulWdClvp4g+IfUemigrkLThSjAQ==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-darwin-arm64": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-darwin-arm64/-/resvg-js-darwin-arm64-2.6.2.tgz",
"integrity": "sha512-nmok2LnAd6nLUKI16aEB9ydMC6Lidiiq2m1nEBDR1LaaP7FGs4AJ90qDraxX+CWlVuRlvNjyYJTNv8qFjtL9+A==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-darwin-x64": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-darwin-x64/-/resvg-js-darwin-x64-2.6.2.tgz",
"integrity": "sha512-GInyZLjgWDfsVT6+SHxQVRwNzV0AuA1uqGsOAW+0th56J7Nh6bHHKXHBWzUrihxMetcFDmQMAX1tZ1fZDYSRsw==",
"cpu": [
"x64"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-linux-arm-gnueabihf": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-linux-arm-gnueabihf/-/resvg-js-linux-arm-gnueabihf-2.6.2.tgz",
"integrity": "sha512-YIV3u/R9zJbpqTTNwTZM5/ocWetDKGsro0SWp70eGEM9eV2MerWyBRZnQIgzU3YBnSBQ1RcxRZvY/UxwESfZIw==",
"cpu": [
"arm"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-linux-arm64-gnu": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-linux-arm64-gnu/-/resvg-js-linux-arm64-gnu-2.6.2.tgz",
"integrity": "sha512-zc2BlJSim7YR4FZDQ8OUoJg5holYzdiYMeobb9pJuGDidGL9KZUv7SbiD4E8oZogtYY42UZEap7dqkkYuA91pg==",
"cpu": [
"arm64"
],
"dev": true,
"libc": [
"glibc"
],
"license": "MPL-2.0",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-linux-arm64-musl": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-linux-arm64-musl/-/resvg-js-linux-arm64-musl-2.6.2.tgz",
"integrity": "sha512-3h3dLPWNgSsD4lQBJPb4f+kvdOSJHa5PjTYVsWHxLUzH4IFTJUAnmuWpw4KqyQ3NA5QCyhw4TWgxk3jRkQxEKg==",
"cpu": [
"arm64"
],
"dev": true,
"libc": [
"musl"
],
"license": "MPL-2.0",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-linux-x64-gnu": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-linux-x64-gnu/-/resvg-js-linux-x64-gnu-2.6.2.tgz",
"integrity": "sha512-IVUe+ckIerA7xMZ50duAZzwf1U7khQe2E0QpUxu5MBJNao5RqC0zwV/Zm965vw6D3gGFUl7j4m+oJjubBVoftw==",
"cpu": [
"x64"
],
"dev": true,
"libc": [
"glibc"
],
"license": "MPL-2.0",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-linux-x64-musl": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-linux-x64-musl/-/resvg-js-linux-x64-musl-2.6.2.tgz",
"integrity": "sha512-UOf83vqTzoYQO9SZ0fPl2ZIFtNIz/Rr/y+7X8XRX1ZnBYsQ/tTb+cj9TE+KHOdmlTFBxhYzVkP2lRByCzqi4jQ==",
"cpu": [
"x64"
],
"dev": true,
"libc": [
"musl"
],
"license": "MPL-2.0",
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-win32-arm64-msvc": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-win32-arm64-msvc/-/resvg-js-win32-arm64-msvc-2.6.2.tgz",
"integrity": "sha512-7C/RSgCa+7vqZ7qAbItfiaAWhyRSoD4l4BQAbVDqRRsRgY+S+hgS3in0Rxr7IorKUpGE69X48q6/nOAuTJQxeQ==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-win32-ia32-msvc": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-win32-ia32-msvc/-/resvg-js-win32-ia32-msvc-2.6.2.tgz",
"integrity": "sha512-har4aPAlvjnLcil40AC77YDIk6loMawuJwFINEM7n0pZviwMkMvjb2W5ZirsNOZY4aDbo5tLx0wNMREp5Brk+w==",
"cpu": [
"ia32"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@resvg/resvg-js-win32-x64-msvc": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/@resvg/resvg-js-win32-x64-msvc/-/resvg-js-win32-x64-msvc-2.6.2.tgz",
"integrity": "sha512-ZXtYhtUr5SSaBrUDq7DiyjOFJqBVL/dOBN7N/qmi/pO0IgiWW/f/ue3nbvu9joWE5aAKDoIzy/CxsY0suwGosQ==",
"cpu": [
"x64"
],
"dev": true,
"license": "MPL-2.0",
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@types/react": {
"version": "19.3.0",
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.3.0.tgz",
"integrity": "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg==",
"dev": true,
"license": "MIT",
"dependencies": {
"csstype": "^3.2.2"
}
},
"node_modules/@types/react-dom": {
"version": "19.3.0",
"resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.3.0.tgz",
"integrity": "sha512-ZI7bU42mZXXKHn/qNLEw2IrbiINU7X5+vfgdixBHkCNpYWXjKgfQ/P+uyGb5CjOLB9UcnTeg3rylQtV2hym44Q==",
"dev": true,
"license": "MIT",
"peerDependencies": {
"@types/react": "^19.3.0"
}
},
"node_modules/csstype": {
"version": "3.2.4",
"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.4.tgz",
"integrity": "sha512-PoKaoPzQapnEoqUSnHx1u6W6ku8CVEgKsnpmmzU3m1nwkidpPBQ8V/Zq2+bWNrsOKoKLwTGdbx6xF7BXP1zLVQ==",
"dev": true,
"license": "MIT"
},
"node_modules/esbuild": {
"version": "0.28.2",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
"integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
"dev": true,
"hasInstallScript": true,
"license": "MIT",
"bin": {
"esbuild": "bin/esbuild"
},
"engines": {
"node": ">=18"
},
"optionalDependencies": {
"@esbuild/aix-ppc64": "0.28.2",
"@esbuild/android-arm": "0.28.2",
"@esbuild/android-arm64": "0.28.2",
"@esbuild/android-x64": "0.28.2",
"@esbuild/darwin-arm64": "0.28.2",
"@esbuild/darwin-x64": "0.28.2",
"@esbuild/freebsd-arm64": "0.28.2",
"@esbuild/freebsd-x64": "0.28.2",
"@esbuild/linux-arm": "0.28.2",
"@esbuild/linux-arm64": "0.28.2",
"@esbuild/linux-ia32": "0.28.2",
"@esbuild/linux-loong64": "0.28.2",
"@esbuild/linux-mips64el": "0.28.2",
"@esbuild/linux-ppc64": "0.28.2",
"@esbuild/linux-riscv64": "0.28.2",
"@esbuild/linux-s390x": "0.28.2",
"@esbuild/linux-x64": "0.28.2",
"@esbuild/netbsd-arm64": "0.28.2",
"@esbuild/netbsd-x64": "0.28.2",
"@esbuild/openbsd-arm64": "0.28.2",
"@esbuild/openbsd-x64": "0.28.2",
"@esbuild/openharmony-arm64": "0.28.2",
"@esbuild/sunos-x64": "0.28.2",
"@esbuild/win32-arm64": "0.28.2",
"@esbuild/win32-ia32": "0.28.2",
"@esbuild/win32-x64": "0.28.2"
}
},
"node_modules/fsevents": {
"version": "2.3.3",
"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
"integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
"dev": true,
"hasInstallScript": true,
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
}
},
"node_modules/react": {
"version": "19.3.0",
"resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz",
"integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==",
"license": "MIT",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/react-dom": {
"version": "19.3.0",
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.0.tgz",
"integrity": "sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==",
"license": "MIT",
"dependencies": {
"scheduler": "^0.28.0"
},
"peerDependencies": {
"react": "^19.3.0"
}
},
"node_modules/scheduler": {
"version": "0.28.0",
"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.28.0.tgz",
"integrity": "sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw==",
"license": "MIT"
},
"node_modules/tsx": {
"version": "4.23.15",
"resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.15.tgz",
"integrity": "sha512-Yiex1Ovn8z2xPpOWckIiysV1SSyRMY9BkLF++q0yKiDxCqRhosKfMg3janKkiLBwZ5c/YryloKwGZcrEmtwxKw==",
"dev": true,
"license": "MIT",
"dependencies": {
"esbuild": "~0.28.0"
},
"bin": {
"tsx": "dist/cli.mjs"
},
"engines": {
"node": ">=18.0.0"
},
"optionalDependencies": {
"fsevents": "~2.3.3"
}
},
"node_modules/typescript": {
"version": "5.9.3",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
"integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
"dev": true,
"license": "Apache-2.0",
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
},
"engines": {
"node": ">=14.17"
}
}
}
}
@@ -0,0 +1,21 @@
{
"name": "cenaforge-personagem-sandbox",
"private": true,
"type": "module",
"scripts": {
"sheet": "tsx render-sheet.tsx",
"sheet:close": "tsx render-sheet.tsx close",
"typecheck": "tsc --noEmit"
},
"dependencies": {
"react": "19.3.0",
"react-dom": "19.3.0"
},
"devDependencies": {
"@resvg/resvg-js": "2.6.2",
"@types/react": "19.3.0",
"@types/react-dom": "19.3.0",
"tsx": "4.23.15",
"typescript": "5.9.3"
}
}
@@ -0,0 +1,242 @@
// Folha de conferência do personagem, SEM Remotion: renderiza o mesmo componente do projeto (CharacterFigure / HandsInsert)
// em várias poses/expressões/objetos e grava out/sheet-full.png, out/sheet-close.png e out/referencia-vs-resultado.png.
//
// npm install
// npx tsx render-sheet.tsx → out/sheet-full.svg + .png (e out/referencia-vs-resultado.png)
// npx tsx render-sheet.tsx close → só o close (rosto + tronco + mãos), como no vídeo
// npx tsx render-sheet.tsx compare → folha referência × resultado lado a lado
import fs from "node:fs";
import path from "node:path";
import React from "react";
import { renderToStaticMarkup } from "react-dom/server";
import { CharacterFigure, HandsInsert } from "./src/CharacterFigure";
import type { CharacterLook } from "./src/character";
import type { IconId } from "./src/spec";
// Personagens de teste (genéricos; não são da série de referência).
const OLD: CharacterLook = {
build: "average", height: 0.95, skin: "#e0a77a", hair: { style: "bald", color: "#9a9aa2" }, beard: { style: "mustache", color: "#8e8e96" },
glasses: "square", brows: "thick", top: { style: "jacket", color: "#4f7a4a", accent: "#e9ecef" }, bottom: { style: "pants", color: "#2c3346" },
shoes: "#2a2a30", head: "wide", nose: "curve", lids: 0.45, wrinkles: 0.6, accessories: ["towel"],
};
const COACH: CharacterLook = {
build: "heavy", height: 0.98, skin: "#d9a27a", hair: { style: "short", color: "#5a4a3a" }, beard: { style: "mustache", color: "#4a3a2a" },
glasses: "none", brows: "thick", top: { style: "jacket", color: "#22335e", accent: "#e8b13a" }, bottom: { style: "pants", color: "#22335e" },
shoes: "#f2f2f2", head: "round", nose: "round", lids: 0.15, wrinkles: 0.3, belly: true, accessories: ["whistle"],
};
const NOAH: CharacterLook = {
build: "slim", height: 0.96, skin: "#c98a5e", hair: { style: "long", color: "#e2e2e8" }, beard: { style: "long", color: "#eeeef2" },
glasses: "none", brows: "thick", top: { style: "robe", color: "#a8865a", accent: "#6b4a2a" }, bottom: { style: "pants", color: "#5a4a3a" },
shoes: "#6b4a2a", footwear: "sandals", head: "oval", nose: "long", lids: 0.5, wrinkles: 0.85,
};
const WORKER: CharacterLook = {
build: "average", height: 0.98, skin: "#dfa678", hair: { style: "short", color: "#4e3829" }, beard: { style: "full", color: "#78604c" },
glasses: "none", brows: "thick", top: { style: "shirt", color: "#6e6545" }, bottom: { style: "pants", color: "#34465e" },
shoes: "#423127", head: "round", nose: "curve", lids: 0.35, wrinkles: 0.25,
};
const MECHANIC: CharacterLook = {
build: "average", height: 0.97, skin: "#e2a878", hair: { style: "short", color: "#4a3525" }, beard: { style: "mustache", color: "#4a3525" },
glasses: "none", brows: "thick", top: { style: "shirt", color: "#687a52" }, bottom: { style: "pants", color: "#3b4c5e" },
shoes: "#4a372b", head: "round", nose: "round", lids: 0.2, wrinkles: 0.2,
};
type Cell = { look: CharacterLook; label: string; expression?: string; pose?: string; item?: IconId; gesture?: "thumbs_up" };
const CELLS: Cell[] = [
{ look: OLD, label: "stand / relaxed", pose: "stand", expression: "smile" },
{ look: OLD, label: "hold book (2 mãos)", pose: "hold", item: "book", expression: "smile" },
{ look: COACH, label: "thumbs up", pose: "thumbs_up", gesture: "thumbs_up", expression: "happy" },
{ look: COACH, label: "hold ruler (1 mão)", pose: "hold", item: "ruler", expression: "laugh" },
{ look: OLD, label: "point", pose: "point", expression: "surprised" },
{ look: OLD, label: "wave", pose: "wave", expression: "happy" },
{ look: COACH, label: "cross_arms", pose: "cross_arms", expression: "suspicious" },
{ look: OLD, label: "think", pose: "think", expression: "confused" },
{ look: OLD, label: "cover_mouth", pose: "cover_mouth", expression: "shocked" },
{ look: NOAH, label: "hold hammer", pose: "hold", item: "hammer", expression: "determined" },
{ look: NOAH, label: "hold olive", pose: "hold", item: "olive", expression: "smile" },
{ look: NOAH, label: "celebrate", pose: "celebrate", expression: "laugh" },
{ look: MECHANIC, label: "point (manga curta)", pose: "point", expression: "happy" },
{ look: WORKER, label: "cross_arms (manga curta)", pose: "cross_arms", expression: "sad" },
{ look: MECHANIC, label: "hands_on_hips", pose: "hands_on_hips", expression: "proud" },
{ look: WORKER, label: "hold phone", pose: "hold", item: "phone", expression: "neutral" },
{ look: OLD, label: "shrug", pose: "shrug", expression: "confused" },
{ look: WORKER, label: "facepalm", pose: "facepalm", expression: "sad" },
];
const Fig = CharacterFigure as unknown as React.FC<Record<string, unknown>>;
const Insert = HandsInsert as unknown as React.FC<Record<string, unknown>>;
function renderPoseSheet(mode: "full" | "close") {
const cw = 360, ch = mode === "close" ? 580 : 760, cols = 6;
const rows = Math.ceil(CELLS.length / cols);
const W = cw * cols, H = ch * rows;
const sheet = (
<svg xmlns="http://www.w3.org/2000/svg" viewBox={`0 0 ${W} ${H}`} width={W} height={H}>
<rect width={W} height={H} fill="#8f9bb3" />
{CELLS.map((c, i) => {
const x = (i % cols) * cw, y = Math.floor(i / cols) * ch;
const fw = mode === "close" ? 400 : 330, fh = fw * 2.2;
const fx = x + (cw - fw) / 2, fy = mode === "close" ? y - 42 : y + ch - fh - 10;
const cid = `cell${mode}${i}`;
return (
<g key={i}>
<defs>
<clipPath id={cid}>
<rect x={x + 4} y={y + 4} width={cw - 8} height={ch - 8} rx={14} />
</clipPath>
</defs>
<rect x={x + 4} y={y + 4} width={cw - 8} height={ch - 8} rx={14} fill={i % 2 ? "#a3adc2" : "#97a3ba"} />
<g clipPath={`url(#${cid})`}>
<svg x={fx} y={fy} width={fw} height={fh} viewBox="0 0 200 440" overflow="hidden">
<Fig look={c.look} expression={c.expression} pose={c.pose} item={c.item} gesture={c.gesture} t={0.6} />
</svg>
</g>
<text x={x + 16} y={y + 34} fontSize={22} fontFamily="Arial" fontWeight={700} fill="#1b1d26">{c.label}</text>
</g>
);
})}
</svg>
);
return { svg: renderToStaticMarkup(sheet), W };
}
function renderCompareSheet() {
const refDir = path.resolve("..", "referencia", "recortes");
const loadRef = (name: string) => {
const p = path.join(refDir, name);
if (!fs.existsSync(p)) return "";
return `data:image/png;base64,${fs.readFileSync(p).toString("base64")}`;
};
// Enquadra nosso SVG (viewBox 0 0 200 440) na mesma janela de recorte usando um `<g transform="translate(...) scale(...)">`.
const cropFig = (boxW: number, boxH: number, cx: number, cy: number, span: number, node: React.ReactNode) => {
const k = boxW / span;
const tx = boxW / 2 - cx * k;
const ty = boxH / 2 - cy * k;
return (
<g transform={`translate(${tx} ${ty}) scale(${k})`}>
<svg width={200} height={440} viewBox="0 0 200 440" overflow="visible">{node}</svg>
</g>
);
};
const items: {
title: string;
refFile: string;
bg: string;
renderOur: (w: number, h: number) => React.ReactNode;
}[] = [
{
title: "1. Rosto (close)",
refFile: "rosto-close.png",
bg: "#1e2742",
renderOur: (w, h) => cropFig(w, h, 100, 148, 138, <Fig look={OLD} expression="smile" pose="stand" t={0.6} />),
},
{
title: "2. Segurando (2 mãos)",
refFile: "maos-segurando.png",
bg: "#232d4b",
renderOur: (w, h) => cropFig(w, h, 100, 250, 128, <Fig look={OLD} expression="smile" pose="hold" item="book" t={0.6} />),
},
{
title: "3. Joinha (thumbs_up)",
refFile: "joinha.png",
bg: "#68623e",
renderOur: (w, h) => cropFig(w, h, 122, 212, 130, <Fig look={COACH} expression="happy" pose="thumbs_up" gesture="thumbs_up" t={0.6} />),
},
{
title: "4. Segurando (1 mão)",
refFile: "mao-prancheta.png",
bg: "#3e4844",
renderOur: (w, h) => cropFig(w, h, 118, 224, 132, <Fig look={COACH} expression="happy" pose="hold" item="ruler" t={0.6} />),
},
{
title: "5. Apontando (point)",
refFile: "apontando.png",
bg: "#6e4e3a",
renderOur: (w, h) => cropFig(w, h, 130, 178, 125, <Fig look={MECHANIC} expression="happy" pose="point" t={0.6} />),
},
{
title: "6. Braços cruzados",
refFile: "bracos-cruzados.png",
bg: "#8c8275",
renderOur: (w, h) => cropFig(w, h, 100, 266, 142, <Fig look={WORKER} expression="sad" pose="cross_arms" t={0.6} />),
},
{
title: "7. Insert de mãos",
refFile: "insert-maos.png",
bg: "#4a3322",
renderOur: (w, h) => (
<g transform={`translate(${-w * 0.12} ${-h * 0.14}) scale(${(w * 1.24) / 1080})`}>
<svg width={1080} height={1080} viewBox="0 0 1080 1080" overflow="visible">
<Insert look={OLD} item="book" t={0.6} />
</svg>
</g>
),
},
];
const cw = 320, ch = 320, pad = 16, topBanner = 52, labelH = 34;
const W = items.length * cw, H = topBanner + (ch + labelH) * 2 + 20;
const sheet = (
<svg xmlns="http://www.w3.org/2000/svg" viewBox={`0 0 ${W} ${H}`} width={W} height={H}>
<rect width={W} height={H} fill="#181c26" />
<text x={20} y={36} fontSize={24} fontFamily="Arial" fontWeight={700} fill="#f2c230">
REFERÊNCIA (recortes originais) × NOSSO RESULTADO (SVG puro / rig contínuo sem juntas)
</text>
{items.map((it, i) => {
const x = i * cw;
const yRef = topBanner + labelH;
const yOur = yRef + ch + labelH;
const boxW = cw - pad, boxH = ch - pad;
const refData = loadRef(it.refFile);
return (
<g key={i}>
<text x={x + 12} y={yRef - 10} fontSize={18} fontFamily="Arial" fontWeight={700} fill="#d5dce8">{it.title} — Ref</text>
<defs>
<clipPath id={`cref${i}`}><rect x={x + 8} y={yRef} width={boxW} height={boxH} rx={12} /></clipPath>
<clipPath id={`cour${i}`}><rect x={x + 8} y={yOur} width={boxW} height={boxH} rx={12} /></clipPath>
</defs>
<g clipPath={`url(#cref${i})`}>
<rect x={x + 8} y={yRef} width={boxW} height={boxH} fill="#2a3040" />
{refData && <image href={refData} x={x + 8} y={yRef} width={boxW} height={boxH} preserveAspectRatio="xMidYMid slice" />}
</g>
<text x={x + 12} y={yOur - 10} fontSize={18} fontFamily="Arial" fontWeight={700} fill="#7be08a">{it.title} — Nosso</text>
<g clipPath={`url(#cour${i})`}>
<g transform={`translate(${x + 8} ${yOur})`}>
<rect width={boxW} height={boxH} fill={it.bg} />
{it.renderOur(boxW, boxH)}
</g>
</g>
</g>
);
})}
</svg>
);
return { svg: renderToStaticMarkup(sheet), W };
}
fs.mkdirSync("out", { recursive: true });
const arg = process.argv[2] ?? "full";
const { Resvg } = await import("@resvg/resvg-js").catch(() => ({ Resvg: null as unknown as typeof import("@resvg/resvg-js").Resvg }));
if (arg === "compare") {
const { svg, W } = renderCompareSheet();
fs.writeFileSync("out/referencia-vs-resultado.svg", svg);
if (Resvg) {
fs.writeFileSync("out/referencia-vs-resultado.png", new Resvg(svg, { fitTo: { mode: "width", value: W } }).render().asPng());
console.log("out/referencia-vs-resultado.png");
}
} else {
const mode = arg === "close" ? "close" : "full";
const { svg, W } = renderPoseSheet(mode);
fs.writeFileSync(`out/sheet-${mode}.svg`, svg);
console.log(`out/sheet-${mode}.svg`);
if (Resvg) {
fs.writeFileSync(`out/sheet-${mode}.png`, new Resvg(svg, { fitTo: { mode: "width", value: W } }).render().asPng());
console.log(`out/sheet-${mode}.png`);
}
const cmp = renderCompareSheet();
fs.writeFileSync("out/referencia-vs-resultado.svg", cmp.svg);
if (Resvg) {
fs.writeFileSync("out/referencia-vs-resultado.png", new Resvg(cmp.svg, { fitTo: { mode: "width", value: cmp.W } }).render().asPng());
console.log("out/referencia-vs-resultado.png");
}
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,111 @@
// Personagem do estilo Cartoon montado por PEÇAS (não é desenho pronto): o mesmo personagem sai igual em
// qualquer cena e história, mudando só expressão, pose e o que tem na mão. Guardado na biblioteca de
// personagens (assets/characters/<id>/character.json) e copiado no spec de cada trecho.
export const BUILDS = ["slim", "average", "heavy"] as const;
export const HAIR_STYLES = ["short", "side", "bun", "long", "curly", "spiky", "bald", "cap"] as const;
export const BEARD_STYLES = ["none", "stubble", "mustache", "full", "goatee", "long"] as const;
export const GLASSES = ["none", "round", "square", "sun"] as const;
export const BROWS = ["thin", "thick"] as const;
/** "robe" = túnica longa até a canela (com faixa na cintura), de roupa antiga. */
export const TOP_STYLES = ["shirt", "jacket", "hoodie", "dress", "uniform", "robe"] as const;
export const BOTTOM_STYLES = ["pants", "shorts", "skirt"] as const;
export const HEAD_SHAPES = ["round", "oval", "square", "wide"] as const;
export const NOSES = ["button", "curve", "round", "long", "wide"] as const;
/** Calçado: sapato fechado (cor em `shoes`), sandália de tiras ou pé descalço. */
export const FOOTWEAR = ["shoes", "sandals", "bare"] as const;
/** Acessórios desenhados por cima da roupa (combináveis). */
export const ACCESSORIES = ["towel", "whistle", "tie", "vest", "helmet", "watch", "badge", "apron", "scarf", "headset", "chain"] as const;
export type Accessory = (typeof ACCESSORIES)[number];
// Expressões e poses são ATALHOS do rig (rig.ts): parâmetros contínuos que dá para ajustar e misturar.
import { EXPRESSION_NAMES, POSE_NAMES, type ExpressionName, type PoseName } from "./rig";
export const EXPRESSIONS = EXPRESSION_NAMES;
export const POSES = POSE_NAMES;
export type Expression = ExpressionName;
export type Pose = PoseName;
export type CharacterLook = {
build: (typeof BUILDS)[number];
/** Altura relativa (0,85 a 1,15). Criança ≈ 0,8 é aceito também. */
height: number;
skin: string;
hair: { style: (typeof HAIR_STYLES)[number]; color: string };
beard: { style: (typeof BEARD_STYLES)[number]; color: string };
glasses: (typeof GLASSES)[number];
brows: (typeof BROWS)[number];
top: { style: (typeof TOP_STYLES)[number]; color: string; accent?: string };
bottom: { style: (typeof BOTTOM_STYLES)[number]; color: string };
shoes: string;
/** Tipo de calçado (padrão "shoes"); a cor continua em `shoes`. */
footwear?: (typeof FOOTWEAR)[number];
/** Detalhe de ilustração (opcionais; sem eles o personagem sai no traço simples). */
head?: (typeof HEAD_SHAPES)[number];
nose?: (typeof NOSES)[number];
/** Pálpebra de cima de base (0 olho aberto … 0,6 meio caído, olhar cansado/esperto). */
lids?: number;
/** Rugas (0 nenhuma … 1 muitas: testa e canto dos olhos). */
wrinkles?: number;
/** Barriga saliente (o "forte" de barriga). */
belly?: boolean;
accessories?: Accessory[];
/** Cor dos acessórios principais (toalha, gravata, colete, capacete…). */
accessoryColor?: string;
};
/** Ficha do personagem na biblioteca. `kind: "3d"` aponta para a pessoa articulada da Godot (godot/kits). */
export type Character = {
schemaVersion: 1;
id: string;
name: string;
/** Texto curto que aparece na etiqueta (ex.: "Engenheiro de minas · 58 anos"). */
caption?: string;
description?: string;
kind: "cartoon" | "3d";
look: CharacterLook;
/** Só kind "3d": parâmetros da pessoa articulada da Godot. */
godot?: Record<string, unknown>;
createdAt?: string;
updatedAt?: string;
};
export const DEFAULT_LOOK: CharacterLook = {
build: "average", height: 1, skin: "#c98a5e",
hair: { style: "short", color: "#3a2a1e" }, beard: { style: "none", color: "#3a2a1e" },
glasses: "none", brows: "thin",
top: { style: "shirt", color: "#4f7a4a", accent: "#e8b13a" }, bottom: { style: "pants", color: "#2b3350" }, shoes: "#1b1b22",
};
const HEX = /^#[0-9a-f]{6}$/i;
const one = <T extends readonly string[]>(list: T, v: unknown): v is T[number] => typeof v === "string" && list.includes(v);
/** Confere a aparência e devolve os problemas (vazio = ok). */
export function validateLook(look: unknown): string[] {
const l = look as Partial<CharacterLook> | null;
if (!l || typeof l !== "object") return ["look precisa ser um objeto"];
const errors: string[] = [];
if (!one(BUILDS, l.build)) errors.push(`build: ${BUILDS.join("|")}`);
if (typeof l.height !== "number" || !(l.height >= 0.6 && l.height <= 1.2)) errors.push("height entre 0,6 e 1,2");
for (const [k, v] of [["skin", l.skin], ["hair.color", l.hair?.color], ["beard.color", l.beard?.color], ["top.color", l.top?.color],
["bottom.color", l.bottom?.color], ["shoes", l.shoes]] as const) {
if (typeof v !== "string" || !HEX.test(v)) errors.push(`${k}: cor #rrggbb`);
}
if (l.top?.accent !== undefined && !HEX.test(l.top.accent)) errors.push("top.accent: cor #rrggbb");
if (!one(HAIR_STYLES, l.hair?.style)) errors.push(`hair.style: ${HAIR_STYLES.join("|")}`);
if (!one(BEARD_STYLES, l.beard?.style)) errors.push(`beard.style: ${BEARD_STYLES.join("|")}`);
if (!one(GLASSES, l.glasses)) errors.push(`glasses: ${GLASSES.join("|")}`);
if (!one(BROWS, l.brows)) errors.push(`brows: ${BROWS.join("|")}`);
if (!one(TOP_STYLES, l.top?.style)) errors.push(`top.style: ${TOP_STYLES.join("|")}`);
if (!one(BOTTOM_STYLES, l.bottom?.style)) errors.push(`bottom.style: ${BOTTOM_STYLES.join("|")}`);
if (l.head !== undefined && !one(HEAD_SHAPES, l.head)) errors.push(`head: ${HEAD_SHAPES.join("|")}`);
if (l.nose !== undefined && !one(NOSES, l.nose)) errors.push(`nose: ${NOSES.join("|")}`);
if (l.lids !== undefined && !(typeof l.lids === "number" && l.lids >= 0 && l.lids <= 0.8)) errors.push("lids entre 0 e 0,8");
if (l.wrinkles !== undefined && !(typeof l.wrinkles === "number" && l.wrinkles >= 0 && l.wrinkles <= 1)) errors.push("wrinkles entre 0 e 1");
if (l.accessories !== undefined && (!Array.isArray(l.accessories) || l.accessories.some((a) => !one(ACCESSORIES, a)))) errors.push(`accessories: ${ACCESSORIES.join("|")}`);
if (l.footwear !== undefined && !one(FOOTWEAR, l.footwear)) errors.push(`footwear: ${FOOTWEAR.join("|")}`);
if (l.accessoryColor !== undefined && !HEX.test(l.accessoryColor)) errors.push("accessoryColor: cor #rrggbb");
return errors;
}
export const isExpression = (v: unknown): v is Expression => typeof v === "string" && (EXPRESSIONS as string[]).includes(v);
export const isPose = (v: unknown): v is Pose => typeof v === "string" && (POSES as string[]).includes(v);
@@ -0,0 +1,32 @@
// Cores e nomes de fonte do estilo Cartoon (vetor chapado). Sem Remotion: o painel também usa.
import type { TimeOfDay, Tone } from "./spec";
export const SKY: Record<TimeOfDay, [string, string]> = {
night: ["#0b0e22", "#1c2147"],
dawn: ["#2a2c5c", "#8a6a9c"],
day: ["#5aa9e6", "#bfe3f5"],
};
export const COLORS = {
ground: "#14172e",
road: "#1a1d38",
roadLine: "#3a3f6b",
house: ["#3b3f74", "#34386a", "#2f3362", "#41467e"],
houseFar: "#2a2d57",
roof: "#272a52",
window: "#1b1d3a",
light: "#ffc94a",
glow: "rgba(255, 190, 70, 0.35)",
text: "#ffffff",
key: "#ffcf3f",
danger: "#ff4d4d",
ok: "#3ddc84",
ink: "#0c0d1a",
blueprint: "#10245a",
grid: "rgba(120, 160, 255, 0.12)",
};
export const TONE_BG: Record<Tone, string> = { info: "#ffcf3f", danger: "#ff4d4d", ok: "#3ddc84" };
export const TONE_FG: Record<Tone, string> = { info: "#141414", danger: "#ffffff", ok: "#0c2a18" };
export const FONT_CAPTION = "CartoonAnton";
export const FONT_LABEL = "CartoonBebas";
@@ -0,0 +1,392 @@
// Biblioteca de MÃOS desenhadas no estilo de ilustração cartoon de referência (quadro canônico 120×120):
// - Proporções cheias, compactas e arredondadas (como em referencia/recortes/joinha.png, maos-segurando.png,
// mao-prancheta.png e apontando.png): sem dedos compridos em salsicha;
// - Base do pulso cilíndrica arredondada centrada em `wrist` (emenda perfeita com o antebraço ou punho da manga);
// - Sulcos quentes e curtos entre os dedos dobrados, e sombreado cel limpo em 2 tons acompanhando o volume;
// - Camadas `back` (atrás do objeto) e `front` (dedos/polegar na frente do objeto) para que qualquer objeto seguro
// fique claramente DENTRO da mão.
import React from "react";
import type { IconId } from "./spec";
export const HAND_SHAPES = [
"relaxed",
"open",
"point",
"thumbs_up",
"grip",
"pinch_edge",
"pinch_low",
"fist",
"on_face",
"think",
"crossed",
] as const;
export type HandShape = (typeof HAND_SHAPES)[number];
type ShapeDef = {
/** Silhueta principal (camada de trás quando `bodyBehind` é true). */
body: string;
/** Sombra cel em crescente macio (recortada pela silhueta `body`). */
shadow: string;
/** Linhas internas quentes: separação dos dedos, nós e dobras da palma. */
lines: string;
/** Peça por cima (polegar ou dedos que abraçam o objeto pela frente), com sombra e linhas próprias. */
over?: { body: string; shadow?: string; lines?: string };
/** Unhas discretas (só quando a vista pede): [cx, cy, rx, ry, giro]. */
nails?: [number, number, number, number, number][];
overNails?: [number, number, number, number, number][];
/** Pulso no quadro (centro da junta redonda onde termina o antebraço). */
wrist: [number, number];
/** Ângulo do antebraço para o qual a forma foi desenhada (0 = descendo; formas alinhadas = 0). */
wristDeg: number;
upright: boolean;
/** Com objeto: `body` fica ATRÁS do objeto e `over` fica NA FRENTE dele (objeto dentro da mão). */
bodyBehind?: boolean;
/** Ponto onde passa o cabo (`grip`) ou encosta a borda (`pinch_edge`/`pinch_low`). */
hold?: [number, number];
};
// Base redonda no pulso (centro (60, 0), raio ~13.5): garante emenda contínua em qualquer rotação.
const WRIST_CAP = "M46.5 0 A13.5 11 0 0 1 73.5 0";
const SHAPES: Record<HandShape, ShapeDef> = {
// Caída ao lado do corpo: formas arredondadas e carnudas, polegar voltado para dentro, dedos juntos curvando suavemente.
relaxed: {
body: `${WRIST_CAP}`
+ " C76 8 82.5 18 84 31 C85.2 43 84.4 55 82 65 C80.8 70.5 77.8 73.5 74.5 73 C72.2 72.6 70.8 70.5 70.4 67.5"
+ " C69.8 74 68 79 64.2 79.6 C60.8 80.2 58.6 77.5 58.2 73"
+ " C57.4 78.5 55.2 82 51.2 82 C47.5 82 45.4 78.5 45.2 73.5"
+ " C44.2 76.5 42 78 39.2 77.4 C35.8 76.6 34.2 72.5 34.8 66 C35.5 57 37.2 48 39 41"
+ " C37 46.5 35 51.5 32.2 54 C29 56.8 25 55.5 24.2 51 C23.2 45.8 25.5 37.5 29.5 29.5"
+ " C34 21 41 13.5 45 5.5 C46 3.5 46.5 1.8 46.5 0 Z",
shadow: "M66 -10 C69 5 75.5 16 78 30 C79.8 43 78.8 56 76 67 C72.5 75 62 80 44 78 L44 90 L92 90 L92 -10 Z",
lines: "M39 41 C40.8 35 41.5 28.5 40.5 22.5 M45.2 73.5 C45.8 65.5 46.8 58 48.2 52 M58.2 73 C58.8 65 59.5 57.5 60.2 51.5 M70.4 67.5 C71 61 71.6 55 72 50",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Mão aberta (acenando / comemorando): palma carnuda, dedos abrindo em leque macio que afinam na ponta, polegar na base.
open: {
body: `${WRIST_CAP}`
+ " C75.5 7 81.5 16 83.8 28 C85 35 86 43 88 51.5 C89.2 56.8 88 61.2 84.8 62.2 C81.5 63.2 78.6 60.4 76.6 55"
+ " C74.8 50.2 73.2 45.2 71.8 41.2 C73 50 74.2 60.5 74.6 68.8 C74.9 74.6 72.2 78.2 68.4 78.2 C64.8 78.2 62.6 74.8 62.2 69"
+ " C61.8 60.5 61.2 51.5 60.8 44 C60.5 54 60.2 65.5 59.6 74.2 C59.2 80.4 56.2 83.6 52.2 83.4 C48.4 83.2 46.2 79.6 46.2 73.5"
+ " C46.2 64.5 46.8 54 47.5 44.5 C46 52.5 44.5 61.5 43.5 68.5 C42.6 74 39.6 76.8 36 76.2 C32.4 75.5 30.8 72 31.5 66.2"
+ " C32.8 56 35.2 44.5 37.5 35 C33.5 38.8 29.2 42.8 25 45.5 C20.8 48.2 16.4 47 15.2 43 C14 39 16.5 34 21.2 30.2"
+ " C27.2 25.4 34.8 20.8 40.2 14.5 C43.8 10.2 46 5 46.5 0 Z",
shadow: "M67 -10 C70 5 77 16 80 30 C82 40 83.5 50 86 60 L96 60 L96 -10 Z"
+ " M46 28 C53 33.5 63 35.5 72 32 C68 38.5 57 40.5 47 35.5 Z",
lines: "M43 37 C53 34 64.5 34.5 73.5 38.5 M38.5 34 C42.8 28 46 21 47 14",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Apontando (como em referencia/recortes/apontando.png):
// Polegar redondo na lateral interna (esquerda), indicador comprido subindo firme ao lado dele,
// e os 3 outros dedos (médio, anelar, mínimo) dobrados em escada arredondada macia na direita.
point: {
body: `${WRIST_CAP}`
+ " C76 8 82.5 18 84.5 30 C86 39 86.5 48 84 55.5 C82 61 77.2 63.5 72.5 61.5"
+ " C71 66.8 66.2 69.8 60.8 68.6 C58 68 55.8 66 54.6 63.5"
+ " C53 67.5 51 69.5 48.8 69.5 C48.8 79.5 48.8 90.5 48.4 98.5"
+ " C48 105.5 44.2 109.2 39.4 109 C34.6 108.8 31.4 104.6 31.8 97.5"
+ " C32.4 85 33.8 69.5 35 55.5 C29 51.5 25 44.5 25.8 36.2 C26.6 28 32.2 21 38.8 15.2"
+ " C43.2 11 45.8 5.2 46.5 0 Z",
shadow: "M65 -10 C68.5 5 76 15 79 29 C81 39 80.5 49 78 56 C73 60.5 63 64.5 50 65.5 L50 75 L93 75 L93 -10 Z"
+ " M42.8 58 C44.2 72 44.2 88 43.2 109 L49.5 109 L49.5 58 Z",
lines: "M50.5 68.5 C50.8 60.5 51.6 53 53.5 47.5 M61.8 68 C62.4 60 63.2 53 64.8 47.5 M72.5 61.5 C73.2 55 74 49 75.2 44.5"
+ " M49 48.5 C57.5 46 67.5 44.5 78 43",
over: {
body: "M25.8 36.2 C26.6 27.5 33.8 21 41.2 24.2 C47 26.8 52.2 34.5 55.5 42.2 C58.5 49 57.5 56.5 52.2 58.8 C47 61.2 39.2 57.8 33.2 51.5 C27.8 45.8 25.2 41.2 25.8 36.2 Z",
shadow: "M28.5 43.5 C33.8 50.8 42.2 56.5 50.5 58 L47.5 62 L26.5 48.5 Z",
lines: "M35 27.5 C41.2 32.5 48 39.5 52.5 46.5",
},
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Joinha (proporção compacta e redonda idêntica a referencia/recortes/joinha.png):
// Punho cheio e arredondado (largura ~52, altura ~56 na palma), 4 dedos gordinhos empilhados com sulcos curtos,
// e polegar forte subindo na vertical do topo da palma.
thumbs_up: {
body: "M74 88 A13.5 13.5 0 0 0 90 66"
+ " C87 57 82 49 75 43"
+ " C75.5 32 75 19 73 10.5 C71.2 3.5 66.5 0 60.5 0.5 C54.8 1 51.2 6 51 14.5"
+ " C50.8 23.5 51.2 32.5 50 39 C41 38.5 33 40 29.5 45.5 C26.2 50.6 27.8 57 33 58.8"
+ " C27.2 61.2 26.8 68.8 32.2 71.6 C28.2 74.4 28.8 81.8 34 84"
+ " C31.8 87.5 34.2 93.8 41 95 C51 96.8 63 96 70.5 91.5 C72.5 90.2 73.5 89 74 88 Z",
shadow: "M67 2 C70.8 10 72 25 72 41 C78.5 46 84 55 87 65 L92 74 L74 92 L34 97 L30 89"
+ " C44 93.5 59 93 68.5 88.5 C75.5 85 78.5 76 77 65 C75.5 54 72 46.5 66 42.5 L66 2 Z"
+ " M31.5 57.2 C40.5 59.8 50.5 60 59 58.5 L59 61.2 C49.5 62.6 40.5 62.2 31 59.8 Z"
+ " M31 70 C40 72.6 50.5 72.8 59 71.2 L59 74 C49.5 75.4 40 75 30.5 72.6 Z"
+ " M33 82.4 C41.5 84.8 50 85 57.5 83.8 L57.5 86.5 C49 87.6 41.5 87.2 32.5 85 Z",
lines: "M33 58.8 C41 60.8 50 61 58 59.5 M32.2 71.6 C40.5 73.6 50 73.8 58 72.2 M34 84 C41.8 85.8 49.5 86 56.5 84.8"
+ " M51 36.5 C56.5 39.8 64.5 40.2 71.5 37.5",
wrist: [82, 76], wristDeg: 135, upright: true,
},
// Punho segurando um cabo ou prancheta (proporção compacta e redonda idêntica a referencia/recortes/mao-prancheta.png):
// - `body` (atrás do cabo): base da palma;
// - `over` (na frente do cabo): mão redonda e carnuda com 4 dedos roliços empilhados e 3 sulcos curtos.
grip: {
body: "M88 77 A13.5 13.5 0 0 0 88 50"
+ " C81 44 71 40 59 40 C47 40 37 43 33.5 51 C30 59 31 73 36 83"
+ " C41 91 54 93 67 90 C77 87.5 84 83 88 77 Z",
shadow: "M76 44 C83 52 86 64 83 75 C80 84 72 90 60 92 L92 92 L92 44 Z",
lines: "",
over: {
body: "M86 48 C79 38 66 33.5 53 34 C41 34.5 33 38 30.5 44.5 C28.5 49.5 30.2 53.5 34.5 55.2"
+ " C28 57 26 63 29.5 68 C31 70 33 71 35.5 71.6"
+ " C29.5 73.8 29 80.5 34 83.5 C32 86.8 34.2 92.5 41 93.8"
+ " C51.5 95.8 65 95 75 90.5 C83 87 88 81 89.5 74 C91 66 90 55 86 48 Z",
shadow: "M76 41 C84 49 87.5 61 85 73 C82 83 73.5 90 61.5 92.5 C49.5 95 39 94 32 90.5 L32 97 L92 97 L92 41 Z"
+ " M33.5 53.8 C42 56.2 52.5 56.2 61 54.5 L61 57.2 C52 59 41.5 58.8 32.5 56.2 Z"
+ " M33.8 70.2 C42 72.5 52 72.8 60 71.2 L60 74 C51 75.5 41 75 32.8 72.8 Z"
+ " M33.5 82.2 C41.5 84.5 51 84.8 58.5 83.5 L58.5 86.2 C50 87.5 40.5 87.2 32.5 84.8 Z",
lines: "M34.5 55.2 C43 57.2 53 57 60.5 55.2 M35.5 71.6 C43.5 73.6 52.5 73.8 59.5 72.2 M34 83.5 C42 85.5 50.5 85.8 57.5 84.5",
},
wrist: [86, 64], wristDeg: 45, upright: true, bodyBehind: true, hold: [44, 65],
},
// Segurando a borda lateral de um objeto largo (proporção redonda e compacta idêntica a referencia/recortes/maos-segurando.png):
// - `body` (atrás): palma arredondada que apoia por trás do objeto;
// - `over` (na frente da borda): mão redonda e gordinha (`largura ~50, altura ~58`) com 4 dedos roliços e 3 sulcos curtos!
pinch_edge: {
body: "M88 73 A13.5 13.5 0 0 0 88 46"
+ " C81 39 70 35 59 36 C47 37 40 44 40 58 C40 72 45 83 54 88"
+ " C63 93 75 91 83 83 C86 79.5 87.5 76 88 73 Z",
shadow: "M76 40 C83 48 86 60 83.5 72 C81 82 73 88 61 90 L92 92 L92 40 Z",
lines: "",
over: {
body: "M85 44 C77 34 63 30 49 31.5 C37.5 32.8 30.5 38.5 32.5 45.8"
+ " C26.8 48 25 55.2 30 59.5 C25 62.2 24.8 70 30.5 73.5"
+ " C27.2 77.2 29.2 84.5 36 87 C46 90.5 60 91 72 87"
+ " C80.5 84 86.5 78 88.2 70.5 C90 62 89 51 85 44 Z",
shadow: "M75 38 C83 47 86.5 59.5 84 71.5 C81.5 81.5 73 87.5 60.5 89 C47.5 90.5 37 88 31.5 83.5 L31.5 93 L92 93 L92 38 Z"
+ " M32 44.5 C40.5 47.2 50.5 47.5 58.5 46 L58.5 48.8 C49.5 50.2 39.5 50 31 47.2 Z"
+ " M29.5 58.2 C38 61 48 61.2 56 59.8 L56 62.5 C47 64 37 63.8 28.5 61 Z"
+ " M30 72.2 C38.5 74.8 48 75 55.5 73.6 L55.5 76.4 C46.5 77.8 37.5 77.5 29 75 Z",
lines: "M32.5 45.8 C41 48 50.5 48.2 58 46.8 M30 59.5 C38.5 61.8 48 62 55.5 60.5 M30.5 73.5 C38.8 75.8 47.8 76 54.8 74.6",
},
wrist: [85, 60], wristDeg: 62, upright: true, bodyBehind: true, hold: [44, 60],
},
// Pegada de borda com o antebraço vindo de baixo (HandsInsert): dedos atrás da página e polegar comprido + palma na frente.
pinch_low: {
body: "M84 106 A14 14 0 0 0 104 86"
+ " C99 76 95 64 92 52 C89 39 81 28 69 26 C59 24.5 52 30 51 40"
+ " C49.5 55 50 72 54 84 C58 93 69 98 84 106 Z",
shadow: "M78 28 C88 39 92 55 95 70 C97 80 100 86 105 92 L112 104 L76 108 L54 90 C66 93 78 90 83 80 C88 68 85 45 78 28 Z",
lines: "M52 44 C59 44.5 66.5 46.5 72.5 50 M51.5 58 C58.5 58.8 65.5 60.8 71.5 64 M52.5 72 C58.5 72.8 64.5 74.8 69.5 78",
over: {
body: "M84 106 A14 14 0 0 0 104 86"
+ " C98 76 91 64 82 54 C72 44 56 34 45 30.5 C36.5 27.8 30.5 32.5 33 40"
+ " C35.5 47.5 45 54.5 55 61 C61 65 65 73 68 84 C71 94 77 101 84 106 Z",
shadow: "M34 41 C42 49 52 56 60 62 C65 68 68 78 72 90 L98 106 L82 110 L62 92 L32 46 Z",
lines: "M56 61 C62 64 67 69 70 76",
},
wrist: [94, 96], wristDeg: 135, upright: true, bodyBehind: true, hold: [56, 52],
},
// Punho fechado: 4 dedos dobrados em arco macio, polegar travando por cima do indicador e do médio.
fist: {
body: `${WRIST_CAP}`
+ " C75.5 8 81 18 82.8 30 C84.2 40 84.2 50 81.5 56.5 C79.2 61.5 75.2 63.2 71.5 61.8"
+ " C69.8 66.2 65.5 68.5 60.8 67.6 C58.2 67 56.2 65.2 55 62.8"
+ " C53.2 66.8 48.8 68.8 44.2 67.6 C39.5 66.4 36.2 62.2 35 55.5"
+ " C33.2 46 33.5 35 36.5 25.5 C39.5 16.5 44 9 46.2 2.5 C46.4 1.5 46.5 0.8 46.5 0 Z",
shadow: "M65 -10 C68 5 75 15 78 29 C80 40 79 50 75 57 C68 63 54 66 38 62 L38 74 L92 74 L92 -10 Z",
lines: "M46 67 C46.2 59.5 47 52.5 48.8 47 M60.8 67.6 C61.2 60 61.8 53 63.4 47.5 M71.5 61.8 C72 55.5 72.6 49.5 73.8 45"
+ " M42 48.5 C53 45.8 65 44.5 76.5 43.2",
over: {
body: "M35.5 28 C41 34 49 41 55.5 46.5 C60.2 50.5 61 56.8 56.5 59.8 C52 62.8 44.8 60 39.5 54.2 C34.5 48.8 32.5 39.5 35.5 28 Z",
shadow: "M35 44 C39.5 51 46.5 56.5 54 58.5 L50 62.5 L33 50 Z",
},
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Mão no rosto (tapar a boca / facepalm): palma arredondada e macia, dedos unidos em concha com sulcos curtos nas pontas.
on_face: {
body: `${WRIST_CAP}`
+ " C75 8 80 18 81.5 30 C82.8 41 82.4 55 80.5 67 C79.5 73 76.8 76 73.5 75.5 C71.5 75.2 70.2 73.5 69.8 71"
+ " C69.2 76.5 67.2 81.5 63.2 82 C59.8 82.4 58 80 57.6 76.5"
+ " C57 81.5 54.6 85 50.6 85 C46.8 85 44.8 81.5 44.6 76.5"
+ " C43.8 79.8 41.4 81.8 38.2 81.2 C34.8 80.5 33 76.5 33.6 69.5 C34.5 58 36.2 46.5 38 38"
+ " C35.5 42.5 33 46.5 30 48.5 C26.8 50.5 23.2 49 22.6 45 C22 40 24.8 32.5 29.5 25.5"
+ " C34.5 18 41.8 11 45.2 4 C46 2.5 46.5 1.2 46.5 0 Z",
shadow: "M65 -10 C68 5 74.5 16 77 30 C78.5 43 78 58 75.5 71 C72.5 79 61 84 44 83 L44 92 L90 92 L90 -10 Z",
lines: "M38 38 C39.8 32.5 40.6 27 40 21 M44.6 76.5 C45 69.5 45.8 63 46.8 57.5 M57.6 76.5 C58 69.5 58.4 63 59 57.5 M69.8 71 C70.2 65 70.6 59.5 71 55",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Mão pensando (apoiada no queixo): punho macio sob o queixo com o indicador estendido na bochecha/queixo
// e os outros 3 dedos dobrados em gomos arredondados (sem aspecto de garfo ou bloco).
think: {
body: `${WRIST_CAP}`
+ " C75.5 8 81.5 18 83.2 30 C84.5 40 84 50 81 57 C78.5 62.5 73.8 64.5 69.5 62.5"
+ " C67.8 67.2 63 69.5 58 68.2 C55.2 67.5 53.2 65.5 52.2 63"
+ " C50.5 66.5 47.8 68.2 44.8 67.5 C44.5 75 44 83.5 43 90"
+ " C42 96.2 38.2 99.5 33.8 98.8 C29.4 98 26.8 93.8 27.6 87"
+ " C29 75.5 31.2 61 33.5 48 C29.5 50.5 25 51.5 21.5 49.5 C17.8 47.5 16.5 42.5 18.8 37.5"
+ " C21.5 31.5 28 25.5 34.5 19.5 C40.5 14 44.8 7 46.5 0 Z",
shadow: "M65 -10 C68 5 75.5 16 78 30 C80 41 79 50 75 57 C69 63.5 57 66.5 43 65 L43 74 L91 74 L91 -10 Z"
+ " M38 56 C39.5 68 39.5 82 38.5 99 L44.5 99 L45 56 Z",
lines: "M33.5 48 C37.5 43 41 37 42.5 31 M45 66.5 C45.8 59 47 52 48.8 46.5 M58 68.2 C58.8 60.5 59.8 53.5 61.5 47.5 M69.5 62.5 C70.2 56 71 50 72.2 45",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Mão de braços cruzados apoiada no bíceps oposto (como em referencia/recortes/bracos-cruzados.png):
// 3 dedos roliços e macios pousados diagonalmente sobre o braço.
crossed: {
body: `${WRIST_CAP}`
+ " C74.5 8 79 18 80 29 C81 40 79.5 52 75.8 61.5 C73.2 68 68.5 71 63.8 69.5"
+ " C61.4 75.8 56.2 79.2 50.5 77.6 C47 76.6 44.6 73.6 43.8 69.5"
+ " C41.2 74 36.2 76 31.2 73.8 C26.4 71.6 24.4 66 26.8 59.2"
+ " C30 50 34.8 38.5 39 27.5 C42.2 19 45.4 9.5 46.5 0 Z",
shadow: "M64 -10 C67 5 72.5 16 74 30 C75 42 73.5 53 70 62 C65.5 70 52 75 33 72 L33 82 L88 82 L88 -10 Z",
lines: "M43.8 69.5 C46.5 59.5 49.8 50 53.2 42 M63.8 69.5 C65.8 60 67.8 51 70.2 43.5",
wrist: [60, 0], wristDeg: 0, upright: false,
},
};
/** Objetos seguros com as DUAS mãos (pelas bordas, na frente do peito). O resto vai numa mão só (`grip`). */
export const TWO_HANDED: IconId[] = ["book", "tablet"];
/**
* Como cada objeto entra no punho (`grip`): ponto do cabo no quadro 100×100 do ícone e o giro que deixa o cabo em pé
* (cabeça do martelo, ponta do ramo e da régua para cima) com sobra visível do cabo abaixo da mão.
*/
export const GRIP: Partial<Record<IconId, { x: number; y: number; rot: number }>> = {
hammer: { x: 50, y: 68, rot: 20 },
olive: { x: 36, y: 68, rot: -42 },
ruler: { x: 32, y: 50, rot: -78 },
phone: { x: 50, y: 62, rot: -6 },
fuel: { x: 50, y: 30, rot: 0 },
bulb: { x: 50, y: 74, rot: 0 },
};
/**
* Posição da forma: espelho (`mirror`), giro em graus e escala, a partir do pulso na tela, do ângulo do antebraço e do
* lado do braço. Formas alinhadas giram com o antebraço; as "em pé" acompanham o ângulo para o qual foram desenhadas.
*/
export function handPlacement(shape: HandShape, x: number, y: number, foreDeg: number, s: number, k: number) {
const def = SHAPES[shape];
let mirror: number;
let rot: number;
if (def.upright) {
mirror = s >= 0 ? 1 : -1;
rot = foreDeg - def.wristDeg * mirror;
} else {
const up = Math.cos((foreDeg * Math.PI) / 180) >= 0;
mirror = up ? s : -s;
rot = foreDeg;
}
const [wx, wy] = def.wrist;
const transform = `translate(${x} ${y}) rotate(${rot}) scale(${k * mirror} ${k}) translate(${-wx} ${-wy})`;
const r = (rot * Math.PI) / 180;
/** Ponto do quadro 120×120 → tela. */
const map = (px: number, py: number) => {
const lx = (px - wx) * k * mirror;
const ly = (py - wy) * k;
return { x: x + lx * Math.cos(r) - ly * Math.sin(r), y: y + lx * Math.sin(r) + ly * Math.cos(r) };
};
return { def, mirror, rot, transform, map, hold: def.hold ? map(def.hold[0], def.hold[1]) : null };
}
/** Pulso que põe o ponto `hold` da forma em (hx, hy) — para pôr as mãos nas bordas do objeto. */
export function wristForHold(shape: HandShape, hx: number, hy: number, foreDeg: number, s: number, k: number) {
const p = handPlacement(shape, 0, 0, foreDeg, s, k);
return { x: hx - (p.hold?.x ?? 0), y: hy - (p.hold?.y ?? 0) };
}
function shadeHex(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16);
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v * k))).toString(16).padStart(2, "0");
return `#${c((n >> 16) & 255)}${c((n >> 8) & 255)}${c(n & 255)}`;
}
/** Mistura duas cores hex (0 = a, 1 = b). */
function mixHex(a: string, b: string, t: number): string {
const pa = parseInt(a.slice(1), 16), pb = parseInt(b.slice(1), 16);
const ch = (sh: number) => Math.round(((pa >> sh) & 255) * (1 - t) + ((pb >> sh) & 255) * t).toString(16).padStart(2, "0");
return `#${ch(16)}${ch(8)}${ch(0)}`;
}
function coolHex(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16);
const r = ((n >> 16) & 255) * k * 0.96, g = ((n >> 8) & 255) * k * 0.96, b = (n & 255) * k + 6;
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
return `#${c(r)}${c(g)}${c(b)}`;
}
/**
* Desenha a forma de mão no lugar. `layer`: "back" = o que fica atrás do objeto, "front" = o que fica na frente,
* "all" = tudo. `light` = lado da sombra na tela (1 = direita).
*/
export function HandArt({ shape, x, y, foreDeg, s, k, skin, light = 1, layer = "all", uid }: {
shape: HandShape; x: number; y: number; foreDeg: number; s: number; k: number; skin: string; light?: number;
layer?: "all" | "back" | "front"; uid: string;
}) {
const p = handPlacement(shape, x, y, foreDeg, s, k);
const def = p.def;
const rightOnScreen = p.mirror * Math.cos((p.rot * Math.PI) / 180);
const flipShadow = Math.sign(rightOnScreen || 1) !== Math.sign(light || 1);
const shadowT = flipShadow && !def.upright ? "translate(120 0) scale(-1 1)" : undefined;
const creaseColor = shadeHex(skin, 0.76);
const shadowFill = coolHex(skin, 0.86);
const skinLite = mixHex(skin, "#fff6ea", 0.06);
const gradId = `hg${uid}${layer}`;
const lineProps = {
stroke: creaseColor,
strokeWidth: 3.1,
strokeLinecap: "round" as const,
strokeLinejoin: "round" as const,
fill: "none",
opacity: 0.9,
};
const nail = ([cx, cy, rx, ry, a]: [number, number, number, number, number], i: number) => (
<ellipse
key={i}
cx={cx}
cy={cy}
rx={rx}
ry={ry}
transform={`rotate(${a} ${cx} ${cy})`}
fill={mixHex(skin, "#fae5de", 0.38)}
opacity={0.8}
/>
);
const bodyLayer = def.bodyBehind ? "back" : def.hold ? "front" : "all";
const showBody = layer === "all" || layer === bodyLayer || (bodyLayer === "all" && layer === "front");
const showOver = layer !== "back";
return (
<g transform={p.transform}>
<defs>
<linearGradient id={gradId} x1="15%" y1="10%" x2="85%" y2="90%">
<stop offset="0%" stopColor={skinLite} />
<stop offset="100%" stopColor={skin} />
</linearGradient>
<clipPath id={`hb${uid}${layer}`}><path d={def.body} /></clipPath>
{def.over && <clipPath id={`ho${uid}${layer}`}><path d={def.over.body} /></clipPath>}
</defs>
{showBody && (
<>
<path d={def.body} fill={`url(#${gradId})`} />
<g clipPath={`url(#hb${uid}${layer})`}>
<path d={def.shadow} fill={shadowFill} transform={shadowT} opacity={0.88} />
</g>
{def.lines && <path d={def.lines} {...lineProps} />}
{(def.nails ?? []).map(nail)}
</>
)}
{showOver && def.over && (
<>
<path d={def.over.body} fill={`url(#${gradId})`} />
<g clipPath={`url(#ho${uid}${layer})`}>
{def.over.shadow && <path d={def.over.shadow} fill={shadowFill} opacity={0.88} />}
</g>
{def.over.lines && <path d={def.over.lines} {...lineProps} />}
{(def.overNails ?? []).map(nail)}
</>
)}
</g>
);
}
@@ -0,0 +1,127 @@
// Ícones chapados (viewBox 100×100). Formas simples, sem contorno, na paleta do estilo.
import React from "react";
import { COLORS } from "./colors";
import type { IconId } from "./spec";
const INK = COLORS.ink;
const DRAW: Record<IconId, React.ReactNode> = {
house: (<>
<polygon points="8,46 50,12 92,46" fill={COLORS.roof} />
<rect x={16} y={44} width={68} height={48} fill={COLORS.house[3]} />
<rect x={24} y={54} width={14} height={14} rx={2} fill={COLORS.light} />
<rect x={62} y={54} width={14} height={14} rx={2} fill={COLORS.light} />
<rect x={44} y={66} width={12} height={26} fill={COLORS.window} />
</>),
generator: (<>
<rect x={8} y={30} width={84} height={56} rx={8} fill="#2a2d3c" />
<rect x={14} y={22} width={58} height={16} rx={6} fill="#e8463d" />
<rect x={16} y={44} width={34} height={34} rx={4} fill="#4a4e63" />
{[0, 1, 2, 3, 4].map((i) => <rect key={i} x={19} y={48 + i * 6} width={28} height={3} fill="#2a2d3c" />)}
<circle cx={64} cy={52} r={4} fill="#11121a" /><circle cx={76} cy={52} r={4} fill="#11121a" />
<circle cx={70} cy={68} r={3} fill={COLORS.ok} />
<rect x={10} y={86} width={14} height={6} fill="#11121a" /><rect x={76} y={86} width={14} height={6} fill="#11121a" />
</>),
fuel: (<>
<rect x={20} y={22} width={60} height={72} rx={8} fill="#c8352f" />
<rect x={26} y={50} width={48} height={38} rx={4} fill="#e6b347" />
<path d="M30 22 L30 12 L60 12 L60 22" stroke="#c8352f" strokeWidth={6} fill="none" />
<rect x={66} y={8} width={12} height={14} fill="#c8352f" />
<path d="M30 56 L70 84 M70 56 L30 84" stroke="#c8352f" strokeWidth={3} />
</>),
battery: (<>
<rect x={28} y={14} width={44} height={80} rx={8} fill="#1d2b2a" stroke={COLORS.ok} strokeWidth={4} />
<rect x={40} y={6} width={20} height={10} rx={3} fill={COLORS.ok} />
<polygon points="54,30 38,58 50,58 46,80 62,50 50,50" fill={COLORS.ok} />
</>),
phone: (<>
<rect x={30} y={8} width={40} height={84} rx={8} fill="#15161f" />
<rect x={35} y={16} width={30} height={64} rx={3} fill="#2c3150" />
<rect x={42} y={40} width={16} height={8} rx={2} fill={COLORS.danger} />
</>),
door: (<>
<rect x={24} y={6} width={52} height={90} rx={3} fill="#4a2f22" />
<rect x={30} y={14} width={40} height={34} rx={2} fill="#3c251b" />
<rect x={30} y={54} width={40} height={34} rx={2} fill="#3c251b" />
<circle cx={66} cy={56} r={3.5} fill="#e6c27a" />
</>),
eye: (<>
<path d="M6 50 Q50 10 94 50 Q50 90 6 50 Z" fill="#f4f6ff" />
<circle cx={50} cy={50} r={20} fill="#2c3466" /><circle cx={50} cy={50} r={9} fill={INK} /><circle cx={56} cy={44} r={4} fill="#fff" />
</>),
bulb: (<>
<circle cx={50} cy={40} r={28} fill={COLORS.light} />
<rect x={38} y={64} width={24} height={16} rx={3} fill="#9aa0b8" /><rect x={42} y={80} width={16} height={8} rx={3} fill="#6c7190" />
</>),
solar: (<>
<polygon points="10,70 30,30 92,30 72,70" fill="#2b4fb8" />
<path d="M30 50 L82 50 M27 40 L87 40 M24 60 L77 60 M45 30 L35 70 M61 30 L51 70 M77 30 L67 70" stroke="#8fb0ff" strokeWidth={2} />
<rect x={46} y={70} width={6} height={22} fill="#6c7190" />
</>),
warning: (<>
<polygon points="50,8 94,88 6,88" fill={COLORS.key} />
<rect x={46} y={34} width={8} height={30} rx={3} fill={INK} /><circle cx={50} cy={74} r={5} fill={INK} />
</>),
money: (<>
<rect x={8} y={26} width={84} height={48} rx={6} fill="#3a9e5f" />
<circle cx={50} cy={50} r={14} fill="#2b7a49" /><text x={50} y={57} textAnchor="middle" fontSize={20} fontWeight={700} fill="#d9f5e3">$</text>
</>),
clock: (<>
<circle cx={50} cy={50} r={40} fill="#f4f6ff" /><circle cx={50} cy={50} r={34} fill="#232850" />
<rect x={48} y={24} width={4} height={28} rx={2} fill="#fff" /><rect x={48} y={48} width={22} height={4} rx={2} fill={COLORS.key} />
</>),
// Itens de mão e objetos de história antiga (também servem como objeto solto na cena).
olive: (<>
<path d="M14 94 Q44 62 86 14" stroke="#3d2814" strokeWidth={8.5} fill="none" strokeLinecap="round" />
<path d="M14 94 Q44 62 86 14" stroke="#7d5632" strokeWidth={5.5} fill="none" strokeLinecap="round" />
{[[38, 62, -38], [48, 52, 28], [58, 42, -38], [68, 32, 28], [78, 22, -38], [84, 15, -12]].map(([x, y, r], i) => (
<g key={i} transform={`rotate(${r} ${x} ${y})`}>
<ellipse cx={x} cy={y} rx={13.5} ry={6} fill={i % 2 ? "#557d32" : "#446827"} />
<ellipse cx={x} cy={y - 1} rx={12} ry={4.2} fill={i % 2 ? "#84ab4c" : "#6c943c"} />
<path d={`M${x - 9} ${y} L${x + 9} ${y}`} stroke="#9ec462" strokeWidth={1.2} strokeLinecap="round" opacity={0.7} />
</g>
))}
<circle cx={54} cy={54} r={4.5} fill="#2e2b4a" /><circle cx={52.5} cy={52.5} r={1.5} fill="#76729e" />
<circle cx={72} cy={35} r={4.5} fill="#2e2b4a" /><circle cx={70.5} cy={33.5} r={1.5} fill="#76729e" />
</>),
hammer: (<>
<g transform="rotate(-20 50 64)">
<rect x={42.5} y={28} width={15} height={68} rx={6} fill="#5c381c" />
<rect x={44} y={29} width={12} height={66} rx={5} fill="#9c6638" />
<rect x={45.5} y={30} width={4.5} height={64} rx={2} fill="#b87e4a" opacity={0.75} />
<rect x={42} y={32} width={16} height={6} rx={2} fill="#4a2e16" />
</g>
<g transform="rotate(-20 47 25)">
<rect x={18} y={11} width={58} height={25} rx={5} fill="#4d525e" />
<rect x={19} y={12} width={56} height={22} rx={4} fill="#8f96a3" />
<rect x={21} y={14} width={52} height={8} rx={3} fill="#b4bac6" opacity={0.7} />
<rect x={18} y={11} width={14} height={25} rx={4} fill="#686e7a" />
</g>
</>),
tablet: (<>
<path d="M18 10 Q50 4 82 10 L86 88 Q50 96 14 88 Z" fill="#8f6c4a" />
<path d="M20 12 Q50 6 80 12 L84 86 Q50 93 16 86 Z" fill="#b8916a" />
{Array.from({ length: 7 }, (_, i) => <path key={i} d={`M24 ${22 + i * 10} L76 ${22 + i * 10}`} stroke="#785638" strokeWidth={2.5} strokeDasharray="5 3 2 3" />)}
<path d="M70 70 L86 60 L86 88 L64 92 Z" fill="#000" opacity={0.18} />
</>),
book: (<>
<path d="M6 26 Q28 18 50 28 Q72 18 94 26 L94 86 Q72 78 50 88 Q28 78 6 86 Z" fill="#6b3022" />
<path d="M8 22 Q30 14 50 24 Q70 14 92 22 L92 80 Q70 72 50 82 Q30 72 8 80 Z" fill="#dfd2b5" />
<path d="M9 20 Q30 12 50 22 Q70 12 91 20 L91 77 Q70 69 50 79 Q30 69 9 77 Z" fill="#f5ecd6" />
<path d="M44 20 Q47 21 50 22 Q53 21 56 20 L56 78 Q53 78.5 50 79 Q47 78.5 44 78 Z" fill="#e2d5b8" />
<path d="M50 22 L50 79" stroke="#b9a882" strokeWidth={2.5} />
{[0, 1, 2, 3].map((i) => <g key={i}><path d={`M16 ${32 + i * 10.5} Q29 ${29 + i * 10.5} 43 ${34 + i * 10.5}`} stroke="#9a8a6a" strokeWidth={2.4} fill="none" strokeLinecap="round" /><path d={`M57 ${34 + i * 10.5} Q71 ${29 + i * 10.5} 84 ${32 + i * 10.5}`} stroke="#9a8a6a" strokeWidth={2.4} fill="none" strokeLinecap="round" /></g>)}
</>),
ruler: (<>
<g transform="rotate(-12 50 50)">
<rect x={4} y={36} width={92} height={26} rx={4} fill="#8c6230" />
<rect x={6} y={37} width={88} height={23} rx={3} fill="#e8c374" />
<rect x={8} y={53} width={84} height={6} rx={2} fill="#cfa656" />
{Array.from({ length: 11 }, (_, i) => <rect key={i} x={11 + i * 7.6} y={37} width={2.2} height={i % 2 ? 7 : 12} rx={0.8} fill="#5c3d1b" />)}
</g>
</>),
};
export function Icon({ id }: { id: IconId }) {
return <svg viewBox="0 0 100 100" width="100%" height="100%" overflow="visible">{DRAW[id]}</svg>;
}
@@ -0,0 +1,66 @@
// Profundidade dos braços do personagem de frente para a câmera (função pura do estado do rig, sem React).
//
// O desenho (CharacterFigure.tsx) empilha as camadas assim:
// tronco → braços "side" → acessórios do peito (toalha, cachecol, crachá, apito) → braços "front" →
// parte da toalha apoiada no ombro → cabeça → braços "face".
// Regra: com o personagem de frente, braço e mão NUNCA somem atrás do tronco, da roupa, de acessório ou da barba.
// - "face": a mão sobe até a altura do pescoço/rosto, dentro da largura da cabeça (pensar, tapar a boca, mão na
// testa) — desenhado por cima da cabeça e da barba;
// - "front": a mão ou o antebraço entram na frente do peito (segurar objeto diante do corpo, cruzar os braços,
// apontar para o outro lado, mão na cintura) — por cima do tronco e dos acessórios do peito;
// - "side": o braço fica ao lado do corpo (caído, acenando para fora, apontando para o lado) — por cima do tronco,
// mas por baixo do pano apoiado no ombro/peito (o braço sai por baixo da toalha).
// Não há caso "atrás do tronco": nenhuma pose do rig leva a mão às costas.
import type { BodyParams } from "./rig";
export type ArmLayer = "side" | "front" | "face";
export type Point = { x: number; y: number };
/** Ponta de um segmento: ângulo de tela em graus (0 = para baixo). Igual ao `tip` do desenho. */
export const tipOf = (x: number, y: number, deg: number, len: number): Point => {
const r = (deg * Math.PI) / 180;
return { x: x - Math.sin(r) * len, y: y + Math.cos(r) * len };
};
/** Medidas do desenho (viewBox 200×440) que a regra usa — as mesmas de CharacterFigure.tsx. */
export const ARM = { shoulderX: 54, upper: 56, wrist: 43, hand: 28, torsoHalf: 56 } as const;
/** Ombro, cotovelo, pulso e centro da mão do braço `s` (1 = direita da tela, -1 = esquerda). `w` = largura do corpo. */
export function armGeometry(b: BodyParams, s: 1 | -1, w = 1) {
const hipY = 306 + b.crouch * 56;
const shY = hipY - 100;
const torsoTop = hipY - 114;
const l = s > 0 ? b.armR : b.armL;
const shoulder = { x: 100 + s * ARM.shoulderX * w, y: shY };
const upperDeg = -s * l.raise;
const elbow = tipOf(shoulder.x, shoulder.y, upperDeg, ARM.upper);
const foreDeg = upperDeg + s * l.bend;
const wrist = tipOf(elbow.x, elbow.y, foreDeg, ARM.wrist);
const hand = tipOf(elbow.x, elbow.y, foreDeg, ARM.wrist + ARM.hand);
return { shoulder, elbow, wrist, hand, upperDeg, foreDeg, torsoTop, hipY };
}
/**
* Camada do braço `s` no quadro. `holds` = segura objeto (sempre na frente do corpo, salvo na altura do rosto).
* O "peito" é o tronco sem as faixas laterais onde o braço caído naturalmente encosta.
*/
export function armLayer(b: BodyParams, s: 1 | -1, opts: { holds?: boolean; w?: number } = {}): ArmLayer {
const w = opts.w ?? 1;
const g = armGeometry(b, s, w);
const l = s > 0 ? b.armR : b.armL;
const half = ARM.torsoHalf * w;
// Altura do pescoço/rosto: acima do topo do tronco (+ folga da gola), dentro da largura da cabeça, ou braço dobrado ao queixo/boca.
const atFace = (p: Point) => p.y < g.torsoTop + 20 && Math.abs(p.x - 100) < 60;
if (atFace(g.hand) || atFace(g.wrist) || (l.raise < 20 && l.bend > 138)) return "face";
if (opts.holds) return "front";
// Cotovelo bem dobrado para dentro com o braço baixo (segurar, joinha, mão na cintura, braços cruzados): antebraço na frente.
if (l.raise < 90 && l.bend > 85) return "front";
const chest = { x0: 100 - half + 14, x1: 100 + half - 14, y0: g.torsoTop + 4, y1: g.hipY + 12 };
const inChest = (p: Point) => p.x > chest.x0 && p.x < chest.x1 && p.y > chest.y0 && p.y < chest.y1;
// Amostra o antebraço (cotovelo → mão): basta um trecho na frente do peito.
for (let i = 0; i <= 8; i++) {
const k = i / 8;
if (inChest({ x: g.elbow.x + (g.hand.x - g.elbow.x) * k, y: g.elbow.y + (g.hand.y - g.elbow.y) * k })) return "front";
}
return "side";
}
@@ -0,0 +1,87 @@
// Boca acompanhando a fala SEM perder a expressão. O formato vem das letras da palavra que está sendo dita
// (tempos de cada palavra da transcrição): "a" abre, "e/i" esticam, "o/u" arredondam, "m/b/p" fecham, "f/v"
// mostram os dentes; vogal dura mais que consoante e as letras vizinhas se misturam (coarticulação). Se houver
// o volume do áudio quadro a quadro (`env`), ele fecha a boca nas pausas e abre mais nas sílabas fortes.
// A expressão continua por cima: os cantos (sorriso/tristeza), as sobrancelhas e os olhos são dela.
import type { FaceParams } from "./rig";
export type Viseme = { open: number; wide: number; round: number; teeth: boolean };
export type SpokenWord = { text: string; startS: number; endS: number };
const CLOSED: Viseme = { open: 0, wide: 0, round: 0, teeth: false };
const V: Record<string, Viseme> = {
a: { open: 0.85, wide: 0.3, round: 0, teeth: false },
e: { open: 0.55, wide: 0.65, round: 0, teeth: true },
i: { open: 0.3, wide: 0.95, round: 0, teeth: true },
o: { open: 0.65, wide: 0, round: 0.75, teeth: false },
u: { open: 0.35, wide: 0, round: 1, teeth: false },
mbp: { open: 0, wide: 0.1, round: 0, teeth: false },
fv: { open: 0.12, wide: 0.2, round: 0, teeth: true },
cons: { open: 0.3, wide: 0.3, round: 0, teeth: true },
};
function visemeOf(ch: string): Viseme {
if ("aáàâã".includes(ch)) return V.a;
if ("eéê".includes(ch)) return V.e;
if ("iíy".includes(ch)) return V.i;
if ("oóôõ".includes(ch)) return V.o;
if ("uúü".includes(ch)) return V.u;
if ("mbp".includes(ch)) return V.mbp;
if ("fv".includes(ch)) return V.fv;
return V.cons;
}
const isVowel = (ch: string) => /[aáàâãeéêiíyoóôõuúü]/.test(ch);
function mix(a: Viseme, b: Viseme, k: number): Viseme {
return { open: a.open + (b.open - a.open) * k, wide: a.wide + (b.wide - a.wide) * k, round: a.round + (b.round - a.round) * k, teeth: k < 0.5 ? a.teeth : b.teeth };
}
/** Formato da boca no instante `t` (segundos do trecho) para as palavras dadas; fechada fora das palavras. */
export function visemeAt(words: SpokenWord[], t: number, env?: { values: number[]; fps: number }): Viseme {
const w = words.find((x) => t >= x.startS && t < x.endS);
if (!w) {
// Fim de palavra: fecha em ~60 ms em vez de bater a boca.
const prev = [...words].reverse().find((x) => x.endS <= t);
return prev && t - prev.endS < 0.06 ? mix(V.cons, CLOSED, (t - prev.endS) / 0.06) : CLOSED;
}
const letters = [...w.text.toLowerCase().replace(/(ch|lh|nh|qu)/g, "c").replace(/[^a-záàâãéêíóôõúüçy]/g, "")];
if (!letters.length) return CLOSED;
// Vogal pesa o dobro da consoante no tempo da palavra.
const weights = letters.map((ch) => (isVowel(ch) ? 1.7 : 0.8));
const total = weights.reduce((a, b) => a + b, 0);
let pos = ((t - w.startS) / Math.max(0.04, w.endS - w.startS)) * total;
let i = 0;
while (i < letters.length - 1 && pos > weights[i]) { pos -= weights[i]; i++; }
const frac = Math.min(1, pos / weights[i]);
const cur = visemeOf(letters[i]);
const next = i + 1 < letters.length ? visemeOf(letters[i + 1]) : CLOSED;
// Coarticulação: a 2ª metade da letra já caminha para a próxima.
let v = frac > 0.5 ? mix(cur, next, (frac - 0.5) * 0.9) : cur;
if (env?.values.length) {
const a = env.values[Math.min(env.values.length - 1, Math.max(0, Math.floor(t * env.fps)))] ?? 0;
const k = Math.max(0, Math.min(1.15, (a - 0.03) / 0.3));
v = { ...v, open: v.open * (0.25 + 0.75 * Math.min(1, k)) * (k < 0.05 ? 0.2 : 1) };
}
return v;
}
/** Ênfase (0–1) no instante: o volume perto do pico levanta um pouco as sobrancelhas. */
export function emphasisAt(t: number, env?: { values: number[]; fps: number }): number {
if (!env?.values.length) return 0;
const a = env.values[Math.min(env.values.length - 1, Math.max(0, Math.floor(t * env.fps)))] ?? 0;
return Math.max(0, Math.min(1, (a - 0.45) / 0.4));
}
/** Põe a fala na boca mantendo a expressão (cantos, sobrancelhas, olhos). `k` = quanto da fala entra (0–1). */
export function speak(face: FaceParams, v: Viseme, k = 1, emphasis = 0): FaceParams {
const open = Math.max(face.mouthOpen * 0.35, v.open * 0.9);
return {
...face,
mouthOpen: face.mouthOpen + (open - face.mouthOpen) * k,
mouthWidth: face.mouthWidth * (1 + (v.wide * 0.22 - v.round * 0.45) * k),
mouthRound: face.mouthRound + (v.round - face.mouthRound) * k,
teeth: k > 0.5 ? v.teeth && v.open > 0.1 : face.teeth,
browL: { ...face.browL, y: face.browL.y - emphasis * 3 * k },
browR: { ...face.browR, y: face.browR.y - emphasis * 3 * k },
};
}
@@ -0,0 +1,222 @@
// Movimento do personagem: uma LINHA DO TEMPO de ações que se combinam (não animações prontas). Cada ação tem
// início (segundos `at`, fração do trecho `atP` ou a palavra da narração `cue`) e duração; o estado em cada
// quadro sai de aplicar as ações em ordem sobre a expressão/pose de base, mais a "vida" (piscar, respirar).
// Ações permanentes mudam o estado dali em diante (express, pose, walk, sit, fall, turn, look); as momentâneas
// voltam ao fim (nod, shake_head, tremble, bounce, wave, jump, talk, emote).
import { emphasisAt, speak, visemeAt, type SpokenWord } from "./lipsync";
import { blendBody, blendFace, bodyOf, faceOf, withBody, withFace, type BodyParams, type BodyPatch, type FaceParams, type FacePatch } from "./rig";
export const ACTIONS = ["express", "pose", "walk", "run", "enter", "exit", "jump", "nod", "shake_head", "tremble", "bounce", "fall",
"sit", "stand_up", "turn", "talk", "look", "emote", "wave", "hammer"] as const;
export type ActionKind = (typeof ACTIONS)[number];
export type Action = {
do: ActionKind;
/** Início: segundos, fração do trecho (0–1) ou a 1ª palavra da narração que começa com `cue`. */
at?: number; atP?: number; cue?: string;
dur?: number;
/** talk: termina no fim desta palavra da narração (a fala vai de `cue` até `cueEnd`). */
cueEnd?: string;
expression?: string; face?: FacePatch;
pose?: string; body?: BodyPatch;
/** walk/run/enter: x de destino (fração). */
to?: number;
/** look: para onde; fall: para que lado. */
dir?: "left" | "right" | "up" | "down";
/** nod/shake_head/bounce/wave: repetições. jump: altura (fração da altura do quadro). */
times?: number; height?: number;
/** emote: símbolo sobre a cabeça ("!", "?", "…", "♥", "zzz", "💢"). talk: o texto falado (sem tempos de palavra, é
* repartido pela duração). */
text?: string;
};
export type ActorInput = {
x: number; expression?: string; pose?: string; face?: FacePatch; body?: BodyPatch; flip?: boolean; timeline?: Action[];
};
export type ActorState = {
face: FaceParams; body: BodyParams;
x: number; dy: number; dx: number; rot: number; sx: number; sy: number; flip: boolean;
emote: { text: string; k: number } | null;
};
const DEFAULT_DUR: Record<ActionKind, number> = {
express: 0.25, pose: 0.35, walk: 1.6, run: 0.9, enter: 1.2, exit: 1.2, jump: 0.8, nod: 0.7, shake_head: 0.8, tremble: 1, bounce: 0.8,
fall: 0.6, sit: 0.5, stand_up: 0.5, turn: 0.3, talk: 1.5, look: 0.3, emote: 1.2, wave: 1.2, hammer: 2.4,
};
const clamp01 = (v: number) => Math.max(0, Math.min(1, v));
const ease = (p: number) => (p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2);
/** Passa um pouco do alvo e volta (dá vida às poses). */
const easeBack = (p: number) => { const c = 1.4; return 1 + (c + 1) * (p - 1) ** 3 + c * (p - 1) ** 2; };
const norm = (s: string) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
/** Início da ação em segundos (cue = palavra falada; sem a palavra, cai para atP/at/0). */
export function startOf(a: Action, durationS: number, words: { text: string; startS: number }[] = []): number {
if (a.cue) {
const c = norm(a.cue);
const w = words.find((x) => norm(x.text).startsWith(c));
if (w) return w.startS;
}
if (a.atP !== undefined) return a.atP * durationS;
return a.at ?? 0;
}
/** Piscar em intervalos variados (2,4–4,6 s), determinístico pela semente. */
function blinkAt(t: number, seed: number): number {
let s = 0.6 + (seed % 7) * 0.13;
let k = 1;
while (s < t + 0.2) {
const d = t - s;
if (d >= 0 && d < 0.13) k = Math.min(k, Math.abs(d - 0.065) / 0.065);
s += 2.4 + ((Math.sin(s * 12.9898 + seed) + 1) / 2) * 2.2;
}
return k;
}
/** Fala do trecho: palavras com tempo (narração) e, se houver, o volume do áudio quadro a quadro. */
export type Speech = { words: SpokenWord[]; env?: { values: number[]; fps: number } };
/** Fim da fala: o fim da palavra `cueEnd` (depois do início), senão início + dur. */
function endOf(a: Action, s: number, words: SpokenWord[]): number | null {
if (!a.cueEnd) return null;
const c = norm(a.cueEnd);
const w = words.find((x) => x.startS >= s - 0.01 && norm(x.text).startsWith(c));
return w ? w.endS : null;
}
export function evaluate(actor: ActorInput, t: number, durationS: number, seed = 1, speech: Speech = { words: [] }): ActorState {
const words = speech.words;
const st: ActorState = {
face: faceOf(actor.expression, actor.face), body: bodyOf(actor.pose, actor.body),
x: actor.x, dy: 0, dx: 0, rot: 0, sx: 1, sy: 1, flip: !!actor.flip, emote: null,
};
const timeline = (actor.timeline ?? []).map((a) => ({ a, s: startOf(a, durationS, words) })).sort((p, q) => p.s - q.s);
for (const { a, s } of timeline) {
if (t < s) break;
const end = a.do === "talk" ? endOf(a, s, words) : null;
const d = Math.max(0.05, end !== null ? end - s : a.dur ?? DEFAULT_DUR[a.do]);
const p = clamp01((t - s) / d);
const active = t - s < d;
const env = active ? Math.min(1, (t - s) / 0.15, (s + d - t) / 0.15) : 0; // entra e sai suave (momentâneas)
switch (a.do) {
case "express": {
const target = a.expression ? faceOf(a.expression, a.face) : withFace(st.face, a.face);
st.face = blendFace(st.face, target, ease(p));
break;
}
case "pose": {
const target = a.pose ? bodyOf(a.pose, a.body) : withBody(st.body, a.body);
st.body = blendBody(st.body, target, clamp01(easeBack(p)));
break;
}
case "walk": case "run": case "enter": case "exit": {
const from = a.do === "enter" ? (a.to ?? st.x) < 0.5 ? -0.25 : 1.25 : st.x;
const to = a.do === "exit" ? (st.x < 0.5 ? -0.3 : 1.3) : a.to ?? st.x;
const run = a.do === "run";
st.x = from + (to - from) * (run ? p : ease(p));
if (to !== from) st.flip = to < from;
if (active) {
const phase = (t - s) * Math.PI * 2 * (run ? 3.2 : 2.1);
const amp = run ? 1.6 : 1;
const sw = Math.sin(phase);
st.body = withBody(st.body, {
armL: { raise: 8 + sw * 20 * amp, bend: run ? 85 : 15 }, armR: { raise: 8 - sw * 20 * amp, bend: run ? 85 : 15 },
legL: { raise: 3 + Math.max(0, sw) * 6, bend: Math.max(0, sw) * 38 * amp }, legR: { raise: 3 + Math.max(0, -sw) * 6, bend: Math.max(0, -sw) * 38 * amp },
lean: (to < from ? -1 : 1) * (run ? 8 : 3),
});
st.dy -= Math.abs(Math.sin(phase)) * (run ? 0.012 : 0.006);
}
break;
}
case "jump": {
if (!active) break;
const h = a.height ?? 0.08;
if (p < 0.15) { st.sy *= 1 - 0.1 * (p / 0.15); st.sx *= 1 + 0.06 * (p / 0.15); st.body = withBody(st.body, { crouch: 0.35 * (p / 0.15) }); }
else if (p < 0.85) {
const q = (p - 0.15) / 0.7;
st.dy -= h * 4 * q * (1 - q);
st.sy *= 1.07; st.sx *= 0.95;
st.body = withBody(st.body, { arms: { raise: 120, bend: -10 }, legs: { raise: 6, bend: 30 } });
} else { const q = (p - 0.85) / 0.15; st.sy *= 1 - 0.08 * (1 - q); st.sx *= 1 + 0.05 * (1 - q); }
break;
}
case "nod": st.body = withBody(st.body, { headNod: st.body.headNod + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.6 * env }); break;
case "shake_head": st.body = withBody(st.body, { headTurn: st.body.headTurn + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.7 * env }); break;
case "tremble": if (active) { st.dx += Math.sin(t * 77.7) * 0.004 * env; st.dy += Math.cos(t * 91.3) * 0.002 * env; } break;
case "bounce": st.dy -= Math.abs(Math.sin(p * Math.PI * (a.times ?? 2))) * 0.02 * env; break;
case "fall": {
const side = a.dir === "right" ? 1 : -1;
st.rot = side * 88 * ease(p);
st.dy += 0.02 * ease(p);
st.face = blendFace(st.face, faceOf("shocked"), Math.min(1, p * 3));
break;
}
case "sit": st.body = blendBody(st.body, withBody(st.body, { crouch: 1, arms: { raise: 14, bend: 40 } }), ease(p)); break;
case "stand_up": st.body = blendBody(st.body, withBody(st.body, { crouch: 0 }), ease(p)); break;
case "turn": {
const flipped = !st.flip;
if (p >= 0.5) st.flip = flipped;
if (active) st.sx *= Math.max(0.15, Math.abs(Math.cos(p * Math.PI)));
break;
}
case "talk": {
if (!active) break;
// Palavras da narração dentro da fala; sem elas, o texto da ação repartido pela duração (vogal pesa mais).
let spoken = words.filter((w) => w.endS > s && w.startS < s + d);
if (!spoken.length && a.text) {
const list = a.text.split(/\s+/).filter(Boolean);
const total = list.reduce((n, w) => n + w.length + 1, 0);
let c = s;
spoken = list.map((w) => { const len = (d * (w.length + 1)) / total; const out = { text: w, startS: c, endS: c + len * 0.88 }; c += len; return out; });
}
if (spoken.length) {
st.face = speak(st.face, visemeAt(spoken, t, speech.env), Math.min(1, (t - s) / 0.08, (s + d - t) / 0.08 + 0.2), emphasisAt(t, speech.env));
} else {
const flap = Math.abs(Math.sin((t - s) * Math.PI * 2 * 4.3 + seed)) * (0.6 + 0.4 * Math.sin((t - s) * 9.1 + seed));
st.face = { ...st.face, mouthOpen: Math.max(st.face.mouthOpen, (0.12 + 0.5 * flap) * env), teeth: st.face.teeth || flap > 0.6 };
}
// Quem fala mexe a cabeça de leve e acompanha as sílabas fortes.
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin((t - s) * 5.3) * 2 * env, headNod: st.body.headNod + emphasisAt(t, speech.env) * 0.25 });
break;
}
case "look": {
const gx = a.dir === "left" ? -0.9 : a.dir === "right" ? 0.9 : 0;
const gy = a.dir === "up" ? -0.8 : a.dir === "down" ? 0.8 : 0;
const k = ease(p);
st.face = { ...st.face, gazeX: st.face.gazeX + (gx - st.face.gazeX) * k, gazeY: st.face.gazeY + (gy - st.face.gazeY) * k };
st.body = withBody(st.body, { headTurn: st.body.headTurn + (gx * 0.5 - st.body.headTurn) * k, headNod: st.body.headNod + (gy * -0.4 - st.body.headNod) * k });
break;
}
case "emote": if (active) st.emote = { text: a.text ?? "!", k: env }; break;
// Martelar: braço direito sobe e desce batendo (`times` golpes), cabeça acompanha cada batida.
case "hammer": if (active) {
const beat = Math.abs(Math.sin(p * Math.PI * (a.times ?? 5)));
st.body = withBody(st.body, { armR: { raise: 40 + beat * 95 * Math.min(1, env * 1.5), bend: 60 + beat * 40 }, headNod: st.body.headNod + (1 - beat) * 0.15 * env });
break;
}
case "wave": if (active) st.body = withBody(st.body, { armR: { raise: 140 * Math.min(1, env * 1.5), bend: -25 + Math.sin(p * Math.PI * 2 * (a.times ?? 3)) * 30 } }); break;
}
}
// Vida: piscar (a não ser de olhos quase fechados), respirar e um balanço leve de cabeça.
const blink = blinkAt(t, seed);
if (blink < 1) st.face = { ...st.face, eyeL: st.face.eyeL * Math.max(0.08, blink), eyeR: st.face.eyeR * Math.max(0.08, blink) };
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin(t * 0.9 + seed) * 1.2 });
return st;
}
/** Confere uma linha do tempo (lista de problemas; vazia = ok). */
export function validateTimeline(timeline: unknown): string[] {
if (timeline === undefined) return [];
if (!Array.isArray(timeline) || timeline.length > 40) return ["timeline: lista de até 40 ações"];
const errors: string[] = [];
timeline.forEach((a: Partial<Action>, i) => {
if (!a || !ACTIONS.includes(a.do as ActionKind)) errors.push(`timeline[${i}].do: ${ACTIONS.join(", ")}`);
for (const k of ["at", "atP", "dur", "to", "times", "height"] as const) {
if (a[k] !== undefined && (typeof a[k] !== "number" || !Number.isFinite(a[k]))) errors.push(`timeline[${i}].${k}: número`);
}
if (a.atP !== undefined && !(a.atP >= 0 && a.atP <= 1)) errors.push(`timeline[${i}].atP entre 0 e 1`);
if (a.dur !== undefined && !(a.dur > 0 && a.dur <= 30)) errors.push(`timeline[${i}].dur entre 0 e 30 s`);
});
return errors;
}
@@ -0,0 +1,167 @@
// Rig do personagem: o rosto e o corpo são PARÂMETROS contínuos, não desenhos prontos. Uma expressão ou uma
// pose é só um conjunto de valores; dá para misturar (blend), ajustar um valor ("sorriso 0,3 a mais") e criar
// novas sem mexer no desenho. Ângulos em graus; "para fora" positivo nos dois lados (o desenho espelha).
export type FaceParams = {
/** Sobrancelha: y (px; negativo sobe) e tilt (graus; positivo = ponta de dentro sobe, como triste/preocupado). */
browL: { y: number; tilt: number };
browR: { y: number; tilt: number };
/** Abertura dos olhos (0 fechado · 1 normal · 1,35 arregalado). */
eyeL: number;
eyeR: number;
/** Tamanho da pupila (0,4 pavor · 1 normal · 1,3 encantado). */
pupil: number;
/** Direção do olhar (-1…1). */
gazeX: number;
gazeY: number;
/** Boca: abertura 0…1, sorriso -1 (triste) … 1 (feliz), largura 0,5…1,4, dentes à mostra. */
mouthOpen: number;
smile: number;
mouthWidth: number;
/** Arredondamento dos lábios (0 normal … 1 bico de "o/u"): vem da fala (lipsync.ts). */
mouthRound: number;
/** Pálpebra de cima somada à de base do personagem (−0,5 arregala … 0,6 quase fecha). */
lid: number;
teeth: boolean;
/** Extras: rubor 0…1, gota de suor, lágrimas, veia de raiva. */
blush: number;
sweat: boolean;
tears: boolean;
anger: boolean;
};
export type Limb = {
/** Abertura a partir do corpo (0 = para baixo; 90 = horizontal para fora; 180 = para cima). */
raise: number;
/** Dobra do cotovelo/joelho (positivo = antebraço/canela para dentro, na frente do corpo). */
bend: number;
};
export type BodyParams = {
/** Inclinação do tronco (graus; positivo = para a direita de quem olha). */
lean: number;
/** Cabeça: inclinação (graus), virada (-1…1, finge 3/4) e aceno (-1 olha para cima … 1 para baixo). */
headTilt: number;
headTurn: number;
headNod: number;
armL: Limb;
armR: Limb;
legL: Limb;
legR: Limb;
/** Agachar/sentar: 0 em pé … 1 sentado (quadril desce, coxa encurta em perspectiva). */
crouch: number;
};
export const NEUTRAL_FACE: FaceParams = {
browL: { y: 0, tilt: 0 }, browR: { y: 0, tilt: 0 }, eyeL: 1, eyeR: 1, pupil: 1, gazeX: 0, gazeY: 0,
mouthOpen: 0, smile: 0.1, mouthWidth: 1, mouthRound: 0, lid: 0, teeth: false, blush: 0, sweat: false, tears: false, anger: false,
};
export const NEUTRAL_BODY: BodyParams = {
lean: 0, headTilt: 0, headTurn: 0, headNod: 0,
armL: { raise: 8, bend: 6 }, armR: { raise: 8, bend: 6 }, legL: { raise: 2, bend: 0 }, legR: { raise: 2, bend: 0 }, crouch: 0,
};
type FacePatch = Partial<Omit<FaceParams, "browL" | "browR">> & { browL?: Partial<FaceParams["browL"]>; browR?: Partial<FaceParams["browR"]>; brows?: Partial<FaceParams["browL"]>; eyes?: number };
type BodyPatch = Partial<Omit<BodyParams, "armL" | "armR" | "legL" | "legR">> & { armL?: Partial<Limb>; armR?: Partial<Limb>; legL?: Partial<Limb>; legR?: Partial<Limb>; arms?: Partial<Limb>; legs?: Partial<Limb> };
/** Aplica um ajuste parcial (aceita `brows`/`eyes`/`arms`/`legs` para os dois lados de uma vez). */
export function withFace(base: FaceParams, p: FacePatch = {}): FaceParams {
const { brows, eyes, browL, browR, ...rest } = p;
return {
...base, ...rest,
browL: { ...base.browL, ...brows, ...browL }, browR: { ...base.browR, ...brows, ...browR },
eyeL: rest.eyeL ?? eyes ?? base.eyeL, eyeR: rest.eyeR ?? eyes ?? base.eyeR,
};
}
export function withBody(base: BodyParams, p: BodyPatch = {}): BodyParams {
const { arms, legs, armL, armR, legL, legR, ...rest } = p;
return {
...base, ...rest,
armL: { ...base.armL, ...arms, ...armL }, armR: { ...base.armR, ...arms, ...armR },
legL: { ...base.legL, ...legs, ...legL }, legR: { ...base.legR, ...legs, ...legR },
};
}
/** Expressões prontas = atalhos de parâmetros (dá para ajustar qualquer valor por cima com `face`). */
export const EXPRESSION_PRESETS = {
neutral: {},
smile: { smile: 0.7, eyes: 0.9 },
happy: { smile: 0.9, mouthOpen: 0.3, teeth: true, eyes: 0.85, brows: { y: -3 } },
laugh: { smile: 1, mouthOpen: 0.75, teeth: true, eyes: 0.18, brows: { y: -5 }, blush: 0.4 },
proud: { smile: 0.6, lid: 0.35, brows: { y: -2 } },
sad: { smile: -0.7, brows: { tilt: 16 }, eyes: 0.8, gazeY: 0.5 },
cry: { smile: -0.9, mouthOpen: 0.35, brows: { tilt: 20 }, eyes: 0.4, tears: true },
worried: { smile: -0.3, brows: { tilt: 14, y: -2 }, eyes: 1.05, sweat: true },
angry: { smile: -0.4, brows: { tilt: -18, y: 3 }, lid: 0.25, mouthWidth: 0.9 },
furious: { smile: -0.6, mouthOpen: 0.6, teeth: true, brows: { tilt: -24, y: 4 }, lid: 0.3, anger: true },
surprised: { mouthOpen: 0.6, mouthWidth: 0.55, smile: 0, brows: { y: -8 }, eyes: 1.25, pupil: 0.8, lid: -0.5 },
scared: { mouthOpen: 0.5, mouthWidth: 0.9, smile: -0.5, teeth: true, brows: { tilt: 18, y: -6 }, eyes: 1.3, pupil: 0.55, sweat: true, lid: -0.5 },
shocked: { mouthOpen: 0.95, mouthWidth: 0.6, smile: 0, brows: { y: -10 }, eyes: 1.35, pupil: 0.45, lid: -0.5 },
suspicious: { smile: -0.1, mouthWidth: 0.8, browL: { y: -6, tilt: 0 }, browR: { y: 4, tilt: -10 }, lid: 0.45, gazeX: 0.6 },
smirk: { smile: 0.45, mouthWidth: 0.8, browL: { y: -5 }, lid: 0.3, gazeX: -0.3 },
confused: { smile: -0.2, mouthWidth: 0.75, browL: { y: -7 }, browR: { tilt: -8 }, gazeY: -0.6, gazeX: 0.4 },
disgusted: { smile: -0.7, mouthWidth: 1.1, brows: { tilt: -10, y: 2 }, lid: 0.35 },
sleepy: { lid: 0.6, brows: { y: 3 }, mouthOpen: 0.1, smile: 0 },
determined: { smile: 0.1, mouthWidth: 0.85, brows: { tilt: -10, y: 2 }, lid: 0.2 },
embarrassed: { smile: 0.3, blush: 1, gazeY: 0.6, gazeX: -0.4, eyes: 0.8, sweat: true },
} satisfies Record<string, FacePatch>;
/** Poses prontas = atalhos de ângulos (ajustáveis por cima com `body`). */
export const POSE_PRESETS = {
stand: {},
point: { armR: { raise: 46, bend: -128 } },
wave: { armR: { raise: 140, bend: -25 } },
hold: { armR: { raise: 34, bend: 106 } },
arms_up: { arms: { raise: 158, bend: -10 } },
celebrate: { arms: { raise: 146, bend: -26 }, headNod: -0.35 },
shrug: { arms: { raise: 38, bend: 100 }, headTilt: 7 },
think: { armR: { raise: -24, bend: 138 }, headTilt: -5 },
hands_on_hips: { arms: { raise: 42, bend: 105 } },
cross_arms: { arms: { raise: 24, bend: 128 } },
facepalm: { armR: { raise: 125, bend: -103 }, headNod: 0.5, headTilt: 8 },
cover_mouth: { armR: { raise: -34, bend: 130 } },
defend: { arms: { raise: 62, bend: 118 }, lean: -4 },
reach: { armR: { raise: 68, bend: -15 }, lean: 6 },
sit: { crouch: 1, arms: { raise: 14, bend: 40 } },
kneel: { crouch: 0.6, arms: { raise: 10, bend: 20 } },
lean_in: { lean: 8, headTilt: 6 },
// Duas mãos segurando um objeto largo (livro, tábua) pelas bordas, na frente do peito.
hold_both: { arms: { raise: 42, bend: 104 } },
// Joinha: cotovelo dobrado, mão na altura do peito/ombro (a forma da mão vem do desenho: `thumbs_up`).
thumbs_up: { armR: { raise: 22, bend: 148 } },
} satisfies Record<string, BodyPatch>;
export type ExpressionName = keyof typeof EXPRESSION_PRESETS;
export type PoseName = keyof typeof POSE_PRESETS;
export const EXPRESSION_NAMES = Object.keys(EXPRESSION_PRESETS) as ExpressionName[];
export const POSE_NAMES = Object.keys(POSE_PRESETS) as PoseName[];
export const faceOf = (name: string | undefined, patch?: FacePatch): FaceParams =>
withFace(withFace(NEUTRAL_FACE, (EXPRESSION_PRESETS as Record<string, FacePatch>)[name ?? "neutral"] ?? {}), patch);
export const bodyOf = (name: string | undefined, patch?: BodyPatch): BodyParams =>
withBody(withBody(NEUTRAL_BODY, (POSE_PRESETS as Record<string, BodyPatch>)[name ?? "stand"] ?? {}), patch);
const lerp = (a: number, b: number, k: number) => a + (b - a) * k;
const limb = (a: Limb, b: Limb, k: number): Limb => ({ raise: lerp(a.raise, b.raise, k), bend: lerp(a.bend, b.bend, k) });
/** Mistura duas expressões (k = 0 → a, 1 → b). Os "liga/desliga" trocam na metade. */
export function blendFace(a: FaceParams, b: FaceParams, k: number): FaceParams {
const pick = <T,>(x: T, y: T) => (k < 0.5 ? x : y);
return {
browL: { y: lerp(a.browL.y, b.browL.y, k), tilt: lerp(a.browL.tilt, b.browL.tilt, k) },
browR: { y: lerp(a.browR.y, b.browR.y, k), tilt: lerp(a.browR.tilt, b.browR.tilt, k) },
eyeL: lerp(a.eyeL, b.eyeL, k), eyeR: lerp(a.eyeR, b.eyeR, k), pupil: lerp(a.pupil, b.pupil, k),
gazeX: lerp(a.gazeX, b.gazeX, k), gazeY: lerp(a.gazeY, b.gazeY, k),
mouthOpen: lerp(a.mouthOpen, b.mouthOpen, k), smile: lerp(a.smile, b.smile, k), mouthWidth: lerp(a.mouthWidth, b.mouthWidth, k), mouthRound: lerp(a.mouthRound, b.mouthRound, k), lid: lerp(a.lid, b.lid, k),
teeth: pick(a.teeth, b.teeth), blush: lerp(a.blush, b.blush, k), sweat: pick(a.sweat, b.sweat), tears: pick(a.tears, b.tears), anger: pick(a.anger, b.anger),
};
}
export function blendBody(a: BodyParams, b: BodyParams, k: number): BodyParams {
return {
lean: lerp(a.lean, b.lean, k), headTilt: lerp(a.headTilt, b.headTilt, k), headTurn: lerp(a.headTurn, b.headTurn, k), headNod: lerp(a.headNod, b.headNod, k),
armL: limb(a.armL, b.armL, k), armR: limb(a.armR, b.armR, k), legL: limb(a.legL, b.legL, k), legR: limb(a.legR, b.legR, k), crouch: lerp(a.crouch, b.crouch, k),
};
}
export type { FacePatch, BodyPatch };
@@ -0,0 +1,9 @@
// Versão REDUZIDA do contrato do CenaForge (cartoon/src/spec.ts): só os tipos que o desenho do personagem usa.
// No projeto real este arquivo é bem maior (cena, lugar, animais, textos…); não é preciso mexer nele.
export const TIMES = ["night", "dawn", "day"] as const;
export type TimeOfDay = (typeof TIMES)[number];
export const ICONS = ["house", "generator", "fuel", "battery", "phone", "door", "eye", "bulb", "solar", "warning", "money", "clock",
"olive", "hammer", "tablet", "book", "ruler"] as const;
export type IconId = (typeof ICONS)[number];
export const TONES = ["info", "danger", "ok"] as const;
export type Tone = (typeof TONES)[number];
@@ -0,0 +1,12 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "Bundler",
"jsx": "react-jsx",
"strict": true,
"skipLibCheck": true,
"noEmit": true
},
"include": ["src", "render-sheet.tsx"]
}
+2
View File
@@ -23,3 +23,5 @@ este resumo basta, não é preciso abrir o `CLAUDE.md` inteiro.
`frame_check.py` e abra só a imagem que ele indicar (uma por render). Reaproveite as cenas da biblioteca. `frame_check.py` e abra só a imagem que ele indicar (uma por render). Reaproveite as cenas da biblioteca.
- **Windows/PowerShell:** rode o pnpm como `pnpm.cmd` (o `pnpm.ps1` é bloqueado pela política de - **Windows/PowerShell:** rode o pnpm como `pnpm.cmd` (o `pnpm.ps1` é bloqueado pela política de
execução) e leia texto com `Get-Content -Raw -Encoding UTF8`. Economize: leia só o que a tarefa pede. execução) e leia texto com `Get-Content -Raw -Encoding UTF8`. Economize: leia só o que a tarefa pede.
File diff suppressed because it is too large Load Diff
+247 -158
View File
@@ -1,187 +1,247 @@
// Biblioteca de MÃOS desenhadas (não montadas com cápsulas): cada forma é um desenho num quadro fixo de 120×120, // Biblioteca de MÃOS desenhadas no estilo de ilustração cartoon de referência (quadro canônico 120×120):
// com a silhueta inteira num path só (Bézier contínuas: dedos afinando em 3 falanges, nós em arco, polegar nascendo // - Proporções cheias, compactas e arredondadas (como em referencia/recortes/joinha.png, maos-segurando.png,
// do montinho da base da palma), as linhas internas no tom escuro da pele, unhas, e uma sombra cel DESENHADA // mao-prancheta.png e apontando.png): sem dedos compridos em salsicha;
// (recortada pela silhueta). O rig só ESCOLHE a forma, posiciona no pulso, gira e espelha. // - Base do pulso cilíndrica arredondada centrada em `wrist` (emenda perfeita com o antebraço ou punho da manga);
// // - Sulcos quentes e curtos entre os dedos dobrados, e sombreado cel limpo em 2 tons acompanhando o volume;
// Regras de construção seguidas (ensino de desenho de mão): palma ≈ quadrada com laterais curvas; dedo médio ≈ altura // - Camadas `back` (atrás do objeto) e `front` (dedos/polegar na frente do objeto) para que qualquer objeto seguro
// da palma, médio o maior, indicador ≈ anelar, mínimo o menor; nós da base e pontas em ARCO (o médio mais à frente); // fique claramente DENTRO da mão.
// dedo afina para a ponta; polegar com 2 segmentos e unha, girando em outro eixo; pulso mais estreito que a palma;
// volume com sombra no lado oposto à luz e embaixo dos dedos; linhas internas sempre curvas.
//
// Quadro canônico: braço da DIREITA da tela (s = 1), luz vinda da esquerda (sombra desenhada à direita/embaixo).
// - formas "alinhadas" (relaxed, open, point, fist, on_face): o antebraço chega por cima (pulso em (60, 4)) e os dedos
// apontam para +y; o polegar fica do lado −x. O rig gira pelo ângulo do antebraço.
// - formas "em pé" (thumbs_up, grip, pinch_edge): desenhadas na orientação da tela, com o pulso num canto e o ângulo
// do antebraço para o qual foram feitas (`wristDeg`); o rig só inclina um pouco para acompanhar o braço.
import React from "react"; import React from "react";
import type { IconId } from "./spec"; import type { IconId } from "./spec";
export const HAND_SHAPES = ["relaxed", "open", "point", "thumbs_up", "grip", "pinch_edge", "pinch_low", "fist", "on_face"] as const; export const HAND_SHAPES = [
"relaxed",
"open",
"point",
"thumbs_up",
"grip",
"pinch_edge",
"pinch_low",
"fist",
"on_face",
"think",
"crossed",
] as const;
export type HandShape = (typeof HAND_SHAPES)[number]; export type HandShape = (typeof HAND_SHAPES)[number];
type ShapeDef = { type ShapeDef = {
/** Silhueta inteira (um path). */ /** Silhueta principal (camada de trás quando `bodyBehind` é true). */
body: string; body: string;
/** Sombra cel desenhada (recortada pela silhueta do corpo). */ /** Sombra cel em crescente macio (recortada pela silhueta `body`). */
shadow: string; shadow: string;
/** Linhas internas do corpo: separação dos dedos, nós, dobras. */ /** Linhas internas quentes: separação dos dedos, nós e dobras da palma. */
lines: string; lines: string;
/** Peça por cima (polegar dobrado por cima dos dedos ou do objeto), com sombra e linhas próprias. */ /** Peça por cima (polegar ou dedos que abraçam o objeto pela frente), com sombra e linhas próprias. */
over?: { body: string; shadow?: string; lines?: string }; over?: { body: string; shadow?: string; lines?: string };
/** Unhas: [cx, cy, rx, ry, giro]. A primeira do corpo, as de `overNails` por cima. */ /** Unhas discretas (só quando a vista pede): [cx, cy, rx, ry, giro]. */
nails?: [number, number, number, number, number][]; nails?: [number, number, number, number, number][];
overNails?: [number, number, number, number, number][]; overNails?: [number, number, number, number, number][];
/** Pulso no quadro (onde encosta o fim do antebraço). */ /** Pulso no quadro (centro da junta redonda onde termina o antebraço). */
wrist: [number, number]; wrist: [number, number];
/** Ângulo do antebraço para o qual a forma foi desenhada (0 = descendo; formas alinhadas = 0). */ /** Ângulo do antebraço para o qual a forma foi desenhada (0 = descendo; formas alinhadas = 0). */
wristDeg: number; wristDeg: number;
upright: boolean; upright: boolean;
/** Com objeto: o corpo fica ATRÁS do objeto (só a peça `over` na frente) — pinch_edge. */ /** Com objeto: `body` fica ATRÁS do objeto e `over` fica NA FRENTE dele (objeto dentro da mão). */
bodyBehind?: boolean; bodyBehind?: boolean;
/** Onde fica o objeto: cabo (grip) ou borda (pinch_edge). */ /** Ponto onde passa o cabo (`grip`) ou encosta a borda (`pinch_edge`/`pinch_low`). */
hold?: [number, number]; hold?: [number, number];
}; };
// Pulso: cilindro com ≈ 60 % da largura da palma (27 unidades), centrado no ponto `wrist`, com uma sobra de 10 // Base redonda no pulso (centro (60, 0), raio ~13.5): garante emenda contínua em qualquer rotação.
// unidades que entra por baixo da manga (fica escondida pelo punho da manga). Sombra do lado oposto à luz (direita): const WRIST_CAP = "M46.5 0 A13.5 11 0 0 1 73.5 0";
// no pulso ela tem a mesma largura da sombra do antebraço (≈ 1/3) e vai afinando na borda da mão; sob os dedos dobrados
// e sob o polegar.
const WRIST_TOP = "M46.5 -10 L46.5 3";
const WRIST_RIGHT_END = "C74.4 6.5 73.6 3 73.5 0 L73.5 -10 Z";
const SHAPES: Record<HandShape, ShapeDef> = { const SHAPES: Record<HandShape, ShapeDef> = {
// Caída ao lado do corpo, vista pelo dorso: dedos juntos levemente curvos (nós e pontas em arco), polegar na frente. // Caída ao lado do corpo: formas arredondadas e carnudas, polegar voltado para dentro, dedos juntos curvando suavemente.
relaxed: { relaxed: {
body: `${WRIST_TOP} C45.5 12 41 18 38.5 25 C35.5 33 34 42 35 50 C35.8 57 38.5 61 42 60.5 C45 60 46 57 45.6 53 C45.3 49 45 46 44.8 44` body: `${WRIST_CAP}`
+ " C43.6 52 42.8 62 43 72 C43.2 79 45.2 82.5 48.3 82.5 C51.3 82.5 52.6 80 52.6 76.5 L52.8 74 C53 80 53.4 86 55.2 89" + " C76 8 82.5 18 84 31 C85.2 43 84.4 55 82 65 C80.8 70.5 77.8 73.5 74.5 73 C72.2 72.6 70.8 70.5 70.4 67.5"
+ " C56.6 91.6 60 92 61.8 89.8 C63 88 63.2 85 63.2 81 L63.4 78 C63.8 82 64.6 85.5 66.4 87.2 C68.4 89 71.4 88.2 72.2 85.4" + " C69.8 74 68 79 64.2 79.6 C60.8 80.2 58.6 77.5 58.2 73"
+ " C72.8 83 72.8 80 72.6 77 L72.8 74 C73.8 76.5 75.4 78 77.4 77.6 C79.6 77 80.6 74.6 80.7 71.5 C81 64 81.8 54 82 46" + " C57.4 78.5 55.2 82 51.2 82 C47.5 82 45.4 78.5 45.2 73.5"
+ ` C82.2 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`, + " C44.2 76.5 42 78 39.2 77.4 C35.8 76.6 34.2 72.5 34.8 66 C35.5 57 37.2 48 39 41"
shadow: "M64.6 -12 L65 1 C69 6 75 12 78 22 C79.6 32 80 42 79.6 52 C79.2 62 78.6 70 78.8 76 L96 80 L96 -12 Z" + " C37 46.5 35 51.5 32.2 54 C29 56.8 25 55.5 24.2 51 C23.2 45.8 25.5 37.5 29.5 29.5"
+ " M40 77 C48 84.5 62 90.5 80 76 L80 100 L40 100 Z M45.2 45 C46.6 52 47 59 46.6 65 L49.6 66 C49.8 58 49.2 50 47.6 44 Z", + " C34 21 41 13.5 45 5.5 C46 3.5 46.5 1.8 46.5 0 Z",
lines: "M52.8 74 C52.7 68 52.8 62 53.2 56 M63.4 78 C63.4 71 63.2 64 63 57 M72.8 74 C73 68 73.4 62 73.8 55 M44.8 44 C44.5 38 43 32 41 27", shadow: "M66 -10 C69 5 75.5 16 78 30 C79.8 43 78.8 56 76 67 C72.5 75 62 80 44 78 L44 90 L92 90 L92 -10 Z",
nails: [[40.6, 54.2, 2.8, 3.8, 6]], lines: "M39 41 C40.8 35 41.5 28.5 40.5 22.5 M45.2 73.5 C45.8 65.5 46.8 58 48.2 52 M58.2 73 C58.8 65 59.5 57.5 60.2 51.5 M70.4 67.5 C71 61 71.6 55 72 50",
wrist: [60, 0], wristDeg: 0, upright: false, wrist: [60, 0], wristDeg: 0, upright: false,
}, },
// Aberta, palma para a câmera (acenando): dedos levemente abertos, polegar saindo da eminência tenar.
// Mão aberta (acenando / comemorando): palma carnuda, dedos abrindo em leque macio que afinam na ponta, polegar na base.
open: { open: {
body: `${WRIST_TOP} C44 12 39 18 35 22 C29 26 24 31 21 37 C18.5 42 19.5 47 23.5 47.5 C26.5 48 28.5 45.5 30 42.5 C32.5 38 35.5 35 38.5 34.5` body: `${WRIST_CAP}`
+ " C39 38 39.2 41 39.5 44 C38.6 54 38 64 38.4 72 C38.6 78 41 80.6 44 80.4 C47 80.2 48.4 78 48.4 74.6 C48.6 64 48.8 55 49.4 47.5" + " C75.5 7 81.5 16 83.8 28 C85 35 86 43 88 51.5 C89.2 56.8 88 61.2 84.8 62.2 C81.5 63.2 78.6 60.4 76.6 55"
+ " C50.4 58 50.8 70 51.2 80 C51.4 86 54.2 88.6 57.2 88.4 C60.2 88.2 61.6 85.6 61.4 82 C61 70 60.8 58 61.2 48" + " C74.8 50.2 73.2 45.2 71.8 41.2 C73 50 74.2 60.5 74.6 68.8 C74.9 74.6 72.2 78.2 68.4 78.2 C64.8 78.2 62.6 74.8 62.2 69"
+ " C62.6 58 63.6 68 64.4 76 C64.8 81.4 67.6 83.6 70.4 83 C73 82.4 74 79.8 73.6 76.6 C72.6 66 72 56 72 47.4" + " C61.8 60.5 61.2 51.5 60.8 44 C60.5 54 60.2 65.5 59.6 74.2 C59.2 80.4 56.2 83.6 52.2 83.4 C48.4 83.2 46.2 79.6 46.2 73.5"
+ " C73.8 54 75.6 61 77.6 66.6 C79 70.6 82 71.6 84.2 70 C86 68.6 86 66 85.2 63 C83 54 82.6 42 81.6 30 C80.6 18 76 8 73.5 2 L73.5 -10 Z", + " C46.2 64.5 46.8 54 47.5 44.5 C46 52.5 44.5 61.5 43.5 68.5 C42.6 74 39.6 76.8 36 76.2 C32.4 75.5 30.8 72 31.5 66.2"
shadow: "M64.6 -12 L65 1 C70 6 77 14 80.6 32 C81.6 44 82 54 83.4 64 L96 64 L96 -12 Z M50 30 C56 36 66 38.4 75 34 C70 42 60 44.4 51 40 Z" + " C32.8 56 35.2 44.5 37.5 35 C33.5 38.8 29.2 42.8 25 45.5 C20.8 48.2 16.4 47 15.2 43 C14 39 16.5 34 21.2 30.2"
+ " M45.6 50 C46.2 60 46.4 70 46 80.4 L49 80 L49.2 50 Z M58.4 50 C58.8 62 59.2 74 59 88.4 L62 88 L61.6 50 Z M70.4 50 C71.2 60 71.8 70 72 82 L74.6 81 L73.6 50 Z", + " C27.2 25.4 34.8 20.8 40.2 14.5 C43.8 10.2 46 5 46.5 0 Z",
lines: "M48 46 C58 42.4 70 42.4 80 46 M42 40 C46 32 50 22 52 12", shadow: "M67 -10 C70 5 77 16 80 30 C82 40 83.5 50 86 60 L96 60 L96 -10 Z"
+ " M46 28 C53 33.5 63 35.5 72 32 C68 38.5 57 40.5 47 35.5 Z",
lines: "M43 37 C53 34 64.5 34.5 73.5 38.5 M38.5 34 C42.8 28 46 21 47 14",
wrist: [60, 0], wristDeg: 0, upright: false, wrist: [60, 0], wristDeg: 0, upright: false,
}, },
// Apontando, vista pelo lado da palma: indicador esticado (3 falanges, afinando, unha na ponta, leve curva); médio,
// anelar e mínimo dobrados como gomos empilhados em arco (médio mais à frente), com a ponta virada para a palma e a // Apontando (como em referencia/recortes/apontando.png):
// UNHA de cada um aparecendo; o polegar fecha por cima do médio, com a unha dele. // Polegar redondo na lateral interna (esquerda), indicador comprido subindo firme ao lado dele,
// e os 3 outros dedos (médio, anelar, mínimo) dobrados em escada arredondada macia na direita.
point: { point: {
body: `${WRIST_TOP} C45 12 40 18 37.5 26 C36 34 36.2 42 38.2 48 C37.8 60 37.9 72 38.5 82 C39 90 39.6 96 40.6 101.4` body: `${WRIST_CAP}`
+ " C41.4 106.6 46 108.4 49.2 106 C51.6 104.2 52.2 100.4 52.2 96.6 C52.2 88 52.6 76 53.4 64" + " C76 8 82.5 18 84.5 30 C86 39 86.5 48 84 55.5 C82 61 77.2 63.5 72.5 61.5"
+ " C54 68.6 56.8 71 60.6 70.6 C64 70.2 65.6 67.6 65.8 64.8 C68 68 71.6 68.4 74 66.6 C76 65 76.4 62 76 59.8" + " C71 66.8 66.2 69.8 60.8 68.6 C58 68 55.8 66 54.6 63.5"
+ ` C78.4 60.6 81 59.4 81.8 56.4 C82.6 53 82.4 49 82 46 C82 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`, + " C53 67.5 51 69.5 48.8 69.5 C48.8 79.5 48.8 90.5 48.4 98.5"
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.8 30 C81.6 40 81 48 79.6 52 C76 50 70 49 64 50 L96 50 L96 -12 Z" + " C48 105.5 44.2 109.2 39.4 109 C34.6 108.8 31.4 104.6 31.8 97.5"
+ " M50 66 C56 72.6 68 72 74 68 C78 66 81 62 83 56 L86 80 L48 80 Z M49.6 66 C50.2 78 50.6 92 50.2 108 L58 108 L58 66 Z" + " C32.4 85 33.8 69.5 35 55.5 C29 51.5 25 44.5 25.8 36.2 C26.6 28 32.2 21 38.8 15.2"
+ " M44 58 C48 62 52 64.4 56.4 63.6 L58 67 L44 64 Z", + " C43.2 11 45.8 5.2 46.5 0 Z",
lines: "M65.8 64.8 C65.4 60.6 64.4 57.6 62.8 55.4 M76 59.8 C75.4 56 74.2 53.4 72.6 51.6 M53 57.4 C60 53.6 70 51.4 81 47" shadow: "M65 -10 C68.5 5 76 15 79 29 C81 39 80.5 49 78 56 C73 60.5 63 64.5 50 65.5 L50 75 L93 75 L93 -10 Z"
+ " M38.8 81 Q45.4 82.6 52.4 81 M40.2 93 Q46 94.4 52.2 93", + " M42.8 58 C44.2 72 44.2 88 43.2 109 L49.5 109 L49.5 58 Z",
nails: [[59.6, 66.6, 3.2, 2.4, 6], [70.8, 63.4, 2.9, 2.2, -8], [79.2, 54.6, 2.3, 1.9, -30], [45.8, 102, 3, 3.6, -4]], lines: "M50.5 68.5 C50.8 60.5 51.6 53 53.5 47.5 M61.8 68 C62.4 60 63.2 53 64.8 47.5 M72.5 61.5 C73.2 55 74 49 75.2 44.5"
+ " M49 48.5 C57.5 46 67.5 44.5 78 43",
over: { over: {
body: "M38.4 30 C42 38 47 46 52.8 52 C56.2 55.4 57 60 54 61.6 C51 63.2 47.4 60.4 44.4 56.6 C40.8 52 38 46 37.6 40 Z", body: "M25.8 36.2 C26.6 27.5 33.8 21 41.2 24.2 C47 26.8 52.2 34.5 55.5 42.2 C58.5 49 57.5 56.5 52.2 58.8 C47 61.2 39.2 57.8 33.2 51.5 C27.8 45.8 25.2 41.2 25.8 36.2 Z",
shadow: "M39.6 46 C42 51 46 56 50 59 L46 62 L38 52 Z", shadow: "M28.5 43.5 C33.8 50.8 42.2 56.5 50.5 58 L47.5 62 L26.5 48.5 Z",
lines: "M35 27.5 C41.2 32.5 48 39.5 52.5 46.5",
}, },
overNails: [[53.2, 57.2, 3, 2.6, 40]],
wrist: [60, 0], wristDeg: 0, upright: false, wrist: [60, 0], wristDeg: 0, upright: false,
}, },
// Joinha: punho de lado, os 4 dedos dobrados na horizontal (um em cima do outro, nós e pontas na frente),
// polegar grosso saindo do topo, com unha, levemente inclinado para trás. Antebraço chegando de baixo, na diagonal. // Joinha (proporção compacta e redonda idêntica a referencia/recortes/joinha.png):
// Punho cheio e arredondado (largura ~52, altura ~56 na palma), 4 dedos gordinhos empilhados com sulcos curtos,
// e polegar forte subindo na vertical do topo da palma.
thumbs_up: { thumbs_up: {
body: "M56 42 C46 39.5 34 40 29 44.5 C24.6 48.6 25.2 54.4 29.6 56 C25.2 58.6 24.8 65.4 29.4 67.8 C25.8 70.6 26.4 77.6 31 79.4" body: "M74 88 A13.5 13.5 0 0 0 90 66"
+ " C28.6 82.6 30.6 88.4 36 89.4 C46 91.2 60 92.6 72 93.6 C78 94.4 83 97.2 86.5 101.5 L93.6 108.6 L112.6 89.6 L105.5 82.5" + " C87 57 82 49 75 43"
+ " C101 77.6 96 70.4 92 61 C89.4 54.4 85 48 78 45 C77.6 40 76.8 30 75.4 20 C74.4 13 71.6 7 66 6.4" + " C75.5 32 75 19 73 10.5 C71.2 3.5 66.5 0 60.5 0.5 C54.8 1 51.2 6 51 14.5"
+ " C60.6 5.8 57.4 9.6 56.8 15.6 C56.2 24 55.8 33 56 42 Z", + " C50.8 23.5 51.2 32.5 50 39 C41 38.5 33 40 29.5 45.5 C26.2 50.6 27.8 57 33 58.8"
shadow: "M84 46 C90 52 95 62 98 72 L104 82 L120 96 L120 40 Z M28 54.6 C38 57.8 50 58 60 56.6 L60 59.6 C48 61 38 60.6 28 58 Z" + " C27.2 61.2 26.8 68.8 32.2 71.6 C28.2 74.4 28.8 81.8 34 84"
+ " M28 66.4 C38 69.6 50 70 60 68.6 L60 71.6 C48 73 38 72.6 28 70 Z M30 78 C40 81 50 81.6 58 80.6 L58 83.6 C48 84.6 40 84 30 81.4 Z" + " C31.8 87.5 34.2 93.8 41 95 C51 96.8 63 96 70.5 91.5 C72.5 90.2 73.5 89 74 88 Z",
+ " M30 88 C46 92 62 94 74 95 L86 104 L40 104 Z M71 8 C74 14 76 24 77 40 L84 44 L84 4 Z", shadow: "M67 2 C70.8 10 72 25 72 41 C78.5 46 84 55 87 65 L92 74 L74 92 L34 97 L30 89"
lines: "M29.6 56 C38 58 48 58.4 58 57 M29.4 67.8 C38 70 48 70.4 58 69 M31 79.4 C39 81.4 48 81.8 56 81" + " C44 93.5 59 93 68.5 88.5 C75.5 85 78.5 76 77 65 C75.5 54 72 46.5 66 42.5 L66 2 Z"
+ " M58 57 C62 55.6 64.6 52.6 65.4 49 M58 69 C62.6 67.6 65.6 64.6 66.4 60.6 M56 81 C60.4 80 63.4 77.4 64.4 73.6 M57 34.5 C62 37 70 37.4 77 33.6", + " M31.5 57.2 C40.5 59.8 50.5 60 59 58.5 L59 61.2 C49.5 62.6 40.5 62.2 31 59.8 Z"
nails: [[65.4, 13.8, 5, 6, 4]], + " M31 70 C40 72.6 50.5 72.8 59 71.2 L59 74 C49.5 75.4 40 75 30.5 72.6 Z"
wrist: [96, 92], wristDeg: 135, upright: true, + " M33 82.4 C41.5 84.8 50 85 57.5 83.8 L57.5 86.5 C49 87.6 41.5 87.2 32.5 85 Z",
lines: "M33 58.8 C41 60.8 50 61 58 59.5 M32.2 71.6 C40.5 73.6 50 73.8 58 72.2 M34 84 C41.8 85.8 49.5 86 56.5 84.8"
+ " M51 36.5 C56.5 39.8 64.5 40.2 71.5 37.5",
wrist: [82, 76], wristDeg: 135, upright: true,
}, },
// Punho em volta de um cabo (martelo, régua, ramo, celular): o cabo passa por dentro, o polegar fecha por cima.
// Punho segurando um cabo ou prancheta (proporção compacta e redonda idêntica a referencia/recortes/mao-prancheta.png):
// - `body` (atrás do cabo): base da palma;
// - `over` (na frente do cabo): mão redonda e carnuda com 4 dedos roliços empilhados e 3 sulcos curtos.
grip: { grip: {
body: "M44 42 C34 41.6 26.6 43.6 26.2 49 C25.8 53.4 26.8 55.6 29.6 56 C25.2 58.6 24.8 65.4 29.4 67.8 C25.8 70.6 26.4 77.6 31 79.4" body: "M88 77 A13.5 13.5 0 0 0 88 50"
+ " C28.6 82.6 30.6 88.4 36 89.4 C48 91.4 64 92 76 89.6 C86 87.4 92.6 80 94.4 70 C96 62 100 55 105.5 49.5 L112.6 42.4 L93.6 23.4 L86.5 30.5" + " C81 44 71 40 59 40 C47 40 37 43 33.5 51 C30 59 31 73 36 83"
+ " C80 36 72 39.6 62 41 C56 41.8 50 42 44 42 Z", + " C41 91 54 93 67 90 C77 87.5 84 83 88 77 Z",
shadow: "M86 34 C92 44 95 58 94 70 C92 82 84 90 74 92 L120 120 L120 30 Z M28 54.6 C38 57.8 50 58 60 56.6 L60 59.6 C48 61 38 60.6 28 58 Z" shadow: "M76 44 C83 52 86 64 83 75 C80 84 72 90 60 92 L92 92 L92 44 Z",
+ " M28 66.4 C38 69.6 50 70 60 68.6 L60 71.6 C48 73 38 72.6 28 70 Z M30 78 C40 81 50 81.6 58 80.6 L58 83.6 C48 84.6 40 84 30 81.4 Z" lines: "",
+ " M30 88 C46 92 62 93 78 90 L78 100 L30 100 Z",
lines: "M29.6 56 C38 58 48 58.4 58 57 M29.4 67.8 C38 70 48 70.4 58 69 M31 79.4 C39 81.4 48 81.8 56 81"
+ " M58 57 C62 55.6 64.6 52.6 65.4 49 M58 69 C62.6 67.6 65.6 64.6 66.4 60.6 M56 81 C60.4 80 63.4 77.4 64.4 73.6",
over: { over: {
body: "M80 36 C72 30.6 58 29.6 46 32.6 C37 34.8 33.4 40.6 36.6 44.2 C40.6 47.6 52 46.6 62 45.6 C70 44.8 76 43 79 40.6 Z", body: "M86 48 C79 38 66 33.5 53 34 C41 34.5 33 38 30.5 44.5 C28.5 49.5 30.2 53.5 34.5 55.2"
shadow: "M36 43 C44 46.6 58 46.4 72 44 L72 48 L36 48 Z", + " C28 57 26 63 29.5 68 C31 70 33 71 35.5 71.6"
+ " C29.5 73.8 29 80.5 34 83.5 C32 86.8 34.2 92.5 41 93.8"
+ " C51.5 95.8 65 95 75 90.5 C83 87 88 81 89.5 74 C91 66 90 55 86 48 Z",
shadow: "M76 41 C84 49 87.5 61 85 73 C82 83 73.5 90 61.5 92.5 C49.5 95 39 94 32 90.5 L32 97 L92 97 L92 41 Z"
+ " M33.5 53.8 C42 56.2 52.5 56.2 61 54.5 L61 57.2 C52 59 41.5 58.8 32.5 56.2 Z"
+ " M33.8 70.2 C42 72.5 52 72.8 60 71.2 L60 74 C51 75.5 41 75 32.8 72.8 Z"
+ " M33.5 82.2 C41.5 84.5 51 84.8 58.5 83.5 L58.5 86.2 C50 87.5 40.5 87.2 32.5 84.8 Z",
lines: "M34.5 55.2 C43 57.2 53 57 60.5 55.2 M35.5 71.6 C43.5 73.6 52.5 73.8 59.5 72.2 M34 83.5 C42 85.5 50.5 85.8 57.5 84.5",
}, },
overNails: [[40.6, 39.4, 4.2, 3.6, -12]], wrist: [86, 64], wristDeg: 45, upright: true, bodyBehind: true, hold: [44, 65],
wrist: [96, 40], wristDeg: 45, upright: true, hold: [44, 66],
}, },
// Segurando a borda de um objeto largo (em par): dedos atrás do objeto, polegar grosso por cima da frente dele.
// Antebraço chegando de cima, por fora (pose hold_both). // Segurando a borda lateral de um objeto largo (proporção redonda e compacta idêntica a referencia/recortes/maos-segurando.png):
// - `body` (atrás): palma arredondada que apoia por trás do objeto;
// - `over` (na frente da borda): mão redonda e gordinha (`largura ~50, altura ~58`) com 4 dedos roliços e 3 sulcos curtos!
pinch_edge: { pinch_edge: {
body: "M56 32 C62 27 72 26.6 80 30.6 C83.6 32.6 85.6 37 87 42 L94.4 35.3 L112.4 55.3 L105 62 C102 70.4 97 78 90 83.4" body: "M88 73 A13.5 13.5 0 0 0 88 46"
+ " C82.6 89 72.6 92 64 90.6 C58.6 89.6 55.6 86 55 80 C54 64 54 46 56 32 Z", + " C81 39 70 35 59 36 C47 37 40 44 40 58 C40 72 45 83 54 88"
shadow: "M82 30 C90 38 94 50 94 62 C92 74 86 82 76 88 L120 120 L120 20 Z M55 78 C60 86 70 90 84 88 L84 96 L54 96 Z", + " C63 93 75 91 83 83 C86 79.5 87.5 76 88 73 Z",
lines: "M56 46 C62 46 68.6 47.6 74 50.6 M55.6 60 C61.4 60.4 67.6 62 73 64.8 M55.6 73.6 C60.6 74 65.4 75.6 69.6 78", shadow: "M76 40 C83 48 86 60 83.5 72 C81 82 73 88 61 90 L92 92 L92 40 Z",
lines: "",
over: { over: {
body: "M70 46 C62 40 52 34.6 45 31.6 C38.4 28.8 33 32.4 35 38.4 C37.4 45 46.4 51 55.6 57 C62 61 70.4 57.6 70 46 Z", body: "M85 44 C77 34 63 30 49 31.5 C37.5 32.8 30.5 38.5 32.5 45.8"
shadow: "M36.4 40.6 C43 47 52 53 60 58 L68 58 L68 64 L34 46 Z", + " C26.8 48 25 55.2 30 59.5 C25 62.2 24.8 70 30.5 73.5"
+ " C27.2 77.2 29.2 84.5 36 87 C46 90.5 60 91 72 87"
+ " C80.5 84 86.5 78 88.2 70.5 C90 62 89 51 85 44 Z",
shadow: "M75 38 C83 47 86.5 59.5 84 71.5 C81.5 81.5 73 87.5 60.5 89 C47.5 90.5 37 88 31.5 83.5 L31.5 93 L92 93 L92 38 Z"
+ " M32 44.5 C40.5 47.2 50.5 47.5 58.5 46 L58.5 48.8 C49.5 50.2 39.5 50 31 47.2 Z"
+ " M29.5 58.2 C38 61 48 61.2 56 59.8 L56 62.5 C47 64 37 63.8 28.5 61 Z"
+ " M30 72.2 C38.5 74.8 48 75 55.5 73.6 L55.5 76.4 C46.5 77.8 37.5 77.5 29 75 Z",
lines: "M32.5 45.8 C41 48 50.5 48.2 58 46.8 M30 59.5 C38.5 61.8 48 62 55.5 60.5 M30.5 73.5 C38.8 75.8 47.8 76 54.8 74.6",
}, },
overNails: [[39.8, 35.2, 4.2, 3.6, 30]], wrist: [85, 60], wristDeg: 62, upright: true, bodyBehind: true, hold: [44, 60],
wrist: [96, 52], wristDeg: 48, upright: true, bodyBehind: true, hold: [56, 52],
}, },
// A mesma pegada de borda com o antebraço chegando de baixo (close de mãos segurando um livro aberto).
// Pegada de borda com o antebraço vindo de baixo (HandsInsert): dedos atrás da página e polegar comprido + palma na frente.
pinch_low: { pinch_low: {
body: "M56 30 C64 25 78 26 85 34 C90 41 93 52 95 62 C96.6 70 100 78 105.5 86.5 L112.6 93.6 L93.6 112.6 L86.5 105.5" body: "M84 106 A14 14 0 0 0 104 86"
+ " C80 98 72 94.6 66 92.4 C59 90 56 85.6 55 79 C53.6 64 53.6 44 56 30 Z", + " C99 76 95 64 92 52 C89 39 81 28 69 26 C59 24.5 52 30 51 40"
shadow: "M80 28 C90 40 94 56 96 68 C98 78 102 84 110 92 L120 120 L120 20 Z M55 78 C60 86 68 91 80 96 L80 104 L54 100 Z", + " C49.5 55 50 72 54 84 C58 93 69 98 84 106 Z",
lines: "M56 46 C62 46 68.6 47.6 74 50.6 M55.6 60 C61.4 60.4 67.6 62 73 64.8 M55.6 73.6 C60.6 74 65.4 75.6 69.6 78", shadow: "M78 28 C88 39 92 55 95 70 C97 80 100 86 105 92 L112 104 L76 108 L54 90 C66 93 78 90 83 80 C88 68 85 45 78 28 Z",
lines: "M52 44 C59 44.5 66.5 46.5 72.5 50 M51.5 58 C58.5 58.8 65.5 60.8 71.5 64 M52.5 72 C58.5 72.8 64.5 74.8 69.5 78",
over: { over: {
body: "M70 46 C62 40 52 34.6 45 31.6 C38.4 28.8 33 32.4 35 38.4 C37.4 45 46.4 51 55.6 57 C62 61 70.4 57.6 70 46 Z", body: "M84 106 A14 14 0 0 0 104 86"
shadow: "M36.4 40.6 C43 47 52 53 60 58 L68 58 L68 64 L34 46 Z", + " C98 76 91 64 82 54 C72 44 56 34 45 30.5 C36.5 27.8 30.5 32.5 33 40"
+ " C35.5 47.5 45 54.5 55 61 C61 65 65 73 68 84 C71 94 77 101 84 106 Z",
shadow: "M34 41 C42 49 52 56 60 62 C65 68 68 78 72 90 L98 106 L82 110 L62 92 L32 46 Z",
lines: "M56 61 C62 64 67 69 70 76",
}, },
overNails: [[39.8, 35.2, 4.2, 3.6, 30]], wrist: [94, 96], wristDeg: 135, upright: true, bodyBehind: true, hold: [56, 52],
wrist: [96, 96], wristDeg: 135, upright: true, bodyBehind: true, hold: [56, 52],
}, },
// Fechada, vista pelo lado da palma: os 4 dedos dobrados como gomos em arco (médio mais à frente, mínimo menor),
// com a ponta virada para a palma e a UNHA de cada um; o polegar fecha por cima do indicador e do médio. // Punho fechado: 4 dedos dobrados em arco macio, polegar travando por cima do indicador e do médio.
fist: { fist: {
body: `${WRIST_TOP} C45 12 40 18 37.5 26 C36 34 36.2 42 38 50 C39.4 57 42.4 62 46.6 63.6 C50 65 53.2 64 54.4 61.4` body: `${WRIST_CAP}`
+ " C56 66.4 60 69 64 68.4 C67.4 67.8 69 65.2 69.2 62.4 C71.4 65.8 75 66.2 77.4 64.2 C79.4 62.4 79.8 59.4 79.4 57" + " C75.5 8 81 18 82.8 30 C84.2 40 84.2 50 81.5 56.5 C79.2 61.5 75.2 63.2 71.5 61.8"
+ ` C81.6 57 82.6 53 82.4 48 C82.2 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`, + " C69.8 66.2 65.5 68.5 60.8 67.6 C58.2 67 56.2 65.2 55 62.8"
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.8 30 C81.6 40 81 46 80 50 L96 50 L96 -12 Z M40 58 C48 68 66 72 82 54 L84 80 L38 80 Z", + " C53.2 66.8 48.8 68.8 44.2 67.6 C39.5 66.4 36.2 62.2 35 55.5"
lines: "M54.4 61.4 C53.8 57 52.4 54 50.6 52 M69.2 62.4 C68.8 58.4 67.6 55.6 66 53.6 M79.4 57 C78.6 53.6 77.4 51.2 75.8 49.6 M44 51 C54 47.6 68 45.6 81 43.6", + " C33.2 46 33.5 35 36.5 25.5 C39.5 16.5 44 9 46.2 2.5 C46.4 1.5 46.5 0.8 46.5 0 Z",
nails: [[46, 59.6, 3, 2.3, 10], [62.6, 64.4, 3.2, 2.4, 0], [74.2, 61.2, 2.8, 2.1, -10], [80, 53, 2.2, 1.8, -30]], shadow: "M65 -10 C68 5 75 15 78 29 C80 40 79 50 75 57 C68 63 54 66 38 62 L38 74 L92 74 L92 -10 Z",
lines: "M46 67 C46.2 59.5 47 52.5 48.8 47 M60.8 67.6 C61.2 60 61.8 53 63.4 47.5 M71.5 61.8 C72 55.5 72.6 49.5 73.8 45"
+ " M42 48.5 C53 45.8 65 44.5 76.5 43.2",
over: { over: {
body: "M38 30 C42 39 48 47 55 52 C59 54.6 60.4 59 57 60.6 C53 62.4 47.6 59 43.6 54.6 C39.8 50.4 37.4 42 38 30 Z", body: "M35.5 28 C41 34 49 41 55.5 46.5 C60.2 50.5 61 56.8 56.5 59.8 C52 62.8 44.8 60 39.5 54.2 C34.5 48.8 32.5 39.5 35.5 28 Z",
shadow: "M39.4 46 C42.6 52 47 57 52 60 L48 63 L38 52 Z", shadow: "M35 44 C39.5 51 46.5 56.5 54 58.5 L50 62.5 L33 50 Z",
}, },
overNails: [[56.6, 56.8, 3.1, 2.7, 35]],
wrist: [60, 0], wristDeg: 0, upright: false, wrist: [60, 0], wristDeg: 0, upright: false,
}, },
// Apoiada no rosto (queixo, boca, lateral da cabeça): dorso, dedos juntos e mais retos, polegar recolhido.
// Mão no rosto (tapar a boca / facepalm): palma arredondada e macia, dedos unidos em concha com sulcos curtos nas pontas.
on_face: { on_face: {
body: `${WRIST_TOP} C45.5 12 41.5 18 39.5 25 C37.5 32 37.5 40 39 46 C39.5 58 39.6 70 40.4 82 C40.8 88 43.4 91.4 46.4 91.2` body: `${WRIST_CAP}`
+ " C49.4 91 50.6 88.4 50.8 85 L51 83 C51.4 90 53.6 94.4 57 94.4 C60.4 94.4 62 91.4 62.2 87.6 L62.3 85.6 C63 91 65.4 93.4 68.4 93" + " C75 8 80 18 81.5 30 C82.8 41 82.4 55 80.5 67 C79.5 73 76.8 76 73.5 75.5 C71.5 75.2 70.2 73.5 69.8 71"
+ " C71.4 92.6 72.4 89.8 72.4 86.4 L72.5 83.6 C73.6 87 75.6 88.2 77.6 87.6 C79.8 86.8 80.6 84 80.8 80.6 C81.6 70 82.2 56 82 44" + " C69.2 76.5 67.2 81.5 63.2 82 C59.8 82.4 58 80 57.6 76.5"
+ ` C81.8 32 79.2 20 75.5 10 ${WRIST_RIGHT_END}`, + " C57 81.5 54.6 85 50.6 85 C46.8 85 44.8 81.5 44.6 76.5"
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.4 36 C81 50 80.6 66 79.6 84 L96 84 L96 -12 Z M40 84 C48 92 66 97 82 84 L82 104 L40 104 Z", + " C43.8 79.8 41.4 81.8 38.2 81.2 C34.8 80.5 33 76.5 33.6 69.5 C34.5 58 36.2 46.5 38 38"
lines: "M51 83 C51 74 51.2 66 51.6 58 M62.3 85.6 C62.3 76 62.2 67 62 58 M72.5 83.6 C72.8 75 73 66 73.2 57", + " C35.5 42.5 33 46.5 30 48.5 C26.8 50.5 23.2 49 22.6 45 C22 40 24.8 32.5 29.5 25.5"
over: { + " C34.5 18 41.8 11 45.2 4 C46 2.5 46.5 1.2 46.5 0 Z",
body: "M39.5 25 C35 31 33.6 40 35.4 46 C36.8 50.4 41 50 41.6 46 C42.2 41 42 34 41.8 28 Z", shadow: "M65 -10 C68 5 74.5 16 77 30 C78.5 43 78 58 75.5 71 C72.5 79 61 84 44 83 L44 92 L90 92 L90 -10 Z",
lines: "M38 38 C39.8 32.5 40.6 27 40 21 M44.6 76.5 C45 69.5 45.8 63 46.8 57.5 M57.6 76.5 C58 69.5 58.4 63 59 57.5 M69.8 71 C70.2 65 70.6 59.5 71 55",
wrist: [60, 0], wristDeg: 0, upright: false,
}, },
overNails: [[37.4, 44.6, 2.4, 3.2, 6]],
// Mão pensando (apoiada no queixo): punho macio sob o queixo com o indicador estendido na bochecha/queixo
// e os outros 3 dedos dobrados em gomos arredondados (sem aspecto de garfo ou bloco).
think: {
body: `${WRIST_CAP}`
+ " C75.5 8 81.5 18 83.2 30 C84.5 40 84 50 81 57 C78.5 62.5 73.8 64.5 69.5 62.5"
+ " C67.8 67.2 63 69.5 58 68.2 C55.2 67.5 53.2 65.5 52.2 63"
+ " C50.5 66.5 47.8 68.2 44.8 67.5 C44.5 75 44 83.5 43 90"
+ " C42 96.2 38.2 99.5 33.8 98.8 C29.4 98 26.8 93.8 27.6 87"
+ " C29 75.5 31.2 61 33.5 48 C29.5 50.5 25 51.5 21.5 49.5 C17.8 47.5 16.5 42.5 18.8 37.5"
+ " C21.5 31.5 28 25.5 34.5 19.5 C40.5 14 44.8 7 46.5 0 Z",
shadow: "M65 -10 C68 5 75.5 16 78 30 C80 41 79 50 75 57 C69 63.5 57 66.5 43 65 L43 74 L91 74 L91 -10 Z"
+ " M38 56 C39.5 68 39.5 82 38.5 99 L44.5 99 L45 56 Z",
lines: "M33.5 48 C37.5 43 41 37 42.5 31 M45 66.5 C45.8 59 47 52 48.8 46.5 M58 68.2 C58.8 60.5 59.8 53.5 61.5 47.5 M69.5 62.5 C70.2 56 71 50 72.2 45",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Mão de braços cruzados apoiada no bíceps oposto (como em referencia/recortes/bracos-cruzados.png):
// 3 dedos roliços e macios pousados diagonalmente sobre o braço.
crossed: {
body: `${WRIST_CAP}`
+ " C74.5 8 79 18 80 29 C81 40 79.5 52 75.8 61.5 C73.2 68 68.5 71 63.8 69.5"
+ " C61.4 75.8 56.2 79.2 50.5 77.6 C47 76.6 44.6 73.6 43.8 69.5"
+ " C41.2 74 36.2 76 31.2 73.8 C26.4 71.6 24.4 66 26.8 59.2"
+ " C30 50 34.8 38.5 39 27.5 C42.2 19 45.4 9.5 46.5 0 Z",
shadow: "M64 -10 C67 5 72.5 16 74 30 C75 42 73.5 53 70 62 C65.5 70 52 75 33 72 L33 82 L88 82 L88 -10 Z",
lines: "M43.8 69.5 C46.5 59.5 49.8 50 53.2 42 M63.8 69.5 C65.8 60 67.8 51 70.2 43.5",
wrist: [60, 0], wristDeg: 0, upright: false, wrist: [60, 0], wristDeg: 0, upright: false,
}, },
}; };
@@ -191,31 +251,29 @@ export const TWO_HANDED: IconId[] = ["book", "tablet"];
/** /**
* Como cada objeto entra no punho (`grip`): ponto do cabo no quadro 100×100 do ícone e o giro que deixa o cabo em pé * Como cada objeto entra no punho (`grip`): ponto do cabo no quadro 100×100 do ícone e o giro que deixa o cabo em pé
* (cabeça do martelo, ponta do ramo e da régua para cima). Sem entrada: pelo meio, sem girar. * (cabeça do martelo, ponta do ramo e da régua para cima) com sobra visível do cabo abaixo da mão.
*/ */
export const GRIP: Partial<Record<IconId, { x: number; y: number; rot: number }>> = { export const GRIP: Partial<Record<IconId, { x: number; y: number; rot: number }>> = {
hammer: { x: 50, y: 80, rot: 20 }, hammer: { x: 50, y: 68, rot: 20 },
olive: { x: 26, y: 80, rot: -43 }, olive: { x: 36, y: 68, rot: -42 },
ruler: { x: 14, y: 58, rot: -78 }, ruler: { x: 32, y: 50, rot: -78 },
phone: { x: 50, y: 74, rot: 0 }, phone: { x: 50, y: 62, rot: -6 },
fuel: { x: 50, y: 30, rot: 0 }, fuel: { x: 50, y: 30, rot: 0 },
bulb: { x: 50, y: 82, rot: 0 }, bulb: { x: 50, y: 74, rot: 0 },
}; };
/** /**
* Posição da forma: espelho (`mirror`), giro em graus e escala, a partir do pulso na tela, do ângulo do antebraço e do * Posição da forma: espelho (`mirror`), giro em graus e escala, a partir do pulso na tela, do ângulo do antebraço e do
* lado do braço. Formas alinhadas giram com o antebraço; as "em pé" só inclinam até ±30° para acompanhá-lo. * lado do braço. Formas alinhadas giram com o antebraço; as "em pé" acompanham o ângulo para o qual foram desenhadas.
*/ */
export function handPlacement(shape: HandShape, x: number, y: number, foreDeg: number, s: number, k: number) { export function handPlacement(shape: HandShape, x: number, y: number, foreDeg: number, s: number, k: number) {
const def = SHAPES[shape]; const def = SHAPES[shape];
let mirror: number; let mirror: number;
let rot: number; let rot: number;
if (def.upright) { if (def.upright) {
// Desenhada para o braço da direita; o pulso acompanha o eixo do antebraço (gira em torno do centro do pulso).
mirror = s >= 0 ? 1 : -1; mirror = s >= 0 ? 1 : -1;
rot = foreDeg - def.wristDeg * mirror; rot = foreDeg - def.wristDeg * mirror;
} else { } else {
// Polegar do lado do corpo; com o braço erguido o eixo local vira e o espelho inverte junto.
const up = Math.cos((foreDeg * Math.PI) / 180) >= 0; const up = Math.cos((foreDeg * Math.PI) / 180) >= 0;
mirror = up ? s : -s; mirror = up ? s : -s;
rot = foreDeg; rot = foreDeg;
@@ -251,14 +309,14 @@ function mixHex(a: string, b: string, t: number): string {
} }
function coolHex(hex: string, k: number): string { function coolHex(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16); const n = parseInt(hex.slice(1), 16);
const r = ((n >> 16) & 255) * k * 0.94, g = ((n >> 8) & 255) * k * 0.97, b = (n & 255) * k + 10; const r = ((n >> 16) & 255) * k * 0.96, g = ((n >> 8) & 255) * k * 0.96, b = (n & 255) * k + 6;
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0"); const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
return `#${c(r)}${c(g)}${c(b)}`; return `#${c(r)}${c(g)}${c(b)}`;
} }
/** /**
* Desenha a forma de mão no lugar. `layer`: "back" = o que fica atrás do objeto, "front" = o que fica na frente, * Desenha a forma de mão no lugar. `layer`: "back" = o que fica atrás do objeto, "front" = o que fica na frente,
* "all" = tudo. `light` = lado da sombra na tela (1 = direita). Sem contorno: a borda é o tom escuro da pele. * "all" = tudo. `light` = lado da sombra na tela (1 = direita).
*/ */
export function HandArt({ shape, x, y, foreDeg, s, k, skin, light = 1, layer = "all", uid }: { export function HandArt({ shape, x, y, foreDeg, s, k, skin, light = 1, layer = "all", uid }: {
shape: HandShape; x: number; y: number; foreDeg: number; s: number; k: number; skin: string; light?: number; shape: HandShape; x: number; y: number; foreDeg: number; s: number; k: number; skin: string; light?: number;
@@ -266,38 +324,69 @@ export function HandArt({ shape, x, y, foreDeg, s, k, skin, light = 1, layer = "
}) { }) {
const p = handPlacement(shape, x, y, foreDeg, s, k); const p = handPlacement(shape, x, y, foreDeg, s, k);
const def = p.def; const def = p.def;
// A sombra foi desenhada à direita; se, depois de espelhar e girar, a direita do desenho não cai do lado da sombra
// pedido, a sombra vira para o outro lado (sempre recortada pela silhueta).
const rightOnScreen = p.mirror * Math.cos((p.rot * Math.PI) / 180); const rightOnScreen = p.mirror * Math.cos((p.rot * Math.PI) / 180);
const flipShadow = Math.sign(rightOnScreen || 1) !== Math.sign(light || 1); const flipShadow = Math.sign(rightOnScreen || 1) !== Math.sign(light || 1);
const shadowT = flipShadow ? "translate(120 0) scale(-1 1)" : undefined; const shadowT = flipShadow && !def.upright ? "translate(120 0) scale(-1 1)" : undefined;
const dark = shadeHex(skin, 0.62); const creaseColor = shadeHex(skin, 0.76);
const shadow = coolHex(skin, 0.8); const shadowFill = coolHex(skin, 0.86);
const lineProps = { stroke: dark, strokeWidth: 1.7, strokeLinecap: "round" as const, strokeLinejoin: "round" as const, fill: "none", opacity: 0.55 }; const skinLite = mixHex(skin, "#fff6ea", 0.06);
const gradId = `hg${uid}${layer}`;
const lineProps = {
stroke: creaseColor,
strokeWidth: 3.1,
strokeLinecap: "round" as const,
strokeLinejoin: "round" as const,
fill: "none",
opacity: 0.9,
};
const nail = ([cx, cy, rx, ry, a]: [number, number, number, number, number], i: number) => ( const nail = ([cx, cy, rx, ry, a]: [number, number, number, number, number], i: number) => (
<ellipse key={i} cx={cx} cy={cy} rx={rx} ry={ry} transform={`rotate(${a} ${cx} ${cy})`} fill={mixHex(skin, "#f7cfc6", 0.55)} stroke={shadeHex(skin, 0.68)} strokeWidth={0.9} /> <ellipse
key={i}
cx={cx}
cy={cy}
rx={rx}
ry={ry}
transform={`rotate(${a} ${cx} ${cy})`}
fill={mixHex(skin, "#fae5de", 0.38)}
opacity={0.8}
/>
); );
const bodyLayer = def.bodyBehind ? "back" : def.hold ? "front" : "all"; const bodyLayer = def.bodyBehind ? "back" : def.hold ? "front" : "all";
const showBody = layer === "all" || layer === bodyLayer || (bodyLayer === "all" && layer === "front"); const showBody = layer === "all" || layer === bodyLayer || (bodyLayer === "all" && layer === "front");
const showOver = layer !== "back"; const showOver = layer !== "back";
return ( return (
<g transform={p.transform}> <g transform={p.transform}>
<defs> <defs>
<linearGradient id={gradId} x1="15%" y1="10%" x2="85%" y2="90%">
<stop offset="0%" stopColor={skinLite} />
<stop offset="100%" stopColor={skin} />
</linearGradient>
<clipPath id={`hb${uid}${layer}`}><path d={def.body} /></clipPath> <clipPath id={`hb${uid}${layer}`}><path d={def.body} /></clipPath>
{def.over && <clipPath id={`ho${uid}${layer}`}><path d={def.over.body} /></clipPath>} {def.over && <clipPath id={`ho${uid}${layer}`}><path d={def.over.body} /></clipPath>}
</defs> </defs>
{showBody && <> {showBody && (
<path d={def.body} fill={skin} /> <>
<g clipPath={`url(#hb${uid}${layer})`}><path d={def.shadow} fill={shadow} transform={shadowT} /></g> <path d={def.body} fill={`url(#${gradId})`} />
<path d={def.lines} {...lineProps} /> <g clipPath={`url(#hb${uid}${layer})`}>
<path d={def.shadow} fill={shadowFill} transform={shadowT} opacity={0.88} />
</g>
{def.lines && <path d={def.lines} {...lineProps} />}
{(def.nails ?? []).map(nail)} {(def.nails ?? []).map(nail)}
</>} </>
{showOver && def.over && <> )}
<path d={def.over.body} fill={shadeHex(skin, 1.03)} /> {showOver && def.over && (
{def.over.shadow && <g clipPath={`url(#ho${uid}${layer})`}><path d={def.over.shadow} fill={shadow} /></g>} <>
<path d={def.over.body} fill={`url(#${gradId})`} />
<g clipPath={`url(#ho${uid}${layer})`}>
{def.over.shadow && <path d={def.over.shadow} fill={shadowFill} opacity={0.88} />}
</g>
{def.over.lines && <path d={def.over.lines} {...lineProps} />} {def.over.lines && <path d={def.over.lines} {...lineProps} />}
{(def.overNails ?? []).map(nail)} {(def.overNails ?? []).map(nail)}
</>} </>
)}
</g> </g>
); );
} }
+37 -15
View File
@@ -72,31 +72,53 @@ const DRAW: Record<IconId, React.ReactNode> = {
</>), </>),
// Itens de mão e objetos de história antiga (também servem como objeto solto na cena). // Itens de mão e objetos de história antiga (também servem como objeto solto na cena).
olive: (<> olive: (<>
<path d="M20 86 Q46 60 86 16" stroke="#6b4a2a" strokeWidth={5} fill="none" strokeLinecap="round" /> <path d="M14 94 Q44 62 86 14" stroke="#3d2814" strokeWidth={8.5} fill="none" strokeLinecap="round" />
{[[34, 66, -40], [44, 56, 30], [54, 46, -40], [64, 36, 30], [74, 26, -40], [28, 76, 30]].map(([x, y, r], i) => ( <path d="M14 94 Q44 62 86 14" stroke="#7d5632" strokeWidth={5.5} fill="none" strokeLinecap="round" />
<ellipse key={i} cx={x} cy={y} rx={13} ry={5.5} fill={i % 2 ? "#7fa24a" : "#5f8a3a"} transform={`rotate(${r} ${x} ${y})`} /> {[[38, 62, -38], [48, 52, 28], [58, 42, -38], [68, 32, 28], [78, 22, -38], [84, 15, -12]].map(([x, y, r], i) => (
<g key={i} transform={`rotate(${r} ${x} ${y})`}>
<ellipse cx={x} cy={y} rx={13.5} ry={6} fill={i % 2 ? "#557d32" : "#446827"} />
<ellipse cx={x} cy={y - 1} rx={12} ry={4.2} fill={i % 2 ? "#84ab4c" : "#6c943c"} />
<path d={`M${x - 9} ${y} L${x + 9} ${y}`} stroke="#9ec462" strokeWidth={1.2} strokeLinecap="round" opacity={0.7} />
</g>
))} ))}
<circle cx={50} cy={58} r={4} fill="#3d3a5a" /><circle cx={70} cy={38} r={4} fill="#3d3a5a" /> <circle cx={54} cy={54} r={4.5} fill="#2e2b4a" /><circle cx={52.5} cy={52.5} r={1.5} fill="#76729e" />
<circle cx={72} cy={35} r={4.5} fill="#2e2b4a" /><circle cx={70.5} cy={33.5} r={1.5} fill="#76729e" />
</>), </>),
hammer: (<> hammer: (<>
<rect x={44} y={34} width={12} height={60} rx={5} fill="#8a5a32" transform="rotate(-20 50 64)" /> <g transform="rotate(-20 50 64)">
<rect x={22} y={14} width={50} height={22} rx={4} fill="#8c929e" transform="rotate(-20 47 25)" /> <rect x={42.5} y={28} width={15} height={68} rx={6} fill="#5c381c" />
<rect x={22} y={14} width={12} height={22} rx={3} fill="#6c717c" transform="rotate(-20 47 25)" /> <rect x={44} y={29} width={12} height={66} rx={5} fill="#9c6638" />
<rect x={45.5} y={30} width={4.5} height={64} rx={2} fill="#b87e4a" opacity={0.75} />
<rect x={42} y={32} width={16} height={6} rx={2} fill="#4a2e16" />
</g>
<g transform="rotate(-20 47 25)">
<rect x={18} y={11} width={58} height={25} rx={5} fill="#4d525e" />
<rect x={19} y={12} width={56} height={22} rx={4} fill="#8f96a3" />
<rect x={21} y={14} width={52} height={8} rx={3} fill="#b4bac6" opacity={0.7} />
<rect x={18} y={11} width={14} height={25} rx={4} fill="#686e7a" />
</g>
</>), </>),
tablet: (<> tablet: (<>
<path d="M18 10 Q50 4 82 10 L86 88 Q50 96 14 88 Z" fill="#b8916a" /> <path d="M18 10 Q50 4 82 10 L86 88 Q50 96 14 88 Z" fill="#8f6c4a" />
{Array.from({ length: 7 }, (_, i) => <path key={i} d={`M24 ${22 + i * 10} L76 ${22 + i * 10}`} stroke="#8a6646" strokeWidth={2.5} strokeDasharray="5 3 2 3" />)} <path d="M20 12 Q50 6 80 12 L84 86 Q50 93 16 86 Z" fill="#b8916a" />
{Array.from({ length: 7 }, (_, i) => <path key={i} d={`M24 ${22 + i * 10} L76 ${22 + i * 10}`} stroke="#785638" strokeWidth={2.5} strokeDasharray="5 3 2 3" />)}
<path d="M70 70 L86 60 L86 88 L64 92 Z" fill="#000" opacity={0.18} /> <path d="M70 70 L86 60 L86 88 L64 92 Z" fill="#000" opacity={0.18} />
</>), </>),
book: (<> book: (<>
<path d="M8 24 Q30 16 50 26 Q70 16 92 24 L92 82 Q70 74 50 84 Q30 74 8 82 Z" fill="#f2e8d0" /> <path d="M6 26 Q28 18 50 28 Q72 18 94 26 L94 86 Q72 78 50 88 Q28 78 6 86 Z" fill="#6b3022" />
<path d="M50 26 L50 84" stroke="#b9a882" strokeWidth={3} /> <path d="M8 22 Q30 14 50 24 Q70 14 92 22 L92 80 Q70 72 50 82 Q30 72 8 80 Z" fill="#dfd2b5" />
{[0, 1, 2, 3].map((i) => <g key={i}><path d={`M16 ${36 + i * 11} L42 ${38 + i * 11}`} stroke="#9a8a6a" strokeWidth={2.5} /><path d={`M58 ${38 + i * 11} L84 ${36 + i * 11}`} stroke="#9a8a6a" strokeWidth={2.5} /></g>)} <path d="M9 20 Q30 12 50 22 Q70 12 91 20 L91 77 Q70 69 50 79 Q30 69 9 77 Z" fill="#f5ecd6" />
<path d="M8 82 Q30 74 50 84 Q70 74 92 82 L92 88 Q70 80 50 90 Q30 80 8 88 Z" fill="#7a3a2a" /> <path d="M44 20 Q47 21 50 22 Q53 21 56 20 L56 78 Q53 78.5 50 79 Q47 78.5 44 78 Z" fill="#e2d5b8" />
<path d="M50 22 L50 79" stroke="#b9a882" strokeWidth={2.5} />
{[0, 1, 2, 3].map((i) => <g key={i}><path d={`M16 ${32 + i * 10.5} Q29 ${29 + i * 10.5} 43 ${34 + i * 10.5}`} stroke="#9a8a6a" strokeWidth={2.4} fill="none" strokeLinecap="round" /><path d={`M57 ${34 + i * 10.5} Q71 ${29 + i * 10.5} 84 ${32 + i * 10.5}`} stroke="#9a8a6a" strokeWidth={2.4} fill="none" strokeLinecap="round" /></g>)}
</>), </>),
ruler: (<> ruler: (<>
<rect x={6} y={38} width={88} height={24} rx={3} fill="#e6c27a" transform="rotate(-12 50 50)" /> <g transform="rotate(-12 50 50)">
{Array.from({ length: 10 }, (_, i) => <rect key={i} x={12 + i * 8.4} y={38} width={2.4} height={i % 2 ? 7 : 12} fill="#6b4a2a" transform="rotate(-12 50 50)" />)} <rect x={4} y={36} width={92} height={26} rx={4} fill="#8c6230" />
<rect x={6} y={37} width={88} height={23} rx={3} fill="#e8c374" />
<rect x={8} y={53} width={84} height={6} rx={2} fill="#cfa656" />
{Array.from({ length: 11 }, (_, i) => <rect key={i} x={11 + i * 7.6} y={37} width={2.2} height={i % 2 ? 7 : 12} rx={0.8} fill="#5c3d1b" />)}
</g>
</>), </>),
}; };
+7 -4
View File
@@ -47,12 +47,15 @@ export function armGeometry(b: BodyParams, s: 1 | -1, w = 1) {
export function armLayer(b: BodyParams, s: 1 | -1, opts: { holds?: boolean; w?: number } = {}): ArmLayer { export function armLayer(b: BodyParams, s: 1 | -1, opts: { holds?: boolean; w?: number } = {}): ArmLayer {
const w = opts.w ?? 1; const w = opts.w ?? 1;
const g = armGeometry(b, s, w); const g = armGeometry(b, s, w);
const l = s > 0 ? b.armR : b.armL;
const half = ARM.torsoHalf * w; const half = ARM.torsoHalf * w;
// Altura do pescoço/rosto: acima do topo do tronco (+ folga da gola), dentro da largura da cabeça. // Altura do pescoço/rosto: acima do topo do tronco (+ folga da gola), dentro da largura da cabeça, ou braço dobrado ao queixo/boca.
const atFace = (p: Point) => p.y < g.torsoTop + 12 && Math.abs(p.x - 100) < 66; const atFace = (p: Point) => p.y < g.torsoTop + 20 && Math.abs(p.x - 100) < 60;
if (atFace(g.hand)) return "face"; if (atFace(g.hand) || atFace(g.wrist) || (l.raise < 20 && l.bend > 138)) return "face";
if (opts.holds) return "front"; if (opts.holds) return "front";
const chest = { x0: 100 - half + 16, x1: 100 + half - 16, y0: g.torsoTop + 6, y1: g.hipY + 10 }; // Cotovelo bem dobrado para dentro com o braço baixo (segurar, joinha, mão na cintura, braços cruzados): antebraço na frente.
if (l.raise < 90 && l.bend > 85) return "front";
const chest = { x0: 100 - half + 14, x1: 100 + half - 14, y0: g.torsoTop + 4, y1: g.hipY + 12 };
const inChest = (p: Point) => p.x > chest.x0 && p.x < chest.x1 && p.y > chest.y0 && p.y < chest.y1; const inChest = (p: Point) => p.x > chest.x0 && p.x < chest.x1 && p.y > chest.y0 && p.y < chest.y1;
// Amostra o antebraço (cotovelo → mão): basta um trecho na frente do peito. // Amostra o antebraço (cotovelo → mão): basta um trecho na frente do peito.
for (let i = 0; i <= 8; i++) { for (let i = 0; i <= 8; i++) {
+9 -9
View File
@@ -110,26 +110,26 @@ export const EXPRESSION_PRESETS = {
/** Poses prontas = atalhos de ângulos (ajustáveis por cima com `body`). */ /** Poses prontas = atalhos de ângulos (ajustáveis por cima com `body`). */
export const POSE_PRESETS = { export const POSE_PRESETS = {
stand: {}, stand: {},
point: { armR: { raise: 92, bend: 0 } }, point: { armR: { raise: 46, bend: -128 } },
wave: { armR: { raise: 140, bend: -25 } }, wave: { armR: { raise: 140, bend: -25 } },
hold: { armR: { raise: 28, bend: 75 } }, hold: { armR: { raise: 34, bend: 106 } },
arms_up: { arms: { raise: 158, bend: -10 } }, arms_up: { arms: { raise: 158, bend: -10 } },
celebrate: { arms: { raise: 150, bend: -30 }, headNod: -0.4 }, celebrate: { arms: { raise: 146, bend: -26 }, headNod: -0.35 },
shrug: { arms: { raise: 38, bend: 100 }, headTilt: 7 }, shrug: { arms: { raise: 38, bend: 100 }, headTilt: 7 },
think: { armR: { raise: -19, bend: 141 }, headTilt: -6 }, think: { armR: { raise: -24, bend: 138 }, headTilt: -5 },
hands_on_hips: { arms: { raise: 42, bend: 105 } }, hands_on_hips: { arms: { raise: 42, bend: 105 } },
cross_arms: { arms: { raise: 22, bend: 128 } }, cross_arms: { arms: { raise: 24, bend: 128 } },
facepalm: { armR: { raise: 125, bend: -103 }, headNod: 0.5, headTilt: 8 }, facepalm: { armR: { raise: 125, bend: -103 }, headNod: 0.5, headTilt: 8 },
cover_mouth: { armR: { raise: -60, bend: 119 } }, cover_mouth: { armR: { raise: -34, bend: 130 } },
defend: { arms: { raise: 62, bend: 118 }, lean: -4 }, defend: { arms: { raise: 62, bend: 118 }, lean: -4 },
reach: { armR: { raise: 70, bend: -10 }, lean: 6 }, reach: { armR: { raise: 68, bend: -15 }, lean: 6 },
sit: { crouch: 1, arms: { raise: 14, bend: 40 } }, sit: { crouch: 1, arms: { raise: 14, bend: 40 } },
kneel: { crouch: 0.6, arms: { raise: 10, bend: 20 } }, kneel: { crouch: 0.6, arms: { raise: 10, bend: 20 } },
lean_in: { lean: 8, headTilt: 6 }, lean_in: { lean: 8, headTilt: 6 },
// Duas mãos segurando um objeto largo (livro, tábua) pelas bordas, na frente do peito. // Duas mãos segurando um objeto largo (livro, tábua) pelas bordas, na frente do peito.
hold_both: { arms: { raise: 51, bend: 99 } }, hold_both: { arms: { raise: 42, bend: 104 } },
// Joinha: cotovelo dobrado, mão na altura do peito/ombro (a forma da mão vem do desenho: `thumbs_up`). // Joinha: cotovelo dobrado, mão na altura do peito/ombro (a forma da mão vem do desenho: `thumbs_up`).
thumbs_up: { armR: { raise: 17, bend: 149 } }, thumbs_up: { armR: { raise: 22, bend: 148 } },
} satisfies Record<string, BodyPatch>; } satisfies Record<string, BodyPatch>;
export type ExpressionName = keyof typeof EXPRESSION_PRESETS; export type ExpressionName = keyof typeof EXPRESSION_PRESETS;
+8 -4
View File
@@ -75,9 +75,12 @@ saída: …" no contexto.
## Contexto do jogo ## Contexto do jogo
- Categoria da plataforma (Streamlink `--json`, `metadata.category`) no início e a cada 10 min (troca registrada em - **Detecção automática** (18/11/2026, `doc/clipador/DETECCAO-JOGO.md`): a cada ~3 min o Clipador cruza categoria da
`games_json`). Sem categoria (YouTube/VOD), o jogo vem da tela (`screen_game` da varredura). A IA também diz o que plataforma (Streamlink `--json`), título, o que a IA lê na tela (`screen_game` + confiança + evidência, da varredura),
vê na tela; divergência (categoria "ROB RUN", tela "GTA V") vai para o contexto dos juízes. chat e fala (jogos cadastrados) e decide: `agreed` / `probable` / `conflict` / `unknown` (`sessions.game_status`,
pistas em `game_detect_json`). Categoria genérica (Just Chatting) não é jogo. Conflito (categoria "ROB RUN", tela
"GTA V") mantém o jogo e o painel pergunta. Jogo confirmado por você não muda sozinho (vira `suggestion`).
`POST /v1/sessions/{id}/game/detect` = "Detectar agora". Trocas ficam em `games_json`.
- **Perfil do jogo** pesquisado na web pela CLI (`codex --search`), guardado por jogo (tabela `games`): resumo, - **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. 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). - Correção manual: `PUT /v1/sessions/{id}/game` (trava a troca automática).
@@ -441,7 +444,8 @@ chave `clipper-<sessão>-<bloco>`; num banco novo as sessões recomeçam do 1 e
|---|---| |---|---|
| `GET /health` | sem chave | | `GET /health` | sem chave |
| `GET /v1/status` | ferramentas, voz, juiz, gravações ativas | | `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/judge` | Equipe de IA (`roles`: varredura, analista, editor, juiz — provedor, modelo, esforço, liga/desliga, instruções do administrador; `roleDefaults` = instruções padrão), nota mínima, varredura, visão, câmera, `timelineJson` (+ lista de modelos) — doc/clipador/EQUIPE-IA.md |
| `GET /v1/judge/report?days=&session=` | medição: chamadas e tokens por papel/IA por hora de live, aprovação, decisões do juiz de contexto, concordância juiz × dono |
| `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/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}/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 | | `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 |
+104 -22
View File
@@ -1,8 +1,11 @@
"""Leitura do chat ao vivo, em tempo real, para medir a reação do público. """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. - 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 - Kick: o mesmo tempo real que o site usa (não é API oficial: pode mudar sem aviso). Desde 11/2026 a Kick
sem aviso e o Cloudflare às vezes bloqueia a consulta do id da sala. escolhe o provedor por canal (`POST web.kick.com/api/v1/realtime/channels/<id>/chat/connection`): hoje responde
**Centrifugo** (token de convidado em `/v1/realtime/auth/connection`, sem login) e o Pusher com a chave fixa antiga
passou a recusar ("App key not in this cluster"). O canal continua `chatrooms.<sala>.v2` e a mensagem tem o mesmo
formato. 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. - 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 Cada leitor roda numa thread, reconecta sozinho e entrega lotes de (instante, usuário, texto) com o relógio
@@ -19,6 +22,7 @@ import socket
import ssl import ssl
import threading import threading
import time import time
import uuid
from typing import Callable from typing import Callable
import httpx import httpx
@@ -31,7 +35,25 @@ OnMessages = Callable[[list[tuple[float, str, str, list[str]]]], None]
_PRIVMSG = re.compile(r"^(?:@(\S+) )?:([^!\s]+)!\S+ PRIVMSG #\S+ :(.*)$") _PRIVMSG = re.compile(r"^(?:@(\S+) )?:([^!\s]+)!\S+ PRIVMSG #\S+ :(.*)$")
_ROOM_ID = re.compile(r"(?:^@|;)room-id=(\d+)") _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" KICK_API = "https://web.kick.com/api/v1/realtime"
KICK_HEADERS = {"User-Agent": "Mozilla/5.0", "Accept": "application/json", "Origin": "https://kick.com"}
# Pedido do site ao escolher o provedor (os dois que ele aceita). Medido 18/11/2026: a resposta é Centrifugo.
KICK_CAPABILITIES = {"accepted_providers": [{"provider": "pusher"}, {"provider": "centrifugo"}]}
KICK_CENTRIFUGO_DEFAULT = "wss://realtime.us-west-2.platform.kick.com/connection/websocket"
_KICK_EMOTE = re.compile(r"\[emote:\d+:([^\]]+)\]")
def kick_message(event: str, payload: object) -> tuple[str, str, list[str]] | None:
"""Mensagem de chat da Kick → (usuário, texto, emotes), ou None se o evento não é mensagem. O `data` vem como
texto JSON (Pusher e Centrifugo). Emotes chegam como [emote:123:NOME]: fica só o nome, que carrega a reação."""
if not str(event).endswith("ChatMessageEvent"):
return None
data = json.loads(payload) if isinstance(payload, str) else (payload or {})
if not isinstance(data, dict):
return None
content = str(data.get("content") or "")
user = str((data.get("sender") or {}).get("username") or "")
return user, _KICK_EMOTE.sub(r"\1", content)[:300], _KICK_EMOTE.findall(content)
class ChatReader: class ChatReader:
@@ -114,20 +136,84 @@ class ChatReader:
if time.monotonic() - last_data > 360: # a Twitch manda PING a cada ~5 min if time.monotonic() - last_data > 360: # a Twitch manda PING a cada ~5 min
raise ConnectionError("sem dados há 6 min") raise ConnectionError("sem dados há 6 min")
# ---------- Kick (Pusher, não oficial) ---------- # ---------- Kick (tempo real do site, não oficial) ----------
def _run_kick(self) -> None: 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=KICK_HEADERS, timeout=20,
follow_redirects=True)
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: if response.status_code != 200:
raise ConnectionError(f"kick.com respondeu {response.status_code} ao buscar a sala do chat") raise ConnectionError(f"kick.com respondeu {response.status_code} ao buscar a sala do chat")
room = response.json()["chatroom"]["id"] channel = response.json()
with connect(KICK_PUSHER, open_timeout=20) as ws: room, channel_id = channel["chatroom"]["id"], channel["id"]
client_id = str(uuid.uuid4())
provider = self._kick_provider(channel_id, client_id)
if provider.get("provider") == "pusher":
self._run_kick_pusher(room, provider)
else:
self._run_kick_centrifugo(room, client_id, (provider.get("credentials") or {}).get("url") or KICK_CENTRIFUGO_DEFAULT)
def _kick_provider(self, channel_id: int, client_id: str) -> dict:
"""Provedor de tempo real que a Kick indica para o chat deste canal ({provider, credentials}). Falha na consulta
→ Centrifugo no endereço padrão (o que a Kick respondeu em todos os canais testados)."""
try:
r = httpx.post(f"{KICK_API}/channels/{channel_id}/chat/connection", headers=KICK_HEADERS, timeout=20,
json={"client": {"id": client_id, "type": "web"}, "capabilities": KICK_CAPABILITIES})
r.raise_for_status()
connections = (r.json().get("data") or {}).get("connections") or []
return connections[0] if connections else {"provider": "centrifugo"}
except (httpx.HTTPError, ValueError, KeyError, IndexError) as exc:
log.info("chat kick/%s: provedor não informado (%s); usando Centrifugo", self.channel, exc)
return {"provider": "centrifugo"}
def _run_kick_centrifugo(self, room: int, client_id: str, url: str) -> None:
"""Centrifugo (protocolo JSON): token de convidado → connect → subscribe `chatrooms.<sala>.v2`. O servidor manda
`{}` como ping (responde `{}`); o token expira (~45 min) e o servidor fecha: o laço reconecta com token novo."""
from websockets.sync.client import connect # import tardio: só quem usa Kick precisa
r = httpx.post(f"{KICK_API}/auth/connection", headers=KICK_HEADERS, json={"client_id": client_id}, timeout=20)
r.raise_for_status()
token = (r.json().get("data") or {}).get("token")
if not token:
raise ConnectionError("Kick não devolveu o token do chat")
with connect(url, open_timeout=20, additional_headers={"Origin": "https://kick.com", "User-Agent": "Mozilla/5.0"}) as ws:
ws.send(json.dumps({"connect": {"token": token, "name": "js"}, "id": 1}))
ws.send(json.dumps({"subscribe": {"channel": f"chatrooms.{room}.v2"}, "id": 2}))
batch, last_flush = [], time.monotonic()
while not self._stop.is_set():
try:
raw = ws.recv(timeout=1.0)
except TimeoutError:
raw = None
for part in (raw or "").split("\n"):
part = part.strip()
if not part:
continue
if part == "{}":
ws.send("{}") # ping do Centrifugo
continue
msg = json.loads(part)
if msg.get("error"):
raise ConnectionError(f"Kick (Centrifugo): {msg['error']}")
if msg.get("id") == 2 and "subscribe" in msg:
self.status = "connected"
pub = (msg.get("push") or {}).get("pub") or {}
data = pub.get("data") or {}
item = kick_message(data.get("event", ""), data.get("data")) if isinstance(data, dict) else None
if item:
batch.append((time.time(), *item))
if time.monotonic() - last_flush >= 1.0:
self._deliver(batch)
batch, last_flush = [], time.monotonic()
def _run_kick_pusher(self, room: int, provider: dict) -> None:
"""Pusher com a chave e o cluster que a Kick informar (a chave fixa antiga parou de valer em 11/2026)."""
from websockets.sync.client import connect
creds = provider.get("credentials") or {}
key, cluster = creds.get("appKey") or creds.get("key"), creds.get("cluster") or "us2"
if not key:
raise ConnectionError("Kick indicou Pusher sem a chave")
url = f"wss://ws-{cluster}.pusher.com/app/{key}?protocol=7&client=js&version=8.4.0&flash=false"
with connect(url, open_timeout=20) as ws:
ws.send(json.dumps({"event": "pusher:subscribe", "data": {"auth": "", "channel": f"chatrooms.{room}.v2"}})) ws.send(json.dumps({"event": "pusher:subscribe", "data": {"auth": "", "channel": f"chatrooms.{room}.v2"}}))
batch, last_flush = [], time.monotonic() batch, last_flush = [], time.monotonic()
while not self._stop.is_set(): while not self._stop.is_set():
@@ -142,14 +228,10 @@ class ChatReader:
self.status = "connected" self.status = "connected"
elif name == "pusher:ping": elif name == "pusher:ping":
ws.send(json.dumps({"event": "pusher:pong", "data": {}})) ws.send(json.dumps({"event": "pusher:pong", "data": {}}))
elif name.endswith("ChatMessageEvent"): else:
data = json.loads(event.get("data") or "{}") item = kick_message(name, event.get("data") or "{}")
user = (data.get("sender") or {}).get("username", "") if item:
# Emotes da Kick chegam como [emote:123:NOME]: fica só o nome, que é o que carrega a reação. batch.append((time.time(), *item))
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: if time.monotonic() - last_flush >= 1.0:
self._deliver(batch) self._deliver(batch)
batch, last_flush = [], time.monotonic() batch, last_flush = [], time.monotonic()
+116
View File
@@ -0,0 +1,116 @@
"""Decisão do JUIZ de contexto pelo código (doc/clipador/EQUIPE-IA.md).
O juiz (IA, só texto) responde perguntas sim/não sobre o corte; quem decide é esta função, com regras fixas e
calibráveis no painel (papel `judge` em `judge.roles`):
- checagem **crítica** que falhou (padrão: começo, desfecho, funciona sozinho) + ajuste de trecho dentro dos limites
→ **ajusta** (o trecho é recalculado com `fit_window`) e o juiz confere UMA vez de novo; falhou de novo → descarta;
- crítica que falhou sem ajuste possível → **descarta** com o motivo em português;
- "funciona sozinho" (e "quem/o quê") falho + frase de contexto → a frase resolve: vai na tela no começo do corte;
- checagem não crítica que falhou só **baixa a nota** (`penalty` por checagem); abaixo da nota mínima → descarta;
- corte manual ("cortar agora"): o juiz só **avisa**, nunca descarta nem mexe no trecho.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from .roles import CHECK_NAMES, CHECKS, DEFAULT_CRITICAL, DEFAULT_PENALTY
from .scoring import fit_window
MIN_SHIFT_S = 1.0 # ajuste menor que isso não muda nada: conta como "sem ajuste"
CONTEXT_LINE_MAX_WORDS = 10
CONTEXT_LINE_MAX_CHARS = 60
OUT_BEFORE_S = 20.0 # o juiz vê 20 s antes do corte, marcados out=1 (o espectador não vê)…
OUT_AFTER_S = 15.0 # …e 15 s depois (para notar o desfecho que ficou de fora)
# O que a frase de contexto resolve (ela dá ao espectador frio quem/o quê e o pano de fundo).
SOLVED_BY_LINE = ("standalone", "who_what")
@dataclass
class Decision:
action: str # approve | adjust | discard | warn
failed: list[str] = field(default_factory=list) # todas as checagens que falharam
failed_critical: list[str] = field(default_factory=list) # críticas que falharam e a frase não resolveu
solved_by_line: list[str] = field(default_factory=list)
window: tuple[float, float] | None = None # trecho novo (só em adjust)
context_line: str = ""
score_after: float | None = None
reason_pt: str = ""
def usable_line(text: str) -> str:
"""Frase de contexto que cabe na tela no começo do corte (curta); senão vazia."""
text = " ".join((text or "").split())
if not text or len(text) > CONTEXT_LINE_MAX_CHARS or len(text.split()) > CONTEXT_LINE_MAX_WORDS:
return ""
return text
def _names(checks: list[str]) -> str:
names = [CHECK_NAMES.get(c, c) for c in checks]
return names[0] if len(names) == 1 else ", ".join(names[:-1]) + " e " + names[-1]
def decide(result: dict, *, start_s: float, end_s: float, lo: float, hi: float, min_s: float, max_s: float,
conf: dict | None = None, score: float | None = None, min_score: float | None = None,
manual: bool = False, allow_fix: bool | None = None) -> Decision:
"""Ação pelo resultado do juiz (`judge.clean_context`). `conf` = papel `judge` da Equipe de IA.
`allow_fix=False` força a 2ª rodada (sem novo ajuste)."""
conf = conf or {}
critical = [c for c in conf.get("critical", DEFAULT_CRITICAL) if c in CHECKS]
penalty = float(conf.get("penalty", DEFAULT_PENALTY))
can_fix = conf.get("allowFix", True) if allow_fix is None else (allow_fix and conf.get("allowFix", True))
checks = result.get("checks") or {}
failed = [c for c in CHECKS if not (checks.get(c) or {}).get("ok", True)]
fix = result.get("fix") or {}
line = usable_line(fix.get("context_line", "")) if conf.get("allowContextLine", True) else ""
solved = [c for c in failed if c in SOLVED_BY_LINE] if line else []
failed_critical = [c for c in failed if c in critical and c not in solved]
others = [c for c in failed if c not in critical and c not in solved]
score_after = None if score is None else round(max(0.0, score - penalty * len(others)), 2)
why_pt = (result.get("pt") or {}).get("reason") or result.get("reason") or ""
d = Decision("approve", failed, failed_critical, solved, None, line, score_after)
if manual:
d.action = "warn" if failed else "approve"
d.reason_pt = (f"Aviso do juiz: falhou em {_names(failed)}. {why_pt}".strip() if failed else "")
return d
if failed_critical:
new = None
if can_fix and (fix.get("start_s") is not None or fix.get("end_s") is not None):
ns = fix["start_s"] if fix.get("start_s") is not None else start_s
ne = fix["end_s"] if fix.get("end_s") is not None else end_s
# Recuar o início (faltou o começo) mantém o início; estender o fim (faltou o desfecho) mantém o fim.
keep = "start" if "setup" in failed_critical or ns < start_s - MIN_SHIFT_S else "end"
ns, ne = fit_window(ns, ne, lo, hi, min_s, max_s, keep=keep)
if ne - ns >= min(min_s, 10.0) and (abs(ns - start_s) >= MIN_SHIFT_S or abs(ne - end_s) >= MIN_SHIFT_S):
new = (ns, ne)
if new:
d.action, d.window = "adjust", new
d.reason_pt = (f"Juiz ajustou o trecho para {new[0]:.0f}–{new[1]:.0f}s: faltava {_names(failed_critical)}. "
f"{why_pt}").strip()
else:
d.action = "discard"
d.reason_pt = f"Descartado pelo juiz: sem {_names(failed_critical)}. {why_pt}".strip()
return d
if score_after is not None and min_score is not None and others and score_after < min_score:
d.action = "discard"
d.reason_pt = (f"Descartado pelo juiz: a nota caiu para {score_after:.1f} (falhou em {_names(others)}). "
f"{why_pt}").strip()
return d
d.reason_pt = (f"Juiz aprovou{' com frase de contexto' if line and solved else ''}"
+ (f" (falhou em {_names(others)}, nota {score_after:.1f})" if others and score_after is not None else "")
+ (f". {why_pt}" if why_pt else "."))
return d
def view(result: dict, decision: Decision, model: str) -> dict:
"""O que vai em `judge_json.context` (o painel mostra em português)."""
return {"model": model, "viewerSummary": result.get("viewer_summary", ""), "checks": result.get("checks", {}),
"fix": result.get("fix", {}), "confidence": result.get("confidence"), "reason": result.get("reason", ""),
"pt": result.get("pt") or {}, "decision": decision.action, "failed": decision.failed,
"failedCritical": decision.failed_critical, "solvedByLine": decision.solved_by_line,
"contextLine": decision.context_line if decision.action in ("approve", "adjust", "warn") else "",
"scoreAfter": decision.score_after, "reasonPt": decision.reason_pt,
**({"window": [round(decision.window[0], 2), round(decision.window[1], 2)]} if decision.window else {})}
+79
View File
@@ -212,6 +212,84 @@ SCHEMA = [
""" """
ALTER TABLE clips ADD COLUMN translation_json TEXT; ALTER TABLE clips ADD COLUMN translation_json TEXT;
""", """,
# v14: vídeo de revisão × vídeo final (doc/clipador/REVISAO.md). O render da fila é o de REVISÃO (com as camadas
# `dev` ligadas); ao aprovar, sai o FINAL (`dev=False`) em `clip-<id>-final.mp4`, que é o único que se publica.
# `review_dev_json` = camadas de desenvolvimento que entraram no arquivo de revisão (["translation", ...]; [] =
# nenhuma → o de revisão já é o final; NULL = desconhecido → renderiza o final). `final_status`: pending |
# rendering | ready | error (NULL = sem final: não aprovado, ou a aprovação foi desfeita/editada).
# Cortes de antes da v14: a única camada de desenvolvimento era a tradução, que só entra com `translation_json`;
# sem ela o arquivo já é limpo ([]).
"""
ALTER TABLE clips ADD COLUMN review_dev_json TEXT;
ALTER TABLE clips ADD COLUMN final_status TEXT CHECK (final_status IN ('pending', 'rendering', 'ready', 'error'));
ALTER TABLE clips ADD COLUMN final_file TEXT;
ALTER TABLE clips ADD COLUMN final_thumb TEXT;
ALTER TABLE clips ADD COLUMN final_cover TEXT;
ALTER TABLE clips ADD COLUMN final_error TEXT;
ALTER TABLE clips ADD COLUMN final_at TEXT;
UPDATE clips SET review_dev_json = '[]' WHERE file IS NOT NULL AND translation_json IS NULL;
UPDATE clips SET final_status = 'pending' WHERE status = 'approved' AND review_dev_json IS NULL AND file IS NOT NULL;
UPDATE clips SET final_status = 'ready', final_file = file, final_thumb = thumb, final_at = updated_at
WHERE status IN ('approved', 'published') AND review_dev_json = '[]';
""",
# v15: falantes (doc/clipador/FALANTES.md). Impressões de voz dos trechos de fala de cada bloco (WeSpeaker), com o
# volume; as vozes da sessão são agrupadas sob demanda a partir daqui (speakers.SpeakerService).
"""
CREATE TABLE IF NOT EXISTS voice_chunks (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
data_json TEXT NOT NULL,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
# v16: detecção do jogo (doc/clipador/DETECCAO-JOGO.md). `game_status`: user | agreed | probable | conflict | unknown
# ('' = sessão antiga, ainda não checada). `game_detect_json`: as pistas guardadas (categoria, tela), os candidatos
# com a nota, a sugestão de troca e a contagem de checagens seguidas.
"""
ALTER TABLE sessions ADD COLUMN game_status TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN game_detect_json TEXT;
""",
# v17: Equipe de IA (doc/clipador/EQUIPE-IA.md).
# - `ai_calls`: cada chamada de IA (papel, IA, tamanho do prompt e das imagens, tokens quando a CLI informa, tempo)
# para comparar custo por hora (F0). Sem FK para a sessão: a medição fica depois de apagar a sessão.
# - `scene_notes`: frase curta do que está na tela num instante (escrita pela varredura/analista ao ver os quadros);
# vira o campo `v` da linha do tempo JSON.
# - `clips.owner_label`/`owner_note`: avaliação do dono (bom / ruim / sem contexto) para o conjunto de avaliação.
"""
CREATE TABLE IF NOT EXISTS ai_calls (
id INTEGER PRIMARY KEY AUTOINCREMENT,
at TEXT NOT NULL,
role TEXT NOT NULL,
purpose TEXT NOT NULL,
provider TEXT NOT NULL,
model TEXT NOT NULL,
ok INTEGER NOT NULL,
error TEXT,
ms INTEGER,
system_chars INTEGER,
prompt_chars INTEGER,
images INTEGER,
image_bytes INTEGER,
tokens_in INTEGER,
tokens_out INTEGER,
tokens_cached INTEGER,
session_id INTEGER,
clip_id INTEGER,
mode TEXT
);
CREATE INDEX IF NOT EXISTS ai_calls_at ON ai_calls (at);
CREATE TABLE IF NOT EXISTS scene_notes (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
t REAL NOT NULL,
source TEXT NOT NULL,
text TEXT NOT NULL,
created_at TEXT NOT NULL,
PRIMARY KEY (session_id, t, source)
);
ALTER TABLE clips ADD COLUMN owner_label TEXT CHECK (owner_label IN ('good', 'bad', 'no_context'));
ALTER TABLE clips ADD COLUMN owner_note TEXT;
""",
] ]
@@ -237,6 +315,7 @@ class Database:
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado). # 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 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'") self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
self.run("UPDATE clips SET final_status = 'pending' WHERE final_status = 'rendering'") # vídeo final idem
def _migrate(self) -> None: def _migrate(self) -> None:
version = self.conn.execute("PRAGMA user_version").fetchone()[0] version = self.conn.execute("PRAGMA user_version").fetchone()[0]
+391
View File
@@ -0,0 +1,391 @@
"""Dublagem em português por TTS — camada SÓ de desenvolvimento (doc/clipador/DUBLAGEM.md).
Pedido do dono (18/11/2026): fonte em inglês → "quando ele estiver falando, a gente dubla em português; baixa o áudio
dele, deixa um pouco baixo para escutar o som do carro, do ambiente do jogo". Só entra no vídeo de REVISÃO
(`dev.dub`); o vídeo final, depois de aprovar, sai com o áudio original (`layout.dev_flags(cfg, dev=False)`).
Fluxo: frases traduzidas (`clips.translation_json` → `[{s, e, text, pt, speaker?}]`, tempo da sessão) → tempo de
saída (`editor.to_output`, respeita os trechos removidos) → uma fala TTS por frase pelo serviço de voz local
(`POST /v1/synthesize`, WAV), com cache em disco por (voz, velocidade, texto) → encaixe no tempo (`fit`) → UMA faixa
WAV do trecho renderizado (`Dubber.build`) que o `editor_render` mistura com a voz original abaixada (`duck_factors`).
Voz: TTS PRONTA do catálogo (padrão `pt-br-antonio`, masculina, Edge). Nunca clonar a voz do streamer — é um
terceiro sem consentimento; o projeto só aceita clonagem com consentimento de quem fala.
"""
from __future__ import annotations
import hashlib
import io
import logging
import os
import threading
import time
import uuid
import wave
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass, field
from pathlib import Path
from typing import Callable
import httpx
from . import layout, media
from .editor import to_output
log = logging.getLogger("cenaforge_clipper.dub")
FALLBACK_VOICE = "pt-br-faber" # Piper, offline: quando a voz escolhida (Edge, online) falha
SPEAKER_OTHER = "other" # `lines[].speaker` (FALANTES.md): "streamer" | "other1", "other2"…; ausente = streamer
# Esclarecimento do dono (18/11/2026): NÃO é dublagem de filme — é para a equipe entender o contexto. Nada de
# sincronia labial: cada fala começa perto do início da original, em velocidade natural (inteligível primeiro), e pode
# escorrer depois da fala original. Duas nunca tocam juntas e o atraso não acumula (limite por frase, `MAX_LATE_S`).
TTS_SPEED = 1.05 # quase natural: o português traduzido costuma ser mais longo que o inglês falado
MAX_TEMPO = 1.2 # aceleração máxima (atempo), só quando nem escorrendo cabe; acima disso fica difícil de entender
MAX_LATE_S = 1.5 # quanto uma fala pode começar depois da original (porque a anterior escorreu); nunca acumula
# Frase PARTIDA no meio pela transcrição (a 1ª não termina em . ! ? …), do mesmo falante e colada (vão menor que
# MERGE_GAP_S), vira uma fala só. Juntar frases completas foi medido pior (corte 259: 8,5 s perdidos contra 3,0 s).
MERGE_GAP_S = 0.4
MERGE_MAX_S = 7.0 # …desde que a junção não passe disso (tempo da fala original)
MERGE_MAX_CHARS = 140
SENTENCE_END = (".", "!", "?", "…", ".\"", "?\"", "!\"")
GAP_S = 0.08 # silêncio mínimo entre duas dublagens (nunca duas tocando juntas)
MIN_SLOT_S = 0.45 # espaço menor que isso: a frase não é dublada (não daria para entender)
FADE_S = 0.12 # fade de saída quando a fala precisa ser cortada
RAMP_S = 0.15 # rampa do ducking (desce antes da dublagem começar, sobe depois que ela acaba)
DUCK_HOLD_S = 0.6 # vão entre duas dublagens menor que isso: a voz original continua baixa (sem "bombear")
SAMPLE_RATE = 48000
# Nível da dublagem: cada fala é guardada a −16 LUFS (média ≈ −16,5 dB RMS sem as pausas). No render, ela é posta
# `LEVEL_OVER_ORIGINAL_DB` acima do volume médio do próprio corte (medido no áudio original) — live baixa (medido no
# corte 259 do tfue: −32 dB) não ganha uma voz 14 dB mais alta que ele. Ganho entre `GAIN_RANGE_DB`; limitador no fim.
TTS_LEVEL_DB = -16.5
LEVEL_OVER_ORIGINAL_DB = 6.0
GAIN_RANGE_DB = (-20.0, 3.0)
WORKERS = 3 # sínteses em paralelo (Edge é online; o serviço tem fila por chave)
SYNTH_TIMEOUT_S = 120
CACHE_KEEP_DAYS = 30 # fala do cache sem uso há mais que isso é apagada quando o serviço sobe
class DubError(RuntimeError):
"""Falha ao sintetizar uma frase (serviço fora, voz inexistente…)."""
# ---------------------------------------------------------------- configuração
def options(cfg: dict) -> dict:
"""Vozes e volume da dublagem a partir da configuração efetiva do corte (grupo `dev`)."""
group = {**layout.DEFAULTS["dev"], **(cfg.get("dev") or {})}
return {"voice": group["dubVoice"], "voiceOther": group["dubVoiceOther"] or group["dubVoice"],
"duck": float(group["dubDuck"])}
def voice_for(line: dict, opts: dict) -> str:
"""Voz da frase: qualquer voz que não é o streamer (`other`, `other1`, `other2`…) usa a segunda voz; sem o
campo, a padrão."""
speaker = line.get("speaker")
return opts["voiceOther"] if isinstance(speaker, str) and speaker.startswith(SPEAKER_OTHER) else opts["voice"]
# ---------------------------------------------------------------- plano (contas puras, sem áudio)
@dataclass(frozen=True)
class DubLine:
at: float # início da frase no tempo de SAÍDA (do corte inteiro)
text: str # português
voice: str
speaker: str | None = None
end: float = 0.0 # fim da fala original (tempo de saída); 0 = desconhecido
@dataclass(frozen=True)
class Cue:
"""Uma dublagem posicionada: começa em `at` (tempo de saída), toca `length` s, acelerada por `tempo`."""
at: float
length: float
tempo: float
cut: bool # não coube nem acelerada: termina com fade
index: int # posição em `lines`
def plan_lines(lines: list[dict], cuts: list[dict], opts: dict) -> list[DubLine]:
"""Frases da tradução (tempo da sessão) → frases no tempo de saída, em ordem. Frase sem português, ou que caiu
inteira num trecho removido (nada dela na saída), fica de fora; fala curta ("Okay." de 0,18 s) é dublada.
Frase partida no meio + continuação (mesmo falante, colada) viram uma fala só (ex.: "…deve dar" + "tudo certo.")."""
out: list[DubLine] = []
for line in lines or []:
text = " ".join(str(line.get("pt") or "").split())
if not text:
continue
try:
s, e = float(line["s"]), float(line["e"])
except (KeyError, TypeError, ValueError):
continue
a, _ = to_output(s, cuts)
b, _ = to_output(e, cuts)
if b - a < 0.05:
continue
speaker = line.get("speaker") if isinstance(line.get("speaker"), str) else None
out.append(DubLine(round(a, 3), text, voice_for(line, opts), speaker, round(b, 3)))
out.sort(key=lambda x: x.at)
merged: list[DubLine] = []
for line in out:
prev = merged[-1] if merged else None
if (prev and prev.voice == line.voice and not prev.text.endswith(SENTENCE_END)
and line.at - prev.end < MERGE_GAP_S and line.end - prev.at <= MERGE_MAX_S
and len(prev.text) + len(line.text) < MERGE_MAX_CHARS):
merged[-1] = DubLine(prev.at, f"{prev.text} {line.text}", prev.voice, prev.speaker, max(prev.end, line.end))
else:
merged.append(line)
return merged
def fit(lines: list[DubLine], durations: list[float | None], total: float) -> list[Cue]:
"""Encaixa cada fala no tempo. `durations[i]` = duração natural do TTS da frase i: 0 = a síntese falhou (a frase
some e não limita a anterior); None = não sintetizada neste render (fora do trecho: não toca, mas ainda é o
limite da anterior).
- Começa no início da frase original (ou logo depois da dublagem anterior, se ela escorreu).
- Toca em velocidade natural e pode escorrer até `MAX_LATE_S` depois do começo da próxima frase (que começa
depois dela). O limite é contado de cada frase original: o atraso nunca acumula.
- Só se nem assim couber: acelera até `MAX_TEMPO`; se ainda não couber, corta com fade.
- Nunca duas tocando juntas (`GAP_S` entre elas) e nunca depois do fim do corte."""
cues: list[Cue] = []
cursor = float("-inf")
for i, (line, natural) in enumerate(zip(lines, durations)):
if not natural or natural <= 0:
continue
start = max(line.at, cursor + GAP_S)
nxt = next((lines[j].at for j in range(i + 1, len(lines)) if durations[j] is None or durations[j] > 0), None)
limit = min(total, nxt + MAX_LATE_S - GAP_S) if nxt is not None else total
room = limit - start
if room < MIN_SLOT_S or start >= total:
log.info("dublagem: frase %d sem espaço (%.2f s) — fica sem dublar", i, room)
continue
tempo = 1.0 if natural <= room else min(MAX_TEMPO, natural / room)
length = natural / tempo
cut = length > room + 1e-6
if cut:
length = room
cues.append(Cue(round(start, 3), round(length, 3), round(tempo, 3), cut, i))
cursor = start + length
return cues
def duck_spans(cues: list[Cue], merge_gap: float = DUCK_HOLD_S) -> list[tuple[float, float]]:
"""Intervalos em que a voz original fica baixa (as dublagens, com vãos curtos emendados)."""
spans: list[list[float]] = []
for c in sorted(cues, key=lambda c: c.at):
a, b = c.at, c.at + c.length
if spans and a - spans[-1][1] < merge_gap + 2 * RAMP_S:
spans[-1][1] = max(spans[-1][1], b)
else:
spans.append([a, b])
return [(round(a, 3), round(b, 3)) for a, b in spans]
def duck_factors(spans: list[tuple[float, float]], duck: float, ramp: float = RAMP_S) -> list[str]:
"""Fatores (expressões do FFmpeg em `t`) que multiplicam o volume da voz original: 1 fora das falas dubladas,
`duck` durante, com rampa de `ramp` s antes e depois. Vão no `volume='…':eval=frame` do `editor_render`."""
if duck >= 1 or not spans:
return []
depth, r = 1 - max(0.0, duck), max(0.01, ramp)
return [f"(1-{depth:.3f}*clip(min((t-{a - r:.3f})/{r:.3f},({b + r:.3f}-t)/{r:.3f}),0,1))" for a, b in spans]
# ---------------------------------------------------------------- síntese com cache
def wav_duration(data: bytes) -> float:
with wave.open(io.BytesIO(data)) as w:
return w.getnframes() / float(w.getframerate() or 1)
def voice_synth(url: str | None, key: str | None) -> Callable[[str, str], bytes]:
"""Função (texto, voz) → WAV pelo serviço de voz local (`POST /v1/synthesize`, mesma chave do `VoiceClient`)."""
def synth(text: str, voice: str) -> bytes:
if not (url and key):
raise DubError("serviço de voz não instalado")
try:
response = httpx.post(f"{url}/v1/synthesize", timeout=SYNTH_TIMEOUT_S, headers={"X-Service-Key": key},
json={"requestId": f"clipper-dub-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": voice,
"params": {"speed": TTS_SPEED, "format": "wav"}})
except httpx.HTTPError as exc:
raise DubError(f"serviço de voz fora do ar ({url})") from exc
if response.status_code != 200:
raise DubError(f"voz {voice} respondeu {response.status_code}: {response.text[:160]}")
return response.content
return synth
class TtsCache:
"""Fala TTS por (voz, velocidade, texto) em disco — prévia e render seguintes não sintetizam de novo.
Com FFmpeg, cada fala é guardada já limpa: sem o silêncio do começo/fim (o Edge põe ~0,5 s), volume igualado
(loudnorm −16 LUFS, vozes de motores diferentes ficam parecidas) e 48 kHz mono."""
def __init__(self, folder: Path, synth: Callable[[str, str], bytes], ffmpeg: str | None):
self.folder, self.synth, self.ffmpeg = folder, synth, ffmpeg
self.synth_calls = 0
self._guard = threading.Lock()
self._locks: dict[str, threading.Lock] = {}
def path(self, voice: str, text: str) -> Path:
digest = hashlib.sha256(f"{voice}|{TTS_SPEED:.2f}|{text}".encode("utf-8")).hexdigest()[:24]
return self.folder / f"{digest}.wav"
def get(self, voice: str, text: str) -> tuple[Path, float]:
"""(arquivo, duração em s) da fala; sintetiza só se ainda não estiver no cache."""
out = self.path(voice, text)
with self._guard:
lock = self._locks.setdefault(out.name, threading.Lock())
with lock:
if not out.is_file():
raw = self.synth(text, voice)
with self._guard:
self.synth_calls += 1
self.folder.mkdir(parents=True, exist_ok=True)
tmp = out.with_suffix(".tmp.wav")
if self.ffmpeg:
raw_file = out.with_suffix(".raw.wav")
raw_file.write_bytes(raw)
try:
trim = "silenceremove=start_periods=1:start_threshold=-50dB"
media.run([self.ffmpeg, "-y", "-v", "error", "-i", str(raw_file), "-af",
f"{trim},areverse,{trim},areverse,loudnorm=I=-16:TP=-1.5:LRA=11,aresample={SAMPLE_RATE}",
"-ac", "1", "-c:a", "pcm_s16le", str(tmp)], timeout=60)
finally:
raw_file.unlink(missing_ok=True)
else:
tmp.write_bytes(raw)
tmp.replace(out)
else:
try:
os.utime(out) # "usada agora": a limpeza (`prune`) apaga só o que ninguém usa há tempo
except OSError:
pass
return out, wav_duration(out.read_bytes())
def prune(self, keep_days: float = CACHE_KEEP_DAYS) -> int:
"""Apaga as falas sem uso há mais de `keep_days` dias. Devolve quantas apagou."""
limit = time.time() - keep_days * 86400
removed = 0
for file in self.folder.glob("*.wav") if self.folder.is_dir() else []:
try:
if file.stat().st_mtime < limit:
file.unlink()
removed += 1
except OSError:
continue
return removed
# ---------------------------------------------------------------- faixa do trecho renderizado
def gain_for(level_db: float | None) -> float:
"""Ganho (dB) da faixa de dublagem para o volume médio `level_db` do áudio original (None = sem medida: 0 dB)."""
if level_db is None:
return 0.0
lo, hi = GAIN_RANGE_DB
return round(min(hi, max(lo, level_db + LEVEL_OVER_ORIGINAL_DB - TTS_LEVEL_DB)), 1)
@dataclass
class DubTrack:
file: Path # WAV 48 kHz estéreo, do tamanho do trecho (t1 − t0), começando em t0
spans: list[tuple[float, float]] # ducking, em tempo relativo a t0
duck: float
cues: int
seconds: float # quanto a dublagem custou neste render (síntese + faixa)
synthesized: int # falas sintetizadas agora (o resto veio do cache)
failed: list[str] = field(default_factory=list)
class Dubber:
def __init__(self, cache: TtsCache, ffmpeg: str | None):
self.cache, self.ffmpeg = cache, ffmpeg
def _speech(self, line: DubLine) -> tuple[Path, float] | None:
try:
return self.cache.get(line.voice, line.text)
except (DubError, media.MediaError, OSError, wave.Error, EOFError) as exc:
if line.voice != FALLBACK_VOICE and not str(exc).startswith("serviço de voz"):
log.warning("dublagem: voz %s falhou (%s); tentando %s", line.voice, exc, FALLBACK_VOICE)
try:
return self.cache.get(FALLBACK_VOICE, line.text)
except (DubError, media.MediaError, OSError, wave.Error, EOFError) as exc2:
exc = exc2
log.warning("dublagem: frase sem áudio (%s)", exc)
return None
def build(self, translation: list[dict], cuts: list[dict], cfg: dict, t0: float, t1: float, work: Path,
stem: str, level_db: float | None = None) -> DubTrack | None:
"""Faixa da dublagem da saída [t0, t1]. Só sintetiza as frases que tocam nesse trecho (prévia de 5 s não
sintetiza o corte inteiro). `level_db` = volume médio do áudio original do corte (nivela a dublagem; ver
`gain_for`). None = nada para dublar (ou serviço de voz fora)."""
if not self.ffmpeg:
return None
started = time.monotonic()
before = self.cache.synth_calls
opts = options(cfg)
lines = plan_lines(translation, cuts, opts)
if not lines:
return None
total = round(sum(c["end"] - c["start"] for c in cuts), 3)
# Frases que podem tocar em [t0, t1]: começam antes de t1 e a próxima (+ atraso máximo) passa de t0.
wanted = [i for i, ln in enumerate(lines)
if ln.at < t1 and (lines[i + 1].at + MAX_LATE_S if i + 1 < len(lines) else total) > t0]
if wanted and wanted[0] > 0: # a anterior decide se a 1ª atrasa: entra na conta (não na faixa)
wanted.insert(0, wanted[0] - 1)
speech: dict[int, tuple[Path, float] | None] = {}
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
for i, result in zip(wanted, pool.map(lambda i: self._speech(lines[i]), wanted)):
speech[i] = result
failed = [lines[i].text for i in wanted if speech.get(i) is None]
if wanted and len(failed) == len(wanted):
log.warning("dublagem: nenhuma fala sintetizada (%d frases) — vídeo sai sem dublagem", len(wanted))
return None
durations = [(speech[i][1] if speech[i] else 0.0) if i in speech else None for i in range(len(lines))]
# Fora de `wanted` a duração não é conhecida (None): a frase vizinha usa o começo dela (`at`) como limite, que
# é o que importa; essas frases não entram na faixa.
cues = [c for c in fit(lines, durations, total) if c.at < t1 and c.at + c.length > t0]
if not cues:
return None
out = work / f"{stem}.dub.wav"
self._mix(cues, [speech[c.index][0] for c in cues], t0, t1, out, gain_for(level_db)) # type: ignore[index]
spans = [(round(a - t0, 3), round(b - t0, 3)) for a, b in duck_spans(cues)]
return DubTrack(out, spans, opts["duck"], len(cues), round(time.monotonic() - started, 2),
self.cache.synth_calls - before, failed)
def _mix(self, cues: list[Cue], files: list[Path], t0: float, t1: float, out: Path, gain_db: float = 0.0) -> None:
"""Uma faixa só (48 kHz estéreo, `t1 − t0` s): cada fala acelerada/cortada e posta no lugar, com `gain_db`."""
length = t1 - t0
args: list[str] = [self.ffmpeg or "ffmpeg", "-y", "-v", "error"]
graph = [f"aevalsrc=0:s={SAMPLE_RATE}:d={length:.3f}[base]"]
for k, (cue, file) in enumerate(zip(cues, files)):
args += ["-i", str(file)]
chain = f"[{k}:a]aformat=sample_rates={SAMPLE_RATE}:channel_layouts=mono"
if cue.tempo > 1.001:
chain += f",atempo={cue.tempo:.3f}"
chain += f",atrim=end={cue.length:.3f}"
if cue.cut:
chain += f",afade=t=out:st={max(0.0, cue.length - FADE_S):.3f}:d={FADE_S:.3f}"
skip = t0 - cue.at
if skip > 0: # prévia que começa no meio desta fala
chain += f",atrim=start={skip:.3f}"
chain += f",asetpts=PTS-STARTPTS,adelay=delays={int(round(max(0.0, -skip) * 1000))}:all=1[d{k}]"
graph.append(chain)
graph.append("[base]" + "".join(f"[d{k}]" for k in range(len(cues)))
+ f"amix=inputs={len(cues) + 1}:duration=first:normalize=0,volume={gain_db:.1f}dB,"
f"alimiter=limit=0.9:level=0,aformat=channel_layouts=stereo[out]")
out.parent.mkdir(parents=True, exist_ok=True)
media.run([*args, "-filter_complex", ";".join(graph), "-map", "[out]", "-c:a", "pcm_s16le", "-t", f"{length:.3f}",
str(out)], timeout=120)
def for_engine(engine) -> Dubber:
"""Dublador do motor (um por processo, criado na 1ª vez): cache em `data/clipper/dub/`, voz pelo serviço local."""
dubber = getattr(engine, "_dubber", None)
if dubber is None:
settings = engine.settings
voice = getattr(engine, "voice", None)
synth = voice_synth(getattr(voice, "url", None) or settings.voice_url, getattr(voice, "key", None) or settings.voice_key)
cache = TtsCache(settings.data_dir / "dub", synth, settings.ffmpeg)
if cache.prune():
log.info("dublagem: cache limpo (falas sem uso há %d dias)", CACHE_KEEP_DAYS)
dubber = Dubber(cache, settings.ffmpeg)
engine._dubber = dubber
return dubber
+17 -2
View File
@@ -148,11 +148,22 @@ def output_words(project: dict) -> list[Word]:
if p.start <= mid <= p.end: if p.start <= mid <= p.end:
s = p.out + max(w["s"], p.start) - p.start s = p.out + max(w["s"], p.start) - p.start
e = p.out + min(w["e"], p.end) - 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"])) out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"], w.get("sp") or ""))
break break
return out return out
def word_item(w: Word) -> dict:
"""Palavra da sessão → palavra do projeto. `sp` (quem fala; doc/clipador/FALANTES.md) só quando atribuído."""
item = {"s": w.start, "e": w.end, "w": w.word}
if w.speaker:
item["sp"] = w.speaker
return item
SPEAKER_RE = re.compile(r"^(streamer|other\d{0,2})$")
def emphasized(project: dict) -> set[tuple[float, str]]: 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")} return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
@@ -194,7 +205,7 @@ def default_project(clip: dict, words: list[Word], session_duration: float) -> d
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}], "cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
"captions": { "captions": {
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "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], "words": [word_item(w) 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, "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 []), "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
@@ -440,6 +451,10 @@ def validate_project(data: dict, *, session_id: int, session_duration: float, re
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms 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) e = round(s + 0.05, 3)
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)} item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
if w.get("sp"):
if not isinstance(w["sp"], str) or not SPEAKER_RE.match(w["sp"]):
raise EditError(f"palavra {i}: falante (sp) precisa ser streamer ou otherN")
item["sp"] = w["sp"]
if w.get("emph"): if w.get("emph"):
item["emph"] = True item["emph"] = True
if w.get("hidden"): if w.get("hidden"):
+51 -21
View File
@@ -21,7 +21,7 @@ from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field from pydantic import BaseModel, Field
from . import editor, editor_render, layout, media from . import dub, editor, editor_render, layout, media, speakers
from .config import REPO_ROOT from .config import REPO_ROOT
from .db import loads, now from .db import loads, now
from .judge import JudgeError, _chat_block, _transcript from .judge import JudgeError, _chat_block, _transcript
@@ -93,8 +93,10 @@ def load_edit(engine, clip_id: int) -> dict | None:
return row return row
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None: def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path, dev: bool = True) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None).""" """Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None).
`dev=True` = vídeo de REVISÃO (com as camadas `dev` ligadas; grava quais entraram em `clips.review_dev_json`);
`dev=False` = vídeo FINAL, depois de aprovar (sem nenhuma camada de desenvolvimento) — doc/clipador/REVISAO.md."""
project = validate_for(engine, clip, session, edit["project"]) project = validate_for(engine, clip, session, edit["project"])
segments = session_segments(engine, clip["session_id"]) segments = session_segments(engine, clip["session_id"])
if engine._encoder is None: if engine._encoder is None:
@@ -111,9 +113,13 @@ def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, t
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela 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) log.warning("capa do corte %s falhou: %s", clip["id"], exc)
cover = None cover = None
translation = translation_for(engine, clip, project, base, dev=dev)
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out, 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, REPO_ROOT, chat=chat_for(engine, project), cover_file=cover,
translation=translation_for(engine, clip, project, base)) translation=translation, dev=dev, dubber=dub.for_engine(engine))
if dev:
layers = review_layers(editor.effective_settings(base, project), translation)
engine.db.run("UPDATE clips SET review_dev_json = ? WHERE id = ?", json.dumps(layers), clip["id"])
total = editor.output_duration(project["cuts"]) total = editor.output_duration(project["cuts"])
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb) 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. # Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
@@ -121,11 +127,24 @@ def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, t
return cover.relative_to(REPO_ROOT).as_posix() if cover else None return cover.relative_to(REPO_ROOT).as_posix() if cover else None
def review_layers(cfg: dict, translation: list[dict] | None) -> list[str]:
"""Camadas de desenvolvimento que entraram no vídeo de revisão (vazio = ele já é o vídeo final). A tradução só
conta se havia frases para desenhar (fonte em português nunca tem); as outras chaves do grupo `dev` (dublagem…)
contam pela configuração, por cautela: na dúvida, o final é renderizado de novo. A dublagem sai das mesmas frases
traduzidas (DUBLAGEM.md): sem frase, também não houve dublagem."""
flags = dict(layout.dev_flags(cfg, True))
if not translation:
flags["translation"] = flags["dub"] = False
return sorted(k for k, on in flags.items() if on)
def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None: def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None:
"""Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md): só com `dev.translation` """Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md) e a dublagem
ligado, render de desenvolvimento e fonte em inglês. Traduz o trecho do projeto se ainda não houver tradução.""" (doc/clipador/DUBLAGEM.md): só com `dev.translation` ou `dev.dub` ligado, render de desenvolvimento e fonte em
inglês. Traduz o trecho do projeto se ainda não houver tradução."""
cfg = editor.effective_settings(base, project) cfg = editor.effective_settings(base, project)
if not layout.dev_flags(cfg, dev)["translation"]: flags = layout.dev_flags(cfg, dev)
if not (flags["translation"] or flags["dub"]):
return None return None
ps = editor.pieces(project["cuts"]) ps = editor.pieces(project["cuts"])
if not ps: if not ps:
@@ -151,11 +170,20 @@ 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).""" """Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
judge = _judge(clip) judge = _judge(clip)
lo, hi = editor.default_window(clip, session["duration_s"]) 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", words = engine.words_between(clip["session_id"], lo, hi) # já com quem fala cada palavra (FALANTES.md)
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"] 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"], analysis = judge.get("analysis")
context = judge.get("context") if isinstance(judge.get("context"), dict) else {}
if context.get("decision") in ("approve", "adjust", "warn") and (context.get("contextLine") or context.get("window")):
analysis = dict(analysis or {})
# Juiz de contexto (EQUIPE-IA.md): a frase de contexto vira o texto do começo do corte (no lugar do gancho)…
if context.get("contextLine"):
analysis["hook"] = context["contextLine"]
# …e, se ele ajustou o trecho, o início/fim do analista não desfaz o ajuste (ex.: recuou para pegar o começo).
if context.get("window"):
analysis.pop("action_start_s", None)
analysis.pop("reaction_end_s", None)
return editor.auto_project(clip, analysis, words, loudness, session["duration_s"],
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now()) engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
@@ -240,9 +268,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
return round(lo, 3), round(hi, 3) return round(lo, 3), round(hi, 3)
def _words(session_id: int, lo: float, hi: float) -> list[Word]: 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", return [w for w in engine.words_between(session_id, lo, hi) if lo <= w.start <= hi]
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: 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" f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
@@ -282,7 +308,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
"origin": row["origin"] if row else "ai", "aiProject": ai_project, "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, "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"], "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)], "words": [editor.word_item(w) for w in _words(clip["session_id"], w_lo, w_hi)],
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis, "chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session), "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], "presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
@@ -333,8 +359,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name) 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) 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) _clean_old(folder, "proxy", name)
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word} return _cached_proxy(clip, lo, hi) | {"words": [editor.word_item(w) for w in _words(clip["session_id"], lo, hi)]}
for w in _words(clip["session_id"], lo, hi)]}
@app.get("/v1/clips/{clip_id}/waveform") @app.get("/v1/clips/{clip_id}/waveform")
def get_waveform(clip_id: int, lo: float, hi: float): def get_waveform(clip_id: int, lo: float, hi: float):
@@ -380,7 +405,8 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"], editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
segments, project, base, credit, out, REPO_ROOT, segments, project, base, credit, out, REPO_ROOT,
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover, out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover,
translation=translation_for(engine, clip, project, base)) translation=translation_for(engine, clip, project, base),
dubber=dub.for_engine(engine))
took = time.monotonic() - t took = time.monotonic() - t
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()} return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
@@ -401,6 +427,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?", 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) 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) db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
engine.drop_final(clip_id) # editou: o final antigo deixa de valer; volta a ser revisão (aprovar de novo)
engine.wake_clips.set() engine.wake_clips.set()
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])} return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
@@ -420,8 +447,11 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}") 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 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 raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
# Quem fala: o mesmo das palavras antigas no mesmo instante (a re-transcrição não sabe o falante).
fresh = speakers.transfer([Word(round(w.start + a, 3), round(w.end + a, 3), w.word) for w in words],
_words(clip["session_id"], a - 1, b + 1))
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1), 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]} "words": [editor.word_item(w) for w in fresh]}
@app.post("/v1/clips/{clip_id}/tts") @app.post("/v1/clips/{clip_id}/tts")
def tts(clip_id: int, body: TtsIn): def tts(clip_id: int, body: TtsIn):
@@ -464,12 +494,12 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
project = validate_for(engine, clip, session, data) project = validate_for(engine, clip, session, data)
lo, hi = project["source"]["lo"], project["source"]["hi"] lo, hi = project["source"]["lo"], project["source"]["hi"]
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5)) 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"] words = [Word(w["s"], w["e"], w["w"], w.get("sp") or "") for w in project["captions"]["words"]] or tl["words"]
view = clip_view(clip) view = clip_view(clip)
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
cfg = editor.effective_settings(engine.intel.settings_for(session), project) cfg = editor.effective_settings(engine.intel.settings_for(session), project)
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis, 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) _transcript(words, lo, hi, streamer=engine.streamer_name(session)), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
t = time.monotonic() t = time.monotonic()
try: try:
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, []) raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
+134 -37
View File
@@ -9,15 +9,21 @@ só entram números formatados aqui e nomes de arquivo relativos gerados por nó
from __future__ import annotations from __future__ import annotations
import logging
import re
import shutil import shutil
import subprocess
from array import array from array import array
from pathlib import Path from pathlib import Path
from . import layout, media, reframe from . import dub, layout, media, reframe
from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output
from .scoring import Word from .scoring import Word
from .subtitles import _escape, _ts, caption_blocks, clean_words from .speakers import is_other
from .subtitles import (OTHER_LANE, STREAMER_LANE, _escape, _ts, caption_blocks, clean_words, has_other, lane,
other_color, other_offset, other_size, other_y)
log = logging.getLogger("cenaforge_clipper.editor_render")
W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração
FPS = 30 FPS = 30
PEAKS_PER_S = 50 PEAKS_PER_S = 50
@@ -79,10 +85,12 @@ def banner_layout(o: dict, canvas: tuple[int, int]) -> dict:
def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: int, def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: int,
total: float) -> list[tuple[float, float, int]]: total: float, below: int = 0) -> list[tuple[float, float, int]]:
"""Onde a legenda vai enquanto cada gancho está na tela, se ele a cobriria: [(início, fim, y do centro)]. """Onde a legenda vai enquanto cada gancho está na tela, se ele a cobriria: [(início, fim, y do centro)].
Com a câmera em cima, o gancho fica logo abaixo dela (layout.hook_y) — o mesmo lugar da legenda automática Com a câmera em cima, o gancho fica logo abaixo dela (layout.hook_y) — o mesmo lugar da legenda automática
(emenda câmera/jogo). Nesses segundos a legenda desce para logo abaixo do gancho; depois volta ao lugar.""" (emenda câmera/jogo). Nesses segundos a legenda desce para logo abaixo do gancho; depois volta ao lugar.
`below` = quanto a legenda ocupa ABAIXO do centro além do próprio tamanho (a linha de outra pessoa,
doc/clipador/FALANTES.md): as duas linhas desviam juntas. 0 = só a linha do streamer (como antes)."""
_, ch = canvas _, ch = canvas
out = [] out = []
for o in project["overlays"]: for o in project["overlays"]:
@@ -94,10 +102,11 @@ def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: in
else: else:
cy, half = int(ch * o["y"]), int(o["size"] * 0.9) cy, half = int(ch * o["y"]), int(o["size"] * 0.9)
top, bottom = cy - half, cy + half top, bottom = cy - half, cy + half
if cap_y + cap_size <= top or cap_y - cap_size >= bottom: reach = max(cap_size, below) # até onde a legenda (com a linha de baixo) desce a partir do centro
if cap_y + reach <= top or cap_y - cap_size >= bottom:
continue # não se encostam continue # não se encostam
below = bottom + cap_size + 12 under = bottom + cap_size + 12
y = below if below + cap_size <= ch else max(cap_size, top - cap_size - 12) y = under if under + reach <= ch else max(cap_size, top - reach - 12)
out.append((float(o["start"]), float(min(o["end"], total)), y)) out.append((float(o["start"]), float(min(o["end"], total)), y))
return out return out
@@ -220,6 +229,17 @@ def build_project_ass(project: dict, cfg: dict, credit: str, t0: float = 0.0, t1
tsize = max(30, int(size * 0.5)) tsize = max(30, int(size * 0.5))
trans_style = (f"Style: Trans,Arial,{tsize},&H00FFE79B,&H00FFE79B,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1," trans_style = (f"Style: Trans,Arial,{tsize},&H00FFE79B,&H00FFE79B,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{max(3, ow // 2)},2,8,60,60,0,1\n") if flags["translation"] and translation else "" f"{max(3, ow // 2)},2,8,60,60,0,1\n") if flags["translation"] and translation else ""
# Fala de outra pessoa (doc/clipador/FALANTES.md): faixa própria, logo abaixo, noutra cor e tamanho. Os estilos
# só entram quando o corte tem outra pessoa: o ASS de um corte só com o streamer fica idêntico ao de antes.
spoken = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end))
two = bool(cap["enabled"]) and has_other(spoken)
osize = other_size(cap)
other_c = layout.ass_color(other_color(cap))
oow = max(2, int(ow) * osize // max(1, int(size))) if ow else 0
other_styles = (f"Style: CaptionOther,{font},{osize},{other_c},{other_c},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{oow},3,5,60,60,0,1\n"
f"Style: KaraokeOther,{font},{osize},{high},{other_c},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{oow},3,5,60,60,0,1\n") if two else ""
header = f"""[Script Info] header = f"""[Script Info]
ScriptType: v4.00+ ScriptType: v4.00+
PlayResX: {cw} PlayResX: {cw}
@@ -231,7 +251,7 @@ ScaledBorderAndShadow: yes
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding 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: 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: 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 {other_styles}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: 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: 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: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1
@@ -255,35 +275,61 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
emph = emphasized(project) emph = emphasized(project)
emph_c = layout.ass_inline_color(project["captions"]["emphColor"]) 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"]) 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)})" oth_c = layout.ass_inline_color(other_color(cap))
dodges = hook_dodges(project, (cw, ch), layout.caption_y(cfg), int(cap["size"]), total) cap_y = layout.caption_y(cfg)
pos = f"\\pos({cw // 2},{cap_y})"
trans_on = bool(flags["translation"] and translation)
# Linha de outra pessoa logo abaixo da do streamer. Com a tradução de desenvolvimento ligada, a tradução do
# streamer (até 2 linhas) fica ENTRE as duas e a de outra pessoa, embaixo da linha dela.
offset = other_offset(int(size), osize, int(2.4 * tsize) + 6 if trans_on else 0)
# O gancho desvia as duas linhas juntas (a de baixo conta na altura ocupada).
below = offset + int(0.6 * osize) + (int(2.4 * tsize) if trans_on else 0) if two else 0
# Sem espaço embaixo para a linha de outra pessoa (horizontal: a legenda já fica a 85 % da altura), a do
# streamer SOBE o necessário: a ordem nunca inverte (streamer em cima, outra pessoa embaixo).
if two:
cap_y = min(cap_y, ch - 8 - below)
pos = f"\\pos({cw // 2},{cap_y})"
dodges = hook_dodges(project, (cw, ch), cap_y, int(cap["size"]), total, below=below)
def y_at(t: float) -> int: def y_at(t: float) -> int:
"""Altura (centro) da legenda no instante t (saída): desviada enquanto um gancho a cobriria.""" """Altura (centro) da legenda do streamer no instante t (saída): desviada enquanto um gancho a cobriria."""
for s, e, y in dodges: for s, e, y in dodges:
if s <= t < e: if s <= t < e:
return y return y
return layout.caption_y(cfg) return cap_y
def at(t: float) -> str: def oy_at(t: float) -> int:
"""Posição da legenda no instante t (saída).""" """Altura (centro) da linha de outra pessoa no instante t (saída)."""
return other_y(y_at(t), offset, osize, ch)
def at(t: float, other: bool = False) -> str:
"""Posição da legenda no instante t (saída). `\\pos` fixo: o libass não empilha as duas linhas."""
if other:
return f"\\pos({cw // 2},{oy_at(t)})"
y = y_at(t) y = y_at(t)
return pos if y == layout.caption_y(cfg) else f"\\pos({cw // 2},{y})" return pos if y == cap_y else f"\\pos({cw // 2},{y})"
# Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos # Ê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 # ORIGINAIS. Depois as palavras são saneadas POR FAIXA (ordem, sem sobreposição, duração mínima) —
# a mesma quantidade, na mesma ordem — e os blocos abaixo nunca ficam dois na tela ao mesmo tempo. # `clean_words` devolve a mesma quantidade, na mesma ordem — e os blocos de uma faixa nunca ficam dois na
raw = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end)) # tela ao mesmo tempo (as duas faixas, sim: cada uma na sua linha).
raw = spoken
raw_emph = _match_emphasis(raw, project, emph) raw_emph = _match_emphasis(raw, project, emph)
words = clean_words(raw) words: list[Word] = list(raw)
for name in (STREAMER_LANE, OTHER_LANE):
idxs = [i for i, w in enumerate(raw) if lane(w.speaker) == name]
for i, w in zip(idxs, clean_words([raw[i] for i in idxs])):
words[i] = w
def txt(w: Word) -> str: def txt(w: Word) -> str:
return _escape(w.word.upper() if cap["uppercase"] else w.word) return _escape(w.word.upper() if cap["uppercase"] else w.word)
def key(w: Word) -> tuple[float, str]: def key(w: Word) -> tuple[float, str, str]:
return round(w.start, 3), w.word # depois de clean_words, cada início é único return round(w.start, 3), w.word, lane(w.speaker) # depois de clean_words, cada início é único na faixa
emph_keys = {key(words[i]) for i in raw_emph} emph_keys = {key(words[i]) for i in raw_emph}
for group, g_end in caption_blocks(words, cap["maxWords"]): for group, g_end in caption_blocks(words, cap["maxWords"]):
other = lane(group[0].speaker) == OTHER_LANE
base_g = oth_c if other else base_c
if preset == "karaoke": if preset == "karaoke":
parts, cursor = [], group[0].start parts, cursor = [], group[0].start
for w in group: for w in group:
@@ -292,39 +338,45 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
color = f"\\1c{emph_c}" if key(w) in emph_keys else "" 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)}") parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}")
cursor = w.end cursor = w.end
event(0, group[0].start, g_end, "Karaoke", f"{{{at(group[0].start)}}}" + " ".join(parts)) event(0, group[0].start, g_end, "KaraokeOther" if other else "Karaoke",
f"{{{at(group[0].start, other)}}}" + " ".join(parts))
continue continue
style = "CaptionOther" if other else "Caption"
for i, word in enumerate(group): for i, word in enumerate(group):
start = word.start start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start: if end <= start:
continue continue
if preset == "single": if preset == "single":
color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_c) color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_g)
event(0, start, end, "Caption", f"{{{at(start)}{_anim('pop')}\\c{color}}}{txt(word)}") event(0, start, end, style, f"{{{at(start, other)}{_anim('pop')}\\c{color}}}{txt(word)}")
continue continue
parts = [] parts = []
for j, w in enumerate(group): for j, w in enumerate(group):
is_emph = key(w) in emph_keys is_emph = key(w) in emph_keys
if preset == "minimal": if preset == "minimal":
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w)) parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_g}}}" if is_emph else txt(w))
elif j == i: elif j == i:
color = emph_c if is_emph else hi_c color = emph_c if is_emph else hi_c
pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else "" 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}}") parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_g}\\fscx100\\fscy100}}")
else: else:
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w)) parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_g}}}" if is_emph else txt(w))
intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else "" intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else ""
event(0, start, end, "Caption", f"{{{at(start)}{intro}}}" + " ".join(parts)) event(0, start, end, style, f"{{{at(start, other)}{intro}}}" + " ".join(parts))
if flags["translation"] and translation: if trans_on:
# Só para desenvolver (doc/clipador/IDIOMAS.md): a frase traduzida em português, menor e em azul claro, # Só para desenvolver (doc/clipador/IDIOMAS.md): a frase traduzida em português, menor e em azul claro,
# logo embaixo da legenda em inglês (\\an8 = cresce para baixo; \\q0 = quebra a linha se for longa). # logo embaixo da legenda de QUEM FALA (`speaker` da linha; sem ele, o streamer) — \\an8 = cresce para
for line in translation: # baixo; \\q0 = quebra a linha se for longa.
for line in translation or []:
a, _ = to_output(float(line["s"]), project["cuts"]) a, _ = to_output(float(line["s"]), project["cuts"])
b, _ = to_output(float(line["e"]), project["cuts"]) b, _ = to_output(float(line["e"]), project["cuts"])
if b - a < 0.2 or not str(line.get("pt") or "").strip(): if b - a < 0.2 or not str(line.get("pt") or "").strip():
continue continue
if two and is_other(line.get("speaker")):
y = oy_at(a) + int(osize * 0.62)
else:
y = y_at(a) + int(size * 0.62) y = y_at(a) + int(size * 0.62)
event(0, a, b, "Trans", f"{{\\an8\\pos({cw // 2},{y})\\q0}}{_escape(str(line['pt']))}") event(0, a, b, "Trans", f"{{\\an8\\pos({cw // 2},{y})\\q0}}{_escape(str(line['pt']))}")
@@ -416,12 +468,14 @@ def zoom_filter(project: dict, t0: float = 0.0, size: tuple[int, int] = (W, H))
class AudioInput: class AudioInput:
"""Entrada de áudio extra (narração, música, efeito): arquivo + onde entra (tempo de saída) + volume.""" """Entrada de áudio extra (narração, música, efeito, dublagem): arquivo + onde entra (tempo de saída) + volume.
`spans` (só `dub`) = intervalos em que a voz original abaixa para `duck`, com rampa (`dub.duck_factors`)."""
def __init__(self, file: Path, at: float, volume: float, kind: str, trim_start: float = 0.0, duck: float = 1.0, def __init__(self, file: Path, at: float, volume: float, kind: str, trim_start: float = 0.0, duck: float = 1.0,
length: float = 0.0): length: float = 0.0, spans: list[tuple[float, float]] | None = None):
self.file, self.at, self.volume, self.kind = file, at, volume, kind self.file, self.at, self.volume, self.kind = file, at, volume, kind
self.trim_start, self.duck, self.length = trim_start, duck, length self.trim_start, self.duck, self.length = trim_start, duck, length
self.spans = spans or []
COVER_INTRO_S = 2 / FPS # capa nos 2 primeiros quadros (as redes usam o quadro 0 como miniatura padrão) COVER_INTRO_S = 2 / FPS # capa nos 2 primeiros quadros (as redes usam o quadro 0 como miniatura padrão)
@@ -477,13 +531,17 @@ def build_filter(project: dict, cfg: dict, ps: list[Piece], in0: float, ass_name
g.append(f"[{cover_input}:v]scale={fw}:{fh},setsar=1,format=yuv420p[cv]") 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]") 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. # Áudio: original (com volume e abaixado sob a narração/dublagem) + narração + dublagem + efeitos; música por
# baixo com ducking. A dublagem (camada de desenvolvimento) abaixa o original com rampa só onde ela fala.
narr = [(k, x) for k, x in enumerate(extras, start=1) if x.kind == "narration"] narr = [(k, x) for k, x in enumerate(extras, start=1) if x.kind == "narration"]
vol_expr = f"{original_volume:.3f}" vol_expr = f"{original_volume:.3f}"
for _, x in narr: for _, x in narr:
end = x.at + (x.length or 0) end = x.at + (x.length or 0)
if x.duck < 1 and x.length: if x.duck < 1 and x.length:
vol_expr = f"{vol_expr}*if(between(t,{x.at:.3f},{end:.3f}),{x.duck:.3f},1)" vol_expr = f"{vol_expr}*if(between(t,{x.at:.3f},{end:.3f}),{x.duck:.3f},1)"
for x in extras:
if x.kind == "dub":
vol_expr = "*".join([vol_expr, *dub.duck_factors(x.spans, x.duck)])
g.append(f"[acat]volume='{vol_expr}':eval=frame[aorig]") g.append(f"[acat]volume='{vol_expr}':eval=frame[aorig]")
voice_labels = ["[aorig]"] voice_labels = ["[aorig]"]
music_label = None music_label = None
@@ -608,13 +666,33 @@ def has_audio_stream(ffprobe: str | None, file: Path) -> bool:
return bool(out.strip()) return bool(out.strip())
def mean_volume(ffmpeg: str, segs: list[tuple[Path, float, float]], start: float, end: float, work: Path,
stem: str) -> float | None:
"""Volume médio (dB RMS, `volumedetect`) do áudio original de [start, end] da sessão; None se não der para medir.
Só o áudio é decodificado (~0,1 s num corte de 1 min)."""
if not segs:
return None
args, concat = _concat_input(work, f"{stem}.level", segs, start, end - start)
try:
result = subprocess.run([ffmpeg, "-v", "info", "-nostats", *args, "-vn", "-af", "volumedetect", "-f", "null", "-"],
capture_output=True, timeout=120, cwd=work, creationflags=media.NO_WINDOW)
except (OSError, subprocess.TimeoutExpired):
return None
finally:
concat.unlink(missing_ok=True)
match = re.search(rb"mean_volume:\s*(-?[\d.]+) dB", result.stderr)
return float(match.group(1)) if match and result.returncode == 0 else None
def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segments: list[tuple[Path, float, float]], 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, 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, out_range: tuple[float, float] | None = None, timeout: float = 900, chat: list | None = None,
cover_file: Path | None = None, translation: list[dict] | None = None, dev: bool = True) -> None: cover_file: Path | None = None, translation: list[dict] | None = None, dev: bool = True,
dubber: "dub.Dubber | None" = None) -> dict:
"""Renderiza o projeto (ou só a saída [a, b] para a prévia real). `segments` = (arquivo, início, fim) da sessão. """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 `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`).""" quadros quando o projeto pede (`cover.atStart`). `dubber` = dublagem em português (`dev.dub`, só com `dev=True`
e `translation`; app/dub.py). Devolve um resumo (`{"dub": {...} | None}`) — quem chama pode ignorar."""
cfg = effective_settings(base_cfg, project) cfg = effective_settings(base_cfg, project)
total = output_duration(project["cuts"]) total = output_duration(project["cuts"])
t0, t1 = out_range if out_range else (0.0, total) t0, t1 = out_range if out_range else (0.0, total)
@@ -649,6 +727,21 @@ def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segment
if music: if music:
extras.append(AudioInput(repo_root / music["file"], 0.0, music["volume"], "music", trim_start=t0, extras.append(AudioInput(repo_root / music["file"], 0.0, music["volume"], "music", trim_start=t0,
duck=0.5 if music["duck"] else 1.0)) duck=0.5 if music["duck"] else 1.0))
dub_track: dub.DubTrack | None = None
if dubber is not None and translation and layout.dev_flags(cfg, dev)["dub"]:
try:
# Volume do original no corte INTEIRO (a prévia de 5 s nivela igual ao render da fila).
full = pieces(project["cuts"])
level = mean_volume(ffmpeg, _segments_for(segments, full[0].start, full[-1].end), full[0].start,
full[-1].end, work, stem)
dub_track = dubber.build(translation, project["cuts"], cfg, t0, t1, work, stem, level_db=level)
except (media.MediaError, OSError) as exc: # camada de teste: o vídeo sai mesmo sem ela
log.warning("dublagem falhou (%s): o vídeo sai sem dublagem", exc)
if dub_track:
extras.append(AudioInput(dub_track.file, 0.0, 1.0, "dub", duck=dub_track.duck, length=t1 - t0,
spans=dub_track.spans))
log.info("dublagem: %d falas, %d sintetizadas agora, %.1f s", dub_track.cues, dub_track.synthesized,
dub_track.seconds)
extra_args: list[str] = [] extra_args: list[str] = []
for x in extras: for x in extras:
extra_args += (["-stream_loop", "-1"] if x.kind == "music" else []) + ["-i", str(x.file)] extra_args += (["-stream_loop", "-1"] if x.kind == "music" else []) + ["-i", str(x.file)]
@@ -689,8 +782,12 @@ def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segment
"-t", f"{t1 - t0:.3f}", "-movflags", "+faststart", tmp.name], timeout=timeout, cwd=work) "-t", f"{t1 - t0:.3f}", "-movflags", "+faststart", tmp.name], timeout=timeout, cwd=work)
tmp.replace(out_file) tmp.replace(out_file)
finally: finally:
for f in (ass_file, concat, tmp, graph_file, *helper_files, *([uniform] if uniform else [])): for f in (ass_file, concat, tmp, graph_file, *helper_files, *([uniform] if uniform else []),
*([dub_track.file] if dub_track else [])):
f.unlink(missing_ok=True) f.unlink(missing_ok=True)
return {"dub": None if dub_track is None else {
"cues": dub_track.cues, "synthesized": dub_track.synthesized, "seconds": dub_track.seconds,
"failed": len(dub_track.failed)}}
def make_proxy(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, out_file: Path) -> None: def make_proxy(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, out_file: Path) -> None:
+153 -11
View File
@@ -167,16 +167,32 @@ class YuNetDetector:
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces] return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
def pose_from_matrix(m: Any) -> tuple[float, float, float]:
"""(yaw, pitch, roll) em graus da matriz 4×4 de transformação facial do MediaPipe (linhas × colunas).
Conferido em quadros reais (sessão 8): pitch DIMINUI quando a cabeça vai para trás (bebendo de lata: −25° contra
~+12° do normal, que olha um pouco para baixo); yaw ±50° = rosto virado de lado; roll ±45° = cabeça deitada.
"""
pitch = math.degrees(math.atan2(float(m[2][1]), float(m[2][2])))
yaw = math.degrees(math.atan2(-float(m[2][0]), math.hypot(float(m[2][1]), float(m[2][2]))))
roll = math.degrees(math.atan2(float(m[1][0]), float(m[0][0])))
return yaw, pitch, roll
class MediaPipeTracker: class MediaPipeTracker:
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco. """MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes + matriz de pose. Um por bloco.
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os 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. submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
`detector` (YuNet, opcional): quando o MediaPipe não acha o rosto — streamer de perfil olhando o monitor do lado
(sessão 15, tfue: rosto em só 10 % dos quadros, YuNet em 100 %) —, a caixa da cabeça vira `FaceSample(head=True)`:
sem expressão, mas com posição e tamanho para o corpo (agitação, chegar perto, sair do quadro).
""" """
name = "mediapipe" name = "mediapipe"
def __init__(self, model_path: Path): def __init__(self, model_path: Path, detector: Detector | None = None):
try: try:
import mediapipe as mp import mediapipe as mp
import numpy as np import numpy as np
@@ -193,8 +209,10 @@ class MediaPipeTracker:
min_face_presence_confidence=0.5, min_face_presence_confidence=0.5,
min_tracking_confidence=0.5, min_tracking_confidence=0.5,
output_face_blendshapes=True, output_face_blendshapes=True,
output_facial_transformation_matrixes=True, # pose da cabeça (balanço, aceno, cabeça para trás)
) )
self._lm = vision.FaceLandmarker.create_from_options(options) self._lm = vision.FaceLandmarker.create_from_options(options)
self._detector = detector
self._last_ms = -1 self._last_ms = -1
def process(self, t: float, rgb: Any) -> reaction.FaceSample: def process(self, t: float, rgb: Any) -> reaction.FaceSample:
@@ -203,16 +221,90 @@ class MediaPipeTracker:
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb)) image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
result = self._lm.detect_for_video(image, ms) result = self._lm.detect_for_video(image, ms)
if not result.face_landmarks: if not result.face_landmarks:
return reaction.FaceSample(t, False) return self._head_only(t, rgb)
xs = [p.x for p in result.face_landmarks[0]] xs = [p.x for p in result.face_landmarks[0]]
ys = [p.y 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 {} 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) matrixes = getattr(result, "facial_transformation_matrixes", None)
pose = pose_from_matrix(matrixes[0]) if matrixes else None
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend,
pose)
def _head_only(self, t: float, rgb: Any) -> reaction.FaceSample:
"""Sem rosto no MediaPipe: a caixa do YuNet (se houver) diz onde está a cabeça. Falha do detector não derruba
o bloco: o quadro fica só sem rosto, como antes."""
if self._detector is None:
return reaction.FaceSample(t, False)
try:
detections = self._detector.detect(self._np.ascontiguousarray(rgb[:, :, ::-1])) # YuNet quer BGR
except Exception as exc: # noqa: BLE001 - OpenCV pode falhar num quadro; o rastreio do rosto segue
log.debug("YuNet falhou no quadro %.2f: %s", t, exc)
return reaction.FaceSample(t, False)
if not detections:
return reaction.FaceSample(t, False)
x, y, w, h, _score = max(detections, key=lambda d: d[4])
height, width = rgb.shape[:2]
return reaction.FaceSample(t, False, (x + w / 2) / width, (y + h / 2) / height, h / height, head=True)
def close(self) -> None: def close(self) -> None:
self._lm.close() self._lm.close()
class MouthMeter:
"""Movimento da boca por quadro, para a atribuição de falante (speakers.py; doc/clipador/FALANTES.md).
Medido na sessão 15 (tfue, webcam pequena e rosto de PERFIL): o MediaPipe só achava o rosto em ~4 % dos quadros
e o `jawOpen` ficava em 0,00 mesmo falando. O YuNet acha o rosto em 99 % dos quadros e dá os cantos da boca:
o recorte da boca (alinhado pelo YuNet em cada quadro, 24×20, normalizado) é comparado com o do quadro anterior.
Valor = diferença média (0 = parado); None = sem rosto neste quadro ou no anterior. É um sinal FRACO por trecho
(fala × boca parada separa pouco num trecho só) e forte na soma: serve para dizer QUAL voz é a do streamer."""
PATCH = (24, 20)
def __init__(self, model_path: Path, score: float = 0.5):
try:
import cv2
import numpy as np
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._np, self._path, self._score = cv2, np, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
self._prev: Any = None
def feed(self, rgb: Any) -> float | None:
cv2, np = self._cv2, self._np
if rgb is None:
self._prev = None
return None
h, w = rgb.shape[:2]
if self._det is None:
self._det = cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 5)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
bgr = np.ascontiguousarray(rgb[:, :, ::-1])
_, faces = self._det.detect(bgr)
if faces is None or len(faces) == 0:
self._prev = None
return None
f = max(faces, key=lambda r: r[14])
fh = float(f[3])
(rx, ry), (lx, ly) = f[10:12], f[12:14] # cantos da boca (direito, esquerdo)
mx, my = (rx + lx) / 2, (ry + ly) / 2
mw = max(abs(lx - rx), float(f[2]) * 0.3)
x0, x1 = int(mx - mw * 0.9), int(mx + mw * 0.9)
y0, y1 = int(my - fh * 0.12), int(my + fh * 0.22)
if x0 < 0 or y0 < 0 or x1 > w or y1 > h or x1 - x0 < 4 or y1 - y0 < 4:
self._prev = None
return None
gray = cv2.cvtColor(bgr[y0:y1, x0:x1], cv2.COLOR_BGR2GRAY)
patch = cv2.resize(gray, self.PATCH).astype(np.float32)
patch = (patch - patch.mean()) / (patch.std() + 1e-3)
prev, self._prev = self._prev, patch
return None if prev is None else float(np.abs(patch - prev).mean())
class OpenSeeFaceTracker: class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes. """Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
@@ -428,6 +520,8 @@ def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.Fa
s.cy = crop["y"] + s.cy * crop["h"] s.cy = crop["y"] + s.cy * crop["h"]
if s.size is not None: if s.size is not None:
s.size = s.size * crop["h"] s.size = s.size * crop["h"]
if s.hsize is not None:
s.hsize = s.hsize * crop["h"]
return seconds return seconds
@@ -449,8 +543,12 @@ class FaceService:
detector_factory: Callable[[], Detector] | None = None, detector_factory: Callable[[], Detector] | None = None,
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None, reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
grabber: Callable[..., Any] | None = None, grabber: Callable[..., Any] | None = None,
sizer: Callable[[Path], tuple[int, int]] | None = None): sizer: Callable[[Path], tuple[int, int]] | None = None,
mouth_factory: Callable[[], Any] | None = None):
self.e = engine self.e = engine
# Movimento da boca por quadro (atribuição de falante). Falha ao criar = bloco sem a série `mouth` (o
# rastreio de reação segue igual). Nos testes (store falso) cai nesse caso sozinho.
self._mouth_factory = mouth_factory or (lambda: MouthMeter(self.store.path("yunet")))
self.store = store or ModelStore(engine.settings.data_dir / "models") 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. # 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._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
@@ -479,7 +577,7 @@ class FaceService:
if backend == OpenSeeFaceTracker.name: if backend == OpenSeeFaceTracker.name:
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector")) return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
try: try:
return MediaPipeTracker(self.store.path("face_landmarker")) return MediaPipeTracker(self.store.path("face_landmarker"), self._head_detector())
except FaceUnavailable as first: except FaceUnavailable as first:
if backend == MediaPipeTracker.name: if backend == MediaPipeTracker.name:
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
@@ -488,6 +586,15 @@ class FaceService:
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo 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 raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
def _head_detector(self) -> Detector | None:
"""YuNet para a cabeça quando o MediaPipe perde o rosto; sem ele o rastreio segue como antes (só sem corpo de
perfil)."""
try:
return self._detector_factory()
except FaceUnavailable as exc:
log.info("rastreio sem a caixa da cabeça (YuNet indisponível: %s)", exc)
return None
def session_backend(self, session_id: int) -> str | None: def session_backend(self, session_id: int) -> str | None:
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda).""" """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", row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
@@ -592,12 +699,21 @@ class FaceService:
started = time.perf_counter() started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name self.backend = tracker.name
mouth = self._mouth_meter()
mouth_values: list[float | None] = []
try: try:
file = REPO_ROOT / segment["file"] file = REPO_ROOT / segment["file"]
crop = expand(cam) crop = expand(cam)
px, out = crop_geometry(crop, self._frame_size(sid, file)) px, out = crop_geometry(crop, self._frame_size(sid, file))
samples = [tracker.process(segment["start_s"] + t, rgb) samples = []
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)] for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out):
samples.append(tracker.process(segment["start_s"] + t, rgb))
if mouth is not None:
try:
mouth_values.append(mouth.feed(rgb))
except Exception as exc: # noqa: BLE001 - a boca é extra: falhou, o bloco segue sem ela
log.info("movimento da boca do bloco %s/%s: %s", sid, idx, exc)
mouth, mouth_values = None, []
except FaceUnavailable: except FaceUnavailable:
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde 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 except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
@@ -612,14 +728,31 @@ class FaceService:
self._save(sid, idx, "error", {"cam": cam}, msg) self._save(sid, idx, "error", {"cam": cam}, msg)
return "error" return "error"
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem. # 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) seconds = to_frame(reaction.per_second(samples, last - first, start_s=first, params=self.params), crop)
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples), data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame", "ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)} "seconds": reaction.seconds_to_json(seconds)}
if mouth is not None and mouth_values:
# Quadro i = início do bloco + i / fps (speakers.py soma isto por trecho de fala).
data["mouth"] = [None if v is None else round(v, 4) for v in mouth_values]
self._save(sid, idx, "done", data, None) self._save(sid, idx, "done", data, None)
self.last_error = None self.last_error = None
self._after_block(sid, idx)
return "done" return "done"
def _mouth_meter(self) -> Any:
try:
return self._mouth_factory()
except Exception as exc: # noqa: BLE001 - sem YuNet/opencv: rastreio segue, só sem a série da boca
log.debug("medidor de boca indisponível: %s", exc)
return None
def _after_block(self, session_id: int, idx: int) -> None:
"""Série nova da boca: a atribuição de falante da sessão é refeita na próxima leitura."""
speakers = getattr(self.e, "speakers", None)
if speakers is not None:
speakers.invalidate(session_id)
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]: def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file) key = str(file)
if key not in self._sizes: if key not in self._sizes:
@@ -694,7 +827,8 @@ class FaceService:
return "" return ""
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi) seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
inside = [s for s in seconds if lo <= s.t <= 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): # Só a cabeça (de perfil, sem expressão) também rende linha: o corpo diz alguma coisa ao analista.
if not inside or not any(s.smile is not None or (s.head or 0.0) > 0 for s in inside):
return "" return ""
return reaction.summarize(seconds, lo, hi, self.params, relative=False) return reaction.summarize(seconds, lo, hi, self.params, relative=False)
@@ -707,16 +841,23 @@ class FaceService:
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end) seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
signal = reaction.reaction_signal(seconds, params=self.params) signal = reaction.reaction_signal(seconds, params=self.params)
moments = reaction.reaction_moments(seconds, self.params) moments = reaction.reaction_moments(seconds, self.params)
body = reaction.body_moments(seconds, self.params)
expressions = reaction.expression_map(seconds, self.params, body)
counts = {r["status"]: r["n"] for r in self.e.db.all( 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)} "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"] total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
rows = [] rows = []
for s, z in zip(seconds, signal): for s, z, mapped in zip(seconds, signal, expressions):
if s.t < start: if s.t < start:
continue continue
item = s.to_json() item = s.to_json()
if z is not None: if z is not None:
item["signal"] = round(z, 2) item["signal"] = round(z, 2)
# Mapa de expressões: a expressão dominante e o movimento do corpo no segundo (ausentes = nada).
if mapped["expr"]:
item["expr"] = mapped["expr"]
if mapped["body"]:
item["body"] = mapped["body"]
rows.append(item) rows.append(item)
return { return {
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame", "sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
@@ -727,6 +868,7 @@ class FaceService:
"fromS": start, "toS": end, "fromS": start, "toS": end,
"seconds": rows, "seconds": rows,
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end], "moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
"body": [b.to_json() for b in body if b.end_s >= start and b.start_s <= end],
} }
# ---------- câmera local (YuNet + reaction.locate_cam) # ---------- câmera local (YuNet + reaction.locate_cam)
+164
View File
@@ -0,0 +1,164 @@
"""Detecção do jogo da live: junta as pistas e decide qual é o jogo, com o grau de certeza.
Pedido do dono (18/11/2026): se ninguém lembrou de dizer o jogo, o Clipador descobre sozinho a cada ~3 min cruzando
várias fontes (a API da plataforma, o título, o que a IA lê na tela, o chat e a fala) e deixa o usuário
confirmar ou trocar. Este módulo é só a regra de decisão (sem banco, sem IA) para ser testável.
Pistas (`source`):
- platform: categoria da live (Streamlink/API). Autoridade da plataforma, mas pode estar abreviada, errada ou
genérica ("Just Chatting").
- screen: o jogo que a IA vê nos frames (logo, HUD, texto na tela), com a confiança que ela mesma declarou.
- title: o título da live cita um jogo conhecido.
- chat / speech: o chat e a fala dos últimos minutos citam um jogo conhecido (o nome ou um dos outros nomes).
Estados (`status`) do resultado:
- agreed: duas ou mais fontes independentes apontam o mesmo jogo.
- probable: uma fonte boa sozinha (ex.: só a categoria).
- conflict: a categoria e a tela (ou outras fontes fortes) apontam jogos diferentes — pergunta ao usuário.
- unknown: nenhuma pista útil.
"""
from __future__ import annotations
import re
import unicodedata
from dataclasses import dataclass, field
# Peso máximo de cada fonte (a força da pista, 0–1, multiplica). A categoria e a tela se equivalem de propósito:
# quando divergem, quem decide é o usuário (conflito), não um empate arbitrário.
SOURCE_WEIGHT = {"platform": 0.55, "screen": 0.5, "title": 0.25, "chat": 0.35, "speech": 0.35}
STRONG_SOURCES = ("platform", "screen")
CONFIDENCE = {"high": 1.0, "medium": 0.7, "low": 0.4}
AGREED_MIN = 0.6 # nota mínima para "várias fontes concordam"
PROBABLE_MIN = 0.34 # só a tela com confiança "média" (0,5 × 0,7 = 0,35) já vale como "provável"
CLEAR_LEAD = 0.25 # vantagem do 1º sobre o 2º para não ser conflito
CHAT_MIN_MESSAGES = 2 # uma mensagem solta citando um jogo é ruído
CHAT_FULL_AT = 6 # mensagens que dão força 1
SPEECH_FULL_AT = 3
# Categorias que não são jogo: não valem como pista de jogo (mas ficam registradas).
GENERIC_CATEGORIES = {
"just-chatting", "irl", "special-events", "music", "art", "asmr", "talk-shows-podcasts", "talk-shows",
"sports", "food-drink", "travel-outdoors", "pools-hot-tubs-beaches", "science-technology", "politics",
"software-and-game-development", "animals-aquariums-zoos", "fitness-health", "makers-crafting", "slots",
"games-demos", "just-sleeping", "retro", "gambling", "podcasts", "variety", "bate-papo", "so-bate-papo",
"unknown", "desconhecido", "nao-identificavel", "nenhum", "none", "n-a",
}
def deaccent(text: str) -> str:
return "".join(c for c in unicodedata.normalize("NFKD", text or "") if not unicodedata.combining(c))
def slug(text: str) -> str:
"""Sem acento ("Só Bate-papo" → "so-bate-papo"), minúsculo, palavras ligadas por hífen."""
return re.sub(r"[^a-z0-9]+", "-", deaccent(text).lower()).strip("-")[:60]
def is_generic(name: str) -> bool:
return not slug(name) or slug(name) in GENERIC_CATEGORIES
def form_ok(form: str) -> bool:
"""Forma de nome boa para procurar em texto solto: curta demais vira falso positivo ("it", "go")."""
return len(form) >= 4 or (len(form) >= 3 and any(c.isdigit() for c in form))
def count_mentions(texts: list[str], forms_by_game: dict[str, set[str]]) -> dict[str, int]:
"""Em quantas mensagens/frases cada jogo é citado. `forms_by_game`: id do jogo → nomes (já em `slug`).
O texto vira `-a-b-c-` e a forma `-gta-6-` precisa aparecer inteira (palavra inteira, sem pegar pedaço)."""
out: dict[str, int] = {}
wanted = {gid: [f"-{f}-" for f in forms if form_ok(f)] for gid, forms in forms_by_game.items()}
for text in texts:
# Duas leituras do texto: sem acento ("pokemon") e como o id do jogo foi gerado, que não tira acento
# (`intel.game_id("Pokémon")` = "pok-mon"). Casar com qualquer uma.
padded = (f"-{slug_all(text)}-", f"-{slug_all(text, fold=False)}-")
for gid, needles in wanted.items():
if any(n in p for n in needles for p in padded):
out[gid] = out.get(gid, 0) + 1
return out
def slug_all(text: str, fold: bool = True) -> str:
"""Como `slug`, sem o corte de 60 caracteres (textos longos: a fala de uns minutos). `fold=False` mantém os
acentos como separador (igual ao `game_id` do Clipador)."""
return re.sub(r"[^a-z0-9]+", "-", (deaccent(text) if fold else text or "").lower()).strip("-")
@dataclass
class Evidence:
source: str
game: str # nome como a fonte disse
gid: str # id canônico (resolvido pelo chamador: categoria "Grand Theft Auto VI" e tela "GTA 6" → o mesmo)
strength: float = 1.0 # 0–1
detail: str = ""
def score(self) -> float:
return SOURCE_WEIGHT.get(self.source, 0.1) * max(0.0, min(1.0, self.strength))
@dataclass
class Candidate:
gid: str
game: str
score: float = 0.0
evidence: list[Evidence] = field(default_factory=list)
@property
def sources(self) -> list[str]:
return sorted({e.source for e in self.evidence})
def view(self) -> dict:
return {"gid": self.gid, "game": self.game, "score": round(self.score, 2),
"sources": [{"source": e.source, "game": e.game, "strength": round(e.strength, 2), "detail": e.detail}
for e in self.evidence]}
@dataclass
class Decision:
status: str # agreed | probable | conflict | unknown
top: Candidate | None
candidates: list[Candidate]
def view(self) -> dict:
return {"status": self.status, "top": self.top.view() if self.top else None,
"candidates": [c.view() for c in self.candidates[:4]]}
def screen_strength(confidence: str) -> float:
return CONFIDENCE.get((confidence or "").strip().lower(), 0.7)
def fuse(evidence: list[Evidence]) -> Decision:
"""Pistas → candidatos (ruído-ou: cada fonte conta uma vez, a mais forte dela) → decisão."""
best: dict[tuple[str, str], Evidence] = {}
for e in evidence:
if not e.gid or e.strength <= 0:
continue
key = (e.gid, e.source)
if key not in best or e.score() > best[key].score():
best[key] = e
by_game: dict[str, Candidate] = {}
for (gid, _), e in best.items():
cand = by_game.setdefault(gid, Candidate(gid, e.game))
cand.evidence.append(e)
for cand in by_game.values():
miss = 1.0
for e in cand.evidence:
miss *= 1.0 - e.score()
cand.score = 1.0 - miss
# O nome mostrado: o da fonte mais forte (categoria > tela > resto).
cand.game = max(cand.evidence, key=lambda e: (e.source == "platform", e.source == "screen", e.score())).game
ranked = sorted(by_game.values(), key=lambda c: c.score, reverse=True)
if not ranked or ranked[0].score < 0.15:
return Decision("unknown", None, ranked)
top = ranked[0]
second = ranked[1] if len(ranked) > 1 else None
if second and second.score >= PROBABLE_MIN and top.score - second.score < CLEAR_LEAD \
and any(s in STRONG_SOURCES for s in second.sources):
return Decision("conflict", top, ranked)
if len(top.sources) >= 2 and top.score >= AGREED_MIN:
return Decision("agreed", top, ranked)
if top.score >= PROBABLE_MIN:
return Decision("probable", top, ranked)
return Decision("unknown", None, ranked)
+225 -19
View File
@@ -18,12 +18,17 @@ import time
from pathlib import Path from pathlib import Path
from typing import TYPE_CHECKING from typing import TYPE_CHECKING
from . import clip_delete, layout from . import clip_delete, layout, media, timeline
from .db import loads, now from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable from .face import FaceError, FaceUnavailable
from .game_detect import (
CHAT_FULL_AT, CHAT_MIN_MESSAGES, SPEECH_FULL_AT, Evidence, count_mentions, fuse, is_generic, screen_strength,
slug_all,
)
from .hashtags import fold, to_tag from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context, lang_key, output_language_note from .judge import (JudgeError, build_scan_prompt, build_scan_timeline_prompt, game_context, lang_key, lean_profile,
output_language_note)
from .scoring import fit_window from .scoring import fit_window
from .sources import parse_source from .sources import parse_source
@@ -33,12 +38,21 @@ if TYPE_CHECKING: # pragma: no cover
log = logging.getLogger("cenaforge_clipper.intel") 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. # 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} # timelineJson: a IA lê o vídeo como linha do tempo JSON curta (timeline.py); desligado = transcrição + chat + frames
# soltos como antes (para comparar custo e qualidade — doc/clipador/EQUIPE-IA.md).
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True,
"timelineJson": True}
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação 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 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) GAME_CHECK_S = 180 # rechecar a categoria da live (e cruzar com tela, chat e fala) a cada 3 min: o streamer troca de jogo
UNKNOWN_GAMES = {"", "desconhecido", "não identificável", "nao identificavel", "unknown", "none", "n/a", "não sei", "nenhum"}
SCREEN_FRESH_S = 900 # o que a IA viu na tela vale como pista por 15 min
CHAT_WINDOW_S = 360 # chat e fala dos últimos 6 min entram na detecção do jogo
SPEECH_SEGMENTS = 12 # = 6 min de blocos de 30 s
SCAN_FRAME_EVERY_S = 30 SCAN_FRAME_EVERY_S = 30
SCAN_MAX_FRAMES = 7 SCAN_MAX_FRAMES = 7
SCAN_MOSAIC_TILES = 8 # mosaico 4×2: 1 imagem por janela de varredura
SCAN_TIMELINE_CHARS = 9000
MEMORY_KEEP = 6 MEMORY_KEEP = 6
SCAN_MAX_MOMENTS = 2 SCAN_MAX_MOMENTS = 2
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia) SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
@@ -132,6 +146,7 @@ class Intel:
self._weights: dict[str, tuple[float, dict[str, float]]] = {} self._weights: dict[str, tuple[float, dict[str, float]]] = {}
self._rooms_ready: set[str] = set() self._rooms_ready: set[str] = set()
self._game_checked: dict[int, float] = {} self._game_checked: dict[int, float] = {}
self._detect_lock = threading.RLock() # `game_detect_json` é lido-e-gravado pelo laço de contexto e pela varredura
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória 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 self.last_scan_error: str | None = None
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")} saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
@@ -255,8 +270,8 @@ class Intel:
return len(names) return len(names)
# ---------------------------------------------------------------- jogo # ---------------------------------------------------------------- jogo
def check_game(self, session: dict, force: bool = False) -> None: def check_game(self, session: dict, force: bool = False, detect: bool = True) -> None:
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo.""" """Categoria atual da live (Streamlink) e título → pistas da sessão; depois cruza tudo (`detect_game`)."""
if session["kind"] != "live": if session["kind"] != "live":
return return
last = self._game_checked.get(session["id"], 0) last = self._game_checked.get(session["id"], 0)
@@ -268,9 +283,154 @@ class Intel:
return return
if meta.get("title") and not session.get("title"): if meta.get("title") and not session.get("title"):
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"]) self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
category = (meta.get("category") or "").strip() with self._detect_lock:
if category and category != session.get("game") and session.get("game_source") != "user": state = self._detect_state(session["id"])
self.set_game(session["id"], category, "platform") state["platform"] = {"game": (meta.get("category") or "").strip()[:120], "title": (meta.get("title") or "")[:200],
"at": now()}
self._save_detect_state(session["id"], state)
if detect:
self.detect_game(session["id"])
# ---- detecção do jogo (game_detect.py: a regra; aqui: juntar as pistas e aplicar)
def _detect_state(self, session_id: int) -> dict:
row = self.e.db.get("SELECT game_detect_json FROM sessions WHERE id = ?", session_id) or {}
state = loads(row.get("game_detect_json"), {})
return state if isinstance(state, dict) else {}
def _save_detect_state(self, session_id: int, state: dict) -> None:
self.e.db.run("UPDATE sessions SET game_detect_json = ? WHERE id = ?", json.dumps(state, ensure_ascii=False), session_id)
def canon(self, name: str) -> tuple[str, str]:
"""(id canônico, nome para mostrar): "GTA 6" e "Grand Theft Auto VI" dão o mesmo id quando o jogo está cadastrado."""
row = self.find_game(name)
return (row["id"], row["name"]) if row else (game_id(name), name.strip())
def note_screen(self, session_id: int, game: str, confidence: str = "", evidence: str = "") -> None:
"""O que a IA viu na tela (varredura ou "Detectar agora") vira pista; vale por SCREEN_FRESH_S."""
game = (game or "").strip()
if not game or game.lower() in UNKNOWN_GAMES:
return
with self._detect_lock:
state = self._detect_state(session_id)
state["screen"] = {"game": game[:120], "confidence": (confidence or "medium").lower()[:10],
"evidence": (evidence or "")[:240], "at": now(), "ts": time.time()}
self._save_detect_state(session_id, state)
def _mention_forms(self) -> tuple[dict[str, set[str]], dict[str, str]]:
"""Jogos conhecidos → formas de nome para procurar no texto (id, nome e outros nomes) e o nome de cada um."""
forms: dict[str, set[str]] = {}
names: dict[str, str] = {}
for row in self.e.db.all("SELECT id, name, aliases_json FROM games"):
if is_generic(row["id"]):
continue
forms[row["id"]] = {row["id"], slug_all(row["name"]), *loads(row["aliases_json"], [])}
names[row["id"]] = row["name"]
return forms, names
def _recent_texts(self, session_id: int) -> tuple[list[str], list[str]]:
"""(mensagens do chat, trechos de fala) dos últimos minutos — só texto cru, sem montar a linha do tempo."""
from .speakers import parse_words # import local: speakers importa módulos que importam este
chat = [r["text"] for r in self.e.db.all(
"SELECT text FROM chat WHERE session_id = ? AND wall >= (SELECT COALESCE(MAX(wall), 0) - ? FROM chat WHERE session_id = ?)",
session_id, CHAT_WINDOW_S, session_id)]
speech = [" ".join(w.word for w in parse_words(r["words_json"])) for r in self.e.db.all(
"SELECT words_json FROM segments WHERE session_id = ? AND analyzed = 1 ORDER BY idx DESC LIMIT ?",
session_id, SPEECH_SEGMENTS)]
return chat, speech
def gather_evidence(self, session: dict, state: dict) -> list[Evidence]:
out: list[Evidence] = []
forms, names = self._mention_forms()
plat = state.get("platform") or {}
if plat.get("game") and not is_generic(plat["game"]):
gid, _ = self.canon(plat["game"])
out.append(Evidence("platform", plat["game"], gid, 1.0, "categoria da live na plataforma"))
title = plat.get("title") or session.get("title") or ""
for gid, n in count_mentions([title], forms).items():
out.append(Evidence("title", names.get(gid, gid), gid, 1.0, "o título da live cita o jogo"))
screen = state.get("screen") or {}
if screen.get("game") and time.time() - float(screen.get("ts") or 0) < SCREEN_FRESH_S and not is_generic(screen["game"]):
gid, _ = self.canon(screen["game"])
out.append(Evidence("screen", screen["game"], gid, screen_strength(screen.get("confidence", "")),
screen.get("evidence") or "a IA viu o jogo nos frames"))
chat, speech = self._recent_texts(session["id"])
for gid, n in count_mentions(chat, forms).items():
if n >= CHAT_MIN_MESSAGES:
out.append(Evidence("chat", names.get(gid, gid), gid, min(1.0, n / CHAT_FULL_AT), f"{n} mensagem(ns) do chat citam o jogo"))
for gid, n in count_mentions(speech, forms).items():
out.append(Evidence("speech", names.get(gid, gid), gid, min(1.0, n / SPEECH_FULL_AT), f"citado em {n} trecho(s) da fala"))
return out
def detect_game(self, session_id: int, immediate: bool = False) -> dict | None:
"""Cruza as pistas (categoria, título, tela, chat e fala) e atualiza o jogo da sessão.
Regras: jogo que VOCÊ confirmou nunca muda sozinho (se as pistas apontarem outro jogo duas vezes seguidas,
vira `suggestion` para o painel perguntar); sem confirmação, só troca de jogo se a categoria da plataforma
apoiar ou se a mesma resposta vier duas checagens seguidas (`immediate` pula isso: pedido do usuário);
categoria e tela discordando = `conflict` (mantém o jogo e pergunta)."""
with self._detect_lock:
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
return None
state = self._detect_state(session_id)
decision = fuse(self.gather_evidence(session, state))
current = session.get("game") or ""
cur_gid = self.canon(current)[0] if current else ""
locked = session.get("game_source") == "user" and bool(current)
top = decision.top
state["candidates"] = [c.view() for c in decision.candidates[:4]]
state["checkedAt"] = now()
state["suggestion"] = None
status = decision.status
if locked:
status = "user"
if top and top.gid != cur_gid and decision.status == "agreed":
state["pending"] = self._streak(state, top.gid)
if state["pending"]["n"] >= 2:
state["suggestion"] = {"game": self.canon(top.game)[1], "score": round(top.score, 2), "sources": top.sources}
else:
state["pending"] = None
elif top and top.gid != cur_gid and (decision.status in ("agreed", "probable") or (decision.status == "conflict" and not current)):
platform_backs = any(e.source == "platform" for e in top.evidence)
state["pending"] = self._streak(state, top.gid)
if immediate or not current or is_generic(current) or platform_backs or state["pending"]["n"] >= 2:
source = "platform" if platform_backs else "screen" if "screen" in top.sources else "chat"
self.set_game(session_id, self.canon(top.game)[1], source)
state["pending"] = None
else:
state["pending"] = None
self.e.db.run("UPDATE sessions SET game_status = ? WHERE id = ?", status, session_id)
self._save_detect_state(session_id, state)
return {"status": status, **{k: state[k] for k in ("candidates", "suggestion")}}
@staticmethod
def _streak(state: dict, gid: str) -> dict:
pending = state.get("pending") or {}
return {"gid": gid, "n": pending.get("n", 0) + 1 if pending.get("gid") == gid else 1}
def detect_game_now(self, session_id: int) -> dict:
""""Detectar agora" (painel): a IA olha 3 frames recentes e diz que jogo é; depois cruza com o resto."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
raise JudgeError("sessão não encontrada")
if not (self.opts["vision"] and self.e.judge.enabled):
raise JudgeError("a detecção pela tela precisa da IA ligada e da visão ligada (Configurações → IA)")
d = session["duration_s"]
if d < 5:
raise JudgeError("gravação curta demais para olhar a tela")
times = sorted({max(1.0, d - 120), max(1.0, d - 60), max(1.0, d - 6)})
frames = self.frames(session, times, "game")
if not frames:
raise JudgeError("sem frames da tela (blocos apagados ou visão sem vídeo)")
data = self.e.judge.detect_game([p for _, p in frames], (self._detect_state(session_id).get("platform") or {}).get("title", ""))
game = str(data.get("game") or "").strip()
if game and game.lower() not in UNKNOWN_GAMES:
self.note_screen(session_id, game, str(data.get("confidence") or ""), str(data.get("evidence") or ""))
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", game[:120], session_id)
self.check_game(session, force=True, detect=False)
result = self.detect_game(session_id, immediate=True) or {}
return result | {"screen": {"game": game, "confidence": data.get("confidence", ""), "evidence": data.get("evidence", "")}}
def set_game(self, session_id: int, name: str, source: str) -> None: def set_game(self, session_id: int, name: str, source: str) -> None:
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id) session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
@@ -474,10 +634,13 @@ class Intel:
"""'en' = fonte em inglês (juízes em inglês, tradução para o painel); 'pt' = o resto.""" """'en' = fonte em inglês (juízes em inglês, tradução para o painel); 'pt' = o resto."""
return lang_key(session.get("language") or self.e.settings.language) return lang_key(session.get("language") or self.e.settings.language)
def context(self, session: dict) -> str: def context(self, session: dict, lean: bool = False) -> str:
"""Contexto do jogo para os prompts. `lean` (linha do tempo JSON): perfil enxuto (judge.lean_profile)."""
memory = loads(session.get("memory_json"), []) memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game")) 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", ""))) profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
if lean:
profile = lean_profile(profile)
text = game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""), text = 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, " | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed,
lang=self.lang(session)) lang=self.lang(session))
@@ -486,7 +649,7 @@ class Intel:
return f"{text}\n{note}" if note else text return f"{text}\n{note}" if note else text
# ---------------------------------------------------------------- frames # ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]: def frames(self, session: dict, times: list[float], tag: str, width: int = 768) -> list[tuple[float, Path]]:
if not self.opts["vision"]: if not self.opts["vision"]:
return [] return []
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"]) segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
@@ -495,11 +658,31 @@ class Intel:
frames = [] frames = []
for t in times: for t in times:
try: try:
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg"))) frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg", width)))
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
log.info("frame %.0fs indisponível: %s", t, exc) log.info("frame %.0fs indisponível: %s", t, exc)
return frames return frames
def visual(self, session: dict, times: list[float], tag: str, mode: str) -> tuple[list[Path], list[float], bool]:
"""Imagens para a IA: (arquivos, instante de cada quadro, é mosaico?). `mode`: "mosaic" = os quadros numa
grade 4×2 numa imagem só (384×216 cada); "frames" = soltos em 768 px (o antigo); "none" = nenhuma.
Mosaico que falha cai para os quadros soltos (a IA não fica sem ver a tela)."""
if mode == "none" or not self.opts["vision"] or not times:
return [], [], False
if mode != "mosaic":
frames = self.frames(session, times, tag)
return [p for _, p in frames], [t for t, _ in frames], False
frames = self.frames(session, times, f"{tag}m", width=media.MOSAIC_TILE_W)
if not frames:
return [], [], False
out = self.e.repo_path(session["dir"]) / "frames" / f"{tag}-mosaic-{int(frames[0][0])}.jpg"
try:
media.mosaic(self.e.settings.ffmpeg or "ffmpeg", [p for _, p in frames], out)
except Exception as exc: # noqa: BLE001 - sem mosaico, vão os quadros (pequenos) soltos
log.info("mosaico %s indisponível: %s", tag, exc)
return [p for _, p in frames], [t for t, _ in frames], False
return [out], [t for t, _ in frames], True
# ---------------------------------------------------------------- webcam # ---------------------------------------------------------------- webcam
def maybe_detect_cam(self, session: dict) -> None: 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.""" """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."""
@@ -633,19 +816,39 @@ class Intel:
cfg = self.settings_for(session) cfg = self.settings_for(session)
dur = cfg["duration"] dur = cfg["duration"]
back_lo = max(0.0, lo - dur["backtrackS"]) back_lo = max(0.0, lo - dur["backtrackS"])
use_timeline = bool(self.opts.get("timelineJson", True))
mode = self.e.judge.roles["scan"].get("images", "mosaic") if use_timeline else "frames"
if mode == "mosaic": # 8 quadros por igual na janela, numa imagem só
step = (hi - lo) / SCAN_MOSAIC_TILES
times = [lo + step / 2 + i * step for i in range(SCAN_MOSAIC_TILES)]
else:
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES) 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] 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") images, tiles, mosaic = self.visual(session, times, "scan", mode)
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all( 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)] "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 existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
lang = self.lang(session)
if use_timeline:
# A "volta" (antes da janela) vai resumida: já foi vista na janela anterior.
ev = timeline.collect(self.e, session, tl, back_lo, hi)
text = timeline.build(ev, back_lo, hi, {"win": [int(lo), int(hi)], "back": int(back_lo), "src": lang},
budget_chars=SCAN_TIMELINE_CHARS, coarse_until=lo)
prompt = build_scan_timeline_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo,
self.context(session, lean=True), text, tiles, mosaic, existing, dur["minS"],
dur["maxS"], lang=lang)
else:
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"], 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"], tl["chat"], self.context(session), list(zip(tiles, images)), existing,
lang=self.lang(session)) dur["minS"], dur["maxS"], lang=lang)
created = 0 created = 0
try: try:
data = self.e.judge.scan(prompt, [p for _, p in frames], lang=self.lang(session)) run_mode = ("timeline" if use_timeline else "legacy") + f"+{'mosaic' if mosaic else mode}"
with self.e.judge.scope(session_id=session["id"], mode=run_mode):
data = self.e.judge.scan(prompt, images, lang=lang)
self.last_scan_error = None self.last_scan_error = None
# O que a varredura viu em cada quadro vira o `v` da linha do tempo (analista, editor e juiz reaproveitam).
timeline.save_scene_lines(self.e, session["id"], "scan", data.get("lines"), tiles)
except (JudgeError, json.JSONDecodeError) as exc: except (JudgeError, json.JSONDecodeError) as exc:
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota. # Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
self.last_scan_error = str(exc)[:300] self.last_scan_error = str(exc)[:300]
@@ -667,12 +870,15 @@ class Intel:
item["summaryPt"] = str(data["summary_pt"])[:240] item["summaryPt"] = str(data["summary_pt"])[:240]
memory.append(item) memory.append(item)
screen = str(data.get("screen_game") or "") screen = str(data.get("screen_game") or "")
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel", "unknown"): if screen.strip().lower() in UNKNOWN_GAMES:
screen = "" screen = ""
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?", 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"]) hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
if screen and not session.get("game"): if screen:
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela # A tela é uma pista (com a confiança e o que a IA leu), não a palavra final: cruza com categoria, título,
# chat e fala. Sem categoria (YouTube/VOD), a tela sozinha ainda define o jogo (estado "provável").
self.note_screen(session["id"], screen, str(data.get("screen_game_confidence") or ""), str(data.get("screen_evidence") or ""))
self.detect_game(session["id"])
return created return created
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool: def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
+555 -60
View File
@@ -30,11 +30,13 @@ import sys
import tempfile import tempfile
import threading import threading
import time import time
from contextlib import contextmanager
from dataclasses import dataclass, field from dataclasses import dataclass, field
from datetime import datetime, timezone from datetime import datetime, timezone
from pathlib import Path from pathlib import Path
from . import layout from . import layout
from . import roles as roles_module
from .ai_settings import AiConfig from .ai_settings import AiConfig
from .scoring import ChatMessage, Word, fit_window from .scoring import ChatMessage, Word, fit_window
@@ -111,6 +113,14 @@ CHAT_GLOSSARY = """Gírias comuns do chat (interprete pelo contexto):
"clipa/clip it" → pedido de corte; "hack/hackudo" → suspeita de trapaça; "gg" → fim de partida. "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.""" - Emotes próprios do canal (prefixo do streamer, ex.: skpPog) carregam a mesma reação do emote original."""
# Frase curta do que está na tela em cada quadro/ladrilho do mosaico (`n` = nº do quadro, 1 = primeiro). Vira o
# campo `v` da linha do tempo (app/timeline.py), guardado em `scene_notes` e reaproveitado por editor e juiz.
SCENE_LINES = {
"type": "array",
"items": {"type": "object", "properties": {"n": {"type": "integer"}, "v": {"type": "string"}},
"required": ["n", "v"], "additionalProperties": False},
}
SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada", SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada",
"historia", "informacao_do_jogo", "reacao", "outro") "historia", "informacao_do_jogo", "reacao", "outro")
@@ -126,11 +136,14 @@ ANALYSIS_SCHEMA = {
"action_start_s": {"type": "number"}, "action_start_s": {"type": "number"},
"reaction_end_s": {"type": "number"}, "reaction_end_s": {"type": "number"},
"hook": {"type": "string"}, "hook": {"type": "string"},
"lines": SCENE_LINES,
}, },
"required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence", "required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence",
"action_start_s", "reaction_end_s", "hook"], "action_start_s", "reaction_end_s", "hook", "lines"],
"additionalProperties": False, "additionalProperties": False,
} }
# Campos que a resposta pode não trazer (modelo antigo/cache): a análise segue sem eles.
ANALYSIS_OPTIONAL = ("lines",)
ANALYST_SYSTEM = """Você é o ANALISTA de uma equipe de cortes de live. Não escreve título: descreve com fidelidade 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 O QUE ACONTECEU no trecho, para o editor decidir. Recebe contexto do jogo, transcrição com tempos, FRAMES da tela
@@ -152,6 +165,8 @@ Campos:
- 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). - 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. - reaction_end_s: instante em que a reação/pagamento termina.
- hook: o que prenderia alguém nos 2 primeiros segundos do corte. - hook: o que prenderia alguém nos 2 primeiros segundos do corte.
- lines: para cada frame/quadro do mosaico anexado (n = o número dele), v = o que está na tela em até 12 palavras,
factual (ação, lugar, texto grande do jogo). Sem imagem anexada: lista vazia.
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido.""" Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
VERDICT_SCHEMA = { VERDICT_SCHEMA = {
@@ -181,11 +196,14 @@ SCAN_SCHEMA = {
"type": "object", "type": "object",
"properties": { "properties": {
"screen_game": {"type": "string"}, "screen_game": {"type": "string"},
"screen_game_confidence": {"type": "string", "enum": ["high", "medium", "low"]},
"screen_evidence": {"type": "string"},
"has_webcam": {"type": "boolean"}, "has_webcam": {"type": "boolean"},
"summary": {"type": "string"}, "summary": {"type": "string"},
"moments": {"type": "array", "items": _MOMENT}, "moments": {"type": "array", "items": _MOMENT},
"lines": SCENE_LINES,
}, },
"required": ["screen_game", "has_webcam", "summary", "moments"], "required": ["screen_game", "screen_game_confidence", "screen_evidence", "has_webcam", "summary", "moments", "lines"],
"additionalProperties": False, "additionalProperties": False,
} }
_MISSION = { _MISSION = {
@@ -268,9 +286,14 @@ Tarefa: aponte de 0 a 2 momentos desta janela que dariam um bom corte SOZINHOS.
moments=[] (é o normal na maior parte do tempo — não force). Não repita um corte já feito. 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), - 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. 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? - screen_game: o jogo que aparece na tela (ou "desconhecido"); screen_game_confidence: high (viu logo, nome ou HUD
inconfundível), medium (reconhece pelo visual) ou low (palpite); screen_evidence: o que você LEU ou VIU que prova
(ex.: "HUD com minimapa e estrelas de procurado", "texto MISSION PASSED"), em 1 frase curta e em português.
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). - 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). - title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
- lines: para cada frame/quadro do mosaico (n = o número dele), v = o que está na tela em até 12 palavras, factual.
Sem imagem anexada: lista vazia.
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido.""" Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
# Perfil do jogo em INGLÊS (doc/clipador/JOGOS.md): é o que vai nos prompts; a tradução para português é só para o # Perfil do jogo em INGLÊS (doc/clipador/JOGOS.md): é o que vai nos prompts; a tradução para português é só para o
@@ -335,6 +358,24 @@ PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "av
"hashtags": "Hashtags", "news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes", "hashtags": "Hashtags", "news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes",
"missions": "Missões", "end_triggers": "Gatilhos de fim de missão", "aliases": "Outros nomes"} "missions": "Missões", "end_triggers": "Gatilhos de fim de missão", "aliases": "Outros nomes"}
GAME_SCHEMA = {
"type": "object",
"properties": {
"game": {"type": "string"},
"confidence": {"type": "string", "enum": ["high", "medium", "low"]},
"evidence": {"type": "string"},
},
"required": ["game", "confidence", "evidence"],
"additionalProperties": False,
}
GAME_SYSTEM = """Você identifica QUAL JOGO está na tela de uma live, olhando frames do mesmo trecho (instantes diferentes).
Use só o que aparece: logo, nome do jogo, menus, HUD, interface, texto na tela, estilo visual. O título da live pode
dar uma dica, mas não é prova. Ignore overlays do streamer (alertas, chat, webcam). game: o nome oficial do jogo em
inglês (ex.: "Grand Theft Auto VI", "Call of Duty: Warzone") ou "desconhecido" se não der para saber, ou se a tela
mostra só conversa/menu da plataforma/área de trabalho. confidence: high (viu logo, nome ou HUD inconfundível),
medium (reconhece pelo visual) ou low (palpite). evidence: o que você LEU ou VIU que prova, em 1 frase curta em
português. Não invente. Responda só com o JSON pedido."""
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e, 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: 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. x, y = canto superior esquerdo; w, h = largura e altura. Sem webcam: has_webcam=false e x=y=w=h=0.
@@ -454,6 +495,8 @@ Fields (in English):
- action_start_s: second of the recording where the ACTION that caused the reaction starts (may be before the speech). - action_start_s: second of the recording where the ACTION that caused the reaction starts (may be before the speech).
- reaction_end_s: second where the reaction/payoff ends. - reaction_end_s: second where the reaction/payoff ends.
- hook: what would hook someone in the first 2 seconds of the clip (English, it goes on screen). - hook: what would hook someone in the first 2 seconds of the clip (English, it goes on screen).
- lines: for each attached frame/mosaic tile (n = its number), v = what is on screen in up to 12 words, factual
(action, place, big on-screen game text), in English. No image attached: empty list.
- pt: what_happened, screen, speech, chat_meaning and hook translated. """ + PT_NOTE + """ - pt: what_happened, screen, speech, chat_meaning and hook translated. """ + PT_NOTE + """
Do not use tools beyond what was given. Answer only with the requested JSON.""" Do not use tools beyond what was given. Answer only with the requested JSON."""
@@ -497,9 +540,14 @@ Task: point out 0 to 2 moments in this window that would make a good clip ON THE
moments=[] (that's normal most of the time — don't force it). Don't repeat a clip already made. moments=[] (that's normal most of the time — don't force it). Don't repeat a clip already made.
- start_s/end_s inside the window (may start back to the "backtrack" limit to catch the action), within the - start_s/end_s inside the window (may start back to the "backtrack" limit to catch the action), within the
min/max duration given. min/max duration given.
- screen_game: the game on screen (or "unknown"); has_webcam: is there a streamer camera in the frame? - screen_game: the game on screen (or "unknown"); screen_game_confidence: high (saw the logo, title or an
unmistakable HUD), medium (recognised by the look) or low (a guess); screen_evidence: what you READ or SAW that
proves it (e.g. "minimap and wanted stars HUD", "MISSION PASSED text"), one short sentence, in Portuguese.
has_webcam: is there a streamer camera in the frame?
- summary: 1 sentence of what's going on in the window (becomes memory for the next windows). - summary: 1 sentence of what's going on in the window (becomes memory for the next windows).
- title/caption/reason in English like an editor would write (title ≤ 70 characters, true). - title/caption/reason in English like an editor would write (title ≤ 70 characters, true).
- lines: for each frame/mosaic tile (n = its number), v = what is on screen in up to 12 words, factual, in English.
No image attached: empty list.
- summary_pt and each moment's pt (title, reason): translated. """ + PT_NOTE + """ - summary_pt and each moment's pt (title, reason): translated. """ + PT_NOTE + """
Do not use tools beyond what was given. Answer only with the requested JSON.""" Do not use tools beyond what was given. Answer only with the requested JSON."""
@@ -535,6 +583,213 @@ names; translate the slang's meaning, e.g. "he's cooked" -> "ele tá ferrado").
as is. Answer only with the requested JSON.""" as is. Answer only with the requested JSON."""
# ---------------------------------------------------------------- JUIZ de contexto (doc/clipador/EQUIPE-IA.md)
# Pedido do dono (18/11/2026): "não trazer corte sem sentido, principalmente em inglês". O juiz vê SÓ o que vai no
# corte final (linha do tempo do trecho + 20 s antes marcados out=1), escreve primeiro o que um espectador frio
# entenderia e depois responde sim/não. Quem decide pelas respostas é o código (context_judge.decide), não uma nota.
CONTEXT_CHECKS = roles_module.CHECKS
_CHECK = {"type": "object",
"properties": {"ok": {"type": "boolean"}, "t": {"type": ["number", "null"]}, "why": {"type": "string"}},
"required": ["ok", "t", "why"], "additionalProperties": False}
CONTEXT_SCHEMA = {
"type": "object",
"properties": {
"viewer_summary": {"type": "string"},
"checks": {"type": "object", "properties": {c: _CHECK for c in CONTEXT_CHECKS}, "required": list(CONTEXT_CHECKS),
"additionalProperties": False},
"fix": {"type": "object",
"properties": {"start_s": {"type": ["number", "null"]}, "end_s": {"type": ["number", "null"]},
"context_line": {"type": "string"}},
"required": ["start_s", "end_s", "context_line"], "additionalProperties": False},
"confidence": {"type": "number"},
"reason": {"type": "string"},
},
"required": ["viewer_summary", "checks", "fix", "confidence", "reason"],
"additionalProperties": False,
}
CONTEXT_SCHEMA_EN = _with(CONTEXT_SCHEMA, pt={
"type": "object",
"properties": {"viewer_summary": {"type": "string"}, "reason": {"type": "string"}, "context_line": {"type": "string"},
"checks": _pt_block(*CONTEXT_CHECKS)},
"required": ["viewer_summary", "reason", "context_line", "checks"], "additionalProperties": False})
CONTEXT_SYSTEM_EN = """You are the CONTEXT JUDGE of a live-stream clipping team. The editor already picked the segment and
wrote the title. You check ONE thing: will someone who has NEVER seen this stream understand the clip and feel it makes
sense on its own? You only get what the viewer will see: the clip's timeline (entries with out=1 are just BEFORE or AFTER
the clip — the viewer does NOT see them; use them only to notice a missing setup or payoff), the title, caption and opening on-screen text, the
intended story (from the analyst) and one line about the game.
First write viewer_summary: what a cold viewer understands from the clip alone (1–2 sentences) — BEFORE the checks.
Then answer every check with ok (true/false), t (second of the recording that is the evidence, or null) and why
(up to 15 words):
- setup: the clip includes the start of the situation the moment depends on. Fails if the key setup is only in the
out=1 entries before the clip (or earlier).
- payoff: the clip includes the outcome/punchline/result (of the fight, escape, mission, joke). Fails if it ends before
(e.g. the result is only in the out=1 entries after the clip).
- who_what: it is clear who is involved and what is happening.
- standalone: it works without knowing earlier events of the stream, the channel's lore or inside jokes.
- intelligible: the key line is in the transcript; fails if the important line is a teammate's/other player's that is
missing, or the streamer only reacts to something we never hear.
- faithful: title/caption only claim what the clip shows ("caught a hacker" when he only accuses him = false).
- strong_open: the first ~3 s already hook (not calm chatter).
Red flags in English streams: references to things outside the clip ("that guy", "again", "like I said", "remember
when", names never introduced), callbacks to donations/raids/subs, chat or channel inside jokes. Irony/slang ("he's
cooked", "Clueless", "W") only counts if the screen confirms it.
fix — only when a check fails and the timeline shows the answer: start_s (earlier, to include the setup) and/or end_s
(later, to include the payoff; or earlier, to drop a tail that depends on other context), seconds of the recording,
within the limits given; null when not needed. context_line: on-screen text for the first seconds (up to 8 words, in
English) that gives a cold viewer the missing context (e.g. "Tfue tries to talk his way out of a robbery"); "" when not
needed. Never invent facts.
confidence: 0–1. reason: one sentence.
pt: viewer_summary, reason, context_line and every check's why, translated. """ + PT_NOTE + """
Do not use tools. Answer only with the requested JSON."""
CONTEXT_SYSTEM = """Você é o JUIZ DE CONTEXTO de uma equipe de cortes de live. O editor já escolheu o trecho e escreveu o
título. Você confere UMA coisa: alguém que NUNCA viu esta live entende o corte e sente que ele faz sentido sozinho?
Você recebe só o que o espectador vai ver: a linha do tempo do corte (entradas com out=1 vêm logo ANTES ou DEPOIS do
corte — o espectador NÃO as vê; use só para notar o começo ou o desfecho que faltam), título, legenda e texto de abertura na tela, a história
pretendida (do analista) e uma linha sobre o jogo.
Escreva primeiro viewer_summary: o que um espectador frio entende só com o corte (1–2 frases) — ANTES das checagens.
Depois responda cada checagem com ok (true/false), t (segundo da gravação que é a evidência, ou null) e why (até 15
palavras):
- setup: o corte inclui o começo da situação de que o momento depende. Falha se o começo importante só está nas
entradas out=1 (ou antes).
- payoff: o corte inclui o desfecho/resultado/piada (da treta, da fuga, da missão). Falha se termina antes (ex.: o
resultado só aparece nas entradas out=1 depois do corte).
- who_what: dá para entender quem está envolvido e o que está acontecendo.
- standalone: funciona sem saber o que aconteceu antes na live, a história do canal ou piadas internas.
- intelligible: a fala principal está na transcrição; falha se ela é de um colega/outro jogador que não aparece, ou se
o streamer só reage a algo que não se ouve.
- faithful: título/legenda só afirmam o que o corte mostra ("pegou um hacker" quando ele só acusa = falso).
- strong_open: os ~3 primeiros segundos já prendem (não é conversa morna).
Sinais de alerta: referência a algo fora do corte ("aquele cara", "de novo", "como eu falei", "lembra quando", nome
nunca apresentado), menção a doação/raid/sub, piada interna do chat ou do canal. Ironia/gíria só vale se a tela
confirma.
fix — só quando uma checagem falha e a linha do tempo mostra a resposta: start_s (mais cedo, para incluir o começo) e/ou
end_s (mais tarde, para incluir o desfecho; ou mais cedo, para tirar uma cauda que depende de outro contexto), em
segundos da gravação, dentro dos limites informados; null quando não precisa. context_line: texto na tela para os
primeiros segundos (até 8 palavras, no idioma do corte) que dá ao espectador frio o contexto que falta; "" se não
precisa. Nunca invente fatos.
confidence: 0–1. reason: uma frase.
Não use ferramentas. Responda só com o JSON pedido."""
def clean_context(data: dict) -> dict:
"""Resposta do juiz normalizada: checagem ausente/inválida conta como "não respondida" (ok=True, sem motivo) —
o código não descarta por falta de resposta. Sem `checks` nem `viewer_summary` é erro de conteúdo."""
if not isinstance(data, dict) or not isinstance(data.get("checks"), dict) or "viewer_summary" not in data:
raise JudgeError("juiz sem viewer_summary/checks", unavailable=False)
checks = {}
for name in CONTEXT_CHECKS:
raw = data["checks"].get(name)
raw = raw if isinstance(raw, dict) else {}
t = raw.get("t")
checks[name] = {"ok": raw.get("ok") is not False,
"t": float(t) if isinstance(t, (int, float)) and not isinstance(t, bool) else None,
"why": str(raw.get("why") or "").strip()[:200]}
fix = data.get("fix") if isinstance(data.get("fix"), dict) else {}
def num(value):
return float(value) if isinstance(value, (int, float)) and not isinstance(value, bool) else None
pt = data.get("pt") if isinstance(data.get("pt"), dict) else {}
pt_checks = pt.get("checks") if isinstance(pt.get("checks"), dict) else {}
try:
confidence = max(0.0, min(1.0, float(data.get("confidence", 0.5))))
except (TypeError, ValueError):
confidence = 0.5
out_pt = {k: str(pt.get(k) or "").strip()[:600] for k in ("viewer_summary", "reason", "context_line") if pt.get(k)}
if pt_checks:
out_pt["checks"] = {c: str(pt_checks.get(c) or "").strip()[:200] for c in CONTEXT_CHECKS if pt_checks.get(c)}
return {
"viewer_summary": str(data.get("viewer_summary") or "").strip()[:600],
"checks": checks,
"fix": {"start_s": num(fix.get("start_s")), "end_s": num(fix.get("end_s")),
"context_line": " ".join(str(fix.get("context_line") or "").split())[:80]},
"confidence": confidence,
"reason": str(data.get("reason") or "").strip()[:300],
"pt": out_pt,
}
# ---------------------------------------------------------------- prompts com a linha do tempo (v1)
def images_block(tiles: list[float], mosaic: bool, lang: str = "pt") -> str:
"""O que vai anexado. `tiles` = instante de cada quadro (no mosaico, da esquerda para a direita, de cima para
baixo). As frases `lines[].n` da resposta se referem a esses números."""
if not tiles:
return "Images: none." if lang == "en" else "Imagens: nenhuma."
numbered = ", ".join(f"#{i + 1}={t:.0f}s" for i, t in enumerate(tiles))
if mosaic:
return (f"Attached: ONE mosaic image with {len(tiles)} frames in a grid (left→right, top→bottom): {numbered}."
if lang == "en" else
f"Anexo: UMA imagem em mosaico com {len(tiles)} quadros em grade (esquerda→direita, cima→baixo): {numbered}.")
return (f"Attached frames, in order: {numbered}." if lang == "en" else f"Frames anexados, em ordem: {numbered}.")
def timeline_section(timeline_text: str, lang: str, streamer: str) -> str:
"""Legenda das chaves + (se há fala de outra pessoa) a nota de quem fala + a linha do tempo."""
from .timeline import legend
me = (streamer or "streamer").replace("[", "(").replace("]", ")")
note = ""
if "[other" in timeline_text: # fala de outra pessoa no trecho (FALANTES.md): sem marca = o streamer
note = "\n" + SPEAKER_NOTE["en" if lang == "en" else "pt"].format(s=me).replace(f"[{me}]", "no tag")
return f"{legend(lang)}{note}\n{timeline_text}"
def build_timeline_prompt(streamer: str, platform: str, start_s: float, end_s: float, peak_s: float,
heuristic: dict, *, context: str, timeline_text: str, tiles: list[float], mosaic: bool,
lo: float, hi: float, min_s: float, max_s: float, lang: str = "pt",
analysis: dict | None = None) -> str:
"""Prompt do ANALISTA e do EDITOR no formato novo: cabeçalho + imagens + linha do tempo JSON (no lugar da
transcrição, do chat e da linha do rosto, que já estão dentro dela)."""
L, to = LABELS[lang], ("to" if lang == "en" else "a")
signals = {k: v for k, v in heuristic.items() if k not in ("topMessages", "face", "emotes")}
text = (f"{L['channel']}: {streamer} ({platform})\n{context}\n\n"
f"{L['window']}: {lo:.0f}s {to} {hi:.0f}s. {L['candidate']}: {start_s:.0f}s {to} {end_s:.0f}s; "
f"{L['peak']} {peak_s:.0f}s. {L['duration']}: {min_s:.0f} {to} {max_s:.0f} s.\n"
f"{L['signals']}: {json.dumps(signals, ensure_ascii=False, separators=(',', ':'))}\n"
f"{images_block(tiles, mosaic, lang)}\n\n{timeline_section(timeline_text, lang, streamer)}")
if analysis:
text += "\n\n" + analysis_block(analysis, lang)
return text
def build_scan_timeline_prompt(streamer: str, platform: str, lo: float, hi: float, back_lo: float, context: str,
timeline_text: str, tiles: list[float], mosaic: bool,
existing: list[tuple[float, float, str]], min_s: float, max_s: float,
lang: str = "pt") -> str:
L, to = LABELS[lang], ("to" if lang == "en" else "a")
done = "; ".join(f"{a:.0f}–{b:.0f}s ({t[:40]})" for a, b, t in existing) or L["none"]
return (f"{L['channel']}: {streamer} ({platform})\n{context}\n\n"
f"{L['new_window']}: {lo:.0f}s {to} {hi:.0f}s ({L['back_to'].format(s=f'{back_lo:.0f}')}).\n"
f"{L['duration']}: {min_s:.0f} {to} {max_s:.0f} s. {L['done']}: {done}\n"
f"{images_block(tiles, mosaic, lang)}\n\n{timeline_section(timeline_text, lang, streamer)}")
def build_context_prompt(*, streamer: str, game: str, game_line: str, start_s: float, end_s: float, title: str,
caption: str, opening: str, story: str, timeline_text: str, lo: float, hi: float,
min_s: float, max_s: float, lang: str = "pt") -> str:
"""Prompt do JUIZ: só o que o espectador verá (e 20 s antes / 15 s depois, marcados out=1) + limites do ajuste."""
if lang == "en":
lines = [f"Game: {game or 'unknown'}" + (f" — {game_line}" if game_line else ""),
f"Streamer: {streamer}",
f"Clip the viewer will see: {start_s:.0f}s to {end_s:.0f}s ({end_s - start_s:.0f} s).",
f"Title: {title}", f"Caption: {caption or '(none)'}", f"Opening on-screen text: {opening or '(none)'}",
f"Intended story (analyst): {story or '(not available)'}",
f"Limits for a fix: start back to {lo:.0f}s at most, end up to {hi:.0f}s; duration {min_s:.0f} to {max_s:.0f} s."]
else:
lines = [f"Jogo: {game or 'desconhecido'}" + (f" — {game_line}" if game_line else ""),
f"Streamer: {streamer}",
f"Corte que o espectador verá: {start_s:.0f}s a {end_s:.0f}s ({end_s - start_s:.0f} s).",
f"Título: {title}", f"Legenda: {caption or '(nenhuma)'}", f"Texto de abertura na tela: {opening or '(nenhum)'}",
f"História pretendida (analista): {story or '(não disponível)'}",
f"Limites para o ajuste: início até {lo:.0f}s no máximo para trás, fim até {hi:.0f}s; duração de "
f"{min_s:.0f} a {max_s:.0f} s."]
return "\n".join(lines) + f"\n\n{timeline_section(timeline_text, lang, streamer)}"
def lang_key(language: str | None) -> str: def lang_key(language: str | None) -> str:
"""'en' para fonte em inglês (juízes em inglês); 'pt' para o resto (prompts em português + nota de saída).""" """'en' para fonte em inglês (juízes em inglês); 'pt' para o resto (prompts em português + nota de saída)."""
return "en" if (language or "").strip().lower().startswith("en") else "pt" return "en" if (language or "").strip().lower().startswith("en") else "pt"
@@ -611,6 +866,23 @@ def mission_lines(profile: dict, lang: str = "pt") -> list[str]:
return lines return lines
LEAN_LIMITS = {"clip_worthy": 6, "avoid": 4, "mechanics": 6, "jargon": 10, "news": 2}
LEAN_ITEM_CHARS = 100
def lean_profile(profile: dict | None) -> dict | None:
"""Perfil enxuto para os prompts da linha do tempo (o perfil completo ia inteiro em TODA chamada: ~1.000
tokens no ROB RUN). Resumo em 2 frases, listas menores e itens curtos; missões seguem com o teto de sempre."""
if not profile:
return profile
out = dict(profile)
summary = str(profile.get("summary") or "")
out["summary"] = ". ".join(summary.split(". ")[:2]).strip()
for key, limit in LEAN_LIMITS.items():
out[key] = [str(item)[:LEAN_ITEM_CHARS] for item in (profile.get(key) or [])[:limit]]
return out
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "", def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
confirmed: bool = False, lang: str = "pt") -> str: confirmed: bool = False, lang: str = "pt") -> str:
if lang == "en": if lang == "en":
@@ -660,16 +932,40 @@ def _game_context_en(game: str, screen_game: str, profile: dict | None, live_tit
return "\n".join(lines) return "\n".join(lines)
def _transcript(words: list[Word], lo: float, hi: float, lang: str = "pt") -> str: SPEAKER_NOTE = {
lines, current, current_t = [], [], None "pt": "Quem fala vem marcado: [{s}] = o streamer; [other1], [other2]… = OUTRA pessoa (colega no Discord, outro "
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start): "jogador no chat de voz do jogo). Nunca atribua a {s} o que outra pessoa disse.",
if current_t is None or word.start - current_t > 4 or len(current) >= 14: "en": "Each line is tagged with who speaks: [{s}] = the streamer; [other1], [other2]… = SOMEONE ELSE (teammate on "
"Discord, another player on in-game voice chat). Never attribute to {s} what someone else said.",
}
def _transcript(words: list[Word], lo: float, hi: float, lang: str = "pt", streamer: str = "") -> str:
"""Transcrição com tempo para os prompts. Com fala de outra pessoa no trecho (doc/clipador/FALANTES.md), cada
linha diz quem fala ([Tfue] / [other1]) e nunca mistura falantes; sem outra pessoa, sai igual a antes."""
inside = sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start)
tagged = any(w.speaker and w.speaker != "streamer" for w in inside)
me = (streamer or "streamer").replace("[", "(").replace("]", ")")
lines: list[str] = []
current: list[str] = []
current_t: float | None = None
current_sp = ""
def flush() -> None:
tag = f" [{me if current_sp == 'streamer' else current_sp}]" if tagged else ""
lines.append(f"[{current_t:.0f}s]{tag} {' '.join(current)}")
for word in inside:
sp = word.speaker or "streamer"
if current_t is None or word.start - current_t > 4 or len(current) >= 14 or (tagged and sp != current_sp):
if current: if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}") flush()
current, current_t = [], word.start current, current_t, current_sp = [], word.start, sp
current.append(word.word) current.append(word.word)
if current: if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}") flush()
if lines and tagged:
lines.insert(0, SPEAKER_NOTE["en" if lang == "en" else "pt"].format(s=me))
return "\n".join(lines) or LABELS[lang]["no_speech"] return "\n".join(lines) or LABELS[lang]["no_speech"]
@@ -717,7 +1013,7 @@ def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, pea
f"{L['signals']}: {json.dumps(heuristic, ensure_ascii=False)}\n" f"{L['signals']}: {json.dumps(heuristic, ensure_ascii=False)}\n"
+ (f"{L['face']}: {face}\n" if face else "") + (f"{L['face']}: {face}\n" if face else "")
+ f"{_frames_block(frames or [], lang)}\n\n" + f"{_frames_block(frames or [], lang)}\n\n"
f"{L['transcript']}:\n{_transcript(words, lo, hi, lang)}\n\n" f"{L['transcript']}:\n{_transcript(words, lo, hi, lang, streamer)}\n\n"
f"{_chat_block(chat, lo, hi, peak_s, lang=lang)}" f"{_chat_block(chat, lo, hi, peak_s, lang=lang)}"
) )
@@ -732,7 +1028,7 @@ def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_l
f"{L['new_window']}: {lo:.0f}s {to} {hi:.0f}s ({L['back_to'].format(s=f'{back_lo:.0f}')}).\n" f"{L['new_window']}: {lo:.0f}s {to} {hi:.0f}s ({L['back_to'].format(s=f'{back_lo:.0f}')}).\n"
f"{L['duration']}: {min_s:.0f} {to} {max_s:.0f} s. {L['done']}: {done}\n" f"{L['duration']}: {min_s:.0f} {to} {max_s:.0f} s. {L['done']}: {done}\n"
f"{_frames_block(frames, lang)}\n\n" f"{_frames_block(frames, lang)}\n\n"
f"{L['transcript']}:\n{_transcript(words, back_lo, hi, lang)}\n\n" f"{L['transcript']}:\n{_transcript(words, back_lo, hi, lang, streamer)}\n\n"
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10, lang=lang)}" f"{_chat_block(chat, back_lo, hi, None, bucket_s=10, lang=lang)}"
) )
@@ -828,14 +1124,70 @@ def codex_models(cache: Path | None = None) -> list[dict]:
return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}] return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
# ---------------------------------------------------------------- uso de tokens (F0: medir antes de otimizar)
def _int(value) -> int | None:
try:
return int(value) if value is not None else None
except (TypeError, ValueError):
return None
def codex_usage(stdout: str) -> dict | None:
"""Uso do `codex exec --json` (eventos JSONL): o último evento com `usage` (`turn.completed`). None = não veio."""
found = None
for line in (stdout or "").splitlines():
line = line.strip()
if not line.startswith("{") or "input_tokens" not in line:
continue
try:
event = json.loads(line)
except json.JSONDecodeError:
continue
usage = event.get("usage") if isinstance(event, dict) else None
if not isinstance(usage, dict): # formato antigo: {"msg": {"type": "token_count", "info": {...}}}
info = ((event.get("msg") or {}).get("info") or {}) if isinstance(event, dict) else {}
usage = info.get("total_token_usage") or info.get("last_token_usage")
if isinstance(usage, dict) and "input_tokens" in usage:
found = {"in": _int(usage.get("input_tokens")), "out": _int(usage.get("output_tokens")),
"cached": _int(usage.get("cached_input_tokens"))}
return found
def claude_usage(envelope: dict) -> dict | None:
"""Uso do envelope `claude -p --output-format json`: entrada = nova + criação de cache + leitura de cache."""
usage = envelope.get("usage") if isinstance(envelope, dict) else None
if not isinstance(usage, dict):
return None
parts = [_int(usage.get(k)) or 0 for k in ("input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens")]
return {"in": sum(parts), "out": _int(usage.get("output_tokens")), "cached": _int(usage.get("cache_read_input_tokens"))}
def gemini_usage(envelope: dict) -> dict | None:
"""Uso do `gemini -o json` (`stats.models.<modelo>.tokens`), somado entre os modelos que a CLI usou."""
models = ((envelope or {}).get("stats") or {}).get("models") if isinstance(envelope, dict) else None
if not isinstance(models, dict) or not models:
return None
total = {"in": 0, "out": 0, "cached": 0}
for data in models.values():
tokens = (data or {}).get("tokens") or {}
total["in"] += _int(tokens.get("prompt")) or 0
total["out"] += (_int(tokens.get("candidates")) or 0) + (_int(tokens.get("thoughts")) or 0)
total["cached"] += _int(tokens.get("cached")) or 0
return total
# ---------------------------------------------------------------- IA # ---------------------------------------------------------------- IA
class Judge: class Judge:
"""As IAs da equipe (doc/clipador/EQUIPE-IA.md). Cada papel (varredura, analista, editor, juiz) tem provedor e
modelo próprios (`roles`); `provider`/`model` continuam existindo como a IA do EDITOR — a "principal", que também
faz os serviços gerais (pesquisa de jogo, tradução, câmera). `provider == "off"` desliga a equipe inteira."""
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = "", def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = "",
ai: AiConfig | None = None, clock=time.time): ai: AiConfig | None = None, clock=time.time, roles: dict | None = None):
self.provider = provider if provider in PROVIDERS else "codex" legacy = provider if provider in PROVIDERS else "codex"
self.model = model or DEFAULT_MODELS.get(self.provider, "") self._master = "off" if legacy == "off" else "on"
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor. base = roles_module.default_roles(legacy if legacy != "off" else "codex", model, analyst_model)
self.analyst_model = analyst_model self.roles = roles_module.normalize_roles(roles, base)
self.workdir = workdir self.workdir = workdir
# Configurações → IA do painel (data/ai): login/chave por provedor e ordem da reserva. # Configurações → IA do painel (data/ai): login/chave por provedor e ordem da reserva.
self.ai = ai or AiConfig() self.ai = ai or AiConfig()
@@ -845,14 +1197,85 @@ class Judge:
self._pause_lock = threading.Lock() self._pause_lock = threading.Lock()
# Quem respondeu a última chamada DESTA thread ("provedor:modelo"): o juiz roda em várias threads. # Quem respondeu a última chamada DESTA thread ("provedor:modelo"): o juiz roda em várias threads.
self._local = threading.local() self._local = threading.local()
# Medição (F0): o motor liga isto para gravar cada chamada em `ai_calls`. None = não mede.
self.meter = None
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None: # ---------- papéis
@property
def provider(self) -> str:
return "off" if self._master == "off" else self.roles["editor"]["provider"]
@provider.setter
def provider(self, value: str) -> None:
"""Compatível com o jeito antigo (um provedor só): "off" desliga a equipe; outro vale para todos os papéis."""
if value == "off":
self._master = "off"
return
if value not in AI_ENABLED:
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
self._master = "on"
for role in self.roles.values():
if role["provider"] != value:
role["provider"], role["model"] = value, ""
@property
def model(self) -> str:
return self.role_model("editor")
@property
def analyst_model(self) -> str:
return self.roles["analyst"]["model"]
def role_model(self, role: str) -> str:
conf = self.roles[role]
return conf["model"] or DEFAULT_MODELS.get(conf["provider"], "")
def role_enabled(self, role: str) -> bool:
return self.enabled and bool(self.roles[role]["enabled"])
def system_for(self, role: str, base: str, lang: str = "pt") -> str:
"""Instruções padrão do papel + as do administrador (somadas, nunca no lugar)."""
return base + roles_module.admin_notes(self.roles.get(role) or {}, lang)
def configure(self, provider: str, model: str, analyst_model: str | None = None, roles: dict | None = None) -> None:
"""`roles` = configuração por papel (painel novo). Sem ela (painel antigo): `provider`/`model` valem para
todos os papéis e `analyst_model` para o analista. `provider == "off"` desliga a equipe."""
if provider not in PROVIDERS: if provider not in PROVIDERS:
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}") raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
self.provider = provider if roles is not None:
self.model = model.strip() or DEFAULT_MODELS.get(provider, "") self.roles = roles_module.normalize_roles(roles, self.roles)
self._master = "off" if provider == "off" else "on"
return
if provider == "off":
self._master = "off"
return
self._master = "on"
model = model.strip()
for name, role in self.roles.items():
role["provider"] = provider
role["model"] = "" if model == DEFAULT_MODELS.get(provider) else model
if analyst_model is not None: if analyst_model is not None:
self.analyst_model = analyst_model.strip() self.roles["analyst"]["model"] = analyst_model.strip()
elif self.roles["analyst"]["model"] and provider != self.roles["analyst"]["provider"]:
self.roles["analyst"]["model"] = ""
def roles_view(self, skip: dict[str, str | None] | None = None) -> dict:
"""Papéis para o painel: a configuração + o modelo efetivo e a cadeia de reserva de cada um."""
out = {}
for name in roles_module.ROLES:
conf = dict(self.roles[name])
conf["resolvedModel"] = self.role_model(name)
conf["chain"] = self.fallback_chain(conf["provider"], skip) if self.enabled else []
out[name] = conf
return out
@staticmethod
def default_instructions() -> dict:
"""Texto padrão de cada papel nos dois idiomas (o painel mostra só para leitura)."""
return {"scan": {"pt": SCAN_SYSTEM, "en": SCAN_SYSTEM_EN},
"analyst": {"pt": ANALYST_SYSTEM, "en": ANALYST_SYSTEM_EN},
"editor": {"pt": JUDGE_SYSTEM, "en": JUDGE_SYSTEM_EN},
"judge": {"pt": CONTEXT_SYSTEM, "en": CONTEXT_SYSTEM_EN}}
@property @property
def enabled(self) -> bool: def enabled(self) -> bool:
@@ -865,6 +1288,16 @@ class Judge:
""""provedor:modelo" de quem respondeu a última chamada desta thread (a reserva pode ter respondido).""" """"provedor:modelo" de quem respondeu a última chamada desta thread (a reserva pode ter respondido)."""
return getattr(self._local, "responder", None) or f"{self.provider}:{self.model}" return getattr(self._local, "responder", None) or f"{self.provider}:{self.model}"
@contextmanager
def scope(self, **context):
"""Contexto das chamadas desta thread para a medição (`session_id`, `clip_id`, `mode`)."""
previous = getattr(self._local, "scope", None) or {}
self._local.scope = {**previous, **context}
try:
yield
finally:
self._local.scope = previous
# ---------- reserva # ---------- reserva
def pauses(self) -> dict[str, tuple[float, str]]: def pauses(self) -> dict[str, tuple[float, str]]:
"""Pausas ainda valendo (as vencidas saem).""" """Pausas ainda valendo (as vencidas saem)."""
@@ -892,18 +1325,21 @@ class Judge:
return "modo chave de API sem chave no cofre" return "modo chave de API sem chave no cofre"
return None return None
def fallback_chain(self) -> list[str]: def fallback_chain(self, primary: str | None = None, skip: dict[str, str | None] | None = None) -> list[str]:
"""Ordem em que `ask` tenta as IAs: a escolhida no juiz primeiro, depois a `order` do painel, só as ligadas, """Ordem em que `ask` tenta as IAs: a do papel (`primary`; padrão = a do editor) primeiro, depois a `order`
com CLI e (no modo chave) com chave; as em pausa são puladas e as perto do limite de uso vão para o fim. do painel, só as ligadas, com CLI e (no modo chave) com chave; as em pausa são puladas e as perto do limite
Reserva desligada: só a escolhida. de uso vão para o fim. Reserva desligada: só a escolhida.
Se TODAS as prontas estiverem em pausa, elas voltam como último recurso (melhor tentar do que parar).""" Se TODAS as prontas estiverem em pausa, elas voltam como último recurso (melhor tentar do que parar).
`skip` = `_skip_reason` já calculado por provedor (o `describe` monta a cadeia de cada papel de uma vez)."""
if not self.enabled: if not self.enabled:
return [] return []
primary = primary if primary in AI_ENABLED else self.provider
settings = self.ai.settings() settings = self.ai.settings()
candidates = [self.provider] candidates = [primary]
if settings["fallback"]["enabled"]: if settings["fallback"]["enabled"]:
candidates += [p for p in settings["order"] if p != self.provider and p in AI_ENABLED] candidates += [p for p in settings["order"] if p != primary and p in AI_ENABLED]
ready = [p for p in candidates if self._skip_reason(p, settings) is None] ready = [p for p in candidates
if (skip[p] if skip is not None and p in skip else self._skip_reason(p, settings)) is None]
if not settings["fallback"]["enabled"]: if not settings["fallback"]["enabled"]:
return ready return ready
paused = self.pauses() paused = self.pauses()
@@ -915,29 +1351,36 @@ class Judge:
def describe(self) -> dict: def describe(self) -> dict:
cmd = self.command() if self.enabled else None cmd = self.command() if self.enabled else None
settings = self.ai.settings() settings = self.ai.settings()
primary_skip = self._skip_reason(self.provider, settings) if self.enabled else None # Uma checagem por provedor (CLI no PATH, ligada, chave) para todas as cadeias: o painel lê isto a cada poucos s.
skip = {p: self._skip_reason(p, settings) for p in AI_ENABLED}
primary_skip = skip.get(self.provider) if self.enabled else None
return {"provider": self.provider, "model": self.model 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, "analystModel": self.role_model("analyst") if self.enabled else None,
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None, "available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None,
# Por que a escolhida não roda (desligada no painel, sem CLI, sem chave); None = pronta. # Por que a escolhida não roda (desligada no painel, sem CLI, sem chave); None = pronta.
"unavailableReason": primary_skip, "unavailableReason": primary_skip,
"authMode": settings["providers"].get(self.provider, {}).get("authMode") if self.enabled else None, "authMode": settings["providers"].get(self.provider, {}).get("authMode") if self.enabled else None,
"fallback": {"enabled": settings["fallback"]["enabled"], "fallback": {"enabled": settings["fallback"]["enabled"],
"cooldownMin": settings["fallback"]["cooldownMin"], "cooldownMin": settings["fallback"]["cooldownMin"],
"chain": self.fallback_chain()}, "chain": self.fallback_chain(skip=skip)},
"pauses": [{"provider": p, "until": datetime.fromtimestamp(until, timezone.utc).isoformat(timespec="seconds"), "pauses": [{"provider": p, "until": datetime.fromtimestamp(until, timezone.utc).isoformat(timespec="seconds"),
"reason": reason} for p, (until, reason) in sorted(self.pauses().items())]} "reason": reason} for p, (until, reason) in sorted(self.pauses().items())],
# Equipe de IA: cada papel com a sua IA (doc/clipador/EQUIPE-IA.md).
"roles": self.roles_view(skip),
"providers": {p: {"ready": skip[p] is None, "reason": skip[p],
"enabled": bool((settings["providers"].get(p) or {}).get("enabled"))}
for p in AI_ENABLED}}
def models(self) -> dict: def models(self) -> dict:
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "gemini": GEMINI_MODELS, "defaults": DEFAULT_MODELS} return {"codex": codex_models(), "claude": CLAUDE_MODELS, "gemini": GEMINI_MODELS, "defaults": DEFAULT_MODELS}
# ---------- usos # ---------- usos
def analyze(self, prompt: str, images: list[Path], lang: str = "pt") -> dict: def analyze(self, prompt: str, images: list[Path], lang: str = "pt") -> dict:
"""1º juiz (ANALISTA): o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título. """ANALISTA: o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título.
`lang="en"`: prompt em inglês e bloco `pt` (tradução para o painel) na mesma resposta.""" `lang="en"`: prompt em inglês e bloco `pt` (tradução para o painel) na mesma resposta."""
system, schema = (ANALYST_SYSTEM_EN, ANALYSIS_SCHEMA_EN) if lang == "en" else (ANALYST_SYSTEM, ANALYSIS_SCHEMA) system, schema = (ANALYST_SYSTEM_EN, ANALYSIS_SCHEMA_EN) if lang == "en" else (ANALYST_SYSTEM, ANALYSIS_SCHEMA)
data = self.ask(system, prompt, schema, images, model=self.analyst_model or self.model) data = self.ask(self.system_for("analyst", system, lang), prompt, schema, images, role="analyst")
missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data] missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data and k not in ANALYSIS_OPTIONAL]
if missing: if missing:
raise JudgeError(f"análise sem os campos {missing}") raise JudgeError(f"análise sem os campos {missing}")
data["confidence"] = max(0.0, min(1.0, float(data["confidence"]))) data["confidence"] = max(0.0, min(1.0, float(data["confidence"])))
@@ -946,18 +1389,26 @@ class Judge:
def judge(self, prompt: str, start_s: float, end_s: float, images: list[Path] | None = None, *, 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, lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
max_s: float = DEFAULT_MAX_S, lang: str = "pt") -> Verdict: max_s: float = DEFAULT_MAX_S, lang: str = "pt") -> Verdict:
"""EDITOR: decide se vira corte, o trecho, título, legenda e hashtags."""
system, schema = (JUDGE_SYSTEM_EN, VERDICT_SCHEMA_EN) if lang == "en" else (JUDGE_SYSTEM, VERDICT_SCHEMA) system, schema = (JUDGE_SYSTEM_EN, VERDICT_SCHEMA_EN) if lang == "en" else (JUDGE_SYSTEM, VERDICT_SCHEMA)
data = self.ask(system, prompt, schema, images or []) data = self.ask(self.system_for("editor", system, lang), prompt, schema, images or [], role="editor")
# Modelo de quem DE FATO respondeu (a reserva pode ter entrado no lugar da escolhida). # Modelo de quem DE FATO respondeu (a reserva pode ter entrado no lugar da escolhida).
return _clean(data, start_s, end_s, self.responder(), lo, hi, min_s, max_s) return _clean(data, start_s, end_s, self.responder(), lo, hi, min_s, max_s)
def check_context(self, prompt: str, lang: str = "pt") -> dict:
"""JUIZ de contexto (só texto): o que um espectador frio entende + as checagens sim/não. Quem decide pelas
respostas é o código (`context_judge.decide`)."""
system, schema = (CONTEXT_SYSTEM_EN, CONTEXT_SCHEMA_EN) if lang == "en" else (CONTEXT_SYSTEM, CONTEXT_SCHEMA)
data = self.ask(self.system_for("judge", system, lang), prompt, schema, [], role="judge")
return clean_context(data)
def translate_lines(self, lines: list[str]) -> list[str]: def translate_lines(self, lines: list[str]) -> list[str]:
"""Fala de um corte (frases em ordem) → português, mesma quantidade. Para o painel e a legenda de """Fala de um corte (frases em ordem) → português, mesma quantidade. Para o painel e a legenda de
desenvolvimento; o vídeo publicado continua no idioma da fonte.""" desenvolvimento; o vídeo publicado continua no idioma da fonte."""
if not lines: if not lines:
return [] return []
prompt = "\n".join(f"{i + 1}. {text}" for i, text in enumerate(lines)) prompt = "\n".join(f"{i + 1}. {text}" for i, text in enumerate(lines))
data = self.ask(LINES_SYSTEM, prompt, LINES_SCHEMA, []) data = self.ask(LINES_SYSTEM, prompt, LINES_SCHEMA, [], purpose="translate")
out = [str(x).strip() for x in (data.get("lines") or [])] out = [str(x).strip() for x in (data.get("lines") or [])]
if len(out) != len(lines): if len(out) != len(lines):
raise JudgeError(f"tradução com {len(out)} linhas para {len(lines)} frases", unavailable=False) raise JudgeError(f"tradução com {len(out)} linhas para {len(lines)} frases", unavailable=False)
@@ -965,7 +1416,7 @@ class Judge:
def scan(self, prompt: str, images: list[Path], lang: str = "pt") -> dict: def scan(self, prompt: str, images: list[Path], lang: str = "pt") -> dict:
system, schema = (SCAN_SYSTEM_EN, SCAN_SCHEMA_EN) if lang == "en" else (SCAN_SYSTEM, SCAN_SCHEMA) system, schema = (SCAN_SYSTEM_EN, SCAN_SCHEMA_EN) if lang == "en" else (SCAN_SYSTEM, SCAN_SCHEMA)
data = self.ask(system, prompt, schema, images) data = self.ask(self.system_for("scan", system, lang), prompt, schema, images, role="scan")
if not isinstance(data.get("moments"), list): if not isinstance(data.get("moments"), list):
raise JudgeError("varredura sem a lista de momentos") raise JudgeError("varredura sem a lista de momentos")
return data return data
@@ -975,7 +1426,8 @@ class Judge:
if notes: if notes:
prompt += "User requests (respect them; may be in Portuguese):\n" + "\n".join(f"- {n}" for n in notes) + "\n" prompt += "User requests (respect them; may be in Portuguese):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
prompt += "Research and return the game profile in English." prompt += "Research and return the game profile in English."
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S) return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S,
purpose="research")
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "", def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> dict: history: list[dict] | None = None) -> dict:
@@ -989,39 +1441,53 @@ class Judge:
f"{'User' if h.get('role') == 'user' else 'AI'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n" f"{'User' if h.get('role') == 'user' else 'AI'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
prompt += f"User REQUEST:\n{instruction}\n\nReturn the complete updated profile (English) and the reply (Portuguese)." prompt += f"User REQUEST:\n{instruction}\n\nReturn the complete updated profile (English) and the reply (Portuguese)."
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search, return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S) timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S, purpose="research")
def translate_game(self, profile: dict, target: str) -> dict: def translate_game(self, profile: dict, target: str) -> dict:
"""Traduz o perfil inteiro (pt-BR <-> en-US), mesmo formato, sem busca. Nomes oficiais e hashtags ficam.""" """Traduz o perfil inteiro (pt-BR <-> en-US), mesmo formato, sem busca. Nomes oficiais e hashtags ficam."""
language = TRANSLATE_TARGETS.get(target, target) language = TRANSLATE_TARGETS.get(target, target)
prompt = (f"Target language: {language}\nProfile JSON:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n" prompt = (f"Target language: {language}\nProfile JSON:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
"Return the translated profile.") "Return the translated profile.")
return self.ask(TRANSLATE_SYSTEM, prompt, PROFILE_SCHEMA, [], timeout=RESEARCH_TIMEOUT_S) return self.ask(TRANSLATE_SYSTEM, prompt, PROFILE_SCHEMA, [], timeout=RESEARCH_TIMEOUT_S, purpose="translate")
def detect_game(self, images: list[Path], live_title: str = "") -> dict:
prompt = (f"Título da live (só uma dica): {live_title or '(sem título)'}\n"
"Identifique o jogo nos frames anexados.")
return self.ask(GAME_SYSTEM, prompt, GAME_SCHEMA, images)
def detect_cam(self, images: list[Path]) -> dict: def detect_cam(self, images: list[Path]) -> dict:
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images) return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images,
purpose="cam")
# ---------- execução # ---------- execução
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False, def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
timeout: int = TIMEOUT_S, model: str | None = None) -> dict: timeout: int = TIMEOUT_S, model: str | None = None, role: str = "editor", purpose: str | None = None) -> dict:
"""Chama a IA escolhida; se ela falhar por indisponibilidade, a próxima da cadeia de reserva (com o modelo """Chama a IA do papel `role`; se ela falhar por indisponibilidade, a próxima da cadeia de reserva (com o
padrão DELA) e a que falhou fica em pausa. Erro de conteúdo (JSON inválido, campos faltando) não troca.""" modelo padrão DELA) e a que falhou fica em pausa. Erro de conteúdo (JSON inválido, campos faltando) não troca.
Cada tentativa é medida (`meter`), com o papel, a IA, o tamanho do prompt e das imagens e os tokens."""
if not self.enabled: if not self.enabled:
raise JudgeError("IA desligada", unavailable=False) raise JudgeError("IA desligada", unavailable=False)
chain = self.fallback_chain() conf = self.roles.get(role) or self.roles["editor"]
primary = conf["provider"]
chain = self.fallback_chain(primary)
if not chain: if not chain:
why = self._skip_reason(self.provider, self.ai.settings()) or "nenhuma IA pronta" why = self._skip_reason(primary, self.ai.settings()) or "nenhuma IA pronta"
raise JudgeError(f"{PROVIDER_NAMES[self.provider]} indisponível: {why} (veja Configurações → IA)", raise JudgeError(f"{PROVIDER_NAMES.get(primary, primary)} indisponível: {why} (veja Configurações → IA)",
unavailable=True) unavailable=True)
fallback_on = self.ai.settings()["fallback"]["enabled"] fallback_on = self.ai.settings()["fallback"]["enabled"]
attempts: list[str] = [] attempts: list[str] = []
for provider in chain: for provider in chain:
use_model = (model or self.model) if provider == self.provider else DEFAULT_MODELS[provider] use_model = (model or self.role_model(role if role in self.roles else "editor")) if provider == primary \
else DEFAULT_MODELS[provider]
effort = conf.get("effort", "") if provider == primary else ""
self._local.usage = None
started = time.monotonic()
try: try:
data = self._call(provider, system, prompt, schema, images, search, timeout, use_model) data = self._call(provider, system, prompt, schema, images, search, timeout, use_model, effort)
except JudgeError as exc: except JudgeError as exc:
text = str(exc) text = str(exc)
unavailable = exc.unavailable if exc.unavailable is not None else is_availability_error(text) unavailable = exc.unavailable if exc.unavailable is not None else is_availability_error(text)
self._measure(role, purpose, provider, use_model, system, prompt, images, started, text)
attempts.append(f"{provider}:{use_model}: {text}") attempts.append(f"{provider}:{use_model}: {text}")
if not unavailable: if not unavailable:
# Erro de conteúdo: a IA respondeu, o pedido é que não deu certo. Não troca de IA. # Erro de conteúdo: a IA respondeu, o pedido é que não deu certo. Não troca de IA.
@@ -1031,16 +1497,38 @@ class Judge:
log.warning("IA %s indisponível (%s); tentando a reserva", provider, text[:160]) log.warning("IA %s indisponível (%s); tentando a reserva", provider, text[:160])
continue continue
raise JudgeError(text, unavailable=True) from exc raise JudgeError(text, unavailable=True) from exc
self._measure(role, purpose, provider, use_model, system, prompt, images, started, None)
self._local.responder = f"{provider}:{use_model}" self._local.responder = f"{provider}:{use_model}"
if provider != self.provider: if provider != primary:
log.info("respondido pela reserva %s:%s", provider, use_model) log.info("respondido pela reserva %s:%s", provider, use_model)
return data return data
raise JudgeError("nenhuma IA respondeu — " + " · ".join(attempts)[:900], unavailable=True) raise JudgeError("nenhuma IA respondeu — " + " · ".join(attempts)[:900], unavailable=True)
def _measure(self, role: str, purpose: str | None, provider: str, model: str, system: str, prompt: str,
images: list[Path], started: float, error: str | None) -> None:
if self.meter is None:
return
image_bytes = 0
for img in images:
try:
image_bytes += Path(img).stat().st_size
except OSError:
pass
usage = getattr(self._local, "usage", None) or {}
record = {"role": role, "purpose": purpose or role, "provider": provider, "model": model, "ok": error is None,
"error": (error or "")[:300] or None, "ms": int((time.monotonic() - started) * 1000),
"systemChars": len(system), "promptChars": len(prompt), "images": len(images),
"imageBytes": image_bytes, "tokensIn": usage.get("in"), "tokensOut": usage.get("out"),
"tokensCached": usage.get("cached"), **(getattr(self._local, "scope", None) or {})}
try:
self.meter(record)
except Exception as exc: # noqa: BLE001 - medir nunca derruba a chamada
log.debug("medição da chamada falhou: %s", exc)
def _call(self, provider: str, system: str, prompt: str, schema: dict, images: list[Path], search: bool, def _call(self, provider: str, system: str, prompt: str, schema: dict, images: list[Path], search: bool,
timeout: int, model: str) -> dict: timeout: int, model: str, effort: str = "") -> dict:
if provider == "codex": if provider == "codex":
return self._codex(system, prompt, schema, images, search, timeout, model) return self._codex(system, prompt, schema, images, search, timeout, model, effort)
if provider == "claude": if provider == "claude":
return self._claude(system, prompt, schema, images, search, timeout, model) return self._claude(system, prompt, schema, images, search, timeout, model)
if provider == "gemini": if provider == "gemini":
@@ -1066,7 +1554,7 @@ class Judge:
return result return result
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int, def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict: model: str, effort: str = "") -> dict:
cmd = find_codex() cmd = find_codex()
if not cmd: if not cmd:
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)", unavailable=True) raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)", unavailable=True)
@@ -1085,12 +1573,16 @@ class Judge:
instructions.write_text(system, encoding="utf-8") instructions.write_text(system, encoding="utf-8")
lean += ["-c", f"model_instructions_file='{instructions}'"] lean += ["-c", f"model_instructions_file='{instructions}'"]
stdin = prompt stdin = prompt
# Esforço de raciocínio por papel (Equipe de IA); padrão = low, o de sempre.
reasoning = effort if effort in ("low", "medium", "high") else "low"
# `--search` é opção global (antes de `exec`). Cada imagem com seu `-i`; o "-" (prompt pela entrada # `--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. # padrão) vem depois de uma opção de valor único para não ser lido como mais uma imagem.
# `--json`: eventos JSONL na saída padrão — o `turn.completed` traz o uso de tokens (medição F0).
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral", 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, "--sandbox", "read-only", "--json", "-c", f'model_reasoning_effort="{reasoning}"', *lean,
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"] "-m", model, *image_args, "--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
self._run(args, stdin, Path(tmp), timeout, "codex") result = self._run(args, stdin, Path(tmp), timeout, "codex")
self._local.usage = codex_usage(result.stdout.decode("utf-8", errors="replace"))
try: try:
return json.loads(out.read_text(encoding="utf-8")) return json.loads(out.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc: except (OSError, json.JSONDecodeError) as exc:
@@ -1120,6 +1612,7 @@ class Judge:
envelope = json.loads(result.stdout.decode("utf-8", errors="replace")) envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
except json.JSONDecodeError as exc: except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu JSON", unavailable=False) from exc raise JudgeError("o Claude não devolveu JSON", unavailable=False) from exc
self._local.usage = claude_usage(envelope)
if envelope.get("is_error"): if envelope.get("is_error"):
# Pode ser cota/login ("Credit balance is too low", "Not logged in"): o texto decide (unavailable=None). # Pode ser cota/login ("Credit balance is too low", "Not logged in"): o texto decide (unavailable=None).
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}") raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
@@ -1166,7 +1659,9 @@ class Judge:
short += " Frames anexados, na ordem: " + " ".join(refs) short += " Frames anexados, na ordem: " + " ".join(refs)
args = [*cmd, "-p", short, "-o", "json", "--approval-mode", "plan", "--skip-trust", "-m", model] args = [*cmd, "-p", short, "-o", "json", "--approval-mode", "plan", "--skip-trust", "-m", model]
result = self._run(args, stdin, Path(tmp), timeout, "gemini") result = self._run(args, stdin, Path(tmp), timeout, "gemini")
return parse_gemini_output(result.stdout.decode("utf-8", errors="replace")) stdout = result.stdout.decode("utf-8", errors="replace")
self._local.usage = gemini_usage(extract_json_object(stdout, fences=False) or {})
return parse_gemini_output(stdout)
def parse_gemini_output(stdout: str) -> dict: def parse_gemini_output(stdout: str) -> dict:
+33 -4
View File
@@ -85,19 +85,31 @@ HOOK_FONT = "Luckiest Guy" if "Luckiest Guy" in PACKAGED_FONTS else "Arial Black
# +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final. # +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final.
DURATION_MARGIN_S = 1.0 DURATION_MARGIN_S = 1.0
DURATION_SLACK_S = 0.1 DURATION_SLACK_S = 0.1
# Dublagem de desenvolvimento (app/dub.py): voz masculina pt-BR natural do serviço de voz (Edge, online); a das
# falas de outra pessoa é outra voz pt-BR nativa (Kokoro, offline), para não parecer o mesmo falando sozinho.
DUB_VOICE = "pt-br-antonio"
DUB_VOICE_OTHER = "kokoro-pm-alex"
DUB_DUCK = 0.25
VOICE_ID_RE = re.compile(r"^[a-z0-9][a-z0-9-]{1,47}$") # mesmo padrão do serviço de voz
DEFAULTS: dict = { DEFAULTS: dict = {
"layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34}, "layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34},
"caption": { "caption": {
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500", "enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3, "outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
# Fala de OUTRA pessoa (colega no Discord, voz do jogo): linha logo abaixo da do streamer, nesta cor;
# `otherSize` None = 85 % de `size` (doc/clipador/FALANTES.md).
"otherColor": "#5CE1FF", "otherSize": None,
# Legado (18/11/2026, manhã): virou `dev.translation`. Ainda lido por `dev_flags` (camadas já salvas). # Legado (18/11/2026, manhã): virou `dev.translation`. Ainda lido por `dev_flags` (camadas já salvas).
"translation": False, "translation": False,
}, },
# Camadas SÓ DE DESENVOLVIMENTO (doc/clipador/IDIOMAS.md): entram no vídeo de revisão (antes de aprovar) e NUNCA no # Camadas SÓ DE DESENVOLVIMENTO (doc/clipador/IDIOMAS.md): entram no vídeo de revisão (antes de aprovar) e NUNCA no
# vídeo final — o render com `dev=False` ignora este grupo inteiro. `translation`: português embaixo da legenda; # vídeo final — o render com `dev=False` ignora este grupo inteiro. `translation`: português embaixo da legenda;
# `dub`: dublagem em português por TTS com a voz original abaixada. # `dub`: dublagem em português por TTS com a voz original abaixada (app/dub.py, doc/clipador/DUBLAGEM.md):
"dev": {"translation": False, "dub": False}, # `dubVoice` = voz TTS pronta do catálogo (nunca clone do streamer), `dubVoiceOther` = voz das falas com
# `speaker: "other"`, `dubDuck` = volume do áudio original enquanto a dublagem toca (0–1).
"dev": {"translation": False, "dub": False, "dubVoice": DUB_VOICE, "dubVoiceOther": DUB_VOICE_OTHER,
"dubDuck": DUB_DUCK},
"credit": {"enabled": True, "position": "top", "size": 44}, "credit": {"enabled": True, "position": "top", "size": 44},
"duration": {"minS": 60, "maxS": 90, "backtrackS": 120}, "duration": {"minS": 60, "maxS": 90, "backtrackS": 120},
"format": {"aspect": "vertical"}, "format": {"aspect": "vertical"},
@@ -171,7 +183,7 @@ def validate(settings: dict) -> dict:
cap = settings.get("caption") cap = settings.get("caption")
if cap is not None: if cap is not None:
o = {} o = {}
for key in ("color", "highlight", "outline"): for key in ("color", "highlight", "outline", "otherColor"):
if key in cap: if key in cap:
if not HEX_RE.match(str(cap[key])): if not HEX_RE.match(str(cap[key])):
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB") raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
@@ -185,6 +197,10 @@ def validate(settings: dict) -> dict:
o[key] = int(cap[key]) o[key] = int(cap[key])
if not lo <= o[key] <= hi: if not lo <= o[key] <= hi:
raise LayoutError(f"caption.{key} vai de {lo} a {hi}") raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
if "otherSize" in cap:
o["otherSize"] = None if cap["otherSize"] in (None, "") else int(cap["otherSize"])
if o["otherSize"] is not None and not 30 <= o["otherSize"] <= 140:
raise LayoutError("caption.otherSize vai de 30 a 140 ou null = automático (85 % do tamanho)")
if "y" in cap: if "y" in cap:
o["y"] = None if cap["y"] is None else float(cap["y"]) 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: if o["y"] is not None and not 0.08 <= o["y"] <= 0.9:
@@ -197,7 +213,20 @@ def validate(settings: dict) -> dict:
if dev is not None: if dev is not None:
if not isinstance(dev, dict): if not isinstance(dev, dict):
raise LayoutError("dev precisa ser um objeto") raise LayoutError("dev precisa ser um objeto")
out["dev"] = {k: bool(dev[k]) for k in ("translation", "dub") if k in dev} o = {k: bool(dev[k]) for k in ("translation", "dub") if k in dev}
for key in ("dubVoice", "dubVoiceOther"):
if key in dev:
if not VOICE_ID_RE.match(str(dev[key] or "")):
raise LayoutError(f"dev.{key} precisa ser o id de uma voz do serviço de voz (ex.: {DUB_VOICE})")
o[key] = str(dev[key])
if "dubDuck" in dev:
try:
o["dubDuck"] = round(float(dev["dubDuck"]), 3)
except (TypeError, ValueError) as exc:
raise LayoutError("dev.dubDuck precisa ser número de 0 a 1") from exc
if not 0 <= o["dubDuck"] <= 1:
raise LayoutError("dev.dubDuck vai de 0 a 1 (volume do áudio original durante a dublagem)")
out["dev"] = o
cred = settings.get("credit") cred = settings.get("credit")
if cred is not None: if cred is not None:
o = {} o = {}
+100 -4
View File
@@ -25,7 +25,7 @@ from .scoring import Word
from .sources import SourceError, parse_source from .sources import SourceError, parse_source
from .subtitles import build_ass from .subtitles import build_ass
from .worker import Engine from .worker import Engine
from . import clip_delete, editor_api from . import clip_delete, editor_api, report
VERSION = "1.0.0" VERSION = "1.0.0"
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
@@ -96,6 +96,12 @@ class JudgeIn(BaseModel):
camDetect: 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. # Rastreio do rosto do streamer (face.py): reforça/cria cortes e vai em texto para o analista.
faceTrack: bool | None = None faceTrack: bool | None = None
# A IA lê o vídeo como linha do tempo JSON curta (novo); False = transcrição + chat + frames soltos (antigo).
timelineJson: bool | None = None
# Equipe de IA (doc/clipador/EQUIPE-IA.md): {scan|analyst|editor|judge: {enabled, provider, model, effort, extra,
# images, critical, allowFix, allowContextLine, penalty}}. None = não mexer (painel antigo: provider/model valem
# para todos os papéis). Validado campo a campo em roles.normalize_roles.
roles: dict | None = None
class GameIn(BaseModel): class GameIn(BaseModel):
@@ -152,6 +158,10 @@ class PreviewIn(BaseModel):
class ClipPatch(BaseModel): class ClipPatch(BaseModel):
status: Literal["approved", "rejected", "ready", "published"] | None = None status: Literal["approved", "rejected", "ready", "published"] | None = None
# Avaliação do dono (conjunto de avaliação do juiz): bom / ruim / sem contexto; "" limpa. Rejeitar com
# label "no_context" = "rejeitado: sem contexto".
label: Literal["good", "bad", "no_context", ""] | None = None
labelNote: str | None = Field(default=None, max_length=300)
title: str | None = Field(default=None, max_length=100) title: str | None = Field(default=None, max_length=100)
caption: str | None = Field(default=None, max_length=2200) caption: str | None = Field(default=None, max_length=2200)
startS: float | None = Field(default=None, ge=0) startS: float | None = Field(default=None, ge=0)
@@ -170,6 +180,19 @@ class ClipsDeleteIn(BaseModel):
confirmPublished: bool = False confirmPublished: bool = False
APPROVED = ("approved", "published") # estados em que o corte tem (ou espera) vídeo final
def final_view(row: dict) -> dict | None:
"""Vídeo final do corte (doc/clipador/REVISAO.md); None = sem final (não aprovado ou a aprovação foi desfeita)."""
if not row.get("final_status"):
return None
return {"status": row["final_status"], "file": row.get("final_file"), "thumb": row.get("final_thumb"),
"cover": row.get("final_cover"), "error": row.get("final_error"), "at": row.get("final_at"),
# O vídeo de revisão não tinha nenhuma camada de desenvolvimento: ele mesmo virou o final (sem render novo).
"reused": bool(row.get("final_file")) and row.get("final_file") == row.get("file")}
def clip_view(row: dict) -> dict: def clip_view(row: dict) -> dict:
return { return {
"id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"], "id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"],
@@ -181,6 +204,8 @@ def clip_view(row: dict) -> dict:
# e nos cortes de antes da migração v8, vale o padrão `vertical`. # e nos cortes de antes da migração v8, vale o padrão `vertical`.
"aspect": row.get("aspect") or "vertical", "aspect": row.get("aspect") or "vertical",
"createdAt": row["created_at"], "updatedAt": row["updated_at"], "createdAt": row["created_at"], "updatedAt": row["updated_at"],
# Avaliação do dono (bom / ruim / sem contexto) para medir o juiz; None = não marcou.
"ownerLabel": row.get("owner_label"), "ownerNote": row.get("owner_note"),
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"), "channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
# Idioma da sessão (resolvido no SELECT: o da sessão ou o padrão do serviço). Ausente só em consultas antigas. # Idioma da sessão (resolvido no SELECT: o da sessão ou o padrão do serviço). Ausente só em consultas antigas.
"language": row.get("language"), "language": row.get("language"),
@@ -191,9 +216,27 @@ def clip_view(row: dict) -> dict:
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"), "edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
"origin": row.get("edit_origin")} "origin": row.get("edit_origin")}
if row.get("edit_updated_at") else None), if row.get("edit_updated_at") else None),
# Revisão × final (doc/clipador/REVISAO.md). `file` é sempre o vídeo de REVISÃO (o da fila, para aprovar);
# `review.devLayers` = camadas de teste que entraram nele ([] = nenhuma; None = desconhecido).
"review": {"devLayers": loads(row.get("review_dev_json"), None)},
"final": final_view(row),
# O ÚNICO arquivo que pode ser publicado: o final pronto de um corte aprovado. None = ainda não (esperar).
"publishFile": row.get("final_file") if row["status"] in APPROVED and row.get("final_status") == "ready" else None,
} }
def game_detect_view(row: dict) -> dict | None:
"""O que o painel mostra da detecção do jogo: pistas guardadas, candidatos, sugestão de troca e quando checou."""
state = loads(row.get("game_detect_json"), None)
if not isinstance(state, dict):
return None
screen = state.get("screen") or {}
return {"checkedAt": state.get("checkedAt"), "candidates": state.get("candidates") or [],
"suggestion": state.get("suggestion"),
"platform": {"game": (state.get("platform") or {}).get("game", ""), "at": (state.get("platform") or {}).get("at")},
"screen": {k: screen.get(k, "") for k in ("game", "confidence", "evidence", "at")} if screen else None}
def session_view(row: dict, engine: Engine) -> dict: def session_view(row: dict, engine: Engine) -> dict:
counts = {r["status"]: r["n"] for r in engine.db.all( 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"])} "SELECT status, COUNT(*) AS n FROM clips WHERE session_id = ? GROUP BY status", row["id"])}
@@ -212,6 +255,9 @@ def session_view(row: dict, engine: Engine) -> dict:
# Contexto do jogo: categoria da plataforma, o que a IA viu na tela, trocas e se você corrigiu à mão. # 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", ""), "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", ""))), "gameHistory": loads(row.get("games_json"), []), "gameProfileReady": bool(engine.intel.profile(row.get("game", ""))),
# Detecção do jogo (doc/clipador/DETECCAO-JOGO.md): estado (user|agreed|probable|conflict|unknown), as pistas
# (categoria, tela), os candidatos com nota e, se o jogo confirmado por você parece ter mudado, a sugestão.
"gameStatus": row.get("game_status", ""), "gameDetect": game_detect_view(row),
"scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []), "scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []),
"camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"), "camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"),
"hasOwnSettings": bool(loads(row.get("settings_json"), {})), "hasOwnSettings": bool(loads(row.get("settings_json"), {})),
@@ -287,18 +333,25 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
# ---------- juiz (IA pela CLI: Codex/GPT ou Claude) # ---------- juiz (IA pela CLI: Codex/GPT ou Claude)
@app.get("/v1/judge") @app.get("/v1/judge")
def get_judge(): def get_judge():
return engine.judge_config() | {"models": engine.judge.models()} return engine.judge_config(full=True) | {"models": engine.judge.models()}
@app.put("/v1/judge") @app.put("/v1/judge")
def put_judge(body: JudgeIn): def put_judge(body: JudgeIn):
try: try:
engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS, engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS,
"vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack}) "vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack,
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel) | { "timelineJson": body.timelineJson})
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel, body.roles) | {
"models": engine.judge.models()} "models": engine.judge.models()}
except JudgeError as exc: except JudgeError as exc:
raise UserError(str(exc)) from exc raise UserError(str(exc)) from exc
@app.get("/v1/judge/report")
def judge_report(days: float = Query(default=7, gt=0, le=365), session: int | None = None):
"""Medição da Equipe de IA (F0): chamadas e tokens por papel/IA, por hora de live; taxa de aprovação; o que o
juiz de contexto decidiu; e a concordância juiz × dono nos cortes que você avaliou."""
return report.build(db, days=days, session_id=session)
# ---------- configuração do corte (layout, câmera, legenda, crédito, duração) # ---------- 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: 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, return {"own": own, "effective": layout.merge(channel_layer, session_layer), "defaults": layout.DEFAULTS,
@@ -391,6 +444,8 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
at, frame = _frame(row, body.t, "preview-src.jpg", width=0) 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. # 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())] sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
# E a fala de outra pessoa (colega no Discord), na linha de baixo, com a cor dela (FALANTES.md).
sample += [Word(0.05 + i * 0.35, 0.35 + i * 0.35, w, "other1") for i, w in enumerate("E A DO COLEGA".split())]
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg) ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
out = settings.clips_dir / str(row["id"]) / "preview.jpg" out = settings.clips_dir / str(row["id"]) / "preview.jpg"
try: try:
@@ -419,6 +474,13 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
raise UserError("`to` precisa ser maior que `from`.") raise UserError("`to` precisa ser maior que `from`.")
return engine.face.view(_session(session_id), from_, to) return engine.face.view(_session(session_id), from_, to)
@app.get("/v1/sessions/{session_id}/speakers")
def get_speakers(session_id: int):
"""Vozes da sessão (doc/clipador/FALANTES.md): quantas, qual é o streamer e por quê (boca/volume), fala por
rótulo. `active: false` = sem prova suficiente: tudo fica como do streamer."""
_session(session_id)
return engine.speakers.view(session_id)
@app.post("/v1/sessions/{session_id}/face/reset") @app.post("/v1/sessions/{session_id}/face/reset")
def reset_face(session_id: int): 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 """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
@@ -433,8 +495,20 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
"""Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais.""" """Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais."""
_session(session_id) _session(session_id)
engine.intel.set_game(session_id, body.name.strip(), "user") engine.intel.set_game(session_id, body.name.strip(), "user")
engine.intel.detect_game(session_id) # grava o estado "confirmado" e limpa a sugestão
return session_view(_session(session_id), engine) return session_view(_session(session_id), engine)
@app.post("/v1/sessions/{session_id}/game/detect")
def detect_game(session_id: int):
""""Detectar agora": a IA olha frames recentes, cruza com categoria, título, chat e fala e atualiza o jogo.
Jogo confirmado por você não muda (só aparece como sugestão). Leva de 10 s a 1 min (chamada à IA)."""
_session(session_id)
try:
result = engine.intel.detect_game_now(session_id)
except JudgeError as exc:
raise UserError(str(exc)) from exc
return {"result": result, "session": session_view(_session(session_id), engine)}
def game_view(g: dict) -> dict: def game_view(g: dict) -> dict:
# `profile` = português (o painel mostra); `profileAi` = inglês (vai nos prompts; null = jogo antigo, a IA # `profile` = português (o painel mostra); `profileAi` = inglês (vai nos prompts; null = jogo antigo, a IA
# usa `profile`). Contrato em doc/clipador/JOGOS.md. # usa `profile`). Contrato em doc/clipador/JOGOS.md.
@@ -735,6 +809,11 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
status = body.status or row["status"] status = body.status or row["status"]
if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"): if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"):
raise UserError("Só dá para aprovar um corte já renderizado.") raise UserError("Só dá para aprovar um corte já renderizado.")
if body.label is not None or body.labelNote is not None:
# Avaliação do dono: vale para qualquer corte (inclusive antigos e descartados), sem mexer no estado.
label = row.get("owner_label") if body.label is None else (body.label or None)
note = row.get("owner_note") if body.labelNote is None else (body.labelNote.strip() or None)
db.run("UPDATE clips SET owner_label = ?, owner_note = ? WHERE id = ?", label, note, clip_id)
if retime: if retime:
status = "pending" # novo trecho → renderiza de novo status = "pending" # novo trecho → renderiza de novo
db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?", db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?",
@@ -743,6 +822,11 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
if retime: if retime:
editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto
engine.wake_clips.set() engine.wake_clips.set()
# Aprovou → pede o vídeo final (sem camadas de teste); desaprovou/mudou o trecho → o final deixa de valer.
if status in APPROVED and row["status"] not in APPROVED:
engine.queue_final(clip_id)
elif row["status"] in APPROVED and status not in APPROVED:
engine.drop_final(clip_id)
if body.status in ("approved", "rejected") and body.status != row["status"]: 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). # 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) engine.intel.learn_from_clip(row, positive=body.status == "approved", mark=True)
@@ -753,9 +837,20 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
"""Força o render (ex.: corte que a IA descartou ou que deu erro).""" """Força o render (ex.: corte que a IA descartou ou que deu erro)."""
_clip(clip_id) _clip(clip_id)
db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id) db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id)
engine.drop_final(clip_id)
engine.wake_clips.set() engine.wake_clips.set()
return clip_view(_clip(clip_id)) return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/final")
def render_final(clip_id: int):
"""(Re)gera o vídeo final de um corte aprovado ("tentar de novo" depois de um erro). 409 se não aprovado."""
row = _clip(clip_id)
if row["status"] not in APPROVED:
raise UserError("Só corte aprovado tem vídeo final. Aprove o corte primeiro.", 409)
if row.get("final_status") not in ("pending", "rendering"):
engine.queue_final(clip_id)
return clip_view(_clip(clip_id))
@app.post("/v1/clips/{clip_id}/translate") @app.post("/v1/clips/{clip_id}/translate")
def translate_clip(clip_id: int): def translate_clip(clip_id: int):
"""Traduz (de novo) a fala do corte para o português. Só para fonte em inglês; 409 se não couber.""" """Traduz (de novo) a fala do corte para o português. Só para fonte em inglês; 409 se não couber."""
@@ -768,6 +863,7 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
def rejudge(clip_id: int): def rejudge(clip_id: int):
_clip(clip_id) _clip(clip_id)
db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id) db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id)
engine.drop_final(clip_id)
engine.wake_clips.set() engine.wake_clips.set()
return clip_view(_clip(clip_id)) return clip_view(_clip(clip_id))
+37
View File
@@ -153,6 +153,43 @@ def grab_frame(ffmpeg: str, segments: list[tuple[Path, float, float]], t: float,
return out_file return out_file
MOSAIC_TILE_W, MOSAIC_TILE_H = 384, 216
MOSAIC_COLS, MOSAIC_ROWS = 4, 2
def mosaic(ffmpeg: str, images: list[Path], out_file: Path, cols: int = MOSAIC_COLS, rows: int = MOSAIC_ROWS,
tile_w: int = MOSAIC_TILE_W, tile_h: int = MOSAIC_TILE_H) -> Path:
"""Vários quadros numa imagem só (grade `cols`×`rows`, da esquerda para a direita e de cima para baixo), cada um
em `tile_w`×`tile_h` (barras pretas se o quadro não for 16:9). Com menos quadros que a grade, a grade encolhe
(até 4 → uma linha só). Para a IA: 1 imagem no lugar de 8 (Claude = 1 leitura; Gemini cobra por imagem)."""
images = [Path(p) for p in images][: cols * rows]
if not images:
raise MediaError("mosaico sem quadros")
n = len(images)
if n <= cols:
cols, rows = n, 1
else:
rows = math.ceil(n / cols)
out_file.parent.mkdir(parents=True, exist_ok=True)
inputs = [arg for img in images for arg in ("-i", str(img))]
fit = (f"scale={tile_w}:{tile_h}:force_original_aspect_ratio=decrease,"
f"pad={tile_w}:{tile_h}:(ow-iw)/2:(oh-ih)/2,setsar=1")
chains = [f"[{i}:v]{fit}[t{i}]" for i in range(n)]
# Grade incompleta (ex.: 6 quadros em 4×2): completa com quadro preto do mesmo tamanho.
pads = cols * rows - n
for k in range(pads):
chains.append(f"color=c=black:s={tile_w}x{tile_h}:d=1[p{k}]")
labels = [f"[t{i}]" for i in range(n)] + [f"[p{k}]" for k in range(pads)]
layout_cells = "|".join(f"{(i % cols) * tile_w}_{(i // cols) * tile_h}" for i in range(cols * rows))
if cols * rows == 1:
graph = chains[0].replace("[t0]", "[out]")
else:
graph = ";".join(chains) + ";" + "".join(labels) + f"xstack=inputs={cols * rows}:layout={layout_cells}[out]"
run([ffmpeg, "-y", "-v", "error", *inputs, "-filter_complex", graph, "-map", "[out]", "-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: 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). """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`).""" `reframe` = reenquadramento parado do jogo (capa de um corte com keyframes; ver `reframe.static_reframe`)."""
+486 -25
View File
@@ -7,7 +7,10 @@ rosto do YuNet) e transforma em:
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela - 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 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; 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; - picos rotulados (risada, grito, susto, choque, confuso, raiva e, desde 18/11/2026, gargalhada, medo, espanto,
nojo, tristeza, tenso; bocejo não é reação) com o início da reação, e um texto curto para o juiz;
- o corpo/cabeça mesmo sem expressão (balançando, acenando, agitado, chegou perto, saiu do quadro) e o mapa de
expressões por segundo (doc/clipador/EXPRESSOES.md);
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados. - 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. Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
@@ -28,6 +31,35 @@ EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "br
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s) 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") SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
# --- Mapa de expressões (18/11/2026, doc/clipador/EXPRESSOES.md). Tudo OPCIONAL na série: o que foi gravado antes
# não tem estes campos e continua valendo (canal ausente = parado, nunca vira pico).
# Expressões a mais dos 52 blendshapes (máximo do segundo). `noseSneer*` e `cheekSquint*` saem ~0 SEMPRE no modelo do
# MediaPipe (medido em 4 sessões): nojo e raiva não podem depender deles — o lábio de cima (`upper_lip`) faz o papel.
EXTRA_EXPRESSION_CHANNELS: tuple[str, ...] = (
"brow_inner", # browInnerUp sozinho (medo/tristeza; `brow` junta a interna e a externa)
"mouth_frown", # cantos da boca para baixo (tristeza)
"squint", # olhos semicerrados (raiva/tensão)
"press", # lábios apertados (tensão/raiva)
"stretch", # boca esticada para os lados (medo, careta)
"upper_lip", # lábio de cima levantado (nojo; sobe junto na gargalhada)
"pucker", # boca em "O" (bico ou funil: espanto, "uuuh")
)
POSE_FIELDS: tuple[str, ...] = ("yaw", "pitch", "roll") # graus, média do segundo (matriz de transformação facial)
# Corpo/cabeça: `shake`/`nod` = idas e voltas da cabeça (yaw/pitch) na janela de 2 s que começa 0,5 s antes do segundo;
# `head` = fração dos quadros com a CABEÇA visível (rosto com pontos OU só a caixa do detector, quando o MediaPipe
# perde o rosto de perfil); `head_motion` = caminho da cabeça em tamanhos de cabeça por segundo, sem os saltos de
# reaquisição; `hsize` = tamanho da caixa do detector nos quadros sem pontos (quem se inclina para a câmera de perfil).
BODY_FIELDS: tuple[str, ...] = ("shake", "nod", "head", "head_motion", "hsize")
EXTRA_SECOND_FIELDS: tuple[str, ...] = EXTRA_EXPRESSION_CHANNELS + POSE_FIELDS + BODY_FIELDS
_ONE_DECIMAL: frozenset[str] = frozenset(POSE_FIELDS + ("shake", "nod")) # graus e contagens: 1 casa basta
# Rótulos que não são reação: o pico sai como o "neutro" (bocejo abre a boca como grito, mas não é momento de corte).
NOT_REACTION: frozenset[str] = frozenset({"neutro", "bocejo"})
# Todos os rótulos de expressão (`label`, `yawn_seconds` e "alegria" do mapa); os de corpo estão em `BODY_PRIORITY`.
EXPRESSION_LABELS: tuple[str, ...] = (
"risada", "gargalhada", "alegria", "grito", "susto", "medo", "choque", "espanto", "confuso", "raiva", "nojo",
"tristeza", "tenso", "bocejo", "neutro",
)
@dataclass(frozen=True) @dataclass(frozen=True)
class ReactionParams: class ReactionParams:
@@ -62,6 +94,42 @@ class ReactionParams:
raw_thresholds: dict[str, float] = field(default_factory=lambda: { 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, "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) }) # usados pelo `label` quando não há z (segundo isolado)
# --- expressões a mais (EXTRA_EXPRESSION_CHANNELS) e corpo; calibrado em doc/clipador/EXPRESSOES.md ---
extra_floors: dict[str, float] = field(default_factory=lambda: {
"brow_inner": 0.10, "mouth_frown": 0.05, "squint": 0.06, "press": 0.08, "stretch": 0.06, "upper_lip": 0.10,
"pucker": 0.12, "head_motion": 0.15,
})
# Peso de cada expressão nova na INTENSIDADE (0 = só rotula). Ver o doc: com peso, viram picos sozinhas.
extra_weights: dict[str, float] = field(default_factory=lambda: {
"brow_inner": 0.0, "mouth_frown": 0.0, "squint": 0.0, "press": 0.0, "stretch": 0.0, "upper_lip": 0.0,
"pucker": 0.0,
})
extra_raw: dict[str, float] = field(default_factory=lambda: {
"brow_inner": 0.5, "mouth_frown": 0.3, "squint": 0.7, "press": 0.5, "stretch": 0.3, "upper_lip": 0.4,
"pucker": 0.6,
}) # limiares absolutos das expressões novas para o `label` sem z
yawn_jaw_raw: float = 0.5 # bocejo: boca muito aberta por ≥ `yawn_min_s` segundos seguidos…
yawn_min_s: int = 2
yawn_squint_z: float = 1.0 # …com os olhos apertando em algum deles (ver `yawn_seconds`)
disgust_smile_max: float = 0.3 # nojo só com o sorriso abaixo disto (valor absoluto)
laugh_jaw_raw: float = 0.3 # risada de boca escancarada = gargalhada
head_back_deg: float = 20.0 # cabeça jogada para trás: X graus acima do neutro dele (com risada = gargalhada)
map_z: float = 2.0 # mapa: segundo com sinal ≥ isto ganha rótulo de expressão (abaixo de `threshold`, sorriso = alegria)
# Corpo/cabeça
shake_deg: float = 8.0 # ida ou volta de pelo menos X graus no yaw conta como uma "perna" do balanço
nod_deg: float = 6.0 # idem no pitch (aceno)
osc_legs: int = 3 # pernas na janela de 2 s para "balançando"/"acenando" (2 = olhou para o lado e voltou)
head_min: float = 0.8 # cabeça visível em ≥ 80 % do segundo para o movimento valer (senão é o rastreio pulando)
head_max_step: float = 1.0 # passo máximo entre dois quadros, em tamanhos de cabeça (mais que isso = reaquisição)
agitation_z: float = 2.5 # agitação: movimento da cabeça com z ≥ isto…
agitation_window_s: int = 5 # …em pelo menos `agitation_min_s` segundos de uma janela deste tamanho
agitation_min_s: int = 3
lean_ratio: float = 1.18 # chegou perto: cabeça ≥ 18 % maior que o tamanho normal dele (p99,9 nas sessões 8/15)…
lean_min_s: int = 1 # …por pelo menos isto
leave_before_s: int = 3 # saiu do quadro: cabeça visível por ≥ 3 s…
leave_gone_s: int = 3 # …e depois sumida por ≥ 3 s (só com o campo `head`: série antiga não diz "saiu")
leave_gone_max: float = 0.1 # "sumida" = cabeça em no máximo 10 % dos quadros do segundo
leave_transition_s: int = 2 # segundos com a cabeça só em parte do quadro entre o "visível" e o "fora"
# --- câmera (locate_cam) --- # --- câmera (locate_cam) ---
min_score: float = 0.6 # confiança mínima da detecção 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 # 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
@@ -91,6 +159,9 @@ class FaceSample:
cy: float = 0.0 cy: float = 0.0
size: float = 0.0 size: float = 0.0
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…) blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
pose: tuple[float, float, float] | None = None # (yaw, pitch, roll) em graus; None = sem matriz de transformação
# Só a caixa da cabeça (detector), sem pontos nem blendshapes: `present` fica False e `cx`/`cy`/`size` são da caixa.
head: bool = False
@dataclass @dataclass
@@ -109,20 +180,37 @@ class FaceSecond:
brow: float | None = None brow: float | None = None
blink: float | None = None blink: float | None = None
motion: float | None = None motion: float | None = None
# Mapa de expressões (EXTRA_SECOND_FIELDS): opcionais, ausentes na série gravada antes de 18/11/2026.
brow_inner: float | None = None
mouth_frown: float | None = None
squint: float | None = None
press: float | None = None
stretch: float | None = None
upper_lip: float | None = None
pucker: float | None = None
yaw: float | None = None
pitch: float | None = None
roll: float | None = None
shake: float | None = None
nod: float | None = None
head: float | None = None
head_motion: float | None = None
hsize: float | None = None
def to_json(self) -> dict: def to_json(self) -> dict:
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`.""" """Formato compacto para o banco/API: 3 casas (graus e contagens: 1), sem os campos `None`."""
out: dict = {"t": self.t, "present": round(self.present, 3)} out: dict = {"t": self.t, "present": round(self.present, 3)}
for name in SECOND_FIELDS: for name in SECOND_FIELDS + EXTRA_SECOND_FIELDS:
value = getattr(self, name) value = getattr(self, name)
if value is not None: if value is not None:
out[name] = round(value, 3) out[name] = round(value, 1 if name in _ONE_DECIMAL else 3)
return out return out
@classmethod @classmethod
def from_json(cls, data: dict) -> FaceSecond: def from_json(cls, data: dict) -> FaceSecond:
return cls(int(data["t"]), float(data.get("present", 0.0)), 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}) **{n: (float(data[n]) if data.get(n) is not None else None)
for n in SECOND_FIELDS + EXTRA_SECOND_FIELDS})
@dataclass @dataclass
@@ -177,13 +265,102 @@ def _channels(blend: dict[str, float]) -> dict[str, float]:
} }
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> list[FaceSecond]: def _extra_channels(blend: dict[str, float]) -> dict[str, float]:
"""Blendshapes do MediaPipe → expressões novas do mapa (EXTRA_EXPRESSION_CHANNELS), 0..1."""
def g(name: str) -> float:
return float(blend.get(name, 0.0))
return {
"brow_inner": g("browInnerUp"),
"mouth_frown": (g("mouthFrownLeft") + g("mouthFrownRight")) / 2,
"squint": (g("eyeSquintLeft") + g("eyeSquintRight")) / 2,
"press": (g("mouthPressLeft") + g("mouthPressRight")) / 2,
"stretch": (g("mouthStretchLeft") + g("mouthStretchRight")) / 2,
"upper_lip": (g("mouthUpperUpLeft") + g("mouthUpperUpRight")) / 2,
"pucker": max(g("mouthPucker"), g("mouthFunnel")),
}
def zigzag_legs(values: list[float], delta: float) -> list[float]:
"""Pernas de um zigue-zague com histerese `delta`: cada ida ou volta de pelo menos `delta` (amplitude).
Cabeça parada com tremida < `delta` → nenhuma perna; olhar para o lado e voltar → 2; balançar → 3 ou mais.
"""
legs: list[float] = []
if not values:
return legs
start = extreme = values[0]
direction = 0
for v in values[1:]:
if direction == 0:
if abs(v - start) >= delta:
direction, extreme = (1 if v > start else -1), v
legs.append(abs(v - start))
continue
if (v - extreme) * direction > 0: # continua na mesma direção: a perna cresce
legs[-1] += abs(v - extreme)
extreme = v
elif abs(v - extreme) >= delta: # virou com folga: perna nova
legs.append(abs(v - extreme))
direction, extreme = -direction, v
return legs
def _body_fields(out: list[FaceSecond], samples: list[FaceSample], first: int, p: ReactionParams) -> None:
"""Preenche pose, balanço/aceno e cabeça (EXTRA: série antiga não tem nada disto)."""
ordered = sorted(samples, key=lambda s: s.t)
posed = [s for s in ordered if s.present and s.pose is not None]
posed_t = [s.t for s in posed]
# Movimento da cabeça: passos entre quadros vizinhos da MESMA fonte (pontos × caixa do detector têm tamanhos
# diferentes), sem buraco de quadro perdido no meio e com o passo limitado: o "pulo" da reaquisição do rosto era o
# maior pico de movimento da live real.
visible = [s for s in ordered if (s.present or s.head) and s.size > 0]
paths = [0.0] * len(out)
for a, b in zip(visible, visible[1:]):
i = int(math.floor(b.t)) - first
if 0 <= i < len(out) and a.present == b.present and b.t - a.t <= 0.4:
step = (math.hypot(b.cx - a.cx, b.cy - a.cy) + abs(b.size - a.size)) / max(1e-6, (a.size + b.size) / 2)
paths[i] += min(step, p.head_max_step)
buckets: list[list[FaceSample]] = [[] for _ in out]
for s in ordered:
i = int(math.floor(s.t)) - first
if 0 <= i < len(out):
buckets[i].append(s)
for i, second in enumerate(out):
bucket = buckets[i]
if not bucket:
continue
seen = [s for s in bucket if (s.present or s.head) and s.size > 0]
second.head = len(seen) / len(bucket)
if seen:
second.head_motion = paths[i]
boxes = [s for s in seen if not s.present]
if boxes:
second.hsize = _mean([s.size for s in boxes])
poses = [s.pose for s in bucket if s.present and s.pose is not None]
if not poses:
continue
second.yaw, second.pitch, second.roll = (_mean([q[k] for q in poses]) for k in range(3))
# Janela de 2 s a partir de 0,5 s antes: um balanço de ~2 Hz a 6 qps tem 1–2 quadros por perna.
lo = bisect.bisect_left(posed_t, second.t - 0.5)
hi = bisect.bisect_left(posed_t, second.t + 1.5)
window = posed[lo:hi]
gaps = [b.t - a.t for a, b in zip(window, window[1:])]
if len(window) >= 6 and (not gaps or max(gaps) <= 0.4):
second.shake = float(len(zigzag_legs([s.pose[0] for s in window], p.shake_deg)))
second.nod = float(len(zigzag_legs([s.pose[1] for s in window], p.nod_deg)))
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0,
params: ReactionParams | None = None) -> list[FaceSecond]:
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s). """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); 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 `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. pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
Mapa de expressões: expressões novas (máximo), pose (média), balanço/aceno e cabeça — ver `_body_fields`.
""" """
p = params or ReactionParams()
n = max(0, int(math.ceil(duration_s))) n = max(0, int(math.ceil(duration_s)))
first = int(math.floor(start_s)) first = int(math.floor(start_s))
buckets: list[list[FaceSample]] = [[] for _ in range(n)] buckets: list[list[FaceSample]] = [[] for _ in range(n)]
@@ -204,6 +381,10 @@ def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.
second.size = _mean([s.size for s in faces]) second.size = _mean([s.size for s in faces])
for name in ("smile", "jaw", "surprise", "frown", "brow"): for name in ("smile", "jaw", "surprise", "frown", "brow"):
setattr(second, name, max(c[name] for c in channels)) setattr(second, name, max(c[name] for c in channels))
if any(s.blend for s in faces): # plano B (sem blendshapes) não inventa expressão nova
extra = [_extra_channels(s.blend) for s in faces]
for name in EXTRA_EXPRESSION_CHANNELS:
setattr(second, name, max(c[name] for c in extra))
second.blink = _mean([c["blink"] for c in channels]) second.blink = _mean([c["blink"] for c in channels])
path = 0.0 path = 0.0
for s in faces: for s in faces:
@@ -213,6 +394,7 @@ def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.
previous = s previous = s
second.motion = path second.motion = path
out.append(second) out.append(second)
_body_fields(out, samples, first, p)
return out return out
@@ -262,13 +444,71 @@ def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -
if second.present < p.motion_min_present: if second.present < p.motion_min_present:
z["motion"] = 0.0 z["motion"] = 0.0
out.append(z) out.append(z)
_extra_z(seconds, face_idx, out, p)
return out return out
def rolling_baseline(seconds: list[FaceSecond], idx: list[int], name: str, floor: float,
p: ReactionParams) -> dict[int, tuple[float, float]]:
"""(mediana, desvio robusto) do campo `name` no neutro recente, para cada índice de `idx` (que já deve conter só
segundos com o campo). Mesma janela do `channel_z`; com menos de `min_baseline_n` segundos na série inteira,
devolve {} — canal novo numa série que mal começou a tê-lo não vira pico."""
if len(idx) < p.min_baseline_n:
return {}
values = [float(getattr(seconds[i], name)) for i in idx]
cache: dict[tuple[int, int], tuple[float, float]] = {}
out: dict[int, tuple[float, float]] = {}
for i in idx:
anchor = i - i % BASELINE_STEP_S
lo = bisect.bisect_left(idx, anchor - p.baseline_s)
hi = bisect.bisect_left(idx, anchor - p.exclude_recent_s)
if hi - lo < p.min_baseline_n:
lo, hi = 0, len(idx)
if (lo, hi) not in cache:
cache[(lo, hi)] = _robust(values[lo:hi], floor)
out[i] = cache[(lo, hi)]
return out
def _extra_z(seconds: list[FaceSecond], face_idx: list[int], out: list[dict[str, float] | None],
p: ReactionParams) -> None:
"""z das expressões novas e "cabeça para trás" (graus acima do neutro), no mesmo dict do `channel_z`.
Ao contrário dos canais antigos, o neutro de um canal novo usa SÓ os segundos que têm o campo: numa sessão em
que o serviço foi atualizado no meio, os segundos antigos (sem o campo) não podem virar um neutro de zeros.
"""
for name in EXTRA_EXPRESSION_CHANNELS:
idx = [i for i in face_idx if getattr(seconds[i], name) is not None]
base = rolling_baseline(seconds, idx, name, p.extra_floors.get(name, p.mad_floor), p)
for i in face_idx:
z = out[i]
if z is None:
continue
value = getattr(seconds[i], name)
if i in base and value is not None:
median, spread = base[i]
z[name] = (value - median) / spread
else:
z[name] = 0.0
# Pitch diminui quando a cabeça vai para trás (olhar para cima): "head_back" = neutro − pitch, em graus.
idx = [i for i in face_idx if seconds[i].pitch is not None]
base = rolling_baseline(seconds, idx, "pitch", 1.0, p)
for i in face_idx:
z = out[i]
if z is not None:
pitch = seconds[i].pitch
z["head_back"] = (base[i][0] - pitch) if (i in base and pitch is not None) else 0.0
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None: def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
if z is None: if z is None:
return None return None
return max(0.0, max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS)) signal = max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS)
for name in EXTRA_EXPRESSION_CHANNELS:
weight = p.extra_weights.get(name, 0.0)
if weight > 0:
signal = max(signal, weight * z.get(name, 0.0))
return max(0.0, signal)
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None, def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
@@ -285,42 +525,75 @@ def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str: 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. """Rótulo da expressão do segundo (um de `EXPRESSION_LABELS`; bocejo e alegria precisam de contexto e saem de
`yawn_seconds`/`expression_map`).
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
absolutos (`raw_thresholds`). absolutos (`raw_thresholds`, `extra_raw`).
Regras (calibradas na live real, doc/FACE_BAKEOFF.md): Regras (calibradas na live real, doc/FACE_BAKEOFF.md e doc/clipador/EXPRESSOES.md), na ordem:
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada, - **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 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); streamer que já sorri o tempo todo o sorriso não tem para onde subir); com a cabeça jogada para trás =
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real: **gargalhada**;
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**;
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça; - **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
- **medo** = sobrancelha interna levantada + boca esticada para os lados (ou olho arregalado com a sobrancelha
descendo) — sem isso, olho arregalado é choque;
- **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**; olhos semicerrados + lábios
apertados com a sobrancelha descendo também é raiva; lábio de cima subindo com o sorriso já alto é risada;
- **nojo** = lábio de cima levantado sem sorriso e de boca fechada (`noseSneer` não funciona no MediaPipe);
- **tristeza** = cantos da boca para baixo + sobrancelha interna levantada, sem bico nem boca esticada (mão na
boca faz os dois);
- **espanto** = boca em "O" com a sobrancelha levantada ou a boca abrindo;
- **choque** = olho arregalado parado; - **choque** = olho arregalado parado;
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média - **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
contra 0,02 no calmo). contra 0,02 no calmo);
- **tenso** = lábios apertados + olhos semicerrados, sem sorriso (foco, tensão).
""" """
p = params or ReactionParams() p = params or ReactionParams()
if second.smile is None: if second.smile is None:
return "neutro" return "neutro"
if z is not None: if z is not None:
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS} on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS + EXTRA_EXPRESSION_CHANNELS}
half = {name: z.get(name, 0.0) >= p.label_z / 2 for name in SIGNAL_CHANNELS + EXTRA_EXPRESSION_CHANNELS}
head_back = z.get("head_back", 0.0) >= p.head_back_deg
else: else:
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS} on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
on |= {name: (getattr(second, name) or 0.0) >= p.extra_raw[name] for name in EXTRA_EXPRESSION_CHANNELS}
half = {name: on[name] for name in on}
head_back = False
smiling_raw = second.smile >= p.smile_raw smiling_raw = second.smile >= p.smile_raw
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])): jaw = second.jaw or 0.0
return "risada" # Lábio de cima subindo com o sorriso já alto = rindo mostrando os dentes (sessão 8: 0,6–0,8 nas risadas).
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"] or on["upper_lip"])):
return "gargalhada" if head_back else "risada"
if (on["surprise"] or on["brow"]) and on["motion"]: if (on["surprise"] or on["brow"]) and on["motion"]:
return "susto" return "susto"
# Medo × choque (FACS): os dois levantam a sobrancelha e arregalam o olho; o medo estica a boca para os lados
# (AU20) ou junta a sobrancelha descendo (AU4).
if on["brow_inner"] and (on["stretch"] or (on["surprise"] and half["frown"])):
return "medo"
if on["jaw"]: if on["jaw"]:
return "grito" return "grito"
if on["frown"]: if on["frown"]:
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva" return "grito" if jaw >= p.shout_jaw_raw else "raiva"
if on["squint"] and on["press"] and half["frown"]:
return "raiva"
# Nojo só sem sorriso: o lábio de cima sobe junto em toda risada de dentes à mostra.
if on["upper_lip"] and not half["jaw"] and second.smile < p.disgust_smile_max:
return "nojo"
# Mão na boca (tique comum: queixo apoiado, coçar o nariz) faz bico e estica a boca: aí não é tristeza.
if on["mouth_frown"] and half["brow_inner"] and not on["pucker"] and not on["stretch"]:
return "tristeza"
if on["pucker"] and (on["brow"] or half["jaw"]):
return "espanto"
if on["surprise"]: if on["surprise"]:
return "choque" return "choque"
if on["brow"]: if on["brow"]:
return "confuso" return "confuso"
if on["press"] and on["squint"]:
return "tenso"
return "neutro" return "neutro"
@@ -351,9 +624,10 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
run[i] = current run[i] = current
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i]) candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
chosen: list[tuple[int, str]] = [] chosen: list[tuple[int, str]] = []
yawns = yawn_seconds(seconds, zs, p)
for peak in candidates: for peak in candidates:
name = _peak_label(seconds, zs, peak, p) name = _peak_label(seconds, zs, peak, p, yawns)
if name == "neutro" and not p.keep_neutral: if name in NOT_REACTION and not p.keep_neutral:
continue continue
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento. # 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): if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
@@ -372,12 +646,32 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
return moments return moments
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str: def yawn_seconds(seconds: list[FaceSecond], zs: list[dict[str, float] | None], p: ReactionParams) -> set[int]:
"""Índices dos segundos de bocejo: boca muito aberta (jawOpen ≥ `yawn_jaw_raw`) por ≥ `yawn_min_s` segundos
seguidos, com os olhos apertando (z do `squint` ≥ `yawn_squint_z`) em algum deles.
Sessão 8 (skipnho, fim de live): os 5 trechos com jawOpen ≥ 0,6 por 3 s eram todos bocejos (olhos fechados,
braços esticando) e eram os maiores "gritos" da sessão (z 12–16); os gritos e exclamações de verdade abriram a
boca assim por 1 s só. O bocejo também levanta o "sorriso" (cantos esticados): por isso vem antes da risada.
"""
wide = [(s.jaw or 0.0) >= p.yawn_jaw_raw and zs[i] is not None for i, s in enumerate(seconds)]
out: set[int] = set()
for i, j in _runs(wide, 0):
if j - i + 1 >= p.yawn_min_s and any((zs[k] or {}).get("squint", 0.0) >= p.yawn_squint_z
for k in range(i, j + 1)):
out.update(range(i, j + 1))
return out
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams,
yawns: set[int] | None = None) -> str:
if yawns and peak in yawns:
return "bocejo"
name = label(seconds[peak], zs[peak], p) name = label(seconds[peak], zs[peak], p)
if name == "neutro": if name == "neutro":
for j in (peak - 1, peak + 1): for j in (peak - 1, peak + 1):
if 0 <= j < len(seconds) and zs[j] is not None: if 0 <= j < len(seconds) and zs[j] is not None:
other = label(seconds[j], zs[j], p) other = "bocejo" if yawns and j in yawns else label(seconds[j], zs[j], p)
if other != "neutro": if other != "neutro":
return other return other
return name return name
@@ -385,32 +679,199 @@ def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], pe
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None, def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
params: ReactionParams | None = None, max_items: int = 4, params: ReactionParams | None = None, max_items: int = 4,
moments: list[ReactionMoment] | None = None, relative: bool = True) -> str: moments: list[ReactionMoment] | None = None, relative: bool = True,
body: list[BodyMoment] | None = None) -> str:
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho. """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. 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` 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). 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. `relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
Corpo/cabeça (`body_moments`, ou `body` já calculado) entra no fim: "balançando a cabeça em 15 s". Com a cabeça
visível mas sem expressão legível (de perfil, longe), o texto diz isso e traz só o corpo.
""" """
p = params or ReactionParams() p = params or ReactionParams()
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s) 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] inside = [s for s in seconds if start_s <= s.t <= end]
def when(t: float) -> str:
return f"{int(round(t - start_s))} s" if relative else f"{t:.0f}s"
body_parts = [f"{BODY_TEXT.get(b.label, b.label)} em {when(b.peak_s)}"
for b in (body if body is not None else body_moments(seconds, p)) if start_s <= b.peak_s <= end]
with_face = [s for s in inside if _has_face(s, p)] with_face = [s for s in inside if _has_face(s, p)]
if not with_face: if not with_face:
heads = [s for s in inside if (s.head or 0.0) >= p.min_present]
if not inside or len(heads) < max(1, len(inside) // 3):
return "rosto do streamer não aparece no trecho" return "rosto do streamer não aparece no trecho"
text = (f"rosto sem expressão legível (de perfil ou longe; cabeça visível em "
f"{int(round(100 * len(heads) / len(inside)))}% do trecho)")
return text + ("; " + "; ".join(body_parts[:max_items]) if body_parts else "; sem movimento marcante")
parts = [] parts = []
for m in (moments if moments is not None else reaction_moments(seconds, p)): for m in (moments if moments is not None else reaction_moments(seconds, p)):
if start_s <= m.peak_s <= end: 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(m.peak_s)}")
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when}")
presence = len(with_face) / len(inside) presence = len(with_face) / len(inside)
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto" text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
if body_parts:
text += "; " + "; ".join(body_parts[:2])
if presence < 0.7: if presence < 0.7:
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)" text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
return text return text
# ---------------------------------------------------------------------------------------------------------------
# Corpo/cabeça e mapa de expressões
# Texto de cada rótulo de corpo no resumo do juiz.
BODY_TEXT: dict[str, str] = {
"balançando": "balançando a cabeça", "acenando": "acenando com a cabeça", "agitado": "agitado na cadeira",
"chegou perto": "chegou perto da câmera", "saiu do quadro": "saiu do quadro",
}
BODY_PRIORITY: tuple[str, ...] = ("saiu do quadro", "chegou perto", "agitado", "balançando", "acenando")
@dataclass
class BodyMoment:
"""Movimento da cabeça/corpo num trecho (mesmo sem expressão no rosto)."""
start_s: int
end_s: int
peak_s: int
label: str # balançando | acenando | agitado | chegou perto | saiu do quadro
value: float # pernas do balanço, z do movimento, razão do tamanho ou segundos fora, conforme o rótulo
def to_json(self) -> dict:
return {"startS": self.start_s, "endS": self.end_s, "peakS": self.peak_s, "label": self.label,
"value": round(self.value, 2)}
def _head_ok(second: FaceSecond, p: ReactionParams) -> bool:
"""Cabeça bem visível no segundo inteiro (rastreio sem pulos). Série antiga: usa o rosto."""
if second.head is not None:
return second.head >= p.head_min
return second.present >= p.motion_min_present
def _runs(flags: list[bool], max_gap: int = 1) -> list[tuple[int, int]]:
"""Trechos [i, j] de índices ligados, juntando buracos de até `max_gap` segundos."""
out: list[tuple[int, int]] = []
for i, on in enumerate(flags):
if not on:
continue
if out and i - out[-1][1] <= max_gap + 1:
out[-1] = (out[-1][0], i)
else:
out.append((i, i))
return out
def body_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[BodyMoment]:
"""Balanço, aceno, agitação, chegar perto e sair do quadro — relativos ao normal do próprio streamer.
Rastreio perdido nunca vira movimento: só contam segundos com a cabeça em ≥ `head_min` dos quadros, o passo
entre quadros é limitado (`head_max_step`) e a agitação exige a janela inteira com a cabeça visível.
"""
p = params or ReactionParams()
n = len(seconds)
ok = [_head_ok(s, p) for s in seconds]
out: list[BodyMoment] = []
def add(name: str, i: int, j: int, values: list[float]) -> None:
k = max(range(i, j + 1), key=lambda x: values[x])
out.append(BodyMoment(seconds[i].t, seconds[j].t, seconds[k].t, name, values[k]))
shake = [(s.shake or 0.0) if ok[i] else 0.0 for i, s in enumerate(seconds)]
nod = [(s.nod or 0.0) if ok[i] else 0.0 for i, s in enumerate(seconds)]
for i, j in _runs([v >= p.osc_legs for v in shake], 0):
add("balançando", i, j, shake)
for i, j in _runs([nod[k] >= p.osc_legs and shake[k] < p.osc_legs for k in range(n)], 0):
add("acenando", i, j, nod)
# Agitação: movimento da cabeça bem acima do normal dele em vários segundos de uma janela sem rastreio perdido.
idx = [i for i, s in enumerate(seconds) if ok[i] and s.head_motion is not None]
base = rolling_baseline(seconds, idx, "head_motion", p.extra_floors.get("head_motion", 0.15), p)
motion_z = [0.0] * n
for i in idx:
if i in base:
median, spread = base[i]
motion_z[i] = ((seconds[i].head_motion or 0.0) - median) / spread
hot = [False] * n
w = p.agitation_window_s
for i in range(0, max(0, n - w + 1)):
window = range(i, i + w)
if all(ok[k] for k in window) and sum(motion_z[k] >= p.agitation_z for k in window) >= p.agitation_min_s:
for k in window:
hot[k] = hot[k] or motion_z[k] >= p.agitation_z
for i, j in _runs(hot, 1):
add("agitado", i, j, motion_z)
# Chegou perto: cabeça bem maior que o tamanho normal dele (rosto com pontos e caixa do detector têm escalas
# diferentes: cada um contra o próprio neutro).
ratio = [0.0] * n
sources = (("size", lambda s: s.present >= p.motion_min_present and bool(s.size)),
("hsize", lambda s: s.hsize is not None and s.present < p.min_present))
for name, has in sources:
idx = [i for i, s in enumerate(seconds) if ok[i] and has(s)]
base = rolling_baseline(seconds, idx, name, 1e-6, p)
for i in idx:
if i in base and base[i][0] > 0:
ratio[i] = float(getattr(seconds[i], name)) / base[i][0]
for i, j in _runs([r >= p.lean_ratio for r in ratio], 0):
if j - i + 1 >= p.lean_min_s:
add("chegou perto", i, j, ratio)
# Saiu do quadro: só com o campo `head` (a caixa do detector segue a cabeça de perfil; sem ele, o MediaPipe
# perdendo o rosto pareceria saída). Segundo sem dado nenhum (bloco não rastreado) não conta como fora.
# Levantar e sair leva 1–2 s com a cabeça só em parte do segundo (sessão 15: "++" antes do vazio): até
# `leave_transition_s` segundos parciais entre o "visível" e o "fora" contam como a saída.
gone = [s.head is not None and s.head <= p.leave_gone_max for s in seconds]
for i, j in _runs(gone, 0):
if j - i + 1 < p.leave_gone_s:
continue
start = i
while (start > 0 and i - start < p.leave_transition_s and seconds[start - 1].head is not None
and p.leave_gone_max < (seconds[start - 1].head or 0.0) < p.head_min):
start -= 1
before = range(max(0, start - p.leave_before_s), start)
if len(before) == p.leave_before_s and all(
seconds[k].head is not None and (seconds[k].head or 0.0) >= p.head_min for k in before):
out.append(BodyMoment(seconds[start].t, seconds[j].t, seconds[start].t, "saiu do quadro",
float(j - i + 1)))
return sorted(out, key=lambda b: (b.start_s, BODY_PRIORITY.index(b.label)))
def expression_map(seconds: list[FaceSecond], params: ReactionParams | None = None,
body: list[BodyMoment] | None = None) -> list[dict]:
"""Mapa de expressões: por segundo, a expressão dominante (`expr`) e o movimento do corpo (`body`).
`expr`: `None` sem rosto; senão o rótulo do segundo (`label` com o z do neutro do streamer). Sorriso que não chega
a pico (sinal < `threshold`) é **alegria**, não risada. `body`: rótulo do `body_moments` que cobre o segundo
(prioridade: saiu do quadro > chegou perto > agitado > balançando > acenando) ou `None`.
"""
p = params or ReactionParams()
zs = channel_z(seconds, p)
yawns = yawn_seconds(seconds, zs, p)
out = []
for i, (second, z) in enumerate(zip(seconds, zs)):
expr = None
if z is not None:
expr = "bocejo" if i in yawns else label(second, z, p)
# Sorriso sem pico e sem boca abrindo/dentes à mostra = alegria; rindo de dentes à mostra continua risada.
if (expr == "risada" and (_signal_from_z(z, p) or 0.0) < p.threshold
and z.get("jaw", 0.0) < p.label_z and z.get("upper_lip", 0.0) < p.label_z):
expr = "alegria"
out.append({"t": second.t, "expr": expr, "body": None})
first = seconds[0].t if seconds else 0
for b in sorted(body if body is not None else body_moments(seconds, p),
key=lambda b: -BODY_PRIORITY.index(b.label)): # o mais importante escreve por último
for t in range(b.start_s, b.end_s + 1):
i = t - first
if 0 <= i < len(out):
out[i]["body"] = b.label
return out
# --------------------------------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------------------------------
# Onde está a câmera # Onde está a câmera
+145
View File
@@ -0,0 +1,145 @@
"""Relatório da Equipe de IA (F0 — medir antes de otimizar; doc/clipador/EQUIPE-IA.md).
`GET /v1/judge/report?days=7[&session=N]`:
- `calls`: por papel × IA × modelo × modo (linha do tempo/antigo, mosaico/frames): chamadas, falhas, tamanho médio do
prompt, imagens, tokens (quando a CLI informa) e tempo médio;
- `perHour`: chamadas e tokens por hora de live gravada no período (por papel);
- `clips`: cortes do período por estado e a taxa de aprovação do dono;
- `judge`: o que o juiz de contexto decidiu (aprovou, ajustou, descartou, avisou, erro, frase de contexto);
- `agreement`: concordância juiz × dono (e editor × dono) nos cortes que o dono avaliou.
Veredito do dono: `owner_label` (bom / ruim / sem contexto) quando marcado; senão aprovado/publicado = bom e
rejeitado = ruim. Veredito do juiz: aprovou/ajustou/avisou = mantém; descartou = descarta.
"""
from __future__ import annotations
from datetime import datetime, timedelta, timezone
from .db import Database, loads
KEEP_DECISIONS = ("approve", "adjust", "warn")
def _since(days: float) -> str:
return (datetime.now(timezone.utc) - timedelta(days=days)).isoformat(timespec="seconds")
def owner_verdict(row: dict) -> str | None:
"""good | bad | no_context | None (o dono ainda não disse)."""
if row.get("owner_label"):
return row["owner_label"]
if row["status"] in ("approved", "published"):
return "good"
if row["status"] == "rejected":
return "bad"
return None
def judge_verdict(judge: dict) -> str | None:
"""keep | discard | None (juiz não rodou ou falhou)."""
context = (judge or {}).get("context") if isinstance(judge, dict) else None
if not isinstance(context, dict) or context.get("error"):
return None
decision = context.get("decision")
if decision in KEEP_DECISIONS:
return "keep"
return "discard" if decision == "discard" else None
def editor_verdict(judge: dict) -> str | None:
if not isinstance(judge, dict) or "keep" not in judge:
return None
return "keep" if judge.get("keep") else "discard"
def agreement(pairs: list[tuple[str, str]]) -> dict:
"""Concordância (e kappa de Cohen) entre "mantém/descarta" da IA e "bom/ruim" do dono ("sem contexto" = ruim)."""
matrix = {"keep": {"good": 0, "bad": 0, "no_context": 0}, "discard": {"good": 0, "bad": 0, "no_context": 0}}
for ai, owner in pairs:
matrix[ai][owner] += 1
n = len(pairs)
if not n:
return {"pairs": 0, "agree": 0, "rate": None, "kappa": None, "matrix": matrix}
agree = matrix["keep"]["good"] + matrix["discard"]["bad"] + matrix["discard"]["no_context"]
p_keep = (sum(matrix["keep"].values())) / n
p_good = (matrix["keep"]["good"] + matrix["discard"]["good"]) / n
pe = p_keep * p_good + (1 - p_keep) * (1 - p_good)
po = agree / n
kappa = None if pe >= 1 else round((po - pe) / (1 - pe), 3)
return {"pairs": n, "agree": agree, "rate": round(po, 3), "kappa": kappa, "matrix": matrix}
def build(db: Database, days: float = 7, session_id: int | None = None) -> dict:
since = _since(days)
call_where, call_args = ("session_id = ?", [session_id]) if session_id else ("at >= ?", [since])
rows = db.all(
"SELECT role, purpose, provider, model, COALESCE(mode, '') AS mode, COUNT(*) AS calls, SUM(ok) AS ok,"
" AVG(COALESCE(system_chars, 0) + COALESCE(prompt_chars, 0)) AS avg_chars, AVG(images) AS avg_images,"
" SUM(COALESCE(image_bytes, 0)) AS image_bytes, SUM(tokens_in) AS tokens_in, SUM(tokens_out) AS tokens_out,"
" SUM(tokens_cached) AS tokens_cached, SUM(CASE WHEN tokens_in IS NOT NULL THEN 1 ELSE 0 END) AS with_usage,"
" AVG(ms) AS avg_ms FROM ai_calls WHERE " + call_where +
" GROUP BY role, purpose, provider, model, mode ORDER BY role, calls DESC", *call_args)
calls = [{"role": r["role"], "purpose": r["purpose"], "provider": r["provider"], "model": r["model"],
"mode": r["mode"], "calls": r["calls"], "failures": r["calls"] - (r["ok"] or 0),
"avgChars": round(r["avg_chars"] or 0), "avgImages": round(r["avg_images"] or 0, 2),
"imageKB": round((r["image_bytes"] or 0) / 1024), "tokensIn": r["tokens_in"], "tokensOut": r["tokens_out"],
"tokensCached": r["tokens_cached"], "withUsage": r["with_usage"], "avgMs": round(r["avg_ms"] or 0)}
for r in rows]
session_where, session_args = ("id = ?", [session_id]) if session_id else ("started_at >= ?", [since])
live_s = db.get(f"SELECT COALESCE(SUM(duration_s), 0) AS s FROM sessions WHERE {session_where}", *session_args)["s"]
hours = live_s / 3600
per_role: dict[str, dict] = {}
for c in calls:
item = per_role.setdefault(c["role"], {"calls": 0, "tokensIn": 0, "tokensOut": 0, "withUsage": 0, "chars": 0})
item["calls"] += c["calls"]
item["tokensIn"] += c["tokensIn"] or 0
item["tokensOut"] += c["tokensOut"] or 0
item["withUsage"] += c["withUsage"]
item["chars"] += c["avgChars"] * c["calls"]
per_hour = {role: {"calls": round(v["calls"] / hours, 1) if hours else None,
"tokensIn": round(v["tokensIn"] / hours) if hours and v["withUsage"] else None,
"tokensOut": round(v["tokensOut"] / hours) if hours and v["withUsage"] else None,
# Estimativa pelo tamanho do texto (~4 caracteres por token), para quando a CLI não informa.
"estTokensIn": round(v["chars"] / 4 / hours) if hours else None}
for role, v in per_role.items()}
clip_where, clip_args = ("session_id = ?", [session_id]) if session_id else ("created_at >= ?", [since])
clips = db.all(f"SELECT id, status, judge_json, owner_label FROM clips WHERE {clip_where}", *clip_args)
by_status: dict[str, int] = {}
decisions = {"approve": 0, "adjust": 0, "discard": 0, "warn": 0, "error": 0, "contextLine": 0}
judge_pairs: list[tuple[str, str]] = []
editor_pairs: list[tuple[str, str]] = []
labeled = 0
for row in clips:
by_status[row["status"]] = by_status.get(row["status"], 0) + 1
judge = loads(row["judge_json"], None)
context = judge.get("context") if isinstance(judge, dict) else None
if isinstance(context, dict):
if context.get("error"):
decisions["error"] += 1
elif context.get("decision") in decisions:
decisions[context["decision"]] += 1
if context.get("contextLine"):
decisions["contextLine"] += 1
owner = owner_verdict(row)
labeled += owner is not None
if owner:
if (jv := judge_verdict(judge)) is not None:
judge_pairs.append((jv, owner))
if (ev := editor_verdict(judge)) is not None:
editor_pairs.append((ev, owner))
approved = by_status.get("approved", 0) + by_status.get("published", 0)
decided = approved + by_status.get("rejected", 0)
no_context = sum(1 for r in clips if r.get("owner_label") == "no_context")
return {
"window": {"days": days, "since": since if not session_id else None, "sessionId": session_id,
"liveHours": round(hours, 2)},
"calls": calls,
"perHour": per_hour,
"clips": {"total": len(clips), "byStatus": by_status, "approvalRate": round(approved / decided, 3) if decided else None,
"labeled": labeled, "noContext": no_context},
"judge": decisions,
"agreement": {"judge": agreement(judge_pairs), "editor": agreement(editor_pairs)},
}
+127
View File
@@ -0,0 +1,127 @@
"""Equipe de IA do Clipador (doc/clipador/EQUIPE-IA.md): quatro papéis, cada um com a sua IA.
- **varredura** (`scan`): assiste a live por janelas e propõe momentos (e descreve a tela para a linha do tempo);
- **analista** (`analyst`): diz O QUE aconteceu no trecho candidato (cruza tela, fala e chat);
- **editor** (`editor`): decide se vira corte, escolhe o trecho e escreve título/legenda — não pode ser desligado;
- **juiz** (`judge`): só texto, vê só o que vai no corte final e confere se ele tem CONTEXTO (começo, desfecho,
funciona sozinho). Quem decide pelas respostas é o código (`context_judge.decide`).
Cada papel tem provedor + modelo (+ esforço de raciocínio no Codex), liga/desliga e as **instruções do
administrador** (texto extra somado às instruções padrão, que continuam no código). Gravado na tabela `settings`
com a chave `judge.roles` (JSON). Sem essa chave (banco de antes), a configuração antiga vira a de todos os papéis:
o provedor/modelo único de hoje vale para todos e o "modelo do analista" que já existia é respeitado.
"""
from __future__ import annotations
import copy
import json
SETTINGS_KEY = "judge.roles"
ROLES = ("scan", "analyst", "editor", "judge")
ROLE_NAMES = {"scan": "Varredura", "analyst": "Analista", "editor": "Editor", "judge": "Juiz"}
ROLE_PROVIDERS = ("codex", "claude", "gemini")
# Esforço de raciocínio: só o Codex aceita (`model_reasoning_effort`). "" = padrão (low, o de sempre).
EFFORTS = ("", "low", "medium", "high")
# Imagens da varredura e do analista: mosaico 4×2 numa imagem só (novo), frames soltos (antigo) ou nenhuma.
IMAGE_MODES = ("mosaic", "frames", "none")
IMAGE_ROLES = ("scan", "analyst")
EXTRA_MAX = 2000
# Perguntas sim/não do juiz (doc/clipador/PESQUISA-JUIZ.md §6). As críticas decidem; as outras só baixam a nota.
CHECKS = ("setup", "payoff", "who_what", "standalone", "intelligible", "faithful", "strong_open")
CHECK_NAMES = {"setup": "começo (setup)", "payoff": "desfecho", "who_what": "quem/o quê", "standalone": "funciona sozinho",
"intelligible": "fala clara", "faithful": "título fiel", "strong_open": "abertura forte"}
DEFAULT_CRITICAL = ("setup", "payoff", "standalone")
DEFAULT_PENALTY = 0.5
def _role(provider: str, model: str = "", effort: str = "", enabled: bool = True) -> dict:
return {"enabled": enabled, "provider": provider, "model": model, "effort": effort, "extra": ""}
def default_roles(provider: str = "codex", model: str = "", analyst_model: str = "") -> dict:
"""Configuração de partida: todos os papéis na mesma IA (como era antes). O juiz pensa um pouco mais
(esforço médio no Codex), como a pesquisa recomenda; os outros continuam no esforço baixo de sempre."""
provider = provider if provider in ROLE_PROVIDERS else "codex"
roles = {
"scan": _role(provider, model),
"analyst": _role(provider, analyst_model or model),
"editor": _role(provider, model),
"judge": _role(provider, model, "medium" if provider == "codex" else ""),
}
roles["scan"]["images"] = "mosaic"
roles["analyst"]["images"] = "mosaic"
roles["judge"] |= {"critical": list(DEFAULT_CRITICAL), "allowFix": True, "allowContextLine": True,
"penalty": DEFAULT_PENALTY}
return roles
def _text(value: object, limit: int) -> str:
return str(value or "").replace("\r\n", "\n").strip()[:limit]
def normalize_roles(raw: object, base: dict | None = None) -> dict:
"""Valida campo a campo sobre `base` (padrão: `default_roles()`). O que vier errado fica como estava.
O editor nunca desliga (é quem decide se vira corte)."""
roles = copy.deepcopy(base or default_roles())
if not isinstance(raw, dict):
return roles
for name in ROLES:
item = raw.get(name)
if not isinstance(item, dict):
continue
role = roles[name]
if isinstance(item.get("enabled"), bool):
role["enabled"] = item["enabled"]
if item.get("provider") in ROLE_PROVIDERS:
if item["provider"] != role["provider"] and "model" not in item:
role["model"] = "" # trocou de provedor sem dizer o modelo: o padrão do provedor novo
role["provider"] = item["provider"]
if isinstance(item.get("model"), str):
model = item["model"].strip()[:80]
if all(c.isalnum() or c in "._:-" for c in model):
role["model"] = model
if item.get("effort") in EFFORTS:
role["effort"] = item["effort"]
if "extra" in item:
role["extra"] = _text(item.get("extra"), EXTRA_MAX)
if name in IMAGE_ROLES and item.get("images") in IMAGE_MODES:
role["images"] = item["images"]
if name == "judge":
critical = item.get("critical")
if isinstance(critical, list):
role["critical"] = [c for c in CHECKS if c in critical]
for key in ("allowFix", "allowContextLine"):
if isinstance(item.get(key), bool):
role[key] = item[key]
penalty = item.get("penalty")
if isinstance(penalty, (int, float)) and not isinstance(penalty, bool) and 0 <= penalty <= 3:
role["penalty"] = float(penalty)
roles["editor"]["enabled"] = True
return roles
def from_settings(saved: dict[str, str], provider: str, model: str) -> dict:
"""Papéis gravados (`judge.roles`) ou, sem eles, a MIGRAÇÃO da configuração antiga: `judge_provider`/
`judge_model` viram os de todos os papéis e `judge_analyst_model` (se havia) fica com o analista.
`provider`/`model` = os valores iniciais do .env, para quando nem a antiga existe."""
legacy_provider = saved.get("judge_provider", provider)
legacy_model = saved.get("judge_model", model) or ""
base = default_roles(legacy_provider, legacy_model, saved.get("judge_analyst_model", "") or "")
raw = saved.get(SETTINGS_KEY)
if not raw:
return base
try:
return normalize_roles(json.loads(raw), base)
except ValueError:
return base
def admin_notes(role: dict, lang: str = "pt") -> str:
"""Bloco que vai DEPOIS das instruções padrão. Os juízes em inglês entendem português: o dono escreve como quiser."""
extra = (role or {}).get("extra", "").strip()
if not extra:
return ""
title = ("Admin notes (may be written in Portuguese; when they conflict with the rules above, they win):"
if lang == "en" else "Instruções do administrador (quando conflitarem com as regras acima, valem estas):")
return f"\n\n{title}\n{extra}"
+3
View File
@@ -90,6 +90,9 @@ class Word:
start: float start: float
end: float end: float
word: str word: str
# Quem falou (doc/clipador/FALANTES.md): "" ou "streamer" = o streamer; "other1", "other2"… = outra pessoa (colega no
# Discord, voz do jogo). Vazio = não atribuído — conta como streamer (o comportamento de antes).
speaker: str = ""
@dataclass @dataclass
+498
View File
@@ -0,0 +1,498 @@
"""Quem fala cada palavra: o streamer ou outra pessoa (colega no Discord, voz do jogo). Doc: doc/clipador/FALANTES.md.
Pedido do dono (18/11/2026): "está atribuindo ao streamer a fala de outro jogador". O áudio da live é um canal só
(microfone do streamer + Discord + jogo misturados) e o Whisper devolve as palavras sem dizer de quem são.
Como decide (medido na sessão 15, tfue com dois colegas no Discord):
1. **Voz** (`index_block`, na análise de cada bloco, logo depois do Whisper): a fala vira trechos curtos (palavras
seguidas, ≤ 3 s) e cada trecho ≥ 0,5 s vira uma impressão de voz (WeSpeaker ResNet34-LM, `voiceprint.py`) +
o volume (dBFS). Fica na tabela `voice_chunks`.
2. **Vozes da sessão** (`model`, sob demanda, em cache): agrupa os trechos ≥ 1 s pela voz (aglomerativo, cosseno ≥
0,5 entre centros); grupo com ≥ 15 s de fala é uma "voz". Na sessão 15 saíram 3 vozes (263 s, 237 s, 201 s).
3. **Qual voz é o streamer** (`pick_streamer`): a que mexe mais a boca na webcam (série `mouth` de `face.py`, soma de
muitos trechos; t ≥ 3 contra a segunda) — ou, sem câmera/sem certeza, a mais alta no áudio (o microfone dele vem
mais forte que o Discord: +4,6 dB na sessão 15) se a diferença for ≥ 3 dB. Nenhum dos dois decide → ninguém vira
"outro": tudo fica `streamer` (o comportamento de antes).
4. **Cada trecho** vai para a voz mais parecida; só vira `otherN` com folga (≥ 0,10 de cosseno a mais que o
streamer e ≥ 0,30 com a outra voz; +0,05 nos dois para trecho < 1 s). Trecho curto sem impressão herda o vizinho mais próximo (≤ 1 s); senão, streamer.
Palavra que já chega com `speaker` (4º elemento do `words_json`) fica como está.
"""
from __future__ import annotations
import base64
import bisect
import json
import logging
import math
import threading
import time
from collections.abc import Callable, Iterable
from dataclasses import dataclass, field, replace
from typing import TYPE_CHECKING, Any
from .db import loads, now
from .scoring import Word
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.speakers")
STREAMER = "streamer"
MODEL_ID = "wespeaker_r34" # entrada do models.lock.json
CHUNK_GAP_S = 0.25 # vão entre palavras que fecha o trecho
CHUNK_MAX_S = 3.0 # trecho mais longo que isto é partido
EMBED_MIN_S = 0.5 # trecho mais curto não vira impressão de voz (herda o vizinho)
EMBED_PAD_S = 0.1 # folga de áudio em volta do trecho
CLUSTER_MIN_S = 1.0 # só trechos ≥ 1 s formam as vozes (os curtos só são atribuídos)
MERGE_SIM = 0.5 # cosseno mínimo entre centros para juntar dois grupos (sessão 15: vozes diferentes a 0,26–0,33)
VOICE_MIN_S = 15.0 # grupo com menos fala que isso não é uma voz (ruído, risada, voz do jogo solta)
CLUSTER_CAP = 600 # trechos usados no agrupamento (o resto só é atribuído): custo O(n²)
# "Outro" só com folga de cosseno sobre o streamer E parecido o bastante com a outra voz. Calibrado na sessão 15:
# trecho curto (0,5–1 s) de colega dá cosseno 0,3–0,45 com a voz dele e ~0 com a do streamer; com 0,45 fixo, 150
# trechos assim ficavam como do streamer. Trecho curto pede um pouco mais dos dois.
OTHER_MARGIN = 0.10
OTHER_MIN_SIM = 0.30
SHORT_EXTRA = 0.05
NEIGHBOR_S = 1.0 # trecho curto herda o rótulo do vizinho até esta distância
EMBEDDER_RETRY_S = 300 # modelo de voz que falhou ao carregar: espera isto antes de tentar de novo
MOUTH_MIN_FRAMES = 3 # quadros com rosto para o trecho contar na boca
MOUTH_MIN_CHUNKS = 8 # trechos por voz para comparar a boca
MOUTH_MIN_T = 3.0 # t de Welch mínimo (melhor × segunda voz); sinal fraco por trecho, ver `pick_streamer`
LOUD_MIN_DB = 3.0 # diferença mínima de volume (mediana) para decidir pelo áudio
def is_other(speaker: str | None) -> bool:
return bool(speaker) and speaker != STREAMER
def parse_words(raw: str | None) -> list[Word]:
"""`words_json` → palavras. Aceita [início, fim, texto] (antigo) e [início, fim, texto, falante]."""
out = []
for item in loads(raw, []) or []:
if not isinstance(item, (list, tuple)) or len(item) < 3:
continue
speaker = str(item[3]) if len(item) > 3 and item[3] else ""
out.append(Word(float(item[0]), float(item[1]), str(item[2]), speaker))
return out
def dump_words(words: Iterable[Word]) -> str:
"""Palavras → `words_json` (4º elemento só quando há falante: o formato antigo continua igual)."""
return json.dumps([[w.start, w.end, w.word, w.speaker] if w.speaker else [w.start, w.end, w.word] for w in words],
ensure_ascii=False)
# ---------------------------------------------------------------------------------------------------------------
# Trechos de fala
def speech_chunks(words: list[Word], gap_s: float = CHUNK_GAP_S, max_s: float = CHUNK_MAX_S) -> list[tuple[float, float]]:
"""(início, fim) de cada trecho de fala contínua: palavras seguidas com vão ≤ `gap_s`, até `max_s`. Também fecha
no fim de frase (. ? !) com o trecho já ≥ `EMBED_MIN_S`: numa conversa a vez troca quase sempre ali, mesmo sem
pausa (sessão 15: "…you should bring two. | I got one code tablet completed." vinham num trecho só)."""
out: list[tuple[float, float]] = []
cur: tuple[float, float] | None = None
closed = False
for w in sorted((w for w in words if w.word.strip()), key=lambda w: w.start):
if cur and not closed and w.start - cur[1] <= gap_s and max(cur[1], w.end) - cur[0] <= max_s:
cur = (cur[0], max(cur[1], w.end))
else:
if cur:
out.append(cur)
cur = (w.start, max(w.end, w.start))
closed = w.word.rstrip().endswith((".", "?", "!")) and cur[1] - cur[0] >= EMBED_MIN_S
if cur:
out.append(cur)
return out
@dataclass
class VoiceChunk:
start: float
end: float
db: float | None = None
vec: Any = None # numpy (256,) com norma 1, ou None (curto demais)
label: str = ""
@property
def length(self) -> float:
return self.end - self.start
def encode_vec(vec: list[float]) -> str:
import numpy as np
return base64.b64encode(np.asarray(vec, np.float16).tobytes()).decode("ascii")
def decode_vec(raw: str) -> Any:
import numpy as np
v = np.frombuffer(base64.b64decode(raw), np.float16).astype(np.float32)
n = float(np.linalg.norm(v))
return v / n if n > 0 else None
# ---------------------------------------------------------------------------------------------------------------
# Agrupamento e decisão (numpy, sem E/S)
def cluster(vectors: Any, threshold: float = MERGE_SIM) -> list[list[int]]:
"""Aglomerativo pelo centro (cosseno entre as médias normalizadas): junta o par mais parecido até nenhum par
passar de `threshold`. Devolve os índices de cada grupo."""
import numpy as np
n = len(vectors)
if n == 0:
return []
sums = np.array(vectors, np.float64)
members: list[list[int] | None] = [[i] for i in range(n)]
cent = sums / np.linalg.norm(sums, axis=1, keepdims=True)
sim = cent @ cent.T
np.fill_diagonal(sim, -np.inf)
alive = np.ones(n, bool)
while True:
flat = int(np.argmax(sim))
i, j = divmod(flat, n)
if not np.isfinite(sim[i, j]) or sim[i, j] < threshold:
break
members[i] = (members[i] or []) + (members[j] or [])
members[j] = None
alive[j] = False
sums[i] += sums[j]
cent[i] = sums[i] / np.linalg.norm(sums[i])
row = cent @ cent[i]
row[~alive] = -np.inf
row[i] = -np.inf
sim[i, :] = row
sim[:, i] = row
sim[j, :] = -np.inf
sim[:, j] = -np.inf
return [m for m in members if m]
@dataclass
class Voice:
label: str
centroid: Any
speech_s: float
db: float | None
mouth: list[float] = field(default_factory=list)
def to_json(self) -> dict:
m = self.mouth
return {"label": self.label, "speechS": round(self.speech_s, 1),
"db": None if self.db is None else round(self.db, 1),
"mouth": round(sum(m) / len(m), 4) if m else None, "mouthChunks": len(m)}
def _welch_t(a: list[float], b: list[float]) -> float:
if len(a) < 2 or len(b) < 2:
return 0.0
ma, mb = sum(a) / len(a), sum(b) / len(b)
va = sum((x - ma) ** 2 for x in a) / (len(a) - 1)
vb = sum((x - mb) ** 2 for x in b) / (len(b) - 1)
se = math.sqrt(va / len(a) + vb / len(b))
return (ma - mb) / se if se > 0 else 0.0
def pick_streamer(voices: list[Voice]) -> tuple[int | None, str]:
"""Índice da voz do streamer e o porquê. Duas provas: a boca na webcam (a voz que mais mexe a boca dele) e o
volume (o microfone dele vem mais forte que o Discord). Concordam ou só uma decide → ela; discordam → None
(ninguém vira "outro"). Na sessão 15 (rosto de perfil) a boca nunca decidiu e chegou a apontar a voz errada nos
10 primeiros minutos (t < 2): por isso o limiar da boca é alto."""
if len(voices) < 2:
return (0 if voices else None), "uma voz só"
idx = range(len(voices))
with_mouth = sorted((i for i in idx if len(voices[i].mouth) >= MOUTH_MIN_CHUNKS),
key=lambda i: -sum(voices[i].mouth) / len(voices[i].mouth))
by_mouth, why_mouth = None, ""
if len(with_mouth) >= 2:
t = _welch_t(voices[with_mouth[0]].mouth, voices[with_mouth[1]].mouth)
if t >= MOUTH_MIN_T:
by_mouth, why_mouth = with_mouth[0], f"boca (t={t:.1f})"
loud = sorted((i for i in idx if voices[i].db is not None), key=lambda i: -(voices[i].db or 0.0))
by_loud, why_loud = None, ""
if len(loud) >= 2:
gap = (voices[loud[0]].db or 0.0) - (voices[loud[1]].db or 0.0)
if gap >= LOUD_MIN_DB:
by_loud, why_loud = loud[0], f"volume (+{gap:.1f} dB)"
if by_mouth is not None and by_loud is not None and by_mouth != by_loud:
return None, f"{why_mouth} e {why_loud} apontam vozes diferentes"
if by_mouth is not None:
return by_mouth, why_mouth + (f" e {why_loud}" if by_loud is not None else "")
if by_loud is not None:
return by_loud, why_loud
return None, "sem prova de qual voz é o streamer (boca e volume empatados)"
@dataclass
class SpeakerModel:
voices: list[Voice]
streamer: int | None
reason: str
chunks: list[VoiceChunk] # todos os trechos da sessão, em ordem, já com `label`
@property
def active(self) -> bool:
return self.streamer is not None and len(self.voices) >= 2
def assign(self, vec: Any, length: float) -> str:
if not self.active or vec is None:
return STREAMER
sims = [float(v.centroid @ vec) for v in self.voices]
s_streamer = sims[self.streamer] # type: ignore[index]
best = max(range(len(sims)), key=lambda i: sims[i])
extra = SHORT_EXTRA if length < CLUSTER_MIN_S else 0.0 # trecho curto: prova mais forte
if (best != self.streamer and sims[best] >= OTHER_MIN_SIM + extra
and sims[best] - s_streamer >= OTHER_MARGIN + extra):
return self.voices[best].label
return STREAMER
def to_json(self) -> dict:
counts: dict[str, float] = {}
for c in self.chunks:
counts[c.label or STREAMER] = counts.get(c.label or STREAMER, 0.0) + c.length
return {"active": self.active, "reason": self.reason,
"streamer": None if self.streamer is None else self.voices[self.streamer].label,
"voices": [v.to_json() for v in self.voices],
"chunks": len(self.chunks), "speechByLabel": {k: round(v, 1) for k, v in counts.items()}}
def build_model(chunks: list[VoiceChunk], mouth_of: Callable[[float, float], float | None] | None = None) -> SpeakerModel:
"""Vozes da sessão, qual é o streamer e o rótulo de cada trecho."""
import numpy as np
chunks = sorted(chunks, key=lambda c: c.start)
strong = [c for c in chunks if c.vec is not None and c.length >= CLUSTER_MIN_S]
if len(strong) > CLUSTER_CAP: # amostra espalhada (os mais longos de cada faixa de tempo)
step = len(strong) / CLUSTER_CAP
strong = [max(strong[int(k * step): max(int(k * step) + 1, int((k + 1) * step))], key=lambda c: c.length)
for k in range(CLUSTER_CAP)]
groups = cluster(np.array([c.vec for c in strong])) if strong else []
voices: list[Voice] = []
for g in sorted(groups, key=lambda g: -sum(strong[i].length for i in g)):
speech = sum(strong[i].length for i in g)
if speech < VOICE_MIN_S:
continue
cent = np.mean([strong[i].vec for i in g], axis=0)
dbs = sorted(strong[i].db for i in g if strong[i].db is not None)
mouth = []
if mouth_of is not None:
for i in g:
m = mouth_of(strong[i].start, strong[i].end)
if m is not None:
mouth.append(m)
voices.append(Voice("", cent / np.linalg.norm(cent), speech, dbs[len(dbs) // 2] if dbs else None, mouth))
streamer, reason = pick_streamer(voices)
k = 0
for i, v in enumerate(voices):
if i == streamer:
v.label = STREAMER
else:
k += 1
v.label = f"other{k}"
model = SpeakerModel(voices, streamer, reason, chunks)
for c in chunks:
c.label = model.assign(c.vec, c.length) if c.vec is not None else ""
return model
def label_words(words: list[Word], chunks: list[VoiceChunk]) -> list[Word]:
"""Rótulo de cada palavra pelo trecho que cobre o meio dela; trecho sem impressão (curto) herda o trecho
rotulado mais próximo (≤ `NEIGHBOR_S`); nada perto → streamer. Palavra com `speaker` já preenchido fica."""
labeled = [c for c in sorted(chunks, key=lambda c: c.start) if c.label]
if not any(is_other(c.label) for c in labeled):
return words # ninguém além do streamer: palavras como vieram (vazio = streamer)
starts = [c.start for c in labeled]
out = []
for w in words:
if w.speaker:
out.append(w)
continue
mid = (w.start + w.end) / 2
k = bisect.bisect_right(starts, mid) - 1
best, dist = None, NEIGHBOR_S
for j in (k, k + 1):
if 0 <= j < len(labeled):
c = labeled[j]
d = 0.0 if c.start <= mid <= c.end else min(abs(mid - c.start), abs(mid - c.end))
if d <= dist:
best, dist = c, d
if d == 0.0:
break
out.append(replace(w, speaker=best.label if best else STREAMER))
return out
def transfer(new_words: list[Word], labeled: list[Word]) -> list[Word]:
"""Falante de palavras novas (re-transcrição de um trecho) pelo das palavras antigas no mesmo tempo."""
marks = sorted((w for w in labeled if w.speaker), key=lambda w: w.start)
if not marks:
return new_words
starts = [w.start for w in marks]
out = []
for w in new_words:
mid = (w.start + w.end) / 2
k = bisect.bisect_right(starts, mid) - 1
near = [marks[j] for j in (k, k + 1) if 0 <= j < len(marks)]
best = min(near, key=lambda m: 0.0 if m.start <= mid <= m.end else min(abs(mid - m.start), abs(mid - m.end)))
out.append(w if w.speaker else replace(w, speaker=best.speaker))
return out
def mouth_activity(series: list[float | None], fps: float, block_start: float, a: float, b: float) -> list[float]:
"""Valores da série da boca (quadro i = `block_start` + i/fps) dentro de [a, b]."""
lo = max(0, int(math.ceil((a - block_start) * fps)))
hi = min(len(series), int(math.floor((b - block_start) * fps)) + 1)
return [v for v in series[lo:hi] if v is not None]
# ---------------------------------------------------------------------------------------------------------------
# Serviço (E/S: banco, modelo de voz)
# A tabela `voice_chunks` é criada pela migração v15 (db.py).
class SpeakerService:
"""Uma instância por motor (`Engine.speakers`)."""
def __init__(self, engine: Engine, embedder_factory: Callable[[], Any] | None = None):
self.e = engine
self._embedder_factory = embedder_factory or self._default_embedder
self._embedder: Any = None
self._embedder_retry_at = 0.0 # modelo de voz falhou (download/onnx): nova tentativa só depois disto
self._lock = threading.Lock()
self._cache: dict[int, tuple[tuple, SpeakerModel]] = {}
self.last_error: str | None = None
@property
def enabled(self) -> bool:
return bool(self.e.intel.opts.get("speakers", True))
def _default_embedder(self) -> Any:
from .voiceprint import Voiceprint
return Voiceprint(self.e.face.store.path(MODEL_ID))
def embedder(self) -> Any:
"""Modelo de voz (carregado no 1º bloco). Falhou → sobe o erro (a análise registra e segue) e só tenta de novo
daqui a `EMBEDDER_RETRY_S`: sem rede, não baixa 26 MB a cada bloco."""
with self._lock:
if self._embedder is None:
if time.monotonic() < self._embedder_retry_at:
raise RuntimeError(f"modelo de voz indisponível (nova tentativa em até {EMBEDDER_RETRY_S} s)")
try:
self._embedder = self._embedder_factory()
except Exception:
self._embedder_retry_at = time.monotonic() + EMBEDDER_RETRY_S
raise
return self._embedder
# ---------- por bloco (thread da análise)
def index_block(self, segment: dict, pcm: bytes, words: list[Word]) -> int:
"""Impressões de voz dos trechos de fala do bloco → `voice_chunks`. Devolve quantos trechos gravou."""
if not self.enabled:
return 0
import numpy as np
samples = np.frombuffer(pcm[: len(pcm) - len(pcm) % 2], np.int16)
base = float(segment["start_s"])
sr = 16_000
items = []
embedder = self.embedder() if words else None
for a, b in speech_chunks(words):
item: dict = {"s": round(a, 3), "e": round(b, 3)}
lo, hi = max(0, int((a - base - EMBED_PAD_S) * sr)), min(len(samples), int((b - base + EMBED_PAD_S) * sr))
part = samples[lo:hi]
if len(part) >= sr * 0.1:
rms = float(np.sqrt(np.mean(part.astype(np.float64) ** 2)))
item["db"] = round(20 * math.log10(rms / 32768), 1) if rms > 0 else None
if b - a >= EMBED_MIN_S and embedder is not None:
vec = embedder.embed(part)
if vec is not None:
item["v"] = encode_vec(vec)
items.append(item)
data = {"model": MODEL_ID, "chunks": items}
self.e.db.run("INSERT INTO voice_chunks (session_id, idx, data_json, updated_at) VALUES (?, ?, ?, ?)"
" ON CONFLICT (session_id, idx) DO UPDATE SET data_json = excluded.data_json,"
" updated_at = excluded.updated_at",
segment["session_id"], segment["idx"], json.dumps(data), now())
self.invalidate(segment["session_id"])
return len(items)
# ---------- sessão
def invalidate(self, session_id: int) -> None:
with self._lock:
self._cache.pop(session_id, None)
def _key(self, session_id: int) -> tuple:
row = self.e.db.get("SELECT COUNT(*) AS n, MAX(updated_at) AS u FROM voice_chunks WHERE session_id = ?", session_id)
face = self.e.db.get("SELECT COUNT(*) AS n, MAX(updated_at) AS u FROM face_track WHERE session_id = ?", session_id)
return (row["n"], row["u"], face["n"], face["u"])
def model(self, session_id: int) -> SpeakerModel | None:
"""Vozes da sessão (em cache até chegar bloco novo de voz ou de rosto). None = nada indexado."""
key = self._key(session_id)
if key[0] == 0:
return None
with self._lock:
hit = self._cache.get(session_id)
if hit and hit[0] == key:
return hit[1]
model = self._build(session_id)
with self._lock:
self._cache[session_id] = (key, model)
return model
def _build(self, session_id: int) -> SpeakerModel:
chunks = []
for row in self.e.db.all("SELECT data_json FROM voice_chunks WHERE session_id = ? ORDER BY idx", session_id):
for item in loads(row["data_json"], {}).get("chunks", []):
vec = decode_vec(item["v"]) if item.get("v") else None
chunks.append(VoiceChunk(float(item["s"]), float(item["e"]), item.get("db"), vec))
blocks = []
for row in self.e.db.all(
"SELECT s.start_s, 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' ORDER BY s.start_s", session_id):
data = loads(row["data_json"], {})
if data.get("mouth"):
blocks.append((float(row["start_s"]), float(data.get("fps") or 6), data["mouth"]))
starts = [b[0] for b in blocks]
def mouth_of(a: float, b: float) -> float | None:
k = bisect.bisect_right(starts, a) - 1
values: list[float] = []
for j in (k, k + 1):
if 0 <= j < len(blocks):
values += mouth_activity(blocks[j][2], blocks[j][1], blocks[j][0], a, b)
return sum(values) / len(values) if len(values) >= MOUTH_MIN_FRAMES else None
model = build_model(chunks, mouth_of if blocks else None)
log.info("sessão %s: %d vozes, streamer = %s (%s)", session_id, len(model.voices),
model.voices[model.streamer].label if model.streamer is not None and model.voices else "—", model.reason)
return model
def label(self, session_id: int, words: list[Word]) -> list[Word]:
"""Palavras com falante. Sem sessão indexada, sem certeza ou desligado → como vieram (contam como streamer)."""
if not words or not self.enabled:
return words
try:
model = self.model(session_id)
except Exception as exc: # noqa: BLE001 - atribuição nunca derruba a leitura da linha do tempo
self.last_error = str(exc)[:300]
log.warning("falantes da sessão %s: %s", session_id, exc)
return words
if model is None or not model.active:
return words
return label_words(words, model.chunks)
def view(self, session_id: int) -> dict:
"""Estado para a API: vozes, qual é o streamer e por quê."""
model = self.model(session_id) if self.enabled else None
return {"enabled": self.enabled, "lastError": self.last_error,
**(model.to_json() if model else {"active": False, "reason": "nada indexado ainda", "voices": []})}
+94 -17
View File
@@ -15,12 +15,23 @@ ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
para o bloco não piscar; 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 - `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). bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
Dois falantes (pedido do dono, 18/11/2026: "a legenda do streamer em cima e a de outra pessoa abaixo, com outra cor,
como se fossem duas pessoas conversando"; doc/clipador/FALANTES.md): cada palavra tem `speaker` e a legenda tem duas
FAIXAS — a do streamer (posição normal) e a de outra pessoa (logo abaixo, `caption.otherColor`/`otherSize`). Um bloco
nunca mistura falantes; o "nunca dois blocos na tela" vale DENTRO de cada faixa, então quando os dois falam ao mesmo
tempo aparecem as duas linhas, cada uma no seu lugar (posição fixa por `pos`: o libass não empilha).
""" """
from __future__ import annotations from __future__ import annotations
from . import layout from . import layout
from .scoring import Word from .scoring import Word
from .speakers import STREAMER, is_other
STREAMER_LANE, OTHER_LANE = "streamer", "other"
OTHER_SIZE_RATIO = 0.85 # tamanho automático da fala de outra pessoa (fração do tamanho da legenda)
LINE_GAP_PX = 10 # vão entre a linha do streamer e a de outra pessoa
WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração 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 MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6
@@ -58,20 +69,34 @@ def clean_words(words: list[Word]) -> list[Word]:
end = max(w.end, round(start + MIN_WORD_S, 3)) end = max(w.end, round(start + MIN_WORD_S, 3))
if out and out[-1].end > start + 1e-9: if out and out[-1].end > start + 1e-9:
prev = out[-1] prev = out[-1]
out[-1] = Word(prev.start, start, prev.word) out[-1] = Word(prev.start, start, prev.word, prev.speaker)
text = w.word.strip() text = w.word.strip()
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word 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)) out.append(w if same else Word(start, end, text, w.speaker))
return out return out
def lane(speaker: str | None) -> str:
"""Faixa da legenda: `streamer` (vazio também) ou `other` (qualquer outra pessoa)."""
return OTHER_LANE if is_other(speaker) else STREAMER_LANE
def same_speaker(a: Word, b: Word) -> bool:
return (a.speaker or STREAMER) == (b.speaker or STREAMER)
def has_other(words: list[Word]) -> bool:
return any(is_other(w.speaker) for w in words)
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]: def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
"""Blocos da legenda (palavras já saneadas por `clean_words`).""" """Blocos da legenda (palavras já saneadas por `clean_words`)."""
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS) max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
groups: list[list[Word]] = [] groups: list[list[Word]] = []
for word in clean_words(words): for word in clean_words(words):
current = groups[-1] if groups else None 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: if (current and same_speaker(current[-1], word) 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 fits = len(" ".join(w.word for w in current + [word])) <= max_chars
room = len(current) < max_words or ( room = len(current) < max_words or (
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler. # Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
@@ -84,36 +109,74 @@ def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]: 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 """(palavras do bloco, fim do bloco), em ordem de início. Cada faixa (streamer / outra pessoa; ver `lane`) é
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro).""" agrupada sozinha e um bloco nunca mistura falantes. O fim nunca passa do início do bloco seguinte DA MESMA FAIXA:
groups = group_words(words, max_words) dois eventos no mesmo lugar ao mesmo tempo ficariam um em cima do outro. Blocos de faixas diferentes podem se
sobrepor (os dois falando juntos): cada um vai para a sua linha."""
out = [] out = []
for name in (STREAMER_LANE, OTHER_LANE):
groups = group_words([w for w in words if lane(w.speaker) == name], max_words)
for k, group in enumerate(groups): for k, group in enumerate(groups):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S) end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
if k + 1 < len(groups): if k + 1 < len(groups):
end = min(end, groups[k + 1][0].start) end = min(end, groups[k + 1][0].start)
out.append((group, round(end, 3))) out.append((group, round(end, 3)))
out.sort(key=lambda item: (item[0][0].start, lane(item[0][0].speaker)))
return out return out
def other_size(cap: dict) -> int:
"""Tamanho da fala de outra pessoa: `caption.otherSize` ou, vazio, 85 % do tamanho da legenda."""
chosen = cap.get("otherSize")
return int(chosen) if chosen else max(30, int(round(int(cap["size"]) * OTHER_SIZE_RATIO)))
def other_color(cap: dict) -> str:
return str(cap.get("otherColor") or layout.DEFAULTS["caption"]["otherColor"])
def other_offset(size: int, osize: int, extra: int = 0) -> int:
"""Distância (px) do centro da linha do streamer ao centro da linha de outra pessoa (logo abaixo). `extra` =
espaço a mais entre as duas (a tradução de desenvolvimento do streamer fica nele)."""
return int(round(0.6 * size + 0.6 * osize)) + LINE_GAP_PX + extra
def other_y(y: int, offset: int, osize: int, canvas_h: int) -> int:
"""Centro da linha de outra pessoa: abaixo da do streamer; sem espaço até a borda, acima dela."""
below = y + offset
return below if below + int(0.6 * osize) <= canvas_h - 8 else max(int(0.6 * osize), y - offset)
PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16 PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16
_SENTENCE_END = (".", "?", "!") _SENTENCE_END = (".", "?", "!")
def phrases(words: list[Word]) -> list[tuple[float, float, str]]: def phrases(words: list[Word], with_speaker: bool = False) -> list[tuple]:
"""Fala em frases curtas com tempo (início, fim, texto) para traduzir: quebra em pausa > 0,7 s, fim de frase """Fala em frases curtas com tempo (início, fim, texto) para traduzir: quebra em pausa > 0,7 s, fim de frase
(. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3.""" (. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3.
out: list[tuple[float, float, str]] = [] Uma frase nunca mistura falantes (quem fala junto vira frase própria). `with_speaker` = devolve
(início, fim, texto, falante), com falante "streamer" ou "otherN"."""
out: list[tuple] = []
def flush(current: list[Word]) -> None:
item = (current[0].start, current[-1].end, " ".join(x.word for x in current))
out.append(item + (current[0].speaker or STREAMER,) if with_speaker else item)
by_speaker: dict[str, list[Word]] = {}
for w in words:
by_speaker.setdefault(w.speaker or STREAMER, []).append(w)
for speaker_words in by_speaker.values():
current: list[Word] = [] current: list[Word] = []
for w in clean_words(words): for w in clean_words(speaker_words):
if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S
or len(current) >= PHRASE_MAX_WORDS or len(current) >= PHRASE_MAX_WORDS
or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)): or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)):
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current))) flush(current)
current = [] current = []
current.append(w) current.append(w)
if current: if current:
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current))) flush(current)
out.sort(key=lambda item: item[0])
return out return out
@@ -123,13 +186,19 @@ def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str
cap, cred = cfg["caption"], cfg["credit"] cap, cred = cfg["caption"], cfg["credit"]
duration = clip_end - clip_start duration = clip_end - clip_start
inside = [ inside = [
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip()) Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip(), w.speaker)
for w in words for w in words
if w.end > clip_start and w.start < clip_end 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"]) 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) credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
width, height = layout.canvas_size(cfg) width, height = layout.canvas_size(cfg)
two = cap["enabled"] and has_other(inside)
osize = other_size(cap)
# Estilo da fala de outra pessoa só quando há outra pessoa: o ASS de um corte só com o streamer fica igual.
other_style = (f"Style: CaptionOther,{cap['font']},{osize},{layout.ass_color(other_color(cap))},"
f"{layout.ass_color(other_color(cap))},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{max(2, int(cap['outlineWidth']) * osize // int(cap['size']))},3,5,60,60,0,1\n") if two else ""
header = f"""[Script Info] header = f"""[Script Info]
ScriptType: v4.00+ ScriptType: v4.00+
PlayResX: {width} PlayResX: {width}
@@ -140,7 +209,7 @@ ScaledBorderAndShadow: yes
[V4+ Styles] [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 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: 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 {other_style}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] [Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
@@ -149,9 +218,17 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
if credit and cred["enabled"]: if credit and cred["enabled"]:
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}") lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
if cap["enabled"]: if cap["enabled"]:
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}" y = layout.caption_y(cfg)
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"]) offset = other_offset(int(cap["size"]), osize)
if two: # sem espaço embaixo para a outra pessoa, a linha do streamer sobe (a ordem nunca inverte)
y = min(y, height - 8 - offset - int(0.6 * osize))
oy = other_y(y, offset, osize, height)
high = layout.ass_inline_color(cap["highlight"])
for group, g_end in caption_blocks(inside, cap["maxWords"]): for group, g_end in caption_blocks(inside, cap["maxWords"]):
other = lane(group[0].speaker) == OTHER_LANE
pos = f"{{\\pos({width // 2},{oy if other else y})}}"
style = "CaptionOther" if other else "Caption"
base = layout.ass_inline_color(other_color(cap) if other else cap["color"])
for i, word in enumerate(group): for i, word in enumerate(group):
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada. # Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
start = word.start start = word.start
@@ -163,5 +240,5 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
for j, w in enumerate(group): for j, w in enumerate(group):
text = _escape(w.word.upper() if cap["uppercase"] else w.word) text = _escape(w.word.upper() if cap["uppercase"] else w.word)
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text) 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)}") lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},{style},,0,0,0,,{pos}{' '.join(parts)}")
return header + "\n".join(lines) + "\n" return header + "\n".join(lines) + "\n"
+298
View File
@@ -0,0 +1,298 @@
"""Linha do tempo em JSON curto (v1): o vídeo "lido" como texto barato para a IA (doc/clipador/EQUIPE-IA.md).
Uma linha JSON por instante (JSON Lines), chaves curtas — a legenda das chaves vai uma vez no prompt —, segundos
inteiros da gravação e campos vazios omitidos. Só com o que já existe (nenhum modelo novo):
| chave | conteúdo | de onde vem |
| --- | --- | --- |
| `t`, `d` | início e duração da entrada | pausas da fala, troca de falante ou no máximo 8 s |
| `v` | o que está na tela (frase curta) | a IA que já vê os frames (varredura/analista), guardada em `scene_notes` |
| `sp` | fala literal (até ~25 palavras); `[other1] …` = outra pessoa | Whisper + falantes |
| `face` | expressão do streamer + intensidade 0–9 (`laugh.7`) | série do rosto (face.FaceService.dense + reaction) |
| `lvl` | volume relativo ao normal da live, 0–9 (3 = normal) | dBFS por segundo já medido |
| `chat` | `"mensagens\\|emote×n\\|frase mais repetida"` | chat da sessão |
| `out` | 1 = fora do corte (o espectador NÃO vê) — só no prompt do juiz | — |
Comportamento antigo (transcrição + chat + frames soltos) continua atrás da opção `timelineJson` (intel.opts).
"""
from __future__ import annotations
import json
import logging
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .scoring import ChatMessage, Word
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.timeline")
STEP_MAX_S = 8.0 # uma entrada nunca passa disso (gameplay contínuo quase não tem corte de plano)
COARSE_STEP_S = 20.0 # trecho de "volta" da varredura: resumido
PAUSE_S = 1.2 # pausa na fala que fecha a entrada (se ela já tem MIN_ENTRY_S)
MIN_ENTRY_S = 4.0
FACE_MIN = 3 # expressão abaixo disso (z do rosto) é ruído: fica de fora
LOUD_LVL, QUIET_LVL = 6, 1 # volume só aparece quando foge do normal (alto ou silêncio)
PHRASE_CHARS = 32
SP_WORDS = 25
COARSE_SP_WORDS = 12
NORMAL_LVL = 3
# Rótulos do rosto (reaction.label) → token curto em inglês (as chaves e valores da linha do tempo são em inglês).
FACE_TOKENS = {"risada": "laugh", "grito": "shout", "susto": "scare", "choque": "shock", "confuso": "confused",
"raiva": "anger"}
LEGEND = {
"en": ("Timeline (JSON Lines; one entry per moment; seconds of the recording). Keys: t=start, d=duration, "
"v=what is on screen (short), sp=speech, literal ([other1] = someone else talking, not the streamer), "
"face=streamer expression.intensity 0-9, lvl=loudness vs. the stream's normal 0-9 (3=normal), "
"chat=messages|top emote×count|most repeated message, out=1 → OUTSIDE the clip (the viewer does NOT see it). "
"Missing key = nothing notable."),
"pt": ("Linha do tempo (JSON Lines; uma entrada por instante; segundos da gravação). Chaves: t=início, d=duração, "
"v=o que está na tela (curto), sp=fala literal ([other1] = outra pessoa falando, não o streamer), "
"face=expressão do streamer.intensidade 0-9, lvl=volume em relação ao normal da live 0-9 (3=normal), "
"chat=mensagens|emote mais usado×vezes|mensagem mais repetida, out=1 → FORA do corte (o espectador NÃO vê). "
"Chave ausente = nada a notar."),
}
@dataclass
class Evidence:
"""Tudo que a linha do tempo de uma janela usa. `face` = (segundo, token, intensidade z); `scenes` = (t, texto)."""
words: list[Word]
chat: list[ChatMessage]
loudness: list[float | None]
face: list[tuple[int, str, float]] = field(default_factory=list)
scenes: list[tuple[float, str]] = field(default_factory=list)
# ---------------------------------------------------------------- coleta (motor → Evidence)
def face_marks(engine: "Engine", session: dict, lo: float, hi: float) -> list[tuple[int, str, float]]:
"""Expressões do streamer por segundo em [lo, hi], pelo que o rastreio já gravou (sem rodar nada novo).
Sem câmera, rastreio desligado ou plano B sem expressões: lista vazia."""
try:
from . import reaction
from .face import OpenSeeFaceTracker
face = engine.face
if not face.enabled or not face.has_cam(session):
return []
if face.session_backend(session["id"]) == OpenSeeFaceTracker.name:
return []
seconds = face.dense(session["id"], max(0.0, lo - 240), hi)
if not any(s.smile is not None for s in seconds if lo <= s.t <= hi):
return []
zs = reaction.channel_z(seconds, face.params)
signal = reaction.reaction_signal(seconds, params=face.params)
marks = []
for second, z, value in zip(seconds, zs, signal):
if not lo <= second.t <= hi or z is None:
continue
label = reaction.label(second, z, face.params)
if label and label != "neutro":
marks.append((int(second.t), FACE_TOKENS.get(label, label), float(value or 0.0)))
return marks
except Exception as exc: # noqa: BLE001 - sem rosto a linha do tempo segue sem `face`
log.info("rosto para a linha do tempo indisponível: %s", exc)
return []
def scene_lines(engine: "Engine", session_id: int, lo: float, hi: float) -> list[tuple[float, str]]:
"""Frases de tela guardadas (varredura e analista). Do analista primeiro quando os dois descreveram o mesmo t."""
rows = engine.db.all("SELECT t, source, text FROM scene_notes WHERE session_id = ? AND t >= ? AND t <= ? ORDER BY t",
session_id, lo, hi)
rows.sort(key=lambda r: (r["t"], r["source"] != "analyst"))
return [(float(r["t"]), r["text"]) for r in rows]
def save_scene_lines(engine: "Engine", session_id: int, source: str, lines: object,
tiles: list[float]) -> int:
"""Grava as frases `v` que a IA escreveu para cada quadro (`n` = nº do quadro, 1 = primeiro). Devolve quantas."""
if not isinstance(lines, list) or not tiles:
return 0
rows = []
for item in lines:
if not isinstance(item, dict):
continue
try:
n = int(item.get("n"))
except (TypeError, ValueError):
continue
text = " ".join(str(item.get("v") or "").split())[:120]
if 1 <= n <= len(tiles) and text:
rows.append((session_id, round(tiles[n - 1], 1), source, text, _now()))
if rows:
engine.db.many("INSERT INTO scene_notes (session_id, t, source, text, created_at) VALUES (?, ?, ?, ?, ?)"
" ON CONFLICT (session_id, t, source) DO UPDATE SET text = excluded.text", rows)
return len(rows)
def _now() -> str:
from .db import now
return now()
def collect(engine: "Engine", session: dict, tl: dict, lo: float, hi: float) -> Evidence:
"""Evidência da janela [lo, hi] a partir da linha do tempo já carregada (`Engine.load_timeline`)."""
return Evidence(words=[w for w in tl["words"] if lo - 1 <= w.start <= hi + 1],
chat=[m for m in tl["chat"] if lo - 1 <= m.t <= hi + 1],
loudness=tl["loudness"], face=face_marks(engine, session, lo, hi),
scenes=scene_lines(engine, session["id"], lo, hi))
# ---------------------------------------------------------------- entradas
def boundaries(words: list[Word], lo: float, hi: float, step: float = STEP_MAX_S, split_speech: bool = True) -> list[float]:
"""Onde cada entrada começa: pausa na fala, troca de quem fala ou no máximo `step` segundos.
`split_speech=False` (resumo): só pelo passo."""
cuts = [lo]
last_end: float | None = None
last_sp: str | None = None
for w in sorted((w for w in words if lo <= w.start < hi), key=lambda w: w.start):
while w.start - cuts[-1] > step:
cuts.append(cuts[-1] + step)
cur = cuts[-1]
speaker = w.speaker or "streamer"
new_speaker = last_sp is not None and speaker != last_sp
pause = last_end is not None and w.start - last_end > PAUSE_S and w.start - cur >= MIN_ENTRY_S
if ((split_speech and (new_speaker or pause)) or w.start - cur >= step) and w.start > cur + 0.5:
cuts.append(w.start)
last_end, last_sp = w.end, speaker
while hi - cuts[-1] > step:
cuts.append(cuts[-1] + step)
if hi - cuts[-1] < 0.5 and len(cuts) > 1:
cuts.pop()
return cuts + [hi]
def _speech(words: list[Word], limit: int) -> str:
parts: list[str] = []
current = None
count = 0
for w in words:
speaker = w.speaker or "streamer"
if speaker != current:
if speaker != "streamer":
parts.append(f"[{speaker}]")
elif current is not None:
parts.append("[streamer]")
current = speaker
parts.append(w.word.strip())
count += 1
if count >= limit:
parts.append("…")
break
return " ".join(p for p in parts if p)
def _chat(messages: list[ChatMessage], coarse: bool) -> str:
if not messages:
return ""
emotes = Counter(e for m in messages for e in set(m.emotes))
top = ""
if emotes:
name, n = emotes.most_common(1)[0]
top = f"{name}×{n}"
phrase = ""
if not coarse:
# Só o que o chat REPETE (reação coletiva); resposta a alguém (@) e comando (!) não contam.
texts = Counter(re.sub(r"\s+", " ", m.text.strip().lower())[:PHRASE_CHARS] for m in messages
if m.text.strip() and not m.text.lstrip().startswith(("@", "!")))
if texts:
text, n = texts.most_common(1)[0]
if n >= 2:
phrase = text
return "|".join((str(len(messages)), top, phrase)).rstrip("|")
def _level(loudness: list[float | None], a: float, b: float, normal: float | None) -> int | None:
values = [v for v in loudness[max(0, int(a)): max(int(a) + 1, int(b))] if v is not None]
if not values or normal is None:
return None
return max(0, min(9, round(NORMAL_LVL + (max(values) - normal) / 4)))
def normal_level(loudness: list[float | None], lo: float, hi: float) -> float | None:
"""Volume "normal" da live em volta da janela (mediana dos segundos com som)."""
values = [v for v in loudness[max(0, int(lo) - 120): int(hi) + 1] if v is not None and v > -60]
return statistics.median(values) if values else None
def entries(ev: Evidence, lo: float, hi: float, *, coarse: bool = False, clip: tuple[float, float] | None = None,
sp_words: int | None = None) -> list[dict]:
"""Entradas da janela. `coarse` = resumo (passo maior, fala curta, sem rosto/volume baixos). `clip` = (início,
fim) do corte: as entradas fora dele saem marcadas `out: 1` (prompt do juiz: o espectador não vê) e nenhuma
entrada atravessa o início ou o fim do corte."""
if clip is not None:
start, end = clip
out_items: list[dict] = []
for a, b, outside in ((lo, min(start, hi), True), (max(lo, start), min(end, hi), False), (max(lo, end), hi, True)):
if b - a < 0.3:
continue
for item in entries(ev, a, b, coarse=coarse, sp_words=sp_words):
out_items.append({"t": item.pop("t"), "d": item.pop("d"), **({"out": 1} if outside else {}), **item})
return out_items
step = COARSE_STEP_S if coarse else STEP_MAX_S
limit = sp_words or (COARSE_SP_WORDS if coarse else SP_WORDS)
cuts = boundaries(ev.words, lo, hi, step, split_speech=not coarse)
normal = normal_level(ev.loudness, lo, hi)
out: list[dict] = []
used_scenes: set[int] = set()
for a, b in zip(cuts, cuts[1:]):
if b - a < 0.3:
continue
item: dict = {"t": int(round(a)), "d": max(1, int(round(b - a)))}
scenes = [(i, text) for i, (t, text) in enumerate(ev.scenes) if a <= t < b and i not in used_scenes]
if scenes:
used_scenes.update(i for i, _ in scenes[:2])
item["v"] = " / ".join(dict.fromkeys(text for _, text in scenes[:2]))
words = [w for w in ev.words if a <= w.start < b]
if words:
item["sp"] = _speech(words, limit)
marks = [m for m in ev.face if a <= m[0] < b]
if marks:
_t, token, value = max(marks, key=lambda m: m[2])
intensity = max(0, min(9, round(value)))
if intensity >= (FACE_MIN + 1 if coarse else FACE_MIN):
item["face"] = f"{token}.{intensity}"
level = _level(ev.loudness, a, b, normal)
if level is not None and (level >= LOUD_LVL or level <= QUIET_LVL):
item["lvl"] = level
chat = _chat([m for m in ev.chat if a <= m.t < b], coarse)
if chat:
item["chat"] = chat
out.append(item)
return out
def render(header: dict, items: list[dict]) -> str:
dump = lambda obj: json.dumps(obj, ensure_ascii=False, separators=(",", ":")) # noqa: E731
return "\n".join([dump(header), *(dump(i) for i in items)])
def build(ev: Evidence, lo: float, hi: float, header: dict, *, budget_chars: int = 9000,
coarse_until: float | None = None, clip: tuple[float, float] | None = None) -> str:
"""JSONL da janela dentro do orçamento de caracteres: se passar, a fala de cada entrada encurta (25 → 12 → 6
palavras) e, por último, o trecho mais antigo vira resumo. `coarse_until` = a parte [lo, coarse_until) já sai
resumida (a "volta" da varredura)."""
for sp_words in (SP_WORDS, COARSE_SP_WORDS, 6):
items: list[dict] = []
split = coarse_until if coarse_until is not None and lo < coarse_until < hi else None
if split is not None:
items += entries(ev, lo, split, coarse=True, clip=clip)
items += entries(ev, split, hi, clip=clip, sp_words=sp_words)
else:
items += entries(ev, lo, hi, clip=clip, sp_words=sp_words)
text = render(header, items)
if len(text) <= budget_chars:
return text
return text[:budget_chars].rsplit("\n", 1)[0]
def legend(lang: str) -> str:
return LEGEND["en" if lang == "en" else "pt"]
+100
View File
@@ -0,0 +1,100 @@
"""Impressão de voz (embedding de falante) para o Clipador: fbank no estilo Kaldi em numpy + WeSpeaker ResNet34-LM
(ONNX, CC-BY-4.0) no onnxruntime. Só E/S de modelo e conta numérica; a decisão de quem fala mora em `speakers.py`.
- Modelo: `voxceleb_resnet34_LM.onnx` do repositório Wespeaker/wespeaker-voxceleb-resnet34-LM (Hugging Face, commit
fixo no `models.lock.json`, licença CC-BY-4.0 — uso comercial permitido com atribuição; ver doc/clipador/FALANTES.md).
- Entrada do modelo: fbank 80 bandas, janela 25 ms / passo 10 ms, 16 kHz, com a média de cada trecho subtraída (CMN),
igual ao `compute_fbank` do WeSpeaker. Saída: vetor de 256, normalizado aqui (comparação por cosseno).
Nada daqui importa numpy/onnxruntime na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
"""
from __future__ import annotations
import math
import threading
from pathlib import Path
from typing import Any
SAMPLE_RATE = 16_000
FRAME_LEN, FRAME_SHIFT, N_FFT, N_MELS = 400, 160, 512, 80
PREEMPH = 0.97
MIN_SAMPLES = FRAME_LEN + FRAME_SHIFT * 20 # ~0,2 s: menos que isso não vira vetor
class VoiceprintUnavailable(RuntimeError):
"""numpy/onnxruntime ou o modelo faltando: a atribuição de falante fica de fora (tudo `streamer`)."""
_mel_cache: dict[int, Any] = {}
def _mel_banks(np: Any) -> Any:
"""Banco de filtros triangulares na escala mel do Kaldi (20 Hz até Nyquist), 80 × 257."""
if N_MELS in _mel_cache:
return _mel_cache[N_MELS]
def mel(f: Any) -> Any:
return 1127.0 * np.log(1.0 + f / 700.0)
lo, hi = mel(np.float64(20.0)), mel(np.float64(SAMPLE_RATE / 2))
centers = np.linspace(lo, hi, N_MELS + 2)
bins = mel(np.arange(N_FFT // 2 + 1) * SAMPLE_RATE / N_FFT)
banks = np.zeros((N_MELS, N_FFT // 2 + 1), np.float32)
for m in range(N_MELS):
left, center, right = centers[m], centers[m + 1], centers[m + 2]
up = (bins - left) / (center - left)
down = (right - bins) / (right - center)
banks[m] = np.maximum(0.0, np.minimum(up, down))
_mel_cache[N_MELS] = banks
return banks
def fbank(samples: Any) -> Any:
"""Fbank Kaldi (snip_edges, janela povey, pré-ênfase 0,97, sem dither) de amostras int16/float na escala int16.
Devolve (quadros × 80) float32 já com a média subtraída (CMN), como o WeSpeaker espera."""
import numpy as np
x = np.asarray(samples, dtype=np.float64)
n = 1 + (len(x) - FRAME_LEN) // FRAME_SHIFT
if n < 1:
return np.zeros((0, N_MELS), np.float32)
idx = np.arange(FRAME_LEN)[None, :] + FRAME_SHIFT * np.arange(n)[:, None]
frames = x[idx]
frames = frames - frames.mean(axis=1, keepdims=True) # tira o nível DC
frames = np.concatenate([frames[:, :1] * (1 - PREEMPH), frames[:, 1:] - PREEMPH * frames[:, :-1]], axis=1)
window = (0.5 - 0.5 * np.cos(2 * math.pi * np.arange(FRAME_LEN) / (FRAME_LEN - 1))) ** 0.85 # povey
spec = np.abs(np.fft.rfft(frames * window, N_FFT)) ** 2
feats = np.log(np.maximum(spec @ _mel_banks(np).T.astype(np.float64), np.finfo(np.float32).eps))
feats = feats - feats.mean(axis=0, keepdims=True)
return feats.astype(np.float32)
class Voiceprint:
"""Sessão ONNX do WeSpeaker. Um por motor; `embed` é seguro entre threads (trinco)."""
def __init__(self, model_path: Path, threads: int = 2):
try:
import numpy as np
import onnxruntime as ort
except ImportError as exc: # pragma: no cover - depende da instalação
raise VoiceprintUnavailable("numpy/onnxruntime não instalados (rode o setup.bat)") from exc
if not Path(model_path).is_file():
raise VoiceprintUnavailable(f"modelo de voz ausente: {model_path}")
opts = ort.SessionOptions()
opts.intra_op_num_threads, opts.inter_op_num_threads = threads, 1
self._np = np
self._sess = ort.InferenceSession(str(model_path), sess_options=opts, providers=["CPUExecutionProvider"])
self._input = self._sess.get_inputs()[0].name
self._lock = threading.Lock()
def embed(self, samples: Any) -> list[float] | None:
"""Vetor de 256 (norma 1) de um trecho de fala; None se curto demais."""
np = self._np
if len(samples) < MIN_SAMPLES:
return None
feats = fbank(samples)
with self._lock:
out = self._sess.run(None, {self._input: feats[None]})[0][0]
norm = float(np.linalg.norm(out))
return (out / norm).astype(np.float32).tolist() if norm > 0 else None
+291 -36
View File
@@ -29,7 +29,8 @@ from pathlib import Path
import httpx import httpx
from . import capture as capture_quality from . import capture as capture_quality
from . import clip_delete, layout, media from . import clip_delete, context_judge, layout, media, timeline
from . import roles as roles_module
from .chat import ChatReader from .chat import ChatReader
from .config import REPO_ROOT, Settings from .config import REPO_ROOT, Settings
from .db import Database, loads, now from .db import Database, loads, now
@@ -37,13 +38,18 @@ from .face import FaceService
from .hashtags import build_caption, split_hashtags from .hashtags import build_caption, split_hashtags
from .hashtags import compose as compose_hashtags from .hashtags import compose as compose_hashtags
from .intel import Intel from .intel import Intel
from .judge import Judge, JudgeError, analysis_block, build_prompt from .judge import (Judge, JudgeError, analysis_block, build_context_prompt, build_prompt, build_timeline_prompt)
from .scoring import ChatMessage, Params, Word, find_moments, overlaps from .scoring import ChatMessage, Params, Word, find_moments, overlaps
from .sources import Source, parse_source from .sources import Source, parse_source
from .speakers import SpeakerService, dump_words, parse_words
from .subtitles import build_ass, phrases from .subtitles import build_ass, phrases
log = logging.getLogger("cenaforge_clipper") log = logging.getLogger("cenaforge_clipper")
LIVE_WINDOW_S = 900 # ao vivo, pontua só os últimos 15 min (o que veio antes já foi decidido) LIVE_WINDOW_S = 900 # ao vivo, pontua só os últimos 15 min (o que veio antes já foi decidido)
# Orçamento de caracteres da linha do tempo JSON por papel (~4 caracteres por token).
ANALYST_TIMELINE_CHARS = 9000
EDITOR_TIMELINE_CHARS = 7000
JUDGE_TIMELINE_CHARS = 6000
def rel(path: Path) -> str: def rel(path: Path) -> str:
@@ -338,9 +344,18 @@ class Engine:
def __init__(self, settings: Settings, db: Database, judge: Judge | None = None, voice: VoiceClient | None = None): def __init__(self, settings: Settings, db: Database, judge: Judge | None = None, voice: VoiceClient | None = None):
self.settings, self.db = settings, db self.settings, self.db = settings, db
saved = {r["key"]: r["value"] for r in db.all("SELECT key, value FROM settings")} saved = {r["key"]: r["value"] for r in db.all("SELECT key, value FROM settings")}
self.judge = judge or Judge(saved.get("judge_provider", settings.judge_provider), if judge is None:
# Equipe de IA: papéis gravados em `judge.roles`; sem eles, a configuração antiga vira a de todos os papéis
# (migração automática, gravada já na subida para ficar explícita no banco).
roles = roles_module.from_settings(saved, settings.judge_provider, settings.judge_model)
judge = Judge(saved.get("judge_provider", settings.judge_provider),
saved.get("judge_model", settings.judge_model), settings.data_dir / "judge", saved.get("judge_model", settings.judge_model), settings.data_dir / "judge",
saved.get("judge_analyst_model", "")) saved.get("judge_analyst_model", ""), roles=roles)
if roles_module.SETTINGS_KEY not in saved:
db.run("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
roles_module.SETTINGS_KEY, json.dumps(judge.roles, ensure_ascii=False))
self.judge = judge
self.judge.meter = self.record_ai_call # medição por chamada (F0): tabela ai_calls
self.min_score = float(saved.get("judge_min_score", settings.judge_min_score)) self.min_score = float(saved.get("judge_min_score", settings.judge_min_score))
self.voice = voice or VoiceClient(settings.voice_url, settings.voice_key, settings.language) self.voice = voice or VoiceClient(settings.voice_url, settings.voice_key, settings.language)
self.params = Params() self.params = Params()
@@ -353,6 +368,7 @@ class Engine:
self._threads: list[threading.Thread] = [] self._threads: list[threading.Thread] = []
self.intel = Intel(self) self.intel = Intel(self)
self.face = FaceService(self) # rastreio do rosto do streamer (face.py); não carrega modelo aqui self.face = FaceService(self) # rastreio do rosto do streamer (face.py); não carrega modelo aqui
self.speakers = SpeakerService(self) # quem fala cada palavra (speakers.py); modelo de voz só no 1º bloco
self.resume_delays: tuple[float, ...] = RESUME_DELAYS_S # os testes encurtam self.resume_delays: tuple[float, ...] = RESUME_DELAYS_S # os testes encurtam
self._recovering: set[int] = set() # sessões com uma thread de retomada em andamento self._recovering: set[int] = set() # sessões com uma thread de retomada em andamento
self._rendering: set[int] = set() # cortes que ESTE processo está renderizando agora self._rendering: set[int] = set() # cortes que ESTE processo está renderizando agora
@@ -511,19 +527,44 @@ class Engine:
self.stop_event.wait(10) self.stop_event.wait(10)
# ---------- juiz (configurável pelo painel, sem reiniciar) # ---------- juiz (configurável pelo painel, sem reiniciar)
def judge_config(self) -> dict: def judge_config(self, full: bool = False) -> dict:
return self.judge.describe() | {"minScore": self.min_score, "options": dict(self.intel.opts), """Configuração da Equipe de IA. `full` (GET /v1/judge) acrescenta as instruções padrão de cada papel (texto
grande, só leitura no painel) e os nomes das checagens do juiz."""
out = self.judge.describe() | {"minScore": self.min_score, "options": dict(self.intel.opts),
"lastScanError": self.intel.last_scan_error} "lastScanError": self.intel.last_scan_error}
if isinstance(out.get("roles"), dict) and "scan" in out["roles"]:
out["roles"]["scan"]["enabled"] = bool(self.intel.opts.get("scanEnabled", True)) # liga/desliga = varredura
if full:
out["roleDefaults"] = self.judge.default_instructions()
out["checks"] = [{"id": c, "label": roles_module.CHECK_NAMES[c]} for c in roles_module.CHECKS]
return out
def set_judge_config(self, provider: str, model: str, min_score: float, analyst_model: str | None = None) -> dict: def set_judge_config(self, provider: str, model: str, min_score: float, analyst_model: str | None = None,
roles: dict | None = None) -> dict:
if not 0 <= min_score <= 10: if not 0 <= min_score <= 10:
raise JudgeError("a nota mínima vai de 0 a 10") raise JudgeError("a nota mínima vai de 0 a 10")
self.judge.configure(provider, model, analyst_model) self.judge.configure(provider, model, analyst_model, roles)
scan = (roles or {}).get("scan") if isinstance(roles, dict) else None
if isinstance(scan, dict) and isinstance(scan.get("enabled"), bool):
self.intel.set_options({"scanEnabled": scan["enabled"]}) # o cartão da varredura liga/desliga a varredura
self.min_score = float(min_score) self.min_score = float(min_score)
rows = [("judge_provider", self.judge.provider), ("judge_model", self.judge.model), ("judge_min_score", str(self.min_score)), rows = [("judge_provider", self.judge.provider), ("judge_model", self.judge.model), ("judge_min_score", str(self.min_score)),
("judge_analyst_model", self.judge.analyst_model)] ("judge_analyst_model", self.judge.analyst_model),
(roles_module.SETTINGS_KEY, json.dumps(self.judge.roles, ensure_ascii=False))]
self.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value", rows) self.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value", rows)
return self.judge_config() return self.judge_config(full=True)
def record_ai_call(self, record: dict) -> None:
"""Uma linha em `ai_calls` por tentativa de chamada de IA (medição F0; relatório em GET /v1/judge/report)."""
self.db.run(
"INSERT INTO ai_calls (at, role, purpose, provider, model, ok, error, ms, system_chars, prompt_chars, images,"
" image_bytes, tokens_in, tokens_out, tokens_cached, session_id, clip_id, mode)"
" VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
now(), record.get("role", ""), record.get("purpose", ""), record.get("provider", ""), record.get("model", ""),
int(bool(record.get("ok"))), record.get("error"), record.get("ms"), record.get("systemChars"),
record.get("promptChars"), record.get("images"), record.get("imageBytes"), record.get("tokensIn"),
record.get("tokensOut"), record.get("tokensCached"), record.get("session_id"), record.get("clip_id"),
record.get("mode"))
# ---------- sessões # ---------- sessões
def start_session(self, url: str, channel_id: str | None = None, language: str | None = None) -> int: def start_session(self, url: str, channel_id: str | None = None, language: str | None = None) -> int:
@@ -721,8 +762,8 @@ class Engine:
def rel(path: Path) -> str: def rel(path: Path) -> str:
return rel(path) return rel(path)
def grab_frame(self, segments: list[tuple[Path, float, float]], t: float, out_file: Path) -> Path: def grab_frame(self, segments: list[tuple[Path, float, float]], t: float, out_file: Path, width: int = 768) -> Path:
return media.grab_frame(self.settings.ffmpeg or "ffmpeg", segments, t, out_file) return media.grab_frame(self.settings.ffmpeg or "ffmpeg", segments, t, out_file, width)
# ---------- análise dos blocos (volume + transcrição) # ---------- análise dos blocos (volume + transcrição)
def _analysis_loop(self) -> None: def _analysis_loop(self) -> None:
@@ -754,12 +795,18 @@ class Engine:
for w in rel_words] for w in rel_words]
except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat
error = str(exc)[:300] error = str(exc)[:300]
if words:
try:
# Impressão de voz de cada trecho de fala (doc/clipador/FALANTES.md): ~0,2 s de CPU por bloco.
self.speakers.index_block(segment, pcm, words)
except Exception as exc: # noqa: BLE001 - sem falantes a legenda segue toda como do streamer
self.speakers.last_error = str(exc)[:300]
log.warning("falantes do bloco %s/%s: %s", segment["session_id"], segment["idx"], exc)
except media.MediaError as exc: except media.MediaError as exc:
error = f"áudio: {exc}"[:300] error = f"áudio: {exc}"[:300]
self.db.run( self.db.run(
"UPDATE segments SET analyzed = 1, loudness_json = ?, words_json = ?, transcript_error = ? WHERE session_id = ? AND idx = ?", "UPDATE segments SET analyzed = 1, loudness_json = ?, words_json = ?, transcript_error = ? WHERE session_id = ? AND idx = ?",
json.dumps(loudness), json.dumps([[w.start, w.end, w.word] for w in words], ensure_ascii=False), error, json.dumps(loudness), dump_words(words), error, segment["session_id"], segment["idx"])
segment["session_id"], segment["idx"])
# ---------- linha do tempo de uma sessão # ---------- linha do tempo de uma sessão
def load_timeline(self, session_id: int, since_s: float = 0.0) -> dict: def load_timeline(self, session_id: int, since_s: float = 0.0) -> dict:
@@ -775,7 +822,7 @@ class Engine:
if seg["analyzed"]: if seg["analyzed"]:
if analyzed_until >= seg["start_s"] - 0.01: # só o trecho contínuo desde o início conta if analyzed_until >= seg["start_s"] - 0.01: # só o trecho contínuo desde o início conta
analyzed_until = seg["end_s"] analyzed_until = seg["end_s"]
words.extend(Word(a, b, c) for a, b, c in loads(seg["words_json"], [])) words.extend(parse_words(seg["words_json"]))
chat = [] chat = []
if segments: if segments:
first_wall = segments[0]["wall_end"] - (segments[0]["end_s"] - segments[0]["start_s"]) first_wall = segments[0]["wall_end"] - (segments[0]["end_s"] - segments[0]["start_s"])
@@ -789,9 +836,17 @@ class Engine:
continue continue
emotes = tuple(loads(r["emotes"], [])) emotes = tuple(loads(r["emotes"], []))
chat.append(ChatMessage(t, r["text"], r["user"], emotes, self.intel.bonus(list(emotes), key))) chat.append(ChatMessage(t, r["text"], r["user"], emotes, self.intel.bonus(list(emotes), key)))
# Quem fala cada palavra (streamer × outra pessoa): juízes, tradução e legenda leem daqui.
words = self.speakers.label(session_id, words)
return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat, return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat,
"analyzedUntil": analyzed_until} "analyzedUntil": analyzed_until}
def words_between(self, session_id: int, lo: float, hi: float) -> list[Word]:
"""Palavras dos blocos que tocam [lo, hi] (sem filtrar o tempo de cada palavra), já com o falante."""
rows = self.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
session_id, lo, hi)
return self.speakers.label(session_id, [w for r in rows for w in parse_words(r["words_json"])])
# ---------- cortes # ---------- cortes
def _clip_loop(self) -> None: def _clip_loop(self) -> None:
while not self.stop_event.is_set(): while not self.stop_event.is_set():
@@ -816,7 +871,7 @@ class Engine:
return 0 return 0
offset = int(since) offset = int(since)
chat = [replace(m, t=m.t - offset) for m in tl["chat"] if m.t >= offset] chat = [replace(m, t=m.t - offset) for m in tl["chat"] if m.t >= offset]
words = [Word(w.start - offset, w.end - offset, w.word) for w in tl["words"] if w.start >= offset] words = [replace(w, start=w.start - offset, end=w.end - offset) for w in tl["words"] if w.start >= offset]
face, face_until = self.face.for_scoring(session, offset, tl["duration"]) # None = sem câmera/rastreio face, face_until = self.face.for_scoring(session, offset, tl["duration"]) # None = sem câmera/rastreio
# O candidato já nasce na duração da configuração do corte desta sessão (padrão 60–90 s). # O candidato já nasce na duração da configuração do corte desta sessão (padrão 60–90 s).
dur = self.intel.settings_for(session)["duration"] dur = self.intel.settings_for(session)["duration"]
@@ -880,31 +935,62 @@ class Engine:
# A ação vem antes do comentário: a IA vê `backtrackS` para trás (transcrição + frames) e pode recuar. # A ação vem antes do comentário: a IA vê `backtrackS` para trás (transcrição + frames) e pode recuar.
lo = max(0.0, clip["start_s"] - dur["backtrackS"]) lo = max(0.0, clip["start_s"] - dur["backtrackS"])
hi = min(tl["duration"], clip["end_s"] + 15) hi = min(tl["duration"], clip["end_s"] + 15)
# Fonte em inglês: os juízes trabalham em inglês e devolvem também o português do painel (IDIOMAS.md).
lang = self.intel.lang(session)
# Linha do tempo JSON (novo) ou transcrição + chat + frames soltos (antigo, `timelineJson` desligado).
use_timeline = bool(self.intel.opts.get("timelineJson", True))
analyst_on = self.judge.role_enabled("analyst")
# Imagens como escolhido no analista (sem analista, o editor recebe as mesmas); formato antigo = soltos.
image_mode = self.judge.roles["analyst"].get("images", "mosaic") if use_timeline else "frames"
# Quadros espalhados de um pouco antes do candidato até o fim da reação: o analista vê a sequência. # Quadros espalhados de um pouco antes do candidato até o fim da reação: o analista vê a sequência.
# 6 quadros; 8 quando o trecho passa de 80 s (cortes de 60–90 s), para não ficar > 20 s entre quadros. # 6 quadros; 8 quando o trecho passa de 80 s (cortes de 60–90 s), para não ficar > 20 s entre quadros.
f_lo = max(lo, clip["start_s"] - 20) f_lo = max(lo, clip["start_s"] - 20)
n_frames = 8 if hi - f_lo > 80 else 6 n_frames = 8 if hi - f_lo > 80 or image_mode == "mosaic" else 6
times = [f_lo + (hi - f_lo) * k / (n_frames - 1) for k in range(n_frames)] times = [f_lo + (hi - f_lo) * k / (n_frames - 1) for k in range(n_frames)]
frames = self.intel.frames(session, times, f"clip{clip['id']}") images, tiles, mosaic = self.intel.visual(session, times, f"clip{clip['id']}", image_mode)
# Fonte em inglês: os juízes trabalham em inglês e devolvem também o português do painel (IDIOMAS.md). mode = ("timeline" if use_timeline else "legacy") + f"+{'mosaic' if mosaic else image_mode}"
lang = self.intel.lang(session) min_len = layout.min_target({"duration": dur})
with self.judge.scope(session_id=session["id"], clip_id=clip["id"], mode=mode):
if use_timeline:
prompt = build_timeline_prompt(
streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], heuristic,
context=self.intel.context(session, lean=True), timeline_text=self._timeline_text(session, tl, lo, hi),
tiles=tiles, mosaic=mosaic, lo=lo, hi=hi, min_s=dur["minS"], max_s=dur["maxS"], lang=lang)
else:
prompt = build_prompt(streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], prompt = build_prompt(streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"],
tl["words"], tl["chat"], heuristic, session["title"], context=self.intel.context(session), tl["words"], tl["chat"], heuristic, session["title"],
frames=frames, backtrack_s=dur["backtrackS"], min_s=dur["minS"], max_s=dur["maxS"], context=self.intel.context(session), frames=list(zip(tiles, images)),
backtrack_s=dur["backtrackS"], min_s=dur["minS"], max_s=dur["maxS"],
face=self.face.summary(session, lo, hi), lang=lang) face=self.face.summary(session, lo, hi), lang=lang)
analysis = None analysis = None
try: try:
# Dois juízes: o ANALISTA (vê os frames) diz o que aconteceu; o EDITOR decide e escreve a partir disso. # ANALISTA (vê a tela) diz o que aconteceu; o EDITOR decide e escreve a partir disso.
if analyst_on:
try: try:
analysis = self.judge.analyze(prompt, [p for _, p in frames], lang=lang) analysis = self.judge.analyze(prompt, images, lang=lang)
except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc:
log.warning("analista falhou no corte %s: %s (editor segue sozinho)", clip["id"], exc) log.warning("analista falhou no corte %s: %s (editor segue sozinho)", clip["id"], exc)
if analysis:
# O que o analista viu em cada quadro vira o `v` da linha do tempo (editor e juiz reaproveitam).
timeline.save_scene_lines(self, session["id"], "analyst", analysis.pop("lines", None), tiles)
if use_timeline and analysis:
# Editor: só texto, linha do tempo do trecho (da ação, se o analista a viu antes) até o fim.
try:
act = float(analysis.get("action_start_s"))
except (TypeError, ValueError):
act = clip["start_s"]
e_lo = max(lo, min(clip["start_s"], act if lo <= act <= hi else clip["start_s"]) - 15)
editor_prompt = build_timeline_prompt(
streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], heuristic,
context=self.intel.context(session, lean=True),
timeline_text=self._timeline_text(session, tl, e_lo, hi, EDITOR_TIMELINE_CHARS),
tiles=[], mosaic=False, lo=lo, hi=hi, min_s=dur["minS"], max_s=dur["maxS"], lang=lang,
analysis=analysis)
else:
editor_prompt = prompt + ("\n\n" + analysis_block(analysis, lang) if analysis else "") editor_prompt = prompt + ("\n\n" + analysis_block(analysis, lang) if analysis else "")
# Sem análise, o editor recebe os frames; com análise, só texto (mais barato, a tela já foi lida). # Sem análise, o editor recebe as imagens; com análise, só texto (mais barato, a tela já foi lida).
verdict = self.judge.judge(editor_prompt, clip["start_s"], clip["end_s"], verdict = self.judge.judge(editor_prompt, clip["start_s"], clip["end_s"], [] if analysis else images,
[] if analysis else [p for _, p in frames], lo=lo, hi=hi, min_s=min_len, max_s=dur["maxS"], lang=lang)
lo=lo, hi=hi, min_s=layout.min_target({"duration": dur}), max_s=dur["maxS"],
lang=lang)
# Corte manual: quem decidiu foi você; o juiz só escreve título e legenda (e não mexe no trecho). # Corte manual: quem decidiu foi você; o juiz só escreve título e legenda (e não mexe no trecho).
manual = clip["source"] == "manual" manual = clip["source"] == "manual"
keep = manual or (verdict.keep and verdict.score >= self.min_score) keep = manual or (verdict.keep and verdict.score >= self.min_score)
@@ -918,7 +1004,11 @@ class Engine:
"reason": verdict.reason, "analysis": analysis, "reason": verdict.reason, "analysis": analysis,
# Fonte em inglês: título/legenda/motivo em português (só o painel lê). # Fonte em inglês: título/legenda/motivo em português (só o painel lê).
**({"pt": verdict.pt} if verdict.pt else {}), **({"pt": verdict.pt} if verdict.pt else {}),
"analystModel": (self.judge.analyst_model or self.judge.model) if analysis else None}} "analystModel": self.judge.role_model("analyst") if analysis else None}}
if keep and self.judge.role_enabled("judge"):
# JUIZ de contexto: o corte faz sentido sozinho? (só texto, só o que vai no corte final)
self._context_check(session, clip, tl, update, verdict.score, analysis, lo, hi, min_len,
float(dur["maxS"]), lang, manual)
except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc:
# Falha do juiz não perde o momento: segue com a heurística e registra o motivo. # Falha do juiz não perde o momento: segue com a heurística e registra o motivo.
update["judge"] = {"error": str(exc)[:300]} update["judge"] = {"error": str(exc)[:300]}
@@ -957,6 +1047,7 @@ class Engine:
# Novo veredito: o projeto que a IA tinha gerado é refeito no render (o que você editou fica). # Novo veredito: o projeto que a IA tinha gerado é refeito no render (o que você editou fica).
self.db.run("DELETE FROM edits WHERE clip_id = ? AND origin = 'ai'", clip["id"]) self.db.run("DELETE FROM edits WHERE clip_id = ? AND origin = 'ai'", clip["id"])
# Fonte em inglês: a fala do corte em português para o painel (falha não segura o corte). # Fonte em inglês: a fala do corte em português para o painel (falha não segura o corte).
with self.judge.scope(session_id=session["id"], clip_id=clip["id"]):
self.translate_clip(clip["id"], update["start_s"], update["end_s"]) self.translate_clip(clip["id"], update["start_s"], update["end_s"])
verdict_info = update["judge"] or {} verdict_info = update["judge"] or {}
if clip["source"] != "manual" and "score" in verdict_info: if clip["source"] != "manual" and "score" in verdict_info:
@@ -966,6 +1057,77 @@ class Engine:
elif verdict_info["score"] >= 7: elif verdict_info["score"] >= 7:
self.intel.learn_from_clip(clip, positive=True, factor=0.5) self.intel.learn_from_clip(clip, positive=True, factor=0.5)
def _timeline_text(self, session: dict, tl: dict, lo: float, hi: float, budget: int = ANALYST_TIMELINE_CHARS,
clip: tuple[float, float] | None = None, header: dict | None = None) -> str:
"""Linha do tempo JSON de [lo, hi] (app/timeline.py) com o que já existe: fala+falante, chat, rosto, volume
e as frases de tela guardadas."""
ev = timeline.collect(self, session, tl, lo, hi)
head = header or {"win": [int(lo), int(hi)], "src": self.intel.lang(session)}
return timeline.build(ev, lo, hi, head, budget_chars=budget, clip=clip)
def _context_check(self, session: dict, clip: dict, tl: dict, update: dict, score: float, analysis: dict | None,
lo: float, hi: float, min_len: float, max_len: float, lang: str, manual: bool) -> None:
"""JUIZ de contexto sobre o corte que o editor manteve. O código decide pelas respostas (context_judge.decide):
aprova (talvez com frase de contexto na tela), ajusta o trecho e confere UMA vez de novo, ou descarta com o
motivo em português. Falha da IA aqui não muda a decisão do editor (só registra o erro)."""
from .editor import pick_hook
conf = self.judge.roles["judge"]
game, profile = self.intel.session_game(session)
summary = str((profile or {}).get("summary") or "")
game_line = (summary.split(". ")[0] if summary else "")[:160]
story = str((analysis or {}).get("what_happened") or "")
opening, _ = pick_hook((analysis or {}).get("hook"), update["title"])
streamer = self.streamer_name(session)
def ask(start: float, end: float) -> tuple[dict, str]:
# O corte + 20 s antes e 15 s depois (marcados out=1): o juiz nota o começo ou o desfecho que ficaram de fora.
t_lo = max(0.0, start - context_judge.OUT_BEFORE_S)
t_hi = min(tl["duration"], end + context_judge.OUT_AFTER_S)
text = self._timeline_text(session, tl, t_lo, t_hi, JUDGE_TIMELINE_CHARS, clip=(start, end),
header={"clip": [int(start), int(end)], "src": lang})
prompt = build_context_prompt(streamer=streamer, game=game, game_line=game_line, start_s=start, end_s=end,
title=update["title"], caption=update["caption"], opening=opening, story=story,
timeline_text=text, lo=lo, hi=hi, min_s=min_len, max_s=max_len, lang=lang)
result = self.judge.check_context(prompt, lang=lang)
return result, self.judge.responder()
judge_info = update["judge"]
start, end = update["start_s"], update["end_s"]
limits = {"lo": lo, "hi": hi, "min_s": min_len, "max_s": max_len, "conf": conf, "score": score,
"min_score": self.min_score, "manual": manual}
try:
result, model = ask(start, end)
decision = context_judge.decide(result, start_s=start, end_s=end, **limits)
info = context_judge.view(result, decision, model)
if decision.action == "adjust" and decision.window:
# Trecho novo dentro dos limites: o juiz confere UMA vez de novo (sem novo ajuste).
ns, ne = decision.window
result2, model2 = ask(ns, ne)
second = context_judge.decide(result2, start_s=ns, end_s=ne, allow_fix=False, **limits)
first = info
info = context_judge.view(result2, second, model2)
info["first"] = {k: first[k] for k in ("viewerSummary", "checks", "failedCritical", "reasonPt", "pt")}
info["window"] = [round(ns, 2), round(ne, 2)]
if second.action == "approve":
info["decision"] = "adjust"
info["contextLine"] = second.context_line or decision.context_line
info["reasonPt"] = f"{decision.reason_pt} Conferido de novo: aprovado."
update["start_s"], update["end_s"] = round(ns, 2), round(ne, 2)
else:
info["decision"] = "discard"
info["contextLine"] = ""
info["reasonPt"] = (f"Descartado pelo juiz depois do ajuste para {ns:.0f}–{ne:.0f}s: "
f"{second.reason_pt.removeprefix('Descartado pelo juiz: ')}")
if info["decision"] == "discard":
update["status"] = "discarded"
judge_info["discardedBy"] = "context"
judge_info["context"] = info
log.info("juiz de contexto no corte %s: %s (%s)", clip["id"], info["decision"], info["reasonPt"][:160])
except (JudgeError, json.JSONDecodeError, KeyError, ValueError, TypeError) as exc:
judge_info["context"] = {"error": str(exc)[:300]}
log.warning("juiz de contexto falhou no corte %s: %s (fica a decisão do editor)", clip["id"], exc)
def translate_clip(self, clip_id: int, lo: float | None = None, hi: float | None = None, def translate_clip(self, clip_id: int, lo: float | None = None, hi: float | None = None,
force: bool = False) -> dict | None: force: bool = False) -> dict | None:
"""Fonte em inglês (doc/clipador/IDIOMAS.md): a fala de [lo, hi] (padrão: o trecho do corte) em frases com """Fonte em inglês (doc/clipador/IDIOMAS.md): a fala de [lo, hi] (padrão: o trecho do corte) em frases com
@@ -980,26 +1142,35 @@ class Engine:
hi = clip["end_s"] if hi is None else hi hi = clip["end_s"] if hi is None else hi
current = loads(clip.get("translation_json"), None) current = loads(clip.get("translation_json"), None)
if (isinstance(current, dict) and not force and current.get("startS", 1e12) <= lo + 0.5 if (isinstance(current, dict) and not force and current.get("startS", 1e12) <= lo + 0.5
and current.get("endS", -1) >= hi - 0.5): and current.get("endS", -1) >= hi - 0.5
and all("speaker" in line for line in current.get("lines") or [])): # antiga, sem falante: refaz
return current return current
tl = self.load_timeline(session["id"], max(0.0, lo - 30)) tl = self.load_timeline(session["id"], max(0.0, lo - 30))
items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi]) # Frases que nunca misturam falantes (doc/clipador/FALANTES.md); cada linha diz quem fala (`speaker`:
# "streamer" ou "otherN") — a legenda de desenvolvimento e a dublagem escolhem posição e voz por ela.
items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi], with_speaker=True)
if not items: if not items:
return None return None
try: try:
pt = self.judge.translate_lines([text for _, _, text in items]) pt = self.judge.translate_lines([text for _, _, text, _ in items])
except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc:
log.warning("tradução da fala do corte %s falhou: %s", clip_id, exc) log.warning("tradução da fala do corte %s falhou: %s", clip_id, exc)
return None return None
data = {"language": "pt-BR", "startS": round(lo, 2), "endS": round(hi, 2), "model": self.judge.responder(), data = {"language": "pt-BR", "startS": round(lo, 2), "endS": round(hi, 2), "model": self.judge.responder(),
"lines": [{"s": round(s, 3), "e": round(e, 3), "text": text, "pt": tr} "lines": [{"s": round(s, 3), "e": round(e, 3), "text": text, "pt": tr, "speaker": speaker}
for (s, e, text), tr in zip(items, pt)]} for (s, e, text, speaker), tr in zip(items, pt)]}
self.db.run("UPDATE clips SET translation_json = ? WHERE id = ?", json.dumps(data, ensure_ascii=False), clip_id) self.db.run("UPDATE clips SET translation_json = ? WHERE id = ?", json.dumps(data, ensure_ascii=False), clip_id)
return data return data
def render_pending(self) -> None: def render_pending(self) -> None:
self.recover_orphan_renders() self.recover_orphan_renders()
self.discard_pending_duplicates() self.discard_pending_duplicates()
# Vídeos finais primeiro: o corte já foi aprovado e a publicação está esperando por ele (REVISAO.md).
for clip in self.db.all("SELECT * FROM clips WHERE final_status = 'pending' AND status IN ('approved', 'published')"
" ORDER BY updated_at, id LIMIT 3"):
if self.stop_event.is_set():
return
self.render_final(clip)
for clip in self.db.all("SELECT * FROM clips WHERE status = 'pending' ORDER BY score DESC, id LIMIT 3"): for clip in self.db.all("SELECT * FROM clips WHERE status = 'pending' ORDER BY score DESC, id LIMIT 3"):
if self.stop_event.is_set(): if self.stop_event.is_set():
return return
@@ -1105,8 +1276,87 @@ class Engine:
self.db.run("UPDATE edits SET cover = ? WHERE clip_id = ?", cover, clip["id"]) self.db.run("UPDATE edits SET cover = ? WHERE clip_id = ?", cover, clip["id"])
self.db.run("UPDATE clips SET status = 'ready', file = ?, thumb = ?, error = NULL, updated_at = ? WHERE id = ?", self.db.run("UPDATE clips SET status = 'ready', file = ?, thumb = ?, error = NULL, updated_at = ? WHERE id = ?",
rel(out), rel(thumb), now(), clip["id"]) rel(out), rel(thumb), now(), clip["id"])
self.drop_final(clip["id"]) # vídeo de revisão novo = conteúdo novo: o final antigo deixa de valer
self._render_attempts.pop(clip["id"], None) self._render_attempts.pop(clip["id"], None)
# ---------- vídeo final (doc/clipador/REVISAO.md)
def queue_final(self, clip_id: int) -> str | None:
"""Corte aprovado: pede o vídeo FINAL (sem camadas de desenvolvimento). Se o vídeo de revisão não teve nenhuma
camada `dev` (`review_dev_json` = []), ele já é o final: reaproveita sem renderizar. Devolve o `final_status`."""
with self.db.lock:
clip = self.db.get("SELECT c.*, e.cover AS edit_cover FROM clips c LEFT JOIN edits e ON e.clip_id = c.id"
" WHERE c.id = ?", clip_id)
if not clip or clip["status"] not in ("approved", "published"):
return None
if loads(clip["review_dev_json"], None) == [] and clip["file"]:
self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?,"
" final_error = NULL, final_at = ? WHERE id = ?",
clip["file"], clip["thumb"], clip["edit_cover"], now(), clip_id)
return "ready"
self.db.run("UPDATE clips SET final_status = 'pending', final_file = NULL, final_thumb = NULL, final_cover = NULL,"
" final_error = NULL, final_at = NULL WHERE id = ?", clip_id)
self.wake_clips.set()
return "pending"
def drop_final(self, clip_id: int) -> None:
"""O final deixa de valer (aprovação desfeita, corte editado ou renderizado de novo). O arquivo fica no disco
até o próximo final (mesmo nome) ou até apagar o corte; nada mais aponta para ele."""
self.db.run("UPDATE clips SET final_status = NULL, final_file = NULL, final_thumb = NULL, final_cover = NULL,"
" final_error = NULL, final_at = NULL WHERE id = ?", clip_id)
def render_final(self, clip: dict) -> None:
"""Renderiza o vídeo final de um corte aprovado. Falha vira `final_status = 'error'` (o corte continua
aprovado; "tentar de novo" no painel = POST /v1/clips/{id}/final)."""
with self.lock:
# Apagado depois de a fila ler a lista, ou já em render: não começa (clip_delete recusa enquanto estiver aqui).
if clip["id"] in self._rendering or not self.db.get("SELECT 1 FROM clips WHERE id = ?", clip["id"]):
return
self._rendering.add(clip["id"])
try:
self._render_final(clip)
except Exception as exc: # noqa: BLE001 - nunca fica preso em 'rendering'
log.exception("vídeo final do corte %s falhou", clip["id"])
self._final_error(clip["id"], f"falha inesperada no render final: {type(exc).__name__}: {exc}")
finally:
with self.lock:
self._rendering.discard(clip["id"])
def _render_final(self, clip: dict) -> None:
taken = self.db.run("UPDATE clips SET final_status = 'rendering', final_error = NULL WHERE id = ? AND final_status = 'pending'"
" AND status IN ('approved', 'published')", clip["id"]).rowcount
if not taken:
return
session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session:
self._final_error(clip["id"], "sessão do corte não existe mais")
return
segments = self.db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?",
clip["session_id"], clip["start_s"], clip["end_s"])
if not segments or any(s["deleted"] for s in segments):
self._final_error(clip["id"], "os blocos gravados deste trecho já foram apagados")
return
out_dir = self.settings.clips_dir / str(clip["session_id"])
out = out_dir / f"clip-{clip['id']}-final.mp4"
thumb = out_dir / f"clip-{clip['id']}-final.jpg"
from . import editor, editor_api # import tardio (ver _render_clip)
t = time.monotonic()
try:
edit = editor_api.ensure_edit(self, clip, session)
cover = editor_api.render_clip_edit(self, clip, session, edit, out, thumb, dev=False)
except (media.MediaError, editor.EditError) as exc:
self._final_error(clip["id"], str(exc))
return
# Só grava se ninguém desfez a aprovação (ou editou) durante o render: aí `final_status` já não é 'rendering'.
done = self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?, final_error = NULL,"
" final_at = ? WHERE id = ? AND final_status = 'rendering'",
rel(out), rel(thumb), cover, now(), clip["id"]).rowcount
log.info("vídeo final do corte %s em %.1f s%s", clip["id"], time.monotonic() - t,
"" if done else " (descartado: o corte mudou durante o render)")
def _final_error(self, clip_id: int, message: str) -> None:
self.db.run("UPDATE clips SET final_status = 'error', final_error = ? WHERE id = ? AND final_status IN ('pending', 'rendering')",
message[:500], clip_id)
def _clip_error(self, clip_id: int, message: str) -> None: def _clip_error(self, clip_id: int, message: str) -> None:
self.db.run("UPDATE clips SET status = 'error', error = ?, updated_at = ? WHERE id = ?", message[:500], now(), clip_id) self.db.run("UPDATE clips SET status = 'error', error = ?, updated_at = ? WHERE id = ?", message[:500], now(), clip_id)
@@ -1128,8 +1378,13 @@ class Engine:
return return
limit = time.time() - self.settings.keep_hours * 3600 limit = time.time() - self.settings.keep_hours * 3600
for seg in self.db.all("SELECT * FROM segments WHERE deleted = 0 AND analyzed = 1 AND wall_end < ? LIMIT 200", limit): for seg in self.db.all("SELECT * FROM segments WHERE deleted = 0 AND analyzed = 1 AND wall_end < ? LIMIT 200", limit):
# Também guarda o trecho de quem ainda vai precisar do vídeo final: aprovado com final por fazer ou com erro, e
# pronto para aprovar cujo vídeo de revisão tem camadas de desenvolvimento (ou não se sabe) — REVISAO.md.
needed = self.db.get( needed = self.db.get(
"SELECT 1 FROM clips WHERE session_id = ? AND status IN ('candidate', 'pending', 'rendering') AND start_s < ? AND end_s > ?", "SELECT 1 FROM clips WHERE session_id = ? AND start_s < ? AND end_s > ? AND ("
"status IN ('candidate', 'pending', 'rendering')"
" OR (status IN ('approved', 'published') AND final_status IN ('pending', 'rendering', 'error'))"
" OR (status = 'ready' AND COALESCE(review_dev_json, '') != '[]'))",
seg["session_id"], seg["end_s"], seg["start_s"]) seg["session_id"], seg["end_s"], seg["start_s"])
if needed: if needed:
continue continue
+11 -1
View File
@@ -1,5 +1,5 @@
{ {
"_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.", "_comment": "Pesos do rastreio de reação e da atribuição de falante 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. Falantes: doc/clipador/FALANTES.md.",
"dir": "data/clipper/models", "dir": "data/clipper/models",
"models": [ "models": [
{ {
@@ -41,6 +41,16 @@
"size": 568302, "size": 568302,
"license": "BSD-2-Clause", "license": "BSD-2-Clause",
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251" "source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
},
{
"id": "wespeaker_r34",
"file": "wespeaker_voxceleb_resnet34_LM.onnx",
"role": "impressão de voz (falante): fbank 80 → vetor de 256 (WeSpeaker ResNet34-LM, VoxCeleb); quem fala cada palavra",
"url": "https://huggingface.co/Wespeaker/wespeaker-voxceleb-resnet34-LM/resolve/f0c48c298fd835726c27956a5d617bad7115627e/voxceleb_resnet34_LM.onnx",
"sha256": "7bb2f06e9df17cdf1ef14ee8a15ab08ed28e8d0ef5054ee135741560df2ec068",
"size": 26530309,
"license": "CC-BY-4.0",
"source": "huggingface.co/Wespeaker/wespeaker-voxceleb-resnet34-LM@f0c48c298fd835726c27956a5d617bad7115627e (atribuição: WeSpeaker, wenet-e2e)"
} }
] ]
} }
+21
View File
@@ -1,8 +1,29 @@
"""Configuração comum dos testes do Clipador.""" """Configuração comum dos testes do Clipador."""
import subprocess
import pytest import pytest
import app.ai_settings as ai_settings_module import app.ai_settings as ai_settings_module
import app.intel as intel_module import app.intel as intel_module
import app.judge as judge_module
class _NoRealCli:
"""`subprocess` do juiz nos testes: igual ao de verdade, mas `run` recusa (nenhuma CLI de IA roda e gasta a cota
do dono — juízes falsos que não cobrem um papel, como o juiz de contexto, caem no caminho de falha da IA).
Quem testa as CLIs (test_ai_fallback) troca `run` por um falso."""
def __getattr__(self, name):
return getattr(subprocess, name)
@staticmethod
def run(*_args, **_kwargs):
raise OSError("CLI de IA bloqueada nos testes")
@pytest.fixture(autouse=True)
def _no_real_ai_cli(monkeypatch):
monkeypatch.setattr(judge_module, "subprocess", _NoRealCli())
@pytest.fixture(autouse=True) @pytest.fixture(autouse=True)
+257
View File
@@ -0,0 +1,257 @@
"""JUIZ de contexto (doc/clipador/EQUIPE-IA.md): decisão pelo código (aprovar / ajustar e conferir uma vez / frase de
contexto / descartar), o fluxo no motor, a linha do tempo JSON dentro do orçamento e o mosaico de quadros."""
import json
import shutil
import subprocess
from pathlib import Path
import pytest
from app import context_judge, editor_api, media, timeline
from app import roles as roles_module
from app.judge import Judge, Verdict
from app.scoring import ChatMessage, Word
from .test_render_and_duplicates import add_clip
from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
FFMPEG = shutil.which("ffmpeg")
FFPROBE = shutil.which("ffprobe")
def result(failed=(), fix=None, line="", reason="motivo"):
return {"viewer_summary": "resumo", "confidence": 0.8, "reason": reason, "pt": {"reason": reason},
"checks": {c: {"ok": c not in failed, "t": None, "why": ""} for c in roles_module.CHECKS},
"fix": {"start_s": None, "end_s": None, "context_line": line, **(fix or {})}}
LIMITS = {"start_s": 200.0, "end_s": 265.0, "lo": 80.0, "hi": 280.0, "min_s": 61.0, "max_s": 90.0}
CONF = roles_module.default_roles()["judge"]
# ---------------------------------------------------------------- decisão pelo código
def test_all_checks_ok_approves():
d = context_judge.decide(result(), conf=CONF, score=8, min_score=6, **LIMITS)
assert d.action == "approve" and d.failed == [] and d.window is None and d.score_after == 8
def test_missing_setup_with_fix_adjusts_inside_the_limits():
d = context_judge.decide(result(["setup"], {"start_s": 150}), conf=CONF, score=8, **LIMITS)
assert d.action == "adjust" and d.failed_critical == ["setup"]
# Recuou o início para pegar o começo; com máximo de 90 s o fim encolhe (fit_window mantém o início).
assert d.window == (150.0, 240.0) and "começo (setup)" in d.reason_pt
def test_fix_outside_the_window_is_clamped_and_no_change_means_discard():
d = context_judge.decide(result(["payoff"], {"end_s": 999}), conf=CONF, **LIMITS)
assert d.action == "adjust" and d.window[1] == 280.0 # nunca passa do limite
same = context_judge.decide(result(["payoff"], {"end_s": 265.2}), conf=CONF, **LIMITS)
assert same.action == "discard" # "ajuste" que não muda nada
def test_critical_failure_without_fix_discards_with_portuguese_reason():
d = context_judge.decide(result(["payoff"], reason="ends before the fight is resolved"), conf=CONF, **LIMITS)
assert d.action == "discard" and d.reason_pt.startswith("Descartado pelo juiz: sem desfecho.")
no_fix = context_judge.decide(result(["setup"], {"start_s": 150}), conf={**CONF, "allowFix": False}, **LIMITS)
assert no_fix.action == "discard"
def test_context_line_solves_standalone():
d = context_judge.decide(result(["standalone"], line="Tfue tries to talk his way out of a robbery"), conf=CONF,
score=8, min_score=6, **LIMITS)
assert d.action == "approve" and d.solved_by_line == ["standalone"] and d.context_line.startswith("Tfue")
off = context_judge.decide(result(["standalone"], line="Tfue tries"), conf={**CONF, "allowContextLine": False},
**LIMITS)
assert off.action == "discard"
too_long = context_judge.decide(result(["standalone"], line=" ".join(["word"] * 14)), conf=CONF, **LIMITS)
assert too_long.action == "discard"
def test_non_critical_failures_only_lower_the_score():
d = context_judge.decide(result(["strong_open"]), conf=CONF, score=7, min_score=6, **LIMITS)
assert d.action == "approve" and d.score_after == 6.5
low = context_judge.decide(result(["strong_open", "faithful", "intelligible"]), conf=CONF, score=7, min_score=6,
**LIMITS)
assert low.action == "discard" and low.score_after == 5.5 and "nota caiu" in low.reason_pt
custom = context_judge.decide(result(["strong_open"]), conf={**CONF, "critical": ["strong_open"]}, **LIMITS)
assert custom.action == "discard" # as críticas são calibráveis no painel
def test_manual_clip_only_warns():
d = context_judge.decide(result(["payoff"], {"end_s": 280}), conf=CONF, manual=True, **LIMITS)
assert d.action == "warn" and d.window is None and d.reason_pt.startswith("Aviso do juiz")
# ---------------------------------------------------------------- fluxo no motor
class ContextFakeJudge(Judge):
"""Analista, editor e juiz falsos (nunca chama CLI). `answers` = respostas do juiz, em ordem."""
def __init__(self, answers, keep=True, score=8.0):
super().__init__("codex", "fake", Path("."))
self.answers = list(answers)
self.keep, self.score_value = keep, score
self.context_prompts: list[str] = []
self.editor_prompt = ""
def analyze(self, prompt, images, lang="pt"):
return {"situation": "treta", "what_happened": "Ele tenta negociar e leva um tiro.", "screen": "", "speech": "",
"chat_meaning": "", "confidence": 0.9, "action_start_s": 270, "reaction_end_s": 330, "hook": "",
"lines": [{"n": 1, "v": "streamer aponta rifle para mascarado"}]}
def judge(self, prompt, start_s, end_s, images=None, lang="pt", **_limits):
self.editor_prompt = prompt
return Verdict(self.keep, self.score_value, 270.0, 340.0, "Tentou negociar e levou tiro", "c", "r", "fake")
def check_context(self, prompt, lang="pt"):
self.context_prompts.append(prompt)
answer = self.answers.pop(0)
if isinstance(answer, Exception):
raise answer
return answer
def run_clip(engine, judge, source="chat"):
engine.judge = judge
# Sem ffmpeg nos blocos falsos: um "mosaico" de um quadro só (em 275 s), que o analista descreve.
engine.intel.visual = lambda *_a, **_k: ([Path("mosaico-falso.jpg")], [275.0], True)
sid = seed_session(engine)
cid = (engine.db.get("SELECT MAX(id) AS n FROM clips")["n"] or 0) + 1
add_clip(engine, sid, cid, "candidate", 300, 280, 345, source=source)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = ?", cid))
row = engine.db.get("SELECT * FROM clips WHERE id = ?", cid)
return row, json.loads(row["judge_json"])
def test_engine_approves_and_records_the_context(env): # noqa: F811
_client, engine = env
row, info = run_clip(engine, ContextFakeJudge([result(line="Tenta negociar com o assaltante")]))
assert row["status"] == "pending" and info["context"]["decision"] == "approve"
assert info["context"]["contextLine"] == "Tenta negociar com o assaltante"
prompt = engine.judge.context_prompts[0]
# O juiz vê só o que vai no corte: o trecho e os 20 s antes marcados out=1.
assert "Corte que o espectador verá: 270s a 340s" in prompt and '"out":1' in prompt
assert "História pretendida (analista): Ele tenta negociar e leva um tiro." in prompt
# O que o analista viu no quadro virou o `v` da linha do tempo do editor.
assert '"v":"streamer aponta rifle para mascarado"' in engine.judge.editor_prompt
def test_engine_adjusts_once_then_approves(env): # noqa: F811
_client, engine = env
row, info = run_clip(engine, ContextFakeJudge([result(["setup"], {"start_s": 250}), result()]))
assert row["status"] == "pending" and (row["start_s"], row["end_s"]) == (250.0, 340.0)
ctx = info["context"]
assert ctx["decision"] == "adjust" and ctx["window"] == [250.0, 340.0] and ctx["first"]["failedCritical"] == ["setup"]
assert len(engine.judge.context_prompts) == 2 and "250s a 340s" in engine.judge.context_prompts[1]
def test_engine_adjusts_then_discards_when_still_failing(env): # noqa: F811
client, engine = env
row, info = run_clip(engine, ContextFakeJudge([result(["payoff"], {"end_s": 355}),
result(["payoff"], {"end_s": 360})]))
assert row["status"] == "discarded" and info["discardedBy"] == "context"
assert info["context"]["decision"] == "discard" and "depois do ajuste" in info["context"]["reasonPt"]
assert len(engine.judge.context_prompts) == 2 # confere UMA vez de novo, nunca mais
# Descartado pelo juiz fica visível e dá para forçar o render, como o descarte de hoje.
forced = client.post("/v1/clips/1/render", headers=auth()).json()
assert forced["status"] == "pending" and forced["judge"]["context"]["decision"] == "discard"
def test_engine_discard_without_fix_and_judge_failure_keeps_editor(env): # noqa: F811
_client, engine = env
row, info = run_clip(engine, ContextFakeJudge([result(["standalone"])]))
assert row["status"] == "discarded" and info["context"]["failedCritical"] == ["standalone"]
from app.judge import JudgeError
row, info = run_clip(engine, ContextFakeJudge([JudgeError("cota")]))
assert row["status"] == "pending" and info["context"] == {"error": "cota"}
def test_judge_role_off_and_editor_discard_skip_the_judge(env): # noqa: F811
_client, engine = env
judge = ContextFakeJudge([result(["payoff"])])
judge.roles["judge"]["enabled"] = False
row, info = run_clip(engine, judge)
assert row["status"] == "pending" and "context" not in info and judge.context_prompts == []
kept_out = ContextFakeJudge([result()], keep=False)
row, info = run_clip(engine, kept_out)
assert row["status"] == "discarded" and kept_out.context_prompts == [] # o editor já descartou
def test_manual_clip_is_never_discarded_by_the_judge(env): # noqa: F811
_client, engine = env
row, info = run_clip(engine, ContextFakeJudge([result(["payoff"], {"end_s": 360})]), source="manual")
assert row["status"] == "pending" and info["context"]["decision"] == "warn"
assert (row["start_s"], row["end_s"]) == (280.0, 345.0)
def test_context_line_becomes_the_opening_text_of_the_edit(env): # noqa: F811
_client, engine = env
row, _info = run_clip(engine, ContextFakeJudge([result(["setup"], {"start_s": 250}),
result(line="Ele tenta negociar com o assaltante")]))
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", row["session_id"])
project = editor_api.auto_for(engine, row, session)
hook = next(o for o in project["overlays"] if o["kind"] == "hook")
assert hook["text"] == "Ele tenta negociar com o assaltante"
# O ajuste do juiz não é desfeito pelo início da ação do analista (270 s).
assert project["cuts"][0]["start"] <= 250.5
# ---------------------------------------------------------------- linha do tempo JSON
def _evidence(seconds=240):
words, chat = [], []
for t in range(0, seconds, 2):
words.append(Word(float(t), t + 1.5, f"palavra{t}", "other1" if 60 <= t < 64 else ""))
for t in range(0, seconds, 3):
chat.append(ChatMessage(float(t), "KEKW que isso" if t % 2 else "lol", emotes=("KEKW",) if t % 2 else ()))
loudness = [-30.0] * seconds
loudness[100] = -10.0
return timeline.Evidence(words=words, chat=chat, loudness=loudness, face=[(101, "laugh", 6.4)],
scenes=[(100.0, "explosão na garagem")])
def test_timeline_entries_are_short_split_by_speaker_and_marked():
ev = _evidence()
items = timeline.entries(ev, 40, 130, clip=(60, 120))
assert all(i["d"] <= 8 for i in items) and items[0]["t"] == 40
assert any(i.get("sp", "").startswith("[other1]") for i in items) # troca de falante abre entrada nova
# Fora do corte (antes e depois) sai marcado; nenhuma entrada atravessa o início ou o fim do corte.
assert all(i.get("out") == 1 for i in items if i["t"] < 60 or i["t"] >= 120)
assert not any("out" in i for i in items if 60 <= i["t"] < 120)
assert {60, 120} <= {i["t"] for i in items} and all(i["t"] + i["d"] <= 60 for i in items if i["t"] < 60)
hit = next(i for i in items if i["t"] <= 100 < i["t"] + i["d"])
assert hit["v"] == "explosão na garagem" and hit["face"] == "laugh.6" and hit["lvl"] > 3
assert hit["chat"].split("|")[0].isdigit() and "KEKW×" in hit["chat"]
def test_timeline_fits_the_budget():
ev = _evidence(600)
full = timeline.build(ev, 0, 600, {"win": [0, 600]}, budget_chars=100_000)
small = timeline.build(ev, 0, 600, {"win": [0, 600]}, budget_chars=6000)
assert len(small) <= 6000 < len(full)
assert all(json.loads(line) for line in small.splitlines()) # cada linha continua JSON válido
coarse = timeline.build(ev, 0, 600, {"win": [480, 600]}, budget_chars=100_000, coarse_until=480)
first = json.loads(coarse.splitlines()[1])
assert first["d"] == 20 and "face" not in first # a "volta" da varredura vai resumida
def test_scene_lines_are_saved_by_tile_number(env): # noqa: F811
_client, engine = env
sid = seed_session(engine)
n = timeline.save_scene_lines(engine, sid, "scan", [{"n": 2, "v": " carro capotando "}, {"n": 9, "v": "x"},
{"n": "a"}], [10.0, 40.0, 70.0])
assert n == 1 and timeline.scene_lines(engine, sid, 0, 100) == [(40.0, "carro capotando")]
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
@pytest.mark.parametrize("count,size", [(8, "1536x432"), (6, "1536x432"), (3, "1152x216")])
def test_mosaic_puts_frames_in_one_image(tmp_path, count, size):
frames = []
for i in range(count):
out = tmp_path / f"f{i}.jpg"
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", f"color=c=0x{i * 30:02x}4080:s=768x432",
"-frames:v", "1", str(out)], check=True)
frames.append(out)
target = media.mosaic(FFMPEG, frames, tmp_path / "m.jpg")
probe = subprocess.run([FFPROBE, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=s=x:p=0", str(target)], capture_output=True, text=True, check=True)
assert probe.stdout.strip() == size
+337
View File
@@ -0,0 +1,337 @@
"""Dublagem em português (camada de desenvolvimento, doc/clipador/DUBLAGEM.md) — sempre com TTS falso."""
import io
import math
import shutil
import struct
import wave
from array import array
from pathlib import Path
import pytest
from app import dub, editor, editor_render, layout, media
FFMPEG = shutil.which("ffmpeg")
CUTS = [{"start": 10.0, "end": 20.0, "mode": None}, {"start": 25.0, "end": 40.0, "mode": None}] # 25 s de saída
def fake_wav(seconds: float, rate: int = 24000, freq: float = 440.0) -> bytes:
"""WAV mono 16 bits com um seno (o "TTS" dos testes)."""
n = int(seconds * rate)
buf = io.BytesIO()
with wave.open(buf, "wb") as w:
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(rate)
w.writeframes(b"".join(struct.pack("<h", int(12000 * math.sin(2 * math.pi * freq * i / rate))) for i in range(n)))
return buf.getvalue()
class FakeSynth:
"""Duração da fala proporcional ao texto (0,08 s por letra); registra cada chamada."""
def __init__(self, per_char: float = 0.08, fail_voices: tuple[str, ...] = ()):
self.per_char, self.fail_voices, self.calls = per_char, fail_voices, []
def __call__(self, text: str, voice: str) -> bytes:
self.calls.append((voice, text))
if voice in self.fail_voices:
raise dub.DubError(f"voz {voice} respondeu 502")
return fake_wav(max(0.2, len(text) * self.per_char))
def opts(**over):
return {**dub.options(layout.merge({"dev": {"dub": True}})), **over}
# ---------------------------------------------------------------- plano no tempo de saída
def test_lines_go_to_output_time_and_skip_removed_parts():
lines = [
{"s": 11.0, "e": 12.0, "text": "a", "pt": "primeira"},
{"s": 21.0, "e": 23.0, "text": "b", "pt": "no trecho removido"}, # 20–25 foi cortado
{"s": 26.0, "e": 27.0, "text": "c", "pt": " depois do corte "},
{"s": 30.0, "e": 31.0, "text": "d", "pt": ""}, # sem tradução: não dubla
]
plan = dub.plan_lines(lines, CUTS, opts())
assert [(p.at, p.text) for p in plan] == [(1.0, "primeira"), (11.0, "depois do corte")]
assert all(p.voice == layout.DUB_VOICE for p in plan)
def test_speaker_other_uses_second_voice_and_missing_falls_back():
lines = [{"s": 11, "e": 12, "pt": "eu"}, {"s": 13, "e": 14, "pt": "outro", "speaker": "other"},
{"s": 15, "e": 16, "pt": "eu de novo", "speaker": "streamer"}, {"s": 17, "e": 18, "pt": "?", "speaker": "x"}]
plan = dub.plan_lines(lines, CUTS, opts(voice="pt-br-antonio", voiceOther="pt-br-cadu"))
assert [p.voice for p in plan] == ["pt-br-antonio", "pt-br-cadu", "pt-br-antonio", "pt-br-antonio"]
assert plan[1].speaker == "other"
# Sem `dubVoiceOther` na configuração salva: a padrão do Clipador; vazio = a mesma voz do streamer.
assert dub.options(layout.merge({}))["voiceOther"] == layout.DUB_VOICE_OTHER
assert dub.options({"dev": {"dubVoice": "pt-br-faber", "dubVoiceOther": ""}})["voiceOther"] == "pt-br-faber"
# ---------------------------------------------------------------- encaixe
def _line(at: float) -> dub.DubLine:
return dub.DubLine(at, "x", "v")
def test_fit_prefers_natural_speed_spills_over_and_never_overlaps_or_drifts():
lines = [_line(0.0), _line(2.0), _line(4.0), _line(5.0), _line(8.0), _line(9.0), _line(10.0)]
durations = [1.5, 2.6, 3.0, 0.9, 5.0, 0.5, 0.5]
cues = dub.fit(lines, durations, total=14.0)
by = {c.index: c for c in cues}
assert by[0].tempo == 1.0 and by[0].length == 1.5 and not by[0].cut # cabe: natural
assert by[1].tempo == 1.0 and by[1].at + by[1].length > 4.0 # escorre além da próxima frase, sem acelerar
assert by[2].at > 4.0 and by[2].at <= 4.0 + dub.MAX_LATE_S # começa depois da anterior, perto da original
# 3 s sem espaço nem escorrendo: acelera pouco (no máximo MAX_TEMPO) e corta com fade.
assert 1.0 < by[2].tempo <= dub.MAX_TEMPO and by[2].cut
for c in cues: # o atraso de cada fala é limitado pela PRÓPRIA frase original: não acumula
assert lines[c.index].at <= c.at <= lines[c.index].at + dub.MAX_LATE_S
assert c.tempo <= dub.MAX_TEMPO and c.at + c.length <= 14.0
ordered = sorted(cues, key=lambda c: c.at)
for a, b in zip(ordered, ordered[1:]):
assert a.at + a.length + dub.GAP_S <= b.at + 1e-6
def test_phrase_split_mid_sentence_is_joined():
lines = [{"s": 11.0, "e": 12.8, "pt": "se a gente fizer rápido deve dar"}, {"s": 12.9, "e": 13.1, "pt": "tudo certo."},
{"s": 13.2, "e": 13.6, "pt": "Beleza."}, # frase completa antes: não junta
{"s": 13.7, "e": 14.0, "pt": "Como assim"}, {"s": 14.1, "e": 14.5, "pt": "mano?", "speaker": "other"}]
plan = dub.plan_lines(lines, CUTS, opts())
assert [(p.at, p.text) for p in plan] == [(1.0, "se a gente fizer rápido deve dar tudo certo."), (3.2, "Beleza."),
(3.7, "Como assim"), (4.1, "mano?")] # falante diferente: não junta
def test_fit_skips_phrase_without_room_or_audio():
cues = dub.fit([_line(0.0), _line(0.05), _line(3.0)], [2.0, 0.0, 1.0], total=3.2)
assert [c.index for c in cues] == [0] # 1 falhou (não limita a 0); 2 com 0,2 s até o fim: não dá para entender
# Frase fora do trecho (None): não toca, mas segura a anterior no lugar dela.
cues = dub.fit([_line(0.0), _line(1.0)], [2.0, None], total=5.0)
assert [c.index for c in cues] == [0] and cues[0].at + cues[0].length <= 1.0 + dub.MAX_LATE_S
def test_duck_spans_merge_short_gaps_and_ramp_expression():
cues = [dub.Cue(1.0, 1.0, 1.0, False, 0), dub.Cue(2.3, 1.0, 1.0, False, 1), dub.Cue(6.0, 1.0, 1.0, False, 2)]
spans = dub.duck_spans(cues)
assert spans == [(1.0, 3.3), (6.0, 7.0)]
factors = dub.duck_factors(spans, 0.25)
env = {"clip": lambda x, lo, hi: max(lo, min(hi, x)), "min": min}
def gain(t: float) -> float:
value = 1.0
for f in factors:
value *= eval(f, env, {"t": t}) # noqa: S307 — expressão gerada pelo próprio teste
return value
assert gain(0.0) == 1.0 and gain(5.0) == 1.0 and gain(9.0) == 1.0 # fora das falas: normal
assert gain(2.0) == pytest.approx(0.25) and gain(6.5) == pytest.approx(0.25)
assert 0.25 < gain(1.0 - dub.RAMP_S / 2) < 1.0 # rampa antes de começar
assert dub.duck_factors(spans, 1.0) == []
def test_gain_follows_original_level():
assert dub.gain_for(None) == 0.0
assert dub.gain_for(-32.0) == pytest.approx(-32.0 + dub.LEVEL_OVER_ORIGINAL_DB - dub.TTS_LEVEL_DB) # live baixa
assert dub.gain_for(-5.0) == dub.GAIN_RANGE_DB[1] and dub.gain_for(-90.0) == dub.GAIN_RANGE_DB[0]
# ---------------------------------------------------------------- cache
def test_cache_synthesizes_once_per_voice_and_text(tmp_path):
synth = FakeSynth()
cache = dub.TtsCache(tmp_path / "dub", synth, ffmpeg=None)
f1, d1 = cache.get("pt-br-antonio", "olha isso")
f2, d2 = cache.get("pt-br-antonio", "olha isso")
assert f1 == f2 and d1 == d2 == pytest.approx(len("olha isso") * 0.08, abs=0.01)
assert len(synth.calls) == 1
cache.get("pt-br-cadu", "olha isso")
assert len(synth.calls) == 2 and len(list((tmp_path / "dub").glob("*.wav"))) == 2
# Outro processo (render da fila depois da prévia) acha o mesmo arquivo.
again = dub.TtsCache(tmp_path / "dub", FakeSynth(), ffmpeg=None)
assert again.get("pt-br-antonio", "olha isso")[0] == f1 and again.synth_calls == 0
# Limpeza: só o que está sem uso há mais de 30 dias.
import os
import time
old = cache.path("pt-br-cadu", "olha isso")
os.utime(old, (time.time() - 40 * 86400,) * 2)
assert cache.prune() == 1 and not old.exists() and f1.exists()
def test_voice_failure_falls_back_to_offline_voice(tmp_path):
synth = FakeSynth(fail_voices=("pt-br-antonio",))
dubber = dub.Dubber(dub.TtsCache(tmp_path, synth, ffmpeg=None), ffmpeg=None)
path, _ = dubber._speech(dub.DubLine(0.0, "oi", "pt-br-antonio"))
assert synth.calls[-1] == (dub.FALLBACK_VOICE, "oi") and path.is_file()
def test_engine_without_voice_service_builds_nothing(tmp_path):
synth = dub.voice_synth(None, None)
with pytest.raises(dub.DubError):
synth("oi", "pt-br-antonio")
dubber = dub.Dubber(dub.TtsCache(tmp_path, synth, ffmpeg="ffmpeg"), ffmpeg="ffmpeg")
cfg = layout.merge({"dev": {"dub": True}})
assert dubber.build([{"s": 11, "e": 12, "pt": "oi"}], CUTS, cfg, 0, 25, tmp_path, "x") is None
# ---------------------------------------------------------------- configuração
def test_dev_group_validates_new_keys():
ok = layout.validate({"dev": {"dub": True, "dubVoice": "pt-br-faber", "dubVoiceOther": "kokoro-pm-alex", "dubDuck": 0.3}})
assert ok["dev"] == {"dub": True, "dubVoice": "pt-br-faber", "dubVoiceOther": "kokoro-pm-alex", "dubDuck": 0.3}
for bad in ({"dubVoice": "../x"}, {"dubVoiceOther": ""}, {"dubDuck": 1.5}, {"dubDuck": "alto"}):
with pytest.raises(layout.LayoutError):
layout.validate({"dev": bad})
merged = layout.merge({"dev": {"dub": True, "dubDuck": 0.1}})
assert merged["dev"]["dubDuck"] == 0.1 and merged["dev"]["dubVoice"] == layout.DUB_VOICE
assert layout.dev_flags(merged, dev=False) == {"translation": False, "dub": False}
# ---------------------------------------------------------------- render: só no vídeo de revisão
class SpyDubber:
def __init__(self):
self.calls, self.level = 0, None
def build(self, translation, cuts, cfg, t0, t1, work, stem, level_db=None):
self.calls, self.level = self.calls + 1, level_db
file = work / f"{stem}.dub.wav"
file.write_bytes(fake_wav(0.5))
return dub.DubTrack(file, [(1.0, 2.0)], 0.25, 1, 0.1, 1)
def _validated(tmp_path: Path) -> dict:
data = {"schema": 1, "source": {"sessionId": 1, "lo": 0, "hi": 60}, "settings": {}, "cuts": CUTS,
"captions": {"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B", "words": []},
"overlays": [], "progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1, "narration": [], "music": None, "sfx": []}, "cover": {"enabled": False, "t": 12, "text": ""}}
return editor.validate_project(data, session_id=1, session_duration=100, repo_root=tmp_path, tts_dir=tmp_path / "tts",
assets_dir=tmp_path / "assets")
@pytest.mark.parametrize("dev_render", [True, False])
def test_render_mixes_dub_only_in_review_video(tmp_path, monkeypatch, dev_render):
seen: list[list[str]] = []
def fake_run(args, timeout, cwd=None):
seen.append(args)
(Path(cwd) / args[-1]).write_bytes(b"mp4")
return b""
monkeypatch.setattr(media, "run", fake_run)
monkeypatch.setattr(editor_render, "mean_volume", lambda *a, **k: -32.0)
(tmp_path / "seg.ts").write_bytes(b"")
spy = SpyDubber()
lines = [{"s": 11.0, "e": 12.0, "text": "No way.", "pt": "Não acredito."}]
info = editor_render.render_project(
"ffmpeg", None, [], [(tmp_path / "seg.ts", 0.0, 100.0)], _validated(tmp_path),
layout.merge({"dev": {"dub": True}}), "x", tmp_path / "out" / "clip.mp4", tmp_path,
translation=lines, dev=dev_render, dubber=spy)
graph = seen[-1][seen[-1].index("-filter_complex") + 1]
if dev_render:
assert spy.calls == 1 and info["dub"]["cues"] == 1 and spy.level == -32.0 # nivelada pelo original
assert any(a.endswith("clip.dub.wav") for a in seen[-1]) and "0.750*clip(" in graph
assert not (tmp_path / "out" / "clip.dub.wav").exists() # faixa temporária apagada
else: # vídeo final (depois de aprovar): nada da dublagem
assert spy.calls == 0 and info["dub"] is None
assert "clip(" not in graph and not any("dub" in a for a in seen[-1])
def test_render_without_dub_flag_does_not_call_dubber(tmp_path, monkeypatch):
monkeypatch.setattr(media, "run", lambda args, timeout, cwd=None: (Path(cwd) / args[-1]).write_bytes(b"x") and b"")
(tmp_path / "seg.ts").write_bytes(b"")
spy = SpyDubber()
editor_render.render_project("ffmpeg", None, [], [(tmp_path / "seg.ts", 0.0, 100.0)], _validated(tmp_path),
layout.merge({}), "x", tmp_path / "out" / "c.mp4", tmp_path,
translation=[{"s": 11, "e": 12, "pt": "oi"}], dubber=spy)
assert spy.calls == 0
# ---------------------------------------------------------------- FFmpeg de verdade (faixa)
def _samples(file: Path) -> tuple[array, int, int]:
with wave.open(str(file)) as w:
data = array("h", w.readframes(w.getnframes()))
return data, w.getframerate(), w.getnchannels()
def _peak(data: array, rate: int, channels: int, a: float, b: float) -> int:
chunk = data[int(a * rate) * channels:int(b * rate) * channels]
return max((abs(x) for x in chunk), default=0)
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_track_places_speech_at_phrase_start_and_uses_cache(tmp_path):
synth = FakeSynth(per_char=0.1)
dubber = dub.Dubber(dub.TtsCache(tmp_path / "cache", synth, FFMPEG), FFMPEG)
cfg = layout.merge({"dev": {"dub": True}})
lines = [{"s": 11.0, "e": 12.0, "pt": "frase um"}, # saída 1,0 s; ~0,8 s de fala
{"s": 22.0, "e": 23.0, "pt": "removida"}, # trecho removido: não dubla
{"s": 27.0, "e": 28.0, "pt": "frase dois"}] # saída 12,0 s
track = dubber.build(lines, CUTS, cfg, 0.0, 25.0, tmp_path, "full")
assert track and track.cues == 2 and track.synthesized == 2
data, rate, channels = _samples(track.file)
assert channels == 2 and abs(len(data) / channels / rate - 25.0) < 0.05
assert _peak(data, rate, channels, 0.0, 0.95) < 200 # silêncio antes da 1ª frase
assert _peak(data, rate, channels, 1.1, 1.6) > 3000 # fala no lugar
assert _peak(data, rate, channels, 3.0, 11.9) < 200
assert _peak(data, rate, channels, 12.1, 12.6) > 3000
assert track.spans[0][0] == pytest.approx(1.0, abs=0.01)
# Prévia de 5 s a partir de 10 s: só a frase que toca ali; tudo do cache.
preview = dubber.build(lines, CUTS, cfg, 10.0, 15.0, tmp_path, "preview")
assert preview and preview.cues == 1 and preview.synthesized == 0 and len(synth.calls) == 2
data, rate, channels = _samples(preview.file)
assert abs(len(data) / channels / rate - 5.0) < 0.05 and _peak(data, rate, channels, 2.1, 2.6) > 3000
assert preview.spans[0][0] == pytest.approx(2.0, abs=0.01)
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_real_render_with_dub(tmp_path):
import subprocess
seg = tmp_path / "seg.ts"
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", "testsrc2=s=640x360:r=30:d=8", "-f", "lavfi", "-i",
"sine=frequency=300:d=8", "-c:v", "libx264", "-preset", "ultrafast", "-c:a", "aac", "-shortest",
"-f", "mpegts", str(seg)], check=True, capture_output=True)
project = _validated(tmp_path)
project["cuts"] = [{"start": 0.0, "end": 3.0, "mode": None, "muted": False}, {"start": 5.0, "end": 8.0, "mode": None, "muted": False}]
dubber = dub.Dubber(dub.TtsCache(tmp_path / "cache", FakeSynth(), FFMPEG), FFMPEG)
out = tmp_path / "out" / "clip.mp4"
info = editor_render.render_project(
FFMPEG, shutil.which("ffprobe"), ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 8.0)], project,
layout.merge({"dev": {"dub": True}}), "x", out, tmp_path, translation=[{"s": 1.0, "e": 2.0, "pt": "olha só"},
{"s": 5.5, "e": 6.5, "pt": "voltou"}],
dubber=dubber)
assert out.is_file() and info["dub"]["cues"] == 2
assert media.probe_duration(shutil.which("ffprobe"), out) == pytest.approx(6.0, abs=0.25)
assert not list((tmp_path / "out").glob("*.dub.wav"))
# ---------------------------------------------------------------- rotas: prévia do editor e render da fila
from .test_editor import _lavfi_segments, api # noqa: E402,F401 — fixture do editor (sessão, blocos, corte 7)
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_preview_and_queue_render_dub_the_same_way(api, monkeypatch):
from .test_sources_and_api import KEY
client, engine, root = api
_lavfi_segments(root / "data" / "s1")
h = {"X-Service-Key": KEY}
monkeypatch.setattr(engine.intel, "settings_for", lambda session: layout.merge({"dev": {"dub": True}}))
lines = [{"s": 3.0, "e": 4.0, "text": "No way.", "pt": "Não acredito."},
{"s": 6.0, "e": 7.0, "text": "Bro.", "pt": "Mano.", "speaker": "other"}]
monkeypatch.setattr(engine, "translate_clip", lambda clip_id, lo=None, hi=None, force=False: {"lines": lines})
synth = FakeSynth()
engine._dubber = dub.Dubber(dub.TtsCache(root / "data" / "dub", synth, FFMPEG), FFMPEG)
assert dub.for_engine(engine) is engine._dubber
project = client.get("/v1/clips/7/edit", headers=h).json()["project"]
assert client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0}).status_code == 200
prev = client.post("/v1/clips/7/preview-render", headers=h, json={"fromS": 0, "durationS": 3})
assert prev.status_code == 200, prev.text
assert synth.calls == [(layout.DUB_VOICE, "Não acredito.")] # a prévia só sintetiza o que toca nela
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"]
# Fila: a 1ª fala veio do cache da prévia; a do "other" saiu com a segunda voz.
assert synth.calls == [(layout.DUB_VOICE, "Não acredito."), (layout.DUB_VOICE_OTHER, "Mano.")]
def test_numbered_other_speakers_use_the_second_voice():
"""Integração com FALANTES.md: a separação entrega `other1`, `other2`…; todas usam a segunda voz."""
from app.dub import voice_for
opts = {"voice": "a", "voiceOther": "b"}
assert voice_for({"speaker": "other1"}, opts) == "b" and voice_for({"speaker": "other2"}, opts) == "b"
assert voice_for({"speaker": "streamer"}, opts) == "a" and voice_for({}, opts) == "a"
+6 -2
View File
@@ -97,7 +97,10 @@ def test_english_session_judges_in_english_and_stores_portuguese(env): # noqa:
add_clip(engine, sid, 1, "candidate", 285, 270, 340) add_clip(engine, sid, 1, "candidate", 285, 270, 340)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1")) engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1"))
assert engine.judge.seen["analyze"][0] == "en" and engine.judge.seen["judge"][0] == "en" assert engine.judge.seen["analyze"][0] == "en" and engine.judge.seen["judge"][0] == "en"
assert "Transcript:" in engine.judge.seen["judge"][1] and "ANALYST's analysis" in engine.judge.seen["judge"][1] # Linha do tempo JSON (padrão desde a Equipe de IA, EQUIPE-IA.md): legenda das chaves e a fala dentro dela.
editor_prompt = engine.judge.seen["judge"][1]
assert "Timeline (JSON Lines" in editor_prompt and "ANALYST's analysis" in editor_prompt
assert '"sp":"No way bro.' in editor_prompt
clip = client.get("/v1/clips/1", headers=_auth()).json() clip = client.get("/v1/clips/1", headers=_auth()).json()
assert clip["title"] == "He robbed the bank solo" # o vídeo/publicação: inglês assert clip["title"] == "He robbed the bank solo" # o vídeo/publicação: inglês
assert clip["judge"]["pt"]["title"] == "Ele roubou o banco sozinho" # o painel: português assert clip["judge"]["pt"]["title"] == "Ele roubou o banco sozinho" # o painel: português
@@ -115,6 +118,7 @@ def test_portuguese_session_has_no_translation(env): # noqa: F811
engine.judge = EnglishJudge() engine.judge = EnglishJudge()
sid = seed_session(engine) sid = seed_session(engine)
add_clip(engine, sid, 1, "candidate", 300, 280, 350) add_clip(engine, sid, 1, "candidate", 300, 280, 350)
engine.intel.opts["timelineJson"] = False # formato antigo (transcrição + chat) continua atrás da opção
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1")) engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1"))
assert engine.judge.seen["judge"][0] == "pt" and "Transcrição:" in engine.judge.seen["judge"][1] assert engine.judge.seen["judge"][0] == "pt" and "Transcrição:" in engine.judge.seen["judge"][1]
assert client.get("/v1/clips/1", headers=_auth()).json()["translation"] is None assert client.get("/v1/clips/1", headers=_auth()).json()["translation"] is None
@@ -152,7 +156,7 @@ def test_voice_language_maps_audience_codes_to_whisper_codes():
def test_dev_layers_never_reach_the_final_render(tmp_path): def test_dev_layers_never_reach_the_final_render(tmp_path):
"""Contrato `dev` (18/11/2026): camadas de desenvolvimento só no vídeo de revisão; `dev=False` = vídeo final limpo.""" """Contrato `dev` (18/11/2026): camadas de desenvolvimento só no vídeo de revisão; `dev=False` = vídeo final limpo."""
assert layout.DEFAULTS["dev"] == {"translation": False, "dub": False} assert {k: layout.DEFAULTS["dev"][k] for k in ("translation", "dub")} == {"translation": False, "dub": False}
assert layout.validate({"dev": {"translation": True, "dub": True, "x": 1}})["dev"] == {"translation": True, "dub": True} assert layout.validate({"dev": {"translation": True, "dub": True, "x": 1}})["dev"] == {"translation": True, "dub": True}
cfg = layout.merge({"dev": {"translation": True, "dub": True}}) cfg = layout.merge({"dev": {"translation": True, "dub": True}})
assert layout.dev_flags(cfg) == {"translation": True, "dub": True} assert layout.dev_flags(cfg) == {"translation": True, "dub": True}
+309
View File
@@ -0,0 +1,309 @@
"""Mapa de expressões (reaction.py + face.py): expressões novas, pose/corpo e compatibilidade com a série antiga.
Séries sintéticas no formato da live real (doc/clipador/EXPRESSOES.md): neutro com ruído pequeno e eventos injetados.
"""
import json
import math
import random
import numpy as np
import pytest
from app import face as face_mod
from app.reaction import (
EXTRA_SECOND_FIELDS, FaceSample, FaceSecond, ReactionParams, body_moments, channel_z, expression_map, label,
per_second, reaction_moments, seconds_from_json, seconds_to_json, summarize, yawn_seconds, zigzag_legs,
)
from tests.test_face import CAM, make_service, set_cam
from tests.test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
FPS = 6
def calm(n: int = 300, seed: int = 1, head: bool = True) -> list[FaceSecond]:
"""Neutro como o do skipnho (sessão 8): sorriso baixo, olhos semicerrados ~0,45, lábios um pouco apertados."""
rng = random.Random(seed)
out = []
for t in range(n):
s = FaceSecond(t, 1.0, 0.5, 0.4, 0.3, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.02),
surprise=rng.uniform(0.0, 0.004), frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.02, 0.1),
blink=0.5, motion=rng.uniform(0.02, 0.15))
s.brow_inner = rng.uniform(0.02, 0.1)
s.mouth_frown = rng.uniform(0.0, 0.01)
s.squint = rng.uniform(0.4, 0.5)
s.press = rng.uniform(0.05, 0.12)
s.stretch = rng.uniform(0.0, 0.03)
s.upper_lip = rng.uniform(0.0, 0.02)
s.pucker = rng.uniform(0.0, 0.05)
s.yaw, s.pitch, s.roll = rng.uniform(-3, 3), 12 + rng.uniform(-2, 2), rng.uniform(-2, 2)
s.shake, s.nod = float(rng.choice([0, 0, 1])), float(rng.choice([0, 0, 1]))
if head:
s.head, s.head_motion = 1.0, rng.uniform(0.05, 0.3)
out.append(s)
return out
def expr_at(seconds: list[FaceSecond], t: int) -> str | None:
return expression_map(seconds)[t]["expr"]
# --- expressões novas -------------------------------------------------------------------------------------------
@pytest.mark.parametrize("name,changes", [
("medo", {"brow_inner": 0.7, "brow": 0.7, "stretch": 0.4}),
("tristeza", {"mouth_frown": 0.35, "brow_inner": 0.3}),
("nojo", {"upper_lip": 0.6}),
("espanto", {"pucker": 0.7, "brow": 0.6}),
("tenso", {"press": 0.5, "squint": 0.75}),
("raiva", {"press": 0.5, "squint": 0.75, "frown": 0.15}),
])
def test_each_new_expression_fires_on_its_pattern(name, changes):
seconds = calm()
for key, value in changes.items():
setattr(seconds[200], key, value)
assert expr_at(seconds, 200) == name
# Os vizinhos continuam neutros.
assert expr_at(seconds, 190) == "neutro" and expr_at(seconds, 210) == "neutro"
def test_neutral_has_no_new_expression_nor_body():
emap = expression_map(calm(600, seed=4))
assert {e["expr"] for e in emap} <= {"neutro"}
assert all(e["body"] is None for e in emap)
def test_upper_lip_with_big_smile_is_laughing_not_disgust():
# Sessão 8: todo "nojo" da 1ª rodada era risada de dentes à mostra (sorriso 0,9 já normal dele, lábio de cima 0,4–0,8).
seconds = calm()
for s in seconds:
s.smile = 0.9 + (s.t % 3) * 0.02
seconds[200].upper_lip = 0.6
assert expr_at(seconds, 200) == "risada"
def test_laugh_with_head_thrown_back_is_gargalhada_and_small_smile_is_alegria():
seconds = calm()
seconds[200].smile, seconds[200].pitch = 0.9, -15.0 # 27° acima do neutro dele (+12°)
seconds[250].smile = 0.9
seconds[280].smile = 0.33 # sorriso acima do neutro, mas sem chegar a pico
emap = expression_map(seconds)
assert emap[200]["expr"] == "gargalhada" and emap[250]["expr"] == "risada" and emap[280]["expr"] == "alegria"
def test_yawn_is_not_a_scream_and_never_a_peak():
# Sessão 8: os 5 trechos de jawOpen ≥ 0,6 por 3 s eram bocejos e eram os maiores "gritos" (z 12–16).
seconds = calm()
for t in range(150, 153):
seconds[t].jaw, seconds[t].squint = 0.75, 0.7
seconds[250].jaw = 0.75 # boca escancarada por 1 s: grito
zs = channel_z(seconds)
assert yawn_seconds(seconds, zs, ReactionParams()) == {150, 151, 152}
assert expr_at(seconds, 151) == "bocejo"
assert [(m.peak_s, m.label) for m in reaction_moments(seconds)] == [(250, "grito")]
def test_new_channels_only_label_unless_weighted():
# Peso 0 (padrão): tristeza aparece no mapa, mas não vira pico; com peso, vira.
seconds = calm()
seconds[200].mouth_frown, seconds[200].brow_inner = 0.4, 0.3
assert reaction_moments(seconds) == []
weighted = ReactionParams(extra_weights={"mouth_frown": 1.0})
assert [(m.peak_s, m.label) for m in reaction_moments(seconds, weighted)] == [(200, "tristeza")]
def test_label_without_z_uses_raw_thresholds_for_new_channels():
second = calm(1)[0]
second.upper_lip = 0.6
assert label(second) == "nojo"
# --- corpo / cabeça pela pose -----------------------------------------------------------------------------------
def posed(duration: int, yaw=lambda t: 0.0, pitch=lambda t: 12.0, size=lambda t: 0.3, cx=lambda t: 0.5,
present=lambda t: True, head=lambda t: False) -> list[FaceSample]:
rng = random.Random(7)
out = []
for i in range(duration * FPS):
t = i / FPS
if present(t):
blend = {"mouthSmileLeft": 0.05, "mouthSmileRight": 0.05, "jawOpen": 0.01}
pose = (yaw(t) + rng.uniform(-1, 1), pitch(t) + rng.uniform(-1, 1), rng.uniform(-1, 1))
out.append(FaceSample(t, True, cx(t) + rng.uniform(-0.003, 0.003), 0.4, size(t), blend, pose))
elif head(t):
out.append(FaceSample(t, False, cx(t), 0.4, size(t), head=True))
else:
out.append(FaceSample(t, False))
return out
def window(lo: float, hi: float, fn, rest=0.0):
return lambda t: fn(t) if lo <= t < hi else rest
def test_zigzag_counts_back_and_forth():
assert zigzag_legs([0, 1, -1, 2, 0], 8) == []
assert len(zigzag_legs([0, 20, 0], 8)) == 2 # olhou para o lado e voltou
assert len(zigzag_legs([0, 15, -15, 15, -15], 8)) == 4
def test_head_shake_and_nod_from_pose():
shake = window(100, 103, lambda t: 15 * math.sin(2 * math.pi * 1.2 * t))
nod = window(200, 203, lambda t: 12 + 10 * math.sin(2 * math.pi * 1.2 * t), 12.0)
glance = window(250, 251.5, lambda t: 30 * math.sin(math.pi * (t - 250) / 1.5)) # vira e volta uma vez
seconds = per_second(posed(300, yaw=lambda t: shake(t) + glance(t), pitch=nod), 300)
labels = [(b.label, b.start_s) for b in body_moments(seconds)]
assert any(name == "balançando" and 99 <= s <= 101 for name, s in labels)
assert any(name == "acenando" and 199 <= s <= 202 for name, s in labels)
assert not any(name == "balançando" and 248 <= s <= 252 for name, s in labels)
assert seconds[50].yaw is not None and abs(seconds[50].pitch - 12) < 2
def test_lost_face_is_not_agitation_but_real_movement_is():
# Rastreio piscando: rosto some e volta noutro lugar a cada meio segundo (o "pico" de movimento da live real).
flicker = lambda t: not (100 <= t < 110 and int(t * 2) % 2 == 1) # noqa: E731
jump = window(100, 110, lambda t: 0.3 * (int(t * 2) % 4 == 0), 0.0)
moving = window(200, 206, lambda t: 0.12 * math.sin(2 * math.pi * 2.5 * t))
seconds = per_second(posed(300, present=flicker, cx=lambda t: 0.5 + jump(t) + moving(t)), 300)
agitated = [b for b in body_moments(seconds) if b.label == "agitado"]
assert agitated and all(199 <= b.start_s and b.end_s <= 206 for b in agitated)
def test_leaving_the_frame_and_leaning_in():
gone = lambda t: not (150 <= t < 170) # noqa: E731
seconds = per_second(posed(300, present=gone, size=window(80, 83, lambda t: 0.42, 0.3)), 300)
labels = {(b.label, b.start_s) for b in body_moments(seconds)}
assert ("saiu do quadro", 150) in labels
assert any(name == "chegou perto" and 80 <= s <= 82 for name, s in labels)
def test_head_box_keeps_the_body_when_the_face_is_in_profile():
# Sessão 15 (tfue de perfil): MediaPipe em 10 % dos quadros, YuNet em 100 %. A caixa da cabeça não é "rosto".
in_profile = lambda t: t < 30 # noqa: E731
out = lambda t: not (150 <= t < 160) # noqa: E731
samples = posed(300, present=in_profile, head=out)
seconds = per_second(samples, 300)
assert seconds[100].present == 0.0 and seconds[100].smile is None and seconds[100].head == 1.0
assert seconds[100].hsize == pytest.approx(0.3) and seconds[155].head == 0.0
assert ("saiu do quadro", 150) in {(b.label, b.start_s) for b in body_moments(seconds)}
text = summarize(seconds, 140, 170)
assert text.startswith("rosto sem expressão legível") and "saiu do quadro em 10 s" in text
# --- compatibilidade --------------------------------------------------------------------------------------------
def test_old_series_without_new_fields_still_works():
seconds = calm()
seconds[200].smile = 0.9
data = seconds_to_json(seconds)
for d in data:
for name in EXTRA_SECOND_FIELDS:
d.pop(name, None)
old = seconds_from_json(json.loads(json.dumps(data)))
assert old[0].brow_inner is None and old[0].head is None
assert [m.label for m in reaction_moments(old)] == ["risada"]
assert body_moments(old) == [] # sem `head` não há "saiu do quadro"; sem pose, nem balanço
assert {e["expr"] for e in expression_map(old)} <= {"neutro", "risada"}
def test_service_updated_mid_session_does_not_fake_new_expressions():
# Primeira metade gravada antes (sem os campos novos), segunda com eles: o neutro do canal novo usa só a segunda.
seconds = calm(400)
for s in seconds[:200]:
for name in EXTRA_SECOND_FIELDS:
setattr(s, name, None)
emap = expression_map(seconds)
assert {e["expr"] for e in emap} <= {"neutro"}
assert body_moments(seconds) == []
def test_new_fields_roundtrip_compact():
s = calm(1)[0]
data = s.to_json()
assert set(EXTRA_SECOND_FIELDS) - {"hsize"} <= set(data)
assert data["yaw"] == round(s.yaw, 1) and len(str(data["squint"]).split(".")[-1]) <= 3
back = FaceSecond.from_json(json.loads(json.dumps(data)))
assert back.hsize is None and abs(back.squint - s.squint) < 1e-3
# --- face.py ----------------------------------------------------------------------------------------------------
def test_pose_from_matrix():
a = math.radians(20)
rx = [[1, 0, 0, 0], [0, math.cos(a), -math.sin(a), 0], [0, math.sin(a), math.cos(a), 0], [0, 0, 0, 1]]
yaw, pitch, roll = face_mod.pose_from_matrix(rx)
assert pitch == pytest.approx(20) and abs(yaw) < 1e-6 and abs(roll) < 1e-6
ry = [[math.cos(a), 0, math.sin(a), 0], [0, 1, 0, 0], [-math.sin(a), 0, math.cos(a), 0], [0, 0, 0, 1]]
assert face_mod.pose_from_matrix(ry)[0] == pytest.approx(20)
class FakeDetector:
def __init__(self, result=None, error=None):
self.result, self.error, self.calls = result or [], error, 0
def detect(self, bgr):
self.calls += 1
assert bgr.shape == (40, 80, 3)
if self.error:
raise self.error
return self.result
def tracker_with(detector):
tracker = object.__new__(face_mod.MediaPipeTracker) # sem carregar o MediaPipe: só o caminho da caixa da cabeça
tracker._np, tracker._detector = np, detector
return tracker
def test_tracker_head_box_when_mediapipe_loses_the_face():
rgb = np.zeros((40, 80, 3), np.uint8)
sample = tracker_with(FakeDetector([(10, 4, 20, 20, 0.7), (40, 10, 16, 20, 0.9)]))._head_only(1.5, rgb)
assert sample.present is False and sample.head is True and sample.blend == {}
assert sample.cx == pytest.approx(0.6) and sample.cy == pytest.approx(0.5) and sample.size == pytest.approx(0.5)
assert tracker_with(FakeDetector([]))._head_only(1.5, rgb) == FaceSample(1.5, False)
assert tracker_with(FakeDetector(error=RuntimeError("cv2")))._head_only(1.5, rgb) == FaceSample(1.5, False)
assert tracker_with(None)._head_only(1.5, rgb) == FaceSample(1.5, False)
def test_to_frame_converts_head_size():
second = FaceSecond(0, 0.0, hsize=0.5)
assert face_mod.to_frame([second], CAM)[0].hsize == pytest.approx(0.25)
class PosedTracker:
"""Rosto com pose: sorriso alto em `laughs`; balanço da cabeça em `shakes`."""
name = "fake"
def __init__(self, laughs=(), shakes=()):
self.laughs, self.shakes = set(laughs), set(shakes)
def process(self, t, rgb):
smile = 0.9 if int(t) in self.laughs else 0.05 + 0.05 * ((int(t * 6) % 3) / 2)
yaw = 15 * math.sin(2 * math.pi * 1.2 * t) if int(t) in self.shakes else 0.0
return FaceSample(t, True, 0.5, 0.4, 0.3, {"mouthSmileLeft": smile, "mouthSmileRight": smile},
(yaw, 12.0, 0.0))
def close(self):
pass
def test_face_api_has_the_expression_map_and_body(env): # noqa: F811
client, engine = env
service = make_service(engine, tracker_factory=lambda _b=None: PosedTracker(range(300, 306), range(310, 313)))
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
body = client.get(f"/v1/sessions/{sid}/face?from=290&to=320", headers=auth()).json()
by_t = {s["t"]: s for s in body["seconds"]}
assert by_t[302]["expr"] == "risada" and by_t[295]["expr"] == "neutro"
assert by_t[311]["body"] == "balançando" and "body" not in by_t[295]
assert "yaw" in by_t[295] and by_t[295]["head"] == 1.0
assert [b["label"] for b in body["body"]] == ["balançando"]
line = service.summary(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid), 295, 315)
assert "risada" in line and "balançando a cabeça em 3" in line
+285
View File
@@ -0,0 +1,285 @@
"""Vídeo de revisão × vídeo final (doc/clipador/REVISAO.md, pedido do dono 18/11/2026): "quando o clipe está ali para
a gente aprovar, a legenda é só de dev. Quando a gente aprovar, ele vai renderizar o vídeo de novo, removendo as coisas
de dev". O render da fila é o de revisão (dev=True); aprovar enfileira o final (dev=False); publicar só usa o final."""
import json
import sqlite3
from pathlib import Path
import app.db as db_module
import app.editor_api as editor_api
import app.worker as worker_module
from app import layout
from app.db import Database
from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
def add_ready_clip(engine, sid, cid=1, layers: list[str] | None = None, status="ready"):
engine.db.run(
"INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, title, file, thumb, review_dev_json,"
" created_at, updated_at) VALUES (?, ?, 100, 90, 160, 8, 'chat', ?, 't', ?, ?, ?, 'x', 'x')",
cid, sid, status, f"output/clipper/{sid}/clip-{cid}.mp4", f"output/clipper/{sid}/clip-{cid}.jpg",
None if layers is None else json.dumps(layers))
class RenderSpy:
"""Troca o render de verdade: guarda com que `dev` e para qual arquivo cada render foi pedido."""
def __init__(self, monkeypatch, engine, fail: bool = False):
self.calls: list[dict] = []
self.fail = fail
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) # caminhos relativos do teste
monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}})
monkeypatch.setattr(editor_api, "render_clip_edit", self)
def __call__(self, engine, clip, session, edit, out: Path, thumb: Path, dev: bool = True):
self.calls.append({"clip": clip["id"], "out": out.name, "thumb": thumb.name, "dev": dev})
if self.fail:
from app import media
raise media.MediaError("ffmpeg caiu")
return f"output/clipper/{clip['session_id']}/{out.stem}-cover.jpg"
def view(client, cid=1) -> dict:
return client.get(f"/v1/clips/{cid}", headers=auth()).json()
def approve(client, cid=1, status="approved") -> dict:
r = client.patch(f"/v1/clips/{cid}", json={"status": status}, headers=auth())
assert r.status_code == 200, r.text
return r.json()
# ---------------------------------------------------------------- aprovar → final com dev=False
def test_approve_queues_final_render_without_dev_layers(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
spy = RenderSpy(monkeypatch, engine)
before = view(client)
assert before["review"]["devLayers"] == ["translation"] and before["final"] is None and before["publishFile"] is None
body = approve(client)
assert body["status"] == "approved"
assert body["final"]["status"] == "pending" and body["publishFile"] is None # nada publicável ainda
assert engine.wake_clips.is_set()
engine.render_pending()
assert spy.calls == [{"clip": 1, "out": "clip-1-final.mp4", "thumb": "clip-1-final.jpg", "dev": False}]
after = view(client)
final = after["final"]
assert final["status"] == "ready" and not final["reused"] and final["error"] is None
assert final["file"].endswith("clip-1-final.mp4") and final["thumb"].endswith("clip-1-final.jpg")
assert final["cover"].endswith("clip-1-final-cover.jpg")
assert after["publishFile"] == final["file"] != after["file"] # o de revisão continua sendo `file`
engine.render_pending()
assert len(spy.calls) == 1 # pronto não renderiza de novo
def test_review_render_of_the_queue_stays_dev_true(env, monkeypatch): # noqa: F811
client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None, status="pending")
spy = RenderSpy(monkeypatch, engine)
engine.render_pending()
assert spy.calls == [{"clip": 1, "out": "clip-1.mp4", "thumb": "clip-1.jpg", "dev": True}]
assert view(client)["status"] == "ready" and view(client)["final"] is None
def test_unknown_layers_render_final(env, monkeypatch): # noqa: F811
"""Sem saber o que entrou no vídeo de revisão (`review_dev_json` NULL), o final é renderizado por cautela."""
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None)
spy = RenderSpy(monkeypatch, engine)
assert approve(client)["final"]["status"] == "pending"
engine.render_pending()
assert [c["dev"] for c in spy.calls] == [False]
# ---------------------------------------------------------------- sem camadas dev: reaproveita
def test_without_dev_layers_review_is_already_final(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=[])
engine.db.run("INSERT INTO edits (clip_id, project_json, created_at, updated_at, cover) VALUES (1, '{}', 'x', 'x', ?)",
f"output/clipper/{sid}/clip-1-cover.jpg")
spy = RenderSpy(monkeypatch, engine)
body = approve(client)
assert body["final"]["status"] == "ready" and body["final"]["reused"]
assert body["publishFile"] == body["file"] and body["final"]["cover"].endswith("clip-1-cover.jpg")
engine.render_pending()
assert spy.calls == [] # não renderizou de novo
# ---------------------------------------------------------------- publicação nunca pega o de revisão
def test_publish_file_is_never_the_review_video(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, 1, layers=["translation"])
add_ready_clip(engine, sid, 2, layers=["dub", "translation"])
spy = RenderSpy(monkeypatch, engine, fail=True)
def publishable() -> dict[int, str | None]:
clips = client.get("/v1/clips?status=ready,approved,published", headers=auth()).json()["clips"]
return {c["id"]: c["publishFile"] for c in clips}
assert publishable() == {1: None, 2: None} # pronto para aprovar = só revisão
approve(client, 1)
approve(client, 2, status="published") # marcado publicado direto também pede o final
assert publishable() == {1: None, 2: None} # final na fila
engine.render_pending() # o render final falha
for cid in (1, 2):
v = view(client, cid)
assert v["final"]["status"] == "error" and "ffmpeg caiu" in v["final"]["error"]
assert v["publishFile"] is None and v["status"] in ("approved", "published") # erro não vira revisão publicável
# "Tentar de novo" (POST /final): volta à fila e, desta vez, sai.
spy.fail = False
assert client.post("/v1/clips/1/final", headers=auth()).json()["final"]["status"] == "pending"
engine.render_pending()
v = view(client, 1)
assert v["publishFile"] and v["publishFile"] != v["file"] and v["publishFile"].endswith("-final.mp4")
assert all(f is None or f.endswith("-final.mp4") for f in publishable().values())
# Só corte aprovado tem final.
client.patch("/v1/clips/2", json={"status": "ready"}, headers=auth())
assert client.post("/v1/clips/2/final", headers=auth()).status_code == 409
# ---------------------------------------------------------------- desaprovar / editar
def test_unapprove_edit_and_rerender_drop_the_final(env, monkeypatch): # noqa: F811
client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
spy = RenderSpy(monkeypatch, engine)
approve(client)
engine.render_pending()
assert view(client)["publishFile"]
# Desaprovar (voltar para pronto) ou rejeitar: o final deixa de valer.
body = client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()).json()
assert body["final"] is None and body["publishFile"] is None
approve(client)
assert view(client)["final"]["status"] == "pending" # aprovar de novo = final novo
engine.render_pending()
# Mudar o trecho de um aprovado: volta a ser revisão (renderiza de novo) e o final some.
body = client.patch("/v1/clips/1", json={"startS": 95, "endS": 160}, headers=auth()).json()
assert body["status"] == "pending" and body["final"] is None and body["publishFile"] is None
# Render de revisão novo também derruba qualquer final (ex.: export do editor).
engine.db.run("UPDATE clips SET status = 'approved', final_status = 'ready', final_file = 'x-final.mp4' WHERE id = 1")
engine.render_pending() # o final está pronto; nada pendente
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 1")
engine.render_pending()
v = view(client)
assert v["status"] == "ready" and v["final"] is None and spy.calls[-1]["dev"] is True
# Pedir render de novo (botão) também.
approve(client)
engine.render_pending()
assert client.post("/v1/clips/1/render", headers=auth()).json()["final"] is None
def test_unapprove_during_final_render_discards_it(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
approve(client)
def slow_render(eng, clip, session, edit, out, thumb, dev=True):
client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()) # desaprovou no meio do render
return None
monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}})
monkeypatch.setattr(editor_api, "render_clip_edit", slow_render)
engine.render_pending()
v = view(client)
assert v["final"] is None and v["publishFile"] is None and engine._rendering == set()
# ---------------------------------------------------------------- quais camadas entraram na revisão
def test_review_layers():
lines = [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}]
on = layout.merge({"dev": {"translation": True}})
assert editor_api.review_layers(on, lines) == ["translation"]
assert editor_api.review_layers(on, None) == [] # fonte em português: nada desenhado
assert editor_api.review_layers(layout.merge(), lines) == []
# A dublagem sai das frases traduzidas: sem frase (fonte em português), não houve dublagem.
assert editor_api.review_layers(layout.merge({"dev": {"dub": True}}), None) == []
assert editor_api.review_layers(layout.merge({"dev": {"dub": True}}), lines) == ["dub"]
legacy = layout.merge({"caption": {"translation": True}})
assert editor_api.review_layers(legacy, lines) == ["translation"]
def test_render_clip_edit_passes_dev_and_records_layers(env, monkeypatch): # noqa: F811
"""render_clip_edit: dev=True grava as camadas da revisão; dev=False não pede tradução nem mexe no registro."""
_client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None)
seen: list[dict] = []
project = {"cover": {"enabled": False}, "cuts": [{"start": 90, "end": 150, "mode": None}]}
monkeypatch.setattr(editor_api, "validate_for", lambda eng, clip, session, data: project)
monkeypatch.setattr(editor_api.editor, "effective_settings", lambda base, p: layout.merge({"dev": {"translation": True}}))
monkeypatch.setattr(editor_api, "translation_for",
lambda eng, clip, p, base, dev=True: [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}] if dev else None)
monkeypatch.setattr(editor_api.editor_render, "render_project",
lambda *a, **k: seen.append({"dev": k["dev"], "translation": k["translation"]}))
monkeypatch.setattr(editor_api.media, "thumbnail", lambda *a, **k: None)
monkeypatch.setattr(editor_api.media, "pick_encoder", lambda *a, **k: [])
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
clip = engine.db.get("SELECT * FROM clips WHERE id = 1")
out = engine.settings.clips_dir / "clip-1.mp4"
editor_api.render_clip_edit(engine, clip, session, {"project": project}, out, out.with_suffix(".jpg"))
assert seen[-1]["dev"] is True and seen[-1]["translation"]
assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"]
final = engine.settings.clips_dir / "clip-1-final.mp4"
editor_api.render_clip_edit(engine, clip, session, {"project": project}, final, final.with_suffix(".jpg"), dev=False)
assert seen[-1] == {"dev": False, "translation": None}
assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"]
# ---------------------------------------------------------------- limpeza e migração
def test_prune_keeps_segments_that_the_final_still_needs(env, monkeypatch): # noqa: F811
_client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine) # blocos de 30 s, todos "velhos" (wall_end ≈ 1970)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at,"
" updated_at) VALUES (1, ?, 100, 90, 110, 8, 'chat', 'ready', '[\"translation\"]', 'x', 'x')", sid)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at,"
" updated_at) VALUES (2, ?, 200, 190, 200, 8, 'chat', 'ready', '[]', 'x', 'x')", sid)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, final_status, created_at,"
" updated_at) VALUES (3, ?, 400, 400, 410, 8, 'chat', 'approved', 'error', 'x', 'x')", sid)
engine.prune()
kept = {r["idx"] for r in engine.db.all("SELECT idx FROM segments WHERE session_id = ? AND deleted = 0", sid)}
assert kept == {3, 13} # 90–110 s (revisão com tradução) e 400–410 s (final com erro); o 190–200 s (limpo) saiu
def test_migration_v14_backfills_old_clips(tmp_path):
path = tmp_path / "clipper.db"
conn = sqlite3.connect(path) # banco como estava na v13
for script in db_module.SCHEMA[:13]:
for statement in db_module._split(script):
conn.execute(statement)
conn.execute("PRAGMA user_version = 13")
conn.execute("INSERT INTO sessions (id, platform, kind, url, status, dir, started_at) VALUES (1, 'twitch', 'live', 'u', 'done', '', 'x')")
rows = [(1, "approved", "a.mp4", None), (2, "approved", "b.mp4", '{"lines": []}'), (3, "published", "c.mp4", '{"lines": []}'),
(4, "ready", "d.mp4", None), (5, "published", "e.mp4", None), (6, "candidate", None, None)]
for cid, status, file, translation in rows:
conn.execute("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, file, translation_json,"
" created_at, updated_at) VALUES (?, 1, 1, 0, 10, 1, 'chat', ?, ?, ?, 'x', 'u')", (cid, status, file, translation))
conn.commit()
conn.close()
db = Database(path)
got = {r["id"]: (r["review_dev_json"], r["final_status"], r["final_file"])
for r in db.all("SELECT id, review_dev_json, final_status, final_file FROM clips")}
db.close()
assert got == {
1: ("[]", "ready", "a.mp4"), # sem tradução: o arquivo já era limpo → é o final
2: (None, "pending", None), # com tradução e aprovado: renderiza o final
3: (None, None, None), # publicado (já saiu): só gera final se pedirem (POST /final)
4: ("[]", None, None),
5: ("[]", "ready", "e.mp4"),
6: (None, None, None),
}
+189
View File
@@ -0,0 +1,189 @@
"""Detecção do jogo (doc/clipador/DETECCAO-JOGO.md): fusão das pistas, aplicação na sessão e rota "Detectar agora"."""
import json
from pathlib import Path
from app.game_detect import Evidence, count_mentions, fuse, is_generic
from tests.test_sources_and_api import FakeJudge, auth, env, seed_session # noqa: F401 - fixture reaproveitada
GTA = "grand-theft-auto-vi"
ALIASES = {GTA: {GTA, "gta-6", "gta6", "gta-vi"}, "rob-run": {"rob-run", "robrun"}}
# ---------------------------------------------------------------- regra pura
def test_generic_categories_are_not_games():
assert is_generic("Just Chatting") and is_generic("Só Bate-papo") and is_generic("") and not is_generic("Rust")
def test_mentions_match_whole_names_only():
texts = ["olha o GTA 6 que loucura", "gta6 hype", "gtavi", "o artista fez isso", "robrunner hoje", "ROB RUN!!"]
counts = count_mentions(texts, ALIASES)
assert counts == {GTA: 2, "rob-run": 1} # "gtavi" não é alias aqui; "robrunner" não é "rob run"
def test_platform_alone_is_probable_and_agreement_is_agreed():
alone = fuse([Evidence("platform", "Rust", "rust")])
assert alone.status == "probable" and alone.top.gid == "rust"
agreed = fuse([Evidence("platform", "Rust", "rust"), Evidence("screen", "Rust", "rust", 0.7)])
assert agreed.status == "agreed" and agreed.top.sources == ["platform", "screen"]
def test_category_and_screen_disagreeing_is_a_conflict():
decision = fuse([Evidence("platform", "ROB RUN", "rob-run"), Evidence("screen", "GTA V", "gta-v", 1.0)])
assert decision.status == "conflict" and {c.gid for c in decision.candidates} == {"rob-run", "gta-v"}
def test_screen_alone_counts_and_weak_signals_do_not():
assert fuse([Evidence("screen", "Rust", "rust", 0.7)]).status == "probable" # tela com confiança média
assert fuse([Evidence("screen", "Rust", "rust", 0.4)]).status == "unknown" # palpite
assert fuse([Evidence("speech", "Rust", "rust", 0.33)]).status == "unknown" # citada uma vez só
assert fuse([]).status == "unknown"
def test_chat_and_screen_beat_a_lone_category():
# Categoria diz A; tela, chat e fala dizem B: B passa com folga, não é conflito.
decision = fuse([Evidence("platform", "A", "a"), Evidence("screen", "B", "b", 1.0),
Evidence("chat", "B", "b", 1.0), Evidence("speech", "B", "b", 1.0)])
assert decision.top.gid == "b" and decision.status in ("agreed", "conflict")
# ---------------------------------------------------------------- aplicação na sessão
def add_game(engine, gid=GTA, name="Grand Theft Auto VI", aliases=("gta-6", "gta6", "gta-vi")):
engine.db.run("INSERT INTO games (id, name, status, aliases_json) VALUES (?, ?, 'ready', ?)", gid, name, json.dumps(list(aliases)))
def platform(engine, sid, category, title=""):
state = engine.intel._detect_state(sid)
state["platform"] = {"game": category, "title": title, "at": "2026-11-18T00:00:00+00:00"}
engine.intel._save_detect_state(sid, state)
def session(engine, sid):
return engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
def test_category_sets_the_game_immediately(env): # noqa: F811
_, engine = env
sid = seed_session(engine)
platform(engine, sid, "Rust")
result = engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "Rust" and row["game_source"] == "platform" and row["game_status"] == "probable"
assert result["status"] == "probable"
def test_generic_category_is_not_a_game_and_screen_fills_in(env): # noqa: F811
_, engine = env
sid = seed_session(engine)
platform(engine, sid, "Just Chatting")
engine.intel.detect_game(sid)
assert session(engine, sid)["game"] == "" and session(engine, sid)["game_status"] == "unknown"
engine.intel.note_screen(sid, "Rust", "high", "logo do Rust no menu")
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "Rust" and row["game_source"] == "screen"
def test_chat_and_title_find_a_known_game_without_category(env): # noqa: F811
_, engine = env
add_game(engine)
sid = seed_session(engine)
wall = engine.db.get("SELECT MAX(wall) AS w FROM chat WHERE session_id = ?", sid)["w"]
engine.db.many("INSERT INTO chat (session_id, wall, user, text) VALUES (?, ?, ?, ?)",
[(sid, wall - i, "u", "esse GTA 6 é lindo demais") for i in range(8)])
platform(engine, sid, "", title="Primeira vez no GTA VI!!")
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "Grand Theft Auto VI" and row["game_source"] == "chat"
evidence = json.loads(row["game_detect_json"])["candidates"][0]["sources"]
assert {e["source"] for e in evidence} >= {"chat", "title"} and row["game_status"] == "probable"
def test_screen_with_another_alias_agrees_with_the_category(env): # noqa: F811
_, engine = env
add_game(engine)
sid = seed_session(engine)
platform(engine, sid, "Grand Theft Auto VI")
engine.intel.note_screen(sid, "GTA 6", "high", "HUD com estrelas de procurado")
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game_status"] == "agreed" and row["game"] == "Grand Theft Auto VI"
def test_conflict_keeps_the_game_and_asks(env): # noqa: F811
_, engine = env
sid = seed_session(engine)
platform(engine, sid, "ROB RUN")
engine.intel.detect_game(sid)
engine.intel.note_screen(sid, "GTA V", "high", "mapa de Los Santos")
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "ROB RUN" and row["game_status"] == "conflict"
assert {c["game"] for c in json.loads(row["game_detect_json"])["candidates"]} == {"ROB RUN", "GTA V"}
def test_screen_only_change_needs_two_checks_in_a_row(env): # noqa: F811
_, engine = env
engine.db.run("INSERT INTO games (id, name, status) VALUES ('rust', 'Rust', 'ready')")
sid = seed_session(engine)
engine.intel.set_game(sid, "Rust", "screen")
engine.intel.note_screen(sid, "Hollow Knight", "high", "tela de título")
engine.intel.detect_game(sid)
assert session(engine, sid)["game"] == "Rust" # 1ª vez: espera
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "Hollow Knight" and [h["game"] for h in json.loads(row["games_json"])] == ["Rust", "Hollow Knight"]
def test_confirmed_game_never_changes_but_suggests(env): # noqa: F811
client, engine = env
add_game(engine)
sid = seed_session(engine)
r = client.put(f"/v1/sessions/{sid}/game", json={"name": "Rust"}, headers=auth())
assert r.json()["gameStatus"] == "user" and r.json()["gameDetect"]["suggestion"] is None
platform(engine, sid, "Grand Theft Auto VI")
engine.intel.note_screen(sid, "GTA 6", "high", "HUD")
engine.intel.detect_game(sid)
assert session(engine, sid)["game"] == "Rust"
assert engine.intel._detect_state(sid)["suggestion"] is None # 1ª vez: ainda não sugere
engine.intel.detect_game(sid)
row = session(engine, sid)
assert row["game"] == "Rust" and row["game_source"] == "user" and row["game_status"] == "user"
assert json.loads(row["game_detect_json"])["suggestion"]["game"] == "Grand Theft Auto VI"
view = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
assert view["gameDetect"]["suggestion"]["game"] == "Grand Theft Auto VI"
# ---------------------------------------------------------------- "Detectar agora"
class VisionJudge(FakeJudge):
def __init__(self, answer):
super().__init__()
self.answer, self.asked = answer, []
@property
def enabled(self):
return True
def detect_game(self, images, live_title=""):
self.asked.append((len(images), live_title))
return self.answer
def test_detect_now_uses_frames_and_applies_immediately(env, monkeypatch): # noqa: F811
client, engine = env
engine.judge = VisionJudge({"game": "Hollow Knight", "confidence": "high", "evidence": "tela de título do jogo"})
monkeypatch.setattr(engine.intel, "frames", lambda s, times, tag: [(t, Path(f"{tag}-{int(t)}.jpg")) for t in times])
sid = seed_session(engine)
r = client.post(f"/v1/sessions/{sid}/game/detect", headers=auth())
assert r.status_code == 200, r.text
body = r.json()
assert body["session"]["game"] == "Hollow Knight" and body["session"]["gameSource"] == "screen"
assert body["result"]["screen"]["evidence"] == "tela de título do jogo"
assert engine.judge.asked and engine.judge.asked[0][0] == 3
def test_detect_now_explains_when_ai_is_off(env): # noqa: F811
client, engine = env
engine.judge.provider = "off"
sid = seed_session(engine)
r = client.post(f"/v1/sessions/{sid}/game/detect", headers=auth())
assert r.status_code == 400 and "IA" in r.json()["error"]
+27
View File
@@ -0,0 +1,27 @@
"""Chat da Kick (18/11/2026): a Kick trocou o Pusher de chave fixa pelo Centrifugo com token de convidado.
O formato da mensagem é o mesmo; estes testes fixam a leitura dos dois envelopes e dos emotes."""
import json
from app.chat import kick_message
CHAT_EVENT = r"App\Events\ChatMessageEvent"
MSG = {"id": "x", "chatroom_id": 58665335, "content": "kkkk [emote:37226:KEKW] ganhou [emote:1:GG]",
"type": "message", "sender": {"username": "BielLopez"}}
def test_kick_message_reads_user_text_and_emotes():
user, text, emotes = kick_message(CHAT_EVENT, json.dumps(MSG))
assert user == "BielLopez" and text == "kkkk KEKW ganhou GG" and emotes == ["KEKW", "GG"]
def test_kick_message_ignores_other_events_and_accepts_dict():
assert kick_message(r"App\Events\UserBannedEvent", json.dumps(MSG)) is None
assert kick_message(CHAT_EVENT, MSG)[0] == "BielLopez"
def test_centrifugo_push_envelope_has_the_pusher_event_inside():
# Linha real do Centrifugo (18/11/2026, chat do peusantista), com o conteúdo trocado.
line = json.dumps({"push": {"channel": "chatrooms.58665335.v2", "pub": {"data": {
"event": CHAT_EVENT, "data": json.dumps(MSG)}}}})
data = json.loads(line)["push"]["pub"]["data"]
assert kick_message(data["event"], data["data"])[1].startswith("kkkk KEKW")
+244
View File
@@ -0,0 +1,244 @@
"""Equipe de IA (doc/clipador/EQUIPE-IA.md): papéis com IA própria, migração da configuração antiga, instruções do
administrador, esforço por papel, medição por chamada (F0) e o relatório. Nenhuma CLI de verdade roda aqui."""
import json
import subprocess
from pathlib import Path
import pytest
from app import judge as judge_module
from app import roles as roles_module
from app.ai_settings import AiConfig
from app.config import Settings
from app.db import Database
from app.judge import Judge, claude_usage, codex_usage, gemini_usage
from app.worker import Engine
from .test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
ANALYSIS = {"situation": "jogada", "what_happened": "Ele roubou o banco.", "screen": "", "speech": "", "chat_meaning": "",
"confidence": 0.9, "action_start_s": 100, "reaction_end_s": 160, "hook": "Assalto solo", "lines": []}
VERDICT = {"keep": True, "score": 8, "start_s": 100, "end_s": 170, "title": "Virada", "caption": "c", "hashtags": [],
"reason": "r"}
CONTEXT_OK = {"viewer_summary": "Ele rouba o banco sozinho.", "fix": {"start_s": None, "end_s": None, "context_line": ""},
"checks": {c: {"ok": True, "t": None, "why": ""} for c in roles_module.CHECKS}, "confidence": 0.9,
"reason": "ok"}
SCAN = {"screen_game": "GTA", "has_webcam": False, "summary": "s", "moments": [], "lines": []}
def answer_for(schema: dict) -> dict:
props = schema["properties"]
if "viewer_summary" in props:
return CONTEXT_OK
if "situation" in props:
return ANALYSIS
if "moments" in props:
return SCAN
if list(props) == ["lines"]:
return {"lines": ["oi"]}
return VERDICT
@pytest.fixture
def team(tmp_path, monkeypatch):
"""Juiz de verdade com as CLIs trocadas por um registro: cada chamada guarda provedor, modelo, esforço e sistema."""
calls: list[dict] = []
def fake_call(self, provider, system, prompt, schema, images, search, timeout, model, effort=""):
calls.append({"provider": provider, "model": model, "effort": effort, "system": system, "prompt": prompt})
return answer_for(schema)
monkeypatch.setattr(Judge, "_call", fake_call)
for name in ("codex", "claude", "gemini"):
monkeypatch.setattr(judge_module, f"find_{name}", (lambda n=name: [n]))
return calls
def make_engine(tmp_path, saved: dict[str, str] | None = None) -> Engine:
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")
if saved:
db.many("INSERT INTO settings (key, value) VALUES (?, ?)", list(saved.items()))
return Engine(settings, db)
# ---------------------------------------------------------------- migração
def test_old_single_provider_becomes_every_role_and_analyst_model_is_kept(tmp_path):
engine = make_engine(tmp_path, {"judge_provider": "claude", "judge_model": "sonnet", "judge_analyst_model": "haiku"})
roles = engine.judge.roles
assert {r["provider"] for r in roles.values()} == {"claude"}
assert roles["editor"]["model"] == "sonnet" and roles["scan"]["model"] == "sonnet" and roles["judge"]["model"] == "sonnet"
assert roles["analyst"]["model"] == "haiku" # o "modelo do analista" que já existia é respeitado
assert roles["judge"]["enabled"] and roles["judge"]["critical"] == ["setup", "payoff", "standalone"]
# A migração fica gravada (explícita no banco); a próxima subida lê `judge.roles`.
saved = json.loads(engine.db.get("SELECT value FROM settings WHERE key = 'judge.roles'")["value"])
assert saved["analyst"]["model"] == "haiku"
again = Engine(engine.settings, engine.db)
assert again.judge.roles == roles
def test_off_master_switch_is_kept_and_roles_still_migrate(tmp_path):
engine = make_engine(tmp_path, {"judge_provider": "off", "judge_model": ""})
assert not engine.judge.enabled and engine.judge.provider == "off"
assert {r["provider"] for r in engine.judge.roles.values()} == {"codex"}
def test_normalize_roles_field_by_field():
base = roles_module.default_roles("codex", "gpt-6-luna")
out = roles_module.normalize_roles({
"editor": {"enabled": False, "provider": "claude"}, # editor nunca desliga; trocou de provedor → modelo padrão
"judge": {"effort": "turbo", "critical": ["payoff", "inventado"], "penalty": 9, "extra": " x "},
"scan": {"images": "frames", "model": "bad model;"},
}, base)
assert out["editor"]["enabled"] is True and out["editor"]["provider"] == "claude" and out["editor"]["model"] == ""
assert out["judge"]["effort"] == "medium" and out["judge"]["critical"] == ["payoff"]
assert out["judge"]["penalty"] == 0.5 and out["judge"]["extra"] == "x"
assert out["scan"]["images"] == "frames" and out["scan"]["model"] == "gpt-6-luna"
# ---------------------------------------------------------------- cada papel chama a sua IA
def test_each_role_calls_its_own_provider_model_and_effort(tmp_path, team):
roles = roles_module.default_roles("codex")
roles["scan"] |= {"provider": "codex", "model": "gpt-6-luna", "effort": "low"}
roles["analyst"] |= {"provider": "claude", "model": "haiku"}
roles["editor"] |= {"provider": "codex", "model": ""}
roles["judge"] |= {"provider": "claude", "model": "sonnet", "effort": ""}
judge = Judge("codex", "", tmp_path / "j", ai=AiConfig(tmp_path / "ai"), roles=roles)
judge.scan("p", [], lang="en")
judge.analyze("p", [], lang="en")
judge.judge("p", 100, 170, [], lang="en")
judge.check_context("p", lang="en")
got = [(c["provider"], c["model"], c["effort"]) for c in team]
assert got == [("codex", "gpt-6-luna", "low"), ("claude", "haiku", ""), ("codex", "gpt-6-luna", ""),
("claude", "sonnet", "")]
# O que não é dos quatro papéis (tradução, pesquisa) usa a IA do editor.
judge.translate_lines(["oi"])
assert team[-1]["provider"] == "codex"
assert judge.fallback_chain("claude")[0] == "claude" and judge.fallback_chain()[0] == "codex"
def test_admin_instructions_are_added_after_the_default_text(tmp_path, team):
roles = roles_module.default_roles("codex")
roles["judge"]["extra"] = "Não aprove corte que termina antes do resultado da treta."
roles["analyst"]["extra"] = "Lag conta como jogada."
judge = Judge("codex", "", tmp_path / "j", ai=AiConfig(tmp_path / "ai"), roles=roles)
judge.check_context("p", lang="en")
judge.analyze("p", [], lang="pt")
judge.judge("p", 100, 170, [], lang="pt")
context_system, analyst_system, editor_system = (c["system"] for c in team)
assert context_system.startswith(judge_module.CONTEXT_SYSTEM_EN) # o padrão continua inteiro, no começo
assert context_system.endswith("Admin notes (may be written in Portuguese; when they conflict with the rules above, "
"they win):\nNão aprove corte que termina antes do resultado da treta.")
assert analyst_system.endswith("valem estas):\nLag conta como jogada.")
assert "Instruções do administrador" not in editor_system # o editor não tem extra
def test_codex_effort_goes_to_the_command_line(tmp_path, monkeypatch):
seen: list[list[str]] = []
def run(args, input=None, capture_output=True, timeout=None, cwd=None, creationflags=0, env=None):
seen.append(list(args))
Path(args[args.index("-o") + 1]).write_text(json.dumps(CONTEXT_OK), encoding="utf-8")
events = '{"type":"thread.started"}\n{"type":"turn.completed","usage":{"input_tokens":1234,"cached_input_tokens":200,"output_tokens":56}}\n'
return subprocess.CompletedProcess(args, 0, events.encode(), b"")
monkeypatch.setattr(judge_module.subprocess, "run", run)
monkeypatch.setattr(judge_module, "find_codex", lambda: ["codex"])
monkeypatch.setattr(judge_module, "find_claude", lambda: None)
records = []
judge = Judge("codex", "", tmp_path / "j", ai=AiConfig(tmp_path / "ai"))
judge.meter = records.append
with judge.scope(clip_id=7, session_id=3, mode="timeline+mosaic"):
judge.check_context("prompt de teste", lang="pt")
assert 'model_reasoning_effort="medium"' in seen[0] and "--json" in seen[0] # juiz: esforço médio por padrão
rec = records[0]
assert rec["role"] == "judge" and rec["provider"] == "codex" and rec["ok"] is True
assert (rec["tokensIn"], rec["tokensOut"], rec["tokensCached"]) == (1234, 56, 200)
assert rec["clip_id"] == 7 and rec["mode"] == "timeline+mosaic" and rec["promptChars"] == len("prompt de teste")
def test_usage_parsers():
assert codex_usage("lixo\n{\"type\":\"turn.completed\",\"usage\":{\"input_tokens\":10,\"output_tokens\":2}}") == \
{"in": 10, "out": 2, "cached": None}
assert codex_usage("") is None
assert claude_usage({"usage": {"input_tokens": 5, "cache_creation_input_tokens": 100, "cache_read_input_tokens": 2000,
"output_tokens": 40}}) == {"in": 2105, "out": 40, "cached": 2000}
assert gemini_usage({"stats": {"models": {"gemini-3.5-flash": {"tokens": {"prompt": 900, "candidates": 50,
"thoughts": 10, "cached": 0}}}}}) == \
{"in": 900, "out": 60, "cached": 0}
assert gemini_usage({"response": "x"}) is None
# ---------------------------------------------------------------- API e medição
def test_put_roles_and_read_defaults(env): # noqa: F811
client, engine = env
roles = {"scan": {"enabled": False, "provider": "codex", "images": "frames"},
"analyst": {"provider": "claude", "model": "haiku", "extra": "Olhe o HUD."},
"editor": {"enabled": False, "provider": "codex"},
"judge": {"enabled": True, "provider": "claude", "model": "sonnet", "critical": ["setup", "payoff"],
"allowContextLine": False}}
r = client.put("/v1/judge", json={"provider": "codex", "model": "", "minScore": 6, "roles": roles}, headers=auth())
assert r.status_code == 200
data = r.json()
assert data["roles"]["analyst"]["provider"] == "claude" and data["roles"]["analyst"]["extra"] == "Olhe o HUD."
assert data["roles"]["editor"]["enabled"] is True # o editor não desliga
assert data["roles"]["judge"]["critical"] == ["setup", "payoff"] and data["roles"]["judge"]["allowContextLine"] is False
# O cartão da varredura liga/desliga a varredura de verdade.
assert data["roles"]["scan"]["enabled"] is False and engine.intel.opts["scanEnabled"] is False
got = client.get("/v1/judge", headers=auth()).json()
assert set(got["roleDefaults"]) == {"scan", "analyst", "editor", "judge"}
assert got["roleDefaults"]["judge"]["en"].startswith("You are the CONTEXT JUDGE")
assert [c["id"] for c in got["checks"]][:3] == ["setup", "payoff", "who_what"]
assert "roleDefaults" not in client.get("/v1/status", headers=auth()).json()["judge"] # status fica leve
# A opção da linha do tempo (comparar com o formato antigo) também se troca pela mesma rota.
client.put("/v1/judge", json={"provider": "codex", "model": "", "minScore": 6, "timelineJson": False}, headers=auth())
assert engine.intel.opts["timelineJson"] is False
def test_owner_label_and_report(env): # noqa: F811
client, engine = env
sid = seed_session(engine)
db = engine.db
def clip(cid, status, decision, keep=True, label=None):
judge = {"keep": keep, "score": 7}
if decision:
judge["context"] = {"decision": decision, "contextLine": "x" if decision == "approve" else ""}
db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, judge_json, created_at,"
" updated_at, owner_label) VALUES (?, ?, 1, 0, 60, 5, 'chat', ?, ?, ?, ?, ?)",
cid, sid, status, json.dumps(judge), engine_now(), engine_now(), label)
clip(1, "approved", "approve") # juiz mantém, dono bom → concorda
clip(2, "rejected", "approve") # juiz mantém, dono ruim → discorda
clip(3, "discarded", "discard", label="no_context") # juiz descarta, dono "sem contexto" → concorda
clip(4, "ready", "adjust") # dono não avaliou
clip(5, "approved", "discard") # juiz descartou, dono forçou e aprovou → falso negativo
# Rejeitar com "sem contexto" pela rota (o rótulo vale também para corte antigo/descartado).
r = client.patch("/v1/clips/4", json={"label": "no_context", "labelNote": "não dá pra entender"}, headers=auth())
assert r.json()["ownerLabel"] == "no_context" and r.json()["ownerNote"] == "não dá pra entender"
assert r.json()["status"] == "ready" # avaliar não muda o estado
engine.record_ai_call({"role": "judge", "purpose": "judge", "provider": "codex", "model": "gpt-6-luna", "ok": True,
"ms": 1200, "systemChars": 2700, "promptChars": 3000, "images": 0, "imageBytes": 0,
"tokensIn": 1500, "tokensOut": 200, "session_id": sid, "mode": "timeline+mosaic"})
engine.record_ai_call({"role": "analyst", "purpose": "analyst", "provider": "codex", "model": "gpt-6-luna",
"ok": False, "error": "cota", "systemChars": 3000, "promptChars": 5000, "images": 1,
"imageBytes": 60_000, "session_id": sid})
rep = client.get(f"/v1/judge/report?session={sid}", headers=auth()).json()
assert rep["window"]["liveHours"] == round(600 / 3600, 2)
judge_row = next(c for c in rep["calls"] if c["role"] == "judge")
assert judge_row["tokensIn"] == 1500 and judge_row["withUsage"] == 1 and judge_row["mode"] == "timeline+mosaic"
assert next(c for c in rep["calls"] if c["role"] == "analyst")["failures"] == 1
assert rep["perHour"]["judge"]["calls"] == pytest.approx(6.0)
assert rep["judge"]["approve"] == 2 and rep["judge"]["discard"] == 2 and rep["judge"]["adjust"] == 1
assert rep["clips"]["approvalRate"] == round(2 / 3, 3) and rep["clips"]["noContext"] == 2
agreement = rep["agreement"]["judge"]
# pares: (keep, good) (keep, bad) (discard, no_context) (keep, no_context) (discard, good) → concordam 2 de 5
assert agreement["pairs"] == 5 and agreement["agree"] == 2
assert agreement["matrix"]["discard"]["good"] == 1 and agreement["matrix"]["keep"]["no_context"] == 1
def engine_now() -> str:
from app.db import now
return now()
+3
View File
@@ -165,6 +165,9 @@ def test_judge_config_persists(env, tmp_path):
assert client.put("/v1/judge", json={"provider": "gpt", "model": ""}, headers=auth()).status_code == 422 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 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")} saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
# Equipe de IA (EQUIPE-IA.md): o painel antigo (um provedor só) troca a IA de todos os papéis.
roles = json.loads(saved.pop("judge.roles"))
assert {r["provider"] for r in roles.values()} == {"claude"}
assert saved == {"judge_provider": "claude", "judge_model": "haiku", "judge_min_score": "7.0", "judge_analyst_model": ""} assert saved == {"judge_provider": "claude", "judge_model": "haiku", "judge_min_score": "7.0", "judge_analyst_model": ""}
+390
View File
@@ -0,0 +1,390 @@
"""Quem fala cada palavra (doc/clipador/FALANTES.md): atribuição por voz + boca/volume, legenda em duas linhas sem
misturar falantes, tradução com `speaker`, juiz com a fala marcada e compatibilidade com `words_json` antigo."""
import json
import re
import numpy as np
import pytest
from app import editor, editor_render, layout, subtitles
from app import speakers as spk
from app.face import FaceService
from app.judge import _transcript
from app.scoring import Word
from app.speakers import STREAMER, SpeakerService, VoiceChunk
from .test_editor import validate
from .test_english_source import EnglishJudge, _english_session
from .test_face import CAM, fake_reader, set_cam
from .test_face import FakeTracker
from .test_render_and_duplicates import add_clip
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
A, B, C = np.eye(256, dtype=np.float32)[0], np.eye(256, dtype=np.float32)[1], np.eye(256, dtype=np.float32)[2]
def _noisy(vec, k):
"""Vetor de voz com um pouco de ruído (a mesma voz nunca dá o mesmo vetor duas vezes)."""
rng = np.random.default_rng(k)
v = vec + rng.normal(0, 0.02, 256).astype(np.float32)
return v / np.linalg.norm(v)
def _conversation(n=12, length=2.0, db_streamer=-28.0, db_other=-36.0):
"""Trechos alternados: streamer (voz A) e colega (voz B), `n` de cada."""
out = []
for i in range(n):
out.append(VoiceChunk(i * 6.0, i * 6.0 + length, db_streamer, _noisy(A, i)))
out.append(VoiceChunk(i * 6.0 + 3.0, i * 6.0 + 3.0 + length, db_other, _noisy(B, 100 + i)))
return out
# ---------------------------------------------------------------- dados / compatibilidade
def test_words_json_old_and_new_format():
old = json.dumps([[1.0, 1.4, "olha"], [1.5, 1.9, "isso"]])
words = spk.parse_words(old)
assert words == [Word(1.0, 1.4, "olha"), Word(1.5, 1.9, "isso")] and words[0].speaker == ""
new = spk.parse_words(json.dumps([[1.0, 1.4, "olha", "streamer"], [2.0, 2.3, "bro", "other1"], [3, 3.1, "x", ""]]))
assert [w.speaker for w in new] == ["streamer", "other1", ""]
# Sem falante, o formato gravado continua o antigo (3 elementos); com falante, 4.
assert json.loads(spk.dump_words(words)) == [[1.0, 1.4, "olha"], [1.5, 1.9, "isso"]]
assert json.loads(spk.dump_words(new))[1] == [2.0, 2.3, "bro", "other1"]
assert spk.parse_words(None) == [] and spk.parse_words("[[1, 2]]") == []
def test_speech_chunks_split_on_pause_and_length():
words = [Word(0.0, 0.4, "a"), Word(0.5, 0.9, "b"), Word(1.5, 1.8, "c"), Word(1.85, 2.0, "d")]
assert spk.speech_chunks(words) == [(0.0, 0.9), (1.5, 2.0)]
long = [Word(i * 0.3, i * 0.3 + 0.28, "w") for i in range(20)] # 6 s de fala corrida
chunks = spk.speech_chunks(long)
assert len(chunks) == 2 and all(b - a <= spk.CHUNK_MAX_S for a, b in chunks)
# Fim de frase fecha o trecho (a vez costuma trocar ali, mesmo sem pausa); frase curtinha não.
turn = [Word(0.0, 0.3, "bring"), Word(0.32, 0.6, "two."), Word(0.62, 0.8, "Ok."), Word(0.82, 1.0, "yes")]
assert spk.speech_chunks(turn) == [(0.0, 0.6), (0.62, 1.0)]
# ---------------------------------------------------------------- atribuição (vetores sintéticos)
def test_two_voices_streamer_by_loudness():
model = spk.build_model(_conversation())
assert model.active and len(model.voices) == 2 and model.reason.startswith("volume")
labels = [c.label for c in model.chunks]
assert labels == ["streamer", "other1"] * 12
def test_mouth_series_picks_the_streamer_even_when_quieter():
# Colega mais ALTO que o streamer (volume enganaria), mas a boca do streamer mexe nos trechos dele.
chunks = _conversation(db_streamer=-36.0, db_other=-29.0)
mine = {round(c.start, 1) for c in chunks if c.vec[0] > 0.5}
def mouth_of(a, b):
rng = np.random.default_rng(int(a * 10))
return float(0.30 + rng.normal(0, 0.02)) if round(a, 1) in mine else float(0.12 + rng.normal(0, 0.02))
model = spk.build_model(chunks, mouth_of)
# Boca e volume discordam → ninguém vira "outro" (seguro: fica tudo como do streamer).
assert not model.active and "apontam vozes diferentes" in model.reason
assert {c.label for c in model.chunks} == {STREAMER}
# Sem volume (sem prova do áudio), a boca decide sozinha.
for c in chunks:
c.db = None
model = spk.build_model(chunks, mouth_of)
assert model.active and model.reason.startswith("boca")
assert [c.label for c in model.chunks] == ["streamer", "other1"] * 12
def test_no_proof_or_single_voice_keeps_everything_as_streamer():
flat = _conversation(db_streamer=-30.0, db_other=-31.0) # 1 dB de diferença e sem câmera
model = spk.build_model(flat)
assert not model.active and {c.label for c in model.chunks} == {STREAMER}
solo = [VoiceChunk(i * 3.0, i * 3.0 + 2.0, -30.0, _noisy(A, i)) for i in range(20)]
model = spk.build_model(solo)
assert len(model.voices) == 1 and not model.active
words = [Word(0.2, 0.5, "oi")]
assert spk.label_words(words, model.chunks) == words # nada muda
def test_three_voices_are_numbered_and_short_chunks_follow_the_neighbor():
chunks = _conversation()
chunks += [VoiceChunk(200 + i * 4.0, 202 + i * 4.0, -37.0, _noisy(C, 300 + i)) for i in range(10)]
chunks.append(VoiceChunk(5.2, 5.5, -36.0, None)) # curto (sem vetor), logo depois do colega (3–5 s)
model = spk.build_model(chunks)
assert [v.label for v in model.voices] == ["streamer", "other1", "other2"]
words = [Word(0.1, 0.5, "yo"), Word(3.2, 3.6, "bro"), Word(5.25, 5.45, "ok"), Word(201.0, 201.4, "hey"),
Word(150.0, 150.3, "longe")]
got = [w.speaker for w in spk.label_words(words, model.chunks)]
assert got == ["streamer", "other1", "other1", "other2", "streamer"]
# Palavra que já veio com falante (4º elemento) não é trocada.
assert spk.label_words([Word(3.2, 3.6, "bro", "streamer")], model.chunks)[0].speaker == "streamer"
def test_transfer_keeps_speaker_on_retranscription():
old = [Word(1.0, 1.5, "a", "streamer"), Word(3.0, 3.5, "b", "other1")]
new = spk.transfer([Word(1.1, 1.4, "A"), Word(3.1, 3.3, "B")], old)
assert [w.speaker for w in new] == ["streamer", "other1"]
# ---------------------------------------------------------------- serviço (banco + embedder falso)
class FakeEmbedder:
"""Voz pelo volume do trecho: alto = voz A (streamer), baixo = voz B (colega)."""
def embed(self, samples):
if len(samples) < 8000:
return None
loud = float(np.sqrt(np.mean(samples.astype(np.float64) ** 2)))
return _noisy(A if loud > 4000 else B, int(loud)).tolist()
def _block_audio(start_s):
"""30 s: streamer (amplitude 8000) em [i·6, i·6+2] e colega (2000) em [i·6+3, i·6+5]; palavras nos mesmos tempos."""
sr = 16000
pcm = np.zeros(30 * sr, np.int16)
words = []
rng = np.random.default_rng(int(start_s))
for i in range(5):
for off, amp, text in ((0.0, 8000, "me"), (3.0, 2000, "you")):
a = i * 6.0 + off
pcm[int(a * sr): int((a + 2.0) * sr)] = (rng.standard_normal(int(2.0 * sr)) * amp).astype(np.int16)
words += [Word(start_s + a + k * 0.4, start_s + a + k * 0.4 + 0.35, text) for k in range(5)]
return pcm.tobytes(), words
def test_service_indexes_blocks_and_labels_the_timeline(env): # noqa: F811
_client, engine = env
engine.speakers = SpeakerService(engine, embedder_factory=FakeEmbedder)
sid = seed_session(engine, duration=120)
assert engine.speakers.view(sid)["active"] is False # nada indexado ainda
for seg in engine.db.all("SELECT * FROM segments WHERE session_id = ? ORDER BY idx", sid):
pcm, words = _block_audio(seg["start_s"])
assert engine.speakers.index_block(seg, pcm, words) == 10
engine.db.run("UPDATE segments SET words_json = ? WHERE session_id = ? AND idx = ?",
spk.dump_words(words), sid, seg["idx"])
view = engine.speakers.view(sid)
assert view["active"] and view["streamer"] == "streamer" and len(view["voices"]) == 2
words = engine.load_timeline(sid)["words"]
assert {w.speaker for w in words if w.word == "me"} == {"streamer"}
assert {w.speaker for w in words if w.word == "you"} == {"other1"}
# O mesmo vale para as palavras que o editor lê.
between = engine.words_between(sid, 0, 30)
assert {w.speaker for w in between if w.word == "you"} == {"other1"}
# Desligado (opção `speakers`), tudo volta a ser como antes.
engine.intel.opts["speakers"] = False
assert {w.speaker for w in engine.load_timeline(sid)["words"]} == {""}
def test_face_block_stores_mouth_series(env): # noqa: F811
_client, engine = env
class Meter:
def feed(self, rgb):
return 0.2
service = FaceService(engine, store=object(), tracker_factory=lambda _b=None: FakeTracker(), detector_factory=None,
reader=fake_reader, grabber=None, sizer=lambda _f: (1280, 720), mouth_factory=Meter)
engine.face = service
sid = seed_session(engine, duration=60)
set_cam(engine, sid, CAM)
assert service.step() is True
data = json.loads(engine.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND idx = 0", sid)["data_json"])
assert len(data["mouth"]) == 180 and data["mouth"][0] == 0.2
# Sem medidor (store falso, sem YuNet): o bloco sai igual ao de antes, sem `mouth`.
service._mouth_factory = lambda: (_ for _ in ()).throw(RuntimeError("sem yunet"))
assert service.step() is True
data = json.loads(engine.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND idx = 1", sid)["data_json"])
assert "mouth" not in data and data["frames"] == 180
# ---------------------------------------------------------------- legenda
def _dialogue(ass: str) -> list[tuple[float, float, str, str]]:
out = []
for line in ass.splitlines():
if line.startswith("Dialogue: 0,"):
parts = line.split(",", 9)
h, m, s = parts[1].split(":")
a = int(h) * 3600 + int(m) * 60 + float(s)
h, m, s = parts[2].split(":")
b = int(h) * 3600 + int(m) * 60 + float(s)
out.append((a, b, parts[3], parts[9]))
return out
def _ypos(text: str) -> int:
return int(re.search(r"\\pos\(\d+,(\d+)\)", text).group(1))
TALK = [Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "isso"), Word(1.62, 1.9, "mano"),
Word(1.7, 2.0, "for", "other1"), Word(2.05, 2.4, "real", "other1"), Word(2.5, 2.9, "bro", "other1"),
Word(3.0, 3.3, "caiu"), Word(3.35, 3.7, "aqui")]
def test_caption_blocks_never_mix_speakers_and_overlap_only_across_lanes():
blocks = subtitles.caption_blocks(TALK, 3)
for group, _end in blocks:
assert len({w.speaker or STREAMER for w in group}) == 1
lanes = {"streamer": [], "other": []}
for group, end in blocks:
lanes[subtitles.lane(group[0].speaker)].append((group[0].start, end))
for spans in lanes.values(): # dentro da faixa, nunca dois blocos ao mesmo tempo
assert all(a1 <= a2 and e1 <= a2 + 1e-9 for (a1, e1), (a2, _) in zip(spans, spans[1:]))
# As duas faixas se sobrepõem (os dois falando juntos em 1,7–1,9 s).
(s_a, s_e), (o_a, o_e) = lanes["streamer"][0], lanes["other"][0]
assert o_a < s_e
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_build_ass_puts_the_other_speaker_below_in_another_color(aspect):
cfg = layout.merge({"format": {"aspect": aspect}, "caption": {"otherColor": "#00FF00"}})
ass = subtitles.build_ass(TALK, 0.0, 6.0, "", cfg)
assert "Style: CaptionOther," in ass and "&H0000FF00&" in ass
events = _dialogue(ass)
mine = [e for e in events if e[2] == "Caption"]
other = [e for e in events if e[2] == "CaptionOther"]
assert mine and other
y, oy = _ypos(mine[0][3]), _ypos(other[0][3])
assert y == layout.caption_y(cfg) and oy > y # embaixo
assert all("FOR" in e[3] or "REAL" in e[3] or "BRO" in e[3] for e in other)
assert not any("OLHA" in e[3] for e in other) and not any("BRO" in e[3] for e in mine)
# Os dois na tela ao mesmo tempo (1,7–1,9 s), em alturas diferentes.
assert any(a < 1.85 < b for a, b, _, _ in mine) and any(a < 1.85 < b for a, b, _, _ in other)
# Só o streamer: o ASS é exatamente o de antes (sem o estilo novo).
solo = [Word(w.start, w.end, w.word) for w in TALK if not w.speaker]
assert "CaptionOther" not in subtitles.build_ass(solo, 0.0, 6.0, "", cfg)
def _project(tmp_path, words, **over):
p = {
"schema": 1, "source": {"sessionId": 1, "lo": 0, "hi": 60}, "settings": {},
"cuts": [{"start": 0, "end": 20, "mode": None}],
"captions": {"enabled": True, "preset": "pop", "style": {}, "emphColor": "#22E36B",
"words": [editor.word_item(w) for w in words]},
"overlays": [], "progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": False, "t": 1, "text": ""},
}
p.update(over)
return validate(p, tmp_path)
@pytest.mark.parametrize("preset", editor.CAPTION_PRESETS)
def test_project_ass_two_lines_for_every_preset(tmp_path, preset):
p = _project(tmp_path, TALK)
assert p["captions"]["words"][3]["sp"] == "other1" and "sp" not in p["captions"]["words"][0]
p["captions"]["preset"] = preset
cfg = editor.effective_settings(layout.merge(), p)
events = _dialogue(editor_render.build_project_ass(p, cfg, ""))
mine = [e for e in events if e[2] in ("Caption", "Karaoke")]
other = [e for e in events if e[2] in ("CaptionOther", "KaraokeOther")]
assert mine and other
assert min(_ypos(e[3]) for e in other) > max(_ypos(e[3]) for e in mine)
for group in (mine, other): # na mesma linha, nunca dois eventos ao mesmo tempo
spans = sorted((a, b) for a, b, _, _ in group)
assert all(b1 <= a2 + 0.011 for (_, b1), (a2, _) in zip(spans, spans[1:]))
def test_hook_dodge_moves_both_lines_and_translation_follows_speaker(tmp_path):
hook = {"id": "hook", "kind": "hook", "text": "NAO ACREDITO", "start": 0, "end": 3, "y": 0.74, "size": 70,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
p = _project(tmp_path, TALK, overlays=[hook])
cfg = editor.effective_settings(layout.merge({"dev": {"translation": True}}), p)
lines = [{"s": 1.0, "e": 1.9, "text": "olha isso mano", "pt": "olha isso", "speaker": "streamer"},
{"s": 1.7, "e": 2.9, "text": "for real bro", "pt": "sério mano", "speaker": "other1"}]
events = _dialogue(editor_render.build_project_ass(p, cfg, "", translation=lines))
cap_y = layout.caption_y(cfg)
mine = [e for e in events if e[2] == "Caption"]
other = [e for e in events if e[2] == "CaptionOther"]
trans = {e[3].split("}")[-1]: _ypos(e[3]) for e in events if e[2] == "Trans"}
# Gancho em cima da legenda nos 3 primeiros segundos: as duas linhas desviam juntas, a do colega embaixo.
y, oy = _ypos(mine[0][3]), _ypos(other[0][3])
assert y != cap_y and oy > y
hook_top = int(1920 * 0.74) - int(70 * 0.9)
hook_bottom = int(1920 * 0.74) + int(70 * 0.9)
assert y - 84 >= hook_bottom or oy + 60 <= hook_top
# Tradução de cada um embaixo da linha de quem fala, entre as duas a do streamer.
assert y < trans["olha isso"] < oy < trans["sério mano"]
def test_old_project_without_speaker_renders_like_before(tmp_path):
words = [Word(w.start, w.end, w.word) for w in TALK]
p = _project(tmp_path, words)
ass = editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), "")
assert "CaptionOther" not in ass
assert {_ypos(e[3]) for e in _dialogue(ass)} == {layout.caption_y(layout.merge())}
def test_layout_validates_other_color_and_size():
assert layout.DEFAULTS["caption"]["otherColor"] == "#5CE1FF" and layout.DEFAULTS["caption"]["otherSize"] is None
ok = layout.validate({"caption": {"otherColor": "#ff00aa", "otherSize": 60}})["caption"]
assert ok == {"otherColor": "#FF00AA", "otherSize": 60}
assert layout.validate({"caption": {"otherSize": None}})["caption"]["otherSize"] is None
with pytest.raises(layout.LayoutError):
layout.validate({"caption": {"otherColor": "azul"}})
with pytest.raises(layout.LayoutError):
layout.validate({"caption": {"otherSize": 10}})
cap = layout.merge()["caption"]
assert subtitles.other_size(cap) == round(84 * 0.85)
assert subtitles.other_size({**cap, "otherSize": 50}) == 50
def test_project_rejects_bad_speaker(tmp_path):
p = _project(tmp_path, TALK)
p["captions"]["words"][0]["sp"] = "ninguém; drop"
with pytest.raises(editor.EditError):
validate(p, tmp_path)
# ---------------------------------------------------------------- tradução e juízes
def test_phrases_never_mix_speakers():
got = subtitles.phrases(TALK, with_speaker=True)
assert got == [(1.0, 1.9, "olha isso mano", "streamer"), (1.7, 2.9, "for real bro", "other1"),
(3.0, 3.7, "caiu aqui", "streamer")]
assert subtitles.phrases(TALK)[0] == (1.0, 1.9, "olha isso mano") # formato antigo continua
def test_translation_lines_get_speaker(env): # noqa: F811
client, engine = env
engine.judge = EnglishJudge()
sid = _english_session(engine)
words = [[281.0, 281.3, "No", "streamer"], [281.3, 281.6, "way", "streamer"], [281.6, 282.0, "bro.", "streamer"],
[282.1, 282.5, "Told", "other1"], [282.5, 283.0, "you.", "other1"]]
engine.db.run("UPDATE segments SET words_json = ? WHERE session_id = ? AND idx = 9", json.dumps(words), sid)
add_clip(engine, sid, 1, "candidate", 285, 270, 340)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1"))
lines = json.loads(engine.db.get("SELECT translation_json FROM clips WHERE id = 1")["translation_json"])["lines"]
assert [(x["text"], x["speaker"]) for x in lines] == [("No way bro.", "streamer"), ("Told you.", "other1")]
# O juiz viu quem fala.
prompt = engine.judge.seen["judge"][1]
# Linha do tempo JSON (EQUIPE-IA.md): cada entrada é de um falante só; a de outra pessoa vem marcada.
assert '"sp":"No way bro."' in prompt and '"sp":"[other1] Told you."' in prompt and "Never attribute to" in prompt
# Tradução antiga (sem `speaker`) é refeita na próxima vez.
engine.db.run("UPDATE clips SET translation_json = ? WHERE id = 1",
json.dumps({"startS": 0, "endS": 1e6, "lines": [{"s": 1, "e": 2, "text": "x", "pt": "y"}]}))
before = len(engine.judge.translated)
engine.translate_clip(1)
assert len(engine.judge.translated) == before + 1
def test_judge_transcript_tags_only_when_someone_else_speaks():
plain = [Word(10.0, 10.3, "olha"), Word(10.4, 10.8, "isso")]
assert _transcript(plain, 0, 60, "pt", "Tfue") == "[10s] olha isso"
mixed = plain + [Word(11.0, 11.3, "bro", "other1"), Word(11.4, 11.8, "nice", "other1"), Word(12.0, 12.2, "ok")]
out = _transcript(mixed, 0, 60, "en", "Tfue").splitlines()
assert out[0].startswith("Each line is tagged") and "[Tfue]" in out[0]
assert out[1:] == ["[10s] [Tfue] olha isso", "[11s] [other1] bro nice", "[12s] [Tfue] ok"]
def test_voice_model_failure_waits_before_retrying(env): # noqa: F811
_client, engine = env
calls = []
def broken():
calls.append(1)
raise RuntimeError("sem rede")
engine.speakers = SpeakerService(engine, embedder_factory=broken)
sid = seed_session(engine, duration=60)
seg = engine.db.get("SELECT * FROM segments WHERE session_id = ? AND idx = 0", sid)
pcm, words = _block_audio(0.0)
for _ in range(3):
with pytest.raises(RuntimeError):
engine.speakers.index_block(seg, pcm, words)
assert len(calls) == 1 # não baixa o modelo a cada bloco
assert engine.load_timeline(sid)["words"][0].speaker == "" # sem voz indexada: como antes
+65
View File
@@ -0,0 +1,65 @@
# Clipador — detecção automática do jogo (18/11/2026)
## Pedido do dono
Se ninguém lembrar de dizer o jogo, o Clipador descobre sozinho, **a cada ~3 min**, cruzando tudo o que a live dá
(API da plataforma, título, o que a IA lê na tela, chat e fala), tenta acertar, **pede confirmação** e deixa
**trocar** se estiver errado.
## Pistas (`app/game_detect.py`, a regra; `app/intel.py`, juntar e aplicar)
| Fonte | O que é | Peso máx. |
|---|---|---|
| `platform` | Categoria da live (Streamlink `--json`), lida a cada 3 min. Categoria genérica ("Just Chatting", "IRL", "Música"…) não conta como jogo. | 0,55 |
| `screen` | O jogo que a IA vê nos frames (logo, HUD, texto na tela). A varredura de 3 min já devolve `screen_game` + `screen_game_confidence` (high/medium/low) + `screen_evidence` (o que ela leu/viu). Vale por 15 min. | 0,50 × confiança |
| `title` | O título da live cita um jogo cadastrado (nome ou outro nome). | 0,25 |
| `chat` | Mensagens dos últimos 6 min citam um jogo cadastrado (mínimo 2 mensagens; força 1 com 6). | 0,35 |
| `speech` | Trechos de fala dos últimos 6 min (12 blocos) citam um jogo cadastrado (força 1 com 3). | 0,35 |
Nomes iguais viram o mesmo jogo pelos **outros nomes** (`aliases`): categoria "Grand Theft Auto VI" + tela "GTA 6" +
chat "gta6" = um jogo só. A busca em texto só acha jogos **cadastrados** (a lista de Jogos) e só por palavra inteira
(nome com 4+ letras, ou 3 com número, ex. `cs2`). Acentos não atrapalham.
## Decisão
Cada jogo ganha uma nota (ruído-ou das fontes, cada fonte conta uma vez). O estado (`sessions.game_status`):
| Estado | Quando | O que o Clipador faz |
|---|---|---|
| `user` | Você confirmou. | **Nunca troca sozinho.** Se as pistas apontarem outro jogo (várias fontes concordando) em 2 checagens seguidas, grava uma `suggestion` e o painel pergunta "o streamer trocou de jogo?". |
| `agreed` | 2+ fontes independentes no mesmo jogo, nota ≥ 0,6. | Aplica. |
| `probable` | Uma fonte boa sozinha (só a categoria; ou só a tela com confiança média). | Aplica e pede "Sim, é X". |
| `conflict` | Categoria × tela (fontes fortes) em jogos diferentes e sem folga (< 0,25). | **Mantém o jogo atual** e pergunta qual é o certo. |
| `unknown` | Sem pista útil (ex.: Just Chatting e nada na tela). | Não mexe. |
Trocar de um jogo já definido (sem confirmação do usuário) exige a categoria da plataforma apoiando **ou** a mesma
resposta em 2 checagens seguidas (evita trocar por um frame de menu). "Detectar agora" pula essa espera.
## Estado guardado
- `sessions.game_status` e `sessions.game_detect_json` (v16): pistas (`platform`, `screen`), `candidates` (até 4, com nota
e cada pista), `suggestion`, `pending` (checagens seguidas) e `checkedAt`.
- `sessions.game` / `game_source` (`platform` | `screen` | `chat` | `user`) / `games_json` (histórico de trocas) continuam
como antes; o perfil do jogo é pesquisado se o jogo é novo.
## Contrato (serviço ↔ painel)
- `GET /v1/sessions[/{id}]` ganha `gameStatus` e `gameDetect` = `{checkedAt, candidates[{gid, game, score, sources[{source, game, strength, detail}]}], suggestion|null, platform{game, at}, screen{game, confidence, evidence, at}|null}`.
- `PUT /v1/sessions/{id}/game {name}`: confirma (estado `user`, limpa a sugestão).
- `POST /v1/sessions/{id}/game/detect` ("Detectar agora"): a IA olha 3 frames dos últimos 2 min, cruza com o resto e aplica
na hora. Responde `{result: {status, candidates, suggestion, screen{game, confidence, evidence}}, session}`. Exige IA e visão
ligadas (erro 400 em português se não).
## Painel (detalhe da sessão)
Selo do estado (confirmado por você · detectado, fontes concordam · provável, confirme · em dúvida · não identificado),
"Sim, é X", "Escolher/Trocar jogo" (a lista inclui os candidatos), **Detectar agora**, aviso de conflito com um botão por
candidato, aviso de sugestão de troca (jogo confirmado) e "Como o jogo foi descoberto" (categoria, tela com o que a IA
leu, e cada candidato com nota e pistas). Na lista de sessões o selo "confirmar" aparece nos mesmos casos.
## Limites conhecidos
- Sem a varredura (IA/visão desligadas) não há pista de tela; o botão "Detectar agora" também precisa da IA.
- Sem leitor de texto (OCR) próprio: o texto na tela é lido pela IA de visão (`screen_evidence`).
- Chat e fala só reconhecem jogos já cadastrados em **Jogos** (os que passaram pela categoria entram sozinhos).
- Categoria genérica não vira jogo: a sessão fica sem jogo até a tela, o chat ou você dizerem qual é.
+52
View File
@@ -0,0 +1,52 @@
# Clipador — dublagem em português (só no vídeo de revisão)
Pedido do dono (18/11/2026), para fontes em inglês: "quando ele estiver falando, a gente dubla em português. Baixa o
áudio dele, deixa um pouco baixo para escutar o som do carro, do ambiente do jogo [...] Depois, quando aprovar, fica o
original." Não é dublagem de filme: serve para a equipe entender o contexto. **Sem sincronia labial.**
## Como liga
Configuração do corte → aba Legenda → **"Dublagem em português (teste)"** (grupo `dev`, padrão desligado):
| Chave | Padrão | O quê |
| --- | --- | --- |
| `dev.dub` | `false` | liga a dublagem no vídeo de revisão |
| `dev.dubVoice` | `pt-br-antonio` | voz do streamer (Edge, masculina, online) |
| `dev.dubVoiceOther` | `kokoro-pm-alex` | voz das falas com `speaker: "other"` (Kokoro, offline) |
| `dev.dubDuck` | `0.25` | volume do áudio original enquanto a dublagem toca (0–1) |
Com `dev=False` (vídeo final, depois de aprovar) nada disto entra (`layout.dev_flags`). Só **vozes TTS prontas**: nunca
clonar a voz do streamer (terceiro sem consentimento); o painel nem lista vozes clonadas.
## Como funciona (`clipper/app/dub.py`)
1. Frases de `clips.translation_json` (`{s, e, text, pt, speaker?}`, tempo da sessão) → tempo de saída
(`editor.to_output`; frase dentro de trecho removido some). Frase partida no meio ("…deve dar" + "tudo certo.") do
mesmo falante vira uma fala só.
2. Uma fala por frase no serviço de voz: `POST /v1/synthesize` (`format: "wav"`, `speed: 1.05`). Cache em
`data/clipper/dub/` por (voz, velocidade, texto), já sem silêncio nas pontas, −16 LUFS e 48 kHz mono; apagado
o que fica 30 dias sem uso. Voz que falha → `pt-br-faber` (Piper, offline).
3. Encaixe (`fit`): começa no início da frase original, **em velocidade natural**, e pode escorrer até 1,5 s depois do
começo da próxima frase (que espera). O atraso é contado de cada frase original: não acumula. Só se nem assim couber
acelera até 1,2× e, se ainda não couber, corta com fade. Nunca duas falas juntas (80 ms entre elas).
4. Uma faixa WAV do trecho; no `editor_render.render_project` o original abaixa para `dubDuck` com rampa de 0,15 s só
onde há dublagem (vãos < 0,6 s ficam baixos, sem "bombear"). Fora das falas o áudio fica igual.
5. Nível: a dublagem fica 6 dB acima do volume médio do próprio corte (`volumedetect`, ~0,1 s), entre −20 e +3 dB.
A prévia do editor (`preview-render`) e o render da fila passam pelo mesmo caminho (`dub.for_engine(engine)`); a prévia
só sintetiza as frases que tocam nela. Serviço de voz fora do ar → o vídeo sai sem dublagem (aviso no log).
## Custo medido (18/11/2026, corte 259 do tfue, 54,5 s, 25 frases, NVENC)
| Render | Tempo |
| --- | --- |
| sem dublagem | 5,8 s |
| com dublagem, 1ª vez (síntese) | +29 a +41 s (~1,6 s por frase; 3 em paralelo; 6 não ajudam) |
| com dublagem, cache pronto | +0,3 s |
| prévia de 5 s, cache pronto | 1,2 s |
Conversa densa: o português sai bem mais longo que o inglês (frase de 4 s vira 6–7 s); no corte 259 9 das 25 falas
terminam cortadas com fade (4 s perdidos ao todo; aceleração média 1,08×). Áudio: fora das falas, idêntico ao original (−47,7 dB nos dois);
nas falas, a dublagem fica no nível do streamer (−29 dB contra −26/−34 dB do original).
Testes: `clipper/tests/test_dub.py` (TTS falso).

Some files were not shown because too many files have changed in this diff Show More