"""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). Dois falantes (pedido do dono, 18/11/2026: "a legenda do streamer em cima e a de outra pessoa abaixo, com outra cor, como se fossem duas pessoas conversando"; doc/clipador/FALANTES.md): cada palavra tem `speaker` e a legenda tem duas FAIXAS — a do streamer (posição normal) e a de outra pessoa (logo abaixo, `caption.otherColor`/`otherSize`). Um bloco nunca mistura falantes; o "nunca dois blocos na tela" vale DENTRO de cada faixa, então quando os dois falam ao mesmo tempo aparecem as duas linhas, cada uma no seu lugar (posição fixa por `pos`: o libass não empilha). """ from __future__ import annotations from . import layout from .scoring import Word from .speakers import STREAMER, is_other STREAMER_LANE, OTHER_LANE = "streamer", "other" OTHER_SIZE_RATIO = 0.85 # tamanho automático da fala de outra pessoa (fração do tamanho da legenda) LINE_GAP_PX = 10 # vão entre a linha do streamer e a de outra pessoa WIDTH, HEIGHT = layout.W, layout.H # quadro do vertical (compatibilidade); o formato real vem da configuração MAX_WORDS, MAX_CHARS, MAX_GAP_S = 3, 18, 0.6 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, prev.speaker) text = w.word.strip() same = abs(start - w.start) < 1e-9 and abs(end - w.end) < 1e-9 and text == w.word out.append(w if same else Word(start, end, text, w.speaker)) return out def lane(speaker: str | None) -> str: """Faixa da legenda: `streamer` (vazio também) ou `other` (qualquer outra pessoa).""" return OTHER_LANE if is_other(speaker) else STREAMER_LANE def same_speaker(a: Word, b: Word) -> bool: return (a.speaker or STREAMER) == (b.speaker or STREAMER) def has_other(words: list[Word]) -> bool: return any(is_other(w.speaker) for w in words) def group_words(words: list[Word], max_words: int = MAX_WORDS) -> list[list[Word]]: """Blocos da legenda (palavras já saneadas por `clean_words`).""" max_chars = MAX_CHARS + 6 * max(0, max_words - MAX_WORDS) groups: list[list[Word]] = [] for word in clean_words(words): current = groups[-1] if groups else None if (current and same_speaker(current[-1], word) and word.start - current[-1].end <= MAX_GAP_S and word.end - current[0].start <= MAX_BLOCK_S): fits = len(" ".join(w.word for w in current + [word])) <= max_chars room = len(current) < max_words or ( # Fala rápida: o bloco cheio passaria voando; uma palavra a mais (se couber) dá tempo de ler. 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), em ordem de início. Cada faixa (streamer / outra pessoa; ver `lane`) é agrupada sozinha e um bloco nunca mistura falantes. O fim nunca passa do início do bloco seguinte DA MESMA FAIXA: dois eventos no mesmo lugar ao mesmo tempo ficariam um em cima do outro. Blocos de faixas diferentes podem se sobrepor (os dois falando juntos): cada um vai para a sua linha.""" out = [] for name in (STREAMER_LANE, OTHER_LANE): groups = group_words([w for w in words if lane(w.speaker) == name], max_words) for k, group in enumerate(groups): end = max(group[-1].end, group[-1].start + MIN_HOLD_S) if k + 1 < len(groups): end = min(end, groups[k + 1][0].start) out.append((group, round(end, 3))) out.sort(key=lambda item: (item[0][0].start, lane(item[0][0].speaker))) return out def other_size(cap: dict) -> int: """Tamanho da fala de outra pessoa: `caption.otherSize` ou, vazio, 85 % do tamanho da legenda.""" chosen = cap.get("otherSize") return int(chosen) if chosen else max(30, int(round(int(cap["size"]) * OTHER_SIZE_RATIO))) def other_color(cap: dict) -> str: return str(cap.get("otherColor") or layout.DEFAULTS["caption"]["otherColor"]) def other_offset(size: int, osize: int, extra: int = 0) -> int: """Distância (px) do centro da linha do streamer ao centro da linha de outra pessoa (logo abaixo). `extra` = espaço a mais entre as duas (a tradução de desenvolvimento do streamer fica nele).""" return int(round(0.6 * size + 0.6 * osize)) + LINE_GAP_PX + extra def other_y(y: int, offset: int, osize: int, canvas_h: int) -> int: """Centro da linha de outra pessoa: abaixo da do streamer; sem espaço até a borda, acima dela.""" below = y + offset return below if below + int(0.6 * osize) <= canvas_h - 8 else max(int(0.6 * osize), y - offset) PHRASE_GAP_S, PHRASE_MAX_S, PHRASE_MAX_WORDS = 0.7, 6.0, 16 _SENTENCE_END = (".", "?", "!") def phrases(words: list[Word], with_speaker: bool = False) -> list[tuple]: """Fala em frases curtas com tempo (início, fim, texto) para traduzir: quebra em pausa > 0,7 s, fim de frase (. ? !) com 4+ palavras, 16 palavras ou 6 s. A tradução de uma frase inteira sai melhor que a de blocos de 3. Uma frase nunca mistura falantes (quem fala junto vira frase própria). `with_speaker` = devolve (início, fim, texto, falante), com falante "streamer" ou "otherN".""" out: list[tuple] = [] def flush(current: list[Word]) -> None: item = (current[0].start, current[-1].end, " ".join(x.word for x in current)) out.append(item + (current[0].speaker or STREAMER,) if with_speaker else item) by_speaker: dict[str, list[Word]] = {} for w in words: by_speaker.setdefault(w.speaker or STREAMER, []).append(w) for speaker_words in by_speaker.values(): current: list[Word] = [] for w in clean_words(speaker_words): if current and (w.start - current[-1].end > PHRASE_GAP_S or w.end - current[0].start > PHRASE_MAX_S or len(current) >= PHRASE_MAX_WORDS or (current[-1].word.endswith(_SENTENCE_END) and len(current) >= 4)): flush(current) current = [] current.append(w) if current: flush(current) out.sort(key=lambda item: item[0]) return out 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(), w.speaker) for w in words if w.end > clip_start and w.start < clip_end ] base, high, outline = layout.ass_color(cap["color"]), layout.ass_color(cap["highlight"]), layout.ass_color(cap["outline"]) credit_align, credit_side, credit_margin = layout.credit_placement(cfg) width, height = layout.canvas_size(cfg) two = cap["enabled"] and has_other(inside) osize = other_size(cap) # Estilo da fala de outra pessoa só quando há outra pessoa: o ASS de um corte só com o streamer fica igual. other_style = (f"Style: CaptionOther,{cap['font']},{osize},{layout.ass_color(other_color(cap))}," f"{layout.ass_color(other_color(cap))},{outline},&H80000000,-1,0,0,0,100,100,0,0,1," f"{max(2, int(cap['outlineWidth']) * osize // int(cap['size']))},3,5,60,60,0,1\n") if two else "" header = f"""[Script Info] ScriptType: v4.00+ PlayResX: {width} 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 {other_style}Style: Credit,Arial,{cred['size']},&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,1,{credit_align},{credit_side},{credit_side},{credit_margin},1 [Events] Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text """ lines = [] if credit and cred["enabled"]: lines.append(f"Dialogue: 1,{_ts(0)},{_ts(duration)},Credit,,0,0,0,,{_escape(credit)}") if cap["enabled"]: y = layout.caption_y(cfg) offset = other_offset(int(cap["size"]), osize) if two: # sem espaço embaixo para a outra pessoa, a linha do streamer sobe (a ordem nunca inverte) y = min(y, height - 8 - offset - int(0.6 * osize)) oy = other_y(y, offset, osize, height) high = layout.ass_inline_color(cap["highlight"]) for group, g_end in caption_blocks(inside, cap["maxWords"]): other = lane(group[0].speaker) == OTHER_LANE pos = f"{{\\pos({width // 2},{oy if other else y})}}" style = "CaptionOther" if other else "Caption" base = layout.ass_inline_color(other_color(cap) if other else cap["color"]) for i, word in enumerate(group): # Cada palavra tem seu tempo na tela; o bloco inteiro aparece com a palavra atual destacada. start = word.start 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)},{style},,0,0,0,,{pos}{' '.join(parts)}") return header + "\n".join(lines) + "\n"