- app/dub.py: frases traduzidas → uma fala TTS por frase no serviço de voz (POST /v1/synthesize, WAV), cache em disco por (voz, velocidade, texto), encaixe sem sincronia labial (velocidade natural, escorre até 1,5 s sem acumular atraso, acelera no máximo 1,2× e corta com fade só se preciso, nunca duas falas juntas), frase partida no meio vira uma fala só, voz reserva offline e faixa única do trecho nivelada pelo volume do corte. - editor_render.render_project: o áudio original abaixa (dubDuck, rampa de 0,15 s) só onde há dublagem; nada muda com dev=False. Devolve resumo. - layout: dev.dubVoice, dev.dubVoiceOther (speaker "other") e dev.dubDuck. - editor_api: prévia e render da fila passam o dublador; translation_for também traduz quando só a dublagem está ligada. - Painel: switch "Dublagem em português (teste)", vozes TTS prontas (sem clone) e volume do original. - doc/clipador/DUBLAGEM.md e tests/test_dub.py (TTS falso). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
484 lines
26 KiB
Python
484 lines
26 KiB
Python
"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`)
|
|
e o render do projeto chamado pela fila do motor (worker.render_clip).
|
|
|
|
O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o
|
|
`rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do
|
|
editor em `output/clipper/<sessão>/edit-<corte>/` (proxy 480p, forma de onda, narração TTS, prévia real).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
import httpx
|
|
from fastapi import FastAPI, Request
|
|
from fastapi.responses import JSONResponse
|
|
from pydantic import BaseModel, Field
|
|
|
|
from . import dub, editor, editor_render, layout, media
|
|
from .config import REPO_ROOT
|
|
from .db import loads, now
|
|
from .judge import JudgeError, _chat_block, _transcript
|
|
from .scoring import Word
|
|
|
|
log = logging.getLogger("cenaforge_clipper.editor")
|
|
PREVIEW_MAX_S = 10.0
|
|
RETRANSCRIBE_MAX_S = 90.0
|
|
_locks: dict[str, threading.Lock] = {}
|
|
_locks_guard = threading.Lock()
|
|
|
|
|
|
def _lock(key: str) -> threading.Lock:
|
|
with _locks_guard:
|
|
return _locks.setdefault(key, threading.Lock())
|
|
|
|
|
|
class EditPut(BaseModel):
|
|
project: dict
|
|
rev: int = Field(default=0, ge=0)
|
|
|
|
|
|
class WindowIn(BaseModel):
|
|
lo: float = Field(ge=0)
|
|
hi: float = Field(ge=0)
|
|
|
|
|
|
class PreviewRenderIn(BaseModel):
|
|
fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S)
|
|
durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S)
|
|
project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo
|
|
|
|
|
|
class RangeIn(BaseModel):
|
|
startS: float = Field(ge=0)
|
|
endS: float = Field(ge=0)
|
|
|
|
|
|
class TtsIn(BaseModel):
|
|
text: str = Field(min_length=1, max_length=300)
|
|
voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$")
|
|
speed: float = Field(default=1.0, ge=0.5, le=2.0)
|
|
|
|
|
|
class SuggestIn(BaseModel):
|
|
project: dict | None = None
|
|
|
|
|
|
# ---------------------------------------------------------------- utilidades (também usadas pelo worker)
|
|
def edit_dir(engine, session_id: int, clip_id: int) -> Path:
|
|
return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}"
|
|
|
|
|
|
def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]:
|
|
return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
|
|
for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)]
|
|
|
|
|
|
def validate_for(engine, clip: dict, session: dict, data: dict) -> dict:
|
|
return editor.validate_project(
|
|
data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT,
|
|
tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets")
|
|
|
|
|
|
def load_edit(engine, clip_id: int) -> dict | None:
|
|
row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id)
|
|
if row:
|
|
row["project"] = loads(row["project_json"], None)
|
|
return row
|
|
|
|
|
|
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
|
|
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
|
|
project = validate_for(engine, clip, session, edit["project"])
|
|
segments = session_segments(engine, clip["session_id"])
|
|
if engine._encoder is None:
|
|
engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder)
|
|
base = engine.intel.settings_for(session)
|
|
credit = engine.channel_label(session)
|
|
ffmpeg = engine.settings.ffmpeg or "ffmpeg"
|
|
# A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4.
|
|
cover: Path | None = None
|
|
if project["cover"]["enabled"]:
|
|
cover = out.parent / f"{out.stem}-cover.jpg"
|
|
try:
|
|
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
|
|
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
|
|
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
|
|
cover = None
|
|
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
|
|
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover,
|
|
translation=translation_for(engine, clip, project, base), dubber=dub.for_engine(engine))
|
|
total = editor.output_duration(project["cuts"])
|
|
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
|
|
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
|
|
engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"])
|
|
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
|
|
|
|
|
|
def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None:
|
|
"""Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md) e a dublagem
|
|
(doc/clipador/DUBLAGEM.md): só com `dev.translation` ou `dev.dub` ligado, render de desenvolvimento e fonte em
|
|
inglês. Traduz o trecho do projeto se ainda não houver tradução."""
|
|
cfg = editor.effective_settings(base, project)
|
|
flags = layout.dev_flags(cfg, dev)
|
|
if not (flags["translation"] or flags["dub"]):
|
|
return None
|
|
ps = editor.pieces(project["cuts"])
|
|
if not ps:
|
|
return None
|
|
data = engine.translate_clip(clip["id"], ps[0].start, ps[-1].end)
|
|
return (data or {}).get("lines") or None
|
|
|
|
|
|
def chat_for(engine, project: dict) -> list | None:
|
|
"""Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede)."""
|
|
if not (project.get("chat") or {}).get("enabled"):
|
|
return None
|
|
lo = project["source"]["lo"]
|
|
return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"]
|
|
|
|
|
|
def _judge(clip: dict) -> dict:
|
|
data = loads(clip.get("judge_json"), None)
|
|
return data if isinstance(data, dict) else {}
|
|
|
|
|
|
def auto_for(engine, clip: dict, session: dict) -> dict:
|
|
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
|
|
judge = _judge(clip)
|
|
lo, hi = editor.default_window(clip, session["duration_s"])
|
|
rows = engine.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
|
|
clip["session_id"], lo, hi)
|
|
words = [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], [])]
|
|
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
|
|
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
|
|
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
|
|
|
|
|
|
def ensure_edit(engine, clip: dict, session: dict) -> dict:
|
|
"""Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um
|
|
agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto."""
|
|
row = load_edit(engine, clip["id"])
|
|
if row and row["project"]:
|
|
return row
|
|
project = validate_for(engine, clip, session, auto_for(engine, clip, session))
|
|
raw = json.dumps(project, ensure_ascii=False)
|
|
ts = now()
|
|
engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
|
|
" VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts)
|
|
start, end = editor.span(project)
|
|
engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"])
|
|
return load_edit(engine, clip["id"])
|
|
|
|
|
|
def retime_edit(engine, clip_id: int, start: float, end: float) -> None:
|
|
"""O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto."""
|
|
row = load_edit(engine, clip_id)
|
|
if not row or not row["project"]:
|
|
return
|
|
project = editor.retime(row["project"], start, end)
|
|
engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?",
|
|
json.dumps(project, ensure_ascii=False), now(), clip_id)
|
|
|
|
|
|
def _audio_library() -> list[dict]:
|
|
root = REPO_ROOT / "assets"
|
|
out = []
|
|
if root.is_dir():
|
|
for f in sorted(root.rglob("*")):
|
|
if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT:
|
|
out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem})
|
|
if len(out) >= 200:
|
|
break
|
|
return out
|
|
|
|
|
|
def _window_key(lo: float, hi: float) -> str:
|
|
return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}"
|
|
|
|
|
|
def _clean_old(folder: Path, prefix: str, keep: str) -> None:
|
|
for f in folder.glob(f"{prefix}-*"):
|
|
if f.name != keep:
|
|
f.unlink(missing_ok=True)
|
|
|
|
|
|
# ---------------------------------------------------------------- rotas
|
|
def register(app: FastAPI, engine, clip_view, get_clip) -> None:
|
|
"""`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir)."""
|
|
db, settings = engine.db, engine.settings
|
|
ffmpeg = settings.ffmpeg or "ffmpeg"
|
|
|
|
@app.exception_handler(editor.EditError)
|
|
async def edit_error(_request: Request, exc: editor.EditError):
|
|
return JSONResponse({"error": str(exc)}, status_code=400)
|
|
|
|
@app.exception_handler(media.MediaError)
|
|
async def media_error(_request: Request, exc: media.MediaError):
|
|
return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400)
|
|
|
|
def _context(clip_id: int) -> tuple[dict, dict]:
|
|
clip = get_clip(clip_id)
|
|
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
|
|
if not session:
|
|
raise editor.EditError("sessão do corte não existe mais")
|
|
return clip, session
|
|
|
|
def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]:
|
|
lo, hi = max(0.0, lo), min(hi, session["duration_s"])
|
|
if not 5 <= hi - lo <= editor.MAX_WINDOW_S:
|
|
raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação")
|
|
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi)
|
|
if not segs:
|
|
raise editor.EditError("não há gravação nessa janela")
|
|
if any(s["deleted"] for s in segs):
|
|
raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor")
|
|
return round(lo, 3), round(hi, 3)
|
|
|
|
def _words(session_id: int, lo: float, hi: float) -> list[Word]:
|
|
rows = db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx",
|
|
session_id, lo, hi)
|
|
return [Word(a, b, c) for r in rows for a, b, c in loads(r["words_json"], []) if lo <= a <= hi]
|
|
|
|
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
|
|
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
|
|
return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None
|
|
|
|
def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None:
|
|
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json"
|
|
return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None
|
|
|
|
@app.get("/v1/clips/{clip_id}/edit")
|
|
def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None):
|
|
"""Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA,
|
|
configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda)."""
|
|
clip, session = _context(clip_id)
|
|
row = load_edit(engine, clip_id)
|
|
view = clip_view(clip)
|
|
if row and row["project"]:
|
|
project, rev = row["project"], row["rev"]
|
|
ai_project = loads(row.get("ai_project_json"), None)
|
|
else:
|
|
project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo)
|
|
rev = 0
|
|
w_lo = project["source"]["lo"] if lo is None else lo
|
|
w_hi = project["source"]["hi"] if hi is None else hi
|
|
w_lo, w_hi = _check_window(session, w_lo, w_hi)
|
|
tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5))
|
|
chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)}
|
|
for m in tl["chat"] if w_lo <= m.t <= w_hi][:600]
|
|
per_s = [0] * int(w_hi - w_lo + 1)
|
|
for m in tl["chat"]:
|
|
if w_lo <= m.t <= w_hi:
|
|
per_s[int(m.t - w_lo)] += 1
|
|
loud = tl["loudness"][int(w_lo): int(w_hi) + 1]
|
|
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
|
|
return {
|
|
"clip": view, "project": project, "rev": rev, "saved": bool(row),
|
|
"origin": row["origin"] if row else "ai", "aiProject": ai_project,
|
|
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
|
|
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
|
|
"words": [{"s": w.start, "e": w.end, "w": w.word} for w in _words(clip["session_id"], w_lo, w_hi)],
|
|
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
|
|
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
|
|
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
|
|
"audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi),
|
|
"waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S,
|
|
"judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured,
|
|
"limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S,
|
|
"previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S},
|
|
}
|
|
|
|
@app.put("/v1/clips/{clip_id}/edit")
|
|
def put_edit(clip_id: int, body: EditPut):
|
|
"""Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes)."""
|
|
clip, session = _context(clip_id)
|
|
project = validate_for(engine, clip, session, body.project)
|
|
ts = now()
|
|
with db.lock:
|
|
row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)
|
|
if row and body.rev != row["rev"]:
|
|
return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]},
|
|
status_code=409)
|
|
if row:
|
|
db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?",
|
|
json.dumps(project, ensure_ascii=False), ts, clip_id)
|
|
else:
|
|
ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False)
|
|
db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
|
|
" VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts)
|
|
rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"]
|
|
return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])}
|
|
|
|
@app.delete("/v1/clips/{clip_id}/edit", status_code=204)
|
|
def delete_edit(clip_id: int):
|
|
"""Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render)."""
|
|
get_clip(clip_id)
|
|
db.run("DELETE FROM edits WHERE clip_id = ?", clip_id)
|
|
|
|
@app.post("/v1/clips/{clip_id}/proxy")
|
|
def make_proxy(clip_id: int, body: WindowIn):
|
|
"""Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela."""
|
|
clip, session = _context(clip_id)
|
|
lo, hi = _check_window(session, body.lo, body.hi)
|
|
folder = edit_dir(engine, clip["session_id"], clip_id)
|
|
name = f"proxy-{_window_key(lo, hi)}.mp4"
|
|
with _lock(f"proxy-{clip_id}"):
|
|
if not (folder / name).is_file():
|
|
t = time.monotonic()
|
|
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
|
|
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
|
|
_clean_old(folder, "proxy", name)
|
|
return _cached_proxy(clip, lo, hi) | {"words": [{"s": w.start, "e": w.end, "w": w.word}
|
|
for w in _words(clip["session_id"], lo, hi)]}
|
|
|
|
@app.get("/v1/clips/{clip_id}/waveform")
|
|
def get_waveform(clip_id: int, lo: float, hi: float):
|
|
clip, session = _context(clip_id)
|
|
lo, hi = _check_window(session, lo, hi)
|
|
folder = edit_dir(engine, clip["session_id"], clip_id)
|
|
name = f"waveform-{_window_key(lo, hi)}.json"
|
|
with _lock(f"wave-{clip_id}"):
|
|
peaks = _cached_wave(clip, lo, hi)
|
|
if peaks is None:
|
|
peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder)
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
(folder / name).write_text(json.dumps(peaks), encoding="utf-8")
|
|
_clean_old(folder, "waveform", name)
|
|
return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks}
|
|
|
|
@app.post("/v1/clips/{clip_id}/preview-render")
|
|
def preview_render(clip_id: int, body: PreviewRenderIn):
|
|
"""Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado."""
|
|
clip, session = _context(clip_id)
|
|
row = load_edit(engine, clip_id)
|
|
data = body.project or (row["project"] if row else None)
|
|
if not data:
|
|
raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)")
|
|
project = validate_for(engine, clip, session, data)
|
|
total = editor.output_duration(project["cuts"])
|
|
a = min(body.fromS, max(0.0, total - 1))
|
|
b = min(total, a + body.durationS)
|
|
out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4"
|
|
segments = session_segments(engine, clip["session_id"])
|
|
base, credit = engine.intel.settings_for(session), engine.channel_label(session)
|
|
with _lock(f"preview-{clip_id}"):
|
|
t = time.monotonic()
|
|
# Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export.
|
|
cover = None
|
|
if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"):
|
|
cover = out.parent / "preview-cover.jpg"
|
|
try:
|
|
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
|
|
except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela
|
|
log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc)
|
|
cover = None
|
|
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
|
|
segments, project, base, credit, out, REPO_ROOT,
|
|
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover,
|
|
translation=translation_for(engine, clip, project, base),
|
|
dubber=dub.for_engine(engine))
|
|
took = time.monotonic() - t
|
|
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
|
|
|
|
@app.post("/v1/clips/{clip_id}/export")
|
|
def export(clip_id: int):
|
|
"""Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar)."""
|
|
clip, session = _context(clip_id)
|
|
row = load_edit(engine, clip_id)
|
|
if not row or not row["project"]:
|
|
raise editor.EditError("nada para exportar: salve o projeto primeiro")
|
|
project = validate_for(engine, clip, session, row["project"])
|
|
start, end = editor.span(project)
|
|
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end)
|
|
if not segs or any(s["deleted"] for s in segs):
|
|
raise editor.EditError("os blocos gravados deste trecho já foram apagados")
|
|
words = editor.output_words(project)
|
|
ts = now()
|
|
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
|
|
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
|
|
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
|
|
engine.wake_clips.set()
|
|
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
|
|
|
|
@app.post("/v1/clips/{clip_id}/retranscribe")
|
|
def retranscribe(clip_id: int, body: RangeIn):
|
|
"""Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão."""
|
|
clip, session = _context(clip_id)
|
|
a, b = body.startS, min(body.endS, session["duration_s"])
|
|
if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S:
|
|
raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s")
|
|
if not engine.voice.configured:
|
|
raise editor.EditError("serviço de voz não instalado")
|
|
wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b,
|
|
edit_dir(engine, clip["session_id"], clip_id))
|
|
t = time.monotonic()
|
|
try:
|
|
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
|
|
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
|
|
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
|
|
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
|
|
"words": [{"s": round(w.start + a, 3), "e": round(w.end + a, 3), "w": w.word} for w in words]}
|
|
|
|
@app.post("/v1/clips/{clip_id}/tts")
|
|
def tts(clip_id: int, body: TtsIn):
|
|
"""Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-<corte>/tts-<hash>.wav."""
|
|
clip, _session = _context(clip_id)
|
|
voice = engine.voice
|
|
if not voice.configured:
|
|
raise editor.EditError("serviço de voz não instalado")
|
|
text = editor.CONTROL_RE.sub(" ", body.text).strip()
|
|
digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12]
|
|
folder = edit_dir(engine, clip["session_id"], clip_id)
|
|
out = folder / f"tts-{digest}.wav"
|
|
if not out.is_file():
|
|
try:
|
|
response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""},
|
|
json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice,
|
|
"params": {"speed": body.speed, "format": "wav"}})
|
|
except httpx.HTTPError as exc:
|
|
raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc
|
|
if response.status_code != 200:
|
|
try:
|
|
detail = response.json().get("error") or response.json().get("detail") or response.text
|
|
except ValueError:
|
|
detail = response.text
|
|
raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}")
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
out.write_bytes(response.content)
|
|
duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0
|
|
return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice}
|
|
|
|
@app.post("/v1/clips/{clip_id}/suggest")
|
|
def suggest(clip_id: int, body: SuggestIn):
|
|
"""IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom."""
|
|
clip, session = _context(clip_id)
|
|
if not engine.judge.enabled:
|
|
raise editor.EditError("IA desligada (página Clipador → Juiz)")
|
|
row = load_edit(engine, clip_id)
|
|
data = body.project or (row["project"] if row else None) or editor.default_project(
|
|
clip, [], session["duration_s"])
|
|
project = validate_for(engine, clip, session, data)
|
|
lo, hi = project["source"]["lo"], project["source"]["hi"]
|
|
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
|
|
words = [Word(w["s"], w["e"], w["w"]) for w in project["captions"]["words"]] or tl["words"]
|
|
view = clip_view(clip)
|
|
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
|
|
cfg = editor.effective_settings(engine.intel.settings_for(session), project)
|
|
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
|
|
_transcript(words, lo, hi), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
|
|
t = time.monotonic()
|
|
try:
|
|
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
|
|
except JudgeError as exc:
|
|
raise editor.EditError(f"IA: {exc}") from exc
|
|
# Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte.
|
|
return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1),
|
|
"model": engine.judge.describe().get("model")}
|