Clipador: quem fala cada palavra (streamer × outra pessoa) e legenda em duas linhas

A fala de colegas no Discord e de outros jogadores saía na legenda como se fosse do
streamer. Agora cada palavra tem falante:

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Mateuus
2026-11-18 03:57:00 -03:00
co-authored by Claude Opus 5.5
parent 54eac7cebf
commit 377536f778
21 changed files with 1657 additions and 126 deletions
+88 -3
View File
@@ -213,6 +213,61 @@ class MediaPipeTracker:
self._lm.close()
class MouthMeter:
"""Movimento da boca por quadro, para a atribuição de falante (speakers.py; doc/clipador/FALANTES.md).
Medido na sessão 15 (tfue, webcam pequena e rosto de PERFIL): o MediaPipe só achava o rosto em ~4 % dos quadros
e o `jawOpen` ficava em 0,00 mesmo falando. O YuNet acha o rosto em 99 % dos quadros e dá os cantos da boca:
o recorte da boca (alinhado pelo YuNet em cada quadro, 24×20, normalizado) é comparado com o do quadro anterior.
Valor = diferença média (0 = parado); None = sem rosto neste quadro ou no anterior. É um sinal FRACO por trecho
(fala × boca parada separa pouco num trecho só) e forte na soma: serve para dizer QUAL voz é a do streamer."""
PATCH = (24, 20)
def __init__(self, model_path: Path, score: float = 0.5):
try:
import cv2
import numpy as np
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("opencv não instalado (rode o setup.bat)") from exc
self._cv2, self._np, self._path, self._score = cv2, np, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
self._prev: Any = None
def feed(self, rgb: Any) -> float | None:
cv2, np = self._cv2, self._np
if rgb is None:
self._prev = None
return None
h, w = rgb.shape[:2]
if self._det is None:
self._det = cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 5)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
bgr = np.ascontiguousarray(rgb[:, :, ::-1])
_, faces = self._det.detect(bgr)
if faces is None or len(faces) == 0:
self._prev = None
return None
f = max(faces, key=lambda r: r[14])
fh = float(f[3])
(rx, ry), (lx, ly) = f[10:12], f[12:14] # cantos da boca (direito, esquerdo)
mx, my = (rx + lx) / 2, (ry + ly) / 2
mw = max(abs(lx - rx), float(f[2]) * 0.3)
x0, x1 = int(mx - mw * 0.9), int(mx + mw * 0.9)
y0, y1 = int(my - fh * 0.12), int(my + fh * 0.22)
if x0 < 0 or y0 < 0 or x1 > w or y1 > h or x1 - x0 < 4 or y1 - y0 < 4:
self._prev = None
return None
gray = cv2.cvtColor(bgr[y0:y1, x0:x1], cv2.COLOR_BGR2GRAY)
patch = cv2.resize(gray, self.PATCH).astype(np.float32)
patch = (patch - patch.mean()) / (patch.std() + 1e-3)
prev, self._prev = self._prev, patch
return None if prev is None else float(np.abs(patch - prev).mean())
class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
@@ -449,8 +504,12 @@ class FaceService:
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):
sizer: Callable[[Path], tuple[int, int]] | None = None,
mouth_factory: Callable[[], Any] | None = None):
self.e = engine
# Movimento da boca por quadro (atribuição de falante). Falha ao criar = bloco sem a série `mouth` (o
# rastreio de reação segue igual). Nos testes (store falso) cai nesse caso sozinho.
self._mouth_factory = mouth_factory or (lambda: MouthMeter(self.store.path("yunet")))
self.store = store or ModelStore(engine.settings.data_dir / "models")
# 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
@@ -592,12 +651,21 @@ class FaceService:
started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name
mouth = self._mouth_meter()
mouth_values: list[float | None] = []
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)]
samples = []
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out):
samples.append(tracker.process(segment["start_s"] + t, rgb))
if mouth is not None:
try:
mouth_values.append(mouth.feed(rgb))
except Exception as exc: # noqa: BLE001 - a boca é extra: falhou, o bloco segue sem ela
log.info("movimento da boca do bloco %s/%s: %s", sid, idx, exc)
mouth, mouth_values = None, []
except FaceUnavailable:
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
@@ -616,10 +684,27 @@ class FaceService:
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)}
if mouth is not None and mouth_values:
# Quadro i = início do bloco + i / fps (speakers.py soma isto por trecho de fala).
data["mouth"] = [None if v is None else round(v, 4) for v in mouth_values]
self._save(sid, idx, "done", data, None)
self.last_error = None
self._after_block(sid, idx)
return "done"
def _mouth_meter(self) -> Any:
try:
return self._mouth_factory()
except Exception as exc: # noqa: BLE001 - sem YuNet/opencv: rastreio segue, só sem a série da boca
log.debug("medidor de boca indisponível: %s", exc)
return None
def _after_block(self, session_id: int, idx: int) -> None:
"""Série nova da boca: a atribuição de falante da sessão é refeita na próxima leitura."""
speakers = getattr(self.e, "speakers", None)
if speakers is not None:
speakers.invalidate(session_id)
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file)
if key not in self._sizes: