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>
847 lines
42 KiB
Python
847 lines
42 KiB
Python
"""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 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.
|
||
|
||
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,
|
||
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
|
||
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
|
||
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 = []
|
||
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
|
||
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)}
|
||
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:
|
||
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()}
|