Files
CenaForge/clipper/app/reframe.py
T
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

284 lines
15 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.
"""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