"""Quem fala cada palavra: o streamer ou outra pessoa (colega no Discord, voz do jogo). Doc: doc/clipador/FALANTES.md. Pedido do dono (18/11/2026): "está atribuindo ao streamer a fala de outro jogador". O áudio da live é um canal só (microfone do streamer + Discord + jogo misturados) e o Whisper devolve as palavras sem dizer de quem são. Como decide (medido na sessão 15, tfue com dois colegas no Discord): 1. **Voz** (`index_block`, na análise de cada bloco, logo depois do Whisper): a fala vira trechos curtos (palavras seguidas, ≤ 3 s) e cada trecho ≥ 0,5 s vira uma impressão de voz (WeSpeaker ResNet34-LM, `voiceprint.py`) + o volume (dBFS). Fica na tabela `voice_chunks`. 2. **Vozes da sessão** (`model`, sob demanda, em cache): agrupa os trechos ≥ 1 s pela voz (aglomerativo, cosseno ≥ 0,5 entre centros); grupo com ≥ 15 s de fala é uma "voz". Na sessão 15 saíram 3 vozes (263 s, 237 s, 201 s). 3. **Qual voz é o streamer** (`pick_streamer`): a que mexe mais a boca na webcam (série `mouth` de `face.py`, soma de muitos trechos; t ≥ 3 contra a segunda) — ou, sem câmera/sem certeza, a mais alta no áudio (o microfone dele vem mais forte que o Discord: +4,6 dB na sessão 15) se a diferença for ≥ 3 dB. Nenhum dos dois decide → ninguém vira "outro": tudo fica `streamer` (o comportamento de antes). 4. **Cada trecho** vai para a voz mais parecida; só vira `otherN` com folga (≥ 0,10 de cosseno a mais que o streamer e ≥ 0,30 com a outra voz; +0,05 nos dois para trecho < 1 s). Trecho curto sem impressão herda o vizinho mais próximo (≤ 1 s); senão, streamer. Palavra que já chega com `speaker` (4º elemento do `words_json`) fica como está. """ from __future__ import annotations import base64 import bisect import json import logging import math import threading import time from collections.abc import Callable, Iterable from dataclasses import dataclass, field, replace from typing import TYPE_CHECKING, Any from .db import loads, now from .scoring import Word if TYPE_CHECKING: # pragma: no cover from .worker import Engine log = logging.getLogger("cenaforge_clipper.speakers") STREAMER = "streamer" MODEL_ID = "wespeaker_r34" # entrada do models.lock.json CHUNK_GAP_S = 0.25 # vão entre palavras que fecha o trecho CHUNK_MAX_S = 3.0 # trecho mais longo que isto é partido EMBED_MIN_S = 0.5 # trecho mais curto não vira impressão de voz (herda o vizinho) EMBED_PAD_S = 0.1 # folga de áudio em volta do trecho CLUSTER_MIN_S = 1.0 # só trechos ≥ 1 s formam as vozes (os curtos só são atribuídos) MERGE_SIM = 0.5 # cosseno mínimo entre centros para juntar dois grupos (sessão 15: vozes diferentes a 0,26–0,33) VOICE_MIN_S = 15.0 # grupo com menos fala que isso não é uma voz (ruído, risada, voz do jogo solta) CLUSTER_CAP = 600 # trechos usados no agrupamento (o resto só é atribuído): custo O(n²) # "Outro" só com folga de cosseno sobre o streamer E parecido o bastante com a outra voz. Calibrado na sessão 15: # trecho curto (0,5–1 s) de colega dá cosseno 0,3–0,45 com a voz dele e ~0 com a do streamer; com 0,45 fixo, 150 # trechos assim ficavam como do streamer. Trecho curto pede um pouco mais dos dois. OTHER_MARGIN = 0.10 OTHER_MIN_SIM = 0.30 SHORT_EXTRA = 0.05 NEIGHBOR_S = 1.0 # trecho curto herda o rótulo do vizinho até esta distância EMBEDDER_RETRY_S = 300 # modelo de voz que falhou ao carregar: espera isto antes de tentar de novo MOUTH_MIN_FRAMES = 3 # quadros com rosto para o trecho contar na boca MOUTH_MIN_CHUNKS = 8 # trechos por voz para comparar a boca MOUTH_MIN_T = 3.0 # t de Welch mínimo (melhor × segunda voz); sinal fraco por trecho, ver `pick_streamer` LOUD_MIN_DB = 3.0 # diferença mínima de volume (mediana) para decidir pelo áudio def is_other(speaker: str | None) -> bool: return bool(speaker) and speaker != STREAMER def parse_words(raw: str | None) -> list[Word]: """`words_json` → palavras. Aceita [início, fim, texto] (antigo) e [início, fim, texto, falante].""" out = [] for item in loads(raw, []) or []: if not isinstance(item, (list, tuple)) or len(item) < 3: continue speaker = str(item[3]) if len(item) > 3 and item[3] else "" out.append(Word(float(item[0]), float(item[1]), str(item[2]), speaker)) return out def dump_words(words: Iterable[Word]) -> str: """Palavras → `words_json` (4º elemento só quando há falante: o formato antigo continua igual).""" return json.dumps([[w.start, w.end, w.word, w.speaker] if w.speaker else [w.start, w.end, w.word] for w in words], ensure_ascii=False) # --------------------------------------------------------------------------------------------------------------- # Trechos de fala def speech_chunks(words: list[Word], gap_s: float = CHUNK_GAP_S, max_s: float = CHUNK_MAX_S) -> list[tuple[float, float]]: """(início, fim) de cada trecho de fala contínua: palavras seguidas com vão ≤ `gap_s`, até `max_s`. Também fecha no fim de frase (. ? !) com o trecho já ≥ `EMBED_MIN_S`: numa conversa a vez troca quase sempre ali, mesmo sem pausa (sessão 15: "…you should bring two. | I got one code tablet completed." vinham num trecho só).""" out: list[tuple[float, float]] = [] cur: tuple[float, float] | None = None closed = False for w in sorted((w for w in words if w.word.strip()), key=lambda w: w.start): if cur and not closed and w.start - cur[1] <= gap_s and max(cur[1], w.end) - cur[0] <= max_s: cur = (cur[0], max(cur[1], w.end)) else: if cur: out.append(cur) cur = (w.start, max(w.end, w.start)) closed = w.word.rstrip().endswith((".", "?", "!")) and cur[1] - cur[0] >= EMBED_MIN_S if cur: out.append(cur) return out @dataclass class VoiceChunk: start: float end: float db: float | None = None vec: Any = None # numpy (256,) com norma 1, ou None (curto demais) label: str = "" @property def length(self) -> float: return self.end - self.start def encode_vec(vec: list[float]) -> str: import numpy as np return base64.b64encode(np.asarray(vec, np.float16).tobytes()).decode("ascii") def decode_vec(raw: str) -> Any: import numpy as np v = np.frombuffer(base64.b64decode(raw), np.float16).astype(np.float32) n = float(np.linalg.norm(v)) return v / n if n > 0 else None # --------------------------------------------------------------------------------------------------------------- # Agrupamento e decisão (numpy, sem E/S) def cluster(vectors: Any, threshold: float = MERGE_SIM) -> list[list[int]]: """Aglomerativo pelo centro (cosseno entre as médias normalizadas): junta o par mais parecido até nenhum par passar de `threshold`. Devolve os índices de cada grupo.""" import numpy as np n = len(vectors) if n == 0: return [] sums = np.array(vectors, np.float64) members: list[list[int] | None] = [[i] for i in range(n)] cent = sums / np.linalg.norm(sums, axis=1, keepdims=True) sim = cent @ cent.T np.fill_diagonal(sim, -np.inf) alive = np.ones(n, bool) while True: flat = int(np.argmax(sim)) i, j = divmod(flat, n) if not np.isfinite(sim[i, j]) or sim[i, j] < threshold: break members[i] = (members[i] or []) + (members[j] or []) members[j] = None alive[j] = False sums[i] += sums[j] cent[i] = sums[i] / np.linalg.norm(sums[i]) row = cent @ cent[i] row[~alive] = -np.inf row[i] = -np.inf sim[i, :] = row sim[:, i] = row sim[j, :] = -np.inf sim[:, j] = -np.inf return [m for m in members if m] @dataclass class Voice: label: str centroid: Any speech_s: float db: float | None mouth: list[float] = field(default_factory=list) def to_json(self) -> dict: m = self.mouth return {"label": self.label, "speechS": round(self.speech_s, 1), "db": None if self.db is None else round(self.db, 1), "mouth": round(sum(m) / len(m), 4) if m else None, "mouthChunks": len(m)} def _welch_t(a: list[float], b: list[float]) -> float: if len(a) < 2 or len(b) < 2: return 0.0 ma, mb = sum(a) / len(a), sum(b) / len(b) va = sum((x - ma) ** 2 for x in a) / (len(a) - 1) vb = sum((x - mb) ** 2 for x in b) / (len(b) - 1) se = math.sqrt(va / len(a) + vb / len(b)) return (ma - mb) / se if se > 0 else 0.0 def pick_streamer(voices: list[Voice]) -> tuple[int | None, str]: """Índice da voz do streamer e o porquê. Duas provas: a boca na webcam (a voz que mais mexe a boca dele) e o volume (o microfone dele vem mais forte que o Discord). Concordam ou só uma decide → ela; discordam → None (ninguém vira "outro"). Na sessão 15 (rosto de perfil) a boca nunca decidiu e chegou a apontar a voz errada nos 10 primeiros minutos (t < 2): por isso o limiar da boca é alto.""" if len(voices) < 2: return (0 if voices else None), "uma voz só" idx = range(len(voices)) with_mouth = sorted((i for i in idx if len(voices[i].mouth) >= MOUTH_MIN_CHUNKS), key=lambda i: -sum(voices[i].mouth) / len(voices[i].mouth)) by_mouth, why_mouth = None, "" if len(with_mouth) >= 2: t = _welch_t(voices[with_mouth[0]].mouth, voices[with_mouth[1]].mouth) if t >= MOUTH_MIN_T: by_mouth, why_mouth = with_mouth[0], f"boca (t={t:.1f})" loud = sorted((i for i in idx if voices[i].db is not None), key=lambda i: -(voices[i].db or 0.0)) by_loud, why_loud = None, "" if len(loud) >= 2: gap = (voices[loud[0]].db or 0.0) - (voices[loud[1]].db or 0.0) if gap >= LOUD_MIN_DB: by_loud, why_loud = loud[0], f"volume (+{gap:.1f} dB)" if by_mouth is not None and by_loud is not None and by_mouth != by_loud: return None, f"{why_mouth} e {why_loud} apontam vozes diferentes" if by_mouth is not None: return by_mouth, why_mouth + (f" e {why_loud}" if by_loud is not None else "") if by_loud is not None: return by_loud, why_loud return None, "sem prova de qual voz é o streamer (boca e volume empatados)" @dataclass class SpeakerModel: voices: list[Voice] streamer: int | None reason: str chunks: list[VoiceChunk] # todos os trechos da sessão, em ordem, já com `label` @property def active(self) -> bool: return self.streamer is not None and len(self.voices) >= 2 def assign(self, vec: Any, length: float) -> str: if not self.active or vec is None: return STREAMER sims = [float(v.centroid @ vec) for v in self.voices] s_streamer = sims[self.streamer] # type: ignore[index] best = max(range(len(sims)), key=lambda i: sims[i]) extra = SHORT_EXTRA if length < CLUSTER_MIN_S else 0.0 # trecho curto: prova mais forte if (best != self.streamer and sims[best] >= OTHER_MIN_SIM + extra and sims[best] - s_streamer >= OTHER_MARGIN + extra): return self.voices[best].label return STREAMER def to_json(self) -> dict: counts: dict[str, float] = {} for c in self.chunks: counts[c.label or STREAMER] = counts.get(c.label or STREAMER, 0.0) + c.length return {"active": self.active, "reason": self.reason, "streamer": None if self.streamer is None else self.voices[self.streamer].label, "voices": [v.to_json() for v in self.voices], "chunks": len(self.chunks), "speechByLabel": {k: round(v, 1) for k, v in counts.items()}} def build_model(chunks: list[VoiceChunk], mouth_of: Callable[[float, float], float | None] | None = None) -> SpeakerModel: """Vozes da sessão, qual é o streamer e o rótulo de cada trecho.""" import numpy as np chunks = sorted(chunks, key=lambda c: c.start) strong = [c for c in chunks if c.vec is not None and c.length >= CLUSTER_MIN_S] if len(strong) > CLUSTER_CAP: # amostra espalhada (os mais longos de cada faixa de tempo) step = len(strong) / CLUSTER_CAP strong = [max(strong[int(k * step): max(int(k * step) + 1, int((k + 1) * step))], key=lambda c: c.length) for k in range(CLUSTER_CAP)] groups = cluster(np.array([c.vec for c in strong])) if strong else [] voices: list[Voice] = [] for g in sorted(groups, key=lambda g: -sum(strong[i].length for i in g)): speech = sum(strong[i].length for i in g) if speech < VOICE_MIN_S: continue cent = np.mean([strong[i].vec for i in g], axis=0) dbs = sorted(strong[i].db for i in g if strong[i].db is not None) mouth = [] if mouth_of is not None: for i in g: m = mouth_of(strong[i].start, strong[i].end) if m is not None: mouth.append(m) voices.append(Voice("", cent / np.linalg.norm(cent), speech, dbs[len(dbs) // 2] if dbs else None, mouth)) streamer, reason = pick_streamer(voices) k = 0 for i, v in enumerate(voices): if i == streamer: v.label = STREAMER else: k += 1 v.label = f"other{k}" model = SpeakerModel(voices, streamer, reason, chunks) for c in chunks: c.label = model.assign(c.vec, c.length) if c.vec is not None else "" return model def label_words(words: list[Word], chunks: list[VoiceChunk]) -> list[Word]: """Rótulo de cada palavra pelo trecho que cobre o meio dela; trecho sem impressão (curto) herda o trecho rotulado mais próximo (≤ `NEIGHBOR_S`); nada perto → streamer. Palavra com `speaker` já preenchido fica.""" labeled = [c for c in sorted(chunks, key=lambda c: c.start) if c.label] if not any(is_other(c.label) for c in labeled): return words # ninguém além do streamer: palavras como vieram (vazio = streamer) starts = [c.start for c in labeled] out = [] for w in words: if w.speaker: out.append(w) continue mid = (w.start + w.end) / 2 k = bisect.bisect_right(starts, mid) - 1 best, dist = None, NEIGHBOR_S for j in (k, k + 1): if 0 <= j < len(labeled): c = labeled[j] d = 0.0 if c.start <= mid <= c.end else min(abs(mid - c.start), abs(mid - c.end)) if d <= dist: best, dist = c, d if d == 0.0: break out.append(replace(w, speaker=best.label if best else STREAMER)) return out def transfer(new_words: list[Word], labeled: list[Word]) -> list[Word]: """Falante de palavras novas (re-transcrição de um trecho) pelo das palavras antigas no mesmo tempo.""" marks = sorted((w for w in labeled if w.speaker), key=lambda w: w.start) if not marks: return new_words starts = [w.start for w in marks] out = [] for w in new_words: mid = (w.start + w.end) / 2 k = bisect.bisect_right(starts, mid) - 1 near = [marks[j] for j in (k, k + 1) if 0 <= j < len(marks)] best = min(near, key=lambda m: 0.0 if m.start <= mid <= m.end else min(abs(mid - m.start), abs(mid - m.end))) out.append(w if w.speaker else replace(w, speaker=best.speaker)) return out def mouth_activity(series: list[float | None], fps: float, block_start: float, a: float, b: float) -> list[float]: """Valores da série da boca (quadro i = `block_start` + i/fps) dentro de [a, b].""" lo = max(0, int(math.ceil((a - block_start) * fps))) hi = min(len(series), int(math.floor((b - block_start) * fps)) + 1) return [v for v in series[lo:hi] if v is not None] # --------------------------------------------------------------------------------------------------------------- # Serviço (E/S: banco, modelo de voz) # A tabela `voice_chunks` é criada pela migração v15 (db.py). class SpeakerService: """Uma instância por motor (`Engine.speakers`).""" def __init__(self, engine: Engine, embedder_factory: Callable[[], Any] | None = None): self.e = engine self._embedder_factory = embedder_factory or self._default_embedder self._embedder: Any = None self._embedder_retry_at = 0.0 # modelo de voz falhou (download/onnx): nova tentativa só depois disto self._lock = threading.Lock() self._cache: dict[int, tuple[tuple, SpeakerModel]] = {} self.last_error: str | None = None @property def enabled(self) -> bool: return bool(self.e.intel.opts.get("speakers", True)) def _default_embedder(self) -> Any: from .voiceprint import Voiceprint return Voiceprint(self.e.face.store.path(MODEL_ID)) def embedder(self) -> Any: """Modelo de voz (carregado no 1º bloco). Falhou → sobe o erro (a análise registra e segue) e só tenta de novo daqui a `EMBEDDER_RETRY_S`: sem rede, não baixa 26 MB a cada bloco.""" with self._lock: if self._embedder is None: if time.monotonic() < self._embedder_retry_at: raise RuntimeError(f"modelo de voz indisponível (nova tentativa em até {EMBEDDER_RETRY_S} s)") try: self._embedder = self._embedder_factory() except Exception: self._embedder_retry_at = time.monotonic() + EMBEDDER_RETRY_S raise return self._embedder # ---------- por bloco (thread da análise) def index_block(self, segment: dict, pcm: bytes, words: list[Word]) -> int: """Impressões de voz dos trechos de fala do bloco → `voice_chunks`. Devolve quantos trechos gravou.""" if not self.enabled: return 0 import numpy as np samples = np.frombuffer(pcm[: len(pcm) - len(pcm) % 2], np.int16) base = float(segment["start_s"]) sr = 16_000 items = [] embedder = self.embedder() if words else None for a, b in speech_chunks(words): item: dict = {"s": round(a, 3), "e": round(b, 3)} lo, hi = max(0, int((a - base - EMBED_PAD_S) * sr)), min(len(samples), int((b - base + EMBED_PAD_S) * sr)) part = samples[lo:hi] if len(part) >= sr * 0.1: rms = float(np.sqrt(np.mean(part.astype(np.float64) ** 2))) item["db"] = round(20 * math.log10(rms / 32768), 1) if rms > 0 else None if b - a >= EMBED_MIN_S and embedder is not None: vec = embedder.embed(part) if vec is not None: item["v"] = encode_vec(vec) items.append(item) data = {"model": MODEL_ID, "chunks": items} self.e.db.run("INSERT INTO voice_chunks (session_id, idx, data_json, updated_at) VALUES (?, ?, ?, ?)" " ON CONFLICT (session_id, idx) DO UPDATE SET data_json = excluded.data_json," " updated_at = excluded.updated_at", segment["session_id"], segment["idx"], json.dumps(data), now()) self.invalidate(segment["session_id"]) return len(items) # ---------- sessão def invalidate(self, session_id: int) -> None: with self._lock: self._cache.pop(session_id, None) def _key(self, session_id: int) -> tuple: row = self.e.db.get("SELECT COUNT(*) AS n, MAX(updated_at) AS u FROM voice_chunks WHERE session_id = ?", session_id) face = self.e.db.get("SELECT COUNT(*) AS n, MAX(updated_at) AS u FROM face_track WHERE session_id = ?", session_id) return (row["n"], row["u"], face["n"], face["u"]) def model(self, session_id: int) -> SpeakerModel | None: """Vozes da sessão (em cache até chegar bloco novo de voz ou de rosto). None = nada indexado.""" key = self._key(session_id) if key[0] == 0: return None with self._lock: hit = self._cache.get(session_id) if hit and hit[0] == key: return hit[1] model = self._build(session_id) with self._lock: self._cache[session_id] = (key, model) return model def _build(self, session_id: int) -> SpeakerModel: chunks = [] for row in self.e.db.all("SELECT data_json FROM voice_chunks WHERE session_id = ? ORDER BY idx", session_id): for item in loads(row["data_json"], {}).get("chunks", []): vec = decode_vec(item["v"]) if item.get("v") else None chunks.append(VoiceChunk(float(item["s"]), float(item["e"]), item.get("db"), vec)) blocks = [] for row in self.e.db.all( "SELECT s.start_s, 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' ORDER BY s.start_s", session_id): data = loads(row["data_json"], {}) if data.get("mouth"): blocks.append((float(row["start_s"]), float(data.get("fps") or 6), data["mouth"])) starts = [b[0] for b in blocks] def mouth_of(a: float, b: float) -> float | None: k = bisect.bisect_right(starts, a) - 1 values: list[float] = [] for j in (k, k + 1): if 0 <= j < len(blocks): values += mouth_activity(blocks[j][2], blocks[j][1], blocks[j][0], a, b) return sum(values) / len(values) if len(values) >= MOUTH_MIN_FRAMES else None model = build_model(chunks, mouth_of if blocks else None) log.info("sessão %s: %d vozes, streamer = %s (%s)", session_id, len(model.voices), model.voices[model.streamer].label if model.streamer is not None and model.voices else "—", model.reason) return model def label(self, session_id: int, words: list[Word]) -> list[Word]: """Palavras com falante. Sem sessão indexada, sem certeza ou desligado → como vieram (contam como streamer).""" if not words or not self.enabled: return words try: model = self.model(session_id) except Exception as exc: # noqa: BLE001 - atribuição nunca derruba a leitura da linha do tempo self.last_error = str(exc)[:300] log.warning("falantes da sessão %s: %s", session_id, exc) return words if model is None or not model.active: return words return label_words(words, model.chunks) def view(self, session_id: int) -> dict: """Estado para a API: vozes, qual é o streamer e por quê.""" model = self.model(session_id) if self.enabled else None return {"enabled": self.enabled, "lastError": self.last_error, **(model.to_json() if model else {"active": False, "reason": "nada indexado ainda", "voices": []})}