Clipador em inglês (doc/clipador/IDIOMAS.md):
- Fonte en-US: analista, editor e varredura com prompts, glossário de chat e saída em inglês;
a mesma resposta traz o bloco `pt` (tradução para o painel, sem chamada extra).
- Fala do corte traduzida por frase (clips.translation_json, migração v13) e
POST /v1/clips/{id}/translate.
- caption.translation (só para desenvolver): português embaixo da legenda em inglês.
- Risada e gírias do chat em inglês na heurística (LMAO, LOL, 💀, 😭, no way, bruh...).
- Idioma do público → código do Whisper (en-US dava 422 no serviço de voz).
- Painel: bloco "Em português" no corte, análise/resumo em PT, título traduzido na lista,
coluna "Ao vivo" mostra a gravação ativa da fonte.
IA: monitor de uso do limite (ai-usage) e 4º provedor (Antigravity CLI).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
168 lines
8.8 KiB
Python
168 lines
8.8 KiB
Python
"""Legenda queimada no corte (formato ASS, lido pelo filtro `ass` do FFmpeg), no vertical ou no horizontal.
|
|
|
|
Estilo de corte de live: blocos curtos, grandes, com contorno, e a palavra falada no momento destacada.
|
|
Cores, fonte, tamanho, posição e palavras por bloco vêm da configuração do corte (layout.py, grupo `caption`).
|
|
O crédito do canal fica em cima ou embaixo (grupo `credit`) — sempre ligado por padrão: o corte é de terceiros.
|
|
|
|
Tempo da legenda (pedido do dono, 16/11/2026: "com fala rápida a legenda sai fora do tempo e fica uma em cima da
|
|
outra"). Medido na cópia do banco: 63 de 286 eventos de legenda dos projetos se sobrepunham — o fim de um bloco
|
|
(fim da última palavra, no mínimo +0,25 s) passava do início do bloco seguinte, e o libass EMPILHA dois eventos
|
|
ativos ao mesmo tempo. Agora (usado pelo render do worker e pelo do editor):
|
|
- `clean_words`: palavras ordenadas, sem sobreposição, duração mínima (o Whisper devolve palavra de 0 s) e nunca
|
|
duas começando no mesmo instante;
|
|
- `group_words`: até `maxWords` palavras e um limite de caracteres; bloco quebra em pausa > 0,6 s ou se passar de
|
|
3,2 s; com fala muito rápida (bloco cheio durando < 0,7 s) aceita UMA palavra a mais se couber nos caracteres,
|
|
para o bloco não piscar;
|
|
- `caption_blocks`: o fim de cada bloco é cortado no início do seguinte — nunca dois blocos na tela. O início do
|
|
bloco é sempre o início da 1ª palavra (a legenda não atrasa em relação ao áudio).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from . import layout
|
|
from .scoring import Word
|
|
|
|
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
|
|
MIN_WORD_S = 0.06 # duração mínima de uma palavra na legenda
|
|
MIN_STEP_S = 0.04 # duas palavras nunca começam no mesmo instante (a palavra destacada precisa de tempo próprio)
|
|
MIN_HOLD_S = 0.25 # a última palavra do bloco fica pelo menos isto (se o próximo bloco não começar antes)
|
|
MAX_BLOCK_S = 3.2 # bloco mais longo que isto quebra (fala arrastada)
|
|
FAST_BLOCK_S = 0.7 # bloco cheio mais curto que isto = fala rápida: aceita uma palavra a mais
|
|
|
|
|
|
def _ts(seconds: float) -> str:
|
|
seconds = max(0.0, seconds)
|
|
cs = int(round(seconds * 100))
|
|
h, cs = divmod(cs, 360000)
|
|
m, cs = divmod(cs, 6000)
|
|
s, cs = divmod(cs, 100)
|
|
return f"{h}:{m:02d}:{s:02d}.{cs:02d}"
|
|
|
|
|
|
def _escape(text: str) -> str:
|
|
# Chaves abrem tags de estilo e \ vira comando no ASS: o texto falado nunca pode virar tag.
|
|
return text.replace("\\", "/").replace("{", "(").replace("}", ")").replace("\n", " ")
|
|
|
|
|
|
def clean_words(words: list[Word]) -> list[Word]:
|
|
"""Saneia os tempos das palavras: ordena, tira vazias, dá duração mínima, empurra a que começa junto com a
|
|
anterior e corta o fim de uma palavra no início da seguinte (sem sobreposição). Idempotente nos valores
|
|
(aplicar duas vezes dá o mesmo resultado); depois dela, (início, texto) identifica cada palavra."""
|
|
items = sorted((w for w in words if w.word.strip()), key=lambda w: (w.start, w.end))
|
|
out: list[Word] = []
|
|
for w in items:
|
|
start = w.start
|
|
if out and start < out[-1].start + MIN_STEP_S - 1e-6:
|
|
start = round(out[-1].start + MIN_STEP_S, 3)
|
|
end = max(w.end, round(start + MIN_WORD_S, 3))
|
|
if out and out[-1].end > start + 1e-9:
|
|
prev = out[-1]
|
|
out[-1] = Word(prev.start, start, prev.word)
|
|
text = w.word.strip()
|
|
same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word
|
|
out.append(w if same else Word(start, end, text))
|
|
return out
|
|
|
|
|
|
def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]:
|
|
"""Blocos da legenda (palavras já saneadas por `clean_words`)."""
|
|
max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS)
|
|
groups: list[list[Word]] = []
|
|
for word in clean_words(words):
|
|
current = groups[-1] if groups else None
|
|
if current and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S:
|
|
fits = len(" ".join(w.word for w in current + [word])) <= max_chars
|
|
room = len(current) < max_words or (
|
|
# Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler.
|
|
max_words >= 2 and len(current) == max_words and word.end - current[0].start < FAST_BLOCK_S)
|
|
if fits and room:
|
|
current.append(word)
|
|
continue
|
|
groups.append([word])
|
|
return groups
|
|
|
|
|
|
def caption_blocks(words: list[Word], max_words: int = MAX_WORDS) -> list[tuple[list[Word], float]]:
|
|
"""(palavras do bloco, fim do bloco). O fim nunca passa do início do bloco seguinte: dois eventos de legenda
|
|
ativos ao mesmo tempo seriam empilhados pelo libass (um em cima do outro)."""
|
|
groups = group_words(words, max_words)
|
|
out = []
|
|
for k, group in enumerate(groups):
|
|
end = max(group[-1].end, group[-1].start + MIN_HOLD_S)
|
|
if k + 1 < len(groups):
|
|
end = min(end, groups[k + 1][0].start)
|
|
out.append((group, round(end, 3)))
|
|
return out
|
|
|
|
|
|
PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16
|
|
_SENTENCE_END = (".", "?", "!")
|
|
|
|
|
|
def phrases(words: list[Word]) -> list[tuple[float, float, str]]:
|
|
"""Fala em frases curtas com tempo (início, fim, texto) para traduzir: quebra em pausa > 0,7 s, fim de frase
|
|
(. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3."""
|
|
out: list[tuple[float, float, str]] = []
|
|
current: list[Word] = []
|
|
for w in clean_words(words):
|
|
if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S
|
|
or len(current) >= PHRASE_MAX_WORDS
|
|
or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)):
|
|
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current)))
|
|
current = []
|
|
current.append(w)
|
|
if current:
|
|
out.append((current[0].start, current[-1].end, " ".join(x.word for x in current)))
|
|
return out
|
|
|
|
|
|
def build_ass(words: list[Word], clip_start: float, clip_end: float, credit: str, settings: dict | None = None) -> str:
|
|
"""`words` com tempos da sessão; a saída usa tempos relativos ao início do corte."""
|
|
cfg = settings or layout.merge()
|
|
cap, cred = cfg["caption"], cfg["credit"]
|
|
duration = clip_end - clip_start
|
|
inside = [
|
|
Word(max(0.0, w.start - clip_start), min(duration, w.end - clip_start), w.word.strip())
|
|
for w in words
|
|
if w.end > clip_start and w.start < clip_end
|
|
]
|
|
base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"])
|
|
credit_align, credit_side, credit_margin = layout.credit_placement(cfg)
|
|
width, height = layout.canvas_size(cfg)
|
|
header = f"""[Script Info]
|
|
ScriptType: v4.00+
|
|
PlayResX: {width}
|
|
PlayResY: {height}
|
|
WrapStyle: 2
|
|
ScaledBorderAndShadow: yes
|
|
|
|
[V4+ Styles]
|
|
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
|
|
Style: Caption,{cap['font']},{cap['size']},{base},{base},{outline},&H80000000,-1,0,0,0,100,100,0,0,1,{cap['outlineWidth']},3,5,60,60,0,1
|
|
Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1
|
|
|
|
[Events]
|
|
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
|
|
"""
|
|
lines = []
|
|
if credit and cred["enabled"]:
|
|
lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}")
|
|
if cap["enabled"]:
|
|
pos = f"{{\\pos({width // 2},{layout.caption_y(cfg)})}}"
|
|
high, base = layout.ass_inline_color(cap["highlight"]), layout.ass_inline_color(cap["color"])
|
|
for group, g_end in caption_blocks(inside, cap["maxWords"]):
|
|
for i, word in enumerate(group):
|
|
# Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada.
|
|
start = word.start
|
|
end = group[i + 1].start if i + 1 < len(group) else g_end
|
|
if end <= start:
|
|
continue
|
|
# Maiúsculas só no texto: as tags (\c) são sensíveis a caixa.
|
|
parts = []
|
|
for j, w in enumerate(group):
|
|
text = _escape(w.word.upper() if cap["uppercase"] else w.word)
|
|
parts.append(f"{{\\c{high}}}{text}{{\\c{base}}}" if j == i else text)
|
|
lines.append(f"Dialogue: 0,{_ts(start)},{_ts(end)},Caption,,0,0,0,,{pos}{' '.join(parts)}")
|
|
return header + "\n".join(lines) + "\n"
|