"""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=`; 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()