"""Reenquadramento do jogo no tempo (câmera virtual com keyframes) e camadas inseridas (recorte da tela em destaque). Pedido do dono (17/11/2026, corte 61 em câmera-em-cima): "na hora que ele abre o inventário preciso pegar um ângulo melhor; se quero mostrar alguma coisa no canto da tela, criar camadas para isso". **Reenquadramento** (`project.reframe.keys`): janela (centro `cx`, `cy` e largura `w`, frações do quadro ORIGINAL) que vira a área do jogo do layout daquele instante. A altura sai da proporção da área de destino (parte de baixo no `cam_top`; a tela toda nos outros), então nunca distorce. Enquanto houver keys, `layout.game` é ignorado (os keys são absolutos no quadro original). Não vale para `cam_only`. Interpolação entre keys pelo `ease` do key de saída: `smooth` (suave), `linear` ou `hold` (segura e salta no key seguinte). Antes do 1º e depois do último, segura. No FFmpeg: `perspective` com `eval=frame` — os 4 cantos da janela (expressões do nº do quadro `in`) viram o quadro inteiro com interpolação SUBPIXEL, depois `scale` para a área de destino. Medido (protótipo, zoom de 1,0 → 0,4 em 4 s num 1280×720): nenhum passo para trás entre quadros, desvio da aceleração 0,12 px (sem tremida), 0,38 s de render. `scale` com `eval=frame` + `crop` de tamanho fixo, a alternativa, falhou no encoder (tamanho variável) e arredonda o deslocamento a pixels inteiros. **Camadas inseridas** (`overlays[]` com `kind: "inset"`): recorte `src` do quadro original, posto em `x`/`y` (centro) com largura `size` da tela; borda, cantos arredondados, sombra e animação. Vêm do vídeo original (antes do layout), ficam acima do vídeo/zoom e abaixo da legenda, gancho, textos e chat (o ASS vem depois). Ordem no array = empilhamento. No FFmpeg: `crop` → `scale` (tamanho-base fixo) → `alphamerge` com a máscara dos cantos → por cima de UMA imagem de decoração (sombra borrada + borda, gerada aqui com numpy/OpenCV) → `scale` por quadro só se o tamanho muda (keys, pop) → `fade` de alfa → um `overlay` sobre o vídeo (expressão por quadro só se a posição muda: keys, slide). Medido no corte 61 (60 s, NVENC): sem nada 6,1–6,2 s; com reenquadramento 7,1–9,5 s; com reenquadramento + 2 camadas (pop e slide) 15,8–20,5 s (com sombra, borda e recorte postos separados: 28,2 s). """ from __future__ import annotations from dataclasses import dataclass from pathlib import Path FPS = 30 EASES = ("smooth", "linear", "hold") INSET_ANIMS = ("pop", "fade", "slide", "none") MAX_KEYS = 60 MAX_INSETS = 12 ANIM_S = 0.18 # entrada/saída de alfa das camadas SLIDE_S = 0.35 SHADOW_ALPHA = 0.55 # ---------------------------------------------------------------- interpolação (Python e expressão do FFmpeg) def _smooth(u: float) -> float: return u * u * (3 - 2 * u) def interp(keys: list[dict], t: float, field: str) -> float: """Valor de `field` no instante `t` (mesmo resultado da expressão do FFmpeg).""" if t <= keys[0]["t"]: return float(keys[0][field]) for a, b in zip(keys, keys[1:]): if t < b["t"]: ease = a.get("ease", "smooth") if ease == "hold": return float(a[field]) u = (t - a["t"]) / max(1e-3, b["t"] - a["t"]) u = _smooth(u) if ease == "smooth" else u return float(a[field]) + (float(b[field]) - float(a[field])) * u return float(keys[-1][field]) def piecewise(keys: list[dict], field: str, var: str) -> str: """Expressão do FFmpeg equivalente a `interp` (variável de tempo `var`, já entre parênteses).""" expr = f"{float(keys[-1][field]):.5f}" for a, b in reversed(list(zip(keys, keys[1:]))): va, vb = float(a[field]), float(b[field]) ease = a.get("ease", "smooth") if ease == "hold" or abs(vb - va) < 1e-9: seg = f"{va:.5f}" else: u = f"clip(({var}-{a['t']:.4f})/{max(1e-3, b['t'] - a['t']):.4f},0,1)" u = f"({u}*{u}*(3-2*{u}))" if ease == "smooth" else u seg = f"({va:.5f}+{vb - va:.5f}*{u})" expr = f"if(lt({var},{b['t']:.4f}),{seg},{expr})" return expr def keys_for_range(keys: list[dict], a: float, b: float) -> list[dict]: """Só os keys que influenciam [a, b] (o último antes de `a`, os de dentro e o primeiro depois de `b`).""" if not keys: return [] first = max([i for i, k in enumerate(keys) if k["t"] <= a], default=0) last = min([i for i, k in enumerate(keys) if k["t"] >= b], default=len(keys) - 1) return keys[first: last + 1] # ---------------------------------------------------------------- reenquadramento def window(keys: list[dict], t: float, src_w: float, src_h: float, dest_aspect: float) -> tuple[float, float, float, float]: """(x, y, largura, altura) em px do quadro original no instante `t` (presa dentro do quadro, sem deformar).""" ww = min(src_w * interp(keys, t, "w"), src_h * dest_aspect) wh = ww / dest_aspect x = min(max(src_w * interp(keys, t, "cx") - ww / 2, 0.0), src_w - ww) y = min(max(src_h * interp(keys, t, "cy") - wh / 2, 0.0), src_h - wh) return x, y, ww, wh def perspective_filter(keys: list[dict], piece_start: float, piece_end: float, dest_aspect: float) -> str: """`perspective` cujos 4 cantos são a janela no tempo da SESSÃO (o trecho começa em `piece_start`; o filtro conta os quadros do trecho em `in`, que começa em 1, a 30 qps). Saída do tamanho da entrada; o layout escala para a área de destino.""" ks = keys_for_range(keys, piece_start, piece_end) # `in` do perspective começa em 1 no 1º quadro (medido: com in/30 a janela ia 1 quadro adiantada). var = f"({piece_start:.4f}+(in-1)/{FPS})" a = f"{dest_aspect:.6f}" ww = f"st(1,min(W*({piecewise(ks, 'w', var)}),H*{a}))" left = f"{ww};st(2,clip(W*({piecewise(ks, 'cx', var)})-ld(1)/2,0,W-ld(1)))" top = f"{ww};st(3,ld(1)/{a});st(4,clip(H*({piecewise(ks, 'cy', var)})-ld(3)/2,0,H-ld(3)))" x_l, x_r = f"{left};ld(2)", f"{left};ld(2)+ld(1)" y_t, y_b = f"{top};ld(4)", f"{top};ld(4)+ld(3)" return (f"perspective=x0='{x_l}':y0='{y_t}':x1='{x_r}':y1='{y_t}':x2='{x_l}':y2='{y_b}':x3='{x_r}':y3='{y_b}'" f":interpolation=linear:sense=source:eval=frame") def piece_reframe(project: dict, piece_start: float, piece_end: float): """Função (proporção de destino → filtro) para `layout.layout_chain`, ou None sem reenquadramento.""" keys = (project.get("reframe") or {}).get("keys") or [] if not keys: return None return lambda dest_aspect: perspective_filter(keys, piece_start, piece_end, dest_aspect) def static_reframe(project: dict, t: float): """Reenquadramento parado no instante `t` (capa): mesma janela, sem animação.""" keys = (project.get("reframe") or {}).get("keys") or [] if not keys: return None frozen = [{"t": 0.0, "cx": interp(keys, t, "cx"), "cy": interp(keys, t, "cy"), "w": interp(keys, t, "w"), "ease": "hold"}] return lambda dest_aspect: perspective_filter(frozen, 0.0, 1.0, dest_aspect) # ---------------------------------------------------------------- camadas inseridas @dataclass class InsetPlan: """Uma camada pronta para o grafo. A camada vira UMA imagem composta (sombra + borda + recorte) de tamanho `decor_w`×`decor_h`, com o recorte em (`ox`, `oy`); só ela é posta sobre o vídeo (um overlay grande por camada). Medido no corte 61 (60 s): com sombra, borda e recorte postos separados no quadro inteiro, 2 camadas levavam o render de 7,1 s para 28,2 s.""" inset: dict a: float # entrada (tempo de saída) b: float # saída base_w: int # recorte em px do vídeo (no maior tamanho dos keys) base_h: int ox: int # posição do recorte dentro da imagem composta oy: int decor_w: int decor_h: int mask_file: Path decor_file: Path | None # sombra + borda (None = sem nenhuma das duas) keys: list[dict] # keys em tempo de SAÍDA (x, y, size, ease) @property def dynamic_size(self) -> bool: return self.inset["anim"] == "pop" or len({k["size"] for k in self.keys}) > 1 @property def dynamic_pos(self) -> bool: return self.inset["anim"] == "slide" or len({(k["x"], k["y"]) for k in self.keys}) > 1 def _rounded_alpha(w: int, h: int, radius: float): import numpy as np yy, xx = np.mgrid[0:h, 0:w].astype(np.float32) + 0.5 r = max(0.0, min(radius, w / 2, h / 2)) if r <= 0: return np.ones((h, w), np.float32) dx = np.maximum(np.maximum(r - xx, xx - (w - r)), 0) dy = np.maximum(np.maximum(r - yy, yy - (h - r)), 0) return np.clip(r - np.sqrt(dx * dx + dy * dy) + 0.5, 0, 1) def _make_images(plan: InsetPlan, border_color: str | None, pad: int, shadow_pad: int, radius_px: float) -> None: """Máscara dos cantos (tamanho do recorte) e a imagem de decoração (sombra borrada + borda), em PNG.""" import cv2 import numpy as np w, h = plan.base_w, plan.base_h cv2.imwrite(str(plan.mask_file), (_rounded_alpha(w, h, radius_px) * 255).astype(np.uint8)) if plan.decor_file is None: return rgb = np.zeros((plan.decor_h, plan.decor_w, 3), np.float32) alpha = np.zeros((plan.decor_h, plan.decor_w), np.float32) bw, bh = w + 2 * pad, h + 2 * pad outer = _rounded_alpha(bw, bh, radius_px + pad if radius_px else 0) x0, y0 = plan.ox - pad, plan.oy - pad if shadow_pad: off = max(1, shadow_pad // 2) shadow = np.zeros_like(alpha) shadow[y0 + off: y0 + off + bh, x0 + off: x0 + off + bw] = outer alpha = cv2.GaussianBlur(shadow, (0, 0), sigmaX=max(1.0, shadow_pad / 2.5)) * SHADOW_ALPHA if pad and border_color: color = np.array([int(border_color[i: i + 2], 16) for i in (5, 3, 1)], np.float32) # BGR a_b = np.zeros_like(alpha) a_b[y0: y0 + bh, x0: x0 + bw] = outer rgb = (color * a_b[..., None] + rgb * (alpha * (1 - a_b))[..., None]) / np.maximum( (a_b + alpha * (1 - a_b))[..., None], 1e-6) alpha = a_b + alpha * (1 - a_b) img = np.dstack([np.clip(rgb, 0, 255), alpha * 255]).astype(np.uint8) cv2.imwrite(str(plan.decor_file), img) def plan_insets(project: dict, cuts_to_output, t0: float, t1: float, frame: tuple[int, int], canvas_w: int, src_size: tuple[int, int], work: Path, stem: str) -> list[InsetPlan]: """Camadas que aparecem na saída [t0, t1], com tamanhos em px e as imagens auxiliares geradas em `work`.""" fw, _fh = frame k = fw / canvas_w # px do quadro lógico (borda, raio) → px do vídeo plans = [] for n, o in enumerate(x for x in project["overlays"] if x["kind"] == "inset"): a, b = cuts_to_output(o["start"]), cuts_to_output(o["end"]) if b - a < 0.05 or b <= t0 or a >= t1: continue keys = [{"t": cuts_to_output(x["t"]), "x": x["x"], "y": x["y"], "size": x["size"], "ease": x.get("ease", "smooth")} for x in o.get("keys") or []] or [{"t": a, "x": o["x"], "y": o["y"], "size": o["size"], "ease": "hold"}] top_size = max(x["size"] for x in keys) src = o["src"] base_w = max(8, int(round(top_size * fw / 2)) * 2) base_h = max(8, int(round(base_w * (src["h"] * src_size[1]) / (src["w"] * src_size[0]) / 2)) * 2) pad = int(round(o["borderW"] * k)) if o["border"] else 0 shadow_pad = max(6, int(round(0.03 * base_w))) if o["shadow"] else 0 decor = pad > 0 or shadow_pad > 0 margin = pad + shadow_pad tag = f"{stem}-inset{n}" plan = InsetPlan(o, a, b, base_w, base_h, margin, margin, base_w + 2 * margin + shadow_pad // 2 if decor else base_w, base_h + 2 * margin + shadow_pad // 2 if decor else base_h, work / f"{tag}-mask.png", work / f"{tag}-decor.png" if decor else None, keys) _make_images(plan, o["border"], pad, shadow_pad, o["radius"] * k) plans.append(plan) return plans def inset_graph(plans: list[InsetPlan], inputs: list[dict], base: str, raw: str, t0: float, frame: tuple[int, int], out: str) -> list[str]: """Trechos do filter_complex: [base] (vídeo já no layout) + camadas → [out]. `raw` = vídeo original concatenado; `inputs[i]` = {"mask": idx, "decor": idx|None} das entradas PNG (em loop) de cada camada. Tamanho e posição só viram expressão por quadro quando mudam (keys, pop, slide).""" fw, fh = frame g = [f"[{raw}]split={len(plans)}" + "".join(f"[ir{i}]" for i in range(len(plans))) if len(plans) > 1 else f"[{raw}]null[ir0]"] cur = base T = f"(t+{t0:.3f})" for i, (p, idx) in enumerate(zip(plans, inputs)): o, src = p.inset, p.inset["src"] a, b = p.a - t0, p.b - t0 # tempo do grafo (a prévia começa em 0) g.append(f"[ir{i}]crop=iw*{src['w']}:ih*{src['h']}:iw*{src['x']}:ih*{src['y']},scale={p.base_w}:{p.base_h}," f"setsar=1,format=rgba[iv{i}]") g.append(f"[{idx['mask']}:v]format=gray[im{i}]") g.append(f"[iv{i}][im{i}]alphamerge[ia{i}]") comp = f"ia{i}" if idx.get("decor") is not None: # recorte por cima da sombra + borda (imagem pequena, uma vez por quadro) g.append(f"[{idx['decor']}:v]format=rgba[id{i}]") g.append(f"[id{i}][ia{i}]overlay={p.ox}:{p.oy}:format=rgb[ic{i}]") comp = f"ic{i}" chain = [] if p.dynamic_size: k = f"(({piecewise(p.keys, 'size', T)})/{p.base_w / fw:.5f})" if o["anim"] == "pop": # cresce de 82 % a 106 % e assenta em 100 % k += (f"*if(lt({T}-{p.a:.3f},0.16),0.82+0.24*({T}-{p.a:.3f})/0.16," f"if(lt({T}-{p.a:.3f},0.28),1.06-0.06*({T}-{p.a:.3f}-0.16)/0.12,1))") chain.append(f"scale=w='max(2,round({p.decor_w}*{k}))':h='max(2,round({p.decor_h}*{k}))':eval=frame") elif p.keys[0]["size"] * fw < p.base_w - 1: # tamanho fixo menor que o maior dos keys (não acontece sem keys) s = p.keys[0]["size"] * fw / p.base_w chain.append(f"scale={max(2, round(p.decor_w * s))}:{max(2, round(p.decor_h * s))}") if o["anim"] != "none": chain.append(f"fade=t=in:st={max(0.0, a):.3f}:d={ANIM_S}:alpha=1") chain.append(f"fade=t=out:st={max(0.0, b - ANIM_S):.3f}:d={ANIM_S}:alpha=1") if chain: g.append(f"[{comp}]" + ",".join(chain) + f"[if{i}]") comp = f"if{i}" fx, fy = (p.ox + p.base_w / 2) / p.decor_w, (p.oy + p.base_h / 2) / p.decor_h # centro do recorte na imagem if p.dynamic_pos: dx = "" if o["anim"] == "slide": # entra pela direita u = f"clip(({T}-{p.a:.3f})/{SLIDE_S},0,1)" dx = f"+{fw * 0.7:.1f}*(1-{u}*{u}*(3-2*{u}))" pos = (f"x='{fw}*({piecewise(p.keys, 'x', T)}){dx}-w*{fx:.5f}':" f"y='{fh}*({piecewise(p.keys, 'y', T)})-h*{fy:.5f}':eval=frame") else: pos = f"x='{fw * p.keys[0]['x']:.2f}-w*{fx:.5f}':y='{fh * p.keys[0]['y']:.2f}-h*{fy:.5f}'" nxt = out if i == len(plans) - 1 else f"li{i}" g.append(f"[{cur}][{comp}]overlay={pos}:enable='between(t,{a:.3f},{b:.3f})'[{nxt}]") cur = nxt return g