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:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+283
View File
@@ -0,0 +1,283 @@
"""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