"""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] def pose_from_matrix(m: Any) -> tuple[float, float, float]: """(yaw, pitch, roll) em graus da matriz 4×4 de transformação facial do MediaPipe (linhas × colunas). Conferido em quadros reais (sessão 8): pitch DIMINUI quando a cabeça vai para trás (bebendo de lata: −25° contra ~+12° do normal, que olha um pouco para baixo); yaw ±50° = rosto virado de lado; roll ±45° = cabeça deitada. """ pitch = math.degrees(math.atan2(float(m[2][1]), float(m[2][2]))) yaw = math.degrees(math.atan2(-float(m[2][0]), math.hypot(float(m[2][1]), float(m[2][2])))) roll = math.degrees(math.atan2(float(m[1][0]), float(m[0][0]))) return yaw, pitch, roll class MediaPipeTracker: """MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes + matriz de pose. 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. `detector` (YuNet, opcional): quando o MediaPipe não acha o rosto — streamer de perfil olhando o monitor do lado (sessão 15, tfue: rosto em só 10 % dos quadros, YuNet em 100 %) —, a caixa da cabeça vira `FaceSample(head=True)`: sem expressão, mas com posição e tamanho para o corpo (agitação, chegar perto, sair do quadro). """ name = "mediapipe" def __init__(self, model_path: Path, detector: Detector | None = None): 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, output_facial_transformation_matrixes=True, # pose da cabeça (balanço, aceno, cabeça para trás) ) self._lm = vision.FaceLandmarker.create_from_options(options) self._detector = detector 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 self._head_only(t, rgb) 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 {} matrixes = getattr(result, "facial_transformation_matrixes", None) pose = pose_from_matrix(matrixes[0]) if matrixes else None return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend, pose) def _head_only(self, t: float, rgb: Any) -> reaction.FaceSample: """Sem rosto no MediaPipe: a caixa do YuNet (se houver) diz onde está a cabeça. Falha do detector não derruba o bloco: o quadro fica só sem rosto, como antes.""" if self._detector is None: return reaction.FaceSample(t, False) try: detections = self._detector.detect(self._np.ascontiguousarray(rgb[:, :, ::-1])) # YuNet quer BGR except Exception as exc: # noqa: BLE001 - OpenCV pode falhar num quadro; o rastreio do rosto segue log.debug("YuNet falhou no quadro %.2f: %s", t, exc) return reaction.FaceSample(t, False) if not detections: return reaction.FaceSample(t, False) x, y, w, h, _score = max(detections, key=lambda d: d[4]) height, width = rgb.shape[:2] return reaction.FaceSample(t, False, (x + w / 2) / width, (y + h / 2) / height, h / height, head=True) 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"] if s.hsize is not None: s.hsize = s.hsize * 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"), self._head_detector()) 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 _head_detector(self) -> Detector | None: """YuNet para a cabeça quando o MediaPipe perde o rosto; sem ele o rastreio segue como antes (só sem corpo de perfil).""" try: return self._detector_factory() except FaceUnavailable as exc: log.info("rastreio sem a caixa da cabeça (YuNet indisponível: %s)", exc) return None 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, params=self.params), 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] # Só a cabeça (de perfil, sem expressão) também rende linha: o corpo diz alguma coisa ao analista. if not inside or not any(s.smile is not None or (s.head or 0.0) > 0 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) body = reaction.body_moments(seconds, self.params) expressions = reaction.expression_map(seconds, self.params, body) 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, mapped in zip(seconds, signal, expressions): if s.t < start: continue item = s.to_json() if z is not None: item["signal"] = round(z, 2) # Mapa de expressões: a expressão dominante e o movimento do corpo no segundo (ausentes = nada). if mapped["expr"]: item["expr"] = mapped["expr"] if mapped["body"]: item["body"] = mapped["body"] 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], "body": [b.to_json() for b in body if b.end_s >= start and b.start_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()}