Files
CenaForge/clipper/app/editor.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

729 lines
38 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.
"""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]}