CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,29 @@
|
||||
# Clipador do CenaForge. O setup.bat copia este arquivo para clipper/.env e preenche a chave.
|
||||
# Gere uma chave à mão com: python -c "import secrets; print(secrets.token_urlsafe(48))"
|
||||
CLIPPER_SERVICE_KEY=
|
||||
# Porta (faixa 4500–4599 do CenaForge). Escuta só em 127.0.0.1.
|
||||
CLIPPER_PORT=4520
|
||||
# A qualidade de gravação agora é por canal/sessão (painel, "Configuração do corte" → Gravação; padrão: a melhor
|
||||
# disponível). CLIPPER_QUALITY não é mais lida.
|
||||
# Tamanho de cada bloco gravado (segundos). Menor = cortes saem mais cedo; maior = menos arquivos.
|
||||
CLIPPER_SEGMENT_S=30
|
||||
# De quanto em quanto tempo checar se um canal monitorado entrou ao vivo (segundos).
|
||||
CLIPPER_POLL_S=60
|
||||
# Blocos gravados mais velhos que isto (horas) são apagados se nenhum corte precisar deles. 0 = nunca apagar.
|
||||
CLIPPER_KEEP_HOURS=6
|
||||
# Idioma da transcrição (serviço de voz).
|
||||
CLIPPER_LANGUAGE=pt-BR
|
||||
# Encoder dos cortes: auto (NVENC se houver, senão libx264) | libx264 | h264_nvenc
|
||||
CLIPPER_ENCODER=auto
|
||||
# Juiz dos candidatos: IA que confirma o momento e escreve título/legenda, pelas CLIs já logadas no PC
|
||||
# (as mesmas da página Agente). codex (padrão, GPT) | claude | off (só a heurística do chat/áudio).
|
||||
# São só os valores iniciais: o provedor, o modelo e a nota mínima se trocam na página Clipador do painel.
|
||||
CLIPPER_JUDGE_PROVIDER=codex
|
||||
# Vazio = padrão do provedor (codex: gpt-6-luna, rápido e barato; claude: haiku).
|
||||
CLIPPER_JUDGE_MODEL=
|
||||
# Nota mínima (0–10) do juiz para o corte ser renderizado.
|
||||
CLIPPER_JUDGE_MIN_SCORE=6
|
||||
# Pastas opcionais para isolar uma instância de teste (vazio = padrão). Precisam ficar dentro do repositório,
|
||||
# porque blocos e cortes vão para o banco com caminho relativo ao repo. Ex.: output/face-live-test/data
|
||||
# CLIPPER_DATA_DIR=data/clipper (banco, blocos gravados, modelos do rastreio, arquivos do juiz)
|
||||
# CLIPPER_OUTPUT_DIR=output/clipper (cortes prontos, prévias e projetos do editor)
|
||||
@@ -0,0 +1,552 @@
|
||||
# Clipador — cortes automáticos de live
|
||||
|
||||
Serviço local do CenaForge (`127.0.0.1:4520`, faixa 4500–4599) que assiste lives da **Twitch, YouTube e Kick**,
|
||||
lê o **chat em tempo real**, transcreve a fala com o **Whisper** (serviço de voz, 4510), pede a uma **IA pela CLI**
|
||||
(Codex/GPT por padrão, ou Claude) que confirme o momento e gera **cortes com legenda queimada**: verticais 1080×1920
|
||||
(Shorts/Reels/TikTok, padrão) ou horizontais 1920×1080 (YouTube "tela grande", mostrando o próprio jogo).
|
||||
O painel (`/clipper`) mostra a fila para aprovar. As contas que recebem os cortes de cada canal são ligadas na
|
||||
página **Contas**, como as histórias.
|
||||
|
||||
> **Publicação nas redes (YouTube, TikTok, Instagram) é a próxima etapa.** Hoje "Aprovar" só marca o corte.
|
||||
|
||||
## Como funciona
|
||||
|
||||
```
|
||||
Streamlink ─► bomba (Python) ─► FFmpeg -f segment: blocos .ts de 30 s + segments.csv data/clipper/sessions/<id>/
|
||||
Chat (IRC anônimo da Twitch · websocket da Kick) ─► tabela chat (hora real de cada mensagem)
|
||||
Cada bloco novo ─► volume por segundo (RMS) + Whisper com tempo por palavra (POST /v1/transcribe, X-Detail: words)
|
||||
A cada 15 s ─► pontuação do chat/áudio (app/scoring.py) ─┐
|
||||
A cada 3 min ─► VARREDURA da IA: frames + fala + chat ──┴► candidato ─► ANALISTA (vê frames) ─► EDITOR ─► render
|
||||
Contexto (app/intel.py): jogo pela categoria + tela + perfil pesquisado na web · webcam achada pela IA · emotes
|
||||
output/clipper/<sessão>/clip-<id>.mp4 (layout.py)
|
||||
```
|
||||
|
||||
1. **Chat aponta.** Cada mensagem pesa 1; risada (`KKKK`, `KEKW`, `ICANT`, `PepeLaugh`…), susto (`caralho`,
|
||||
`HUH`, `monkaW`…), hype (`POG`, `W`, `GG`…) somam peso, e pedido de clipe (`clip`, `clipa`) soma 3.
|
||||
A empolgação de cada segundo é comparada com o **normal recente da própria live** (mediana dos últimos 3 min):
|
||||
canal grande tem muita mensagem o tempo todo, o que conta é o pico relativo. O mínimo de mensagens nos 8 s do
|
||||
pico é **proporcional ao chat** (3× a mediana recente, entre 4 e 12) e exige ≥ 2 mensagens de reação (texto ou
|
||||
emote) — chat de 0,15 msg/s (skipnho) nunca chegava às 12 fixas. Ignora o 1º minuto da gravação.
|
||||
**Emotes** (Twitch nativos pela tag do IRC, 7TV/BTTV/FFZ do canal e globais, emojis, Kick) contam como reação e
|
||||
têm **peso aprendido por canal** (tabela `emotes`): sobe nos cortes que você aprova, desce nos rejeitados (a
|
||||
decisão da IA também conta, com metade do peso).
|
||||
2. **O corte começa antes da reação.** O chat reage depois do acontecimento: do pico, o código volta até onde a
|
||||
reação começou e pega mais 14 s antes; termina 6 s depois do pico. Ajusta início/fim a pausas da fala (não corta
|
||||
no meio da frase) e limita à duração da configuração do corte (`duration`, padrão **60–90 s**; o candidato já
|
||||
nasce nessa duração, crescendo para trás a partir do fim da reação).
|
||||
3. **Chat fraco ou sem chat**: o volume (gritos/risadas) e palavras de reação também propõem momentos.
|
||||
4. **Varredura da IA** (live pequena, reação que não vira mensagem): a cada `scanIntervalS` (180 s) de gravação a IA
|
||||
assiste a janela — 7 frames, fala, chat, perfil do jogo, resumos das janelas anteriores — e propõe 0–2 momentos.
|
||||
Medido: ~7 s por janela com `gpt-6-luna` (~20 chamadas/h). Proposta com nota < 4 nem vai aos juízes.
|
||||
5. **Dois juízes** para cada candidato (chat, áudio ou varredura):
|
||||
- **Analista** (vê 6 frames do trecho + fala + chat + glossário de gírias): `situation` (lag_ou_bug, jogada,
|
||||
falha_engracada, morte, susto, treta, conversa_engracada, historia, informacao_do_jogo, reacao, outro),
|
||||
o que aconteceu, o que a tela/fala/chat mostram, confiança 0–1, início da AÇÃO e fim da reação.
|
||||
- **Editor** (só texto + a análise): manter/descartar, nota, início/fim, título e legenda fiéis à situação.
|
||||
Pode voltar até `duration.backtrackS` (padrão **120 s**) antes do candidato: o comentário vem depois da ação.
|
||||
O analista recebe 6 quadros (8 quando o trecho passa de 80 s, o normal com cortes de 60–90 s) de 20 s antes do
|
||||
candidato até 15 s depois; a transcrição vai da volta inteira (até 2 min antes) até 15 s depois.
|
||||
Medido no corte do lag (skipnho): título antigo "Jogando três jogos ao mesmo tempo…" → "O lag jogou ele em três
|
||||
lugares ao mesmo tempo" (situation `lag_ou_bug`, confiança 0,93; chat "server chinês?" entendido como lag), início
|
||||
recuado 35 s até "o jogo voltou a lagar". ~18 s pelos dois juízes.
|
||||
Abaixo da nota mínima (padrão 6) o corte fica como **descartado pela IA** — visível, e dá para forçar o render.
|
||||
6. **Ao vivo**, um pico só é fechado quando passaram 18 s depois dele (pico ainda crescendo não vira corte cedo) e a
|
||||
fala do trecho já foi transcrita.
|
||||
|
||||
Tempo: `t` = soma das durações dos blocos. A mensagem do chat é convertida pela hora em que cada bloco terminou de
|
||||
chegar (`wall_end`), então a pausa do Streamlink ao filtrar anúncio da Twitch não desalinha chat e vídeo.
|
||||
|
||||
**Cartão da sessão no painel:** o relógio da gravação corre segundo a segundo a partir do último `durationS`, com
|
||||
teto de 45 s além dele (passou disso, mostra "aguardando o bloco"); "Agora na live" mostra a contagem para o próximo
|
||||
resumo da varredura, com o intervalo vindo de `GET /v1/status` → `judge.options.scanIntervalS`.
|
||||
|
||||
## Contexto do jogo
|
||||
|
||||
- Categoria da plataforma (Streamlink `--json`, `metadata.category`) no início e a cada 10 min (troca registrada em
|
||||
`games_json`). Sem categoria (YouTube/VOD), o jogo vem da tela (`screen_game` da varredura). A IA também diz o que
|
||||
vê na tela; divergência (categoria "ROB RUN", tela "GTA V") vai para o contexto dos juízes.
|
||||
- **Perfil do jogo** pesquisado na web pela CLI (`codex --search`), guardado por jogo (tabela `games`): resumo,
|
||||
mecânicas, o que rende corte, o que não rende, gírias, novidades, fontes. Medido: ~15–35 s por jogo.
|
||||
- Correção manual: `PUT /v1/sessions/{id}/game` (trava a troca automática).
|
||||
|
||||
## Configuração do corte (layout, câmera, legenda)
|
||||
|
||||
Por canal (padrão do streamer), por sessão e por corte (`settings` do projeto de edição) — cada camada sobrescreve
|
||||
campo a campo (padrão ← canal ← sessão ← projeto) — `app/layout.py`:
|
||||
- `format.aspect`: `vertical` (padrão, 1080×1920, Shorts/Reels/TikTok) ou `horizontal` (1920×1080, YouTube "tela
|
||||
grande"). No **horizontal** o vídeo mostra o quadro original inteiro (16:9 preenche; outra proporção ganha faixas
|
||||
pretas em vez de ser cortada) ou, se `layout.game` estiver marcado, essa região recortada para preencher 1920×1080
|
||||
sem distorcer; `cam_only` continua valendo (câmera em tela cheia); `auto`, `blur`, `cam_top` e `game_only` viram
|
||||
"quadro inteiro" (`resolved_mode` = `full`). Textos: o ASS do horizontal usa um quadro lógico de **2560×1440**
|
||||
(o libass reduz para 1920×1080), então os mesmos tamanhos em px do JSON saem a **75 %**: legenda 84 → 63 px,
|
||||
gancho 68 → 51 px, crédito 44 → 33 px, chat 34 → 25,5 px. Posições 0–1 continuam relativas ao quadro. Legenda
|
||||
automática (`caption.y: null`) a 85 % da altura (terço de baixo); crédito no canto direito (em cima ou embaixo).
|
||||
- `layout.mode`: `auto` (câmera em cima se houver câmera marcada), `blur`, `cam_top` (webcam no terço de cima, jogo
|
||||
embaixo recortado no centro), `game_only`, `cam_only` (a câmera do streamer ocupa a tela inteira; sem câmera
|
||||
marcada cai em `blur`); `cam`/`game` = retângulos 0–1 do quadro original; `camHeight`.
|
||||
- `caption`: fonte, tamanho, cor, cor da palavra falada, contorno, posição (`y`; automático = emenda câmera/jogo),
|
||||
maiúsculas, palavras por bloco. `credit`: liga/desliga, topo/rodapé (no `cam_top` desce para o pé da câmera).
|
||||
- `duration`: `minS` (5–120, padrão 60), `maxS` (15–180, padrão 90), `minS` < `maxS`, e `backtrackS` (0–120, padrão
|
||||
120 = a IA pode voltar até 2 min para pegar o contexto). Para Shorts de terceiros, um canal pode baixar para ≤ 60 s.
|
||||
**Todo corte automático sai com duração final ≥ `minS` + 1 s** (pedido do dono: "se o mínimo é 60 tem que ser 60;
|
||||
sempre 1 s a mais"; no código, +0,1 s de folga de quadro: `layout.min_target`) e ≤ `maxS`, medida no arquivo. Vale
|
||||
para a heurística (candidato), a varredura, os juízes, o projeto da IA (depois de silêncios e aparos) e o "IA
|
||||
sugere"; faltando material, o corte cresce para trás (contexto) e, no começo da gravação, para a frente
|
||||
(`scoring.fit_window`). Gravação menor que o mínimo: não inventa vídeo, o projeto registra "curto: só havia X s".
|
||||
"Cortar agora" e a edição à mão continuam livres.
|
||||
- `hook`: estilo do gancho que o projeto da IA põe no começo: `style` (`plain` | `banner`), `bg` (cor da tarja),
|
||||
`color` (texto), `font`, `anim` (`pop` | `fade` | `none` | `slide`) e `seconds` (1–8). Padrão: **tarja** verde-limão
|
||||
`#00FF00`, texto branco com contorno preto em Luckiest Guy, `slide`, 3 s. A tarja cobre o começo do corte: o
|
||||
segundo a mais do mínimo é essa abertura (vem da própria gravação, de preferência antes da ação; não há tela parada
|
||||
nem atraso do conteúdo). Se a legenda automática estiver perto de 20 % da altura, a tarja vai para o outro lado.
|
||||
- **Fontes**: `caption.font`, `hook.font` e `font` dos textos aceitam as do Windows (Arial Black, Arial, Impact,
|
||||
Verdana, Segoe UI Black, Trebuchet MS) e as **empacotadas** em `assets/fonts/` (Luckiest Guy — Apache-2.0; Bangers,
|
||||
Anton, Bebas Neue, Poppins ExtraBold — OFL-1.1), baixadas do google/fonts num commit fixo, com sha256 em
|
||||
`assets/fonts/fonts.lock.json` e a licença ao lado de cada arquivo. O serviço confere o sha256 ao carregar e, quando
|
||||
o ASS usa uma delas, passa a pasta ao libass (`ass=…:fontsdir='…'`). Acentos do português conferidos.
|
||||
- **Webcam achada sem IA** nos 2 primeiros blocos da sessão: YuNet procura o rosto em 12 quadros espalhados e
|
||||
`reaction.locate_cam` acha a câmera (ver "Rastreio de reação"); salva como padrão do canal (ou da sessão). A IA (3
|
||||
frames, ~5 s) só entra se o local não achar rosto e a visão estiver ligada, ou com `POST …/detect-cam?ai=true`.
|
||||
`cam_json.source` diz quem achou: `yunet` | `ai` | `manual`.
|
||||
- Prévia: `POST /v1/sessions/{id}/preview` gera a imagem no formato efetivo (1080×1920 ou 1920×1080) sem salvar;
|
||||
`GET …/frame` dá o quadro para desenhar.
|
||||
|
||||
## Qualidade de gravação (`capture`)
|
||||
|
||||
Pedido do dono (17/11/2026): "pegar a live na melhor resolução; a live tem 2K, e isso é configurável". Antes a
|
||||
captura pedia `720p60,720p,480p,best` (`CLIPPER_QUALITY`) e nunca passava de 720p. Agora é o grupo `capture` da
|
||||
configuração do corte (padrão ← canal ← sessão; `app/capture.py`):
|
||||
|
||||
- `capture.quality`: `best` (**padrão**: a maior resolução que a live oferece) ou um **teto** — `1440p`, `1080p`,
|
||||
`720p`, `480p` (a maior variante que não passa dele). Vale na próxima gravação ou retomada: a captura em andamento
|
||||
não troca de qualidade. `CLIPPER_QUALITY` não é mais lida.
|
||||
- **Escolha** pelos sinônimos do próprio Streamlink: `best` (ignora `audio_only` e as variantes verticais
|
||||
`*_portrait`); teto = `--stream-sorting-excludes >{teto}60` + `best,worst-unfiltered` (sem nada abaixo do teto, pega
|
||||
a menor variante que existe: nunca falha por causa da qualidade). Twitch com `best`/`1440p`:
|
||||
`--twitch-supported-codecs h264,h265` (o 2K da transmissão aprimorada vem em HEVC; com h265 pedido as variantes
|
||||
paisagem continuaram H.264). AV1 não é pedido (FFmpeg sem libdav1d).
|
||||
- **Sem opção de 30/60 qps**: a variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives) e o
|
||||
corte sai em 30 qps de qualquer jeito; pedir 30 qps custaria resolução.
|
||||
- **O que foi gravado**: o `ffprobe` do 1º bloco de cada execução (início ou retomada) vai para `sessions.capture_json`
|
||||
(migração v9) e sai em `GET /v1/sessions/{id}` como `capture`: `quality` (pedida), `width`, `height`, `fps`,
|
||||
`codec`, `kbps`, `gbPerHour`, `fromIdx`, `runs` (últimas 10 execuções) e `mixed` (blocos em mais de uma
|
||||
resolução). Sessões de antes ficam `null` (eram ≤ 720p). As rotas de settings devolvem `captureQualities`
|
||||
(rótulo, teto, GB/h e dica de cada opção).
|
||||
|
||||
Nomes de stream medidos com `streamlink --json` (17/11/2026; 143 lives da Twitch, 5 da Kick, 22 do YouTube):
|
||||
|
||||
| Plataforma | Nomes | `best` |
|
||||
|---|---|---|
|
||||
| Twitch | `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`, `360p30`, `160p30`, `audio_only`; em 9 canais `1920p60_portrait`, `1280p60_portrait`, `852p30_portrait`… (a de 1080×1920 em HEVC) | `1080p60` (ou `936p60`/`1080p`) |
|
||||
| Kick | `1080p60`, `720p60`, `480p`, `360p`, `160p` | `1080p60` |
|
||||
| YouTube | `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p` (o HLS do Streamlink para em 1080p, até em live "4K") | `1080p` |
|
||||
|
||||
Nenhuma live 2K no ar nas 3 plataformas no dia: o 1440p foi medido com blocos 1440p60 gerados a partir do 1080p60 real.
|
||||
|
||||
**Custo medido** (17/11/2026, trecho real do skipnho gravado ao mesmo tempo em 720p60 e 1080p60, no formato do serviço;
|
||||
2K = 1080p60 ampliado para 2560×1440 a ~10 Mbps, em H.264 e em HEVC; CPU de 32 threads + RTX 2060 SUPER):
|
||||
|
||||
| Etapa | 720p60 | 1080p60 | 1440p60 H.264 | 1440p60 HEVC |
|
||||
|---|---|---|---|---|
|
||||
| Bloco de 30 s | 12,8 MB | 29,9 MB | 40,9 MB | 39,3 MB |
|
||||
| Disco por hora | 1,5 GB | 3,6 GB | 4,9 GB | 4,7 GB |
|
||||
| Render de 60 s, vertical / horizontal (NVENC) | 6,3 / 6,2 s | 6,5 / 6,4 s | 6,5 / 6,4 s | 6,7 / 6,7 s |
|
||||
| Render de 60 s, vertical / horizontal (libx264) | 4,6 / 3,3 s | — | — | 6,2 / 5,4 s |
|
||||
| Proxy 480p de 90 s | 2,5 s | 3,1 s | 3,8 s | 5,2 s |
|
||||
| 8 frames do analista (a varredura usa 7) | 0,9 s | 1,4 s | 1,9 s | 2,3 s |
|
||||
| Achar a câmera (YuNet, 12 quadros) | 1,5 s | 2,3 s | 3,0 s | 3,5 s |
|
||||
| Rastreio do rosto, bloco de 30 s (só o FFmpeg) | 1,7 s (0,4 s) | 1,7 s (0,7 s) | 1,9 s (1,0 s) | 2,1 s (1,5 s) |
|
||||
| Áudio do bloco (volume + Whisper) | 0,06 s | 0,07 s | 0,07 s | 0,08 s |
|
||||
|
||||
Disco por hora pelas playlistas mestras da Twitch (`BANDWIDTH`, mediana de 62–69 lives): 1080p60 7,1 Mbps
|
||||
(4,6–9,1) ≈ **3,2 GB/h** (até 4,1); 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h. 2K estimado em
|
||||
~4,5 GB/h. Com `CLIPPER_KEEP_HOURS` = 6, uma live longa em 1080p60 guarda até ~19–25 GB de blocos (antes ~9 GB);
|
||||
o padrão continua 6. Nenhuma etapa ficou inviável: tudo que não precisa de 2K já reduz a escala (frames do juiz
|
||||
768 px, YuNet 1280 px, rastreio ~384 px, proxy 480p); o custo extra é decodificar a fonte maior.
|
||||
|
||||
**Nitidez**: a câmera recortada no vertical (`cam_top`) gravada em 1080p60 sai mais nítida que em 720p60, no mesmo
|
||||
trecho: variância do Laplaciano 130 → 149, energia de alta frequência 3,24 → 3,91 (+21 %). O 2K ampliado não ganha
|
||||
nada (mesma informação do 1080p), como esperado. Retângulos `cam`/`game` são 0–1 e valem em qualquer resolução;
|
||||
nenhum filtro do render assume 720p (os `scale=` são para o tamanho de saída; NVENC/x264 por qualidade, sem teto
|
||||
de bitrate).
|
||||
|
||||
## Editor de cortes (`/clipper/edit/<id>`)
|
||||
|
||||
**Um caminho só de render:** todo corte é renderizado a partir de um **projeto de edição** (JSON versionado,
|
||||
tabela `edits`; migrações v4 e v7), seja ele feito pela IA ou por você.
|
||||
|
||||
**A IA entrega o corte quase pronto.** Depois dos juízes, o render gera o projeto (`editor.auto_project`) com o que
|
||||
o pipeline já sabe:
|
||||
|
||||
- **trecho:** do início da ação (`action_start_s` − 0,8 s) ao fim da reação (+0,8 s), sem cortar no meio de
|
||||
palavra e limitado a `duration.maxS`;
|
||||
- **silêncios:** vãos ≥ 2 s sem fala, quietos (< −38 dBFS) e longe do pico (±3 s) saem do corte;
|
||||
- **legenda:** palavras do Whisper no estilo da configuração do corte, preset `pop` (tempo saneado no render: ver
|
||||
"Tempo da legenda");
|
||||
- **gancho:** o `hook` do analista nos primeiros 2,8 s, só se for curto (≤ 8 palavras e ≤ 48 caracteres) e sem tempo
|
||||
da gravação (frase como "Aos 5085s, ele…" é recusada; `editor.pick_hook`); senão, o título do editor. Um
|
||||
"aos/em NNN s" que sobrar é tirado, e texto acima de 60 caracteres é cortado em palavra inteira (nunca no meio);
|
||||
- **zoom:** punch-in de 1,25× no `peak_s`, no rosto quando a câmera está em cima;
|
||||
- **capa:** quadro do pico com o gancho;
|
||||
- **layout e formato:** os da sessão/canal (o projeto pode trocar o formato só deste corte em `settings.format`).
|
||||
|
||||
O projeto fica marcado `meta.origin = "ai"` (com data, modelo e passos). O que a IA gerou fica guardado em
|
||||
`ai_project_json` ("Projeto da IA" no editor volta a ele, e dá para desfazer). Se você salvar no editor, a origem
|
||||
vira `user`. Nova avaliação dos juízes refaz só o projeto de origem `ai`; o seu nunca é apagado.
|
||||
|
||||
O painel abre o editor em **tela cheia**:
|
||||
|
||||
- barra superior com fila, título, origem, estado do salvamento, **Salvar projeto** (Ctrl+S; também salva sozinho),
|
||||
botões para **minimizar** cada painel (camadas, transcrição/chat, propriedades), "IA sugere", atalhos e Exportar;
|
||||
- **Camadas** à esquerda (textos, legenda, zoom, câmera, vídeo, áudio, narração, música, chat na tela, barra, capa),
|
||||
transcrição/chat ao lado, **Fonte · Programa** no centro (gravação original e o 9:16) e **Propriedades** à direita;
|
||||
- timeline na largura toda, com uma trilha por camada: C1 legenda, V3 textos, V2 zoom, **CAM câmera** (layout de
|
||||
cada trecho), V1 vídeo (miniaturas), A1 áudio (forma de onda, "MUDO"), A2 narração, A3 música, CH chat.
|
||||
|
||||
Tudo cabe em 100vh, e cada painel rola sozinho. O desenho segue o padrão dos editores de vídeo (tokens `nle-*` em
|
||||
`panel/src/app/globals.css`); fluxos secundários (exportar, IA, narração, atalhos) abrem em modal.
|
||||
|
||||
**Mexer com a mão:**
|
||||
|
||||
| Onde | Gesto | Efeito |
|
||||
|---|---|---|
|
||||
| Timeline, palavra da legenda | arrastar o corpo | move a palavra (ou o grupo selecionado) no tempo, sem passar pelas vizinhas |
|
||||
| Timeline, palavra da legenda | puxar a borda esquerda ou direita | apara: encurta ou estica só aquele lado (o áudio não muda) |
|
||||
| Timeline, clipe de vídeo/áudio | puxar as bordas · arrastar o corpo | estica/encolhe o trecho · desliza o trecho sobre a gravação |
|
||||
| Timeline, clipe | lâmina (C) ou **Ctrl+Shift+clique** · S ou **Ctrl+K** | divide onde clicar · divide no playhead |
|
||||
| Timeline, texto/zoom/narração | arrastar corpo e bordas | move e muda a duração |
|
||||
| Programa (vídeo 9:16) | arrastar texto, gancho, legenda ou chat | muda a posição na tela (`x`/`y`); com um zoom selecionado, o clique põe o foco |
|
||||
| Fonte | alternador Câmera / Área do jogo; arrastar o retângulo move, as alças redimensionam, arrastar em área vazia desenha outro, setas e Shift+setas pelo teclado | grava `settings.layout.cam`/`game` só deste corte ("Usar esta câmera nos próximos cortes da sessão" grava na sessão) |
|
||||
| Transcrição | selecionar palavras → Tirar, Manter, **Editar** (troca o texto e reparte o tempo), **Ocultar** (só da legenda), Ênfase | corte pelo texto e correção da legenda |
|
||||
|
||||
O arraste de mover só começa depois de 4 px: um clique simples nunca tira o bloco do lugar.
|
||||
|
||||
### Tempo e modelo do projeto
|
||||
|
||||
- **Tempo da sessão:** `cuts`, palavras, textos, zoom, narração e capa. Remover um pedaço do meio não desloca o
|
||||
que está ancorado no conteúdo.
|
||||
- **Tempo de saída:** só o gancho.
|
||||
|
||||
| Campo | O que é |
|
||||
|---|---|
|
||||
| `source` | Janela carregada da gravação (`lo`/`hi`, até 10 min). |
|
||||
| `settings` | Configuração do corte só deste corte (mesma validação de `layout.validate`), por cima de canal/sessão: layout, câmera, legenda, crédito e **`format.aspect`** (o corte pode sair horizontal num canal vertical e vice-versa). Projeto salvo antes do formato (sem `format`) segue o canal/sessão; sem nada, vertical. |
|
||||
| `cuts` | Trechos mantidos, cada um com `mode` próprio (troca de layout por trecho, inclusive `cam_only`) e `muted` (trecho sem o áudio da live). Trechos encostados só se juntam com o mesmo `mode` e o mesmo `muted`. |
|
||||
| `captions` | Preset `classic`, `pop`, `karaoke`, `single` ou `minimal`; `style` (mesma validação de `layout.validate`); `emphColor`; palavras editáveis (`emph`, `hidden`). |
|
||||
| `overlays` | `hook`, `text` (posição `x` e `y`, 0–1; `x` ausente = centro) e `zoom` (escala, foco e rampa). `hook`/`text` têm ainda, opcionais: `style` (`plain` padrão, ou `banner` = tarja na largura toda, centrada em `y`, texto em maiúsculas em até 2 linhas — a fonte diminui em vez de cortar palavra), `bg` (cor da tarja), `color`, `font` (uma de `fonts`) e `anim` `slide` (tarja atravessa a tela em 0,24 s; texto entra deslizando com desfoque de 90 a 430 ms e assenta nítido). Projeto sem esses campos renderiza idêntico ao de antes. |
|
||||
| `overlays` (`kind: "inset"`) | **Camada inserida** (recorte da tela em destaque): `start`/`end` (tempo da sessão), `src` `{x, y, w, h}` (recorte do quadro ORIGINAL, 0–1), `x`/`y` (centro na tela de saída, 0–1), `size` (largura, 0,1–1 da largura; a altura sai da proporção do `src`), `border` (`#RRGGBB` ou null), `borderW` (px no quadro lógico, 0–40, padrão 6), `radius` (px, 0–200, padrão 18), `shadow` (padrão true), `anim` (`pop` padrão, `fade`, `slide`, `none`) e `keys` opcionais `[{t, x, y, size, ease}]` para andar/crescer (mesma interpolação do reenquadramento). No máximo 12. Ordem no array = empilhamento (a última por cima); ficam acima do vídeo e do zoom e abaixo de legenda, gancho, textos e chat. |
|
||||
| `reframe` | **Reenquadramento do jogo no tempo** (opcional; ausente = como antes): `{keys: [{t, cx, cy, w, ease}]}`, no máximo 60. `t` = tempo da sessão; `cx`/`cy` = centro da janela e `w` = largura (0,05–1), frações do quadro ORIGINAL. A altura sai da proporção da área do jogo do layout daquele trecho (parte de baixo no `cam_top`; a tela toda no `game_only`, `blur` e horizontal), então nunca distorce; zoom que não cabe encolhe a janela, e a janela é presa dentro do quadro (desloca, não deforma). `ease` = como chega ao key seguinte: `smooth`, `linear` ou `hold` (segura e salta no key seguinte); antes do 1º e depois do último, segura. Com keys, `layout.game` é ignorado (keys absolutos no quadro original). Não vale para `cam_only`. A capa usa a janela parada do instante dela. |
|
||||
| `chat` | Chat da live na tela: `enabled`, `x`, `y` (base do bloco), `width`, `lines` (1–10), `size`, `showUser`. Cada mensagem fica até chegar a próxima (no máximo 9 s). |
|
||||
| `progress` | Barra de progresso. |
|
||||
| `audio` | Volume da live; `narration` (TTS, com a live abaixada por baixo); `music` (só de `assets/`, com ducking por `sidechaincompress`); `sfx`. |
|
||||
| `cover` | Capa. Com `atStart`, a capa também entra nos 2 primeiros quadros do vídeo (0 s), para a rede usar como miniatura. |
|
||||
| `meta` | Origem do projeto. |
|
||||
|
||||
### Render
|
||||
|
||||
`editor_render.py`:
|
||||
|
||||
- um `-ss` antes do `-i` para a janela inteira;
|
||||
- `trim`/`atrim` por trecho e layout por trecho (`layout.layout_chain`);
|
||||
- `concat`, depois `zoompan` (expressão do tempo), depois `ass` (legenda animada, gancho, textos, barra e
|
||||
crédito), depois `fps=30` e `yuv420p`;
|
||||
- áudio com `afade` de 20 ms nas emendas, `adelay`/`amix` para narração e efeitos, música em loop;
|
||||
- saída MP4 no formato do corte (1080×1920 ou 1920×1080), 30 fps, H.264 + AAC 48 kHz; o `zoompan` e a capa no
|
||||
início usam o mesmo tamanho. O formato do arquivo fica em `clips.aspect` (migração v8) e sai no JSON do corte.
|
||||
|
||||
### Reenquadramento e camadas inseridas (`app/reframe.py`)
|
||||
|
||||
Pedido do dono (17/11/2026, corte 61 em câmera-em-cima: o inventário ocupava a tela e saía só o miolo):
|
||||
|
||||
- **Reenquadramento**: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro do trecho, `in`, que começa em 1) viram o quadro inteiro com interpolação **subpixel**, depois `scale` para a área do jogo. Os keys estão em tempo da sessão e cada trecho do corte usa o próprio início, então `cuts` não desalinha. Medido: janela a < 4 px do esperado em todos os quadros testados; zoom suave sem passo para trás nem tremida (protótipo: desvio da aceleração 0,12 px). `scale` com `eval=frame` + `crop` fixo falhou no encoder e arredonda a posição a pixel inteiro. Grafo > 20 000 caracteres (muitos keys) vai por arquivo (`-/filter_complex`).
|
||||
- **Camadas inseridas**: o vídeo original de cada trecho é duplicado e concatenado (`[vraw]`); cada camada faz `crop` → `scale` → `alphamerge` (máscara dos cantos) → por cima de UMA imagem de decoração (sombra borrada + borda, gerada com numpy/OpenCV) → `scale` por quadro só se o tamanho muda (keys, pop) → `fade` de alfa → um `overlay` (expressão por quadro só se a posição muda: keys, slide).
|
||||
- **Medido** (corte 61, 60 s, NVENC): sem nada 6,1–6,2 s; com reenquadramento 7,1–9,5 s; com reenquadramento + 2 camadas (pop e slide) 15,8–20,5 s (com sombra, borda e recorte postos separados era 28,2 s).
|
||||
- No 9:16 com câmera em cima, a área do jogo é 1080×1268 (proporção 0,85): um inventário de 16:10 não cabe inteiro sem faixas; a janela mostra no máximo 0,48 da largura (uma coluna grande, ex.: a bolsa). No 16:9 cabe.
|
||||
- A IA ainda NÃO propõe reenquadramento nem camadas: o analista não devolve região da tela (precisaria de caixa na imagem, que hoje não é confiável).
|
||||
|
||||
### Tempo da legenda (fala rápida)
|
||||
|
||||
Pedido do dono (16/11/2026): "com fala rápida a legenda sai fora do tempo e fica uma em cima da outra". Causa
|
||||
medida na cópia do banco (3 projetos, sessão 3 do skipnho): **63 de 286** eventos de legenda começavam antes do fim
|
||||
do anterior: o fim de cada bloco (fim da última palavra, no mínimo +0,25 s) passava do início do bloco seguinte, e o
|
||||
libass **empilha** dois eventos ativos ao mesmo tempo. O Whisper também devolve palavras de 0 s (380 de 15 583) e
|
||||
palavras que começam no mesmo instante. Agora (`app/subtitles.py`, usado pelo render do editor e pelo do worker,
|
||||
nos dois formatos):
|
||||
|
||||
- `clean_words`: ordena, dá 60 ms mínimos por palavra, empurra 40 ms a que começa junto com a anterior e corta o fim
|
||||
de cada palavra no início da seguinte;
|
||||
- `group_words`: até `maxWords` e um limite de caracteres; quebra em pausa > 0,6 s ou bloco > 3,2 s; com fala muito
|
||||
rápida (bloco cheio durando < 0,7 s) aceita **uma** palavra a mais, se couber, para o bloco não piscar;
|
||||
- `caption_blocks`: o fim de um bloco é cortado no início do seguinte: **nunca dois blocos na tela**. O bloco entra
|
||||
no início da sua 1ª palavra e a palavra destacada troca no início de cada palavra (sem atraso em relação ao áudio);
|
||||
- a ênfase marcada no editor é casada nos tempos originais, antes do saneamento.
|
||||
|
||||
Medido depois: **0 de 299** eventos sobrepostos; deslocamento máximo do início de uma palavra = 140 ms (só em
|
||||
sequências de várias palavras que o Whisper pôs no mesmo instante; nas demais, 0); 3–7 blocos de 4 palavras por
|
||||
corte (fala rápida). O vertical com fala normal sai idêntico ao de antes (MD5 dos quadros conferido).
|
||||
|
||||
Validação forte (`editor.validate_project`): limites de duração (3–180 s) e de quantidade, texto escapado no ASS,
|
||||
áudio só de `assets/` ou dos TTS gerados pelo editor, e nada vira comando de shell.
|
||||
|
||||
### Medido (cópia do banco, sessão 3 do skipnho, 16/11/2026)
|
||||
|
||||
| Operação | Tempo |
|
||||
|---|---|
|
||||
| Proxy 480p de 120 s | 4,3 s |
|
||||
| Forma de onda | 0,2 s |
|
||||
| Re-transcrição de 13 s (Whisper) | 0,7 s |
|
||||
| TTS | 2,4 s |
|
||||
| IA sugere (`gpt-6-luna`) | 6,0 s |
|
||||
| Prévia real de 5 s | 0,8–1,3 s |
|
||||
| Export de 55,6 s | ~9 s |
|
||||
| Corte 10 pelos juízes até o vídeo pelo projeto da IA | 24 s |
|
||||
|
||||
### Limitações
|
||||
|
||||
- A prévia do navegador é aproximada (canvas); a exata é "Prévia real".
|
||||
- A tarja do gancho no layout câmera-em-cima fica sobre o painel da câmera nos primeiros segundos (a legenda fica na
|
||||
emenda); ajuste `y` no editor se preferir.
|
||||
- Camadas inseridas não entram na capa (a capa usa só o reenquadramento parado).
|
||||
- A prévia do editor (canvas) segue o formato do corte (9:16 ou 16:9, quadro lógico de `frames`), mas é aproximada:
|
||||
a exata é a "Prévia real" ou o export.
|
||||
- `clips.aspect` é gravado no render: antes do 1º render o corte informa `vertical` (padrão), mesmo num canal
|
||||
horizontal.
|
||||
- A varredura da IA limita o fim do momento ao fim da janela varrida: perto do fim da janela, a proposta pode sair
|
||||
mais curta que `minS` (os juízes ainda podem recuar o início).
|
||||
- Emoji sai monocromático (libass).
|
||||
- Sem B-roll e sem segunda trilha de vídeo: um pedaço não pode ser arrastado para outra camada nem tocar fora da
|
||||
ordem da gravação (a timeline é o tempo da sessão).
|
||||
- Código novo de render (`cam_only`, `muted`, `chat`, `cover.atStart`, texto com `x`) só vale depois de reiniciar o
|
||||
serviço; um serviço antigo rejeita o projeto com `cam_only`.
|
||||
- A forma de onda e o proxy cobrem só a janela carregada ("+30 s antes/depois" gera outra).
|
||||
- O corte usa os blocos `.ts`: depois de `CLIPPER_KEEP_HOURS` sem trabalho pendente, a edição daquele trecho
|
||||
deixa de ser possível.
|
||||
- Nova avaliação dos juízes (rejudge) troca o trecho de um projeto de origem `ai` (ele é refeito), mas não o de
|
||||
um projeto seu.
|
||||
|
||||
## Rastreio de reação (rosto do streamer)
|
||||
|
||||
`app/face.py` (E/S) + `app/reaction.py` (lógica pura). Plano: `doc/PLANO_RASTREIO_REACAO.md`; números:
|
||||
`doc/FACE_BAKEOFF.md`. Opção `faceTrack` (padrão ligada; `PUT /v1/judge`, interruptor no painel) — roda no PC, sem IA.
|
||||
|
||||
- **Câmera**: YuNet (`face_detection_yunet_2026may.onnx`) em 12 quadros; `locate_cam` agrupa pelo centro do grupo (1
|
||||
rosto de tolerância), exige presença em ≥ 50 % dos quadros e confiança média do grupo ≥ 0,7 (webcam real dá
|
||||
0,92–0,94; objeto parado que engana o YuNet, ~0,63) e expande o rosto (3,2× largura, 3,6× altura, folga na
|
||||
testa). Câmera em tela cheia (rosto > 40 % da altura) não vira layout. Sem rosto enquanto grava: tenta de novo em 5 min.
|
||||
- **Rastreio**: thread `face` do motor, um bloco por vez (sessões gravando primeiro; sessões antigas com blocos
|
||||
ainda no disco também). FFmpeg recorta a câmera +10 %, ~384 px, 6 qps, `rgb24` por pipe → MediaPipe Face
|
||||
Landmarker (VIDEO, um por bloco) → série por segundo na tabela `face_track` (status `done`/`no_cam`/`error`).
|
||||
`cx`/`cy`/`size` gravados no **quadro inteiro**. Medido: ~1,5 s de CPU por bloco de 30 s. Sem MediaPipe, cai no
|
||||
OpenSeeFace (só posição, sem expressões). Câmera trocada (detecção ou layout) → a série da sessão é refeita sozinha.
|
||||
- **Sinal**: z robusto de cada expressão contra o normal dos últimos 180 s do próprio streamer; rótulos risada,
|
||||
grito, susto, confuso, choque, raiva. Movimento só rotula (susto) e só com rosto em ≥ 80 % do segundo.
|
||||
- **Cortes**: momentos do chat/áudio ganham `reasons.face` e até +0,6 na nota; fonte nova `face` só com z ≥ 6 **e**
|
||||
apoio (áudio suavizado ≥ 1,5 ou ≥ 2 mensagens de reação). Com câmera e rastreio ligado, a decisão do corte espera
|
||||
o rosto do trecho (no máximo 2 blocos atrás da transcrição). O analista recebe a linha "Rosto do streamer: …".
|
||||
- **Modelos**: `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`; o `setup.ps1` (passo 6b)
|
||||
baixa; o serviço baixa sob demanda se faltar (fora da thread do chat). Falha de modelo não marca blocos: nova
|
||||
tentativa em 5 min.
|
||||
- **API**: `GET /v1/sessions/{id}/face?from=&to=` (série, `signal`, picos, câmera, progresso) e `POST …/face/reset`.
|
||||
|
||||
## Juiz de IA (pela CLI, sem chave de API)
|
||||
|
||||
Usa as CLIs já logadas no PC — as mesmas da página Agente:
|
||||
|
||||
| Provedor | Comando | Modelo padrão | Lista de modelos |
|
||||
|---|---|---|---|
|
||||
| `codex` (padrão) | `codex exec --ephemeral --sandbox read-only --output-schema … -o … -` | `gpt-6-luna` (rápido e barato) | `~/.codex/models_cache.json` (só `visibility: list`) |
|
||||
| `claude` | `claude -p --json-schema … --no-session-persistence` (imagens pela ferramenta Read; web por WebSearch) | `haiku` | `haiku`, `sonnet`, `opus` |
|
||||
| `off` | — | — | só a heurística |
|
||||
|
||||
Codex: imagens com `-i` (uma por flag, antes de `-`), busca na web com `--search` (opção global, antes de `exec`).
|
||||
Provedor, modelo do editor, **modelo do analista** (`analystModel`, vazio = o mesmo), nota mínima, varredura
|
||||
(`scanEnabled`, `scanIntervalS`), visão (`vision`), detecção de câmera (`camDetect`) e rastreio de reação (`faceTrack`) se trocam no painel (`PUT /v1/judge`) e ficam na tabela `settings` do banco — sem
|
||||
reiniciar. O `.env` só dá os valores iniciais. Medido (16/11/2026): `gpt-6-luna` respondeu em ~7 s por candidato.
|
||||
Falha do juiz não perde o momento: o corte segue pela heurística e o erro fica em `judge.error`.
|
||||
|
||||
## Instalação e subida
|
||||
|
||||
- `setup.bat` cria `clipper/.venv` (Python 3.12 via uv), instala `requirements.txt` (Streamlink 8.6.3) e gera
|
||||
`clipper/.env` com chave nova.
|
||||
- `start.bat` / `pnpm dev` sobem voz + Clipador + painel. Sem `clipper/.venv` ou sem chave, o Clipador é pulado com aviso.
|
||||
- Só o serviço: `cd clipper && .venv\Scripts\python -m uvicorn app.main:build --factory --host 127.0.0.1 --port 4520`
|
||||
- Testes: `cd clipper && .venv\Scripts\python -m pytest`
|
||||
- Mudança de **código** em `clipper/app/` só vale depois de reiniciar o serviço (o `pnpm dev` não usa `--reload`).
|
||||
Provedor/modelo do juiz não precisam: mudam pelo painel na hora.
|
||||
|
||||
Precisa do FFmpeg com `libass` (legenda) — o build `essentials` do gyan.dev tem. NVENC é usado quando existe.
|
||||
|
||||
## Configuração (`clipper/.env`)
|
||||
|
||||
| Variável | Padrão | O que faz |
|
||||
|---|---|---|
|
||||
| `CLIPPER_SERVICE_KEY` | (setup) | chave exigida em toda rota, exceto `GET /health` |
|
||||
| `CLIPPER_PORT` | 4520 | faixa 4500–4599 |
|
||||
| ~~`CLIPPER_QUALITY`~~ | — | não é mais lida: a qualidade é `capture.quality` por canal/sessão (padrão `best`) |
|
||||
| `CLIPPER_SEGMENT_S` | 30 | tamanho do bloco gravado |
|
||||
| `CLIPPER_POLL_S` | 60 | intervalo para checar se um canal monitorado entrou ao vivo |
|
||||
| `CLIPPER_KEEP_HOURS` | 6 | apaga blocos mais velhos que isto se nenhum corte pendente precisar (0 = nunca) |
|
||||
| `CLIPPER_LANGUAGE` | `pt-BR` | idioma da transcrição |
|
||||
| `CLIPPER_ENCODER` | `auto` | `auto` (NVENC se houver) · `libx264` · `h264_nvenc` |
|
||||
| `CLIPPER_JUDGE_PROVIDER` / `_MODEL` / `_MIN_SCORE` | `codex` / (padrão) / 6 | valores iniciais do juiz |
|
||||
| `CLIPPER_DATA_DIR` | `data/clipper` | banco, blocos gravados, modelos do rastreio e arquivos do juiz; para isolar uma instância de teste (relativo ao repo ou absoluto, **dentro** do repo) |
|
||||
| `CLIPPER_OUTPUT_DIR` | `output/clipper` | cortes prontos, prévias e projetos do editor (mesma regra; fora de `output/` o painel não serve os arquivos) |
|
||||
|
||||
Instância de teste isolada (não toca no banco nem nos blocos do serviço do usuário): defina `CLIPPER_PORT=4521`,
|
||||
`CLIPPER_DATA_DIR=output/<teste>/data` e `CLIPPER_OUTPUT_DIR=output/<teste>/clips` no ambiente (o ambiente vence o
|
||||
`clipper/.env`) e suba o uvicorn com essa porta. Atenção: o serviço de voz é compartilhado e guarda a transcrição pela
|
||||
chave `clipper-<sessão>-<bloco>`; num banco novo as sessões recomeçam do 1 e colidiriam com as do banco real — suba o
|
||||
`sqlite_sequence` de `sessions` (ex.: 90000) antes da primeira sessão.
|
||||
|
||||
## API (todas com `X-Service-Key`)
|
||||
|
||||
| Rota | O que faz |
|
||||
|---|---|
|
||||
| `GET /health` | sem chave |
|
||||
| `GET /v1/status` | ferramentas, voz, juiz, gravações ativas |
|
||||
| `GET/PUT /v1/judge` | provedor, modelos (editor/analista), nota mínima, varredura, visão, câmera (+ lista de modelos) |
|
||||
| `GET/PUT /v1/channels/{id}/settings` · `GET/PUT /v1/sessions/{id}/settings` | configuração do corte: `own`, `effective`, `defaults` (com `format`, `duration` e `hook`), `modes`, `fonts`, `fontFiles` (`{família: "assets/fonts/…ttf"}` das empacotadas, relativo à raiz do repositório), `hookStyles`, `hookAnims`, `aspects`, `frames` (`{vertical, horizontal: {width, height, canvasWidth, canvasHeight}}`, para o painel desenhar a prévia) e `captureQualities` (`[{id, label, maxHeight, gbPerHour, gbPerHourMax, hint}]`) |
|
||||
| `GET /v1/sessions/{id}/frame?t=` · `POST …/preview` · `POST …/detect-cam[?ai=true]` | quadro para o editor, prévia do layout, achar webcam (local primeiro) |
|
||||
| `GET /v1/sessions/{id}/face?from=&to=` · `POST …/face/reset` | série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal`) e picos; refazer o rastreio |
|
||||
| `PUT /v1/sessions/{id}/game` · `GET /v1/games` · `POST /v1/games/{id}/research` · `PUT /v1/games/{id}` · `POST /v1/games/{id}/refine` · `DELETE /v1/games/{id}/notes/{n}` | jogo da sessão, perfis pesquisados, edição à mão e pedidos à IA |
|
||||
| `GET /v1/emotes?channel=twitch-<login>` | emotes do canal, usos e peso aprendido |
|
||||
| `GET/POST /v1/channels` · `PATCH/DELETE /v1/channels/{id}` · `POST /v1/channels/{id}/check` | canais (`monitor` grava sozinho ao entrar ao vivo; `authorized` = streamer autorizou) |
|
||||
| `GET/POST /v1/sessions` · `GET/DELETE /v1/sessions/{id}` · `POST …/stop` | gravar live ou processar VOD pelo link; cada sessão traz `capture` (resolução, qps, codec e taxa gravados de fato; `null` = sessão antiga) |
|
||||
| `GET /v1/sessions/{id}/timeline` | mensagens/s, razão do chat e volume por segundo |
|
||||
| `POST /v1/sessions/{id}/clips` | **cortar agora**: `{lastS}` ou `{startS,endS}`; corte manual nunca é descartado pela IA |
|
||||
| `GET /v1/clips?status=&session=` · `GET/PATCH /v1/clips/{id}` · `POST …/render` · `POST …/rejudge` | fila de cortes; cada corte traz `aspect` (`vertical` ou `horizontal`) = formato em que o arquivo foi renderizado |
|
||||
| `DELETE /v1/clips/{id}[?confirmPublished=true]` | **apagar um corte**: linha, projeto de edição e arquivos (ver "Apagar cortes"). 200 `{id, sessionId, status, removedFiles, left: [{file, reason}]}`; 404 `not_found`; 409 `busy_candidate` / `busy_rendering` / `published` / `changed` (`{error, code}`) |
|
||||
| `POST /v1/clips/delete` `{ids: [..≤500]}` ou `{statuses: [...], sessionId?}`, `confirmPublished?` | **apagar em lote** (selecionados ou a aba inteira, até 500 por chamada, do mais novo para o mais velho). 200 `{requested, remaining, deleted: [como acima], failed: [{id, code, reason}]}`; 400 sem `ids` nem `statuses` (ou os dois, ou `sessionId` com `ids`); 422 acima de 500 ids ou estado inválido |
|
||||
| `GET/PUT/DELETE /v1/clips/{id}/edit` (PUT com `rev`; 409 se outro salvou) · `POST …/proxy` `{lo,hi}` · `GET …/waveform?lo=&hi=` | editor: projeto, prévia 480p e forma de onda |
|
||||
| `POST /v1/clips/{id}/preview-render` `{fromS,durationS≤10,project?}` · `POST …/export` | prévia real de poucos segundos (no formato do corte; com `cover.atStart` e `fromS` = 0 a capa entra nos 2 primeiros quadros, como no export); exportar (volta para a fila de render → `ready`) |
|
||||
| `POST /v1/clips/{id}/retranscribe` `{startS,endS≤90 s}` · `POST …/tts` `{text,voice,speed}` · `POST …/suggest` | Whisper de novo; narração (WAV em `edit-<id>/tts-*.wav`); IA sugere gancho, título, início/fim, trechos mortos e zooms |
|
||||
|
||||
Origem do corte (`source`): `chat`, `audio`, `ai` (varredura), `face` (reação no rosto com apoio do áudio/chat), `manual`.
|
||||
Estados do corte: `candidate` (esperando IA) → `pending` (fila de render) → `rendering` → `ready` → `approved`/`rejected`;
|
||||
`discarded` (IA descartou) e `error`. `published` é só uma marcação manual até existir a etapa de publicação nas redes.
|
||||
|
||||
### Apagar cortes (`app/clip_delete.py`)
|
||||
|
||||
Pedido do dono (17/11/2026): apagar um corte, vários ou todos de uma aba, inclusive "Descartados pela IA" e "Para
|
||||
aprovar". No painel, tudo discreto (o dono reprovou uma barra presa no topo): "Apagar" em cada cartão (confirmação no
|
||||
próprio cartão); no canto da linha das abas, "Selecionar" e o menu "⋯" com "Apagar todos desta aba (N)" (modal com a
|
||||
contagem; com a fila filtrada por sessão, vale só para aquela sessão e o modal diz isso); a caixa de cada cartão só
|
||||
aparece no hover/foco ou no modo de seleção; com algo marcado, uma pílula flutuante no canto inferior direito
|
||||
("N selecionados · Selecionar todos · Apagar · ✕"; Esc sai do modo). O painel manda os **ids que está mostrando** (não `statuses`):
|
||||
corte que chegar depois da confirmação não é apagado junto.
|
||||
|
||||
- **O que some:** a linha em `clips`, o projeto (`edits`) e os arquivos: `clip-<id>.mp4`/`.jpg`/`-cover.jpg` e restos do
|
||||
render (`clip-<id>.*`, `clip-<id>-*`) em `output/clipper/<sessão>/`, a pasta do editor `edit-<id>/` (proxy, forma de
|
||||
onda, TTS, prévias) e os quadros do juiz `data/clipper/sessions/<sessão>/frames/clip<id>-*.jpg`. Os blocos gravados
|
||||
(`.ts`) ficam: são da sessão.
|
||||
- **Só dentro das pastas do Clipador** (`CLIPPER_OUTPUT_DIR`, `CLIPPER_DATA_DIR`): cada caminho é resolvido antes;
|
||||
caminho de fora (inclusive `clips.file` apontando para fora, ou pasta da sessão trocada por junção) não é tocado e
|
||||
volta em `left` com "fora das pastas do Clipador". Link ou junção dentro da pasta do editor: some só o link, o alvo
|
||||
fica. Arquivo em uso também volta em `left`.
|
||||
- **Recusa:** `candidate` (a IA está avaliando) e `rendering` (inclusive o `pending` que o motor acabou de pegar:
|
||||
`Engine.render_clip` confere sob o mesmo trinco que o corte ainda existe). `published` só com `confirmPublished`
|
||||
(o vídeo já foi postado; hoje ninguém marca `published`, mas a etapa de publicação vai precisar do registro).
|
||||
- **O momento apagado não volta.** Sem o corte, a regra anti-duplicado (que compara com cortes em qualquer estado,
|
||||
inclusive descartados) deixaria a IA recriar o mesmo momento na passada seguinte da live ou na passada final da
|
||||
sessão. Fica uma marca mínima na tabela `deleted_clips` (migração **v10**: id, sessão, pico, trecho final, janela
|
||||
original do candidato, estado, origem, título, data), que entra na conta como se o corte existisse: no candidato
|
||||
(`find_new_clips`), na varredura da IA (`mark_spans`) e no trecho final depois do juiz para quem foi apagado num
|
||||
estado de `VETO_STATUSES` ("Duplicado do corte N (que você apagou)"; descartado pela IA apagado não veta, como
|
||||
antes). A marca some com a sessão (`ON DELETE CASCADE`).
|
||||
- **Nada mais quebra:** o peso aprendido dos emotes (`clips.learned`) mora na tabela `emotes` e fica; `judge.duplicateOf`
|
||||
de outros cortes é só texto (nada lê o id de volta); a memória da varredura (`sessions.memory_json`) não guarda id de
|
||||
corte; apagar o último pendente deixa a sessão terminar (`finish_if_done`); `prune` deixa de segurar os blocos dele.
|
||||
- Testes: `tests/test_clip_delete.py`.
|
||||
|
||||
## Armadilhas já resolvidas
|
||||
|
||||
- **Legenda sumia do vídeo**: com `-ss` depois do `-i`, o filtro `ass` via o tempo do bloco (não do corte) e a legenda
|
||||
saía deslocada. `-ss` vai antes do `-i` (`app/media.py`).
|
||||
- **`.upper()` na linha ASS** transformava a tag `\c` em `\C` (inválida). Maiúsculas só no texto.
|
||||
- **Falsos positivos com chat calmo**: 3 mensagens com um emote `clip5k1hmm` davam razão 2,35. Regras: palavra inteira
|
||||
para "clip", mínimo de mensagens no pico (hoje proporcional ao chat, entre 4 e 12), 60 s de aquecimento (teste de regressão em `tests/test_scoring.py`).
|
||||
- **Chat pequeno sem corte nenhum** (skipnho, 0,15 msg/s): mínimo fixo de 12 mensagens → proporcional + varredura.
|
||||
- **Título preso à transcrição** ("jogando três jogos" num momento de lag): dois juízes, frames e glossário do chat.
|
||||
- **Crédito em cima do rosto** no layout câmera-em-cima: desce para o pé do painel da câmera.
|
||||
- `codex.cmd` (lote do npm) não roda bem sem shell: o juiz chama o `codex.js` pelo Node, como o painel.
|
||||
- Matar o serviço à força não deixou `streamlink`/`ffmpeg` órfãos no teste, mas em queda o banco marca as sessões
|
||||
em andamento como `interrupted` na próxima subida.
|
||||
- **Palavra com duração zero do Whisper** (ex.: "queria" 1020,10–1020,10 no skipnho) derrubava a validação do
|
||||
projeto do editor: agora ganha 50 ms.
|
||||
- **Capa sem imagem**: o mjpeg do FFmpeg 7.1 recusa yuv420p marcado como faixa "tv" (bloco do libx264); o quadro
|
||||
intermediário da capa é PNG.
|
||||
- **Gancho cortado no meio**: o `hook` do analista às vezes é uma frase descritiva ("Aos 5085s, ele solta que…",
|
||||
corte 25 do skipnho); o projeto da IA só usa se for curto (≤ 8 palavras, ≤ 48 caracteres) e sem tempo da gravação,
|
||||
senão usa o título do editor; resto de "aos NNN s" é tirado e o texto é cortado em palavra inteira (`pick_hook`).
|
||||
- **Live no ar foi para "processando" depois de reiniciar o serviço** (16/11/2026, sessão 3): a retomada da subida
|
||||
fazia UMA checagem; o `streamlink --json` falhou (timeout/erro eram engolidos e pareciam "offline") e a sessão foi
|
||||
encerrada. Agora `Engine.live_check` separa `live`, `offline` ("No playable streams…") e `unknown` (timeout, erro,
|
||||
JSON inválido; motivo e fim do stderr vão para o log), e `keep_live` tenta de novo com espera crescente
|
||||
(0, 10, 20, 40, 60, 90, 120 s ≈ 5,7 min). Enquanto tenta, a sessão fica `interrupted` ("Retomar gravação" no
|
||||
painel); só processa depois de esgotar as tentativas ou de ver `offline` 2 vezes seguidas. Se você retomar,
|
||||
processar ou apagar no meio, a thread para sem mexer. O mesmo vale para a **captura que cai no meio da live**
|
||||
(antes ia direto para `processing`): ela vira `interrupted` e passa pelo mesmo `keep_live`; 3 retomadas seguidas
|
||||
sem nenhum bloco novo desistem.
|
||||
- **Cortes presos em "renderizando"** (17/11/2026, sessão 3: 10 cortes, ids 42–58): o serviço subiu com uma versão
|
||||
intermediária da legenda que dava `KeyError` quando o saneamento mudava alguma palavra (o corte 40, com 0 palavras
|
||||
mudadas, saiu; os 10 presos tinham de 6 a 20). A exceção não prevista escapava do render, o laço reiniciava e o corte
|
||||
ficava em `rendering` para sempre. Agora qualquer falha no render vira `error` com a mensagem e a fila segue; um
|
||||
`rendering` que este processo não está renderizando há mais de 5 min volta para `pending` (na 3ª vez, `error`).
|
||||
- **O mesmo momento virando vários cortes** (sessão 3: pico 1149 s → cortes 42, 47, 49, 51, 52, em cima do 9, já
|
||||
pronto): a checagem comparava o candidato (em volta do pico) só com o trecho final dos cortes, mas o juiz recua o
|
||||
trecho (1012–1100); na passada seguinte o mesmo pico já não sobrepunha e era criado de novo. Agora (`worker.py`):
|
||||
o candidato guarda a janela original (`reasons.candidateStartS/EndS`) e não nasce se o pico estiver a ≤ 10 s de
|
||||
outro corte, ou se sobrepuser o trecho final ou a janela original de um corte em qualquer estado (inclusive
|
||||
descartado). Depois do juiz, o trecho final é conferido contra os cortes mantidos (pendente, renderizando, pronto,
|
||||
aprovado, publicado): mesmo momento (pico a ≤ 10 s ou ≥ 60 % do mais curto coberto) = descartado como
|
||||
"Duplicado do corte N" (`judge.duplicateOf`). Vale para chat, áudio, rosto e varredura; "cortar agora" (manual)
|
||||
só ganha o aviso `judge.warning`. Antes de cada render, pendentes que já são o mesmo momento de um corte pronto,
|
||||
aprovado, publicado ou rejeitado, de um corte apagado que estava num desses estados, ou de um pendente mais antigo
|
||||
saem da fila como "Duplicado do corte N (que você rejeitou/apagou)" — o mesmo conjunto do veto depois do juiz;
|
||||
descartado pela IA não veta (nunca sai um manual ou um que você exportou do editor). Cortes duplicados que JÁ estão
|
||||
prontos não são mexidos: rejeite à mão.
|
||||
- **Testes chamavam a CLI de IA de verdade**: o juiz falso dos testes não cobria o analista; agora `FakeJudge.ask`
|
||||
falha sempre (caminho de "IA fora" que o serviço já trata).
|
||||
- **Cortes mais curtos que o mínimo** (sessão 3, mínimo 60: cortes 43 = 54,6 s, 44 = 55,0 s, 55 = 46,8 s, 58 = 57,7 s,
|
||||
61 = 43,8 s): o projeto da IA ADIANTAVA o início para o `action_start_s` do analista quando ele vinha depois do
|
||||
início do juiz ("início no começo da ação"), e nada reimpunha o mínimo depois. Também: o juiz limitava o fim em
|
||||
`hi` sem recuar o início, a varredura idem, e `fit_length` podia passar do máximo. Agora todos passam por
|
||||
`fit_window` com mínimo + 1 s, e o início só adianta se o mínimo continuar.
|
||||
- **Fonte empacotada ignorada pelo libass**: o `fontsdir` NÃO lê subpastas (medido: `fonts/` não achava nada,
|
||||
`fonts/bangers/` achava). A pasta é plana. No Windows o caminho vai absoluto, entre aspas, com `:` escapado. A
|
||||
Poppins ExtraBold só é achada pelo nome de família ID 1 ("Poppins ExtraBold"), não por "Poppins".
|
||||
- **Corte que atravessa blocos de resoluções ou codecs diferentes** (retomada em outra qualidade, ou a fonte mudou
|
||||
no meio): o vídeo parava na emenda sem erro (medido em 17/11/2026: corte de 35 s com 20 s de vídeo; 15 s na troca
|
||||
H.264 → HEVC). Agora `uniform_segments` (`editor_render.py`) converte os blocos do trecho num intermediário
|
||||
uniforme (maior tamanho do trecho, 30 qps) só nesse caso, no render e no proxy; trecho com blocos iguais segue
|
||||
pelo caminho de sempre. A qualidade pode ser trocada também numa retomada. O proxy faz `fps` antes do `scale`.
|
||||
- **"Não está gerando os clipes"** (17/11/2026, sessão 3, 9000–10560 s): diagnóstico numa cópia do banco. A live
|
||||
esfriou: chat de 0,27–0,39 msg/s e 56–78 reações a cada 500 s (7000–8000 s) caiu para 0,04–0,10 msg/s e 2–10
|
||||
reações (9000–10000 s); a heurística não achou NENHUM pico entre 8872 e 10350 s, nem com as regras antigas
|
||||
(15–59 s, só sobreposição); a varredura descreveu cada janela como "sem confronto ou reação marcante"; e o juiz deu
|
||||
3,2–4,2 aos candidatos 65–67 (mínimo 6). Regras atuais × antigas em 7200–10560 s: 1 × 4 candidatos, mas os 3 a
|
||||
mais eram rosto fraco (nota 2,5) ou a cena do corte 61, rejeitado; zona proibida 34 % × 24 %. Afrouxar o
|
||||
anti-duplicado não traria corte novo, então ficou como está. Mudanças: rejeitado também veta o trecho final depois
|
||||
do juiz ("Duplicado do corte N (que você rejeitou)"); a varredura grava `proposals`/`created` em cada janela da
|
||||
memória (e no log), porque antes não dava para saber se ela não propôs nada ou se foi barrada.
|
||||
- **Legenda uma em cima da outra com fala rápida**: o fim de um bloco passava do início do seguinte e o libass
|
||||
empilhava os dois. Blocos agora nunca se sobrepõem e as palavras são saneadas (ver "Tempo da legenda").
|
||||
- **Quadro errado ao buscar dentro de um bloco `.ts`** (17/11/2026): o demuxer mpegts do FFmpeg trata todo pacote
|
||||
como ponto de busca; `-ss` antes do `-i` caía num quadro P. No H.264 saía o próximo quadro-chave (até 2 s depois);
|
||||
no **HEVC** (2K da Twitch) saía um quadro **cinza** — frames do juiz, capa e YuNet (a câmera não era achada). Um
|
||||
2º `-ss` depois do `-i` também erra com áudio no bloco (7,5 s virou 6,06 s). Agora `media.seek_args`: busca 4 s
|
||||
antes, `-copyts -start_at_zero` e `select='gte(t,alvo)'` (usado por `grab_frame` e `face.grab_bgr`). Render e
|
||||
proxy (concat demuxer) já buscavam certo.
|
||||
- **Rastreio do rosto com resolução trocada no meio da sessão**: o tamanho do quadro era medido uma vez por sessão;
|
||||
uma retomada em outra qualidade recortaria a câmera no lugar errado. Agora é medido por bloco.
|
||||
|
||||
## Limites conhecidos
|
||||
|
||||
- **Direitos autorais**: cortar lives de terceiros sem autorização pode render strike/derrubada da conta. Cada corte
|
||||
leva o crédito do canal no vídeo e na legenda; marque `authorized` nos canais que autorizaram.
|
||||
- Chat do **YouTube** ainda não é lido (exige a API do YouTube); a sessão segue pelo áudio e pela transcrição.
|
||||
- Chat da **Kick** usa o websocket público do site (não oficial; o Cloudflare às vezes bloqueia o id da sala).
|
||||
- VOD não tem chat (o replay de chat da Twitch não é API pública): só áudio + transcrição.
|
||||
- A webcam é tratada como retângulo fixo (overlay do streamer); se ele mover a câmera no meio da live, ajuste no editor.
|
||||
- O analista pode errar a situação quando tela, fala e chat não batem (ex.: corte 10 do skipnho: chat "live
|
||||
travando", analista concluiu "pegadinha na conversa") — a confiança e o motivo ficam no corte para você conferir.
|
||||
@@ -0,0 +1,150 @@
|
||||
"""Qualidade de gravação da live (grupo `capture` da configuração do corte) e o que foi gravado de fato.
|
||||
|
||||
Pedido do dono (17/11/2026): "pegar a live na melhor resolução; a live tem 2K, e isso é configurável".
|
||||
Antes a captura pedia `720p60,720p,480p,best` e nunca passava de 720p, mesmo com a fonte em 1080p ou 1440p.
|
||||
|
||||
`capture.quality`:
|
||||
- `best` (padrão): a maior resolução que a live oferece;
|
||||
- `1440p` | `1080p` | `720p` | `480p`: TETO — a maior variante que não passa dele.
|
||||
|
||||
Nomes de stream medidos com `streamlink --json` (17/11/2026, 143 lives da Twitch, 5 da Kick, 22 do YouTube):
|
||||
- Twitch: `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`,
|
||||
`360p30`, `160p30`, `audio_only` e, em 9 canais, variantes VERTICAIS `1920p60_portrait`, `1280p30_portrait`…
|
||||
(a de 1080×1920 vem em HEVC). Nenhuma live com 1440p no momento, nem pedindo h265/av1;
|
||||
- Kick: `1080p60`, `720p60`, `480p`, `360p`, `160p`;
|
||||
- YouTube (pelo HLS do Streamlink, até lives "4K"): `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p`.
|
||||
|
||||
Como a escolha é feita: pelos sinônimos `best`/`worst` do próprio Streamlink, que ordenam por peso
|
||||
(`1440p60` = 1500, `1080p60` = 1140, `1080p` = 1080, `936p60` = 996…) e ignoram nomes de peso 0 (`audio_only`,
|
||||
`*_portrait`, `source`). O teto vira `--stream-sorting-excludes >{teto}p60`; se nada sobrar abaixo do teto, a reserva
|
||||
`worst-unfiltered` pega a menor variante de vídeo que existe (a mais perto do teto) — a captura nunca falha por
|
||||
causa da qualidade escolhida.
|
||||
|
||||
FPS: não há opção de 30/60 qps. A variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives; a
|
||||
Kick também), então pedir 30 qps custaria resolução; e o corte sai em 30 qps de qualquer jeito.
|
||||
|
||||
2K na Twitch (transmissão aprimorada) vem em HEVC: com `best` ou `1440p` a captura pede `--twitch-supported-codecs
|
||||
h264,h265`. Medido: com h265 pedido, as variantes paisagem das lives continuaram H.264 (só a vertical vira HEVC).
|
||||
AV1 não é pedido: o FFmpeg instalado não tem decodificador libdav1d.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
from . import media
|
||||
from .layout import CAPTURE_QUALITIES as QUALITIES
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.capture")
|
||||
|
||||
DEFAULT_QUALITY = "best"
|
||||
CEILING_HEIGHT = {"1440p": 1440, "1080p": 1080, "720p": 720, "480p": 480}
|
||||
# Twitch: 2K só aparece pedindo HEVC. Abaixo disso, o padrão do Streamlink (h264) basta.
|
||||
TWITCH_HEVC_QUALITIES = ("best", "1440p")
|
||||
|
||||
# Disco por hora (GB) de cada opção. Medido nas playlistas mestras da Twitch (BANDWIDTH, mediana de 62–69 lives,
|
||||
# 17/11/2026): 1080p60 7,1 Mbps (4,6–9,1) ≈ 3,2 GB/h; 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h.
|
||||
# Gravação real (skipnho): 720p60 12,7 MB por bloco de 30 s (1,53 GB/h); 1080p60 29,9 MB (3,58 GB/h).
|
||||
# 2K: nenhuma live achada — estimativa de ~10 Mbps (≈ 4,5 GB/h).
|
||||
OPTIONS = [
|
||||
{"id": "best", "label": "Melhor disponível", "maxHeight": None, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
|
||||
"hint": "A maior resolução que a live oferece (2K, se o canal transmitir em 2K)."},
|
||||
{"id": "1440p", "label": "Até 2K (1440p)", "maxHeight": 1440, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
|
||||
"hint": "Igual a \"Melhor\" hoje; não passa de 2K se o canal transmitir em 4K."},
|
||||
{"id": "1080p", "label": "Até Full HD (1080p)", "maxHeight": 1080, "gbPerHour": 3.2, "gbPerHourMax": 4.1,
|
||||
"hint": "Mesma nitidez do corte final (1080 px de largura)."},
|
||||
{"id": "720p", "label": "Até HD (720p)", "maxHeight": 720, "gbPerHour": 1.5, "gbPerHourMax": 2.7,
|
||||
"hint": "Como era antes: metade do disco, câmera recortada mais borrada."},
|
||||
{"id": "480p", "label": "Até 480p", "maxHeight": 480, "gbPerHour": 0.65, "gbPerHourMax": 0.7,
|
||||
"hint": "Só para economizar disco: o corte sai visivelmente borrado."},
|
||||
]
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class StreamChoice:
|
||||
"""Opções extras do Streamlink + a lista de streams (primeiro que existir), em argumentos separados."""
|
||||
options: tuple[str, ...]
|
||||
streams: str
|
||||
|
||||
def args(self, url: str) -> list[str]:
|
||||
return [*self.options, url, self.streams]
|
||||
|
||||
|
||||
def normalize_quality(value: object) -> str:
|
||||
return value if isinstance(value, str) and value in QUALITIES else DEFAULT_QUALITY
|
||||
|
||||
|
||||
def stream_choice(quality: str, platform: str) -> StreamChoice:
|
||||
"""Lista de preferência do Streamlink para a opção `quality` na plataforma (`twitch` | `kick` | `youtube`)."""
|
||||
quality = normalize_quality(quality)
|
||||
options: list[str] = []
|
||||
if platform == "twitch" and quality in TWITCH_HEVC_QUALITIES:
|
||||
options += ["--twitch-supported-codecs", "h264,h265"]
|
||||
if quality == "best":
|
||||
return StreamChoice(tuple(options), "best")
|
||||
# Teto: exclui do `best` tudo que pesa mais que "<teto>p60" (1080p60 fica; 1440p30 e 1440p60 saem). Sem nada
|
||||
# abaixo do teto, `best` some e `worst-unfiltered` entrega a menor variante de vídeo (a mais perto do teto).
|
||||
options += ["--stream-sorting-excludes", f">{quality}60"]
|
||||
return StreamChoice(tuple(options), "best,worst-unfiltered")
|
||||
|
||||
|
||||
def probe_block(ffprobe: str, file: Path) -> dict:
|
||||
"""Resolução, qps, codec e taxa reais de um bloco gravado (`ffprobe`). Levanta `media.MediaError`."""
|
||||
out = media.run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries",
|
||||
"stream=codec_name,width,height,avg_frame_rate,r_frame_rate:format=duration,size",
|
||||
"-of", "default=nw=1", str(file)], 30).decode("utf-8", errors="replace")
|
||||
info: dict[str, str] = {}
|
||||
for line in out.splitlines():
|
||||
if "=" in line:
|
||||
key, value = line.split("=", 1)
|
||||
info.setdefault(key.strip(), value.strip())
|
||||
try:
|
||||
width, height = int(info["width"]), int(info["height"])
|
||||
except (KeyError, ValueError) as exc:
|
||||
raise media.MediaError(f"sem vídeo em {file.name}") from exc
|
||||
fps = _rate(info.get("avg_frame_rate")) or _rate(info.get("r_frame_rate"))
|
||||
try:
|
||||
duration, size = float(info.get("duration") or 0), float(info.get("size") or file.stat().st_size)
|
||||
except (ValueError, OSError):
|
||||
duration, size = 0.0, 0.0
|
||||
kbps = round(size * 8 / duration / 1000) if duration > 1 else None
|
||||
return {"width": width, "height": height, "fps": round(fps) if fps else None,
|
||||
"codec": info.get("codec_name") or "", "kbps": kbps,
|
||||
"gbPerHour": round(kbps * 3600 / 8 / 1e6, 2) if kbps else None}
|
||||
|
||||
|
||||
def _rate(raw: str | None) -> float:
|
||||
if not raw or raw in ("0/0", "N/A"):
|
||||
return 0.0
|
||||
try:
|
||||
if "/" in raw:
|
||||
num, den = raw.split("/", 1)
|
||||
return float(num) / float(den) if float(den) else 0.0
|
||||
return float(raw)
|
||||
except ValueError:
|
||||
return 0.0
|
||||
|
||||
|
||||
MAX_RUNS = 10
|
||||
|
||||
|
||||
def record_run(previous: dict | None, quality: str, from_idx: int, probed: dict, at: str) -> dict:
|
||||
"""`sessions.capture_json` depois do 1º bloco de uma execução da captura (início ou retomada).
|
||||
|
||||
Topo = a execução atual (o painel mostra "gravando em 2560×1440 · 60 qps"); `runs` guarda as últimas
|
||||
`MAX_RUNS` execuções; `mixed` = a sessão tem blocos em mais de uma resolução (retomada com outra qualidade)."""
|
||||
runs = [r for r in (previous or {}).get("runs", []) if isinstance(r, dict) and r.get("fromIdx") != from_idx]
|
||||
run = {"fromIdx": from_idx, "quality": quality, **{k: probed.get(k) for k in ("width", "height", "fps", "codec")}}
|
||||
runs = (runs + [run])[-MAX_RUNS:]
|
||||
sizes = {(r.get("width"), r.get("height")) for r in runs}
|
||||
return {"quality": quality, **probed, "fromIdx": from_idx, "at": at, "runs": runs, "mixed": len(sizes) > 1}
|
||||
|
||||
|
||||
def label(info: dict | None) -> str:
|
||||
""""2560×1440 · 60 qps" (texto do log; o painel monta o seu)."""
|
||||
if not info or not info.get("width"):
|
||||
return "resolução desconhecida"
|
||||
fps = f" · {info['fps']} qps" if info.get("fps") else ""
|
||||
return f"{info['width']}×{info['height']}{fps}"
|
||||
@@ -0,0 +1,165 @@
|
||||
"""Leitura do chat ao vivo, em tempo real, para medir a reação do público.
|
||||
|
||||
- Twitch: IRC anônimo (irc.chat.twitch.tv:6697, apelido `justinfanNNNN`): só leitura, sem conta nem token.
|
||||
- Kick: websocket público do Pusher usado pelo site (`chatrooms.<id>.v2`). Não é API oficial: pode mudar
|
||||
sem aviso e o Cloudflare às vezes bloqueia a consulta do id da sala.
|
||||
- YouTube: ler o chat exige a API do YouTube (cota) — ainda não suportado; a sessão segue pelo áudio.
|
||||
|
||||
Cada leitor roda numa thread, reconecta sozinho e entrega lotes de (instante, usuário, texto) com o relógio
|
||||
de parede; quem chama converte para o tempo da gravação.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import random
|
||||
import re
|
||||
import socket
|
||||
import ssl
|
||||
import threading
|
||||
import time
|
||||
from typing import Callable
|
||||
|
||||
import httpx
|
||||
|
||||
from .emotes import parse_twitch_tag
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.chat")
|
||||
# (hora real, usuário, texto, emotes nativos recortados do texto)
|
||||
OnMessages = Callable[[list[tuple[float, str, str, list[str]]]], None]
|
||||
|
||||
_PRIVMSG = re.compile(r"^(?:@(\S+) )?:([^!\s]+)!\S+ PRIVMSG #\S+ :(.*)$")
|
||||
_ROOM_ID = re.compile(r"(?:^@|;)room-id=(\d+)")
|
||||
KICK_PUSHER = "wss://ws-us2.pusher.com/app/32cbd69e4b950bf97679?protocol=7&client=js&version=8.4.0&flash=false"
|
||||
|
||||
|
||||
class ChatReader:
|
||||
def __init__(self, platform: str, channel: str, on_messages: OnMessages):
|
||||
self.platform, self.channel, self.on_messages = platform, channel, on_messages
|
||||
self.status = "off"
|
||||
self.received = 0
|
||||
self.room_id: str | None = None # id numérico do canal na Twitch (para emotes 7TV/BTTV/FFZ)
|
||||
self._stop = threading.Event()
|
||||
self._thread: threading.Thread | None = None
|
||||
|
||||
def start(self) -> None:
|
||||
if self.platform == "youtube" or not self.channel:
|
||||
self.status = "unsupported"
|
||||
return
|
||||
target = {"twitch": self._run_twitch, "kick": self._run_kick}[self.platform]
|
||||
self._thread = threading.Thread(target=self._loop, args=(target,), name=f"chat-{self.channel}", daemon=True)
|
||||
self._thread.start()
|
||||
|
||||
def stop(self) -> None:
|
||||
self._stop.set()
|
||||
|
||||
def _loop(self, target: Callable[[], None]) -> None:
|
||||
delay = 2.0
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
self.status = "connecting"
|
||||
target()
|
||||
delay = 2.0
|
||||
except Exception as exc: # noqa: BLE001 - rede caiu: reconecta com espera crescente
|
||||
self.status = f"error: {type(exc).__name__}: {str(exc)[:120]}"
|
||||
log.warning("chat %s/%s: %s", self.platform, self.channel, self.status)
|
||||
self._stop.wait(delay)
|
||||
delay = min(60.0, delay * 2)
|
||||
self.status = "off"
|
||||
|
||||
def _deliver(self, batch: list[tuple[float, str, str]]) -> None:
|
||||
if batch:
|
||||
self.received += len(batch)
|
||||
self.on_messages(batch)
|
||||
|
||||
# ---------- Twitch (IRC) ----------
|
||||
def _run_twitch(self) -> None:
|
||||
context = ssl.create_default_context()
|
||||
with socket.create_connection(("irc.chat.twitch.tv", 6697), timeout=30) as raw:
|
||||
with context.wrap_socket(raw, server_hostname="irc.chat.twitch.tv") as sock:
|
||||
sock.settimeout(1.0)
|
||||
nick = f"justinfan{random.randint(10000, 99999)}"
|
||||
# Tags trazem os emotes nativos (com posição no texto) e o room-id do canal.
|
||||
sock.sendall(f"CAP REQ :twitch.tv/tags\r\nNICK {nick}\r\nJOIN #{self.channel}\r\n".encode())
|
||||
buffer, batch, last_flush, last_data = b"", [], time.monotonic(), time.monotonic()
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
chunk = sock.recv(65536)
|
||||
if not chunk:
|
||||
raise ConnectionError("conexão fechada pela Twitch")
|
||||
buffer += chunk
|
||||
last_data = time.monotonic()
|
||||
except TimeoutError:
|
||||
pass
|
||||
except socket.timeout:
|
||||
pass
|
||||
*lines, buffer = buffer.split(b"\r\n")
|
||||
for line in lines:
|
||||
text = line.decode("utf-8", errors="replace")
|
||||
if text.startswith("PING"):
|
||||
sock.sendall(("PONG" + text[4:] + "\r\n").encode())
|
||||
elif " 366 " in text or " JOIN #" in text:
|
||||
self.status = "connected"
|
||||
elif match := _PRIVMSG.match(text):
|
||||
tags, body = _parse_tags(match.group(1) or ""), match.group(3)
|
||||
self.room_id = self.room_id or tags.get("room-id")
|
||||
batch.append((time.time(), match.group(2), body[:300],
|
||||
parse_twitch_tag(tags.get("emotes", ""), body)))
|
||||
elif room := _ROOM_ID.search(text):
|
||||
self.room_id = self.room_id or room.group(1)
|
||||
if time.monotonic() - last_flush >= 1.0:
|
||||
self._deliver(batch)
|
||||
batch, last_flush = [], time.monotonic()
|
||||
if time.monotonic() - last_data > 360: # a Twitch manda PING a cada ~5 min
|
||||
raise ConnectionError("sem dados há 6 min")
|
||||
|
||||
# ---------- Kick (Pusher, não oficial) ----------
|
||||
def _run_kick(self) -> None:
|
||||
from websockets.sync.client import connect # import tardio: só quem usa Kick precisa
|
||||
|
||||
response = httpx.get(
|
||||
f"https://kick.com/api/v2/channels/{self.channel}",
|
||||
headers={"User-Agent": "Mozilla/5.0", "Accept": "application/json"},
|
||||
timeout=20,
|
||||
follow_redirects=True,
|
||||
)
|
||||
if response.status_code != 200:
|
||||
raise ConnectionError(f"kick.com respondeu {response.status_code} ao buscar a sala do chat")
|
||||
room = response.json()["chatroom"]["id"]
|
||||
with connect(KICK_PUSHER, open_timeout=20) as ws:
|
||||
ws.send(json.dumps({"event": "pusher:subscribe", "data": {"auth": "", "channel": f"chatrooms.{room}.v2"}}))
|
||||
batch, last_flush = [], time.monotonic()
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
raw = ws.recv(timeout=1.0)
|
||||
except TimeoutError:
|
||||
raw = None
|
||||
if raw:
|
||||
event = json.loads(raw)
|
||||
name = event.get("event", "")
|
||||
if name == "pusher_internal:subscription_succeeded":
|
||||
self.status = "connected"
|
||||
elif name == "pusher:ping":
|
||||
ws.send(json.dumps({"event": "pusher:pong", "data": {}}))
|
||||
elif name.endswith("ChatMessageEvent"):
|
||||
data = json.loads(event.get("data") or "{}")
|
||||
user = (data.get("sender") or {}).get("username", "")
|
||||
# Emotes da Kick chegam como [emote:123:NOME]: fica só o nome, que é o que carrega a reação.
|
||||
content = data.get("content", "")
|
||||
kick_emotes = re.findall(r"\[emote:\d+:([^\]]+)\]", content)
|
||||
text = re.sub(r"\[emote:\d+:([^\]]+)\]", r"\1", content)
|
||||
batch.append((time.time(), user, text[:300], kick_emotes))
|
||||
if time.monotonic() - last_flush >= 1.0:
|
||||
self._deliver(batch)
|
||||
batch, last_flush = [], time.monotonic()
|
||||
|
||||
|
||||
def _parse_tags(raw: str) -> dict[str, str]:
|
||||
"""`color=#F00;emotes=25:0-4;room-id=123` → dict. Só usamos ids e posições (sem desescapar valores)."""
|
||||
tags: dict[str, str] = {}
|
||||
for item in raw.split(";"):
|
||||
if "=" in item:
|
||||
key, value = item.split("=", 1)
|
||||
tags[key] = value
|
||||
return tags
|
||||
@@ -0,0 +1,268 @@
|
||||
"""Apagar cortes: um, vários ou todos de uma aba (rotas `DELETE /v1/clips/{id}` e `POST /v1/clips/delete`).
|
||||
|
||||
O que some com o corte: a linha em `clips`, o projeto de edição (`edits`) e os arquivos dele — vídeo, capa,
|
||||
miniatura e restos do render em `output/clipper/<sessão>/clip-<id>*`, a pasta do editor `edit-<id>/` (proxy,
|
||||
forma de onda, narração, prévias) e os quadros que o juiz viu (`<sessão>/frames/clip<id>-*.jpg`). Só apaga
|
||||
dentro das pastas do Clipador (`CLIPPER_OUTPUT_DIR` e `CLIPPER_DATA_DIR`): o caminho é resolvido antes, link
|
||||
ou junção nunca é seguido (some só o próprio link) e caminho de fora fica onde está, com o motivo na resposta.
|
||||
|
||||
Regras:
|
||||
- `candidate` (a IA está avaliando) e `rendering` (o FFmpeg está trabalhando) são recusados: o laço do motor
|
||||
escreveria num corte que não existe mais. Um `pending` que o motor acabou de pegar para renderizar também.
|
||||
- `published` só com `confirmPublished`: o vídeo já foi postado e a cópia local é o único registro dele aqui.
|
||||
- **O momento apagado não volta.** A regra anti-duplicado (`worker.find_new_clips`, varredura da IA) compara o
|
||||
candidato com os cortes existentes, inclusive descartados. Sem o corte, a passada seguinte de uma live em
|
||||
andamento (ou a passada final da sessão inteira) recriaria o mesmo momento. Por isso fica uma marca mínima em
|
||||
`deleted_clips` (migração v10): pico, trecho final e janela original do candidato. Ela entra na mesma conta
|
||||
dos cortes existentes e some junto com a sessão. Apagado que estava pronto, aprovado, rejeitado etc.
|
||||
(`worker.VETO_STATUSES`) também veta o trecho final depois do juiz ("Duplicado do corte N (que você apagou)");
|
||||
descartado pela IA não veta, como antes.
|
||||
- O aprendizado já feito (peso dos emotes, `clips.learned`) fica: ele mora na tabela `emotes`, não no corte.
|
||||
`judge.duplicateOf` de outros cortes é só texto informativo (nada no código lê esse id de volta).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from .config import REPO_ROOT
|
||||
from .db import loads, now
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.delete")
|
||||
|
||||
MAX_BATCH = 500 # mesmo teto da listagem (GET /v1/clips?limit=500), que é o que o painel mostra
|
||||
|
||||
# Estados em que o motor ainda está mexendo no corte: recusa com motivo (código, texto para o painel).
|
||||
BUSY = {
|
||||
"candidate": ("busy_candidate", "a IA está avaliando este corte"),
|
||||
"rendering": ("busy_rendering", "está renderizando"),
|
||||
}
|
||||
PUBLISHED = ("published", "está publicado: confirme para apagar a cópia local")
|
||||
NOT_FOUND = ("not_found", "corte não encontrado")
|
||||
CHANGED = ("changed", "mudou de estado agora há pouco; tente de novo")
|
||||
|
||||
|
||||
class DeleteRefused(Exception):
|
||||
def __init__(self, code: str, message: str, status: int = 409):
|
||||
super().__init__(message)
|
||||
self.code, self.message, self.status = code, message, status
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- marca do momento apagado
|
||||
def marks(db, session_id: int) -> list[dict]:
|
||||
"""Momentos apagados da sessão no mesmo formato das linhas de `clips` que o anti-duplicado lê (`id` = o do corte
|
||||
apagado, que nunca volta a ser usado; `status` = o estado em que ele foi apagado; `peak_s`, `start_s`, `end_s`;
|
||||
`reasons_json` com a janela original do candidato) e `deleted: True`."""
|
||||
out = []
|
||||
for r in db.all("SELECT * FROM deleted_clips WHERE session_id = ?", session_id):
|
||||
reasons = ({"candidateStartS": r["candidate_start_s"], "candidateEndS": r["candidate_end_s"]}
|
||||
if r["candidate_start_s"] is not None and r["candidate_end_s"] is not None else {})
|
||||
out.append({"id": r["clip_id"], "session_id": r["session_id"], "status": r["status"], "peak_s": r["peak_s"],
|
||||
"start_s": r["start_s"], "end_s": r["end_s"], "title": r["title"],
|
||||
"reasons_json": json.dumps(reasons), "deleted": True})
|
||||
return out
|
||||
|
||||
|
||||
def mark_spans(db, session_id: int, lo: float, hi: float) -> list[tuple[float, float, str]]:
|
||||
"""Trechos apagados que tocam [lo, hi], para a varredura da IA não propor o mesmo momento de novo."""
|
||||
spans = []
|
||||
for m in marks(db, session_id):
|
||||
reasons = loads(m["reasons_json"], {})
|
||||
a = min(m["start_s"], reasons.get("candidateStartS", m["start_s"]))
|
||||
b = max(m["end_s"], reasons.get("candidateEndS", m["end_s"]))
|
||||
if b > lo and a < hi:
|
||||
spans.append((a, b, "apagado"))
|
||||
return spans
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- arquivos do corte
|
||||
def _roots(engine) -> list[Path]:
|
||||
return [engine.settings.clips_dir.resolve(), engine.settings.data_dir.resolve()]
|
||||
|
||||
|
||||
def _inside(path: Path, roots: list[Path]) -> bool:
|
||||
try:
|
||||
resolved = path.resolve()
|
||||
except OSError:
|
||||
return False
|
||||
return any(resolved.is_relative_to(r) for r in roots)
|
||||
|
||||
|
||||
def _is_link(path: Path) -> bool:
|
||||
return path.is_symlink() or path.is_junction()
|
||||
|
||||
|
||||
def _rel(path: Path) -> str:
|
||||
try:
|
||||
return path.relative_to(REPO_ROOT).as_posix()
|
||||
except ValueError:
|
||||
return path.as_posix()
|
||||
|
||||
|
||||
def _unlink_link(path: Path) -> None:
|
||||
"""Remove só o link (símbolo ou junção), nunca o alvo."""
|
||||
try:
|
||||
os.unlink(path)
|
||||
except (IsADirectoryError, PermissionError):
|
||||
os.rmdir(path) # junção/link de pasta no Windows: rmdir tira o link e não toca no alvo
|
||||
|
||||
|
||||
def _remove_tree(folder: Path, removed: list[str], left: list[dict]) -> None:
|
||||
"""Apaga a pasta sem seguir link nem junção (o link some; o alvo fica)."""
|
||||
with os.scandir(folder) as entries:
|
||||
for entry in entries:
|
||||
path = Path(entry.path)
|
||||
try:
|
||||
if entry.is_symlink() or entry.is_junction():
|
||||
_unlink_link(path)
|
||||
elif entry.is_dir(follow_symlinks=False):
|
||||
_remove_tree(path, removed, left)
|
||||
continue
|
||||
else:
|
||||
path.unlink()
|
||||
removed.append(_rel(path))
|
||||
except OSError as exc:
|
||||
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
|
||||
try:
|
||||
folder.rmdir()
|
||||
except OSError as exc:
|
||||
left.append({"file": _rel(folder), "reason": f"pasta não ficou vazia ({exc.__class__.__name__})"})
|
||||
|
||||
|
||||
def clip_paths(engine, clip: dict, session: dict | None, cover: str | None) -> tuple[list[Path], list[Path]]:
|
||||
"""(arquivos, pastas) que pertencem ao corte. Caminhos do banco são relativos à raiz do repositório."""
|
||||
out_dir = engine.settings.clips_dir / str(clip["session_id"])
|
||||
cid = clip["id"]
|
||||
files: list[Path] = [REPO_ROOT / p for p in (clip.get("file"), clip.get("thumb"), cover) if p]
|
||||
if out_dir.is_dir():
|
||||
# vídeo, miniatura, capa (`-cover.jpg`) e restos do render (`.ass`, `.concat.txt`, `.tmp.mp4`, `.graph.txt`,
|
||||
# `.uniform.mkv`, máscaras das camadas). `clip-1.*`/`clip-1-*` não pegam o `clip-12`.
|
||||
files += sorted(out_dir.glob(f"clip-{cid}.*")) + sorted(out_dir.glob(f"clip-{cid}-*"))
|
||||
if session and session.get("dir"):
|
||||
frames = REPO_ROOT / session["dir"] / "frames"
|
||||
if frames.is_dir():
|
||||
files += sorted(frames.glob(f"clip{cid}-*.jpg")) # quadros que o analista/editor viram
|
||||
folders = [out_dir / f"edit-{cid}"] # editor: proxy, forma de onda, TTS, prévias
|
||||
return files, folders
|
||||
|
||||
|
||||
def remove_files(engine, files: list[Path], folders: list[Path]) -> tuple[list[str], list[dict]]:
|
||||
roots = _roots(engine)
|
||||
removed: list[str] = []
|
||||
left: list[dict] = []
|
||||
seen: set[str] = set()
|
||||
for path in files:
|
||||
key = os.path.normcase(os.path.abspath(path))
|
||||
if key in seen:
|
||||
continue
|
||||
seen.add(key)
|
||||
if not (path.exists() or _is_link(path)):
|
||||
continue
|
||||
try:
|
||||
if _is_link(path):
|
||||
# O link pode apontar para fora: some só ele, e só se ele mesmo estiver dentro das pastas.
|
||||
if not _inside(path.parent, roots):
|
||||
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
|
||||
continue
|
||||
_unlink_link(path)
|
||||
elif not _inside(path, roots):
|
||||
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
|
||||
continue
|
||||
elif path.is_file():
|
||||
path.unlink()
|
||||
else:
|
||||
continue
|
||||
removed.append(_rel(path))
|
||||
except OSError as exc:
|
||||
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
|
||||
for folder in folders:
|
||||
if _is_link(folder):
|
||||
if _inside(folder.parent, roots):
|
||||
_unlink_link(folder)
|
||||
removed.append(_rel(folder))
|
||||
else:
|
||||
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
|
||||
elif folder.is_dir():
|
||||
if _inside(folder, roots):
|
||||
_remove_tree(folder, removed, left)
|
||||
else:
|
||||
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
|
||||
return removed, left
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- apagar
|
||||
def delete_clip(engine, clip_id: int, confirm_published: bool = False) -> dict:
|
||||
"""Apaga um corte. Recusa com `DeleteRefused` (código + motivo). Devolve o que foi apagado."""
|
||||
db = engine.db
|
||||
# engine.lock: o motor marca `_rendering` sob o mesmo trinco (render_clip), então um corte não começa a
|
||||
# renderizar no meio da exclusão. db.lock: ler o estado e apagar sem outra thread escrever no meio.
|
||||
with engine.lock, db.lock:
|
||||
clip = db.get("SELECT * FROM clips WHERE id = ?", clip_id)
|
||||
if not clip:
|
||||
raise DeleteRefused(*NOT_FOUND, status=404)
|
||||
status = clip["status"]
|
||||
if status in BUSY:
|
||||
raise DeleteRefused(*BUSY[status])
|
||||
if clip_id in engine._rendering:
|
||||
raise DeleteRefused(*BUSY["rendering"])
|
||||
if status == "published" and not confirm_published:
|
||||
raise DeleteRefused(*PUBLISHED)
|
||||
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
|
||||
edit = db.get("SELECT cover FROM edits WHERE clip_id = ?", clip_id)
|
||||
reasons = loads(clip.get("reasons_json"), {})
|
||||
reasons = reasons if isinstance(reasons, dict) else {}
|
||||
|
||||
def number(key: str) -> float | None:
|
||||
try:
|
||||
return float(reasons[key])
|
||||
except (KeyError, TypeError, ValueError):
|
||||
return None
|
||||
|
||||
db.conn.execute("BEGIN")
|
||||
try:
|
||||
# A marca vem antes de apagar: o anti-duplicado nunca vê a sessão sem o corte e sem a marca.
|
||||
db.conn.execute(
|
||||
"INSERT OR REPLACE INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, candidate_start_s,"
|
||||
" candidate_end_s, status, source, title, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
(clip_id, clip["session_id"], clip["peak_s"], clip["start_s"], clip["end_s"], number("candidateStartS"),
|
||||
number("candidateEndS"), status, clip["source"], (clip["title"] or "")[:100], now()))
|
||||
db.conn.execute("DELETE FROM edits WHERE clip_id = ?", (clip_id,))
|
||||
gone = db.conn.execute("DELETE FROM clips WHERE id = ? AND status = ?", (clip_id, status)).rowcount
|
||||
if gone != 1:
|
||||
raise DeleteRefused(*CHANGED)
|
||||
db.conn.execute("COMMIT")
|
||||
except BaseException:
|
||||
db.conn.execute("ROLLBACK")
|
||||
raise
|
||||
# Arquivos fora do trinco (podem demorar); nada mais aponta para eles e o render não pega um id que sumiu.
|
||||
files, folders = clip_paths(engine, clip, session, edit["cover"] if edit else None)
|
||||
removed, left = remove_files(engine, files, folders)
|
||||
log.info("corte %s apagado (%s): %d arquivos, %d ficaram", clip_id, status, len(removed), len(left))
|
||||
return {"id": clip_id, "sessionId": clip["session_id"], "status": status, "removedFiles": len(removed),
|
||||
"left": left}
|
||||
|
||||
|
||||
def select_ids(db, session_id: int | None, statuses: list[str], limit: int = MAX_BATCH) -> tuple[list[int], int]:
|
||||
"""Ids dos cortes nesses estados (e nessa sessão, se vier), do mais novo para o mais velho, até `limit`.
|
||||
Devolve (ids, quantos ficaram de fora pelo limite)."""
|
||||
sql = "SELECT id FROM clips WHERE status IN (" + ",".join("?" * len(statuses)) + ")"
|
||||
params: list = list(statuses)
|
||||
if session_id is not None:
|
||||
sql += " AND session_id = ?"
|
||||
params.append(session_id)
|
||||
ids = [r["id"] for r in db.all(sql + " ORDER BY id DESC", *params)]
|
||||
return ids[:limit], max(0, len(ids) - limit)
|
||||
|
||||
|
||||
def delete_many(engine, ids: list[int], confirm_published: bool = False) -> dict:
|
||||
"""Apaga vários. Cada um passa pelas mesmas regras; o que não pôde vai em `failed` com o motivo."""
|
||||
deleted, failed = [], []
|
||||
for clip_id in dict.fromkeys(ids): # sem repetir, na ordem pedida
|
||||
try:
|
||||
deleted.append(delete_clip(engine, clip_id, confirm_published))
|
||||
except DeleteRefused as exc:
|
||||
failed.append({"id": clip_id, "code": exc.code, "reason": exc.message})
|
||||
return {"deleted": deleted, "failed": failed}
|
||||
@@ -0,0 +1,130 @@
|
||||
"""Configuração do Clipador, lida de clipper/.env (e do ambiente, que tem prioridade)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
CLIPPER_DIR = Path(__file__).resolve().parent.parent
|
||||
REPO_ROOT = CLIPPER_DIR.parent
|
||||
PORT_RANGE = (4500, 4599)
|
||||
|
||||
|
||||
class ConfigError(RuntimeError):
|
||||
"""Configuração inválida: o serviço não sobe."""
|
||||
|
||||
|
||||
def read_env_file(path: Path) -> dict[str, str]:
|
||||
if not path.is_file():
|
||||
return {}
|
||||
values: dict[str, str] = {}
|
||||
for line in path.read_text(encoding="utf-8").splitlines():
|
||||
if "=" not in line or line.lstrip().startswith("#"):
|
||||
continue
|
||||
name, value = line.split("=", 1)
|
||||
values[name.strip()] = value.strip()
|
||||
return values
|
||||
|
||||
|
||||
def _find_tool(env_name: str, names: list[str], extra_dirs: list[Path]) -> str | None:
|
||||
if os.environ.get(env_name):
|
||||
return os.environ[env_name]
|
||||
for directory in extra_dirs:
|
||||
for name in names:
|
||||
for ext in ("", ".exe"):
|
||||
candidate = directory / f"{name}{ext}"
|
||||
if candidate.is_file():
|
||||
return str(candidate)
|
||||
for name in names:
|
||||
found = shutil.which(name)
|
||||
if found:
|
||||
return found
|
||||
return None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Settings:
|
||||
service_key: str
|
||||
port: int
|
||||
segment_s: int
|
||||
poll_s: int
|
||||
keep_hours: float
|
||||
language: str
|
||||
encoder: str
|
||||
data_dir: Path
|
||||
clips_dir: Path
|
||||
ffmpeg: str | None
|
||||
ffprobe: str | None
|
||||
streamlink: str | None
|
||||
voice_url: str | None
|
||||
voice_key: str | None
|
||||
judge_provider: str
|
||||
judge_model: str
|
||||
judge_min_score: float
|
||||
|
||||
@staticmethod
|
||||
def load(env_file: Path | None = None, **overrides: object) -> "Settings":
|
||||
env = {**read_env_file(env_file or CLIPPER_DIR / ".env"), **os.environ}
|
||||
voice_env = read_env_file(REPO_ROOT / "voice" / ".env")
|
||||
|
||||
def num(name: str, default: float, minimum: float = 0) -> float:
|
||||
raw = env.get(name, "")
|
||||
try:
|
||||
value = float(raw) if raw else default
|
||||
except ValueError as exc:
|
||||
raise ConfigError(f"{name} precisa ser número") from exc
|
||||
if value < minimum:
|
||||
raise ConfigError(f"{name} precisa ser >= {minimum}")
|
||||
return value
|
||||
|
||||
port = int(num("CLIPPER_PORT", 4520, 1))
|
||||
if not PORT_RANGE[0] <= port <= PORT_RANGE[1]:
|
||||
raise ConfigError(f"CLIPPER_PORT={port} fora da faixa {PORT_RANGE[0]}–{PORT_RANGE[1]} do CenaForge")
|
||||
venv_scripts = CLIPPER_DIR / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
|
||||
|
||||
def repo_dir(name: str, default: Path) -> Path:
|
||||
"""Pasta opcional (CLIPPER_DATA_DIR/CLIPPER_OUTPUT_DIR) para isolar uma instância de teste. Precisa ficar
|
||||
dentro do repositório: blocos e cortes são gravados no banco com caminho relativo ao repo."""
|
||||
raw = env.get(name, "").strip()
|
||||
if not raw:
|
||||
return default
|
||||
path = Path(raw)
|
||||
path = (path if path.is_absolute() else REPO_ROOT / path).resolve()
|
||||
if not path.is_relative_to(REPO_ROOT.resolve()):
|
||||
raise ConfigError(f"{name} precisa ficar dentro do repositório ({REPO_ROOT})")
|
||||
return REPO_ROOT / path.relative_to(REPO_ROOT.resolve())
|
||||
|
||||
settings = Settings(
|
||||
service_key=env.get("CLIPPER_SERVICE_KEY", ""),
|
||||
port=port,
|
||||
# CLIPPER_QUALITY não é mais lida: a qualidade de gravação é `capture.quality` (canal/sessão, painel).
|
||||
segment_s=int(num("CLIPPER_SEGMENT_S", 30, 5)),
|
||||
poll_s=int(num("CLIPPER_POLL_S", 60, 15)),
|
||||
keep_hours=num("CLIPPER_KEEP_HOURS", 6, 0),
|
||||
language=env.get("CLIPPER_LANGUAGE", "pt-BR") or "pt-BR",
|
||||
encoder=env.get("CLIPPER_ENCODER", "auto") or "auto",
|
||||
data_dir=repo_dir("CLIPPER_DATA_DIR", REPO_ROOT / "data" / "clipper"),
|
||||
# output/ é servido pelo painel (/api/files): os cortes prontos ficam lá.
|
||||
clips_dir=repo_dir("CLIPPER_OUTPUT_DIR", REPO_ROOT / "output" / "clipper"),
|
||||
ffmpeg=_find_tool("FFMPEG_BIN", ["ffmpeg"], []),
|
||||
ffprobe=_find_tool("FFPROBE_BIN", ["ffprobe"], []),
|
||||
streamlink=_find_tool("STREAMLINK_BIN", ["streamlink"], [venv_scripts]),
|
||||
voice_url=f"http://127.0.0.1:{voice_env.get('VOICE_PORT') or '4510'}" if voice_env.get("VOICE_SERVICE_KEY") else None,
|
||||
voice_key=voice_env.get("VOICE_SERVICE_KEY") or None,
|
||||
# Valores iniciais do juiz; depois quem manda é o painel (tabela settings do banco do Clipador).
|
||||
judge_provider=(env.get("CLIPPER_JUDGE_PROVIDER") or "codex").lower(),
|
||||
judge_model=env.get("CLIPPER_JUDGE_MODEL", ""),
|
||||
judge_min_score=num("CLIPPER_JUDGE_MIN_SCORE", 6, 0),
|
||||
)
|
||||
if settings.judge_provider not in ("codex", "claude", "off"):
|
||||
raise ConfigError("CLIPPER_JUDGE_PROVIDER precisa ser codex, claude ou off")
|
||||
if settings.encoder not in ("auto", "libx264", "h264_nvenc"):
|
||||
raise ConfigError("CLIPPER_ENCODER precisa ser auto, libx264 ou h264_nvenc")
|
||||
if overrides:
|
||||
from dataclasses import replace
|
||||
|
||||
settings = replace(settings, **overrides) # type: ignore[arg-type]
|
||||
return settings
|
||||
@@ -0,0 +1,270 @@
|
||||
"""Estado do Clipador em data/clipper/clipper.db (SQLite). Canais monitorados, sessões de gravação, blocos
|
||||
gravados, chat e cortes. As contas (e o vínculo conta ↔ canal) ficam no banco do painel."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
SCHEMA = [
|
||||
"""
|
||||
CREATE TABLE channels (
|
||||
id TEXT PRIMARY KEY,
|
||||
platform TEXT NOT NULL CHECK (platform IN ('twitch', 'youtube', 'kick')),
|
||||
channel TEXT NOT NULL,
|
||||
url TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
monitor INTEGER NOT NULL DEFAULT 1,
|
||||
authorized INTEGER NOT NULL DEFAULT 0,
|
||||
threshold REAL,
|
||||
created_at TEXT NOT NULL,
|
||||
last_check_at TEXT,
|
||||
last_status TEXT NOT NULL DEFAULT ''
|
||||
);
|
||||
CREATE TABLE sessions (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
channel_id TEXT REFERENCES channels(id) ON DELETE SET NULL,
|
||||
platform TEXT NOT NULL,
|
||||
kind TEXT NOT NULL CHECK (kind IN ('live', 'vod')),
|
||||
url TEXT NOT NULL,
|
||||
title TEXT NOT NULL DEFAULT '',
|
||||
status TEXT NOT NULL CHECK (status IN ('starting', 'recording', 'processing', 'done', 'stopped', 'error', 'interrupted')),
|
||||
chat_status TEXT NOT NULL DEFAULT 'off',
|
||||
dir TEXT NOT NULL,
|
||||
duration_s REAL NOT NULL DEFAULT 0,
|
||||
started_at TEXT NOT NULL,
|
||||
ended_at TEXT,
|
||||
error TEXT
|
||||
);
|
||||
CREATE TABLE segments (
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
idx INTEGER NOT NULL,
|
||||
file TEXT NOT NULL,
|
||||
start_s REAL NOT NULL,
|
||||
end_s REAL NOT NULL,
|
||||
wall_end REAL NOT NULL,
|
||||
analyzed INTEGER NOT NULL DEFAULT 0,
|
||||
loudness_json TEXT,
|
||||
words_json TEXT,
|
||||
transcript_error TEXT,
|
||||
deleted INTEGER NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY (session_id, idx)
|
||||
);
|
||||
CREATE TABLE chat (
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
wall REAL NOT NULL,
|
||||
user TEXT NOT NULL,
|
||||
text TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX chat_session_wall ON chat (session_id, wall);
|
||||
CREATE TABLE clips (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
peak_s REAL NOT NULL,
|
||||
start_s REAL NOT NULL,
|
||||
end_s REAL NOT NULL,
|
||||
score REAL NOT NULL,
|
||||
source TEXT NOT NULL,
|
||||
reasons_json TEXT NOT NULL DEFAULT '{}',
|
||||
title TEXT NOT NULL DEFAULT '',
|
||||
caption TEXT NOT NULL DEFAULT '',
|
||||
transcript TEXT NOT NULL DEFAULT '',
|
||||
status TEXT NOT NULL CHECK (status IN ('candidate', 'discarded', 'pending', 'rendering', 'ready', 'approved', 'rejected', 'published', 'error')),
|
||||
judge_json TEXT,
|
||||
file TEXT,
|
||||
thumb TEXT,
|
||||
error TEXT,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
""",
|
||||
# v2: configurações trocadas pelo painel em tempo de execução (juiz: provedor, modelo, nota mínima).
|
||||
"""
|
||||
CREATE TABLE settings (
|
||||
key TEXT PRIMARY KEY,
|
||||
value TEXT NOT NULL
|
||||
);
|
||||
""",
|
||||
# v3: contexto do jogo, varredura da IA, emotes que aprendem e configuração do corte (layout/legenda).
|
||||
"""
|
||||
ALTER TABLE sessions ADD COLUMN game TEXT NOT NULL DEFAULT '';
|
||||
ALTER TABLE sessions ADD COLUMN game_source TEXT NOT NULL DEFAULT '';
|
||||
ALTER TABLE sessions ADD COLUMN screen_game TEXT NOT NULL DEFAULT '';
|
||||
ALTER TABLE sessions ADD COLUMN games_json TEXT NOT NULL DEFAULT '[]';
|
||||
ALTER TABLE sessions ADD COLUMN room_id TEXT;
|
||||
ALTER TABLE sessions ADD COLUMN settings_json TEXT;
|
||||
ALTER TABLE sessions ADD COLUMN scanned_until REAL NOT NULL DEFAULT 0;
|
||||
ALTER TABLE sessions ADD COLUMN memory_json TEXT NOT NULL DEFAULT '[]';
|
||||
ALTER TABLE sessions ADD COLUMN cam_json TEXT;
|
||||
ALTER TABLE clips ADD COLUMN learned INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE channels ADD COLUMN settings_json TEXT;
|
||||
ALTER TABLE chat ADD COLUMN emotes TEXT;
|
||||
CREATE TABLE games (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
status TEXT NOT NULL CHECK (status IN ('pending', 'ready', 'error')),
|
||||
profile_json TEXT,
|
||||
error TEXT,
|
||||
model TEXT,
|
||||
researched_at TEXT
|
||||
);
|
||||
CREATE TABLE emotes (
|
||||
channel_key TEXT NOT NULL,
|
||||
name TEXT NOT NULL,
|
||||
source TEXT NOT NULL,
|
||||
uses INTEGER NOT NULL DEFAULT 0,
|
||||
weight REAL NOT NULL DEFAULT 0,
|
||||
first_seen TEXT NOT NULL,
|
||||
last_seen TEXT NOT NULL,
|
||||
PRIMARY KEY (channel_key, name)
|
||||
);
|
||||
""",
|
||||
# v4: projeto do editor de cortes (JSON versionado por corte; `rev` sobe a cada gravação — autosave sem atropelar).
|
||||
"""
|
||||
CREATE TABLE edits (
|
||||
clip_id INTEGER PRIMARY KEY REFERENCES clips(id) ON DELETE CASCADE,
|
||||
project_json TEXT NOT NULL,
|
||||
rev INTEGER NOT NULL DEFAULT 1,
|
||||
cover TEXT,
|
||||
exported_at TEXT,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
""",
|
||||
# v5: rastreio de reação (face.py) — série por segundo do rosto do streamer, uma linha por bloco gravado.
|
||||
# status: done | no_cam | error. `data_json` = {cam, crop, fps, backend, seconds: [FaceSecond…]} (quadro inteiro).
|
||||
"""
|
||||
CREATE TABLE face_track (
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
idx INTEGER NOT NULL,
|
||||
status TEXT NOT NULL CHECK (status IN ('done', 'no_cam', 'error')),
|
||||
data_json TEXT,
|
||||
error TEXT,
|
||||
updated_at TEXT NOT NULL,
|
||||
PRIMARY KEY (session_id, idx)
|
||||
);
|
||||
""",
|
||||
# v6: perfil do jogo editável pelo painel. `notes_json` = pedidos que você fez à IA ([{text, at}]) — entram de
|
||||
# novo em toda pesquisa, para "Pesquisar de novo" não apagar o que você acrescentou; `edited_at` = última edição
|
||||
# à mão ou por pedido seu.
|
||||
"""
|
||||
ALTER TABLE games ADD COLUMN notes_json TEXT NOT NULL DEFAULT '[]';
|
||||
ALTER TABLE games ADD COLUMN edited_at TEXT;
|
||||
""",
|
||||
# v7: a IA entrega o projeto de edição pronto. `origin` = quem fez a versão atual (ai = pipeline; user = você
|
||||
# salvou no editor); `ai_project_json` guarda o que a IA gerou, para "voltar ao projeto da IA".
|
||||
"""
|
||||
ALTER TABLE edits ADD COLUMN origin TEXT NOT NULL DEFAULT 'ai' CHECK (origin IN ('ai', 'user'));
|
||||
ALTER TABLE edits ADD COLUMN ai_project_json TEXT;
|
||||
""",
|
||||
# v8: formato em que o corte foi renderizado (`format.aspect` da configuração efetiva no render): o painel
|
||||
# desenha o player na proporção certa. Cortes antigos foram todos verticais (1080×1920).
|
||||
"""
|
||||
ALTER TABLE clips ADD COLUMN aspect TEXT NOT NULL DEFAULT 'vertical' CHECK (aspect IN ('vertical', 'horizontal'));
|
||||
""",
|
||||
# v9: o que a captura gravou de fato (app/capture.py): qualidade pedida + resolução, qps, codec e taxa lidos do
|
||||
# 1º bloco de cada execução (início ou retomada). Sessões antigas ficam NULL (gravadas com o teto antigo de 720p).
|
||||
"""
|
||||
ALTER TABLE sessions ADD COLUMN capture_json TEXT;
|
||||
""",
|
||||
# v10: marca mínima de cada corte apagado (app/clip_delete.py): pico, trecho final e janela original do
|
||||
# candidato. A regra anti-duplicado conta com ela como se o corte ainda existisse, então apagar um descartado
|
||||
# não faz a IA recriar o mesmo momento na passada seguinte da live (nem na passada final da sessão).
|
||||
"""
|
||||
CREATE TABLE deleted_clips (
|
||||
clip_id INTEGER PRIMARY KEY,
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
peak_s REAL NOT NULL,
|
||||
start_s REAL NOT NULL,
|
||||
end_s REAL NOT NULL,
|
||||
candidate_start_s REAL,
|
||||
candidate_end_s REAL,
|
||||
status TEXT NOT NULL,
|
||||
source TEXT NOT NULL,
|
||||
title TEXT NOT NULL DEFAULT '',
|
||||
deleted_at TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX deleted_clips_session ON deleted_clips (session_id);
|
||||
""",
|
||||
]
|
||||
|
||||
|
||||
def now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat(timespec="seconds")
|
||||
|
||||
|
||||
class Database:
|
||||
def __init__(self, path: Path):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.lock = threading.RLock()
|
||||
self.conn = sqlite3.connect(path, check_same_thread=False, isolation_level=None)
|
||||
self.conn.row_factory = sqlite3.Row
|
||||
self.conn.executescript("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 3000;")
|
||||
self._migrate()
|
||||
# Sessões que estavam gravando quando o serviço caiu: a captura morreu junto. Ficam 'interrupted' e o motor
|
||||
# tenta retomar as lives sozinho na subida (Engine.start → resume_interrupted); quem estava só processando
|
||||
# volta a processar.
|
||||
self.interrupted_on_start = [r["id"] for r in self.all(
|
||||
"SELECT id FROM sessions WHERE status IN ('starting', 'recording') AND kind = 'live'")]
|
||||
self.run("UPDATE sessions SET status = 'interrupted', ended_at = ?, chat_status = 'off' WHERE status IN ('starting', 'recording')", now())
|
||||
# Antes as que estavam 'processing' também viravam 'interrupted' e paravam; processar não depende da captura.
|
||||
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado).
|
||||
self.run("UPDATE sessions SET chat_status = 'off' WHERE status NOT IN ('starting', 'recording') AND chat_status != 'off'")
|
||||
self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
|
||||
|
||||
def _migrate(self) -> None:
|
||||
version = self.conn.execute("PRAGMA user_version").fetchone()[0]
|
||||
for v in range(version, len(SCHEMA)):
|
||||
with self.lock:
|
||||
self.conn.execute("BEGIN")
|
||||
try:
|
||||
for statement in _split(SCHEMA[v]):
|
||||
self.conn.execute(statement)
|
||||
self.conn.execute(f"PRAGMA user_version = {v + 1}")
|
||||
self.conn.execute("COMMIT")
|
||||
except Exception:
|
||||
self.conn.execute("ROLLBACK")
|
||||
raise
|
||||
|
||||
def run(self, sql: str, *params: Any) -> sqlite3.Cursor:
|
||||
with self.lock:
|
||||
return self.conn.execute(sql, params)
|
||||
|
||||
def many(self, sql: str, rows: list[tuple]) -> None:
|
||||
with self.lock:
|
||||
self.conn.execute("BEGIN")
|
||||
try:
|
||||
self.conn.executemany(sql, rows)
|
||||
self.conn.execute("COMMIT")
|
||||
except Exception:
|
||||
self.conn.execute("ROLLBACK")
|
||||
raise
|
||||
|
||||
def all(self, sql: str, *params: Any) -> list[dict]:
|
||||
with self.lock:
|
||||
return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
|
||||
|
||||
def get(self, sql: str, *params: Any) -> dict | None:
|
||||
with self.lock:
|
||||
row = self.conn.execute(sql, params).fetchone()
|
||||
return dict(row) if row else None
|
||||
|
||||
def close(self) -> None:
|
||||
with self.lock:
|
||||
self.conn.close()
|
||||
|
||||
|
||||
def _split(script: str) -> list[str]:
|
||||
# executescript faria COMMIT implícito no meio da transação; executamos comando por comando.
|
||||
return [s.strip() for s in script.split(";") if s.strip()]
|
||||
|
||||
|
||||
def loads(raw: str | None, default: Any) -> Any:
|
||||
try:
|
||||
return json.loads(raw) if raw else default
|
||||
except json.JSONDecodeError:
|
||||
return default
|
||||
@@ -0,0 +1,728 @@
|
||||
"""Editor de cortes: o PROJETO DE EDIÇÃO de um corte (JSON versionado, tabela `edits`) e as contas de tempo.
|
||||
|
||||
Fonte da verdade do editor do painel (`/clipper/edit/<id>`). O servidor sabe renderizar o projeto com FFmpeg
|
||||
(`editor_render.py`). Ideias tiradas do OpenCut (MIT; só o padrão, nenhum código copiado): trilhas por papel
|
||||
(vídeo, legenda, textos, áudio), elementos com início/fim, desfazer por instantâneos e atalhos J/K/L/S.
|
||||
|
||||
Tempos:
|
||||
- **tempo da sessão** (`t` da gravação): `cuts`, palavras da legenda, textos, zooms, narração e capa. Assim,
|
||||
remover um pedaço do meio não desloca o que está ancorado no conteúdo (o zoom continua na reação);
|
||||
- **tempo de saída** (segundos do MP4): só o gancho (`kind: "hook"`), que vale a partir do 1º quadro.
|
||||
`to_output` converte; tudo que cai num trecho removido "gruda" no começo do próximo trecho mantido.
|
||||
|
||||
Validação forte (`validate_project`): nada do JSON vira comando de shell (FFmpeg recebe lista de argumentos e só
|
||||
números formatados no filtro), texto é escapado no ASS, arquivos de áudio só de pastas permitidas, limites de
|
||||
duração e de quantidade.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
from . import layout, reframe
|
||||
from .scoring import ChatMessage, Word, fit_window
|
||||
|
||||
SCHEMA_VERSION = 1
|
||||
MAX_WINDOW_S = 600.0 # janela da gravação que o editor carrega (proxy e forma de onda)
|
||||
MIN_OUTPUT_S, MAX_OUTPUT_S = 3.0, 180.0
|
||||
MIN_CUT_S = 0.2
|
||||
MAX_CUTS = 60
|
||||
MAX_WORDS = 4000
|
||||
MAX_OVERLAYS = 40
|
||||
MAX_NARRATION = 12
|
||||
MAX_SFX = 20
|
||||
CAPTION_PRESETS = ("classic", "pop", "karaoke", "single", "minimal")
|
||||
TEXT_ANIMS = layout.HOOK_ANIMS # pop, fade, none, slide (tarja/texto entram deslizando com desfoque)
|
||||
OVERLAY_KINDS = ("hook", "text", "zoom", "inset") # inset = recorte da tela em destaque
|
||||
AUDIO_EXT = (".mp3", ".wav", ".ogg", ".m4a", ".opus", ".flac")
|
||||
ID_RE = re.compile(r"^[A-Za-z0-9_-]{1,40}$")
|
||||
VOICE_RE = re.compile(r"^[a-z0-9][a-z0-9-]{1,47}$")
|
||||
TTS_FILE_RE = re.compile(r"^tts-[0-9a-f]{12}\.wav$")
|
||||
CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
|
||||
|
||||
# Padrão de cada preset de legenda (camada por cima do estilo do canal/sessão; o projeto ainda pode sobrescrever).
|
||||
PRESET_STYLE: dict[str, dict] = {
|
||||
"classic": {},
|
||||
"pop": {"maxWords": 3},
|
||||
"karaoke": {"maxWords": 4, "size": 76},
|
||||
"single": {"maxWords": 1, "size": 104},
|
||||
"minimal": {"uppercase": False, "size": 64, "outlineWidth": 4, "maxWords": 4},
|
||||
}
|
||||
PRESET_LABEL = {
|
||||
"classic": "Clássica (palavra falada em destaque)",
|
||||
"pop": "Pop (palavra falada cresce e volta)",
|
||||
"karaoke": "Karaokê (preenche palavra a palavra)",
|
||||
"single": "Uma palavra por vez (entra com escala)",
|
||||
"minimal": "Mínima (sem destaque, discreta)",
|
||||
}
|
||||
|
||||
|
||||
class EditError(ValueError):
|
||||
"""Projeto inválido ou pedido impossível: vira 400 com a mensagem para o usuário."""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- tempo
|
||||
@dataclass(frozen=True)
|
||||
class Piece:
|
||||
"""Trecho mantido: [start, end] da sessão que entra no MP4 a partir de `out` (tempo de saída)."""
|
||||
start: float
|
||||
end: float
|
||||
out: float
|
||||
mode: str | None = None
|
||||
muted: bool = False # trecho sem o som da live (a narração e a música continuam)
|
||||
|
||||
@property
|
||||
def length(self) -> float:
|
||||
return self.end - self.start
|
||||
|
||||
|
||||
def pieces(cuts: list[dict]) -> list[Piece]:
|
||||
out, acc = [], 0.0
|
||||
for cut in cuts:
|
||||
out.append(Piece(cut["start"], cut["end"], acc, cut.get("mode"), bool(cut.get("muted"))))
|
||||
acc += cut["end"] - cut["start"]
|
||||
return out
|
||||
|
||||
|
||||
def output_duration(cuts: list[dict]) -> float:
|
||||
return round(sum(c["end"] - c["start"] for c in cuts), 3)
|
||||
|
||||
|
||||
def to_output(t: float, cuts: list[dict]) -> tuple[float, bool]:
|
||||
"""Tempo da sessão → tempo de saída. Segundo valor: o instante está num trecho mantido?
|
||||
Num trecho removido (ou antes do 1º), cai no começo do próximo trecho mantido."""
|
||||
for p in pieces(cuts):
|
||||
if t < p.start:
|
||||
return round(p.out, 3), False
|
||||
if t <= p.end:
|
||||
return round(p.out + t - p.start, 3), True
|
||||
return output_duration(cuts), False
|
||||
|
||||
|
||||
def to_session(t_out: float, cuts: list[dict]) -> float:
|
||||
"""Tempo de saída → tempo da sessão."""
|
||||
ps = pieces(cuts)
|
||||
for p in ps:
|
||||
if t_out <= p.out + p.length:
|
||||
return round(p.start + max(0.0, t_out - p.out), 3)
|
||||
return ps[-1].end if ps else 0.0
|
||||
|
||||
|
||||
def slice_pieces(cuts: list[dict], a: float, b: float) -> list[Piece]:
|
||||
"""Trechos da sessão que formam a saída [a, b] (para a prévia real de poucos segundos)."""
|
||||
out = []
|
||||
for p in pieces(cuts):
|
||||
lo, hi = max(a, p.out), min(b, p.out + p.length)
|
||||
if hi - lo > 0.01:
|
||||
out.append(Piece(p.start + lo - p.out, p.start + hi - p.out, lo - a, p.mode, p.muted))
|
||||
return out
|
||||
|
||||
|
||||
def normalize_cuts(cuts: list[dict]) -> list[dict]:
|
||||
"""Ordena e junta trechos que se encostam/sobrepõem, se tiverem o mesmo layout e o mesmo "mudo"."""
|
||||
merged: list[dict] = []
|
||||
for cut in sorted(cuts, key=lambda c: c["start"]):
|
||||
same = merged and cut.get("mode") == merged[-1].get("mode") and bool(cut.get("muted")) == bool(merged[-1].get("muted"))
|
||||
if same and cut["start"] <= merged[-1]["end"] + 0.02:
|
||||
merged[-1]["end"] = max(merged[-1]["end"], cut["end"])
|
||||
else:
|
||||
merged.append(dict(cut))
|
||||
return merged
|
||||
|
||||
|
||||
def output_words(project: dict) -> list[Word]:
|
||||
"""Palavras visíveis da legenda em tempo de saída (palavra cujo meio caiu num trecho removido some)."""
|
||||
cuts = project["cuts"]
|
||||
out = []
|
||||
for w in project["captions"]["words"]:
|
||||
if w.get("hidden") or not w["w"].strip():
|
||||
continue
|
||||
mid = (w["s"] + w["e"]) / 2
|
||||
t, inside = to_output(mid, cuts)
|
||||
if not inside:
|
||||
continue
|
||||
for p in pieces(cuts):
|
||||
if p.start <= mid <= p.end:
|
||||
s = p.out + max(w["s"], p.start) - p.start
|
||||
e = p.out + min(w["e"], p.end) - p.start
|
||||
out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"]))
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
def emphasized(project: dict) -> set[tuple[float, str]]:
|
||||
return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- projeto
|
||||
def default_window(clip: dict, session_duration: float) -> tuple[float, float]:
|
||||
"""Janela inicial: 45 s antes e 20 s depois do corte (dá para voltar o começo sem gerar outra prévia)."""
|
||||
lo = max(0.0, clip["start_s"] - 45)
|
||||
hi = min(session_duration, clip["end_s"] + 20) if session_duration > 0 else clip["end_s"] + 20
|
||||
return round(lo, 3), round(max(hi, clip["end_s"]), 3)
|
||||
|
||||
|
||||
_SESSION_TIME_RE = re.compile(r"\b(?:aos|ao|em|no)\s+\d{2,}\s*s\b\s*[,:;—-]?\s*", re.IGNORECASE)
|
||||
|
||||
|
||||
def pick_hook(raw: str | None, title: str | None) -> tuple[str, bool]:
|
||||
"""Texto do gancho na tela. O do analista só serve se for curto e sem tempo da gravação (ele às vezes devolve
|
||||
uma frase descritiva como "Aos 5085s, ele solta que…", que saía cortada no meio — medido no corte 25 do skipnho);
|
||||
senão vale o título do editor, que já é escrito como gancho. Nunca corta no meio de uma palavra.
|
||||
Devolve (texto, veio_do_analista)."""
|
||||
raw = (raw or "").strip()
|
||||
short = bool(raw) and len(raw.split()) <= 8 and len(raw) <= 48 and not re.search(r"\d{3,}\s*s\b", raw)
|
||||
text = _SESSION_TIME_RE.sub("", raw if short else (title or raw or "")).strip()
|
||||
if text:
|
||||
text = text[0].upper() + text[1:]
|
||||
if len(text) > 60:
|
||||
text = text[:60].rsplit(" ", 1)[0].rstrip(" ,;:—-")
|
||||
return text, short
|
||||
|
||||
|
||||
def default_project(clip: dict, words: list[Word], session_duration: float) -> dict:
|
||||
lo, hi = default_window(clip, session_duration)
|
||||
analysis = ((clip.get("judge") or {}) if isinstance(clip.get("judge"), dict) else {}).get("analysis") or {}
|
||||
hook, _ = pick_hook(analysis.get("hook"), clip.get("title"))
|
||||
return {
|
||||
"schema": SCHEMA_VERSION,
|
||||
"source": {"sessionId": clip["session_id"], "lo": lo, "hi": hi},
|
||||
"settings": {},
|
||||
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
|
||||
"captions": {
|
||||
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
|
||||
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in words if lo <= w.start <= hi][:MAX_WORDS],
|
||||
},
|
||||
"overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68,
|
||||
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
|
||||
"progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
|
||||
"audio": {"volume": 1.0, "narration": [], "music": None, "sfx": []},
|
||||
"cover": {"enabled": True, "t": round(clip.get("peak_s") or clip["start_s"], 3), "text": hook[:40]},
|
||||
}
|
||||
|
||||
|
||||
QUIET_DB = -38.0 # silêncio "de verdade": nem fala nem som do jogo (dBFS por segundo, volume medido no bloco)
|
||||
AUTO_GAP_S = 2.0 # vão sem fala a partir do qual a IA corta (se também estiver quieto)
|
||||
|
||||
|
||||
def auto_project(clip: dict, analysis: dict | None, words: list[Word], loudness: list[float | None],
|
||||
session_duration: float, cfg: dict, *, model: str = "", generated_at: str = "") -> dict:
|
||||
"""Projeto que a IA entrega pronto (o render automático usa ESTE projeto, o mesmo que o editor abre):
|
||||
trecho pela análise (início da ação, fim da reação) encaixado nas palavras, silêncios longos E quietos
|
||||
removidos (longe do pico), legenda do Whisper no estilo do corte (preset pop), gancho do analista nos
|
||||
primeiros segundos, punch-in no pico e capa no pico. `loudness` = dBFS por segundo da sessão (índice = s)."""
|
||||
p = default_project(clip, words, session_duration)
|
||||
lo, hi = p["source"]["lo"], p["source"]["hi"]
|
||||
dur = {**layout.DEFAULTS["duration"], **(cfg.get("duration") or {})}
|
||||
max_s = float(dur["maxS"])
|
||||
# Corte automático: duração FINAL (depois de silêncios e aparos) ≥ mínimo + 1 s. "Cortar agora" é livre.
|
||||
manual = clip.get("source") == "manual"
|
||||
min_s = 0.0 if manual else layout.min_target({"duration": dur})
|
||||
steps: list[str] = []
|
||||
start, end = float(clip["start_s"]), float(clip["end_s"])
|
||||
a = analysis or {}
|
||||
try:
|
||||
act, react = float(a.get("action_start_s")), float(a.get("reaction_end_s"))
|
||||
except (TypeError, ValueError):
|
||||
act = react = None # type: ignore[assignment]
|
||||
# Início no começo da ação. Medido (sessão 3, cortes 43, 44, 55, 58, 61): quando o analista punha a ação DEPOIS do
|
||||
# início do juiz, o corte encolhia para 44–58 s com mínimo 60. Adiantar o início só vale se o mínimo continua.
|
||||
if (act is not None and lo <= act < end - 5 and act >= start - 15 and abs(act - start) > 0.5
|
||||
and end - max(lo, act - 0.8) >= min_s):
|
||||
start = max(lo, act - 0.8)
|
||||
steps.append(f"início no começo da ação ({act:.0f}s, analista)")
|
||||
if react is not None and end < react <= min(hi, end + 8):
|
||||
end = min(hi, react + 0.8)
|
||||
steps.append(f"fim depois da reação ({react:.0f}s, analista)")
|
||||
inside = sorted((w for w in words if lo <= w.start <= hi and w.word.strip()), key=lambda w: w.start)
|
||||
for w in inside: # nunca corta no meio da palavra
|
||||
if w.start < start < w.end:
|
||||
start = max(lo, w.start - 0.1)
|
||||
if w.start < end < w.end:
|
||||
end = min(hi, w.end + 0.15)
|
||||
if end - start > max_s:
|
||||
end = start + max_s
|
||||
steps.append(f"limitado a {max_s:.0f} s")
|
||||
if end - start < min_s:
|
||||
# Falta material: cresce para trás (contexto; é onde o gancho fica) e, no começo da gravação, para a frente.
|
||||
before = end - start
|
||||
start, end = fit_window(start, end, lo, hi, min_s, max_s, keep="start")
|
||||
for w in inside: # o início novo também não corta palavra (só recua)
|
||||
if w.start < start < w.end and end - (w.start - 0.1) <= max_s:
|
||||
start = max(lo, w.start - 0.1)
|
||||
steps.append(f"estendido de {before:.1f} s para {end - start:.1f} s (mínimo {min_s:.1f} s)")
|
||||
if end - start < min_s - 0.01:
|
||||
steps.append(f"curto: só havia {end - start:.1f} s de gravação em volta do momento (mínimo {min_s:.1f} s)")
|
||||
cuts = [{"start": round(start, 3), "end": round(end, 3), "mode": None}]
|
||||
peak = float(clip.get("peak_s") or (start + end) / 2)
|
||||
|
||||
def quiet(x: float, y: float) -> bool:
|
||||
values = loudness[int(x): int(y) + 1]
|
||||
return bool(values) and all(v is None or v < QUIET_DB for v in values)
|
||||
|
||||
removed = 0.0
|
||||
spoken = [w for w in inside if start <= w.start <= end]
|
||||
for w1, w2 in zip(spoken, spoken[1:]):
|
||||
x, y = w1.end + 0.25, w2.start - 0.25
|
||||
if w2.start - w1.end < AUTO_GAP_S or y - x < 0.5 or x - 3 <= peak <= y + 3 or not quiet(x, y):
|
||||
continue
|
||||
if output_duration(cuts) - (y - x) < min_s: # o corte final nunca fica abaixo do mínimo + 1 s
|
||||
break
|
||||
out, kept = [], cuts
|
||||
for c in kept:
|
||||
if y <= c["start"] or x >= c["end"]:
|
||||
out.append(c)
|
||||
continue
|
||||
if x > c["start"]:
|
||||
out.append({**c, "end": round(x, 3)})
|
||||
if y < c["end"]:
|
||||
out.append({**c, "start": round(y, 3)})
|
||||
cuts = normalize_cuts(out)
|
||||
removed += y - x
|
||||
if removed:
|
||||
steps.append(f"{removed:.1f} s de silêncio removidos")
|
||||
p["cuts"] = cuts
|
||||
p["captions"]["preset"] = "pop"
|
||||
steps.append(f"legenda do Whisper ({len(spoken)} palavras, estilo pop)")
|
||||
|
||||
# Gancho: o do analista só se for curto (às vezes ele devolve uma frase descritiva — medido no corte 10 do
|
||||
# skipnho); senão o título do editor, que já é escrito como gancho.
|
||||
hook, short = pick_hook(a.get("hook"), clip.get("title"))
|
||||
p["overlays"] = []
|
||||
if hook:
|
||||
# Estilo do gancho pela configuração do corte (grupo `hook`; padrão: tarja verde-limão que entra deslizando).
|
||||
# Ele cobre o começo do corte — o segundo a mais do mínimo é justamente essa abertura (não há tela parada).
|
||||
hk = {**layout.DEFAULTS["hook"], **(cfg.get("hook") or {})}
|
||||
overlay = {"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": round(float(hk["seconds"]), 3),
|
||||
"y": 0.2, "size": 68, "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
|
||||
if hk["style"] == "banner":
|
||||
overlay |= {"style": "banner", "bg": hk["bg"], "color": hk["color"], "font": hk["font"], "anim": hk["anim"],
|
||||
"box": None, "size": 76}
|
||||
# A tarja (até ~0,13 da altura no vertical) não pode cobrir a legenda automática: se a legenda estiver
|
||||
# perto de 20 % da altura (câmera em cima com painel baixo, ou y escolhido), a tarja vai para o outro lado.
|
||||
cap_y = layout.caption_y(cfg) / layout.canvas_size(cfg)[1]
|
||||
if abs(cap_y - overlay["y"]) < 0.2:
|
||||
overlay["y"] = round(cap_y - 0.22 if cap_y > 0.3 else min(0.85, cap_y + 0.22), 3)
|
||||
else:
|
||||
overlay |= {"color": hk["color"], "font": hk["font"], "anim": hk["anim"]}
|
||||
p["overlays"].append(overlay)
|
||||
steps.append(("gancho do analista" if short else "gancho = título do editor") + f" ({hk['style']})")
|
||||
t_out, kept_peak = to_output(peak, cuts)
|
||||
if kept_peak and t_out >= 1.5:
|
||||
cut = next(c for c in cuts if c["start"] <= peak <= c["end"])
|
||||
z_end = min(cut["end"], peak + 2.0)
|
||||
if z_end - peak >= 0.8:
|
||||
cam = layout.resolved_mode(cfg) == "cam_top"
|
||||
# Câmera em cima: aproxima do rosto (centro do painel da câmera); senão, o centro da tela.
|
||||
fy = round(cfg["layout"]["camHeight"] / 2, 3) if cam else 0.45
|
||||
p["overlays"].append({"id": "zoom-peak", "kind": "zoom", "start": round(max(cut["start"], peak - 0.2), 3),
|
||||
"end": round(z_end, 3), "scale": 1.25, "x": 0.5, "y": fy, "ramp": 0.15})
|
||||
steps.append(f"zoom no pico ({peak:.0f}s)")
|
||||
p["cover"] = {"enabled": True, "t": round(min(max(peak, lo), hi), 3), "text": hook[:40]}
|
||||
p["meta"] = {"origin": "ai", "generatedAt": generated_at, "model": model or "", "steps": steps[:12]}
|
||||
return p
|
||||
|
||||
|
||||
def _num(value, name: str, lo: float, hi: float) -> float:
|
||||
try:
|
||||
v = float(value)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise EditError(f"{name} precisa ser número") from exc
|
||||
if v != v or not lo <= v <= hi: # NaN ou fora da faixa
|
||||
raise EditError(f"{name} vai de {lo:g} a {hi:g}")
|
||||
return round(v, 3)
|
||||
|
||||
|
||||
def _text(value, name: str, max_len: int, allow_empty: bool = True) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise EditError(f"{name} precisa ser texto")
|
||||
text = CONTROL_RE.sub(" ", value).replace("\r", "").strip()
|
||||
if len(text) > max_len:
|
||||
raise EditError(f"{name} passa de {max_len} caracteres")
|
||||
if not text and not allow_empty:
|
||||
raise EditError(f"{name} está vazio")
|
||||
return text
|
||||
|
||||
|
||||
def _hex(value, name: str) -> str:
|
||||
if not isinstance(value, str) or not layout.HEX_RE.match(value):
|
||||
raise EditError(f"{name} precisa ser cor #RRGGBB")
|
||||
return value.upper()
|
||||
|
||||
|
||||
def _list(value, name: str, limit: int) -> list:
|
||||
if value is None:
|
||||
return []
|
||||
if not isinstance(value, list):
|
||||
raise EditError(f"{name} precisa ser lista")
|
||||
if len(value) > limit:
|
||||
raise EditError(f"{name}: no máximo {limit}")
|
||||
return value
|
||||
|
||||
|
||||
def _id(value, name: str) -> str:
|
||||
if not isinstance(value, str) or not ID_RE.match(value):
|
||||
raise EditError(f"{name} precisa ser um id curto (letras, números, - e _)")
|
||||
return value
|
||||
|
||||
|
||||
def safe_audio_file(value, roots: list[Path], repo_root: Path, name: str) -> str:
|
||||
"""Arquivo de áudio relativo ao repositório, dentro de uma das pastas permitidas e existente."""
|
||||
if not isinstance(value, str) or not value or "\\" in value or value.startswith("/") or ".." in value.split("/"):
|
||||
raise EditError(f"{name}: caminho inválido")
|
||||
full = (repo_root / value).resolve()
|
||||
if full.suffix.lower() not in AUDIO_EXT:
|
||||
raise EditError(f"{name}: só áudio ({', '.join(AUDIO_EXT)})")
|
||||
if not any(full.is_relative_to(r.resolve()) for r in roots):
|
||||
raise EditError(f"{name}: arquivo fora das pastas permitidas")
|
||||
if not full.is_file():
|
||||
raise EditError(f"{name}: arquivo não encontrado")
|
||||
return value
|
||||
|
||||
|
||||
def validate_project(data: dict, *, session_id: int, session_duration: float, repo_root: Path,
|
||||
tts_dir: Path, assets_dir: Path) -> dict:
|
||||
"""Valida e normaliza o projeto inteiro. Levanta EditError com a 1ª falha (mensagem em português)."""
|
||||
if not isinstance(data, dict):
|
||||
raise EditError("projeto precisa ser um objeto")
|
||||
if data.get("schema") != SCHEMA_VERSION:
|
||||
raise EditError(f"versão do projeto não suportada (esperado schema {SCHEMA_VERSION})")
|
||||
src = data.get("source") or {}
|
||||
if src.get("sessionId") != session_id:
|
||||
raise EditError("o projeto é de outra sessão")
|
||||
limit = session_duration if session_duration > 0 else 1e9
|
||||
lo = _num(src.get("lo"), "source.lo", 0, limit)
|
||||
hi = _num(src.get("hi"), "source.hi", 0, limit)
|
||||
if not 5 <= hi - lo <= MAX_WINDOW_S:
|
||||
raise EditError(f"a janela da gravação precisa ter de 5 s a {MAX_WINDOW_S / 60:.0f} min")
|
||||
|
||||
# Configuração do corte própria do projeto (mesma validação da configuração de canal/sessão).
|
||||
try:
|
||||
own_settings = layout.validate(data.get("settings") or {})
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise EditError(f"configuração do corte: {exc}") from exc
|
||||
|
||||
raw_cuts = _list(data.get("cuts"), "cuts", MAX_CUTS)
|
||||
if not raw_cuts:
|
||||
raise EditError("o corte precisa de pelo menos um trecho")
|
||||
cuts = []
|
||||
for i, c in enumerate(raw_cuts):
|
||||
if not isinstance(c, dict):
|
||||
raise EditError(f"cuts[{i}] precisa ser objeto")
|
||||
start, end = _num(c.get("start"), f"cuts[{i}].start", lo, hi), _num(c.get("end"), f"cuts[{i}].end", lo, hi)
|
||||
if end - start < MIN_CUT_S:
|
||||
raise EditError(f"cuts[{i}] precisa ter pelo menos {MIN_CUT_S:g} s")
|
||||
mode = c.get("mode")
|
||||
if mode is not None and mode not in layout.MODES:
|
||||
raise EditError(f"cuts[{i}].mode precisa ser um de {', '.join(layout.MODES)} ou null")
|
||||
cuts.append({"start": start, "end": end, "mode": mode, "muted": bool(c.get("muted", False))})
|
||||
cuts = normalize_cuts(cuts)
|
||||
total = output_duration(cuts)
|
||||
if not MIN_OUTPUT_S <= total <= MAX_OUTPUT_S:
|
||||
raise EditError(f"o corte editado precisa ter de {MIN_OUTPUT_S:g} a {MAX_OUTPUT_S:g} s (tem {total:.1f} s)")
|
||||
|
||||
cap = data.get("captions") or {}
|
||||
preset = cap.get("preset", "classic")
|
||||
if preset not in CAPTION_PRESETS:
|
||||
raise EditError(f"captions.preset precisa ser um de {', '.join(CAPTION_PRESETS)}")
|
||||
try:
|
||||
style = layout.validate({"caption": cap.get("style") or {}}).get("caption", {})
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise EditError(f"estilo da legenda: {exc}") from exc
|
||||
words = []
|
||||
for i, w in enumerate(_list(cap.get("words"), "captions.words", MAX_WORDS)):
|
||||
if not isinstance(w, dict):
|
||||
raise EditError(f"captions.words[{i}] precisa ser objeto")
|
||||
s, e = _num(w.get("s"), f"palavra {i} (início)", 0, limit), _num(w.get("e"), f"palavra {i} (fim)", 0, limit)
|
||||
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms
|
||||
e = round(s + 0.05, 3)
|
||||
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
|
||||
if w.get("emph"):
|
||||
item["emph"] = True
|
||||
if w.get("hidden"):
|
||||
item["hidden"] = True
|
||||
words.append(item)
|
||||
words.sort(key=lambda w: w["s"])
|
||||
captions = {"enabled": bool(cap.get("enabled", True)), "preset": preset, "style": style,
|
||||
"emphColor": _hex(cap.get("emphColor", "#22E36B"), "captions.emphColor"), "words": words}
|
||||
|
||||
overlays, seen = [], set()
|
||||
for i, o in enumerate(_list(data.get("overlays"), "overlays", MAX_OVERLAYS)):
|
||||
if not isinstance(o, dict) or o.get("kind") not in OVERLAY_KINDS:
|
||||
raise EditError(f"overlays[{i}].kind precisa ser um de {', '.join(OVERLAY_KINDS)}")
|
||||
oid = _id(o.get("id"), f"overlays[{i}].id")
|
||||
if oid in seen:
|
||||
raise EditError(f"overlays: id repetido ({oid})")
|
||||
seen.add(oid)
|
||||
kind = o["kind"]
|
||||
if kind == "hook": # tempo de saída
|
||||
start, end = _num(o.get("start", 0), "gancho: início", 0, MAX_OUTPUT_S), _num(o.get("end"), "gancho: fim", 0, MAX_OUTPUT_S)
|
||||
else: # tempo da sessão
|
||||
start, end = _num(o.get("start"), f"overlays[{i}].start", lo, hi), _num(o.get("end"), f"overlays[{i}].end", lo, hi)
|
||||
if end - start < 0.2:
|
||||
raise EditError(f"overlays[{i}] precisa durar pelo menos 0,2 s")
|
||||
item = {"id": oid, "kind": kind, "start": start, "end": end}
|
||||
if kind == "inset":
|
||||
item |= _inset(o, i, lo, hi)
|
||||
elif kind == "zoom":
|
||||
item |= {"scale": _num(o.get("scale", 1.3), "zoom: escala", 1.05, 2.5),
|
||||
"x": _num(o.get("x", 0.5), "zoom: x", 0, 1), "y": _num(o.get("y", 0.5), "zoom: y", 0, 1),
|
||||
"ramp": _num(o.get("ramp", 0.25), "zoom: rampa", 0, 1.5)}
|
||||
else:
|
||||
box = o.get("box")
|
||||
style = o.get("style", "plain")
|
||||
if style not in layout.HOOK_STYLES:
|
||||
raise EditError(f"overlays[{i}].style precisa ser um de {', '.join(layout.HOOK_STYLES)}")
|
||||
font = o.get("font")
|
||||
if font is not None and font not in layout.FONTS:
|
||||
raise EditError(f"overlays[{i}].font precisa ser uma de {', '.join(layout.FONTS)}")
|
||||
bg = o.get("bg")
|
||||
# Campos novos só entram no projeto quando usados: projeto antigo continua byte a byte igual.
|
||||
if style != "plain":
|
||||
item["style"] = style
|
||||
if font is not None:
|
||||
item["font"] = font
|
||||
if bg not in (None, ""):
|
||||
item["bg"] = _hex(bg, f"overlays[{i}].bg")
|
||||
item |= {"text": _text(o.get("text", ""), f"overlays[{i}].text", 120, allow_empty=False),
|
||||
"x": _num(o.get("x", 0.5), f"overlays[{i}].x", 0.05, 0.95),
|
||||
"y": _num(o.get("y", 0.2), f"overlays[{i}].y", 0.04, 0.96),
|
||||
"size": int(_num(o.get("size", 64), f"overlays[{i}].size", 24, 180)),
|
||||
"color": _hex(o.get("color", "#FFFFFF"), f"overlays[{i}].color"),
|
||||
"box": None if box in (None, "") else _hex(box, f"overlays[{i}].box"),
|
||||
"anim": o.get("anim", "pop")}
|
||||
if item["anim"] not in TEXT_ANIMS:
|
||||
raise EditError(f"overlays[{i}].anim precisa ser um de {', '.join(TEXT_ANIMS)}")
|
||||
overlays.append(item)
|
||||
if sum(1 for o in overlays if o["kind"] == "inset") > reframe.MAX_INSETS:
|
||||
raise EditError(f"no máximo {reframe.MAX_INSETS} camadas inseridas")
|
||||
zooms = sorted((o for o in overlays if o["kind"] == "zoom"), key=lambda o: o["start"])
|
||||
for a, b in zip(zooms, zooms[1:]):
|
||||
if b["start"] < a["end"]:
|
||||
raise EditError("dois zooms ao mesmo tempo: separe os trechos de zoom")
|
||||
|
||||
prog = data.get("progress") or {}
|
||||
progress = {"enabled": bool(prog.get("enabled", False)), "color": _hex(prog.get("color", "#FF7A1A"), "progress.color"),
|
||||
"height": int(_num(prog.get("height", 12), "progress.height", 4, 40))}
|
||||
|
||||
aud = data.get("audio") or {}
|
||||
narration = []
|
||||
for i, n in enumerate(_list(aud.get("narration"), "audio.narration", MAX_NARRATION)):
|
||||
if not isinstance(n, dict):
|
||||
raise EditError(f"audio.narration[{i}] precisa ser objeto")
|
||||
file = safe_audio_file(n.get("file"), [tts_dir], repo_root, f"narração {i + 1}")
|
||||
if not TTS_FILE_RE.match(Path(file).name):
|
||||
raise EditError(f"narração {i + 1}: arquivo precisa ser gerado pelo editor (tts-*.wav)")
|
||||
voice = n.get("voice", "")
|
||||
if voice and not VOICE_RE.match(str(voice)):
|
||||
raise EditError(f"narração {i + 1}: voz inválida")
|
||||
narration.append({"id": _id(n.get("id"), f"narração {i + 1}"), "file": file,
|
||||
"at": _num(n.get("at"), f"narração {i + 1}: instante", lo, hi),
|
||||
"volume": _num(n.get("volume", 1.0), f"narração {i + 1}: volume", 0, 2),
|
||||
"durationS": _num(n.get("durationS", 0), f"narração {i + 1}: duração", 0, 120),
|
||||
"duck": _num(n.get("duck", 0.35), f"narração {i + 1}: volume do original por baixo", 0, 1),
|
||||
"text": _text(n.get("text", ""), f"narração {i + 1}: texto", 300), "voice": str(voice)})
|
||||
music = None
|
||||
if aud.get("music"):
|
||||
m = aud["music"]
|
||||
if not isinstance(m, dict):
|
||||
raise EditError("audio.music precisa ser objeto ou null")
|
||||
music = {"file": safe_audio_file(m.get("file"), [assets_dir], repo_root, "música"),
|
||||
"volume": _num(m.get("volume", 0.18), "música: volume", 0, 1), "duck": bool(m.get("duck", True))}
|
||||
sfx = []
|
||||
for i, x in enumerate(_list(aud.get("sfx"), "audio.sfx", MAX_SFX)):
|
||||
if not isinstance(x, dict):
|
||||
raise EditError(f"audio.sfx[{i}] precisa ser objeto")
|
||||
sfx.append({"id": _id(x.get("id"), f"efeito {i + 1}"), "file": safe_audio_file(x.get("file"), [assets_dir], repo_root, f"efeito {i + 1}"),
|
||||
"at": _num(x.get("at"), f"efeito {i + 1}: instante", lo, hi),
|
||||
"volume": _num(x.get("volume", 0.8), f"efeito {i + 1}: volume", 0, 2)})
|
||||
audio = {"volume": _num(aud.get("volume", 1.0), "audio.volume", 0, 2), "narration": narration, "music": music, "sfx": sfx}
|
||||
|
||||
cov = data.get("cover") or {}
|
||||
cover = {"enabled": bool(cov.get("enabled", True)), "t": _num(cov.get("t", cuts[0]["start"]), "capa: instante", lo, hi),
|
||||
"text": _text(cov.get("text", ""), "capa: texto", 60),
|
||||
# Capa também nos 2 primeiros quadros do vídeo: as redes usam o quadro 0 como miniatura padrão.
|
||||
"atStart": bool(cov.get("atStart", False))}
|
||||
|
||||
# Chat da live na tela: as últimas mensagens num bloco, na posição escolhida (x = borda esquerda, y = base).
|
||||
ch = data.get("chat") or {}
|
||||
if not isinstance(ch, dict):
|
||||
raise EditError("chat precisa ser objeto")
|
||||
chat = {"enabled": bool(ch.get("enabled", False)),
|
||||
"x": _num(ch.get("x", 0.04), "chat: x", 0, 0.9), "y": _num(ch.get("y", 0.62), "chat: y", 0.1, 0.98),
|
||||
"width": _num(ch.get("width", 0.6), "chat: largura", 0.25, 0.96),
|
||||
"lines": int(_num(ch.get("lines", 5), "chat: linhas", 1, 10)),
|
||||
"size": int(_num(ch.get("size", 34), "chat: tamanho", 18, 64)),
|
||||
"showUser": bool(ch.get("showUser", True))}
|
||||
|
||||
raw_meta = data.get("meta") or {}
|
||||
if not isinstance(raw_meta, dict):
|
||||
raise EditError("meta precisa ser objeto")
|
||||
origin = raw_meta.get("origin", "user")
|
||||
if origin not in ("ai", "user"):
|
||||
raise EditError("meta.origin precisa ser ai ou user")
|
||||
meta = {"origin": origin, "generatedAt": _text(raw_meta.get("generatedAt", ""), "meta.generatedAt", 40),
|
||||
"model": _text(raw_meta.get("model") or "", "meta.model", 80),
|
||||
"steps": [_text(x, "meta.steps", 200) for x in _list(raw_meta.get("steps"), "meta.steps", 12)]}
|
||||
|
||||
project = {"schema": SCHEMA_VERSION, "source": {"sessionId": session_id, "lo": lo, "hi": hi}, "settings": own_settings,
|
||||
"cuts": cuts, "captions": captions, "overlays": overlays, "progress": progress, "audio": audio,
|
||||
"cover": cover, "chat": chat, "meta": meta}
|
||||
# Reenquadramento do jogo no tempo: só entra no projeto quando há keys (projeto antigo continua igual).
|
||||
keys = _reframe_keys(data.get("reframe"), lo, hi)
|
||||
if keys:
|
||||
project["reframe"] = {"keys": keys}
|
||||
return project
|
||||
|
||||
|
||||
def _keys(raw, name: str, lo: float, hi: float, fields: dict[str, tuple[float, float]]) -> list[dict]:
|
||||
"""Keyframes {t (tempo da sessão), campos..., ease}: validados, ordenados, no máximo `reframe.MAX_KEYS`."""
|
||||
out = []
|
||||
for i, k in enumerate(_list(raw, name, reframe.MAX_KEYS)):
|
||||
if not isinstance(k, dict):
|
||||
raise EditError(f"{name}[{i}] precisa ser objeto")
|
||||
item = {"t": _num(k.get("t"), f"{name}[{i}].t", lo, hi)}
|
||||
for field, (a, b) in fields.items():
|
||||
item[field] = _num(k.get(field), f"{name}[{i}].{field}", a, b)
|
||||
ease = k.get("ease", "smooth")
|
||||
if ease not in reframe.EASES:
|
||||
raise EditError(f"{name}[{i}].ease precisa ser um de {', '.join(reframe.EASES)}")
|
||||
item["ease"] = ease
|
||||
out.append(item)
|
||||
out.sort(key=lambda k: k["t"])
|
||||
for a, b in zip(out, out[1:]):
|
||||
if b["t"] - a["t"] < 0.02:
|
||||
raise EditError(f"{name}: dois keyframes no mesmo instante ({a['t']:g} s)")
|
||||
return out
|
||||
|
||||
|
||||
def _reframe_keys(raw, lo: float, hi: float) -> list[dict]:
|
||||
if raw in (None, {}):
|
||||
return []
|
||||
if not isinstance(raw, dict):
|
||||
raise EditError("reframe precisa ser objeto {keys: [...]}")
|
||||
return _keys(raw.get("keys"), "reframe.keys", lo, hi, {"cx": (0, 1), "cy": (0, 1), "w": (0.05, 1)})
|
||||
|
||||
|
||||
def _inset(o: dict, i: int, lo: float, hi: float) -> dict:
|
||||
"""Camada inserida: recorte `src` do quadro original posto em (x, y) com largura `size` da tela."""
|
||||
name = f"overlays[{i}]"
|
||||
try:
|
||||
src = layout._rect(o.get("src"), f"{name}.src")
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise EditError(str(exc)) from exc
|
||||
if src is None:
|
||||
raise EditError(f"{name}.src precisa ser {{x, y, w, h}} (recorte do quadro original)")
|
||||
border = o.get("border")
|
||||
anim = o.get("anim", "pop")
|
||||
if anim not in reframe.INSET_ANIMS:
|
||||
raise EditError(f"{name}.anim precisa ser um de {', '.join(reframe.INSET_ANIMS)}")
|
||||
return {"src": src, "x": _num(o.get("x", 0.5), f"{name}.x", 0, 1), "y": _num(o.get("y", 0.5), f"{name}.y", 0, 1),
|
||||
"size": _num(o.get("size", 0.45), f"{name}.size", 0.1, 1),
|
||||
"border": None if border in (None, "") else _hex(border, f"{name}.border"),
|
||||
"borderW": int(_num(o.get("borderW", 6), f"{name}.borderW", 0, 40)),
|
||||
"radius": int(_num(o.get("radius", 18), f"{name}.radius", 0, 200)),
|
||||
"shadow": bool(o.get("shadow", True)), "anim": anim,
|
||||
"keys": _keys(o.get("keys"), f"{name}.keys", lo, hi, {"x": (0, 1), "y": (0, 1), "size": (0.1, 1)})}
|
||||
|
||||
|
||||
def effective_settings(base: dict, project: dict) -> dict:
|
||||
"""Configuração do corte do render: padrão ← canal ← sessão ← projeto, mais o preset e o estilo da legenda."""
|
||||
cfg = layout.merge(base, project.get("settings") or {})
|
||||
cap = project["captions"]
|
||||
cfg["caption"].update(PRESET_STYLE.get(cap["preset"], {}))
|
||||
cfg["caption"].update(cap.get("style") or {})
|
||||
cfg["caption"]["enabled"] = cap["enabled"]
|
||||
return cfg
|
||||
|
||||
|
||||
def retime(project: dict, start: float, end: float) -> dict:
|
||||
"""O cartão do corte mudou início/fim (−30 s, +2 s…): estica/encolhe as pontas do projeto, mantém o meio."""
|
||||
p = copy.deepcopy(project)
|
||||
cuts = p["cuts"]
|
||||
cuts[0]["start"] = min(start, cuts[0]["end"] - MIN_CUT_S)
|
||||
cuts[-1]["end"] = max(end, cuts[-1]["start"] + MIN_CUT_S)
|
||||
p["source"]["lo"] = min(p["source"]["lo"], cuts[0]["start"])
|
||||
p["source"]["hi"] = max(p["source"]["hi"], cuts[-1]["end"])
|
||||
return p
|
||||
|
||||
|
||||
def span(project: dict) -> tuple[float, float]:
|
||||
return project["cuts"][0]["start"], project["cuts"][-1]["end"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- IA sugere
|
||||
SUGGEST_SYSTEM = """Você é EDITOR de cortes de lives de jogos em português do Brasil — verticais (Shorts/TikTok/Reels)
|
||||
ou horizontais (YouTube, tela cheia do jogo), conforme o formato informado.
|
||||
Recebe a transcrição palavra a palavra com tempos, o chat e a análise do momento. Devolva:
|
||||
- hook: texto curto de gancho para os 2 primeiros segundos (até 8 palavras, sem hashtag, fiel ao que acontece);
|
||||
- title: título do vídeo (até 70 caracteres, gancho + palavra de busca);
|
||||
- start_s/end_s: início ideal (onde a AÇÃO começa, sem enrolação) e fim (depois da reação/pagamento);
|
||||
- remove: trechos mortos DENTRO de [start_s, end_s] para cortar (silêncio longo, enrolação, fala sem relação),
|
||||
sem quebrar o contexto nem cortar no meio de frase. Pode ser vazio;
|
||||
- zooms: instantes de reação forte para um punch-in curto (0 a 3);
|
||||
- reason: por que, em uma frase.
|
||||
Tempos sempre em segundos da gravação (os mesmos da transcrição). Nunca invente o que não está na fala/chat/análise."""
|
||||
|
||||
SUGGEST_SCHEMA = {
|
||||
"type": "object", "additionalProperties": False,
|
||||
"required": ["hook", "title", "start_s", "end_s", "remove", "zooms", "reason"],
|
||||
"properties": {
|
||||
"hook": {"type": "string"}, "title": {"type": "string"},
|
||||
"start_s": {"type": "number"}, "end_s": {"type": "number"},
|
||||
"remove": {"type": "array", "items": {"type": "object", "additionalProperties": False,
|
||||
"required": ["start_s", "end_s", "why"],
|
||||
"properties": {"start_s": {"type": "number"}, "end_s": {"type": "number"},
|
||||
"why": {"type": "string"}}}},
|
||||
"zooms": {"type": "array", "items": {"type": "object", "additionalProperties": False, "required": ["t", "why"],
|
||||
"properties": {"t": {"type": "number"}, "why": {"type": "string"}}}},
|
||||
"reason": {"type": "string"},
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def suggest_prompt(streamer: str, title: str, project: dict, chat: list[ChatMessage], analysis: dict | None,
|
||||
transcript: str, chat_block: str, cfg: dict | None = None) -> str:
|
||||
"""`cfg` = configuração efetiva do corte (duração e formato); sem ela, os padrões de `layout.DEFAULTS`."""
|
||||
cfg = cfg or layout.merge()
|
||||
lo, hi = project["source"]["lo"], project["source"]["hi"]
|
||||
a, b = span(project)
|
||||
dur = cfg["duration"]
|
||||
fmt = "horizontal 16:9 (YouTube)" if layout.aspect(cfg) == "horizontal" else "vertical 9:16 (Shorts/TikTok/Reels)"
|
||||
return (f"Canal: {streamer}\nTítulo atual do corte: {title or '(nenhum)'}\nFormato: {fmt}\n"
|
||||
f"Janela disponível da gravação: {lo:.0f}s a {hi:.0f}s. Corte atual: {a:.0f}s a {b:.0f}s "
|
||||
f"({output_duration(project['cuts']):.0f} s depois dos cortes internos).\n"
|
||||
f"Duração final ideal: {dur['minS']:.0f} a {dur['maxS']:.0f} s.\n\n"
|
||||
f"Transcrição (segundos da gravação):\n{transcript}\n\n{chat_block}\n\n"
|
||||
+ (f"Análise do momento (1º juiz): {analysis}\n" if analysis else ""))
|
||||
|
||||
|
||||
def clean_suggestion(data: dict, lo: float, hi: float, min_len: float = MIN_OUTPUT_S,
|
||||
max_len: float = MAX_OUTPUT_S) -> dict:
|
||||
"""Prende tudo dentro da janela e nos limites (a IA pode errar números). `min_len`/`max_len` = duração final do
|
||||
corte (o editor passa mínimo + 1 s e máximo da configuração); os trechos a remover que levariam o corte abaixo do
|
||||
mínimo ficam de fora."""
|
||||
start, end = fit_window(float(data.get("start_s", lo)), float(data.get("end_s", hi)), lo, hi,
|
||||
max(MIN_OUTPUT_S, min_len), max_len, keep="start")
|
||||
remove = []
|
||||
for r in (data.get("remove") or [])[:10]:
|
||||
try:
|
||||
a, b = max(float(r["start_s"]), start), min(float(r["end_s"]), end)
|
||||
except (KeyError, TypeError, ValueError):
|
||||
continue
|
||||
if b - a >= 0.4 and (end - start) - sum(x["end"] - x["start"] for x in remove) - (b - a) >= min_len:
|
||||
remove.append({"start": round(a, 2), "end": round(b, 2), "why": str(r.get("why", ""))[:160]})
|
||||
zooms = []
|
||||
for z in (data.get("zooms") or [])[:3]:
|
||||
try:
|
||||
t = float(z["t"])
|
||||
except (KeyError, TypeError, ValueError):
|
||||
continue
|
||||
if start <= t <= end:
|
||||
zooms.append({"t": round(t, 2), "why": str(z.get("why", ""))[:160]})
|
||||
return {"hook": str(data.get("hook", "")).strip()[:80], "title": str(data.get("title", "")).strip()[:100],
|
||||
"start": round(start, 2), "end": round(end, 2), "remove": remove, "zooms": zooms,
|
||||
"reason": str(data.get("reason", ""))[:300]}
|
||||
@@ -0,0 +1,465 @@
|
||||
"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`)
|
||||
e o render do projeto chamado pela fila do motor (worker.render_clip).
|
||||
|
||||
O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o
|
||||
`rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do
|
||||
editor em `output/clipper/<sessão>/edit-<corte>/` (proxy 480p, forma de onda, narração TTS, prévia real).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from . import editor, editor_render, layout, media
|
||||
from .config import REPO_ROOT
|
||||
from .db import loads, now
|
||||
from .judge import JudgeError, _chat_block, _transcript
|
||||
from .scoring import Word
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.editor")
|
||||
PREVIEW_MAX_S = 10.0
|
||||
RETRANSCRIBE_MAX_S = 90.0
|
||||
_locks: dict[str, threading.Lock] = {}
|
||||
_locks_guard = threading.Lock()
|
||||
|
||||
|
||||
def _lock(key: str) -> threading.Lock:
|
||||
with _locks_guard:
|
||||
return _locks.setdefault(key, threading.Lock())
|
||||
|
||||
|
||||
class EditPut(BaseModel):
|
||||
project: dict
|
||||
rev: int = Field(default=0, ge=0)
|
||||
|
||||
|
||||
class WindowIn(BaseModel):
|
||||
lo: float = Field(ge=0)
|
||||
hi: float = Field(ge=0)
|
||||
|
||||
|
||||
class PreviewRenderIn(BaseModel):
|
||||
fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S)
|
||||
durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S)
|
||||
project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo
|
||||
|
||||
|
||||
class RangeIn(BaseModel):
|
||||
startS: float = Field(ge=0)
|
||||
endS: float = Field(ge=0)
|
||||
|
||||
|
||||
class TtsIn(BaseModel):
|
||||
text: str = Field(min_length=1, max_length=300)
|
||||
voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$")
|
||||
speed: float = Field(default=1.0, ge=0.5, le=2.0)
|
||||
|
||||
|
||||
class SuggestIn(BaseModel):
|
||||
project: dict | None = None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- utilidades (também usadas pelo worker)
|
||||
def edit_dir(engine, session_id: int, clip_id: int) -> Path:
|
||||
return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}"
|
||||
|
||||
|
||||
def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]:
|
||||
return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
|
||||
for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)]
|
||||
|
||||
|
||||
def validate_for(engine, clip: dict, session: dict, data: dict) -> dict:
|
||||
return editor.validate_project(
|
||||
data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT,
|
||||
tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets")
|
||||
|
||||
|
||||
def load_edit(engine, clip_id: int) -> dict | None:
|
||||
row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id)
|
||||
if row:
|
||||
row["project"] = loads(row["project_json"], None)
|
||||
return row
|
||||
|
||||
|
||||
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
|
||||
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
|
||||
project = validate_for(engine, clip, session, edit["project"])
|
||||
segments = session_segments(engine, clip["session_id"])
|
||||
if engine._encoder is None:
|
||||
engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder)
|
||||
base = engine.intel.settings_for(session)
|
||||
credit = engine.channel_label(session)
|
||||
ffmpeg = engine.settings.ffmpeg or "ffmpeg"
|
||||
# A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4.
|
||||
cover: Path | None = None
|
||||
if project["cover"]["enabled"]:
|
||||
cover = out.parent / f"{out.stem}-cover.jpg"
|
||||
try:
|
||||
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
|
||||
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
|
||||
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
|
||||
cover = None
|
||||
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
|
||||
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover)
|
||||
total = editor.output_duration(project["cuts"])
|
||||
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
|
||||
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
|
||||
engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"])
|
||||
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
|
||||
|
||||
|
||||
def chat_for(engine, project: dict) -> list | None:
|
||||
"""Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede)."""
|
||||
if not (project.get("chat") or {}).get("enabled"):
|
||||
return None
|
||||
lo = project["source"]["lo"]
|
||||
return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"]
|
||||
|
||||
|
||||
def _judge(clip: dict) -> dict:
|
||||
data = loads(clip.get("judge_json"), None)
|
||||
return data if isinstance(data, dict) else {}
|
||||
|
||||
|
||||
def auto_for(engine, clip: dict, session: dict) -> dict:
|
||||
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
|
||||
judge = _judge(clip)
|
||||
lo, hi = editor.default_window(clip, session["duration_s"])
|
||||
rows = engine.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
|
||||
clip["session_id"], lo, hi)
|
||||
words = [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], [])]
|
||||
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
|
||||
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
|
||||
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
|
||||
|
||||
|
||||
def ensure_edit(engine, clip: dict, session: dict) -> dict:
|
||||
"""Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um
|
||||
agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto."""
|
||||
row = load_edit(engine, clip["id"])
|
||||
if row and row["project"]:
|
||||
return row
|
||||
project = validate_for(engine, clip, session, auto_for(engine, clip, session))
|
||||
raw = json.dumps(project, ensure_ascii=False)
|
||||
ts = now()
|
||||
engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
|
||||
" VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts)
|
||||
start, end = editor.span(project)
|
||||
engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"])
|
||||
return load_edit(engine, clip["id"])
|
||||
|
||||
|
||||
def retime_edit(engine, clip_id: int, start: float, end: float) -> None:
|
||||
"""O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto."""
|
||||
row = load_edit(engine, clip_id)
|
||||
if not row or not row["project"]:
|
||||
return
|
||||
project = editor.retime(row["project"], start, end)
|
||||
engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?",
|
||||
json.dumps(project, ensure_ascii=False), now(), clip_id)
|
||||
|
||||
|
||||
def _audio_library() -> list[dict]:
|
||||
root = REPO_ROOT / "assets"
|
||||
out = []
|
||||
if root.is_dir():
|
||||
for f in sorted(root.rglob("*")):
|
||||
if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT:
|
||||
out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem})
|
||||
if len(out) >= 200:
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
def _window_key(lo: float, hi: float) -> str:
|
||||
return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}"
|
||||
|
||||
|
||||
def _clean_old(folder: Path, prefix: str, keep: str) -> None:
|
||||
for f in folder.glob(f"{prefix}-*"):
|
||||
if f.name != keep:
|
||||
f.unlink(missing_ok=True)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- rotas
|
||||
def register(app: FastAPI, engine, clip_view, get_clip) -> None:
|
||||
"""`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir)."""
|
||||
db, settings = engine.db, engine.settings
|
||||
ffmpeg = settings.ffmpeg or "ffmpeg"
|
||||
|
||||
@app.exception_handler(editor.EditError)
|
||||
async def edit_error(_request: Request, exc: editor.EditError):
|
||||
return JSONResponse({"error": str(exc)}, status_code=400)
|
||||
|
||||
@app.exception_handler(media.MediaError)
|
||||
async def media_error(_request: Request, exc: media.MediaError):
|
||||
return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400)
|
||||
|
||||
def _context(clip_id: int) -> tuple[dict, dict]:
|
||||
clip = get_clip(clip_id)
|
||||
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
|
||||
if not session:
|
||||
raise editor.EditError("sessão do corte não existe mais")
|
||||
return clip, session
|
||||
|
||||
def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]:
|
||||
lo, hi = max(0.0, lo), min(hi, session["duration_s"])
|
||||
if not 5 <= hi - lo <= editor.MAX_WINDOW_S:
|
||||
raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação")
|
||||
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi)
|
||||
if not segs:
|
||||
raise editor.EditError("não há gravação nessa janela")
|
||||
if any(s["deleted"] for s in segs):
|
||||
raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor")
|
||||
return round(lo, 3), round(hi, 3)
|
||||
|
||||
def _words(session_id: int, lo: float, hi: float) -> list[Word]:
|
||||
rows = db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
|
||||
session_id, lo, hi)
|
||||
return [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], []) if lo <= a <= hi]
|
||||
|
||||
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
|
||||
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
|
||||
return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None
|
||||
|
||||
def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None:
|
||||
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json"
|
||||
return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None
|
||||
|
||||
@app.get("/v1/clips/{clip_id}/edit")
|
||||
def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None):
|
||||
"""Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA,
|
||||
configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda)."""
|
||||
clip, session = _context(clip_id)
|
||||
row = load_edit(engine, clip_id)
|
||||
view = clip_view(clip)
|
||||
if row and row["project"]:
|
||||
project, rev = row["project"], row["rev"]
|
||||
ai_project = loads(row.get("ai_project_json"), None)
|
||||
else:
|
||||
project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo)
|
||||
rev = 0
|
||||
w_lo = project["source"]["lo"] if lo is None else lo
|
||||
w_hi = project["source"]["hi"] if hi is None else hi
|
||||
w_lo, w_hi = _check_window(session, w_lo, w_hi)
|
||||
tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5))
|
||||
chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)}
|
||||
for m in tl["chat"] if w_lo <= m.t <= w_hi][:600]
|
||||
per_s = [0] * int(w_hi - w_lo + 1)
|
||||
for m in tl["chat"]:
|
||||
if w_lo <= m.t <= w_hi:
|
||||
per_s[int(m.t - w_lo)] += 1
|
||||
loud = tl["loudness"][int(w_lo): int(w_hi) + 1]
|
||||
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
|
||||
return {
|
||||
"clip": view, "project": project, "rev": rev, "saved": bool(row),
|
||||
"origin": row["origin"] if row else "ai", "aiProject": ai_project,
|
||||
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
|
||||
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
|
||||
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in _words(clip["session_id"], w_lo, w_hi)],
|
||||
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
|
||||
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
|
||||
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
|
||||
"audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi),
|
||||
"waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S,
|
||||
"judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured,
|
||||
"limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S,
|
||||
"previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S},
|
||||
}
|
||||
|
||||
@app.put("/v1/clips/{clip_id}/edit")
|
||||
def put_edit(clip_id: int, body: EditPut):
|
||||
"""Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes)."""
|
||||
clip, session = _context(clip_id)
|
||||
project = validate_for(engine, clip, session, body.project)
|
||||
ts = now()
|
||||
with db.lock:
|
||||
row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)
|
||||
if row and body.rev != row["rev"]:
|
||||
return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]},
|
||||
status_code=409)
|
||||
if row:
|
||||
db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?",
|
||||
json.dumps(project, ensure_ascii=False), ts, clip_id)
|
||||
else:
|
||||
ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False)
|
||||
db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
|
||||
" VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts)
|
||||
rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"]
|
||||
return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])}
|
||||
|
||||
@app.delete("/v1/clips/{clip_id}/edit", status_code=204)
|
||||
def delete_edit(clip_id: int):
|
||||
"""Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render)."""
|
||||
get_clip(clip_id)
|
||||
db.run("DELETE FROM edits WHERE clip_id = ?", clip_id)
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/proxy")
|
||||
def make_proxy(clip_id: int, body: WindowIn):
|
||||
"""Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela."""
|
||||
clip, session = _context(clip_id)
|
||||
lo, hi = _check_window(session, body.lo, body.hi)
|
||||
folder = edit_dir(engine, clip["session_id"], clip_id)
|
||||
name = f"proxy-{_window_key(lo, hi)}.mp4"
|
||||
with _lock(f"proxy-{clip_id}"):
|
||||
if not (folder / name).is_file():
|
||||
t = time.monotonic()
|
||||
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
|
||||
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
|
||||
_clean_old(folder, "proxy", name)
|
||||
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word}
|
||||
for w in _words(clip["session_id"], lo, hi)]}
|
||||
|
||||
@app.get("/v1/clips/{clip_id}/waveform")
|
||||
def get_waveform(clip_id: int, lo: float, hi: float):
|
||||
clip, session = _context(clip_id)
|
||||
lo, hi = _check_window(session, lo, hi)
|
||||
folder = edit_dir(engine, clip["session_id"], clip_id)
|
||||
name = f"waveform-{_window_key(lo, hi)}.json"
|
||||
with _lock(f"wave-{clip_id}"):
|
||||
peaks = _cached_wave(clip, lo, hi)
|
||||
if peaks is None:
|
||||
peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder)
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
(folder / name).write_text(json.dumps(peaks), encoding="utf-8")
|
||||
_clean_old(folder, "waveform", name)
|
||||
return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks}
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/preview-render")
|
||||
def preview_render(clip_id: int, body: PreviewRenderIn):
|
||||
"""Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado."""
|
||||
clip, session = _context(clip_id)
|
||||
row = load_edit(engine, clip_id)
|
||||
data = body.project or (row["project"] if row else None)
|
||||
if not data:
|
||||
raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)")
|
||||
project = validate_for(engine, clip, session, data)
|
||||
total = editor.output_duration(project["cuts"])
|
||||
a = min(body.fromS, max(0.0, total - 1))
|
||||
b = min(total, a + body.durationS)
|
||||
out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4"
|
||||
segments = session_segments(engine, clip["session_id"])
|
||||
base, credit = engine.intel.settings_for(session), engine.channel_label(session)
|
||||
with _lock(f"preview-{clip_id}"):
|
||||
t = time.monotonic()
|
||||
# Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export.
|
||||
cover = None
|
||||
if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"):
|
||||
cover = out.parent / "preview-cover.jpg"
|
||||
try:
|
||||
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
|
||||
except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela
|
||||
log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc)
|
||||
cover = None
|
||||
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
|
||||
segments, project, base, credit, out, REPO_ROOT,
|
||||
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover)
|
||||
took = time.monotonic() - t
|
||||
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/export")
|
||||
def export(clip_id: int):
|
||||
"""Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar)."""
|
||||
clip, session = _context(clip_id)
|
||||
row = load_edit(engine, clip_id)
|
||||
if not row or not row["project"]:
|
||||
raise editor.EditError("nada para exportar: salve o projeto primeiro")
|
||||
project = validate_for(engine, clip, session, row["project"])
|
||||
start, end = editor.span(project)
|
||||
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end)
|
||||
if not segs or any(s["deleted"] for s in segs):
|
||||
raise editor.EditError("os blocos gravados deste trecho já foram apagados")
|
||||
words = editor.output_words(project)
|
||||
ts = now()
|
||||
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
|
||||
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
|
||||
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
|
||||
engine.wake_clips.set()
|
||||
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/retranscribe")
|
||||
def retranscribe(clip_id: int, body: RangeIn):
|
||||
"""Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão."""
|
||||
clip, session = _context(clip_id)
|
||||
a, b = body.startS, min(body.endS, session["duration_s"])
|
||||
if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S:
|
||||
raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s")
|
||||
if not engine.voice.configured:
|
||||
raise editor.EditError("serviço de voz não instalado")
|
||||
wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b,
|
||||
edit_dir(engine, clip["session_id"], clip_id))
|
||||
t = time.monotonic()
|
||||
try:
|
||||
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
|
||||
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
|
||||
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
|
||||
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
|
||||
"words": [{"s": round(w.start + a, 3), "e": round(w.end + a, 3), "w": w.word} for w in words]}
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/tts")
|
||||
def tts(clip_id: int, body: TtsIn):
|
||||
"""Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-<corte>/tts-<hash>.wav."""
|
||||
clip, _session = _context(clip_id)
|
||||
voice = engine.voice
|
||||
if not voice.configured:
|
||||
raise editor.EditError("serviço de voz não instalado")
|
||||
text = editor.CONTROL_RE.sub(" ", body.text).strip()
|
||||
digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12]
|
||||
folder = edit_dir(engine, clip["session_id"], clip_id)
|
||||
out = folder / f"tts-{digest}.wav"
|
||||
if not out.is_file():
|
||||
try:
|
||||
response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""},
|
||||
json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice,
|
||||
"params": {"speed": body.speed, "format": "wav"}})
|
||||
except httpx.HTTPError as exc:
|
||||
raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc
|
||||
if response.status_code != 200:
|
||||
try:
|
||||
detail = response.json().get("error") or response.json().get("detail") or response.text
|
||||
except ValueError:
|
||||
detail = response.text
|
||||
raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}")
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
out.write_bytes(response.content)
|
||||
duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0
|
||||
return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice}
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/suggest")
|
||||
def suggest(clip_id: int, body: SuggestIn):
|
||||
"""IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom."""
|
||||
clip, session = _context(clip_id)
|
||||
if not engine.judge.enabled:
|
||||
raise editor.EditError("IA desligada (página Clipador → Juiz)")
|
||||
row = load_edit(engine, clip_id)
|
||||
data = body.project or (row["project"] if row else None) or editor.default_project(
|
||||
clip, [], session["duration_s"])
|
||||
project = validate_for(engine, clip, session, data)
|
||||
lo, hi = project["source"]["lo"], project["source"]["hi"]
|
||||
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
|
||||
words = [Word(w["s"], w["e"], w["w"]) for w in project["captions"]["words"]] or tl["words"]
|
||||
view = clip_view(clip)
|
||||
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
|
||||
cfg = editor.effective_settings(engine.intel.settings_for(session), project)
|
||||
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
|
||||
_transcript(words, lo, hi), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
|
||||
t = time.monotonic()
|
||||
try:
|
||||
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
|
||||
except JudgeError as exc:
|
||||
raise editor.EditError(f"IA: {exc}") from exc
|
||||
# Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte.
|
||||
return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1),
|
||||
"model": engine.judge.describe().get("model")}
|
||||
@@ -0,0 +1,721 @@
|
||||
"""Render do projeto de edição (editor.py) com FFmpeg: legenda animada e textos em ASS, filtergraph com trechos,
|
||||
layout por trecho, zoom (punch-in), narração/música/efeitos, proxy 480p, forma de onda e capa.
|
||||
|
||||
Regras herdadas do Clipador (gotchas 57/58/71): `-ss` ANTES do `-i`; maiúsculas só no texto (nunca nas tags);
|
||||
cores `&H00BBGGRR&` na linha Style e `&HBBGGRR&` nas tags. Formato: o vídeo sai em `layout.frame_size` (1080×1920
|
||||
ou 1920×1080) e os textos são contados no quadro lógico `layout.canvas_size` (no horizontal, 2560×1440). Subprocesso sem shell, argumentos em lista; no filtro
|
||||
só entram números formatados aqui e nomes de arquivo relativos gerados por nós.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
from array import array
|
||||
from pathlib import Path
|
||||
|
||||
from . import layout, media, reframe
|
||||
from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output
|
||||
from .scoring import Word
|
||||
from .subtitles import _escape, _ts, caption_blocks, clean_words
|
||||
|
||||
W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração
|
||||
FPS = 30
|
||||
PEAKS_PER_S = 50
|
||||
COVER_BOX = "#E11D48" # mesma cor da caixa do gancho padrão
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- ASS (legenda animada + textos + barra)
|
||||
def _wrap(text: str, size: int, width: int = W - 120) -> str:
|
||||
"""Quebra manual (o cabeçalho usa WrapStyle 2 = sem quebra automática). Escapa cada pedaço."""
|
||||
max_chars = max(6, int(width / (size * 0.58)))
|
||||
lines, line = [], ""
|
||||
for word in text.split():
|
||||
if line and len(line) + 1 + len(word) > max_chars:
|
||||
lines.append(line)
|
||||
line = word
|
||||
else:
|
||||
line = f"{line} {word}".strip()
|
||||
if line:
|
||||
lines.append(line)
|
||||
return "\\N".join(_escape(x) for x in lines[:4])
|
||||
|
||||
|
||||
BANNER_MAX_LINES = 2
|
||||
BANNER_SLIDE_MS = 240 # a tarja atravessa a tela
|
||||
TEXT_SLIDE_MS = (90, 430) # o texto entra deslizando, borrado, e assenta nítido nesse intervalo
|
||||
|
||||
|
||||
def _lines(text: str, size: int, width: int, char_w: float = 0.6) -> list[str]:
|
||||
"""Quebra em linhas pela largura estimada (nunca no meio da palavra)."""
|
||||
max_chars = max(4, int(width / (size * char_w)))
|
||||
lines, line = [], ""
|
||||
for word in text.split():
|
||||
if line and len(line) + 1 + len(word) > max_chars:
|
||||
lines.append(line)
|
||||
line = word
|
||||
else:
|
||||
line = f"{line} {word}".strip()
|
||||
if line:
|
||||
lines.append(line)
|
||||
return lines
|
||||
|
||||
|
||||
def banner_layout(o: dict, canvas: tuple[int, int]) -> dict:
|
||||
"""Geometria da tarja do gancho no quadro lógico: linhas (no máximo 2, sem cortar palavra: a fonte diminui até
|
||||
caber), tamanho, topo e altura da faixa."""
|
||||
cw, ch = canvas
|
||||
text = o["text"].upper()
|
||||
size = int(o["size"])
|
||||
lines = _lines(text, size, int(cw * 0.9))
|
||||
while len(lines) > BANNER_MAX_LINES and size > 24:
|
||||
size = max(24, int(size * 0.9))
|
||||
lines = _lines(text, size, int(cw * 0.9))
|
||||
line_h = size * 1.18
|
||||
pad = size * 0.42
|
||||
height = int(round(len(lines) * line_h + 2 * pad))
|
||||
cy = int(ch * o["y"])
|
||||
top = max(0, min(ch - height, cy - height // 2))
|
||||
return {"lines": lines, "size": size, "top": top, "height": height, "cy": top + height // 2}
|
||||
|
||||
|
||||
def banner_events(o: dict, canvas: tuple[int, int]) -> list[tuple[int, str, str, tuple[float, float | None] | None]]:
|
||||
"""Gancho em TARJA (referência do dono, 17/11/2026): faixa na largura toda, na cor `bg`, que atravessa a tela, e o
|
||||
texto em maiúsculas (cor `color`, contorno preto grosso, fonte `font`) que entra deslizando com desfoque de
|
||||
movimento e assenta nítido. Tudo em ASS (desenho \\p1, \\move e \\t com \\blur): sem filtro extra no FFmpeg.
|
||||
|
||||
Com contorno, o \\blur do libass desfoca só a borda e o preenchimento fica nítido (achado ao comparar com o modelo
|
||||
do dono). Por isso, na ENTRADA (`slide`, até 430 ms) o texto vem em duas camadas: o preenchimento sem contorno, com
|
||||
o desfoque animado, e o contorno, também borrado, que aparece junto. Do fim da entrada em diante entra o MESMO
|
||||
evento assentado de antes (posição, quebra, tamanho, contorno), para a prévia do editor continuar batendo.
|
||||
|
||||
Devolve [(camada, estilo, texto ASS, janela)]; janela = None (o tempo todo do gancho) ou (início, fim) em segundos
|
||||
relativos ao início do gancho (fim None = até o fim)."""
|
||||
cw, _ = canvas
|
||||
g = banner_layout(o, canvas)
|
||||
bg = layout.ass_inline_color(o.get("bg") or layout.DEFAULTS["hook"]["bg"])
|
||||
color = layout.ass_inline_color(o.get("color") or "#FFFFFF")
|
||||
font = o.get("font") or layout.HOOK_FONT
|
||||
slide = o.get("anim") == "slide"
|
||||
out_fade = "\\fad(0,180)"
|
||||
band_pos = (f"\\move({-cw},{g['top']},0,{g['top']},0,{BANNER_SLIDE_MS})" if slide else f"\\pos(0,{g['top']})")
|
||||
band_anim = out_fade if slide else _anim(o.get("anim", "none")).replace("\\fscx70\\fscy70", "")
|
||||
band = (f"{{\\an7{band_pos}\\p1\\bord0\\shad0\\1c{bg}{band_anim}}}"
|
||||
f"m 0 0 l {cw} 0 {cw} {g['height']} 0 {g['height']}{{\\p0}}")
|
||||
cx = cw // 2
|
||||
a, b = TEXT_SLIDE_MS
|
||||
border = max(3, int(round(g["size"] * 0.1)))
|
||||
lines = "\\N".join(_escape(x) for x in g["lines"])
|
||||
look = f"\\fn{font}\\fs{g['size']}\\1c{color}\\3c&H000000&\\4c&H000000&"
|
||||
settled_tags = f"\\bord{border}\\shad{max(2, border // 2)}"
|
||||
if not slide:
|
||||
text = f"{{\\an5\\pos({cx},{g['cy']}){_anim(o.get('anim', 'none'))}{look}{settled_tags}}}{lines}"
|
||||
return [(2, "Bar", band, None), (4, "Text", text, None)]
|
||||
move = f"\\move({cx + int(cw * 0.55)},{g['cy']},{cx},{g['cy']},{a},{b})"
|
||||
entry = (0.0, b / 1000)
|
||||
# Preenchimento sem contorno: o desfoque pega a letra inteira (como no modelo).
|
||||
fill = f"{{\\an5{move}\\blur18\\t({a},{b},\\blur0){look}\\bord0\\shad0}}{lines}"
|
||||
# Contorno (e sombra) sem preenchimento, borrado e surgindo junto; por baixo do preenchimento.
|
||||
outline = (f"{{\\an5{move}\\1a&HFF&\\3a&HC0&\\4a&HFF&\\blur18\\t({a},{b},\\blur0\\3a&H00&\\4a&H00&)"
|
||||
f"{look}{settled_tags}}}{lines}")
|
||||
# Assentado: o mesmo evento de antes, parado na posição final (a saída com \\fad continua no fim do gancho).
|
||||
settled = f"{{\\an5\\pos({cx},{g['cy']}){out_fade}{look}{settled_tags}}}{lines}"
|
||||
return [(2, "Bar", band, None), (5, "Text", fill, entry), (4, "Text", outline, entry), (4, "Text", settled, (b / 1000, None))]
|
||||
|
||||
|
||||
def _anim(kind: str) -> str:
|
||||
if kind == "pop":
|
||||
return "\\fad(80,120)\\fscx70\\fscy70\\t(0,140,\\fscx108\\fscy108)\\t(140,220,\\fscx100\\fscy100)"
|
||||
if kind == "fade":
|
||||
return "\\fad(250,250)"
|
||||
if kind == "slide":
|
||||
return "\\blur14\\t(0,320,\\blur0)\\fad(0,180)"
|
||||
return ""
|
||||
|
||||
|
||||
CHAT_HOLD_S = 9.0 # quanto uma mensagem fica na tela se não chegar outra
|
||||
CHAT_COLORS = ("#FF7A7A", "#7AD7FF", "#9BE77A", "#FFD36B", "#C9A2FF", "#FF9FD6")
|
||||
|
||||
|
||||
def chat_events(project: dict, chat: list | None, total: float,
|
||||
canvas: tuple[int, int] = (W, H)) -> list[tuple[float, float, str]]:
|
||||
"""Chat da live na tela: (início, fim, texto ASS) em tempo de saída. A cada mensagem nova o bloco mostra as
|
||||
últimas `lines` (uma linha por mensagem, cortada na largura do bloco), ancorado pela base em (x, y).
|
||||
`canvas` = quadro lógico do ASS (largura, altura)."""
|
||||
cw, ch = canvas
|
||||
cfg = project.get("chat") or {}
|
||||
if not cfg.get("enabled") or not chat:
|
||||
return []
|
||||
cuts = project["cuts"]
|
||||
msgs = []
|
||||
for m in chat:
|
||||
t_out, inside = to_output(m.t, cuts)
|
||||
if inside and m.text.strip():
|
||||
msgs.append((t_out, m.user, " ".join(m.text.split())))
|
||||
msgs.sort(key=lambda x: x[0])
|
||||
max_chars = max(8, int(cw * cfg["width"] / (cfg["size"] * 0.54)))
|
||||
pos = f"\\an1\\pos({int(cw * cfg['x'])},{int(ch * cfg['y'])})"
|
||||
|
||||
def line(user: str, text: str) -> str:
|
||||
name = user[:16] if cfg["showUser"] and user else ""
|
||||
room = max_chars - (len(name) + 2 if name else 0)
|
||||
body = text if len(text) <= room else text[: max(1, room - 1)].rstrip() + "…"
|
||||
if not name:
|
||||
return _escape(body)
|
||||
color = layout.ass_inline_color(CHAT_COLORS[sum(map(ord, user)) % len(CHAT_COLORS)])
|
||||
return f"{{\\1c{color}}}{_escape(name)}:{{\\1c&HFFFFFF&}} {_escape(body)}"
|
||||
|
||||
out = []
|
||||
for i, (t, _user, _text) in enumerate(msgs):
|
||||
nxt = msgs[i + 1][0] if i + 1 < len(msgs) else total
|
||||
end = min(total, nxt, t + CHAT_HOLD_S)
|
||||
if end - t < 0.03:
|
||||
continue
|
||||
shown = [m for m in msgs[max(0, i - cfg["lines"] + 1): i + 1] if t - m[0] <= CHAT_HOLD_S * 2]
|
||||
out.append((t, end, f"{{{pos}}}" + "\\N".join(line(u, x) for _, u, x in shown)))
|
||||
return out
|
||||
|
||||
|
||||
def build_project_ass(project: dict, cfg: dict, credit: str, t0: float = 0.0, t1: float | None = None,
|
||||
chat: list | None = None) -> str:
|
||||
"""ASS do projeto em tempo de saída. [t0, t1] recorta a janela (prévia real de poucos segundos).
|
||||
`chat` = mensagens da sessão (ChatMessage) para o bloco de chat na tela, se o projeto pedir."""
|
||||
cap, cred = cfg["caption"], cfg["credit"]
|
||||
total = output_duration(project["cuts"])
|
||||
t1 = total if t1 is None else min(t1, total)
|
||||
length = t1 - t0
|
||||
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
|
||||
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
|
||||
cw, ch = layout.canvas_size(cfg)
|
||||
font, size, ow = cap["font"], cap["size"], cap["outlineWidth"]
|
||||
header = f"""[Script Info]
|
||||
ScriptType: v4.00+
|
||||
PlayResX: {cw}
|
||||
PlayResY: {ch}
|
||||
WrapStyle: 2
|
||||
ScaledBorderAndShadow: yes
|
||||
|
||||
[V4+ Styles]
|
||||
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
|
||||
Style: Caption,{font},{size},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
|
||||
Style: Karaoke,{font},{size},{high},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
|
||||
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
|
||||
Style: Text,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,2,5,60,60,0,1
|
||||
Style: Box,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H004D1DE1,&H00000000,-1,0,0,0,100,100,0,0,3,18,0,5,60,60,0,1
|
||||
Style: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1
|
||||
Style: Chat,Arial,{(project.get('chat') or {}).get('size', 34)},&H00FFFFFF,&H00FFFFFF,&H78000000,&H00000000,-1,0,0,0,100,100,0,0,3,5,0,1,0,0,0,1
|
||||
|
||||
[Events]
|
||||
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
|
||||
"""
|
||||
lines: list[str] = []
|
||||
|
||||
def event(layer: int, s: float, e: float, style: str, text: str) -> None:
|
||||
s, e = max(s, t0) - t0, min(e, t1) - t0
|
||||
if e - s > 0.01:
|
||||
lines.append(f"Dialogue: {layer},{_ts(s)},{_ts(e)},{style},,0,0,0,,{text}")
|
||||
|
||||
if credit and cred["enabled"]:
|
||||
event(1, 0, total, "Credit", _escape(credit))
|
||||
|
||||
if cap["enabled"]:
|
||||
preset = project["captions"]["preset"]
|
||||
emph = emphasized(project)
|
||||
emph_c = layout.ass_inline_color(project["captions"]["emphColor"])
|
||||
hi_c, base_c = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
|
||||
pos = f"\\pos({cw // 2},{layout.caption_y(cfg)})"
|
||||
# Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos
|
||||
# ORIGINAIS. Depois as palavras são saneadas (ordem, sem sobreposição, duração mínima) — `clean_words` devolve
|
||||
# a mesma quantidade, na mesma ordem — e os blocos abaixo nunca ficam dois na tela ao mesmo tempo.
|
||||
raw = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end))
|
||||
raw_emph = _match_emphasis(raw, project, emph)
|
||||
words = clean_words(raw)
|
||||
|
||||
def txt(w: Word) -> str:
|
||||
return _escape(w.word.upper() if cap["uppercase"] else w.word)
|
||||
|
||||
def key(w: Word) -> tuple[float, str]:
|
||||
return round(w.start, 3), w.word # depois de clean_words, cada início é único
|
||||
|
||||
emph_keys = {key(words[i]) for i in raw_emph}
|
||||
for group, g_end in caption_blocks(words, cap["maxWords"]):
|
||||
if preset == "karaoke":
|
||||
parts, cursor = [], group[0].start
|
||||
for w in group:
|
||||
gap = max(0, int(round((w.start - cursor) * 100)))
|
||||
dur = max(1, int(round((w.end - w.start) * 100)))
|
||||
color = f"\\1c{emph_c}" if key(w) in emph_keys else ""
|
||||
parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}")
|
||||
cursor = w.end
|
||||
event(0, group[0].start, g_end, "Karaoke", f"{{{pos}}}" + " ".join(parts))
|
||||
continue
|
||||
for i, word in enumerate(group):
|
||||
start = word.start
|
||||
end = group[i + 1].start if i + 1 < len(group) else g_end
|
||||
if end <= start:
|
||||
continue
|
||||
if preset == "single":
|
||||
color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_c)
|
||||
event(0, start, end, "Caption", f"{{{pos}{_anim('pop')}\\c{color}}}{txt(word)}")
|
||||
continue
|
||||
parts = []
|
||||
for j, w in enumerate(group):
|
||||
is_emph = key(w) in emph_keys
|
||||
if preset == "minimal":
|
||||
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
|
||||
elif j == i:
|
||||
color = emph_c if is_emph else hi_c
|
||||
pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else ""
|
||||
parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_c}\\fscx100\\fscy100}}")
|
||||
else:
|
||||
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w))
|
||||
intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else ""
|
||||
event(0, start, end, "Caption", f"{{{pos}{intro}}}" + " ".join(parts))
|
||||
|
||||
cuts = project["cuts"]
|
||||
for o in project["overlays"]:
|
||||
if o["kind"] in ("zoom", "inset"):
|
||||
continue
|
||||
if o["kind"] == "hook":
|
||||
s, e = o["start"], min(o["end"], total)
|
||||
else:
|
||||
s, e = to_output(o["start"], cuts)[0], to_output(o["end"], cuts)[0]
|
||||
if o.get("style") == "banner":
|
||||
for layer, style, text, window in banner_events(o, (cw, ch)):
|
||||
a0, b0 = (s, e) if window is None else (s + window[0], e if window[1] is None else min(e, s + window[1]))
|
||||
event(layer, a0, b0, style, text)
|
||||
continue
|
||||
style = "Box" if o["box"] else "Text"
|
||||
x, y = int(cw * o.get("x", 0.5)), int(ch * o["y"])
|
||||
if o["anim"] == "slide": # entra deslizando da direita, borrado, e assenta nítido
|
||||
a, b = TEXT_SLIDE_MS
|
||||
pos = f"\\move({x + int(cw * 0.5)},{y},{x},{y},{a},{b})"
|
||||
else:
|
||||
pos = f"\\pos({x},{y})"
|
||||
tags = f"{pos}\\fs{o['size']}\\1c{layout.ass_inline_color(o['color'])}"
|
||||
if o.get("font"):
|
||||
tags += f"\\fn{o['font']}"
|
||||
if o["box"]:
|
||||
tags += f"\\3c{layout.ass_inline_color(o['box'])}"
|
||||
event(2, s, e, style, f"{{{tags}{_anim(o['anim'])}}}{_wrap(o['text'], o['size'], cw - 120)}")
|
||||
|
||||
for s, e, text in chat_events(project, chat, total, (cw, ch)):
|
||||
event(2, s, e, "Chat", text)
|
||||
|
||||
prog = project["progress"]
|
||||
if prog["enabled"] and total > 0:
|
||||
h = prog["height"]
|
||||
a, b = 100 * t0 / total, 100 * t1 / total
|
||||
draw = f"m 0 0 l {cw} 0 {cw} {h} 0 {h}"
|
||||
lines.append(f"Dialogue: 3,{_ts(0)},{_ts(length)},Bar,,0,0,0,,"
|
||||
f"{{\\an7\\pos(0,{ch - h})\\p1\\1c{layout.ass_inline_color(prog['color'])}\\fscx{a:.2f}"
|
||||
f"\\t(0,{int(length * 1000)},\\fscx{b:.2f})}}{draw}{{\\p0}}")
|
||||
return header + "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
def _match_emphasis(words: list[Word], project: dict, emph: set[tuple[float, str]]) -> set[int]:
|
||||
"""Índices (em `words`, tempo de saída) das palavras marcadas com ênfase no projeto (tempo da sessão)."""
|
||||
if not emph:
|
||||
return set()
|
||||
marked = [w for w in project["captions"]["words"] if not w.get("hidden") and w["w"].strip()]
|
||||
out_times = {}
|
||||
for w in marked:
|
||||
if (round(w["s"], 3), w["w"]) in emph:
|
||||
out_times[(round(to_output((w["s"] + w["e"]) / 2, project["cuts"])[0], 2), w["w"])] = True
|
||||
result = set()
|
||||
for i, w in enumerate(words):
|
||||
mid = round((w.start + w.end) / 2, 2)
|
||||
if any(abs(mid - t) <= 0.06 and text == w.word for (t, text) in out_times):
|
||||
result.add(i)
|
||||
return result
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- filtergraph
|
||||
def zoom_filter(project: dict, t0: float = 0.0, size: tuple[int, int] = (W, H)) -> str | None:
|
||||
"""zoompan com escala por expressão do tempo de saída (`it` + t0). Rampa suave na entrada e na saída.
|
||||
`size` = tamanho do vídeo de saída (formato do corte)."""
|
||||
zooms = [o for o in project["overlays"] if o["kind"] == "zoom"]
|
||||
if not zooms:
|
||||
return None
|
||||
cuts = project["cuts"]
|
||||
z_terms, x_terms, y_terms = [], [], []
|
||||
for z in zooms:
|
||||
a, b = to_output(z["start"], cuts)[0], to_output(z["end"], cuts)[0]
|
||||
if b - a < 0.1:
|
||||
continue
|
||||
r = max(0.001, min(z["ramp"], (b - a) / 2))
|
||||
env = f"clip((T-{a:.3f})/{r:.3f},0,1)*clip(({b:.3f}-T)/{r:.3f},0,1)"
|
||||
z_terms.append(f"{z['scale'] - 1:.4f}*{env}")
|
||||
x_terms.append(f"{z['x'] - 0.5:.4f}*{env}")
|
||||
y_terms.append(f"{z['y'] - 0.5:.4f}*{env}")
|
||||
if not z_terms:
|
||||
return None
|
||||
t = f"(it+{t0:.3f})"
|
||||
zexpr = ("1+" + "+".join(z_terms)).replace("T", t)
|
||||
fx = ("0.5+" + "+".join(x_terms)).replace("T", t)
|
||||
fy = ("0.5+" + "+".join(y_terms)).replace("T", t)
|
||||
# x/y = canto do recorte; o foco (fx, fy) fica no centro do recorte, preso dentro do quadro.
|
||||
return (f"zoompan=z='{zexpr}':x='max(0,min(iw-iw/zoom,iw*({fx})-iw/zoom/2))'"
|
||||
f":y='max(0,min(ih-ih/zoom,ih*({fy})-ih/zoom/2))':d=1:s={size[0]}x{size[1]}:fps={FPS}")
|
||||
|
||||
|
||||
class AudioInput:
|
||||
"""Entrada de áudio extra (narração, música, efeito): arquivo + onde entra (tempo de saída) + volume."""
|
||||
|
||||
def __init__(self, file: Path, at: float, volume: float, kind: str, trim_start: float = 0.0, duck: float = 1.0,
|
||||
length: float = 0.0):
|
||||
self.file, self.at, self.volume, self.kind = file, at, volume, kind
|
||||
self.trim_start, self.duck, self.length = trim_start, duck, length
|
||||
|
||||
|
||||
COVER_INTRO_S = 2 / FPS # capa nos 2 primeiros quadros (as redes usam o quadro 0 como miniatura padrão)
|
||||
|
||||
|
||||
def build_filter(project: dict, cfg: dict, ps: list[Piece], in0: float, ass_name: str | None, extras: list[AudioInput],
|
||||
has_audio: bool = True, t0: float = 0.0, original_volume: float = 1.0, cover_input: int | None = None,
|
||||
ass_text: str | None = None, insets: list | None = None,
|
||||
inset_inputs: list[dict] | None = None) -> str:
|
||||
"""filter_complex completo. Entrada 0 = blocos concatenados começando em `in0` (tempo da sessão); entradas 1..N
|
||||
= `extras` na ordem; `cover_input` = índice da entrada com a imagem da capa (vai por cima dos 2 primeiros
|
||||
quadros); `ass_text` = conteúdo do ASS (com fonte empacotada, o filtro ganha `fontsdir`). `insets` =
|
||||
`reframe.InsetPlan` das camadas inseridas e `inset_inputs` = índices das entradas PNG de cada uma. O
|
||||
reenquadramento (`project.reframe`) entra por trecho no layout. Sem os dois, o grafo é o mesmo de antes.
|
||||
Saídas [v] e [a]."""
|
||||
n = len(ps)
|
||||
out_len = sum(p.length for p in ps)
|
||||
g: list[str] = []
|
||||
g.append(f"[0:v]split={n}" + "".join(f"[sv{i}]" for i in range(n)) if n > 1 else "[0:v]null[sv0]")
|
||||
if has_audio:
|
||||
g.append(f"[0:a]asplit={n}" + "".join(f"[sa{i}]" for i in range(n)) if n > 1 else "[0:a]anull[sa0]")
|
||||
for i, p in enumerate(ps):
|
||||
a, b = p.start - in0, p.end - in0
|
||||
g.append(f"[sv{i}]trim=start={a:.3f}:end={b:.3f},setpts=PTS-STARTPTS,fps={FPS}[tv{i}]")
|
||||
src = f"tv{i}"
|
||||
if insets: # as camadas recortam o quadro ORIGINAL: uma cópia do trecho vai para elas
|
||||
g.append(f"[tv{i}]split=2[tl{i}][tr{i}]")
|
||||
src = f"tl{i}"
|
||||
g.append(layout.layout_chain(cfg, src, f"pv{i}", ",setsar=1", suffix=f"_{i}", mode=p.mode,
|
||||
reframe=reframe.piece_reframe(project, p.start, p.end)))
|
||||
fade = min(0.02, p.length / 4)
|
||||
if has_audio:
|
||||
g.append(f"[sa{i}]atrim=start={a:.3f}:end={b:.3f},asetpts=PTS-STARTPTS,"
|
||||
f"aformat=sample_rates=48000:channel_layouts=stereo,"
|
||||
f"afade=t=in:d={fade:.3f},afade=t=out:st={max(0.0, p.length - fade):.3f}:d={fade:.3f}"
|
||||
+ (",volume=0" if p.muted else "") + f"[pa{i}]")
|
||||
else:
|
||||
g.append(f"aevalsrc=0|0:s=48000:d={p.length:.3f},aformat=channel_layouts=stereo[pa{i}]")
|
||||
g.append("".join(f"[pv{i}][pa{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=1[vcat][acat]")
|
||||
fw, fh = layout.frame_size(cfg)
|
||||
zoom = zoom_filter(project, t0, (fw, fh))
|
||||
last = "[v]" if cover_input is None else "[vbase]"
|
||||
head = "[vcat]"
|
||||
if insets:
|
||||
# Vídeo (com zoom) → camadas inseridas (na ordem do projeto) → texto (ASS) por cima de tudo.
|
||||
g.append("".join(f"[tr{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=0[vraw]" if n > 1 else "[tr0]null[vraw]")
|
||||
g.append(f"[vcat]{zoom or 'null'}[vzoom]")
|
||||
g += reframe.inset_graph(insets, inset_inputs or [], "vzoom", "vraw", t0, (fw, fh), "vins")
|
||||
head, zoom = "[vins]", None
|
||||
vchain = head + (f"{zoom}," if zoom else "") + (f"{layout.ass_filter(ass_name, ass_text)}," if ass_name else "") + f"fps={FPS},format=yuv420p{last}"
|
||||
g.append(vchain)
|
||||
if cover_input is not None:
|
||||
g.append(f"[{cover_input}:v]scale={fw}:{fh},setsar=1,format=yuv420p[cv]")
|
||||
g.append(f"[vbase][cv]overlay=enable='lt(t,{COVER_INTRO_S:.4f})':eof_action=pass,format=yuv420p[v]")
|
||||
|
||||
# Áudio: original (com volume e abaixado sob a narração) + narração + efeitos; música por baixo com ducking.
|
||||
narr = [(k, x) for k, x in enumerate(extras, start=1) if x.kind == "narration"]
|
||||
vol_expr = f"{original_volume:.3f}"
|
||||
for _, x in narr:
|
||||
end = x.at + (x.length or 0)
|
||||
if x.duck < 1 and x.length:
|
||||
vol_expr = f"{vol_expr}*if(between(t,{x.at:.3f},{end:.3f}),{x.duck:.3f},1)"
|
||||
g.append(f"[acat]volume='{vol_expr}':eval=frame[aorig]")
|
||||
voice_labels = ["[aorig]"]
|
||||
music_label = None
|
||||
for k, x in enumerate(extras, start=1):
|
||||
chain = f"[{k}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo"
|
||||
if x.trim_start > 0:
|
||||
chain += f",atrim=start={x.trim_start:.3f},asetpts=PTS-STARTPTS"
|
||||
chain += f",volume={x.volume:.3f}"
|
||||
if x.kind == "music":
|
||||
g.append(chain + f",atrim=end={out_len:.3f}[m{k}]")
|
||||
music_label = f"[m{k}]"
|
||||
continue
|
||||
delay = int(round(max(0.0, x.at) * 1000))
|
||||
g.append(chain + f",adelay=delays={delay}:all=1[x{k}]")
|
||||
voice_labels.append(f"[x{k}]")
|
||||
if len(voice_labels) > 1:
|
||||
g.append("".join(voice_labels) + f"amix=inputs={len(voice_labels)}:duration=first:normalize=0[voice]")
|
||||
else:
|
||||
g.append("[aorig]anull[voice]")
|
||||
if music_label:
|
||||
music = next(x for x in extras if x.kind == "music")
|
||||
if music.duck < 1: # duck guardado como 0 = sem ducking; < 1 = abaixa sob a voz
|
||||
g.append("[voice]asplit=2[voice1][side]")
|
||||
g.append(f"{music_label}[side]sidechaincompress=threshold=0.03:ratio=8:attack=20:release=350[mduck]")
|
||||
g.append("[voice1][mduck]amix=inputs=2:duration=first:normalize=0[a]")
|
||||
else:
|
||||
g.append(f"[voice]{music_label}amix=inputs=2:duration=first:normalize=0[a]")
|
||||
else:
|
||||
g.append("[voice]anull[a]")
|
||||
return ";".join(g)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- execução
|
||||
def _segments_for(segments: list[tuple[Path, float, float]], a: float, b: float) -> list[tuple[Path, float, float]]:
|
||||
return [s for s in segments if s[2] > a and s[1] < b]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- blocos de resolução/codec diferentes
|
||||
# Uma retomada pode gravar em outra qualidade (ou o streamer muda a resolução da fonte). Medido (17/11/2026, blocos
|
||||
# reais 720p60 + 1080p60 do skipnho): o concat demuxer + filter_complex corta o VÍDEO na emenda, sem erro — corte de
|
||||
# 35 s saiu com 20 s de vídeo (troca de tamanho: o FFmpeg reinicia o grafo) ou 15 s (H.264 → HEVC). Nesse caso (e só
|
||||
# nele) os blocos do trecho viram um intermediário uniforme: maior tamanho do trecho, 30 qps, quadro-chave a cada
|
||||
# 0,5 s. Trecho com blocos iguais (o normal) segue pelo caminho de sempre, idêntico.
|
||||
_STREAM_CACHE: dict[tuple[str, int, int], tuple[str, int, int, bool] | None] = {}
|
||||
|
||||
|
||||
def _stream_key(ffprobe: str, file: Path) -> tuple[str, int, int, bool] | None:
|
||||
"""(codec, largura, altura, tem áudio) do bloco, em cache pelo arquivo (caminho, tamanho, data)."""
|
||||
try:
|
||||
st = file.stat()
|
||||
except OSError:
|
||||
return None
|
||||
key = (str(file), st.st_size, int(st.st_mtime))
|
||||
if key not in _STREAM_CACHE:
|
||||
if len(_STREAM_CACHE) > 4000:
|
||||
_STREAM_CACHE.clear()
|
||||
try:
|
||||
out = media.run([ffprobe, "-v", "error", "-show_entries", "stream=codec_type,codec_name,width,height",
|
||||
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace")
|
||||
except media.MediaError:
|
||||
_STREAM_CACHE[key] = None
|
||||
return None
|
||||
video, audio = None, False
|
||||
for line in out.splitlines():
|
||||
parts = [x.strip() for x in line.split(",")]
|
||||
if "video" in parts and video is None:
|
||||
nums = [int(x) for x in parts if x.isdigit()]
|
||||
codec = next((x for x in parts if x and not x.isdigit() and x != "video"), "")
|
||||
video = (codec, nums[0], nums[1]) if len(nums) >= 2 else None
|
||||
elif "audio" in parts:
|
||||
audio = True
|
||||
_STREAM_CACHE[key] = (*video, audio) if video else None
|
||||
return _STREAM_CACHE[key]
|
||||
|
||||
|
||||
def _ffprobe_near(ffmpeg: str) -> str | None:
|
||||
"""ffprobe ao lado do ffmpeg (mesma instalação) ou no PATH."""
|
||||
sibling = Path(ffmpeg).with_name("ffprobe" + Path(ffmpeg).suffix)
|
||||
return str(sibling) if sibling.is_file() else shutil.which("ffprobe")
|
||||
|
||||
|
||||
def uniform_segments(ffmpeg: str, ffprobe: str | None, segs: list[tuple[Path, float, float]], work: Path,
|
||||
stem: str) -> tuple[list[tuple[Path, float, float]], Path | None]:
|
||||
"""Blocos do trecho num formato só. Devolve (blocos, intermediário criado ou None); quem chama apaga o arquivo."""
|
||||
if not ffprobe or len(segs) < 2:
|
||||
return segs, None
|
||||
keys = [_stream_key(ffprobe, f) for f, _, _ in segs]
|
||||
if any(k is None for k in keys) or len({k[:3] for k in keys}) == 1: # type: ignore[index]
|
||||
return segs, None
|
||||
w, h = max(((k[1], k[2]) for k in keys), key=lambda size: size[1]) # type: ignore[index]
|
||||
out = work / f"{stem}.uniform.mkv"
|
||||
args: list[str] = [ffmpeg, "-y", "-v", "error"]
|
||||
graph: list[str] = []
|
||||
for i, ((file, a, b), k) in enumerate(zip(segs, keys)):
|
||||
args += ["-i", str(file)]
|
||||
graph.append(f"[{i}:v]scale={w}:{h}:force_original_aspect_ratio=decrease,pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,"
|
||||
f"setsar=1,fps={FPS},format=yuv420p[v{i}]")
|
||||
graph.append(f"[{i}:a]aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo[a{i}]" if k[3] # type: ignore[index]
|
||||
else f"aevalsrc=0|0:s=48000:d={b - a:.3f}[a{i}]")
|
||||
graph.append("".join(f"[v{i}][a{i}]" for i in range(len(segs))) + f"concat=n={len(segs)}:v=1:a=1[v][a]")
|
||||
media.run([*args, "-filter_complex", ";".join(graph), "-map", "[v]", "-map", "[a]", "-c:v", "libx264",
|
||||
"-preset", "ultrafast", "-crf", "14", "-g", "15", "-c:a", "aac", "-b:a", "256k", str(out)], timeout=900)
|
||||
return [(out, segs[0][1], segs[-1][2])], out
|
||||
|
||||
|
||||
def _concat_input(work: Path, stem: str, segs: list[tuple[Path, float, float]], start: float, length: float) -> tuple[list[str], Path]:
|
||||
concat = work / f"{stem}.concat.txt"
|
||||
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _, _ in segs), encoding="utf-8")
|
||||
offset = max(0.0, start - segs[0][1])
|
||||
# -ss ANTES do -i (gotcha 57): os quadros chegam ao filtro com tempo 0 = `start`.
|
||||
return ["-ss", f"{offset:.3f}", "-f", "concat", "-safe", "0", "-i", concat.name, "-t", f"{length:.3f}"], concat
|
||||
|
||||
|
||||
def has_audio_stream(ffprobe: str | None, file: Path) -> bool:
|
||||
if not ffprobe:
|
||||
return True
|
||||
try:
|
||||
out = media.run([ffprobe, "-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0",
|
||||
str(file)], 30)
|
||||
except media.MediaError:
|
||||
return True
|
||||
return bool(out.strip())
|
||||
|
||||
|
||||
def render_project(ffmpeg: str, ffprobe: str | None, encoder: list[str], segments: list[tuple[Path, float, float]],
|
||||
project: dict, base_cfg: dict, credit: str, out_file: Path, repo_root: Path,
|
||||
out_range: tuple[float, float] | None = None, timeout: float = 900, chat: list | None = None,
|
||||
cover_file: Path | None = None) -> None:
|
||||
"""Renderiza o projeto (ou só a saída [a, b] para a prévia real). `segments` = (arquivo, início, fim) da sessão.
|
||||
`chat` = mensagens da sessão (para o chat na tela); `cover_file` = capa já renderizada, posta nos 2 primeiros
|
||||
quadros quando o projeto pede (`cover.atStart`)."""
|
||||
cfg = effective_settings(base_cfg, project)
|
||||
total = output_duration(project["cuts"])
|
||||
t0, t1 = out_range if out_range else (0.0, total)
|
||||
ps = slice_pieces(project["cuts"], t0, t1) if out_range else pieces(project["cuts"])
|
||||
if not ps:
|
||||
raise media.MediaError("o trecho pedido está fora do corte")
|
||||
in0, in1 = ps[0].start, ps[-1].end
|
||||
segs = _segments_for(segments, in0, in1)
|
||||
if not segs or segs[0][1] > in0 + 0.5 or segs[-1][2] < in1 - 0.5:
|
||||
raise media.MediaError("os blocos gravados deste trecho não estão mais disponíveis")
|
||||
work = out_file.parent
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
stem = out_file.stem
|
||||
segs, uniform = uniform_segments(ffmpeg, ffprobe, segs, work, stem) # emenda de resolução/codec (retomada)
|
||||
ass_file = work / f"{stem}.ass"
|
||||
ass_text = build_project_ass(project, cfg, credit, t0, t1, chat)
|
||||
ass_file.write_text(ass_text, encoding="utf-8")
|
||||
input0, concat = _concat_input(work, stem, segs, in0, in1 - in0)
|
||||
|
||||
extras: list[AudioInput] = []
|
||||
for n in project["audio"]["narration"]:
|
||||
at = to_output(n["at"], project["cuts"])[0] - t0
|
||||
if at + (n["durationS"] or 60) <= 0 or at >= t1 - t0:
|
||||
continue
|
||||
extras.append(AudioInput(repo_root / n["file"], max(0.0, at), n["volume"], "narration",
|
||||
trim_start=max(0.0, -at), duck=n["duck"], length=n["durationS"]))
|
||||
for x in project["audio"]["sfx"]:
|
||||
at = to_output(x["at"], project["cuts"])[0] - t0
|
||||
if 0 <= at < t1 - t0:
|
||||
extras.append(AudioInput(repo_root / x["file"], at, x["volume"], "sfx"))
|
||||
music = project["audio"]["music"]
|
||||
if music:
|
||||
extras.append(AudioInput(repo_root / music["file"], 0.0, music["volume"], "music", trim_start=t0,
|
||||
duck=0.5 if music["duck"] else 1.0))
|
||||
extra_args: list[str] = []
|
||||
for x in extras:
|
||||
extra_args += (["-stream_loop", "-1"] if x.kind == "music" else []) + ["-i", str(x.file)]
|
||||
|
||||
cover_input = None
|
||||
if cover_file and cover_file.is_file() and project["cover"].get("atStart") and t0 <= 0.001:
|
||||
cover_input = len(extras) + 1
|
||||
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", "1", "-i", str(cover_file)]
|
||||
# Camadas inseridas: tamanhos pela proporção do vídeo original e PNGs de máscara/borda/sombra, em loop.
|
||||
plans, inset_inputs, helper_files = [], [], []
|
||||
if any(o["kind"] == "inset" for o in project["overlays"]):
|
||||
src_size = media.probe_size(ffprobe, segs[0][0]) if ffprobe else (1280, 720)
|
||||
plans = reframe.plan_insets(project, lambda t: to_output(t, project["cuts"])[0], t0, t1,
|
||||
layout.frame_size(cfg), layout.canvas_size(cfg)[0], src_size, work, stem)
|
||||
next_input = len(extras) + 1 + (1 if cover_input is not None else 0)
|
||||
for plan in plans:
|
||||
idx = {}
|
||||
for key, file in (("mask", plan.mask_file), ("decor", plan.decor_file)):
|
||||
if file is None:
|
||||
idx[key] = None
|
||||
continue
|
||||
extra_args += ["-loop", "1", "-framerate", str(FPS), "-t", f"{t1 - t0 + 1:.3f}", "-i", file.name]
|
||||
idx[key] = next_input
|
||||
next_input += 1
|
||||
helper_files.append(file)
|
||||
inset_inputs.append(idx)
|
||||
graph = build_filter(project, cfg, ps, in0, ass_file.name, extras, has_audio_stream(ffprobe, segs[0][0]), t0,
|
||||
project["audio"]["volume"], cover_input, ass_text, plans or None, inset_inputs)
|
||||
tmp = work / f"{stem}.tmp.mp4"
|
||||
graph_file = work / f"{stem}.graph.txt"
|
||||
graph_args = ["-filter_complex", graph]
|
||||
if len(graph) > 20000: # muitos keyframes: o grafo vai por arquivo (linha de comando do Windows tem limite)
|
||||
graph_file.write_text(graph, encoding="utf-8")
|
||||
graph_args = ["-/filter_complex", graph_file.name]
|
||||
try:
|
||||
media.run([ffmpeg, "-y", "-v", "error", *input0, *extra_args, *graph_args,
|
||||
"-map", "[v]", "-map", "[a]", *encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000",
|
||||
"-t", f"{t1 - t0:.3f}", "-movflags", "+faststart", tmp.name], timeout=timeout, cwd=work)
|
||||
tmp.replace(out_file)
|
||||
finally:
|
||||
for f in (ass_file, concat, tmp, graph_file, *helper_files, *([uniform] if uniform else [])):
|
||||
f.unlink(missing_ok=True)
|
||||
|
||||
|
||||
def make_proxy(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, out_file: Path) -> None:
|
||||
"""Vídeo leve (480p, 30 fps, quadro-chave a cada 0,5 s para pular rápido) da janela [lo, hi] para o navegador."""
|
||||
segs = _segments_for(segments, lo, hi)
|
||||
if not segs:
|
||||
raise media.MediaError("nenhum bloco gravado cobre essa janela")
|
||||
work = out_file.parent
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
segs, uniform = uniform_segments(ffmpeg, _ffprobe_near(ffmpeg), segs, work, out_file.stem)
|
||||
input0, concat = _concat_input(work, out_file.stem, segs, lo, hi - lo)
|
||||
tmp = work / f"{out_file.stem}.tmp.mp4"
|
||||
try:
|
||||
# fps ANTES do scale: com a fonte em 60 qps (1080p60/1440p60) metade dos quadros nem é escalada.
|
||||
media.run([ffmpeg, "-y", "-v", "error", *input0, "-vf", f"fps={FPS},scale=-2:480", "-c:v", "libx264",
|
||||
"-preset", "veryfast", "-crf", "30", "-g", "15", "-keyint_min", "15", "-pix_fmt", "yuv420p",
|
||||
"-c:a", "aac", "-b:a", "96k", "-ac", "2", "-movflags", "+faststart", tmp.name], timeout=600, cwd=work)
|
||||
tmp.replace(out_file)
|
||||
finally:
|
||||
concat.unlink(missing_ok=True)
|
||||
tmp.unlink(missing_ok=True)
|
||||
if uniform:
|
||||
uniform.unlink(missing_ok=True)
|
||||
|
||||
|
||||
def waveform(ffmpeg: str, segments: list[tuple[Path, float, float]], lo: float, hi: float, work: Path) -> list[float]:
|
||||
"""Picos de volume (0–1) da janela, `PEAKS_PER_S` por segundo, para desenhar a forma de onda."""
|
||||
segs = _segments_for(segments, lo, hi)
|
||||
if not segs:
|
||||
return []
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
rate = 4000
|
||||
input0, concat = _concat_input(work, "waveform", segs, lo, hi - lo)
|
||||
try:
|
||||
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(rate), "-f", "s16le", "-"], 300, cwd=work)
|
||||
finally:
|
||||
concat.unlink(missing_ok=True)
|
||||
samples = array("h")
|
||||
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
|
||||
step = rate // PEAKS_PER_S
|
||||
peaks = [max((abs(v) for v in samples[i: i + step]), default=0) / 32768 for i in range(0, len(samples), step)]
|
||||
top = max(peaks, default=0) or 1
|
||||
return [round(min(1.0, (p / top) ** 0.7), 3) for p in peaks]
|
||||
|
||||
|
||||
def extract_wav(ffmpeg: str, segments: list[tuple[Path, float, float]], a: float, b: float, work: Path) -> bytes:
|
||||
"""Áudio mono 16 kHz do trecho [a, b] da sessão, em WAV (para re-transcrever)."""
|
||||
segs = _segments_for(segments, a, b)
|
||||
if not segs:
|
||||
raise media.MediaError("nenhum bloco gravado cobre esse trecho")
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
input0, concat = _concat_input(work, "retranscribe", segs, a, b - a)
|
||||
try:
|
||||
pcm = media.run([ffmpeg, "-v", "error", *input0, "-vn", "-ac", "1", "-ar", str(media.SAMPLE_RATE), "-f", "s16le", "-"],
|
||||
120, cwd=work)
|
||||
finally:
|
||||
concat.unlink(missing_ok=True)
|
||||
return media.to_wav(pcm)
|
||||
|
||||
|
||||
def render_cover(ffmpeg: str, segments: list[tuple[Path, float, float]], project: dict, base_cfg: dict, credit: str,
|
||||
out_file: Path) -> Path:
|
||||
"""Capa no formato do corte (1080×1920 ou 1920×1080; etapa 7): quadro do instante escolhido no layout do corte +
|
||||
texto curto grande no centro."""
|
||||
cfg = effective_settings(base_cfg, project)
|
||||
cover = project["cover"]
|
||||
mode = next((p.mode for p in pieces(project["cuts"]) if p.start <= cover["t"] <= p.end), None)
|
||||
if mode and mode != "auto":
|
||||
cfg["layout"]["mode"] = mode
|
||||
work = out_file.parent
|
||||
# Quadro intermediário em PNG: o mjpeg do FFmpeg 7.1 recusa yuv420p marcado como faixa "tv" (blocos do libx264).
|
||||
frame = media.grab_frame(ffmpeg, segments, cover["t"], work / f"{out_file.stem}-src.png", width=0)
|
||||
cap = {**cfg, "caption": {**cfg["caption"], "enabled": False}}
|
||||
ass = build_project_ass({**project, "captions": {**project["captions"], "enabled": False}, "overlays": [],
|
||||
"progress": {**project["progress"], "enabled": False}}, cap, credit, 0, 1)
|
||||
if cover["text"]:
|
||||
cw, ch = layout.canvas_size(cfg)
|
||||
line = (f"Dialogue: 4,{_ts(0)},{_ts(1)},Box,,0,0,0,,{{\\pos({cw // 2},{int(ch * 0.5)})\\fs110\\3c{layout.ass_inline_color(COVER_BOX)}}}"
|
||||
f"{_wrap(cover['text'].upper(), 110, cw - 120)}")
|
||||
ass = ass + line + "\n"
|
||||
try:
|
||||
media.preview_still(ffmpeg, frame, cap, ass, out_file, reframe.static_reframe(project, cover["t"]))
|
||||
finally:
|
||||
frame.unlink(missing_ok=True)
|
||||
return out_file
|
||||
@@ -0,0 +1,158 @@
|
||||
"""Emotes do chat: reconhecer, contar por canal e APRENDER quais indicam um bom momento.
|
||||
|
||||
Por quê: chat pequeno (3–5 pessoas) e público que reage com emote em vez de texto ("kkkk") faziam a heurística
|
||||
não ver nada. Agora cada mensagem leva a lista de emotes, e cada canal tem um peso aprendido por emote.
|
||||
|
||||
De onde vêm:
|
||||
- Twitch nativos: tag `emotes` do IRC (CAP twitch.tv/tags) com as posições na mensagem;
|
||||
- 7TV, BTTV e FFZ do canal + globais: APIs públicas por `room-id` (o id do canal vem nas tags do IRC);
|
||||
- emojis Unicode.
|
||||
Cada fonte externa é opcional: a que falhar (404, lenta) é ignorada e tentada de novo na próxima hora.
|
||||
|
||||
Aprendizado (por canal, tabela `emotes`):
|
||||
- `uses`: quantas vezes apareceu (contagem simples, para o painel);
|
||||
- `weight`: sobe quando o emote aparece na reação de um corte aprovado/bem avaliado, desce quando o corte é
|
||||
rejeitado/descartado. Entra no peso da mensagem na pontuação do chat.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
|
||||
import httpx
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.emotes")
|
||||
|
||||
CATALOG_TTL_S = 3600
|
||||
LEARN_UP, LEARN_DOWN = 0.3, 0.15
|
||||
WEIGHT_MIN, WEIGHT_MAX = -1.0, 3.0
|
||||
BASE_EMOTE_BONUS = 0.4 # mensagem com emote já é reação
|
||||
BONUS_MIN, BONUS_MAX = -0.5, 3.0
|
||||
|
||||
# Faixas comuns de emoji (pictogramas, símbolos, bandeiras, rostos). Não é exaustivo, só precisa pegar os de reação.
|
||||
EMOJI_RE = re.compile("[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U0001F1E6-\U0001F1FF]")
|
||||
|
||||
GLOBAL_URLS = {
|
||||
"7tv": "https://7tv.io/v3/emote-sets/global",
|
||||
"bttv": "https://api.betterttv.net/3/cached/emotes/global",
|
||||
"ffz": "https://api.frankerfacez.com/v1/set/global",
|
||||
}
|
||||
CHANNEL_URLS = {
|
||||
"7tv": "https://7tv.io/v3/users/twitch/{room}",
|
||||
"bttv": "https://api.betterttv.net/3/cached/users/twitch/{room}",
|
||||
"ffz": "https://api.frankerfacez.com/v1/room/id/{room}",
|
||||
}
|
||||
|
||||
|
||||
def parse_twitch_tag(tag_value: str, text: str) -> list[str]:
|
||||
"""`emotes=25:0-4,12-16/1902:6-10` → nomes recortados do texto (posições em code points, como o str do Python)."""
|
||||
names: list[str] = []
|
||||
if not tag_value:
|
||||
return names
|
||||
for part in tag_value.split("/"):
|
||||
if ":" not in part:
|
||||
continue
|
||||
_id, spans = part.split(":", 1)
|
||||
for span in spans.split(","):
|
||||
try:
|
||||
a, b = (int(x) for x in span.split("-"))
|
||||
except ValueError:
|
||||
continue
|
||||
if 0 <= a <= b < len(text):
|
||||
names.append(text[a: b + 1])
|
||||
return names
|
||||
|
||||
|
||||
def _names_from(source: str, data) -> list[str]:
|
||||
if source == "7tv":
|
||||
emotes = data.get("emotes") or (data.get("emote_set") or {}).get("emotes") or []
|
||||
return [e["name"] for e in emotes if isinstance(e, dict) and e.get("name")]
|
||||
if source == "bttv":
|
||||
items = data if isinstance(data, list) else (data.get("channelEmotes", []) + data.get("sharedEmotes", []))
|
||||
return [e["code"] for e in items if isinstance(e, dict) and e.get("code")]
|
||||
if source == "ffz":
|
||||
return [e["name"] for s in (data.get("sets") or {}).values() for e in s.get("emoticons", []) if e.get("name")]
|
||||
return []
|
||||
|
||||
|
||||
class EmoteCatalog:
|
||||
"""Nomes de emotes de terceiros (globais + do canal), com cache de 1 h por canal."""
|
||||
|
||||
def __init__(self, fetch=None):
|
||||
self._fetch = fetch or self._http_json
|
||||
self._lock = threading.Lock()
|
||||
self._global: dict[str, str] = {}
|
||||
self._global_at = 0.0
|
||||
self._channels: dict[str, tuple[float, dict[str, str]]] = {}
|
||||
|
||||
@staticmethod
|
||||
def _http_json(url: str):
|
||||
response = httpx.get(url, timeout=20, headers={"User-Agent": "CenaForge-Clipador"})
|
||||
if response.status_code != 200:
|
||||
return None
|
||||
return response.json()
|
||||
|
||||
def _load(self, urls: dict[str, str]) -> dict[str, str]:
|
||||
found: dict[str, str] = {}
|
||||
for source, url in urls.items():
|
||||
try:
|
||||
data = self._fetch(url)
|
||||
except Exception as exc: # noqa: BLE001 - fonte externa opcional
|
||||
log.info("emotes %s indisponível (%s)", source, type(exc).__name__)
|
||||
continue
|
||||
if data:
|
||||
for name in _names_from(source, data):
|
||||
found.setdefault(name, source)
|
||||
return found
|
||||
|
||||
def cached(self, room_id: str | None) -> dict[str, str]:
|
||||
"""O que já foi baixado, sem tocar na rede (usado na linha do chat, que não pode esperar API externa)."""
|
||||
with self._lock:
|
||||
merged = dict(self._global)
|
||||
if room_id and room_id in self._channels:
|
||||
merged.update(self._channels[room_id][1])
|
||||
return merged
|
||||
|
||||
def names(self, room_id: str | None) -> dict[str, str]:
|
||||
now = time.time()
|
||||
with self._lock:
|
||||
if now - self._global_at > CATALOG_TTL_S:
|
||||
self._global, self._global_at = self._load(GLOBAL_URLS), now
|
||||
merged = dict(self._global)
|
||||
if room_id:
|
||||
cached = self._channels.get(room_id)
|
||||
if not cached or now - cached[0] > CATALOG_TTL_S:
|
||||
cached = (now, self._load({k: v.format(room=room_id) for k, v in CHANNEL_URLS.items()}))
|
||||
self._channels[room_id] = cached
|
||||
merged.update(cached[1])
|
||||
return merged
|
||||
|
||||
|
||||
def extract(text: str, twitch_emotes: list[str], catalog: dict[str, str]) -> list[tuple[str, str]]:
|
||||
"""(nome, fonte) de cada emote da mensagem: nativos da Twitch, de terceiros (palavra exata) e emojis."""
|
||||
out: list[tuple[str, str]] = [(name, "twitch") for name in twitch_emotes]
|
||||
seen = {name for name, _ in out}
|
||||
for token in text.split():
|
||||
if token in catalog and token not in seen:
|
||||
out.append((token, catalog[token]))
|
||||
seen.add(token)
|
||||
for emoji in EMOJI_RE.findall(text):
|
||||
if emoji not in seen:
|
||||
out.append((emoji, "emoji"))
|
||||
seen.add(emoji)
|
||||
return out
|
||||
|
||||
|
||||
def message_bonus(emotes: list[str], weights: dict[str, float]) -> float:
|
||||
"""Bônus de peso da mensagem pelos emotes: base por ter emote + pesos aprendidos do canal."""
|
||||
if not emotes:
|
||||
return 0.0
|
||||
learned = sum(max(WEIGHT_MIN, min(WEIGHT_MAX, weights.get(name, 0.0))) for name in set(emotes))
|
||||
return max(BONUS_MIN, min(BONUS_MAX, BASE_EMOTE_BONUS + learned))
|
||||
|
||||
|
||||
def learn_delta(positive: bool) -> float:
|
||||
return LEARN_UP if positive else -LEARN_DOWN
|
||||
@@ -0,0 +1,761 @@
|
||||
"""Rastreio do rosto do streamer no Clipador: acha a câmera (YuNet), segue o rosto e as expressões (MediaPipe Face
|
||||
Landmarker; plano B OpenSeeFace) bloco a bloco e grava a série por segundo em `face_track`.
|
||||
|
||||
A lógica de sinal (série por segundo, z relativo ao neutro do streamer, rótulos, `locate_cam`) é pura e mora em
|
||||
`reaction.py`; aqui fica só E/S: modelos, FFmpeg, backends e banco. Decisões e números: doc/FACE_BAKEOFF.md.
|
||||
|
||||
- Modelos: baixados sob demanda (na primeira vez que o rastreio ou a detecção rodam, sempre fora da thread do chat)
|
||||
para `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`. O `setup.ps1` (passo 6b) já
|
||||
deixa tudo baixado; o download aqui é só a rede de segurança.
|
||||
- Bloco: FFmpeg recorta a câmera (+10 % de margem), escala para ~384 px no maior lado, 6 qps, `rgb24` por pipe →
|
||||
MediaPipe em modo VIDEO (um landmarker por bloco: timestamps sempre crescentes) → `reaction.per_second`.
|
||||
- Coordenadas gravadas (`cx`, `cy`, `size`) já convertidas para o QUADRO INTEIRO (0..1; `size` = altura do rosto
|
||||
como fração da altura do quadro): é o que o editor usa para reenquadrar a câmera.
|
||||
- Câmera mudou (detecção nova ou layout editado) → a série da sessão é apagada e refeita sozinha.
|
||||
|
||||
Nada daqui importa cv2/mediapipe/numpy na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import math
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
from collections.abc import Callable, Iterator
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Any, Protocol
|
||||
|
||||
from . import reaction
|
||||
from .config import CLIPPER_DIR, REPO_ROOT
|
||||
from .db import loads, now
|
||||
from .media import NO_WINDOW, MediaError, run, seek_args
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from .worker import Engine
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.face")
|
||||
|
||||
LOCK_FILE = CLIPPER_DIR / "models.lock.json"
|
||||
FPS = 6 # quadros por segundo no rastreio (bancada: 6 qps bastam para pegar a reação)
|
||||
CROP_SIDE = 384 # maior lado do recorte que vai para o modelo (256–384 dá o mesmo sinal)
|
||||
CROP_MARGIN = 0.10 # margem em volta da câmera (o streamer se inclina para fora do retângulo)
|
||||
CAM_FRAMES = 12 # quadros espalhados para achar a câmera
|
||||
DETECT_WIDTH = 1280 # largura do quadro inteiro para o YuNet
|
||||
UNAVAILABLE_RETRY_S = 300 # backend sem modelo/biblioteca: tenta de novo daqui a 5 min (não marca blocos)
|
||||
BASELINE_EXTRA_S = 240 # segundos antes da janela pedidos para o neutro do streamer (z relativo)
|
||||
MAX_LAG_BLOCKS = 2 # a decisão do corte espera o rosto do trecho, no máximo 2 blocos atrás da transcrição
|
||||
READ_TIMEOUT_S = 120.0 # prazo do FFmpeg para entregar um bloco de 30 s (medido: ~0,5 s)
|
||||
MIN_FRAMES_RATIO = 0.9 # bloco com menos de 90 % dos quadros esperados (fps × duração) é erro, não série truncada
|
||||
RESET_WAIT_S = 0.5 # o reset pedido pela API espera o bloco em andamento só isto; senão fica agendado para o laço
|
||||
|
||||
Detection = tuple[float, float, float, float, float] # x, y, w, h (px), score
|
||||
|
||||
|
||||
class FaceError(RuntimeError):
|
||||
"""Falha de um bloco (vídeo apagado, FFmpeg) ou da detecção da câmera."""
|
||||
|
||||
|
||||
class FaceUnavailable(FaceError):
|
||||
"""Backend indisponível (biblioteca ou modelo faltando, download/sha256 falhou): não é culpa do bloco."""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Modelos (download sob demanda + sha256)
|
||||
|
||||
|
||||
def sha256_of(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as fh:
|
||||
for chunk in iter(lambda: fh.read(1 << 20), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _http_download(url: str, dest: Path) -> None:
|
||||
import httpx
|
||||
|
||||
with httpx.stream("GET", url, follow_redirects=True, timeout=60) as response:
|
||||
response.raise_for_status()
|
||||
with dest.open("wb") as fh:
|
||||
for chunk in response.iter_bytes(1 << 16):
|
||||
fh.write(chunk)
|
||||
|
||||
|
||||
class ModelStore:
|
||||
"""Pesos do `models.lock.json`: confere o sha256 (uma vez por processo) e baixa o que faltar."""
|
||||
|
||||
def __init__(self, models_dir: Path, lock_file: Path = LOCK_FILE,
|
||||
fetch: Callable[[str, Path], None] | None = None):
|
||||
lock = json.loads(lock_file.read_text(encoding="utf-8"))
|
||||
self.dir = models_dir
|
||||
self.models: dict[str, dict] = {m["id"]: m for m in lock["models"]}
|
||||
self.fetch = fetch or _http_download
|
||||
self._checked: set[str] = set()
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def path(self, model_id: str) -> Path:
|
||||
info = self.models.get(model_id)
|
||||
if info is None:
|
||||
raise FaceUnavailable(f"modelo {model_id} não está no models.lock.json")
|
||||
dest = self.dir / info["file"]
|
||||
with self._lock:
|
||||
if model_id in self._checked and dest.is_file():
|
||||
return dest
|
||||
if dest.is_file() and sha256_of(dest) == info["sha256"]:
|
||||
self._checked.add(model_id)
|
||||
return dest
|
||||
# Ausente ou corrompido: baixa de novo (URL imutável do lock) e só aceita com o sha256 certo.
|
||||
self.dir.mkdir(parents=True, exist_ok=True)
|
||||
part = dest.with_name(dest.name + ".part")
|
||||
try:
|
||||
log.info("baixando o modelo %s (%s)", model_id, info["url"])
|
||||
self.fetch(info["url"], part)
|
||||
digest = sha256_of(part)
|
||||
except Exception as exc: # noqa: BLE001 - qualquer falha de rede/disco vira "indisponível"
|
||||
part.unlink(missing_ok=True)
|
||||
raise FaceUnavailable(f"não deu para baixar o modelo {info['file']}: {exc}") from exc
|
||||
if digest != info["sha256"]:
|
||||
part.unlink(missing_ok=True)
|
||||
raise FaceUnavailable(f"sha256 do modelo {info['file']} não confere (baixado {digest[:12]}…)")
|
||||
part.replace(dest)
|
||||
self._checked.add(model_id)
|
||||
return dest
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Backends
|
||||
|
||||
|
||||
class Detector(Protocol):
|
||||
def detect(self, bgr: Any) -> list[Detection]: ...
|
||||
|
||||
|
||||
class Tracker(Protocol):
|
||||
name: str
|
||||
|
||||
def process(self, t: float, rgb: Any) -> reaction.FaceSample: ...
|
||||
|
||||
def close(self) -> None: ...
|
||||
|
||||
|
||||
class YuNetDetector:
|
||||
"""Rosto no quadro inteiro (`cv2.FaceDetectorYN`, variante 2026may de entrada dinâmica)."""
|
||||
|
||||
def __init__(self, model_path: Path, score: float = 0.6):
|
||||
try:
|
||||
import cv2
|
||||
except ImportError as exc: # pragma: no cover - depende da instalação
|
||||
raise FaceUnavailable("opencv não instalado (rode o setup.bat)") from exc
|
||||
self._cv2, self._path, self._score = cv2, model_path, score
|
||||
self._det = None
|
||||
self._size: tuple[int, int] | None = None
|
||||
|
||||
def detect(self, bgr: Any) -> list[Detection]:
|
||||
h, w = bgr.shape[:2]
|
||||
if self._det is None:
|
||||
self._det = self._cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 50)
|
||||
elif self._size != (w, h):
|
||||
self._det.setInputSize((w, h))
|
||||
self._size = (w, h)
|
||||
_, faces = self._det.detect(bgr)
|
||||
if faces is None:
|
||||
return []
|
||||
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
|
||||
|
||||
|
||||
class MediaPipeTracker:
|
||||
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco.
|
||||
|
||||
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
|
||||
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
|
||||
"""
|
||||
|
||||
name = "mediapipe"
|
||||
|
||||
def __init__(self, model_path: Path):
|
||||
try:
|
||||
import mediapipe as mp
|
||||
import numpy as np
|
||||
from mediapipe.tasks.python import vision
|
||||
from mediapipe.tasks.python.core.base_options import BaseOptions
|
||||
except ImportError as exc: # pragma: no cover - depende da instalação
|
||||
raise FaceUnavailable("mediapipe não instalado (rode o setup.bat)") from exc
|
||||
self._mp, self._np = mp, np
|
||||
options = vision.FaceLandmarkerOptions(
|
||||
base_options=BaseOptions(model_asset_path=str(model_path)),
|
||||
running_mode=vision.RunningMode.VIDEO,
|
||||
num_faces=1,
|
||||
min_face_detection_confidence=0.5,
|
||||
min_face_presence_confidence=0.5,
|
||||
min_tracking_confidence=0.5,
|
||||
output_face_blendshapes=True,
|
||||
)
|
||||
self._lm = vision.FaceLandmarker.create_from_options(options)
|
||||
self._last_ms = -1
|
||||
|
||||
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
|
||||
ms = max(self._last_ms + 1, int(round(t * 1000)))
|
||||
self._last_ms = ms
|
||||
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
|
||||
result = self._lm.detect_for_video(image, ms)
|
||||
if not result.face_landmarks:
|
||||
return reaction.FaceSample(t, False)
|
||||
xs = [p.x for p in result.face_landmarks[0]]
|
||||
ys = [p.y for p in result.face_landmarks[0]]
|
||||
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
|
||||
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend)
|
||||
|
||||
def close(self) -> None:
|
||||
self._lm.close()
|
||||
|
||||
|
||||
class OpenSeeFaceTracker:
|
||||
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
|
||||
|
||||
Reimplementação mínima do `tracker.py` do commit 50c0974 (BSD-2), igual à da bancada (`tools/face_bench.py`).
|
||||
Só o canal de movimento sai daqui; usado quando o MediaPipe não carrega.
|
||||
"""
|
||||
|
||||
name = "openseeface"
|
||||
RES, OUT_RES, LOGIT = 224, 27, 16.0
|
||||
|
||||
def __init__(self, landmarks_path: Path, detector_path: Path, threshold: float = 0.6):
|
||||
try:
|
||||
import cv2
|
||||
import numpy as np
|
||||
import onnxruntime as ort
|
||||
except ImportError as exc: # pragma: no cover - depende da instalação
|
||||
raise FaceUnavailable("onnxruntime/opencv não instalados (rode o setup.bat)") from exc
|
||||
self._cv2, self._np = cv2, np
|
||||
opts = ort.SessionOptions()
|
||||
opts.inter_op_num_threads, opts.intra_op_num_threads = 1, 1
|
||||
providers = ["CPUExecutionProvider"]
|
||||
self._lm = ort.InferenceSession(str(landmarks_path), sess_options=opts, providers=providers)
|
||||
self._det = ort.InferenceSession(str(detector_path), sess_options=opts, providers=providers)
|
||||
self._lm_input = self._lm.get_inputs()[0].name
|
||||
mean, std = np.float32([0.485, 0.456, 0.406]), np.float32([0.229, 0.224, 0.225])
|
||||
self._mean, self._scale = -(mean / std), 1.0 / (std * 255.0)
|
||||
self._threshold = threshold
|
||||
self._box: tuple[float, float, float, float] | None = None
|
||||
|
||||
def _norm(self, rgb: Any, size: int) -> Any:
|
||||
im = self._cv2.resize(rgb.astype(self._np.float32), (size, size)) * self._scale + self._mean
|
||||
return self._np.transpose(im[None], (0, 3, 1, 2)).astype(self._np.float32)
|
||||
|
||||
def _detect(self, rgb: Any) -> tuple[float, float, float, float] | None:
|
||||
np = self._np
|
||||
out, maxpool = (np.array(a) for a in self._det.run([], {"input": self._norm(rgb, 224)}))
|
||||
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
|
||||
y, x = divmod(int(np.argmax(out[0, 0])), 56)
|
||||
if out[0, 0, y, x] < self._threshold:
|
||||
return None
|
||||
r = out[0, 1, y, x] * 112.0
|
||||
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
|
||||
return ((x * 4 - r) * sx, (y * 4 - r) * sy, 2 * r * sx, 2 * r * sy)
|
||||
|
||||
def _landmarks(self, rgb: Any, box: tuple[float, float, float, float]) -> tuple[float, Any]:
|
||||
np = self._np
|
||||
h, w = rgb.shape[:2]
|
||||
x, y, bw, bh = box
|
||||
x1, y1 = int(np.clip(x - bw * 0.1, 0, w - 1)), int(np.clip(y - bh * 0.125, 0, h - 1))
|
||||
x2, y2 = int(np.clip(x + bw * 1.1, 0, w - 1)), int(np.clip(y + bh * 1.125, 0, h - 1))
|
||||
if x2 - x1 < 4 or y2 - y1 < 4:
|
||||
return 0.0, None
|
||||
tensor = self._lm.run([], {self._lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
|
||||
n, res = self.OUT_RES + 1, self.RES - 1
|
||||
main = tensor[0:66].reshape(66, n * n)
|
||||
idx = main.argmax(1)[:, None]
|
||||
conf = np.take_along_axis(main, idx, 1)[:, 0]
|
||||
|
||||
def logit(v: Any) -> Any:
|
||||
v = np.clip(v, 1e-7, 1 - 1e-7)
|
||||
return np.log(v / (1 - v)) / self.LOGIT
|
||||
|
||||
off_y = np.take_along_axis(tensor[66:132].reshape(66, n * n), idx, 1)[:, 0]
|
||||
off_x = np.take_along_axis(tensor[132:198].reshape(66, n * n), idx, 1)[:, 0]
|
||||
m = idx[:, 0]
|
||||
# No original a 1ª coluna dos pontos é y; aqui já sai (x, y).
|
||||
py = y1 + (y2 - y1) / self.RES * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
|
||||
px = x1 + (x2 - x1) / self.RES * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
|
||||
return float(conf.mean()), np.stack([px, py], 1)
|
||||
|
||||
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
|
||||
box = self._box or self._detect(rgb)
|
||||
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
|
||||
if conf < self._threshold and self._box is not None:
|
||||
box = self._detect(rgb) # caixa do quadro anterior se perdeu: detector neste mesmo quadro
|
||||
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
|
||||
if pts is None or conf < self._threshold:
|
||||
self._box = None
|
||||
return reaction.FaceSample(t, False)
|
||||
(x1, y1), (x2, y2) = pts.min(0), pts.max(0)
|
||||
self._box = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
|
||||
h, w = rgb.shape[:2]
|
||||
return reaction.FaceSample(t, True, float(x1 + x2) / 2 / w, float(y1 + y2) / 2 / h, float(y2 - y1) / h, {})
|
||||
|
||||
def close(self) -> None:
|
||||
self._box = None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Vídeo (FFmpeg, sem shell, argumentos em lista)
|
||||
|
||||
|
||||
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
|
||||
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
|
||||
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace").strip().splitlines()
|
||||
if not out:
|
||||
raise FaceError(f"sem vídeo em {file.name}")
|
||||
w, h = out[0].split(",")[:2]
|
||||
return int(w), int(h)
|
||||
|
||||
|
||||
def _stop(proc: subprocess.Popen, grace: float = 10.0) -> None:
|
||||
"""Espera o processo sair; se não sair, mata e ESPERA de novo (sem processo zumbi)."""
|
||||
try:
|
||||
proc.wait(timeout=grace)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
proc.wait(timeout=grace)
|
||||
|
||||
|
||||
def read_crop(ffmpeg: str, file: Path, crop_px: tuple[int, int, int, int], out_size: tuple[int, int],
|
||||
fps: int = FPS, timeout: float = READ_TIMEOUT_S) -> Iterator[tuple[float, Any]]:
|
||||
"""Quadros RGB do recorte (x, y, w, h em px) a `fps` qps, um por vez (sem guardar o bloco na memória).
|
||||
|
||||
`fps` antes do `crop` reduz o trabalho do filtro. Devolve (segundos desde o início do bloco, H×W×3 uint8).
|
||||
Prazo total `timeout`: passou, o FFmpeg é morto. stderr é drenado numa thread (FFmpeg tagarela não trava no
|
||||
buffer do pipe). FFmpeg que sai com código ≠ 0 — inclusive morto pelo prazo — vira `FaceError`, mesmo depois de
|
||||
ter entregado alguns quadros: bloco truncado não pode ser gravado como completo.
|
||||
"""
|
||||
x, y, w, h = crop_px
|
||||
ow, oh = out_size
|
||||
args = [ffmpeg, "-v", "error", "-i", str(file), "-vf", f"fps={fps},crop={w}:{h}:{x}:{y},scale={ow}:{oh}",
|
||||
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
|
||||
return _read_frames(args, out_size, fps, timeout, file.name)
|
||||
|
||||
|
||||
def _read_frames(args: list[str], out_size: tuple[int, int], fps: int, timeout: float,
|
||||
name: str) -> Iterator[tuple[float, Any]]:
|
||||
"""Lê quadros rawvideo rgb24 do stdout de `args` (sem shell), com prazo e stderr drenado."""
|
||||
import numpy as np
|
||||
|
||||
ow, oh = out_size
|
||||
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=NO_WINDOW)
|
||||
errors: list[bytes] = []
|
||||
drain = threading.Thread(target=lambda: errors.append(proc.stderr.read()), daemon=True) # type: ignore[union-attr]
|
||||
drain.start()
|
||||
timed_out = threading.Event()
|
||||
|
||||
def kill() -> None:
|
||||
timed_out.set()
|
||||
proc.kill()
|
||||
|
||||
killer = threading.Timer(timeout, kill)
|
||||
killer.daemon = True
|
||||
killer.start()
|
||||
size = ow * oh * 3
|
||||
i = 0
|
||||
try:
|
||||
while True:
|
||||
buf = proc.stdout.read(size) # type: ignore[union-attr]
|
||||
if len(buf) < size:
|
||||
break
|
||||
yield i / fps, np.frombuffer(buf, np.uint8).reshape(oh, ow, 3).copy()
|
||||
i += 1
|
||||
finally:
|
||||
killer.cancel()
|
||||
proc.stdout.close() # type: ignore[union-attr]
|
||||
_stop(proc)
|
||||
drain.join(timeout=5)
|
||||
if proc.stderr:
|
||||
proc.stderr.close()
|
||||
if timed_out.is_set():
|
||||
raise FaceError(f"ffmpeg passou de {timeout:.0f} s lendo {name} ({i} quadros)")
|
||||
if proc.returncode != 0:
|
||||
tail = b"".join(errors).decode("utf-8", errors="replace").strip().splitlines()[-1:]
|
||||
raise FaceError(f"ffmpeg saiu com código {proc.returncode} depois de {i} quadros: {' '.join(tail)}")
|
||||
|
||||
|
||||
def grab_bgr(ffmpeg: str, file: Path, offset: float, width: int = DETECT_WIDTH) -> Any | None:
|
||||
"""Um quadro BGR do bloco, escalado para `width` de largura (altura proporcional, par)."""
|
||||
import numpy as np
|
||||
|
||||
before, select = seek_args(offset) # quadro exato (no HEVC a busca direta dava quadro cinza)
|
||||
raw = run([ffmpeg, "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-frames:v", "1",
|
||||
"-vf", f"{select},scale={width}:-2", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], 60)
|
||||
h = len(raw) // (width * 3)
|
||||
if h < 2:
|
||||
return None
|
||||
return np.frombuffer(raw[: width * h * 3], np.uint8).reshape(h, width, 3).copy()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Geometria
|
||||
|
||||
|
||||
def expand(rect: dict, margin: float = CROP_MARGIN) -> dict:
|
||||
"""Retângulo 0..1 com margem em volta, recortado no quadro."""
|
||||
mx, my = rect["w"] * margin, rect["h"] * margin
|
||||
x0, y0 = max(0.0, rect["x"] - mx), max(0.0, rect["y"] - my)
|
||||
x1, y1 = min(1.0, rect["x"] + rect["w"] + mx), min(1.0, rect["y"] + rect["h"] + my)
|
||||
return {"x": round(x0, 4), "y": round(y0, 4), "w": round(x1 - x0, 4), "h": round(y1 - y0, 4)}
|
||||
|
||||
|
||||
def crop_geometry(crop: dict, frame: tuple[int, int], side: int = CROP_SIDE) -> tuple[tuple[int, int, int, int],
|
||||
tuple[int, int]]:
|
||||
"""Recorte em px (valores pares) e tamanho de saída com o maior lado = `side`."""
|
||||
fw, fh = frame
|
||||
# Tudo par e dentro do quadro, mesmo com retângulo fora de 0..1 (layout antigo, arredondamento).
|
||||
x = min(max(0, int(crop["x"] * fw)), fw - 2) // 2 * 2
|
||||
y = min(max(0, int(crop["y"] * fh)), fh - 2) // 2 * 2
|
||||
w = max(2, min(fw - x, int(round(crop["w"] * fw))) // 2 * 2)
|
||||
h = max(2, min(fh - y, int(round(crop["h"] * fh))) // 2 * 2)
|
||||
k = side / max(w, h)
|
||||
return (x, y, w, h), (max(2, int(w * k) // 2 * 2), max(2, int(h * k) // 2 * 2))
|
||||
|
||||
|
||||
def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.FaceSecond]:
|
||||
"""Posição/tamanho do recorte → quadro inteiro (0..1). `size` vira fração da altura do quadro."""
|
||||
for s in seconds:
|
||||
if s.cx is not None:
|
||||
s.cx = crop["x"] + s.cx * crop["w"]
|
||||
if s.cy is not None:
|
||||
s.cy = crop["y"] + s.cy * crop["h"]
|
||||
if s.size is not None:
|
||||
s.size = s.size * crop["h"]
|
||||
return seconds
|
||||
|
||||
|
||||
def same_rect(a: dict | None, b: dict | None, tol: float = 1e-3) -> bool:
|
||||
if a is None or b is None:
|
||||
return a is b
|
||||
return all(abs(float(a[k]) - float(b[k])) <= tol for k in ("x", "y", "w", "h"))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Serviço
|
||||
|
||||
|
||||
class FaceService:
|
||||
"""Câmera local, rastreio por bloco e leitura da série. Uma instância por motor (`Engine.face`)."""
|
||||
|
||||
def __init__(self, engine: Engine, store: ModelStore | None = None,
|
||||
tracker_factory: Callable[[str | None], Tracker] | None = None,
|
||||
detector_factory: Callable[[], Detector] | None = None,
|
||||
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
|
||||
grabber: Callable[..., Any] | None = None,
|
||||
sizer: Callable[[Path], tuple[int, int]] | None = None):
|
||||
self.e = engine
|
||||
self.store = store or ModelStore(engine.settings.data_dir / "models")
|
||||
# Recebe o backend que a sessão já usa (None = sessão nova) e devolve o rastreador.
|
||||
self._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
|
||||
self._detector_factory = detector_factory or (lambda: YuNetDetector(self.store.path("yunet")))
|
||||
self._reader = reader or read_crop
|
||||
self._grabber = grabber or grab_bgr
|
||||
self._sizer = sizer or (lambda file: probe_size(self.e.settings.ffprobe or "ffprobe", file))
|
||||
# Tamanho do quadro POR BLOCO: uma retomada pode gravar em outra resolução (outra qualidade de captura).
|
||||
self._sizes: dict[str, tuple[int, int]] = {}
|
||||
self._busy = threading.Lock() # um bloco por vez (o laço e um reset concorrente não se atropelam)
|
||||
self._resets: set[int] = set() # resets pedidos com um bloco em andamento: o laço aplica no próximo passo
|
||||
self._resets_lock = threading.Lock()
|
||||
self._unavailable_until = 0.0
|
||||
self.backend: str | None = None
|
||||
self.last_error: str | None = None
|
||||
self.params = reaction.ReactionParams()
|
||||
|
||||
# ---------- opções / backends
|
||||
@property
|
||||
def enabled(self) -> bool:
|
||||
return bool(self.e.intel.opts.get("faceTrack", True))
|
||||
|
||||
def _default_tracker(self, backend: str | None = None) -> Tracker:
|
||||
"""MediaPipe; o plano B OpenSeeFace só numa sessão que ainda não tem série. Uma sessão nunca mistura os
|
||||
dois: sem blendshapes, o neutro do streamer ficaria zerado no meio da série e qualquer sorriso viraria pico."""
|
||||
if backend == OpenSeeFaceTracker.name:
|
||||
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
|
||||
try:
|
||||
return MediaPipeTracker(self.store.path("face_landmarker"))
|
||||
except FaceUnavailable as first:
|
||||
if backend == MediaPipeTracker.name:
|
||||
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
|
||||
log.warning("MediaPipe indisponível (%s): usando o plano B OpenSeeFace (sem expressões)", first)
|
||||
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
|
||||
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
|
||||
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
|
||||
|
||||
def session_backend(self, session_id: int) -> str | None:
|
||||
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
|
||||
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
|
||||
session_id)
|
||||
return loads(row["data_json"], {}).get("backend") if row else None
|
||||
|
||||
# ---------- câmera da sessão
|
||||
def cam_for(self, session: dict) -> tuple[dict | None, str, bool]:
|
||||
"""(retângulo 0..1 da câmera, origem, decidido?). Layout do corte primeiro (o que o usuário vê e edita);
|
||||
senão o que a detecção achou. Não decidido = a detecção ainda não rodou: o rastreio espera."""
|
||||
layout_cam = self.e.intel.settings_for(session)["layout"]["cam"]
|
||||
detected = loads(session.get("cam_json"), None) or {}
|
||||
if layout_cam:
|
||||
same = same_rect(detected.get("cam"), layout_cam)
|
||||
return layout_cam, (detected.get("source") or "ai") if same else "manual", True
|
||||
if detected.get("hasWebcam") and detected.get("cam"):
|
||||
return detected["cam"], detected.get("source") or "ai", True
|
||||
if detected:
|
||||
return None, detected.get("source") or "", True
|
||||
return None, "", False
|
||||
|
||||
def has_cam(self, session: dict) -> bool:
|
||||
cam, _, decided = self.cam_for(session)
|
||||
return decided and cam is not None
|
||||
|
||||
# ---------- laço (thread `face` do motor)
|
||||
def run_forever(self, stop: threading.Event) -> None:
|
||||
while not stop.is_set():
|
||||
worked = False
|
||||
if self.enabled and time.monotonic() >= self._unavailable_until:
|
||||
try:
|
||||
worked = self.step()
|
||||
except FaceUnavailable as exc:
|
||||
self.last_error = str(exc)[:300]
|
||||
self._unavailable_until = time.monotonic() + UNAVAILABLE_RETRY_S
|
||||
log.warning("rastreio de rosto indisponível: %s (nova tentativa em %d s)", exc, UNAVAILABLE_RETRY_S)
|
||||
except Exception as exc: # noqa: BLE001 - qualquer outra falha não pode matar a thread do rastreio
|
||||
self.last_error = str(exc)[:300]
|
||||
log.exception("rastreio de rosto: erro inesperado no laço")
|
||||
stop.wait(0.2 if worked else 10)
|
||||
|
||||
def step(self) -> bool:
|
||||
"""Processa UM bloco pendente (sessões gravando/processando primeiro). True se trabalhou."""
|
||||
db = self.e.db
|
||||
self._apply_pending_resets()
|
||||
sessions = db.all("SELECT * FROM sessions WHERE status != 'error' ORDER BY "
|
||||
"CASE WHEN status IN ('recording', 'processing', 'starting') THEN 0 ELSE 1 END, id DESC")
|
||||
for session in sessions:
|
||||
cam, _source, decided = self.cam_for(session)
|
||||
if not decided:
|
||||
continue
|
||||
self.sync_cam(session["id"], cam)
|
||||
segment = db.get(
|
||||
"SELECT s.* FROM segments s LEFT JOIN face_track f ON f.session_id = s.session_id AND f.idx = s.idx"
|
||||
" WHERE s.session_id = ? AND s.deleted = 0 AND f.idx IS NULL ORDER BY s.idx LIMIT 1", session["id"])
|
||||
if segment:
|
||||
self.process_block(session, segment, cam)
|
||||
return True
|
||||
return False
|
||||
|
||||
def sync_cam(self, session_id: int, cam: dict | None) -> bool:
|
||||
"""Câmera diferente da usada na série gravada → apaga a série (o laço refaz). True se apagou."""
|
||||
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? ORDER BY idx DESC LIMIT 1", session_id)
|
||||
if row is None or same_rect(loads(row["data_json"], {}).get("cam"), cam):
|
||||
return False
|
||||
log.info("sessão %s: câmera mudou, refazendo o rastreio do rosto", session_id)
|
||||
self.reset(session_id)
|
||||
return True
|
||||
|
||||
def reset(self, session_id: int, wait_s: float = RESET_WAIT_S) -> dict:
|
||||
"""Apaga a série da sessão. Não prende a requisição HTTP atrás de um bloco em andamento: se o laço estiver
|
||||
ocupado por mais de `wait_s`, o reset fica agendado e o laço aplica antes do próximo bloco."""
|
||||
if not self._busy.acquire(timeout=wait_s):
|
||||
with self._resets_lock:
|
||||
self._resets.add(session_id)
|
||||
return {"deleted": 0, "scheduled": True}
|
||||
try:
|
||||
with self._resets_lock:
|
||||
self._resets.discard(session_id)
|
||||
return {"deleted": self._delete(session_id), "scheduled": False}
|
||||
finally:
|
||||
self._busy.release()
|
||||
|
||||
def _delete(self, session_id: int) -> int:
|
||||
return self.e.db.run("DELETE FROM face_track WHERE session_id = ?", session_id).rowcount
|
||||
|
||||
def _apply_pending_resets(self) -> None:
|
||||
with self._resets_lock:
|
||||
pending, self._resets = self._resets, set()
|
||||
for session_id in pending:
|
||||
with self._busy:
|
||||
self._delete(session_id)
|
||||
|
||||
def process_block(self, session: dict, segment: dict, cam: dict | None) -> str:
|
||||
"""Rastreia um bloco e grava a linha de `face_track`. Devolve o status gravado."""
|
||||
sid, idx = segment["session_id"], segment["idx"]
|
||||
if cam is None:
|
||||
self._save(sid, idx, "no_cam", {"cam": None}, None)
|
||||
return "no_cam"
|
||||
first, last = math.ceil(segment["start_s"]), math.ceil(segment["end_s"])
|
||||
with self._busy:
|
||||
started = time.perf_counter()
|
||||
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
|
||||
self.backend = tracker.name
|
||||
try:
|
||||
file = REPO_ROOT / segment["file"]
|
||||
crop = expand(cam)
|
||||
px, out = crop_geometry(crop, self._frame_size(sid, file))
|
||||
samples = [tracker.process(segment["start_s"] + t, rgb)
|
||||
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)]
|
||||
except FaceUnavailable:
|
||||
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde
|
||||
except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
|
||||
log.warning("bloco %s/%s do rastreio falhou: %s", sid, idx, exc)
|
||||
self._save(sid, idx, "error", {"cam": cam}, str(exc)[:300])
|
||||
return "error"
|
||||
finally:
|
||||
tracker.close()
|
||||
expected = (segment["end_s"] - segment["start_s"]) * FPS
|
||||
if len(samples) < MIN_FRAMES_RATIO * expected - 2:
|
||||
msg = f"bloco truncado: {len(samples)} de ~{expected:.0f} quadros"
|
||||
self._save(sid, idx, "error", {"cam": cam}, msg)
|
||||
return "error"
|
||||
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
|
||||
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first), crop)
|
||||
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
|
||||
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
|
||||
"seconds": reaction.seconds_to_json(seconds)}
|
||||
self._save(sid, idx, "done", data, None)
|
||||
self.last_error = None
|
||||
return "done"
|
||||
|
||||
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
|
||||
key = str(file)
|
||||
if key not in self._sizes:
|
||||
if len(self._sizes) > 2000:
|
||||
self._sizes.clear()
|
||||
self._sizes[key] = self._sizer(file)
|
||||
return self._sizes[key]
|
||||
|
||||
def _save(self, session_id: int, idx: int, status: str, data: dict, error: str | None) -> None:
|
||||
self.e.db.run("INSERT INTO face_track (session_id, idx, status, data_json, error, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
|
||||
" ON CONFLICT (session_id, idx) DO UPDATE SET status = excluded.status, data_json = excluded.data_json,"
|
||||
" error = excluded.error, updated_at = excluded.updated_at",
|
||||
session_id, idx, status, json.dumps(data, ensure_ascii=False), error, now())
|
||||
|
||||
# ---------- leitura
|
||||
def tracked_until(self, session_id: int) -> float:
|
||||
"""Até onde (s) a série está contínua desde o início (qualquer status conta: bloco sem câmera também
|
||||
já foi "decidido")."""
|
||||
until = 0.0
|
||||
# Blocos apagados nunca ganham linha (o laço os ignora): pular, senão a série "trava" no primeiro apagado.
|
||||
for row in self.e.db.all("SELECT s.start_s, s.end_s, f.idx AS done FROM segments s LEFT JOIN face_track f"
|
||||
" ON f.session_id = s.session_id AND f.idx = s.idx WHERE s.session_id = ? AND s.deleted = 0"
|
||||
" ORDER BY s.idx",
|
||||
session_id):
|
||||
if row["done"] is None:
|
||||
break
|
||||
until = row["end_s"]
|
||||
return until
|
||||
|
||||
def dense(self, session_id: int, lo: float, hi: float) -> list[reaction.FaceSecond]:
|
||||
"""Série contínua por segundo em [floor(lo), ceil(hi)) — índice i = segundo floor(lo) + i; segundos sem
|
||||
dado (sem câmera, erro, ainda não rastreado) saem com `present` 0. É o formato que `reaction` espera."""
|
||||
first, last = max(0, int(math.floor(lo))), max(0, int(math.ceil(hi)))
|
||||
out = [reaction.FaceSecond(t) for t in range(first, last)]
|
||||
if not out:
|
||||
return out
|
||||
rows = self.e.db.all(
|
||||
"SELECT f.data_json FROM face_track f JOIN segments s ON s.session_id = f.session_id AND s.idx = f.idx"
|
||||
" WHERE f.session_id = ? AND f.status = 'done' AND s.end_s >= ? AND s.start_s < ? ORDER BY f.idx",
|
||||
session_id, first, last)
|
||||
for row in rows:
|
||||
for item in loads(row["data_json"], {}).get("seconds", []):
|
||||
i = int(item["t"]) - first
|
||||
if 0 <= i < len(out):
|
||||
out[i] = reaction.FaceSecond.from_json(item)
|
||||
return out
|
||||
|
||||
def for_scoring(self, session: dict, offset: int, duration: float) -> tuple[list[reaction.FaceSecond] | None, float]:
|
||||
"""(série alinhada à janela da pontuação — t relativo a `offset` —, até onde o rastreio chegou).
|
||||
`None` quando o rastreio está desligado ou a sessão não tem câmera: a pontuação segue como antes."""
|
||||
if not self.enabled or not self.has_cam(session):
|
||||
return None, 0.0
|
||||
seconds = self.dense(session["id"], offset, duration)
|
||||
for s in seconds:
|
||||
s.t -= offset
|
||||
return seconds, self.tracked_until(session["id"])
|
||||
|
||||
def must_wait(self, needed_until: float, face_until: float, analyzed_until: float) -> bool:
|
||||
"""Espera o rosto do trecho antes de decidir o corte — mas nunca mais que `MAX_LAG_BLOCKS` blocos atrás da
|
||||
transcrição (rastreio atrasado ou travado não segura os cortes)."""
|
||||
if time.monotonic() < self._unavailable_until:
|
||||
return False # backend fora do ar: esperar não adianta (sessão curta ficaria sem cortes até voltar)
|
||||
lag = analyzed_until - face_until
|
||||
return needed_until > face_until and lag <= MAX_LAG_BLOCKS * self.e.settings.segment_s
|
||||
|
||||
def summary(self, session: dict, lo: float, hi: float) -> str:
|
||||
"""Linha "Rosto do streamer" do prompt do analista; "" quando não há câmera/rastreio nesse trecho."""
|
||||
if not self.enabled or not self.has_cam(session):
|
||||
return ""
|
||||
# Plano B (OpenSeeFace) não mede expressão: os canais saem 0 e o texto diria "sem reação marcante" — falso.
|
||||
if self.session_backend(session["id"]) == OpenSeeFaceTracker.name:
|
||||
return ""
|
||||
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
|
||||
inside = [s for s in seconds if lo <= s.t <= hi]
|
||||
if not inside or not any(s.smile is not None for s in inside):
|
||||
return ""
|
||||
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
|
||||
|
||||
def view(self, session: dict, lo: float, hi: float | None) -> dict:
|
||||
"""Série por segundo para a API (o editor usa cx/cy/size, já no quadro inteiro, para reenquadrar)."""
|
||||
sid = session["id"]
|
||||
cam, source, decided = self.cam_for(session)
|
||||
end = session["duration_s"] if hi is None else min(hi, session["duration_s"])
|
||||
start = max(0.0, min(lo, end))
|
||||
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
|
||||
signal = reaction.reaction_signal(seconds, params=self.params)
|
||||
moments = reaction.reaction_moments(seconds, self.params)
|
||||
counts = {r["status"]: r["n"] for r in self.e.db.all(
|
||||
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
|
||||
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
|
||||
rows = []
|
||||
for s, z in zip(seconds, signal):
|
||||
if s.t < start:
|
||||
continue
|
||||
item = s.to_json()
|
||||
if z is not None:
|
||||
item["signal"] = round(z, 2)
|
||||
rows.append(item)
|
||||
return {
|
||||
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
|
||||
"cam": cam, "camSource": source, "camDecided": decided, "backend": self.backend,
|
||||
"lastError": self.last_error, "trackedUntilS": self.tracked_until(sid),
|
||||
"blocks": {"total": total, "done": counts.get("done", 0), "noCam": counts.get("no_cam", 0),
|
||||
"error": counts.get("error", 0)},
|
||||
"fromS": start, "toS": end,
|
||||
"seconds": rows,
|
||||
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
|
||||
}
|
||||
|
||||
# ---------- câmera local (YuNet + reaction.locate_cam)
|
||||
def locate(self, session: dict) -> dict:
|
||||
"""Acha a câmera olhando `CAM_FRAMES` quadros espalhados da gravação, sem IA."""
|
||||
segments = self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])
|
||||
if not segments:
|
||||
raise FaceError("sem vídeo gravado (blocos apagados?)")
|
||||
lo, hi = segments[0]["start_s"], segments[-1]["end_s"]
|
||||
margin = min(30.0, (hi - lo) * 0.05)
|
||||
span = max(0.0, hi - lo - 2 * margin)
|
||||
times = [lo + margin + span * k / max(1, CAM_FRAMES - 1) for k in range(CAM_FRAMES)]
|
||||
detector = self._detector_factory()
|
||||
detections: list[list[Detection]] = []
|
||||
size: tuple[int, int] | None = None
|
||||
ffmpeg = self.e.settings.ffmpeg or "ffmpeg"
|
||||
for t in times:
|
||||
seg = next((s for s in segments if s["start_s"] <= t < s["end_s"]), segments[-1])
|
||||
try:
|
||||
bgr = self._grabber(ffmpeg, REPO_ROOT / seg["file"], t - seg["start_s"])
|
||||
except (MediaError, OSError) as exc:
|
||||
log.info("quadro %.0fs indisponível para achar a câmera: %s", t, exc)
|
||||
continue
|
||||
if bgr is None:
|
||||
continue
|
||||
size = (bgr.shape[1], bgr.shape[0])
|
||||
detections.append(detector.detect(bgr))
|
||||
if size is None or len(detections) < 3:
|
||||
raise FaceError("poucos quadros legíveis para achar a câmera")
|
||||
result = reaction.locate_cam(detections, size[0], size[1])
|
||||
return result | {"source": "yunet", "frames": len(detections), "framesWithFace": sum(1 for d in detections if d),
|
||||
"at": now()}
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Hashtags da legenda de um corte (pedido do dono, 17/11/2026: "a IA colocar as # certas, como o jogo e a missão").
|
||||
|
||||
A legenda sai em três partes, sempre na mesma ordem:
|
||||
texto (1–2 frases da IA, sem hashtags)
|
||||
hashtags: canal → jogo (fixas, do perfil do jogo) → momento (da IA: missão, evento, modo, item, personagem)
|
||||
🎥 Créditos: link do canal
|
||||
|
||||
As do canal e do jogo não dependem da IA acertar: vêm do nome do streamer e do perfil do jogo (seção "Hashtags",
|
||||
preenchida pela pesquisa e editável no painel; sem ela, o nome do jogo vira a tag). As do momento são as que a IA
|
||||
escolheu para o trecho. Repetidas saem (sem diferenciar maiúscula e acento) e o total fica em até 8.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import unicodedata
|
||||
|
||||
MAX_TAGS = 8
|
||||
GAME_TAGS = 3
|
||||
MOMENT_TAGS = 4
|
||||
TAG_MAX_LEN = 30
|
||||
|
||||
_HASHTAG = re.compile(r"#[^\s#]+")
|
||||
_WORD = re.compile(r"[^\W_]+|_", re.UNICODE)
|
||||
|
||||
|
||||
def to_tag(text: object) -> str | None:
|
||||
"""'ROB RUN' → '#ROBRUN', 'perseguição policial' → '#PerseguiçãoPolicial', '#Lamborghini' → '#Lamborghini'.
|
||||
Sem letra (só número/símbolo) ou vazio → None."""
|
||||
words = _WORD.findall(str(text or "").strip().lstrip("#"))
|
||||
words = [w for w in words if w != "_"]
|
||||
if not words:
|
||||
return None
|
||||
if len(words) == 1:
|
||||
body = words[0]
|
||||
else:
|
||||
body = "".join(w[:1].upper() + w[1:] for w in words)
|
||||
body = body[:TAG_MAX_LEN]
|
||||
if not any(ch.isalpha() for ch in body):
|
||||
return None
|
||||
return f"#{body}"
|
||||
|
||||
|
||||
def fold(tag: str) -> str:
|
||||
"""Chave para comparar tags: sem #, sem acento, minúscula."""
|
||||
plain = unicodedata.normalize("NFKD", tag.lstrip("#"))
|
||||
return "".join(ch for ch in plain if not unicodedata.combining(ch)).casefold()
|
||||
|
||||
|
||||
def split_hashtags(text: str) -> tuple[str, list[str]]:
|
||||
"""Separa o texto das hashtags que vieram no meio dele (a IA às vezes põe mesmo pedindo para não pôr)."""
|
||||
tags = _HASHTAG.findall(text or "")
|
||||
clean = _HASHTAG.sub("", text or "")
|
||||
clean = re.sub(r"[ \t]+", " ", clean)
|
||||
clean = re.sub(r" *\n *", "\n", clean).strip()
|
||||
return clean, tags
|
||||
|
||||
|
||||
def compose(streamer: str, game: str, profile: dict | None, moment: list[str] | tuple[str, ...]) -> list[str]:
|
||||
"""Hashtags finais: canal, jogo (do perfil; senão o nome do jogo) e as do momento, sem repetidas, até 8."""
|
||||
game_tags = [t for t in (profile or {}).get("hashtags") or [] if t][:GAME_TAGS] or ([game] if game else [])
|
||||
ordered = [streamer, *game_tags, *list(moment)[:MOMENT_TAGS]]
|
||||
out: list[str] = []
|
||||
seen: set[str] = set()
|
||||
for raw in ordered:
|
||||
tag = to_tag(raw)
|
||||
if tag and fold(tag) not in seen:
|
||||
seen.add(fold(tag))
|
||||
out.append(tag)
|
||||
if len(out) >= MAX_TAGS:
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
def build_caption(text: str, tags: list[str], credit: str) -> str:
|
||||
"""Texto, hashtags e crédito, separados por linha em branco (partes vazias somem)."""
|
||||
return "\n\n".join(part for part in (text.strip(), " ".join(tags), credit.strip()) if part)
|
||||
@@ -0,0 +1,507 @@
|
||||
"""Inteligência do Clipador além da heurística: contexto do jogo, varredura da IA, webcam e emotes que aprendem.
|
||||
|
||||
Pedido do usuário (17/11/2026), depois de uma live com chat pequeno (skipnho, 0,15 msg/s) passar 15 min sem corte:
|
||||
- a IA precisa saber QUE JOGO é (categoria da plataforma, título, chat e a própria tela) e conhecer o jogo
|
||||
(pesquisa na web, guardada por jogo);
|
||||
- a IA precisa VER a tela (frames) e procurar momentos sozinha, mesmo sem pico de chat (varredura);
|
||||
- achar a webcam do streamer para o layout câmera-em-cima;
|
||||
- emotes da Twitch/7TV/BTTV/FFZ contam como reação e ganham peso por canal conforme os cortes aprovados.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from . import clip_delete, layout
|
||||
from .db import loads, now
|
||||
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
|
||||
from .face import FaceError, FaceUnavailable
|
||||
from .hashtags import fold, to_tag
|
||||
from .judge import JudgeError, build_scan_prompt, game_context
|
||||
from .scoring import fit_window
|
||||
from .sources import parse_source
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover
|
||||
from .worker import Engine
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.intel")
|
||||
|
||||
# faceTrack: rastreio do rosto do streamer (face.py) — reforça/cria cortes e vai em texto para o analista.
|
||||
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True}
|
||||
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação
|
||||
CAM_MAX_ATTEMPTS = 6 # falha sem rosto decidido (poucos quadros legíveis): no máximo isto de tentativas
|
||||
GAME_CHECK_S = 600 # rechecar a categoria da live a cada 10 min (o streamer troca de jogo)
|
||||
SCAN_FRAME_EVERY_S = 30
|
||||
SCAN_MAX_FRAMES = 7
|
||||
MEMORY_KEEP = 6
|
||||
SCAN_MAX_MOMENTS = 2
|
||||
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
|
||||
|
||||
|
||||
class CamRetryLater(JudgeError):
|
||||
"""Câmera local indisponível por um motivo passageiro (modelo/download): não é "sem câmera"."""
|
||||
|
||||
|
||||
def game_id(name: str) -> str:
|
||||
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
|
||||
|
||||
|
||||
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources")
|
||||
|
||||
|
||||
def clean_profile(raw: dict) -> dict:
|
||||
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
|
||||
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
|
||||
raw = raw if isinstance(raw, dict) else {}
|
||||
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
|
||||
for key in PROFILE_LISTS:
|
||||
items, seen = [], set()
|
||||
for item in raw.get(key) or []:
|
||||
text = str(item or "").strip()[:300]
|
||||
if key == "hashtags":
|
||||
text = to_tag(text) or ""
|
||||
if text and fold(text) not in seen:
|
||||
seen.add(fold(text))
|
||||
items.append(text)
|
||||
continue
|
||||
if text and text.lower() not in seen:
|
||||
seen.add(text.lower())
|
||||
items.append(text)
|
||||
out[key] = items[:20]
|
||||
return out
|
||||
|
||||
|
||||
class Intel:
|
||||
def __init__(self, engine: "Engine"):
|
||||
self.e = engine
|
||||
self.catalog = EmoteCatalog()
|
||||
self._weights: dict[str, tuple[float, dict[str, float]]] = {}
|
||||
self._rooms_ready: set[str] = set()
|
||||
self._game_checked: dict[int, float] = {}
|
||||
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória
|
||||
self.last_scan_error: str | None = None
|
||||
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
|
||||
self.opts = dict(OPTION_DEFAULTS)
|
||||
for key in OPTION_DEFAULTS:
|
||||
if f"opt_{key}" in saved:
|
||||
self.opts[key] = json.loads(saved[f"opt_{key}"])
|
||||
|
||||
# ---------------------------------------------------------------- opções (painel)
|
||||
def set_options(self, values: dict) -> dict:
|
||||
clean = {}
|
||||
for key, value in values.items():
|
||||
if key not in OPTION_DEFAULTS or value is None:
|
||||
continue
|
||||
if key == "scanIntervalS":
|
||||
value = int(value)
|
||||
if not 60 <= value <= 900:
|
||||
raise JudgeError("intervalo da varredura vai de 60 a 900 s")
|
||||
else:
|
||||
value = bool(value)
|
||||
clean[key] = value
|
||||
self.opts.update(clean)
|
||||
self.e.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
|
||||
[(f"opt_{k}", json.dumps(v)) for k, v in clean.items()])
|
||||
return dict(self.opts)
|
||||
|
||||
# ---------------------------------------------------------------- canal / configuração do corte
|
||||
@staticmethod
|
||||
def channel_key(session: dict) -> str:
|
||||
source = parse_source(session["url"])
|
||||
return source.channel_id if source.channel else ""
|
||||
|
||||
def settings_for(self, session: dict) -> dict:
|
||||
channel = None
|
||||
if session.get("channel_id"):
|
||||
channel = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
|
||||
return layout.merge(loads(channel["settings_json"], {}) if channel else {}, loads(session.get("settings_json"), {}))
|
||||
|
||||
# ---------------------------------------------------------------- emotes
|
||||
def ingest_chat(self, session_id: int, channel_key: str, room_id: str | None,
|
||||
batch: list[tuple[float, str, str, list[str]]]) -> None:
|
||||
if room_id:
|
||||
if room_id not in self._rooms_ready:
|
||||
self.e.db.run("UPDATE sessions SET room_id = ? WHERE id = ? AND room_id IS NULL", room_id, session_id)
|
||||
# Baixa o catálogo do canal fora da linha do chat (APIs externas podem demorar).
|
||||
self._rooms_ready.add(room_id)
|
||||
threading.Thread(target=self.catalog.names, args=(room_id,), daemon=True).start()
|
||||
catalog = self.catalog.cached(room_id)
|
||||
rows, seen = [], []
|
||||
for wall, user, text, twitch_emotes in batch:
|
||||
found = extract(text, twitch_emotes, catalog)
|
||||
rows.append((session_id, wall, user, text, json.dumps([n for n, _ in found], ensure_ascii=False) if found else None))
|
||||
seen.extend(found)
|
||||
self.e.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, ?, ?, ?)", rows)
|
||||
if channel_key and seen:
|
||||
ts = now()
|
||||
self.e.db.many(
|
||||
"INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES (?, ?, ?, 1, 0, ?, ?)"
|
||||
" ON CONFLICT (channel_key, name) DO UPDATE SET uses = uses + 1, last_seen = excluded.last_seen",
|
||||
[(channel_key, name, source, ts, ts) for name, source in seen])
|
||||
|
||||
def weights(self, channel_key: str) -> dict[str, float]:
|
||||
cached = self._weights.get(channel_key)
|
||||
if cached and time.time() - cached[0] < 30:
|
||||
return cached[1]
|
||||
rows = self.e.db.all("SELECT name, weight FROM emotes WHERE channel_key = ? AND weight != 0", channel_key)
|
||||
weights = {r["name"]: r["weight"] for r in rows}
|
||||
self._weights[channel_key] = (time.time(), weights)
|
||||
return weights
|
||||
|
||||
def bonus(self, emotes: list[str], channel_key: str) -> float:
|
||||
return message_bonus(emotes, self.weights(channel_key)) if emotes else 0.0
|
||||
|
||||
def learn_from_clip(self, clip: dict, positive: bool, factor: float = 1.0, mark: bool = False) -> int:
|
||||
"""Emotes da reação do corte (−10 s a +6 s do pico) ganham (aprovado) ou perdem (rejeitado) peso no canal."""
|
||||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
|
||||
if not session or (mark and clip.get("learned")):
|
||||
return 0
|
||||
key = self.channel_key(session)
|
||||
if not key:
|
||||
return 0
|
||||
tl = self.e.load_timeline(session["id"], max(0.0, clip["peak_s"] - 120))
|
||||
names = {e for m in tl["chat"] if clip["peak_s"] - 10 <= m.t <= clip["peak_s"] + 6 for e in m.emotes}
|
||||
delta = learn_delta(positive) * factor
|
||||
self.e.db.many("UPDATE emotes SET weight = MAX(-1.0, MIN(3.0, weight + ?)) WHERE channel_key = ? AND name = ?",
|
||||
[(delta, key, n) for n in names])
|
||||
if mark:
|
||||
self.e.db.run("UPDATE clips SET learned = 1 WHERE id = ?", clip["id"])
|
||||
self._weights.pop(key, None)
|
||||
return len(names)
|
||||
|
||||
# ---------------------------------------------------------------- jogo
|
||||
def check_game(self, session: dict, force: bool = False) -> None:
|
||||
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo."""
|
||||
if session["kind"] != "live":
|
||||
return
|
||||
last = self._game_checked.get(session["id"], 0)
|
||||
if not force and time.time() - last < GAME_CHECK_S:
|
||||
return
|
||||
self._game_checked[session["id"]] = time.time()
|
||||
meta = self.e.check_meta(session["url"])
|
||||
if not meta:
|
||||
return
|
||||
if meta.get("title") and not session.get("title"):
|
||||
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
|
||||
category = (meta.get("category") or "").strip()
|
||||
if category and category != session.get("game") and session.get("game_source") != "user":
|
||||
self.set_game(session["id"], category, "platform")
|
||||
|
||||
def set_game(self, session_id: int, name: str, source: str) -> None:
|
||||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||||
if not session:
|
||||
return
|
||||
history = loads(session["games_json"], [])
|
||||
history.append({"game": name, "source": source, "atS": session["duration_s"], "at": now()})
|
||||
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
|
||||
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
|
||||
gid = game_id(name)
|
||||
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
|
||||
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
|
||||
|
||||
def research_pending(self) -> None:
|
||||
if not self.e.judge.enabled:
|
||||
return # IA desligada: o jogo fica 'pending' até ligar (antes: um WARNING no log a cada 30 s)
|
||||
for game in self.e.db.all("SELECT * FROM games WHERE status = 'pending' LIMIT 1"):
|
||||
self.research(game["id"])
|
||||
|
||||
def research(self, gid: str) -> dict:
|
||||
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||||
if not game:
|
||||
raise JudgeError("jogo não encontrado")
|
||||
if not self.e.judge.enabled:
|
||||
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo")
|
||||
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
|
||||
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
|
||||
try:
|
||||
profile = self.e.judge.research_game(game["name"], title, notes)
|
||||
except (JudgeError, json.JSONDecodeError) as exc:
|
||||
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
|
||||
raise JudgeError(str(exc)) from exc
|
||||
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?",
|
||||
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid)
|
||||
return profile
|
||||
|
||||
def save_profile(self, gid: str, profile: dict) -> dict:
|
||||
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready')."""
|
||||
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
|
||||
raise JudgeError("jogo não encontrado")
|
||||
clean = clean_profile(profile)
|
||||
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?",
|
||||
json.dumps(clean, ensure_ascii=False), now(), gid)
|
||||
return clean
|
||||
|
||||
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
|
||||
history: list[dict] | None = None) -> tuple[dict, str]:
|
||||
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
|
||||
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
|
||||
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||||
if not game:
|
||||
raise JudgeError("jogo não encontrado")
|
||||
if not self.e.judge.enabled:
|
||||
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA")
|
||||
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]})
|
||||
try:
|
||||
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
|
||||
except json.JSONDecodeError as exc:
|
||||
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
|
||||
reply = str(data.get("reply") or "").strip()[:600]
|
||||
profile = clean_profile(data)
|
||||
notes = loads(game.get("notes_json"), [])
|
||||
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
|
||||
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?,"
|
||||
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False),
|
||||
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid)
|
||||
return profile, reply
|
||||
|
||||
def delete_note(self, gid: str, index: int) -> None:
|
||||
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
|
||||
game = self.e.db.get("SELECT notes_json FROM games WHERE id = ?", gid)
|
||||
if not game:
|
||||
raise JudgeError("jogo não encontrado")
|
||||
notes = loads(game["notes_json"], [])
|
||||
if 0 <= index < len(notes):
|
||||
notes.pop(index)
|
||||
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
|
||||
|
||||
def profile(self, name: str) -> dict | None:
|
||||
if not name:
|
||||
return None
|
||||
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name))
|
||||
return loads(row["profile_json"], None) if row else None
|
||||
|
||||
def session_game(self, session: dict) -> tuple[str, dict | None]:
|
||||
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
|
||||
senão a categoria e, sem perfil dela, o jogo que a IA viu na tela."""
|
||||
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
|
||||
game, screen = session.get("game") or "", session.get("screen_game") or ""
|
||||
profile = self.profile(game)
|
||||
if profile or confirmed:
|
||||
return game, profile
|
||||
screen_profile = self.profile(screen) if screen.lower() not in ("", "desconhecido") else None
|
||||
return (screen, screen_profile) if screen_profile else (game or ("" if screen.lower() == "desconhecido" else screen), None)
|
||||
|
||||
def context(self, session: dict) -> str:
|
||||
memory = loads(session.get("memory_json"), [])
|
||||
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
|
||||
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
|
||||
return game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
|
||||
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed)
|
||||
|
||||
# ---------------------------------------------------------------- frames
|
||||
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
|
||||
if not self.opts["vision"]:
|
||||
return []
|
||||
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
|
||||
for s in self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])]
|
||||
out_dir = self.e.repo_path(session["dir"]) / "frames"
|
||||
frames = []
|
||||
for t in times:
|
||||
try:
|
||||
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
|
||||
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
|
||||
log.info("frame %.0fs indisponível: %s", t, exc)
|
||||
return frames
|
||||
|
||||
# ---------------------------------------------------------------- webcam
|
||||
def maybe_detect_cam(self, session: dict) -> None:
|
||||
"""Acha a câmera no início da sessão. A detecção local (YuNet) não precisa de IA, visão nem juiz ligados."""
|
||||
if not self.opts["camDetect"] or time.time() < self._cam_retry_at.get(session["id"], 0.0):
|
||||
return
|
||||
saved = loads(session.get("cam_json"), None)
|
||||
# Sem rosto na 1ª olhada (tela de "já volto" no começo da live): tenta de novo mais tarde enquanto grava.
|
||||
# Falha sem rosto decidido (poucos quadros legíveis): tenta de novo pelo relógio, também em VOD/sessão parada.
|
||||
due = saved and ((saved.get("retryAfterS") and session["duration_s"] >= saved["retryAfterS"])
|
||||
or (saved.get("retryAt") is not None and time.time() >= saved["retryAt"]
|
||||
and saved.get("attempts", 1) < CAM_MAX_ATTEMPTS))
|
||||
if saved and not due:
|
||||
return
|
||||
analyzed = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 1", session["id"])["n"]
|
||||
if analyzed < 2:
|
||||
return
|
||||
if self.settings_for(session)["layout"]["cam"]:
|
||||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
|
||||
json.dumps({"skipped": "já definida", "source": "manual"}), session["id"])
|
||||
return
|
||||
try:
|
||||
self.detect_cam(session["id"], apply=True)
|
||||
except CamRetryLater as exc:
|
||||
# Modelo indisponível/download falhou: nada a ver com a live. Não grava "sem câmera" (seria permanente e
|
||||
# o rastreio marcaria tudo no_cam); tenta de novo em 5 min.
|
||||
self._cam_retry_at[session["id"]] = time.time() + CAM_RETRY_S
|
||||
log.warning("câmera da sessão %s: %s (nova tentativa em %d s)", session["id"], exc, CAM_RETRY_S)
|
||||
except JudgeError as exc:
|
||||
# Sem frame legível e sem IA: registra para não repetir a cada 30 s, com nova tentativa marcada
|
||||
# (por tempo de gravação enquanto grava; pelo relógio em qualquer estado, até CAM_MAX_ATTEMPTS vezes).
|
||||
attempts = (saved or {}).get("attempts", 0) + 1
|
||||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(
|
||||
{"hasWebcam": False, "cam": None, "source": "yunet", "error": str(exc)[:200], "at": now(),
|
||||
"retryAt": time.time() + CAM_RETRY_S, "attempts": attempts,
|
||||
**({"retryAfterS": session["duration_s"] + CAM_RETRY_S} if session["status"] == "recording" else {})},
|
||||
ensure_ascii=False), session["id"])
|
||||
|
||||
def detect_cam(self, session_id: int, apply: bool = False, use_ai: bool = False) -> dict:
|
||||
"""Onde está a webcam. Primeiro local (YuNet + reaction.locate_cam, sem custo de IA); a IA só entra se o
|
||||
local não achar rosto (e a IA estiver ligada com visão) ou se pedirem (`use_ai`). `cam_json.source` diz
|
||||
quem achou: yunet | ai | manual."""
|
||||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||||
if not session or session["duration_s"] < 5:
|
||||
raise JudgeError("gravação curta demais para achar a câmera")
|
||||
ai_ready = self.opts["vision"] and self.e.judge.enabled
|
||||
local, local_error, transient = None, "", False
|
||||
if not use_ai:
|
||||
try:
|
||||
local = self.e.face.locate(session)
|
||||
except FaceUnavailable as exc: # modelo/biblioteca/download: passageiro, não é "sem câmera"
|
||||
local_error, transient = str(exc), True
|
||||
log.info("câmera local da sessão %s indisponível: %s", session_id, exc)
|
||||
except FaceError as exc:
|
||||
local_error = str(exc)
|
||||
log.info("câmera local da sessão %s falhou: %s", session_id, exc)
|
||||
if local is not None and (local["hasWebcam"] or not ai_ready):
|
||||
result = local
|
||||
if not local["hasWebcam"] and session["status"] == "recording":
|
||||
result["retryAfterS"] = session["duration_s"] + CAM_RETRY_S
|
||||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
|
||||
# Câmera em tela cheia (só o streamer) não vira layout câmera-em-cima; o rastreio usa o quadro inteiro.
|
||||
if local["hasWebcam"] and not local["fullFrame"] and apply:
|
||||
try:
|
||||
rect = layout.validate({"layout": {"cam": local["cam"]}})["layout"]["cam"]
|
||||
except layout.LayoutError:
|
||||
rect = None
|
||||
if rect:
|
||||
self._apply_cam(session, rect)
|
||||
return result
|
||||
if not ai_ready:
|
||||
if transient:
|
||||
raise CamRetryLater(f"detector de rosto indisponível agora ({local_error}); tente de novo em instantes")
|
||||
raise JudgeError(f"não deu para achar a câmera sem a IA ({local_error or 'sem rosto'}); ligue a visão ou marque à mão")
|
||||
d = session["duration_s"]
|
||||
frames = self.frames(session, [d * 0.25, d * 0.55, max(1.0, d - 8)], "cam")
|
||||
if not frames:
|
||||
raise JudgeError("sem frames (visão desligada ou blocos apagados)")
|
||||
data = self.e.judge.detect_cam([p for _, p in frames])
|
||||
rect = None
|
||||
if data.get("has_webcam"):
|
||||
try:
|
||||
rect = layout.validate({"layout": {"cam": {k: data[k] for k in ("x", "y", "w", "h")}}})["layout"]["cam"]
|
||||
except layout.LayoutError:
|
||||
rect = None
|
||||
result = {"hasWebcam": bool(data.get("has_webcam")), "cam": rect, "gameOnScreen": data.get("game_on_screen", ""),
|
||||
"frame": self.e.rel(frames[-1][1]), "at": now(), "source": "ai"}
|
||||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
|
||||
if rect and apply:
|
||||
self._apply_cam(session, rect)
|
||||
if result["gameOnScreen"] and result["gameOnScreen"].lower() not in ("desconhecido", "não identificável"):
|
||||
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", result["gameOnScreen"][:120], session_id)
|
||||
return result
|
||||
|
||||
def _apply_cam(self, session: dict, rect: dict) -> None:
|
||||
"""Câmera achada vira padrão do canal (se o canal não tiver uma); sem canal, vale para a sessão."""
|
||||
if session.get("channel_id"):
|
||||
row = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
|
||||
current = loads(row["settings_json"], {}) if row else {}
|
||||
if row and not (current.get("layout") or {}).get("cam"):
|
||||
current.setdefault("layout", {})["cam"] = rect
|
||||
self.e.db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(current), session["channel_id"])
|
||||
return
|
||||
current = loads(session.get("settings_json"), {})
|
||||
if not (current.get("layout") or {}).get("cam"):
|
||||
current.setdefault("layout", {})["cam"] = rect
|
||||
self.e.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(current), session["id"])
|
||||
|
||||
# ---------------------------------------------------------------- varredura
|
||||
def scan_due(self, session: dict, analyzed_until: float) -> tuple[float, float] | None:
|
||||
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
|
||||
return None
|
||||
if session["status"] == "recording" and session["kind"] == "vod":
|
||||
return None # VOD baixa mais rápido que o tempo real: varre quando terminar
|
||||
lo = session["scanned_until"]
|
||||
hi = lo + self.opts["scanIntervalS"]
|
||||
if hi <= analyzed_until:
|
||||
return lo, hi
|
||||
if session["status"] in ("processing", "stopped") and analyzed_until - lo >= 20:
|
||||
return lo, analyzed_until # fim da gravação: varre o resto
|
||||
return None
|
||||
|
||||
def scan_session(self, session: dict) -> int | None:
|
||||
"""Varre a próxima janela pronta. None = nada a varrer agora; senão, quantos cortes criou."""
|
||||
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
|
||||
return None
|
||||
tl = self.e.load_timeline(session["id"], max(0.0, session["scanned_until"] - 200))
|
||||
window = self.scan_due(session, tl["analyzedUntil"])
|
||||
if not window:
|
||||
return None
|
||||
lo, hi = window
|
||||
cfg = self.settings_for(session)
|
||||
dur = cfg["duration"]
|
||||
back_lo = max(0.0, lo - dur["backtrackS"])
|
||||
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
|
||||
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
|
||||
frames = self.frames(session, times, "scan")
|
||||
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all(
|
||||
"SELECT start_s, end_s, title FROM clips WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], back_lo, hi)]
|
||||
existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
|
||||
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
|
||||
tl["chat"], self.context(session), frames, existing, dur["minS"], dur["maxS"])
|
||||
created = 0
|
||||
try:
|
||||
data = self.e.judge.scan(prompt, [p for _, p in frames])
|
||||
self.last_scan_error = None
|
||||
except (JudgeError, json.JSONDecodeError) as exc:
|
||||
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
|
||||
self.last_scan_error = str(exc)[:300]
|
||||
log.warning("varredura %s %.0f–%.0fs falhou: %s", session["id"], lo, hi, exc)
|
||||
data = {"moments": [], "summary": "", "screen_game": ""}
|
||||
proposals = data.get("moments", [])[:SCAN_MAX_MOMENTS]
|
||||
for moment in proposals:
|
||||
if self._insert_scan_moment(session, moment, back_lo, hi, dur, existing):
|
||||
created += 1
|
||||
# Quantas propostas a IA fez e quantas viraram candidato (as outras: nota < SCAN_MIN_PROPOSAL, curtas ou em
|
||||
# cima de um corte). Antes não ficava registrado (diagnóstico de 17/11/2026: impossível saber se a varredura
|
||||
# não propôs nada ou se foi barrada).
|
||||
log.info("varredura %s %.0f–%.0fs: %d proposta(s), %d candidato(s)", session["id"], lo, hi, len(proposals), created)
|
||||
memory = loads(session.get("memory_json"), [])
|
||||
if data.get("summary") or proposals:
|
||||
memory.append({"fromS": lo, "toS": hi, "summary": str(data.get("summary") or "")[:240],
|
||||
"proposals": len(proposals), "created": created})
|
||||
screen = str(data.get("screen_game") or "")
|
||||
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel"):
|
||||
screen = ""
|
||||
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?",
|
||||
hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
|
||||
if screen and not session.get("game"):
|
||||
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela
|
||||
return created
|
||||
|
||||
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
|
||||
"""Momento proposto pela varredura vira CANDIDATO: passa pelos dois juízes (analista + editor) como os do chat."""
|
||||
try:
|
||||
# Mínimo + 1 s de verdade: se o fim bate no fim da janela, o início recua (fit_window).
|
||||
start, end = fit_window(float(m["start_s"]), float(m["end_s"]), lo, hi,
|
||||
layout.min_target({"duration": dur}), float(dur["maxS"]), keep="start")
|
||||
score = max(0.0, min(10.0, float(m["score"])))
|
||||
except (KeyError, TypeError, ValueError):
|
||||
return False
|
||||
if end - start < min(10.0, dur["minS"]) or score < SCAN_MIN_PROPOSAL:
|
||||
return False
|
||||
from .scoring import overlaps # import local: evita ciclo na carga do módulo
|
||||
|
||||
if any(overlaps(start, end, a, b) for a, b, _ in existing):
|
||||
return False
|
||||
ts = now()
|
||||
reasons = {"via": "varredura", "scanFromS": lo, "scanToS": hi, "proposalScore": score,
|
||||
"proposalTitle": str(m.get("title", ""))[:100], "proposalReason": str(m.get("reason", ""))[:300]}
|
||||
self.e.db.run(
|
||||
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
|
||||
" VALUES (?, ?, ?, ?, ?, 'ai', ?, 'candidate', ?, ?)",
|
||||
session["id"], round((start + end) / 2, 2), round(start, 2), round(end, 2), score,
|
||||
json.dumps(reasons, ensure_ascii=False), ts, ts)
|
||||
existing.append((start, end, ""))
|
||||
return True
|
||||
@@ -0,0 +1,640 @@
|
||||
"""IA do Clipador pelas CLIs já logadas no PC (Codex/GPT por padrão, ou Claude) — sem chave de API.
|
||||
|
||||
Quatro usos, todos com saída JSON validada por schema:
|
||||
1. **juiz** de candidato (chat/áudio apontaram): manter/descartar, nota, início/fim, título e legenda. Vê a
|
||||
transcrição com bastante tempo para trás (o comentário vem DEPOIS da ação), o chat, os emotes, o perfil do
|
||||
jogo e FRAMES da tela.
|
||||
2. **varredura**: a cada poucos minutos de gravação a IA olha a janela inteira (fala + tela + chat) e propõe
|
||||
momentos mesmo sem pico de chat — essencial em live pequena (3–5 pessoas) ou chat que reage pouco.
|
||||
3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades.
|
||||
4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima.
|
||||
|
||||
Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`) ou `claude`
|
||||
(`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
from . import layout
|
||||
from .scoring import ChatMessage, Word, fit_window
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.judge")
|
||||
|
||||
PROVIDERS = ("codex", "claude", "off")
|
||||
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku"}
|
||||
CLAUDE_MODELS = [
|
||||
{"id": "haiku", "label": "Haiku (mais barato)"},
|
||||
{"id": "sonnet", "label": "Sonnet (equilíbrio)"},
|
||||
{"id": "opus", "label": "Opus (mais capaz, mais caro)"},
|
||||
]
|
||||
CONTEXT_AFTER_S = 15.0
|
||||
# Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min.
|
||||
DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"])
|
||||
DEFAULT_MAX_S = float(layout.DEFAULTS["duration"]["maxS"])
|
||||
DEFAULT_BACKTRACK_S = float(layout.DEFAULTS["duration"]["backtrackS"])
|
||||
TIMEOUT_S, RESEARCH_TIMEOUT_S = 240, 420
|
||||
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
|
||||
|
||||
# Economia de tokens (medido em 17/11/2026, codex-cli 0.169.0): cada chamada do juiz é um processo novo e
|
||||
# pagava ~77 mil caracteres fixos (~19 mil tokens) antes do prompt — instruções de agente de código (18 mil),
|
||||
# ferramentas (46 mil: exec, plugins, computer-use) e listas de skills/apps. Uma live de 3,7 h = 150 chamadas.
|
||||
# Sem busca na web o juiz não usa ferramenta nenhuma (as imagens vão por `-i`), então: o texto do juiz
|
||||
# substitui as instruções de base e os recursos com ferramentas saem. Resultado: ~35 mil caracteres fixos.
|
||||
# Com `--search` (pesquisa de jogo) só saem os extras; a web do Codex depende das ferramentas de execução.
|
||||
CODEX_TOOL_FEATURES = ("plugins", "apps", "shell_tool", "unified_exec", "code_mode_host", "sleep_tool",
|
||||
"skill_search", "tool_suggest", "in_app_browser", "browser_use")
|
||||
CODEX_EXTRA_FEATURES = ("computer_use", "image_generation", "goals", "hooks")
|
||||
CODEX_UNUSED_PLUGINS = ("computer-use@openai-bundled", "unified-computer-use@openai-bundled")
|
||||
|
||||
|
||||
def codex_lean_overrides(search: bool, config_file: Path | None = None) -> list[str]:
|
||||
"""Overrides `-c` só para esta chamada (a config global do Codex não muda)."""
|
||||
features = CODEX_EXTRA_FEATURES + (() if search else CODEX_TOOL_FEATURES)
|
||||
overrides = [f"features.{name}=false" for name in features]
|
||||
try:
|
||||
config = (config_file or Path.home() / ".codex" / "config.toml").read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
config = ""
|
||||
# `-c mcp_servers={}` não desliga (o Codex mescla tabelas): é preciso `enabled=false` por servidor.
|
||||
for name in dict.fromkeys(re.findall(r'^\s*\[mcp_servers\.("?)([A-Za-z0-9_-]+)\1\]\s*$', config, re.M)):
|
||||
overrides.append(f"mcp_servers.{name[1]}.enabled=false")
|
||||
for plugin in CODEX_UNUSED_PLUGINS:
|
||||
if f'[plugins."{plugin}"]' in config:
|
||||
overrides.append(f'plugins."{plugin}".enabled=false')
|
||||
return [arg for item in overrides for arg in ("-c", item)]
|
||||
|
||||
# ---------------------------------------------------------------- guia editorial (pesquisa de 16–17/11/2026)
|
||||
CLIP_GUIDE = """O que faz um bom corte de live (pesquisa de mercado, 2026):
|
||||
- Abre no momento forte: o espectador decide em 1–2 s. Nada de "como eu tava falando".
|
||||
- Se explica sozinho: quem nunca viu a live entende em poucos segundos (contexto mínimo no começo).
|
||||
- Rende corte: reação forte (susto, risada, raiva), jogada absurda/virada, falha engraçada, treta, história que
|
||||
se desenrola, fala marcante, e INFORMAÇÃO NOVA DO JOGO (mecânica, segredo, novidade, comparação) — em
|
||||
lançamentos (ex.: GTA 6) informação vale tanto quanto reação.
|
||||
- Não rende: espera, menu/loading, leitura de doação/propaganda, conversa sem gancho, piada interna da live.
|
||||
- TEMPO: o streamer costuma comentar DEPOIS da ação. Volte até o início da AÇÃO que motivou o comentário (pode
|
||||
ser de 20 s a 2 min antes da fala, até o limite de volta informado) — o corte precisa mostrar a ação e a reação.
|
||||
- Corte justo: termina logo depois do pagamento (reação/resolução)."""
|
||||
|
||||
# Gírias/memes do chat (BR/Twitch) que mudam o sentido do momento. O analista interpreta com o contexto.
|
||||
CHAT_GLOSSARY = """Gírias comuns do chat (interprete pelo contexto):
|
||||
- "server chinês", "ping", "lag", "travou/travando", "exit lag", "bugou", "rubberband", "teleportou" → o jogo ou a
|
||||
live está travando/com atraso (personagem pulando de lugar, morrendo do nada) — a graça é o lag.
|
||||
- "kkkk", "KEKW", "LUL", "OMEGALUL", "ICANT", "PepeLaugh" → risada; "?????" → confusão/não entenderam;
|
||||
"F" → morte/perda/luto; "W"/"L" → vitória/derrota; "Pog/POGGERS" → impressionados; "monkaS/monkaW" → tensão;
|
||||
"clipa/clip it" → pedido de corte; "hack/hackudo" → suspeita de trapaça; "gg" → fim de partida.
|
||||
- Emotes próprios do canal (prefixo do streamer, ex.: skpPog) carregam a mesma reação do emote original."""
|
||||
|
||||
SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada",
|
||||
"historia", "informacao_do_jogo", "reacao", "outro")
|
||||
|
||||
ANALYSIS_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"situation": {"type": "string", "enum": list(SITUATIONS)},
|
||||
"what_happened": {"type": "string"},
|
||||
"screen": {"type": "string"},
|
||||
"speech": {"type": "string"},
|
||||
"chat_meaning": {"type": "string"},
|
||||
"confidence": {"type": "number"},
|
||||
"action_start_s": {"type": "number"},
|
||||
"reaction_end_s": {"type": "number"},
|
||||
"hook": {"type": "string"},
|
||||
},
|
||||
"required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence",
|
||||
"action_start_s", "reaction_end_s", "hook"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
|
||||
ANALYST_SYSTEM = """Você é o ANALISTA de uma equipe de cortes de live. Não escreve título: descreve com fidelidade
|
||||
O QUE ACONTECEU no trecho, para o editor decidir. Recebe contexto do jogo, transcrição com tempos, FRAMES da tela
|
||||
com o instante de cada um e o chat.
|
||||
|
||||
Cruze as três fontes antes de concluir: a fala sozinha engana (ex.: "tô jogando três jogos… morri, morri" junto
|
||||
de chat "server chinês?/kkkk" e a tela pulando = o jogo está travando e ele morre por causa do lag, não está
|
||||
jogando três jogos). O chat reage alguns segundos depois do acontecimento.
|
||||
|
||||
""" + CHAT_GLOSSARY + """
|
||||
|
||||
Campos:
|
||||
- situation: o tipo do momento (um da lista).
|
||||
- what_happened: 2–3 frases factuais do que aconteceu, na ordem, sem exagero.
|
||||
- screen: o que os frames mostram (cite o nº do frame) — ou "frames não ajudam".
|
||||
- speech: o que a fala revela (cite o instante).
|
||||
- chat_meaning: o que o chat está dizendo/rindo e por quê.
|
||||
- confidence: 0–1, quanto você tem certeza da interpretação (baixe se as fontes não batem).
|
||||
- action_start_s: instante (s da gravação) em que começa a AÇÃO que gerou a reação (pode ser antes da fala).
|
||||
- reaction_end_s: instante em que a reação/pagamento termina.
|
||||
- hook: o que prenderia alguém nos 2 primeiros segundos do corte.
|
||||
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
|
||||
|
||||
VERDICT_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"keep": {"type": "boolean"},
|
||||
"score": {"type": "number"},
|
||||
"start_s": {"type": "number"},
|
||||
"end_s": {"type": "number"},
|
||||
"title": {"type": "string"},
|
||||
"caption": {"type": "string"},
|
||||
"hashtags": {"type": "array", "items": {"type": "string"}},
|
||||
"reason": {"type": "string"},
|
||||
},
|
||||
"required": ["keep", "score", "start_s", "end_s", "title", "caption", "hashtags", "reason"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
|
||||
# A varredura só aponta momentos (o juiz escreve título/legenda/hashtags depois): sem `keep` e sem `hashtags`.
|
||||
_MOMENT = {
|
||||
"type": "object",
|
||||
"properties": {k: v for k, v in VERDICT_SCHEMA["properties"].items() if k not in ("keep", "hashtags")},
|
||||
"required": ["score", "start_s", "end_s", "title", "caption", "reason"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
SCAN_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"screen_game": {"type": "string"},
|
||||
"has_webcam": {"type": "boolean"},
|
||||
"summary": {"type": "string"},
|
||||
"moments": {"type": "array", "items": _MOMENT},
|
||||
},
|
||||
"required": ["screen_game", "has_webcam", "summary", "moments"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
PROFILE_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"name": {"type": "string"},
|
||||
"summary": {"type": "string"},
|
||||
"genre": {"type": "string"},
|
||||
"mechanics": {"type": "array", "items": {"type": "string"}},
|
||||
"clip_worthy": {"type": "array", "items": {"type": "string"}},
|
||||
"avoid": {"type": "array", "items": {"type": "string"}},
|
||||
"jargon": {"type": "array", "items": {"type": "string"}},
|
||||
"news": {"type": "array", "items": {"type": "string"}},
|
||||
"hashtags": {"type": "array", "items": {"type": "string"}},
|
||||
"sources": {"type": "array", "items": {"type": "string"}},
|
||||
},
|
||||
"required": ["name", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
CAM_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"has_webcam": {"type": "boolean"},
|
||||
"x": {"type": "number"}, "y": {"type": "number"}, "w": {"type": "number"}, "h": {"type": "number"},
|
||||
"game_on_screen": {"type": "string"},
|
||||
},
|
||||
"required": ["has_webcam", "x", "y", "w", "h", "game_on_screen"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
|
||||
JUDGE_SYSTEM = """Você é o EDITOR de cortes de live para Shorts, TikTok, Reels e YouTube, em português do Brasil.
|
||||
Recebe um trecho candidato de uma live (contexto do jogo, transcrição com tempos, chat, emotes) e, quando houver,
|
||||
a ANÁLISE do analista da equipe, que já cruzou tela, fala e chat. Confie na análise para entender O QUE
|
||||
aconteceu; o seu trabalho é decidir se rende corte e escrever título e legenda FIÉIS a isso.
|
||||
|
||||
""" + CLIP_GUIDE + """
|
||||
|
||||
""" + CHAT_GLOSSARY + """
|
||||
|
||||
Título e legenda: descrevem a situação real (ex.: se a análise diz lag, o título é sobre o lag/travamento, não
|
||||
sobre a frase solta da transcrição). Com confidence da análise < 0,5, seja descritivo e não invente detalhes.
|
||||
Use action_start_s/reaction_end_s da análise como base para start_s/end_s."""
|
||||
JUDGE_SYSTEM += """
|
||||
|
||||
Regras da resposta:
|
||||
- keep=false para o que não rende; score de 0 a 10 (7+ = corte forte; abaixo de 5 = descartar).
|
||||
- start_s e end_s em segundos da gravação, DENTRO da janela recebida e respeitando a duração mínima/máxima
|
||||
informada; comece antes da ação (contexto) e termine logo depois da reação. Não corte no meio de uma frase.
|
||||
- title: até 70 caracteres, chamativo mas verdadeiro, sem inventar o que não está na fala/tela.
|
||||
- caption: 1–2 frases, SEM hashtags e sem link (o sistema acrescenta as hashtags do canal e do jogo e o crédito).
|
||||
- hashtags: 2 a 4 tags DO MOMENTO, sem "#": a missão/atividade, o evento, o modo, o lugar, o item ou o personagem
|
||||
que aparece NESTE trecho (ex.: nome da missão ou do assalto, "perseguição", "sorteio", "Lamborghini", "lag").
|
||||
Prefira os termos do perfil do jogo (mecânicas, gírias) e o que o streamer e o chat falam. Nada genérico
|
||||
("gameplay", "live", "viral"), nada que não aconteça aqui, e não repita o canal nem o nome do jogo.
|
||||
- reason: uma frase dizendo por que manteve ou descartou (cite o que viu na tela, se ajudou).
|
||||
- Não use ferramentas nem leia nada além do que foi entregue. Responda só com o JSON pedido."""
|
||||
|
||||
SCAN_SYSTEM = """Você é editor de cortes de live e está ASSISTINDO uma live por janelas de alguns minutos.
|
||||
Recebe o contexto do jogo, a transcrição com tempos (segundos da gravação), frames da tela com o instante de
|
||||
cada um, o chat (pode ser quase vazio: live pequena) e os cortes já feitos nessa região.
|
||||
|
||||
""" + CLIP_GUIDE + """
|
||||
|
||||
Tarefa: aponte de 0 a 2 momentos desta janela que dariam um bom corte SOZINHOS. Se nada rende, devolva
|
||||
moments=[] (é o normal na maior parte do tempo — não force). Não repita um corte já feito.
|
||||
- start_s/end_s dentro da janela recebida (pode começar até o limite de "volta" informado para pegar a ação),
|
||||
com a duração mínima/máxima informada.
|
||||
- screen_game: o jogo que aparece na tela (ou "desconhecido"); has_webcam: há câmera do streamer no quadro?
|
||||
- summary: 1 frase do que está acontecendo na janela (vira memória para as próximas janelas).
|
||||
- title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
|
||||
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
|
||||
|
||||
PROFILE_SYSTEM = """Você pesquisa jogos para um editor de cortes de live em português do Brasil. Use a busca na
|
||||
web para confirmar o que é o jogo (nome da categoria da Twitch pode ser abreviado ou ambíguo). Seja factual e
|
||||
cite as fontes (URLs). Responda só com o JSON pedido, textos em português do Brasil.
|
||||
- summary: 2–3 frases do que é o jogo e como se joga.
|
||||
- mechanics: até 8 mecânicas/sistemas que aparecem em gameplay.
|
||||
- clip_worthy: até 10 situações que rendem corte NESTE jogo (específicas, não genéricas).
|
||||
- avoid: até 6 situações que parecem momento mas não rendem (menus, farm, fila...).
|
||||
- jargon: até 12 termos/gírias que streamer e chat usam (para entender a transcrição).
|
||||
- news: até 6 novidades recentes com mês/ano (lançamento, atualização, polêmica) que tornam informação valiosa.
|
||||
- hashtags: 3 a 6 hashtags que o público usa para ESTE jogo no TikTok, Shorts e Reels (Brasil): o nome do jogo sem
|
||||
espaço, abreviação conhecida, o modo/gênero quando for buscado (ex.: GTARP). A primeira é a principal do jogo.
|
||||
Escreva com "#", sem inventar tag que ninguém usa.
|
||||
- sources: até 5 URLs usadas.
|
||||
Se vierem "pedidos do usuário", eles valem mais que a pesquisa: inclua o que ele pediu para acrescentar e respeite
|
||||
o que ele mandou tirar ou corrigir (ele conhece o canal e o jogo)."""
|
||||
|
||||
REFINE_SYSTEM = """Você mantém o perfil de um jogo usado por um editor de cortes de live em português do Brasil.
|
||||
Recebe o perfil ATUAL (JSON) e um PEDIDO do usuário (acrescentar, corrigir, tirar ou detalhar algo). Devolva o
|
||||
perfil COMPLETO atualizado, no mesmo formato:
|
||||
- mantenha tudo o que o pedido não mexe, com o mesmo texto;
|
||||
- aplique o pedido no campo certo (situação que rende corte → clip_worthy; o que não rende → avoid; gíria → jargon;
|
||||
mecânica → mechanics; novidade → news com mês/ano; hashtag do jogo → hashtags, com "#", a principal primeiro),
|
||||
escrito no estilo dos itens que já estão lá;
|
||||
- os limites de tamanho das listas podem crescer até 15 itens quando o usuário pedir para acrescentar;
|
||||
- se precisar confirmar um fato, pode usar a busca na web e acrescentar a URL em sources;
|
||||
- o usuário conhece o canal e o jogo: o que ele afirma vale, mesmo que você não ache na web;
|
||||
- se vier uma SEÇÃO em foco, o pedido é sobre ela: mexa nela (outras só se o pedido disser);
|
||||
- pode transformar um pedido genérico em itens concretos e úteis para o editor (ex.: "reação do streamer conta"
|
||||
vira "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga");
|
||||
- reply: 1–2 frases para o usuário dizendo o que você mudou (ou, se o pedido for uma pergunta, a resposta).
|
||||
Textos em português do Brasil. Responda só com o JSON pedido."""
|
||||
|
||||
REFINE_SCHEMA = {
|
||||
"type": "object",
|
||||
"properties": {**PROFILE_SCHEMA["properties"], "reply": {"type": "string"}},
|
||||
"required": [*PROFILE_SCHEMA["required"], "reply"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas",
|
||||
"hashtags": "Hashtags",
|
||||
"news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes"}
|
||||
|
||||
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e,
|
||||
se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro:
|
||||
x, y = canto superior esquerdo; w, h = largura e altura. Sem webcam: has_webcam=false e x=y=w=h=0.
|
||||
game_on_screen: o jogo que aparece (ou "desconhecido"). Responda só com o JSON pedido."""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Verdict:
|
||||
keep: bool
|
||||
score: float
|
||||
start_s: float
|
||||
end_s: float
|
||||
title: str
|
||||
caption: str
|
||||
reason: str
|
||||
model: str
|
||||
# Tags DO MOMENTO (sem "#"), escolhidas pela IA; as do canal e do jogo o sistema põe (app/hashtags.py).
|
||||
hashtags: tuple[str, ...] = ()
|
||||
|
||||
|
||||
class JudgeError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- prompts
|
||||
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
|
||||
confirmed: bool = False) -> str:
|
||||
lines = [f"Título da live: {live_title or '(desconhecido)'}"]
|
||||
if confirmed:
|
||||
# O usuário confirmou no painel: não questionar (jogo novo/pouco conhecido lembra outros na tela).
|
||||
lines.append(f"Jogo CONFIRMADO pelo usuário: {game}. A tela pode lembrar outro jogo parecido (ex.: GTA, "
|
||||
f"Warzone) — não questione o jogo; use o perfil abaixo para entender o que acontece.")
|
||||
else:
|
||||
lines.append(f"Jogo pela categoria da plataforma: {game or '(desconhecida)'}")
|
||||
if screen_game and screen_game.lower() not in (game or "").lower():
|
||||
lines.append(f"Jogo que a IA viu na tela recentemente: {screen_game} (confira nos frames; a categoria pode estar errada)")
|
||||
if profile:
|
||||
lines.append(f"Perfil do jogo: {profile.get('summary', '')}")
|
||||
for key, label in (("clip_worthy", "Rende corte neste jogo"), ("avoid", "Não rende"),
|
||||
("mechanics", "Mecânicas/atividades (termos para as hashtags do momento)"),
|
||||
("jargon", "Gírias/termos"), ("news", "Novidades")):
|
||||
if profile.get(key):
|
||||
lines.append(f"{label}: " + "; ".join(profile[key][:10]))
|
||||
if history:
|
||||
lines.append(f"O que aconteceu antes na live: {history}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _transcript(words: list[Word], lo: float, hi: float) -> str:
|
||||
lines, current, current_t = [], [], None
|
||||
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start):
|
||||
if current_t is None or word.start - current_t > 4 or len(current) >= 14:
|
||||
if current:
|
||||
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
|
||||
current, current_t = [], word.start
|
||||
current.append(word.word)
|
||||
if current:
|
||||
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
|
||||
return "\n".join(lines) or "(sem fala transcrita)"
|
||||
|
||||
|
||||
def _chat_block(chat: list[ChatMessage], lo: float, hi: float, focus: float | None, bucket_s: int = 5) -> str:
|
||||
buckets: dict[int, int] = {}
|
||||
emotes: dict[str, int] = {}
|
||||
sample: list[str] = []
|
||||
for message in chat:
|
||||
if lo <= message.t <= hi:
|
||||
b = int(message.t // bucket_s * bucket_s)
|
||||
buckets[b] = buckets.get(b, 0) + 1
|
||||
for e in set(message.emotes):
|
||||
emotes[e] = emotes.get(e, 0) + 1
|
||||
near = focus is None or focus - 10 <= message.t <= focus + 8
|
||||
if near and len(sample) < 60:
|
||||
sample.append(f"[{message.t:.0f}s] {message.text[:80]}")
|
||||
rate = ", ".join(f"{t}s:{n}" for t, n in sorted(buckets.items())) or "sem chat"
|
||||
top = ", ".join(f"{e}×{n}" for e, n in sorted(emotes.items(), key=lambda kv: -kv[1])[:12]) or "nenhum"
|
||||
return (f"Mensagens do chat por {bucket_s} s: {rate}\nEmotes mais usados: {top}\n"
|
||||
f"Amostra do chat:\n" + ("\n".join(sample) or "(sem chat)"))
|
||||
|
||||
|
||||
def _frames_block(frames: list[tuple[float, Path]]) -> str:
|
||||
if not frames:
|
||||
return "Frames: (nenhum)"
|
||||
return "Frames anexados, em ordem: " + ", ".join(f"#{i + 1} = {t:.0f}s" for i, (t, _) in enumerate(frames))
|
||||
|
||||
|
||||
def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, peak_s: float,
|
||||
words: list[Word], chat: list[ChatMessage], heuristic: dict, live_title: str = "", *,
|
||||
context: str = "", frames: list[tuple[float, Path]] | None = None,
|
||||
backtrack_s: float = DEFAULT_BACKTRACK_S, min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S,
|
||||
face: str = "") -> str:
|
||||
"""Prompt do juiz. Janela = candidato com `backtrack_s` para trás (a ação vem antes do comentário).
|
||||
`face`: resumo do rosto do streamer na janela (face.FaceService.summary); vazio = sem câmera/rastreio."""
|
||||
lo, hi = max(0.0, start_s - backtrack_s), end_s + CONTEXT_AFTER_S
|
||||
return (
|
||||
f"Canal: {streamer} ({platform})\n"
|
||||
+ (context or f"Título da live: {live_title or '(desconhecido)'}") + "\n\n"
|
||||
f"Janela disponível: {lo:.0f}s a {hi:.0f}s. Candidato da heurística: {start_s:.0f}s a {end_s:.0f}s; "
|
||||
f"pico de reação em {peak_s:.0f}s. Duração do corte: {min_s:.0f} a {max_s:.0f} s.\n"
|
||||
f"Sinais da heurística: {json.dumps(heuristic, ensure_ascii=False)}\n"
|
||||
+ (f"Rosto do streamer (expressão medida na webcam, relativa ao normal dele): {face}\n" if face else "")
|
||||
+ f"{_frames_block(frames or [])}\n\n"
|
||||
f"Transcrição:\n{_transcript(words, lo, hi)}\n\n"
|
||||
f"{_chat_block(chat, lo, hi, peak_s)}"
|
||||
)
|
||||
|
||||
|
||||
def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_lo: float, words: list[Word],
|
||||
chat: list[ChatMessage], context: str, frames: list[tuple[float, Path]],
|
||||
existing: list[tuple[float, float, str]], min_s: float, max_s: float) -> str:
|
||||
done = "; ".join(f"{a:.0f}–{b:.0f}s ({t[:40]})" for a, b, t in existing) or "nenhum"
|
||||
return (
|
||||
f"Canal: {streamer} ({platform})\n{context}\n\n"
|
||||
f"Janela nova: {lo:.0f}s a {hi:.0f}s (pode voltar até {back_lo:.0f}s para pegar o início de uma ação).\n"
|
||||
f"Duração do corte: {min_s:.0f} a {max_s:.0f} s. Cortes já feitos aqui: {done}\n"
|
||||
f"{_frames_block(frames)}\n\n"
|
||||
f"Transcrição:\n{_transcript(words, back_lo, hi)}\n\n"
|
||||
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10)}"
|
||||
)
|
||||
|
||||
|
||||
def _clean(data: dict, start_s: float, end_s: float, model: str, lo: float | None = None, hi: float | None = None,
|
||||
min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S) -> Verdict:
|
||||
# `hashtags` é opcional na leitura: resposta sem ele (modelo antigo/cache) segue com as tags do canal e do jogo.
|
||||
missing = [k for k in VERDICT_SCHEMA["required"] if k not in data and k != "hashtags"]
|
||||
if missing:
|
||||
raise JudgeError(f"resposta sem os campos {missing}")
|
||||
lo = max(0.0, start_s - DEFAULT_BACKTRACK_S) if lo is None else lo
|
||||
hi = end_s + CONTEXT_AFTER_S if hi is None else hi
|
||||
# Mínimo de verdade (pedido do dono, 17/11/2026): se o fim bate em `hi`, o início recua (antes ficava curto).
|
||||
new_start, new_end = fit_window(float(data["start_s"]), float(data["end_s"]), lo, hi, min_s, max_s, keep="start")
|
||||
if new_end - new_start < min(10.0, min_s): # resposta incoerente: fica com o candidato da heurística
|
||||
new_start, new_end = start_s, end_s
|
||||
return Verdict(
|
||||
keep=bool(data["keep"]), score=max(0.0, min(10.0, float(data["score"]))),
|
||||
start_s=round(new_start, 2), end_s=round(new_end, 2),
|
||||
title=str(data["title"]).strip()[:100], caption=str(data["caption"]).strip()[:600],
|
||||
reason=str(data["reason"]).strip()[:300], model=model,
|
||||
hashtags=tuple(str(t).strip()[:40] for t in (data.get("hashtags") or [])[:6] if str(t).strip()),
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- executáveis das CLIs
|
||||
def find_codex() -> list[str] | None:
|
||||
"""Comando do Codex. No Windows o npm instala `codex.cmd` (lote não roda sem shell e escapa mal argumentos):
|
||||
como no painel (agents.ts), rodamos o `codex.js` do pacote direto pelo Node."""
|
||||
env = os.environ.get("CODEX_BIN")
|
||||
if env:
|
||||
return [shutil.which("node") or "node", env] if env.endswith(".js") else [env]
|
||||
exe = shutil.which("codex.exe") if sys.platform == "win32" else shutil.which("codex")
|
||||
if exe:
|
||||
return [exe]
|
||||
cmd = shutil.which("codex.cmd") or shutil.which("codex")
|
||||
node = shutil.which("node")
|
||||
if cmd and node:
|
||||
js = Path(cmd).parent / "node_modules" / "@openai" / "codex" / "bin" / "codex.js"
|
||||
if js.is_file():
|
||||
return [node, str(js)]
|
||||
return None
|
||||
|
||||
|
||||
def find_claude() -> list[str] | None:
|
||||
env = os.environ.get("CLAUDE_BIN")
|
||||
if env:
|
||||
return [env]
|
||||
exe = shutil.which("claude.exe") if sys.platform == "win32" else shutil.which("claude")
|
||||
return [exe] if exe else None
|
||||
|
||||
|
||||
def codex_models(cache: Path | None = None) -> list[dict]:
|
||||
"""Modelos que o Codex lista para esta conta (cache que a própria CLI mantém)."""
|
||||
cache = cache or Path.home() / ".codex" / "models_cache.json"
|
||||
try:
|
||||
data = json.loads(cache.read_text(encoding="utf-8"))
|
||||
except (OSError, json.JSONDecodeError):
|
||||
return [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
|
||||
out = []
|
||||
for m in data.get("models", []):
|
||||
if isinstance(m, dict) and m.get("slug") and m.get("visibility", "list") == "list":
|
||||
out.append({"id": m["slug"], "label": m.get("display_name") or m["slug"], "description": m.get("description", "")})
|
||||
return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- IA
|
||||
class Judge:
|
||||
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = ""):
|
||||
self.provider = provider if provider in PROVIDERS else "codex"
|
||||
self.model = model or DEFAULT_MODELS.get(self.provider, "")
|
||||
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor.
|
||||
self.analyst_model = analyst_model
|
||||
self.workdir = workdir
|
||||
|
||||
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None:
|
||||
if provider not in PROVIDERS:
|
||||
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
|
||||
self.provider = provider
|
||||
self.model = model.strip() or DEFAULT_MODELS.get(provider, "")
|
||||
if analyst_model is not None:
|
||||
self.analyst_model = analyst_model.strip()
|
||||
|
||||
@property
|
||||
def enabled(self) -> bool:
|
||||
return self.provider in ("codex", "claude")
|
||||
|
||||
def command(self) -> list[str] | None:
|
||||
return find_codex() if self.provider == "codex" else find_claude() if self.provider == "claude" else None
|
||||
|
||||
def describe(self) -> dict:
|
||||
cmd = self.command() if self.enabled else None
|
||||
return {"provider": self.provider, "model": self.model if self.enabled else None,
|
||||
"analystModel": (self.analyst_model or self.model) if self.enabled else None,
|
||||
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None}
|
||||
|
||||
def models(self) -> dict:
|
||||
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "defaults": DEFAULT_MODELS}
|
||||
|
||||
# ---------- usos
|
||||
def analyze(self, prompt: str, images: list[Path]) -> dict:
|
||||
"""1º juiz (ANALISTA): o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título."""
|
||||
data = self.ask(ANALYST_SYSTEM, prompt, ANALYSIS_SCHEMA, images, model=self.analyst_model or self.model)
|
||||
missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data]
|
||||
if missing:
|
||||
raise JudgeError(f"análise sem os campos {missing}")
|
||||
data["confidence"] = max(0.0, min(1.0, float(data["confidence"])))
|
||||
return data
|
||||
|
||||
def judge(self, prompt: str, start_s: float, end_s: float, images: list[Path] | None = None, *,
|
||||
lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
|
||||
max_s: float = DEFAULT_MAX_S) -> Verdict:
|
||||
data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or [])
|
||||
return _clean(data, start_s, end_s, f"{self.provider}:{self.model}", lo, hi, min_s, max_s)
|
||||
|
||||
def scan(self, prompt: str, images: list[Path]) -> dict:
|
||||
data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images)
|
||||
if not isinstance(data.get("moments"), list):
|
||||
raise JudgeError("varredura sem a lista de momentos")
|
||||
return data
|
||||
|
||||
def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict:
|
||||
prompt = f"Categoria/jogo da live: {name}\nTítulo da live (pista extra): {live_title or '(nenhum)'}\n"
|
||||
if notes:
|
||||
prompt += "Pedidos do usuário (respeite):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
|
||||
prompt += "Pesquise e devolva o perfil do jogo."
|
||||
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S)
|
||||
|
||||
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
|
||||
history: list[dict] | None = None) -> dict:
|
||||
"""Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro
|
||||
mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior."""
|
||||
prompt = f"Jogo: {name}\nPerfil ATUAL:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
|
||||
if section in PROFILE_SECTIONS:
|
||||
prompt += f"SEÇÃO em foco: {section} ({PROFILE_SECTIONS[section]})\n"
|
||||
if history:
|
||||
prompt += "Conversa até aqui:\n" + "\n".join(
|
||||
f"{'Usuário' if h.get('role') == 'user' else 'IA'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
|
||||
prompt += f"PEDIDO do usuário:\n{instruction}\n\nDevolva o perfil completo atualizado e o reply."
|
||||
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
|
||||
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S)
|
||||
|
||||
def detect_cam(self, images: list[Path]) -> dict:
|
||||
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images)
|
||||
|
||||
# ---------- execução
|
||||
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
|
||||
timeout: int = TIMEOUT_S, model: str | None = None) -> dict:
|
||||
model = model or self.model
|
||||
if self.provider == "codex":
|
||||
return self._codex(system, prompt, schema, images, search, timeout, model)
|
||||
if self.provider == "claude":
|
||||
return self._claude(system, prompt, schema, images, search, timeout, model)
|
||||
raise JudgeError("IA desligada")
|
||||
|
||||
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int) -> subprocess.CompletedProcess:
|
||||
try:
|
||||
result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd,
|
||||
creationflags=NO_WINDOW)
|
||||
except subprocess.TimeoutExpired as exc:
|
||||
raise JudgeError(f"a CLI passou de {timeout} s") from exc
|
||||
except OSError as exc:
|
||||
raise JudgeError(f"não consegui rodar a CLI: {exc}") from exc
|
||||
if result.returncode != 0:
|
||||
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-2:]
|
||||
raise JudgeError(f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}")
|
||||
return result
|
||||
|
||||
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
|
||||
model: str) -> dict:
|
||||
cmd = find_codex()
|
||||
if not cmd:
|
||||
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)")
|
||||
self.workdir.mkdir(parents=True, exist_ok=True)
|
||||
with tempfile.TemporaryDirectory(dir=self.workdir) as tmp:
|
||||
schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json"
|
||||
schema_file.write_text(json.dumps(schema), encoding="utf-8")
|
||||
image_args = [arg for img in images for arg in ("-i", str(Path(img).resolve()))]
|
||||
lean = codex_lean_overrides(search)
|
||||
if search:
|
||||
stdin = system + "\n\n---\n\n" + prompt
|
||||
else:
|
||||
# Sem ferramentas, o texto do juiz faz o papel das instruções de base do Codex (como o
|
||||
# --system-prompt do Claude). String literal do TOML ('...'): o caminho do Windows não é escapado.
|
||||
instructions = Path(tmp) / "instructions.md"
|
||||
instructions.write_text(system, encoding="utf-8")
|
||||
lean += ["-c", f"model_instructions_file='{instructions}'"]
|
||||
stdin = prompt
|
||||
# `--search` é opção global (antes de `exec`). Cada imagem com seu `-i`; o "-" (prompt pela entrada
|
||||
# padrão) vem depois de uma opção de valor único para não ser lido como mais uma imagem.
|
||||
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral",
|
||||
"--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args,
|
||||
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
|
||||
self._run(args, stdin, Path(tmp), timeout)
|
||||
try:
|
||||
return json.loads(out.read_text(encoding="utf-8"))
|
||||
except (OSError, json.JSONDecodeError) as exc:
|
||||
raise JudgeError("o Codex não devolveu o JSON pedido") from exc
|
||||
|
||||
def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
|
||||
model: str) -> dict:
|
||||
cmd = find_claude()
|
||||
if not cmd:
|
||||
raise JudgeError("Claude Code CLI não encontrado")
|
||||
self.workdir.mkdir(parents=True, exist_ok=True)
|
||||
tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else [])
|
||||
extra: list[str] = []
|
||||
if images:
|
||||
# O Claude vê imagem lendo o arquivo (ferramenta Read): liberamos só a pasta das imagens.
|
||||
for folder in sorted({str(Path(i).resolve().parent) for i in images}):
|
||||
extra += ["--add-dir", folder]
|
||||
prompt += "\n\nImagens (leia cada uma com a ferramenta Read, na ordem):\n" + "\n".join(
|
||||
str(Path(i).resolve()) for i in images)
|
||||
args = [*cmd, "-p", "--model", model, "--output-format", "json", "--json-schema", json.dumps(schema),
|
||||
"--tools", ",".join(tools), *(["--allowedTools", ",".join(tools)] if tools else []), *extra,
|
||||
# --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s).
|
||||
"--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local",
|
||||
"--system-prompt", system]
|
||||
result = self._run(args, prompt, self.workdir, timeout)
|
||||
try:
|
||||
envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
|
||||
except json.JSONDecodeError as exc:
|
||||
raise JudgeError("o Claude não devolveu JSON") from exc
|
||||
if envelope.get("is_error"):
|
||||
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
|
||||
data = envelope.get("structured_output")
|
||||
if not isinstance(data, dict):
|
||||
try:
|
||||
data = json.loads(envelope.get("result") or "")
|
||||
except json.JSONDecodeError as exc:
|
||||
raise JudgeError("o Claude não devolveu o JSON pedido") from exc
|
||||
return data
|
||||
|
||||
|
||||
def analysis_block(analysis: dict) -> str:
|
||||
"""Análise do 1º juiz no formato que o editor lê."""
|
||||
return "Análise do ANALISTA (cruzou tela, fala e chat):\n" + json.dumps(analysis, ensure_ascii=False, indent=1)
|
||||
@@ -0,0 +1,415 @@
|
||||
"""Configuração do corte: formato (vertical/horizontal), layout, câmera do streamer, legenda, crédito e duração.
|
||||
|
||||
Fica por CANAL (padrão do streamer: a webcam dele mora sempre no mesmo canto) e pode ser sobrescrita por SESSÃO.
|
||||
Efetiva = padrão ← canal ← sessão (campo a campo). O painel edita pelo modal de "Configuração do corte".
|
||||
|
||||
Formato (`format.aspect`):
|
||||
- `vertical` (padrão): 1080×1920, para Shorts/Reels/TikTok;
|
||||
- `horizontal`: 1920×1080, para o YouTube "tela grande" mostrando o próprio jogo.
|
||||
|
||||
Layouts no vertical (1080×1920):
|
||||
- `blur`: vídeo 16:9 inteiro no meio, o próprio vídeo ampliado e desfocado no fundo (sem câmera definida);
|
||||
- `cam_top`: webcam recortada em cima (`camHeight` da altura, padrão 1/3) + jogo embaixo, recortado no centro;
|
||||
- `game_only`: só o jogo, recortado para preencher a tela (ou a região `game`, se definida);
|
||||
- `cam_only`: a câmera do streamer em tela cheia.
|
||||
No horizontal (1920×1080) só existem dois resultados: `cam_only` (câmera em tela cheia, se marcada) e "quadro
|
||||
inteiro" (`full`, interno) para todos os outros modos — o quadro original inteiro, ou a região `game` se marcada.
|
||||
Retângulos (`cam`, `game`) são normalizados 0–1 sobre o quadro original (x, y, w, h).
|
||||
|
||||
Textos (legenda, crédito, gancho, textos, chat, capa) são desenhados em ASS num QUADRO LÓGICO (`canvas_size`):
|
||||
no vertical é o próprio 1080×1920; no horizontal é 2560×1440, que o libass reduz para 1920×1080 (escala 0,75).
|
||||
Assim os mesmos tamanhos em px (legenda 84, gancho 68…) ficam proporcionais à altura menor do horizontal sem
|
||||
mudar o JSON. Posições 0–1 continuam relativas ao quadro.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.layout")
|
||||
|
||||
ASPECTS = ("vertical", "horizontal")
|
||||
# Qualidades de gravação da live (grupo `capture`; regras e medições em app/capture.py).
|
||||
CAPTURE_QUALITIES = ("best", "1440p", "1080p", "720p", "480p")
|
||||
FRAME_SIZES = {"vertical": (1080, 1920), "horizontal": (1920, 1080)}
|
||||
# Quadro lógico do ASS: no horizontal, 2560×1440 → o vídeo 1920×1080 mostra os textos a 75 %.
|
||||
CANVAS_SIZES = {"vertical": (1080, 1920), "horizontal": (2560, 1440)}
|
||||
W, H = FRAME_SIZES["vertical"] # compatibilidade: o quadro do vertical (padrão)
|
||||
# cam_only = a câmera do streamer em tela cheia (sem o jogo), para o trecho em que a reação é o assunto.
|
||||
MODES = ("auto", "blur", "cam_top", "game_only", "cam_only")
|
||||
HEX_RE = re.compile(r"^#[0-9A-Fa-f]{6}$")
|
||||
SYSTEM_FONTS = ("Arial Black", "Arial", "Impact", "Verdana", "Segoe UI Black", "Trebuchet MS")
|
||||
# Fontes de vídeo curto EMPACOTADAS no repositório (assets/fonts, pasta plana: o fontsdir do libass não lê subpastas),
|
||||
# com licença livre ao lado de cada arquivo e sha256 no fonts.lock.json. Pedido do dono (17/11/2026): escolher fonte
|
||||
# na legenda, no gancho e nos textos.
|
||||
FONTS_DIR = Path(__file__).resolve().parents[2] / "assets" / "fonts"
|
||||
|
||||
|
||||
def _load_packaged_fonts(folder: Path) -> dict[str, str]:
|
||||
"""{família: caminho relativo à raiz do repositório} das fontes do lock que existem e batem o sha256."""
|
||||
try:
|
||||
lock = json.loads((folder / "fonts.lock.json").read_text(encoding="utf-8"))
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
out = {}
|
||||
for entry in lock.get("files", []):
|
||||
file = folder.parent.parent / entry["path"]
|
||||
try:
|
||||
ok = hashlib.sha256(file.read_bytes()).hexdigest() == entry["sha256"]
|
||||
except OSError:
|
||||
ok = False
|
||||
if ok:
|
||||
out[entry["family"]] = entry["path"]
|
||||
else:
|
||||
log.warning("fonte %s ausente ou com sha256 diferente do lock: fora da lista", entry.get("path"))
|
||||
return out
|
||||
|
||||
|
||||
PACKAGED_FONTS = _load_packaged_fonts(FONTS_DIR)
|
||||
FONTS = SYSTEM_FONTS + tuple(PACKAGED_FONTS)
|
||||
HOOK_STYLES = ("plain", "banner")
|
||||
HOOK_ANIMS = ("pop", "fade", "none", "slide")
|
||||
# Gancho em tarja (referência do dono, 17/11/2026: tarja verde-limão atravessa a tela e o texto entra borrado e assenta
|
||||
# nítido, letras brancas "cartoon" com contorno preto). Fonte padrão: Luckiest Guy, se estiver empacotada.
|
||||
HOOK_FONT = "Luckiest Guy" if "Luckiest Guy" in PACKAGED_FONTS else "Arial Black"
|
||||
# Margem do mínimo (pedido do dono, 17/11/2026: "se o mínimo é 60 tem que ser 60; o certo é sempre 1 s a mais").
|
||||
# +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final.
|
||||
DURATION_MARGIN_S = 1.0
|
||||
DURATION_SLACK_S = 0.1
|
||||
|
||||
DEFAULTS: dict = {
|
||||
"layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34},
|
||||
"caption": {
|
||||
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
|
||||
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
|
||||
},
|
||||
"credit": {"enabled": True, "position": "top", "size": 44},
|
||||
"duration": {"minS": 60, "maxS": 90, "backtrackS": 120},
|
||||
"format": {"aspect": "vertical"},
|
||||
# Gancho que o projeto da IA põe no começo do corte (o editor pode trocar por corte).
|
||||
"hook": {"style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": HOOK_FONT, "anim": "slide", "seconds": 3.0},
|
||||
# Qualidade de GRAVAÇÃO da live (app/capture.py): `best` = a maior que a live oferece; os outros são teto.
|
||||
# Vale na próxima gravação ou retomada (a captura em andamento não troca de qualidade no meio).
|
||||
"capture": {"quality": "best"},
|
||||
}
|
||||
|
||||
|
||||
class LayoutError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def merge(*layers: dict | None) -> dict:
|
||||
"""Mescla campo a campo (padrão ← canal ← sessão). Camadas vazias são ignoradas."""
|
||||
out = copy.deepcopy(DEFAULTS)
|
||||
for layer in layers:
|
||||
for group, values in (layer or {}).items():
|
||||
if group in out and isinstance(values, dict):
|
||||
out[group].update({k: v for k, v in values.items() if k in out[group]})
|
||||
return out
|
||||
|
||||
|
||||
def _rect(value, name: str) -> dict | None:
|
||||
if value is None:
|
||||
return None
|
||||
if not isinstance(value, dict) or set(value) != {"x", "y", "w", "h"}:
|
||||
raise LayoutError(f"{name} precisa ser {{x, y, w, h}} (0–1) ou null")
|
||||
r = {k: float(value[k]) for k in ("x", "y", "w", "h")}
|
||||
if not (0 <= r["x"] < 1 and 0 <= r["y"] < 1 and 0.03 <= r["w"] <= 1 and 0.03 <= r["h"] <= 1
|
||||
and r["x"] + r["w"] <= 1.0001 and r["y"] + r["h"] <= 1.0001):
|
||||
raise LayoutError(f"{name} fora do quadro (valores 0–1, largura/altura ≥ 0,03)")
|
||||
return {k: round(v, 4) for k, v in r.items()}
|
||||
|
||||
|
||||
def validate(settings: dict) -> dict:
|
||||
"""Valida uma camada parcial (canal ou sessão) e devolve só os campos conhecidos, normalizados."""
|
||||
if not isinstance(settings, dict):
|
||||
raise LayoutError("configuração precisa ser um objeto")
|
||||
out: dict = {}
|
||||
lay = settings.get("layout")
|
||||
if lay is not None:
|
||||
o: dict = {}
|
||||
if "mode" in lay:
|
||||
if lay["mode"] not in MODES:
|
||||
raise LayoutError(f"layout.mode precisa ser um de {', '.join(MODES)}")
|
||||
o["mode"] = lay["mode"]
|
||||
if "cam" in lay:
|
||||
o["cam"] = _rect(lay["cam"], "layout.cam")
|
||||
if "game" in lay:
|
||||
o["game"] = _rect(lay["game"], "layout.game")
|
||||
if "camHeight" in lay:
|
||||
o["camHeight"] = float(lay["camHeight"])
|
||||
if not 0.2 <= o["camHeight"] <= 0.6:
|
||||
raise LayoutError("layout.camHeight vai de 0,2 a 0,6")
|
||||
out["layout"] = o
|
||||
cap = settings.get("caption")
|
||||
if cap is not None:
|
||||
o = {}
|
||||
for key in ("color", "highlight", "outline"):
|
||||
if key in cap:
|
||||
if not HEX_RE.match(str(cap[key])):
|
||||
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
|
||||
o[key] = str(cap[key]).upper()
|
||||
if "font" in cap:
|
||||
if cap["font"] not in FONTS:
|
||||
raise LayoutError(f"caption.font precisa ser uma de {', '.join(FONTS)}")
|
||||
o["font"] = cap["font"]
|
||||
for key, lo, hi in (("size", 40, 140), ("outlineWidth", 0, 14), ("maxWords", 1, 6)):
|
||||
if key in cap:
|
||||
o[key] = int(cap[key])
|
||||
if not lo <= o[key] <= hi:
|
||||
raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
|
||||
if "y" in cap:
|
||||
o["y"] = None if cap["y"] is None else float(cap["y"])
|
||||
if o["y"] is not None and not 0.08 <= o["y"] <= 0.9:
|
||||
raise LayoutError("caption.y vai de 0,08 a 0,9 (fração da altura) ou null = automático")
|
||||
for key in ("enabled", "uppercase"):
|
||||
if key in cap:
|
||||
o[key] = bool(cap[key])
|
||||
out["caption"] = o
|
||||
cred = settings.get("credit")
|
||||
if cred is not None:
|
||||
o = {}
|
||||
if "enabled" in cred:
|
||||
o["enabled"] = bool(cred["enabled"])
|
||||
if "position" in cred:
|
||||
if cred["position"] not in ("top", "bottom"):
|
||||
raise LayoutError("credit.position precisa ser top ou bottom")
|
||||
o["position"] = cred["position"]
|
||||
if "size" in cred:
|
||||
o["size"] = int(cred["size"])
|
||||
if not 24 <= o["size"] <= 80:
|
||||
raise LayoutError("credit.size vai de 24 a 80")
|
||||
out["credit"] = o
|
||||
dur = settings.get("duration")
|
||||
if dur is not None:
|
||||
o = {}
|
||||
for key, lo, hi in (("minS", 5, 120), ("maxS", 15, 180), ("backtrackS", 0, 120)):
|
||||
if key in dur:
|
||||
o[key] = float(dur[key])
|
||||
if not lo <= o[key] <= hi:
|
||||
raise LayoutError(f"duration.{key} vai de {lo} a {hi}")
|
||||
out["duration"] = o
|
||||
if "duration" in out and out["duration"].get("minS", 0) >= out["duration"].get("maxS", 999):
|
||||
raise LayoutError("duration.minS precisa ser menor que maxS")
|
||||
hook = settings.get("hook")
|
||||
if hook is not None:
|
||||
if not isinstance(hook, dict):
|
||||
raise LayoutError("hook precisa ser um objeto")
|
||||
o = {}
|
||||
if "style" in hook:
|
||||
if hook["style"] not in HOOK_STYLES:
|
||||
raise LayoutError(f"hook.style precisa ser um de {', '.join(HOOK_STYLES)}")
|
||||
o["style"] = hook["style"]
|
||||
for key in ("bg", "color"):
|
||||
if key in hook:
|
||||
if not HEX_RE.match(str(hook[key])):
|
||||
raise LayoutError(f"hook.{key} precisa ser cor #RRGGBB")
|
||||
o[key] = str(hook[key]).upper()
|
||||
if "font" in hook:
|
||||
if hook["font"] not in FONTS:
|
||||
raise LayoutError(f"hook.font precisa ser uma de {', '.join(FONTS)}")
|
||||
o["font"] = hook["font"]
|
||||
if "anim" in hook:
|
||||
if hook["anim"] not in HOOK_ANIMS:
|
||||
raise LayoutError(f"hook.anim precisa ser um de {', '.join(HOOK_ANIMS)}")
|
||||
o["anim"] = hook["anim"]
|
||||
if "seconds" in hook:
|
||||
o["seconds"] = float(hook["seconds"])
|
||||
if not 1 <= o["seconds"] <= 8:
|
||||
raise LayoutError("hook.seconds vai de 1 a 8")
|
||||
out["hook"] = o
|
||||
fmt = settings.get("format")
|
||||
if fmt is not None:
|
||||
if not isinstance(fmt, dict):
|
||||
raise LayoutError("format precisa ser um objeto")
|
||||
o = {}
|
||||
if "aspect" in fmt:
|
||||
if fmt["aspect"] not in ASPECTS:
|
||||
raise LayoutError(f"format.aspect precisa ser um de {', '.join(ASPECTS)}")
|
||||
o["aspect"] = fmt["aspect"]
|
||||
out["format"] = o
|
||||
cap = settings.get("capture")
|
||||
if cap is not None:
|
||||
if not isinstance(cap, dict):
|
||||
raise LayoutError("capture precisa ser um objeto")
|
||||
o = {}
|
||||
if "quality" in cap:
|
||||
if cap["quality"] not in CAPTURE_QUALITIES:
|
||||
raise LayoutError(f"capture.quality precisa ser um de {', '.join(CAPTURE_QUALITIES)}")
|
||||
o["quality"] = cap["quality"]
|
||||
out["capture"] = o
|
||||
return out
|
||||
|
||||
|
||||
def min_target(settings: dict) -> float:
|
||||
"""Duração final mínima de um corte AUTOMÁTICO: `minS` + 1 s (+ folga de quadro), sem passar de `maxS`."""
|
||||
dur = settings.get("duration") or DEFAULTS["duration"]
|
||||
return round(min(float(dur["maxS"]), float(dur["minS"]) + DURATION_MARGIN_S + DURATION_SLACK_S), 3)
|
||||
|
||||
|
||||
def font_files() -> dict[str, str]:
|
||||
"""{família: caminho do arquivo relativo à raiz do repositório} das fontes empacotadas (o painel carrega o mesmo)."""
|
||||
return dict(PACKAGED_FONTS)
|
||||
|
||||
|
||||
def ass_filter(ass_name: str, ass_text: str | None = None) -> str:
|
||||
"""`ass=<arquivo>`; com `:fontsdir=` (pasta das fontes empacotadas) só quando o ASS usa uma delas — assim o
|
||||
filtro de projetos antigos (só fontes do Windows) fica idêntico ao de antes."""
|
||||
if ass_text and PACKAGED_FONTS and any(f",{fam}," in ass_text or f"\\fn{fam}" in ass_text for fam in PACKAGED_FONTS):
|
||||
# Caminho absoluto entre aspas, com ":" escapado (medido: sem aspas o FFmpeg recusa o grafo no Windows).
|
||||
return f"ass={ass_name}:fontsdir='{FONTS_DIR.as_posix().replace(':', chr(92) + ':')}'"
|
||||
return f"ass={ass_name}"
|
||||
|
||||
|
||||
def aspect(settings: dict) -> str:
|
||||
"""Formato do corte (`vertical` ou `horizontal`). Configuração sem o grupo `format` (antiga) = vertical."""
|
||||
value = (settings.get("format") or {}).get("aspect", "vertical")
|
||||
return value if value in ASPECTS else "vertical"
|
||||
|
||||
|
||||
def frame_size(settings: dict) -> tuple[int, int]:
|
||||
"""Tamanho do vídeo de saída (largura, altura)."""
|
||||
return FRAME_SIZES[aspect(settings)]
|
||||
|
||||
|
||||
def canvas_size(settings: dict) -> tuple[int, int]:
|
||||
"""Quadro lógico do ASS (PlayResX, PlayResY): posições e tamanhos dos textos são contados nele."""
|
||||
return CANVAS_SIZES[aspect(settings)]
|
||||
|
||||
|
||||
def resolved_mode(settings: dict) -> str:
|
||||
"""Modo efetivo do layout. No horizontal só há `cam_only` (com câmera marcada) e `full` (quadro inteiro)."""
|
||||
mode = settings["layout"]["mode"]
|
||||
if aspect(settings) == "horizontal":
|
||||
return "cam_only" if mode == "cam_only" and settings["layout"]["cam"] else "full"
|
||||
if mode == "auto":
|
||||
return "cam_top" if settings["layout"]["cam"] else "blur"
|
||||
if mode in ("cam_top", "cam_only") and not settings["layout"]["cam"]:
|
||||
return "blur" # sem câmera marcada não dá para montar o layout com câmera
|
||||
return mode
|
||||
|
||||
|
||||
def _crop(rect: dict | None) -> str:
|
||||
if not rect:
|
||||
return "iw:ih:0:0"
|
||||
return f"iw*{rect['w']}:ih*{rect['h']}:iw*{rect['x']}:ih*{rect['y']}"
|
||||
|
||||
|
||||
def _fill(width: int, height: int) -> str:
|
||||
"""Escala cobrindo e recorta no centro para width×height."""
|
||||
return f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}"
|
||||
|
||||
|
||||
def _fit(width: int, height: int) -> str:
|
||||
"""Escala cabendo inteiro (sem cortar nem distorcer) e completa com faixas pretas até width×height."""
|
||||
return (f"scale={width}:{height}:force_original_aspect_ratio=decrease:force_divisible_by=2,"
|
||||
f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color=black")
|
||||
|
||||
|
||||
def cam_panel_height(settings: dict) -> int:
|
||||
"""Altura (px do vídeo vertical) do painel da câmera no `cam_top`."""
|
||||
return int(round(H * settings["layout"]["camHeight"] / 2)) * 2
|
||||
|
||||
|
||||
def layout_chain(settings: dict, src: str, dst: str, tail: str = "", suffix: str = "", mode: str | None = None,
|
||||
reframe=None) -> str:
|
||||
"""Trecho de filtergraph: [src] (quadro original) → [dst] no tamanho do formato (1080×1920 ou 1920×1080).
|
||||
`tail` = filtros extras (com vírgula na frente) antes do rótulo final; `suffix` deixa os rótulos internos únicos
|
||||
(vários trechos no mesmo grafo, no editor); `mode` sobrescreve o modo (troca de layout por trecho).
|
||||
`reframe` = função (proporção da área do jogo → filtro, de `reframe.py`) que reenquadra o jogo no tempo: a janela
|
||||
vira a área do jogo (parte de baixo no `cam_top`; a tela toda nos outros modos, inclusive `blur`) e `layout.game`
|
||||
é ignorado. Não vale para `cam_only`."""
|
||||
if mode and mode != "auto":
|
||||
settings = {**settings, "layout": {**settings["layout"], "mode": mode}}
|
||||
mode = resolved_mode(settings)
|
||||
lay = settings["layout"]
|
||||
s = suffix
|
||||
if reframe is not None and mode != "cam_only":
|
||||
if mode == "cam_top":
|
||||
top = cam_panel_height(settings)
|
||||
return (
|
||||
f"[{src}]split=2[c{s}][g{s}];"
|
||||
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
|
||||
f"[g{s}]{reframe(W / (H - top))},scale={W}:{H - top},setsar=1[game{s}];"
|
||||
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
|
||||
)
|
||||
fw, fh = frame_size(settings)
|
||||
return f"[{src}]{reframe(fw / fh)},scale={fw}:{fh},setsar=1{tail}[{dst}]"
|
||||
if aspect(settings) == "horizontal":
|
||||
fw, fh = frame_size(settings)
|
||||
if mode == "cam_only":
|
||||
return f"[{src}]crop={_crop(lay['cam'])},{_fill(fw, fh)}{tail}[{dst}]"
|
||||
if lay["game"]: # região do jogo marcada: preenche a tela (recorta no centro, sem distorcer)
|
||||
return f"[{src}]crop={_crop(lay['game'])},{_fill(fw, fh)}{tail}[{dst}]"
|
||||
# Quadro original inteiro (16:9 já preenche; outra proporção ganha faixas pretas em vez de ser cortada).
|
||||
return f"[{src}]{_fit(fw, fh)}{tail}[{dst}]"
|
||||
if mode == "cam_top":
|
||||
top = cam_panel_height(settings)
|
||||
return (
|
||||
f"[{src}]split=2[c{s}][g{s}];"
|
||||
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
|
||||
f"[g{s}]crop={_crop(lay['game'])},{_fill(W, H - top)}[game{s}];"
|
||||
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
|
||||
)
|
||||
if mode == "game_only":
|
||||
return f"[{src}]crop={_crop(lay['game'])},{_fill(W, H)}{tail}[{dst}]"
|
||||
if mode == "cam_only":
|
||||
return f"[{src}]crop={_crop(lay['cam'])},{_fill(W, H)}{tail}[{dst}]"
|
||||
return (
|
||||
f"[{src}]split=2[bg{s}][fg{s}];"
|
||||
f"[bg{s}]{_fill(W, H)},boxblur=25:2,eq=brightness=-0.08[bg2{s}];"
|
||||
f"[fg{s}]scale=1080:-2[fg2{s}];"
|
||||
f"[bg2{s}][fg2{s}]overlay=(W-w)/2:(H-h)/2-80{tail}[{dst}]"
|
||||
)
|
||||
|
||||
|
||||
def video_filter(settings: dict, ass_name: str | None, ass_text: str | None = None, reframe=None) -> str:
|
||||
"""filter_complex de [0:v] → [v] no tamanho do formato, 30 fps, com a legenda (se houver). `ass_text` = conteúdo
|
||||
do ASS (decide se o libass precisa da pasta das fontes empacotadas); `reframe` = ver `layout_chain`."""
|
||||
tail = (f",{ass_filter(ass_name, ass_text)}" if ass_name else "") + ",fps=30,format=yuv420p"
|
||||
return layout_chain(settings, "0:v", "v", tail, reframe=reframe)
|
||||
|
||||
|
||||
def caption_y(settings: dict) -> int:
|
||||
"""Centro vertical da legenda em px do quadro lógico do ASS (`canvas_size`). Automático: na emenda câmera/jogo
|
||||
(cam_top) ou ~74 % da altura no vertical; no horizontal, 85 % da altura (terço de baixo, acima do rodapé)."""
|
||||
y = settings["caption"]["y"]
|
||||
_, ch = canvas_size(settings)
|
||||
if y is not None:
|
||||
return int(ch * y)
|
||||
if aspect(settings) == "horizontal":
|
||||
return int(ch * 0.85)
|
||||
if resolved_mode(settings) == "cam_top":
|
||||
return cam_panel_height(settings) + 40
|
||||
return 1420
|
||||
|
||||
|
||||
def credit_placement(settings: dict) -> tuple[int, int, int]:
|
||||
"""(alinhamento ASS, margem lateral, margem vertical) do crédito do canal no quadro lógico.
|
||||
Vertical: centralizado, abaixo da área do título das redes (topo) ou acima da barra (rodapé); com a câmera em
|
||||
cima, desce para o pé do painel da câmera. Horizontal: no canto direito, para não cobrir o meio do jogo."""
|
||||
cred = settings["credit"]
|
||||
if aspect(settings) == "horizontal":
|
||||
return (9, 48, 36) if cred["position"] == "top" else (3, 48, 36)
|
||||
align, margin = (8, 170) if cred["position"] == "top" else (2, 90)
|
||||
if cred["position"] == "top" and resolved_mode(settings) == "cam_top":
|
||||
# Com a câmera em cima, o topo é o rosto do streamer: o crédito desce para o pé do painel da câmera.
|
||||
margin = max(20, cam_panel_height(settings) - cred["size"] - 34)
|
||||
return align, 40, margin
|
||||
|
||||
|
||||
def ass_color(hex_rgb: str) -> str:
|
||||
"""#RRGGBB → &H00BBGGRR& para a linha Style (ASS guarda em BGR, com alfa na frente)."""
|
||||
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
|
||||
return f"&H00{b}{g}{r}&".upper()
|
||||
|
||||
|
||||
def ass_inline_color(hex_rgb: str) -> str:
|
||||
"""#RRGGBB → &HBBGGRR& para a tag \\c dentro do texto (sem alfa)."""
|
||||
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
|
||||
return f"&H{b}{g}{r}&".upper()
|
||||
@@ -0,0 +1,681 @@
|
||||
"""API do Clipador (127.0.0.1:4520, faixa 4500–4599 do CenaForge). Toda rota, exceto GET /health, exige
|
||||
`X-Service-Key` = CLIPPER_SERVICE_KEY (clipper/.env). Quem chama é o painel (panel/src/lib/clipper.ts)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hmac
|
||||
import logging
|
||||
from contextlib import asynccontextmanager
|
||||
from typing import Literal
|
||||
|
||||
from fastapi import FastAPI, Query, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from .config import ConfigError, Settings
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
from . import capture, layout, media
|
||||
from .config import REPO_ROOT
|
||||
from .db import Database, loads, now
|
||||
from .judge import JudgeError
|
||||
from .scoring import timeline as timeline_series
|
||||
from .scoring import Word
|
||||
from .sources import SourceError, parse_source
|
||||
from .subtitles import build_ass
|
||||
from .worker import Engine
|
||||
from . import clip_delete, editor_api
|
||||
|
||||
VERSION = "1.0.0"
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
||||
|
||||
|
||||
class UserError(Exception):
|
||||
def __init__(self, message: str, status: int = 400):
|
||||
super().__init__(message)
|
||||
self.message, self.status = message, status
|
||||
|
||||
|
||||
class ChannelIn(BaseModel):
|
||||
url: str = Field(min_length=3, max_length=300)
|
||||
displayName: str | None = Field(default=None, max_length=60)
|
||||
monitor: bool = True
|
||||
authorized: bool = False
|
||||
|
||||
|
||||
class ChannelPatch(BaseModel):
|
||||
displayName: str | None = Field(default=None, max_length=60)
|
||||
monitor: bool | None = None
|
||||
authorized: bool | None = None
|
||||
|
||||
|
||||
class SessionIn(BaseModel):
|
||||
url: str = Field(min_length=3, max_length=300)
|
||||
|
||||
|
||||
class ManualClipIn(BaseModel):
|
||||
"""Corte manual: os últimos `lastS` segundos gravados, ou o trecho [startS, endS]."""
|
||||
lastS: float | None = Field(default=None, ge=5, le=180)
|
||||
startS: float | None = Field(default=None, ge=0)
|
||||
endS: float | None = Field(default=None, ge=0)
|
||||
|
||||
|
||||
class JudgeIn(BaseModel):
|
||||
provider: Literal["codex", "claude", "off"]
|
||||
model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
|
||||
minScore: float = Field(default=6, ge=0, le=10)
|
||||
# Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer.
|
||||
analystModel: str | None = Field(default=None, max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
|
||||
# Varredura da IA (procura momentos sem pico de chat), visão (frames da tela) e detecção da webcam.
|
||||
scanEnabled: bool | None = None
|
||||
scanIntervalS: int | None = Field(default=None, ge=60, le=900)
|
||||
vision: bool | None = None
|
||||
camDetect: bool | None = None
|
||||
# Rastreio do rosto do streamer (face.py): reforça/cria cortes e vai em texto para o analista.
|
||||
faceTrack: bool | None = None
|
||||
|
||||
|
||||
class GameIn(BaseModel):
|
||||
name: str = Field(min_length=1, max_length=120)
|
||||
|
||||
|
||||
class GameProfileIn(BaseModel):
|
||||
"""Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve)."""
|
||||
name: str = Field(default="", max_length=120)
|
||||
summary: str = Field(default="", max_length=1500)
|
||||
genre: str = Field(default="", max_length=120)
|
||||
mechanics: list[str] = Field(default_factory=list, max_length=30)
|
||||
clip_worthy: list[str] = Field(default_factory=list, max_length=30)
|
||||
avoid: list[str] = Field(default_factory=list, max_length=30)
|
||||
jargon: list[str] = Field(default_factory=list, max_length=40)
|
||||
news: list[str] = Field(default_factory=list, max_length=30)
|
||||
hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py)
|
||||
sources: list[str] = Field(default_factory=list, max_length=20)
|
||||
|
||||
|
||||
class ChatTurnIn(BaseModel):
|
||||
role: Literal["user", "ai"]
|
||||
text: str = Field(max_length=1500)
|
||||
|
||||
|
||||
class GameRefineIn(BaseModel):
|
||||
instruction: str = Field(min_length=3, max_length=1500)
|
||||
search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo
|
||||
section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources"] = ""
|
||||
history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção
|
||||
|
||||
|
||||
class PreviewIn(BaseModel):
|
||||
t: float | None = Field(default=None, ge=0)
|
||||
settings: dict = Field(default_factory=dict)
|
||||
|
||||
|
||||
class ClipPatch(BaseModel):
|
||||
status: Literal["approved", "rejected", "ready", "published"] | None = None
|
||||
title: str | None = Field(default=None, max_length=100)
|
||||
caption: str | None = Field(default=None, max_length=2200)
|
||||
startS: float | None = Field(default=None, ge=0)
|
||||
endS: float | None = Field(default=None, ge=0)
|
||||
|
||||
|
||||
ClipStatusName = Literal["candidate", "discarded", "pending", "rendering", "ready", "approved", "rejected", "published", "error"]
|
||||
|
||||
|
||||
class ClipsDeleteIn(BaseModel):
|
||||
"""Apagar em lote: `ids` (os cortes escolhidos) OU `statuses` (+ `sessionId` opcional) = todos de uma aba.
|
||||
`confirmPublished` libera apagar corte publicado (sem ele, o publicado é recusado com o motivo)."""
|
||||
ids: list[int] | None = Field(default=None, min_length=1, max_length=clip_delete.MAX_BATCH)
|
||||
statuses: list[ClipStatusName] | None = Field(default=None, min_length=1, max_length=9)
|
||||
sessionId: int | None = Field(default=None, ge=1)
|
||||
confirmPublished: bool = False
|
||||
|
||||
|
||||
def clip_view(row: dict) -> dict:
|
||||
return {
|
||||
"id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"],
|
||||
"endS": row["end_s"], "durationS": round(row["end_s"] - row["start_s"], 2), "score": row["score"],
|
||||
"source": row["source"], "reasons": loads(row["reasons_json"], {}), "judge": loads(row["judge_json"], None),
|
||||
"title": row["title"], "caption": row["caption"], "transcript": row["transcript"], "status": row["status"],
|
||||
"file": row["file"], "thumb": row["thumb"], "error": row["error"],
|
||||
# Formato em que o arquivo foi renderizado (vertical 1080×1920 · horizontal 1920×1080); antes do 1º render,
|
||||
# e nos cortes de antes da migração v8, vale o padrão `vertical`.
|
||||
"aspect": row.get("aspect") or "vertical",
|
||||
"createdAt": row["created_at"], "updatedAt": row["updated_at"],
|
||||
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
|
||||
# Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export)
|
||||
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
|
||||
"origin": row.get("edit_origin")}
|
||||
if row.get("edit_updated_at") else None),
|
||||
}
|
||||
|
||||
|
||||
def session_view(row: dict, engine: Engine) -> dict:
|
||||
counts = {r["status"]: r["n"] for r in engine.db.all(
|
||||
"SELECT status, COUNT(*) AS n FROM clips WHERE session_id = ? GROUP BY status", row["id"])}
|
||||
seg = engine.db.get(
|
||||
"SELECT COUNT(*) AS total, SUM(analyzed) AS analyzed, SUM(CASE WHEN transcript_error IS NOT NULL THEN 1 ELSE 0 END) AS errors"
|
||||
" FROM segments WHERE session_id = ?", row["id"])
|
||||
chat = engine.db.get("SELECT COUNT(*) AS n FROM chat WHERE session_id = ?", row["id"])["n"]
|
||||
live_chat = engine.chat_status(row["id"])
|
||||
return {
|
||||
"id": row["id"], "channelId": row["channel_id"], "platform": row["platform"], "kind": row["kind"],
|
||||
"url": row["url"], "title": row["title"], "status": row["status"],
|
||||
"chatStatus": live_chat["status"] if live_chat else row["chat_status"], "chatMessages": chat,
|
||||
"durationS": row["duration_s"], "startedAt": row["started_at"], "endedAt": row["ended_at"], "error": row["error"],
|
||||
"segments": {"total": seg["total"] or 0, "analyzed": seg["analyzed"] or 0, "transcriptErrors": seg["errors"] or 0},
|
||||
"clips": counts,
|
||||
# Contexto do jogo: categoria da plataforma, o que a IA viu na tela, trocas e se você corrigiu à mão.
|
||||
"game": row.get("game", ""), "gameSource": row.get("game_source", ""), "screenGame": row.get("screen_game", ""),
|
||||
"gameHistory": loads(row.get("games_json"), []), "gameProfileReady": bool(engine.intel.profile(row.get("game", ""))),
|
||||
"scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []),
|
||||
"camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"),
|
||||
"hasOwnSettings": bool(loads(row.get("settings_json"), {})),
|
||||
# O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec,
|
||||
# kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco.
|
||||
"capture": loads(row.get("capture_json"), None),
|
||||
}
|
||||
|
||||
|
||||
def channel_view(row: dict) -> dict:
|
||||
return {
|
||||
"id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"],
|
||||
"displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]),
|
||||
"lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"],
|
||||
}
|
||||
|
||||
|
||||
def create_app(settings: Settings | None = None, engine: Engine | None = None, start_engine: bool = True) -> FastAPI:
|
||||
settings = settings or Settings.load()
|
||||
if not settings.service_key:
|
||||
raise ConfigError("CLIPPER_SERVICE_KEY vazio: rode o setup.bat (ou preencha clipper/.env).")
|
||||
db = engine.db if engine else Database(settings.data_dir / "clipper.db")
|
||||
engine = engine or Engine(settings, db)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
if start_engine:
|
||||
engine.start()
|
||||
yield
|
||||
engine.shutdown()
|
||||
|
||||
app = FastAPI(title="CenaForge Clipador", version=VERSION, docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
|
||||
app.state.engine = engine
|
||||
|
||||
@app.middleware("http")
|
||||
async def auth(request: Request, call_next):
|
||||
if request.url.path != "/health":
|
||||
given = request.headers.get("X-Service-Key", "")
|
||||
if not hmac.compare_digest(given.encode(), settings.service_key.encode()):
|
||||
return JSONResponse({"error": "Chave do serviço ausente ou inválida."}, status_code=401)
|
||||
return await call_next(request)
|
||||
|
||||
@app.exception_handler(UserError)
|
||||
async def user_error(_request: Request, exc: UserError):
|
||||
return JSONResponse({"error": exc.message}, status_code=exc.status)
|
||||
|
||||
@app.exception_handler(SourceError)
|
||||
async def source_error(_request: Request, exc: SourceError):
|
||||
return JSONResponse({"error": str(exc)}, status_code=400)
|
||||
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "ok", "version": VERSION}
|
||||
|
||||
@app.get("/v1/status")
|
||||
def status():
|
||||
return {
|
||||
"version": VERSION,
|
||||
"tools": {"streamlink": settings.streamlink, "ffmpeg": settings.ffmpeg},
|
||||
"voice": {"configured": engine.voice.configured, "online": engine.voice.healthy()},
|
||||
"judge": engine.judge_config(),
|
||||
"recording": db.get("SELECT COUNT(*) AS n FROM sessions WHERE status IN ('starting', 'recording')")["n"],
|
||||
# A qualidade de gravação agora é por canal/sessão (`capture.quality`); aqui vai o padrão do serviço.
|
||||
"settings": {"quality": layout.DEFAULTS["capture"]["quality"], "segmentS": settings.segment_s, "pollS": settings.poll_s,
|
||||
"keepHours": settings.keep_hours, "language": settings.language},
|
||||
}
|
||||
|
||||
# ---------- juiz (IA pela CLI: Codex/GPT ou Claude)
|
||||
@app.get("/v1/judge")
|
||||
def get_judge():
|
||||
return engine.judge_config() | {"models": engine.judge.models()}
|
||||
|
||||
@app.put("/v1/judge")
|
||||
def put_judge(body: JudgeIn):
|
||||
try:
|
||||
engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS,
|
||||
"vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack})
|
||||
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel) | {
|
||||
"models": engine.judge.models()}
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
|
||||
# ---------- configuração do corte (layout, câmera, legenda, crédito, duração)
|
||||
def _settings_payload(own: dict, channel_layer: dict | None, session_layer: dict | None) -> dict:
|
||||
return {"own": own, "effective": layout.merge(channel_layer, session_layer), "defaults": layout.DEFAULTS,
|
||||
"modes": list(layout.MODES), "fonts": list(layout.FONTS), "aspects": list(layout.ASPECTS),
|
||||
# Fontes empacotadas: {família: arquivo relativo à raiz do repositório} (o painel carrega a mesma).
|
||||
# Qualidades de gravação (grupo `capture`): rótulo, teto e disco por hora medido/estimado.
|
||||
"captureQualities": capture.OPTIONS,
|
||||
"fontFiles": layout.font_files(), "hookStyles": list(layout.HOOK_STYLES), "hookAnims": list(layout.HOOK_ANIMS),
|
||||
# Tamanho do vídeo e quadro lógico dos textos (ASS) de cada formato, para o painel desenhar a prévia.
|
||||
"frames": {a: {"width": layout.FRAME_SIZES[a][0], "height": layout.FRAME_SIZES[a][1],
|
||||
"canvasWidth": layout.CANVAS_SIZES[a][0], "canvasHeight": layout.CANVAS_SIZES[a][1]}
|
||||
for a in layout.ASPECTS}}
|
||||
|
||||
@app.get("/v1/channels/{channel_id}/settings")
|
||||
def get_channel_settings(channel_id: str):
|
||||
row = db.get("SELECT settings_json FROM channels WHERE id = ?", channel_id)
|
||||
if not row:
|
||||
raise UserError("Canal não encontrado.", 404)
|
||||
own = loads(row["settings_json"], {})
|
||||
return _settings_payload(own, own, None)
|
||||
|
||||
@app.put("/v1/channels/{channel_id}/settings")
|
||||
def put_channel_settings(channel_id: str, body: dict):
|
||||
if not db.get("SELECT 1 FROM channels WHERE id = ?", channel_id):
|
||||
raise UserError("Canal não encontrado.", 404)
|
||||
try:
|
||||
own = layout.validate(body)
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(own), channel_id)
|
||||
return _settings_payload(own, own, None)
|
||||
|
||||
def _session(session_id: int) -> dict:
|
||||
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||||
if not row:
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
return row
|
||||
|
||||
def _channel_layer(row: dict) -> dict | None:
|
||||
if not row.get("channel_id"):
|
||||
return None
|
||||
ch = db.get("SELECT settings_json FROM channels WHERE id = ?", row["channel_id"])
|
||||
return loads(ch["settings_json"], {}) if ch else None
|
||||
|
||||
@app.get("/v1/sessions/{session_id}/settings")
|
||||
def get_session_settings(session_id: int):
|
||||
row = _session(session_id)
|
||||
own = loads(row["settings_json"], {})
|
||||
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
|
||||
|
||||
@app.put("/v1/sessions/{session_id}/settings")
|
||||
def put_session_settings(session_id: int, body: dict):
|
||||
"""Configuração própria da sessão (sobrescreve a do canal campo a campo). Vale para os próximos renders."""
|
||||
row = _session(session_id)
|
||||
try:
|
||||
own = layout.validate(body)
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(own) if own else None, session_id)
|
||||
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
|
||||
|
||||
def _frame(row: dict, t: float | None, name: str, width: int = 1280) -> tuple[float, Path]:
|
||||
segments = [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
|
||||
for s in db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", row["id"])]
|
||||
if not segments:
|
||||
raise UserError("Ainda não há vídeo gravado nesta sessão.")
|
||||
at = segments[-1][2] - 3 if t is None else t
|
||||
out = settings.clips_dir / str(row["id"]) / name
|
||||
try:
|
||||
media.grab_frame(settings.ffmpeg or "ffmpeg", segments, at, out, width)
|
||||
except media.MediaError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
return at, out
|
||||
|
||||
@app.get("/v1/sessions/{session_id}/frame")
|
||||
def get_frame(session_id: int, t: float | None = None):
|
||||
"""Quadro do vídeo original (1280 px) para o editor desenhar a câmera. Servido por /api/files."""
|
||||
at, out = _frame(_session(session_id), t, "frame.jpg")
|
||||
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "version": now()}
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/preview")
|
||||
def preview(session_id: int, body: PreviewIn):
|
||||
"""Prévia (1080×1920 ou 1920×1080, pelo `format.aspect` efetivo) de como o corte vai ficar com a configuração enviada (sem salvar)."""
|
||||
row = _session(session_id)
|
||||
try:
|
||||
layer = layout.validate(body.settings)
|
||||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
cfg = layout.merge(_channel_layer(row), loads(row["settings_json"], {}), layer)
|
||||
at, frame = _frame(row, body.t, "preview-src.jpg", width=0)
|
||||
# Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda.
|
||||
sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
|
||||
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
|
||||
out = settings.clips_dir / str(row["id"]) / "preview.jpg"
|
||||
try:
|
||||
media.preview_still(settings.ffmpeg or "ffmpeg", frame, cfg, ass, out)
|
||||
except media.MediaError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "mode": layout.resolved_mode(cfg),
|
||||
"version": now()}
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/detect-cam")
|
||||
def detect_cam(session_id: int, ai: bool = False):
|
||||
"""Acha a webcam: primeiro local (YuNet em 12 quadros, sem IA); a IA olha 3 quadros se o local não achar
|
||||
rosto ou com `?ai=true`. Aplica como padrão do canal (ou da sessão) se ainda não houver."""
|
||||
_session(session_id)
|
||||
try:
|
||||
return engine.intel.detect_cam(session_id, apply=True, use_ai=ai)
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
|
||||
# ---------- rastreio de reação (rosto do streamer)
|
||||
@app.get("/v1/sessions/{session_id}/face")
|
||||
def get_face(session_id: int, from_: float = Query(default=0.0, alias="from", ge=0),
|
||||
to: float | None = Query(default=None, ge=0)):
|
||||
"""Série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal` = z da reação) e picos."""
|
||||
if to is not None and to < from_:
|
||||
raise UserError("`to` precisa ser maior que `from`.")
|
||||
return engine.face.view(_session(session_id), from_, to)
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/face/reset")
|
||||
def reset_face(session_id: int):
|
||||
"""Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco
|
||||
em andamento não espera: responde 202 com `scheduled: true` e o laço apaga antes do próximo bloco."""
|
||||
_session(session_id)
|
||||
result = engine.face.reset(session_id)
|
||||
return JSONResponse({"ok": True, **result}, status_code=202 if result["scheduled"] else 200)
|
||||
|
||||
# ---------- jogo
|
||||
@app.put("/v1/sessions/{session_id}/game")
|
||||
def put_game(session_id: int, body: GameIn):
|
||||
"""Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais."""
|
||||
_session(session_id)
|
||||
engine.intel.set_game(session_id, body.name.strip(), "user")
|
||||
return session_view(_session(session_id), engine)
|
||||
|
||||
@app.get("/v1/games")
|
||||
def list_games():
|
||||
return {"games": [{"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"],
|
||||
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
|
||||
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None)}
|
||||
for g in db.all("SELECT * FROM games ORDER BY name")]}
|
||||
|
||||
@app.post("/v1/games/{game_id}/research")
|
||||
def research_game(game_id: str):
|
||||
"""Pesquisa (de novo) o jogo na web pela IA. Leva de 15 s a alguns minutos. Os pedidos guardados entram junto."""
|
||||
try:
|
||||
engine.intel.research(game_id)
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
return list_games()
|
||||
|
||||
@app.put("/v1/games/{game_id}")
|
||||
def put_game_profile(game_id: str, body: GameProfileIn):
|
||||
"""Grava o perfil editado à mão. A IA passa a usar na hora."""
|
||||
try:
|
||||
engine.intel.save_profile(game_id, body.model_dump())
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc), 404) from exc
|
||||
return list_games()
|
||||
|
||||
@app.post("/v1/games/{game_id}/refine")
|
||||
def refine_game(game_id: str, body: GameRefineIn):
|
||||
"""Pede à IA para acrescentar/corrigir algo no perfil ("acrescente que ..."). O pedido fica guardado."""
|
||||
try:
|
||||
_, reply = engine.intel.refine(game_id, body.instruction.strip(), body.search, body.section,
|
||||
[t.model_dump() for t in body.history])
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
return {**list_games(), "reply": reply}
|
||||
|
||||
@app.delete("/v1/games/{game_id}/notes/{index}")
|
||||
def delete_game_note(game_id: str, index: int):
|
||||
"""Esquece um pedido guardado (não volta mais nas pesquisas; o perfil atual fica como está)."""
|
||||
try:
|
||||
engine.intel.delete_note(game_id, index)
|
||||
except JudgeError as exc:
|
||||
raise UserError(str(exc), 404) from exc
|
||||
return list_games()
|
||||
|
||||
# ---------- emotes que o canal usa (e o peso que aprenderam)
|
||||
@app.get("/v1/emotes")
|
||||
def list_emotes(channel: str, limit: int = 60):
|
||||
rows = db.all("SELECT * FROM emotes WHERE channel_key = ? ORDER BY uses DESC LIMIT ?", channel, max(1, min(limit, 300)))
|
||||
return {"emotes": [{"name": r["name"], "source": r["source"], "uses": r["uses"], "weight": round(r["weight"], 2),
|
||||
"lastSeen": r["last_seen"]} for r in rows]}
|
||||
|
||||
# ---------- canais
|
||||
@app.get("/v1/channels")
|
||||
def list_channels():
|
||||
return {"channels": [channel_view(r) for r in db.all("SELECT * FROM channels ORDER BY display_name")]}
|
||||
|
||||
@app.post("/v1/channels", status_code=201)
|
||||
def create_channel(body: ChannelIn):
|
||||
source = parse_source(body.url)
|
||||
if source.kind != "live" or not source.channel:
|
||||
raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.")
|
||||
if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id):
|
||||
raise UserError("Esse canal já está na lista.", 409)
|
||||
db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at)"
|
||||
" VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
source.channel_id, source.platform, source.channel, source.url,
|
||||
(body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now())
|
||||
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id))
|
||||
|
||||
@app.patch("/v1/channels/{channel_id}")
|
||||
def update_channel(channel_id: str, body: ChannelPatch):
|
||||
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
|
||||
if not row:
|
||||
raise UserError("Canal não encontrado.", 404)
|
||||
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ? WHERE id = ?",
|
||||
(body.displayName or row["display_name"]).strip(),
|
||||
int(body.monitor if body.monitor is not None else row["monitor"]),
|
||||
int(body.authorized if body.authorized is not None else row["authorized"]), channel_id)
|
||||
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id))
|
||||
|
||||
@app.delete("/v1/channels/{channel_id}", status_code=204)
|
||||
def delete_channel(channel_id: str):
|
||||
for s in db.all("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel_id):
|
||||
engine.stop_session(s["id"])
|
||||
db.run("DELETE FROM channels WHERE id = ?", channel_id)
|
||||
|
||||
@app.post("/v1/channels/{channel_id}/check")
|
||||
def check_channel(channel_id: str):
|
||||
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
|
||||
if not row:
|
||||
raise UserError("Canal não encontrado.", 404)
|
||||
live, title = engine.check_live(row["url"])
|
||||
db.run("UPDATE channels SET last_check_at = ?, last_status = ? WHERE id = ?", now(), "ao vivo" if live else "offline", channel_id)
|
||||
return {"live": live, "title": title}
|
||||
|
||||
# ---------- sessões
|
||||
@app.get("/v1/sessions")
|
||||
def list_sessions(limit: int = 30):
|
||||
rows = db.all("SELECT * FROM sessions ORDER BY id DESC LIMIT ?", max(1, min(limit, 200)))
|
||||
return {"sessions": [session_view(r, engine) for r in rows]}
|
||||
|
||||
@app.post("/v1/sessions", status_code=201)
|
||||
def create_session(body: SessionIn):
|
||||
source = parse_source(body.url)
|
||||
channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None
|
||||
try:
|
||||
session_id = engine.start_session(body.url, channel["id"] if channel else None)
|
||||
except RuntimeError as exc:
|
||||
raise UserError(str(exc)) from exc
|
||||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||||
|
||||
@app.get("/v1/sessions/{session_id}")
|
||||
def get_session(session_id: int):
|
||||
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||||
if not row:
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
return session_view(row, engine)
|
||||
|
||||
@app.get("/v1/sessions/{session_id}/timeline")
|
||||
def get_timeline(session_id: int):
|
||||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
tl = engine.load_timeline(session_id)
|
||||
return {"durationS": tl["duration"], **timeline_series(tl["duration"], tl["chat"], tl["loudness"], engine.params)}
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/clips", status_code=201)
|
||||
def manual_clip(session_id: int, body: ManualClipIn):
|
||||
session = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||||
if not session:
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
duration = session["duration_s"]
|
||||
if body.lastS is not None:
|
||||
start, end = max(0.0, duration - body.lastS), duration
|
||||
elif body.startS is not None and body.endS is not None:
|
||||
start, end = body.startS, min(body.endS, duration)
|
||||
else:
|
||||
raise UserError("Informe lastS ou startS e endS.")
|
||||
if end - start < 5:
|
||||
raise UserError("Ainda não há gravação suficiente para esse corte.")
|
||||
ts = now()
|
||||
cur = db.run(
|
||||
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
|
||||
" VALUES (?, ?, ?, ?, 0, 'manual', '{}', 'candidate', ?, ?)", session_id, end, start, end, ts, ts)
|
||||
engine.wake_clips.set()
|
||||
return clip_view(_clip(int(cur.lastrowid)))
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/stop")
|
||||
def stop_session(session_id: int):
|
||||
engine.stop_session(session_id)
|
||||
return {"ok": True}
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/resume")
|
||||
def resume_session(session_id: int):
|
||||
"""Volta a gravar uma live interrompida (ex.: o serviço reiniciou) ou parada, na mesma sessão."""
|
||||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
try:
|
||||
engine.resume_session(session_id)
|
||||
except RuntimeError as exc:
|
||||
raise UserError(f"Não deu para retomar: {exc}.") from exc
|
||||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||||
|
||||
@app.post("/v1/sessions/{session_id}/finish")
|
||||
def finish_session(session_id: int):
|
||||
"""Encerra e processa o que foi gravado: varredura do restante, juízes e render dos cortes."""
|
||||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||||
raise UserError("Sessão não encontrada.", 404)
|
||||
engine.finish_session(session_id)
|
||||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||||
|
||||
@app.delete("/v1/sessions/{session_id}", status_code=204)
|
||||
def delete_session(session_id: int):
|
||||
engine.delete_session(session_id)
|
||||
|
||||
# ---------- cortes
|
||||
@app.get("/v1/clips")
|
||||
def list_clips(status: str | None = None, session: int | None = None, limit: int = 100,
|
||||
channel: str | None = None, ids: str | None = None):
|
||||
"""Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`.
|
||||
O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila."""
|
||||
sql = "SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1"
|
||||
params: list = []
|
||||
if status:
|
||||
sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")"
|
||||
params += status.split(",")
|
||||
if session:
|
||||
sql += " AND c.session_id = ?"
|
||||
params.append(session)
|
||||
if channel:
|
||||
channels = [c for c in channel.split(",") if c][:200]
|
||||
sql += " AND s.channel_id IN (" + ",".join("?" * len(channels)) + ")"
|
||||
params += channels
|
||||
if ids:
|
||||
try:
|
||||
id_list = [int(i) for i in ids.split(",") if i][:500]
|
||||
except ValueError as exc:
|
||||
raise UserError("`ids` precisa ser uma lista de números separados por vírgula.") from exc
|
||||
sql += " AND c.id IN (" + ",".join("?" * len(id_list)) + ")"
|
||||
params += id_list
|
||||
sql += " ORDER BY c.id DESC LIMIT ?"
|
||||
params.append(max(1, min(limit, 500)))
|
||||
return {"clips": [clip_view(r) for r in db.all(sql, *params)]}
|
||||
|
||||
def _clip(clip_id: int) -> dict:
|
||||
row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", clip_id)
|
||||
if not row:
|
||||
raise UserError("Corte não encontrado.", 404)
|
||||
return row
|
||||
|
||||
@app.post("/v1/clips/delete")
|
||||
def delete_clips(body: ClipsDeleteIn):
|
||||
"""Apaga vários cortes: os `ids` escolhidos, ou todos nos `statuses` (de uma sessão, com `sessionId`), até
|
||||
`clip_delete.MAX_BATCH` por chamada. Cada um segue as regras de `DELETE /v1/clips/{id}`; a resposta diz o
|
||||
que saiu (`deleted`) e o que não saiu e por quê (`failed`). `remaining` = quantos passaram do limite."""
|
||||
if (body.ids is None) == (body.statuses is None):
|
||||
raise UserError("Mande `ids` ou `statuses` (um dos dois).")
|
||||
if body.ids is not None and body.sessionId is not None:
|
||||
raise UserError("`sessionId` só vale junto com `statuses`.")
|
||||
remaining = 0
|
||||
if body.ids is not None:
|
||||
if any(i < 1 for i in body.ids):
|
||||
raise UserError("Id de corte inválido.")
|
||||
ids = list(dict.fromkeys(body.ids))
|
||||
else:
|
||||
ids, remaining = clip_delete.select_ids(db, body.sessionId, list(dict.fromkeys(body.statuses)))
|
||||
result = clip_delete.delete_many(engine, ids, body.confirmPublished)
|
||||
if result["deleted"]:
|
||||
engine.wake_clips.set() # a sessão pode ter acabado de ficar sem pendências (finish_if_done)
|
||||
return {"requested": len(ids), "remaining": remaining, **result}
|
||||
|
||||
@app.delete("/v1/clips/{clip_id}")
|
||||
def delete_clip(clip_id: int, confirmPublished: bool = False):
|
||||
"""Apaga o corte, o projeto de edição e os arquivos dele (só dentro das pastas do Clipador). Recusa `candidate`
|
||||
e `rendering` (409, o motor está mexendo nele) e `published` sem `?confirmPublished=true`. O momento fica
|
||||
marcado: a IA não recria o mesmo corte (clip_delete.py)."""
|
||||
try:
|
||||
result = clip_delete.delete_clip(engine, clip_id, confirmPublished)
|
||||
except clip_delete.DeleteRefused as exc:
|
||||
message = "Corte não encontrado." if exc.code == "not_found" else f"Não deu para apagar: {exc.message}."
|
||||
return JSONResponse({"error": message, "code": exc.code}, status_code=exc.status)
|
||||
engine.wake_clips.set()
|
||||
return result
|
||||
|
||||
@app.get("/v1/clips/{clip_id}")
|
||||
def get_clip(clip_id: int):
|
||||
return clip_view(_clip(clip_id))
|
||||
|
||||
@app.patch("/v1/clips/{clip_id}")
|
||||
def update_clip(clip_id: int, body: ClipPatch):
|
||||
row = _clip(clip_id)
|
||||
start = body.startS if body.startS is not None else row["start_s"]
|
||||
end = body.endS if body.endS is not None else row["end_s"]
|
||||
if not 5 <= end - start <= 180:
|
||||
raise UserError("O corte precisa ter entre 5 e 180 segundos.")
|
||||
retime = (start, end) != (row["start_s"], row["end_s"])
|
||||
status = body.status or row["status"]
|
||||
if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"):
|
||||
raise UserError("Só dá para aprovar um corte já renderizado.")
|
||||
if retime:
|
||||
status = "pending" # novo trecho → renderiza de novo
|
||||
db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?",
|
||||
body.title if body.title is not None else row["title"],
|
||||
body.caption if body.caption is not None else row["caption"], start, end, status, now(), clip_id)
|
||||
if retime:
|
||||
editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto
|
||||
engine.wake_clips.set()
|
||||
if body.status in ("approved", "rejected") and body.status != row["status"]:
|
||||
# Sua decisão é o sinal forte: emotes da reação deste corte ganham/perdem peso no canal (uma vez).
|
||||
engine.intel.learn_from_clip(row, positive=body.status == "approved", mark=True)
|
||||
return clip_view(_clip(clip_id))
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/render")
|
||||
def rerender(clip_id: int):
|
||||
"""Força o render (ex.: corte que a IA descartou ou que deu erro)."""
|
||||
_clip(clip_id)
|
||||
db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id)
|
||||
engine.wake_clips.set()
|
||||
return clip_view(_clip(clip_id))
|
||||
|
||||
@app.post("/v1/clips/{clip_id}/rejudge")
|
||||
def rejudge(clip_id: int):
|
||||
_clip(clip_id)
|
||||
db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id)
|
||||
engine.wake_clips.set()
|
||||
return clip_view(_clip(clip_id))
|
||||
|
||||
# Editor de cortes (/v1/clips/{id}/edit, proxy, waveform, export, preview-render, retranscribe, tts, suggest).
|
||||
editor_api.register(app, engine, clip_view, _clip)
|
||||
return app
|
||||
|
||||
|
||||
def build() -> FastAPI: # pragma: no cover - ponto de entrada do uvicorn (--factory)
|
||||
return create_app()
|
||||
@@ -0,0 +1,188 @@
|
||||
"""FFmpeg do Clipador: áudio dos blocos (volume por segundo + WAV para o Whisper), corte vertical e miniatura.
|
||||
Subprocesso sempre sem shell, argumentos em lista, com timeout; código != 0 é falha."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import io
|
||||
import math
|
||||
import subprocess
|
||||
import sys
|
||||
import wave
|
||||
from array import array
|
||||
from pathlib import Path
|
||||
|
||||
from . import layout
|
||||
|
||||
SAMPLE_RATE = 16_000
|
||||
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
|
||||
|
||||
|
||||
class MediaError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
def run(args: list[str], timeout: float, cwd: Path | None = None) -> bytes:
|
||||
try:
|
||||
result = subprocess.run(args, capture_output=True, timeout=timeout, cwd=cwd, creationflags=NO_WINDOW)
|
||||
except subprocess.TimeoutExpired as exc:
|
||||
raise MediaError(f"{Path(args[0]).name} passou de {timeout:.0f} s") from exc
|
||||
if result.returncode != 0:
|
||||
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-3:]
|
||||
raise MediaError(f"{Path(args[0]).name} saiu com código {result.returncode}: {' | '.join(tail)}")
|
||||
return result.stdout
|
||||
|
||||
|
||||
def decode_pcm(ffmpeg: str, files: list[Path]) -> bytes:
|
||||
"""Áudio mono 16 kHz s16le dos arquivos, em sequência."""
|
||||
out = bytearray()
|
||||
for file in files:
|
||||
out += run([ffmpeg, "-v", "error", "-i", str(file), "-vn", "-ac", "1", "-ar", str(SAMPLE_RATE), "-f", "s16le", "-"], 120)
|
||||
return bytes(out)
|
||||
|
||||
|
||||
def loudness_per_second(pcm: bytes) -> list[float | None]:
|
||||
"""RMS em dBFS por segundo (None = silêncio absoluto)."""
|
||||
samples = array("h")
|
||||
samples.frombytes(pcm[: len(pcm) - len(pcm) % 2])
|
||||
out: list[float | None] = []
|
||||
for i in range(0, len(samples), SAMPLE_RATE):
|
||||
chunk = samples[i: i + SAMPLE_RATE]
|
||||
if len(chunk) < SAMPLE_RATE // 4:
|
||||
break
|
||||
rms = math.sqrt(sum(s * s for s in chunk) / len(chunk))
|
||||
out.append(round(20 * math.log10(rms / 32768), 2) if rms > 0 else None)
|
||||
return out
|
||||
|
||||
|
||||
def to_wav(pcm: bytes) -> bytes:
|
||||
buffer = io.BytesIO()
|
||||
with wave.open(buffer, "wb") as wav:
|
||||
wav.setnchannels(1)
|
||||
wav.setsampwidth(2)
|
||||
wav.setframerate(SAMPLE_RATE)
|
||||
wav.writeframes(pcm)
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def pick_encoder(ffmpeg: str, wanted: str) -> list[str]:
|
||||
if wanted == "auto":
|
||||
try:
|
||||
encoders = run([ffmpeg, "-hide_banner", "-encoders"], 30).decode(errors="replace")
|
||||
except MediaError:
|
||||
encoders = ""
|
||||
wanted = "h264_nvenc" if "h264_nvenc" in encoders else "libx264"
|
||||
if wanted == "h264_nvenc":
|
||||
return ["-c:v", "h264_nvenc", "-preset", "p5", "-rc", "vbr", "-cq", "23", "-b:v", "0"]
|
||||
return ["-c:v", "libx264", "-preset", "veryfast", "-crf", "21"]
|
||||
|
||||
|
||||
def render_vertical(ffmpeg: str, encoder: list[str], segments: list[tuple[Path, float]], start_s: float, end_s: float,
|
||||
ass_text: str, out_file: Path, settings: dict | None = None) -> None:
|
||||
"""`segments` = blocos (arquivo, início na sessão) que cobrem [start_s, end_s], em ordem.
|
||||
`settings` = configuração do corte efetiva (layout.merge); define layout, câmera e legenda."""
|
||||
if not segments:
|
||||
raise MediaError("nenhum bloco gravado cobre o trecho")
|
||||
work = out_file.parent
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
stem = out_file.stem
|
||||
# O filtro `ass` recebe o nome relativo (cwd = pasta do corte): caminho absoluto do Windows ("C:\...")
|
||||
# exigiria escapar ":" e "\" dentro do filtergraph.
|
||||
ass_file = work / f"{stem}.ass"
|
||||
ass_file.write_text(ass_text, encoding="utf-8")
|
||||
concat = work / f"{stem}.concat.txt"
|
||||
concat.write_text("".join(f"file '{p.as_posix()}'\n" for p, _ in segments), encoding="utf-8")
|
||||
offset = start_s - segments[0][1]
|
||||
tmp = work / f"{stem}.tmp.mp4"
|
||||
try:
|
||||
run(
|
||||
# -ss ANTES do -i: os quadros entram no filtro já com tempo 0 = início do corte. Depois do -i o
|
||||
# filtro `ass` veria o tempo do bloco e a legenda sairia deslocada (medido: sumia do vídeo).
|
||||
[ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, offset):.3f}", "-f", "concat", "-safe", "0",
|
||||
"-i", concat.name, "-t", f"{end_s - start_s:.3f}",
|
||||
"-filter_complex", layout.video_filter(settings or layout.merge(), ass_file.name, ass_text),
|
||||
"-map", "[v]", "-map", "0:a:0?",
|
||||
*encoder, "-c:a", "aac", "-b:a", "160k", "-ar", "48000", "-movflags", "+faststart", tmp.name],
|
||||
timeout=600, cwd=work,
|
||||
)
|
||||
tmp.replace(out_file)
|
||||
finally:
|
||||
concat.unlink(missing_ok=True)
|
||||
ass_file.unlink(missing_ok=True)
|
||||
tmp.unlink(missing_ok=True)
|
||||
|
||||
|
||||
def segment_at(segments: list[tuple[Path, float, float]], t: float) -> tuple[Path, float] | None:
|
||||
"""Bloco (arquivo, deslocamento dentro dele) que contém o instante `t` da sessão."""
|
||||
for file, start, end in segments:
|
||||
if start <= t < end:
|
||||
return file, t - start
|
||||
if segments and t >= segments[-1][2]:
|
||||
file, start, end = segments[-1]
|
||||
return file, max(0.0, end - start - 0.5)
|
||||
return None
|
||||
|
||||
|
||||
# Busca num bloco .ts: o demuxer mpegts do FFmpeg trata todo pacote como ponto de busca, então `-ss` antes do `-i`
|
||||
# cai num quadro P perto do alvo. Medido (17/11/2026): no H.264 sai o PRÓXIMO quadro-chave (até 2 s depois do
|
||||
# pedido); no HEVC (2K da Twitch) sai um quadro CINZA (referências faltando) — frames do juiz, capa e YuNet
|
||||
# estragados. Um 2º `-ss` depois do `-i` também erra quando o bloco tem áudio (a base de tempo vem do áudio; 7,5 s
|
||||
# virou 6,06 s). Agora: busca rápida `SEEK_PREROLL_S` antes, tempo absoluto do bloco (`-copyts -start_at_zero`) e
|
||||
# o 1º quadro com t ≥ alvo (`select`). GOP da Twitch = 2 s; o YouTube recomenda ≤ 4 s. O concat (render, proxy)
|
||||
# não tem esse problema: não passa por aqui.
|
||||
SEEK_PREROLL_S = 4.0
|
||||
|
||||
|
||||
def seek_args(offset: float) -> tuple[list[str], str]:
|
||||
"""(argumentos antes do `-i`, filtro `select` do quadro exato) para o instante `offset` s de um bloco .ts."""
|
||||
offset = max(0.0, offset)
|
||||
return (["-ss", f"{max(0.0, offset - SEEK_PREROLL_S):.3f}", "-copyts", "-start_at_zero"],
|
||||
f"select='gte(t,{offset:.3f})'")
|
||||
|
||||
|
||||
def grab_frame(ffmpeg: str, segments: list[tuple[Path, float, float]], t: float, out_file: Path, width: int = 768) -> Path:
|
||||
"""Um quadro do instante `t` (sessão) em JPG. Para a IA olhar a tela e para o editor de layout."""
|
||||
found = segment_at(segments, t)
|
||||
if not found:
|
||||
raise MediaError(f"nenhum bloco gravado em {t:.0f}s")
|
||||
file, offset = found
|
||||
out_file.parent.mkdir(parents=True, exist_ok=True)
|
||||
before, select = seek_args(offset)
|
||||
vf = select + (f",scale={width}:-2" if width else "")
|
||||
run([ffmpeg, "-y", "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-vf", vf, "-frames:v", "1",
|
||||
"-q:v", "4", str(out_file)], 60)
|
||||
return out_file
|
||||
|
||||
|
||||
def preview_still(ffmpeg: str, frame_file: Path, settings: dict, ass_text: str, out_file: Path, reframe=None) -> Path:
|
||||
"""Prévia do layout num quadro só (imagem no formato do corte com câmera, jogo, legenda e crédito de exemplo).
|
||||
`reframe` = reenquadramento parado do jogo (capa de um corte com keyframes; ver `reframe.static_reframe`)."""
|
||||
work = out_file.parent
|
||||
ass_file = work / f"{out_file.stem}.ass"
|
||||
ass_file.write_text(ass_text, encoding="utf-8")
|
||||
try:
|
||||
run([ffmpeg, "-y", "-v", "error", "-loop", "1", "-t", "1", "-i", frame_file.name,
|
||||
"-filter_complex", layout.video_filter(settings, ass_file.name, ass_text, reframe), "-map", "[v]",
|
||||
"-frames:v", "1", "-q:v", "3", out_file.name], 60, cwd=work)
|
||||
finally:
|
||||
ass_file.unlink(missing_ok=True)
|
||||
return out_file
|
||||
|
||||
|
||||
def thumbnail(ffmpeg: str, video: Path, at_s: float, out_file: Path) -> None:
|
||||
run([ffmpeg, "-y", "-v", "error", "-ss", f"{max(0.0, at_s):.2f}", "-i", str(video), "-frames:v", "1",
|
||||
"-vf", "scale=360:-2", "-q:v", "4", str(out_file)], 60)
|
||||
|
||||
|
||||
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
|
||||
"""(largura, altura) do vídeo; 1280×720 se não der para ler (as camadas inseridas usam a proporção)."""
|
||||
try:
|
||||
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
|
||||
"-of", "csv=p=0", str(file)], 30).decode().strip().split(",")
|
||||
return int(out[0]), int(out[1])
|
||||
except (MediaError, ValueError, IndexError):
|
||||
return 1280, 720
|
||||
|
||||
|
||||
def probe_duration(ffprobe: str, file: Path) -> float:
|
||||
out = run([ffprobe, "-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", str(file)], 30)
|
||||
return float(out.decode().strip() or 0)
|
||||
@@ -0,0 +1,514 @@
|
||||
"""Rastreio de reação do streamer: lógica pura (sem E/S, sem numpy/opencv/mediapipe).
|
||||
|
||||
Recebe o que o detector/rastreador já mediu (rosto por quadro com os blendshapes do MediaPipe, ou caixas de
|
||||
rosto do YuNet) e transforma em:
|
||||
|
||||
- uma série por segundo (`FaceSecond`) compacta, para gravar no banco e para o editor reenquadrar a câmera;
|
||||
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela
|
||||
recente, só com segundos em que o rosto aparece). Tem streamer que fica sorrindo o tempo todo, tem quem fale
|
||||
de boca aberta: o que importa é o desvio do normal DELE, não o valor absoluto do blendshape;
|
||||
- picos rotulados (risada, grito, susto, choque, confuso, raiva) com o início da reação, e um texto curto para o juiz;
|
||||
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados.
|
||||
|
||||
Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import bisect
|
||||
import math
|
||||
import statistics
|
||||
from dataclasses import dataclass, field, replace
|
||||
|
||||
# Canais com z (o piscar fica de fora: é ruído, não reação). `brow` = sobrancelha levantada (interna ou externa:
|
||||
# na live real as duas sobem juntas); `surprise` = olho arregalado. `motion` só ajuda a ROTULAR (susto): fica fora da
|
||||
# intensidade — na live real os maiores "picos" de movimento eram o rastreio perdendo o rosto, não reação.
|
||||
SIGNAL_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow", "motion")
|
||||
EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow")
|
||||
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s)
|
||||
SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ReactionParams:
|
||||
# --- série por segundo / sinal ---
|
||||
min_present: float = 0.3 # fração mínima de quadros com rosto para o segundo contar
|
||||
motion_min_present: float = 0.8 # movimento só vale com o rosto em ≥ 80 % do segundo (senão é o rastreio pulando)
|
||||
baseline_s: int = 180 # janela do "neutro recente" do streamer
|
||||
exclude_recent_s: int = 10 # os últimos segundos ficam fora do neutro (a própria reação não se anula)
|
||||
min_baseline_n: int = 30 # menos segundos com rosto que isso na janela → usa todos os segundos com rosto da série
|
||||
mad_floor: float = 0.05 # piso do desvio robusto de um canal sem piso próprio em `mad_floors`
|
||||
# Pisos por canal, calibrados na live real (doc/FACE_BAKEOFF.md, sessão 3): no calmo o sorriso por segundo
|
||||
# tem mediana ~0,10 e picos soltos de 0,38 (fala/tique) → piso 0,10; browInnerUp tem pico solto de 0,38 num
|
||||
# segundo calmo contra 0,7–0,8 sustentado no lag → piso 0,10 e peso menor; browDown no calmo fica ≤ 0,07.
|
||||
# `motion` em "tamanhos de rosto" por segundo.
|
||||
mad_floors: dict[str, float] = field(default_factory=lambda: {
|
||||
"smile": 0.10, "jaw": 0.05, "surprise": 0.06, "frown": 0.07, "brow": 0.10, "motion": 0.15,
|
||||
})
|
||||
weights: dict[str, float] = field(default_factory=lambda: {
|
||||
"smile": 1.0, "jaw": 1.0, "surprise": 1.0, "frown": 0.8, "brow": 0.6, "motion": 0.7,
|
||||
})
|
||||
# --- picos ---
|
||||
threshold: float = 3.0 # z mínimo do sinal para virar pico (igual ao `face_threshold` do plano)
|
||||
strong_z: float = 6.0 # a partir daqui o texto diz "forte"
|
||||
onset_z: float = 1.0 # o início/fim da reação é onde o sinal cai abaixo disto
|
||||
max_onset_s: int = 10
|
||||
min_gap_s: float = 4.0 # distância mínima entre dois picos
|
||||
keep_neutral: bool = False # pico só de movimento (pegar a água, ajeitar a cadeira) vira "neutro" e sai
|
||||
# --- rótulo ---
|
||||
label_z: float = 2.0 # canal "ligado" no pico quando o z dele passa disto
|
||||
smile_raw: float = 0.5 # sorriso alto em valor absoluto também conta (neutro sorridente saturado)
|
||||
shout_jaw_raw: float = 0.2 # sobrancelha franzida COM boca aberta pelo menos isso = grito (senão, raiva)
|
||||
raw_thresholds: dict[str, float] = field(default_factory=lambda: {
|
||||
"smile": 0.4, "jaw": 0.35, "surprise": 0.35, "frown": 0.35, "brow": 0.35, "motion": 0.5,
|
||||
}) # usados pelo `label` quando não há z (segundo isolado)
|
||||
# --- câmera (locate_cam) ---
|
||||
min_score: float = 0.6 # confiança mínima da detecção
|
||||
# Confiança MÉDIA mínima do grupo que vira câmera. Teste ao vivo de 17/11: webcam real (skipnho) 0,92–0,94 em
|
||||
# todo quadro; na lofigirl (sem webcam) a tela de um notebook desenhado, parada na borda, deu 0,61–0,66 em 8 de 12
|
||||
# quadros e virou "câmera" de 24×34 px com o layout aplicado.
|
||||
min_cam_score: float = 0.7
|
||||
# Agrupa pelo CENTRO do grupo (média corrente) com tolerância em tamanhos de rosto: comparar com o 1º membro
|
||||
# partiu o streamer em dois quando ele se inclinou (0,8 largura de rosto na bancada).
|
||||
cluster_faces: float = 1.0 # distância máxima ao centro do grupo, em larguras (x) e alturas (y) de rosto
|
||||
min_presence: float = 0.5 # grupo precisa aparecer em ≥ 50 % dos quadros
|
||||
stable_faces: float = 0.6 # desvio-padrão máximo do centro do grupo, em tamanhos de rosto (bancada: 0,24)
|
||||
full_frame_h: float = 0.4 # rosto mais alto que isso = câmera em tela cheia
|
||||
expand_w: float = 3.2 # retângulo estimado = rosto × 3,2 na largura
|
||||
expand_h: float = 3.6 # e × 3,6 na altura
|
||||
shift_down: float = 0.45 # deslocado para baixo em "alturas de rosto" (ombros/peito aparecem na câmera)
|
||||
edge_reach: float = 1.5 # borda da moldura vale se estiver até X larguras de rosto do lado estimado
|
||||
headroom: float = 0.35 # a borda de cima nunca encosta no rosto: fica ≥ X alturas de rosto acima (testa/cabelo)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class FaceSample:
|
||||
"""Um quadro do rastreador. `cx`/`cy`/`size` normalizados (0..1) no recorte da câmera; `size` = altura do rosto."""
|
||||
|
||||
t: float
|
||||
present: bool
|
||||
cx: float = 0.0
|
||||
cy: float = 0.0
|
||||
size: float = 0.0
|
||||
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
|
||||
|
||||
|
||||
@dataclass
|
||||
class FaceSecond:
|
||||
"""Resumo de um segundo. Canais `None` quando o rosto não apareceu nesse segundo."""
|
||||
|
||||
t: int
|
||||
present: float = 0.0 # fração dos quadros com rosto
|
||||
cx: float | None = None
|
||||
cy: float | None = None
|
||||
size: float | None = None
|
||||
smile: float | None = None
|
||||
jaw: float | None = None
|
||||
surprise: float | None = None
|
||||
frown: float | None = None
|
||||
brow: float | None = None
|
||||
blink: float | None = None
|
||||
motion: float | None = None
|
||||
|
||||
def to_json(self) -> dict:
|
||||
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`."""
|
||||
out: dict = {"t": self.t, "present": round(self.present, 3)}
|
||||
for name in SECOND_FIELDS:
|
||||
value = getattr(self, name)
|
||||
if value is not None:
|
||||
out[name] = round(value, 3)
|
||||
return out
|
||||
|
||||
@classmethod
|
||||
def from_json(cls, data: dict) -> FaceSecond:
|
||||
return cls(int(data["t"]), float(data.get("present", 0.0)),
|
||||
**{n: (float(data[n]) if data.get(n) is not None else None) for n in SECOND_FIELDS})
|
||||
|
||||
|
||||
@dataclass
|
||||
class ReactionMoment:
|
||||
peak_s: int
|
||||
onset_s: int # onde a reação começou (o que causou está logo antes)
|
||||
end_s: int
|
||||
intensity: float # z do sinal no pico
|
||||
label: str
|
||||
strong: bool
|
||||
|
||||
def to_json(self) -> dict:
|
||||
return {"peakS": self.peak_s, "onsetS": self.onset_s, "endS": self.end_s,
|
||||
"intensity": round(self.intensity, 2), "label": self.label, "strong": self.strong}
|
||||
|
||||
|
||||
def seconds_to_json(seconds: list[FaceSecond]) -> list[dict]:
|
||||
return [s.to_json() for s in seconds]
|
||||
|
||||
|
||||
def seconds_from_json(data: list[dict]) -> list[FaceSecond]:
|
||||
return [FaceSecond.from_json(d) for d in data]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Série por segundo
|
||||
|
||||
|
||||
def _mean(values: list[float]) -> float:
|
||||
return sum(values) / len(values)
|
||||
|
||||
|
||||
def _channels(blend: dict[str, float]) -> dict[str, float]:
|
||||
"""Blendshapes do MediaPipe → canais de expressão (0..1).
|
||||
|
||||
Na live real (bancada) `eyeWide*` fica ~0 o tempo todo e `jawOpen` quase nunca passa de 0,1: a surpresa não
|
||||
pode depender do olho arregalado: a sobrancelha levantada (`brow`, o maior entre a interna e a externa — na live
|
||||
inteira as duas sobem juntas) é canal próprio e, com movimento da cabeça, já é susto. Marcou o lag: 0,27 de
|
||||
média contra 0,02 no calmo.
|
||||
"""
|
||||
def g(name: str) -> float:
|
||||
return float(blend.get(name, 0.0))
|
||||
|
||||
outer_up = (g("browOuterUpLeft") + g("browOuterUpRight")) / 2
|
||||
return {
|
||||
"smile": (g("mouthSmileLeft") + g("mouthSmileRight")) / 2,
|
||||
"jaw": g("jawOpen"),
|
||||
"surprise": (g("eyeWideLeft") + g("eyeWideRight")) / 2,
|
||||
"frown": (g("browDownLeft") + g("browDownRight")) / 2,
|
||||
"brow": max(g("browInnerUp"), outer_up),
|
||||
"blink": (g("eyeBlinkLeft") + g("eyeBlinkRight")) / 2,
|
||||
}
|
||||
|
||||
|
||||
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> list[FaceSecond]:
|
||||
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s).
|
||||
|
||||
Posição/tamanho/piscar = média; expressões = máximo do segundo (a reação dura menos que 1 s às vezes);
|
||||
`motion` = caminho percorrido pelo centro (mais a variação de tamanho, quem se joga para a câmera) dividido
|
||||
pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
|
||||
"""
|
||||
n = max(0, int(math.ceil(duration_s)))
|
||||
first = int(math.floor(start_s))
|
||||
buckets: list[list[FaceSample]] = [[] for _ in range(n)]
|
||||
for sample in samples:
|
||||
i = int(math.floor(sample.t)) - first
|
||||
if 0 <= i < n:
|
||||
buckets[i].append(sample)
|
||||
out: list[FaceSecond] = []
|
||||
previous: FaceSample | None = None # última amostra com rosto (para o movimento atravessar a virada do segundo)
|
||||
for i, bucket in enumerate(buckets):
|
||||
bucket.sort(key=lambda s: s.t)
|
||||
second = FaceSecond(first + i, present=(sum(1 for s in bucket if s.present) / len(bucket)) if bucket else 0.0)
|
||||
faces = [s for s in bucket if s.present and s.size > 0]
|
||||
if faces:
|
||||
channels = [_channels(s.blend) for s in faces]
|
||||
second.cx = _mean([s.cx for s in faces])
|
||||
second.cy = _mean([s.cy for s in faces])
|
||||
second.size = _mean([s.size for s in faces])
|
||||
for name in ("smile", "jaw", "surprise", "frown", "brow"):
|
||||
setattr(second, name, max(c[name] for c in channels))
|
||||
second.blink = _mean([c["blink"] for c in channels])
|
||||
path = 0.0
|
||||
for s in faces:
|
||||
if previous is not None and s.t - previous.t <= 1.0:
|
||||
scale = max(1e-6, (s.size + previous.size) / 2)
|
||||
path += (math.hypot(s.cx - previous.cx, s.cy - previous.cy) + abs(s.size - previous.size)) / scale
|
||||
previous = s
|
||||
second.motion = path
|
||||
out.append(second)
|
||||
return out
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Sinal relativo ao neutro do streamer
|
||||
|
||||
|
||||
def _has_face(second: FaceSecond, p: ReactionParams) -> bool:
|
||||
return second.present >= p.min_present and second.smile is not None
|
||||
|
||||
|
||||
def _robust(values: list[float], floor: float) -> tuple[float, float]:
|
||||
"""Mediana e desvio robusto (1,4826 × MAD, com piso)."""
|
||||
median = statistics.median(values)
|
||||
mad = statistics.median([abs(v - median) for v in values])
|
||||
return median, max(floor, 1.4826 * mad)
|
||||
|
||||
|
||||
def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[dict[str, float] | None]:
|
||||
"""z robusto de cada canal por segundo contra o neutro recente do próprio streamer; `None` sem rosto."""
|
||||
p = params or ReactionParams()
|
||||
face_idx = [i for i, s in enumerate(seconds) if _has_face(s, p)]
|
||||
# Série antiga (sem o canal) → 0: o canal fica parado em vez de quebrar.
|
||||
values = {name: [getattr(seconds[i], name) or 0.0 for i in face_idx] for name in SIGNAL_CHANNELS}
|
||||
floors = {name: p.mad_floors.get(name, p.mad_floor) for name in SIGNAL_CHANNELS}
|
||||
# O neutro anda devagar: recalcula a cada `BASELINE_STEP_S` (com cache pelos limites da janela), e a janela sai
|
||||
# por bisect em `face_idx` — antes era O(n²) e uma live de horas levava segundos por chamada.
|
||||
cache: dict[tuple[int, int], dict[str, tuple[float, float]]] = {}
|
||||
out: list[dict[str, float] | None] = []
|
||||
for t, second in enumerate(seconds):
|
||||
if not _has_face(second, p):
|
||||
out.append(None)
|
||||
continue
|
||||
anchor = t - t % BASELINE_STEP_S
|
||||
lo = bisect.bisect_left(face_idx, anchor - p.baseline_s)
|
||||
hi = bisect.bisect_left(face_idx, anchor - p.exclude_recent_s)
|
||||
if hi - lo < p.min_baseline_n:
|
||||
# Começo da gravação: ainda não há neutro suficiente; usa a série inteira (a mediana aguenta os picos).
|
||||
lo, hi = 0, len(face_idx)
|
||||
base = cache.get((lo, hi))
|
||||
if base is None:
|
||||
base = cache[(lo, hi)] = {name: _robust(values[name][lo:hi], floors[name]) for name in SIGNAL_CHANNELS}
|
||||
z: dict[str, float] = {}
|
||||
for name in SIGNAL_CHANNELS:
|
||||
median, spread = base[name]
|
||||
z[name] = ((getattr(second, name) or 0.0) - median) / spread
|
||||
if second.present < p.motion_min_present:
|
||||
z["motion"] = 0.0
|
||||
out.append(z)
|
||||
return out
|
||||
|
||||
|
||||
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
|
||||
if z is None:
|
||||
return None
|
||||
return max(0.0, max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS))
|
||||
|
||||
|
||||
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
|
||||
params: ReactionParams | None = None) -> list[float | None]:
|
||||
"""Intensidade de reação por segundo (máximo ponderado dos z das expressões, ≥ 0); `None` sem rosto."""
|
||||
p = params or ReactionParams()
|
||||
if baseline_s is not None:
|
||||
p = replace(p, baseline_s=baseline_s)
|
||||
return [_signal_from_z(z, p) for z in channel_z(seconds, p)]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Rótulo
|
||||
|
||||
|
||||
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
|
||||
"""Rótulo da expressão: risada, grito, susto, choque, confuso, raiva ou neutro.
|
||||
|
||||
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
|
||||
absolutos (`raw_thresholds`).
|
||||
|
||||
Regras (calibradas na live real, doc/FACE_BAKEOFF.md):
|
||||
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada,
|
||||
jawOpen ≤ 0,1); sorriso alto em valor absoluto também conta quando outro canal de rosto sobe junto (no
|
||||
streamer que já sorri o tempo todo o sorriso não tem para onde subir);
|
||||
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real:
|
||||
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**;
|
||||
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
|
||||
- **choque** = olho arregalado parado;
|
||||
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
|
||||
contra 0,02 no calmo).
|
||||
"""
|
||||
p = params or ReactionParams()
|
||||
if second.smile is None:
|
||||
return "neutro"
|
||||
if z is not None:
|
||||
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS}
|
||||
else:
|
||||
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
|
||||
smiling_raw = second.smile >= p.smile_raw
|
||||
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
|
||||
return "risada"
|
||||
if (on["surprise"] or on["brow"]) and on["motion"]:
|
||||
return "susto"
|
||||
if on["jaw"]:
|
||||
return "grito"
|
||||
if on["frown"]:
|
||||
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva"
|
||||
if on["surprise"]:
|
||||
return "choque"
|
||||
if on["brow"]:
|
||||
return "confuso"
|
||||
return "neutro"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Picos e resumo para o juiz
|
||||
|
||||
|
||||
def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[ReactionMoment]:
|
||||
"""Picos do sinal (≥ `threshold`, do maior para o menor, a `min_gap_s` um do outro), em ordem de tempo.
|
||||
|
||||
A mesma reação num trecho contínuo acima de `onset_z` vira um pico só (risada de 5 s não conta duas vezes).
|
||||
|
||||
O rótulo vem do segundo do pico; se o pico for só movimento ("neutro"), olha os vizinhos (±1 s) — o grito pode
|
||||
ter o máximo de boca um segundo antes do pulo. Sem rótulo de expressão o pico sai (salvo `keep_neutral`).
|
||||
"""
|
||||
p = params or ReactionParams()
|
||||
zs = channel_z(seconds, p)
|
||||
signal = [_signal_from_z(z, p) for z in zs]
|
||||
values = [v if v is not None else -1.0 for v in signal]
|
||||
# Trecho contínuo acima de `onset_z` de cada segundo: uma risada de 5 s é UM pico, não dois.
|
||||
run = [0] * len(values)
|
||||
current = 0
|
||||
for i, v in enumerate(values):
|
||||
if v >= p.onset_z and i > 0 and values[i - 1] >= p.onset_z:
|
||||
run[i] = current
|
||||
else:
|
||||
current += 1
|
||||
run[i] = current
|
||||
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
|
||||
chosen: list[tuple[int, str]] = []
|
||||
for peak in candidates:
|
||||
name = _peak_label(seconds, zs, peak, p)
|
||||
if name == "neutro" and not p.keep_neutral:
|
||||
continue
|
||||
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento.
|
||||
if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
|
||||
continue
|
||||
chosen.append((peak, name))
|
||||
moments: list[ReactionMoment] = []
|
||||
for peak, name in sorted(chosen):
|
||||
begin = peak
|
||||
while begin > 0 and peak - begin < p.max_onset_s and values[begin - 1] >= p.onset_z:
|
||||
begin -= 1
|
||||
end = peak
|
||||
while end + 1 < len(values) and end - peak < p.max_onset_s and values[end + 1] >= p.onset_z:
|
||||
end += 1
|
||||
moments.append(ReactionMoment(seconds[peak].t, seconds[begin].t, seconds[end].t, values[peak], name,
|
||||
values[peak] >= p.strong_z))
|
||||
return moments
|
||||
|
||||
|
||||
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str:
|
||||
name = label(seconds[peak], zs[peak], p)
|
||||
if name == "neutro":
|
||||
for j in (peak - 1, peak + 1):
|
||||
if 0 <= j < len(seconds) and zs[j] is not None:
|
||||
other = label(seconds[j], zs[j], p)
|
||||
if other != "neutro":
|
||||
return other
|
||||
return name
|
||||
|
||||
|
||||
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
|
||||
params: ReactionParams | None = None, max_items: int = 4,
|
||||
moments: list[ReactionMoment] | None = None, relative: bool = True) -> str:
|
||||
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho.
|
||||
|
||||
Passe a série inteira (ou bem mais que o trecho): o neutro do streamer vem do que veio antes.
|
||||
Ex.: "risada forte em 12 s; susto em 15 s". `moments` (opcional): picos já calculados com `reaction_moments`
|
||||
sobre a série inteira — evita recalcular a live toda a cada corte (~1 s por hora de live).
|
||||
`relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
|
||||
"""
|
||||
p = params or ReactionParams()
|
||||
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s)
|
||||
inside = [s for s in seconds if start_s <= s.t <= end]
|
||||
with_face = [s for s in inside if _has_face(s, p)]
|
||||
if not with_face:
|
||||
return "rosto do streamer não aparece no trecho"
|
||||
parts = []
|
||||
for m in (moments if moments is not None else reaction_moments(seconds, p)):
|
||||
if start_s <= m.peak_s <= end:
|
||||
when = f"{int(round(m.peak_s - start_s))} s" if relative else f"{m.peak_s:.0f}s"
|
||||
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when}")
|
||||
presence = len(with_face) / len(inside)
|
||||
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
|
||||
if presence < 0.7:
|
||||
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
|
||||
return text
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------
|
||||
# Onde está a câmera
|
||||
|
||||
|
||||
def _rect(x: float, y: float, w: float, h: float) -> dict[str, float]:
|
||||
return {"x": round(x, 4), "y": round(y, 4), "w": round(w, 4), "h": round(h, 4)}
|
||||
|
||||
|
||||
def _clip_rect(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
|
||||
x0, y0 = min(1.0, max(0.0, x0)), min(1.0, max(0.0, y0))
|
||||
x1, y1 = min(1.0, max(0.0, x1)), min(1.0, max(0.0, y1))
|
||||
return x0, y0, max(x0, x1), max(y0, y1)
|
||||
|
||||
|
||||
def locate_cam(detections_per_frame: list[list[tuple[float, float, float, float, float]]], frame_w: float,
|
||||
frame_h: float, edges: dict[str, list[float]] | None = None,
|
||||
params: ReactionParams | None = None) -> dict:
|
||||
"""Acha a câmera do streamer a partir das detecções de rosto de alguns quadros espalhados da live.
|
||||
|
||||
`detections_per_frame`: um item por quadro (lista vazia = nenhum rosto), cada detecção `(x, y, w, h, score)`
|
||||
em pixels. `edges` (opcional): bordas persistentes da moldura da câmera, em fração do quadro —
|
||||
`{"xs": [linhas verticais], "ys": [linhas horizontais]}` (ex.: média do gradiente entre os quadros).
|
||||
|
||||
A câmera é o grupo de rostos que aparece na mesma posição em ≥ `min_presence` dos quadros; rosto de jogo,
|
||||
cutscene ou de outra pessoa passa por poucos quadros e é ignorado (na bancada, 6 rostos de uma tela de
|
||||
carregamento apareceram em 2 de 12 quadros, sempre no mesmo lugar: é a presença que separa, não a posição).
|
||||
Cada detecção entra no grupo cujo CENTRO (média corrente) esteja a até `cluster_faces` larguras/alturas de
|
||||
rosto dela — o streamer que se inclina continua no mesmo grupo.
|
||||
|
||||
Retângulo: rosto expandido (≈3,2× largura, 3,6× altura, deslocado para baixo), com folga acima da testa.
|
||||
Câmera sem moldura (streamer recortado sobre o jogo, o caso da bancada) só tem esse caminho; `edges` é opcional
|
||||
e só ajusta os lados quando há moldura de verdade. Devolve
|
||||
`{hasWebcam, cam: {x,y,w,h} | None, faceRect, confidence, fullFrame}` em frações 0..1.
|
||||
"""
|
||||
p = params or ReactionParams()
|
||||
total = len(detections_per_frame)
|
||||
empty = {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
|
||||
if total == 0 or frame_w <= 0 or frame_h <= 0:
|
||||
return empty
|
||||
# Grupos por posição: cada um guarda (quadro, cx, cy, w, h, score) normalizados.
|
||||
groups: list[list[tuple[int, float, float, float, float, float]]] = []
|
||||
for frame, detections in enumerate(detections_per_frame):
|
||||
for x, y, w, h, score in detections:
|
||||
if score < p.min_score or w <= 0 or h <= 0:
|
||||
continue
|
||||
nw, nh = w / frame_w, h / frame_h
|
||||
cx, cy = x / frame_w + nw / 2, y / frame_h + nh / 2
|
||||
best, best_d = None, math.inf
|
||||
for g in groups:
|
||||
gx, gy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
|
||||
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
|
||||
dx, dy = abs(cx - gx) / gw, abs(cy - gy) / gh
|
||||
if dx <= p.cluster_faces and dy <= p.cluster_faces and max(dx, dy) < best_d:
|
||||
best, best_d = g, max(dx, dy)
|
||||
if best is None:
|
||||
groups.append([(frame, cx, cy, nw, nh, score)])
|
||||
else:
|
||||
best.append((frame, cx, cy, nw, nh, score))
|
||||
candidates = []
|
||||
for g in groups:
|
||||
frames = len({d[0] for d in g})
|
||||
ratio = frames / total
|
||||
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
|
||||
# Estabilidade em tamanhos de rosto: independe do zoom da câmera e da resolução.
|
||||
spread = math.hypot(statistics.pstdev([d[1] for d in g]) / gw, statistics.pstdev([d[2] for d in g]) / gh)
|
||||
if ratio >= p.min_presence and spread <= p.stable_faces and _mean([d[5] for d in g]) >= p.min_cam_score:
|
||||
candidates.append((ratio, _mean([d[5] for d in g]), spread, g))
|
||||
if not candidates:
|
||||
return empty
|
||||
ratio, score, spread, g = max(candidates, key=lambda c: (c[0], c[1]))
|
||||
fw, fh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
|
||||
fcx, fcy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
|
||||
face_rect = _rect(*_xywh(*_clip_rect(fcx - fw / 2, fcy - fh / 2, fcx + fw / 2, fcy + fh / 2)))
|
||||
confidence = round(min(1.0, ratio * score * (1.0 - 0.5 * spread / p.stable_faces)), 3)
|
||||
if fh > p.full_frame_h:
|
||||
return {"hasWebcam": True, "cam": _rect(0, 0, 1, 1), "faceRect": face_rect,
|
||||
"confidence": confidence, "fullFrame": True}
|
||||
# Estimativa pelo rosto: 3,2× a largura, 3,6× a altura, deslocado para baixo (ombros aparecem na câmera).
|
||||
cw, ch = fw * p.expand_w, fh * p.expand_h
|
||||
ccy = fcy + p.shift_down * fh
|
||||
x0, x1 = fcx - cw / 2, fcx + cw / 2
|
||||
y0, y1 = ccy - ch / 2, ccy + ch / 2
|
||||
if edges:
|
||||
reach_x, reach_y = p.edge_reach * fw, p.edge_reach * fh
|
||||
x0 = _snap(x0, edges.get("xs", []), outside_of=fcx - fw / 2, reach=reach_x, side=-1)
|
||||
x1 = _snap(x1, edges.get("xs", []), outside_of=fcx + fw / 2, reach=reach_x, side=1)
|
||||
# Em cima, a borda só vale acima da folga da testa: moldura falsa (ex.: um banner) não corta a cabeça.
|
||||
y0 = _snap(y0, edges.get("ys", []), outside_of=fcy - fh / 2 - p.headroom * fh, reach=reach_y, side=-1)
|
||||
y1 = _snap(y1, edges.get("ys", []), outside_of=fcy + fh / 2, reach=reach_y, side=1)
|
||||
cam = _rect(*_xywh(*_clip_rect(x0, y0, x1, y1)))
|
||||
return {"hasWebcam": True, "cam": cam, "faceRect": face_rect, "confidence": confidence, "fullFrame": False}
|
||||
|
||||
|
||||
def _xywh(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
|
||||
return x0, y0, x1 - x0, y1 - y0
|
||||
|
||||
|
||||
def _snap(estimate: float, lines: list[float], outside_of: float, reach: float, side: int) -> float:
|
||||
"""Troca o lado estimado pela borda da moldura mais próxima dele, se houver uma além do rosto e a até `reach`."""
|
||||
valid = [v for v in lines if (v <= outside_of if side < 0 else v >= outside_of) and abs(v - estimate) <= reach]
|
||||
return min(valid, key=lambda v: abs(v - estimate)) if valid else estimate
|
||||
@@ -0,0 +1,283 @@
|
||||
"""Reenquadramento do jogo no tempo (câmera virtual com keyframes) e camadas inseridas (recorte da tela em destaque).
|
||||
|
||||
Pedido do dono (17/11/2026, corte 61 em câmera-em-cima): "na hora que ele abre o inventário preciso pegar um ângulo
|
||||
melhor; se quero mostrar alguma coisa no canto da tela, criar camadas para isso".
|
||||
|
||||
**Reenquadramento** (`project.reframe.keys`): janela (centro `cx`, `cy` e largura `w`, frações do quadro ORIGINAL)
|
||||
que vira a área do jogo do layout daquele instante. A altura sai da proporção da área de destino (parte de baixo no
|
||||
`cam_top`; a tela toda nos outros), então nunca distorce. Enquanto houver keys, `layout.game` é ignorado (os keys são
|
||||
absolutos no quadro original). Não vale para `cam_only`. Interpolação entre keys pelo `ease` do key de saída:
|
||||
`smooth` (suave), `linear` ou `hold` (segura e salta no key seguinte). Antes do 1º e depois do último, segura.
|
||||
|
||||
No FFmpeg: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro `in`) viram o quadro
|
||||
inteiro com interpolação SUBPIXEL, depois `scale` para a área de destino. Medido (protótipo, zoom de 1,0 → 0,4 em 4 s
|
||||
num 1280×720): nenhum passo para trás entre quadros, desvio da aceleração 0,12 px (sem tremida), 0,38 s de render.
|
||||
`scale` com `eval=frame` + `crop` de tamanho fixo, a alternativa, falhou no encoder (tamanho variável) e arredonda o
|
||||
deslocamento a pixels inteiros.
|
||||
|
||||
**Camadas inseridas** (`overlays[]` com `kind: "inset"`): recorte `src` do quadro original, posto em `x`/`y` (centro) com
|
||||
largura `size` da tela; borda, cantos arredondados, sombra e animação. Vêm do vídeo original (antes do layout), ficam
|
||||
acima do vídeo/zoom e abaixo da legenda, gancho, textos e chat (o ASS vem depois). Ordem no array = empilhamento.
|
||||
No FFmpeg: `crop` → `scale` (tamanho-base fixo) → `alphamerge` com a máscara dos cantos → por cima de UMA imagem
|
||||
de decoração (sombra borrada + borda, gerada aqui com numpy/OpenCV) → `scale` por quadro só se o tamanho muda
|
||||
(keys, pop) → `fade` de alfa → um `overlay` sobre o vídeo (expressão por quadro só se a posição muda: keys,
|
||||
slide). Medido no corte 61 (60 s, NVENC): sem nada 6,1–6,2 s; com reenquadramento 7,1–9,5 s; com
|
||||
reenquadramento + 2 camadas (pop e slide) 15,8–20,5 s (com sombra, borda e recorte postos separados: 28,2 s).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
FPS = 30
|
||||
EASES = ("smooth", "linear", "hold")
|
||||
INSET_ANIMS = ("pop", "fade", "slide", "none")
|
||||
MAX_KEYS = 60
|
||||
MAX_INSETS = 12
|
||||
ANIM_S = 0.18 # entrada/saída de alfa das camadas
|
||||
SLIDE_S = 0.35
|
||||
SHADOW_ALPHA = 0.55
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- interpolação (Python e expressão do FFmpeg)
|
||||
def _smooth(u: float) -> float:
|
||||
return u * u * (3 - 2 * u)
|
||||
|
||||
|
||||
def interp(keys: list[dict], t: float, field: str) -> float:
|
||||
"""Valor de `field` no instante `t` (mesmo resultado da expressão do FFmpeg)."""
|
||||
if t <= keys[0]["t"]:
|
||||
return float(keys[0][field])
|
||||
for a, b in zip(keys, keys[1:]):
|
||||
if t < b["t"]:
|
||||
ease = a.get("ease", "smooth")
|
||||
if ease == "hold":
|
||||
return float(a[field])
|
||||
u = (t - a["t"]) / max(1e-3, b["t"] - a["t"])
|
||||
u = _smooth(u) if ease == "smooth" else u
|
||||
return float(a[field]) + (float(b[field]) - float(a[field])) * u
|
||||
return float(keys[-1][field])
|
||||
|
||||
|
||||
def piecewise(keys: list[dict], field: str, var: str) -> str:
|
||||
"""Expressão do FFmpeg equivalente a `interp` (variável de tempo `var`, já entre parênteses)."""
|
||||
expr = f"{float(keys[-1][field]):.5f}"
|
||||
for a, b in reversed(list(zip(keys, keys[1:]))):
|
||||
va, vb = float(a[field]), float(b[field])
|
||||
ease = a.get("ease", "smooth")
|
||||
if ease == "hold" or abs(vb - va) < 1e-9:
|
||||
seg = f"{va:.5f}"
|
||||
else:
|
||||
u = f"clip(({var}-{a['t']:.4f})/{max(1e-3, b['t'] - a['t']):.4f},0,1)"
|
||||
u = f"({u}*{u}*(3-2*{u}))" if ease == "smooth" else u
|
||||
seg = f"({va:.5f}+{vb - va:.5f}*{u})"
|
||||
expr = f"if(lt({var},{b['t']:.4f}),{seg},{expr})"
|
||||
return expr
|
||||
|
||||
|
||||
def keys_for_range(keys: list[dict], a: float, b: float) -> list[dict]:
|
||||
"""Só os keys que influenciam [a, b] (o último antes de `a`, os de dentro e o primeiro depois de `b`)."""
|
||||
if not keys:
|
||||
return []
|
||||
first = max([i for i, k in enumerate(keys) if k["t"] <= a], default=0)
|
||||
last = min([i for i, k in enumerate(keys) if k["t"] >= b], default=len(keys) - 1)
|
||||
return keys[first: last + 1]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- reenquadramento
|
||||
def window(keys: list[dict], t: float, src_w: float, src_h: float, dest_aspect: float) -> tuple[float, float, float, float]:
|
||||
"""(x, y, largura, altura) em px do quadro original no instante `t` (presa dentro do quadro, sem deformar)."""
|
||||
ww = min(src_w * interp(keys, t, "w"), src_h * dest_aspect)
|
||||
wh = ww / dest_aspect
|
||||
x = min(max(src_w * interp(keys, t, "cx") - ww / 2, 0.0), src_w - ww)
|
||||
y = min(max(src_h * interp(keys, t, "cy") - wh / 2, 0.0), src_h - wh)
|
||||
return x, y, ww, wh
|
||||
|
||||
|
||||
def perspective_filter(keys: list[dict], piece_start: float, piece_end: float, dest_aspect: float) -> str:
|
||||
"""`perspective` cujos 4 cantos são a janela no tempo da SESSÃO (o trecho começa em `piece_start`; o filtro conta
|
||||
os quadros do trecho em `in`, que começa em 1, a 30 qps). Saída do tamanho da entrada; o layout escala para a área de destino."""
|
||||
ks = keys_for_range(keys, piece_start, piece_end)
|
||||
# `in` do perspective começa em 1 no 1º quadro (medido: com in/30 a janela ia 1 quadro adiantada).
|
||||
var = f"({piece_start:.4f}+(in-1)/{FPS})"
|
||||
a = f"{dest_aspect:.6f}"
|
||||
ww = f"st(1,min(W*({piecewise(ks, 'w', var)}),H*{a}))"
|
||||
left = f"{ww};st(2,clip(W*({piecewise(ks, 'cx', var)})-ld(1)/2,0,W-ld(1)))"
|
||||
top = f"{ww};st(3,ld(1)/{a});st(4,clip(H*({piecewise(ks, 'cy', var)})-ld(3)/2,0,H-ld(3)))"
|
||||
x_l, x_r = f"{left};ld(2)", f"{left};ld(2)+ld(1)"
|
||||
y_t, y_b = f"{top};ld(4)", f"{top};ld(4)+ld(3)"
|
||||
return (f"perspective=x0='{x_l}':y0='{y_t}':x1='{x_r}':y1='{y_t}':x2='{x_l}':y2='{y_b}':x3='{x_r}':y3='{y_b}'"
|
||||
f":interpolation=linear:sense=source:eval=frame")
|
||||
|
||||
|
||||
def piece_reframe(project: dict, piece_start: float, piece_end: float):
|
||||
"""Função (proporção de destino → filtro) para `layout.layout_chain`, ou None sem reenquadramento."""
|
||||
keys = (project.get("reframe") or {}).get("keys") or []
|
||||
if not keys:
|
||||
return None
|
||||
return lambda dest_aspect: perspective_filter(keys, piece_start, piece_end, dest_aspect)
|
||||
|
||||
|
||||
def static_reframe(project: dict, t: float):
|
||||
"""Reenquadramento parado no instante `t` (capa): mesma janela, sem animação."""
|
||||
keys = (project.get("reframe") or {}).get("keys") or []
|
||||
if not keys:
|
||||
return None
|
||||
frozen = [{"t": 0.0, "cx": interp(keys, t, "cx"), "cy": interp(keys, t, "cy"), "w": interp(keys, t, "w"), "ease": "hold"}]
|
||||
return lambda dest_aspect: perspective_filter(frozen, 0.0, 1.0, dest_aspect)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- camadas inseridas
|
||||
@dataclass
|
||||
class InsetPlan:
|
||||
"""Uma camada pronta para o grafo. A camada vira UMA imagem composta (sombra + borda + recorte) de tamanho
|
||||
`decor_w`×`decor_h`, com o recorte em (`ox`, `oy`); só ela é posta sobre o vídeo (um overlay grande por camada).
|
||||
Medido no corte 61 (60 s): com sombra, borda e recorte postos separados no quadro inteiro, 2 camadas levavam o
|
||||
render de 7,1 s para 28,2 s."""
|
||||
inset: dict
|
||||
a: float # entrada (tempo de saída)
|
||||
b: float # saída
|
||||
base_w: int # recorte em px do vídeo (no maior tamanho dos keys)
|
||||
base_h: int
|
||||
ox: int # posição do recorte dentro da imagem composta
|
||||
oy: int
|
||||
decor_w: int
|
||||
decor_h: int
|
||||
mask_file: Path
|
||||
decor_file: Path | None # sombra + borda (None = sem nenhuma das duas)
|
||||
keys: list[dict] # keys em tempo de SAÍDA (x, y, size, ease)
|
||||
|
||||
@property
|
||||
def dynamic_size(self) -> bool:
|
||||
return self.inset["anim"] == "pop" or len({k["size"] for k in self.keys}) > 1
|
||||
|
||||
@property
|
||||
def dynamic_pos(self) -> bool:
|
||||
return self.inset["anim"] == "slide" or len({(k["x"], k["y"]) for k in self.keys}) > 1
|
||||
|
||||
|
||||
def _rounded_alpha(w: int, h: int, radius: float):
|
||||
import numpy as np
|
||||
|
||||
yy, xx = np.mgrid[0:h, 0:w].astype(np.float32) + 0.5
|
||||
r = max(0.0, min(radius, w / 2, h / 2))
|
||||
if r <= 0:
|
||||
return np.ones((h, w), np.float32)
|
||||
dx = np.maximum(np.maximum(r - xx, xx - (w - r)), 0)
|
||||
dy = np.maximum(np.maximum(r - yy, yy - (h - r)), 0)
|
||||
return np.clip(r - np.sqrt(dx * dx + dy * dy) + 0.5, 0, 1)
|
||||
|
||||
|
||||
def _make_images(plan: InsetPlan, border_color: str | None, pad: int, shadow_pad: int, radius_px: float) -> None:
|
||||
"""Máscara dos cantos (tamanho do recorte) e a imagem de decoração (sombra borrada + borda), em PNG."""
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
w, h = plan.base_w, plan.base_h
|
||||
cv2.imwrite(str(plan.mask_file), (_rounded_alpha(w, h, radius_px) * 255).astype(np.uint8))
|
||||
if plan.decor_file is None:
|
||||
return
|
||||
rgb = np.zeros((plan.decor_h, plan.decor_w, 3), np.float32)
|
||||
alpha = np.zeros((plan.decor_h, plan.decor_w), np.float32)
|
||||
bw, bh = w + 2 * pad, h + 2 * pad
|
||||
outer = _rounded_alpha(bw, bh, radius_px + pad if radius_px else 0)
|
||||
x0, y0 = plan.ox - pad, plan.oy - pad
|
||||
if shadow_pad:
|
||||
off = max(1, shadow_pad // 2)
|
||||
shadow = np.zeros_like(alpha)
|
||||
shadow[y0 + off: y0 + off + bh, x0 + off: x0 + off + bw] = outer
|
||||
alpha = cv2.GaussianBlur(shadow, (0, 0), sigmaX=max(1.0, shadow_pad / 2.5)) * SHADOW_ALPHA
|
||||
if pad and border_color:
|
||||
color = np.array([int(border_color[i: i + 2], 16) for i in (5, 3, 1)], np.float32) # BGR
|
||||
a_b = np.zeros_like(alpha)
|
||||
a_b[y0: y0 + bh, x0: x0 + bw] = outer
|
||||
rgb = (color * a_b[..., None] + rgb * (alpha * (1 - a_b))[..., None]) / np.maximum(
|
||||
(a_b + alpha * (1 - a_b))[..., None], 1e-6)
|
||||
alpha = a_b + alpha * (1 - a_b)
|
||||
img = np.dstack([np.clip(rgb, 0, 255), alpha * 255]).astype(np.uint8)
|
||||
cv2.imwrite(str(plan.decor_file), img)
|
||||
|
||||
|
||||
def plan_insets(project: dict, cuts_to_output, t0: float, t1: float, frame: tuple[int, int], canvas_w: int,
|
||||
src_size: tuple[int, int], work: Path, stem: str) -> list[InsetPlan]:
|
||||
"""Camadas que aparecem na saída [t0, t1], com tamanhos em px e as imagens auxiliares geradas em `work`."""
|
||||
fw, _fh = frame
|
||||
k = fw / canvas_w # px do quadro lógico (borda, raio) → px do vídeo
|
||||
plans = []
|
||||
for n, o in enumerate(x for x in project["overlays"] if x["kind"] == "inset"):
|
||||
a, b = cuts_to_output(o["start"]), cuts_to_output(o["end"])
|
||||
if b - a < 0.05 or b <= t0 or a >= t1:
|
||||
continue
|
||||
keys = [{"t": cuts_to_output(x["t"]), "x": x["x"], "y": x["y"], "size": x["size"], "ease": x.get("ease", "smooth")}
|
||||
for x in o.get("keys") or []] or [{"t": a, "x": o["x"], "y": o["y"], "size": o["size"], "ease": "hold"}]
|
||||
top_size = max(x["size"] for x in keys)
|
||||
src = o["src"]
|
||||
base_w = max(8, int(round(top_size * fw / 2)) * 2)
|
||||
base_h = max(8, int(round(base_w * (src["h"] * src_size[1]) / (src["w"] * src_size[0]) / 2)) * 2)
|
||||
pad = int(round(o["borderW"] * k)) if o["border"] else 0
|
||||
shadow_pad = max(6, int(round(0.03 * base_w))) if o["shadow"] else 0
|
||||
decor = pad > 0 or shadow_pad > 0
|
||||
margin = pad + shadow_pad
|
||||
tag = f"{stem}-inset{n}"
|
||||
plan = InsetPlan(o, a, b, base_w, base_h, margin, margin,
|
||||
base_w + 2 * margin + shadow_pad // 2 if decor else base_w,
|
||||
base_h + 2 * margin + shadow_pad // 2 if decor else base_h,
|
||||
work / f"{tag}-mask.png", work / f"{tag}-decor.png" if decor else None, keys)
|
||||
_make_images(plan, o["border"], pad, shadow_pad, o["radius"] * k)
|
||||
plans.append(plan)
|
||||
return plans
|
||||
|
||||
|
||||
def inset_graph(plans: list[InsetPlan], inputs: list[dict], base: str, raw: str, t0: float, frame: tuple[int, int],
|
||||
out: str) -> list[str]:
|
||||
"""Trechos do filter_complex: [base] (vídeo já no layout) + camadas → [out]. `raw` = vídeo original concatenado;
|
||||
`inputs[i]` = {"mask": idx, "decor": idx|None} das entradas PNG (em loop) de cada camada. Tamanho e posição só
|
||||
viram expressão por quadro quando mudam (keys, pop, slide)."""
|
||||
fw, fh = frame
|
||||
g = [f"[{raw}]split={len(plans)}" + "".join(f"[ir{i}]" for i in range(len(plans))) if len(plans) > 1
|
||||
else f"[{raw}]null[ir0]"]
|
||||
cur = base
|
||||
T = f"(t+{t0:.3f})"
|
||||
for i, (p, idx) in enumerate(zip(plans, inputs)):
|
||||
o, src = p.inset, p.inset["src"]
|
||||
a, b = p.a - t0, p.b - t0 # tempo do grafo (a prévia começa em 0)
|
||||
g.append(f"[ir{i}]crop=iw*{src['w']}:ih*{src['h']}:iw*{src['x']}:ih*{src['y']},scale={p.base_w}:{p.base_h},"
|
||||
f"setsar=1,format=rgba[iv{i}]")
|
||||
g.append(f"[{idx['mask']}:v]format=gray[im{i}]")
|
||||
g.append(f"[iv{i}][im{i}]alphamerge[ia{i}]")
|
||||
comp = f"ia{i}"
|
||||
if idx.get("decor") is not None: # recorte por cima da sombra + borda (imagem pequena, uma vez por quadro)
|
||||
g.append(f"[{idx['decor']}:v]format=rgba[id{i}]")
|
||||
g.append(f"[id{i}][ia{i}]overlay={p.ox}:{p.oy}:format=rgb[ic{i}]")
|
||||
comp = f"ic{i}"
|
||||
chain = []
|
||||
if p.dynamic_size:
|
||||
k = f"(({piecewise(p.keys, 'size', T)})/{p.base_w / fw:.5f})"
|
||||
if o["anim"] == "pop": # cresce de 82 % a 106 % e assenta em 100 %
|
||||
k += (f"*if(lt({T}-{p.a:.3f},0.16),0.82+0.24*({T}-{p.a:.3f})/0.16,"
|
||||
f"if(lt({T}-{p.a:.3f},0.28),1.06-0.06*({T}-{p.a:.3f}-0.16)/0.12,1))")
|
||||
chain.append(f"scale=w='max(2,round({p.decor_w}*{k}))':h='max(2,round({p.decor_h}*{k}))':eval=frame")
|
||||
elif p.keys[0]["size"] * fw < p.base_w - 1: # tamanho fixo menor que o maior dos keys (não acontece sem keys)
|
||||
s = p.keys[0]["size"] * fw / p.base_w
|
||||
chain.append(f"scale={max(2, round(p.decor_w * s))}:{max(2, round(p.decor_h * s))}")
|
||||
if o["anim"] != "none":
|
||||
chain.append(f"fade=t=in:st={max(0.0, a):.3f}:d={ANIM_S}:alpha=1")
|
||||
chain.append(f"fade=t=out:st={max(0.0, b - ANIM_S):.3f}:d={ANIM_S}:alpha=1")
|
||||
if chain:
|
||||
g.append(f"[{comp}]" + ",".join(chain) + f"[if{i}]")
|
||||
comp = f"if{i}"
|
||||
fx, fy = (p.ox + p.base_w / 2) / p.decor_w, (p.oy + p.base_h / 2) / p.decor_h # centro do recorte na imagem
|
||||
if p.dynamic_pos:
|
||||
dx = ""
|
||||
if o["anim"] == "slide": # entra pela direita
|
||||
u = f"clip(({T}-{p.a:.3f})/{SLIDE_S},0,1)"
|
||||
dx = f"+{fw * 0.7:.1f}*(1-{u}*{u}*(3-2*{u}))"
|
||||
pos = (f"x='{fw}*({piecewise(p.keys, 'x', T)}){dx}-w*{fx:.5f}':"
|
||||
f"y='{fh}*({piecewise(p.keys, 'y', T)})-h*{fy:.5f}':eval=frame")
|
||||
else:
|
||||
pos = f"x='{fw * p.keys[0]['x']:.2f}-w*{fx:.5f}':y='{fh * p.keys[0]['y']:.2f}-h*{fy:.5f}'"
|
||||
nxt = out if i == len(plans) - 1 else f"li{i}"
|
||||
g.append(f"[{cur}][{comp}]overlay={pos}:enable='between(t,{a:.3f},{b:.3f})'[{nxt}]")
|
||||
cur = nxt
|
||||
return g
|
||||
@@ -0,0 +1,399 @@
|
||||
"""Escolha dos melhores momentos. Funções puras (sem E/S): recebem a linha do tempo e devolvem os trechos.
|
||||
|
||||
Ideia central: o chat reage DEPOIS do momento. Medimos a "empolgação" do chat por segundo (mensagens com peso:
|
||||
risada, susto, hype e pedido de clip valem mais), comparamos com o normal recente da própria live (chat grande
|
||||
tem muita mensagem o tempo todo; o que importa é o pico relativo) e, achado o pico, voltamos no tempo até onde a
|
||||
reação começou e pegamos alguns segundos antes disso: é ali que aconteceu a coisa.
|
||||
|
||||
Sem chat (VOD), o sinal vem do volume do áudio (gritos, risadas) e de palavras de reação na transcrição.
|
||||
|
||||
Rosto do streamer (opcional, `face`): a série por segundo do rastreio (reaction.py). Reforça momentos do chat/áudio
|
||||
(`reasons.face` + bônus limitado na nota) e cria momentos de fonte "face" só quando o áudio ou o chat também se
|
||||
mexem no mesmo trecho — rosto sozinho nunca vira corte. Sem `face`, o resultado é idêntico ao de antes.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import re
|
||||
import statistics
|
||||
from collections import Counter
|
||||
from dataclasses import dataclass, field, replace
|
||||
|
||||
from . import reaction
|
||||
|
||||
# Peso extra por categoria de reação. Uma mensagem pode somar mais de uma.
|
||||
REACTION_PATTERNS: dict[str, tuple[re.Pattern[str], float]] = {
|
||||
"risada": (re.compile(r"(k{3,}|kek|lul|lmao|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b)", re.I), 1.0),
|
||||
"susto": (re.compile(r"(caralho|crlh|caraca|nossa|meu deus|mds|wtf|omg|que isso|q isso|monkas|monkaw|\bhuh+\b|"
|
||||
r"😱|😳|\?{3,}|!{3,})", re.I), 1.0),
|
||||
"hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥)", re.I), 0.7),
|
||||
# Palavra inteira: "clip5k1hmm" (emote) casava com \bclip e dava peso de pedido de clipe.
|
||||
"clip": (re.compile(r"\b(clip|clips|clipa|clipe|clipou|clipar|clip it|clipit)\b", re.I), 3.0),
|
||||
}
|
||||
# Palavras faladas que indicam reação (modo sem chat).
|
||||
SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha)$", re.I)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Params:
|
||||
pre_s: float = 14.0 # quanto antes do início da reação o corte começa
|
||||
post_s: float = 6.0 # quanto depois do pico o corte termina
|
||||
# Duração do candidato: o motor troca pelos valores da configuração do corte de cada sessão (`duration`);
|
||||
# estes são os mesmos padrões de layout.DEFAULTS (pedido do dono, 16/11/2026: cortes de 60 a 90 s).
|
||||
min_s: float = 60.0
|
||||
max_s: float = 90.0
|
||||
threshold: float = 2.2 # pico precisa ser X vezes o normal recente do chat
|
||||
audio_threshold: float = 2.0 # modo sem chat: z-score mínimo
|
||||
min_gap_s: float = 45.0 # distância mínima entre dois picos
|
||||
smooth_s: int = 5
|
||||
baseline_s: int = 180
|
||||
onset_ratio: float = 1.3 # o início da reação é onde a razão cai abaixo disto
|
||||
max_onset_s: float = 30.0
|
||||
settle_s: float = 12.0 # ao vivo: espera este tanto depois do fim do corte antes de fechar o pico
|
||||
min_rate: float = 0.2 # mensagens/s mínimas no denominador (live com chat parado não vira pico por 2 msgs)
|
||||
min_peak_messages: int = 12 # teto do mínimo de mensagens nos 8 s do pico (chat grande)
|
||||
min_peak_floor: int = 4 # piso do mínimo (chat pequeno): 3 mensagens soltas nunca viram pico
|
||||
min_reactions: int = 2 # mensagens de reação (risada/susto/hype/clip) nos 8 s do pico
|
||||
sparse_rate: float = 0.5 # msg/s abaixo disso o chat é "fraco" e o áudio também propõe momentos
|
||||
warmup_s: int = 60 # começo da gravação: ainda não há "normal" do chat para comparar
|
||||
# --- rosto do streamer (reaction.py) ---
|
||||
face_threshold: float = 3.0 # z mínimo da reação no rosto para anotar/reforçar um momento
|
||||
face_bonus: float = 0.08 # nota extra por unidade de z do rosto num momento do chat/áudio…
|
||||
face_bonus_max: float = 0.6 # …limitada a isto (o rosto reforça, não manda)
|
||||
# Momento NOVO de fonte "face" (calibrado na sessão 3: com z ≥ 3 e apoio fraco saíam 32 momentos em 72 min,
|
||||
# mais que os 21 do chat): reação forte no rosto E apoio de verdade no mesmo trecho.
|
||||
face_source_threshold: float = 6.0 # z mínimo (= "forte")
|
||||
face_support_audio_z: float = 1.5 # sinal do áudio suavizado (3 s) acima disto…
|
||||
face_support_reactions: int = 2 # …ou pelo menos isto de mensagens de reação (texto ou emote) no chat
|
||||
face_chat_after_s: float = 10.0 # o chat reage depois: conta até X s após o pico do rosto
|
||||
face_score_scale: float = 0.4 # nota do momento "face" = z do rosto (até 10) × isto, na escala da razão do chat
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ChatMessage:
|
||||
t: float
|
||||
text: str
|
||||
user: str = ""
|
||||
emotes: tuple[str, ...] = () # emotes da mensagem (Twitch, 7TV, BTTV, FFZ, Kick, emoji)
|
||||
bonus: float = 0.0 # peso extra pelos emotes (base + aprendido do canal; ver emotes.py)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Word:
|
||||
start: float
|
||||
end: float
|
||||
word: str
|
||||
|
||||
|
||||
@dataclass
|
||||
class Moment:
|
||||
peak_s: float
|
||||
start_s: float
|
||||
end_s: float
|
||||
score: float
|
||||
source: str # "chat" ou "audio"
|
||||
reasons: dict = field(default_factory=dict)
|
||||
|
||||
|
||||
def message_weight(text: str) -> tuple[float, list[str]]:
|
||||
weight, tags = 1.0, []
|
||||
for tag, (pattern, bonus) in REACTION_PATTERNS.items():
|
||||
if pattern.search(text):
|
||||
weight += bonus
|
||||
tags.append(tag)
|
||||
return weight, tags
|
||||
|
||||
|
||||
def per_second(duration_s: float, chat: list[ChatMessage]) -> list[float]:
|
||||
n = max(0, int(math.ceil(duration_s)))
|
||||
series = [0.0] * n
|
||||
for message in chat:
|
||||
i = int(message.t)
|
||||
if 0 <= i < n:
|
||||
series[i] += message_weight(message.text)[0] + message.bonus
|
||||
return series
|
||||
|
||||
|
||||
def smooth(series: list[float], window: int) -> list[float]:
|
||||
"""Média móvel para trás (só usa o passado: o valor em t não depende do futuro)."""
|
||||
out, acc = [], 0.0
|
||||
for i, value in enumerate(series):
|
||||
acc += value
|
||||
if i >= window:
|
||||
acc -= series[i - window]
|
||||
out.append(acc / min(i + 1, window))
|
||||
return out
|
||||
|
||||
|
||||
def chat_ratio(series: list[float], p: Params) -> list[float]:
|
||||
"""Razão entre a empolgação suavizada e o normal recente (mediana dos últimos `baseline_s`, sem os últimos 10 s)."""
|
||||
smoothed = smooth(series, p.smooth_s)
|
||||
ratio = []
|
||||
for t, value in enumerate(smoothed):
|
||||
window = smoothed[max(0, t - p.baseline_s): max(0, t - 10)]
|
||||
if len(window) < 30: # começo da gravação: usa o que tiver
|
||||
window = smoothed[: t + 1]
|
||||
base = max(p.min_rate, statistics.median(window) if window else p.min_rate)
|
||||
ratio.append(value / base)
|
||||
return ratio
|
||||
|
||||
|
||||
def zscores(series: list[float]) -> list[float]:
|
||||
values = [v for v in series if v is not None and not math.isnan(v)]
|
||||
if len(values) < 10:
|
||||
return [0.0] * len(series)
|
||||
mean = statistics.fmean(values)
|
||||
sd = statistics.pstdev(values) or 1.0
|
||||
return [((v - mean) / sd) if v is not None and not math.isnan(v) else 0.0 for v in series]
|
||||
|
||||
|
||||
def audio_signal(duration_s: float, loudness: list[float | None], words: list[Word]) -> list[float]:
|
||||
n = max(0, int(math.ceil(duration_s)))
|
||||
loud = (list(loudness) + [None] * n)[:n]
|
||||
z = zscores([v if v is not None else float("nan") for v in loud])
|
||||
signal = [max(0.0, v) for v in z]
|
||||
for word in words:
|
||||
i = int(word.start)
|
||||
if 0 <= i < n and SPOKEN_REACTION.match(word.word.strip(" .,!?…").lower()):
|
||||
signal[i] += 0.5
|
||||
return smooth(signal, 3)
|
||||
|
||||
|
||||
def pick_peaks(score: list[float], threshold: float, min_gap_s: float, limit_s: float | None = None) -> list[int]:
|
||||
"""Picos acima do limiar, do maior para o menor, sem dois a menos de `min_gap_s`."""
|
||||
# Escolhe olhando a série inteira e só depois descarta os não assentados (após `limit_s`): assim, ao vivo,
|
||||
# um pico maior que ainda está crescendo segura os pontos menores do começo da mesma explosão.
|
||||
candidates = sorted((i for i in range(len(score)) if score[i] >= threshold), key=lambda i: -score[i])
|
||||
chosen: list[int] = []
|
||||
for i in candidates:
|
||||
if all(abs(i - j) >= min_gap_s for j in chosen):
|
||||
chosen.append(i)
|
||||
return sorted(i for i in chosen if limit_s is None or i < limit_s)
|
||||
|
||||
|
||||
def onset(score: list[float], peak: int, below: float, max_back_s: float) -> int:
|
||||
t = peak
|
||||
while t > 0 and peak - t < max_back_s and score[t - 1] >= below:
|
||||
t -= 1
|
||||
return t
|
||||
|
||||
|
||||
def snap_to_words(start: float, end: float, words: list[Word], gap: float = 0.35, reach: float = 4.0) -> tuple[float, float]:
|
||||
"""Não corta no meio de uma frase: recua o início até uma pausa e estica o fim até uma pausa (até `reach` s)."""
|
||||
if not words:
|
||||
return start, end
|
||||
ordered = sorted(words, key=lambda w: w.start)
|
||||
# Começos de frase (palavra depois de uma pausa) perto do início pedido; prefere o mais próximo ANTES dele.
|
||||
starts = [
|
||||
w.start for i, w in enumerate(ordered)
|
||||
if start - reach <= w.start <= start + 0.5 and (i == 0 or w.start - ordered[i - 1].end >= gap)
|
||||
]
|
||||
before = [s for s in starts if s <= start]
|
||||
new_start = (max(before) if before else min(starts)) - 0.15 if starts else start
|
||||
new_end = end
|
||||
for i, word in enumerate(ordered):
|
||||
if end - 0.5 <= word.end <= end + reach:
|
||||
pause_after = ordered[i + 1].start - word.end if i + 1 < len(ordered) else gap
|
||||
if pause_after >= gap:
|
||||
new_end = word.end + 0.25
|
||||
break
|
||||
return max(0.0, new_start), max(new_end, new_start + 1)
|
||||
|
||||
|
||||
def fit_window(start: float, end: float, lo: float, hi: float, min_len: float, max_len: float,
|
||||
keep: str = "end") -> tuple[float, float]:
|
||||
"""Encaixa [start, end] em [lo, hi] com duração entre `min_len` e `max_len`. Longo demais: corta o lado oposto a
|
||||
`keep`. Curto demais: cresce PARA TRÁS primeiro (o contexto vem antes da reação) e, se bater em `lo` (começo da
|
||||
gravação/janela), para a frente até `hi`. Se nem assim couber (material menor que o mínimo), devolve o que der —
|
||||
quem chama decide o que fazer (não inventa vídeo). Arredonda para fora (centésimos), nunca encurta."""
|
||||
start, end = max(lo, start), min(hi, end)
|
||||
if end < start:
|
||||
end = start
|
||||
if end - start > max_len:
|
||||
if keep == "start":
|
||||
end = start + max_len
|
||||
else:
|
||||
start = end - max_len
|
||||
if end - start < min_len:
|
||||
start = max(lo, end - min_len)
|
||||
if end - start < min_len:
|
||||
end = min(hi, start + min_len)
|
||||
return math.floor(start * 100) / 100, math.ceil(end * 100 - 1e-6) / 100
|
||||
|
||||
|
||||
def fit_length(start: float, end: float, peak: float, p: Params, duration_s: float) -> tuple[float, float]:
|
||||
"""Duração do candidato: começa pelo menos 2 s antes do pico e fica entre `min_s` e `max_s` (o motor passa o
|
||||
mínimo da configuração + 1 s). Antes a ordem permitia passar do máximo e, no fim da gravação, ficar curto."""
|
||||
start = max(0.0, min(start, peak - 2))
|
||||
return fit_window(start, end, 0.0, max(duration_s, end), p.min_s, p.max_s, keep="end")
|
||||
|
||||
|
||||
def chat_reasons(chat: list[ChatMessage], start: float, end: float) -> dict:
|
||||
inside = [m for m in chat if start <= m.t <= end]
|
||||
tags: Counter[str] = Counter()
|
||||
phrases: Counter[str] = Counter()
|
||||
emotes: Counter[str] = Counter()
|
||||
for message in inside:
|
||||
tags.update(message_weight(message.text)[1])
|
||||
emotes.update(set(message.emotes))
|
||||
normalized = re.sub(r"\s+", " ", message.text.strip())[:40]
|
||||
if normalized:
|
||||
phrases[normalized.lower()] += 1
|
||||
return {
|
||||
"messages": len(inside),
|
||||
"tags": dict(tags.most_common()),
|
||||
"topMessages": [text for text, _ in phrases.most_common(5)],
|
||||
"emotes": dict(emotes.most_common(8)),
|
||||
}
|
||||
|
||||
|
||||
def find_moments(
|
||||
duration_s: float,
|
||||
chat: list[ChatMessage],
|
||||
loudness: list[float | None],
|
||||
words: list[Word],
|
||||
params: Params | None = None,
|
||||
live: bool = False,
|
||||
face: list[reaction.FaceSecond] | None = None,
|
||||
) -> list[Moment]:
|
||||
"""Melhores momentos da linha do tempo. `live=True` só devolve picos já "assentados" (fim + settle_s <= duração).
|
||||
|
||||
Chat com movimento → picos do chat. Chat fraco (média < `sparse_rate` msg/s) → picos do chat E do áudio
|
||||
(gritos/risadas/palavras de reação), sem sobrepor; o juiz de IA filtra. Sem chat → só áudio.
|
||||
`face`: série do rosto alinhada à linha do tempo (índice = segundo; `None`/vazia = sem rosto).
|
||||
"""
|
||||
p = params or Params()
|
||||
use_chat = len(chat) >= 30
|
||||
moments = _chat_moments(duration_s, chat, loudness, words, p, live) if use_chat else []
|
||||
sparse = duration_s > 0 and len(chat) / duration_s < p.sparse_rate
|
||||
if not use_chat or sparse:
|
||||
for m in _audio_moments(duration_s, loudness, words, p, live):
|
||||
if not any(overlaps(m.start_s, m.end_s, c.start_s, c.end_s) for c in moments):
|
||||
moments.append(m)
|
||||
if face:
|
||||
moments += _face_moments(duration_s, chat if use_chat else [], loudness, words, face, moments, p, live)
|
||||
return sorted(moments, key=lambda m: m.peak_s)
|
||||
|
||||
|
||||
def _face_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
|
||||
face: list[reaction.FaceSecond], moments: list[Moment], p: Params, live: bool) -> list[Moment]:
|
||||
"""Anota o rosto nos momentos do chat/áudio (bônus limitado) e devolve os momentos novos de fonte "face"."""
|
||||
reactions = reaction.reaction_moments(face, replace(reaction.ReactionParams(), threshold=p.face_threshold))
|
||||
if not reactions:
|
||||
return []
|
||||
for m in moments:
|
||||
near = [r for r in reactions if m.start_s - 2 <= r.peak_s <= m.end_s + 3]
|
||||
if near:
|
||||
best = max(near, key=lambda r: r.intensity)
|
||||
m.reasons["face"] = best.to_json()
|
||||
m.score = round(m.score + min(p.face_bonus_max, p.face_bonus * best.intensity), 3)
|
||||
n = max(0, int(math.ceil(duration_s)))
|
||||
# Sinal do áudio suavizado (3 s, igual ao da fonte "audio"): o z cru de 1 segundo passa de 1 por acaso em ~16 %
|
||||
# dos segundos e não serviria de apoio.
|
||||
loud = audio_signal(duration_s, loudness, words)
|
||||
reacting = [m.t for m in chat if message_weight(m.text)[1] or m.emotes]
|
||||
limit = duration_s - p.post_s - p.settle_s if live else None
|
||||
out: list[Moment] = []
|
||||
for r in sorted(reactions, key=lambda r: -r.intensity):
|
||||
if r.intensity < p.face_source_threshold or (limit is not None and r.peak_s >= limit):
|
||||
continue
|
||||
lo, hi = max(0, r.onset_s - 2), min(n, r.peak_s + 4)
|
||||
audio = max(loud[lo:hi], default=0.0)
|
||||
chat_hits = sum(1 for t in reacting if r.onset_s - 2 <= t <= r.peak_s + p.face_chat_after_s)
|
||||
# Rosto sozinho não vira corte: precisa de apoio do áudio (gritou/riu alto) ou do chat no mesmo trecho.
|
||||
if audio < p.face_support_audio_z and chat_hits < p.face_support_reactions:
|
||||
continue
|
||||
start, end = snap_to_words(r.onset_s - p.pre_s, max(r.end_s, r.peak_s) + p.post_s, words)
|
||||
start, end = fit_length(start, end, r.peak_s, p, duration_s)
|
||||
if any(overlaps(start, end, m.start_s, m.end_s) for m in moments + out):
|
||||
continue
|
||||
if any(abs(r.peak_s - m.peak_s) < p.min_gap_s for m in out):
|
||||
continue
|
||||
reasons = {"peakRatio": round(r.intensity, 2), "onsetS": r.onset_s, "face": r.to_json(),
|
||||
"support": {"audioZ": round(audio, 2), "chatReactions": chat_hits}}
|
||||
if chat:
|
||||
reasons |= chat_reasons(chat, r.onset_s - 2, r.peak_s + 3)
|
||||
out.append(Moment(float(r.peak_s), start, end, round(min(10.0, r.intensity) * p.face_score_scale, 3), "face",
|
||||
reasons))
|
||||
return out
|
||||
|
||||
|
||||
def _required_messages(counts_8s: list[int], t: int, p: Params) -> int:
|
||||
"""Mínimo de mensagens nos 8 s do pico, proporcional ao chat daquela live (mediana recente × 3).
|
||||
|
||||
Medido em 17/11/2026: chat de 0,15 msg/s (skipnho) nunca chegava às 12 mensagens fixas e a live inteira ficava
|
||||
sem corte; chat de ~0,6 msg/s (alanzoka) com 3 mensagens soltas não pode virar pico. Fica entre 4 e 12.
|
||||
"""
|
||||
window = counts_8s[max(0, t - p.baseline_s): max(0, t - 10)] or counts_8s[: t + 1]
|
||||
typical = statistics.median(window) if window else 0
|
||||
return int(max(p.min_peak_floor, min(p.min_peak_messages, math.ceil(typical * 3))))
|
||||
|
||||
|
||||
def _chat_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
|
||||
p: Params, live: bool) -> list[Moment]:
|
||||
score, threshold = chat_ratio(per_second(duration_s, chat), p), p.threshold
|
||||
loud_z = zscores([v if v is not None else float("nan") for v in (list(loudness) + [None] * len(score))[: len(score)]])
|
||||
score = [s + 0.15 * max(0.0, z) for s, z in zip(score, loud_z)] # grito junto com o pico do chat soma um pouco
|
||||
# Falso positivo medido na live real: chat calmo + 3 mensagens (uma com "clip") já dava razão 2,35, e o
|
||||
# começo da gravação (sem "normal" para comparar) virava pico. Exige gente reagindo (relativo ao chat) e aquecimento.
|
||||
counts, reacts = [0] * len(score), [0] * len(score)
|
||||
for message in chat:
|
||||
i = int(message.t)
|
||||
if 0 <= i < len(counts):
|
||||
counts[i] += 1
|
||||
# Reação = texto de reação OU emote (público pequeno reage com emote em vez de "kkkk").
|
||||
reacts[i] += 1 if (message_weight(message.text)[1] or message.emotes) else 0
|
||||
prefix, rprefix = [0], [0]
|
||||
for c, r in zip(counts, reacts):
|
||||
prefix.append(prefix[-1] + c)
|
||||
rprefix.append(rprefix[-1] + r)
|
||||
counts_8s = [prefix[t + 1] - prefix[max(0, t - 7)] for t in range(len(score))] # mensagens nos últimos 8 s
|
||||
for t in range(len(score)):
|
||||
required = _required_messages(counts_8s, t, p)
|
||||
reactions = rprefix[t + 1] - rprefix[max(0, t - 7)]
|
||||
# Chat pequeno junta 4 "oi" por acaso: além do volume, exige reação de verdade (ou volume dobrado).
|
||||
enough = counts_8s[t] >= required and (reactions >= p.min_reactions or counts_8s[t] >= 2 * required)
|
||||
if t < p.warmup_s or not enough:
|
||||
score[t] = min(score[t], threshold - 0.01)
|
||||
return _build(score, threshold, p.onset_ratio, "chat", duration_s, chat, words, p, live)
|
||||
|
||||
|
||||
def _audio_moments(duration_s: float, loudness: list[float | None], words: list[Word], p: Params, live: bool) -> list[Moment]:
|
||||
score = audio_signal(duration_s, loudness, words)
|
||||
return _build(score, p.audio_threshold, 0.8, "audio", duration_s, [], words, p, live)
|
||||
|
||||
|
||||
def _build(score: list[float], threshold: float, below: float, source: str, duration_s: float,
|
||||
chat: list[ChatMessage], words: list[Word], p: Params, live: bool) -> list[Moment]:
|
||||
limit = duration_s - p.post_s - p.settle_s if live else None
|
||||
moments = []
|
||||
for peak in pick_peaks(score, threshold, p.min_gap_s, limit):
|
||||
begin = onset(score, peak, below, p.max_onset_s)
|
||||
start, end = begin - p.pre_s, peak + p.post_s
|
||||
start, end = snap_to_words(start, end, words)
|
||||
start, end = fit_length(start, end, peak, p, duration_s)
|
||||
reasons = {"peakRatio": round(score[peak], 2), "onsetS": begin}
|
||||
if chat:
|
||||
reasons |= chat_reasons(chat, begin - 2, peak + 3)
|
||||
moments.append(Moment(float(peak), start, end, round(score[peak], 3), source, reasons))
|
||||
return moments
|
||||
|
||||
|
||||
def overlaps(a_start: float, a_end: float, b_start: float, b_end: float, tolerance: float = 5.0) -> bool:
|
||||
return a_start < b_end - tolerance and b_start < a_end - tolerance
|
||||
|
||||
|
||||
def timeline(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], params: Params | None = None) -> dict:
|
||||
"""Séries por segundo para o gráfico do painel (mensagens/s, razão do chat, volume)."""
|
||||
p = params or Params()
|
||||
raw = per_second(duration_s, chat)
|
||||
counts = [0] * len(raw)
|
||||
for message in chat:
|
||||
if 0 <= int(message.t) < len(counts):
|
||||
counts[int(message.t)] += 1
|
||||
return {
|
||||
"messagesPerS": counts,
|
||||
"ratio": [round(v, 2) for v in chat_ratio(raw, p)] if chat else [],
|
||||
"loudnessDb": [None if v is None else round(v, 1) for v in loudness[: len(raw)]],
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
"""Reconhece a plataforma e o canal a partir do link colado (Twitch, YouTube, Kick)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
PLATFORMS = ("twitch", "youtube", "kick")
|
||||
|
||||
_TWITCH_LOGIN = re.compile(r"^[a-z0-9_]{3,25}$")
|
||||
_KICK_SLUG = re.compile(r"^[a-z0-9_-]{2,40}$")
|
||||
_YT_HANDLE = re.compile(r"^@[A-Za-z0-9._-]{2,40}$")
|
||||
_YT_VIDEO = re.compile(r"^[A-Za-z0-9_-]{11}$")
|
||||
_TWITCH_RESERVED = {"videos", "directory", "settings", "p", "search", "downloads", "jobs", "turbo"}
|
||||
|
||||
|
||||
class SourceError(ValueError):
|
||||
"""Link que o Clipador não reconhece."""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Source:
|
||||
platform: str
|
||||
channel: str # login (Twitch), slug (Kick) ou @handle/ID do canal (YouTube); "" quando só há o vídeo
|
||||
url: str # link normalizado que vai para o Streamlink
|
||||
kind: str # "live" (canal) ou "vod" (vídeo gravado)
|
||||
|
||||
@property
|
||||
def channel_id(self) -> str:
|
||||
return f"{self.platform}-{self.channel.lstrip('@').lower()}"
|
||||
|
||||
|
||||
def parse_source(raw: str) -> Source:
|
||||
text = raw.strip()
|
||||
if not text:
|
||||
raise SourceError("Cole o link da live ou do vídeo.")
|
||||
if "://" not in text:
|
||||
text = "https://" + text
|
||||
url = urlparse(text)
|
||||
if url.scheme not in ("http", "https"):
|
||||
raise SourceError("O link precisa começar com https://.")
|
||||
host = (url.hostname or "").lower().removeprefix("www.").removeprefix("m.")
|
||||
parts = [p for p in url.path.split("/") if p]
|
||||
|
||||
if host in ("twitch.tv", "go.twitch.tv"):
|
||||
if len(parts) >= 2 and parts[0] == "videos" and parts[1].isdigit():
|
||||
return Source("twitch", "", f"https://www.twitch.tv/videos/{parts[1]}", "vod")
|
||||
if len(parts) >= 3 and parts[1] == "video" and parts[2].isdigit():
|
||||
return Source("twitch", parts[0].lower(), f"https://www.twitch.tv/videos/{parts[2]}", "vod")
|
||||
if parts and _TWITCH_LOGIN.fullmatch(parts[0].lower()) and parts[0].lower() not in _TWITCH_RESERVED:
|
||||
login = parts[0].lower()
|
||||
return Source("twitch", login, f"https://www.twitch.tv/{login}", "live")
|
||||
raise SourceError("Link da Twitch não reconhecido (use twitch.tv/<canal> ou twitch.tv/videos/<id>).")
|
||||
|
||||
if host == "kick.com":
|
||||
if len(parts) >= 3 and parts[1] == "videos":
|
||||
return Source("kick", parts[0].lower(), f"https://kick.com/{parts[0].lower()}/videos/{parts[2]}", "vod")
|
||||
if len(parts) == 1 and _KICK_SLUG.fullmatch(parts[0].lower()):
|
||||
slug = parts[0].lower()
|
||||
return Source("kick", slug, f"https://kick.com/{slug}", "live")
|
||||
raise SourceError("Link da Kick não reconhecido (use kick.com/<canal>).")
|
||||
|
||||
if host in ("youtube.com", "youtu.be"):
|
||||
if host == "youtu.be" and parts and _YT_VIDEO.fullmatch(parts[0]):
|
||||
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[0]}", "vod")
|
||||
video = parse_qs(url.query).get("v", [""])[0]
|
||||
if parts[:1] == ["watch"] and _YT_VIDEO.fullmatch(video):
|
||||
return Source("youtube", "", f"https://www.youtube.com/watch?v={video}", "vod")
|
||||
if len(parts) >= 2 and parts[0] in ("live", "shorts") and _YT_VIDEO.fullmatch(parts[1]):
|
||||
return Source("youtube", "", f"https://www.youtube.com/watch?v={parts[1]}", "vod")
|
||||
if parts and _YT_HANDLE.fullmatch(parts[0]):
|
||||
return Source("youtube", parts[0], f"https://www.youtube.com/{parts[0]}/live", "live")
|
||||
if len(parts) >= 2 and parts[0] == "channel" and re.fullmatch(r"UC[A-Za-z0-9_-]{22}", parts[1]):
|
||||
return Source("youtube", parts[1], f"https://www.youtube.com/channel/{parts[1]}/live", "live")
|
||||
raise SourceError("Link do YouTube não reconhecido (use youtube.com/@canal ou o link do vídeo).")
|
||||
|
||||
raise SourceError("Plataforma não suportada: use Twitch, YouTube ou Kick.")
|
||||
@@ -0,0 +1,146 @@
|
||||
"""Legenda queimada no corte (formato ASS, lido pelo filtro `ass` do FFmpeg), no vertical ou no horizontal.
|
||||
|
||||
Estilo de corte de live: blocos curtos, grandes, com contorno, e a palavra falada no momento destacada.
|
||||
Cores, fonte, tamanho, posição e palavras por bloco vêm da configuração do corte (layout.py, grupo `caption`).
|
||||
O crédito do canal fica em cima ou embaixo (grupo `credit`) — sempre ligado por padrão: o corte é de terceiros.
|
||||
|
||||
Tempo da legenda (pedido do dono, 16/11/2026: "com fala rápida a legenda sai fora do tempo e fica uma em cima da
|
||||
outra"). Medido na cópia do banco: 63 de 286 eventos de legenda dos projetos se sobrepunham — o fim de um bloco
|
||||
(fim da última palavra, no mínimo +0,25 s) passava do início do bloco seguinte, e o libass EMPILHA dois eventos
|
||||
ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
|
||||
- `clean_words`: palavras ordenadas, sem sobreposição, duração mínima (o Whisper devolve palavra de 0 s) e nunca
|
||||
duas começando no mesmo instante;
|
||||
- `group_words`: até `maxWords` palavras e um limite de caracteres; bloco quebra em pausa > 0,6 s ou se passar de
|
||||
3,2 s; com fala muito rápida (bloco cheio durando < 0,7 s) aceita UMA palavra a mais se couber nos caracteres,
|
||||
para o bloco não piscar;
|
||||
- `caption_blocks`: o fim de cada bloco é cortado no início do seguinte — nunca dois blocos na tela. O início do
|
||||
bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from . import layout
|
||||
from .scoring import Word
|
||||
|
||||
WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração
|
||||
MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6
|
||||
MIN_WORD_S = 0.06 # duração mínima de uma palavra na legenda
|
||||
MIN_STEP_S = 0.04 # duas palavras nunca começam no mesmo instante (a palavra destacada precisa de tempo próprio)
|
||||
MIN_HOLD_S = 0.25 # a última palavra do bloco fica pelo menos isto (se o próximo bloco não começar antes)
|
||||
MAX_BLOCK_S = 3.2 # bloco mais longo que isto quebra (fala arrastada)
|
||||
FAST_BLOCK_S = 0.7 # bloco cheio mais curto que isto = fala rápida: aceita uma palavra a mais
|
||||
|
||||
|
||||
def _ts(seconds: float) -> str:
|
||||
seconds = max(0.0, seconds)
|
||||
cs = int(round(seconds * 100))
|
||||
h, cs = divmod(cs, 360000)
|
||||
m, cs = divmod(cs, 6000)
|
||||
s, cs = divmod(cs, 100)
|
||||
return f"{h}:{m:02d}:{s:02d}.{cs:02d}"
|
||||
|
||||
|
||||
def _escape(text: str) -> str:
|
||||
# Chaves abrem tags de estilo e \ vira comando no ASS: o texto falado nunca pode virar tag.
|
||||
return text.replace("\\", "/").replace("{", "(").replace("}", ")").replace("\n", " ")
|
||||
|
||||
|
||||
def clean_words(words: list[Word]) -> list[Word]:
|
||||
"""Saneia os tempos das palavras: ordena, tira vazias, dá duração mínima, empurra a que começa junto com a
|
||||
anterior e corta o fim de uma palavra no início da seguinte (sem sobreposição). Idempotente nos valores
|
||||
(aplicar duas vezes dá o mesmo resultado); depois dela, (início, texto) identifica cada palavra."""
|
||||
items = sorted((w for w in words if w.word.strip()), key=lambda w: (w.start, w.end))
|
||||
out: list[Word] = []
|
||||
for w in items:
|
||||
start = w.start
|
||||
if out and start < out[-1].start + MIN_STEP_S - 1e-6:
|
||||
start = round(out[-1].start + MIN_STEP_S, 3)
|
||||
end = max(w.end, round(start + MIN_WORD_S, 3))
|
||||
if out and out[-1].end > start + 1e-9:
|
||||
prev = out[-1]
|
||||
out[-1] = Word(prev.start, start, prev.word)
|
||||
text = w.word.strip()
|
||||
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word
|
||||
out.append(w if same else Word(start, end, text))
|
||||
return out
|
||||
|
||||
|
||||
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
|
||||
"""Blocos da legenda (palavras já saneadas por `clean_words`)."""
|
||||
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
|
||||
groups: list[list[Word]] = []
|
||||
for word in clean_words(words):
|
||||
current = groups[-1] if groups else None
|
||||
if current and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S:
|
||||
fits = len(" ".join(w.word for w in current + [word])) <= max_chars
|
||||
room = len(current) < max_words or (
|
||||
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
|
||||
max_words >= 2 and len(current) == max_words and word.end - current[0].start < FAST_BLOCK_S)
|
||||
if fits and room:
|
||||
current.append(word)
|
||||
continue
|
||||
groups.append([word])
|
||||
return groups
|
||||
|
||||
|
||||
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]:
|
||||
"""(palavras do bloco, fim do bloco). O fim nunca passa do início do bloco seguinte: dois eventos de legenda
|
||||
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro)."""
|
||||
groups = group_words(words, max_words)
|
||||
out = []
|
||||
for k, group in enumerate(groups):
|
||||
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
|
||||
if k + 1 < len(groups):
|
||||
end = min(end, groups[k + 1][0].start)
|
||||
out.append((group, round(end, 3)))
|
||||
return out
|
||||
|
||||
|
||||
def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str, settings: dict | None = None) -> str:
|
||||
"""`words` com tempos da sessão; a saída usa tempos relativos ao início do corte."""
|
||||
cfg = settings or layout.merge()
|
||||
cap, cred = cfg["caption"], cfg["credit"]
|
||||
duration = clip_end - clip_start
|
||||
inside = [
|
||||
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip())
|
||||
for w in words
|
||||
if w.end > clip_start and w.start < clip_end
|
||||
]
|
||||
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
|
||||
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
|
||||
width, height = layout.canvas_size(cfg)
|
||||
header = f"""[Script Info]
|
||||
ScriptType: v4.00+
|
||||
PlayResX: {width}
|
||||
PlayResY: {height}
|
||||
WrapStyle: 2
|
||||
ScaledBorderAndShadow: yes
|
||||
|
||||
[V4+ Styles]
|
||||
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
|
||||
Style: Caption,{cap['font']},{cap['size']},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{cap['outlineWidth']},3,5,60,60,0,1
|
||||
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
|
||||
|
||||
[Events]
|
||||
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
|
||||
"""
|
||||
lines = []
|
||||
if credit and cred["enabled"]:
|
||||
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
|
||||
if cap["enabled"]:
|
||||
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}"
|
||||
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
|
||||
for group, g_end in caption_blocks(inside, cap["maxWords"]):
|
||||
for i, word in enumerate(group):
|
||||
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
|
||||
start = word.start
|
||||
end = group[i + 1].start if i + 1 < len(group) else g_end
|
||||
if end <= start:
|
||||
continue
|
||||
# Maiúsculas só no texto: as tags (\c) são sensíveis a caixa.
|
||||
parts = []
|
||||
for j, w in enumerate(group):
|
||||
text = _escape(w.word.upper() if cap["uppercase"] else w.word)
|
||||
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text)
|
||||
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},Caption,,0,0,0,,{pos}{' '.join(parts)}")
|
||||
return header + "\n".join(lines) + "\n"
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"_comment": "Pesos do rastreio de reação do Clipador. Baixados para data/clipper/models/ pelo scripts/setup.ps1 (passo 6b) e conferidos pelo sha256. URLs imutáveis (commit fixo ou caminho versionado). Bancada: doc/FACE_BAKEOFF.md.",
|
||||
"dir": "data/clipper/models",
|
||||
"models": [
|
||||
{
|
||||
"id": "yunet",
|
||||
"file": "face_detection_yunet_2026may.onnx",
|
||||
"role": "achar a câmera (rosto no quadro inteiro), cv2.FaceDetectorYN; entrada dinâmica (OpenCV 5)",
|
||||
"url": "https://media.githubusercontent.com/media/opencv/opencv_zoo/eb9f4f2d4b79b58e5513b5d25d5f0243a8357bf4/models/face_detection_yunet/face_detection_yunet_2026may.onnx",
|
||||
"sha256": "ebafce4e3c118d6554634be5c27ab333b4c047a9a8c3faf1d7cf93101c22f0f0",
|
||||
"size": 229738,
|
||||
"license": "MIT",
|
||||
"source": "github.com/opencv/opencv_zoo@eb9f4f2d4b79b58e5513b5d25d5f0243a8357bf4 (Git LFS)"
|
||||
},
|
||||
{
|
||||
"id": "face_landmarker",
|
||||
"file": "face_landmarker.task",
|
||||
"role": "478 pontos + 52 blendshapes (MediaPipe Face Landmarker, float16 v1)",
|
||||
"url": "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
|
||||
"sha256": "64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff",
|
||||
"size": 3758596,
|
||||
"license": "Apache-2.0",
|
||||
"source": "Google MediaPipe (caminho versionado float16/1)"
|
||||
},
|
||||
{
|
||||
"id": "osf_landmarks",
|
||||
"file": "osf_lm_model3_opt.onnx",
|
||||
"role": "plano B: 66 pontos (OpenSeeFace modelo 3), sem blendshapes",
|
||||
"url": "https://raw.githubusercontent.com/emilianavt/OpenSeeFace/50c09741897010faad721a218b2bbe14ecad6251/models/lm_model3_opt.onnx",
|
||||
"sha256": "5aa0ab2594acaf2e1d3916a8de592cffeb1f1a7a7f778cad2f37948bff6549d1",
|
||||
"size": 13500226,
|
||||
"license": "BSD-2-Clause",
|
||||
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
|
||||
},
|
||||
{
|
||||
"id": "osf_detector",
|
||||
"file": "osf_mnv3_detection_opt.onnx",
|
||||
"role": "plano B: detector de rosto do OpenSeeFace (224×224)",
|
||||
"url": "https://raw.githubusercontent.com/emilianavt/OpenSeeFace/50c09741897010faad721a218b2bbe14ecad6251/models/mnv3_detection_opt.onnx",
|
||||
"sha256": "0e8e4806766d85ab067a52c7af0dcb59eb7f9dfe580b44f20a8e6ab712d89809",
|
||||
"size": 568302,
|
||||
"license": "BSD-2-Clause",
|
||||
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
[pytest]
|
||||
testpaths = tests
|
||||
addopts = -q -p no:cacheprovider
|
||||
@@ -0,0 +1,2 @@
|
||||
-r requirements.txt
|
||||
pytest==9.1.1
|
||||
@@ -0,0 +1,17 @@
|
||||
# Serviço Clipador do CenaForge (cortes de live). Versões fixas; suba com teste.
|
||||
fastapi==0.159.1
|
||||
uvicorn==0.54.0
|
||||
pydantic==2.14.1
|
||||
httpx==0.28.1
|
||||
# Captura de live/VOD (Twitch, YouTube, Kick). O executável streamlink.exe fica em clipper/.venv/Scripts.
|
||||
streamlink==8.6.3
|
||||
# Chat da Kick (websocket do Pusher)
|
||||
websockets==17.4
|
||||
# Rastreio de reação (câmera + rosto). Bancada em doc/FACE_BAKEOFF.md; pesos em clipper/models.lock.json.
|
||||
# O MediaPipe já traz o OpenCV (opencv-contrib-python, com cv2.FaceDetectorYN para o YuNet).
|
||||
# NÃO instale opencv-python-headless junto: os dois brigam pelo mesmo módulo cv2.
|
||||
mediapipe==1.2.3
|
||||
opencv-contrib-python==5.0.0.93
|
||||
numpy==2.5.5
|
||||
# Plano B (OpenSeeFace só pelos .onnx, BSD-2) — sem blendshapes; fica instalado para o face.py.
|
||||
onnxruntime==1.32.0
|
||||
@@ -0,0 +1,264 @@
|
||||
"""Qualidade de gravação (`capture.quality`), escolha do stream no Streamlink, resolução gravada de fato, busca
|
||||
exata de quadro em .ts (H.264 e HEVC) e render que atravessa blocos de resolução/codec diferentes."""
|
||||
|
||||
import json
|
||||
import shutil
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from app import capture, editor, editor_render, layout, media
|
||||
from app.db import loads
|
||||
from app.scoring import Word
|
||||
|
||||
from .test_sources_and_api import KEY, env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
FFMPEG = shutil.which("ffmpeg")
|
||||
FFPROBE = shutil.which("ffprobe")
|
||||
needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
|
||||
|
||||
|
||||
def auth():
|
||||
return {"X-Service-Key": KEY}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- configuração (camadas e validação)
|
||||
def test_capture_defaults_to_best_and_layers_field_by_field():
|
||||
assert layout.merge()["capture"] == {"quality": "best"}
|
||||
assert layout.merge({"capture": {"quality": "720p"}})["capture"]["quality"] == "720p"
|
||||
# canal 720p, sessão 1080p: a sessão vence
|
||||
assert layout.merge({"capture": {"quality": "720p"}}, {"capture": {"quality": "1080p"}})["capture"]["quality"] == "1080p"
|
||||
# configuração antiga (sem o grupo) segue o padrão
|
||||
assert layout.merge({"layout": {"mode": "blur"}})["capture"]["quality"] == "best"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
|
||||
def test_capture_validate_accepts_each_quality(quality):
|
||||
assert layout.validate({"capture": {"quality": quality}}) == {"capture": {"quality": quality}}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bad", [{"capture": {"quality": "4k"}}, {"capture": {"quality": "720p60"}},
|
||||
{"capture": "best"}, {"capture": {"quality": None}}])
|
||||
def test_capture_validate_rejects_unknown(bad):
|
||||
with pytest.raises(layout.LayoutError):
|
||||
layout.validate(bad)
|
||||
|
||||
|
||||
def test_capture_options_match_the_contract():
|
||||
assert [o["id"] for o in capture.OPTIONS] == list(capture.QUALITIES) == list(layout.CAPTURE_QUALITIES)
|
||||
for option in capture.OPTIONS:
|
||||
assert option["label"] and option["hint"] and option["gbPerHour"] > 0
|
||||
assert option["maxHeight"] == capture.CEILING_HEIGHT.get(option["id"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- argumentos do Streamlink
|
||||
@pytest.mark.parametrize("platform", ["twitch", "kick", "youtube"])
|
||||
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
|
||||
def test_stream_choice_per_option_and_platform(platform, quality):
|
||||
choice = capture.stream_choice(quality, platform)
|
||||
opts = list(choice.options)
|
||||
hevc = platform == "twitch" and quality in ("best", "1440p")
|
||||
assert ("--twitch-supported-codecs" in opts) == hevc
|
||||
if hevc:
|
||||
assert opts[opts.index("--twitch-supported-codecs") + 1] == "h264,h265" # sem av1: sem libdav1d no FFmpeg
|
||||
if quality == "best":
|
||||
assert choice.streams == "best" and "--stream-sorting-excludes" not in opts
|
||||
else:
|
||||
assert opts[opts.index("--stream-sorting-excludes") + 1] == f">{quality}60"
|
||||
assert choice.streams == "best,worst-unfiltered" # reserva: nunca falha por causa do teto
|
||||
url = "https://www.twitch.tv/x"
|
||||
assert choice.args(url)[-2:] == [url, choice.streams]
|
||||
|
||||
|
||||
def test_unknown_quality_falls_back_to_best():
|
||||
assert capture.stream_choice("4k", "kick") == capture.stream_choice("best", "kick")
|
||||
|
||||
|
||||
# Nomes medidos com `streamlink --json` (17/11/2026). O 2K da Twitch não estava no ar: lista do mesmo formato.
|
||||
TWITCH = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60"]
|
||||
TWITCH_PORTRAIT = TWITCH + ["284p30_portrait", "640p30_portrait", "852p30_portrait", "1280p60_portrait", "1920p60_portrait"]
|
||||
TWITCH_936 = ["audio_only", "160p30", "360p30", "480p30", "720p60", "936p60"]
|
||||
TWITCH_30 = ["audio_only", "160p30", "360p30", "480p30", "720p30", "1080p"]
|
||||
TWITCH_2K = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60", "1440p60"]
|
||||
KICK = ["160p", "360p", "480p", "720p60", "1080p60"]
|
||||
YOUTUBE = ["144p", "240p", "360p", "480p", "720p", "1080p"]
|
||||
YOUTUBE_60 = ["144p", "240p", "360p", "480p", "720p60", "1080p60"]
|
||||
|
||||
|
||||
def _pick(names: list[str], choice: capture.StreamChoice) -> str | None:
|
||||
"""Mesma escolha da CLI (1º nome da lista que existir), com o `Plugin.streams` de verdade do Streamlink."""
|
||||
from streamlink import Streamlink
|
||||
from streamlink.plugin import Plugin
|
||||
from streamlink.stream.http import HTTPStream
|
||||
|
||||
class Fake(Plugin):
|
||||
def _get_streams(self):
|
||||
return {n: HTTPStream(self.session, f"https://e.invalid/{n}") for n in names}
|
||||
|
||||
opts = list(choice.options)
|
||||
excludes = opts[opts.index("--stream-sorting-excludes") + 1].split(",") if "--stream-sorting-excludes" in opts else None
|
||||
streams = Fake(Streamlink(), "https://e.invalid/").streams(sorting_excludes=excludes)
|
||||
name = next((n for n in choice.streams.split(",") if n in streams), None)
|
||||
return streams[name].url.rsplit("/", 1)[1] if name else None
|
||||
|
||||
|
||||
@pytest.mark.parametrize("names,platform,expected", [
|
||||
(TWITCH, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
|
||||
(TWITCH_PORTRAIT, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
|
||||
(TWITCH_936, "twitch", {"best": "936p60", "1440p": "936p60", "1080p": "936p60", "720p": "720p60", "480p": "480p30"}),
|
||||
(TWITCH_30, "twitch", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p30", "480p": "480p30"}),
|
||||
(TWITCH_2K, "twitch", {"best": "1440p60", "1440p": "1440p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
|
||||
(KICK, "kick", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
|
||||
(YOUTUBE, "youtube", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p", "480p": "480p"}),
|
||||
(YOUTUBE_60, "youtube", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
|
||||
])
|
||||
def test_preference_picks_largest_under_the_ceiling(names, platform, expected):
|
||||
"""Medido nas lives reais com os mesmos argumentos (skipnho, kagura0mea, hpduketv, hotrodd, westcol): mesmo
|
||||
resultado. Variantes verticais (`*_portrait`) e `audio_only` nunca são escolhidas."""
|
||||
assert {q: _pick(names, capture.stream_choice(q, platform)) for q in capture.QUALITIES} == expected
|
||||
|
||||
|
||||
def test_ceiling_with_nothing_below_takes_the_closest_above():
|
||||
assert _pick(["audio_only", "1080p60"], capture.stream_choice("480p", "twitch")) == "1080p60"
|
||||
assert _pick(["720p60", "1080p60"], capture.stream_choice("480p", "kick")) == "720p60"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- resolução gravada de fato
|
||||
def _make_ts(path: Path, size: str, seconds: float, codec: str = "libx264", rate: int = 60, lum: str | None = None) -> Path:
|
||||
"""Bloco .ts sintético com GOP de 2 s (como a Twitch). `lum` = expressão do brilho no tempo (geq)."""
|
||||
src = f"color=c=gray:s={size}:r={rate}:d={seconds}" + (f",geq=lum='{lum}':cb=128:cr=128" if lum else "")
|
||||
codec_args = ["-c:v", codec, "-g", str(2 * rate), "-bf", "0"]
|
||||
if codec == "libx265":
|
||||
codec_args += ["-x265-params", f"keyint={2 * rate}:min-keyint={2 * rate}:open-gop=0:bframes=0:log-level=error"]
|
||||
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", src, "-f", "lavfi", "-i",
|
||||
f"sine=frequency=440:sample_rate=48000:duration={seconds}", *codec_args, "-pix_fmt", "yuv420p",
|
||||
"-c:a", "aac", "-shortest", "-f", "mpegts", str(path)], check=True, capture_output=True)
|
||||
return path
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_probe_block_reads_resolution_fps_codec(tmp_path):
|
||||
info = capture.probe_block(FFPROBE, _make_ts(tmp_path / "a.ts", "320x180", 2))
|
||||
assert (info["width"], info["height"], info["fps"], info["codec"]) == (320, 180, 60, "h264")
|
||||
assert info["kbps"] and info["gbPerHour"] > 0
|
||||
|
||||
|
||||
def test_record_run_keeps_runs_and_flags_mixed_resolution():
|
||||
p1 = {"width": 1920, "height": 1080, "fps": 60, "codec": "h264", "kbps": 8000, "gbPerHour": 3.6}
|
||||
first = capture.record_run(None, "best", 0, p1, "t1")
|
||||
assert first["width"] == 1920 and first["quality"] == "best" and first["mixed"] is False and len(first["runs"]) == 1
|
||||
same = capture.record_run(first, "best", 40, p1, "t2")
|
||||
assert same["mixed"] is False and [r["fromIdx"] for r in same["runs"]] == [0, 40]
|
||||
p2 = {**p1, "width": 1280, "height": 720}
|
||||
mixed = capture.record_run(same, "720p", 80, p2, "t3")
|
||||
assert mixed["height"] == 720 and mixed["fromIdx"] == 80 and mixed["mixed"] is True
|
||||
assert capture.label(mixed) == "1280×720 · 60 qps"
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_capture_records_real_resolution_on_first_block(env, tmp_path, monkeypatch): # noqa: F811
|
||||
from dataclasses import replace
|
||||
|
||||
from app.sources import parse_source
|
||||
from app.worker import Capture
|
||||
|
||||
client, engine = env
|
||||
sid = seed_session(engine, duration=60)
|
||||
engine.db.run("DELETE FROM segments WHERE session_id = ?", sid)
|
||||
engine.settings = replace(engine.settings, ffprobe=FFPROBE)
|
||||
work = tmp_path / "cap"
|
||||
work.mkdir()
|
||||
_make_ts(work / "seg_00000.ts", "640x360", 2)
|
||||
(work / "segments.csv").write_text("seg_00000.ts,0.000000,2.000000\n", encoding="utf-8")
|
||||
cap = Capture(engine, sid, parse_source("https://www.twitch.tv/alanzoka"), work)
|
||||
cap.quality = "1440p"
|
||||
import app.worker as worker_module
|
||||
monkeypatch.setattr(worker_module, "rel", lambda path: path.as_posix()) # bloco fora do repositório (tmp)
|
||||
assert cap._collect(work / "segments.csv", 0) == 1
|
||||
info = loads(engine.db.get("SELECT capture_json FROM sessions WHERE id = ?", sid)["capture_json"], None)
|
||||
assert (info["quality"], info["width"], info["height"], info["fps"], info["fromIdx"]) == ("1440p", 640, 360, 60, 0)
|
||||
view = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
|
||||
assert view["capture"]["width"] == 640 and view["capture"]["mixed"] is False
|
||||
|
||||
|
||||
def test_session_without_capture_info_reports_none(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine, duration=60)
|
||||
assert client.get(f"/v1/sessions/{sid}", headers=auth()).json()["capture"] is None
|
||||
|
||||
|
||||
def test_engine_quality_follows_channel_then_session(env): # noqa: F811
|
||||
client, engine = env
|
||||
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
|
||||
sid = seed_session(engine, duration=60)
|
||||
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
|
||||
assert engine.capture_quality(sid) == "best" # padrão novo
|
||||
r = client.put("/v1/channels/twitch-alanzoka/settings", json={"capture": {"quality": "720p"}}, headers=auth())
|
||||
assert r.status_code == 200 and r.json()["effective"]["capture"]["quality"] == "720p"
|
||||
assert engine.capture_quality(sid) == "720p"
|
||||
r = client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "1080p"}}, headers=auth())
|
||||
assert r.json()["effective"]["capture"]["quality"] == "1080p"
|
||||
assert engine.capture_quality(sid) == "1080p"
|
||||
assert client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "8k"}}, headers=auth()).status_code == 400
|
||||
|
||||
|
||||
def test_settings_route_lists_capture_qualities(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine, duration=60)
|
||||
body = client.get(f"/v1/sessions/{sid}/settings", headers=auth()).json()
|
||||
assert [o["id"] for o in body["captureQualities"]] == list(capture.QUALITIES)
|
||||
assert body["defaults"]["capture"] == {"quality": "best"}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- busca exata de quadro em .ts
|
||||
@needs_ffmpeg
|
||||
@pytest.mark.parametrize("codec", ["libx264", "libx265"])
|
||||
def test_grab_frame_is_exact_in_ts(tmp_path, codec):
|
||||
"""Antes: `-ss` antes do `-i` num .ts dava o PRÓXIMO quadro-chave no H.264 e um quadro CINZA no HEVC."""
|
||||
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
|
||||
capture_output=True, text=True).stdout:
|
||||
pytest.skip("FFmpeg sem libx265")
|
||||
ts = _make_ts(tmp_path / "b.ts", "160x96", 12, codec=codec, rate=30, lum="min(235,16+T*18)")
|
||||
for t in (3.0, 7.5, 9.3):
|
||||
out = media.grab_frame(FFMPEG, [(ts, 0.0, 12.0)], t, tmp_path / f"f{t}.png", width=0)
|
||||
raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(out), "-f", "rawvideo", "-pix_fmt", "gray", "-"],
|
||||
capture_output=True, check=True).stdout
|
||||
mean = sum(raw) / len(raw)
|
||||
expected = t * 18 * 255 / 219 # Y de faixa limitada (16 + 18·t) → cinza de faixa cheia
|
||||
assert abs(mean - expected) < 6, (t, mean, expected) # 6 ≈ 0,3 s; o próximo quadro-chave daria até 42
|
||||
|
||||
|
||||
def test_seek_args_prerolls_and_selects_absolute_time():
|
||||
assert media.seek_args(10.0) == (["-ss", "6.000", "-copyts", "-start_at_zero"], "select='gte(t,10.000)'")
|
||||
assert media.seek_args(1.5) == (["-ss", "0.000", "-copyts", "-start_at_zero"], "select='gte(t,1.500)'")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- render que atravessa a troca de resolução
|
||||
@needs_ffmpeg
|
||||
@pytest.mark.parametrize("second", [("640x360", "libx264"), ("960x540", "libx265")])
|
||||
def test_render_across_resolution_change_keeps_whole_video(tmp_path, second):
|
||||
"""Retomada em outra qualidade (ou fonte que muda de resolução). Antes o vídeo parava na emenda (corte de 35 s
|
||||
com 20 s de vídeo; 15 s na troca H.264 → HEVC)."""
|
||||
size, codec = second
|
||||
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
|
||||
capture_output=True, text=True).stdout:
|
||||
pytest.skip("FFmpeg sem libx265")
|
||||
a = _make_ts(tmp_path / "seg_00000.ts", "320x180", 4)
|
||||
b = _make_ts(tmp_path / "seg_00001.ts", size, 4, codec=codec)
|
||||
segs = [(a, 0.0, 4.0), (b, 4.0, 8.0)]
|
||||
same, created = editor_render.uniform_segments(FFMPEG, FFPROBE, [(a, 0.0, 4.0), (a, 4.0, 8.0)], tmp_path, "x")
|
||||
assert created is None and same == [(a, 0.0, 4.0), (a, 4.0, 8.0)] # blocos iguais: caminho de sempre
|
||||
clip = {"session_id": 1, "start_s": 1.0, "end_s": 7.0, "peak_s": 4.0, "title": "Emenda"}
|
||||
project = editor.validate_project(editor.default_project(clip, [Word(1.2, 1.5, "oi")], 8.0), session_id=1,
|
||||
session_duration=8.0, repo_root=tmp_path, tts_dir=tmp_path, assets_dir=tmp_path)
|
||||
project["cover"]["enabled"] = False
|
||||
out = tmp_path / "clip.mp4"
|
||||
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], segs, project,
|
||||
layout.merge(), "canal", out, tmp_path)
|
||||
streams = json.loads(subprocess.run([FFPROBE, "-v", "error", "-select_streams", "v", "-show_entries",
|
||||
"stream=duration,width,height", "-of", "json", str(out)],
|
||||
capture_output=True, text=True, check=True).stdout)["streams"][0]
|
||||
assert (streams["width"], streams["height"]) == (1080, 1920)
|
||||
assert float(streams["duration"]) == pytest.approx(6.0, abs=0.15)
|
||||
assert not list(tmp_path.glob("*.uniform.mkv")) # intermediário apagado
|
||||
@@ -0,0 +1,291 @@
|
||||
"""Apagar cortes (um, vários, por aba): regras de estado, arquivos só dentro das pastas do Clipador e a marca que
|
||||
impede a IA de recriar o momento apagado."""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
import app.clip_delete as clip_delete
|
||||
import app.worker as worker_module
|
||||
from app.scoring import Moment
|
||||
|
||||
from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
|
||||
def add_clip(engine, sid, cid, status, peak=100.0, start=90.0, end=150.0, source="chat", reasons=None):
|
||||
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, reasons_json, status, title, "
|
||||
"created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, ?, ?, ?, 't', 'x', ?)",
|
||||
cid, sid, peak, start, end, source, json.dumps(reasons or {}), status, worker_module.now())
|
||||
|
||||
|
||||
def touch(path: Path, data: bytes = b"x") -> Path:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(data)
|
||||
return path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def repo(env, tmp_path, monkeypatch): # noqa: F811
|
||||
"""REPO_ROOT = tmp_path: os caminhos do banco (relativos à raiz) caem na pasta do teste."""
|
||||
monkeypatch.setattr(clip_delete, "REPO_ROOT", tmp_path)
|
||||
monkeypatch.setattr(worker_module, "REPO_ROOT", tmp_path)
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET dir = ? WHERE id = ?", f"data/sessions/{sid}", sid)
|
||||
return client, engine, sid, tmp_path
|
||||
|
||||
|
||||
def clip_files(root: Path, sid: int, cid: int) -> dict[str, Path]:
|
||||
out = root / "clips" / str(sid)
|
||||
return {
|
||||
"mp4": touch(out / f"clip-{cid}.mp4"), "jpg": touch(out / f"clip-{cid}.jpg"),
|
||||
"cover": touch(out / f"clip-{cid}-cover.jpg"), "ass": touch(out / f"clip-{cid}.ass"),
|
||||
"tmp": touch(out / f"clip-{cid}.tmp.mp4"), "proxy": touch(out / f"edit-{cid}" / "proxy-1000-2000.mp4"),
|
||||
"tts": touch(out / f"edit-{cid}" / "tts-abcdef123456.wav"), "nested": touch(out / f"edit-{cid}" / "sub" / "a.json"),
|
||||
"frame": touch(root / "data" / "sessions" / str(sid) / "frames" / f"clip{cid}-120.jpg"),
|
||||
}
|
||||
|
||||
|
||||
def set_files(engine, cid: int, sid: int, cover: bool = True) -> None:
|
||||
engine.db.run("UPDATE clips SET file = ?, thumb = ? WHERE id = ?", f"clips/{sid}/clip-{cid}.mp4", f"clips/{sid}/clip-{cid}.jpg", cid)
|
||||
engine.db.run("INSERT INTO edits (clip_id, project_json, rev, cover, created_at, updated_at) VALUES (?, '{}', 1, ?, 'x', 'x')",
|
||||
cid, f"clips/{sid}/clip-{cid}-cover.jpg" if cover else None)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- um corte
|
||||
def test_delete_one_removes_row_edit_and_all_files(repo):
|
||||
client, engine, sid, root = repo
|
||||
add_clip(engine, sid, 1, "ready")
|
||||
add_clip(engine, sid, 12, "ready", peak=400, start=380, end=450) # vizinho com id que começa igual
|
||||
files = clip_files(root, sid, 1)
|
||||
neighbor = clip_files(root, sid, 12)
|
||||
set_files(engine, 1, sid)
|
||||
session_file = touch(root / "data" / "sessions" / str(sid) / "seg_00001.ts")
|
||||
r = client.delete("/v1/clips/1", headers=auth())
|
||||
assert r.status_code == 200, r.text
|
||||
body = r.json()
|
||||
assert body["id"] == 1 and body["status"] == "ready" and body["left"] == []
|
||||
assert body["removedFiles"] >= len(files)
|
||||
assert not any(p.exists() for p in files.values())
|
||||
assert not (root / "clips" / str(sid) / "edit-1").exists()
|
||||
assert all(p.exists() for p in neighbor.values()) and session_file.exists() # nada do corte 12 nem da gravação
|
||||
assert engine.db.get("SELECT 1 FROM clips WHERE id = 1") is None
|
||||
assert engine.db.get("SELECT 1 FROM edits WHERE clip_id = 1") is None
|
||||
assert client.get("/v1/clips/1", headers=auth()).status_code == 404
|
||||
mark = engine.db.get("SELECT * FROM deleted_clips WHERE clip_id = 1")
|
||||
assert mark["session_id"] == sid and mark["peak_s"] == 100 and mark["status"] == "ready"
|
||||
|
||||
|
||||
def test_nonexistent_id_is_404_and_listed_as_not_found(repo):
|
||||
client, engine, sid, _root = repo
|
||||
r = client.delete("/v1/clips/999", headers=auth())
|
||||
assert r.status_code == 404 and r.json()["code"] == "not_found"
|
||||
r = client.post("/v1/clips/delete", json={"ids": [999]}, headers=auth())
|
||||
assert r.status_code == 200 and r.json()["failed"] == [{"id": 999, "code": "not_found", "reason": "corte não encontrado"}]
|
||||
|
||||
|
||||
def test_rendering_and_candidate_are_refused(repo):
|
||||
client, engine, sid, root = repo
|
||||
add_clip(engine, sid, 1, "rendering")
|
||||
add_clip(engine, sid, 2, "candidate", peak=300, start=280, end=340)
|
||||
add_clip(engine, sid, 3, "pending", peak=500, start=480, end=540)
|
||||
mp4 = touch(root / "clips" / str(sid) / "clip-1.mp4")
|
||||
r = client.delete("/v1/clips/1", headers=auth())
|
||||
assert r.status_code == 409 and r.json()["code"] == "busy_rendering" and "renderizando" in r.json()["error"]
|
||||
assert client.delete("/v1/clips/2", headers=auth()).json()["code"] == "busy_candidate"
|
||||
engine._rendering.add(3) # o motor acabou de pegar o pendente para renderizar
|
||||
assert client.delete("/v1/clips/3", headers=auth()).json()["code"] == "busy_rendering"
|
||||
assert mp4.exists() and engine.db.get("SELECT COUNT(*) AS n FROM clips")["n"] == 3
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM deleted_clips")["n"] == 0
|
||||
|
||||
|
||||
def test_published_needs_explicit_confirmation(repo):
|
||||
client, engine, sid, _root = repo
|
||||
add_clip(engine, sid, 1, "published")
|
||||
r = client.delete("/v1/clips/1", headers=auth())
|
||||
assert r.status_code == 409 and r.json()["code"] == "published"
|
||||
assert client.post("/v1/clips/delete", json={"ids": [1]}, headers=auth()).json()["failed"][0]["code"] == "published"
|
||||
assert client.delete("/v1/clips/1?confirmPublished=true", headers=auth()).status_code == 200
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- vários e por aba
|
||||
def test_delete_many_reports_what_was_and_was_not_deleted(repo):
|
||||
client, engine, sid, root = repo
|
||||
for cid, st, peak in ((1, "discarded", 100), (2, "ready", 200), (3, "rendering", 300), (4, "rejected", 400), (5, "error", 500)):
|
||||
add_clip(engine, sid, cid, st, peak=peak, start=peak - 10, end=peak + 50)
|
||||
touch(root / "clips" / str(sid) / "clip-2.mp4")
|
||||
r = client.post("/v1/clips/delete", json={"ids": [1, 2, 3, 4, 2, 999, 5]}, headers=auth())
|
||||
assert r.status_code == 200, r.text
|
||||
body = r.json()
|
||||
assert body["requested"] == 6 and body["remaining"] == 0 # o 2 repetido conta uma vez
|
||||
assert [d["id"] for d in body["deleted"]] == [1, 2, 4, 5]
|
||||
assert {f["id"]: f["code"] for f in body["failed"]} == {3: "busy_rendering", 999: "not_found"}
|
||||
assert [r["id"] for r in engine.db.all("SELECT id FROM clips")] == [3]
|
||||
assert not (root / "clips" / str(sid) / "clip-2.mp4").exists()
|
||||
|
||||
|
||||
def test_delete_whole_tab_respects_session_filter(repo):
|
||||
client, engine, sid, _root = repo
|
||||
other = seed_session(engine)
|
||||
add_clip(engine, sid, 1, "discarded", peak=100)
|
||||
add_clip(engine, sid, 2, "discarded", peak=200)
|
||||
add_clip(engine, sid, 3, "ready", peak=300)
|
||||
add_clip(engine, other, 4, "discarded", peak=100)
|
||||
r = client.post("/v1/clips/delete", json={"statuses": ["discarded"], "sessionId": sid}, headers=auth())
|
||||
body = r.json()
|
||||
assert sorted(d["id"] for d in body["deleted"]) == [1, 2] and body["failed"] == []
|
||||
assert sorted(r["id"] for r in engine.db.all("SELECT id FROM clips")) == [3, 4]
|
||||
# Sem sessão: todas as sessões, inclusive "para aprovar".
|
||||
r = client.post("/v1/clips/delete", json={"statuses": ["ready", "discarded"]}, headers=auth())
|
||||
assert sorted(d["id"] for d in r.json()["deleted"]) == [3, 4]
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM clips")["n"] == 0
|
||||
|
||||
|
||||
def test_batch_validation_and_limit(repo, monkeypatch):
|
||||
client, engine, sid, _root = repo
|
||||
assert client.post("/v1/clips/delete", json={}, headers=auth()).status_code == 400
|
||||
assert client.post("/v1/clips/delete", json={"ids": [1], "statuses": ["ready"]}, headers=auth()).status_code == 400
|
||||
assert client.post("/v1/clips/delete", json={"ids": [1], "sessionId": sid}, headers=auth()).status_code == 400
|
||||
assert client.post("/v1/clips/delete", json={"ids": list(range(1, 502))}, headers=auth()).status_code == 422
|
||||
assert client.post("/v1/clips/delete", json={"statuses": ["nada"]}, headers=auth()).status_code == 422
|
||||
for cid in range(1, 6):
|
||||
add_clip(engine, sid, cid, "discarded", peak=cid * 100)
|
||||
monkeypatch.setattr(clip_delete, "MAX_BATCH", 3)
|
||||
ids, remaining = clip_delete.select_ids(engine.db, None, ["discarded"], clip_delete.MAX_BATCH)
|
||||
assert ids == [5, 4, 3] and remaining == 2
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- arquivos fora da pasta
|
||||
def test_files_outside_clipper_folders_are_never_touched(repo):
|
||||
client, engine, sid, root = repo
|
||||
outside = touch(root / "outside" / "importante.mp4", b"nao apague")
|
||||
add_clip(engine, sid, 1, "ready")
|
||||
engine.db.run("UPDATE clips SET file = ?, thumb = ? WHERE id = 1", "outside/importante.mp4", "../fora.jpg")
|
||||
fora = touch(root.parent / "fora.jpg", b"tambem nao")
|
||||
try:
|
||||
body = client.delete("/v1/clips/1", headers=auth()).json()
|
||||
assert outside.read_bytes() == b"nao apague" and fora.read_bytes() == b"tambem nao"
|
||||
assert {x["file"] for x in body["left"]} >= {"outside/importante.mp4"}
|
||||
assert all("fora das pastas" in x["reason"] for x in body["left"])
|
||||
finally:
|
||||
fora.unlink(missing_ok=True)
|
||||
|
||||
|
||||
@pytest.mark.skipif(sys.platform != "win32", reason="junção é do Windows")
|
||||
def test_junction_inside_edit_folder_is_not_followed(repo):
|
||||
import _winapi
|
||||
|
||||
client, engine, sid, root = repo
|
||||
target = root / "outside" / "pasta"
|
||||
keep = touch(target / "nao-apague.txt", b"alvo")
|
||||
add_clip(engine, sid, 1, "ready")
|
||||
edit = root / "clips" / str(sid) / "edit-1"
|
||||
touch(edit / "proxy-1-2.mp4")
|
||||
_winapi.CreateJunction(str(target), str(edit / "link"))
|
||||
# A própria pasta da sessão nos cortes trocada por junção para fora: nada dela é apagado.
|
||||
other = seed_session(engine)
|
||||
elsewhere = root / "outside" / "sessao"
|
||||
keep2 = touch(elsewhere / "clip-2.mp4", b"alvo2")
|
||||
(root / "clips").mkdir(exist_ok=True)
|
||||
_winapi.CreateJunction(str(elsewhere), str(root / "clips" / str(other)))
|
||||
add_clip(engine, other, 2, "ready")
|
||||
body = client.delete("/v1/clips/1", headers=auth()).json()
|
||||
assert keep.read_bytes() == b"alvo" and not edit.exists() and body["left"] == []
|
||||
body = client.post("/v1/clips/delete", json={"ids": [2]}, headers=auth()).json()
|
||||
assert keep2.read_bytes() == b"alvo2" and body["deleted"][0]["left"][0]["reason"] == "fora das pastas do Clipador"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- o momento apagado não volta
|
||||
@pytest.mark.parametrize("session_status", ["recording", "stopped"])
|
||||
def test_deleted_discard_is_not_recreated(repo, monkeypatch, session_status):
|
||||
"""Ao vivo (passada da janela recente) e no fim (passada final da sessão inteira): o pico apagado não vira
|
||||
candidato de novo, nem com o juiz tendo recuado o trecho para longe do pico."""
|
||||
client, engine, sid, _root = repo
|
||||
engine.db.run("UPDATE sessions SET status = ?, duration_s = 1300 WHERE id = ?", session_status, sid)
|
||||
moment = Moment(peak_s=1149.0, start_s=1095.0, end_s=1155.0, score=5.0, source="chat", reasons={"onsetS": 1142})
|
||||
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [moment])
|
||||
analyzed = {"until": 1300.0}
|
||||
real = engine.load_timeline
|
||||
monkeypatch.setattr(engine, "load_timeline", lambda *a, **k: {**real(*a, **k), "duration": 1300.0,
|
||||
"analyzedUntil": analyzed["until"]})
|
||||
monkeypatch.setattr(engine.face, "for_scoring", lambda *a, **k: (None, 0.0))
|
||||
session = lambda: engine.db.get("SELECT * FROM sessions WHERE id = ?", sid) # noqa: E731
|
||||
assert engine.find_new_clips(session()) == 1
|
||||
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
|
||||
engine.db.run("UPDATE clips SET start_s = 1012, end_s = 1100, status = 'discarded' WHERE id = ?", clip["id"])
|
||||
assert client.delete(f"/v1/clips/{clip['id']}", headers=auth()).status_code == 200
|
||||
for _ in range(3):
|
||||
assert engine.find_new_clips(session()) == 0
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ?", sid)["n"] == 0
|
||||
# Outro momento, longe do apagado, continua nascendo normalmente.
|
||||
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [
|
||||
Moment(peak_s=400.0, start_s=340.0, end_s=405.0, score=5.0, source="chat", reasons={})])
|
||||
assert engine.find_new_clips(session()) == 1
|
||||
|
||||
|
||||
def test_judge_backtrack_onto_deleted_kept_or_rejected_clip_is_vetoed(repo):
|
||||
"""O juiz recua um candidato novo para cima de um corte que você apagou: pronto/rejeitado apagado veta (como
|
||||
vetava enquanto existia); descartado pela IA apagado não veta (como não vetava)."""
|
||||
from .test_render_and_duplicates import RecuoJudge
|
||||
|
||||
_client, engine, sid, _root = repo
|
||||
engine.db.run("UPDATE sessions SET duration_s = 1300 WHERE id = ?", sid)
|
||||
add_clip(engine, sid, 9, "rejected", peak=1084, start=1045, end=1100)
|
||||
add_clip(engine, sid, 10, "discarded", peak=600, start=560, end=620)
|
||||
clip_delete.delete_clip(engine, 9)
|
||||
clip_delete.delete_clip(engine, 10)
|
||||
engine.judge = RecuoJudge(back_to=1012)
|
||||
add_clip(engine, sid, 42, "candidate", peak=1149, start=1095, end=1155)
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 42"))
|
||||
row = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 42")
|
||||
judge = json.loads(row["judge_json"])
|
||||
assert row["status"] == "discarded" and judge["duplicateOf"] == 9 and "que você apagou" in judge["reason"]
|
||||
engine.judge = RecuoJudge(back_to=548)
|
||||
add_clip(engine, sid, 43, "candidate", peak=660, start=630, end=690)
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 43"))
|
||||
assert engine.db.get("SELECT status FROM clips WHERE id = 43")["status"] == "pending"
|
||||
|
||||
|
||||
def test_scan_does_not_propose_a_deleted_moment(repo):
|
||||
_client, engine, sid, _root = repo
|
||||
add_clip(engine, sid, 7, "discarded", peak=200, start=150, end=230, reasons={"candidateStartS": 180, "candidateEndS": 240})
|
||||
clip_delete.delete_clip(engine, 7)
|
||||
assert clip_delete.mark_spans(engine.db, sid, 0, 600) == [(150, 240, "apagado")]
|
||||
assert clip_delete.mark_spans(engine.db, sid, 300, 600) == []
|
||||
dur = {"minS": 60, "maxS": 90, "backtrackS": 120}
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
existing = clip_delete.mark_spans(engine.db, sid, 0, 600)
|
||||
assert engine.intel._insert_scan_moment(session, {"start_s": 160, "end_s": 230, "score": 8}, 0, 600, dur, existing) is False
|
||||
assert engine.intel._insert_scan_moment(session, {"start_s": 400, "end_s": 470, "score": 8}, 0, 600, dur, existing) is True
|
||||
|
||||
|
||||
def test_render_skips_a_clip_deleted_after_the_queue_listed_it(repo, monkeypatch):
|
||||
_client, engine, sid, root = repo
|
||||
add_clip(engine, sid, 1, "pending")
|
||||
stale = engine.db.get("SELECT * FROM clips WHERE id = 1") # a fila leu a lista…
|
||||
clip_delete.delete_clip(engine, 1) # …e o corte foi apagado antes de o render começar
|
||||
called = []
|
||||
monkeypatch.setattr(engine, "_render_clip", lambda clip: called.append(clip["id"]))
|
||||
engine.render_clip(stale)
|
||||
assert called == [] and engine._rendering == set()
|
||||
assert not (root / "clips" / str(sid) / "clip-1.mp4").exists()
|
||||
|
||||
|
||||
def test_session_finishes_and_learning_stays_after_delete(repo):
|
||||
client, engine, sid, _root = repo
|
||||
engine.db.run("UPDATE sessions SET status = 'processing' WHERE id = ?", sid)
|
||||
engine.db.run("INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES ('k', 'KEKW', 'twitch', 3, 0.6, 'x', 'x')")
|
||||
add_clip(engine, sid, 1, "pending")
|
||||
engine.db.run("UPDATE clips SET learned = 1 WHERE id = 1")
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
engine.finish_if_done(session)
|
||||
assert engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"] == "processing" # pendente segura
|
||||
assert client.delete("/v1/clips/1", headers=auth()).status_code == 200
|
||||
engine.finish_if_done(session)
|
||||
assert engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"] == "done"
|
||||
assert engine.db.get("SELECT weight FROM emotes WHERE name = 'KEKW'")["weight"] == 0.6 # o aprendizado fica
|
||||
# Apagar a sessão leva as marcas junto.
|
||||
engine.delete_session(sid)
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM deleted_clips")["n"] == 0
|
||||
@@ -0,0 +1,281 @@
|
||||
"""Pedidos do dono de 17/11/2026: duração mínima de verdade (mínimo + 1 s em todo corte automático), gancho em tarja
|
||||
animada e fontes empacotadas para escolher."""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from app import editor, editor_render, layout
|
||||
from app.config import REPO_ROOT
|
||||
from app.judge import _clean
|
||||
from app.scoring import ChatMessage, Params, Word, find_moments, fit_length, fit_window
|
||||
|
||||
from .test_editor import KEY, api, make_project, validate # noqa: F401 - api é fixture
|
||||
from .test_scoring import burst, calm_chat
|
||||
from .test_sources_and_api import env, seed_session # noqa: F401
|
||||
|
||||
FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe")
|
||||
CFG = layout.merge()
|
||||
TARGET = layout.min_target(CFG) # 60 + 1 + 0,1
|
||||
EPS = 1e-6 # 61,1 em ponto flutuante
|
||||
HORIZONTAL = {"format": {"aspect": "horizontal"}}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 1. duração mínima
|
||||
def test_target_is_min_plus_one_second_and_never_above_max():
|
||||
assert TARGET == 61.1
|
||||
assert layout.min_target(layout.merge({"duration": {"minS": 89.5, "maxS": 90}})) == 90
|
||||
|
||||
|
||||
def test_fit_window_grows_backwards_then_forwards_and_never_invents():
|
||||
assert fit_window(100, 140, 0, 200, TARGET, 90) == (78.9, 140.0) # contexto antes
|
||||
assert fit_window(5, 30, 0, 200, TARGET, 90) == (0.0, 61.1) # começo da gravação: cresce para a frente
|
||||
assert fit_window(5, 30, 0, 40, TARGET, 90) == (0.0, 40.0) # gravação de 40 s: não inventa
|
||||
assert fit_window(0, 200, 0, 300, TARGET, 90, keep="start") == (0.0, 90.0)
|
||||
|
||||
|
||||
def test_candidate_from_heuristic_has_the_target_even_at_the_end_of_recording():
|
||||
p = Params(min_s=TARGET, max_s=90.0)
|
||||
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
|
||||
m = find_moments(600, chat, [], [], p)[0]
|
||||
assert m.end_s - m.start_s >= TARGET - EPS
|
||||
start, end = fit_length(580, 600, 595, p, 600) # pico no fim da gravação: recua o início
|
||||
assert end - start >= TARGET - EPS and end <= 600
|
||||
|
||||
|
||||
def test_judge_answer_capped_by_window_end_still_has_the_minimum():
|
||||
# O juiz pôs o início tarde demais: o fim bate em `hi`; antes saía curto (end − start < mínimo).
|
||||
v = _clean({"keep": True, "score": 8, "start_s": 1100, "end_s": 1200, "title": "t", "caption": "c", "reason": "r"},
|
||||
1095, 1155, "m", lo=975, hi=1170, min_s=TARGET, max_s=90)
|
||||
assert v.end_s == 1170 and v.end_s - v.start_s >= TARGET - EPS
|
||||
|
||||
|
||||
def test_scan_moment_has_the_minimum(env): # noqa: F811
|
||||
_client, engine = env
|
||||
sid = seed_session(engine)
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
ok = engine.intel._insert_scan_moment(session, {"start_s": 470, "end_s": 495, "score": 7, "title": "t", "reason": "r"},
|
||||
300.0, 500.0, CFG["duration"], [])
|
||||
clip = engine.db.get("SELECT start_s, end_s FROM clips WHERE session_id = ?", sid)
|
||||
assert ok and clip["end_s"] - clip["start_s"] >= TARGET - EPS and clip["end_s"] <= 500
|
||||
|
||||
|
||||
def _clip55():
|
||||
"""Caso medido (corte 55 da sessão 3): juiz 7900–7960 (60 s) e analista com a ação em 7915 → saía 46,8 s."""
|
||||
clip = {"session_id": 1, "start_s": 7900.0, "end_s": 7960.7, "peak_s": 7944.0, "title": "Pajé mão leve", "source": "chat"}
|
||||
words = [Word(7880 + i * 0.9, 7880 + i * 0.9 + 0.5, f"p{i}") for i in range(100)]
|
||||
return clip, {"action_start_s": 7915.0, "reaction_end_s": 7952.0, "hook": "Pajé mão leve"}, words
|
||||
|
||||
|
||||
def test_auto_project_never_goes_below_the_minimum():
|
||||
clip, analysis, words = _clip55()
|
||||
p = editor.auto_project(clip, analysis, words, [-20.0] * 9000, 9000.0, CFG)
|
||||
assert editor.output_duration(p["cuts"]) >= TARGET - EPS
|
||||
# silêncios quietos longos: só sai o que não derruba o corte abaixo do mínimo
|
||||
quiet = [-55.0] * 9000
|
||||
sparse = [Word(7890 + i * 6, 7890 + i * 6 + 0.4, "x") for i in range(14)]
|
||||
q = editor.auto_project({**clip, "peak_s": 7899.0}, None, sparse, quiet, 9000.0, CFG)
|
||||
assert editor.output_duration(q["cuts"]) >= TARGET - EPS
|
||||
# gravação curta demais: não inventa vídeo, registra o motivo
|
||||
r = editor.auto_project({**clip, "start_s": 5.0, "end_s": 30.0, "peak_s": 20.0}, None, [], [], 40.0, CFG)
|
||||
assert editor.output_duration(r["cuts"]) == 40.0 and any(s.startswith("curto:") for s in r["meta"]["steps"])
|
||||
# "cortar agora" (manual) é livre
|
||||
m = editor.auto_project({**clip, "source": "manual", "start_s": 7900.0, "end_s": 7930.0}, None, [], [], 9000.0, CFG)
|
||||
assert editor.output_duration(m["cuts"]) == 30.0
|
||||
|
||||
|
||||
def test_suggestion_respects_minimum_and_drops_removes_that_would_shrink_it():
|
||||
s = editor.clean_suggestion({"start_s": 1100, "end_s": 1130, "remove": [{"start_s": 1110, "end_s": 1120, "why": "x"}],
|
||||
"zooms": [], "hook": "h", "title": "t", "reason": "r"}, 1000, 1200, TARGET, 90)
|
||||
assert s["end"] - s["start"] >= TARGET - EPS and s["remove"] == []
|
||||
|
||||
|
||||
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
|
||||
def test_auto_clip_file_is_at_least_min_plus_one_second(tmp_path):
|
||||
"""Medido no arquivo (ffprobe): o projeto da IA do caso do corte 55 sai com ≥ 61 s."""
|
||||
seg = tmp_path / "seg.ts"
|
||||
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "testsrc2=size=320x180:rate=30:duration=100", "-f", "lavfi",
|
||||
"-i", "sine=frequency=440:duration=100", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
|
||||
"-c:a", "aac", "-shortest", str(seg)], check=True)
|
||||
clip = {"session_id": 1, "start_s": 30.0, "end_s": 90.7, "peak_s": 74.0, "title": "Pajé mão leve", "source": "chat"}
|
||||
analysis = {"action_start_s": 45.0, "reaction_end_s": 82.0, "hook": "Pajé mão leve"}
|
||||
data = editor.auto_project(clip, analysis, [], [-20.0] * 100, 100.0, CFG)
|
||||
p = validate(data, tmp_path, duration=100.0)
|
||||
out = tmp_path / "auto.mp4"
|
||||
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 100.0)], p, CFG,
|
||||
"twitch.tv/x", out, tmp_path)
|
||||
duration = float(subprocess.run([FFPROBE, "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(out)],
|
||||
capture_output=True, text=True, check=True).stdout)
|
||||
assert duration >= CFG["duration"]["minS"] + 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 2. gancho em tarja
|
||||
def _banner(**over):
|
||||
o = {"id": "hook", "kind": "hook", "text": "Carregando o dilera no PvP do Rob Run!", "start": 0, "end": 3, "y": 0.2,
|
||||
"size": 76, "style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": layout.HOOK_FONT, "anim": "slide"}
|
||||
o.update(over)
|
||||
return o
|
||||
|
||||
|
||||
def test_hook_config_validates_and_merges():
|
||||
assert layout.DEFAULTS["hook"]["style"] == "banner" and layout.DEFAULTS["hook"]["anim"] == "slide"
|
||||
assert layout.validate({"hook": {"style": "plain", "bg": "#123abc", "seconds": 2.5}})["hook"] == \
|
||||
{"style": "plain", "bg": "#123ABC", "seconds": 2.5}
|
||||
for bad in ({"style": "x"}, {"bg": "verde"}, {"font": "Comic Sans"}, {"anim": "spin"}, {"seconds": 20}):
|
||||
with pytest.raises(layout.LayoutError):
|
||||
layout.validate({"hook": bad})
|
||||
|
||||
|
||||
def test_banner_overlay_validation_and_old_projects_untouched(tmp_path):
|
||||
p = validate(make_project(overlays=[_banner()]), tmp_path)
|
||||
o = p["overlays"][0]
|
||||
assert (o["style"], o["bg"], o["font"], o["anim"]) == ("banner", "#00FF00", layout.HOOK_FONT, "slide")
|
||||
old = validate(make_project(), tmp_path)["overlays"][0]
|
||||
assert not {"style", "bg", "font"} & set(old) # projeto antigo: nenhum campo novo aparece
|
||||
for bad in ({"style": "neon"}, {"font": "Comic Sans"}, {"bg": "verde"}, {"anim": "spin"}):
|
||||
with pytest.raises(editor.EditError):
|
||||
validate(make_project(overlays=[_banner(**bad)]), tmp_path)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("settings", [{}, CAM := {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}, HORIZONTAL])
|
||||
def test_banner_ass_two_lines_animated_and_clear_of_captions(tmp_path, settings):
|
||||
clip = {"session_id": 1, "start_s": 10.0, "end_s": 75.0, "peak_s": 50.0, "title": "Carregando o dilera no PvP do Rob Run!",
|
||||
"source": "chat"}
|
||||
cfg = layout.merge(settings)
|
||||
data = editor.auto_project(clip, None, [Word(11, 11.4, "olha")], [], 100.0, cfg)
|
||||
hook = data["overlays"][0]
|
||||
assert hook["style"] == "banner" and hook["end"] == 3.0
|
||||
p = validate(data, tmp_path)
|
||||
ass = editor_render.build_project_ass(p, editor.effective_settings(cfg, p), "twitch.tv/x")
|
||||
band = next(line for line in ass.splitlines() if ",Bar,," in line and "\\p1" in line and "&H00FF00&" in line)
|
||||
text = next(line for line in ass.splitlines() if "CARREGANDO" in line)
|
||||
assert "\\move(" in band and "\\move(" in text and "\\blur18" in text and "\\t(90,430,\\blur0)" in text
|
||||
assert f"\\fn{layout.HOOK_FONT}" in text and text.count("\\N") <= 1 # no máximo 2 linhas, palavra inteira
|
||||
g = editor_render.banner_layout(p["overlays"][0], layout.canvas_size(cfg))
|
||||
cap_y = layout.caption_y(editor.effective_settings(cfg, p))
|
||||
size = editor.effective_settings(cfg, p)["caption"]["size"]
|
||||
assert cap_y + size < g["top"] or cap_y - size > g["top"] + g["height"] # a tarja não cobre a legenda
|
||||
assert all(len(line) <= 40 for line in g["lines"])
|
||||
|
||||
|
||||
def test_banner_shrinks_long_text_instead_of_cutting_words():
|
||||
o = _banner(text="Uma frase bem comprida que não caberia em duas linhas no tamanho cheio do gancho {\\b1}", size=120)
|
||||
g = editor_render.banner_layout(o, (1080, 1920))
|
||||
assert len(g["lines"]) <= 2 and g["size"] < 120
|
||||
assert " ".join(g["lines"]) == o["text"].upper() # nenhuma palavra cortada
|
||||
events = editor_render.banner_events(o, (1080, 1920))
|
||||
assert "{\\b1}" not in events[1][2] and "(/B1)" in events[1][2] # texto escapado
|
||||
|
||||
|
||||
def _frame(video: Path, at: float, size: tuple[int, int]) -> bytes:
|
||||
return subprocess.run([FFMPEG, "-v", "error", "-ss", f"{at:.2f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
|
||||
"-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout[: size[0] * size[1] * 3]
|
||||
|
||||
|
||||
def _green_rows(frame: bytes, w: int, h: int) -> list[int]:
|
||||
rows = []
|
||||
for y in range(0, h, 4):
|
||||
px = [frame[(y * w + x) * 3: (y * w + x) * 3 + 3] for x in range(0, w, 40)]
|
||||
if sum(1 for r, g, b in px if g > 200 and r < 80 and b < 80) > len(px) * 0.6:
|
||||
rows.append(y)
|
||||
return rows
|
||||
|
||||
|
||||
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
|
||||
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
|
||||
def test_real_render_banner(tmp_path, aspect):
|
||||
seg = tmp_path / "dark.ts"
|
||||
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "color=c=0x202060:size=640x360:rate=30:duration=6",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=6", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
|
||||
"-c:a", "aac", "-shortest", str(seg)], check=True)
|
||||
words = [{"s": 1.0 + i * 0.4, "e": 1.3 + i * 0.4, "w": w} for i, w in enumerate("tá escutando tiro não é".split())]
|
||||
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, settings={"format": {"aspect": aspect}},
|
||||
cuts=[{"start": 0, "end": 5, "mode": None}], overlays=[_banner(end=3)],
|
||||
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words},
|
||||
cover={"enabled": False, "t": 1})
|
||||
p = validate(data, tmp_path, duration=6.0)
|
||||
out = tmp_path / f"{aspect}.mp4"
|
||||
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 6.0)], p,
|
||||
layout.merge(), "twitch.tv/x", out, tmp_path)
|
||||
w, h = layout.FRAME_SIZES[aspect]
|
||||
early, settled, after = _frame(out, 0.05, (w, h)), _frame(out, 1.5, (w, h)), _frame(out, 4.0, (w, h))
|
||||
rows = _green_rows(settled, w, h)
|
||||
assert rows and abs((min(rows) + max(rows)) / 2 / h - 0.2) < 0.05 # tarja assentada perto de 20 % da altura
|
||||
assert len(_green_rows(early, w, h)) < len(rows) # no começo ela ainda está entrando
|
||||
assert _green_rows(after, w, h) == [] # depois do gancho, some
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 3. fontes empacotadas
|
||||
def test_packaged_fonts_lock_files_and_licenses():
|
||||
lock = json.loads((REPO_ROOT / "assets" / "fonts" / "fonts.lock.json").read_text(encoding="utf-8"))
|
||||
families = [e["family"] for e in lock["files"]]
|
||||
assert {"Luckiest Guy", "Bangers", "Anton", "Bebas Neue", "Poppins ExtraBold"} == set(families)
|
||||
for e in lock["files"]:
|
||||
assert hashlib.sha256((REPO_ROOT / e["path"]).read_bytes()).hexdigest() == e["sha256"]
|
||||
assert (REPO_ROOT / e["licenseFile"]).is_file() and e["license"] in ("OFL-1.1", "Apache-2.0")
|
||||
assert re.search(r"/google/fonts/[0-9a-f]{40}/", e["url"]) # URL presa a commit
|
||||
assert Path(e["path"]).parent.as_posix() == "assets/fonts" # pasta plana (fontsdir não lê subpastas)
|
||||
assert layout.font_files() == {e["family"]: e["path"] for e in lock["files"]}
|
||||
assert set(families) <= set(layout.FONTS)
|
||||
|
||||
|
||||
def test_packaged_fonts_have_portuguese_accents_and_matching_family_name():
|
||||
ttlib = pytest.importorskip("fontTools.ttLib")
|
||||
for family, path in layout.font_files().items():
|
||||
font = ttlib.TTFont(REPO_ROOT / path)
|
||||
cmap = font.getBestCmap()
|
||||
assert all(ord(c) in cmap for c in "TÁ ESCUTANDO TIRO, NÃO É? ÇÃÕÂÊÔÍÓÚÀ".replace(" ", ""))
|
||||
names = {r.nameID: r.toUnicode() for r in font["name"].names if r.platformID == 3}
|
||||
assert family == names[1] # o nome usado no ASS é o da família (ID 1) do arquivo
|
||||
|
||||
|
||||
def test_fontsdir_only_when_a_packaged_font_is_used():
|
||||
assert layout.ass_filter("a.ass", "Style: Caption,Arial Black,84") == "ass=a.ass"
|
||||
assert "fontsdir='" in layout.ass_filter("a.ass", "Style: Caption,Bangers,84")
|
||||
assert "fontsdir='" in layout.ass_filter("a.ass", "{\\fnLuckiest Guy}OI")
|
||||
|
||||
|
||||
def test_settings_route_lists_font_files(api): # noqa: F811
|
||||
client, _engine, _root = api
|
||||
body = client.get("/v1/sessions/1/settings", headers={"X-Service-Key": KEY}).json()
|
||||
assert body["fontFiles"]["Bangers"] == "assets/fonts/Bangers-Regular.ttf" and "Bangers" in body["fonts"]
|
||||
assert body["defaults"]["hook"]["style"] == "banner" and "slide" in body["hookAnims"]
|
||||
|
||||
|
||||
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
|
||||
def test_packaged_font_is_really_used_in_render(tmp_path):
|
||||
"""Mesmo texto acentuado com Bangers, com Arial Black e com uma família inexistente: Bangers sai diferente das
|
||||
duas (o libass achou o arquivo empacotado)."""
|
||||
words = [{"s": 0.0, "e": 0.9, "w": w} for w in ["TÁ"]] + [{"s": 0.95, "e": 1.9, "w": "ESCUTANDO"}]
|
||||
|
||||
def still(font: str) -> bytes:
|
||||
p = validate(make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, cuts=[{"start": 0, "end": 3, "mode": None}],
|
||||
overlays=[], captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
|
||||
"words": words}, progress={"enabled": False}, cover={"enabled": False, "t": 1}), tmp_path, duration=6.0)
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
cfg["caption"]["font"] = font
|
||||
ass = editor_render.build_project_ass(p, cfg, "")
|
||||
(tmp_path / "f.ass").write_text(ass, encoding="utf-8")
|
||||
frame = tmp_path / "f.png"
|
||||
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", "color=c=0x303030:s=1080x1920:d=1", "-filter_complex",
|
||||
f"[0:v]{layout.ass_filter('f.ass', ass)}[v]", "-map", "[v]", "-frames:v", "1", frame.name],
|
||||
cwd=tmp_path, check=True)
|
||||
return frame.read_bytes()
|
||||
|
||||
bangers, arial, missing = still("Bangers"), still("Arial Black"), still("Fonte Que Nao Existe")
|
||||
assert bangers != arial and bangers != missing
|
||||
|
||||
|
||||
def test_banner_entry_blurs_the_whole_letter_and_settles_identical():
|
||||
"""Com contorno, o blur do libass só desfoca a borda: na entrada o preenchimento vem numa camada sem contorno
|
||||
(borrada inteira, como no modelo do dono) e, do fim da entrada em diante, entra o evento assentado de sempre."""
|
||||
events = editor_render.banner_events(_banner(), (1080, 1920))
|
||||
fill, outline, settled = events[1], events[2], events[3]
|
||||
assert r"\bord0" in fill[2] and r"\blur18\t(90,430,\blur0)" in fill[2] and fill[3] == (0.0, 0.43)
|
||||
assert r"\1a&HFF&" in outline[2] and outline[0] < fill[0] # contorno sem preenchimento, por baixo
|
||||
assert settled[3] == (0.43, None) and r"\move" not in settled[2] and r"\blur" not in settled[2]
|
||||
assert r"\pos(540," in settled[2] and r"\bord8\shad4" in settled[2]
|
||||
@@ -0,0 +1,313 @@
|
||||
"""Editor de cortes: validador do projeto, contas de tempo, legenda animada (ASS), filtergraph e rotas."""
|
||||
import json
|
||||
import shutil
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app import editor, editor_render, layout
|
||||
from app.config import Settings
|
||||
from app.db import Database
|
||||
from app.main import create_app
|
||||
from app.scoring import Word
|
||||
from app.worker import Engine
|
||||
|
||||
from .test_sources_and_api import KEY, FakeJudge
|
||||
|
||||
FFMPEG = shutil.which("ffmpeg")
|
||||
|
||||
|
||||
def make_project(**over) -> dict:
|
||||
p = {
|
||||
"schema": 1, "source": {"sessionId": 1, "lo": 0, "hi": 60}, "settings": {},
|
||||
"cuts": [{"start": 10, "end": 20, "mode": None}, {"start": 25, "end": 30, "mode": "game_only"}],
|
||||
"captions": {"enabled": True, "preset": "pop", "style": {}, "emphColor": "#22E36B",
|
||||
"words": [{"s": 11, "e": 11.4, "w": "olha"}, {"s": 11.5, "e": 12, "w": "isso", "emph": True},
|
||||
{"s": 21, "e": 22, "w": "removida"}, {"s": 26, "e": 26.5, "w": "voltou"}]},
|
||||
"overlays": [{"id": "hook", "kind": "hook", "text": "ELE NÃO ACREDITOU", "start": 0, "end": 3, "y": 0.2, "size": 70,
|
||||
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"},
|
||||
{"id": "z1", "kind": "zoom", "start": 12, "end": 15, "scale": 1.4, "x": 0.5, "y": 0.4, "ramp": 0.2}],
|
||||
"progress": {"enabled": True, "color": "#FF7A1A", "height": 12},
|
||||
"audio": {"volume": 1, "narration": [], "music": None, "sfx": []},
|
||||
"cover": {"enabled": True, "t": 12, "text": "LAG"},
|
||||
}
|
||||
p.update(over)
|
||||
return p
|
||||
|
||||
|
||||
def validate(data, tmp_path: Path, duration=100.0):
|
||||
return editor.validate_project(data, session_id=1, session_duration=duration, repo_root=tmp_path,
|
||||
tts_dir=tmp_path / "tts", assets_dir=tmp_path / "assets")
|
||||
|
||||
|
||||
def test_time_mapping():
|
||||
cuts = [{"start": 10, "end": 20}, {"start": 25, "end": 30}]
|
||||
assert editor.output_duration(cuts) == 15
|
||||
assert editor.to_output(15, cuts) == (5, True)
|
||||
assert editor.to_output(22, cuts) == (10, False) # trecho removido gruda no começo do próximo
|
||||
assert editor.to_output(26, cuts) == (11, True)
|
||||
assert editor.to_session(11, cuts) == 26
|
||||
sl = editor.slice_pieces(cuts, 8, 12)
|
||||
assert [(p.start, p.end, p.out) for p in sl] == [(18, 20, 0), (25, 27, 2)]
|
||||
assert editor.normalize_cuts([{"start": 5, "end": 8}, {"start": 1, "end": 5.01}]) == [{"start": 1, "end": 8}]
|
||||
|
||||
|
||||
def test_validate_accepts_and_normalizes(tmp_path):
|
||||
p = validate(make_project(), tmp_path)
|
||||
assert p["cuts"][1]["mode"] == "game_only" and p["captions"]["words"][1]["emph"] is True
|
||||
assert editor.output_duration(p["cuts"]) == 15
|
||||
|
||||
|
||||
@pytest.mark.parametrize("change,message", [
|
||||
({"schema": 2}, "versão"),
|
||||
({"cuts": []}, "pelo menos um trecho"),
|
||||
({"cuts": [{"start": 10, "end": 11}]}, "de 3 a 180"),
|
||||
({"cuts": [{"start": 10, "end": 70}]}, r"cuts\[0\]\.end vai de 0 a 60"), # fora da janela (hi = 60)
|
||||
({"source": {"sessionId": 9, "lo": 0, "hi": 60}}, "outra sessão"),
|
||||
({"source": {"sessionId": 1, "lo": 0, "hi": 900}}, "source.hi"), # além do fim da gravação
|
||||
({"cuts": [{"start": 10, "end": 20, "mode": "rm -rf"}]}, "mode"),
|
||||
({"overlays": [{"id": "a b", "kind": "text", "text": "x", "start": 10, "end": 12}]}, "id curto"),
|
||||
({"overlays": [{"id": "z1", "kind": "zoom", "start": 10, "end": 14, "scale": 1.3},
|
||||
{"id": "z2", "kind": "zoom", "start": 12, "end": 16, "scale": 1.3}]}, "dois zooms"),
|
||||
({"overlays": [{"id": "t", "kind": "text", "text": "x" * 200, "start": 10, "end": 12}]}, "120"),
|
||||
({"audio": {"music": {"file": "../voice/.env"}}}, "música"),
|
||||
({"audio": {"music": {"file": "C:/Windows/win.ini"}}}, "música"),
|
||||
({"audio": {"narration": [{"id": "n", "file": "output/x.wav", "at": 10}]}}, "narração"),
|
||||
])
|
||||
def test_validate_rejects(tmp_path, change, message):
|
||||
with pytest.raises(editor.EditError, match=message):
|
||||
validate(make_project(**change), tmp_path)
|
||||
|
||||
|
||||
def test_zero_length_word_is_tolerated(tmp_path):
|
||||
data = make_project()
|
||||
data["captions"]["words"].append({"s": 13.0, "e": 13.0, "w": "queria"}) # Whisper real (corte 9 do skipnho)
|
||||
words = validate(data, tmp_path)["captions"]["words"]
|
||||
assert {"s": 13.0, "e": 13.05, "w": "queria"} in words
|
||||
|
||||
|
||||
def test_window_limit(tmp_path):
|
||||
with pytest.raises(editor.EditError, match="janela"):
|
||||
validate(make_project(source={"sessionId": 1, "lo": 0, "hi": 900}), tmp_path, duration=2000)
|
||||
|
||||
|
||||
def test_audio_only_from_allowed_folders(tmp_path):
|
||||
(tmp_path / "assets").mkdir()
|
||||
(tmp_path / "assets" / "beat.mp3").write_bytes(b"x")
|
||||
(tmp_path / "tts").mkdir()
|
||||
(tmp_path / "tts" / "tts-0123456789ab.wav").write_bytes(b"x")
|
||||
p = validate(make_project(audio={"volume": 1, "music": {"file": "assets/beat.mp3", "volume": 0.2},
|
||||
"narration": [{"id": "n1", "file": "tts/tts-0123456789ab.wav", "at": 12}]}), tmp_path)
|
||||
assert p["audio"]["music"]["file"] == "assets/beat.mp3" and p["audio"]["narration"][0]["at"] == 12
|
||||
|
||||
|
||||
def test_output_words_and_ass_presets(tmp_path):
|
||||
p = validate(make_project(), tmp_path)
|
||||
words = editor.output_words(p)
|
||||
assert [w.word for w in words] == ["olha", "isso", "voltou"] # "removida" caiu no trecho cortado
|
||||
assert words[2].start == 11.0 # 26 s da sessão = 10 s + 1 s
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x")
|
||||
assert "\\fscx118" in ass # pop na palavra falada
|
||||
assert "&H6BE322&" in ass # cor da ênfase (#22E36B em BGR) na palavra marcada
|
||||
assert "ELE NÃO ACREDITOU" in ass and "Box" in ass # gancho com caixa
|
||||
assert "\\p1" in ass and "\\fscx100.00" in ass # barra de progresso até 100%
|
||||
assert "\\C" not in ass # gotcha 58: tag nunca em maiúscula
|
||||
for preset, mark in (("karaoke", "\\kf"), ("single", "\\fscx70"), ("minimal", "OLHA")):
|
||||
q = json.loads(json.dumps(p))
|
||||
q["captions"]["preset"] = preset
|
||||
text = editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
|
||||
assert mark in text if preset != "minimal" else mark not in text # mínima não usa maiúsculas
|
||||
|
||||
|
||||
def test_ass_escapes_user_text(tmp_path):
|
||||
p = make_project(overlays=[{"id": "t", "kind": "text", "text": "{\\b1}oi\\N", "start": 11, "end": 13}])
|
||||
q = validate(p, tmp_path)
|
||||
ass = editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
|
||||
assert "{\\b1}" not in ass and "(/b1)oi/N" in ass
|
||||
|
||||
|
||||
def test_filter_has_pieces_layouts_and_zoom(tmp_path):
|
||||
p = validate(make_project(), tmp_path)
|
||||
cfg = editor.effective_settings(layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}}), p)
|
||||
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
|
||||
assert "trim=start=0.000:end=10.000" in graph and "trim=start=15.000:end=20.000" in graph
|
||||
assert "vstack" in graph and "[c_0]" in graph # 1º trecho câmera em cima (rótulos únicos por trecho)
|
||||
assert "concat=n=2:v=1:a=1" in graph and "zoompan=z='1+0.4000*" in graph and "ass=e.ass" in graph
|
||||
# Prévia real a partir de 8 s: o zoom continua no mesmo instante do corte (it + 8).
|
||||
assert "(it+8.000)" in editor_render.zoom_filter(p, 8.0)
|
||||
|
||||
|
||||
def test_suggestion_is_clamped():
|
||||
s = editor.clean_suggestion({"hook": "x" * 200, "title": "t", "start_s": -50, "end_s": 999,
|
||||
"remove": [{"start_s": 20, "end_s": 20.1, "why": ""}, {"start_s": 30, "end_s": 34, "why": "silêncio"}],
|
||||
"zooms": [{"t": 40, "why": "grito"}, {"t": 500, "why": "fora"}], "reason": "r"}, 10, 80)
|
||||
assert (s["start"], s["end"]) == (10, 80) and len(s["hook"]) == 80
|
||||
assert s["remove"] == [{"start": 30, "end": 34, "why": "silêncio"}] and [z["t"] for z in s["zooms"]] == [40]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- rotas e render real
|
||||
def _lavfi_segments(folder: Path, n: int = 3, seconds: int = 4) -> list[Path]:
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
files = []
|
||||
for i in range(n):
|
||||
f = folder / f"seg_{i:05d}.ts"
|
||||
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", f"testsrc2=s=640x360:r=30:d={seconds}",
|
||||
"-f", "lavfi", "-i", f"sine=frequency={300 + 100 * i}:d={seconds}", "-c:v", "libx264", "-preset",
|
||||
"ultrafast", "-g", "15", "-c:a", "aac", "-shortest", "-f", "mpegts", str(f)], check=True, capture_output=True)
|
||||
files.append(f)
|
||||
return files
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def api(tmp_path, monkeypatch):
|
||||
import app.editor_api as editor_api
|
||||
import app.worker as worker
|
||||
monkeypatch.setattr(editor_api, "REPO_ROOT", tmp_path)
|
||||
monkeypatch.setattr(worker, "REPO_ROOT", tmp_path)
|
||||
settings = Settings.load(env_file=tmp_path / "none.env", service_key=KEY, data_dir=tmp_path / "data",
|
||||
clips_dir=tmp_path / "output" / "clipper", judge_provider="codex", voice_url=None, voice_key=None)
|
||||
db = Database(settings.data_dir / "clipper.db")
|
||||
engine = Engine(settings, db, judge=FakeJudge())
|
||||
client = TestClient(create_app(settings, engine, start_engine=False))
|
||||
db.run("INSERT INTO sessions (id, platform, kind, url, status, dir, duration_s, started_at) "
|
||||
"VALUES (1, 'twitch', 'live', 'https://www.twitch.tv/skipnho', 'done', 'data/s1', 12, 'x')")
|
||||
words = [[1.0, 1.4, "olha"], [1.5, 2.0, "isso"], [9.0, 9.5, "fim"]]
|
||||
for i in range(3):
|
||||
db.run("INSERT INTO segments (session_id, idx, file, start_s, end_s, wall_end, analyzed, words_json) VALUES (1, ?, ?, ?, ?, 0, 1, ?)",
|
||||
i, f"data/s1/seg_{i:05d}.ts", i * 4.0, i * 4.0 + 4, json.dumps([w for w in words if i * 4 <= w[0] < i * 4 + 4]))
|
||||
db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, title, created_at, updated_at) "
|
||||
"VALUES (7, 1, 5, 2, 10, 8, 'manual', 'ready', 'Título', 'x', 'x')")
|
||||
return client, engine, tmp_path
|
||||
|
||||
|
||||
def test_edit_routes_roundtrip(api):
|
||||
client, engine, root = api
|
||||
h = {"X-Service-Key": KEY}
|
||||
r = client.get("/v1/clips/7/edit", headers=h)
|
||||
assert r.status_code == 200, r.text
|
||||
body = r.json()
|
||||
assert body["rev"] == 0 and body["project"]["cuts"] == [{"start": 2.0, "end": 10.0, "mode": None}]
|
||||
assert [w["w"] for w in body["words"]] == ["olha", "isso", "fim"] and body["window"] == {"lo": 0.0, "hi": 12.0}
|
||||
project = body["project"]
|
||||
project["cuts"] = [{"start": 0.0, "end": 3.0, "mode": None}, {"start": 6.0, "end": 10.0, "mode": None}]
|
||||
saved = client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0})
|
||||
assert saved.status_code == 200 and saved.json()["rev"] == 1 and saved.json()["durationS"] == 7
|
||||
stale = client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0})
|
||||
assert stale.status_code == 409 # autosave de outra aba não atropela
|
||||
bad = client.put("/v1/clips/7/edit", headers=h, json={"project": {**project, "cuts": []}, "rev": 1})
|
||||
assert bad.status_code == 400 and "trecho" in bad.json()["error"]
|
||||
assert client.get("/v1/clips/7", headers=h).json()["edit"]["updatedAt"]
|
||||
exp = client.post("/v1/clips/7/export", headers=h)
|
||||
assert exp.status_code == 200 and exp.json()["status"] == "pending" and exp.json()["editedDurationS"] == 7
|
||||
assert (exp.json()["startS"], exp.json()["endS"]) == (0.0, 10.0)
|
||||
# Ajuste do cartão (−2 s no início não cabe: a sessão começa em 0) → as pontas do projeto acompanham.
|
||||
client.patch("/v1/clips/7", headers=h, json={"endS": 11.0})
|
||||
assert client.get("/v1/clips/7/edit", headers=h).json()["project"]["cuts"][-1]["end"] == 11.0
|
||||
assert client.delete("/v1/clips/7/edit", headers=h).status_code == 204
|
||||
assert client.get("/v1/clips/7", headers=h).json()["edit"] is None
|
||||
|
||||
|
||||
def test_tts_and_suggest_need_services(api):
|
||||
client, _engine, _root = api
|
||||
h = {"X-Service-Key": KEY}
|
||||
assert "voz" in client.post("/v1/clips/7/tts", headers=h, json={"text": "oi", "voice": "pt-br-x"}).json()["error"]
|
||||
assert client.post("/v1/clips/7/tts", headers=h, json={"text": "oi", "voice": "../x"}).status_code == 422
|
||||
|
||||
|
||||
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
|
||||
def test_real_render_proxy_and_waveform(api):
|
||||
client, engine, root = api
|
||||
_lavfi_segments(root / "data" / "s1")
|
||||
h = {"X-Service-Key": KEY}
|
||||
project = client.get("/v1/clips/7/edit", headers=h).json()["project"]
|
||||
project["cuts"] = [{"start": 1.0, "end": 4.0, "mode": None}, {"start": 6.0, "end": 9.0, "mode": "game_only"}]
|
||||
project["overlays"].append({"id": "z", "kind": "zoom", "start": 7, "end": 8.5, "scale": 1.5, "x": 0.5, "y": 0.5, "ramp": 0.2})
|
||||
project["progress"]["enabled"] = True
|
||||
assert client.put("/v1/clips/7/edit", headers=h, json={"project": project, "rev": 0}).status_code == 200
|
||||
proxy = client.post("/v1/clips/7/proxy", headers=h, json={"lo": 0, "hi": 12})
|
||||
assert proxy.status_code == 200, proxy.text
|
||||
wave = client.get("/v1/clips/7/waveform?lo=0&hi=12", headers=h).json()
|
||||
assert 500 <= len(wave["peaks"]) <= 610 and max(wave["peaks"]) == 1.0
|
||||
prev = client.post("/v1/clips/7/preview-render", headers=h, json={"fromS": 2, "durationS": 3})
|
||||
assert prev.status_code == 200, prev.text
|
||||
client.post("/v1/clips/7/export", headers=h)
|
||||
engine.render_pending()
|
||||
clip = client.get("/v1/clips/7", headers=h).json()
|
||||
assert clip["status"] == "ready", clip["error"]
|
||||
out = root / clip["file"]
|
||||
assert clip["edit"]["cover"] and (root / clip["edit"]["cover"]).is_file() # capa (etapa 7) gerada no export
|
||||
probe = subprocess.run([shutil.which("ffprobe") or "ffprobe", "-v", "error", "-show_entries", "stream=width,height:format=duration",
|
||||
"-of", "json", str(out)], capture_output=True, text=True, check=True)
|
||||
info = json.loads(probe.stdout)
|
||||
assert {"width": 1080, "height": 1920} in [{k: s[k] for k in ("width", "height")} for s in info["streams"] if "width" in s]
|
||||
assert abs(float(info["format"]["duration"]) - 6.0) < 0.25 # 3 s + 3 s, sem o meio removido
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- projeto entregue pela IA
|
||||
def test_auto_project_uses_pipeline_knowledge():
|
||||
clip = {"session_id": 1, "start_s": 100.0, "end_s": 140.0, "peak_s": 120.0, "title": "Título do juiz"}
|
||||
analysis = {"action_start_s": 95.0, "reaction_end_s": 143.0, "hook": "Caiu a 1 m da chegada"}
|
||||
words = [Word(94.0, 95.3, "olha"), Word(96.0, 96.4, "vai"), Word(103.0, 103.5, "silêncio"),
|
||||
Word(110.0, 110.4, "depois"), Word(118.0, 118.5, "NÃO"), Word(141.0, 141.4, "kkkk")]
|
||||
loudness = [-20.0] * 200
|
||||
for t in range(103, 111):
|
||||
loudness[t] = -55.0 # quieto entre 103,5 e 110 s → a IA corta; perto do pico (120 s) não corta
|
||||
# Mínimo de 15 s (configuração do canal): sobra espaço para tirar o silêncio. Com o padrão novo (60 s) o corte de
|
||||
# 50 s já está abaixo do mínimo e nenhum silêncio sai (conferido no fim).
|
||||
cfg = layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}, "duration": {"minS": 15}})
|
||||
p = editor.auto_project(clip, analysis, words, loudness, 300.0, cfg, model="m", generated_at="agora")
|
||||
assert p["cuts"][0]["start"] == 93.9 # ação em 95 − 0,8 s caiu no meio de "olha" → recua para antes da palavra
|
||||
assert p["cuts"][-1]["end"] == 143.8 # fim da reação + 0,8 s
|
||||
assert len(p["cuts"]) == 2 and p["cuts"][0]["end"] == 103.75 and p["cuts"][1]["start"] == 109.75
|
||||
hook = next(o for o in p["overlays"] if o["kind"] == "hook")
|
||||
zoom = next(o for o in p["overlays"] if o["kind"] == "zoom")
|
||||
assert hook["text"] == "Caiu a 1 m da chegada" and zoom["start"] == 119.8 and zoom["y"] == 0.17 # rosto (câmera em cima)
|
||||
assert p["captions"]["preset"] == "pop" and p["meta"]["origin"] == "ai" and p["cover"]["t"] == 120.0
|
||||
assert any("silêncio" in s for s in p["meta"]["steps"])
|
||||
# Sem análise e sem som medido: trecho do juiz, gancho = título.
|
||||
q = editor.auto_project(clip, None, words, [], 300.0, layout.merge())
|
||||
# Mínimo de verdade (17/11/2026): o trecho de 40 s do juiz cresce PARA TRÁS até mínimo + 1 s (+0,1 de folga).
|
||||
assert (q["cuts"][0]["start"], q["cuts"][-1]["end"]) == (78.9, 140.0)
|
||||
assert editor.output_duration(q["cuts"]) >= 61.0 and any("estendido" in s for s in q["meta"]["steps"])
|
||||
assert q["overlays"][0]["text"] == "Título do juiz"
|
||||
# Gancho do analista longo (frase descritiva) → usa o título do editor.
|
||||
long_hook = {"hook": "A provocação sobre ficar moscando começa e, logo depois, ele solta vários gritos"}
|
||||
assert editor.auto_project(clip, long_hook, words, [], 300.0, layout.merge())["overlays"][0]["text"] == "Título do juiz"
|
||||
default_min = editor.auto_project(clip, analysis, words, loudness, 300.0, layout.merge())
|
||||
assert len(default_min["cuts"]) == 1 and not any("silêncio" in s for s in default_min["meta"]["steps"])
|
||||
|
||||
|
||||
def test_render_always_goes_through_project(api):
|
||||
"""Um caminho de render: corte sem projeto ganha o da IA (origem ai); salvar no editor vira origem user."""
|
||||
client, engine, root = api
|
||||
h = {"X-Service-Key": KEY}
|
||||
body = client.get("/v1/clips/7/edit", headers=h).json()
|
||||
assert body["origin"] == "ai" and body["aiProject"]["meta"]["origin"] == "ai" and not body["saved"]
|
||||
if FFMPEG:
|
||||
_lavfi_segments(root / "data" / "s1")
|
||||
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 7")
|
||||
engine.render_pending()
|
||||
clip = client.get("/v1/clips/7", headers=h).json()
|
||||
assert clip["status"] == "ready", clip["error"]
|
||||
assert clip["edit"]["origin"] == "ai"
|
||||
project = client.get("/v1/clips/7/edit", headers=h).json()
|
||||
saved = client.put("/v1/clips/7/edit", headers=h, json={"project": project["project"], "rev": project["rev"]})
|
||||
assert saved.status_code == 200
|
||||
again = client.get("/v1/clips/7/edit", headers=h).json()
|
||||
assert again["origin"] == "user" and again["aiProject"]["meta"]["origin"] == "ai"
|
||||
|
||||
|
||||
def test_pick_hook_never_shows_session_time_or_cuts_a_word():
|
||||
from app.editor import pick_hook
|
||||
# Medido no corte 25 do skipnho: o analista devolveu uma frase com o tempo da gravação e ela saía cortada.
|
||||
raw = "Aos 5085s, ele solta que não veio de família rica e imediatamente começa a se desculpar"
|
||||
text, from_analyst = pick_hook(raw, "“Não vim de família rica” — e vêm os pedidos de desculpa")
|
||||
assert not from_analyst and text == "“Não vim de família rica” — e vêm os pedidos de desculpa"
|
||||
assert pick_hook("O lag jogou ele na água", "título") == ("O lag jogou ele na água", True)
|
||||
long_title = "Ele tenta explicar o que aconteceu com o carro e acaba piorando tudo na frente do chat"
|
||||
text, _ = pick_hook("", long_title)
|
||||
assert len(text) <= 60 and long_title.startswith(text) and not text.endswith(" ")
|
||||
assert pick_hook("Aos 120s, vem o susto", None)[0] == "Vem o susto"
|
||||
@@ -0,0 +1,109 @@
|
||||
"""Camadas novas do editor (17/11/2026): câmera em tela cheia por trecho, trecho mudo, texto com posição livre,
|
||||
chat da live na tela e capa nos primeiros quadros."""
|
||||
from pathlib import Path
|
||||
|
||||
from app import editor, editor_render, layout
|
||||
from app.scoring import ChatMessage
|
||||
|
||||
from .test_editor import make_project, validate
|
||||
|
||||
CAM = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}
|
||||
|
||||
|
||||
def test_old_projects_get_defaults_for_new_fields(tmp_path):
|
||||
p = validate(make_project(), tmp_path)
|
||||
assert p["chat"]["enabled"] is False and p["chat"]["lines"] == 5
|
||||
assert p["cover"]["atStart"] is False
|
||||
assert all(c["muted"] is False for c in p["cuts"])
|
||||
assert p["overlays"][0]["x"] == 0.5
|
||||
|
||||
|
||||
def test_cam_only_layout_fills_the_screen_with_the_camera():
|
||||
cfg = layout.merge(CAM)
|
||||
chain = layout.layout_chain(cfg, "in", "out", mode="cam_only")
|
||||
assert "crop=iw*0.2:ih*0.25:iw*0.02:ih*0.45" in chain and "vstack" not in chain and "boxblur" not in chain
|
||||
assert f"crop={layout.W}:{layout.H}" in chain
|
||||
# sem câmera marcada não há o que mostrar: cai no desfoque
|
||||
assert "boxblur" in layout.layout_chain(layout.merge(), "in", "out", mode="cam_only")
|
||||
|
||||
|
||||
def test_cut_mode_and_mute_survive_and_do_not_merge(tmp_path):
|
||||
cuts = [{"start": 10, "end": 15, "mode": "cam_only"}, {"start": 15, "end": 20, "mode": "cam_only", "muted": True},
|
||||
{"start": 20, "end": 24, "mode": "cam_only", "muted": True}]
|
||||
p = validate(make_project(cuts=cuts), tmp_path)
|
||||
assert [(c["start"], c["end"], c["muted"]) for c in p["cuts"]] == [(10, 15, False), (15, 24, True)]
|
||||
cfg = editor.effective_settings(layout.merge(CAM), p)
|
||||
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, None, [])
|
||||
first, second = graph.split("[pa0]")[0], graph.split("[pa0]")[1].split("[pa1]")[0]
|
||||
assert "volume=0" not in first.split("[sa0]atrim")[1] # 1º trecho com som
|
||||
assert second.rstrip().endswith("volume=0") # 2º trecho mudo
|
||||
assert graph.count("crop=iw*0.2:ih*0.25") == 2 # câmera em tela cheia nos dois
|
||||
|
||||
|
||||
def test_text_position_and_chat_block_in_ass(tmp_path):
|
||||
data = make_project(chat={"enabled": True, "x": 0.05, "y": 0.6, "width": 0.5, "lines": 2, "size": 30})
|
||||
data["overlays"][0]["x"] = 0.25
|
||||
p = validate(data, tmp_path)
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
chat = [ChatMessage(11.0, "KKKKKK", "ana"), ChatMessage(12.0, "server chinês? {\\b1}", "beto"),
|
||||
ChatMessage(13.0, "terceira mensagem bem comprida que não cabe na largura do bloco de chat", "caio"),
|
||||
ChatMessage(22.0, "fora do corte", "dani")]
|
||||
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x", chat=chat)
|
||||
assert f"\\pos({int(1080 * 0.25)},{int(1920 * 0.2)})" in ass # gancho na posição arrastada
|
||||
chat_lines = [line for line in ass.splitlines() if ",Chat," in line]
|
||||
assert len(chat_lines) == 3 and "fora do corte" not in ass
|
||||
assert f"\\an1\\pos({int(1080 * 0.05)},{int(1920 * 0.6)})" in chat_lines[0]
|
||||
assert "ana:" in chat_lines[0] and "\\N" not in chat_lines[0]
|
||||
assert chat_lines[2].count("\\N") == 1 and "ana:" not in chat_lines[2] # só as 2 últimas
|
||||
assert "{\\b1}" not in ass and "…" in chat_lines[2] # texto do chat nunca vira tag; linha longa é cortada
|
||||
# desligado (padrão): nenhum evento de chat
|
||||
off = editor_render.build_project_ass(validate(make_project(), tmp_path), cfg, "", chat=chat)
|
||||
assert ",Chat,," not in off.split("[Events]")[1]
|
||||
|
||||
|
||||
def test_cover_at_start_overlays_first_frames(tmp_path):
|
||||
p = validate(make_project(cover={"enabled": True, "t": 12, "text": "LAG", "atStart": True}), tmp_path)
|
||||
assert p["cover"]["atStart"] is True
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
|
||||
assert "[vbase]" in graph and "[1:v]scale=1080:1920" in graph and "overlay=enable='lt(t,0.0667)'" in graph
|
||||
assert graph.rstrip().split(";")[-1] != "" and "[v]" in graph
|
||||
plain = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
|
||||
assert "[vbase]" not in plain
|
||||
|
||||
|
||||
def test_real_render_with_new_layers(tmp_path):
|
||||
"""Render de verdade (FFmpeg) com câmera inteira, trecho mudo, chat na tela e capa no início."""
|
||||
import shutil
|
||||
import subprocess
|
||||
|
||||
ffmpeg = shutil.which("ffmpeg")
|
||||
if not ffmpeg:
|
||||
import pytest
|
||||
pytest.skip("sem ffmpeg")
|
||||
seg = tmp_path / "seg0.ts"
|
||||
subprocess.run([ffmpeg, "-v", "error", "-f", "lavfi", "-i", "testsrc2=size=640x360:rate=30:duration=8", "-f", "lavfi",
|
||||
"-i", "sine=frequency=440:duration=8", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15", "-c:a", "aac", "-shortest",
|
||||
str(seg)], check=True) # -g 15: quadro-chave a cada 0,5 s (senão não dá para saltar no .ts)
|
||||
cuts = [{"start": 1, "end": 4, "mode": "cam_only"}, {"start": 4, "end": 7, "mode": None, "muted": True}]
|
||||
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, cuts=cuts, overlays=[],
|
||||
captions={"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B", "words": []},
|
||||
cover={"enabled": True, "t": 2, "text": "CAPA", "atStart": True},
|
||||
chat={"enabled": True, "lines": 3})
|
||||
p = validate(data, tmp_path, duration=8.0)
|
||||
base = layout.merge(CAM)
|
||||
segments = [(seg, 0.0, 8.0)]
|
||||
cover = editor_render.render_cover(ffmpeg, segments, p, base, "twitch.tv/x", tmp_path / "cover.jpg")
|
||||
out = tmp_path / "out.mp4"
|
||||
editor_render.render_project(ffmpeg, shutil.which("ffprobe"), ["-c:v", "libx264", "-preset", "ultrafast"], segments, p, base,
|
||||
"twitch.tv/x", out, tmp_path, chat=[ChatMessage(2.0, "KKKK", "ana"), ChatMessage(5.0, "F", "beto")],
|
||||
cover_file=cover)
|
||||
probe = subprocess.run([shutil.which("ffprobe") or "ffprobe", "-v", "error", "-show_entries", "format=duration:stream=width,height",
|
||||
"-of", "csv=p=0", str(out)], capture_output=True, text=True, check=True).stdout
|
||||
assert "1080,1920" in probe and abs(float(probe.strip().splitlines()[-1]) - 6.0) < 0.2
|
||||
# Trecho mudo: o volume médio da 2ª metade é silêncio; a 1ª tem o tom de teste.
|
||||
def mean_db(start: float) -> float:
|
||||
err = subprocess.run([ffmpeg, "-v", "info", "-ss", str(start), "-t", "2", "-i", str(out), "-af", "volumedetect", "-vn",
|
||||
"-f", "null", "-"], capture_output=True, text=True).stderr
|
||||
return float(err.split("mean_volume:")[1].split("dB")[0])
|
||||
assert mean_db(0.5) > -40 and mean_db(3.6) < -70
|
||||
@@ -0,0 +1,469 @@
|
||||
"""Rastreio de reação (face.py) com backends falsos: sem rede, sem modelo, sem FFmpeg."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from app import face as face_mod
|
||||
from app.db import SCHEMA, Database
|
||||
from app.face import FaceService, FaceUnavailable, ModelStore
|
||||
from app.judge import build_prompt
|
||||
from app.reaction import FaceSample
|
||||
from tests.test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
CAM = {"x": 0.014, "y": 0.4, "w": 0.2, "h": 0.5}
|
||||
|
||||
|
||||
class FakeTracker:
|
||||
"""Rosto parado no meio do recorte; sorriso alto nos segundos de `laughs`; sem rosto nos de `gone`."""
|
||||
|
||||
name = "fake"
|
||||
|
||||
def __init__(self, laughs=(), gone=()):
|
||||
self.laughs, self.gone, self.closed = set(laughs), set(gone), False
|
||||
|
||||
def process(self, t, rgb):
|
||||
if int(t) in self.gone:
|
||||
return FaceSample(t, False)
|
||||
smile = 0.9 if int(t) in self.laughs else 0.05 + 0.05 * ((int(t * 6) % 3) / 2)
|
||||
return FaceSample(t, True, 0.5, 0.4, 0.3, {"mouthSmileLeft": smile, "mouthSmileRight": smile})
|
||||
|
||||
def close(self):
|
||||
self.closed = True
|
||||
|
||||
|
||||
def fake_reader(_ffmpeg, _file, crop_px, out_size, fps=6):
|
||||
for i in range(30 * fps):
|
||||
yield i / fps, None
|
||||
|
||||
|
||||
def make_service(engine, laughs=(), gone=(), tracker_factory=None):
|
||||
service = FaceService(engine, store=object(), tracker_factory=tracker_factory or (lambda _backend=None: FakeTracker(laughs, gone)),
|
||||
detector_factory=None, reader=fake_reader, grabber=None, sizer=lambda _f: (1280, 720))
|
||||
engine.face = service
|
||||
return service
|
||||
|
||||
|
||||
def set_cam(engine, sid, cam=CAM, source="yunet"):
|
||||
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
|
||||
json.dumps({"hasWebcam": cam is not None, "cam": cam, "source": source}), sid)
|
||||
|
||||
|
||||
def session(engine, sid):
|
||||
return engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- banco / modelos
|
||||
def test_migration_creates_face_track(tmp_path):
|
||||
db = Database(tmp_path / "c.db")
|
||||
assert db.conn.execute("PRAGMA user_version").fetchone()[0] == len(SCHEMA)
|
||||
cols = {r["name"] for r in db.all("PRAGMA table_info(face_track)")}
|
||||
assert {"session_id", "idx", "status", "data_json", "error", "updated_at"} <= cols
|
||||
|
||||
|
||||
def _lock(tmp_path, content: bytes) -> object:
|
||||
lock = tmp_path / "models.lock.json"
|
||||
lock.write_text(json.dumps({"dir": "x", "models": [
|
||||
{"id": "m", "file": "m.onnx", "url": "https://exemplo/m.onnx", "sha256": hashlib.sha256(content).hexdigest()}]}))
|
||||
return lock
|
||||
|
||||
|
||||
def test_model_store_downloads_lazily_and_checks_sha256(tmp_path):
|
||||
calls = []
|
||||
|
||||
def fetch(url, dest):
|
||||
calls.append(url)
|
||||
dest.write_bytes(b"pesos certos")
|
||||
|
||||
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=fetch)
|
||||
path = store.path("m")
|
||||
assert path.read_bytes() == b"pesos certos" and calls == ["https://exemplo/m.onnx"]
|
||||
assert store.path("m") == path and len(calls) == 1 # conferido uma vez; não baixa de novo
|
||||
# Arquivo já presente e certo (setup.ps1 baixou): nenhum download.
|
||||
fresh = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=lambda *_: pytest.fail("baixou"))
|
||||
assert fresh.path("m") == path
|
||||
|
||||
|
||||
def test_model_store_rejects_wrong_sha256_and_network_errors(tmp_path):
|
||||
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"),
|
||||
fetch=lambda _url, dest: dest.write_bytes(b"adulterado"))
|
||||
with pytest.raises(FaceUnavailable, match="sha256"):
|
||||
store.path("m")
|
||||
assert not list((tmp_path / "models").iterdir()) # nem o .part fica
|
||||
|
||||
def offline(_url, _dest):
|
||||
raise OSError("sem rede")
|
||||
with pytest.raises(FaceUnavailable, match="baixar"):
|
||||
ModelStore(tmp_path / "models", _lock(tmp_path, b"x"), fetch=offline).path("m")
|
||||
with pytest.raises(FaceUnavailable):
|
||||
store.path("nao-existe")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- laço por bloco
|
||||
def test_block_is_tracked_in_full_frame_coords(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine, laughs=range(40, 45))
|
||||
sid = seed_session(engine, duration=120)
|
||||
assert service.step() is False # câmera ainda não decidida: espera a detecção
|
||||
set_cam(engine, sid)
|
||||
for _ in range(4):
|
||||
assert service.step() is True
|
||||
assert service.step() is False
|
||||
rows = engine.db.all("SELECT * FROM face_track WHERE session_id = ? ORDER BY idx", sid)
|
||||
assert [r["status"] for r in rows] == ["done"] * 4
|
||||
data = json.loads(rows[1]["data_json"])
|
||||
assert data["cam"] == CAM and data["backend"] == "fake" and data["frames"] == 180
|
||||
seconds = data["seconds"]
|
||||
assert [s["t"] for s in seconds] == list(range(30, 60)) # bloco 30–60 s, sem repetir segundos do vizinho
|
||||
crop = face_mod.expand(CAM)
|
||||
assert seconds[0]["cx"] == pytest.approx(crop["x"] + 0.5 * crop["w"], abs=1e-3) # quadro inteiro, não recorte
|
||||
assert seconds[0]["size"] == pytest.approx(0.3 * crop["h"], abs=1e-3)
|
||||
assert service.tracked_until(sid) == 120
|
||||
dense = service.dense(sid, 0, 120)
|
||||
assert len(dense) == 120 and dense[42].smile == pytest.approx(0.9)
|
||||
|
||||
|
||||
def test_no_cam_and_backend_unavailable(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
sid = seed_session(engine, duration=60)
|
||||
set_cam(engine, sid, cam=None) # detecção rodou e não achou câmera
|
||||
assert service.step() and service.step()
|
||||
assert {r["status"] for r in engine.db.all("SELECT status FROM face_track WHERE session_id = ?", sid)} == {"no_cam"}
|
||||
assert service.for_scoring(session(engine, sid), 0, 60) == (None, 0.0) # pontuação segue como antes
|
||||
# Backend sem modelo/biblioteca: não marca o bloco (tenta de novo depois).
|
||||
sid2 = seed_session(engine, duration=60)
|
||||
set_cam(engine, sid2)
|
||||
|
||||
def broken(_backend=None):
|
||||
raise FaceUnavailable("sem modelo")
|
||||
service._tracker_factory = broken
|
||||
with pytest.raises(FaceUnavailable):
|
||||
service.step()
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid2)["n"] == 0
|
||||
|
||||
|
||||
def test_block_error_is_recorded(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
sid = seed_session(engine, duration=30)
|
||||
set_cam(engine, sid)
|
||||
|
||||
def failing(*_a, **_k):
|
||||
raise face_mod.FaceError("bloco apagado")
|
||||
yield # pragma: no cover
|
||||
service._reader = failing
|
||||
assert service.step()
|
||||
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
|
||||
assert row["status"] == "error" and "apagado" in row["error"]
|
||||
|
||||
|
||||
def test_camera_change_resets_the_track(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
sid = seed_session(engine, duration=60)
|
||||
set_cam(engine, sid)
|
||||
service.step()
|
||||
service.step()
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track")["n"] == 2
|
||||
# Você corrige a câmera no layout da sessão: a série é apagada e refeita com o retângulo novo.
|
||||
new_cam = {"x": 0.7, "y": 0.6, "w": 0.25, "h": 0.35}
|
||||
engine.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps({"layout": {"cam": new_cam}}), sid)
|
||||
assert service.cam_for(session(engine, sid)) == (new_cam, "manual", True)
|
||||
service.step()
|
||||
rows = engine.db.all("SELECT data_json FROM face_track WHERE session_id = ?", sid)
|
||||
assert len(rows) == 1 and json.loads(rows[0]["data_json"])["cam"] == new_cam
|
||||
|
||||
|
||||
def test_find_new_clips_waits_for_face_at_most_two_blocks(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine, laughs=range(300, 306))
|
||||
sid = seed_session(engine) # pico do chat em 300 s, 600 s gravados, transcrição toda pronta
|
||||
set_cam(engine, sid)
|
||||
for _ in range(9): # rosto até 270 s: 11 blocos atrás da transcrição → não segura o corte
|
||||
service.step()
|
||||
assert service.must_wait(330, 270, 600) is False
|
||||
assert service.must_wait(330, 270, 320) is True # rosto 1–2 blocos atrás: espera
|
||||
while service.step():
|
||||
pass
|
||||
assert engine.find_new_clips(session(engine, sid)) == 1
|
||||
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
|
||||
reasons = json.loads(clip["reasons_json"])
|
||||
assert clip["source"] == "chat" and reasons["face"]["label"] == "risada" and 300 <= reasons["face"]["peakS"] <= 306
|
||||
|
||||
|
||||
def test_live_clip_waits_while_face_is_one_block_behind(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine, laughs=range(300, 306))
|
||||
sid = seed_session(engine)
|
||||
set_cam(engine, sid)
|
||||
for _ in range(10): # rosto até 300 s; o corte (≈ 286–306 s + folga) precisa até ~318 s
|
||||
service.step()
|
||||
engine.db.run("UPDATE segments SET analyzed = 0 WHERE session_id = ? AND idx >= 12", sid) # transcrição até 360 s
|
||||
assert engine.find_new_clips(session(engine, sid)) == 0
|
||||
service.step()
|
||||
assert engine.find_new_clips(session(engine, sid)) == 1
|
||||
|
||||
|
||||
def test_judge_prompt_gets_face_line(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine, laughs=range(300, 306))
|
||||
sid = seed_session(engine)
|
||||
set_cam(engine, sid)
|
||||
while service.step():
|
||||
pass
|
||||
text = service.summary(session(engine, sid), 280, 330)
|
||||
assert text.startswith("risada forte em 30")
|
||||
prompt = build_prompt("x", "twitch", 290, 320, 305, [], [], {}, face=text)
|
||||
assert "Rosto do streamer" in prompt and "risada forte em 30" in prompt
|
||||
assert "Rosto do streamer" not in build_prompt("x", "twitch", 290, 320, 305, [], [], {})
|
||||
engine.intel.opts["faceTrack"] = False
|
||||
assert service.summary(session(engine, sid), 280, 330) == ""
|
||||
|
||||
|
||||
class FakeOsfTracker(FakeTracker):
|
||||
"""Plano B: rosto e posição, sem blendshapes (como o OpenSeeFace de verdade)."""
|
||||
|
||||
name = "openseeface"
|
||||
|
||||
def process(self, t, rgb):
|
||||
return FaceSample(t, True, 0.5, 0.4, 0.3, {})
|
||||
|
||||
|
||||
def test_openseeface_series_does_not_break_signal_nor_lie_to_the_judge(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine, tracker_factory=lambda _backend=None: FakeOsfTracker())
|
||||
sid = seed_session(engine)
|
||||
set_cam(engine, sid)
|
||||
while service.step():
|
||||
pass
|
||||
view = service.view(session(engine, sid), 0, None)
|
||||
assert view["blocks"]["done"] > 0 and view["moments"] == []
|
||||
assert all(r.get("signal", 0) == 0 for r in view["seconds"])
|
||||
face, _until = service.for_scoring(session(engine, sid), 0, 300)
|
||||
from app.scoring import find_moments
|
||||
assert find_moments(300, [], [None] * 300, [], face=face) == []
|
||||
# Sem expressões, "sem reação marcante" seria mentira para o analista: a linha não vai.
|
||||
assert service.summary(session(engine, sid), 100, 200) == ""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- câmera local
|
||||
class FakeDetector:
|
||||
def detect(self, bgr):
|
||||
return [(18.0, 363.0, 85.0, 109.0, 0.92)]
|
||||
|
||||
|
||||
class FakeFrame:
|
||||
shape = (720, 1280, 3)
|
||||
|
||||
|
||||
def test_detect_cam_local_first_without_ai(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
service._detector_factory = FakeDetector
|
||||
service._grabber = lambda *_a, **_k: FakeFrame()
|
||||
engine.judge.provider = "off" # sem IA nenhuma
|
||||
sid = seed_session(engine)
|
||||
result = engine.intel.detect_cam(sid, apply=True)
|
||||
assert result["hasWebcam"] and result["source"] == "yunet" and result["frames"] == 12
|
||||
cam = result["cam"]
|
||||
assert cam["y"] < 363 / 720 - 0.5 * 109 / 720 # folga acima da testa
|
||||
saved = json.loads(session(engine, sid)["settings_json"])
|
||||
assert saved["layout"]["cam"] == cam # sem canal: vale para a sessão
|
||||
assert json.loads(session(engine, sid)["cam_json"])["source"] == "yunet"
|
||||
|
||||
|
||||
def test_detect_cam_no_face_falls_back_to_ai_or_records_retry(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
service._detector_factory = lambda: type("D", (), {"detect": lambda self, bgr: []})()
|
||||
service._grabber = lambda *_a, **_k: FakeFrame()
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
|
||||
calls = []
|
||||
|
||||
def ai_cam(images):
|
||||
calls.append(len(images))
|
||||
return {"has_webcam": True, "x": 0.01, "y": 0.5, "w": 0.2, "h": 0.4, "game_on_screen": ""}
|
||||
engine.judge.detect_cam = ai_cam
|
||||
engine.intel.frames = lambda _s, times, _tag: [(t, f"f{int(t)}.jpg") for t in times]
|
||||
engine.intel.e.rel = lambda p: str(p)
|
||||
result = engine.intel.detect_cam(sid)
|
||||
assert result["source"] == "ai" and calls == [3] # local sem rosto → IA (ligada, com visão)
|
||||
# Sem IA: fica registrado "sem câmera" e tenta de novo daqui a 5 min de gravação.
|
||||
engine.judge.provider = "off"
|
||||
engine.db.run("UPDATE sessions SET cam_json = NULL WHERE id = ?", sid)
|
||||
engine.intel.maybe_detect_cam(session(engine, sid))
|
||||
saved = json.loads(session(engine, sid)["cam_json"])
|
||||
assert saved["hasWebcam"] is False and saved["source"] == "yunet" and saved["retryAfterS"] == 900
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- API
|
||||
def test_face_api_and_reset(env): # noqa: F811
|
||||
client, engine = env
|
||||
service = make_service(engine, laughs=range(300, 306))
|
||||
sid = seed_session(engine)
|
||||
set_cam(engine, sid)
|
||||
while service.step():
|
||||
pass
|
||||
r = client.get(f"/v1/sessions/{sid}/face?from=290&to=320", headers=auth())
|
||||
assert r.status_code == 200
|
||||
body = r.json()
|
||||
assert body["cam"] == CAM and body["camSource"] == "yunet" and body["coords"] == "frame"
|
||||
assert body["blocks"]["done"] == 20 and body["trackedUntilS"] == 600
|
||||
assert [s["t"] for s in body["seconds"]][:2] == [290, 291] and body["seconds"][-1]["t"] == 319
|
||||
assert 0 < body["seconds"][0]["cx"] < CAM["x"] + CAM["w"] and "signal" in body["seconds"][0]
|
||||
assert [m["label"] for m in body["moments"]] == ["risada"]
|
||||
assert client.get(f"/v1/sessions/{sid}/face?from=50&to=10", headers=auth()).status_code == 400
|
||||
assert client.get("/v1/sessions/999/face", headers=auth()).status_code == 404
|
||||
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
|
||||
assert r.status_code == 200 and r.json() == {"ok": True, "deleted": 20, "scheduled": False}
|
||||
assert client.get(f"/v1/sessions/{sid}/face", headers=auth()).json()["blocks"]["done"] == 0
|
||||
|
||||
|
||||
def test_face_track_option_persists(env): # noqa: F811
|
||||
client, engine = env
|
||||
r = client.put("/v1/judge", json={"provider": "codex", "model": "", "minScore": 6, "faceTrack": False}, headers=auth())
|
||||
assert r.status_code == 200 and r.json()["options"]["faceTrack"] is False
|
||||
assert engine.face.enabled is False
|
||||
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
|
||||
assert saved["opt_faceTrack"] == "false"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- correções da revisão (médios)
|
||||
import sys # noqa: E402
|
||||
import time # noqa: E402
|
||||
|
||||
|
||||
def _fake_ffmpeg(code: str) -> list[str]:
|
||||
"""Processo falso no lugar do FFmpeg (Python sem shell): `code` escreve quadros/stderr e sai."""
|
||||
return [sys.executable, "-c", code]
|
||||
|
||||
|
||||
def test_read_frames_ok_and_nonzero_exit_after_some_frames():
|
||||
frame = 4 * 2 * 3
|
||||
ok = face_mod._read_frames(_fake_ffmpeg(f"import sys; sys.stdout.buffer.write(b'x' * {frame * 3})"), (4, 2), 6, 30, "b")
|
||||
assert len(list(ok)) == 3
|
||||
# FFmpeg que cai no meio (2 quadros e código 1): erro, não bloco truncado gravado como completo.
|
||||
code = f"import sys; sys.stdout.buffer.write(b'x' * {frame * 2}); sys.stdout.flush(); sys.exit(1)"
|
||||
with pytest.raises(face_mod.FaceError, match="código 1 depois de 2 quadros"):
|
||||
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
|
||||
|
||||
|
||||
def test_read_frames_drains_big_stderr_and_has_a_deadline():
|
||||
# ~360 KB no stderr (mais que o buffer do pipe) não trava; o erro traz a última linha.
|
||||
code = "import sys; sys.stderr.write('ruido\\n' * 60000 + 'fim do erro\\n'); sys.exit(2)"
|
||||
started = time.perf_counter()
|
||||
with pytest.raises(face_mod.FaceError, match="fim do erro"):
|
||||
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
|
||||
# Processo que não entrega nada nem sai: morto pelo prazo.
|
||||
with pytest.raises(face_mod.FaceError, match="passou de 1 s"):
|
||||
list(face_mod._read_frames(_fake_ffmpeg("import time; time.sleep(60)"), (4, 2), 6, 1, "b"))
|
||||
assert time.perf_counter() - started < 20
|
||||
|
||||
|
||||
def test_truncated_block_is_error_not_done(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
sid = seed_session(engine, duration=30)
|
||||
set_cam(engine, sid)
|
||||
|
||||
def short(*_a, **_k):
|
||||
for i in range(60): # 10 s de 30
|
||||
yield i / 6, None
|
||||
service._reader = short
|
||||
assert service.step()
|
||||
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
|
||||
assert row["status"] == "error" and "truncado" in row["error"]
|
||||
|
||||
|
||||
def test_reset_does_not_block_while_a_block_is_running(env): # noqa: F811
|
||||
client, engine = env
|
||||
service = make_service(engine)
|
||||
sid = seed_session(engine, duration=60)
|
||||
set_cam(engine, sid)
|
||||
service.step()
|
||||
service._busy.acquire() # um bloco "em andamento"
|
||||
try:
|
||||
started = time.perf_counter()
|
||||
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
|
||||
assert time.perf_counter() - started < 3
|
||||
assert r.status_code == 202 and r.json()["scheduled"] is True
|
||||
finally:
|
||||
service._busy.release()
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid)["n"] == 1
|
||||
service.step() # o laço aplica o reset agendado antes do próximo bloco
|
||||
rows = engine.db.all("SELECT idx FROM face_track WHERE session_id = ?", sid)
|
||||
assert [r["idx"] for r in rows] == [0] # apagou e refez só o primeiro
|
||||
|
||||
|
||||
def test_backend_is_fixed_per_session():
|
||||
seen = []
|
||||
|
||||
class Store:
|
||||
def path(self, model_id):
|
||||
if model_id == "face_landmarker":
|
||||
raise FaceUnavailable("sem mediapipe")
|
||||
seen.append(model_id)
|
||||
raise FaceUnavailable("sem pesos do plano B")
|
||||
|
||||
service = FaceService.__new__(FaceService)
|
||||
service.store = Store()
|
||||
# Sessão que começou no MediaPipe: espera ele voltar, não troca para o OpenSeeFace no meio.
|
||||
with pytest.raises(FaceUnavailable, match="sem mediapipe"):
|
||||
service._default_tracker("mediapipe")
|
||||
assert seen == []
|
||||
# Sessão nova: o plano B só entra aqui.
|
||||
with pytest.raises(FaceUnavailable, match="plano B"):
|
||||
service._default_tracker(None)
|
||||
assert seen == ["osf_landmarks"]
|
||||
|
||||
|
||||
def test_session_backend_comes_from_the_series(env): # noqa: F811
|
||||
_client, engine = env
|
||||
asked = []
|
||||
|
||||
def factory(backend=None):
|
||||
asked.append(backend)
|
||||
return FakeTracker()
|
||||
service = make_service(engine, tracker_factory=factory)
|
||||
sid = seed_session(engine, duration=60)
|
||||
set_cam(engine, sid)
|
||||
service.step()
|
||||
service.step()
|
||||
assert asked == [None, "fake"]
|
||||
|
||||
|
||||
def test_crop_geometry_never_leaves_the_frame():
|
||||
for crop in ({"x": 0.95, "y": 0.9, "w": 0.3, "h": 0.4}, {"x": -0.1, "y": -0.2, "w": 1.5, "h": 1.5},
|
||||
{"x": 0.999, "y": 0.999, "w": 0.01, "h": 0.01}):
|
||||
(x, y, w, h), (ow, oh) = face_mod.crop_geometry(crop, (1280, 720))
|
||||
assert 0 <= x and 0 <= y and x + w <= 1280 and y + h <= 720 and w >= 2 and h >= 2
|
||||
assert x % 2 == y % 2 == w % 2 == h % 2 == 0 and ow >= 2 and oh >= 2
|
||||
|
||||
|
||||
def test_transient_detector_failure_is_not_saved_as_no_cam(env): # noqa: F811
|
||||
_client, engine = env
|
||||
service = make_service(engine)
|
||||
|
||||
def unavailable():
|
||||
raise FaceUnavailable("download do YuNet falhou")
|
||||
service._detector_factory = unavailable
|
||||
engine.judge.provider = "off"
|
||||
sid = seed_session(engine) # sessão 'processing' (não grava)
|
||||
engine.intel.maybe_detect_cam(session(engine, sid))
|
||||
assert session(engine, sid)["cam_json"] is None # nada permanente
|
||||
assert engine.intel._cam_retry_at[sid] > time.time()
|
||||
engine.intel.maybe_detect_cam(session(engine, sid)) # dentro da espera: nem tenta
|
||||
# Falha não passageira (poucos quadros) em sessão parada: grava com nova tentativa pelo relógio.
|
||||
engine.intel._cam_retry_at.clear()
|
||||
service._detector_factory = FakeDetector
|
||||
service._grabber = lambda *_a, **_k: None
|
||||
engine.intel.maybe_detect_cam(session(engine, sid))
|
||||
saved = json.loads(session(engine, sid)["cam_json"])
|
||||
assert saved["hasWebcam"] is False and saved["retryAt"] > time.time() and saved["attempts"] == 1
|
||||
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(saved | {"retryAt": 0}), sid)
|
||||
service._grabber = lambda *_a, **_k: FakeFrame()
|
||||
engine.intel.maybe_detect_cam(session(engine, sid))
|
||||
assert json.loads(session(engine, sid)["cam_json"])["hasWebcam"] is True
|
||||
@@ -0,0 +1,318 @@
|
||||
"""Formato do corte (vertical 9:16 / horizontal 16:9), durações padrão novas (60–90 s, volta até 2 min) e tempo da
|
||||
legenda com fala rápida (pedidos do dono, 16/11/2026)."""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
import sqlite3
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from app import db as db_module
|
||||
from app import editor, editor_render, layout, subtitles
|
||||
from app.scoring import ChatMessage, Word
|
||||
|
||||
from .test_editor import KEY, _lavfi_segments, api, make_project, validate # noqa: F401 - api é fixture
|
||||
|
||||
FFMPEG = shutil.which("ffmpeg")
|
||||
FFPROBE = shutil.which("ffprobe")
|
||||
HORIZONTAL = {"format": {"aspect": "horizontal"}}
|
||||
CAM = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- configuração: format e duration
|
||||
def test_format_validate_and_merge():
|
||||
assert layout.DEFAULTS["format"] == {"aspect": "vertical"}
|
||||
assert layout.merge()["format"]["aspect"] == "vertical"
|
||||
assert layout.validate({"format": {"aspect": "horizontal"}}) == {"format": {"aspect": "horizontal"}}
|
||||
assert layout.validate({"format": {}}) == {"format": {}}
|
||||
for bad in ({"format": {"aspect": "quadrado"}}, {"format": "horizontal"}):
|
||||
with pytest.raises(layout.LayoutError):
|
||||
layout.validate(bad)
|
||||
# padrão ← canal ← sessão ← projeto: a camada de cima vence; sem `format` (config antiga) = vertical.
|
||||
cfg = layout.merge({"format": {"aspect": "horizontal"}}, {"caption": {"size": 90}})
|
||||
assert layout.aspect(cfg) == "horizontal" and layout.frame_size(cfg) == (1920, 1080)
|
||||
assert layout.aspect(layout.merge(cfg, {"format": {"aspect": "vertical"}})) == "vertical"
|
||||
assert layout.aspect({"layout": {}}) == "vertical" and layout.frame_size(layout.merge()) == (1080, 1920)
|
||||
|
||||
|
||||
def test_duration_defaults_and_limits():
|
||||
assert layout.DEFAULTS["duration"] == {"minS": 60, "maxS": 90, "backtrackS": 120}
|
||||
assert layout.validate({"duration": {"minS": 120, "maxS": 180, "backtrackS": 120}})["duration"]["minS"] == 120
|
||||
for bad in ({"minS": 121}, {"minS": 4}, {"maxS": 181}, {"maxS": 14}, {"backtrackS": 121}, {"minS": 90, "maxS": 90},
|
||||
{"minS": 100, "maxS": 90}):
|
||||
with pytest.raises(layout.LayoutError):
|
||||
layout.validate({"duration": bad})
|
||||
|
||||
|
||||
def test_settings_routes_carry_format(api): # noqa: F811
|
||||
client, engine, _root = api
|
||||
h = {"X-Service-Key": KEY}
|
||||
r = client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "horizontal"}})
|
||||
assert r.status_code == 200, r.text
|
||||
body = r.json()
|
||||
assert body["own"] == {"format": {"aspect": "horizontal"}} and body["effective"]["format"]["aspect"] == "horizontal"
|
||||
assert body["defaults"]["format"]["aspect"] == "vertical" and body["defaults"]["duration"]["maxS"] == 90
|
||||
assert body["aspects"] == ["vertical", "horizontal"] and body["frames"]["horizontal"]["width"] == 1920
|
||||
assert client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "x"}}).status_code == 400
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- layout horizontal
|
||||
def test_horizontal_layout_modes():
|
||||
plain = layout.merge(HORIZONTAL)
|
||||
for mode in ("auto", "blur", "cam_top", "game_only"):
|
||||
cfg = layout.merge(HORIZONTAL, CAM, {"layout": {"mode": mode}})
|
||||
assert layout.resolved_mode(cfg) == "full"
|
||||
chain = layout.layout_chain(cfg, "in", "out")
|
||||
assert "vstack" not in chain and "boxblur" not in chain and "pad=1920:1080" in chain # quadro inteiro
|
||||
cam_only = layout.merge(HORIZONTAL, CAM, {"layout": {"mode": "cam_only"}})
|
||||
chain = layout.layout_chain(cam_only, "in", "out")
|
||||
assert layout.resolved_mode(cam_only) == "cam_only" and "crop=iw*0.2:ih*0.25:iw*0.02:ih*0.45" in chain
|
||||
assert "crop=1920:1080" in chain # câmera preenche 1920×1080 sem distorcer
|
||||
# cam_only sem câmera marcada: quadro inteiro; região do jogo marcada: recorta e preenche.
|
||||
assert layout.resolved_mode(layout.merge(HORIZONTAL, {"layout": {"mode": "cam_only"}})) == "full"
|
||||
game = layout.merge(HORIZONTAL, {"layout": {"game": {"x": 0.1, "y": 0.1, "w": 0.8, "h": 0.8}}})
|
||||
assert "crop=iw*0.8:ih*0.8:iw*0.1:ih*0.1,scale=1920:1080:force_original_aspect_ratio=increase,crop=1920:1080" in \
|
||||
layout.layout_chain(game, "in", "out")
|
||||
# troca de layout por trecho (editor) também respeita o formato
|
||||
assert "crop=iw*0.2" in layout.layout_chain(layout.merge(HORIZONTAL, CAM), "in", "out", mode="cam_only")
|
||||
assert layout.layout_chain(plain, "in", "out").startswith("[in]scale=1920:1080:force_original_aspect_ratio=decrease")
|
||||
|
||||
|
||||
def test_horizontal_ass_positions_and_sizes(tmp_path):
|
||||
data = make_project(settings=HORIZONTAL, chat={"enabled": True, "x": 0.02, "y": 0.9, "width": 0.3, "lines": 3})
|
||||
p = validate(data, tmp_path)
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
assert layout.aspect(cfg) == "horizontal"
|
||||
ass = editor_render.build_project_ass(p, cfg, "twitch.tv/x", chat=[ChatMessage(11.0, "KKKK", "ana")])
|
||||
assert "PlayResX: 2560" in ass and "PlayResY: 1440" in ass # quadro lógico (textos a 75 % no 1920×1080)
|
||||
assert "\\pos(1280,1224)" in ass # legenda automática: centro, 85 % da altura
|
||||
assert f"\\pos(1280,{int(1440 * 0.2)})" in ass # gancho (y relativo)
|
||||
assert f"\\an1\\pos({int(2560 * 0.02)},{int(1440 * 0.9)})" in ass # chat (x/y relativos)
|
||||
assert "m 0 0 l 2560 0 2560 12 0 12" in ass # barra de progresso na largura toda
|
||||
credit = next(line for line in ass.splitlines() if line.startswith("Style: Credit"))
|
||||
assert credit.endswith(",9,48,48,36,1") # crédito no canto superior direito
|
||||
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
|
||||
assert "s=1920x1080" in graph and "[1:v]scale=1920:1080" in graph # zoom e capa no tamanho do formato
|
||||
# legenda com y escolhido: fração da altura do quadro lógico
|
||||
q = validate(make_project(settings={**HORIZONTAL, "caption": {"y": 0.5}}), tmp_path)
|
||||
assert "\\pos(1280,720)" in editor_render.build_project_ass(q, editor.effective_settings(layout.merge(), q), "")
|
||||
|
||||
|
||||
def _golden_values() -> dict:
|
||||
"""Mesmas entradas usadas para gravar tests/data/vertical_golden_sha256.json com o código de ANTES do formato."""
|
||||
cam = {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}, "game": {"x": 0.3, "y": 0.1, "w": 0.6, "h": 0.8}}}
|
||||
g = {}
|
||||
for base_name, base in (("nocam", {}), ("cam", cam)):
|
||||
for mode in layout.MODES:
|
||||
cfg = layout.merge(base, {"layout": {"mode": mode}})
|
||||
g[f"chain-{base_name}-{mode}"] = layout.layout_chain(cfg, "in", "out", ",setsar=1", "_0")
|
||||
g[f"vf-{base_name}-{mode}"] = layout.video_filter(cfg, "a.ass")
|
||||
g[f"capy-{base_name}-{mode}"] = layout.caption_y(cfg)
|
||||
return g, cam
|
||||
|
||||
|
||||
def test_vertical_output_is_unchanged(tmp_path):
|
||||
"""O vertical continua idêntico ao de antes do formato (filtergraph, legenda, textos, chat, capa)."""
|
||||
expected = json.loads((Path(__file__).parent / "data" / "vertical_golden_sha256.json").read_text(encoding="utf-8"))
|
||||
g, cam = _golden_values()
|
||||
p = validate(make_project(chat={"enabled": True, "lines": 3}), tmp_path)
|
||||
chat = [ChatMessage(11.0, "KKKKKK", "ana"), ChatMessage(13.0, "server chinês", "beto")]
|
||||
for base_name, base in (("nocam", {}), ("cam", cam)):
|
||||
for preset in editor.CAPTION_PRESETS:
|
||||
q = json.loads(json.dumps(p))
|
||||
q["captions"]["preset"] = preset
|
||||
g[f"ass-{base_name}-{preset}"] = editor_render.build_project_ass(
|
||||
q, editor.effective_settings(layout.merge(base), q), "twitch.tv/x", chat=chat)
|
||||
cfg = editor.effective_settings(layout.merge(base), p)
|
||||
g[f"filter-{base_name}"] = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [], cover_input=1)
|
||||
words = [Word(1.0, 1.3, "olha"), Word(1.4, 1.8, "isso"), Word(1.9, 2.3, "aqui"), Word(3.5, 3.9, "caiu"), Word(4.0, 4.6, "mano")]
|
||||
g[f"subs-{base_name}"] = subtitles.build_ass(words, 0.5, 6.0, "twitch.tv/x", layout.merge(base))
|
||||
got = {k: hashlib.sha256(str(v).encode("utf-8")).hexdigest() for k, v in g.items()}
|
||||
assert set(got) == set(expected)
|
||||
assert [k for k in expected if got[k] != expected[k]] == []
|
||||
|
||||
|
||||
def test_old_project_without_format_stays_vertical(tmp_path):
|
||||
p = validate(make_project(settings={"caption": {"size": 90}}), tmp_path)
|
||||
assert "format" not in p["settings"]
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
assert layout.aspect(cfg) == "vertical" and "PlayResY: 1920" in editor_render.build_project_ass(p, cfg, "")
|
||||
# o projeto escolhe o formato por corte, por cima do canal/sessão
|
||||
q = validate(make_project(settings={"format": {"aspect": "vertical"}}), tmp_path)
|
||||
assert layout.aspect(editor.effective_settings(layout.merge(HORIZONTAL), q)) == "vertical"
|
||||
with pytest.raises(editor.EditError):
|
||||
validate(make_project(settings={"format": {"aspect": "4:3"}}), tmp_path)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- render real
|
||||
def _dark_segment(folder: Path, seconds: int = 8) -> Path:
|
||||
"""Bloco de vídeo escuro (texto claro aparece com clareza) com tom de teste."""
|
||||
seg = folder / "dark.ts"
|
||||
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0x202020:size=640x360:rate=30:duration={seconds}",
|
||||
"-f", "lavfi", "-i", f"sine=frequency=440:duration={seconds}", "-c:v", "libx264", "-preset", "ultrafast",
|
||||
"-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
|
||||
return seg
|
||||
|
||||
|
||||
def _gray_frame(video: Path, at: float, w: int, h: int) -> bytes:
|
||||
return subprocess.run([FFMPEG, "-v", "error", "-ss", f"{at:.2f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
|
||||
"-pix_fmt", "gray", "-"], capture_output=True, check=True).stdout[: w * h]
|
||||
|
||||
|
||||
def _bright(frame: bytes, w: int, x0: float, x1: float, y0: float, y1: float, h: int) -> int:
|
||||
return sum(1 for y in range(int(y0 * h), int(y1 * h)) for x in range(int(x0 * w), int(x1 * w), 2)
|
||||
if frame[y * w + x] > 200)
|
||||
|
||||
|
||||
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
|
||||
def test_real_horizontal_render(tmp_path):
|
||||
"""Render de verdade em 1920×1080: legenda, gancho, chat, zoom, barra, crédito e capa no início."""
|
||||
seg = _dark_segment(tmp_path)
|
||||
words = [{"s": 1.2 + i * 0.3, "e": 1.45 + i * 0.3, "w": w} for i, w in enumerate("olha isso aqui caiu mano".split())]
|
||||
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, settings=HORIZONTAL,
|
||||
cuts=[{"start": 1, "end": 4, "mode": None}, {"start": 4, "end": 7, "mode": "cam_only"}],
|
||||
overlays=[{"id": "hook", "kind": "hook", "text": "ELE NÃO ACREDITOU", "start": 0, "end": 2, "y": 0.2,
|
||||
"size": 70, "color": "#FFFFFF", "box": "#E11D48", "anim": "none"},
|
||||
{"id": "z", "kind": "zoom", "start": 5, "end": 6.5, "scale": 1.3, "x": 0.5, "y": 0.5, "ramp": 0.2}],
|
||||
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words},
|
||||
cover={"enabled": True, "t": 2, "text": "CAPA", "atStart": True},
|
||||
chat={"enabled": True, "x": 0.02, "y": 0.6, "width": 0.3, "lines": 3, "size": 40})
|
||||
p = validate(data, tmp_path, duration=8.0)
|
||||
base = layout.merge(CAM)
|
||||
segments = [(seg, 0.0, 8.0)]
|
||||
cover = editor_render.render_cover(FFMPEG, segments, p, base, "twitch.tv/x", tmp_path / "cover.jpg")
|
||||
out = tmp_path / "out.mp4"
|
||||
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], segments, p, base, "twitch.tv/x",
|
||||
out, tmp_path, chat=[ChatMessage(1.5, "KKKK", "ana"), ChatMessage(5.0, "F", "beto")],
|
||||
cover_file=cover)
|
||||
probe = subprocess.run([FFPROBE, "-v", "error", "-show_entries", "format=duration:stream=width,height", "-of", "csv=p=0",
|
||||
str(out)], capture_output=True, text=True, check=True).stdout
|
||||
assert "1920,1080" in probe and abs(float(probe.strip().splitlines()[-1]) - 6.0) < 0.2
|
||||
cover_probe = subprocess.run([FFPROBE, "-v", "error", "-show_entries", "stream=width,height", "-of", "csv=p=0", str(cover)],
|
||||
capture_output=True, text=True, check=True).stdout
|
||||
assert cover_probe.strip() == "1920,1080"
|
||||
w, h = 1920, 1080
|
||||
frame = _gray_frame(out, 1.0, w, h) # 1 s de saída = 2 s da sessão: gancho, legenda e chat na tela
|
||||
assert _bright(frame, w, 0.25, 0.75, 0.15, 0.25, h) > 200 # gancho em cima
|
||||
assert _bright(frame, w, 0.25, 0.75, 0.80, 0.90, h) > 200 # legenda no terço de baixo
|
||||
assert _bright(frame, w, 0.0, 0.3, 0.50, 0.60, h) > 50 # chat à esquerda
|
||||
assert _bright(frame, w, 0.7, 1.0, 0.0, 0.08, h) > 50 # crédito no canto de cima à direita
|
||||
assert _bright(frame, w, 0.0, 1.0, 0.30, 0.45, h) < 50 # o meio do jogo fica limpo
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- aspect no corte + migração v8
|
||||
def test_migration_v8_marks_old_clips_vertical(tmp_path):
|
||||
path = tmp_path / "old.db"
|
||||
conn = sqlite3.connect(path)
|
||||
for script in db_module.SCHEMA[:7]:
|
||||
for statement in db_module._split(script):
|
||||
conn.execute(statement)
|
||||
conn.execute("PRAGMA user_version = 7")
|
||||
conn.execute("INSERT INTO sessions (id, platform, kind, url, status, dir, started_at) VALUES (1, 'twitch', 'live', 'u', 'done', 'd', 'x')")
|
||||
conn.execute("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at) "
|
||||
"VALUES (1, 5, 0, 10, 1, 'chat', 'ready', 'x', 'x')")
|
||||
conn.commit()
|
||||
conn.close()
|
||||
database = db_module.Database(path)
|
||||
assert database.get("PRAGMA user_version")["user_version"] == len(db_module.SCHEMA) >= 8 # v9 (capture_json) em cima
|
||||
assert database.get("SELECT aspect FROM clips")["aspect"] == "vertical"
|
||||
with pytest.raises(sqlite3.IntegrityError):
|
||||
database.run("UPDATE clips SET aspect = 'quadrado'")
|
||||
database.close()
|
||||
|
||||
|
||||
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
|
||||
def test_clip_reports_rendered_aspect(api): # noqa: F811
|
||||
client, engine, root = api
|
||||
h = {"X-Service-Key": KEY}
|
||||
assert client.get("/v1/clips/7", headers=h).json()["aspect"] == "vertical" # antes do render: padrão
|
||||
_lavfi_segments(root / "data" / "s1")
|
||||
client.put("/v1/sessions/1/settings", headers=h, json={"format": {"aspect": "horizontal"}})
|
||||
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 7")
|
||||
engine.render_pending()
|
||||
clip = client.get("/v1/clips/7", headers=h).json()
|
||||
assert clip["status"] == "ready", clip["error"]
|
||||
assert clip["aspect"] == "horizontal"
|
||||
assert any(c["aspect"] == "horizontal" for c in client.get("/v1/clips", headers=h).json()["clips"])
|
||||
probe = subprocess.run([FFPROBE or "ffprobe", "-v", "error", "-select_streams", "v", "-show_entries", "stream=width,height",
|
||||
"-of", "csv=p=0", str(root / clip["file"])], capture_output=True, text=True, check=True).stdout
|
||||
assert probe.strip() == "1920,1080"
|
||||
# Prévia real do começo com capa no início: a capa é gerada também para a prévia.
|
||||
project = client.get("/v1/clips/7/edit", headers=h).json()
|
||||
project["project"]["cover"]["atStart"] = True
|
||||
assert client.put("/v1/clips/7/edit", headers=h, json=project).status_code == 200
|
||||
prev = client.post("/v1/clips/7/preview-render", headers=h, json={"fromS": 0, "durationS": 2})
|
||||
assert prev.status_code == 200, prev.text
|
||||
assert (root / "output" / "clipper" / "1" / "edit-7" / "preview-cover.jpg").is_file()
|
||||
# O projeto escolhe o formato por corte: vertical por cima da sessão horizontal.
|
||||
project = client.get("/v1/clips/7/edit", headers=h).json()
|
||||
project["project"]["settings"] = {"format": {"aspect": "vertical"}}
|
||||
assert client.put("/v1/clips/7/edit", headers=h, json=project).status_code == 200
|
||||
client.post("/v1/clips/7/export", headers=h)
|
||||
engine.render_pending()
|
||||
assert client.get("/v1/clips/7", headers=h).json()["aspect"] == "vertical"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- legenda com fala rápida
|
||||
def _fast_words() -> list[Word]:
|
||||
"""~7 palavras/s, com sobreposição (fim depois do início da seguinte), duração zero e duas no mesmo instante."""
|
||||
out, t = [], 0.3
|
||||
for i, text in enumerate("e aí mano olha isso que ele fez cara não acredito vai vai vai pega ele agora sim kkkk".split()):
|
||||
dur = 0.0 if i % 5 == 3 else 0.22 # algumas de 0 s (Whisper)
|
||||
out.append(Word(round(t, 3), round(t + dur, 3), text))
|
||||
t += 0.14
|
||||
out.append(Word(out[-1].start, out[-1].start + 0.2, "boa")) # mesmo instante da anterior
|
||||
return out
|
||||
|
||||
|
||||
def _caption_events(ass: str) -> list[tuple[float, float]]:
|
||||
def ts(s: str) -> float:
|
||||
hh, mm, ss = s.split(":")
|
||||
return int(hh) * 3600 + int(mm) * 60 + float(ss)
|
||||
rows = [line.split(",") for line in ass.splitlines() if re.match(r"Dialogue: 0,.*,(Caption|Karaoke),", line)]
|
||||
return sorted((ts(r[1]), ts(r[2])) for r in rows)
|
||||
|
||||
|
||||
def test_fast_speech_captions_never_overlap_and_stay_in_sync(tmp_path):
|
||||
raw = _fast_words()
|
||||
clean = subtitles.clean_words(raw)
|
||||
assert all(b.start > a.start and a.end <= b.start + 1e-9 for a, b in zip(clean, clean[1:])) # ordem, sem sobreposição
|
||||
assert all(w.end - w.start > 0 for w in clean)
|
||||
assert subtitles.clean_words(clean) == clean # idempotente
|
||||
# só a palavra que começava junto com a anterior foi empurrada (e no máximo 40 ms)
|
||||
shifts = [round(c.start - r.start, 3) for r, c in zip(sorted(raw, key=lambda w: (w.start, w.end)), clean)]
|
||||
assert [s for s in shifts if s] == [0.04]
|
||||
blocks = subtitles.caption_blocks(raw, 3)
|
||||
assert all(len(g) <= 4 for g, _ in blocks) and any(len(g) == 4 for g, _ in blocks) # fala rápida: +1 palavra
|
||||
for (g1, end1), (g2, _) in zip(blocks, blocks[1:]):
|
||||
assert end1 <= g2[0].start # um bloco sai antes do próximo entrar
|
||||
|
||||
# Render do editor (todos os presets, nos dois formatos) e do worker: nenhum par de eventos ao mesmo tempo, e
|
||||
# cada bloco entra no início da sua 1ª palavra (no centésimo do ASS).
|
||||
words = [{"s": w.start + 10, "e": w.end + 10, "w": w.word} for w in raw]
|
||||
starts = {round(w.start, 2) for w in clean}
|
||||
for settings in ({}, HORIZONTAL):
|
||||
for preset in editor.CAPTION_PRESETS:
|
||||
p = validate(make_project(settings=settings, cuts=[{"start": 10, "end": 20, "mode": None}], overlays=[],
|
||||
captions={"enabled": True, "preset": preset, "style": {}, "emphColor": "#22E36B",
|
||||
"words": words}), tmp_path)
|
||||
events = _caption_events(editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), ""))
|
||||
assert len(events) >= 5, preset
|
||||
assert all(b[0] >= a[1] - 1e-6 for a, b in zip(events, events[1:])), preset
|
||||
assert all(round(s, 2) in starts or any(abs(s - x) <= 0.011 for x in starts) for s, _ in events), preset
|
||||
events = _caption_events(subtitles.build_ass(raw, 0.0, 10.0, "", layout.merge(settings)))
|
||||
assert all(b[0] >= a[1] - 1e-6 for a, b in zip(events, events[1:]))
|
||||
|
||||
|
||||
def test_emphasis_and_highlight_survive_word_cleaning(tmp_path):
|
||||
words = [{"s": 11.0, "e": 11.3, "w": "olha"}, {"s": 11.0, "e": 11.2, "w": "isso", "emph": True},
|
||||
{"s": 11.25, "e": 11.25, "w": "aqui"}]
|
||||
p = validate(make_project(cuts=[{"start": 10, "end": 15, "mode": None}], overlays=[],
|
||||
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words}),
|
||||
tmp_path)
|
||||
ass = editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), "")
|
||||
assert "&H6BE322&" in ass # ênfase ainda casada com a palavra certa depois do saneamento
|
||||
assert len(_caption_events(ass)) == 3
|
||||
@@ -0,0 +1,54 @@
|
||||
"""Hashtags da legenda: canal e jogo fixos (perfil), momento da IA, sem repetidas, até 8."""
|
||||
|
||||
from app.hashtags import build_caption, compose, fold, split_hashtags, to_tag
|
||||
from app.intel import clean_profile
|
||||
from app.judge import _clean
|
||||
|
||||
|
||||
def test_to_tag_normalizes_names_and_phrases():
|
||||
assert to_tag("ROB RUN") == "#ROBRUN"
|
||||
assert to_tag("#Lamborghini") == "#Lamborghini"
|
||||
assert to_tag("perseguição policial") == "#PerseguiçãoPolicial"
|
||||
assert to_tag("Call of Duty: Warzone") == "#CallOfDutyWarzone"
|
||||
assert to_tag(" ") is None and to_tag("#123") is None and to_tag("!!!") is None
|
||||
|
||||
|
||||
def test_compose_puts_channel_then_game_then_moment_without_duplicates():
|
||||
profile = {"hashtags": ["#ROBRUN", "#RobRunGame", "#jogodeassalto", "#quarta"]}
|
||||
tags = compose("skipnho", "ROB RUN", profile, ["assalto ao banco", "RobRun", "Clã", "cla", "sorteio", "extra", "mais"])
|
||||
# Jogo: até 3 do perfil; momento: até 4; "RobRun"/"cla" repetem (sem maiúscula/acento) e saem.
|
||||
assert tags == ["#skipnho", "#ROBRUN", "#RobRunGame", "#jogodeassalto", "#AssaltoAoBanco", "#Clã"]
|
||||
assert fold("#Clã") == fold("#CLA")
|
||||
|
||||
|
||||
def test_compose_without_profile_uses_game_name_and_caps_at_eight():
|
||||
assert compose("skipnho", "ROB RUN", None, []) == ["#skipnho", "#ROBRUN"]
|
||||
many = compose("canal", "Jogo", {"hashtags": ["#a1", "#b2", "#c3"]}, [f"tag{i}" for i in range(10)])
|
||||
assert len(many) == 8
|
||||
|
||||
|
||||
def test_caption_layout_text_tags_credit():
|
||||
text, inline = split_hashtags("O clã vai ao banco #skipnho e o plano dá errado. #assalto")
|
||||
assert text == "O clã vai ao banco e o plano dá errado." and inline == ["#skipnho", "#assalto"]
|
||||
caption = build_caption(text, ["#skipnho", "#ROBRUN"], "🎥 Créditos: https://twitch.tv/skipnho")
|
||||
assert caption == "O clã vai ao banco e o plano dá errado.\n\n#skipnho #ROBRUN\n\n🎥 Créditos: https://twitch.tv/skipnho"
|
||||
assert build_caption("", [], "🎥 Créditos: x") == "🎥 Créditos: x"
|
||||
|
||||
|
||||
def test_profile_hashtags_are_cleaned():
|
||||
profile = clean_profile({"name": "ROB RUN", "hashtags": ["rob run", "#ROBRUN", "#robrun", "#123", "GTA RP"]})
|
||||
# "rob run" vira "#RobRun"; "#ROBRUN" e "#robrun" são a mesma tag (sem maiúscula) e saem.
|
||||
assert profile["hashtags"] == ["#RobRun", "#GTARP"]
|
||||
|
||||
|
||||
def test_api_accepts_hashtags_in_profile_edit_and_section_chat():
|
||||
from app.main import GameProfileIn, GameRefineIn
|
||||
|
||||
assert GameProfileIn(hashtags=["#ROBRUN"]).hashtags == ["#ROBRUN"]
|
||||
assert GameRefineIn(instruction="pesquise as hashtags", section="hashtags").section == "hashtags"
|
||||
|
||||
|
||||
def test_verdict_reads_moment_hashtags_and_tolerates_old_answers():
|
||||
base = {"keep": True, "score": 8, "start_s": 10, "end_s": 80, "title": "t", "caption": "c", "reason": "r"}
|
||||
assert _clean({**base, "hashtags": ["assalto", " ", "Lamborghini"]}, 10, 80, "m", 0, 200, 30, 90).hashtags == ("assalto", "Lamborghini")
|
||||
assert _clean(base, 10, 80, "m", 0, 200, 30, 90).hashtags == ()
|
||||
@@ -0,0 +1,225 @@
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from app import layout
|
||||
from app.emotes import EmoteCatalog, extract, message_bonus, parse_twitch_tag
|
||||
from app.judge import Judge
|
||||
from app.scoring import ChatMessage, find_moments
|
||||
from tests.test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- emotes
|
||||
def test_parse_twitch_emote_tag_uses_codepoints():
|
||||
text = "😂 Kappa oi LUL"
|
||||
assert parse_twitch_tag("25:2-6/425618:11-13", text) == ["Kappa", "LUL"]
|
||||
assert parse_twitch_tag("", text) == []
|
||||
assert parse_twitch_tag("25:90-99", text) == [] # posição fora do texto não quebra
|
||||
|
||||
|
||||
def test_extract_third_party_and_emoji():
|
||||
found = extract("PepeLaugh mano 😂 Kappa", ["Kappa"], {"PepeLaugh": "bttv", "mano": "7tv"})
|
||||
assert ("Kappa", "twitch") in found and ("PepeLaugh", "bttv") in found and ("😂", "emoji") in found
|
||||
|
||||
|
||||
def test_message_bonus_learned_and_clamped():
|
||||
assert message_bonus([], {}) == 0
|
||||
assert message_bonus(["skpPog"], {}) == pytest.approx(0.4)
|
||||
assert message_bonus(["skpPog"], {"skpPog": 2.0}) == pytest.approx(2.4)
|
||||
assert message_bonus(["a", "b"], {"a": 3, "b": 3}) == 3.0
|
||||
|
||||
|
||||
def test_catalog_tolerates_failing_sources():
|
||||
def fetch(url):
|
||||
if "7tv" in url:
|
||||
raise TimeoutError
|
||||
if "betterttv" in url and "users" in url:
|
||||
return {"channelEmotes": [{"code": "skpPog"}], "sharedEmotes": [{"code": "PepeLaugh"}]}
|
||||
if "betterttv" in url:
|
||||
return [{"code": "FeelsGoodMan"}]
|
||||
return None
|
||||
catalog = EmoteCatalog(fetch)
|
||||
names = catalog.names("123")
|
||||
assert names["skpPog"] == "bttv" and "FeelsGoodMan" in names
|
||||
assert catalog.cached("123")["PepeLaugh"] == "bttv"
|
||||
assert catalog.cached("999").get("skpPog") is None
|
||||
|
||||
|
||||
def test_emote_only_reactions_make_a_peak_in_small_chat():
|
||||
# Live pequena: ninguém escreve "kkkk", só manda emote do canal.
|
||||
calm = [ChatMessage(t * 7.0, "salve") for t in range(130)]
|
||||
burst = [ChatMessage(500 + i, "skpPog", emotes=("skpPog",), bonus=0.4) for i in range(5)]
|
||||
moments = [m for m in find_moments(900, calm + burst, [], []) if m.source == "chat"]
|
||||
assert len(moments) == 1 and moments[0].reasons["emotes"] == {"skpPog": 5}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- layout
|
||||
def test_layout_validate_and_merge():
|
||||
own = layout.validate({"layout": {"mode": "cam_top", "cam": {"x": 0.01, "y": 0.46, "w": 0.2, "h": 0.3}},
|
||||
"caption": {"color": "#ffffff", "highlight": "#00ff88", "size": 90}})
|
||||
cfg = layout.merge({"caption": {"size": 70}}, own)
|
||||
assert cfg["caption"]["size"] == 90 and cfg["caption"]["highlight"] == "#00FF88"
|
||||
assert layout.resolved_mode(cfg) == "cam_top"
|
||||
for bad in ({"layout": {"mode": "x"}}, {"layout": {"cam": {"x": 0.9, "y": 0, "w": 0.5, "h": 0.3}}},
|
||||
{"caption": {"color": "red"}}, {"duration": {"minS": 60, "maxS": 30}}):
|
||||
with pytest.raises(layout.LayoutError):
|
||||
layout.validate(bad)
|
||||
|
||||
|
||||
def test_layout_filters():
|
||||
cam = layout.merge({"layout": {"cam": {"x": 0, "y": 0.5, "w": 0.2, "h": 0.3}}})
|
||||
f = layout.video_filter(cam, "c.ass")
|
||||
assert "vstack" in f and "ass=c.ass" in f and "crop=iw*0.2:ih*0.3:iw*0:ih*0.5" in f
|
||||
assert layout.caption_y(cam) == layout.cam_panel_height(cam) + 40 # legenda na emenda câmera/jogo
|
||||
assert "boxblur" in layout.video_filter(layout.merge(), None) # sem câmera: layout desfocado
|
||||
assert layout.ass_color("#FFE500") == "&H0000E5FF&" and layout.ass_inline_color("#FFE500") == "&H00E5FF&"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- API + motor
|
||||
def test_settings_api_channel_and_session(env): # noqa: F811
|
||||
client, engine = env
|
||||
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
|
||||
r = client.put("/v1/channels/twitch-alanzoka/settings",
|
||||
json={"layout": {"cam": {"x": 0.7, "y": 0.0, "w": 0.3, "h": 0.3}}}, headers=auth())
|
||||
assert r.status_code == 200 and r.json()["effective"]["layout"]["cam"]["x"] == 0.7
|
||||
assert client.put("/v1/channels/twitch-alanzoka/settings", json={"caption": {"size": 999}}, headers=auth()).status_code == 400
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
|
||||
r = client.put(f"/v1/sessions/{sid}/settings", json={"caption": {"highlight": "#FF0000"}}, headers=auth())
|
||||
eff = r.json()["effective"]
|
||||
assert eff["caption"]["highlight"] == "#FF0000" and eff["layout"]["cam"]["x"] == 0.7 # sessão sobre o canal
|
||||
|
||||
|
||||
def test_user_approval_teaches_emote_weights(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
wall = engine.db.get("SELECT wall_end FROM segments WHERE session_id = ? AND idx = 10", sid)["wall_end"]
|
||||
engine.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, 'u', 'skpPog', ?)",
|
||||
[(sid, wall - 28 + i, json.dumps(["skpPog"])) for i in range(4)])
|
||||
engine.db.run("INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen)"
|
||||
" VALUES ('twitch-alanzoka', 'skpPog', 'bttv', 4, 0, 'x', 'x')")
|
||||
engine.db.run("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at)"
|
||||
" VALUES (?, 304, 290, 320, 5, 'chat', 'ready', 'x', 'x')", sid)
|
||||
clip_id = engine.db.get("SELECT id FROM clips WHERE session_id = ?", sid)["id"]
|
||||
client.patch(f"/v1/clips/{clip_id}", json={"status": "approved"}, headers=auth())
|
||||
client.patch(f"/v1/clips/{clip_id}", json={"status": "approved"}, headers=auth()) # repetir não soma de novo
|
||||
weight = engine.db.get("SELECT weight FROM emotes WHERE name = 'skpPog'")["weight"]
|
||||
assert weight == pytest.approx(0.3)
|
||||
emotes = client.get("/v1/emotes?channel=twitch-alanzoka", headers=auth()).json()["emotes"]
|
||||
assert emotes[0]["name"] == "skpPog" and emotes[0]["weight"] == 0.3
|
||||
|
||||
|
||||
class ScanJudge(Judge):
|
||||
def __init__(self):
|
||||
super().__init__("codex", "fake", __import__("pathlib").Path("."))
|
||||
self.prompts = []
|
||||
|
||||
def scan(self, prompt, images):
|
||||
self.prompts.append(prompt)
|
||||
return {"screen_game": "ROB RUN", "has_webcam": True, "summary": "tiroteio na base",
|
||||
"moments": [{"score": 8, "start_s": 100, "end_s": 140, "title": "Emboscada", "caption": "c #robrun",
|
||||
"reason": "virada"},
|
||||
{"score": 3, "start_s": 150, "end_s": 175, "title": "fraco", "caption": "", "reason": "morno"}]}
|
||||
|
||||
|
||||
def test_scan_creates_clips_without_chat_peak(env): # noqa: F811
|
||||
client, engine = env
|
||||
engine.judge = ScanJudge()
|
||||
engine.intel.opts["vision"] = False # sem ffmpeg nos testes
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET status = 'recording', game = 'ROB RUN' WHERE id = ?", sid)
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
assert engine.intel.scan_session(session) == 1 # a proposta nota 3 nem vai aos juízes
|
||||
clips = client.get(f"/v1/clips?session={sid}", headers=auth()).json()["clips"]
|
||||
assert len(clips) == 1 and clips[0]["status"] == "candidate" and clips[0]["source"] == "ai"
|
||||
assert clips[0]["reasons"]["proposalTitle"] == "Emboscada"
|
||||
s2 = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
|
||||
assert s2["scannedUntilS"] == 180 and s2["screenGame"] == "ROB RUN" and s2["memory"][0]["summary"] == "tiroteio na base"
|
||||
# janela seguinte também é varrida; a anterior não é repetida
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
engine.intel.scan_session(session)
|
||||
assert "Janela nova: 180s a 360s" in engine.judge.prompts[-1]
|
||||
|
||||
|
||||
def test_game_override_and_chat_ingest(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
r = client.put(f"/v1/sessions/{sid}/game", json={"name": "GTA VI"}, headers=auth())
|
||||
assert r.json()["game"] == "GTA VI" and r.json()["gameSource"] == "user"
|
||||
assert client.get("/v1/games", headers=auth()).json()["games"][0]["status"] == "pending"
|
||||
engine.intel.ingest_chat(sid, "twitch-alanzoka", None, [(20000.0, "u", "Kappa kkk 😂", ["Kappa"])])
|
||||
row = engine.db.get("SELECT emotes FROM chat WHERE wall = 20000.0")
|
||||
assert json.loads(row["emotes"]) == ["Kappa", "😂"]
|
||||
uses = {r["name"]: r["uses"] for r in engine.db.all("SELECT name, uses FROM emotes")}
|
||||
assert uses == {"Kappa": 1, "😂": 1}
|
||||
|
||||
|
||||
def test_resume_and_finish_interrupted_session(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
|
||||
engine.check_live = lambda url: (False, "") # canal offline: não dá para retomar
|
||||
r = client.post(f"/v1/sessions/{sid}/resume", headers=auth())
|
||||
assert r.status_code == 400 and "não está ao vivo" in r.json()["error"]
|
||||
started = []
|
||||
engine.check_live = lambda url: (True, "título")
|
||||
|
||||
class FakeCapture:
|
||||
def __init__(self, eng, session_id, source, workdir, start_idx=0):
|
||||
started.append(start_idx)
|
||||
self.chat = None
|
||||
|
||||
def start(self):
|
||||
pass
|
||||
|
||||
import app.worker as worker_module
|
||||
original = worker_module.Capture
|
||||
worker_module.Capture = FakeCapture
|
||||
try:
|
||||
r = client.post(f"/v1/sessions/{sid}/resume", headers=auth())
|
||||
finally:
|
||||
worker_module.Capture = original
|
||||
assert r.status_code == 200 and r.json()["status"] == "starting"
|
||||
assert started == [20] # 20 blocos já existiam (0–19): continua a numeração
|
||||
engine.captures.clear()
|
||||
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
|
||||
r = client.post(f"/v1/sessions/{sid}/finish", headers=auth())
|
||||
assert r.json()["status"] == "processing"
|
||||
|
||||
|
||||
def test_startup_marks_recording_as_interrupted_and_remembers(tmp_path):
|
||||
from app.db import Database
|
||||
db = Database(tmp_path / "c.db")
|
||||
db.run("INSERT INTO sessions (platform, kind, url, status, chat_status, dir, started_at) VALUES"
|
||||
" ('twitch', 'live', 'https://www.twitch.tv/x', 'recording', 'connected', '', 'x')")
|
||||
db.run("INSERT INTO sessions (platform, kind, url, status, chat_status, dir, started_at) VALUES"
|
||||
" ('twitch', 'live', 'https://www.twitch.tv/y', 'interrupted', 'connected', '', 'x')")
|
||||
db.close()
|
||||
db = Database(tmp_path / "c.db")
|
||||
rows = db.all("SELECT status, chat_status FROM sessions ORDER BY id")
|
||||
assert db.interrupted_on_start == [1]
|
||||
assert rows == [{"status": "interrupted", "chat_status": "off"}, {"status": "interrupted", "chat_status": "off"}]
|
||||
|
||||
|
||||
def test_confirmed_game_silences_screen_doubt(env): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET game = 'ROB RUN', game_source = 'platform', screen_game = 'Call of Duty: Warzone' WHERE id = ?", sid)
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
assert "Warzone" in engine.intel.context(session) # sem confirmação: a dúvida vai para os juízes
|
||||
client.put(f"/v1/sessions/{sid}/game", json={"name": "ROB RUN"}, headers=auth())
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
ctx = engine.intel.context(session)
|
||||
assert "CONFIRMADO" in ctx and "visto na tela" not in ctx and "Call of Duty" not in ctx
|
||||
engine.check_meta = lambda url: {"title": "", "category": "Grand Theft Auto V", "author": ""}
|
||||
engine.intel.check_game(session, force=True) # checagem automática não troca jogo confirmado
|
||||
assert engine.db.get("SELECT game_source FROM sessions WHERE id = ?", sid)["game_source"] == "user"
|
||||
|
||||
|
||||
def test_research_pending_is_quiet_with_ai_off(env): # noqa: F811
|
||||
"""IA desligada: o jogo fica 'pending' sem erro (antes o laço de contexto logava um WARNING a cada 30 s)."""
|
||||
_client, engine = env
|
||||
engine.judge = Judge("off", "", engine.settings.data_dir / "judge")
|
||||
engine.db.run("INSERT INTO games (id, name, status) VALUES ('rob-run', 'ROB RUN', 'pending')")
|
||||
engine.intel.research_pending()
|
||||
assert engine.db.get("SELECT status FROM games WHERE id = 'rob-run'")["status"] == "pending"
|
||||
@@ -0,0 +1,353 @@
|
||||
import json
|
||||
import random
|
||||
|
||||
import pytest
|
||||
|
||||
from app.reaction import (
|
||||
FaceSample, FaceSecond, ReactionParams, label, locate_cam, per_second, reaction_moments, reaction_signal,
|
||||
seconds_from_json, seconds_to_json, summarize,
|
||||
)
|
||||
|
||||
FPS = 6
|
||||
|
||||
|
||||
def neutral_blend(rng: random.Random, smile: float = 0.05) -> dict[str, float]:
|
||||
"""Rosto parado: blendshapes baixos com ruído (fala/tique), sorriso no nível pedido."""
|
||||
n = lambda base: max(0.0, min(1.0, base + rng.uniform(-0.03, 0.03))) # noqa: E731
|
||||
return {
|
||||
"mouthSmileLeft": n(smile), "mouthSmileRight": n(smile), "jawOpen": n(0.08),
|
||||
"eyeWideLeft": n(0.05), "eyeWideRight": n(0.05), "browInnerUp": n(0.05),
|
||||
"browOuterUpLeft": n(0.04), "browOuterUpRight": n(0.04), "browDownLeft": n(0.05), "browDownRight": n(0.05),
|
||||
"eyeBlinkLeft": n(0.1), "eyeBlinkRight": n(0.1),
|
||||
}
|
||||
|
||||
|
||||
def track(duration: int, seed: int = 1, smile: float = 0.05, events: dict | None = None,
|
||||
absent: range | None = None) -> list[FaceSample]:
|
||||
"""Quadros a 6 qps. `events`: {segundo: função(blend, rng) → (blend, dx, dy)} para injetar reações."""
|
||||
rng = random.Random(seed)
|
||||
events = events or {}
|
||||
out = []
|
||||
for i in range(duration * FPS):
|
||||
t = i / FPS
|
||||
if absent is not None and int(t) in absent:
|
||||
out.append(FaceSample(t, False))
|
||||
continue
|
||||
blend, dx, dy = neutral_blend(rng, smile), 0.0, 0.0
|
||||
if int(t) in events:
|
||||
blend, dx, dy = events[int(t)](blend, rng)
|
||||
cx = 0.5 + rng.uniform(-0.005, 0.005) + dx
|
||||
cy = 0.4 + rng.uniform(-0.005, 0.005) + dy
|
||||
out.append(FaceSample(t, True, cx, cy, 0.3, blend))
|
||||
return out
|
||||
|
||||
|
||||
def laugh(blend, rng):
|
||||
blend |= {"mouthSmileLeft": 0.9, "mouthSmileRight": 0.85, "jawOpen": 0.7}
|
||||
return blend, 0.0, rng.uniform(-0.02, 0.02)
|
||||
|
||||
|
||||
def scream(blend, rng):
|
||||
blend |= {"mouthSmileLeft": 0.02, "mouthSmileRight": 0.02, "jawOpen": 0.85}
|
||||
return blend, 0.0, 0.0
|
||||
|
||||
|
||||
def startle(blend, rng):
|
||||
blend |= {"eyeWideLeft": 0.8, "eyeWideRight": 0.8, "browInnerUp": 0.7, "browOuterUpLeft": 0.6,
|
||||
"browOuterUpRight": 0.6}
|
||||
return blend, rng.choice([-1, 1]) * 0.1, rng.uniform(-0.08, 0.08)
|
||||
|
||||
|
||||
# --- série e sinal ------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_per_second_shapes_and_none_without_face():
|
||||
seconds = per_second(track(10, absent=range(4, 6)), 10)
|
||||
assert [s.t for s in seconds] == list(range(10))
|
||||
assert seconds[0].present == 1.0 and 0.0 <= seconds[0].smile <= 0.1 and seconds[0].size == 0.3
|
||||
assert seconds[4].present == 0.0 and seconds[4].smile is None and seconds[4].cx is None
|
||||
assert seconds[0].motion is not None and seconds[0].motion < 0.5
|
||||
|
||||
|
||||
def test_json_roundtrip_is_compact_and_rounded():
|
||||
seconds = per_second(track(5, absent=range(2, 3)), 5)
|
||||
data = seconds_to_json(seconds)
|
||||
assert "smile" not in data[2] and data[2]["present"] == 0.0
|
||||
assert all(len(str(v).split(".")[-1]) <= 3 for d in data for v in d.values() if isinstance(v, float))
|
||||
back = seconds_from_json(json.loads(json.dumps(data)))
|
||||
assert back[2].smile is None and abs(back[0].cx - seconds[0].cx) < 1e-3
|
||||
|
||||
|
||||
def test_neutral_with_noise_has_no_peak():
|
||||
seconds = per_second(track(300, seed=3), 300)
|
||||
assert reaction_moments(seconds) == []
|
||||
signal = reaction_signal(seconds)
|
||||
assert max(v for v in signal if v is not None) < ReactionParams().threshold
|
||||
|
||||
|
||||
def test_laugh_is_a_peak_with_right_label_and_onset():
|
||||
events = {t: laugh for t in range(200, 205)}
|
||||
seconds = per_second(track(300, events=events), 300)
|
||||
moments = reaction_moments(seconds)
|
||||
assert len(moments) == 1
|
||||
m = moments[0]
|
||||
assert m.label == "risada" and 200 <= m.peak_s <= 204
|
||||
assert m.onset_s == 200 # a reação começa exatamente onde o evento começou
|
||||
assert m.end_s >= 204 and m.strong
|
||||
|
||||
|
||||
def test_constant_smiling_streamer_is_not_a_false_positive():
|
||||
# Streamer de "neutro sorridente": o sorriso alto é o normal dele, não reação.
|
||||
seconds = per_second(track(300, seed=5, smile=0.65), 300)
|
||||
assert reaction_moments(seconds) == []
|
||||
# E uma risada de verdade nesse mesmo streamer ainda aparece (pela boca).
|
||||
events = {t: (lambda b, r: (b | {"jawOpen": 0.7, "mouthSmileLeft": 0.8, "mouthSmileRight": 0.8}, 0.0, 0.0))
|
||||
for t in range(150, 154)}
|
||||
moments = reaction_moments(per_second(track(300, seed=5, smile=0.65, events=events), 300))
|
||||
assert [m.label for m in moments] == ["risada"]
|
||||
|
||||
|
||||
def test_scream_versus_laugh():
|
||||
events = {t: scream for t in range(100, 103)} | {t: laugh for t in range(200, 203)}
|
||||
moments = reaction_moments(per_second(track(300, events=events), 300))
|
||||
assert [(m.label, 100 <= m.peak_s <= 102 or 200 <= m.peak_s <= 202) for m in moments] == [
|
||||
("grito", True), ("risada", True)]
|
||||
|
||||
|
||||
def test_startle_versus_shock():
|
||||
still = lambda b, r: (startle(b, r)[0], 0.0, 0.0) # noqa: E731 — olhos/sobrancelha sem pulo da cabeça
|
||||
events = {t: startle for t in range(100, 102)} | {t: still for t in range(200, 202)}
|
||||
labels = [m.label for m in reaction_moments(per_second(track(300, events=events), 300))]
|
||||
assert labels == ["susto", "choque"]
|
||||
|
||||
|
||||
def test_seconds_without_face_are_none_and_never_peak():
|
||||
# Rosto some exatamente na hora em que haveria uma "risada": não pode virar pico.
|
||||
events = {t: laugh for t in range(150, 155)}
|
||||
seconds = per_second(track(300, events=events, absent=range(148, 158)), 300)
|
||||
signal = reaction_signal(seconds)
|
||||
assert all(signal[t] is None for t in range(148, 158))
|
||||
assert reaction_moments(seconds) == []
|
||||
|
||||
|
||||
def test_label_without_z_uses_absolute_thresholds():
|
||||
s = FaceSecond(0, 1.0, 0.5, 0.4, 0.3, smile=0.8, jaw=0.7, surprise=0.1, frown=0.0, blink=0.1, motion=0.1)
|
||||
assert label(s) == "risada"
|
||||
s.smile = 0.0
|
||||
assert label(s) == "grito"
|
||||
assert label(FaceSecond(1, 0.0)) == "neutro"
|
||||
assert label(FaceSecond(2, 1.0, smile=0.0, jaw=0.0, surprise=0.0, frown=0.6, motion=0.0)) == "raiva"
|
||||
|
||||
|
||||
def test_summarize_text_for_the_judge():
|
||||
events = {t: laugh for t in range(200, 204)} | {t: startle for t in range(215, 217)}
|
||||
seconds = per_second(track(300, events=events), 300)
|
||||
text = summarize(seconds, 190, 230)
|
||||
assert text.startswith("risada forte em 1") and "susto" in text and "; " in text
|
||||
assert summarize(seconds, 20, 60) == "sem reação marcante no rosto"
|
||||
gone = per_second(track(100, absent=range(0, 100)), 100)
|
||||
assert summarize(gone, 0, 50) == "rosto do streamer não aparece no trecho"
|
||||
|
||||
|
||||
# --- câmera -------------------------------------------------------------------------------------------------------
|
||||
|
||||
W, H = 1920, 1080
|
||||
|
||||
|
||||
def cam_face(rng: random.Random) -> tuple[float, float, float, float, float]:
|
||||
"""Rosto da câmera no canto inferior esquerdo, com tremida de poucos pixels."""
|
||||
return (120 + rng.uniform(-4, 4), 700 + rng.uniform(-4, 4), 110, 130, 0.9)
|
||||
|
||||
|
||||
def inside_unit(rect: dict) -> bool:
|
||||
return (0 <= rect["x"] <= 1 and 0 <= rect["y"] <= 1 and rect["w"] > 0 and rect["h"] > 0
|
||||
and rect["x"] + rect["w"] <= 1 + 1e-9 and rect["y"] + rect["h"] <= 1 + 1e-9)
|
||||
|
||||
|
||||
def test_locate_cam_stable_corner():
|
||||
rng = random.Random(1)
|
||||
frames = [[cam_face(rng)] for _ in range(12)]
|
||||
result = locate_cam(frames, W, H)
|
||||
assert result["hasWebcam"] and not result["fullFrame"] and result["confidence"] > 0.7
|
||||
cam, face = result["cam"], result["faceRect"]
|
||||
assert inside_unit(cam) and inside_unit(face)
|
||||
# O rosto fica dentro do retângulo da câmera, que está no canto inferior esquerdo.
|
||||
assert cam["x"] <= face["x"] and cam["y"] <= face["y"]
|
||||
assert face["x"] + face["w"] <= cam["x"] + cam["w"] and face["y"] + face["h"] <= cam["y"] + cam["h"]
|
||||
assert cam["x"] < 0.1 and cam["y"] > 0.4 and cam["w"] < 0.3
|
||||
|
||||
|
||||
def test_locate_cam_ignores_cutscene_face():
|
||||
rng = random.Random(2)
|
||||
frames = [[cam_face(rng)] for _ in range(12)]
|
||||
frames[3].append((900, 300, 200, 240, 0.95)) # rosto do personagem na cutscene, só em 2 de 12 quadros
|
||||
frames[4].append((905, 302, 198, 238, 0.95))
|
||||
result = locate_cam(frames, W, H)
|
||||
assert result["hasWebcam"] and result["faceRect"]["x"] < 0.1
|
||||
# Só a cutscene (sem câmera): nada.
|
||||
only = [[] for _ in range(12)]
|
||||
only[3], only[4] = [(900, 300, 200, 240, 0.95)], [(905, 302, 198, 238, 0.95)]
|
||||
assert locate_cam(only, W, H)["hasWebcam"] is False
|
||||
|
||||
|
||||
def test_locate_cam_full_frame():
|
||||
rng = random.Random(3)
|
||||
frames = [[(760 + rng.uniform(-10, 10), 250, 420, 520, 0.95)] for _ in range(10)]
|
||||
result = locate_cam(frames, W, H)
|
||||
assert result["hasWebcam"] and result["fullFrame"] and result["cam"] == {"x": 0, "y": 0, "w": 1, "h": 1}
|
||||
|
||||
|
||||
def test_locate_cam_no_face():
|
||||
result = locate_cam([[] for _ in range(12)], W, H)
|
||||
assert result == {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
|
||||
assert locate_cam([], W, H)["hasWebcam"] is False
|
||||
# Detecções fracas (score baixo) não contam.
|
||||
assert locate_cam([[(120, 700, 110, 130, 0.3)] for _ in range(12)], W, H)["hasWebcam"] is False
|
||||
|
||||
|
||||
def test_locate_cam_rect_clipped_and_snapped_to_frame_edges():
|
||||
# Rosto colado no canto: a expansão passaria da borda do quadro e precisa ser recortada em 0..1.
|
||||
frames = [[(10, 950, 110, 120, 0.9)] for _ in range(8)]
|
||||
result = locate_cam(frames, W, H)
|
||||
assert inside_unit(result["cam"]) and result["cam"]["x"] == 0
|
||||
# Com bordas persistentes da moldura, o retângulo encaixa nelas.
|
||||
rng = random.Random(4)
|
||||
frames = [[cam_face(rng)] for _ in range(12)]
|
||||
edges = {"xs": [0.02, 0.2, 0.7], "ys": [0.55, 0.95, 0.1]}
|
||||
cam = locate_cam(frames, W, H, edges=edges)["cam"]
|
||||
assert cam == {"x": 0.02, "y": 0.55, "w": 0.18, "h": 0.4}
|
||||
|
||||
|
||||
# --- ajustes da bancada (números reais da sessão 3, doc/FACE_BAKEOFF.md) ------------------------------------------
|
||||
|
||||
|
||||
def real_calm(n: int, seed: int = 7) -> list[FaceSecond]:
|
||||
"""Neutro como o da live real: sorriso por segundo 0,02–0,25 (mediana ~0,1), boca ~0, olho arregalado ~0."""
|
||||
rng = random.Random(seed)
|
||||
return [FaceSecond(t, 1.0, 0.5, 0.4, 0.3, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.01),
|
||||
surprise=rng.uniform(0.0, 0.004), frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.01, 0.05),
|
||||
blink=0.1, motion=rng.uniform(0.02, 0.15)) for t in range(n)]
|
||||
|
||||
|
||||
def test_real_calm_with_isolated_spikes_has_no_peak():
|
||||
# No calmo real houve um segundo com sorriso 0,38 e outro com browInnerUp 0,38: não é reação.
|
||||
seconds = real_calm(300)
|
||||
seconds[200].smile = 0.38
|
||||
seconds[250].brow = 0.38
|
||||
assert reaction_moments(seconds) == []
|
||||
|
||||
|
||||
def test_laugh_without_open_mouth_is_risada():
|
||||
# Corte 10/12: sorriso 0,84–0,95 por vários segundos com jawOpen ≤ 0,11.
|
||||
seconds = real_calm(300)
|
||||
for t in range(200, 210):
|
||||
seconds[t].smile, seconds[t].jaw = 0.9, 0.05
|
||||
moments = reaction_moments(seconds)
|
||||
assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 200 and moments[0].strong
|
||||
|
||||
|
||||
def test_shout_is_jaw_and_brow_down_without_smile():
|
||||
# Corte 10, 1628 s: jawOpen 0,42 + browDown forte, sorriso 0,06 naquele segundo.
|
||||
seconds = real_calm(300)
|
||||
seconds[200].smile, seconds[200].jaw, seconds[200].frown = 0.06, 0.42, 0.5
|
||||
seconds[250].frown = 0.6 # franziu de boca fechada
|
||||
labels = [(m.peak_s, m.label) for m in reaction_moments(seconds)]
|
||||
assert labels == [(200, "grito"), (250, "raiva")]
|
||||
|
||||
|
||||
def test_confused_brow_inner_up_without_smile():
|
||||
# Corte 9 (lag): browInnerUp 0,7–0,8 por ~6 s, sorriso baixo, eyeWide ~0.
|
||||
seconds = real_calm(300)
|
||||
for t in range(200, 206):
|
||||
seconds[t].brow = 0.78
|
||||
moments = reaction_moments(seconds)
|
||||
assert [m.label for m in moments] == ["confuso"] and moments[0].onset_s == 200
|
||||
|
||||
|
||||
def test_surprise_does_not_need_eye_wide():
|
||||
# Na live real eyeWide fica ~0: sobrancelha (interna OU externa) levantada é o canal `brow`; parada = confuso,
|
||||
# com a cabeça se mexendo = susto. Olho arregalado parado continua sendo choque.
|
||||
blend = {"browOuterUpLeft": 0.7, "browOuterUpRight": 0.7, "eyeWideLeft": 0.0, "eyeWideRight": 0.0}
|
||||
second = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, blend)], 1)[0]
|
||||
assert second.brow == pytest.approx(0.7) and second.surprise == 0.0
|
||||
assert label(second) == "confuso"
|
||||
second.motion = 0.9
|
||||
assert label(second) == "susto"
|
||||
eyes = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, {"eyeWideLeft": 0.8, "eyeWideRight": 0.8})], 1)[0]
|
||||
assert label(eyes) == "choque"
|
||||
|
||||
|
||||
def test_motion_alone_or_with_flickering_face_is_not_a_peak():
|
||||
# Rastreio pulando (rosto em 1/3 do segundo) dava "susto" de intensidade 13 na live real.
|
||||
seconds = real_calm(300)
|
||||
seconds[200].present, seconds[200].motion, seconds[200].brow = 0.33, 3.0, 0.2
|
||||
seconds[250].motion = 3.0 # só movimento, rosto inteiro: ajeitou a cadeira
|
||||
assert reaction_moments(seconds) == []
|
||||
|
||||
|
||||
def test_old_series_without_brow_still_works():
|
||||
# Série gravada antes do canal `brow`: o canal fica parado, sem quebrar.
|
||||
data = seconds_to_json(real_calm(60))
|
||||
for d in data:
|
||||
d.pop("brow", None)
|
||||
assert all(v is not None for v in reaction_signal(seconds_from_json(data)))
|
||||
|
||||
|
||||
def test_summarize_absolute_times_for_the_prompt():
|
||||
seconds = real_calm(300)
|
||||
for t in range(200, 205):
|
||||
seconds[t].smile = 0.9
|
||||
assert summarize(seconds, 190, 230, relative=False).startswith("risada forte em 20")
|
||||
|
||||
|
||||
def test_locate_cam_leaning_streamer_stays_one_group():
|
||||
# Câmera grande (rosto ~0,16 do quadro): ele se inclina 0,8 largura de rosto em metade dos quadros.
|
||||
# Com distância fixa em fração do quadro (ou comparando com o 1º membro) o grupo se partia em dois.
|
||||
rng = random.Random(9)
|
||||
frames = []
|
||||
for i in range(12):
|
||||
lean = 0.8 * 300 if i % 2 else 0
|
||||
frames.append([(200 + lean + rng.uniform(-4, 4), 600 + rng.uniform(-4, 4), 300, 340, 0.9)])
|
||||
result = locate_cam(frames, W, H)
|
||||
assert result["hasWebcam"] and result["confidence"] > 0.5 # partido em dois daria presença 0,5 → ≤ 0,45
|
||||
face = result["faceRect"]
|
||||
center = (face["x"] + face["w"] / 2) * W
|
||||
assert 200 + 150 + 80 < center < 200 + 150 + 160 # média das duas posições (~350 + 120)
|
||||
|
||||
|
||||
def test_locate_cam_frameless_keeps_forehead():
|
||||
# Câmera sem moldura (streamer recortado sobre o jogo, banner logo abaixo): o retângulo vem do rosto e deixa
|
||||
# folga acima da testa — a IA cortava a testa (topo em y 0,532 com o rosto começando em 0,504).
|
||||
fw, fh = 1280, 720
|
||||
frames = [[(80 + i % 3, 363, 85, 109, 0.92)] for i in range(12)] # rosto da bancada: x 0,066 y 0,504 h 0,152
|
||||
result = locate_cam(frames, fw, fh)
|
||||
cam, face = result["cam"], result["faceRect"]
|
||||
assert face["y"] - cam["y"] >= 0.5 * face["h"] # testa e cabelo dentro
|
||||
assert cam["y"] + cam["h"] >= face["y"] + face["h"] + face["h"] # ombros/peito abaixo do queixo
|
||||
# Borda "falsa" logo acima da testa (ex.: banner) não corta a cabeça.
|
||||
edges = {"xs": [], "ys": [face["y"] - 0.01]}
|
||||
assert locate_cam(frames, fw, fh, edges=edges)["cam"]["y"] < face["y"] - 0.3 * face["h"]
|
||||
|
||||
|
||||
def test_two_hours_of_series_is_fast():
|
||||
# channel_z era O(n²): a API e a pontuação recalculam a live inteira. 2 h sintéticas precisam de < 1 s.
|
||||
import time
|
||||
|
||||
seconds = real_calm(7200, seed=3)
|
||||
for t in range(4000, 4006):
|
||||
seconds[t].smile = 0.9
|
||||
started = time.perf_counter()
|
||||
moments = reaction_moments(seconds)
|
||||
assert time.perf_counter() - started < 1.0
|
||||
assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 4000
|
||||
|
||||
|
||||
def test_locate_cam_ignores_static_low_score_object():
|
||||
"""Teste ao vivo de 17/11 (lofigirl, sem webcam): a tela de um notebook desenhado na borda esquerda saiu como
|
||||
rosto de 24×34 px com score 0,61–0,66 em 8 de 12 quadros e virou câmera. Webcam real: 0,92–0,94."""
|
||||
fake = (0.0, 415.0, 24.0, 34.0, 0.63)
|
||||
frames = [[fake], [fake], [fake, (726.0, 253.0, 73.0, 98.0, 0.604)], [], [fake], [], [fake], [fake],
|
||||
[(606.0, 254.0, 155.0, 197.0, 0.615)], [fake], [], [fake, (605.0, 257.0, 154.0, 193.0, 0.61)]]
|
||||
assert locate_cam(frames, 1280, 720)["hasWebcam"] is False
|
||||
real = [[(109.0 + i % 3, 359.0, 82.0, 112.0, 0.93)] for i in range(12)]
|
||||
assert locate_cam(real, 1280, 720)["hasWebcam"] is True
|
||||
@@ -0,0 +1,252 @@
|
||||
"""Reenquadramento do jogo no tempo (keyframes) e camadas inseridas (pedido do dono, 17/11/2026, corte 61)."""
|
||||
import shutil
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from app import editor, editor_render, layout, reframe
|
||||
|
||||
from .test_editor import make_project, validate
|
||||
|
||||
FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe")
|
||||
needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
|
||||
SRC_W, SRC_H = 1280, 720
|
||||
DOT = (808.0, 308.0) # centro do quadrado branco de 16 px no vídeo de teste
|
||||
|
||||
|
||||
def _project(**over):
|
||||
base = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, cuts=[{"start": 0, "end": 4, "mode": None}],
|
||||
overlays=[], captions={"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B",
|
||||
"words": []},
|
||||
progress={"enabled": False}, cover={"enabled": False, "t": 1})
|
||||
base.update(over)
|
||||
return base
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- interpolação e validação
|
||||
def test_interpolation_semantics():
|
||||
keys = [{"t": 1.0, "cx": 0.2, "ease": "linear"}, {"t": 3.0, "cx": 0.6, "ease": "hold"},
|
||||
{"t": 5.0, "cx": 0.9, "ease": "smooth"}, {"t": 7.0, "cx": 0.1, "ease": "smooth"}]
|
||||
assert reframe.interp(keys, 0.0, "cx") == 0.2 # antes do 1º: segura
|
||||
assert reframe.interp(keys, 2.0, "cx") == pytest.approx(0.4) # linear
|
||||
assert reframe.interp(keys, 4.99, "cx") == 0.6 and reframe.interp(keys, 5.0, "cx") == 0.9 # hold salta no key seguinte
|
||||
assert reframe.interp(keys, 6.0, "cx") == pytest.approx(0.5) # smooth: meio exato no meio
|
||||
assert reframe.interp(keys, 6.5, "cx") < 0.9 - 0.8 * 0.75 + 0.05 # smooth acelera no meio (mais que linear)
|
||||
assert reframe.interp(keys, 9.0, "cx") == 0.1 # depois do último: segura
|
||||
|
||||
|
||||
def test_window_keeps_aspect_and_stays_inside():
|
||||
keys = [{"t": 0, "cx": 0.98, "cy": 0.02, "w": 0.4, "ease": "smooth"}]
|
||||
x, y, w, h = reframe.window(keys, 0, SRC_W, SRC_H, 1080 / 1268)
|
||||
assert w / h == pytest.approx(1080 / 1268) and x + w <= SRC_W + 1e-6 and y >= 0 and x >= 0
|
||||
big = [{"t": 0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"}]
|
||||
x, y, w, h = reframe.window(big, 0, SRC_W, SRC_H, 1080 / 1920) # zoom que não cabe: encolhe, não deforma
|
||||
assert h == pytest.approx(SRC_H) and w == pytest.approx(SRC_H * 1080 / 1920)
|
||||
|
||||
|
||||
def test_validation(tmp_path):
|
||||
keys = [{"t": 3, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1, "cx": 0.2, "cy": 0.3, "w": 1, "ease": "hold"}]
|
||||
p = validate(_project(reframe={"keys": keys}), tmp_path)
|
||||
assert [k["t"] for k in p["reframe"]["keys"]] == [1, 3] and p["reframe"]["keys"][1]["ease"] == "smooth"
|
||||
assert "reframe" not in validate(_project(), tmp_path) and "reframe" not in validate(_project(reframe={"keys": []}), tmp_path)
|
||||
inset = {"id": "i", "kind": "inset", "start": 1, "end": 3, "src": {"x": 0.7, "y": 0.0, "w": 0.3, "h": 0.25},
|
||||
"x": 0.5, "y": 0.3, "size": 0.5, "border": "#ffffff"}
|
||||
q = validate(_project(overlays=[inset]), tmp_path)["overlays"][0]
|
||||
assert q["border"] == "#FFFFFF" and q["borderW"] == 6 and q["radius"] == 18 and q["shadow"] is True and q["keys"] == []
|
||||
bad = [
|
||||
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.01}]}},
|
||||
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5, "ease": "bounce"}]}},
|
||||
{"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1.01, "cx": 0.5, "cy": 0.5, "w": 0.5}]}},
|
||||
{"reframe": {"keys": [{"t": 1 + i * 0.05, "cx": 0.5, "cy": 0.5, "w": 0.5} for i in range(61)]}},
|
||||
{"overlays": [{**inset, "src": {"x": 0.9, "y": 0, "w": 0.3, "h": 0.2}}]}, # fora do quadro
|
||||
{"overlays": [{**inset, "size": 0.05}]},
|
||||
{"overlays": [{**inset, "anim": "spin"}]},
|
||||
{"overlays": [{**inset, "src": None}]},
|
||||
{"overlays": [{**inset, "id": f"i{n}"} for n in range(13)]}, # mais de 12 camadas
|
||||
]
|
||||
for change in bad:
|
||||
with pytest.raises(editor.EditError):
|
||||
validate(_project(**change), tmp_path)
|
||||
|
||||
|
||||
def test_old_project_graph_unchanged_and_inset_not_in_ass(tmp_path):
|
||||
p = validate(make_project(), tmp_path)
|
||||
cfg = editor.effective_settings(layout.merge(), p)
|
||||
graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", [])
|
||||
assert "perspective" not in graph and "[vraw]" not in graph and "split=2[tl" not in graph
|
||||
inset = {"id": "i", "kind": "inset", "start": 11, "end": 13, "src": {"x": 0, "y": 0, "w": 0.3, "h": 0.3}}
|
||||
q = validate(make_project(overlays=[inset]), tmp_path)
|
||||
assert "Dialogue: 2" not in editor_render.build_project_ass(q, cfg, "")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- render real
|
||||
@pytest.fixture(scope="module")
|
||||
def dot_video(tmp_path_factory):
|
||||
if not FFMPEG:
|
||||
pytest.skip("FFmpeg não instalado")
|
||||
folder = tmp_path_factory.mktemp("reframe")
|
||||
seg = folder / "dot.ts"
|
||||
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0x101010:s={SRC_W}x{SRC_H}:r=30:d=8",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=8",
|
||||
"-vf", "drawbox=x=800:y=300:w=16:h=16:color=white:t=fill", "-c:v", "libx264", "-preset", "ultrafast",
|
||||
"-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
|
||||
return seg
|
||||
|
||||
|
||||
def _frames(video: Path, size: tuple[int, int]):
|
||||
import numpy as np
|
||||
raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(video), "-f", "rawvideo", "-pix_fmt", "gray", "-"],
|
||||
capture_output=True, check=True).stdout
|
||||
return np.frombuffer(raw, np.uint8).reshape(-1, size[1], size[0]).astype(float)
|
||||
|
||||
|
||||
def _centroid(frame):
|
||||
import numpy as np
|
||||
m = np.where(frame > 128, frame, 0)
|
||||
s = m.sum()
|
||||
if not s:
|
||||
return None
|
||||
ys, xs = np.mgrid[0:frame.shape[0], 0:frame.shape[1]]
|
||||
return (m * xs).sum() / s, (m * ys).sum() / s
|
||||
|
||||
|
||||
def _expected(keys, t, dest):
|
||||
x, y, w, h = reframe.window(keys, t, SRC_W, SRC_H, dest[0] / dest[1])
|
||||
return (DOT[0] - x) / w * dest[0], (DOT[1] - y) / h * dest[1]
|
||||
|
||||
|
||||
def _render(tmp_path, video, project, settings=None, name="out.mp4"):
|
||||
p = validate(project, tmp_path, duration=8.0)
|
||||
out = tmp_path / name
|
||||
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "12"],
|
||||
[(video, 0.0, 8.0)], p, layout.merge(settings or {}), "", out, tmp_path)
|
||||
return p, out
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
|
||||
def test_reframe_window_follows_keys_smoothly(tmp_path, dot_video, aspect):
|
||||
keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"},
|
||||
{"t": 2.0, "cx": 0.62, "cy": 0.42, "w": 0.3, "ease": "hold"},
|
||||
{"t": 3.0, "cx": 0.66, "cy": 0.45, "w": 0.45, "ease": "linear"}]
|
||||
settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only"}}
|
||||
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings))
|
||||
size = layout.FRAME_SIZES[aspect]
|
||||
frames = _frames(out, size)
|
||||
for n in (0, 15, 30, 45, 60, 75, 89, 91, 105): # quadro n = sessão n/30 (um trecho só)
|
||||
got = _centroid(frames[n])
|
||||
want = _expected(keys, n / 30, size)
|
||||
assert got and abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (n, got, want)
|
||||
xs = [_centroid(f)[0] for f in frames[1:60]]
|
||||
steps = [b - a for a, b in zip(xs, xs[1:])]
|
||||
assert all(s <= 0.05 for s in steps) or all(s >= -0.05 for s in steps) # sempre no mesmo sentido: sem tremida
|
||||
jump_before, jump_after = _centroid(frames[89]), _centroid(frames[91]) # hold: salta no key de 3,0 s
|
||||
assert abs(jump_after[0] - jump_before[0]) > 20
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_reframe_uses_session_time_across_cuts(tmp_path, dot_video):
|
||||
keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "linear"}, {"t": 6.0, "cx": 0.66, "cy": 0.45, "w": 0.35}]
|
||||
cuts = [{"start": 0.0, "end": 1.5, "mode": None}, {"start": 3.0, "end": 5.0, "mode": None}]
|
||||
settings = {"layout": {"mode": "game_only"}}
|
||||
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, cuts=cuts, settings=settings))
|
||||
frames = _frames(out, (1080, 1920))
|
||||
for out_t, session_t in ((0.5, 0.5), (2.0, 3.5), (3.0, 4.5)):
|
||||
got, want = _centroid(frames[int(out_t * 30)]), _expected(keys, session_t, (1080, 1920))
|
||||
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (out_t, got, want)
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_reframe_in_cam_top_uses_game_area_and_cover(tmp_path, dot_video):
|
||||
keys = [{"t": 0.0, "cx": 0.62, "cy": 0.42, "w": 0.3}]
|
||||
settings = {"layout": {"mode": "cam_top", "cam": {"x": 0.0, "y": 0.0, "w": 0.2, "h": 0.25}}}
|
||||
p, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings))
|
||||
top = layout.cam_panel_height(layout.merge(settings))
|
||||
got = _centroid(_frames(out, (1080, 1920))[10][top:])
|
||||
want = _expected(keys, 0, (1080, 1920 - top))
|
||||
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4
|
||||
cover = editor_render.render_cover(FFMPEG, [(dot_video, 0.0, 8.0)], {**p, "cover": {**p["cover"], "t": 1.0}},
|
||||
layout.merge(settings), "", tmp_path / "cover.jpg")
|
||||
assert cover.is_file()
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def color_video(tmp_path_factory):
|
||||
if not FFMPEG:
|
||||
pytest.skip("FFmpeg não instalado")
|
||||
folder = tmp_path_factory.mktemp("insets")
|
||||
seg = folder / "colors.ts"
|
||||
boxes = ("drawbox=x=0:y=0:w=300:h=200:color=0x00FF00:t=fill,"
|
||||
"drawbox=x=900:y=500:w=380:h=220:color=0x0000FF:t=fill")
|
||||
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0xFF0000:s={SRC_W}x{SRC_H}:r=30:d=8",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=8", "-vf", boxes, "-c:v", "libx264",
|
||||
"-preset", "ultrafast", "-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True)
|
||||
return seg
|
||||
|
||||
|
||||
def _rgb(video: Path, t: float, size: tuple[int, int]):
|
||||
import numpy as np
|
||||
raw = subprocess.run([FFMPEG, "-v", "error", "-ss", f"{t:.3f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
|
||||
"-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout
|
||||
return np.frombuffer(raw, np.uint8).reshape(size[1], size[0], 3).astype(int)
|
||||
|
||||
|
||||
def _is(px, color, tol=60):
|
||||
return all(abs(int(a) - b) < tol for a, b in zip(px, color))
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
|
||||
def test_two_overlapping_insets_with_border_and_anim(tmp_path, color_video, aspect):
|
||||
green = {"id": "g", "kind": "inset", "start": 0.5, "end": 3.5, "src": {"x": 0.0, "y": 0.0, "w": 0.2344, "h": 0.2778},
|
||||
"x": 0.25, "y": 0.25, "size": 0.4, "border": "#FFFFFF", "borderW": 8, "radius": 20, "shadow": True, "anim": "fade"}
|
||||
blue = {"id": "b", "kind": "inset", "start": 1.0, "end": 3.5, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056},
|
||||
"x": 0.45, "y": 0.35, "size": 0.4, "border": "#FFFF00", "borderW": 8, "radius": 0, "shadow": False, "anim": "pop"}
|
||||
settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}}
|
||||
_, out = _render(tmp_path, color_video, _project(overlays=[green, blue], settings=settings))
|
||||
w, h = size = layout.FRAME_SIZES[aspect]
|
||||
frame = _rgb(out, 2.0, size)
|
||||
gx, gy = int(0.25 * w), int(0.25 * h)
|
||||
gw = 0.4 * w
|
||||
gh = gw * (0.2778 * SRC_H) / (0.2344 * SRC_W)
|
||||
bw = 0.4 * w
|
||||
bh = bw * (0.3056 * SRC_H) / (0.2969 * SRC_W)
|
||||
bx0, by0 = 0.45 * w - bw / 2, 0.35 * h - bh / 2
|
||||
assert _is(frame[gy, int(gx - gw / 2 + 12)], (0, 255, 0)) # camada verde (dentro, longe da azul)
|
||||
assert _is(frame[gy, int(gx - gw / 2 - 3)], (255, 255, 255)) # borda branca do lado de fora
|
||||
assert _is(frame[int(by0 + bh / 2), int(0.45 * w)], (0, 0, 255)) # camada azul
|
||||
ox, oy = int(bx0 + 15), int(by0 + 15) # canto da azul que cai em cima da verde: a azul (última) fica por cima
|
||||
assert gx - gw / 2 < ox < gx + gw / 2 and gy - gh / 2 < oy < gy + gh / 2
|
||||
assert _is(frame[oy, ox], (0, 0, 255))
|
||||
assert _is(frame[int(0.9 * h), int(0.9 * w)], (255, 0, 0)) # fora das camadas: o jogo (vermelho)
|
||||
early = _rgb(out, 0.56, size)[gy, int(gx - gw / 2 + 12)] # fade: no começo a verde ainda está entrando
|
||||
assert not _is(early, (0, 255, 0), tol=30)
|
||||
assert _is(_rgb(out, 3.8, size)[gy, gx], (255, 0, 0)) # depois do fim: some
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_inset_keys_move_it_in_session_time(tmp_path, color_video):
|
||||
blue = {"id": "b", "kind": "inset", "start": 0.0, "end": 6.0, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056},
|
||||
"x": 0.3, "y": 0.5, "size": 0.3, "border": None, "shadow": False, "anim": "none",
|
||||
"keys": [{"t": 1.0, "x": 0.3, "y": 0.5, "size": 0.3, "ease": "linear"}, {"t": 5.0, "x": 0.7, "y": 0.5, "size": 0.3}]}
|
||||
cuts = [{"start": 0.0, "end": 2.0, "mode": None}, {"start": 3.0, "end": 6.0, "mode": None}]
|
||||
settings = {"layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}}
|
||||
_, out = _render(tmp_path, color_video, _project(overlays=[blue], cuts=cuts, settings=settings))
|
||||
frame = _rgb(out, 2.0, (1080, 1920)) # saída 2,0 s = sessão 3,0 s → x = 0,3 + 0,4 × (2/4) = 0,5
|
||||
assert _is(frame[960, 540], (0, 0, 255)) and _is(frame[960, int(0.3 * 1080) - 120], (255, 0, 0))
|
||||
|
||||
|
||||
@needs_ffmpeg
|
||||
def test_sixty_keys_render_through_graph_file(tmp_path, dot_video):
|
||||
"""60 keyframes num trecho: o grafo passa do limite da linha de comando e vai por arquivo (-/filter_complex)."""
|
||||
keys = [{"t": i * 0.06, "cx": 0.5 + 0.1 * (i % 2), "cy": 0.5, "w": 0.4 + 0.3 * (i % 3) / 2, "ease": "linear"}
|
||||
for i in range(60)]
|
||||
p = validate(_project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}}), tmp_path, duration=8.0)
|
||||
graph = editor_render.build_filter(p, editor.effective_settings(layout.merge(), p), editor.pieces(p["cuts"]), 0.0,
|
||||
None, [])
|
||||
assert len(graph) > 20000
|
||||
_, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}}))
|
||||
got, want = _centroid(_frames(out, (1080, 1920))[100]), _expected(keys, 100 / 30, (1080, 1920))
|
||||
assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4
|
||||
assert not list(tmp_path.glob("*.graph.txt")) # arquivo temporário apagado
|
||||
@@ -0,0 +1,190 @@
|
||||
"""Bugs de produção de 16–17/11/2026 (sessão 3 do skipnho):
|
||||
1. corte preso em 'rendering' quando o render levantava uma exceção não prevista (KeyError da legenda);
|
||||
2. o mesmo momento virando vários cortes (pico 1149 → cortes 42, 47, 49, 51, 52 em cima do 9, já pronto)."""
|
||||
import json
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import app.editor_api as editor_api
|
||||
import app.worker as worker_module
|
||||
from app.judge import Judge, Verdict
|
||||
from app.scoring import Moment
|
||||
|
||||
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
|
||||
class RecuoJudge(Judge):
|
||||
"""Juiz falso (nunca chama a CLI): mantém e recua o início para `back_to`, como o juiz real fez no corte 42."""
|
||||
|
||||
def __init__(self, back_to: float | None = None):
|
||||
super().__init__("codex", "fake", Path("."))
|
||||
self.back_to = back_to
|
||||
|
||||
def analyze(self, prompt, images):
|
||||
return {"situation": "lag_ou_bug", "confidence": 0.9, "action_start_s": 0, "reaction_end_s": 0, "hook": ""}
|
||||
|
||||
def judge(self, prompt, start_s, end_s, images=None, **_limits):
|
||||
start = self.back_to if self.back_to is not None else start_s
|
||||
return Verdict(True, 8.0, start, end_s, "O lag colocou ele em três lugares", "legenda", "motivo", "fake")
|
||||
|
||||
|
||||
def add_clip(engine, sid, cid, status, peak, start, end, source="chat", reasons=None):
|
||||
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, reasons_json, status, title, "
|
||||
"created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, ?, ?, ?, 't', 'x', ?)",
|
||||
cid, sid, peak, start, end, source, json.dumps(reasons or {}), status, worker_module.now())
|
||||
|
||||
|
||||
def status(engine, cid):
|
||||
return engine.db.get("SELECT status FROM clips WHERE id = ?", cid)["status"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- bug 1: render
|
||||
def test_render_that_explodes_becomes_error_and_next_clip_runs(env, monkeypatch): # noqa: F811
|
||||
_client, engine = env
|
||||
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
|
||||
sid = seed_session(engine)
|
||||
add_clip(engine, sid, 1, "pending", 100, 90, 120)
|
||||
add_clip(engine, sid, 2, "pending", 300, 290, 320)
|
||||
|
||||
def ensure_edit(eng, clip, session):
|
||||
if clip["id"] == 1:
|
||||
raise KeyError(2413111138480) # o erro medido na versão intermediária da legenda
|
||||
return {"project": {}}
|
||||
monkeypatch.setattr(editor_api, "ensure_edit", ensure_edit)
|
||||
monkeypatch.setattr(editor_api, "render_clip_edit", lambda *a, **k: None)
|
||||
engine.render_pending()
|
||||
first = engine.db.get("SELECT status, error FROM clips WHERE id = 1")
|
||||
assert first["status"] == "error" and "KeyError" in first["error"]
|
||||
assert status(engine, 2) == "ready" and engine._rendering == set()
|
||||
|
||||
|
||||
def test_orphan_rendering_goes_back_to_queue_then_error(env, monkeypatch): # noqa: F811
|
||||
_client, engine = env
|
||||
sid = seed_session(engine)
|
||||
old = (datetime.now(timezone.utc) - timedelta(minutes=10)).isoformat(timespec="seconds")
|
||||
add_clip(engine, sid, 1, "rendering", 100, 90, 120)
|
||||
add_clip(engine, sid, 2, "rendering", 300, 290, 320) # recente: pode estar renderizando ainda
|
||||
add_clip(engine, sid, 3, "rendering", 500, 490, 520)
|
||||
engine.db.run("UPDATE clips SET updated_at = ? WHERE id IN (1, 3)", old)
|
||||
engine._rendering.add(3) # este processo está renderizando o 3 agora
|
||||
engine.recover_orphan_renders()
|
||||
assert [status(engine, c) for c in (1, 2, 3)] == ["pending", "rendering", "rendering"]
|
||||
for _ in range(worker_module.MAX_RENDER_ATTEMPTS - 1):
|
||||
engine.db.run("UPDATE clips SET status = 'rendering', updated_at = ? WHERE id = 1", old)
|
||||
engine.recover_orphan_renders()
|
||||
assert status(engine, 1) == "error"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- bug 2: duplicados
|
||||
def test_judge_backtrack_onto_ready_clip_is_discarded_as_duplicate(env): # noqa: F811
|
||||
_client, engine = env
|
||||
sid = seed_session(engine, duration=1300)
|
||||
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
|
||||
engine.judge = RecuoJudge(back_to=1012)
|
||||
add_clip(engine, sid, 42, "candidate", 1149, 1095, 1155)
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 42"))
|
||||
row = engine.db.get("SELECT status, start_s, judge_json FROM clips WHERE id = 42")
|
||||
judge = json.loads(row["judge_json"])
|
||||
assert row["status"] == "discarded" and judge["duplicateOf"] == 9 and "Duplicado do corte 9" in judge["reason"]
|
||||
# "cortar agora" nunca é bloqueado: só avisa
|
||||
add_clip(engine, sid, 43, "candidate", 1080, 1040, 1100, source="manual")
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 43"))
|
||||
manual = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 43")
|
||||
assert manual["status"] == "pending" and json.loads(manual["judge_json"])["warning"] == "mesmo momento do corte 9"
|
||||
|
||||
|
||||
def test_repeated_passes_never_recreate_the_same_peak(env, monkeypatch): # noqa: F811
|
||||
_client, engine = env
|
||||
sid = seed_session(engine, duration=1300)
|
||||
engine.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ?", sid)
|
||||
moment = Moment(peak_s=1149.0, start_s=1095.0, end_s=1155.0, score=5.0, source="chat", reasons={"onsetS": 1142})
|
||||
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [moment])
|
||||
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
|
||||
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
|
||||
assert json.loads(clip["reasons_json"])["candidateStartS"] == 1095.0 # janela original guardada
|
||||
# O juiz recuou o corte para 1012–1100: o candidato do mesmo pico já não sobrepõe o trecho final…
|
||||
engine.db.run("UPDATE clips SET start_s = 1012, end_s = 1100, status = 'discarded' WHERE id = ?", clip["id"])
|
||||
for _ in range(3): # …mas passadas seguidas não recriam (nem com o corte descartado)
|
||||
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
|
||||
assert engine.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ?", sid)["n"] == 1
|
||||
# Corte antigo sem janela guardada: o pico igual também bloqueia.
|
||||
engine.db.run("UPDATE clips SET reasons_json = '{}' WHERE id = ?", clip["id"])
|
||||
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
|
||||
|
||||
|
||||
def test_startup_queue_drops_pending_duplicates(env): # noqa: F811
|
||||
"""Caso real da sessão 3: 42, 47, 51 e 52 (pico 1149, recuados para 1012–1100) em cima do 9, pronto."""
|
||||
_client, engine = env
|
||||
sid = seed_session(engine, duration=9000)
|
||||
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
|
||||
for cid, start, end in ((42, 1012.2, 1099.68), (47, 1012.2, 1099.68), (51, 1012.86, 1099.68), (52, 1012.86, 1102.86)):
|
||||
add_clip(engine, sid, cid, "pending", 1149, start, end)
|
||||
add_clip(engine, sid, 53, "pending", 7850, 7793.484, 7860.114) # momento próprio (o 54 parecido foi descartado)
|
||||
add_clip(engine, sid, 54, "discarded", 7928, 7792.57, 7852.57)
|
||||
add_clip(engine, sid, 70, "pending", 1150, 1012, 1100, source="manual") # seu: nunca sai da fila
|
||||
dropped = engine.discard_pending_duplicates()
|
||||
assert sorted(dropped) == [(42, 9), (47, 9), (51, 9), (52, 9)]
|
||||
assert status(engine, 53) == "pending" and status(engine, 70) == "pending"
|
||||
assert json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = 47")["judge_json"])["duplicateOf"] == 9
|
||||
|
||||
|
||||
def test_same_moment_rule():
|
||||
a = {"peak_s": 1084, "start_s": 1045, "end_s": 1100}
|
||||
assert worker_module.same_moment(a, {"peak_s": 1149, "start_s": 1012, "end_s": 1100}) # cobre 100 % do 9
|
||||
assert worker_module.same_moment(a, {"peak_s": 1090, "start_s": 1200, "end_s": 1260}) # mesmo pico
|
||||
# momentos vizinhos de 60–90 s que só encostam não são duplicados
|
||||
assert not worker_module.same_moment({"peak_s": 1221, "start_s": 1184, "end_s": 1239},
|
||||
{"peak_s": 1287, "start_s": 1253, "end_s": 1308})
|
||||
assert not worker_module.same_moment({"peak_s": 100, "start_s": 40, "end_s": 130},
|
||||
{"peak_s": 170, "start_s": 100, "end_s": 190}) # 30 s de 90 s = 33 %
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 17/11/2026: "não está gerando os clipes"
|
||||
def test_rejected_moment_vetoes_judge_backtrack(env): # noqa: F811
|
||||
"""Caso 61/64 da sessão 3: o juiz recua o candidato (pico 8909) para a cena de um corte que você rejeitou."""
|
||||
_client, engine = env
|
||||
sid = seed_session(engine, duration=9000)
|
||||
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
|
||||
add_clip(engine, sid, 64, "candidate", 8909, 8878.0, 8939.1)
|
||||
engine.judge = RecuoJudge(back_to=8790)
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 64"))
|
||||
row = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 64")
|
||||
judge = json.loads(row["judge_json"])
|
||||
assert row["status"] == "discarded" and judge["duplicateOf"] == 61 and "que você rejeitou" in judge["reason"]
|
||||
# descartado pela IA NÃO veta o trecho final de outro momento (só o candidato do mesmo pico)
|
||||
engine.db.run("UPDATE clips SET status = 'discarded' WHERE id = 61")
|
||||
add_clip(engine, sid, 65, "candidate", 8909, 8878.0, 8939.1)
|
||||
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 65"))
|
||||
assert status(engine, 65) == "pending"
|
||||
|
||||
|
||||
def test_scan_memory_records_proposals_and_created(env): # noqa: F811
|
||||
from .test_intel import ScanJudge
|
||||
_client, engine = env
|
||||
engine.judge = ScanJudge() # 2 propostas: nota 8 (vira candidato) e nota 3 (barrada)
|
||||
engine.intel.opts["vision"] = False
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
|
||||
assert engine.intel.scan_session(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
|
||||
memory = json.loads(engine.db.get("SELECT memory_json FROM sessions WHERE id = ?", sid)["memory_json"])
|
||||
assert memory[-1]["proposals"] == 2 and memory[-1]["created"] == 1 and memory[-1]["summary"] == "tiroteio na base"
|
||||
|
||||
|
||||
def test_queue_cleanup_uses_the_same_veto_as_the_judge(env): # noqa: F811
|
||||
"""Fila antes do render: pendente igual a rejeitado ou a apagado-que-estava-pronto sai; igual a descartado pela IA
|
||||
fica; manual nunca sai."""
|
||||
_client, engine = env
|
||||
sid = seed_session(engine, duration=9000)
|
||||
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
|
||||
add_clip(engine, sid, 70, "pending", 8820, 8790.0, 8858.0) # = rejeitado
|
||||
add_clip(engine, sid, 71, "discarded", 5000, 4970.0, 5030.0)
|
||||
add_clip(engine, sid, 72, "pending", 5004, 4968.0, 5032.0) # = descartado pela IA: fica
|
||||
engine.db.run("INSERT INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, status, source, deleted_at)"
|
||||
" VALUES (80, ?, 3000, 2970, 3040, 'ready', 'chat', 'x')", sid)
|
||||
add_clip(engine, sid, 73, "pending", 3002, 2968.0, 3038.0) # = apagado que estava pronto
|
||||
add_clip(engine, sid, 74, "pending", 8818, 8790.0, 8850.0, source="manual") # manual: nunca sai
|
||||
assert sorted(engine.discard_pending_duplicates()) == [(70, 61), (73, 80)]
|
||||
reasons = {cid: json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = ?", cid)["judge_json"])["reason"]
|
||||
for cid in (70, 73)}
|
||||
assert "que você rejeitou" in reasons[70] and "que você apagou" in reasons[73]
|
||||
assert status(engine, 72) == "pending" and status(engine, 74) == "pending"
|
||||
@@ -0,0 +1,166 @@
|
||||
"""Retomada de live depois de reinício ou de queda da captura (bug de 16/11/2026, sessão 3 do skipnho): a 1ª
|
||||
checagem logo depois do reinício falhou e a live, que estava no ar, foi direto para o processamento."""
|
||||
import subprocess
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
import app.worker as worker_module
|
||||
from app.worker import LiveCheck
|
||||
|
||||
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
|
||||
|
||||
|
||||
class FakeCapture:
|
||||
started: list[int] = []
|
||||
|
||||
def __init__(self, eng, session_id, source, workdir, start_idx=0):
|
||||
FakeCapture.started.append(start_idx)
|
||||
self.chat = None
|
||||
|
||||
def start(self):
|
||||
pass
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def live(env, monkeypatch): # noqa: F811
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
|
||||
engine.resume_delays = (0.0,) * 7
|
||||
FakeCapture.started = []
|
||||
monkeypatch.setattr(worker_module, "Capture", FakeCapture)
|
||||
return engine, sid
|
||||
|
||||
|
||||
def scripted(engine, results):
|
||||
calls = []
|
||||
|
||||
def check(url):
|
||||
calls.append(url)
|
||||
return results[min(len(calls), len(results)) - 1]
|
||||
engine.live_check = check
|
||||
return calls
|
||||
|
||||
|
||||
def status(engine, sid):
|
||||
return engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"]
|
||||
|
||||
|
||||
def test_startup_resume_retries_until_the_check_works(live):
|
||||
engine, sid = live
|
||||
unknown = LiveCheck("unknown", reason="streamlink --json passou de 60 s")
|
||||
calls = scripted(engine, [unknown, unknown, unknown, LiveCheck("live", {"title": "t"})])
|
||||
engine.resume_interrupted([sid])
|
||||
assert len(calls) == 4 and FakeCapture.started == [20] # retomou na mesma sessão, continuando a numeração
|
||||
assert status(engine, sid) == "starting" # gravando de novo, não processando
|
||||
|
||||
|
||||
def test_startup_resume_gives_up_only_after_all_attempts(live):
|
||||
engine, sid = live
|
||||
calls = scripted(engine, [LiveCheck("unknown", reason="erro")])
|
||||
seen = []
|
||||
original = engine.live_check
|
||||
|
||||
def check(url):
|
||||
seen.append(status(engine, sid)) # enquanto tenta, a sessão continua 'interrupted'
|
||||
return original(url)
|
||||
engine.live_check = check
|
||||
engine.resume_interrupted([sid])
|
||||
assert len(calls) == len(engine.resume_delays) and set(seen) == {"interrupted"}
|
||||
assert FakeCapture.started == [] and status(engine, sid) == "processing"
|
||||
|
||||
|
||||
def test_offline_confirmed_twice_finishes_early(live):
|
||||
engine, sid = live
|
||||
calls = scripted(engine, [LiveCheck("offline", reason="No playable streams")])
|
||||
engine.resume_interrupted([sid])
|
||||
assert len(calls) == 2 and status(engine, sid) == "processing"
|
||||
# "offline" isolado entre falhas de checagem não conta como confirmação
|
||||
engine.db.run("UPDATE sessions SET status = 'interrupted' WHERE id = ?", sid)
|
||||
off, unk = LiveCheck("offline"), LiveCheck("unknown")
|
||||
calls = scripted(engine, [off, unk, off, unk, off, unk, off])
|
||||
engine.resume_interrupted([sid])
|
||||
assert len(calls) == 7
|
||||
|
||||
|
||||
def test_owner_action_in_the_middle_wins(live):
|
||||
engine, sid = live
|
||||
|
||||
def check(url):
|
||||
engine.db.run("UPDATE sessions SET status = 'processing' WHERE id = ?", sid) # você clicou "Processar"
|
||||
return LiveCheck("live", {"title": "t"})
|
||||
engine.live_check = check
|
||||
assert engine.keep_live(sid, "teste") is False
|
||||
assert FakeCapture.started == [] and status(engine, sid) == "processing"
|
||||
|
||||
|
||||
def test_capture_drop_mid_live_reconnects(live):
|
||||
engine, sid = live
|
||||
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
|
||||
scripted(engine, [LiveCheck("unknown"), LiveCheck("live", {"title": "t"})])
|
||||
started = []
|
||||
engine.keep_live = lambda session_id, why: started.append(why) # a thread chamaria keep_live
|
||||
engine.capture_dropped(sid, got_video=True)
|
||||
import time
|
||||
for _ in range(50):
|
||||
if started:
|
||||
break
|
||||
time.sleep(0.02)
|
||||
assert status(engine, sid) == "interrupted" and started == ["captura caiu"]
|
||||
# Retomadas seguidas sem nenhum bloco novo: desiste depois de MAX_EMPTY_RESUMES e processa.
|
||||
for _ in range(worker_module.MAX_EMPTY_RESUMES):
|
||||
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
|
||||
engine.capture_dropped(sid, got_video=False)
|
||||
assert status(engine, sid) == "processing"
|
||||
|
||||
|
||||
def _fake_run(monkeypatch, stdout=b"", stderr=b"", code=0, exc=None):
|
||||
def run(*_args, **_kwargs):
|
||||
if exc:
|
||||
raise exc
|
||||
return SimpleNamespace(stdout=stdout, stderr=stderr, returncode=code)
|
||||
monkeypatch.setattr(worker_module.subprocess, "run", run)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("kwargs,state", [
|
||||
({"stdout": b'{"streams": {"best": {}}, "metadata": {"title": "oi", "category": "GTA"}}'}, "live"),
|
||||
({"stdout": b'{"error": "No playable streams found on this URL: https://www.twitch.tv/x"}', "code": 1}, "offline"),
|
||||
({"exc": subprocess.TimeoutExpired("streamlink", 60)}, "unknown"),
|
||||
({"exc": OSError("não achou")}, "unknown"),
|
||||
({"stdout": b"<html>erro</html>", "stderr": b"error: rede", "code": 1}, "unknown"),
|
||||
({"stdout": b'{"error": "Unable to open URL: https://gql.twitch.tv (503 Server Error)"}', "code": 1}, "unknown"),
|
||||
])
|
||||
def test_live_check_tells_offline_from_check_failure(env, monkeypatch, caplog, kwargs, state): # noqa: F811
|
||||
_client, engine = env
|
||||
from dataclasses import replace
|
||||
engine.settings = replace(engine.settings, streamlink="streamlink")
|
||||
_fake_run(monkeypatch, **kwargs)
|
||||
result = engine.live_check("https://www.twitch.tv/x")
|
||||
assert result.state == state
|
||||
if state == "live":
|
||||
assert result.meta["category"] == "GTA" and engine.check_live("u") == (True, "oi")
|
||||
else:
|
||||
assert engine.check_meta("u") is None # quem só quer saber "está ao vivo?" continua recebendo None
|
||||
if state == "unknown":
|
||||
assert "checagem da live" in caplog.text and result.reason # motivo registrado no log
|
||||
|
||||
|
||||
@pytest.mark.skipif(not __import__("shutil").which("ffmpeg"), reason="FFmpeg não instalado")
|
||||
def test_capture_that_stops_by_itself_goes_to_reconnect(env, tmp_path, monkeypatch): # noqa: F811
|
||||
"""Captura de live que para sem stop() (aqui o "streamlink" sai na hora) não processa direto: vai para a
|
||||
retomada com novas tentativas."""
|
||||
import shutil
|
||||
import sys
|
||||
from dataclasses import replace
|
||||
|
||||
from app.sources import parse_source
|
||||
_client, engine = env
|
||||
sid = seed_session(engine)
|
||||
engine.settings = replace(engine.settings, streamlink=sys.executable, ffmpeg=shutil.which("ffmpeg"))
|
||||
dropped = []
|
||||
monkeypatch.setattr(engine, "capture_dropped", lambda session_id, got_video: dropped.append((session_id, got_video)))
|
||||
capture = worker_module.Capture(engine, sid, parse_source("https://www.twitch.tv/alanzoka"), tmp_path / "cap", start_idx=20)
|
||||
capture.thread.start() # sem o chat (não abre conexão)
|
||||
capture.thread.join(timeout=60)
|
||||
assert dropped == [(sid, False)]
|
||||
@@ -0,0 +1,196 @@
|
||||
import random
|
||||
|
||||
from app.scoring import ChatMessage, Params, Word, find_moments, message_weight, overlaps, snap_to_words
|
||||
from app.subtitles import build_ass, group_words
|
||||
|
||||
|
||||
def calm_chat(duration: int, rate: float = 3.0, seed: int = 1) -> list[ChatMessage]:
|
||||
rng = random.Random(seed)
|
||||
out = []
|
||||
for t in range(duration):
|
||||
for _ in range(int(rate) + (1 if rng.random() < rate % 1 else 0)):
|
||||
out.append(ChatMessage(t + rng.random(), rng.choice(["oi", "salve", "boa noite", "eae", "kappa"])))
|
||||
return out
|
||||
|
||||
|
||||
def burst(at: int, seconds: int, per_s: int, text: str) -> list[ChatMessage]:
|
||||
return [ChatMessage(at + s + i / per_s, text) for s in range(seconds) for i in range(per_s)]
|
||||
|
||||
|
||||
def test_message_weight_counts_reactions():
|
||||
assert message_weight("oi")[0] == 1.0
|
||||
weight, tags = message_weight("KKKKKKK clipa isso")
|
||||
assert "risada" in tags and "clip" in tags and weight == 5.0
|
||||
|
||||
|
||||
def test_finds_peak_after_the_event_and_cuts_before_it():
|
||||
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
|
||||
moments = find_moments(600, chat, [], [])
|
||||
assert len(moments) == 1
|
||||
m = moments[0]
|
||||
assert 300 <= m.peak_s <= 310
|
||||
assert m.start_s < 300 - 5 # o corte começa ANTES da reação (é ali que aconteceu)
|
||||
assert m.end_s >= m.peak_s
|
||||
assert Params().min_s <= m.end_s - m.start_s <= Params().max_s
|
||||
assert m.source == "chat" and m.reasons["tags"].get("risada")
|
||||
|
||||
|
||||
def test_big_chat_needs_relative_peak():
|
||||
# Chat enorme o tempo todo (canal grande) não vira corte sem um pico relativo.
|
||||
assert find_moments(600, calm_chat(600, rate=40), [], []) == []
|
||||
|
||||
|
||||
def test_two_peaks_far_apart_both_found_and_close_ones_merged():
|
||||
chat = calm_chat(900) + burst(200, 6, 25, "caralho") + burst(215, 4, 25, "kkkkk") + burst(600, 6, 25, "POGGERS")
|
||||
peaks = [m.peak_s for m in find_moments(900, chat, [], [])]
|
||||
assert len(peaks) == 2
|
||||
assert 195 <= peaks[0] <= 225 and 595 <= peaks[1] <= 610
|
||||
|
||||
|
||||
def test_live_mode_waits_for_settle():
|
||||
chat = calm_chat(316) + burst(300, 8, 25, "KKKK")
|
||||
assert find_moments(316, chat, [], [], live=True) == [] # pico perto demais do fim da gravação
|
||||
chat = calm_chat(400) + burst(300, 8, 25, "KKKK")
|
||||
assert len(find_moments(400, chat, [], [], live=True)) == 1
|
||||
|
||||
|
||||
def test_live_mode_does_not_cut_a_burst_that_is_still_growing():
|
||||
# Explosão começa em 300 e só atinge o máximo em 312; com 326 s gravados o máximo ainda não assentou,
|
||||
# e o começo da explosão (já "assentado") não pode virar corte sozinho.
|
||||
chat = calm_chat(326) + burst(300, 6, 10, "kkk") + burst(306, 8, 40, "KKKKKKK")
|
||||
assert find_moments(326, chat, [], [], live=True) == []
|
||||
|
||||
|
||||
def test_audio_mode_without_chat():
|
||||
loud = [-40.0] * 600
|
||||
for t in range(400, 406):
|
||||
loud[t] = -8.0
|
||||
moments = find_moments(600, [], loud, [])
|
||||
assert len(moments) == 1 and moments[0].source == "audio" and 395 <= moments[0].peak_s <= 410
|
||||
|
||||
|
||||
def test_snap_to_words_avoids_cutting_mid_sentence():
|
||||
words = [Word(10.0, 10.4, "olha"), Word(10.5, 10.9, "isso"), Word(12.0, 12.3, "não"), Word(12.35, 12.8, "acredito"),
|
||||
Word(20.0, 20.5, "mano")]
|
||||
start, end = snap_to_words(12.2, 12.5, words)
|
||||
assert start <= 12.0 and end >= 12.8
|
||||
|
||||
|
||||
def test_overlaps():
|
||||
assert overlaps(0, 30, 20, 50)
|
||||
assert not overlaps(0, 30, 27, 60) # tolerância de 5 s
|
||||
|
||||
|
||||
def test_ass_groups_words_and_escapes_tags():
|
||||
words = [Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "{isso}"), Word(1.7, 2.0, "aqui"), Word(5.0, 5.4, "gente")]
|
||||
groups = group_words(words)
|
||||
assert [len(g) for g in groups] == [3, 1]
|
||||
ass = build_ass(words, 0.5, 6.0, "twitch.tv/alanzoka")
|
||||
assert "Credit" in ass and "twitch.tv/alanzoka" in ass
|
||||
assert "{isso}" not in ass and "(ISSO)" in ass # chave do texto falado não vira tag ASS
|
||||
assert "0:00:00.50" in ass # "olha" em 1.0 s da sessão = 0.5 s do corte
|
||||
|
||||
|
||||
def test_params_default_follows_cut_settings_defaults():
|
||||
# Pedido do dono (16/11/2026): cortes de 60 a 90 s por padrão — a heurística segue a configuração do corte.
|
||||
from app.layout import DEFAULTS
|
||||
assert (Params().min_s, Params().max_s) == (DEFAULTS["duration"]["minS"], DEFAULTS["duration"]["maxS"]) == (60, 90)
|
||||
|
||||
|
||||
def test_regression_calm_chat_has_no_false_positives():
|
||||
# Medido na live real (16/11/2026): ~0,6 msg/s, 3 mensagens com um emote "clip5k1hmm" viravam corte,
|
||||
# e o começo da gravação também.
|
||||
chat = calm_chat(180, rate=0.6)
|
||||
chat += [ChatMessage(100.2, "l i b e r t e s é!"), ChatMessage(100.5, "clip5k1hmm"), ChatMessage(101.0, "ff")]
|
||||
chat += [ChatMessage(3 + i * 0.3, "130") for i in range(5)]
|
||||
assert message_weight("clip5k1hmm")[0] == 1.0
|
||||
assert message_weight("CLIP IT")[1] == ["clip"]
|
||||
assert find_moments(180, chat, [], []) == []
|
||||
|
||||
|
||||
def test_ass_keeps_tags_lowercase_when_uppercasing_text():
|
||||
ass = build_ass([Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "isso")], 0.0, 5.0, "")
|
||||
assert r"{\c&H00E5FF&}OLHA{\c&HFFFFFF&} ISSO" in ass and r"\C&" not in ass
|
||||
|
||||
|
||||
def test_regression_sparse_chat_still_finds_reactions():
|
||||
# Medido em 17/11/2026 (skipnho): 0,15 msg/s; reação de 6 mensagens em 8 s nunca passava do mínimo fixo de 12.
|
||||
chat = calm_chat(900, rate=0.15, seed=3)
|
||||
chat += [ChatMessage(500 + i, t) for i, t in enumerate(["KKKKKK", "kkkkkkk", "caralho", "KKKKK", "que isso", "kkkk"])]
|
||||
moments = [m for m in find_moments(900, chat, [], []) if m.source == "chat"]
|
||||
assert len(moments) == 1 and 495 <= moments[0].peak_s <= 510
|
||||
|
||||
|
||||
def test_sparse_chat_also_uses_audio():
|
||||
chat = calm_chat(600, rate=0.15, seed=4)
|
||||
loud = [-40.0] * 600
|
||||
for t in range(300, 306):
|
||||
loud[t] = -6.0
|
||||
moments = find_moments(600, chat, loud, [])
|
||||
assert any(m.source == "audio" and 295 <= m.peak_s <= 312 for m in moments)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- rosto do streamer (reaction.py)
|
||||
from app.reaction import FaceSecond # noqa: E402
|
||||
|
||||
|
||||
def calm_face(n: int, seed: int = 11) -> list[FaceSecond]:
|
||||
rng = random.Random(seed)
|
||||
return [FaceSecond(t, 1.0, 0.1, 0.5, 0.15, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.01),
|
||||
surprise=0.002, frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.01, 0.05), blink=0.1,
|
||||
motion=rng.uniform(0.02, 0.15)) for t in range(n)]
|
||||
|
||||
|
||||
def laugh_at(face: list[FaceSecond], start: int, seconds: int = 6) -> list[FaceSecond]:
|
||||
for t in range(start, start + seconds):
|
||||
face[t].smile = 0.9
|
||||
return face
|
||||
|
||||
|
||||
def noisy_loudness(n: int, seed: int = 2) -> list[float]:
|
||||
rng = random.Random(seed)
|
||||
return [-30.0 + rng.uniform(-1.5, 1.5) for _ in range(n)]
|
||||
|
||||
|
||||
def test_face_none_or_empty_keeps_old_behavior():
|
||||
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
|
||||
loud = noisy_loudness(600)
|
||||
base = find_moments(600, chat, loud, [])
|
||||
for face in (None, [], [FaceSecond(t) for t in range(600)]): # sem rosto em nenhum segundo
|
||||
again = find_moments(600, chat, loud, [], face=face)
|
||||
assert [(m.peak_s, m.start_s, m.end_s, m.score, m.source, m.reasons) for m in again] == \
|
||||
[(m.peak_s, m.start_s, m.end_s, m.score, m.source, m.reasons) for m in base]
|
||||
|
||||
|
||||
def test_face_reinforces_chat_moment_with_limited_bonus():
|
||||
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
|
||||
base = find_moments(600, chat, [], [])[0]
|
||||
m = find_moments(600, chat, [], [], face=laugh_at(calm_face(600), 296))[0]
|
||||
assert (m.peak_s, m.start_s, m.end_s, m.source) == (base.peak_s, base.start_s, base.end_s, "chat")
|
||||
assert m.reasons["face"]["label"] == "risada" and m.reasons["face"]["onsetS"] == 296
|
||||
assert 0 < m.score - base.score <= Params().face_bonus_max + 1e-9
|
||||
|
||||
|
||||
def test_face_alone_never_becomes_a_clip():
|
||||
# Risada no rosto sem áudio nem chat se mexendo: não vira corte (o rosto reforça, não manda).
|
||||
face = laugh_at(calm_face(600), 300)
|
||||
assert find_moments(600, [], noisy_loudness(600), [], face=face) == []
|
||||
|
||||
|
||||
def test_face_with_audio_support_creates_face_moment():
|
||||
loud = noisy_loudness(600)
|
||||
for t in range(299, 305):
|
||||
loud[t] = -28.5 # um pouco acima do normal: sozinho não chega a pico de áudio
|
||||
assert find_moments(600, [], loud, []) == []
|
||||
moments = find_moments(600, [], loud, [], face=laugh_at(calm_face(600), 300))
|
||||
assert len(moments) == 1
|
||||
m = moments[0]
|
||||
assert m.source == "face" and 300 <= m.peak_s <= 305 and m.reasons["face"]["label"] == "risada"
|
||||
assert m.start_s < 300 - 5 and m.reasons["support"]["audioZ"] >= 1.0 and m.score > 0
|
||||
|
||||
|
||||
def test_face_moment_respects_live_settle():
|
||||
loud = noisy_loudness(316)
|
||||
for t in range(299, 305):
|
||||
loud[t] = -28.5
|
||||
assert find_moments(316, [], loud, [], live=True, face=laugh_at(calm_face(316), 300)) == []
|
||||
@@ -0,0 +1,255 @@
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.config import Settings
|
||||
from app.db import Database
|
||||
from app.judge import Judge, JudgeError, Verdict, _clean, build_prompt
|
||||
from app.main import create_app
|
||||
from app.scoring import ChatMessage, Word
|
||||
from app.sources import SourceError, parse_source
|
||||
from app.worker import Engine, wall_to_t
|
||||
|
||||
KEY = "k" * 40
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url,platform,channel,kind", [
|
||||
("https://www.twitch.tv/alanzoka", "twitch", "alanzoka", "live"),
|
||||
("twitch.tv/Alanzoka?x=1", "twitch", "alanzoka", "live"),
|
||||
("https://www.twitch.tv/videos/123456789", "twitch", "", "vod"),
|
||||
("https://kick.com/gaules", "kick", "gaules", "live"),
|
||||
("https://www.youtube.com/@canal", "youtube", "@canal", "live"),
|
||||
("https://youtu.be/dQw4w9WgXcQ", "youtube", "", "vod"),
|
||||
("https://www.youtube.com/watch?v=dQw4w9WgXcQ", "youtube", "", "vod"),
|
||||
])
|
||||
def test_parse_source(url, platform, channel, kind):
|
||||
source = parse_source(url)
|
||||
assert (source.platform, source.channel, source.kind) == (platform, channel, kind)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url", ["", "https://vimeo.com/1", "https://www.twitch.tv/directory", "ftp://twitch.tv/x"])
|
||||
def test_parse_source_rejects(url):
|
||||
with pytest.raises(SourceError):
|
||||
parse_source(url)
|
||||
|
||||
|
||||
def test_wall_to_t_maps_by_segment_arrival():
|
||||
# Bloco 0 (0–30 s) chegou às 1000; bloco 1 (30–60 s) chegou às 1060 (pausa de 30 s: anúncio filtrado).
|
||||
segments = [{"idx": 0, "start_s": 0.0, "end_s": 30.0, "wall_end": 1000.0},
|
||||
{"idx": 1, "start_s": 30.0, "end_s": 60.0, "wall_end": 1060.0}]
|
||||
assert wall_to_t(990.0, segments) == 20.0
|
||||
assert wall_to_t(960.0, segments) is None # antes de a gravação começar
|
||||
assert wall_to_t(1010.0, segments) == 30.0 # durante a pausa: cai no começo do bloco seguinte
|
||||
assert wall_to_t(1050.0, segments) == 50.0
|
||||
assert wall_to_t(1065.0, segments) == 65.0
|
||||
|
||||
|
||||
def test_judge_prompt_and_clean():
|
||||
words = [Word(100.0, 100.4, "não"), Word(100.5, 101.0, "acredito")]
|
||||
chat = [ChatMessage(104.0, "KKKKK"), ChatMessage(105.0, "clipa")]
|
||||
prompt = build_prompt("alanzoka", "twitch", 90, 120, 104, words, chat, {"peakRatio": 4.2})
|
||||
assert "[100s] não acredito" in prompt and "KKKKK" in prompt and "alanzoka" in prompt
|
||||
verdict = _clean({"keep": True, "score": 14, "start_s": 0, "end_s": 500, "title": "t", "caption": "c", "reason": "r"},
|
||||
200, 230, "m")
|
||||
# Padrão novo (16/11/2026): pode voltar até 2 min antes do candidato (a ação vem antes do comentário), nunca
|
||||
# além; duração de 60 a 90 s.
|
||||
assert verdict.score == 10.0 and verdict.start_s == 80 and verdict.end_s == 170
|
||||
assert "Duração do corte: 60 a 90 s" in prompt and "Janela disponível: 0s a 135s" in prompt
|
||||
old = _clean({"keep": True, "score": 8, "start_s": 0, "end_s": 500, "title": "t", "caption": "c", "reason": "r"},
|
||||
90, 120, "m", lo=30, hi=135, min_s=15, max_s=59)
|
||||
assert (old.start_s, old.end_s) == (30, 89) # configuração antiga (15–59 s) continua valendo se o canal pedir
|
||||
longer = _clean({"keep": True, "score": 8, "start_s": 70, "end_s": 160, "title": "t", "caption": "c", "reason": "r"},
|
||||
90, 120, "m", lo=30, hi=135, max_s=90)
|
||||
assert (longer.start_s, longer.end_s) == (70, 135) # duração máxima configurável (até 180 s)
|
||||
|
||||
|
||||
class FakeJudge(Judge):
|
||||
def __init__(self, keep=True, score=8.0):
|
||||
super().__init__("codex", "fake", Path("."))
|
||||
self.keep, self.score_value, self.calls = keep, score, 0
|
||||
|
||||
def ask(self, system, prompt, schema, images, **_kwargs):
|
||||
# Nunca chama a CLI de verdade nos testes (gastaria a cota do dono): analista, varredura e "IA sugere"
|
||||
# seguem o caminho de falha da IA, que o serviço já trata.
|
||||
raise JudgeError("IA falsa nos testes")
|
||||
|
||||
def judge(self, prompt, start_s, end_s, images=None, **_limits):
|
||||
self.calls += 1
|
||||
return Verdict(self.keep, self.score_value, start_s, end_s, "Título da IA", "legenda #cortes", "motivo", "fake")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def env(tmp_path):
|
||||
settings = Settings.load(env_file=tmp_path / "none.env", service_key=KEY, data_dir=tmp_path / "data",
|
||||
clips_dir=tmp_path / "clips", judge_provider="codex", voice_url=None, voice_key=None)
|
||||
db = Database(settings.data_dir / "clipper.db")
|
||||
engine = Engine(settings, db, judge=FakeJudge())
|
||||
app = create_app(settings, engine, start_engine=False)
|
||||
return TestClient(app), engine
|
||||
|
||||
|
||||
def auth():
|
||||
return {"X-Service-Key": KEY}
|
||||
|
||||
|
||||
def test_auth_required(env):
|
||||
client, _ = env
|
||||
assert client.get("/health").status_code == 200
|
||||
assert client.get("/v1/channels").status_code == 401
|
||||
assert client.get("/v1/channels", headers={"X-Service-Key": "errada"}).status_code == 401
|
||||
|
||||
|
||||
def test_channel_crud(env):
|
||||
client, _ = env
|
||||
r = client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
|
||||
assert r.status_code == 201 and r.json()["id"] == "twitch-alanzoka" and r.json()["displayName"] == "alanzoka"
|
||||
assert client.post("/v1/channels", json={"url": "twitch.tv/alanzoka"}, headers=auth()).status_code == 409
|
||||
assert client.post("/v1/channels", json={"url": "https://www.twitch.tv/videos/1"}, headers=auth()).status_code == 400
|
||||
r = client.patch("/v1/channels/twitch-alanzoka", json={"monitor": False, "displayName": "Alanzoka"}, headers=auth())
|
||||
assert r.json()["monitor"] is False and r.json()["displayName"] == "Alanzoka"
|
||||
assert client.delete("/v1/channels/twitch-alanzoka", headers=auth()).status_code == 204
|
||||
assert client.get("/v1/channels", headers=auth()).json()["channels"] == []
|
||||
|
||||
|
||||
def seed_session(engine: Engine, duration: int = 600, burst_at: int = 300) -> int:
|
||||
db = engine.db
|
||||
cur = db.run("INSERT INTO sessions (platform, kind, url, status, dir, started_at, duration_s) VALUES"
|
||||
" ('twitch', 'live', 'https://www.twitch.tv/alanzoka', 'processing', '', '2026-11-16T00:00:00+00:00', ?)",
|
||||
duration)
|
||||
sid = cur.lastrowid
|
||||
base_wall = 10_000.0
|
||||
for i in range(duration // 30):
|
||||
db.run("INSERT INTO segments (session_id, idx, file, start_s, end_s, wall_end, analyzed, loudness_json, words_json)"
|
||||
" VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)",
|
||||
sid, i, f"x/seg_{i:05d}.ts", i * 30.0, (i + 1) * 30.0, base_wall + (i + 1) * 30.0,
|
||||
json.dumps([-30.0] * 30), json.dumps([[i * 30 + 1.0, i * 30 + 1.5, "fala"]]))
|
||||
rows = []
|
||||
for t in range(duration):
|
||||
rows.append((sid, base_wall + t + 0.5, "u", "salve"))
|
||||
rows.append((sid, base_wall + t + 0.7, "u", "oi"))
|
||||
for s in range(8):
|
||||
for k in range(25):
|
||||
rows.append((sid, base_wall + burst_at + s + k / 25, "u", "KKKKKKK"))
|
||||
db.many("INSERT INTO chat (session_id, wall, user, text) VALUES (?, ?, ?, ?)", rows)
|
||||
return sid
|
||||
|
||||
|
||||
def test_pipeline_finds_judges_and_lists_clip(env):
|
||||
client, engine = env
|
||||
sid = seed_session(engine)
|
||||
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
|
||||
assert engine.find_new_clips(session) == 1
|
||||
assert engine.find_new_clips(session) == 0 # não repete o mesmo trecho
|
||||
engine.judge_candidates()
|
||||
clip = client.get("/v1/clips", headers=auth()).json()["clips"][0]
|
||||
assert clip["status"] == "pending" and clip["title"] == "Título da IA"
|
||||
assert "twitch.tv/alanzoka" in clip["caption"] # crédito do canal sempre na legenda
|
||||
assert clip["judge"]["score"] == 8.0
|
||||
# aprovar antes do render é recusado
|
||||
assert client.patch(f"/v1/clips/{clip['id']}", json={"status": "approved"}, headers=auth()).status_code == 400
|
||||
# mudar o trecho volta para a fila de render
|
||||
r = client.patch(f"/v1/clips/{clip['id']}", json={"startS": clip["startS"] - 3}, headers=auth())
|
||||
assert r.json()["status"] == "pending"
|
||||
tl = client.get(f"/v1/sessions/{sid}/timeline", headers=auth()).json()
|
||||
assert tl["durationS"] == 600 and max(tl["messagesPerS"]) >= 25
|
||||
|
||||
|
||||
def test_judge_config_persists(env, tmp_path):
|
||||
client, engine = env
|
||||
r = client.get("/v1/judge", headers=auth()).json()
|
||||
assert r["provider"] == "codex" and "codex" in r["models"]
|
||||
r = client.put("/v1/judge", json={"provider": "claude", "model": "", "minScore": 7}, headers=auth())
|
||||
assert r.status_code == 200 and r.json()["model"] == "haiku" and r.json()["minScore"] == 7
|
||||
assert client.put("/v1/judge", json={"provider": "gpt", "model": ""}, headers=auth()).status_code == 422
|
||||
assert client.put("/v1/judge", json={"provider": "codex", "model": "x; rm -rf"}, headers=auth()).status_code == 422
|
||||
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
|
||||
assert saved == {"judge_provider": "claude", "judge_model": "haiku", "judge_min_score": "7.0", "judge_analyst_model": ""}
|
||||
|
||||
|
||||
def test_manual_clip_is_never_discarded(env):
|
||||
client, engine = env
|
||||
engine.judge = FakeJudge(keep=False, score=1)
|
||||
sid = seed_session(engine)
|
||||
r = client.post(f"/v1/sessions/{sid}/clips", json={"lastS": 40}, headers=auth())
|
||||
assert r.status_code == 201 and r.json()["startS"] == 560
|
||||
engine.judge_candidates()
|
||||
clip = client.get(f"/v1/clips/{r.json()['id']}", headers=auth()).json()
|
||||
assert clip["status"] == "pending" and (clip["startS"], clip["endS"]) == (560, 600)
|
||||
|
||||
|
||||
def test_codex_models_reads_cache(tmp_path):
|
||||
from app.judge import codex_models
|
||||
cache = tmp_path / "m.json"
|
||||
cache.write_text(json.dumps({"models": [{"slug": "gpt-6-luna", "display_name": "GPT-6-Luna", "visibility": "list"},
|
||||
{"slug": "hidden", "visibility": "hide"}]}))
|
||||
assert [m["id"] for m in codex_models(cache)] == ["gpt-6-luna"]
|
||||
assert codex_models(tmp_path / "nao-existe.json")[0]["id"] == "gpt-6-luna"
|
||||
|
||||
|
||||
def test_codex_lean_overrides(tmp_path):
|
||||
from app.judge import codex_lean_overrides
|
||||
config = tmp_path / "config.toml"
|
||||
config.write_text('[mcp_servers.node_repl]\ncommand = "x"\n[mcp_servers.node_repl.env]\n'
|
||||
'[plugins."computer-use@openai-bundled"]\nenabled = true\n')
|
||||
plain = codex_lean_overrides(False, config)
|
||||
assert plain.count("-c") == len(plain) // 2
|
||||
assert "features.shell_tool=false" in plain and "features.computer_use=false" in plain
|
||||
# Um servidor por nome (a subtabela .env não vira outro servidor) e o plugin presente no config.
|
||||
assert plain.count("mcp_servers.node_repl.enabled=false") == 1
|
||||
assert 'plugins."computer-use@openai-bundled".enabled=false' in plain
|
||||
assert not any("unified-computer-use" in a for a in plain)
|
||||
# Com busca na web, as ferramentas de execução ficam (a web do Codex depende delas).
|
||||
searching = codex_lean_overrides(True, config)
|
||||
assert "features.shell_tool=false" not in searching and "features.computer_use=false" in searching
|
||||
assert codex_lean_overrides(False, tmp_path / "nao-existe.toml")[-1] == "features.browser_use=false"
|
||||
|
||||
|
||||
def test_judge_discard_keeps_record(env):
|
||||
client, engine = env
|
||||
engine.judge = FakeJudge(keep=False, score=3)
|
||||
sid = seed_session(engine)
|
||||
engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid))
|
||||
engine.judge_candidates()
|
||||
clip = client.get("/v1/clips?status=discarded", headers=auth()).json()["clips"][0]
|
||||
assert clip["judge"]["keep"] is False
|
||||
r = client.post(f"/v1/clips/{clip['id']}/render", headers=auth())
|
||||
assert r.json()["status"] == "pending"
|
||||
|
||||
|
||||
def test_data_and_output_dirs_can_be_isolated(tmp_path, monkeypatch):
|
||||
"""CLIPPER_DATA_DIR/CLIPPER_OUTPUT_DIR: instância de teste isolada; padrão igual ao de antes; fora do repo = erro."""
|
||||
from app.config import REPO_ROOT, ConfigError
|
||||
|
||||
for name in ("CLIPPER_DATA_DIR", "CLIPPER_OUTPUT_DIR"):
|
||||
monkeypatch.delenv(name, raising=False)
|
||||
s = Settings.load(env_file=tmp_path / "none.env")
|
||||
assert s.data_dir == REPO_ROOT / "data" / "clipper" and s.clips_dir == REPO_ROOT / "output" / "clipper"
|
||||
monkeypatch.setenv("CLIPPER_DATA_DIR", "output/x-test/data")
|
||||
monkeypatch.setenv("CLIPPER_OUTPUT_DIR", str(REPO_ROOT / "output" / "x-test" / "clips"))
|
||||
s = Settings.load(env_file=tmp_path / "none.env")
|
||||
assert s.data_dir == REPO_ROOT / "output" / "x-test" / "data"
|
||||
assert (s.data_dir / "sessions" / "1").relative_to(REPO_ROOT).as_posix() == "output/x-test/data/sessions/1"
|
||||
assert s.clips_dir == REPO_ROOT / "output" / "x-test" / "clips"
|
||||
monkeypatch.setenv("CLIPPER_DATA_DIR", str(tmp_path / "fora"))
|
||||
with pytest.raises(ConfigError):
|
||||
Settings.load(env_file=tmp_path / "none.env")
|
||||
|
||||
|
||||
def test_list_clips_filters_by_channel_and_ids(env):
|
||||
"""Filtros usados pelo despachante de publicação do painel: fonte (`channel`) e lista de `ids`."""
|
||||
client, engine = env
|
||||
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
|
||||
sid = seed_session(engine)
|
||||
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
|
||||
other = seed_session(engine)
|
||||
for s in (sid, other):
|
||||
engine.db.run("INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, status, created_at, updated_at)"
|
||||
" VALUES (?, 10, 0, 20, 5, 'manual', 'ready', 'x', 'x')", s)
|
||||
mine = client.get("/v1/clips?status=ready,approved&channel=twitch-alanzoka", headers=auth()).json()["clips"]
|
||||
assert [c["channelId"] for c in mine] == ["twitch-alanzoka"]
|
||||
all_ids = [c["id"] for c in client.get("/v1/clips", headers=auth()).json()["clips"]]
|
||||
picked = client.get(f"/v1/clips?ids={all_ids[0]}", headers=auth()).json()["clips"]
|
||||
assert [c["id"] for c in picked] == [all_ids[0]]
|
||||
assert client.get("/v1/clips?ids=1,abc", headers=auth()).status_code == 400
|
||||
@@ -0,0 +1,562 @@
|
||||
"""Bancada de rastreio de rosto do Clipador (Fase 0 do doc/PLANO_RASTREIO_REACAO.md).
|
||||
|
||||
Compara, numa sessão já gravada:
|
||||
1. YuNet no quadro inteiro para achar a câmera (12 quadros espalhados);
|
||||
2. MediaPipe Face Landmarker (blendshapes) × OpenSeeFace (só os .onnx) no recorte da câmera,
|
||||
em trechos de 30 s a 6 qps.
|
||||
|
||||
Uso (venv do Clipador):
|
||||
clipper\\.venv\\Scripts\\python.exe clipper\\tools\\face_bench.py --session 3
|
||||
|
||||
Lê o banco só em modo leitura (o serviço do usuário pode estar rodando). Saídas em output/face-bench/.
|
||||
Não é usado pelo serviço; a integração fica em clipper/app/face.py (Fase 2).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import csv
|
||||
import json
|
||||
import sqlite3
|
||||
import statistics
|
||||
import subprocess
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
MODELS = ROOT / "data" / "clipper" / "models"
|
||||
YUNET = "face_detection_yunet_2026may.onnx"
|
||||
YUNET_OLD = "face_detection_yunet_2023mar.onnx"
|
||||
LANDMARKER = "face_landmarker.task"
|
||||
OSF_LM = "osf_lm_model3_opt.onnx"
|
||||
OSF_DET = "osf_mnv3_detection_opt.onnx"
|
||||
|
||||
BLENDS = (
|
||||
"jawOpen", "mouthSmileLeft", "mouthSmileRight", "eyeWideLeft", "eyeWideRight",
|
||||
"browInnerUp", "browDownLeft", "browDownRight",
|
||||
)
|
||||
FPS = 6
|
||||
WINDOW_S = 30.0
|
||||
CROP_SIDE = 384 # maior lado do recorte da câmera que vai para os modelos
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- vídeo
|
||||
|
||||
def ffmpeg_bin() -> str:
|
||||
return "ffmpeg"
|
||||
|
||||
|
||||
@dataclass
|
||||
class Block:
|
||||
path: Path
|
||||
start: float
|
||||
end: float
|
||||
|
||||
|
||||
def load_blocks(session_dir: Path) -> list[Block]:
|
||||
blocks = []
|
||||
with open(session_dir / "segments.csv", newline="", encoding="utf-8") as fh:
|
||||
for name, start, end in csv.reader(fh):
|
||||
blocks.append(Block(session_dir / name, float(start), float(end)))
|
||||
return blocks
|
||||
|
||||
|
||||
def probe_size(path: Path) -> tuple[int, int]:
|
||||
out = subprocess.run(
|
||||
["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
|
||||
"-of", "csv=p=0", str(path)],
|
||||
capture_output=True, text=True, check=True,
|
||||
).stdout.strip().splitlines()[0]
|
||||
w, h = out.split(",")[:2]
|
||||
return int(w), int(h)
|
||||
|
||||
|
||||
def grab_frame(blocks: list[Block], t: float, size: tuple[int, int]) -> np.ndarray | None:
|
||||
"""Um quadro BGR no tempo t (s da sessão)."""
|
||||
block = next((b for b in blocks if b.start <= t < b.end), None)
|
||||
if block is None:
|
||||
return None
|
||||
w, h = size
|
||||
raw = subprocess.run(
|
||||
[ffmpeg_bin(), "-v", "error", "-ss", f"{t - block.start:.3f}", "-i", str(block.path),
|
||||
"-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"],
|
||||
capture_output=True, check=True,
|
||||
).stdout
|
||||
if len(raw) < w * h * 3:
|
||||
return None
|
||||
return np.frombuffer(raw[: w * h * 3], np.uint8).reshape(h, w, 3).copy()
|
||||
|
||||
|
||||
def read_window(blocks: list[Block], t0: float, length: float, crop_px: tuple[int, int, int, int],
|
||||
out_size: tuple[int, int]) -> list[tuple[float, np.ndarray]]:
|
||||
"""Quadros RGB do recorte (x, y, w, h em px) a FPS qps, de t0 a t0+length, atravessando blocos."""
|
||||
x, y, cw, ch = crop_px
|
||||
ow, oh = out_size
|
||||
frames: list[tuple[float, np.ndarray]] = []
|
||||
t1 = t0 + length
|
||||
for b in blocks:
|
||||
a, z = max(t0, b.start), min(t1, b.end)
|
||||
if z <= a:
|
||||
continue
|
||||
raw = subprocess.run(
|
||||
[ffmpeg_bin(), "-v", "error", "-ss", f"{a - b.start:.3f}", "-t", f"{z - a:.3f}", "-i", str(b.path),
|
||||
"-vf", f"fps={FPS},crop={cw}:{ch}:{x}:{y},scale={ow}:{oh}",
|
||||
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
|
||||
capture_output=True, check=True,
|
||||
).stdout
|
||||
n = len(raw) // (ow * oh * 3)
|
||||
arr = np.frombuffer(raw[: n * ow * oh * 3], np.uint8).reshape(n, oh, ow, 3)
|
||||
for i in range(n):
|
||||
frames.append((a + i / FPS, arr[i].copy()))
|
||||
return frames
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- câmera (YuNet)
|
||||
|
||||
def make_yunet(name: str, size: tuple[int, int]):
|
||||
return cv2.FaceDetectorYN.create(str(MODELS / name), "", size, 0.6, 0.3, 50)
|
||||
|
||||
|
||||
def iou(a: dict, b: dict) -> float:
|
||||
ax2, ay2, bx2, by2 = a["x"] + a["w"], a["y"] + a["h"], b["x"] + b["w"], b["y"] + b["h"]
|
||||
iw = max(0.0, min(ax2, bx2) - max(a["x"], b["x"]))
|
||||
ih = max(0.0, min(ay2, by2) - max(a["y"], b["y"]))
|
||||
inter = iw * ih
|
||||
union = a["w"] * a["h"] + b["w"] * b["h"] - inter
|
||||
return inter / union if union > 0 else 0.0
|
||||
|
||||
|
||||
def clamp_rect(r: dict) -> dict:
|
||||
x, y = max(0.0, r["x"]), max(0.0, r["y"])
|
||||
x2, y2 = min(1.0, r["x"] + r["w"]), min(1.0, r["y"] + r["h"])
|
||||
return {"x": round(x, 4), "y": round(y, 4), "w": round(x2 - x, 4), "h": round(y2 - y, 4)}
|
||||
|
||||
|
||||
def face_to_cam(face: dict) -> dict:
|
||||
"""Retângulo da câmera estimado só pelo rosto (≈3,2× largura, 3,6× altura, rosto no terço de cima)."""
|
||||
cx, cy = face["x"] + face["w"] / 2, face["y"] + face["h"] / 2
|
||||
w, h = face["w"] * 3.2, face["h"] * 3.6
|
||||
return clamp_rect({"x": cx - w / 2, "y": cy - h * 0.38, "w": w, "h": h})
|
||||
|
||||
|
||||
def locate_cam(blocks, size, duration, ai_cam, out_dir: Path) -> dict:
|
||||
fw, fh = size
|
||||
times = [30 + i * (duration - 60) / 11 for i in range(12)]
|
||||
det = make_yunet(YUNET, size)
|
||||
# A 2023mar (entrada fixa) não está no models.lock.json; só entra na comparação se estiver na pasta.
|
||||
det_old = make_yunet(YUNET_OLD, size) if (MODELS / YUNET_OLD).exists() else None
|
||||
rows, thumbs, ms, ms_old = [], [], [], []
|
||||
for t in times:
|
||||
img = grab_frame(blocks, t, size)
|
||||
if img is None:
|
||||
continue
|
||||
t_a = time.perf_counter()
|
||||
_, faces = det.detect(img)
|
||||
ms.append((time.perf_counter() - t_a) * 1000)
|
||||
faces_old = faces
|
||||
if det_old is not None:
|
||||
t_a = time.perf_counter()
|
||||
_, faces_old = det_old.detect(img)
|
||||
ms_old.append((time.perf_counter() - t_a) * 1000)
|
||||
found = []
|
||||
for f in (faces if faces is not None else []):
|
||||
found.append({"x": float(f[0]) / fw, "y": float(f[1]) / fh, "w": float(f[2]) / fw,
|
||||
"h": float(f[3]) / fh, "score": round(float(f[14]), 3)})
|
||||
rows.append({"t": round(t, 1), "faces": found,
|
||||
"old_same": (faces_old is not None) == (faces is not None)})
|
||||
thumbs.append((t, img, found))
|
||||
|
||||
# Agrupa rostos pela posição: entra no grupo de centroide mais próximo se estiver a menos de 1 largura
|
||||
# (e 1 altura) de rosto dele. Comparar com o 1º membro (versão anterior) partia o streamer inclinado em 2.
|
||||
clusters: list[list[dict]] = []
|
||||
|
||||
def centroid(cl):
|
||||
return (statistics.mean(m["x"] + m["w"] / 2 for m in cl), statistics.mean(m["y"] + m["h"] / 2 for m in cl),
|
||||
statistics.mean(m["w"] for m in cl), statistics.mean(m["h"] for m in cl))
|
||||
|
||||
for r in rows:
|
||||
for f in r["faces"]:
|
||||
c = (f["x"] + f["w"] / 2, f["y"] + f["h"] / 2)
|
||||
best_cl, best_d = None, 1.0
|
||||
for cl in clusters:
|
||||
gx, gy, gw, gh = centroid(cl)
|
||||
dx, dy = abs(c[0] - gx) / gw, abs(c[1] - gy) / gh
|
||||
if dx < 1.0 and dy < 1.0 and max(dx, dy) < best_d:
|
||||
best_cl, best_d = cl, max(dx, dy)
|
||||
if best_cl is not None:
|
||||
best_cl.append({**f, "t": r["t"]})
|
||||
else:
|
||||
clusters.append([{**f, "t": r["t"]}])
|
||||
clusters.sort(key=lambda cl: len({m["t"] for m in cl}), reverse=True)
|
||||
best = clusters[0] if clusters else []
|
||||
result: dict = {
|
||||
"frames": len(rows),
|
||||
"framesWithFace": sum(1 for r in rows if r["faces"]),
|
||||
"yunetMsPerFrame": round(statistics.mean(ms), 1) if ms else None,
|
||||
"yunet2023marMsPerFrame": round(statistics.mean(ms_old), 1) if ms_old else None,
|
||||
"variantsAgree": all(r["old_same"] for r in rows),
|
||||
"clusters": [{"n": len({m["t"] for m in cl}),
|
||||
"cx": round(statistics.median(m["x"] + m["w"] / 2 for m in cl), 3),
|
||||
"cy": round(statistics.median(m["y"] + m["h"] / 2 for m in cl), 3)} for cl in clusters],
|
||||
"rows": rows,
|
||||
}
|
||||
if best:
|
||||
med = {k: statistics.median(m[k] for m in best) for k in ("x", "y", "w", "h")}
|
||||
cxs = [m["x"] + m["w"] / 2 for m in best]
|
||||
cys = [m["y"] + m["h"] / 2 for m in best]
|
||||
cam = face_to_cam(med)
|
||||
inside = clamp_rect({"x": max(med["x"], ai_cam["x"]), "y": max(med["y"], ai_cam["y"]),
|
||||
"w": min(med["x"] + med["w"], ai_cam["x"] + ai_cam["w"]) - max(med["x"], ai_cam["x"]),
|
||||
"h": min(med["y"] + med["h"], ai_cam["y"] + ai_cam["h"]) - max(med["y"], ai_cam["y"])})
|
||||
result.update({
|
||||
"presence": round(len({m["t"] for m in best}) / max(1, len(rows)), 3),
|
||||
"face": {k: round(v, 4) for k, v in med.items()},
|
||||
"facePx": round(med["h"] * fh),
|
||||
"jitterCx": round(statistics.pstdev(cxs) / med["w"], 3),
|
||||
"jitterCy": round(statistics.pstdev(cys) / med["h"], 3),
|
||||
"cam": cam,
|
||||
"iouWithAi": round(iou(cam, ai_cam), 3),
|
||||
"faceInsideAi": round(max(0.0, inside["w"]) * max(0.0, inside["h"]) / (med["w"] * med["h"]), 3),
|
||||
})
|
||||
# Folha de contato: verde = YuNet, azul = câmera da IA, amarelo = câmera estimada pelo rosto.
|
||||
tiles = []
|
||||
for t, img, found in thumbs:
|
||||
tile = img.copy()
|
||||
for f in found:
|
||||
cv2.rectangle(tile, (int(f["x"] * fw), int(f["y"] * fh)),
|
||||
(int((f["x"] + f["w"]) * fw), int((f["y"] + f["h"]) * fh)), (0, 255, 0), 3)
|
||||
for rect, color in ((ai_cam, (255, 120, 0)), (result.get("cam"), (0, 220, 255))):
|
||||
if rect:
|
||||
cv2.rectangle(tile, (int(rect["x"] * fw), int(rect["y"] * fh)),
|
||||
(int((rect["x"] + rect["w"]) * fw), int((rect["y"] + rect["h"]) * fh)), color, 3)
|
||||
tile = cv2.resize(tile, (480, 270))
|
||||
cv2.putText(tile, f"t={t:.0f}s", (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
|
||||
tiles.append(tile)
|
||||
save_grid(tiles, 4, out_dir / "cam_sheet.png")
|
||||
return result
|
||||
|
||||
|
||||
def save_grid(tiles: list[np.ndarray], cols: int, path: Path) -> None:
|
||||
if not tiles:
|
||||
return
|
||||
h, w = tiles[0].shape[:2]
|
||||
rows = (len(tiles) + cols - 1) // cols
|
||||
sheet = np.zeros((rows * h, cols * w, 3), np.uint8)
|
||||
for i, tile in enumerate(tiles):
|
||||
r, c = divmod(i, cols)
|
||||
sheet[r * h:(r + 1) * h, c * w:(c + 1) * w] = tile
|
||||
cv2.imwrite(str(path), sheet)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- MediaPipe
|
||||
|
||||
@dataclass
|
||||
class Sample:
|
||||
t: float
|
||||
present: bool
|
||||
ms: float
|
||||
box: tuple[float, float, float, float] | None = None # x, y, w, h em px do recorte
|
||||
points: np.ndarray | None = None
|
||||
blend: dict = field(default_factory=dict)
|
||||
|
||||
|
||||
def run_mediapipe(frames: list[tuple[float, np.ndarray]]) -> list[Sample]:
|
||||
import mediapipe as mp
|
||||
from mediapipe.tasks.python.core.base_options import BaseOptions
|
||||
from mediapipe.tasks.python import vision
|
||||
|
||||
options = vision.FaceLandmarkerOptions(
|
||||
base_options=BaseOptions(model_asset_path=str(MODELS / LANDMARKER)),
|
||||
running_mode=vision.RunningMode.VIDEO,
|
||||
num_faces=1,
|
||||
min_face_detection_confidence=0.5,
|
||||
min_face_presence_confidence=0.5,
|
||||
min_tracking_confidence=0.5,
|
||||
output_face_blendshapes=True,
|
||||
)
|
||||
out: list[Sample] = []
|
||||
with vision.FaceLandmarker.create_from_options(options) as lm:
|
||||
for t, rgb in frames:
|
||||
h, w = rgb.shape[:2]
|
||||
image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.ascontiguousarray(rgb))
|
||||
t_a = time.perf_counter()
|
||||
res = lm.detect_for_video(image, int(round(t * 1000)))
|
||||
ms = (time.perf_counter() - t_a) * 1000
|
||||
if not res.face_landmarks:
|
||||
out.append(Sample(t, False, ms))
|
||||
continue
|
||||
pts = np.array([(p.x * w, p.y * h) for p in res.face_landmarks[0]], np.float32)
|
||||
x1, y1 = pts.min(0)
|
||||
x2, y2 = pts.max(0)
|
||||
blend = {c.category_name: float(c.score) for c in res.face_blendshapes[0] if c.category_name in BLENDS}
|
||||
out.append(Sample(t, True, ms, (float(x1), float(y1), float(x2 - x1), float(y2 - y1)), pts, blend))
|
||||
return out
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- OpenSeeFace (pré/pós mínimo do tracker.py)
|
||||
|
||||
class OsfTracker:
|
||||
"""Reimplementação mínima de emilianavt/OpenSeeFace tracker.py (BSD-2), modelo 3, sem olhar/3D.
|
||||
|
||||
Detector mnv3 (224×224, saída 56×56 com raio) quando não há rosto; depois reaproveita a caixa dos
|
||||
pontos do quadro anterior, como o original. Pontos no formato 66 do OpenSeeFace (≈ iBUG 68 sem 60/64).
|
||||
"""
|
||||
|
||||
RES = 224
|
||||
OUT_RES = 27
|
||||
LOGIT = 16.0
|
||||
|
||||
def __init__(self, threads: int = 1, threshold: float = 0.6, det_threshold: float = 0.6):
|
||||
import onnxruntime as ort
|
||||
|
||||
opts = ort.SessionOptions()
|
||||
opts.inter_op_num_threads = 1
|
||||
opts.intra_op_num_threads = threads
|
||||
opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
|
||||
prov = ["CPUExecutionProvider"]
|
||||
self.lm = ort.InferenceSession(str(MODELS / OSF_LM), sess_options=opts, providers=prov)
|
||||
self.det = ort.InferenceSession(str(MODELS / OSF_DET), sess_options=opts, providers=prov)
|
||||
self.lm_input = self.lm.get_inputs()[0].name
|
||||
mean = np.float32([0.485, 0.456, 0.406])
|
||||
std = np.float32([0.229, 0.224, 0.225])
|
||||
self.mean = -(mean / std)
|
||||
self.scale = 1.0 / (std * 255.0)
|
||||
self.threshold = threshold
|
||||
self.det_threshold = det_threshold
|
||||
self.face: tuple[float, float, float, float] | None = None
|
||||
self.misses = 0
|
||||
|
||||
def _norm(self, rgb: np.ndarray, size: int) -> np.ndarray:
|
||||
im = cv2.resize(rgb.astype(np.float32), (size, size), interpolation=cv2.INTER_LINEAR)
|
||||
im = im * self.scale + self.mean
|
||||
return np.transpose(im[None], (0, 3, 1, 2)).astype(np.float32)
|
||||
|
||||
def detect(self, rgb: np.ndarray) -> tuple[float, float, float, float] | None:
|
||||
out, maxpool = self.det.run([], {"input": self._norm(rgb, 224)})
|
||||
out, maxpool = np.array(out), np.array(maxpool)
|
||||
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
|
||||
best = int(np.argmax(out[0, 0]))
|
||||
y, x = divmod(best, 56)
|
||||
if out[0, 0, y, x] < self.det_threshold:
|
||||
return None
|
||||
r = out[0, 1, y, x] * 112.0
|
||||
x, y = x * 4, y * 4
|
||||
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
|
||||
return ((x - r) * sx, (y - r) * sy, 2 * r * sx, 2 * r * sy)
|
||||
|
||||
def landmarks(self, rgb: np.ndarray, box) -> tuple[float, np.ndarray]:
|
||||
h, w = rgb.shape[:2]
|
||||
x, y, bw, bh = box
|
||||
x1 = int(np.clip(x - int(bw * 0.1), 0, w - 1))
|
||||
y1 = int(np.clip(y - int(bh * 0.125), 0, h - 1))
|
||||
x2 = int(np.clip(x + bw + int(bw * 0.1), 0, w - 1))
|
||||
y2 = int(np.clip(y + bh + int(bh * 0.125), 0, h - 1))
|
||||
if x2 - x1 < 4 or y2 - y1 < 4:
|
||||
return 0.0, np.zeros((66, 3), np.float32)
|
||||
sx, sy = (x2 - x1) / self.RES, (y2 - y1) / self.RES
|
||||
tensor = self.lm.run([], {self.lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
|
||||
n = self.OUT_RES + 1
|
||||
res = self.RES - 1
|
||||
main = tensor[0:66].reshape(66, n * n)
|
||||
idx = main.argmax(1)[:, None]
|
||||
conf = np.take_along_axis(main, idx, 1)[:, 0]
|
||||
off_y = np.take_along_axis(tensor[66:132].reshape(66, n * n), idx, 1)[:, 0]
|
||||
off_x = np.take_along_axis(tensor[132:198].reshape(66, n * n), idx, 1)[:, 0]
|
||||
|
||||
def logit(p):
|
||||
p = np.clip(p, 1e-7, 1 - 1e-7)
|
||||
return np.log(p / (1 - p)) / self.LOGIT
|
||||
|
||||
m = idx[:, 0]
|
||||
# No original a 1ª coluna é y e a 2ª é x; aqui já devolvemos (x, y, conf).
|
||||
py = y1 + sy * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
|
||||
px = x1 + sx * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
|
||||
pts = np.stack([px, py, conf], 1).astype(np.float32)
|
||||
pts[np.isnan(pts).any(axis=1)] = 0
|
||||
return float(conf.mean()), pts
|
||||
|
||||
def step(self, rgb: np.ndarray) -> tuple[float, np.ndarray] | None:
|
||||
box = self.face if self.face is not None else self.detect(rgb)
|
||||
if box is None:
|
||||
return None
|
||||
conf, pts = self.landmarks(rgb, box)
|
||||
if conf < self.threshold and self.face is not None:
|
||||
# caixa antiga perdida: tenta o detector neste mesmo quadro
|
||||
box = self.detect(rgb)
|
||||
if box is None:
|
||||
self.face = None
|
||||
return None
|
||||
conf, pts = self.landmarks(rgb, box)
|
||||
if conf < self.threshold:
|
||||
self.face = None
|
||||
return None
|
||||
x1, y1 = pts[:, :2].min(0)
|
||||
x2, y2 = pts[:, :2].max(0)
|
||||
self.face = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
|
||||
return conf, pts
|
||||
|
||||
|
||||
def run_osf(frames: list[tuple[float, np.ndarray]]) -> list[Sample]:
|
||||
tr = OsfTracker()
|
||||
out = []
|
||||
for t, rgb in frames:
|
||||
t_a = time.perf_counter()
|
||||
got = tr.step(rgb)
|
||||
ms = (time.perf_counter() - t_a) * 1000
|
||||
if got is None:
|
||||
out.append(Sample(t, False, ms))
|
||||
continue
|
||||
conf, pts = got
|
||||
xy = pts[:, :2]
|
||||
x1, y1 = xy.min(0)
|
||||
x2, y2 = xy.max(0)
|
||||
# boca aberta: lábios internos (60–62 em cima, 63–65 embaixo no layout de 66) / altura do rosto
|
||||
mouth = float(abs(xy[[63, 64, 65], 1].mean() - xy[[60, 61, 62], 1].mean()) / max(1.0, y2 - y1))
|
||||
out.append(Sample(t, True, ms, (float(x1), float(y1), float(x2 - x1), float(y2 - y1)), xy,
|
||||
{"mouthOpen": mouth, "conf": conf}))
|
||||
return out
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- métricas
|
||||
|
||||
def summarize(samples: list[Sample]) -> dict:
|
||||
ms = sorted(s.ms for s in samples)
|
||||
present = [s for s in samples if s.present]
|
||||
out = {
|
||||
"frames": len(samples),
|
||||
"presentPct": round(100 * len(present) / max(1, len(samples)), 1),
|
||||
"msMean": round(statistics.mean(ms), 2) if ms else None,
|
||||
"msP95": round(ms[int(0.95 * (len(ms) - 1))], 2) if ms else None,
|
||||
"facePxMedian": round(statistics.median(s.box[3] for s in present), 1) if present else None,
|
||||
}
|
||||
return out
|
||||
|
||||
|
||||
def per_second(samples: list[Sample], keys) -> list[dict]:
|
||||
by: dict[int, list[Sample]] = {}
|
||||
for s in samples:
|
||||
by.setdefault(int(s.t), []).append(s)
|
||||
rows = []
|
||||
for sec in sorted(by):
|
||||
ss = [s for s in by[sec] if s.present]
|
||||
row = {"t": sec, "present": round(len(ss) / len(by[sec]), 2)}
|
||||
for k in keys:
|
||||
vals = [s.blend.get(k, 0.0) for s in ss]
|
||||
row[k] = round(max(vals), 3) if vals else None
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
|
||||
def blend_stats(samples: list[Sample], keys, t_from=None, t_to=None) -> dict:
|
||||
ss = [s for s in samples if s.present and (t_from is None or t_from <= s.t <= t_to)]
|
||||
out = {}
|
||||
for k in keys:
|
||||
vals = [s.blend.get(k, 0.0) for s in ss]
|
||||
out[k] = {"mean": round(statistics.mean(vals), 3), "p90": round(float(np.percentile(vals, 90)), 3),
|
||||
"max": round(max(vals), 3)} if vals else None
|
||||
return out
|
||||
|
||||
|
||||
def draw_sheet(frames, mp_samples, osf_samples, path: Path, n: int = 10) -> None:
|
||||
idxs = np.linspace(0, len(frames) - 1, n).astype(int)
|
||||
tiles = []
|
||||
for i in idxs:
|
||||
t, rgb = frames[i]
|
||||
img = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
|
||||
m, o = mp_samples[i], osf_samples[i]
|
||||
if m.present:
|
||||
for p in m.points[::3]:
|
||||
cv2.circle(img, (int(p[0]), int(p[1])), 1, (0, 255, 0), -1)
|
||||
x, y, w, h = m.box
|
||||
cv2.rectangle(img, (int(x), int(y)), (int(x + w), int(y + h)), (0, 255, 0), 1)
|
||||
if o.present:
|
||||
for p in o.points:
|
||||
cv2.circle(img, (int(p[0]), int(p[1])), 2, (0, 0, 255), -1)
|
||||
label = f"t={t:.1f} jaw={m.blend.get('jawOpen', 0):.2f} sm={max(m.blend.get('mouthSmileLeft', 0), m.blend.get('mouthSmileRight', 0)):.2f}"
|
||||
cv2.putText(img, label, (4, 14), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
|
||||
tiles.append(img)
|
||||
save_grid(tiles, 5, path)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- principal
|
||||
|
||||
def main() -> None:
|
||||
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
ap.add_argument("--session", type=int, default=3)
|
||||
ap.add_argument("--out", default=str(ROOT / "output" / "face-bench"))
|
||||
args = ap.parse_args()
|
||||
out_dir = Path(args.out)
|
||||
out_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
con = sqlite3.connect(f"file:{ROOT / 'data' / 'clipper' / 'clipper.db'}?mode=ro", uri=True)
|
||||
cam_json = json.loads(con.execute("select cam_json from sessions where id=?", (args.session,)).fetchone()[0])
|
||||
ai_cam = cam_json["cam"]
|
||||
clips = con.execute("select id, peak_s, start_s, end_s, title from clips where session_id=? order by peak_s",
|
||||
(args.session,)).fetchall()
|
||||
loud = {r[0]: json.loads(r[1]) for r in con.execute(
|
||||
"select idx, loudness_json from segments where session_id=? and loudness_json is not null", (args.session,))}
|
||||
con.close()
|
||||
|
||||
session_dir = ROOT / "data" / "clipper" / "sessions" / str(args.session)
|
||||
blocks = load_blocks(session_dir)
|
||||
duration = blocks[-1].end
|
||||
size = probe_size(blocks[0].path)
|
||||
print(f"sessão {args.session}: {len(blocks)} blocos, {duration:.0f} s, {size[0]}x{size[1]}")
|
||||
|
||||
report: dict = {"session": args.session, "frameSize": size, "aiCam": ai_cam,
|
||||
"clips": [{"id": c[0], "peak": c[1], "start": c[2], "end": c[3]} for c in clips]}
|
||||
cam = locate_cam(blocks, size, duration, ai_cam, out_dir)
|
||||
report["camera"] = cam
|
||||
print("câmera:", {k: v for k, v in cam.items() if k != "rows"})
|
||||
|
||||
# Trecho calmo: bloco com menor volume (p90) a ≥ 120 s de qualquer corte, longe das pontas.
|
||||
peaks = [c[1] for c in clips]
|
||||
calm_idx = min((i for i in loud if 2 <= i < len(blocks) - 2
|
||||
and all(abs(blocks[i].start + 15 - p) >= 120 for p in peaks)),
|
||||
key=lambda i: float(np.percentile(loud[i], 90)))
|
||||
windows = [("calmo", blocks[calm_idx].start, None)]
|
||||
for cid, peak, start, end, _title in clips:
|
||||
if peak + 10 > duration: # corte novo além dos blocos lidos no início (o serviço continua gravando)
|
||||
continue
|
||||
windows.append((f"corte{cid}", max(0.0, peak - 20), peak))
|
||||
|
||||
# Recorte: câmera local (+10 % de margem); comparação extra com o retângulo da IA.
|
||||
fw, fh = size
|
||||
crops = {"local": cam.get("cam") or ai_cam, "ai": ai_cam}
|
||||
report["windows"] = []
|
||||
for name, t0, peak in windows:
|
||||
for crop_name, rect in crops.items():
|
||||
mx, my = rect["w"] * 0.1, rect["h"] * 0.1
|
||||
r = clamp_rect({"x": rect["x"] - mx, "y": rect["y"] - my, "w": rect["w"] + 2 * mx, "h": rect["h"] + 2 * my})
|
||||
px = (int(r["x"] * fw) // 2 * 2, int(r["y"] * fh) // 2 * 2, int(r["w"] * fw) // 2 * 2, int(r["h"] * fh) // 2 * 2)
|
||||
k = CROP_SIDE / max(px[2], px[3])
|
||||
out_size = (int(px[2] * k) // 2 * 2, int(px[3] * k) // 2 * 2)
|
||||
t_a = time.perf_counter()
|
||||
frames = read_window(blocks, t0, WINDOW_S, px, out_size)
|
||||
decode_s = time.perf_counter() - t_a
|
||||
mp_s = run_mediapipe(frames)
|
||||
entry = {"window": name, "crop": crop_name, "t0": t0, "peak": peak, "cropPx": px, "inputSize": out_size,
|
||||
"decodeS": round(decode_s, 2), "mediapipe": summarize(mp_s)}
|
||||
if crop_name == "local":
|
||||
osf_s = run_osf(frames)
|
||||
entry["openseeface"] = summarize(osf_s)
|
||||
entry["mpBlend"] = blend_stats(mp_s, BLENDS)
|
||||
entry["osfMouth"] = blend_stats(osf_s, ("mouthOpen",))
|
||||
if peak is not None:
|
||||
entry["mpBlendNearPeak"] = blend_stats(mp_s, BLENDS, peak - 4, peak + 4)
|
||||
entry["osfMouthNearPeak"] = blend_stats(osf_s, ("mouthOpen",), peak - 4, peak + 4)
|
||||
entry["mpPerSecond"] = per_second(mp_s, BLENDS)
|
||||
entry["osfPerSecond"] = per_second(osf_s, ("mouthOpen",))
|
||||
draw_sheet(frames, mp_s, osf_s, out_dir / f"track_{name}.png")
|
||||
report["windows"].append(entry)
|
||||
print(name, crop_name, "MP", entry["mediapipe"], "OSF", entry.get("openseeface"))
|
||||
|
||||
(out_dir / "results.json").write_text(json.dumps(report, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
print("resultado:", out_dir / "results.json")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user