Files
CenaForge/clipper/app/layout.py
T
MateuusandClaude Opus 5.5 54eac7cebf Clipador: grupo dev (camadas só do vídeo de revisão) e render com dev=False
Base comum para três frentes em paralelo (vídeo final ao aprovar, dublagem, falantes):
- layout: grupo `dev` {translation, dub}; `dev_flags(cfg, dev)` desliga tudo no vídeo final;
  `caption.translation` vira legado de `dev.translation`.
- editor_render.build_project_ass / render_project e editor_api.translation_for: parâmetro
  `dev` (padrão True = revisão; False = final, sem camadas de desenvolvimento).
- Painel: switch da tradução passa a gravar em `dev.translation`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:09:31 -03:00

465 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Configuração do corte: formato (vertical/horizontal), layout, câmera do streamer, legenda, crédito e duração.
Fica por CANAL (padrão do streamer: a webcam dele mora sempre no mesmo canto) e pode ser sobrescrita por SESSÃO.
Efetiva = padrão ← canal ← sessão (campo a campo). O painel edita pelo modal de "Configuração do corte".
Formato (`format.aspect`):
- `vertical` (padrão): 1080×1920, para Shorts/Reels/TikTok;
- `horizontal`: 1920×1080, para o YouTube "tela grande" mostrando o próprio jogo.
Layouts no vertical (1080×1920):
- `blur`: vídeo 16:9 inteiro no meio, o próprio vídeo ampliado e desfocado no fundo (sem câmera definida);
- `cam_top`: webcam recortada em cima (`camHeight` da altura, padrão 1/3) + jogo embaixo, recortado no centro;
- `game_only`: só o jogo, recortado para preencher a tela (ou a região `game`, se definida);
- `cam_only`: a câmera do streamer em tela cheia.
No horizontal (1920×1080) só existem dois resultados: `cam_only` (câmera em tela cheia, se marcada) e "quadro
inteiro" (`full`, interno) para todos os outros modos — o quadro original inteiro, ou a região `game` se marcada.
Retângulos (`cam`, `game`) são normalizados 0–1 sobre o quadro original (x, y, w, h).
Textos (legenda, crédito, gancho, textos, chat, capa) são desenhados em ASS num QUADRO LÓGICO (`canvas_size`):
no vertical é o próprio 1080×1920; no horizontal é 2560×1440, que o libass reduz para 1920×1080 (escala 0,75).
Assim os mesmos tamanhos em px (legenda 84, gancho 68…) ficam proporcionais à altura menor do horizontal sem
mudar o JSON. Posições 0–1 continuam relativas ao quadro.
"""
from __future__ import annotations
import copy
import hashlib
import json
import logging
import re
from pathlib import Path
log = logging.getLogger("cenaforge_clipper.layout")
ASPECTS = ("vertical", "horizontal")
# Qualidades de gravação da live (grupo `capture`; regras e medições em app/capture.py).
CAPTURE_QUALITIES = ("best", "1440p", "1080p", "720p", "480p")
FRAME_SIZES = {"vertical": (1080, 1920), "horizontal": (1920, 1080)}
# Quadro lógico do ASS: no horizontal, 2560×1440 → o vídeo 1920×1080 mostra os textos a 75 %.
CANVAS_SIZES = {"vertical": (1080, 1920), "horizontal": (2560, 1440)}
W, H = FRAME_SIZES["vertical"] # compatibilidade: o quadro do vertical (padrão)
# cam_only = a câmera do streamer em tela cheia (sem o jogo), para o trecho em que a reação é o assunto.
MODES = ("auto", "blur", "cam_top", "game_only", "cam_only")
HEX_RE = re.compile(r"^#[0-9A-Fa-f]{6}$")
SYSTEM_FONTS = ("Arial Black", "Arial", "Impact", "Verdana", "Segoe UI Black", "Trebuchet MS")
# Fontes de vídeo curto EMPACOTADAS no repositório (assets/fonts, pasta plana: o fontsdir do libass não lê subpastas),
# com licença livre ao lado de cada arquivo e sha256 no fonts.lock.json. Pedido do dono (17/11/2026): escolher fonte
# na legenda, no gancho e nos textos.
FONTS_DIR = Path(__file__).resolve().parents[2] / "assets" / "fonts"
def _load_packaged_fonts(folder: Path) -> dict[str, str]:
"""{família: caminho relativo à raiz do repositório} das fontes do lock que existem e batem o sha256."""
try:
lock = json.loads((folder / "fonts.lock.json").read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
out = {}
for entry in lock.get("files", []):
file = folder.parent.parent / entry["path"]
try:
ok = hashlib.sha256(file.read_bytes()).hexdigest() == entry["sha256"]
except OSError:
ok = False
if ok:
out[entry["family"]] = entry["path"]
else:
log.warning("fonte %s ausente ou com sha256 diferente do lock: fora da lista", entry.get("path"))
return out
PACKAGED_FONTS = _load_packaged_fonts(FONTS_DIR)
FONTS = SYSTEM_FONTS + tuple(PACKAGED_FONTS)
HOOK_STYLES = ("plain", "banner")
HOOK_ANIMS = ("pop", "fade", "none", "slide")
HOOK_Y_RANGE = (0.04, 0.96)
# Gancho automático com a câmera em cima: centro logo abaixo da emenda câmera/jogo. Pedido do dono (17/11/2026): no
# editor ele pôs 0,384 com a câmera em 0,34 ("ficou perfeito") — antes o automático ia para 0,14, em cima do rosto.
HOOK_BELOW_CAM = 0.044
# Gancho em tarja (referência do dono, 17/11/2026: tarja verde-limão atravessa a tela e o texto entra borrado e assenta
# nítido, letras brancas "cartoon" com contorno preto). Fonte padrão: Luckiest Guy, se estiver empacotada.
HOOK_FONT = "Luckiest Guy" if "Luckiest Guy" in PACKAGED_FONTS else "Arial Black"
# Margem do mínimo (pedido do dono, 17/11/2026: "se o mínimo é 60 tem que ser 60; o certo é sempre 1 s a mais").
# +0,1 s de folga cobre o arredondamento de quadro e do contêiner no arquivo final.
DURATION_MARGIN_S = 1.0
DURATION_SLACK_S = 0.1
DEFAULTS: dict = {
"layout": {"mode": "auto", "cam": None, "game": None, "camHeight": 0.34},
"caption": {
"enabled": True, "font": "Arial Black", "size": 84, "color": "#FFFFFF", "highlight": "#FFE500",
"outline": "#000000", "outlineWidth": 7, "y": None, "uppercase": True, "maxWords": 3,
# Legado (18/11/2026, manhã): virou `dev.translation`. Ainda lido por `dev_flags` (camadas já salvas).
"translation": False,
},
# Camadas SÓ DE DESENVOLVIMENTO (doc/clipador/IDIOMAS.md): entram no vídeo de revisão (antes de aprovar) e NUNCA no
# vídeo final — o render com `dev=False` ignora este grupo inteiro. `translation`: português embaixo da legenda;
# `dub`: dublagem em português por TTS com a voz original abaixada.
"dev": {"translation": False, "dub": False},
"credit": {"enabled": True, "position": "top", "size": 44},
"duration": {"minS": 60, "maxS": 90, "backtrackS": 120},
"format": {"aspect": "vertical"},
# Gancho que o projeto da IA põe no começo do corte (o editor pode trocar por corte).
# `y` = centro do gancho em fração da altura; None = automático (logo abaixo da câmera; ver `hook_y`).
"hook": {"style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": HOOK_FONT, "anim": "slide", "seconds": 3.0,
"y": None},
# Qualidade de GRAVAÇÃO da live (app/capture.py): `best` = a maior que a live oferece; os outros são teto.
# Vale na próxima gravação ou retomada (a captura em andamento não troca de qualidade no meio).
"capture": {"quality": "best"},
}
class LayoutError(ValueError):
pass
def merge(*layers: dict | None) -> dict:
"""Mescla campo a campo (padrão ← canal ← sessão). Camadas vazias são ignoradas."""
out = copy.deepcopy(DEFAULTS)
for layer in layers:
for group, values in (layer or {}).items():
if group in out and isinstance(values, dict):
out[group].update({k: v for k, v in values.items() if k in out[group]})
return out
def dev_flags(settings: dict, dev: bool = True) -> dict:
"""Camadas de desenvolvimento ligadas neste render. `dev=False` (vídeo final, depois de aprovar) = tudo desligado.
`caption.translation` (legado) conta como `dev.translation`."""
if not dev:
return {"translation": False, "dub": False}
group = {**DEFAULTS["dev"], **(settings.get("dev") or {})}
return {"translation": bool(group["translation"] or (settings.get("caption") or {}).get("translation")),
"dub": bool(group["dub"])}
def _rect(value, name: str) -> dict | None:
if value is None:
return None
if not isinstance(value, dict) or set(value) != {"x", "y", "w", "h"}:
raise LayoutError(f"{name} precisa ser {{x, y, w, h}} (0–1) ou null")
r = {k: float(value[k]) for k in ("x", "y", "w", "h")}
if not (0 <= r["x"] < 1 and 0 <= r["y"] < 1 and 0.03 <= r["w"] <= 1 and 0.03 <= r["h"] <= 1
and r["x"] + r["w"] <= 1.0001 and r["y"] + r["h"] <= 1.0001):
raise LayoutError(f"{name} fora do quadro (valores 0–1, largura/altura ≥ 0,03)")
return {k: round(v, 4) for k, v in r.items()}
def validate(settings: dict) -> dict:
"""Valida uma camada parcial (canal ou sessão) e devolve só os campos conhecidos, normalizados."""
if not isinstance(settings, dict):
raise LayoutError("configuração precisa ser um objeto")
out: dict = {}
lay = settings.get("layout")
if lay is not None:
o: dict = {}
if "mode" in lay:
if lay["mode"] not in MODES:
raise LayoutError(f"layout.mode precisa ser um de {', '.join(MODES)}")
o["mode"] = lay["mode"]
if "cam" in lay:
o["cam"] = _rect(lay["cam"], "layout.cam")
if "game" in lay:
o["game"] = _rect(lay["game"], "layout.game")
if "camHeight" in lay:
o["camHeight"] = float(lay["camHeight"])
if not 0.2 <= o["camHeight"] <= 0.6:
raise LayoutError("layout.camHeight vai de 0,2 a 0,6")
out["layout"] = o
cap = settings.get("caption")
if cap is not None:
o = {}
for key in ("color", "highlight", "outline"):
if key in cap:
if not HEX_RE.match(str(cap[key])):
raise LayoutError(f"caption.{key} precisa ser cor #RRGGBB")
o[key] = str(cap[key]).upper()
if "font" in cap:
if cap["font"] not in FONTS:
raise LayoutError(f"caption.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = cap["font"]
for key, lo, hi in (("size", 40, 140), ("outlineWidth", 0, 14), ("maxWords", 1, 6)):
if key in cap:
o[key] = int(cap[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"caption.{key} vai de {lo} a {hi}")
if "y" in cap:
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:
raise LayoutError("caption.y vai de 0,08 a 0,9 (fração da altura) ou null = automático")
for key in ("enabled", "uppercase", "translation"):
if key in cap:
o[key] = bool(cap[key])
out["caption"] = o
dev = settings.get("dev")
if dev is not None:
if not isinstance(dev, dict):
raise LayoutError("dev precisa ser um objeto")
out["dev"] = {k: bool(dev[k]) for k in ("translation", "dub") if k in dev}
cred = settings.get("credit")
if cred is not None:
o = {}
if "enabled" in cred:
o["enabled"] = bool(cred["enabled"])
if "position" in cred:
if cred["position"] not in ("top", "bottom"):
raise LayoutError("credit.position precisa ser top ou bottom")
o["position"] = cred["position"]
if "size" in cred:
o["size"] = int(cred["size"])
if not 24 <= o["size"] <= 80:
raise LayoutError("credit.size vai de 24 a 80")
out["credit"] = o
dur = settings.get("duration")
if dur is not None:
o = {}
for key, lo, hi in (("minS", 5, 120), ("maxS", 15, 180), ("backtrackS", 0, 120)):
if key in dur:
o[key] = float(dur[key])
if not lo <= o[key] <= hi:
raise LayoutError(f"duration.{key} vai de {lo} a {hi}")
out["duration"] = o
if "duration" in out and out["duration"].get("minS", 0) >= out["duration"].get("maxS", 999):
raise LayoutError("duration.minS precisa ser menor que maxS")
hook = settings.get("hook")
if hook is not None:
if not isinstance(hook, dict):
raise LayoutError("hook precisa ser um objeto")
o = {}
if "style" in hook:
if hook["style"] not in HOOK_STYLES:
raise LayoutError(f"hook.style precisa ser um de {', '.join(HOOK_STYLES)}")
o["style"] = hook["style"]
for key in ("bg", "color"):
if key in hook:
if not HEX_RE.match(str(hook[key])):
raise LayoutError(f"hook.{key} precisa ser cor #RRGGBB")
o[key] = str(hook[key]).upper()
if "font" in hook:
if hook["font"] not in FONTS:
raise LayoutError(f"hook.font precisa ser uma de {', '.join(FONTS)}")
o["font"] = hook["font"]
if "anim" in hook:
if hook["anim"] not in HOOK_ANIMS:
raise LayoutError(f"hook.anim precisa ser um de {', '.join(HOOK_ANIMS)}")
o["anim"] = hook["anim"]
if "seconds" in hook:
o["seconds"] = float(hook["seconds"])
if not 1 <= o["seconds"] <= 8:
raise LayoutError("hook.seconds vai de 1 a 8")
if "y" in hook:
if hook["y"] is None:
o["y"] = None
else:
o["y"] = round(float(hook["y"]), 3)
if not HOOK_Y_RANGE[0] <= o["y"] <= HOOK_Y_RANGE[1]:
raise LayoutError("hook.y vai de 0,04 a 0,96 (fração da altura) ou vazio para automático")
out["hook"] = o
fmt = settings.get("format")
if fmt is not None:
if not isinstance(fmt, dict):
raise LayoutError("format precisa ser um objeto")
o = {}
if "aspect" in fmt:
if fmt["aspect"] not in ASPECTS:
raise LayoutError(f"format.aspect precisa ser um de {', '.join(ASPECTS)}")
o["aspect"] = fmt["aspect"]
out["format"] = o
cap = settings.get("capture")
if cap is not None:
if not isinstance(cap, dict):
raise LayoutError("capture precisa ser um objeto")
o = {}
if "quality" in cap:
if cap["quality"] not in CAPTURE_QUALITIES:
raise LayoutError(f"capture.quality precisa ser um de {', '.join(CAPTURE_QUALITIES)}")
o["quality"] = cap["quality"]
out["capture"] = o
return out
def min_target(settings: dict) -> float:
"""Duração final mínima de um corte AUTOMÁTICO: `minS` + 1 s (+ folga de quadro), sem passar de `maxS`."""
dur = settings.get("duration") or DEFAULTS["duration"]
return round(min(float(dur["maxS"]), float(dur["minS"]) + DURATION_MARGIN_S + DURATION_SLACK_S), 3)
def font_files() -> dict[str, str]:
"""{família: caminho do arquivo relativo à raiz do repositório} das fontes empacotadas (o painel carrega o mesmo)."""
return dict(PACKAGED_FONTS)
def ass_filter(ass_name: str, ass_text: str | None = None) -> str:
"""`ass=<arquivo>`; com `:fontsdir=` (pasta das fontes empacotadas) só quando o ASS usa uma delas — assim o
filtro de projetos antigos (só fontes do Windows) fica idêntico ao de antes."""
if ass_text and PACKAGED_FONTS and any(f",{fam}," in ass_text or f"\\fn{fam}" in ass_text for fam in PACKAGED_FONTS):
# Caminho absoluto entre aspas, com ":" escapado (medido: sem aspas o FFmpeg recusa o grafo no Windows).
return f"ass={ass_name}:fontsdir='{FONTS_DIR.as_posix().replace(':', chr(92) + ':')}'"
return f"ass={ass_name}"
def aspect(settings: dict) -> str:
"""Formato do corte (`vertical` ou `horizontal`). Configuração sem o grupo `format` (antiga) = vertical."""
value = (settings.get("format") or {}).get("aspect", "vertical")
return value if value in ASPECTS else "vertical"
def frame_size(settings: dict) -> tuple[int, int]:
"""Tamanho do vídeo de saída (largura, altura)."""
return FRAME_SIZES[aspect(settings)]
def canvas_size(settings: dict) -> tuple[int, int]:
"""Quadro lógico do ASS (PlayResX, PlayResY): posições e tamanhos dos textos são contados nele."""
return CANVAS_SIZES[aspect(settings)]
def resolved_mode(settings: dict) -> str:
"""Modo efetivo do layout. No horizontal só há `cam_only` (com câmera marcada) e `full` (quadro inteiro)."""
mode = settings["layout"]["mode"]
if aspect(settings) == "horizontal":
return "cam_only" if mode == "cam_only" and settings["layout"]["cam"] else "full"
if mode == "auto":
return "cam_top" if settings["layout"]["cam"] else "blur"
if mode in ("cam_top", "cam_only") and not settings["layout"]["cam"]:
return "blur" # sem câmera marcada não dá para montar o layout com câmera
return mode
def _crop(rect: dict | None) -> str:
if not rect:
return "iw:ih:0:0"
return f"iw*{rect['w']}:ih*{rect['h']}:iw*{rect['x']}:ih*{rect['y']}"
def _fill(width: int, height: int) -> str:
"""Escala cobrindo e recorta no centro para width×height."""
return f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}"
def _fit(width: int, height: int) -> str:
"""Escala cabendo inteiro (sem cortar nem distorcer) e completa com faixas pretas até width×height."""
return (f"scale={width}:{height}:force_original_aspect_ratio=decrease:force_divisible_by=2,"
f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color=black")
def cam_panel_height(settings: dict) -> int:
"""Altura (px do vídeo vertical) do painel da câmera no `cam_top`."""
return int(round(H * settings["layout"]["camHeight"] / 2)) * 2
def layout_chain(settings: dict, src: str, dst: str, tail: str = "", suffix: str = "", mode: str | None = None,
reframe=None) -> str:
"""Trecho de filtergraph: [src] (quadro original) → [dst] no tamanho do formato (1080×1920 ou 1920×1080).
`tail` = filtros extras (com vírgula na frente) antes do rótulo final; `suffix` deixa os rótulos internos únicos
(vários trechos no mesmo grafo, no editor); `mode` sobrescreve o modo (troca de layout por trecho).
`reframe` = função (proporção da área do jogo → filtro, de `reframe.py`) que reenquadra o jogo no tempo: a janela
vira a área do jogo (parte de baixo no `cam_top`; a tela toda nos outros modos, inclusive `blur`) e `layout.game`
é ignorado. Não vale para `cam_only`."""
if mode and mode != "auto":
settings = {**settings, "layout": {**settings["layout"], "mode": mode}}
mode = resolved_mode(settings)
lay = settings["layout"]
s = suffix
if reframe is not None and mode != "cam_only":
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]{reframe(W / (H - top))},scale={W}:{H - top},setsar=1[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
fw, fh = frame_size(settings)
return f"[{src}]{reframe(fw / fh)},scale={fw}:{fh},setsar=1{tail}[{dst}]"
if aspect(settings) == "horizontal":
fw, fh = frame_size(settings)
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(fw, fh)}{tail}[{dst}]"
if lay["game"]: # região do jogo marcada: preenche a tela (recorta no centro, sem distorcer)
return f"[{src}]crop={_crop(lay['game'])},{_fill(fw, fh)}{tail}[{dst}]"
# Quadro original inteiro (16:9 já preenche; outra proporção ganha faixas pretas em vez de ser cortada).
return f"[{src}]{_fit(fw, fh)}{tail}[{dst}]"
if mode == "cam_top":
top = cam_panel_height(settings)
return (
f"[{src}]split=2[c{s}][g{s}];"
f"[c{s}]crop={_crop(lay['cam'])},{_fill(W, top)}[cam{s}];"
f"[g{s}]crop={_crop(lay['game'])},{_fill(W, H - top)}[game{s}];"
f"[cam{s}][game{s}]vstack=inputs=2{tail}[{dst}]"
)
if mode == "game_only":
return f"[{src}]crop={_crop(lay['game'])},{_fill(W, H)}{tail}[{dst}]"
if mode == "cam_only":
return f"[{src}]crop={_crop(lay['cam'])},{_fill(W, H)}{tail}[{dst}]"
return (
f"[{src}]split=2[bg{s}][fg{s}];"
f"[bg{s}]{_fill(W, H)},boxblur=25:2,eq=brightness=-0.08[bg2{s}];"
f"[fg{s}]scale=1080:-2[fg2{s}];"
f"[bg2{s}][fg2{s}]overlay=(W-w)/2:(H-h)/2-80{tail}[{dst}]"
)
def video_filter(settings: dict, ass_name: str | None, ass_text: str | None = None, reframe=None) -> str:
"""filter_complex de [0:v] → [v] no tamanho do formato, 30 fps, com a legenda (se houver). `ass_text` = conteúdo
do ASS (decide se o libass precisa da pasta das fontes empacotadas); `reframe` = ver `layout_chain`."""
tail = (f",{ass_filter(ass_name, ass_text)}" if ass_name else "") + ",fps=30,format=yuv420p"
return layout_chain(settings, "0:v", "v", tail, reframe=reframe)
def caption_y(settings: dict) -> int:
"""Centro vertical da legenda em px do quadro lógico do ASS (`canvas_size`). Automático: na emenda câmera/jogo
(cam_top) ou ~74 % da altura no vertical; no horizontal, 85 % da altura (terço de baixo, acima do rodapé)."""
y = settings["caption"]["y"]
_, ch = canvas_size(settings)
if y is not None:
return int(ch * y)
if aspect(settings) == "horizontal":
return int(ch * 0.85)
if resolved_mode(settings) == "cam_top":
return cam_panel_height(settings) + 40
return 1420
def hook_y(settings: dict) -> float:
"""Centro vertical do gancho (fração da altura do quadro). Escolhido em `hook.y` vale como está. Automático:
com a câmera em cima (vertical `cam_top`), logo abaixo dela — nunca por cima do rosto; nos outros layouts, 20 % da
altura, mudando de lado se cair em cima da legenda automática (a tarja tem até ~0,13 da altura)."""
chosen = (settings.get("hook") or {}).get("y")
if chosen is not None:
return float(chosen)
if aspect(settings) == "vertical" and resolved_mode(settings) == "cam_top":
return round(min(HOOK_Y_RANGE[1], settings["layout"]["camHeight"] + HOOK_BELOW_CAM), 3)
cap_y = caption_y(settings) / canvas_size(settings)[1]
if abs(cap_y - 0.2) < 0.2:
return round(cap_y - 0.22 if cap_y > 0.3 else min(0.85, cap_y + 0.22), 3)
return 0.2
def credit_placement(settings: dict) -> tuple[int, int, int]:
"""(alinhamento ASS, margem lateral, margem vertical) do crédito do canal no quadro lógico.
Vertical: centralizado, abaixo da área do título das redes (topo) ou acima da barra (rodapé); com a câmera em
cima, desce para o pé do painel da câmera. Horizontal: no canto direito, para não cobrir o meio do jogo."""
cred = settings["credit"]
if aspect(settings) == "horizontal":
return (9, 48, 36) if cred["position"] == "top" else (3, 48, 36)
align, margin = (8, 170) if cred["position"] == "top" else (2, 90)
if cred["position"] == "top" and resolved_mode(settings) == "cam_top":
# Com a câmera em cima, o topo é o rosto do streamer: o crédito desce para o pé do painel da câmera.
margin = max(20, cam_panel_height(settings) - cred["size"] - 34)
return align, 40, margin
def ass_color(hex_rgb: str) -> str:
"""#RRGGBB → &H00BBGGRR& para a linha Style (ASS guarda em BGR, com alfa na frente)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H00{b}{g}{r}&".upper()
def ass_inline_color(hex_rgb: str) -> str:
"""#RRGGBB → &HBBGGRR& para a tag \\c dentro do texto (sem alfa)."""
r, g, b = hex_rgb[1:3], hex_rgb[3:5], hex_rgb[5:7]
return f"&H{b}{g}{r}&".upper()