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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+761
View File
@@ -0,0 +1,761 @@
"""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()}