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:
Mateuus
2026-11-18 03:59:44 -03:00
co-authored by Claude Opus 5.5
24 changed files with 1671 additions and 129 deletions
+11
View File
@@ -232,6 +232,17 @@ SCHEMA = [
UPDATE clips SET final_status = 'ready', final_file = file, final_thumb = thumb, final_at = updated_at UPDATE clips SET final_status = 'ready', final_file = file, final_thumb = thumb, final_at = updated_at
WHERE status IN ('approved', 'published') AND review_dev_json = '[]'; WHERE status IN ('approved', 'published') AND review_dev_json = '[]';
""", """,
# v15: falantes (doc/clipador/FALANTES.md). Impressões de voz dos trechos de fala de cada bloco (WeSpeaker), com o
# volume; as vozes da sessão são agrupadas sob demanda a partir daqui (speakers.SpeakerService).
"""
CREATE TABLE IF NOT EXISTS voice_chunks (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
data_json TEXT NOT NULL,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
] ]
+5 -3
View File
@@ -36,7 +36,7 @@ from .editor import to_output
log = logging.getLogger("cenaforge_clipper.dub") log = logging.getLogger("cenaforge_clipper.dub")
FALLBACK_VOICE = "pt-br-faber" # Piper, offline: quando a voz escolhida (Edge, online) falha FALLBACK_VOICE = "pt-br-faber" # Piper, offline: quando a voz escolhida (Edge, online) falha
SPEAKER_OTHER = "other" # `lines[].speaker` (outro agente): "streamer" | "other"; ausente = streamer SPEAKER_OTHER = "other" # `lines[].speaker` (FALANTES.md): "streamer" | "other1", "other2"…; ausente = streamer
# Esclarecimento do dono (18/11/2026): NÃO é dublagem de filme — é para a equipe entender o contexto. Nada de # Esclarecimento do dono (18/11/2026): NÃO é dublagem de filme — é para a equipe entender o contexto. Nada de
# sincronia labial: cada fala começa perto do início da original, em velocidade natural (inteligível primeiro), e pode # sincronia labial: cada fala começa perto do início da original, em velocidade natural (inteligível primeiro), e pode
# escorrer depois da fala original. Duas nunca tocam juntas e o atraso não acumula (limite por frase, `MAX_LATE_S`). # escorrer depois da fala original. Duas nunca tocam juntas e o atraso não acumula (limite por frase, `MAX_LATE_S`).
@@ -79,8 +79,10 @@ def options(cfg: dict) -> dict:
def voice_for(line: dict, opts: dict) -> str: def voice_for(line: dict, opts: dict) -> str:
"""Voz da frase: `speaker == "other"` usa a segunda voz; sem o campo (ou qualquer outro valor), a padrão.""" """Voz da frase: qualquer voz que não é o streamer (`other`, `other1`, `other2`…) usa a segunda voz; sem o
return opts["voiceOther"] if line.get("speaker") == SPEAKER_OTHER else opts["voice"] campo, a padrão."""
speaker = line.get("speaker")
return opts["voiceOther"] if isinstance(speaker, str) and speaker.startswith(SPEAKER_OTHER) else opts["voice"]
# ---------------------------------------------------------------- plano (contas puras, sem áudio) # ---------------------------------------------------------------- plano (contas puras, sem áudio)
+17 -2
View File
@@ -148,11 +148,22 @@ def output_words(project: dict) -> list[Word]:
if p.start <= mid <= p.end: if p.start <= mid <= p.end:
s = p.out + max(w["s"], p.start) - p.start s = p.out + max(w["s"], p.start) - p.start
e = p.out + min(w["e"], p.end) - p.start e = p.out + min(w["e"], p.end) - p.start
out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"])) out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"], w.get("sp") or ""))
break break
return out return out
def word_item(w: Word) -> dict:
"""Palavra da sessão → palavra do projeto. `sp` (quem fala; doc/clipador/FALANTES.md) só quando atribuído."""
item = {"s": w.start, "e": w.end, "w": w.word}
if w.speaker:
item["sp"] = w.speaker
return item
SPEAKER_RE = re.compile(r"^(streamer|other\d{0,2})$")
def emphasized(project: dict) -> set[tuple[float, str]]: def emphasized(project: dict) -> set[tuple[float, str]]:
return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")} return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
@@ -194,7 +205,7 @@ def default_project(clip: dict, words: list[Word], session_duration: float) -> d
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}], "cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
"captions": { "captions": {
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in words if lo <= w.start <= hi][:MAX_WORDS], "words": [word_item(w) for w in words if lo <= w.start <= hi][:MAX_WORDS],
}, },
"overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68, "overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []), "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
@@ -440,6 +451,10 @@ def validate_project(data: dict, *, session_id: int, session_duration: float, re
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms
e = round(s + 0.05, 3) e = round(s + 0.05, 3)
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)} item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
if w.get("sp"):
if not isinstance(w["sp"], str) or not SPEAKER_RE.match(w["sp"]):
raise EditError(f"palavra {i}: falante (sp) precisa ser streamer ou otherN")
item["sp"] = w["sp"]
if w.get("emph"): if w.get("emph"):
item["emph"] = True item["emph"] = True
if w.get("hidden"): if w.get("hidden"):
+11 -13
View File
@@ -21,7 +21,7 @@ from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field from pydantic import BaseModel, Field
from . import dub, editor, editor_render, layout, media from . import dub, editor, editor_render, layout, media, speakers
from .config import REPO_ROOT from .config import REPO_ROOT
from .db import loads, now from .db import loads, now
from .judge import JudgeError, _chat_block, _transcript from .judge import JudgeError, _chat_block, _transcript
@@ -170,9 +170,7 @@ def auto_for(engine, clip: dict, session: dict) -> dict:
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte).""" """Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
judge = _judge(clip) judge = _judge(clip)
lo, hi = editor.default_window(clip, session["duration_s"]) lo, hi = editor.default_window(clip, session["duration_s"])
rows = engine.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx", words = engine.words_between(clip["session_id"], lo, hi) # já com quem fala cada palavra (FALANTES.md)
clip["session_id"], lo, hi)
words = [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], [])]
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"] loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"], return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now()) engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
@@ -259,9 +257,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
return round(lo, 3), round(hi, 3) return round(lo, 3), round(hi, 3)
def _words(session_id: int, lo: float, hi: float) -> list[Word]: def _words(session_id: int, lo: float, hi: float) -> list[Word]:
rows = db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx", return [w for w in engine.words_between(session_id, lo, hi) if lo <= w.start <= hi]
session_id, lo, hi)
return [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], []) if lo <= a <= hi]
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None: def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4" f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
@@ -301,7 +297,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
"origin": row["origin"] if row else "ai", "aiProject": ai_project, "origin": row["origin"] if row else "ai", "aiProject": ai_project,
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None, "exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"], "window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in _words(clip["session_id"], w_lo, w_hi)], "words": [editor.word_item(w) for w in _words(clip["session_id"], w_lo, w_hi)],
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis, "chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session), "settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS], "presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
@@ -352,8 +348,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name) editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t) log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
_clean_old(folder, "proxy", name) _clean_old(folder, "proxy", name)
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word} return _cached_proxy(clip, lo, hi) | {"words": [editor.word_item(w) for w in _words(clip["session_id"], lo, hi)]}
for w in _words(clip["session_id"], lo, hi)]}
@app.get("/v1/clips/{clip_id}/waveform") @app.get("/v1/clips/{clip_id}/waveform")
def get_waveform(clip_id: int, lo: float, hi: float): def get_waveform(clip_id: int, lo: float, hi: float):
@@ -441,8 +436,11 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}") words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
# Quem fala: o mesmo das palavras antigas no mesmo instante (a re-transcrição não sabe o falante).
fresh = speakers.transfer([Word(round(w.start + a, 3), round(w.end + a, 3), w.word) for w in words],
_words(clip["session_id"], a - 1, b + 1))
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1), return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
"words": [{"s": round(w.start + a, 3), "e": round(w.end + a, 3), "w": w.word} for w in words]} "words": [editor.word_item(w) for w in fresh]}
@app.post("/v1/clips/{clip_id}/tts") @app.post("/v1/clips/{clip_id}/tts")
def tts(clip_id: int, body: TtsIn): def tts(clip_id: int, body: TtsIn):
@@ -485,12 +483,12 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
project = validate_for(engine, clip, session, data) project = validate_for(engine, clip, session, data)
lo, hi = project["source"]["lo"], project["source"]["hi"] lo, hi = project["source"]["lo"], project["source"]["hi"]
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5)) tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
words = [Word(w["s"], w["e"], w["w"]) for w in project["captions"]["words"]] or tl["words"] words = [Word(w["s"], w["e"], w["w"], w.get("sp") or "") for w in project["captions"]["words"]] or tl["words"]
view = clip_view(clip) view = clip_view(clip)
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
cfg = editor.effective_settings(engine.intel.settings_for(session), project) cfg = editor.effective_settings(engine.intel.settings_for(session), project)
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis, prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
_transcript(words, lo, hi), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg) _transcript(words, lo, hi, streamer=engine.streamer_name(session)), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
t = time.monotonic() t = time.monotonic()
try: try:
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, []) raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
+79 -31
View File
@@ -19,7 +19,9 @@ from pathlib import Path
from . import dub, layout, media, reframe from . import dub, layout, media, reframe
from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output from .editor import Piece, effective_settings, emphasized, output_duration, output_words, pieces, slice_pieces, to_output
from .scoring import Word from .scoring import Word
from .subtitles import _escape, _ts, caption_blocks, clean_words from .speakers import is_other
from .subtitles import (OTHER_LANE, STREAMER_LANE, _escape, _ts, caption_blocks, clean_words, has_other, lane,
other_color, other_offset, other_size, other_y)
log = logging.getLogger("cenaforge_clipper.editor_render") log = logging.getLogger("cenaforge_clipper.editor_render")
W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração W, H = layout.W, layout.H # quadro do vertical (padrão dos parâmetros); o formato real vem da configuração
@@ -83,10 +85,12 @@ def banner_layout(o: dict, canvas: tuple[int, int]) -> dict:
def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: int, def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: int,
total: float) -> list[tuple[float, float, int]]: total: float, below: int = 0) -> list[tuple[float, float, int]]:
"""Onde a legenda vai enquanto cada gancho está na tela, se ele a cobriria: [(início, fim, y do centro)]. """Onde a legenda vai enquanto cada gancho está na tela, se ele a cobriria: [(início, fim, y do centro)].
Com a câmera em cima, o gancho fica logo abaixo dela (layout.hook_y) — o mesmo lugar da legenda automática Com a câmera em cima, o gancho fica logo abaixo dela (layout.hook_y) — o mesmo lugar da legenda automática
(emenda câmera/jogo). Nesses segundos a legenda desce para logo abaixo do gancho; depois volta ao lugar.""" (emenda câmera/jogo). Nesses segundos a legenda desce para logo abaixo do gancho; depois volta ao lugar.
`below` = quanto a legenda ocupa ABAIXO do centro além do próprio tamanho (a linha de outra pessoa,
doc/clipador/FALANTES.md): as duas linhas desviam juntas. 0 = só a linha do streamer (como antes)."""
_, ch = canvas _, ch = canvas
out = [] out = []
for o in project["overlays"]: for o in project["overlays"]:
@@ -98,10 +102,11 @@ def hook_dodges(project: dict, canvas: tuple[int, int], cap_y: int, cap_size: in
else: else:
cy, half = int(ch * o["y"]), int(o["size"] * 0.9) cy, half = int(ch * o["y"]), int(o["size"] * 0.9)
top, bottom = cy - half, cy + half top, bottom = cy - half, cy + half
if cap_y + cap_size <= top or cap_y - cap_size >= bottom: reach = max(cap_size, below) # até onde a legenda (com a linha de baixo) desce a partir do centro
if cap_y + reach <= top or cap_y - cap_size >= bottom:
continue # não se encostam continue # não se encostam
below = bottom + cap_size + 12 under = bottom + cap_size + 12
y = below if below + cap_size <= ch else max(cap_size, top - cap_size - 12) y = under if under + reach <= ch else max(cap_size, top - reach - 12)
out.append((float(o["start"]), float(min(o["end"], total)), y)) out.append((float(o["start"]), float(min(o["end"], total)), y))
return out return out
@@ -224,6 +229,17 @@ def build_project_ass(project: dict, cfg: dict, credit: str, t0: float = 0.0, t1
tsize = max(30, int(size * 0.5)) tsize = max(30, int(size * 0.5))
trans_style = (f"Style: Trans,Arial,{tsize},&H00FFE79B,&H00FFE79B,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1," trans_style = (f"Style: Trans,Arial,{tsize},&H00FFE79B,&H00FFE79B,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{max(3, ow // 2)},2,8,60,60,0,1\n") if flags["translation"] and translation else "" f"{max(3, ow // 2)},2,8,60,60,0,1\n") if flags["translation"] and translation else ""
# Fala de outra pessoa (doc/clipador/FALANTES.md): faixa própria, logo abaixo, noutra cor e tamanho. Os estilos
# só entram quando o corte tem outra pessoa: o ASS de um corte só com o streamer fica idêntico ao de antes.
spoken = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end))
two = bool(cap["enabled"]) and has_other(spoken)
osize = other_size(cap)
other_c = layout.ass_color(other_color(cap))
oow = max(2, int(ow) * osize // max(1, int(size))) if ow else 0
other_styles = (f"Style: CaptionOther,{font},{osize},{other_c},{other_c},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{oow},3,5,60,60,0,1\n"
f"Style: KaraokeOther,{font},{osize},{high},{other_c},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,"
f"{oow},3,5,60,60,0,1\n") if two else ""
header = f"""[Script Info] header = f"""[Script Info]
ScriptType: v4.00+ ScriptType: v4.00+
PlayResX: {cw} PlayResX: {cw}
@@ -235,7 +251,7 @@ ScaledBorderAndShadow: yes
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding 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,{font},{size},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1 Style: Caption,{font},{size},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1
Style: Karaoke,{font},{size},{high},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},3,5,60,60,0,1 Style: Karaoke,{font},{size},{high},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{ow},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_styles}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
Style: Text,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,2,5,60,60,0,1 Style: Text,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,2,5,60,60,0,1
Style: Box,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H004D1DE1,&H00000000,-1,0,0,0,100,100,0,0,3,18,0,5,60,60,0,1 Style: Box,Arial Black,64,&H00FFFFFF,&H00FFFFFF,&H004D1DE1,&H00000000,-1,0,0,0,100,100,0,0,3,18,0,5,60,60,0,1
Style: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1 Style: Bar,Arial,10,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1
@@ -259,35 +275,61 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
emph = emphasized(project) emph = emphasized(project)
emph_c = layout.ass_inline_color(project["captions"]["emphColor"]) emph_c = layout.ass_inline_color(project["captions"]["emphColor"])
hi_c, base_c = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"]) hi_c, base_c = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
pos = f"\\pos({cw // 2},{layout.caption_y(cfg)})" oth_c = layout.ass_inline_color(other_color(cap))
dodges = hook_dodges(project, (cw, ch), layout.caption_y(cfg), int(cap["size"]), total) cap_y = layout.caption_y(cfg)
pos = f"\\pos({cw // 2},{cap_y})"
trans_on = bool(flags["translation"] and translation)
# Linha de outra pessoa logo abaixo da do streamer. Com a tradução de desenvolvimento ligada, a tradução do
# streamer (até 2 linhas) fica ENTRE as duas e a de outra pessoa, embaixo da linha dela.
offset = other_offset(int(size), osize, int(2.4 * tsize) + 6 if trans_on else 0)
# O gancho desvia as duas linhas juntas (a de baixo conta na altura ocupada).
below = offset + int(0.6 * osize) + (int(2.4 * tsize) if trans_on else 0) if two else 0
# Sem espaço embaixo para a linha de outra pessoa (horizontal: a legenda já fica a 85 % da altura), a do
# streamer SOBE o necessário: a ordem nunca inverte (streamer em cima, outra pessoa embaixo).
if two:
cap_y = min(cap_y, ch - 8 - below)
pos = f"\\pos({cw // 2},{cap_y})"
dodges = hook_dodges(project, (cw, ch), cap_y, int(cap["size"]), total, below=below)
def y_at(t: float) -> int: def y_at(t: float) -> int:
"""Altura (centro) da legenda no instante t (saída): desviada enquanto um gancho a cobriria.""" """Altura (centro) da legenda do streamer no instante t (saída): desviada enquanto um gancho a cobriria."""
for s, e, y in dodges: for s, e, y in dodges:
if s <= t < e: if s <= t < e:
return y return y
return layout.caption_y(cfg) return cap_y
def at(t: float) -> str: def oy_at(t: float) -> int:
"""Posição da legenda no instante t (saída).""" """Altura (centro) da linha de outra pessoa no instante t (saída)."""
return other_y(y_at(t), offset, osize, ch)
def at(t: float, other: bool = False) -> str:
"""Posição da legenda no instante t (saída). `\\pos` fixo: o libass não empilha as duas linhas."""
if other:
return f"\\pos({cw // 2},{oy_at(t)})"
y = y_at(t) y = y_at(t)
return pos if y == layout.caption_y(cfg) else f"\\pos({cw // 2},{y})" return pos if y == cap_y else f"\\pos({cw // 2},{y})"
# Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos # Ênfase: palavra de saída ↔ palavra marcada no projeto (mesmo texto, mesmo instante), casada nos tempos
# ORIGINAIS. Depois as palavras são saneadas (ordem, sem sobreposição, duração mínima) — `clean_words` devolve # ORIGINAIS. Depois as palavras são saneadas POR FAIXA (ordem, sem sobreposição, duração mínima) —
# a mesma quantidade, na mesma ordem — e os blocos abaixo nunca ficam dois na tela ao mesmo tempo. # `clean_words` devolve a mesma quantidade, na mesma ordem — e os blocos de uma faixa nunca ficam dois na
raw = sorted((w for w in output_words(project) if w.word.strip()), key=lambda w: (w.start, w.end)) # tela ao mesmo tempo (as duas faixas, sim: cada uma na sua linha).
raw = spoken
raw_emph = _match_emphasis(raw, project, emph) raw_emph = _match_emphasis(raw, project, emph)
words = clean_words(raw) words: list[Word] = list(raw)
for name in (STREAMER_LANE, OTHER_LANE):
idxs = [i for i, w in enumerate(raw) if lane(w.speaker) == name]
for i, w in zip(idxs, clean_words([raw[i] for i in idxs])):
words[i] = w
def txt(w: Word) -> str: def txt(w: Word) -> str:
return _escape(w.word.upper() if cap["uppercase"] else w.word) return _escape(w.word.upper() if cap["uppercase"] else w.word)
def key(w: Word) -> tuple[float, str]: def key(w: Word) -> tuple[float, str, str]:
return round(w.start, 3), w.word # depois de clean_words, cada início é único return round(w.start, 3), w.word, lane(w.speaker) # depois de clean_words, cada início é único na faixa
emph_keys = {key(words[i]) for i in raw_emph} emph_keys = {key(words[i]) for i in raw_emph}
for group, g_end in caption_blocks(words, cap["maxWords"]): for group, g_end in caption_blocks(words, cap["maxWords"]):
other = lane(group[0].speaker) == OTHER_LANE
base_g = oth_c if other else base_c
if preset == "karaoke": if preset == "karaoke":
parts, cursor = [], group[0].start parts, cursor = [], group[0].start
for w in group: for w in group:
@@ -296,40 +338,46 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
color = f"\\1c{emph_c}" if key(w) in emph_keys else "" color = f"\\1c{emph_c}" if key(w) in emph_keys else ""
parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}") parts.append((f"{{\\k{gap}}}" if gap else "") + f"{{\\kf{dur}{color}}}{txt(w)}")
cursor = w.end cursor = w.end
event(0, group[0].start, g_end, "Karaoke", f"{{{at(group[0].start)}}}" + " ".join(parts)) event(0, group[0].start, g_end, "KaraokeOther" if other else "Karaoke",
f"{{{at(group[0].start, other)}}}" + " ".join(parts))
continue continue
style = "CaptionOther" if other else "Caption"
for i, word in enumerate(group): for i, word in enumerate(group):
start = word.start start = word.start
end = group[i + 1].start if i + 1 < len(group) else g_end end = group[i + 1].start if i + 1 < len(group) else g_end
if end <= start: if end <= start:
continue continue
if preset == "single": if preset == "single":
color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_c) color = emph_c if key(word) in emph_keys else (hi_c if len(group) > 1 else base_g)
event(0, start, end, "Caption", f"{{{at(start)}{_anim('pop')}\\c{color}}}{txt(word)}") event(0, start, end, style, f"{{{at(start, other)}{_anim('pop')}\\c{color}}}{txt(word)}")
continue continue
parts = [] parts = []
for j, w in enumerate(group): for j, w in enumerate(group):
is_emph = key(w) in emph_keys is_emph = key(w) in emph_keys
if preset == "minimal": if preset == "minimal":
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w)) parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_g}}}" if is_emph else txt(w))
elif j == i: elif j == i:
color = emph_c if is_emph else hi_c color = emph_c if is_emph else hi_c
pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else "" pop = "\\fscx118\\fscy118\\t(0,130,\\fscx100\\fscy100)" if preset == "pop" else ""
parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_c}\\fscx100\\fscy100}}") parts.append(f"{{\\c{color}{pop}}}{txt(w)}{{\\c{base_g}\\fscx100\\fscy100}}")
else: else:
parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_c}}}" if is_emph else txt(w)) parts.append(f"{{\\c{emph_c}}}{txt(w)}{{\\c{base_g}}}" if is_emph else txt(w))
intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else "" intro = "\\fscx85\\fscy85\\t(0,90,\\fscx100\\fscy100)" if preset == "pop" and i == 0 else ""
event(0, start, end, "Caption", f"{{{at(start)}{intro}}}" + " ".join(parts)) event(0, start, end, style, f"{{{at(start, other)}{intro}}}" + " ".join(parts))
if flags["translation"] and translation: if trans_on:
# Só para desenvolver (doc/clipador/IDIOMAS.md): a frase traduzida em português, menor e em azul claro, # Só para desenvolver (doc/clipador/IDIOMAS.md): a frase traduzida em português, menor e em azul claro,
# logo embaixo da legenda em inglês (\\an8 = cresce para baixo; \\q0 = quebra a linha se for longa). # logo embaixo da legenda de QUEM FALA (`speaker` da linha; sem ele, o streamer) — \\an8 = cresce para
for line in translation: # baixo; \\q0 = quebra a linha se for longa.
for line in translation or []:
a, _ = to_output(float(line["s"]), project["cuts"]) a, _ = to_output(float(line["s"]), project["cuts"])
b, _ = to_output(float(line["e"]), project["cuts"]) b, _ = to_output(float(line["e"]), project["cuts"])
if b - a < 0.2 or not str(line.get("pt") or "").strip(): if b - a < 0.2 or not str(line.get("pt") or "").strip():
continue continue
y = y_at(a) + int(size * 0.62) if two and is_other(line.get("speaker")):
y = oy_at(a) + int(osize * 0.62)
else:
y = y_at(a) + int(size * 0.62)
event(0, a, b, "Trans", f"{{\\an8\\pos({cw // 2},{y})\\q0}}{_escape(str(line['pt']))}") event(0, a, b, "Trans", f"{{\\an8\\pos({cw // 2},{y})\\q0}}{_escape(str(line['pt']))}")
cuts = project["cuts"] cuts = project["cuts"]
+88 -3
View File
@@ -213,6 +213,61 @@ class MediaPipeTracker:
self._lm.close() self._lm.close()
class MouthMeter:
"""Movimento da boca por quadro, para a atribuição de falante (speakers.py; doc/clipador/FALANTES.md).
Medido na sessão 15 (tfue, webcam pequena e rosto de PERFIL): o MediaPipe só achava o rosto em ~4 % dos quadros
e o `jawOpen` ficava em 0,00 mesmo falando. O YuNet acha o rosto em 99 % dos quadros e dá os cantos da boca:
o recorte da boca (alinhado pelo YuNet em cada quadro, 24×20, normalizado) é comparado com o do quadro anterior.
Valor = diferença média (0 = parado); None = sem rosto neste quadro ou no anterior. É um sinal FRACO por trecho
(fala × boca parada separa pouco num trecho só) e forte na soma: serve para dizer QUAL voz é a do streamer."""
PATCH = (24, 20)
def __init__(self, model_path: Path, score: float = 0.5):
try:
import cv2
import numpy as np
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._np, self._path, self._score = cv2, np, model_path, score
self._det = None
self._size: tuple[int, int] | None = None
self._prev: Any = None
def feed(self, rgb: Any) -> float | None:
cv2, np = self._cv2, self._np
if rgb is None:
self._prev = None
return None
h, w = rgb.shape[:2]
if self._det is None:
self._det = cv2.FaceDetectorYN.create(str(self._path), "", (w, h), self._score, 0.3, 5)
elif self._size != (w, h):
self._det.setInputSize((w, h))
self._size = (w, h)
bgr = np.ascontiguousarray(rgb[:, :, ::-1])
_, faces = self._det.detect(bgr)
if faces is None or len(faces) == 0:
self._prev = None
return None
f = max(faces, key=lambda r: r[14])
fh = float(f[3])
(rx, ry), (lx, ly) = f[10:12], f[12:14] # cantos da boca (direito, esquerdo)
mx, my = (rx + lx) / 2, (ry + ly) / 2
mw = max(abs(lx - rx), float(f[2]) * 0.3)
x0, x1 = int(mx - mw * 0.9), int(mx + mw * 0.9)
y0, y1 = int(my - fh * 0.12), int(my + fh * 0.22)
if x0 < 0 or y0 < 0 or x1 > w or y1 > h or x1 - x0 < 4 or y1 - y0 < 4:
self._prev = None
return None
gray = cv2.cvtColor(bgr[y0:y1, x0:x1], cv2.COLOR_BGR2GRAY)
patch = cv2.resize(gray, self.PATCH).astype(np.float32)
patch = (patch - patch.mean()) / (patch.std() + 1e-3)
prev, self._prev = self._prev, patch
return None if prev is None else float(np.abs(patch - prev).mean())
class OpenSeeFaceTracker: class OpenSeeFaceTracker:
"""Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes. """Plano B (OpenSeeFace, só os .onnx no onnxruntime): presença e posição do rosto, SEM blendshapes.
@@ -449,8 +504,12 @@ class FaceService:
detector_factory: Callable[[], Detector] | None = None, detector_factory: Callable[[], Detector] | None = None,
reader: Callable[..., Iterator[tuple[float, Any]]] | None = None, reader: Callable[..., Iterator[tuple[float, Any]]] | None = None,
grabber: Callable[..., Any] | None = None, grabber: Callable[..., Any] | None = None,
sizer: Callable[[Path], tuple[int, int]] | None = None): sizer: Callable[[Path], tuple[int, int]] | None = None,
mouth_factory: Callable[[], Any] | None = None):
self.e = engine self.e = engine
# Movimento da boca por quadro (atribuição de falante). Falha ao criar = bloco sem a série `mouth` (o
# rastreio de reação segue igual). Nos testes (store falso) cai nesse caso sozinho.
self._mouth_factory = mouth_factory or (lambda: MouthMeter(self.store.path("yunet")))
self.store = store or ModelStore(engine.settings.data_dir / "models") 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. # 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._tracker_factory: Callable[[str | None], Tracker] = tracker_factory or self._default_tracker
@@ -592,12 +651,21 @@ class FaceService:
started = time.perf_counter() started = time.perf_counter()
tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco tracker = self._tracker_factory(self.session_backend(sid)) # FaceUnavailable sobe: não marca o bloco
self.backend = tracker.name self.backend = tracker.name
mouth = self._mouth_meter()
mouth_values: list[float | None] = []
try: try:
file = REPO_ROOT / segment["file"] file = REPO_ROOT / segment["file"]
crop = expand(cam) crop = expand(cam)
px, out = crop_geometry(crop, self._frame_size(sid, file)) px, out = crop_geometry(crop, self._frame_size(sid, file))
samples = [tracker.process(segment["start_s"] + t, rgb) samples = []
for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out)] for t, rgb in self._reader(self.e.settings.ffmpeg or "ffmpeg", file, px, out):
samples.append(tracker.process(segment["start_s"] + t, rgb))
if mouth is not None:
try:
mouth_values.append(mouth.feed(rgb))
except Exception as exc: # noqa: BLE001 - a boca é extra: falhou, o bloco segue sem ela
log.info("movimento da boca do bloco %s/%s: %s", sid, idx, exc)
mouth, mouth_values = None, []
except FaceUnavailable: except FaceUnavailable:
raise # não é culpa do bloco: não grava, o laço tenta de novo mais tarde 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 except Exception as exc: # noqa: BLE001 - FFmpeg, MediaPipe (RuntimeError) etc.: o bloco vira "error" e o laço segue
@@ -616,10 +684,27 @@ class FaceService:
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples), data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame", "ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)} "seconds": reaction.seconds_to_json(seconds)}
if mouth is not None and mouth_values:
# Quadro i = início do bloco + i / fps (speakers.py soma isto por trecho de fala).
data["mouth"] = [None if v is None else round(v, 4) for v in mouth_values]
self._save(sid, idx, "done", data, None) self._save(sid, idx, "done", data, None)
self.last_error = None self.last_error = None
self._after_block(sid, idx)
return "done" return "done"
def _mouth_meter(self) -> Any:
try:
return self._mouth_factory()
except Exception as exc: # noqa: BLE001 - sem YuNet/opencv: rastreio segue, só sem a série da boca
log.debug("medidor de boca indisponível: %s", exc)
return None
def _after_block(self, session_id: int, idx: int) -> None:
"""Série nova da boca: a atribuição de falante da sessão é refeita na próxima leitura."""
speakers = getattr(self.e, "speakers", None)
if speakers is not None:
speakers.invalidate(session_id)
def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]: def _frame_size(self, session_id: int, file: Path) -> tuple[int, int]:
key = str(file) key = str(file)
if key not in self._sizes: if key not in self._sizes:
+33 -9
View File
@@ -660,16 +660,40 @@ def _game_context_en(game: str, screen_game: str, profile: dict | None, live_tit
return "\n".join(lines) return "\n".join(lines)
def _transcript(words: list[Word], lo: float, hi: float, lang: str = "pt") -> str: SPEAKER_NOTE = {
lines, current, current_t = [], [], None "pt": "Quem fala vem marcado: [{s}] = o streamer; [other1], [other2]… = OUTRA pessoa (colega no Discord, outro "
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start): "jogador no chat de voz do jogo). Nunca atribua a {s} o que outra pessoa disse.",
if current_t is None or word.start - current_t > 4 or len(current) >= 14: "en": "Each line is tagged with who speaks: [{s}] = the streamer; [other1], [other2]… = SOMEONE ELSE (teammate on "
"Discord, another player on in-game voice chat). Never attribute to {s} what someone else said.",
}
def _transcript(words: list[Word], lo: float, hi: float, lang: str = "pt", streamer: str = "") -> str:
"""Transcrição com tempo para os prompts. Com fala de outra pessoa no trecho (doc/clipador/FALANTES.md), cada
linha diz quem fala ([Tfue] / [other1]) e nunca mistura falantes; sem outra pessoa, sai igual a antes."""
inside = sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start)
tagged = any(w.speaker and w.speaker != "streamer" for w in inside)
me = (streamer or "streamer").replace("[", "(").replace("]", ")")
lines: list[str] = []
current: list[str] = []
current_t: float | None = None
current_sp = ""
def flush() -> None:
tag = f" [{me if current_sp == 'streamer' else current_sp}]" if tagged else ""
lines.append(f"[{current_t:.0f}s]{tag} {' '.join(current)}")
for word in inside:
sp = word.speaker or "streamer"
if current_t is None or word.start - current_t > 4 or len(current) >= 14 or (tagged and sp != current_sp):
if current: if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}") flush()
current, current_t = [], word.start current, current_t, current_sp = [], word.start, sp
current.append(word.word) current.append(word.word)
if current: if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}") flush()
if lines and tagged:
lines.insert(0, SPEAKER_NOTE["en" if lang == "en" else "pt"].format(s=me))
return "\n".join(lines) or LABELS[lang]["no_speech"] return "\n".join(lines) or LABELS[lang]["no_speech"]
@@ -717,7 +741,7 @@ def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, pea
f"{L['signals']}: {json.dumps(heuristic, ensure_ascii=False)}\n" f"{L['signals']}: {json.dumps(heuristic, ensure_ascii=False)}\n"
+ (f"{L['face']}: {face}\n" if face else "") + (f"{L['face']}: {face}\n" if face else "")
+ f"{_frames_block(frames or [], lang)}\n\n" + f"{_frames_block(frames or [], lang)}\n\n"
f"{L['transcript']}:\n{_transcript(words, lo, hi, lang)}\n\n" f"{L['transcript']}:\n{_transcript(words, lo, hi, lang, streamer)}\n\n"
f"{_chat_block(chat, lo, hi, peak_s, lang=lang)}" f"{_chat_block(chat, lo, hi, peak_s, lang=lang)}"
) )
@@ -732,7 +756,7 @@ def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_l
f"{L['new_window']}: {lo:.0f}s {to} {hi:.0f}s ({L['back_to'].format(s=f'{back_lo:.0f}')}).\n" f"{L['new_window']}: {lo:.0f}s {to} {hi:.0f}s ({L['back_to'].format(s=f'{back_lo:.0f}')}).\n"
f"{L['duration']}: {min_s:.0f} {to} {max_s:.0f} s. {L['done']}: {done}\n" f"{L['duration']}: {min_s:.0f} {to} {max_s:.0f} s. {L['done']}: {done}\n"
f"{_frames_block(frames, lang)}\n\n" f"{_frames_block(frames, lang)}\n\n"
f"{L['transcript']}:\n{_transcript(words, back_lo, hi, lang)}\n\n" f"{L['transcript']}:\n{_transcript(words, back_lo, hi, lang, streamer)}\n\n"
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10, lang=lang)}" f"{_chat_block(chat, back_lo, hi, None, bucket_s=10, lang=lang)}"
) )
+8 -1
View File
@@ -97,6 +97,9 @@ DEFAULTS: dict = {
"caption": { "caption": {
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500", "enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3, "outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
# Fala de OUTRA pessoa (colega no Discord, voz do jogo): linha logo abaixo da do streamer, nesta cor;
# `otherSize` None = 85 % de `size` (doc/clipador/FALANTES.md).
"otherColor": "#5CE1FF", "otherSize": None,
# Legado (18/11/2026, manhã): virou `dev.translation`. Ainda lido por `dev_flags` (camadas já salvas). # Legado (18/11/2026, manhã): virou `dev.translation`. Ainda lido por `dev_flags` (camadas já salvas).
"translation": False, "translation": False,
}, },
@@ -180,7 +183,7 @@ def validate(settings: dict) -> dict:
cap = settings.get("caption") cap = settings.get("caption")
if cap is not None: if cap is not None:
o = {} o = {}
for key in ("color", "highlight", "outline"): for key in ("color", "highlight", "outline", "otherColor"):
if key in cap: if key in cap:
if not HEX_RE.match(str(cap[key])): if not HEX_RE.match(str(cap[key])):
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB") raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
@@ -194,6 +197,10 @@ def validate(settings: dict) -> dict:
o[key] = int(cap[key]) o[key] = int(cap[key])
if not lo <= o[key] <= hi: if not lo <= o[key] <= hi:
raise LayoutError(f"caption.{key} vai de {lo} a {hi}") raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
if "otherSize" in cap:
o["otherSize"] = None if cap["otherSize"] in (None, "") else int(cap["otherSize"])
if o["otherSize"] is not None and not 30 <= o["otherSize"] <= 140:
raise LayoutError("caption.otherSize vai de 30 a 140 ou null = automático (85 % do tamanho)")
if "y" in cap: if "y" in cap:
o["y"] = None if cap["y"] is None else float(cap["y"]) o["y"] = None if cap["y"] is None else float(cap["y"])
if o["y"] is not None and not 0.08 <= o["y"] <= 0.9: if o["y"] is not None and not 0.08 <= o["y"] <= 0.9:
+9
View File
@@ -410,6 +410,8 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
at, frame = _frame(row, body.t, "preview-src.jpg", width=0) at, frame = _frame(row, body.t, "preview-src.jpg", width=0)
# Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda. # Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda.
sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())] sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
# E a fala de outra pessoa (colega no Discord), na linha de baixo, com a cor dela (FALANTES.md).
sample += [Word(0.05 + i * 0.35, 0.35 + i * 0.35, w, "other1") for i, w in enumerate("E A DO COLEGA".split())]
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg) ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
out = settings.clips_dir / str(row["id"]) / "preview.jpg" out = settings.clips_dir / str(row["id"]) / "preview.jpg"
try: try:
@@ -438,6 +440,13 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
raise UserError("`to` precisa ser maior que `from`.") raise UserError("`to` precisa ser maior que `from`.")
return engine.face.view(_session(session_id), from_, to) return engine.face.view(_session(session_id), from_, to)
@app.get("/v1/sessions/{session_id}/speakers")
def get_speakers(session_id: int):
"""Vozes da sessão (doc/clipador/FALANTES.md): quantas, qual é o streamer e por quê (boca/volume), fala por
rótulo. `active: false` = sem prova suficiente: tudo fica como do streamer."""
_session(session_id)
return engine.speakers.view(session_id)
@app.post("/v1/sessions/{session_id}/face/reset") @app.post("/v1/sessions/{session_id}/face/reset")
def reset_face(session_id: int): def reset_face(session_id: int):
"""Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco """Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco
+3
View File
@@ -90,6 +90,9 @@ class Word:
start: float start: float
end: float end: float
word: str word: str
# Quem falou (doc/clipador/FALANTES.md): "" ou "streamer" = o streamer; "other1", "other2"… = outra pessoa (colega no
# Discord, voz do jogo). Vazio = não atribuído — conta como streamer (o comportamento de antes).
speaker: str = ""
@dataclass @dataclass
+498
View File
@@ -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": []})}
+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; 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 - `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). 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 __future__ import annotations
from . import layout from . import layout
from .scoring import Word 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 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 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)) end = max(w.end, round(start + MIN_WORD_S, 3))
if out and out[-1].end > start + 1e-9: if out and out[-1].end > start + 1e-9:
prev = out[-1] 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() text = w.word.strip()
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word 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 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]]: def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
"""Blocos da legenda (palavras já saneadas por `clean_words`).""" """Blocos da legenda (palavras já saneadas por `clean_words`)."""
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS) max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
groups: list[list[Word]] = [] groups: list[list[Word]] = []
for word in clean_words(words): for word in clean_words(words):
current = groups[-1] if groups else None 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 fits = len(" ".join(w.word for w in current + [word])) <= max_chars
room = len(current) < max_words or ( room = len(current) < max_words or (
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler. # 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]]: 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 """(palavras do bloco, fim do bloco), em ordem de início. Cada faixa (streamer / outra pessoa; ver `lane`) é
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro).""" agrupada sozinha e um bloco nunca mistura falantes. O fim nunca passa do início do bloco seguinte DA MESMA FAIXA:
groups = group_words(words, max_words) 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 = [] out = []
for k, group in enumerate(groups): for name in (STREAMER_LANE, OTHER_LANE):
end = max(group[-1].end, group[-1].start + MIN_HOLD_S) groups = group_words([w for w in words if lane(w.speaker) == name], max_words)
if k + 1 < len(groups): for k, group in enumerate(groups):
end = min(end, groups[k + 1][0].start) end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
out.append((group, round(end, 3))) 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 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 PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16
_SENTENCE_END = (".", "?", "!") _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 """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.""" (. ? !) 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]] = [] Uma frase nunca mistura falantes (quem fala junto vira frase própria). `with_speaker` = devolve
current: list[Word] = [] (início, fim, texto, falante), com falante "streamer" ou "otherN"."""
for w in clean_words(words): out: list[tuple] = []
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 def flush(current: list[Word]) -> None:
or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)): item = (current[0].start, current[-1].end, " ".join(x.word for x in current))
out.append((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)
current = []
current.append(w) by_speaker: dict[str, list[Word]] = {}
if current: for w in words:
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current))) 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 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"] cap, cred = cfg["caption"], cfg["credit"]
duration = clip_end - clip_start duration = clip_end - clip_start
inside = [ 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 for w in words
if w.end > clip_start and w.start < clip_end 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"]) 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) credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
width, height = layout.canvas_size(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] header = f"""[Script Info]
ScriptType: v4.00+ ScriptType: v4.00+
PlayResX: {width} PlayResX: {width}
@@ -140,7 +209,7 @@ ScaledBorderAndShadow: yes
[V4+ Styles] [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 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: 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] [Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text 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"]: if credit and cred["enabled"]:
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}") lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
if cap["enabled"]: if cap["enabled"]:
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}" y = layout.caption_y(cfg)
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"]) 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"]): 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): for i, word in enumerate(group):
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada. # Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
start = word.start start = word.start
@@ -163,5 +240,5 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
for j, w in enumerate(group): for j, w in enumerate(group):
text = _escape(w.word.upper() if cap["uppercase"] else w.word) text = _escape(w.word.upper() if cap["uppercase"] else w.word)
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text) 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" return header + "\n".join(lines) + "\n"
+100
View File
@@ -0,0 +1,100 @@
"""Impressão de voz (embedding de falante) para o Clipador: fbank no estilo Kaldi em numpy + WeSpeaker ResNet34-LM
(ONNX, CC-BY-4.0) no onnxruntime. Só E/S de modelo e conta numérica; a decisão de quem fala mora em `speakers.py`.
- Modelo: `voxceleb_resnet34_LM.onnx` do repositório Wespeaker/wespeaker-voxceleb-resnet34-LM (Hugging Face, commit
fixo no `models.lock.json`, licença CC-BY-4.0 — uso comercial permitido com atribuição; ver doc/clipador/FALANTES.md).
- Entrada do modelo: fbank 80 bandas, janela 25 ms / passo 10 ms, 16 kHz, com a média de cada trecho subtraída (CMN),
igual ao `compute_fbank` do WeSpeaker. Saída: vetor de 256, normalizado aqui (comparação por cosseno).
Nada daqui importa numpy/onnxruntime na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
"""
from __future__ import annotations
import math
import threading
from pathlib import Path
from typing import Any
SAMPLE_RATE = 16_000
FRAME_LEN, FRAME_SHIFT, N_FFT, N_MELS = 400, 160, 512, 80
PREEMPH = 0.97
MIN_SAMPLES = FRAME_LEN + FRAME_SHIFT * 20 # ~0,2 s: menos que isso não vira vetor
class VoiceprintUnavailable(RuntimeError):
"""numpy/onnxruntime ou o modelo faltando: a atribuição de falante fica de fora (tudo `streamer`)."""
_mel_cache: dict[int, Any] = {}
def _mel_banks(np: Any) -> Any:
"""Banco de filtros triangulares na escala mel do Kaldi (20 Hz até Nyquist), 80 × 257."""
if N_MELS in _mel_cache:
return _mel_cache[N_MELS]
def mel(f: Any) -> Any:
return 1127.0 * np.log(1.0 + f / 700.0)
lo, hi = mel(np.float64(20.0)), mel(np.float64(SAMPLE_RATE / 2))
centers = np.linspace(lo, hi, N_MELS + 2)
bins = mel(np.arange(N_FFT // 2 + 1) * SAMPLE_RATE / N_FFT)
banks = np.zeros((N_MELS, N_FFT // 2 + 1), np.float32)
for m in range(N_MELS):
left, center, right = centers[m], centers[m + 1], centers[m + 2]
up = (bins - left) / (center - left)
down = (right - bins) / (right - center)
banks[m] = np.maximum(0.0, np.minimum(up, down))
_mel_cache[N_MELS] = banks
return banks
def fbank(samples: Any) -> Any:
"""Fbank Kaldi (snip_edges, janela povey, pré-ênfase 0,97, sem dither) de amostras int16/float na escala int16.
Devolve (quadros × 80) float32 já com a média subtraída (CMN), como o WeSpeaker espera."""
import numpy as np
x = np.asarray(samples, dtype=np.float64)
n = 1 + (len(x) - FRAME_LEN) // FRAME_SHIFT
if n < 1:
return np.zeros((0, N_MELS), np.float32)
idx = np.arange(FRAME_LEN)[None, :] + FRAME_SHIFT * np.arange(n)[:, None]
frames = x[idx]
frames = frames - frames.mean(axis=1, keepdims=True) # tira o nível DC
frames = np.concatenate([frames[:, :1] * (1 - PREEMPH), frames[:, 1:] - PREEMPH * frames[:, :-1]], axis=1)
window = (0.5 - 0.5 * np.cos(2 * math.pi * np.arange(FRAME_LEN) / (FRAME_LEN - 1))) ** 0.85 # povey
spec = np.abs(np.fft.rfft(frames * window, N_FFT)) ** 2
feats = np.log(np.maximum(spec @ _mel_banks(np).T.astype(np.float64), np.finfo(np.float32).eps))
feats = feats - feats.mean(axis=0, keepdims=True)
return feats.astype(np.float32)
class Voiceprint:
"""Sessão ONNX do WeSpeaker. Um por motor; `embed` é seguro entre threads (trinco)."""
def __init__(self, model_path: Path, threads: int = 2):
try:
import numpy as np
import onnxruntime as ort
except ImportError as exc: # pragma: no cover - depende da instalação
raise VoiceprintUnavailable("numpy/onnxruntime não instalados (rode o setup.bat)") from exc
if not Path(model_path).is_file():
raise VoiceprintUnavailable(f"modelo de voz ausente: {model_path}")
opts = ort.SessionOptions()
opts.intra_op_num_threads, opts.inter_op_num_threads = threads, 1
self._np = np
self._sess = ort.InferenceSession(str(model_path), sess_options=opts, providers=["CPUExecutionProvider"])
self._input = self._sess.get_inputs()[0].name
self._lock = threading.Lock()
def embed(self, samples: Any) -> list[float] | None:
"""Vetor de 256 (norma 1) de um trecho de fala; None se curto demais."""
np = self._np
if len(samples) < MIN_SAMPLES:
return None
feats = fbank(samples)
with self._lock:
out = self._sess.run(None, {self._input: feats[None]})[0][0]
norm = float(np.linalg.norm(out))
return (out / norm).astype(np.float32).tolist() if norm > 0 else None
+28 -9
View File
@@ -40,6 +40,7 @@ from .intel import Intel
from .judge import Judge, JudgeError, analysis_block, build_prompt from .judge import Judge, JudgeError, analysis_block, build_prompt
from .scoring import ChatMessage, Params, Word, find_moments, overlaps from .scoring import ChatMessage, Params, Word, find_moments, overlaps
from .sources import Source, parse_source from .sources import Source, parse_source
from .speakers import SpeakerService, dump_words, parse_words
from .subtitles import build_ass, phrases from .subtitles import build_ass, phrases
log = logging.getLogger("cenaforge_clipper") log = logging.getLogger("cenaforge_clipper")
@@ -353,6 +354,7 @@ class Engine:
self._threads: list[threading.Thread] = [] self._threads: list[threading.Thread] = []
self.intel = Intel(self) self.intel = Intel(self)
self.face = FaceService(self) # rastreio do rosto do streamer (face.py); não carrega modelo aqui self.face = FaceService(self) # rastreio do rosto do streamer (face.py); não carrega modelo aqui
self.speakers = SpeakerService(self) # quem fala cada palavra (speakers.py); modelo de voz só no 1º bloco
self.resume_delays: tuple[float, ...] = RESUME_DELAYS_S # os testes encurtam self.resume_delays: tuple[float, ...] = RESUME_DELAYS_S # os testes encurtam
self._recovering: set[int] = set() # sessões com uma thread de retomada em andamento self._recovering: set[int] = set() # sessões com uma thread de retomada em andamento
self._rendering: set[int] = set() # cortes que ESTE processo está renderizando agora self._rendering: set[int] = set() # cortes que ESTE processo está renderizando agora
@@ -754,12 +756,18 @@ class Engine:
for w in rel_words] for w in rel_words]
except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat
error = str(exc)[:300] error = str(exc)[:300]
if words:
try:
# Impressão de voz de cada trecho de fala (doc/clipador/FALANTES.md): ~0,2 s de CPU por bloco.
self.speakers.index_block(segment, pcm, words)
except Exception as exc: # noqa: BLE001 - sem falantes a legenda segue toda como do streamer
self.speakers.last_error = str(exc)[:300]
log.warning("falantes do bloco %s/%s: %s", segment["session_id"], segment["idx"], exc)
except media.MediaError as exc: except media.MediaError as exc:
error = f"áudio: {exc}"[:300] error = f"áudio: {exc}"[:300]
self.db.run( self.db.run(
"UPDATE segments SET analyzed = 1, loudness_json = ?, words_json = ?, transcript_error = ? WHERE session_id = ? AND idx = ?", "UPDATE segments SET analyzed = 1, loudness_json = ?, words_json = ?, transcript_error = ? WHERE session_id = ? AND idx = ?",
json.dumps(loudness), json.dumps([[w.start, w.end, w.word] for w in words], ensure_ascii=False), error, json.dumps(loudness), dump_words(words), error, segment["session_id"], segment["idx"])
segment["session_id"], segment["idx"])
# ---------- linha do tempo de uma sessão # ---------- linha do tempo de uma sessão
def load_timeline(self, session_id: int, since_s: float = 0.0) -> dict: def load_timeline(self, session_id: int, since_s: float = 0.0) -> dict:
@@ -775,7 +783,7 @@ class Engine:
if seg["analyzed"]: if seg["analyzed"]:
if analyzed_until >= seg["start_s"] - 0.01: # só o trecho contínuo desde o início conta if analyzed_until >= seg["start_s"] - 0.01: # só o trecho contínuo desde o início conta
analyzed_until = seg["end_s"] analyzed_until = seg["end_s"]
words.extend(Word(a, b, c) for a, b, c in loads(seg["words_json"], [])) words.extend(parse_words(seg["words_json"]))
chat = [] chat = []
if segments: if segments:
first_wall = segments[0]["wall_end"] - (segments[0]["end_s"] - segments[0]["start_s"]) first_wall = segments[0]["wall_end"] - (segments[0]["end_s"] - segments[0]["start_s"])
@@ -789,9 +797,17 @@ class Engine:
continue continue
emotes = tuple(loads(r["emotes"], [])) emotes = tuple(loads(r["emotes"], []))
chat.append(ChatMessage(t, r["text"], r["user"], emotes, self.intel.bonus(list(emotes), key))) chat.append(ChatMessage(t, r["text"], r["user"], emotes, self.intel.bonus(list(emotes), key)))
# Quem fala cada palavra (streamer × outra pessoa): juízes, tradução e legenda leem daqui.
words = self.speakers.label(session_id, words)
return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat, return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat,
"analyzedUntil": analyzed_until} "analyzedUntil": analyzed_until}
def words_between(self, session_id: int, lo: float, hi: float) -> list[Word]:
"""Palavras dos blocos que tocam [lo, hi] (sem filtrar o tempo de cada palavra), já com o falante."""
rows = self.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
session_id, lo, hi)
return self.speakers.label(session_id, [w for r in rows for w in parse_words(r["words_json"])])
# ---------- cortes # ---------- cortes
def _clip_loop(self) -> None: def _clip_loop(self) -> None:
while not self.stop_event.is_set(): while not self.stop_event.is_set():
@@ -816,7 +832,7 @@ class Engine:
return 0 return 0
offset = int(since) offset = int(since)
chat = [replace(m, t=m.t - offset) for m in tl["chat"] if m.t >= offset] chat = [replace(m, t=m.t - offset) for m in tl["chat"] if m.t >= offset]
words = [Word(w.start - offset, w.end - offset, w.word) for w in tl["words"] if w.start >= offset] words = [replace(w, start=w.start - offset, end=w.end - offset) for w in tl["words"] if w.start >= offset]
face, face_until = self.face.for_scoring(session, offset, tl["duration"]) # None = sem câmera/rastreio face, face_until = self.face.for_scoring(session, offset, tl["duration"]) # None = sem câmera/rastreio
# O candidato já nasce na duração da configuração do corte desta sessão (padrão 60–90 s). # O candidato já nasce na duração da configuração do corte desta sessão (padrão 60–90 s).
dur = self.intel.settings_for(session)["duration"] dur = self.intel.settings_for(session)["duration"]
@@ -980,20 +996,23 @@ class Engine:
hi = clip["end_s"] if hi is None else hi hi = clip["end_s"] if hi is None else hi
current = loads(clip.get("translation_json"), None) current = loads(clip.get("translation_json"), None)
if (isinstance(current, dict) and not force and current.get("startS", 1e12) <= lo + 0.5 if (isinstance(current, dict) and not force and current.get("startS", 1e12) <= lo + 0.5
and current.get("endS", -1) >= hi - 0.5): and current.get("endS", -1) >= hi - 0.5
and all("speaker" in line for line in current.get("lines") or [])): # antiga, sem falante: refaz
return current return current
tl = self.load_timeline(session["id"], max(0.0, lo - 30)) tl = self.load_timeline(session["id"], max(0.0, lo - 30))
items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi]) # Frases que nunca misturam falantes (doc/clipador/FALANTES.md); cada linha diz quem fala (`speaker`:
# "streamer" ou "otherN") — a legenda de desenvolvimento e a dublagem escolhem posição e voz por ela.
items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi], with_speaker=True)
if not items: if not items:
return None return None
try: try:
pt = self.judge.translate_lines([text for _, _, text in items]) pt = self.judge.translate_lines([text for _, _, text, _ in items])
except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc:
log.warning("tradução da fala do corte %s falhou: %s", clip_id, exc) log.warning("tradução da fala do corte %s falhou: %s", clip_id, exc)
return None return None
data = {"language": "pt-BR", "startS": round(lo, 2), "endS": round(hi, 2), "model": self.judge.responder(), data = {"language": "pt-BR", "startS": round(lo, 2), "endS": round(hi, 2), "model": self.judge.responder(),
"lines": [{"s": round(s, 3), "e": round(e, 3), "text": text, "pt": tr} "lines": [{"s": round(s, 3), "e": round(e, 3), "text": text, "pt": tr, "speaker": speaker}
for (s, e, text), tr in zip(items, pt)]} for (s, e, text, speaker), tr in zip(items, pt)]}
self.db.run("UPDATE clips SET translation_json = ? WHERE id = ?", json.dumps(data, ensure_ascii=False), clip_id) self.db.run("UPDATE clips SET translation_json = ? WHERE id = ?", json.dumps(data, ensure_ascii=False), clip_id)
return data return data
+11 -1
View File
@@ -1,5 +1,5 @@
{ {
"_comment": "Pesos do rastreio de reação do Clipador. Baixados para data/clipper/models/ pelo scripts/setup.ps1 (passo 6b) e conferidos pelo sha256. URLs imutáveis (commit fixo ou caminho versionado). Bancada: doc/FACE_BAKEOFF.md.", "_comment": "Pesos do rastreio de reação e da atribuição de falante do Clipador. Baixados para data/clipper/models/ pelo scripts/setup.ps1 (passo 6b) e conferidos pelo sha256. URLs imutáveis (commit fixo ou caminho versionado). Bancada: doc/FACE_BAKEOFF.md. Falantes: doc/clipador/FALANTES.md.",
"dir": "data/clipper/models", "dir": "data/clipper/models",
"models": [ "models": [
{ {
@@ -41,6 +41,16 @@
"size": 568302, "size": 568302,
"license": "BSD-2-Clause", "license": "BSD-2-Clause",
"source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251" "source": "github.com/emilianavt/OpenSeeFace@50c09741897010faad721a218b2bbe14ecad6251"
},
{
"id": "wespeaker_r34",
"file": "wespeaker_voxceleb_resnet34_LM.onnx",
"role": "impressão de voz (falante): fbank 80 → vetor de 256 (WeSpeaker ResNet34-LM, VoxCeleb); quem fala cada palavra",
"url": "https://huggingface.co/Wespeaker/wespeaker-voxceleb-resnet34-LM/resolve/f0c48c298fd835726c27956a5d617bad7115627e/voxceleb_resnet34_LM.onnx",
"sha256": "7bb2f06e9df17cdf1ef14ee8a15ab08ed28e8d0ef5054ee135741560df2ec068",
"size": 26530309,
"license": "CC-BY-4.0",
"source": "huggingface.co/Wespeaker/wespeaker-voxceleb-resnet34-LM@f0c48c298fd835726c27956a5d617bad7115627e (atribuição: WeSpeaker, wenet-e2e)"
} }
] ]
} }
+8
View File
@@ -327,3 +327,11 @@ def test_preview_and_queue_render_dub_the_same_way(api, monkeypatch):
assert clip["status"] == "ready", clip["error"] assert clip["status"] == "ready", clip["error"]
# Fila: a 1ª fala veio do cache da prévia; a do "other" saiu com a segunda voz. # Fila: a 1ª fala veio do cache da prévia; a do "other" saiu com a segunda voz.
assert synth.calls == [(layout.DUB_VOICE, "Não acredito."), (layout.DUB_VOICE_OTHER, "Mano.")] assert synth.calls == [(layout.DUB_VOICE, "Não acredito."), (layout.DUB_VOICE_OTHER, "Mano.")]
def test_numbered_other_speakers_use_the_second_voice():
"""Integração com FALANTES.md: a separação entrega `other1`, `other2`…; todas usam a segunda voz."""
from app.dub import voice_for
opts = {"voice": "a", "voiceOther": "b"}
assert voice_for({"speaker": "other1"}, opts) == "b" and voice_for({"speaker": "other2"}, opts) == "b"
assert voice_for({"speaker": "streamer"}, opts) == "a" and voice_for({}, opts) == "a"
+389
View File
@@ -0,0 +1,389 @@
"""Quem fala cada palavra (doc/clipador/FALANTES.md): atribuição por voz + boca/volume, legenda em duas linhas sem
misturar falantes, tradução com `speaker`, juiz com a fala marcada e compatibilidade com `words_json` antigo."""
import json
import re
import numpy as np
import pytest
from app import editor, editor_render, layout, subtitles
from app import speakers as spk
from app.face import FaceService
from app.judge import _transcript
from app.scoring import Word
from app.speakers import STREAMER, SpeakerService, VoiceChunk
from .test_editor import validate
from .test_english_source import EnglishJudge, _english_session
from .test_face import CAM, fake_reader, set_cam
from .test_face import FakeTracker
from .test_render_and_duplicates import add_clip
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
A, B, C = np.eye(256, dtype=np.float32)[0], np.eye(256, dtype=np.float32)[1], np.eye(256, dtype=np.float32)[2]
def _noisy(vec, k):
"""Vetor de voz com um pouco de ruído (a mesma voz nunca dá o mesmo vetor duas vezes)."""
rng = np.random.default_rng(k)
v = vec + rng.normal(0, 0.02, 256).astype(np.float32)
return v / np.linalg.norm(v)
def _conversation(n=12, length=2.0, db_streamer=-28.0, db_other=-36.0):
"""Trechos alternados: streamer (voz A) e colega (voz B), `n` de cada."""
out = []
for i in range(n):
out.append(VoiceChunk(i * 6.0, i * 6.0 + length, db_streamer, _noisy(A, i)))
out.append(VoiceChunk(i * 6.0 + 3.0, i * 6.0 + 3.0 + length, db_other, _noisy(B, 100 + i)))
return out
# ---------------------------------------------------------------- dados / compatibilidade
def test_words_json_old_and_new_format():
old = json.dumps([[1.0, 1.4, "olha"], [1.5, 1.9, "isso"]])
words = spk.parse_words(old)
assert words == [Word(1.0, 1.4, "olha"), Word(1.5, 1.9, "isso")] and words[0].speaker == ""
new = spk.parse_words(json.dumps([[1.0, 1.4, "olha", "streamer"], [2.0, 2.3, "bro", "other1"], [3, 3.1, "x", ""]]))
assert [w.speaker for w in new] == ["streamer", "other1", ""]
# Sem falante, o formato gravado continua o antigo (3 elementos); com falante, 4.
assert json.loads(spk.dump_words(words)) == [[1.0, 1.4, "olha"], [1.5, 1.9, "isso"]]
assert json.loads(spk.dump_words(new))[1] == [2.0, 2.3, "bro", "other1"]
assert spk.parse_words(None) == [] and spk.parse_words("[[1, 2]]") == []
def test_speech_chunks_split_on_pause_and_length():
words = [Word(0.0, 0.4, "a"), Word(0.5, 0.9, "b"), Word(1.5, 1.8, "c"), Word(1.85, 2.0, "d")]
assert spk.speech_chunks(words) == [(0.0, 0.9), (1.5, 2.0)]
long = [Word(i * 0.3, i * 0.3 + 0.28, "w") for i in range(20)] # 6 s de fala corrida
chunks = spk.speech_chunks(long)
assert len(chunks) == 2 and all(b - a <= spk.CHUNK_MAX_S for a, b in chunks)
# Fim de frase fecha o trecho (a vez costuma trocar ali, mesmo sem pausa); frase curtinha não.
turn = [Word(0.0, 0.3, "bring"), Word(0.32, 0.6, "two."), Word(0.62, 0.8, "Ok."), Word(0.82, 1.0, "yes")]
assert spk.speech_chunks(turn) == [(0.0, 0.6), (0.62, 1.0)]
# ---------------------------------------------------------------- atribuição (vetores sintéticos)
def test_two_voices_streamer_by_loudness():
model = spk.build_model(_conversation())
assert model.active and len(model.voices) == 2 and model.reason.startswith("volume")
labels = [c.label for c in model.chunks]
assert labels == ["streamer", "other1"] * 12
def test_mouth_series_picks_the_streamer_even_when_quieter():
# Colega mais ALTO que o streamer (volume enganaria), mas a boca do streamer mexe nos trechos dele.
chunks = _conversation(db_streamer=-36.0, db_other=-29.0)
mine = {round(c.start, 1) for c in chunks if c.vec[0] > 0.5}
def mouth_of(a, b):
rng = np.random.default_rng(int(a * 10))
return float(0.30 + rng.normal(0, 0.02)) if round(a, 1) in mine else float(0.12 + rng.normal(0, 0.02))
model = spk.build_model(chunks, mouth_of)
# Boca e volume discordam → ninguém vira "outro" (seguro: fica tudo como do streamer).
assert not model.active and "apontam vozes diferentes" in model.reason
assert {c.label for c in model.chunks} == {STREAMER}
# Sem volume (sem prova do áudio), a boca decide sozinha.
for c in chunks:
c.db = None
model = spk.build_model(chunks, mouth_of)
assert model.active and model.reason.startswith("boca")
assert [c.label for c in model.chunks] == ["streamer", "other1"] * 12
def test_no_proof_or_single_voice_keeps_everything_as_streamer():
flat = _conversation(db_streamer=-30.0, db_other=-31.0) # 1 dB de diferença e sem câmera
model = spk.build_model(flat)
assert not model.active and {c.label for c in model.chunks} == {STREAMER}
solo = [VoiceChunk(i * 3.0, i * 3.0 + 2.0, -30.0, _noisy(A, i)) for i in range(20)]
model = spk.build_model(solo)
assert len(model.voices) == 1 and not model.active
words = [Word(0.2, 0.5, "oi")]
assert spk.label_words(words, model.chunks) == words # nada muda
def test_three_voices_are_numbered_and_short_chunks_follow_the_neighbor():
chunks = _conversation()
chunks += [VoiceChunk(200 + i * 4.0, 202 + i * 4.0, -37.0, _noisy(C, 300 + i)) for i in range(10)]
chunks.append(VoiceChunk(5.2, 5.5, -36.0, None)) # curto (sem vetor), logo depois do colega (3–5 s)
model = spk.build_model(chunks)
assert [v.label for v in model.voices] == ["streamer", "other1", "other2"]
words = [Word(0.1, 0.5, "yo"), Word(3.2, 3.6, "bro"), Word(5.25, 5.45, "ok"), Word(201.0, 201.4, "hey"),
Word(150.0, 150.3, "longe")]
got = [w.speaker for w in spk.label_words(words, model.chunks)]
assert got == ["streamer", "other1", "other1", "other2", "streamer"]
# Palavra que já veio com falante (4º elemento) não é trocada.
assert spk.label_words([Word(3.2, 3.6, "bro", "streamer")], model.chunks)[0].speaker == "streamer"
def test_transfer_keeps_speaker_on_retranscription():
old = [Word(1.0, 1.5, "a", "streamer"), Word(3.0, 3.5, "b", "other1")]
new = spk.transfer([Word(1.1, 1.4, "A"), Word(3.1, 3.3, "B")], old)
assert [w.speaker for w in new] == ["streamer", "other1"]
# ---------------------------------------------------------------- serviço (banco + embedder falso)
class FakeEmbedder:
"""Voz pelo volume do trecho: alto = voz A (streamer), baixo = voz B (colega)."""
def embed(self, samples):
if len(samples) < 8000:
return None
loud = float(np.sqrt(np.mean(samples.astype(np.float64) ** 2)))
return _noisy(A if loud > 4000 else B, int(loud)).tolist()
def _block_audio(start_s):
"""30 s: streamer (amplitude 8000) em [i·6, i·6+2] e colega (2000) em [i·6+3, i·6+5]; palavras nos mesmos tempos."""
sr = 16000
pcm = np.zeros(30 * sr, np.int16)
words = []
rng = np.random.default_rng(int(start_s))
for i in range(5):
for off, amp, text in ((0.0, 8000, "me"), (3.0, 2000, "you")):
a = i * 6.0 + off
pcm[int(a * sr): int((a + 2.0) * sr)] = (rng.standard_normal(int(2.0 * sr)) * amp).astype(np.int16)
words += [Word(start_s + a + k * 0.4, start_s + a + k * 0.4 + 0.35, text) for k in range(5)]
return pcm.tobytes(), words
def test_service_indexes_blocks_and_labels_the_timeline(env): # noqa: F811
_client, engine = env
engine.speakers = SpeakerService(engine, embedder_factory=FakeEmbedder)
sid = seed_session(engine, duration=120)
assert engine.speakers.view(sid)["active"] is False # nada indexado ainda
for seg in engine.db.all("SELECT * FROM segments WHERE session_id = ? ORDER BY idx", sid):
pcm, words = _block_audio(seg["start_s"])
assert engine.speakers.index_block(seg, pcm, words) == 10
engine.db.run("UPDATE segments SET words_json = ? WHERE session_id = ? AND idx = ?",
spk.dump_words(words), sid, seg["idx"])
view = engine.speakers.view(sid)
assert view["active"] and view["streamer"] == "streamer" and len(view["voices"]) == 2
words = engine.load_timeline(sid)["words"]
assert {w.speaker for w in words if w.word == "me"} == {"streamer"}
assert {w.speaker for w in words if w.word == "you"} == {"other1"}
# O mesmo vale para as palavras que o editor lê.
between = engine.words_between(sid, 0, 30)
assert {w.speaker for w in between if w.word == "you"} == {"other1"}
# Desligado (opção `speakers`), tudo volta a ser como antes.
engine.intel.opts["speakers"] = False
assert {w.speaker for w in engine.load_timeline(sid)["words"]} == {""}
def test_face_block_stores_mouth_series(env): # noqa: F811
_client, engine = env
class Meter:
def feed(self, rgb):
return 0.2
service = FaceService(engine, store=object(), tracker_factory=lambda _b=None: FakeTracker(), detector_factory=None,
reader=fake_reader, grabber=None, sizer=lambda _f: (1280, 720), mouth_factory=Meter)
engine.face = service
sid = seed_session(engine, duration=60)
set_cam(engine, sid, CAM)
assert service.step() is True
data = json.loads(engine.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND idx = 0", sid)["data_json"])
assert len(data["mouth"]) == 180 and data["mouth"][0] == 0.2
# Sem medidor (store falso, sem YuNet): o bloco sai igual ao de antes, sem `mouth`.
service._mouth_factory = lambda: (_ for _ in ()).throw(RuntimeError("sem yunet"))
assert service.step() is True
data = json.loads(engine.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND idx = 1", sid)["data_json"])
assert "mouth" not in data and data["frames"] == 180
# ---------------------------------------------------------------- legenda
def _dialogue(ass: str) -> list[tuple[float, float, str, str]]:
out = []
for line in ass.splitlines():
if line.startswith("Dialogue: 0,"):
parts = line.split(",", 9)
h, m, s = parts[1].split(":")
a = int(h) * 3600 + int(m) * 60 + float(s)
h, m, s = parts[2].split(":")
b = int(h) * 3600 + int(m) * 60 + float(s)
out.append((a, b, parts[3], parts[9]))
return out
def _ypos(text: str) -> int:
return int(re.search(r"\\pos\(\d+,(\d+)\)", text).group(1))
TALK = [Word(1.0, 1.3, "olha"), Word(1.35, 1.6, "isso"), Word(1.62, 1.9, "mano"),
Word(1.7, 2.0, "for", "other1"), Word(2.05, 2.4, "real", "other1"), Word(2.5, 2.9, "bro", "other1"),
Word(3.0, 3.3, "caiu"), Word(3.35, 3.7, "aqui")]
def test_caption_blocks_never_mix_speakers_and_overlap_only_across_lanes():
blocks = subtitles.caption_blocks(TALK, 3)
for group, _end in blocks:
assert len({w.speaker or STREAMER for w in group}) == 1
lanes = {"streamer": [], "other": []}
for group, end in blocks:
lanes[subtitles.lane(group[0].speaker)].append((group[0].start, end))
for spans in lanes.values(): # dentro da faixa, nunca dois blocos ao mesmo tempo
assert all(a1 <= a2 and e1 <= a2 + 1e-9 for (a1, e1), (a2, _) in zip(spans, spans[1:]))
# As duas faixas se sobrepõem (os dois falando juntos em 1,7–1,9 s).
(s_a, s_e), (o_a, o_e) = lanes["streamer"][0], lanes["other"][0]
assert o_a < s_e
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_build_ass_puts_the_other_speaker_below_in_another_color(aspect):
cfg = layout.merge({"format": {"aspect": aspect}, "caption": {"otherColor": "#00FF00"}})
ass = subtitles.build_ass(TALK, 0.0, 6.0, "", cfg)
assert "Style: CaptionOther," in ass and "&H0000FF00&" in ass
events = _dialogue(ass)
mine = [e for e in events if e[2] == "Caption"]
other = [e for e in events if e[2] == "CaptionOther"]
assert mine and other
y, oy = _ypos(mine[0][3]), _ypos(other[0][3])
assert y == layout.caption_y(cfg) and oy > y # embaixo
assert all("FOR" in e[3] or "REAL" in e[3] or "BRO" in e[3] for e in other)
assert not any("OLHA" in e[3] for e in other) and not any("BRO" in e[3] for e in mine)
# Os dois na tela ao mesmo tempo (1,7–1,9 s), em alturas diferentes.
assert any(a < 1.85 < b for a, b, _, _ in mine) and any(a < 1.85 < b for a, b, _, _ in other)
# Só o streamer: o ASS é exatamente o de antes (sem o estilo novo).
solo = [Word(w.start, w.end, w.word) for w in TALK if not w.speaker]
assert "CaptionOther" not in subtitles.build_ass(solo, 0.0, 6.0, "", cfg)
def _project(tmp_path, words, **over):
p = {
"schema": 1, "source": {"sessionId": 1, "lo": 0, "hi": 60}, "settings": {},
"cuts": [{"start": 0, "end": 20, "mode": None}],
"captions": {"enabled": True, "preset": "pop", "style": {}, "emphColor": "#22E36B",
"words": [editor.word_item(w) for w in words]},
"overlays": [], "progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": False, "t": 1, "text": ""},
}
p.update(over)
return validate(p, tmp_path)
@pytest.mark.parametrize("preset", editor.CAPTION_PRESETS)
def test_project_ass_two_lines_for_every_preset(tmp_path, preset):
p = _project(tmp_path, TALK)
assert p["captions"]["words"][3]["sp"] == "other1" and "sp" not in p["captions"]["words"][0]
p["captions"]["preset"] = preset
cfg = editor.effective_settings(layout.merge(), p)
events = _dialogue(editor_render.build_project_ass(p, cfg, ""))
mine = [e for e in events if e[2] in ("Caption", "Karaoke")]
other = [e for e in events if e[2] in ("CaptionOther", "KaraokeOther")]
assert mine and other
assert min(_ypos(e[3]) for e in other) > max(_ypos(e[3]) for e in mine)
for group in (mine, other): # na mesma linha, nunca dois eventos ao mesmo tempo
spans = sorted((a, b) for a, b, _, _ in group)
assert all(b1 <= a2 + 0.011 for (_, b1), (a2, _) in zip(spans, spans[1:]))
def test_hook_dodge_moves_both_lines_and_translation_follows_speaker(tmp_path):
hook = {"id": "hook", "kind": "hook", "text": "NAO ACREDITO", "start": 0, "end": 3, "y": 0.74, "size": 70,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
p = _project(tmp_path, TALK, overlays=[hook])
cfg = editor.effective_settings(layout.merge({"dev": {"translation": True}}), p)
lines = [{"s": 1.0, "e": 1.9, "text": "olha isso mano", "pt": "olha isso", "speaker": "streamer"},
{"s": 1.7, "e": 2.9, "text": "for real bro", "pt": "sério mano", "speaker": "other1"}]
events = _dialogue(editor_render.build_project_ass(p, cfg, "", translation=lines))
cap_y = layout.caption_y(cfg)
mine = [e for e in events if e[2] == "Caption"]
other = [e for e in events if e[2] == "CaptionOther"]
trans = {e[3].split("}")[-1]: _ypos(e[3]) for e in events if e[2] == "Trans"}
# Gancho em cima da legenda nos 3 primeiros segundos: as duas linhas desviam juntas, a do colega embaixo.
y, oy = _ypos(mine[0][3]), _ypos(other[0][3])
assert y != cap_y and oy > y
hook_top = int(1920 * 0.74) - int(70 * 0.9)
hook_bottom = int(1920 * 0.74) + int(70 * 0.9)
assert y - 84 >= hook_bottom or oy + 60 <= hook_top
# Tradução de cada um embaixo da linha de quem fala, entre as duas a do streamer.
assert y < trans["olha isso"] < oy < trans["sério mano"]
def test_old_project_without_speaker_renders_like_before(tmp_path):
words = [Word(w.start, w.end, w.word) for w in TALK]
p = _project(tmp_path, words)
ass = editor_render.build_project_ass(p, editor.effective_settings(layout.merge(), p), "")
assert "CaptionOther" not in ass
assert {_ypos(e[3]) for e in _dialogue(ass)} == {layout.caption_y(layout.merge())}
def test_layout_validates_other_color_and_size():
assert layout.DEFAULTS["caption"]["otherColor"] == "#5CE1FF" and layout.DEFAULTS["caption"]["otherSize"] is None
ok = layout.validate({"caption": {"otherColor": "#ff00aa", "otherSize": 60}})["caption"]
assert ok == {"otherColor": "#FF00AA", "otherSize": 60}
assert layout.validate({"caption": {"otherSize": None}})["caption"]["otherSize"] is None
with pytest.raises(layout.LayoutError):
layout.validate({"caption": {"otherColor": "azul"}})
with pytest.raises(layout.LayoutError):
layout.validate({"caption": {"otherSize": 10}})
cap = layout.merge()["caption"]
assert subtitles.other_size(cap) == round(84 * 0.85)
assert subtitles.other_size({**cap, "otherSize": 50}) == 50
def test_project_rejects_bad_speaker(tmp_path):
p = _project(tmp_path, TALK)
p["captions"]["words"][0]["sp"] = "ninguém; drop"
with pytest.raises(editor.EditError):
validate(p, tmp_path)
# ---------------------------------------------------------------- tradução e juízes
def test_phrases_never_mix_speakers():
got = subtitles.phrases(TALK, with_speaker=True)
assert got == [(1.0, 1.9, "olha isso mano", "streamer"), (1.7, 2.9, "for real bro", "other1"),
(3.0, 3.7, "caiu aqui", "streamer")]
assert subtitles.phrases(TALK)[0] == (1.0, 1.9, "olha isso mano") # formato antigo continua
def test_translation_lines_get_speaker(env): # noqa: F811
client, engine = env
engine.judge = EnglishJudge()
sid = _english_session(engine)
words = [[281.0, 281.3, "No", "streamer"], [281.3, 281.6, "way", "streamer"], [281.6, 282.0, "bro.", "streamer"],
[282.1, 282.5, "Told", "other1"], [282.5, 283.0, "you.", "other1"]]
engine.db.run("UPDATE segments SET words_json = ? WHERE session_id = ? AND idx = 9", json.dumps(words), sid)
add_clip(engine, sid, 1, "candidate", 285, 270, 340)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 1"))
lines = json.loads(engine.db.get("SELECT translation_json FROM clips WHERE id = 1")["translation_json"])["lines"]
assert [(x["text"], x["speaker"]) for x in lines] == [("No way bro.", "streamer"), ("Told you.", "other1")]
# O juiz viu quem fala.
prompt = engine.judge.seen["judge"][1]
assert "] No way bro." in prompt and "[other1] Told you." in prompt and "Never attribute to" in prompt
# Tradução antiga (sem `speaker`) é refeita na próxima vez.
engine.db.run("UPDATE clips SET translation_json = ? WHERE id = 1",
json.dumps({"startS": 0, "endS": 1e6, "lines": [{"s": 1, "e": 2, "text": "x", "pt": "y"}]}))
before = len(engine.judge.translated)
engine.translate_clip(1)
assert len(engine.judge.translated) == before + 1
def test_judge_transcript_tags_only_when_someone_else_speaks():
plain = [Word(10.0, 10.3, "olha"), Word(10.4, 10.8, "isso")]
assert _transcript(plain, 0, 60, "pt", "Tfue") == "[10s] olha isso"
mixed = plain + [Word(11.0, 11.3, "bro", "other1"), Word(11.4, 11.8, "nice", "other1"), Word(12.0, 12.2, "ok")]
out = _transcript(mixed, 0, 60, "en", "Tfue").splitlines()
assert out[0].startswith("Each line is tagged") and "[Tfue]" in out[0]
assert out[1:] == ["[10s] [Tfue] olha isso", "[11s] [other1] bro nice", "[12s] [Tfue] ok"]
def test_voice_model_failure_waits_before_retrying(env): # noqa: F811
_client, engine = env
calls = []
def broken():
calls.append(1)
raise RuntimeError("sem rede")
engine.speakers = SpeakerService(engine, embedder_factory=broken)
sid = seed_session(engine, duration=60)
seg = engine.db.get("SELECT * FROM segments WHERE session_id = ? AND idx = 0", sid)
pcm, words = _block_audio(0.0)
for _ in range(3):
with pytest.raises(RuntimeError):
engine.speakers.index_block(seg, pcm, words)
assert len(calls) == 1 # não baixa o modelo a cada bloco
assert engine.load_timeline(sid)["words"][0].speaker == "" # sem voz indexada: como antes
+139
View File
@@ -0,0 +1,139 @@
# Clipador — quem fala cada palavra (streamer × outra pessoa)
Pedido do dono (18/11/2026):
> Está atribuindo ao streamer a fala de outro jogador. A gente vai separar: a legenda do streamer em cima e a de
> outra pessoa abaixo, com outra cor, como se fossem duas pessoas conversando.
O áudio da live é um canal só: microfone do streamer, colegas no Discord e outros jogadores no chat de voz do jogo
saem misturados, e o Whisper devolve as palavras sem dizer de quem são. Na câmera só aparece o streamer: as outras
vozes **não estão no vídeo**.
## Como funciona
| Etapa | Onde | Quando | Custo medido |
| --- | --- | --- | --- |
| Trechos de fala → impressão de voz (256 números) + volume (dBFS) | `speakers.index_block` + `voiceprint.py` | análise de cada bloco, logo depois do Whisper (thread da análise) | **0,19 s de CPU por bloco de 30 s** (máx. 0,67 s) |
| Movimento da boca do streamer, quadro a quadro | `face.MouthMeter` (YuNet) | rastreio do rosto de cada bloco (thread `face`), nos mesmos quadros já decodificados | **+0,5 s de CPU por bloco** |
| Vozes da sessão, qual é o streamer, rótulo de cada trecho | `speakers.build_model` | sob demanda (`load_timeline`, editor), em cache até chegar bloco novo | **0,05 s** (1 061 trechos, 72 min); 0,07 s com 6 400 trechos (~7 h) |
Por que assim: a parte cara (rede de voz) roda uma vez por bloco, em segundo plano, junto com o áudio que a análise já
decodificou; o agrupamento precisa da sessão inteira (as vozes só se separam com muitos trechos) e custa centésimos,
então é refeito na leitura — e o rótulo melhora sozinho conforme a live avança, sem reescrever nada no banco.
1. **Trechos**: palavras seguidas (vão ≤ 0,25 s), até 3 s, e fecha no fim de frase (`. ? !`) — numa conversa a vez
troca quase sempre ali, mesmo sem pausa. Trecho ≥ 0,5 s vira impressão de voz (com 0,1 s de folga de áudio).
2. **Vozes**: os trechos ≥ 1 s são agrupados pela voz (aglomerativo, cosseno ≥ 0,5 entre os centros; até 600
trechos espalhados na sessão). Grupo com ≥ 15 s de fala é uma voz. Funciona com qualquer número de colegas.
3. **Qual voz é o streamer** — duas provas:
- **boca**: a voz cujos trechos coincidem com mais movimento da boca dele na webcam (média de muitos trechos;
t de Welch ≥ 3 contra a segunda voz);
- **volume**: o microfone dele vem mais forte que o Discord/jogo (mediana ≥ 3 dB acima da segunda voz).
Concordam ou só uma decide → ela. **Discordam ou nenhuma decide → ninguém vira "outro"** (tudo como do
streamer, o comportamento de antes). Uma voz só (streamer sozinho) → nada muda.
4. **Cada trecho** vai para a voz mais parecida. Só vira `otherN` com folga: cosseno com a outra voz ≥ 0,30 e ≥ 0,10
acima do cosseno com o streamer (+0,05 nos dois para trecho < 1 s). Senão, streamer. Trecho curto sem impressão
herda o rótulo do trecho vizinho (até 1 s); longe de tudo, streamer.
`GET /v1/sessions/{id}/speakers` mostra as vozes, qual é o streamer e por quê. Opção `speakers` (`intel.opts`,
padrão ligada) desliga tudo.
## Dados
- `scoring.Word` ganhou `speaker: str = ""` (no fim, opcional): `""`/`"streamer"` = streamer; `"other1"`,
`"other2"`… = outra pessoa (numeradas pela quantidade de fala na sessão; a numeração pode mudar com a live).
- `segments.words_json` aceita o 4º elemento `[início, fim, texto, falante]`; o formato antigo (3) continua valendo e é
o que se grava hoje (`speakers.dump_words`). Falante gravado no 4º elemento tem prioridade sobre a atribuição.
- Tabela `voice_chunks (session_id, idx, data_json, updated_at)` — `{model, chunks: [{s, e, db, v}]}`, `v` = vetor em
float16/base64 (~5 KB por bloco, ~0,6 MB por hora). Criada com `CREATE TABLE IF NOT EXISTS` ao subir o serviço,
**fora** da lista de migrações: a v14 é de outra frente e ainda não está nesta branch; numa posição fixa da lista ela
viraria a v14 aqui. Quem integrar pode movê-la para a v15.
- `face_track.data_json.mouth`: série por quadro (6 qps) do movimento da boca; blocos antigos não têm (a prova da boca
só vale para blocos rastreados depois desta versão).
- Projeto do editor: cada palavra ganha `sp` (só quando atribuída). Projetos antigos, sem `sp`, saem iguais.
- Tradução (`clips.translation_json`): cada linha tem `speaker`; as frases nunca misturam falantes. Tradução antiga,
sem `speaker`, é refeita na próxima chamada.
## Legenda
- Duas faixas: a do streamer na posição normal; a de outra pessoa **logo abaixo** (`caption.otherColor`, padrão
`#5CE1FF`; `caption.otherSize`, padrão vazio = 85 % de `size`). A palavra falada continua com `highlight`.
- Um bloco nunca mistura falantes; "nunca dois blocos ao mesmo tempo" vale dentro de cada faixa. Os dois falando
juntos = as duas linhas na tela, cada uma com `\pos` próprio (o libass não empilha).
- Sem espaço embaixo (horizontal, legenda a 85 % da altura), a linha do streamer **sobe** o necessário: a ordem nunca
inverte. O gancho (`hook_dodges`) desvia as duas linhas juntas.
- Tradução de desenvolvimento (`dev.translation`): o português de cada um fica embaixo da linha de quem fala (a do
streamer entre as duas linhas).
- Estilos `CaptionOther`/`KaraokeOther` só entram no ASS quando o corte tem outra pessoa: corte só com o streamer sai
byte a byte igual (conferido pelo teste dourado do vertical).
- Painel: a configuração do corte tem "Fala de outra pessoa" (cor e tamanho); o editor marca o falante de cada
parágrafo da transcrição e o botão **Outra pessoa / É o streamer** corrige as palavras selecionadas; a prévia
(canvas) desenha as duas linhas; o modal mostra quem fala em "O que falam".
## Juízes
`judge._transcript`: com outra pessoa no trecho, cada linha diz quem fala (`[Tfue] …` / `[other1] …`) e vem a nota
"Never attribute to Tfue what someone else said" (em português nos prompts em português). Sem outra pessoa, a
transcrição sai igual à de antes.
## Licenças (conferidas em 18/11/2026)
| Peça | Licença | Onde conferi |
| --- | --- | --- |
| **WeSpeaker ResNet34-LM** (`voxceleb_resnet34_LM.onnx`, commit `f0c48c2…` do Hugging Face) — os PESOS | **CC-BY-4.0** (uso comercial permitido, pede atribuição: "WeSpeaker, wenet-e2e") | cartão do modelo `Wespeaker/wespeaker-voxceleb-resnet34-LM` (`license: cc-by-4.0`) e `docs/pretrained.md` do WeSpeaker ("o modelo segue a licença do conjunto de treino"; VoxCeleb = CC BY 4.0) |
| Código de fbank | nosso (reimplementação em numpy; conferida contra o `torchaudio.compliance.kaldi.fbank`: diferença máx. 0,00016) | — |
| YuNet (boca) | MIT (já no projeto) | `models.lock.json` |
Não usados: **pyannote**, **SpeechBrain ECAPA**, **NeMo TitaNet**, **Resemblyzer** — todos pedem PyTorch, que não está
no venv do Clipador (o modelo escolhido roda no `onnxruntime` que já existe). **3D-Speaker CAM++** (código
Apache-2.0): a página do modelo no ModelScope não abriu para conferir a licença dos pesos, então ficou de fora.
Nenhum pacote novo foi instalado; o modelo (26,5 MB) entra no `models.lock.json` com sha256 e é baixado pelo
`setup.ps1` ou sob demanda (`ModelStore`).
## Qualidade medida — sessão 15 (twitch.tv/tfue, inglês, dois colegas no Discord)
Medido só lendo o banco e os blocos da pasta principal (cópia em memória), 144 blocos (~72 min), com o código desta
versão.
**A boca sozinha não resolve nesta live.** Webcam pequena (rosto ~45×66 px no 1080p) e streamer de PERFIL olhando o
monitor:
- MediaPipe Face Landmarker (o rastreio atual): rosto em ~4 % dos quadros na maioria dos blocos (0 a 58 %), e
`jawOpen` = 0,00 mesmo nos quadros com rosto e falando. Recorte justo no rosto: 26–69 % de presença, `jawOpen`
ainda ~0,01. Inútil para falante.
- YuNet + recorte da boca (`MouthMeter`): rosto em **99 %** dos quadros. Mas por trecho o sinal separa pouco: AUC
**0,55–0,64** (boca do streamer × boca nos trechos dos colegas). Somando muitos trechos aponta a voz certa
(média 0,188 × 0,167 × 0,159), com t = 2,3 contra a 2ª voz — abaixo do limiar 3: aqui quem decide é o volume.
Em câmera de frente e maior a boca deve pesar mais; não foi medido.
**A voz separa bem**:
- 3 vozes (358 s, 313 s e 244 s de fala em trechos ≥ 1 s); cosseno entre os centros 0,26–0,33 (vozes bem distintas).
- Volume: streamer −27,3 dBFS × −34,8 e −37,6 dBFS dos colegas → **+7,5 dB**; o streamer é achado pelo volume desde os
primeiros 5 minutos.
- 1 061 trechos: 916 com impressão; **514 viraram outra pessoa**, 73 ficaram como do streamer por dúvida (a voz mais
parecida era a de um colega, mas sem a folga exigida); 145 curtos herdam o vizinho.
- **Conferência visual às cegas** (30 trechos ≥ 1,2 s sorteados, 10 de cada voz, embaralhados; olhei 8 quadros da boca
de cada um sem saber a voz): 20 casos claros.
- boca parada o trecho todo (não é ele): **9 de 9** rotulados como outra pessoa;
- boca mexendo (seria ele): **7 de 11** rotulados streamer; os 4 restantes são todos da mesma voz de colega
(`other2`) e, revistos a 24 qps, mostram lábios entreabertos sem articular — duvidosos. Outros 2 trechos dessa
mesma voz mostram a boca dele fechada enquanto ela fala, e ela é 10 dB mais baixa que o microfone dele: tratei
como colega. Esta conferência é fraca (rosto de perfil, 45 px); não há gabarito de áudio.
- **Estabilidade** (streamer × outra pessoa, comparando com o modelo da sessão inteira): com 5 min de live, 52/62
trechos iguais (84 %); 10 min, 129/132 (98 %); 20 min, 287/292 (98 %); 40 min, 555/563 (99 %).
- Exemplo real (5:30–5:50): "How many drills is the gallery?" → streamer; "Gallery is three." → `other1`;
"I think we need five. I have three so I think you should bring two." → `other1`; "I got one code tablet
completed." → streamer (antes do corte por fim de frase, "I got one code" ia junto com o colega).
## Limites conhecidos
- Troca de falante no meio de um trecho sem pausa nem pontuação fica com um rótulo só.
- Nos primeiros minutos (menos de 15 s de fala por voz) não há atribuição: tudo como do streamer.
- Vozes do jogo (NPC, anúncio) também viram "outra pessoa" — o que é verdade (não é o streamer).
- Projeto do editor guarda o `sp` de quando foi criado; projeto antigo (sem `sp`) sai como antes. Nova avaliação dos
juízes refaz o projeto da IA já com falantes.
- A série da boca só existe em blocos rastreados por esta versão; a do volume vale para qualquer bloco com fala.
- Modelo de voz indisponível (sem rede no 1º uso, arquivo corrompido): os blocos analisados nesse tempo ficam sem
impressão de voz (não são refeitos depois) e o serviço tenta carregar de novo a cada 5 min.
- Tudo isso só vale depois de reiniciar o serviço (o código novo não roda no Clipador que está no ar).
+51 -14
View File
@@ -10,7 +10,8 @@ import {
/** `muted` = trecho sem o som da live (a narração e a música continuam). */ /** `muted` = trecho sem o som da live (a narração e a música continuam). */
export type EditCut = { start: number; end: number; mode: LayoutMode | null; muted?: boolean }; export type EditCut = { start: number; end: number; mode: LayoutMode | null; muted?: boolean };
export type EditWord = { s: number; e: number; w: string; emph?: boolean; hidden?: boolean }; /** `sp` = quem fala (doc/clipador/FALANTES.md): ausente/"streamer" = o streamer; "other1", "other2"… = outra pessoa. */
export type EditWord = { s: number; e: number; w: string; emph?: boolean; hidden?: boolean; sp?: string };
export type CaptionPreset = "classic" | "pop" | "karaoke" | "single" | "minimal"; export type CaptionPreset = "classic" | "pop" | "karaoke" | "single" | "minimal";
export type TextAnim = HookAnim; export type TextAnim = HookAnim;
/** Gancho: tempo de SAÍDA (vale a partir do 1º quadro). Texto: tempo da SESSÃO (gruda no conteúdo). */ /** Gancho: tempo de SAÍDA (vale a partir do 1º quadro). Texto: tempo da SESSÃO (gruda no conteúdo). */
@@ -278,7 +279,35 @@ export function removeSilences(cuts: EditCut[], words: EditWord[], minGap: numbe
/* ---------- legenda (prévia no navegador) ---------- */ /* ---------- legenda (prévia no navegador) ---------- */
export type OutWord = { start: number; end: number; word: string; emph: boolean }; export type OutWord = { start: number; end: number; word: string; emph: boolean; sp?: string };
/** Fala de outra pessoa (qualquer `sp` que não seja vazio nem "streamer"). */
export function isOther(sp: string | undefined | null): boolean {
return Boolean(sp) && sp !== "streamer";
}
/** Faixa da legenda: a do streamer (posição normal) ou a de outra pessoa (logo abaixo). */
export type CaptionLane = "streamer" | "other";
export function laneOf(sp: string | undefined | null): CaptionLane {
return isOther(sp) ? "other" : "streamer";
}
/** Rótulo de quem fala, para o painel. */
export function speakerLabel(sp: string | undefined | null): string {
if (!isOther(sp)) return "Streamer";
const n = /^other(\d+)$/.exec(sp ?? "");
return n ? `Outra pessoa ${n[1]}` : "Outra pessoa";
}
/** Tamanho da fala de outra pessoa (`caption.otherSize` ou 85 % do tamanho), como `subtitles.other_size`. */
export function otherSize(cap: CutSettings["caption"]): number {
return cap.otherSize ? cap.otherSize : Math.max(30, Math.round(cap.size * 0.85));
}
/** Distância do centro da linha do streamer ao centro da de outra pessoa, como `subtitles.other_offset`. */
export function otherOffset(size: number, osize: number): number {
return Math.round(0.6 * size + 0.6 * osize) + 10;
}
export function outputWords(project: EditProject): OutWord[] { export function outputWords(project: EditProject): OutWord[] {
const ps = pieces(project.cuts); const ps = pieces(project.cuts);
@@ -291,7 +320,7 @@ export function outputWords(project: EditProject): OutWord[] {
const s = p.out + Math.max(w.s, p.start) - p.start; const s = p.out + Math.max(w.s, p.start) - p.start;
const e = p.out + Math.min(w.e, p.end) - p.start; const e = p.out + Math.min(w.e, p.end) - p.start;
// Arredondado a 3 casas como `editor.output_words` (o agrupamento compara esses números). // Arredondado a 3 casas como `editor.output_words` (o agrupamento compara esses números).
out.push({ start: round3(s), end: round3(Math.max(e, s + 0.05)), word: w.w, emph: Boolean(w.emph) }); out.push({ start: round3(s), end: round3(Math.max(e, s + 0.05)), word: w.w, emph: Boolean(w.emph), sp: w.sp ?? "" });
} }
return out; return out;
} }
@@ -350,7 +379,8 @@ export function groupWords(words: OutWord[], maxWords: number = CAPTION_TIMING.M
const groups: OutWord[][] = []; const groups: OutWord[][] = [];
for (const word of cleanWords(words)) { for (const word of cleanWords(words)) {
const cur = groups[groups.length - 1]; const cur = groups[groups.length - 1];
if (cur && word.start - cur[cur.length - 1].end <= MAX_GAP_S && word.end - cur[0].start <= MAX_BLOCK_S) { const same = cur && (cur[cur.length - 1].sp || "streamer") === (word.sp || "streamer"); // bloco nunca mistura falantes
if (cur && same && word.start - cur[cur.length - 1].end <= MAX_GAP_S && word.end - cur[0].start <= MAX_BLOCK_S) {
const fits = [...cur, word].map((w) => w.word).join(" ").length <= maxChars; const fits = [...cur, word].map((w) => w.word).join(" ").length <= maxChars;
// Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler. // Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
const room = cur.length < maxWords || (maxWords >= 2 && cur.length === maxWords && word.end - cur[0].start < FAST_BLOCK_S); const room = cur.length < maxWords || (maxWords >= 2 && cur.length === maxWords && word.end - cur[0].start < FAST_BLOCK_S);
@@ -363,22 +393,29 @@ export function groupWords(words: OutWord[], maxWords: number = CAPTION_TIMING.M
export type CaptionBlock = { words: OutWord[]; end: number }; export type CaptionBlock = { words: OutWord[]; end: number };
/** Blocos com o fim: nunca passa do início do bloco seguinte (dois eventos ativos o libass empilharia). */ /**
* Blocos com o fim: nunca passa do início do bloco seguinte DA MESMA FAIXA (streamer / outra pessoa), como
* `subtitles.caption_blocks`. Os dois falando juntos = um bloco em cada faixa ao mesmo tempo.
*/
export function captionBlocks(words: OutWord[], maxWords: number = CAPTION_TIMING.MAX_WORDS): CaptionBlock[] { export function captionBlocks(words: OutWord[], maxWords: number = CAPTION_TIMING.MAX_WORDS): CaptionBlock[] {
const groups = groupWords(words, maxWords); const out: CaptionBlock[] = [];
return groups.map((g, k) => { for (const lane of ["streamer", "other"] as const) {
let end = Math.max(g[g.length - 1].end, g[g.length - 1].start + CAPTION_TIMING.MIN_HOLD_S); const groups = groupWords(words.filter((w) => laneOf(w.sp) === lane), maxWords);
if (k + 1 < groups.length) end = Math.min(end, groups[k + 1][0].start); groups.forEach((g, k) => {
return { words: g, end: pyRound3(end) }; let end = Math.max(g[g.length - 1].end, g[g.length - 1].start + CAPTION_TIMING.MIN_HOLD_S);
}); if (k + 1 < groups.length) end = Math.min(end, groups[k + 1][0].start);
out.push({ words: g, end: pyRound3(end) });
});
}
return out.sort((a, b) => a.words[0].start - b.words[0].start);
} }
/** /**
* Bloco e palavra destacada no instante `t` (saída), como os eventos do ASS: o bloco vale de `[0].start` até `end`; * Bloco e palavra destacada no instante `t` (saída), como os eventos do ASS: o bloco vale de `[0].start` até `end`;
* a palavra i vale do início dela até o início da seguinte (a última, até o fim do bloco). * a palavra i vale do início dela até o início da seguinte (a última, até o fim do bloco). `lane` = faixa.
*/ */
export function captionAt(blocks: CaptionBlock[], t: number): { block: CaptionBlock; active: number } | null { export function captionAt(blocks: CaptionBlock[], t: number, lane: CaptionLane = "streamer"): { block: CaptionBlock; active: number } | null {
const block = blocks.find((b) => t >= b.words[0].start && t < b.end); const block = blocks.find((b) => laneOf(b.words[0].sp) === lane && t >= b.words[0].start && t < b.end);
if (!block) return null; if (!block) return null;
let active = 0; let active = 0;
for (let i = 0; i < block.words.length; i++) if (t >= block.words[i].start) active = i; for (let i = 0; i < block.words.length; i++) if (t >= block.words[i].start) active = i;
+17 -5
View File
@@ -19,7 +19,7 @@ import type { CutSettings, Rect } from "./clipper-client";
import { canvasFont, fontMetrics } from "./clip-editor-fonts"; import { canvasFont, fontMetrics } from "./clip-editor-fonts";
import { import {
BANNER_SLIDE_MS, CHAT_HOLD_S, INSET_ANIM_S, INSET_SHADOW_ALPHA, INSET_SLIDE_S, TEXT_SLIDE_MS, bannerLayout, camPanelHeight, captionY, BANNER_SLIDE_MS, CHAT_HOLD_S, INSET_ANIM_S, INSET_SHADOW_ALPHA, INSET_SLIDE_S, TEXT_SLIDE_MS, bannerLayout, camPanelHeight, captionY,
captionAt, captionBlocks, chatDefault, clamp, cutAt, easeAt, ffmpegCropFill, gameWindowAt, insetAt, insetHeight, outputDuration, outputWords, plainLines, produce, resolvedMode, captionAt, captionBlocks, chatDefault, clamp, otherOffset, otherSize, type CaptionLane, cutAt, easeAt, ffmpegCropFill, gameWindowAt, insetAt, insetHeight, outputDuration, outputWords, plainLines, produce, resolvedMode,
round3, setInsetPlace, toOutput, zoomAt, type ChatItem, type EditProject, type Frame, type InsetOverlay, type OutWord, type Selection, type TextOverlay, round3, setInsetPlace, toOutput, zoomAt, type ChatItem, type EditProject, type Frame, type InsetOverlay, type OutWord, type Selection, type TextOverlay,
} from "./clip-editor-model"; } from "./clip-editor-model";
import { cx } from "./ui"; import { cx } from "./ui";
@@ -277,8 +277,15 @@ function renderFrame(ctx: CanvasRenderingContext2D, comp: HTMLCanvasElement, vid
if (fontsReady) { if (fontsReady) {
const cap = cfg.caption; const cap = cfg.caption;
if (cap.enabled && inside) { if (cap.enabled && inside) {
const box = drawCaption(ctx, project, cfg, tOut, captionY(cfg, mode, frame) * k, k, cw); // Fala de outra pessoa (colega no Discord, voz do jogo): logo abaixo, na cor dela (FALANTES.md). Sem espaço
// embaixo, a linha do streamer sobe (como no render: a ordem nunca inverte).
const two = project.captions.words.some((w) => w.sp && w.sp !== "streamer");
const offset = otherOffset(cap.size, otherSize(cap));
const capY = two ? Math.min(captionY(cfg, mode, frame), frame.canvasHeight - 8 - offset - Math.trunc(0.6 * otherSize(cap)))
: captionY(cfg, mode, frame);
const box = drawCaption(ctx, project, cfg, tOut, capY * k, k, cw);
if (box) hits.push({ key: "caption", ...box }); if (box) hits.push({ key: "caption", ...box });
if (two) drawCaption(ctx, project, cfg, tOut, (capY + offset) * k, k, cw, "other");
} }
for (const o of project.overlays) { for (const o of project.overlays) {
if (o.kind === "zoom" || o.kind === "inset") continue; if (o.kind === "zoom" || o.kind === "inset") continue;
@@ -547,10 +554,15 @@ function drawBanner(ctx: CanvasRenderingContext2D, o: TextOverlay, frame: Frame,
* comportamento de cada preset de `editor_render.build_project_ass`. `y` = centro em px do canvas. Estilo "Caption": * comportamento de cada preset de `editor_render.build_project_ass`. `y` = centro em px do canvas. Estilo "Caption":
* negrito, contorno e sombra 3 (meio preto). * negrito, contorno e sombra 3 (meio preto).
*/ */
function drawCaption(ctx: CanvasRenderingContext2D, project: EditProject, cfg: CutSettings, t: number, y: number, k: number, cw: number): Box { function drawCaption(ctx: CanvasRenderingContext2D, project: EditProject, cfg: CutSettings, t: number, y: number, k: number, cw: number,
const cap = cfg.caption; lane: CaptionLane = "streamer"): Box {
// A linha de outra pessoa usa a cor e o tamanho dela (`otherColor`/`otherSize`), como o estilo CaptionOther do ASS.
const cap = lane === "other"
? { ...cfg.caption, color: cfg.caption.otherColor ?? "#5CE1FF", size: otherSize(cfg.caption),
outlineWidth: cfg.caption.outlineWidth ? Math.max(2, Math.floor((cfg.caption.outlineWidth * otherSize(cfg.caption)) / cfg.caption.size)) : 0 }
: cfg.caption;
const preset = project.captions.preset; const preset = project.captions.preset;
const now = captionAt(captionBlocks(outputWords(project), cap.maxWords), t); const now = captionAt(captionBlocks(outputWords(project), cap.maxWords), t, lane);
const group = now?.block.words; const group = now?.block.words;
const m = fontMetrics(cap.font); const m = fontMetrics(cap.font);
const size = cap.size * k; const size = cap.size * k;
@@ -4,10 +4,13 @@
// Com palavras selecionadas, a barra oferece tirar/manter no corte e ênfase (o resto fica em Propriedades). // Com palavras selecionadas, a barra oferece tirar/manter no corte e ênfase (o resto fica em Propriedades).
// Palavras fora do corte aparecem riscadas. Ferramentas: remover silêncios maiores que X s e re-transcrever um // Palavras fora do corte aparecem riscadas. Ferramentas: remover silêncios maiores que X s e re-transcrever um
// trecho com o Whisper do serviço de voz. Chat: as mensagens da janela, com o tempo; clique = ir ao instante. // trecho com o Whisper do serviço de voz. Chat: as mensagens da janela, com o tempo; clique = ir ao instante.
// Quem fala (doc/clipador/FALANTES.md): cada parágrafo é de um falante só; a fala de outra pessoa (colega no Discord,
// voz do jogo) vem marcada e na cor dela; "Falante" troca as palavras selecionadas entre streamer e outra pessoa.
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { clipperCall } from "./clipper-client"; import { clipperCall } from "./clipper-client";
import { import {
cutAt, keepRange, produce, removeRange, removeSilences, sessionClock, type ChatItem, type EditProject, type EditWord, type Selection, cutAt, isOther, keepRange, produce, removeRange, removeSilences, sessionClock, speakerLabel, type ChatItem, type EditProject, type EditWord,
type Selection,
} from "./clip-editor-model"; } from "./clip-editor-model";
import { Btn } from "./clip-editor-ui"; import { Btn } from "./clip-editor-ui";
import { MicIcon, ScissorsIcon } from "./icons"; import { MicIcon, ScissorsIcon } from "./icons";
@@ -62,9 +65,10 @@ export function EditorTranscript({ clipId, project, playhead, selection, onSelec
if (!parts.length || parts.join(" ") === sel.map((w) => w.w).join(" ")) return; if (!parts.length || parts.join(" ") === sel.map((w) => w.w).join(" ")) return;
const weight = parts.reduce((n, w) => n + w.length + 1, 0); const weight = parts.reduce((n, w) => n + w.length + 1, 0);
let cursor = selA; let cursor = selA;
const sp = sel[0].sp; // o texto novo continua de quem falava
const fresh: EditWord[] = parts.map((w) => { const fresh: EditWord[] = parts.map((w) => {
const dur = Math.max(0.06, ((selB - selA) * (w.length + 1)) / weight); const dur = Math.max(0.06, ((selB - selA) * (w.length + 1)) / weight);
const item = { s: Math.round(cursor * 1000) / 1000, e: Math.round(Math.min(selB, cursor + dur) * 1000) / 1000, w: w.slice(0, 40) }; const item: EditWord = { s: Math.round(cursor * 1000) / 1000, e: Math.round(Math.min(selB, cursor + dur) * 1000) / 1000, w: w.slice(0, 40), ...(sp ? { sp } : {}) };
cursor += dur; cursor += dur;
return item; return item;
}).filter((w) => w.e > w.s); }).filter((w) => w.e > w.s);
@@ -92,11 +96,13 @@ export function EditorTranscript({ clipId, project, playhead, selection, onSelec
onNotice(true, `Whisper transcreveu ${sessionClock(a)}–${sessionClock(b)} de novo: ${r.data.words.length} palavras em ${r.data.seconds.toLocaleString("pt-BR")} s.`); onNotice(true, `Whisper transcreveu ${sessionClock(a)}–${sessionClock(b)} de novo: ${r.data.words.length} palavras em ${r.data.seconds.toLocaleString("pt-BR")} s.`);
} }
// Parágrafos: quebra quando a fala para mais de 1,2 s (fica mais fácil achar onde cortar). // Parágrafos: quebra quando a fala para mais de 1,2 s (fica mais fácil achar onde cortar) ou quando muda quem fala.
const paragraphs: number[][] = []; const paragraphs: number[][] = [];
const speakerOf = (w: EditWord) => (isOther(w.sp) ? w.sp : "streamer");
const anyOther = words.some((w) => isOther(w.sp));
words.forEach((w, i) => { words.forEach((w, i) => {
const last = paragraphs[paragraphs.length - 1]; const last = paragraphs[paragraphs.length - 1];
if (!last || w.s - words[i - 1].e > 1.2) paragraphs.push([i]); if (!last || w.s - words[i - 1].e > 1.2 || speakerOf(w) !== speakerOf(words[i - 1])) paragraphs.push([i]);
else last.push(i); else last.push(i);
}); });
@@ -120,6 +126,11 @@ export function EditorTranscript({ clipId, project, playhead, selection, onSelec
const on = !sel.every((w) => w.emph); const on = !sel.every((w) => w.emph);
setWords((ws) => ws.map((w, i) => (range && i >= range.from && i <= range.to ? { ...w, emph: on || undefined } : w))); setWords((ws) => ws.map((w, i) => (range && i >= range.from && i <= range.to ? { ...w, emph: on || undefined } : w)));
}}>Ênfase</Btn> }}>Ênfase</Btn>
<Btn variant="ghost" className="px-2" title="Trocar quem fala estas palavras: streamer ↔ outra pessoa (legenda de baixo, outra cor)" onClick={() => {
const toStreamer = sel.every((w) => isOther(w.sp));
setWords((ws) => ws.map((w, i) => (range && i >= range.from && i <= range.to ? { ...w, sp: toStreamer ? "streamer" : "other1" } : w)));
onNotice(true, toStreamer ? "Palavras marcadas como do streamer." : "Palavras marcadas como de outra pessoa (legenda de baixo).");
}}>{sel.every((w) => isOther(w.sp)) ? "É o streamer" : "Outra pessoa"}</Btn>
</> </>
) : ( ) : (
<> <>
@@ -160,8 +171,15 @@ export function EditorTranscript({ clipId, project, playhead, selection, onSelec
{paragraphs.map((para) => ( {paragraphs.map((para) => (
<p key={para[0]} className="mb-1.5 grid grid-cols-[52px_minmax(0,1fr)] gap-x-2"> <p key={para[0]} className="mb-1.5 grid grid-cols-[52px_minmax(0,1fr)] gap-x-2">
<button type="button" tabIndex={-1} onClick={() => onSeek(words[para[0]].s)} <button type="button" tabIndex={-1} onClick={() => onSeek(words[para[0]].s)}
className="cursor-pointer pt-[3px] text-left font-mono text-[10.5px] text-nle-hot/80 hover:text-nle-hot">{sessionClock(words[para[0]].s)}</button> className="grid cursor-pointer content-start pt-[3px] text-left font-mono text-[10.5px] text-nle-hot/80 hover:text-nle-hot">
<span> {sessionClock(words[para[0]].s)}
{anyOther && (
<span className={cx("font-sans text-[10px] leading-tight", isOther(words[para[0]].sp) ? "text-[#5ce1ff]" : "text-nle-dim")}>
{speakerLabel(words[para[0]].sp)}
</span>
)}
</button>
<span className={cx(isOther(words[para[0]].sp) && "text-[#9fe9ff]")}>
{para.map((i) => { {para.map((i) => {
const w = words[i]; const w = words[i];
const kept = cutAt(project.cuts, (w.s + w.e) / 2) >= 0; const kept = cutAt(project.cuts, (w.s + w.e) / 2) >= 0;
+4 -1
View File
@@ -141,7 +141,8 @@ export type ClipAnalysis = {
/** Fonte em inglês: a fala do corte em frases (tempo da sessão) com a tradução em português. */ /** Fonte em inglês: a fala do corte em frases (tempo da sessão) com a tradução em português. */
export type ClipTranslation = { export type ClipTranslation = {
language: string; startS: number; endS: number; model?: string; language: string; startS: number; endS: number; model?: string;
lines: { s: number; e: number; text: string; pt: string }[]; /** `speaker` = quem fala a frase ("streamer" ou "other1", "other2"…; ausente nas traduções antigas = streamer). */
lines: { s: number; e: number; text: string; pt: string; speaker?: string }[];
}; };
export type ClipJudge = null export type ClipJudge = null
@@ -238,6 +239,8 @@ export type CutSettings = {
caption: { caption: {
enabled: boolean; font: string; size: number; color: string; highlight: string; outline: string; enabled: boolean; font: string; size: number; color: string; highlight: string; outline: string;
outlineWidth: number; y: number | null; uppercase: boolean; maxWords: number; outlineWidth: number; y: number | null; uppercase: boolean; maxWords: number;
/** Fala de outra pessoa (colega no Discord, voz do jogo): cor e tamanho (null = 85 % de `size`). Serviço antigo não manda. */
otherColor?: string; otherSize?: number | null;
/** Legado: virou `dev.translation`. */ /** Legado: virou `dev.translation`. */
translation?: boolean; translation?: boolean;
}; };
+12 -2
View File
@@ -8,6 +8,7 @@ import { CLIP_STATUS, SOURCE_LABEL, clipperCall, formatClock, formatDuration, la
import { import {
ChatSignals, ClipActions, ClipMedia, ClipVideoState, DeleteControl, FaceSignal, JudgeVerdict, TrimControl, situationLabel, type DeleteClip, ChatSignals, ClipActions, ClipMedia, ClipVideoState, DeleteControl, FaceSignal, JudgeVerdict, TrimControl, situationLabel, type DeleteClip,
} from "./clipper-clip-parts"; } from "./clipper-clip-parts";
import { isOther, speakerLabel } from "./clip-editor-model";
import { Dialog } from "./dialog"; import { Dialog } from "./dialog";
import { ArrowLeftIcon, ArrowRightIcon, CheckIcon, ClockIcon } from "./icons"; import { ArrowLeftIcon, ArrowRightIcon, CheckIcon, ClockIcon } from "./icons";
import type { PublishJob } from "./publishing-client"; import type { PublishJob } from "./publishing-client";
@@ -171,6 +172,8 @@ function Portuguese({ clip, pending, run }: {
const pt = clip.judge && "pt" in clip.judge ? clip.judge.pt : undefined; const pt = clip.judge && "pt" in clip.judge ? clip.judge.pt : undefined;
const lines = clip.translation?.lines ?? []; const lines = clip.translation?.lines ?? [];
const english = (clip.language ?? "").toLowerCase().startsWith("en"); const english = (clip.language ?? "").toLowerCase().startsWith("en");
// Quem fala cada frase (doc/clipador/FALANTES.md): o streamer ou outra pessoa (colega no Discord, voz do jogo).
const others = lines.some((l) => isOther(l.speaker));
if (!english && !pt && !lines.length) return null; if (!english && !pt && !lines.length) return null;
const translate = () => run("translate", () => clipperCall<Clip>(`clips/${clip.id}/translate`, "POST"), "Fala traduzida."); const translate = () => run("translate", () => clipperCall<Clip>(`clips/${clip.id}/translate`, "POST"), "Fala traduzida.");
return ( return (
@@ -183,12 +186,19 @@ function Portuguese({ clip, pending, run }: {
{pt?.caption && <p className="text-[0.8125rem] leading-relaxed text-fg-muted">{pt.caption}</p>} {pt?.caption && <p className="text-[0.8125rem] leading-relaxed text-fg-muted">{pt.caption}</p>}
{lines.length > 0 ? ( {lines.length > 0 ? (
<details className="text-[0.8125rem]"> <details className="text-[0.8125rem]">
<summary className="cursor-pointer text-fg-muted select-none hover:text-fg">O que ele fala ({lines.length} frases)</summary> <summary className="cursor-pointer text-fg-muted select-none hover:text-fg">
{others ? "O que falam" : "O que ele fala"} ({lines.length} frases)
</summary>
<ol className="mt-2 grid gap-2"> <ol className="mt-2 grid gap-2">
{lines.map((line, i) => ( {lines.map((line, i) => (
<li key={i} className="grid grid-cols-[3.25rem_minmax(0,1fr)] gap-2"> <li key={i} className="grid grid-cols-[3.25rem_minmax(0,1fr)] gap-2">
<span className="pt-px font-mono text-[0.6875rem] text-fg-subtle tabular-nums">{formatClock(line.s - clip.startS)}</span> <span className="pt-px font-mono text-[0.6875rem] text-fg-subtle tabular-nums">{formatClock(line.s - clip.startS)}</span>
<span className="grid gap-0.5"> <span className={cx("grid gap-0.5", isOther(line.speaker) && "border-l-2 border-info/60 pl-2")}>
{others && (
<span className={cx("text-[0.6875rem] font-semibold", isOther(line.speaker) ? "text-info" : "text-fg-muted")}>
{speakerLabel(line.speaker)}
</span>
)}
<span className="text-fg">{line.pt}</span> <span className="text-fg">{line.pt}</span>
<span className="text-xs text-fg-subtle italic">{line.text}</span> <span className="text-xs text-fg-subtle italic">{line.text}</span>
</span> </span>
@@ -506,6 +506,21 @@ function CutSettingsEditor({ scope, onDirty, onClose, onSaved }: {
</div> </div>
<RangeField label="Espessura do contorno" min={0} max={14} step={1} value={draft.caption.outlineWidth} <RangeField label="Espessura do contorno" min={0} max={14} step={1} value={draft.caption.outlineWidth}
onChange={(outlineWidth) => update("caption", { outlineWidth })} format={(v) => `${v} px`} /> onChange={(outlineWidth) => update("caption", { outlineWidth })} format={(v) => `${v} px`} />
<h4 className="pt-2 text-eyebrow font-semibold text-fg-subtle uppercase">Fala de outra pessoa</h4>
<p className="-mt-2 text-xs text-fg-subtle">
Colega no Discord ou outro jogador no chat de voz: a legenda dele sai logo abaixo da do streamer, nesta cor.
</p>
<div className="grid grid-cols-3 gap-2">
<ColorField label="Cor da outra pessoa" value={draft.caption.otherColor ?? "#5CE1FF"}
onChange={(otherColor) => update("caption", { otherColor })} />
</div>
<Switch label="Tamanho automático" checked={!draft.caption.otherSize}
onChange={(auto) => update("caption", { otherSize: auto ? null : Math.round(draft.caption.size * 0.85) })}
hint="85% do tamanho da legenda do streamer." />
{Boolean(draft.caption.otherSize) && (
<RangeField label="Tamanho da outra pessoa" min={30} max={140} step={2} value={draft.caption.otherSize ?? 70}
onChange={(otherSize) => update("caption", { otherSize })} format={(v) => `${v} px`} />
)}
</div> </div>
<div className="grid content-start gap-4"> <div className="grid content-start gap-4">
<h4 className="text-eyebrow font-semibold text-fg-subtle uppercase">Ritmo e posição</h4> <h4 className="text-eyebrow font-semibold text-fg-subtle uppercase">Ritmo e posição</h4>
@@ -980,6 +995,11 @@ function CaptionSample({ caption }: { caption: CutSettings["caption"] }) {
}}> }}>
{words.map((w, i) => <span key={w} style={i === 1 ? { color: caption.highlight } : undefined}>{w}{i < words.length - 1 ? " " : ""}</span>)} {words.map((w, i) => <span key={w} style={i === 1 ? { color: caption.highlight } : undefined}>{w}{i < words.length - 1 ? " " : ""}</span>)}
</span> </span>
{/* A fala de outra pessoa (colega no Discord), logo abaixo e na cor dela. */}
<span className="text-center text-lg leading-tight" style={{
fontFamily: fontStack(caption.font), fontWeight: 900, color: caption.otherColor ?? "#5CE1FF",
WebkitTextStroke: stroke ? `${stroke}px ${caption.outline}` : undefined, paintOrder: "stroke fill",
}}>{caption.uppercase ? "E O COLEGA" : "e o colega"}</span>
</div> </div>
); );
} }