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
+728
View File
@@ -0,0 +1,728 @@
"""Editor de cortes: o PROJETO DE EDIÇÃO de um corte (JSON versionado, tabela `edits`) e as contas de tempo.
Fonte da verdade do editor do painel (`/clipper/edit/<id>`). O servidor sabe renderizar o projeto com FFmpeg
(`editor_render.py`). Ideias tiradas do OpenCut (MIT; só o padrão, nenhum código copiado): trilhas por papel
(vídeo, legenda, textos, áudio), elementos com início/fim, desfazer por instantâneos e atalhos J/K/L/S.
Tempos:
- **tempo da sessão** (`t` da gravação): `cuts`, palavras da legenda, textos, zooms, narração e capa. Assim,
remover um pedaço do meio não desloca o que está ancorado no conteúdo (o zoom continua na reação);
- **tempo de saída** (segundos do MP4): só o gancho (`kind: "hook"`), que vale a partir do 1º quadro.
`to_output` converte; tudo que cai num trecho removido "gruda" no começo do próximo trecho mantido.
Validação forte (`validate_project`): nada do JSON vira comando de shell (FFmpeg recebe lista de argumentos e só
números formatados no filtro), texto é escapado no ASS, arquivos de áudio só de pastas permitidas, limites de
duração e de quantidade.
"""
from __future__ import annotations
import copy
import re
from dataclasses import dataclass
from pathlib import Path
from . import layout, reframe
from .scoring import ChatMessage, Word, fit_window
SCHEMA_VERSION = 1
MAX_WINDOW_S = 600.0 # janela da gravação que o editor carrega (proxy e forma de onda)
MIN_OUTPUT_S, MAX_OUTPUT_S = 3.0, 180.0
MIN_CUT_S = 0.2
MAX_CUTS = 60
MAX_WORDS = 4000
MAX_OVERLAYS = 40
MAX_NARRATION = 12
MAX_SFX = 20
CAPTION_PRESETS = ("classic", "pop", "karaoke", "single", "minimal")
TEXT_ANIMS = layout.HOOK_ANIMS # pop, fade, none, slide (tarja/texto entram deslizando com desfoque)
OVERLAY_KINDS = ("hook", "text", "zoom", "inset") # inset = recorte da tela em destaque
AUDIO_EXT = (".mp3", ".wav", ".ogg", ".m4a", ".opus", ".flac")
ID_RE = re.compile(r"^[A-Za-z0-9_-]{1,40}$")
VOICE_RE = re.compile(r"^[a-z0-9][a-z0-9-]{1,47}$")
TTS_FILE_RE = re.compile(r"^tts-[0-9a-f]{12}\.wav$")
CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
# Padrão de cada preset de legenda (camada por cima do estilo do canal/sessão; o projeto ainda pode sobrescrever).
PRESET_STYLE: dict[str, dict] = {
"classic": {},
"pop": {"maxWords": 3},
"karaoke": {"maxWords": 4, "size": 76},
"single": {"maxWords": 1, "size": 104},
"minimal": {"uppercase": False, "size": 64, "outlineWidth": 4, "maxWords": 4},
}
PRESET_LABEL = {
"classic": "Clássica (palavra falada em destaque)",
"pop": "Pop (palavra falada cresce e volta)",
"karaoke": "Karaokê (preenche palavra a palavra)",
"single": "Uma palavra por vez (entra com escala)",
"minimal": "Mínima (sem destaque, discreta)",
}
class EditError(ValueError):
"""Projeto inválido ou pedido impossível: vira 400 com a mensagem para o usuário."""
# ---------------------------------------------------------------- tempo
@dataclass(frozen=True)
class Piece:
"""Trecho mantido: [start, end] da sessão que entra no MP4 a partir de `out` (tempo de saída)."""
start: float
end: float
out: float
mode: str | None = None
muted: bool = False # trecho sem o som da live (a narração e a música continuam)
@property
def length(self) -> float:
return self.end - self.start
def pieces(cuts: list[dict]) -> list[Piece]:
out, acc = [], 0.0
for cut in cuts:
out.append(Piece(cut["start"], cut["end"], acc, cut.get("mode"), bool(cut.get("muted"))))
acc += cut["end"] - cut["start"]
return out
def output_duration(cuts: list[dict]) -> float:
return round(sum(c["end"] - c["start"] for c in cuts), 3)
def to_output(t: float, cuts: list[dict]) -> tuple[float, bool]:
"""Tempo da sessão → tempo de saída. Segundo valor: o instante está num trecho mantido?
Num trecho removido (ou antes do 1º), cai no começo do próximo trecho mantido."""
for p in pieces(cuts):
if t < p.start:
return round(p.out, 3), False
if t <= p.end:
return round(p.out + t - p.start, 3), True
return output_duration(cuts), False
def to_session(t_out: float, cuts: list[dict]) -> float:
"""Tempo de saída → tempo da sessão."""
ps = pieces(cuts)
for p in ps:
if t_out <= p.out + p.length:
return round(p.start + max(0.0, t_out - p.out), 3)
return ps[-1].end if ps else 0.0
def slice_pieces(cuts: list[dict], a: float, b: float) -> list[Piece]:
"""Trechos da sessão que formam a saída [a, b] (para a prévia real de poucos segundos)."""
out = []
for p in pieces(cuts):
lo, hi = max(a, p.out), min(b, p.out + p.length)
if hi - lo > 0.01:
out.append(Piece(p.start + lo - p.out, p.start + hi - p.out, lo - a, p.mode, p.muted))
return out
def normalize_cuts(cuts: list[dict]) -> list[dict]:
"""Ordena e junta trechos que se encostam/sobrepõem, se tiverem o mesmo layout e o mesmo "mudo"."""
merged: list[dict] = []
for cut in sorted(cuts, key=lambda c: c["start"]):
same = merged and cut.get("mode") == merged[-1].get("mode") and bool(cut.get("muted")) == bool(merged[-1].get("muted"))
if same and cut["start"] <= merged[-1]["end"] + 0.02:
merged[-1]["end"] = max(merged[-1]["end"], cut["end"])
else:
merged.append(dict(cut))
return merged
def output_words(project: dict) -> list[Word]:
"""Palavras visíveis da legenda em tempo de saída (palavra cujo meio caiu num trecho removido some)."""
cuts = project["cuts"]
out = []
for w in project["captions"]["words"]:
if w.get("hidden") or not w["w"].strip():
continue
mid = (w["s"] + w["e"]) / 2
t, inside = to_output(mid, cuts)
if not inside:
continue
for p in pieces(cuts):
if p.start <= mid <= p.end:
s = p.out + max(w["s"], p.start) - p.start
e = p.out + min(w["e"], p.end) - p.start
out.append(Word(round(s, 3), round(max(e, s + 0.05), 3), w["w"]))
break
return out
def emphasized(project: dict) -> set[tuple[float, str]]:
return {(round(w["s"], 3), w["w"]) for w in project["captions"]["words"] if w.get("emph")}
# ---------------------------------------------------------------- projeto
def default_window(clip: dict, session_duration: float) -> tuple[float, float]:
"""Janela inicial: 45 s antes e 20 s depois do corte (dá para voltar o começo sem gerar outra prévia)."""
lo = max(0.0, clip["start_s"] - 45)
hi = min(session_duration, clip["end_s"] + 20) if session_duration > 0 else clip["end_s"] + 20
return round(lo, 3), round(max(hi, clip["end_s"]), 3)
_SESSION_TIME_RE = re.compile(r"\b(?:aos|ao|em|no)\s+\d{2,}\s*s\b\s*[,:;—-]?\s*", re.IGNORECASE)
def pick_hook(raw: str | None, title: str | None) -> tuple[str, bool]:
"""Texto do gancho na tela. O do analista só serve se for curto e sem tempo da gravação (ele às vezes devolve
uma frase descritiva como "Aos 5085s, ele solta que…", que saía cortada no meio — medido no corte 25 do skipnho);
senão vale o título do editor, que já é escrito como gancho. Nunca corta no meio de uma palavra.
Devolve (texto, veio_do_analista)."""
raw = (raw or "").strip()
short = bool(raw) and len(raw.split()) <= 8 and len(raw) <= 48 and not re.search(r"\d{3,}\s*s\b", raw)
text = _SESSION_TIME_RE.sub("", raw if short else (title or raw or "")).strip()
if text:
text = text[0].upper() + text[1:]
if len(text) > 60:
text = text[:60].rsplit(" ", 1)[0].rstrip(" ,;:—-")
return text, short
def default_project(clip: dict, words: list[Word], session_duration: float) -> dict:
lo, hi = default_window(clip, session_duration)
analysis = ((clip.get("judge") or {}) if isinstance(clip.get("judge"), dict) else {}).get("analysis") or {}
hook, _ = pick_hook(analysis.get("hook"), clip.get("title"))
return {
"schema": SCHEMA_VERSION,
"source": {"sessionId": clip["session_id"], "lo": lo, "hi": hi},
"settings": {},
"cuts": [{"start": round(clip["start_s"], 3), "end": round(clip["end_s"], 3), "mode": None}],
"captions": {
"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in words if lo <= w.start <= hi][:MAX_WORDS],
},
"overlays": ([{"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": 3.0, "y": 0.2, "size": 68,
"color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}] if hook else []),
"progress": {"enabled": False, "color": "#FF7A1A", "height": 12},
"audio": {"volume": 1.0, "narration": [], "music": None, "sfx": []},
"cover": {"enabled": True, "t": round(clip.get("peak_s") or clip["start_s"], 3), "text": hook[:40]},
}
QUIET_DB = -38.0 # silêncio "de verdade": nem fala nem som do jogo (dBFS por segundo, volume medido no bloco)
AUTO_GAP_S = 2.0 # vão sem fala a partir do qual a IA corta (se também estiver quieto)
def auto_project(clip: dict, analysis: dict | None, words: list[Word], loudness: list[float | None],
session_duration: float, cfg: dict, *, model: str = "", generated_at: str = "") -> dict:
"""Projeto que a IA entrega pronto (o render automático usa ESTE projeto, o mesmo que o editor abre):
trecho pela análise (início da ação, fim da reação) encaixado nas palavras, silêncios longos E quietos
removidos (longe do pico), legenda do Whisper no estilo do corte (preset pop), gancho do analista nos
primeiros segundos, punch-in no pico e capa no pico. `loudness` = dBFS por segundo da sessão (índice = s)."""
p = default_project(clip, words, session_duration)
lo, hi = p["source"]["lo"], p["source"]["hi"]
dur = {**layout.DEFAULTS["duration"], **(cfg.get("duration") or {})}
max_s = float(dur["maxS"])
# Corte automático: duração FINAL (depois de silêncios e aparos) ≥ mínimo + 1 s. "Cortar agora" é livre.
manual = clip.get("source") == "manual"
min_s = 0.0 if manual else layout.min_target({"duration": dur})
steps: list[str] = []
start, end = float(clip["start_s"]), float(clip["end_s"])
a = analysis or {}
try:
act, react = float(a.get("action_start_s")), float(a.get("reaction_end_s"))
except (TypeError, ValueError):
act = react = None # type: ignore[assignment]
# Início no começo da ação. Medido (sessão 3, cortes 43, 44, 55, 58, 61): quando o analista punha a ação DEPOIS do
# início do juiz, o corte encolhia para 44–58 s com mínimo 60. Adiantar o início só vale se o mínimo continua.
if (act is not None and lo <= act < end - 5 and act >= start - 15 and abs(act - start) > 0.5
and end - max(lo, act - 0.8) >= min_s):
start = max(lo, act - 0.8)
steps.append(f"início no começo da ação ({act:.0f}s, analista)")
if react is not None and end < react <= min(hi, end + 8):
end = min(hi, react + 0.8)
steps.append(f"fim depois da reação ({react:.0f}s, analista)")
inside = sorted((w for w in words if lo <= w.start <= hi and w.word.strip()), key=lambda w: w.start)
for w in inside: # nunca corta no meio da palavra
if w.start < start < w.end:
start = max(lo, w.start - 0.1)
if w.start < end < w.end:
end = min(hi, w.end + 0.15)
if end - start > max_s:
end = start + max_s
steps.append(f"limitado a {max_s:.0f} s")
if end - start < min_s:
# Falta material: cresce para trás (contexto; é onde o gancho fica) e, no começo da gravação, para a frente.
before = end - start
start, end = fit_window(start, end, lo, hi, min_s, max_s, keep="start")
for w in inside: # o início novo também não corta palavra (só recua)
if w.start < start < w.end and end - (w.start - 0.1) <= max_s:
start = max(lo, w.start - 0.1)
steps.append(f"estendido de {before:.1f} s para {end - start:.1f} s (mínimo {min_s:.1f} s)")
if end - start < min_s - 0.01:
steps.append(f"curto: só havia {end - start:.1f} s de gravação em volta do momento (mínimo {min_s:.1f} s)")
cuts = [{"start": round(start, 3), "end": round(end, 3), "mode": None}]
peak = float(clip.get("peak_s") or (start + end) / 2)
def quiet(x: float, y: float) -> bool:
values = loudness[int(x): int(y) + 1]
return bool(values) and all(v is None or v < QUIET_DB for v in values)
removed = 0.0
spoken = [w for w in inside if start <= w.start <= end]
for w1, w2 in zip(spoken, spoken[1:]):
x, y = w1.end + 0.25, w2.start - 0.25
if w2.start - w1.end < AUTO_GAP_S or y - x < 0.5 or x - 3 <= peak <= y + 3 or not quiet(x, y):
continue
if output_duration(cuts) - (y - x) < min_s: # o corte final nunca fica abaixo do mínimo + 1 s
break
out, kept = [], cuts
for c in kept:
if y <= c["start"] or x >= c["end"]:
out.append(c)
continue
if x > c["start"]:
out.append({**c, "end": round(x, 3)})
if y < c["end"]:
out.append({**c, "start": round(y, 3)})
cuts = normalize_cuts(out)
removed += y - x
if removed:
steps.append(f"{removed:.1f} s de silêncio removidos")
p["cuts"] = cuts
p["captions"]["preset"] = "pop"
steps.append(f"legenda do Whisper ({len(spoken)} palavras, estilo pop)")
# Gancho: o do analista só se for curto (às vezes ele devolve uma frase descritiva — medido no corte 10 do
# skipnho); senão o título do editor, que já é escrito como gancho.
hook, short = pick_hook(a.get("hook"), clip.get("title"))
p["overlays"] = []
if hook:
# Estilo do gancho pela configuração do corte (grupo `hook`; padrão: tarja verde-limão que entra deslizando).
# Ele cobre o começo do corte — o segundo a mais do mínimo é justamente essa abertura (não há tela parada).
hk = {**layout.DEFAULTS["hook"], **(cfg.get("hook") or {})}
overlay = {"id": "hook", "kind": "hook", "text": hook, "start": 0.0, "end": round(float(hk["seconds"]), 3),
"y": 0.2, "size": 68, "color": "#FFFFFF", "box": "#E11D48", "anim": "pop"}
if hk["style"] == "banner":
overlay |= {"style": "banner", "bg": hk["bg"], "color": hk["color"], "font": hk["font"], "anim": hk["anim"],
"box": None, "size": 76}
# A tarja (até ~0,13 da altura no vertical) não pode cobrir a legenda automática: se a legenda estiver
# perto de 20 % da altura (câmera em cima com painel baixo, ou y escolhido), a tarja vai para o outro lado.
cap_y = layout.caption_y(cfg) / layout.canvas_size(cfg)[1]
if abs(cap_y - overlay["y"]) < 0.2:
overlay["y"] = round(cap_y - 0.22 if cap_y > 0.3 else min(0.85, cap_y + 0.22), 3)
else:
overlay |= {"color": hk["color"], "font": hk["font"], "anim": hk["anim"]}
p["overlays"].append(overlay)
steps.append(("gancho do analista" if short else "gancho = título do editor") + f" ({hk['style']})")
t_out, kept_peak = to_output(peak, cuts)
if kept_peak and t_out >= 1.5:
cut = next(c for c in cuts if c["start"] <= peak <= c["end"])
z_end = min(cut["end"], peak + 2.0)
if z_end - peak >= 0.8:
cam = layout.resolved_mode(cfg) == "cam_top"
# Câmera em cima: aproxima do rosto (centro do painel da câmera); senão, o centro da tela.
fy = round(cfg["layout"]["camHeight"] / 2, 3) if cam else 0.45
p["overlays"].append({"id": "zoom-peak", "kind": "zoom", "start": round(max(cut["start"], peak - 0.2), 3),
"end": round(z_end, 3), "scale": 1.25, "x": 0.5, "y": fy, "ramp": 0.15})
steps.append(f"zoom no pico ({peak:.0f}s)")
p["cover"] = {"enabled": True, "t": round(min(max(peak, lo), hi), 3), "text": hook[:40]}
p["meta"] = {"origin": "ai", "generatedAt": generated_at, "model": model or "", "steps": steps[:12]}
return p
def _num(value, name: str, lo: float, hi: float) -> float:
try:
v = float(value)
except (TypeError, ValueError) as exc:
raise EditError(f"{name} precisa ser número") from exc
if v != v or not lo <= v <= hi: # NaN ou fora da faixa
raise EditError(f"{name} vai de {lo:g} a {hi:g}")
return round(v, 3)
def _text(value, name: str, max_len: int, allow_empty: bool = True) -> str:
if not isinstance(value, str):
raise EditError(f"{name} precisa ser texto")
text = CONTROL_RE.sub(" ", value).replace("\r", "").strip()
if len(text) > max_len:
raise EditError(f"{name} passa de {max_len} caracteres")
if not text and not allow_empty:
raise EditError(f"{name} está vazio")
return text
def _hex(value, name: str) -> str:
if not isinstance(value, str) or not layout.HEX_RE.match(value):
raise EditError(f"{name} precisa ser cor #RRGGBB")
return value.upper()
def _list(value, name: str, limit: int) -> list:
if value is None:
return []
if not isinstance(value, list):
raise EditError(f"{name} precisa ser lista")
if len(value) > limit:
raise EditError(f"{name}: no máximo {limit}")
return value
def _id(value, name: str) -> str:
if not isinstance(value, str) or not ID_RE.match(value):
raise EditError(f"{name} precisa ser um id curto (letras, números, - e _)")
return value
def safe_audio_file(value, roots: list[Path], repo_root: Path, name: str) -> str:
"""Arquivo de áudio relativo ao repositório, dentro de uma das pastas permitidas e existente."""
if not isinstance(value, str) or not value or "\\" in value or value.startswith("/") or ".." in value.split("/"):
raise EditError(f"{name}: caminho inválido")
full = (repo_root / value).resolve()
if full.suffix.lower() not in AUDIO_EXT:
raise EditError(f"{name}: só áudio ({', '.join(AUDIO_EXT)})")
if not any(full.is_relative_to(r.resolve()) for r in roots):
raise EditError(f"{name}: arquivo fora das pastas permitidas")
if not full.is_file():
raise EditError(f"{name}: arquivo não encontrado")
return value
def validate_project(data: dict, *, session_id: int, session_duration: float, repo_root: Path,
tts_dir: Path, assets_dir: Path) -> dict:
"""Valida e normaliza o projeto inteiro. Levanta EditError com a 1ª falha (mensagem em português)."""
if not isinstance(data, dict):
raise EditError("projeto precisa ser um objeto")
if data.get("schema") != SCHEMA_VERSION:
raise EditError(f"versão do projeto não suportada (esperado schema {SCHEMA_VERSION})")
src = data.get("source") or {}
if src.get("sessionId") != session_id:
raise EditError("o projeto é de outra sessão")
limit = session_duration if session_duration > 0 else 1e9
lo = _num(src.get("lo"), "source.lo", 0, limit)
hi = _num(src.get("hi"), "source.hi", 0, limit)
if not 5 <= hi - lo <= MAX_WINDOW_S:
raise EditError(f"a janela da gravação precisa ter de 5 s a {MAX_WINDOW_S / 60:.0f} min")
# Configuração do corte própria do projeto (mesma validação da configuração de canal/sessão).
try:
own_settings = layout.validate(data.get("settings") or {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"configuração do corte: {exc}") from exc
raw_cuts = _list(data.get("cuts"), "cuts", MAX_CUTS)
if not raw_cuts:
raise EditError("o corte precisa de pelo menos um trecho")
cuts = []
for i, c in enumerate(raw_cuts):
if not isinstance(c, dict):
raise EditError(f"cuts[{i}] precisa ser objeto")
start, end = _num(c.get("start"), f"cuts[{i}].start", lo, hi), _num(c.get("end"), f"cuts[{i}].end", lo, hi)
if end - start < MIN_CUT_S:
raise EditError(f"cuts[{i}] precisa ter pelo menos {MIN_CUT_S:g} s")
mode = c.get("mode")
if mode is not None and mode not in layout.MODES:
raise EditError(f"cuts[{i}].mode precisa ser um de {', '.join(layout.MODES)} ou null")
cuts.append({"start": start, "end": end, "mode": mode, "muted": bool(c.get("muted", False))})
cuts = normalize_cuts(cuts)
total = output_duration(cuts)
if not MIN_OUTPUT_S <= total <= MAX_OUTPUT_S:
raise EditError(f"o corte editado precisa ter de {MIN_OUTPUT_S:g} a {MAX_OUTPUT_S:g} s (tem {total:.1f} s)")
cap = data.get("captions") or {}
preset = cap.get("preset", "classic")
if preset not in CAPTION_PRESETS:
raise EditError(f"captions.preset precisa ser um de {', '.join(CAPTION_PRESETS)}")
try:
style = layout.validate({"caption": cap.get("style") or {}}).get("caption", {})
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(f"estilo da legenda: {exc}") from exc
words = []
for i, w in enumerate(_list(cap.get("words"), "captions.words", MAX_WORDS)):
if not isinstance(w, dict):
raise EditError(f"captions.words[{i}] precisa ser objeto")
s, e = _num(w.get("s"), f"palavra {i} (início)", 0, limit), _num(w.get("e"), f"palavra {i} (fim)", 0, limit)
if e <= s: # o Whisper às vezes devolve palavra com duração zero (medido no skipnho): ganha 50 ms
e = round(s + 0.05, 3)
item = {"s": s, "e": e, "w": _text(w.get("w", ""), f"palavra {i}", 40)}
if w.get("emph"):
item["emph"] = True
if w.get("hidden"):
item["hidden"] = True
words.append(item)
words.sort(key=lambda w: w["s"])
captions = {"enabled": bool(cap.get("enabled", True)), "preset": preset, "style": style,
"emphColor": _hex(cap.get("emphColor", "#22E36B"), "captions.emphColor"), "words": words}
overlays, seen = [], set()
for i, o in enumerate(_list(data.get("overlays"), "overlays", MAX_OVERLAYS)):
if not isinstance(o, dict) or o.get("kind") not in OVERLAY_KINDS:
raise EditError(f"overlays[{i}].kind precisa ser um de {', '.join(OVERLAY_KINDS)}")
oid = _id(o.get("id"), f"overlays[{i}].id")
if oid in seen:
raise EditError(f"overlays: id repetido ({oid})")
seen.add(oid)
kind = o["kind"]
if kind == "hook": # tempo de saída
start, end = _num(o.get("start", 0), "gancho: início", 0, MAX_OUTPUT_S), _num(o.get("end"), "gancho: fim", 0, MAX_OUTPUT_S)
else: # tempo da sessão
start, end = _num(o.get("start"), f"overlays[{i}].start", lo, hi), _num(o.get("end"), f"overlays[{i}].end", lo, hi)
if end - start < 0.2:
raise EditError(f"overlays[{i}] precisa durar pelo menos 0,2 s")
item = {"id": oid, "kind": kind, "start": start, "end": end}
if kind == "inset":
item |= _inset(o, i, lo, hi)
elif kind == "zoom":
item |= {"scale": _num(o.get("scale", 1.3), "zoom: escala", 1.05, 2.5),
"x": _num(o.get("x", 0.5), "zoom: x", 0, 1), "y": _num(o.get("y", 0.5), "zoom: y", 0, 1),
"ramp": _num(o.get("ramp", 0.25), "zoom: rampa", 0, 1.5)}
else:
box = o.get("box")
style = o.get("style", "plain")
if style not in layout.HOOK_STYLES:
raise EditError(f"overlays[{i}].style precisa ser um de {', '.join(layout.HOOK_STYLES)}")
font = o.get("font")
if font is not None and font not in layout.FONTS:
raise EditError(f"overlays[{i}].font precisa ser uma de {', '.join(layout.FONTS)}")
bg = o.get("bg")
# Campos novos só entram no projeto quando usados: projeto antigo continua byte a byte igual.
if style != "plain":
item["style"] = style
if font is not None:
item["font"] = font
if bg not in (None, ""):
item["bg"] = _hex(bg, f"overlays[{i}].bg")
item |= {"text": _text(o.get("text", ""), f"overlays[{i}].text", 120, allow_empty=False),
"x": _num(o.get("x", 0.5), f"overlays[{i}].x", 0.05, 0.95),
"y": _num(o.get("y", 0.2), f"overlays[{i}].y", 0.04, 0.96),
"size": int(_num(o.get("size", 64), f"overlays[{i}].size", 24, 180)),
"color": _hex(o.get("color", "#FFFFFF"), f"overlays[{i}].color"),
"box": None if box in (None, "") else _hex(box, f"overlays[{i}].box"),
"anim": o.get("anim", "pop")}
if item["anim"] not in TEXT_ANIMS:
raise EditError(f"overlays[{i}].anim precisa ser um de {', '.join(TEXT_ANIMS)}")
overlays.append(item)
if sum(1 for o in overlays if o["kind"] == "inset") > reframe.MAX_INSETS:
raise EditError(f"no máximo {reframe.MAX_INSETS} camadas inseridas")
zooms = sorted((o for o in overlays if o["kind"] == "zoom"), key=lambda o: o["start"])
for a, b in zip(zooms, zooms[1:]):
if b["start"] < a["end"]:
raise EditError("dois zooms ao mesmo tempo: separe os trechos de zoom")
prog = data.get("progress") or {}
progress = {"enabled": bool(prog.get("enabled", False)), "color": _hex(prog.get("color", "#FF7A1A"), "progress.color"),
"height": int(_num(prog.get("height", 12), "progress.height", 4, 40))}
aud = data.get("audio") or {}
narration = []
for i, n in enumerate(_list(aud.get("narration"), "audio.narration", MAX_NARRATION)):
if not isinstance(n, dict):
raise EditError(f"audio.narration[{i}] precisa ser objeto")
file = safe_audio_file(n.get("file"), [tts_dir], repo_root, f"narração {i + 1}")
if not TTS_FILE_RE.match(Path(file).name):
raise EditError(f"narração {i + 1}: arquivo precisa ser gerado pelo editor (tts-*.wav)")
voice = n.get("voice", "")
if voice and not VOICE_RE.match(str(voice)):
raise EditError(f"narração {i + 1}: voz inválida")
narration.append({"id": _id(n.get("id"), f"narração {i + 1}"), "file": file,
"at": _num(n.get("at"), f"narração {i + 1}: instante", lo, hi),
"volume": _num(n.get("volume", 1.0), f"narração {i + 1}: volume", 0, 2),
"durationS": _num(n.get("durationS", 0), f"narração {i + 1}: duração", 0, 120),
"duck": _num(n.get("duck", 0.35), f"narração {i + 1}: volume do original por baixo", 0, 1),
"text": _text(n.get("text", ""), f"narração {i + 1}: texto", 300), "voice": str(voice)})
music = None
if aud.get("music"):
m = aud["music"]
if not isinstance(m, dict):
raise EditError("audio.music precisa ser objeto ou null")
music = {"file": safe_audio_file(m.get("file"), [assets_dir], repo_root, "música"),
"volume": _num(m.get("volume", 0.18), "música: volume", 0, 1), "duck": bool(m.get("duck", True))}
sfx = []
for i, x in enumerate(_list(aud.get("sfx"), "audio.sfx", MAX_SFX)):
if not isinstance(x, dict):
raise EditError(f"audio.sfx[{i}] precisa ser objeto")
sfx.append({"id": _id(x.get("id"), f"efeito {i + 1}"), "file": safe_audio_file(x.get("file"), [assets_dir], repo_root, f"efeito {i + 1}"),
"at": _num(x.get("at"), f"efeito {i + 1}: instante", lo, hi),
"volume": _num(x.get("volume", 0.8), f"efeito {i + 1}: volume", 0, 2)})
audio = {"volume": _num(aud.get("volume", 1.0), "audio.volume", 0, 2), "narration": narration, "music": music, "sfx": sfx}
cov = data.get("cover") or {}
cover = {"enabled": bool(cov.get("enabled", True)), "t": _num(cov.get("t", cuts[0]["start"]), "capa: instante", lo, hi),
"text": _text(cov.get("text", ""), "capa: texto", 60),
# Capa também nos 2 primeiros quadros do vídeo: as redes usam o quadro 0 como miniatura padrão.
"atStart": bool(cov.get("atStart", False))}
# Chat da live na tela: as últimas mensagens num bloco, na posição escolhida (x = borda esquerda, y = base).
ch = data.get("chat") or {}
if not isinstance(ch, dict):
raise EditError("chat precisa ser objeto")
chat = {"enabled": bool(ch.get("enabled", False)),
"x": _num(ch.get("x", 0.04), "chat: x", 0, 0.9), "y": _num(ch.get("y", 0.62), "chat: y", 0.1, 0.98),
"width": _num(ch.get("width", 0.6), "chat: largura", 0.25, 0.96),
"lines": int(_num(ch.get("lines", 5), "chat: linhas", 1, 10)),
"size": int(_num(ch.get("size", 34), "chat: tamanho", 18, 64)),
"showUser": bool(ch.get("showUser", True))}
raw_meta = data.get("meta") or {}
if not isinstance(raw_meta, dict):
raise EditError("meta precisa ser objeto")
origin = raw_meta.get("origin", "user")
if origin not in ("ai", "user"):
raise EditError("meta.origin precisa ser ai ou user")
meta = {"origin": origin, "generatedAt": _text(raw_meta.get("generatedAt", ""), "meta.generatedAt", 40),
"model": _text(raw_meta.get("model") or "", "meta.model", 80),
"steps": [_text(x, "meta.steps", 200) for x in _list(raw_meta.get("steps"), "meta.steps", 12)]}
project = {"schema": SCHEMA_VERSION, "source": {"sessionId": session_id, "lo": lo, "hi": hi}, "settings": own_settings,
"cuts": cuts, "captions": captions, "overlays": overlays, "progress": progress, "audio": audio,
"cover": cover, "chat": chat, "meta": meta}
# Reenquadramento do jogo no tempo: só entra no projeto quando há keys (projeto antigo continua igual).
keys = _reframe_keys(data.get("reframe"), lo, hi)
if keys:
project["reframe"] = {"keys": keys}
return project
def _keys(raw, name: str, lo: float, hi: float, fields: dict[str, tuple[float, float]]) -> list[dict]:
"""Keyframes {t (tempo da sessão), campos..., ease}: validados, ordenados, no máximo `reframe.MAX_KEYS`."""
out = []
for i, k in enumerate(_list(raw, name, reframe.MAX_KEYS)):
if not isinstance(k, dict):
raise EditError(f"{name}[{i}] precisa ser objeto")
item = {"t": _num(k.get("t"), f"{name}[{i}].t", lo, hi)}
for field, (a, b) in fields.items():
item[field] = _num(k.get(field), f"{name}[{i}].{field}", a, b)
ease = k.get("ease", "smooth")
if ease not in reframe.EASES:
raise EditError(f"{name}[{i}].ease precisa ser um de {', '.join(reframe.EASES)}")
item["ease"] = ease
out.append(item)
out.sort(key=lambda k: k["t"])
for a, b in zip(out, out[1:]):
if b["t"] - a["t"] < 0.02:
raise EditError(f"{name}: dois keyframes no mesmo instante ({a['t']:g} s)")
return out
def _reframe_keys(raw, lo: float, hi: float) -> list[dict]:
if raw in (None, {}):
return []
if not isinstance(raw, dict):
raise EditError("reframe precisa ser objeto {keys: [...]}")
return _keys(raw.get("keys"), "reframe.keys", lo, hi, {"cx": (0, 1), "cy": (0, 1), "w": (0.05, 1)})
def _inset(o: dict, i: int, lo: float, hi: float) -> dict:
"""Camada inserida: recorte `src` do quadro original posto em (x, y) com largura `size` da tela."""
name = f"overlays[{i}]"
try:
src = layout._rect(o.get("src"), f"{name}.src")
except (layout.LayoutError, TypeError, ValueError) as exc:
raise EditError(str(exc)) from exc
if src is None:
raise EditError(f"{name}.src precisa ser {{x, y, w, h}} (recorte do quadro original)")
border = o.get("border")
anim = o.get("anim", "pop")
if anim not in reframe.INSET_ANIMS:
raise EditError(f"{name}.anim precisa ser um de {', '.join(reframe.INSET_ANIMS)}")
return {"src": src, "x": _num(o.get("x", 0.5), f"{name}.x", 0, 1), "y": _num(o.get("y", 0.5), f"{name}.y", 0, 1),
"size": _num(o.get("size", 0.45), f"{name}.size", 0.1, 1),
"border": None if border in (None, "") else _hex(border, f"{name}.border"),
"borderW": int(_num(o.get("borderW", 6), f"{name}.borderW", 0, 40)),
"radius": int(_num(o.get("radius", 18), f"{name}.radius", 0, 200)),
"shadow": bool(o.get("shadow", True)), "anim": anim,
"keys": _keys(o.get("keys"), f"{name}.keys", lo, hi, {"x": (0, 1), "y": (0, 1), "size": (0.1, 1)})}
def effective_settings(base: dict, project: dict) -> dict:
"""Configuração do corte do render: padrão ← canal ← sessão ← projeto, mais o preset e o estilo da legenda."""
cfg = layout.merge(base, project.get("settings") or {})
cap = project["captions"]
cfg["caption"].update(PRESET_STYLE.get(cap["preset"], {}))
cfg["caption"].update(cap.get("style") or {})
cfg["caption"]["enabled"] = cap["enabled"]
return cfg
def retime(project: dict, start: float, end: float) -> dict:
"""O cartão do corte mudou início/fim (−30 s, +2 s…): estica/encolhe as pontas do projeto, mantém o meio."""
p = copy.deepcopy(project)
cuts = p["cuts"]
cuts[0]["start"] = min(start, cuts[0]["end"] - MIN_CUT_S)
cuts[-1]["end"] = max(end, cuts[-1]["start"] + MIN_CUT_S)
p["source"]["lo"] = min(p["source"]["lo"], cuts[0]["start"])
p["source"]["hi"] = max(p["source"]["hi"], cuts[-1]["end"])
return p
def span(project: dict) -> tuple[float, float]:
return project["cuts"][0]["start"], project["cuts"][-1]["end"]
# ---------------------------------------------------------------- IA sugere
SUGGEST_SYSTEM = """Você é EDITOR de cortes de lives de jogos em português do Brasil — verticais (Shorts/TikTok/Reels)
ou horizontais (YouTube, tela cheia do jogo), conforme o formato informado.
Recebe a transcrição palavra a palavra com tempos, o chat e a análise do momento. Devolva:
- hook: texto curto de gancho para os 2 primeiros segundos (até 8 palavras, sem hashtag, fiel ao que acontece);
- title: título do vídeo (até 70 caracteres, gancho + palavra de busca);
- start_s/end_s: início ideal (onde a AÇÃO começa, sem enrolação) e fim (depois da reação/pagamento);
- remove: trechos mortos DENTRO de [start_s, end_s] para cortar (silêncio longo, enrolação, fala sem relação),
sem quebrar o contexto nem cortar no meio de frase. Pode ser vazio;
- zooms: instantes de reação forte para um punch-in curto (0 a 3);
- reason: por que, em uma frase.
Tempos sempre em segundos da gravação (os mesmos da transcrição). Nunca invente o que não está na fala/chat/análise."""
SUGGEST_SCHEMA = {
"type": "object", "additionalProperties": False,
"required": ["hook", "title", "start_s", "end_s", "remove", "zooms", "reason"],
"properties": {
"hook": {"type": "string"}, "title": {"type": "string"},
"start_s": {"type": "number"}, "end_s": {"type": "number"},
"remove": {"type": "array", "items": {"type": "object", "additionalProperties": False,
"required": ["start_s", "end_s", "why"],
"properties": {"start_s": {"type": "number"}, "end_s": {"type": "number"},
"why": {"type": "string"}}}},
"zooms": {"type": "array", "items": {"type": "object", "additionalProperties": False, "required": ["t", "why"],
"properties": {"t": {"type": "number"}, "why": {"type": "string"}}}},
"reason": {"type": "string"},
},
}
def suggest_prompt(streamer: str, title: str, project: dict, chat: list[ChatMessage], analysis: dict | None,
transcript: str, chat_block: str, cfg: dict | None = None) -> str:
"""`cfg` = configuração efetiva do corte (duração e formato); sem ela, os padrões de `layout.DEFAULTS`."""
cfg = cfg or layout.merge()
lo, hi = project["source"]["lo"], project["source"]["hi"]
a, b = span(project)
dur = cfg["duration"]
fmt = "horizontal 16:9 (YouTube)" if layout.aspect(cfg) == "horizontal" else "vertical 9:16 (Shorts/TikTok/Reels)"
return (f"Canal: {streamer}\nTítulo atual do corte: {title or '(nenhum)'}\nFormato: {fmt}\n"
f"Janela disponível da gravação: {lo:.0f}s a {hi:.0f}s. Corte atual: {a:.0f}s a {b:.0f}s "
f"({output_duration(project['cuts']):.0f} s depois dos cortes internos).\n"
f"Duração final ideal: {dur['minS']:.0f} a {dur['maxS']:.0f} s.\n\n"
f"Transcrição (segundos da gravação):\n{transcript}\n\n{chat_block}\n\n"
+ (f"Análise do momento (1º juiz): {analysis}\n" if analysis else ""))
def clean_suggestion(data: dict, lo: float, hi: float, min_len: float = MIN_OUTPUT_S,
max_len: float = MAX_OUTPUT_S) -> dict:
"""Prende tudo dentro da janela e nos limites (a IA pode errar números). `min_len`/`max_len` = duração final do
corte (o editor passa mínimo + 1 s e máximo da configuração); os trechos a remover que levariam o corte abaixo do
mínimo ficam de fora."""
start, end = fit_window(float(data.get("start_s", lo)), float(data.get("end_s", hi)), lo, hi,
max(MIN_OUTPUT_S, min_len), max_len, keep="start")
remove = []
for r in (data.get("remove") or [])[:10]:
try:
a, b = max(float(r["start_s"]), start), min(float(r["end_s"]), end)
except (KeyError, TypeError, ValueError):
continue
if b - a >= 0.4 and (end - start) - sum(x["end"] - x["start"] for x in remove) - (b - a) >= min_len:
remove.append({"start": round(a, 2), "end": round(b, 2), "why": str(r.get("why", ""))[:160]})
zooms = []
for z in (data.get("zooms") or [])[:3]:
try:
t = float(z["t"])
except (KeyError, TypeError, ValueError):
continue
if start <= t <= end:
zooms.append({"t": round(t, 2), "why": str(z.get("why", ""))[:160]})
return {"hook": str(data.get("hook", "")).strip()[:80], "title": str(data.get("title", "")).strip()[:100],
"start": round(start, 2), "end": round(end, 2), "remove": remove, "zooms": zooms,
"reason": str(data.get("reason", ""))[:300]}