Files
CenaForge/clipper/app/speakers.py
T
MateuusandClaude Opus 5.5 439e111052 Integração: falantes + dublagem + vídeo final
- editor_api: importa dub e speakers juntos.
- voice_chunks (falantes) vira a migração v15, depois da v14 do vídeo final (antes era criada fora das migrações).
- dub.voice_for: qualquer voz que não é o streamer (other1, other2…) usa a segunda voz da dublagem.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:59:44 -03:00

499 lines
23 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.
"""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": []})}