Files
CenaForge/clipper/app/face.py
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

762 lines
38 KiB
Python
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.
"""Rastreio do rosto do streamer no Clipador: acha a câmera (YuNet), segue o rosto e as expressões (MediaPipe Face
Landmarker; plano B OpenSeeFace) bloco a bloco e grava a série por segundo em `face_track`.
A lógica de sinal (série por segundo, z relativo ao neutro do streamer, rótulos, `locate_cam`) é pura e mora em
`reaction.py`; aqui fica só E/S: modelos, FFmpeg, backends e banco. Decisões e números: doc/FACE_BAKEOFF.md.
- Modelos: baixados sob demanda (na primeira vez que o rastreio ou a detecção rodam, sempre fora da thread do chat)
para `data/clipper/models/`, conferidos pelo sha256 de `clipper/models.lock.json`. O `setup.ps1` (passo 6b) já
deixa tudo baixado; o download aqui é só a rede de segurança.
- Bloco: FFmpeg recorta a câmera (+10 % de margem), escala para ~384 px no maior lado, 6 qps, `rgb24` por pipe →
MediaPipe em modo VIDEO (um landmarker por bloco: timestamps sempre crescentes) → `reaction.per_second`.
- Coordenadas gravadas (`cx`, `cy`, `size`) já convertidas para o QUADRO INTEIRO (0..1; `size` = altura do rosto
como fração da altura do quadro): é o que o editor usa para reenquadrar a câmera.
- Câmera mudou (detecção nova ou layout editado) → a série da sessão é apagada e refeita sozinha.
Nada daqui importa cv2/mediapipe/numpy na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
"""
from __future__ import annotations
import hashlib
import json
import logging
import math
import subprocess
import threading
import time
from collections.abc import Callable, Iterator
from pathlib import Path
from typing import TYPE_CHECKING, Any, Protocol
from . import reaction
from .config import CLIPPER_DIR, REPO_ROOT
from .db import loads, now
from .media import NO_WINDOW, MediaError, run, seek_args
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.face")
LOCK_FILE = CLIPPER_DIR / "models.lock.json"
FPS = 6 # quadros por segundo no rastreio (bancada: 6 qps bastam para pegar a reação)
CROP_SIDE = 384 # maior lado do recorte que vai para o modelo (256–384 dá o mesmo sinal)
CROP_MARGIN = 0.10 # margem em volta da câmera (o streamer se inclina para fora do retângulo)
CAM_FRAMES = 12 # quadros espalhados para achar a câmera
DETECT_WIDTH = 1280 # largura do quadro inteiro para o YuNet
UNAVAILABLE_RETRY_S = 300 # backend sem modelo/biblioteca: tenta de novo daqui a 5 min (não marca blocos)
BASELINE_EXTRA_S = 240 # segundos antes da janela pedidos para o neutro do streamer (z relativo)
MAX_LAG_BLOCKS = 2 # a decisão do corte espera o rosto do trecho, no máximo 2 blocos atrás da transcrição
READ_TIMEOUT_S = 120.0 # prazo do FFmpeg para entregar um bloco de 30 s (medido: ~0,5 s)
MIN_FRAMES_RATIO = 0.9 # bloco com menos de 90 % dos quadros esperados (fps × duração) é erro, não série truncada
RESET_WAIT_S = 0.5 # o reset pedido pela API espera o bloco em andamento só isto; senão fica agendado para o laço
Detection = tuple[float, float, float, float, float] # x, y, w, h (px), score
class FaceError(RuntimeError):
"""Falha de um bloco (vídeo apagado, FFmpeg) ou da detecção da câmera."""
class FaceUnavailable(FaceError):
"""Backend indisponível (biblioteca ou modelo faltando, download/sha256 falhou): não é culpa do bloco."""
# ---------------------------------------------------------------------------------------------------------------
# Modelos (download sob demanda + sha256)
def sha256_of(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as fh:
for chunk in iter(lambda: fh.read(1 << 20), b""):
digest.update(chunk)
return digest.hexdigest()
def _http_download(url: str, dest: Path) -> None:
import httpx
with httpx.stream("GET", url, follow_redirects=True, timeout=60) as response:
response.raise_for_status()
with dest.open("wb") as fh:
for chunk in response.iter_bytes(1 << 16):
fh.write(chunk)
class ModelStore:
"""Pesos do `models.lock.json`: confere o sha256 (uma vez por processo) e baixa o que faltar."""
def __init__(self, models_dir: Path, lock_file: Path = LOCK_FILE,
fetch: Callable[[str, Path], None] | None = None):
lock = json.loads(lock_file.read_text(encoding="utf-8"))
self.dir = models_dir
self.models: dict[str, dict] = {m["id"]: m for m in lock["models"]}
self.fetch = fetch or _http_download
self._checked: set[str] = set()
self._lock = threading.Lock()
def path(self, model_id: str) -> Path:
info = self.models.get(model_id)
if info is None:
raise FaceUnavailable(f"modelo {model_id} não está no models.lock.json")
dest = self.dir / info["file"]
with self._lock:
if model_id in self._checked and dest.is_file():
return dest
if dest.is_file() and sha256_of(dest) == info["sha256"]:
self._checked.add(model_id)
return dest
# Ausente ou corrompido: baixa de novo (URL imutável do lock) e só aceita com o sha256 certo.
self.dir.mkdir(parents=True, exist_ok=True)
part = dest.with_name(dest.name + ".part")
try:
log.info("baixando o modelo %s (%s)", model_id, info["url"])
self.fetch(info["url"], part)
digest = sha256_of(part)
except Exception as exc: # noqa: BLE001 - qualquer falha de rede/disco vira "indisponível"
part.unlink(missing_ok=True)
raise FaceUnavailable(f"não deu para baixar o modelo {info['file']}: {exc}") from exc
if digest != info["sha256"]:
part.unlink(missing_ok=True)
raise FaceUnavailable(f"sha256 do modelo {info['file']} não confere (baixado {digest[:12]}…)")
part.replace(dest)
self._checked.add(model_id)
return dest
# ---------------------------------------------------------------------------------------------------------------
# Backends
class Detector(Protocol):
def detect(self, bgr: Any) -> list[Detection]: ...
class Tracker(Protocol):
name: str
def process(self, t: float, rgb: Any) -> reaction.FaceSample: ...
def close(self) -> None: ...
class YuNetDetector:
"""Rosto no quadro inteiro (`cv2.FaceDetectorYN`, variante 2026may de entrada dinâmica)."""
def __init__(self, model_path: Path, score: float = 0.6):
try:
import cv2
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("opencv não instalado (rode o setup.bat)") from exc
self._cv2, self._path, self._score = cv2, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
def detect(self, bgr: Any) -> list[Detection]:
h, w = bgr.shape[:2]
if self._det is None:
self._det = self._cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 50)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
_, faces = self._det.detect(bgr)
if faces is None:
return []
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
class MediaPipeTracker:
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco.
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
"""
name = "mediapipe"
def __init__(self, model_path: Path):
try:
import mediapipe as mp
import numpy as np
from mediapipe.tasks.python import vision
from mediapipe.tasks.python.core.base_options import BaseOptions
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("mediapipe não instalado (rode o setup.bat)") from exc
self._mp, self._np = mp, np
options = vision.FaceLandmarkerOptions(
base_options=BaseOptions(model_asset_path=str(model_path)),
running_mode=vision.RunningMode.VIDEO,
num_faces=1,
min_face_detection_confidence=0.5,
min_face_presence_confidence=0.5,
min_tracking_confidence=0.5,
output_face_blendshapes=True,
)
self._lm = vision.FaceLandmarker.create_from_options(options)
self._last_ms = -1
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
ms = max(self._last_ms + 1, int(round(t * 1000)))
self._last_ms = ms
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
result = self._lm.detect_for_video(image, ms)
if not result.face_landmarks:
return reaction.FaceSample(t, False)
xs = [p.x for p in result.face_landmarks[0]]
ys = [p.y for p in result.face_landmarks[0]]
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend)
def close(self) -> None:
self._lm.close()
class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
Reimplementação mínima do `tracker.py` do commit 50c0974 (BSD-2), igual à da bancada (`tools/face_bench.py`).
Só o canal de movimento sai daqui; usado quando o MediaPipe não carrega.
"""
name = "openseeface"
RES, OUT_RES, LOGIT = 224, 27, 16.0
def __init__(self, landmarks_path: Path, detector_path: Path, threshold: float = 0.6):
try:
import cv2
import numpy as np
import onnxruntime as ort
except ImportError as exc: # pragma: no cover - depende da instalação
raise FaceUnavailable("onnxruntime/opencv não instalados (rode o setup.bat)") from exc
self._cv2, self._np = cv2, np
opts = ort.SessionOptions()
opts.inter_op_num_threads, opts.intra_op_num_threads = 1, 1
providers = ["CPUExecutionProvider"]
self._lm = ort.InferenceSession(str(landmarks_path), sess_options=opts, providers=providers)
self._det = ort.InferenceSession(str(detector_path), sess_options=opts, providers=providers)
self._lm_input = self._lm.get_inputs()[0].name
mean, std = np.float32([0.485, 0.456, 0.406]), np.float32([0.229, 0.224, 0.225])
self._mean, self._scale = -(mean / std), 1.0 / (std * 255.0)
self._threshold = threshold
self._box: tuple[float, float, float, float] | None = None
def _norm(self, rgb: Any, size: int) -> Any:
im = self._cv2.resize(rgb.astype(self._np.float32), (size, size)) * self._scale + self._mean
return self._np.transpose(im[None], (0, 3, 1, 2)).astype(self._np.float32)
def _detect(self, rgb: Any) -> tuple[float, float, float, float] | None:
np = self._np
out, maxpool = (np.array(a) for a in self._det.run([], {"input": self._norm(rgb, 224)}))
out[0, 0, out[0, 0] != maxpool[0, 0]] = 0
y, x = divmod(int(np.argmax(out[0, 0])), 56)
if out[0, 0, y, x] < self._threshold:
return None
r = out[0, 1, y, x] * 112.0
sx, sy = rgb.shape[1] / 224.0, rgb.shape[0] / 224.0
return ((x * 4 - r) * sx, (y * 4 - r) * sy, 2 * r * sx, 2 * r * sy)
def _landmarks(self, rgb: Any, box: tuple[float, float, float, float]) -> tuple[float, Any]:
np = self._np
h, w = rgb.shape[:2]
x, y, bw, bh = box
x1, y1 = int(np.clip(x - bw * 0.1, 0, w - 1)), int(np.clip(y - bh * 0.125, 0, h - 1))
x2, y2 = int(np.clip(x + bw * 1.1, 0, w - 1)), int(np.clip(y + bh * 1.125, 0, h - 1))
if x2 - x1 < 4 or y2 - y1 < 4:
return 0.0, None
tensor = self._lm.run([], {self._lm_input: self._norm(rgb[y1:y2, x1:x2], self.RES)})[0][0]
n, res = self.OUT_RES + 1, self.RES - 1
main = tensor[0:66].reshape(66, n * n)
idx = main.argmax(1)[:, None]
conf = np.take_along_axis(main, idx, 1)[:, 0]
def logit(v: Any) -> Any:
v = np.clip(v, 1e-7, 1 - 1e-7)
return np.log(v / (1 - v)) / self.LOGIT
off_y = np.take_along_axis(tensor[66:132].reshape(66, n * n), idx, 1)[:, 0]
off_x = np.take_along_axis(tensor[132:198].reshape(66, n * n), idx, 1)[:, 0]
m = idx[:, 0]
# No original a 1ª coluna dos pontos é y; aqui já sai (x, y).
py = y1 + (y2 - y1) / self.RES * (res * np.floor(m / n) / self.OUT_RES + res * logit(off_y))
px = x1 + (x2 - x1) / self.RES * (res * np.floor(np.mod(m, n)) / self.OUT_RES + res * logit(off_x))
return float(conf.mean()), np.stack([px, py], 1)
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
box = self._box or self._detect(rgb)
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if conf < self._threshold and self._box is not None:
box = self._detect(rgb) # caixa do quadro anterior se perdeu: detector neste mesmo quadro
conf, pts = self._landmarks(rgb, box) if box else (0.0, None)
if pts is None or conf < self._threshold:
self._box = None
return reaction.FaceSample(t, False)
(x1, y1), (x2, y2) = pts.min(0), pts.max(0)
self._box = (float(x1), float(y1), float(x2 - x1), float(y2 - y1))
h, w = rgb.shape[:2]
return reaction.FaceSample(t, True, float(x1 + x2) / 2 / w, float(y1 + y2) / 2 / h, float(y2 - y1) / h, {})
def close(self) -> None:
self._box = None
# ---------------------------------------------------------------------------------------------------------------
# Vídeo (FFmpeg, sem shell, argumentos em lista)
def probe_size(ffprobe: str, file: Path) -> tuple[int, int]:
out = run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height",
"-of", "csv=p=0", str(file)], 30).decode("utf-8", errors="replace").strip().splitlines()
if not out:
raise FaceError(f"sem vídeo em {file.name}")
w, h = out[0].split(",")[:2]
return int(w), int(h)
def _stop(proc: subprocess.Popen, grace: float = 10.0) -> None:
"""Espera o processo sair; se não sair, mata e ESPERA de novo (sem processo zumbi)."""
try:
proc.wait(timeout=grace)
except subprocess.TimeoutExpired:
proc.kill()
proc.wait(timeout=grace)
def read_crop(ffmpeg: str, file: Path, crop_px: tuple[int, int, int, int], out_size: tuple[int, int],
fps: int = FPS, timeout: float = READ_TIMEOUT_S) -> Iterator[tuple[float, Any]]:
"""Quadros RGB do recorte (x, y, w, h em px) a `fps` qps, um por vez (sem guardar o bloco na memória).
`fps` antes do `crop` reduz o trabalho do filtro. Devolve (segundos desde o início do bloco, H×W×3 uint8).
Prazo total `timeout`: passou, o FFmpeg é morto. stderr é drenado numa thread (FFmpeg tagarela não trava no
buffer do pipe). FFmpeg que sai com código ≠ 0 — inclusive morto pelo prazo — vira `FaceError`, mesmo depois de
ter entregado alguns quadros: bloco truncado não pode ser gravado como completo.
"""
x, y, w, h = crop_px
ow, oh = out_size
args = [ffmpeg, "-v", "error", "-i", str(file), "-vf", f"fps={fps},crop={w}:{h}:{x}:{y},scale={ow}:{oh}",
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
return _read_frames(args, out_size, fps, timeout, file.name)
def _read_frames(args: list[str], out_size: tuple[int, int], fps: int, timeout: float,
name: str) -> Iterator[tuple[float, Any]]:
"""Lê quadros rawvideo rgb24 do stdout de `args` (sem shell), com prazo e stderr drenado."""
import numpy as np
ow, oh = out_size
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=NO_WINDOW)
errors: list[bytes] = []
drain = threading.Thread(target=lambda: errors.append(proc.stderr.read()), daemon=True) # type: ignore[union-attr]
drain.start()
timed_out = threading.Event()
def kill() -> None:
timed_out.set()
proc.kill()
killer = threading.Timer(timeout, kill)
killer.daemon = True
killer.start()
size = ow * oh * 3
i = 0
try:
while True:
buf = proc.stdout.read(size) # type: ignore[union-attr]
if len(buf) < size:
break
yield i / fps, np.frombuffer(buf, np.uint8).reshape(oh, ow, 3).copy()
i += 1
finally:
killer.cancel()
proc.stdout.close() # type: ignore[union-attr]
_stop(proc)
drain.join(timeout=5)
if proc.stderr:
proc.stderr.close()
if timed_out.is_set():
raise FaceError(f"ffmpeg passou de {timeout:.0f} s lendo {name} ({i} quadros)")
if proc.returncode != 0:
tail = b"".join(errors).decode("utf-8", errors="replace").strip().splitlines()[-1:]
raise FaceError(f"ffmpeg saiu com código {proc.returncode} depois de {i} quadros: {' '.join(tail)}")
def grab_bgr(ffmpeg: str, file: Path, offset: float, width: int = DETECT_WIDTH) -> Any | None:
"""Um quadro BGR do bloco, escalado para `width` de largura (altura proporcional, par)."""
import numpy as np
before, select = seek_args(offset) # quadro exato (no HEVC a busca direta dava quadro cinza)
raw = run([ffmpeg, "-v", "error", *before, "-i", str(file), "-map", "0:v:0", "-frames:v", "1",
"-vf", f"{select},scale={width}:-2", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], 60)
h = len(raw) // (width * 3)
if h < 2:
return None
return np.frombuffer(raw[: width * h * 3], np.uint8).reshape(h, width, 3).copy()
# ---------------------------------------------------------------------------------------------------------------
# Geometria
def expand(rect: dict, margin: float = CROP_MARGIN) -> dict:
"""Retângulo 0..1 com margem em volta, recortado no quadro."""
mx, my = rect["w"] * margin, rect["h"] * margin
x0, y0 = max(0.0, rect["x"] - mx), max(0.0, rect["y"] - my)
x1, y1 = min(1.0, rect["x"] + rect["w"] + mx), min(1.0, rect["y"] + rect["h"] + my)
return {"x": round(x0, 4), "y": round(y0, 4), "w": round(x1 - x0, 4), "h": round(y1 - y0, 4)}
def crop_geometry(crop: dict, frame: tuple[int, int], side: int = CROP_SIDE) -> tuple[tuple[int, int, int, int],
tuple[int, int]]:
"""Recorte em px (valores pares) e tamanho de saída com o maior lado = `side`."""
fw, fh = frame
# Tudo par e dentro do quadro, mesmo com retângulo fora de 0..1 (layout antigo, arredondamento).
x = min(max(0, int(crop["x"] * fw)), fw - 2) // 2 * 2
y = min(max(0, int(crop["y"] * fh)), fh - 2) // 2 * 2
w = max(2, min(fw - x, int(round(crop["w"] * fw))) // 2 * 2)
h = max(2, min(fh - y, int(round(crop["h"] * fh))) // 2 * 2)
k = side / max(w, h)
return (x, y, w, h), (max(2, int(w * k) // 2 * 2), max(2, int(h * k) // 2 * 2))
def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.FaceSecond]:
"""Posição/tamanho do recorte → quadro inteiro (0..1). `size` vira fração da altura do quadro."""
for s in seconds:
if s.cx is not None:
s.cx = crop["x"] + s.cx * crop["w"]
if s.cy is not None:
s.cy = crop["y"] + s.cy * crop["h"]
if s.size is not None:
s.size = s.size * crop["h"]
return seconds
def same_rect(a: dict | None, b: dict | None, tol: float = 1e-3) -> bool:
if a is None or b is None:
return a is b
return all(abs(float(a[k]) - float(b[k])) <= tol for k in ("x", "y", "w", "h"))
# ---------------------------------------------------------------------------------------------------------------
# Serviço
class FaceService:
"""Câmera local, rastreio por bloco e leitura da série. Uma instância por motor (`Engine.face`)."""
def __init__(self, engine: Engine, store: ModelStore | None = None,
tracker_factory: Callable[[str | None], Tracker] | None = None,
detector_factory: Callable[[], Detector] | None = None,
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
grabber: Callable[..., Any] | None = None,
sizer: Callable[[Path], tuple[int, int]] | None = None):
self.e = engine
self.store = store or ModelStore(engine.settings.data_dir / "models")
# Recebe o backend que a sessão já usa (None = sessão nova) e devolve o rastreador.
self._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
self._detector_factory = detector_factory or (lambda: YuNetDetector(self.store.path("yunet")))
self._reader = reader or read_crop
self._grabber = grabber or grab_bgr
self._sizer = sizer or (lambda file: probe_size(self.e.settings.ffprobe or "ffprobe", file))
# Tamanho do quadro POR BLOCO: uma retomada pode gravar em outra resolução (outra qualidade de captura).
self._sizes: dict[str, tuple[int, int]] = {}
self._busy = threading.Lock() # um bloco por vez (o laço e um reset concorrente não se atropelam)
self._resets: set[int] = set() # resets pedidos com um bloco em andamento: o laço aplica no próximo passo
self._resets_lock = threading.Lock()
self._unavailable_until = 0.0
self.backend: str | None = None
self.last_error: str | None = None
self.params = reaction.ReactionParams()
# ---------- opções / backends
@property
def enabled(self) -> bool:
return bool(self.e.intel.opts.get("faceTrack", True))
def _default_tracker(self, backend: str | None = None) -> Tracker:
"""MediaPipe; o plano B OpenSeeFace só numa sessão que ainda não tem série. Uma sessão nunca mistura os
dois: sem blendshapes, o neutro do streamer ficaria zerado no meio da série e qualquer sorriso viraria pico."""
if backend == OpenSeeFaceTracker.name:
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
try:
return MediaPipeTracker(self.store.path("face_landmarker"))
except FaceUnavailable as first:
if backend == MediaPipeTracker.name:
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
log.warning("MediaPipe indisponível (%s): usando o plano B OpenSeeFace (sem expressões)", first)
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
def session_backend(self, session_id: int) -> str | None:
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
session_id)
return loads(row["data_json"], {}).get("backend") if row else None
# ---------- câmera da sessão
def cam_for(self, session: dict) -> tuple[dict | None, str, bool]:
"""(retângulo 0..1 da câmera, origem, decidido?). Layout do corte primeiro (o que o usuário vê e edita);
senão o que a detecção achou. Não decidido = a detecção ainda não rodou: o rastreio espera."""
layout_cam = self.e.intel.settings_for(session)["layout"]["cam"]
detected = loads(session.get("cam_json"), None) or {}
if layout_cam:
same = same_rect(detected.get("cam"), layout_cam)
return layout_cam, (detected.get("source") or "ai") if same else "manual", True
if detected.get("hasWebcam") and detected.get("cam"):
return detected["cam"], detected.get("source") or "ai", True
if detected:
return None, detected.get("source") or "", True
return None, "", False
def has_cam(self, session: dict) -> bool:
cam, _, decided = self.cam_for(session)
return decided and cam is not None
# ---------- laço (thread `face` do motor)
def run_forever(self, stop: threading.Event) -> None:
while not stop.is_set():
worked = False
if self.enabled and time.monotonic() >= self._unavailable_until:
try:
worked = self.step()
except FaceUnavailable as exc:
self.last_error = str(exc)[:300]
self._unavailable_until = time.monotonic() + UNAVAILABLE_RETRY_S
log.warning("rastreio de rosto indisponível: %s (nova tentativa em %d s)", exc, UNAVAILABLE_RETRY_S)
except Exception as exc: # noqa: BLE001 - qualquer outra falha não pode matar a thread do rastreio
self.last_error = str(exc)[:300]
log.exception("rastreio de rosto: erro inesperado no laço")
stop.wait(0.2 if worked else 10)
def step(self) -> bool:
"""Processa UM bloco pendente (sessões gravando/processando primeiro). True se trabalhou."""
db = self.e.db
self._apply_pending_resets()
sessions = db.all("SELECT * FROM sessions WHERE status != 'error' ORDER BY "
"CASE WHEN status IN ('recording', 'processing', 'starting') THEN 0 ELSE 1 END, id DESC")
for session in sessions:
cam, _source, decided = self.cam_for(session)
if not decided:
continue
self.sync_cam(session["id"], cam)
segment = db.get(
"SELECT s.* FROM segments s LEFT JOIN face_track f ON f.session_id = s.session_id AND f.idx = s.idx"
" WHERE s.session_id = ? AND s.deleted = 0 AND f.idx IS NULL ORDER BY s.idx LIMIT 1", session["id"])
if segment:
self.process_block(session, segment, cam)
return True
return False
def sync_cam(self, session_id: int, cam: dict | None) -> bool:
"""Câmera diferente da usada na série gravada → apaga a série (o laço refaz). True se apagou."""
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? ORDER BY idx DESC LIMIT 1", session_id)
if row is None or same_rect(loads(row["data_json"], {}).get("cam"), cam):
return False
log.info("sessão %s: câmera mudou, refazendo o rastreio do rosto", session_id)
self.reset(session_id)
return True
def reset(self, session_id: int, wait_s: float = RESET_WAIT_S) -> dict:
"""Apaga a série da sessão. Não prende a requisição HTTP atrás de um bloco em andamento: se o laço estiver
ocupado por mais de `wait_s`, o reset fica agendado e o laço aplica antes do próximo bloco."""
if not self._busy.acquire(timeout=wait_s):
with self._resets_lock:
self._resets.add(session_id)
return {"deleted": 0, "scheduled": True}
try:
with self._resets_lock:
self._resets.discard(session_id)
return {"deleted": self._delete(session_id), "scheduled": False}
finally:
self._busy.release()
def _delete(self, session_id: int) -> int:
return self.e.db.run("DELETE FROM face_track WHERE session_id = ?", session_id).rowcount
def _apply_pending_resets(self) -> None:
with self._resets_lock:
pending, self._resets = self._resets, set()
for session_id in pending:
with self._busy:
self._delete(session_id)
def process_block(self, session: dict, segment: dict, cam: dict | None) -> str:
"""Rastreia um bloco e grava a linha de `face_track`. Devolve o status gravado."""
sid, idx = segment["session_id"], segment["idx"]
if cam is None:
self._save(sid, idx, "no_cam", {"cam": None}, None)
return "no_cam"
first, last = math.ceil(segment["start_s"]), math.ceil(segment["end_s"])
with self._busy:
started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name
try:
file = REPO_ROOT / segment["file"]
crop = expand(cam)
px, out = crop_geometry(crop, self._frame_size(sid, file))
samples = [tracker.process(segment["start_s"] + t, rgb)
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)]
except FaceUnavailable:
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde
except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
log.warning("bloco %s/%s do rastreio falhou: %s", sid, idx, exc)
self._save(sid, idx, "error", {"cam": cam}, str(exc)[:300])
return "error"
finally:
tracker.close()
expected = (segment["end_s"] - segment["start_s"]) * FPS
if len(samples) < MIN_FRAMES_RATIO * expected - 2:
msg = f"bloco truncado: {len(samples)} de ~{expected:.0f} quadros"
self._save(sid, idx, "error", {"cam": cam}, msg)
return "error"
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first), crop)
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)}
self._save(sid, idx, "done", data, None)
self.last_error = None
return "done"
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file)
if key not in self._sizes:
if len(self._sizes) > 2000:
self._sizes.clear()
self._sizes[key] = self._sizer(file)
return self._sizes[key]
def _save(self, session_id: int, idx: int, status: str, data: dict, error: str | None) -> None:
self.e.db.run("INSERT INTO face_track (session_id, idx, status, data_json, error, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
" ON CONFLICT (session_id, idx) DO UPDATE SET status = excluded.status, data_json = excluded.data_json,"
" error = excluded.error, updated_at = excluded.updated_at",
session_id, idx, status, json.dumps(data, ensure_ascii=False), error, now())
# ---------- leitura
def tracked_until(self, session_id: int) -> float:
"""Até onde (s) a série está contínua desde o início (qualquer status conta: bloco sem câmera também
já foi "decidido")."""
until = 0.0
# Blocos apagados nunca ganham linha (o laço os ignora): pular, senão a série "trava" no primeiro apagado.
for row in self.e.db.all("SELECT s.start_s, s.end_s, f.idx AS done FROM segments s LEFT JOIN face_track f"
" ON f.session_id = s.session_id AND f.idx = s.idx WHERE s.session_id = ? AND s.deleted = 0"
" ORDER BY s.idx",
session_id):
if row["done"] is None:
break
until = row["end_s"]
return until
def dense(self, session_id: int, lo: float, hi: float) -> list[reaction.FaceSecond]:
"""Série contínua por segundo em [floor(lo), ceil(hi)) — índice i = segundo floor(lo) + i; segundos sem
dado (sem câmera, erro, ainda não rastreado) saem com `present` 0. É o formato que `reaction` espera."""
first, last = max(0, int(math.floor(lo))), max(0, int(math.ceil(hi)))
out = [reaction.FaceSecond(t) for t in range(first, last)]
if not out:
return out
rows = self.e.db.all(
"SELECT f.data_json FROM face_track f JOIN segments s ON s.session_id = f.session_id AND s.idx = f.idx"
" WHERE f.session_id = ? AND f.status = 'done' AND s.end_s >= ? AND s.start_s < ? ORDER BY f.idx",
session_id, first, last)
for row in rows:
for item in loads(row["data_json"], {}).get("seconds", []):
i = int(item["t"]) - first
if 0 <= i < len(out):
out[i] = reaction.FaceSecond.from_json(item)
return out
def for_scoring(self, session: dict, offset: int, duration: float) -> tuple[list[reaction.FaceSecond] | None, float]:
"""(série alinhada à janela da pontuação — t relativo a `offset` —, até onde o rastreio chegou).
`None` quando o rastreio está desligado ou a sessão não tem câmera: a pontuação segue como antes."""
if not self.enabled or not self.has_cam(session):
return None, 0.0
seconds = self.dense(session["id"], offset, duration)
for s in seconds:
s.t -= offset
return seconds, self.tracked_until(session["id"])
def must_wait(self, needed_until: float, face_until: float, analyzed_until: float) -> bool:
"""Espera o rosto do trecho antes de decidir o corte — mas nunca mais que `MAX_LAG_BLOCKS` blocos atrás da
transcrição (rastreio atrasado ou travado não segura os cortes)."""
if time.monotonic() < self._unavailable_until:
return False # backend fora do ar: esperar não adianta (sessão curta ficaria sem cortes até voltar)
lag = analyzed_until - face_until
return needed_until > face_until and lag <= MAX_LAG_BLOCKS * self.e.settings.segment_s
def summary(self, session: dict, lo: float, hi: float) -> str:
"""Linha "Rosto do streamer" do prompt do analista; "" quando não há câmera/rastreio nesse trecho."""
if not self.enabled or not self.has_cam(session):
return ""
# Plano B (OpenSeeFace) não mede expressão: os canais saem 0 e o texto diria "sem reação marcante" — falso.
if self.session_backend(session["id"]) == OpenSeeFaceTracker.name:
return ""
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
inside = [s for s in seconds if lo <= s.t <= hi]
if not inside or not any(s.smile is not None for s in inside):
return ""
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
def view(self, session: dict, lo: float, hi: float | None) -> dict:
"""Série por segundo para a API (o editor usa cx/cy/size, já no quadro inteiro, para reenquadrar)."""
sid = session["id"]
cam, source, decided = self.cam_for(session)
end = session["duration_s"] if hi is None else min(hi, session["duration_s"])
start = max(0.0, min(lo, end))
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
signal = reaction.reaction_signal(seconds, params=self.params)
moments = reaction.reaction_moments(seconds, self.params)
counts = {r["status"]: r["n"] for r in self.e.db.all(
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
rows = []
for s, z in zip(seconds, signal):
if s.t < start:
continue
item = s.to_json()
if z is not None:
item["signal"] = round(z, 2)
rows.append(item)
return {
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
"cam": cam, "camSource": source, "camDecided": decided, "backend": self.backend,
"lastError": self.last_error, "trackedUntilS": self.tracked_until(sid),
"blocks": {"total": total, "done": counts.get("done", 0), "noCam": counts.get("no_cam", 0),
"error": counts.get("error", 0)},
"fromS": start, "toS": end,
"seconds": rows,
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
}
# ---------- câmera local (YuNet + reaction.locate_cam)
def locate(self, session: dict) -> dict:
"""Acha a câmera olhando `CAM_FRAMES` quadros espalhados da gravação, sem IA."""
segments = self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])
if not segments:
raise FaceError("sem vídeo gravado (blocos apagados?)")
lo, hi = segments[0]["start_s"], segments[-1]["end_s"]
margin = min(30.0, (hi - lo) * 0.05)
span = max(0.0, hi - lo - 2 * margin)
times = [lo + margin + span * k / max(1, CAM_FRAMES - 1) for k in range(CAM_FRAMES)]
detector = self._detector_factory()
detections: list[list[Detection]] = []
size: tuple[int, int] | None = None
ffmpeg = self.e.settings.ffmpeg or "ffmpeg"
for t in times:
seg = next((s for s in segments if s["start_s"] <= t < s["end_s"]), segments[-1])
try:
bgr = self._grabber(ffmpeg, REPO_ROOT / seg["file"], t - seg["start_s"])
except (MediaError, OSError) as exc:
log.info("quadro %.0fs indisponível para achar a câmera: %s", t, exc)
continue
if bgr is None:
continue
size = (bgr.shape[1], bgr.shape[0])
detections.append(detector.detect(bgr))
if size is None or len(detections) < 3:
raise FaceError("poucos quadros legíveis para achar a câmera")
result = reaction.locate_cam(detections, size[0], size[1])
return result | {"source": "yunet", "frames": len(detections), "framesWithFace": sum(1 for d in detections if d),
"at": now()}