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>
This commit is contained in:
@@ -0,0 +1,498 @@
|
||||
"""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": []})}
|
||||
Reference in New Issue
Block a user