Clipador: quem fala cada palavra (streamer × outra pessoa) e legenda em duas linhas

A fala de colegas no Discord e de outros jogadores saía na legenda como se fosse do
streamer. Agora cada palavra tem falante:

- voz: cada trecho de fala vira uma impressão de voz (WeSpeaker ResNet34-LM, ONNX,
  pesos CC-BY-4.0) na análise do bloco (~0,2 s de CPU por bloco); as vozes da sessão
  são agrupadas sob demanda (0,05 s) e a do streamer é a que mexe a boca na webcam
  (YuNet, nova série `mouth` no rastreio) ou a mais alta no áudio. Sem prova, tudo
  continua como do streamer.
- dados: `scoring.Word.speaker`; `words_json` aceita o 4º elemento; tabela
  `voice_chunks` (CREATE TABLE IF NOT EXISTS, fora da lista de migrações).
- legenda: streamer na posição normal e outra pessoa logo abaixo, em outra cor
  (`caption.otherColor`/`otherSize`); blocos nunca misturam falantes; os dois juntos
  = duas linhas; gancho desvia as duas; vertical e horizontal.
- tradução com `speaker` por linha; juízes recebem a transcrição marcada.
- painel: cor da outra pessoa na configuração, falante na transcrição do editor
  (com correção manual), prévia em duas linhas e "O que falam" no modal.
- doc/clipador/FALANTES.md com abordagem, licenças e qualidade medida na sessão 15.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Mateuus
2026-11-18 03:57:00 -03:00
co-authored by Claude Opus 5.5
parent 54eac7cebf
commit 377536f778
21 changed files with 1657 additions and 126 deletions
+106 -29
View File
@@ -15,12 +15,23 @@ ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
para o bloco não piscar;
- `caption_blocks`: o fim de cada bloco é cortado no início do seguinte — nunca dois blocos na tela. O início do
bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
Dois falantes (pedido do dono, 18/11/2026: "a legenda do streamer em cima e a de outra pessoa abaixo, com outra cor,
como se fossem duas pessoas conversando"; doc/clipador/FALANTES.md): cada palavra tem `speaker` e a legenda tem duas
FAIXAS — a do streamer (posição normal) e a de outra pessoa (logo abaixo, `caption.otherColor`/`otherSize`). Um bloco
nunca mistura falantes; o "nunca dois blocos na tela" vale DENTRO de cada faixa, então quando os dois falam ao mesmo
tempo aparecem as duas linhas, cada uma no seu lugar (posição fixa por `pos`: o libass não empilha).
"""
from __future__ import annotations
from . import layout
from .scoring import Word
from .speakers import STREAMER, is_other
STREAMER_LANE, OTHER_LANE = "streamer", "other"
OTHER_SIZE_RATIO = 0.85 # tamanho automático da fala de outra pessoa (fração do tamanho da legenda)
LINE_GAP_PX = 10 # vão entre a linha do streamer e a de outra pessoa
WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração
MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6
@@ -58,20 +69,34 @@ def clean_words(words: list[Word]) -> list[Word]:
end = max(w.end, round(start + MIN_WORD_S, 3))
if out and out[-1].end > start + 1e-9:
prev = out[-1]
out[-1] = Word(prev.start, start, prev.word)
out[-1] = Word(prev.start, start, prev.word, prev.speaker)
text = w.word.strip()
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word
out.append(w if same else Word(start, end, text))
out.append(w if same else Word(start, end, text, w.speaker))
return out
def lane(speaker: str | None) -> str:
"""Faixa da legenda: `streamer` (vazio também) ou `other` (qualquer outra pessoa)."""
return OTHER_LANE if is_other(speaker) else STREAMER_LANE
def same_speaker(a: Word, b: Word) -> bool:
return (a.speaker or STREAMER) == (b.speaker or STREAMER)
def has_other(words: list[Word]) -> bool:
return any(is_other(w.speaker) for w in words)
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
"""Blocos da legenda (palavras já saneadas por `clean_words`)."""
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
groups: list[list[Word]] = []
for word in clean_words(words):
current = groups[-1] if groups else None
if current and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S:
if (current and same_speaker(current[-1], word) and word.start - current[-1].end <= MAX_GAP_S
and word.end - current[0].start <= MAX_BLOCK_S):
fits = len(" ".join(w.word for w in current + [word])) <= max_chars
room = len(current) < max_words or (
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
@@ -84,36 +109,74 @@ def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]:
"""(palavras do bloco, fim do bloco). O fim nunca passa do início do bloco seguinte: dois eventos de legenda
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro)."""
groups = group_words(words, max_words)
"""(palavras do bloco, fim do bloco), em ordem de início. Cada faixa (streamer / outra pessoa; ver `lane`) é
agrupada sozinha e um bloco nunca mistura falantes. O fim nunca passa do início do bloco seguinte DA MESMA FAIXA:
dois eventos no mesmo lugar ao mesmo tempo ficariam um em cima do outro. Blocos de faixas diferentes podem se
sobrepor (os dois falando juntos): cada um vai para a sua linha."""
out = []
for k, group in enumerate(groups):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
if k + 1 < len(groups):
end = min(end, groups[k + 1][0].start)
out.append((group, round(end, 3)))
for name in (STREAMER_LANE, OTHER_LANE):
groups = group_words([w for w in words if lane(w.speaker) == name], max_words)
for k, group in enumerate(groups):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
if k + 1 < len(groups):
end = min(end, groups[k + 1][0].start)
out.append((group, round(end, 3)))
out.sort(key=lambda item: (item[0][0].start, lane(item[0][0].speaker)))
return out
def other_size(cap: dict) -> int:
"""Tamanho da fala de outra pessoa: `caption.otherSize` ou, vazio, 85 % do tamanho da legenda."""
chosen = cap.get("otherSize")
return int(chosen) if chosen else max(30, int(round(int(cap["size"]) * OTHER_SIZE_RATIO)))
def other_color(cap: dict) -> str:
return str(cap.get("otherColor") or layout.DEFAULTS["caption"]["otherColor"])
def other_offset(size: int, osize: int, extra: int = 0) -> int:
"""Distância (px) do centro da linha do streamer ao centro da linha de outra pessoa (logo abaixo). `extra` =
espaço a mais entre as duas (a tradução de desenvolvimento do streamer fica nele)."""
return int(round(0.6 * size + 0.6 * osize)) + LINE_GAP_PX + extra
def other_y(y: int, offset: int, osize: int, canvas_h: int) -> int:
"""Centro da linha de outra pessoa: abaixo da do streamer; sem espaço até a borda, acima dela."""
below = y + offset
return below if below + int(0.6 * osize) <= canvas_h - 8 else max(int(0.6 * osize), y - offset)
PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16
_SENTENCE_END = (".", "?", "!")
def phrases(words: list[Word]) -> list[tuple[float, float, str]]:
def phrases(words: list[Word], with_speaker: bool = False) -> list[tuple]:
"""Fala em frases curtas com tempo (início, fim, texto) para traduzir: quebra em pausa > 0,7 s, fim de frase
(. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3."""
out: list[tuple[float, float, str]] = []
current: list[Word] = []
for w in clean_words(words):
if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S
or len(current) >= PHRASE_MAX_WORDS
or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)):
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current)))
current = []
current.append(w)
if current:
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current)))
(. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3.
Uma frase nunca mistura falantes (quem fala junto vira frase própria). `with_speaker` = devolve
(início, fim, texto, falante), com falante "streamer" ou "otherN"."""
out: list[tuple] = []
def flush(current: list[Word]) -> None:
item = (current[0].start, current[-1].end, " ".join(x.word for x in current))
out.append(item + (current[0].speaker or STREAMER,) if with_speaker else item)
by_speaker: dict[str, list[Word]] = {}
for w in words:
by_speaker.setdefault(w.speaker or STREAMER, []).append(w)
for speaker_words in by_speaker.values():
current: list[Word] = []
for w in clean_words(speaker_words):
if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S
or len(current) >= PHRASE_MAX_WORDS
or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)):
flush(current)
current = []
current.append(w)
if current:
flush(current)
out.sort(key=lambda item: item[0])
return out
@@ -123,13 +186,19 @@ def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str
cap, cred = cfg["caption"], cfg["credit"]
duration = clip_end - clip_start
inside = [
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip())
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip(), w.speaker)
for w in words
if w.end > clip_start and w.start < clip_end
]
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
width, height = layout.canvas_size(cfg)
two = cap["enabled"] and has_other(inside)
osize = other_size(cap)
# Estilo da fala de outra pessoa só quando há outra pessoa: o ASS de um corte só com o streamer fica igual.
other_style = (f"Style: CaptionOther,{cap['font']},{osize},{layout.ass_color(other_color(cap))},"
f"{layout.ass_color(other_color(cap))},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{max(2, int(cap['outlineWidth']) * osize // int(cap['size']))},3,5,60,60,0,1\n") if two else ""
header = f"""[Script Info]
ScriptType: v4.00+
PlayResX: {width}
@@ -140,7 +209,7 @@ ScaledBorderAndShadow: yes
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Caption,{cap['font']},{cap['size']},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{cap['outlineWidth']},3,5,60,60,0,1
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
{other_style}Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
@@ -149,9 +218,17 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
if credit and cred["enabled"]:
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
if cap["enabled"]:
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}"
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
y = layout.caption_y(cfg)
offset = other_offset(int(cap["size"]), osize)
if two: # sem espaço embaixo para a outra pessoa, a linha do streamer sobe (a ordem nunca inverte)
y = min(y, height - 8 - offset - int(0.6 * osize))
oy = other_y(y, offset, osize, height)
high = layout.ass_inline_color(cap["highlight"])
for group, g_end in caption_blocks(inside, cap["maxWords"]):
other = lane(group[0].speaker) == OTHER_LANE
pos = f"{{\\pos({width // 2},{oy if other else y})}}"
style = "CaptionOther" if other else "Caption"
base = layout.ass_inline_color(other_color(cap) if other else cap["color"])
for i, word in enumerate(group):
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
start = word.start
@@ -163,5 +240,5 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
for j, w in enumerate(group):
text = _escape(w.word.upper() if cap["uppercase"] else w.word)
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text)
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},Caption,,0,0,0,,{pos}{' '.join(parts)}")
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},{style},,0,0,0,,{pos}{' '.join(parts)}")
return header + "\n".join(lines) + "\n"