Files
CenaForge/doc/FACE_BAKEOFF.md
T
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

372 lines
25 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Bancada de rastreio de rosto (Fase 0) — MediaPipe × OpenSeeFace, YuNet para a câmera
Data: 16/11/2026. Plano: [PLANO_RASTREIO_REACAO.md](PLANO_RASTREIO_REACAO.md). Script:
`clipper/tools/face_bench.py`; saídas em `output/face-bench/` (`results.json`, `cam_sheet.png`, `track_*.png`).
```
clipper\.venv\Scripts\python.exe clipper\tools\face_bench.py --session 3
```
Máquina: Windows 11, 32 threads de CPU, RTX 2060 Super (sem uso: MediaPipe Python no Windows é só CPU).
Dados: sessão 3 (skipnho, Warzone/ROB RUN, 99 blocos `.ts` 1280×720 a 60 qps, 2954 s). Banco aberto só
leitura (`mode=ro`); o serviço do usuário estava gravando e criou cortes novos durante a bancada.
## Decisão
**MediaPipe Face Landmarker confirmado.** Critério do plano: rosto em ≥ 85 % dos quadros com o streamer
presente e ≤ 15 ms/quadro na CPU.
| | MediaPipe 1.2.3 | OpenSeeFace (modelo 3, onnxruntime 1.32) |
|---|---|---|
| Rosto presente (6 trechos × 180 quadros) | **97,8–100 %** (1 trecho 97,8 %, demais 100 %) | 100 % |
| ms/quadro, média (p95), recorte 256×384 | **5,1–7,1 (5,6–11,6)** | 9,5–11,5 (10,1–17,4), 1 thread |
| Expressões | 52 blendshapes prontos | só 66 pontos; "boca aberta" calculada à mão, sinal fraco |
OpenSeeFace fica como plano B (pesos baixados, código mínimo funcionando na bancada), mas não ganhou em
nada aqui: a câmera desta live é boa (rosto ~110 px na fonte). Não foi testado em câmera escura/minúscula.
## 1. Achar a câmera (YuNet, quadro inteiro)
12 quadros espalhados (30 s … 2924 s), 1280×720, limiar 0,6. Folha: `output/face-bench/cam_sheet.png`
(verde = YuNet, azul = câmera da IA, amarelo = câmera estimada pelo rosto).
| Métrica | Valor |
|---|---|
| Quadros com rosto do streamer | **12/12** (presença do grupo = 1,0) |
| Rosto (mediana, 0–1) | x 0,084 y 0,504 w 0,066 h 0,152 → **~110 px de altura** |
| Oscilação do centro (desvio / tamanho do rosto) | x 0,24, y 0,06 (o x sobe por 1 quadro com ele inclinado, t=30 s) |
| Câmera estimada (rosto × 3,2 larg., × 3,6 alt.) | x 0,011 y 0,371 w 0,211 h 0,548 |
| **IoU com a câmera da IA** (x 0,014 y 0,532 w 0,183 h 0,395) | **0,61** |
| Fração do rosto dentro do retângulo da IA | **0,81** — a IA corta a testa (topo em y 0,532, o rosto começa em 0,504) |
| Tempo YuNet 1280×720 | 15–17 ms/quadro |
| Rostos falsos | tela de carregamento do ROB RUN (t=819 e 1872): **6 rostos do jogo** em cada, posições fixas |
Observações para o `locate_cam` (agente B) e para o `face.py`:
- A câmera desta live **não tem moldura**: é o streamer recortado (fundo removido) sobre o jogo, com um
banner de patrocinador logo abaixo do rosto. "Bordas persistentes" não vão existir aqui; o retângulo tem de vir
do rosto expandido. O retângulo da IA cortou a cabeça; o local ficou mais correto (ver folha).
- Os rostos do jogo aparecem em **2 de 12 quadros** (mesma tela repetida) → o corte de 50 % de presença resolve.
Note que eles se repetem na *mesma posição*; presença é o que separa, não estabilidade.
- Agrupar comparando com o **1º membro** do grupo partiu o streamer em dois (inclinado em t=30 s, centro
0,064 × 0,116 = 0,8 largura de rosto). Comparar com o **centroide** do grupo e tolerância de **1 largura /
1 altura de rosto** juntou os 12. Use essa regra.
- Rosto ≈ 15 % da altura do quadro → bem abaixo do limite de 40 % de "tela cheia".
### Variante do YuNet
Com `opencv-contrib-python 5.0.0.93` (`cv2 5.0.0`), **as duas variantes funcionaram** — `2023mar` (entrada
fixa) e `2026may` (entrada dinâmica) deram as mesmas caixas em 768×432, 640×360 e 1280×720, e o mesmo resultado
nos 12 quadros. Mesmo assim, o lock fixa a **`face_detection_yunet_2026may.onnx`**: é a indicada pelo
opencv_zoo para o motor ONNX Runtime do OpenCV 5.x (a 2023mar pode falhar quando o OpenCV usar esse motor).
O OpenCV imprime `[ WARN ] ... Targets are not supported by the new graph engine for now` ao criar o detector:
inofensivo.
## 2. Rastreio no recorte da câmera (6 qps, 30 s por trecho)
Recorte: câmera local + 10 % de margem = px (0, 226, 316, 472) → escalado para **256×384** (maior lado 384),
`rgb24` por pipe. Comparação extra só com MediaPipe no recorte da IA (274×340 → 308×384).
| Trecho (início) | Corte | MP % rosto | MP ms média/p95 | OSF % | OSF ms média/p95 |
|---|---|---|---|---|---|
| calmo (1980 s, menor volume a ≥ 120 s de cortes) | — | 100 | 5,6 / 6,6 | 100 | 11,5 / 17,4 |
| 1064 s | 9 — lag, "três jogos ao mesmo tempo" (pico 1084) | 100 | 7,1 / 11,6 | 100 | 9,5 / 10,1 |
| 1608 s | 10 — "sai fora!" (pico 1628) | 97,8 | 5,5 / 7,2 | 100 | 9,5 / 10,1 |
| 2180 s | 11 — internet cai (pico 2200, descartado) | 100 | 5,6 / 7,1 | 100 | 9,9 / 11,7 |
| 2381 s | 12 — heliponto (pico 2401) | 100 | 5,4 / 6,4 | 100 | 9,7 / 10,5 |
| 2897 s | 13 — "Helicóptero!" (pico 2917, descartado) | 100 | 5,1 / 5,6 | 100 | 9,9 / 12,1 |
Recorte da IA (rosto maior no recorte, ~105 px): MediaPipe 98,3–100 %, 5,4–7,3 ms. Recorte apertado no rosto
(284×284 → 256 ou 384, teste à parte): blendshapes praticamente iguais (diferença ≤ 0,01 na média), então
**o tamanho do recorte não muda o sinal**; 256–384 px no maior lado basta.
Tempo por bloco de 30 s: decodificar+recortar+escalar+6 qps com FFmpeg ≈ **0,45–0,6 s**, MediaPipe 180 ×
~6 ms ≈ **1,1 s** → **≈ 1,6–1,8 s por bloco** (meta do plano: ≤ 5 s). Medido num processo com 32 threads livres;
a carga real de CPU com a gravação rodando junto não foi medida.
Folhas de contato (`track_*.png`, 10 quadros por trecho; verde = MediaPipe, vermelho = OpenSeeFace): conferidas
a olho — os dois acertam o rosto em todos os quadros mostrados, inclusive com o banner trocando atrás.
## 3. As expressões sobem nos cortes?
Média (e p90) por trecho, MediaPipe, recorte local. `smile` = maior entre `mouthSmileLeft/Right`.
| Trecho | smile média (p90) | jawOpen máx | browInnerUp média (p90) | browDownLeft máx | eyeWide máx | OSF boca aberta média |
|---|---|---|---|---|---|---|
| calmo | **0,06** (0,15) | 0,01 | 0,02 (0,03) | 0,07 | 0,002 | 0,012 |
| corte 9 (lag) | 0,06 (0,14) | 0,05 | **0,27 (0,77)** | 0,03 | 0,004 | 0,018 |
| corte 10 ("sai fora") | **0,48 (0,88)** | **0,42** | 0,02 (0,05) | **0,61** | 0,007 | 0,029 |
| corte 11 (internet) | 0,12 (0,48) | 0,10 | 0,07 (0,21) | 0,12 | 0,037 | 0,020 |
| corte 12 (heliponto) | **0,55 (0,82)** | 0,11 | 0,01 (0,01) | 0,16 | 0,002 | 0,020 |
| corte 13 ("Helicóptero!") | 0,30 (0,52) | 0,01 | 0,02 (0,04) | 0,08 | 0,015 | 0,012 |
Leitura:
- **Sorriso é o sinal forte**: 0,06 no calmo × 0,48–0,55 nos cortes de risada (10 e 12), com longas
sequências de segundos em 0,75–0,95 (corte 10: 1613–1629 s; corte 12: 2391–2410 s). Bate com os títulos e com o chat
(`tags.risada`). No corte 12 o sorriso perto do pico (±4 s) foi 0,68.
- **`browInnerUp` marcou o lag** (corte 9): 0,27 de média e p90 0,77 contra 0,02 no calmo — cara de
"ué?"/confusão sem sorriso. Bom candidato a "choque/confusão" no `reaction.py`.
- **`browDown*` sobe com o grito** do corte 10 (0,61) junto com `jawOpen` 0,42 num segundo isolado (1628 s,
exatamente o pico do chat).
- **`jawOpen` quase nunca passa de 0,1** e **`eyeWide*` fica em ~0** em todos os trechos, inclusive com recorte
maior. Este streamer ri de boca pouco aberta; não dá para concluir se é ele ou o modelo. Na fórmula, usar
z relativo ao próprio streamer (como o plano já prevê) e **não** exigir jawOpen alto para "risada".
- Os cortes descartados pelo usuário (11 e 13) têm reação facial bem menor que os aprovados 10 e 12 — indício
(6 trechos só) de que o rosto ajuda a separar corte bom de ruim.
- OpenSeeFace: a "boca aberta" calculada dos pontos quase não se mexe (0,012 → 0,029); sem blendshapes ele
não serve para o sinal de expressão desta live.
## Notas para o agente de integração (Fase 2)
**Instalação** (`clipper/requirements.txt`): `mediapipe==1.2.3`, `opencv-contrib-python==5.0.0.93`,
`numpy==2.5.5`, `onnxruntime==1.32.0`. Nunca `opencv-python-headless` junto. Pesos em `data/clipper/models/`
conforme `clipper/models.lock.json` (o `setup.ps1` passo 6b baixa e confere o sha256; teste do bloco isolado num
diretório vazio baixou os 4 e conferiu).
**API do MediaPipe 1.2.3 que funcionou** (atenção: `from mediapipe.tasks import python` **não existe** nesta
versão; importe os submódulos):
```python
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 / "face_landmarker.task")),
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,
)
with vision.FaceLandmarker.create_from_options(options) as landmarker:
image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.ascontiguousarray(rgb)) # uint8 H×W×3 RGB
result = landmarker.detect_for_video(image, timestamp_ms) # int, estritamente crescente
result.face_landmarks[0] # 478 NormalizedLandmark (x, y em 0..1 do recorte)
result.face_blendshapes[0] # 52 Category: .category_name, .score
```
- `timestamp_ms` tem de crescer sempre dentro do mesmo landmarker; usei o tempo da sessão em ms. Ao recomeçar
(bloco fora de ordem, reset), crie outro landmarker.
- O array vindo de `np.frombuffer` é só-leitura: passei uma cópia contígua (`.copy()`); sem cópia não testei.
- Ao criar, o MediaPipe escreve avisos do glog no stderr (`inference_feedback_manager ... Disabling support for
feedback tensors`, `Logging before InitGoogle()`): inofensivos.
**YuNet:** `cv2.FaceDetectorYN.create(path, "", (w, h), 0.6, 0.3, 50)`; `_, faces = det.detect(bgr)`;
`faces` é `None` ou N×15 (`x, y, w, h` em px, 10 valores de pontos, `score` na coluna 14). Entrada BGR uint8.
Com a `2026may`, `setInputSize((w, h))` troca a resolução sem recriar.
**FFmpeg do recorte** (por bloco, sem shell):
`ffmpeg -v error -ss <off> -t <len> -i seg_XXXXX.ts -vf fps=6,crop=W:H:X:Y,scale=OW:OH -f rawvideo -pix_fmt rgb24 -`
(crop/escala com valores pares). `fps` antes do `crop` reduz o trabalho do filtro.
**OpenSeeFace (plano B):** `OsfTracker` em `face_bench.py` reimplementa o mínimo do `tracker.py` do commit
`50c0974`: detector `mnv3_detection_opt.onnx` (entrada `input` 1×3×224×224, normalização ImageNet; saída 56×56 com
NMS por maxpool e raio × 112) e landmarks `lm_model3_opt.onnx` (224×224, saída 198×28×28: 66 mapas de
confiança + 66 offsets de linha + 66 de coluna, `logit/16`). Cuidado: no original a 1ª coluna dos pontos é **y**.
Limiar de confiança 0,6. Esforço ~20 min; ficou funcionando, mas não é recomendado aqui.
## Integração (Fase 2) — pipeline de verdade na sessão 3
Data: 16/11/2026. Código: `clipper/app/face.py` (novo), `reaction.py` recalibrado, ganchos em `db.py` (migração
**v5** `face_track`), `intel.py`, `worker.py`, `scoring.py`, `judge.py`, `main.py`. Rodado numa **cópia** do banco
(`output/face-bench/clipper-copy.db`, `sqlite3.backup` do banco vivo aberto só leitura) com o `FaceService` real
(YuNet + MediaPipe 1.2.3, CPU), bloco a bloco como o laço `face` do serviço. Saída: `output/face-bench/integration.json`
e `track_log.txt`. A live seguia gravando: 144 blocos, 4316 s (o jogo trocou para Supermarket Together perto do fim).
### Câmera local × IA
`FaceService.locate` (12 quadros espalhados pela live inteira, YuNet 1280 px + `reaction.locate_cam` com grupo pelo
centro e tolerância de 1 rosto): **1,34 s**, rosto em 10/12 quadros, confiança 0,585.
| Retângulo | x | y | w | h | IoU com o local | rosto dentro dele |
|---|---|---|---|---|---|---|
| **local (yunet)** | 0,005 | 0,388 | 0,213 | 0,519 | — | 1,00 |
| IA da bancada (cam_json antigo) | 0,014 | 0,532 | 0,183 | 0,395 | 0,60 | 0,85 (corta a testa) |
| IA nova (cam_json, Supermarket Together) | 0,036 | 0,499 | 0,167 | 0,222 | 0,34 | 1,00 |
| layout da sessão (marcado à mão) | 0,023 | 0,425 | 0,206 | 0,241 | 0,41 | 1,00 |
O local deixa 0,85 altura de rosto de folga acima da testa. Ele é mais **alto** que o layout marcado à mão: vai
até ~1,75 rosto abaixo do queixo e pega o banner do patrocinador; o manual termina logo abaixo do queixo.
### Rastreio (câmera local + 10 %, 6 qps, recorte ~384 px)
| Métrica | Valor |
|---|---|
| Blocos | 144/144 `done`, backend `mediapipe`, nenhum erro |
| Tempo por bloco de 30 s (FFmpeg + MediaPipe, landmarker novo por bloco) | média **1,47 s**, mediana 1,44, p95 2,05, máx 2,44 (meta ≤ 5 s) |
| Quadros com rosto | **85,1 %** dos 25 822 (segundos com rosto: 85,4 %) |
| Trechos dos cortes 9–13 e calmo | rosto 95–100 %; 1,24–2,12 s por bloco |
| Sem rosto | 630 s, quase tudo de **3767 s ao fim** (troca de jogo/câmera) e 3692–3761 s |
### Calibração (números da live inteira, não só dos 6 trechos da bancada)
Na live inteira o normal deste streamer é bem diferente dos trechos: sorriso por segundo mediana 0,24 (MAD 0,30),
`browOuterUp` sobe junto com `browInnerUp` (canal de "surpresa" com mediana 0,24), movimento p90 0,46 e até 3,0
quando o rastreio pisca. A 1ª rodada (surpresa = olho ou sobrancelha externa, movimento na intensidade, corte
"face" com z ≥ 3 e apoio fraco) deu **165 picos** (41 "choque", 20 "susto" — os maiores eram o rosto piscando) e
**32 cortes novos** de fonte `face` em 72 min, mais que os 21 do chat. Ajustes:
- `brow` = maior entre browInnerUp e browOuterUp; `surprise` = só olho arregalado; sobrancelha + cabeça mexendo = susto;
- movimento fora da intensidade (só rotula) e só vale com rosto em ≥ 80 % do segundo;
- pisos por canal: sorriso 0,10, boca 0,05, olho 0,06, franzido 0,07, sobrancelha 0,10 (peso 0,6), movimento 0,15;
- corte novo de fonte `face`: z ≥ 6 (forte) **e** áudio suavizado ≥ 1,5 **ou** ≥ 2 mensagens de reação até 10 s depois.
Resultado final: **114 picos** (risada 77, grito 16, confuso 10, susto 6, raiva 5), nenhum no trecho calmo
(1980–2010 s), **0 cortes novos** de fonte `face` (nenhum pico forte teve apoio suficiente), **14 dos 21** momentos do
chat ganharam `reasons.face`. A nota dos momentos do chat sobe no máximo 0,6.
### 10 maiores reações e os cortes
| Pico | Rótulo | z | Corte que contém (±5 s) |
|---|---|---|---|
| 2884 s | risada forte | 10,8 | 13 (descartado) |
| 3264 s | risada forte | 10,4 | — |
| 1553 s | risada forte | 9,9 | — (75 s antes do corte 10) |
| 403 s | risada forte | 7,9 | — |
| 1247 s | risada forte | 7,8 | — |
| 3687 s | risada forte | 7,7 | 21 (descartado pela IA) |
| 3588 s | risada forte | 7,6 | — |
| 144 s | grito forte | 7,4 | — |
| 493 s | risada forte | 7,3 | — (perto do pico do chat em 501 s, que não virou corte) |
| 3078 s | risada forte | 7,2 | 16 |
Nos cortes da bancada (rótulo/z do maior pico dentro do corte ±5 s):
| Corte | Usuário | Rosto |
|---|---|---|
| 9 (lag) | — | **confuso** 3,8 em 1076 s e 1090 s (era "choque" antes do ajuste) |
| 10 ("sai fora!") | aprovado | risada 4,4 em 1638 s; **grito em 1626 s** (o pico do chat é 1628 s) |
| 11 (internet cai) | descartado | risada 4,7 |
| 12 (heliponto) | aprovado | nenhum pico ≥ 3 dentro do corte (sorriso alto, mas o normal dele já estava alto; risada forte em 2339 s) |
| 13 ("Helicóptero!") | descartado | **risada forte 10,8** em 2884 s (a maior da live) |
Leitura honesta: com a live inteira, o rosto **não** separa os aprovados dos descartados como os 6 trechos da
bancada sugeriam — o 13 descartado tem a maior risada, o 12 aprovado não tem pico (z relativo a um "normal" que
já é sorridente). O rosto acerta bem o **tipo** de reação (lag = confuso, grito no segundo do grito) e o início
dela; por isso entra como reforço limitado, texto para o analista e série para o editor — não como juiz.
Linha que vai para o analista (corte 10, janela −60/+15 s): "risada forte em 1553s; grito em 1626s; risada em
1638s; susto em 1651s".
### Não verificado na integração
- Serviço de verdade rodando o laço `face` junto com gravação + transcrição (CPU concorrente); só a cópia, fora do serviço.
- Câmera que muda de lugar no meio da live: a detecção roda uma vez (com nova tentativa só quando não acha rosto);
aqui o rosto some depois de 3767 s e o rastreio marca esses segundos sem rosto.
- Backend OpenSeeFace (plano B) dentro do `face.py`: código portado da bancada, sem teste com os pesos reais.
- Download sob demanda real (os pesos já estavam em `data/clipper/models/`; testado só com download falso).
- Painel no navegador (só `tsc`); `GET …/face` só pelos testes da API.
## Não verificado
- Outra sessão/canal (só existe a sessão 3 no banco e em `data/clipper/sessions/`).
- Câmera escura, pequena (< 40 px de rosto) ou muito comprimida — o caso em que o OpenSeeFace poderia ganhar.
- Live sem câmera (falso positivo do YuNet no jogo ao longo de uma live inteira) e câmera em tela cheia.
- Uso de CPU com a gravação/transcrição rodando ao mesmo tempo; GPU não foi tentada.
- `setup.ps1` inteiro não foi rodado; só o bloco novo do passo 6b (isolado, nas duas situações: arquivos já
presentes e pasta vazia) e o parse do arquivo.
## Testes de 17/11 — ao vivo
Data: 16–17/11/2026 (23:30–00:10). Instância **isolada** do Clipador na porta **4521**, com
`CLIPPER_DATA_DIR=output/face-live-test/data` e `CLIPPER_OUTPUT_DIR=output/face-live-test/clips` (variáveis novas do
`config.py`; o padrão continua `data/clipper` e `output/clipper`), juiz `off`, banco novo com o `sqlite_sequence` de
`sessions` em 90000 (a chave de idempotência da voz é `clipper-<sessão>-<bloco>`: as sessões 1–3 colidiriam com as do
banco real). Nada foi escrito em `data/clipper/` nem no serviço do usuário (4520). Saídas em `output/face-live-test/`
(`t1_models.json`, `t2_osf.json`, `monitor.jsonl`, `service*.log`, `panel-*.png`, cortes em `clips/`).
### 1. Download real dos modelos — passou
`face.ModelStore` com a pasta de modelos vazia (`output/face-live-test/data/models/`), rede de verdade:
| Modelo | Tamanho | Tempo | sha256 |
|---|---|---|---|
| `face_detection_yunet_2026may.onnx` | 229 738 B | 0,79 s | confere |
| `face_landmarker.task` | 3 758 596 B | 0,33 s | confere |
| `osf_lm_model3_opt.onnx` | 13 500 226 B | 0,91 s | confere |
| `osf_mnv3_detection_opt.onnx` | 568 302 B | 0,28 s | confere |
Nenhum `.part` sobrou; nova checagem sem baixar: 4 ms. Num diretório temporário: lock adulterado (sha256 = 0…0) →
`FaceUnavailable("sha256 … não confere")` e a pasta ficou vazia (`.part` apagado); arquivo corrompido no lugar →
baixado de novo e aceito; URL 404 → `FaceUnavailable` e pasta vazia. O lock real não foi tocado.
### 2. Plano B OpenSeeFace com pesos reais (sessão 3, cópia do banco) — passou
Backend `openseeface` forçado pelo `tracker_factory` do `FaceService.process_block`, nos blocos 54 (grito/risada do
corte 10), 66 (calmo) e 80 (heliponto), com a câmera local da integração; depois o MediaPipe nos mesmos blocos. Cópia
por `sqlite3.backup` do banco aberto só leitura (`output/face-live-test/t2-copy.db`); os `.ts` foram só lidos.
| Bloco | OSF % rosto | OSF ms/quadro (bloco) | MP % rosto | MP ms/quadro (bloco) | cy OSF × MP | size OSF × MP |
|---|---|---|---|---|---|---|
| 54 | 96,7 | 12,3 (2,2 s) | 94,4 | 13,2 (2,4 s) | 0,605 × 0,593 | 0,110 × 0,132 |
| 66 | 100 | 13,6 (2,4 s) | 100 | 10,4 (1,9 s) | 0,600 × 0,588 | 0,109 × 0,133 |
| 80 | 100 | 13,9 (2,5 s) | 100 | 9,8 (1,8 s) | 0,601 × 0,589 | 0,105 × 0,128 |
ms/quadro aqui = tempo do bloco inteiro (FFmpeg + modelo) ÷ 180. A série gravada é válida nos dois (180 quadros, `cx/cy`
dentro da câmera, `size` 0..1). O `size` do OpenSeeFace é ~18 % menor (os 66 pontos não pegam a testa). Sem
blendshapes, os canais ficam em 0 → `reaction_signal` 0 em todo segundo, nenhum pico, `find_moments(face=…)` sem erro
e sem corte, e o `view` responde. O MediaPipe no mesmo trecho: grito em 1626 s e risada em 1638 s (z 4,2 e 4,4), iguais
à integração. **Bug achado e corrigido:** com o OpenSeeFace, o `FaceService.summary` mandava ao analista "sem reação
marcante no rosto", o que é falso (ele não mede expressão). Agora a linha não vai quando a série da sessão é do plano B.
### 3. Serviço real gravando ao vivo (twitch.tv/skipnho, ROB RUN) — passou
Sessão 90001, 722 s gravados (23:48–00:01), 25 blocos. A voz (4510) ficou no ar até 23:56 (1 bloco com erro de
transcrição depois disso). No meio do teste (23:56) o `start.bat` do usuário foi reiniciado e **todos** os serviços da
faixa caíram, inclusive a instância de teste (sem traceback e sem evento de crash no Windows). Religada, a sessão foi
**retomada sozinha** (`resume_interrupted`), com a numeração dos blocos seguindo.
| Verificação | Resultado |
|---|---|
| Câmera | `cam_json.source = yunet`, rosto em 12/12 quadros, confiança 0,864, cam x 0,014 y 0,372 w 0,207 h 0,545 (achada 73 s depois do início, com 2 blocos analisados) |
| `_face_loop` durante a gravação | `face_track done` acompanhou: atraso de 0–1 bloco em regime (37 leituras do monitor), 25/25 `done`, 0 erro |
| Tempo por bloco (FFmpeg + MediaPipe, com gravação + transcrição + chat juntos) | média **1,71 s**, mediana 1,74, p95 2,20, máx 2,91 |
| Latência do fim do bloco ao rosto gravado | 1,4–9,4 s (o laço dorme até 10 s quando ocioso); 16,5 s no bloco pego durante a reconstrução |
| CPU (árvore do processo, % de 1 núcleo, amostras de 15 s) | média 16,8 %, pico 90,5 % (reconstrução depois do reset); sistema (32 threads): média 21 %, máx 48 % |
| Rosto presente | 99,8 % dos segundos |
| `GET /v1/sessions/90001/face?from=60&to=75` | 200; `cx` 0,10–0,13, `cy` 0,58–0,59, `size` 0,12–0,13 (no quadro inteiro, dentro da câmera); `signal`, `blocks`, `camSource` |
| `POST …/face/reset` | 200 `{deleted: 17}` com o laço ocioso; **202** `{scheduled: true}` com um bloco em andamento; série refeita: 19 blocos em ~45 s (≈ 12× o tempo real) |
| `find_new_clips` | não travou: 2 cortes do chat criados ao vivo e renderizados em `output/face-live-test/clips/90001/`; o 1º com `reasons.face` = **grito forte, z 12,7, pico em 430 s** (corte 383–443 s); o 2º, decidido durante a reconstrução do reset, saiu sem rosto (atraso > 2 blocos → não espera, como desenhado) |
**Bug achado e corrigido:** com o juiz `off`, o `Intel.research_pending` tentava pesquisar o jogo e registrava o WARNING
"pesquisa de jogo falhou: IA desligada" **a cada 30 s**. Agora ele sai cedo com a IA desligada (o jogo fica `pending`).
### Live sem câmera (twitch.tv/lofigirl, 3 min) — falhou, corrigido
Sessão 90002, 8 blocos. O YuNet achou um "rosto" de **24×34 px colado na borda esquerda** (a tela de um notebook
desenhado) em 8 de 12 quadros, com score 0,61–0,66. O `locate_cam` aceitou (`hasWebcam: true`, confiança 0,42) e
aplicou uma câmera de 51×122 px como layout da sessão. O MediaPipe não achou rosto nenhum no recorte (`present` 0 em
todos). O rosto real do skipnho tem score **0,92–0,94** em todo quadro. **Correção:** `ReactionParams.min_cam_score =
0.7` — o grupo que vira câmera precisa de confiança média ≥ 0,7 (`reaction.locate_cam`). Refeito no serviço:
`detect-cam` → `hasWebcam: false` (8/11 quadros com o falso positivo, recusado), série refeita como **8 `no_cam`**,
layout sem câmera e `GET …/face` respondendo; um corte de áudio saiu normalmente. O skipnho continua achado (confiança 0,87).
### 4. Painel no navegador (http://127.0.0.1:4500/clipper) — passou, com ressalva
A página carrega sem erro nem aviso no console (só logs de dev e um "issue" de acessibilidade: campos sem id/name).
O painel fala com o serviço **antigo** da 4520: o selo da câmera aparece como "câmera achada pela IA" (o `cam_json`
antigo não tem `source`) e o interruptor "Rastrear a reação do streamer" fica **oculto** (o serviço antigo não manda
`faceTrack`, e o painel esconde o interruptor de propósito). Para ver o desenho com dados do serviço novo, as respostas
GET de `/api/clipper/*` foram alteradas **só no navegador** (script injetado na aba, nada enviado ao serviço): selo
"câmera achada (rosto, sem IA)", interruptor visível e ligado ("Nada mudou", nenhum botão de salvar clicado) e o chip
do cartão "rosto: risada forte · intensidade 4,4 · pico em 8:21". Nenhuma configuração, aprovação ou corte foi
alterado. Screenshots: `output/face-live-test/panel-1…5.png`. A interação real (ligar/desligar, `reasons.face` de
verdade) depende de o serviço do usuário rodar o código novo. Ele reiniciou às 23:56, então já pega o `config.py` e o
`intel.py` corrigidos, mas **não** a correção do `locate_cam` (feita depois): é preciso reiniciar o `start.bat` de novo.
### Testes automatizados
`clipper/.venv/Scripts/python -m pytest -q`: verde (novos: série OpenSeeFace no sinal/pontuação/resumo, objeto parado
de score baixo no `locate_cam`, `research_pending` quieto com a IA desligada, `CLIPPER_DATA_DIR`/`CLIPPER_OUTPUT_DIR`).
`npx tsc --noEmit -p panel`: sem erros.
### Ainda não verificado
- Câmera em tela cheia e câmera escura ou minúscula (nenhuma live assim encontrada); GPU.
- Live longa (> 15 min) com o rastreio: a janela da pontuação ao vivo (`LIVE_WINDOW_S`, 900 s) não foi ultrapassada.
- O juiz analista recebendo a linha "Rosto do streamer" ao vivo (juiz desligado para não gastar cota).
- Interação real com o interruptor no painel contra o serviço novo.