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