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>
25 KiB
Bancada de rastreio de rosto (Fase 0) — MediaPipe × OpenSeeFace, YuNet para a câmera
Data: 16/11/2026. Plano: 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. browInnerUpmarcou 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" noreaction.py.browDown*sobe com o grito do corte 10 (0,61) junto comjawOpen0,42 num segundo isolado (1628 s, exatamente o pico do chat).jawOpenquase nunca passa de 0,1 eeyeWide*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):
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_mstem 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
facejunto 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 …/facesó 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.ps1inteiro 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.