CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,415 @@
|
||||
"""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")
|
||||
# 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,
|
||||
},
|
||||
"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).
|
||||
"hook": {"style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": HOOK_FONT, "anim": "slide", "seconds": 3.0},
|
||||
# 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 _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"):
|
||||
if key in cap:
|
||||
o[key] = bool(cap[key])
|
||||
out["caption"] = o
|
||||
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")
|
||||
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 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()
|
||||
Reference in New Issue
Block a user