Clipador (fila de cortes) - Seletor "Ordenar": mais novos, mais antigos, maior/menor nota da IA, sinal mais forte e mais longos; a escolha fica lembrada no navegador. - A fila abre filtrada pela sessão que está gravando. - Gancho automático logo abaixo da câmera e legenda desviada enquanto o gancho a cobriria; posição do gancho editável no painel. Publicação - "Publicar este corte" ganha "Horário específico": um dia e hora para todas as redes ou um diferente por rede (timing "at" + scheduledAt por rede na rota POST /api/publishing/clips/[id]), com validação e testes. - Capa do vídeo publicado copiada para output/publishing/covers/: apagar a sessão no Clipador não quebra mais a miniatura do dashboard; jobs antigos migram no ciclo de sincronização. - Dashboard só usa capa que existe no disco; corrige a regex do número do episódio (link do episódio). - Canais de publicação: seletor compacto de canais e detalhe reorganizado. - Publicador: confirmação pela página pública quando o YouTube Studio fica com a caixa de envio aberta; estatísticas por rede. Skill cenaforge 1.44.0 com as regras e a armadilha das capas. Testes: painel 68/68, Clipador 279, Publicador 84. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
444 lines
22 KiB
Python
444 lines
22 KiB
Python
"""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,
|
||
},
|
||
"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 _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")
|
||
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()
|