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
+264
View File
@@ -0,0 +1,264 @@
"""Qualidade de gravação (`capture.quality`), escolha do stream no Streamlink, resolução gravada de fato, busca
exata de quadro em .ts (H.264 e HEVC) e render que atravessa blocos de resolução/codec diferentes."""
import json
import shutil
import subprocess
from pathlib import Path
import pytest
from app import capture, editor, editor_render, layout, media
from app.db import loads
from app.scoring import Word
from .test_sources_and_api import KEY, env, seed_session # noqa: F401 - fixture reaproveitada
FFMPEG = shutil.which("ffmpeg")
FFPROBE = shutil.which("ffprobe")
needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
def auth():
return {"X-Service-Key": KEY}
# ---------------------------------------------------------------- configuração (camadas e validação)
def test_capture_defaults_to_best_and_layers_field_by_field():
assert layout.merge()["capture"] == {"quality": "best"}
assert layout.merge({"capture": {"quality": "720p"}})["capture"]["quality"] == "720p"
# canal 720p, sessão 1080p: a sessão vence
assert layout.merge({"capture": {"quality": "720p"}}, {"capture": {"quality": "1080p"}})["capture"]["quality"] == "1080p"
# configuração antiga (sem o grupo) segue o padrão
assert layout.merge({"layout": {"mode": "blur"}})["capture"]["quality"] == "best"
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
def test_capture_validate_accepts_each_quality(quality):
assert layout.validate({"capture": {"quality": quality}}) == {"capture": {"quality": quality}}
@pytest.mark.parametrize("bad", [{"capture": {"quality": "4k"}}, {"capture": {"quality": "720p60"}},
{"capture": "best"}, {"capture": {"quality": None}}])
def test_capture_validate_rejects_unknown(bad):
with pytest.raises(layout.LayoutError):
layout.validate(bad)
def test_capture_options_match_the_contract():
assert [o["id"] for o in capture.OPTIONS] == list(capture.QUALITIES) == list(layout.CAPTURE_QUALITIES)
for option in capture.OPTIONS:
assert option["label"] and option["hint"] and option["gbPerHour"] > 0
assert option["maxHeight"] == capture.CEILING_HEIGHT.get(option["id"])
# ---------------------------------------------------------------- argumentos do Streamlink
@pytest.mark.parametrize("platform", ["twitch", "kick", "youtube"])
@pytest.mark.parametrize("quality", ["best", "1440p", "1080p", "720p", "480p"])
def test_stream_choice_per_option_and_platform(platform, quality):
choice = capture.stream_choice(quality, platform)
opts = list(choice.options)
hevc = platform == "twitch" and quality in ("best", "1440p")
assert ("--twitch-supported-codecs" in opts) == hevc
if hevc:
assert opts[opts.index("--twitch-supported-codecs") + 1] == "h264,h265" # sem av1: sem libdav1d no FFmpeg
if quality == "best":
assert choice.streams == "best" and "--stream-sorting-excludes" not in opts
else:
assert opts[opts.index("--stream-sorting-excludes") + 1] == f">{quality}60"
assert choice.streams == "best,worst-unfiltered" # reserva: nunca falha por causa do teto
url = "https://www.twitch.tv/x"
assert choice.args(url)[-2:] == [url, choice.streams]
def test_unknown_quality_falls_back_to_best():
assert capture.stream_choice("4k", "kick") == capture.stream_choice("best", "kick")
# Nomes medidos com `streamlink --json` (17/11/2026). O 2K da Twitch não estava no ar: lista do mesmo formato.
TWITCH = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60"]
TWITCH_PORTRAIT = TWITCH + ["284p30_portrait", "640p30_portrait", "852p30_portrait", "1280p60_portrait", "1920p60_portrait"]
TWITCH_936 = ["audio_only", "160p30", "360p30", "480p30", "720p60", "936p60"]
TWITCH_30 = ["audio_only", "160p30", "360p30", "480p30", "720p30", "1080p"]
TWITCH_2K = ["audio_only", "160p30", "360p30", "480p30", "720p60", "1080p60", "1440p60"]
KICK = ["160p", "360p", "480p", "720p60", "1080p60"]
YOUTUBE = ["144p", "240p", "360p", "480p", "720p", "1080p"]
YOUTUBE_60 = ["144p", "240p", "360p", "480p", "720p60", "1080p60"]
def _pick(names: list[str], choice: capture.StreamChoice) -> str | None:
"""Mesma escolha da CLI (1º nome da lista que existir), com o `Plugin.streams` de verdade do Streamlink."""
from streamlink import Streamlink
from streamlink.plugin import Plugin
from streamlink.stream.http import HTTPStream
class Fake(Plugin):
def _get_streams(self):
return {n: HTTPStream(self.session, f"https://e.invalid/{n}") for n in names}
opts = list(choice.options)
excludes = opts[opts.index("--stream-sorting-excludes") + 1].split(",") if "--stream-sorting-excludes" in opts else None
streams = Fake(Streamlink(), "https://e.invalid/").streams(sorting_excludes=excludes)
name = next((n for n in choice.streams.split(",") if n in streams), None)
return streams[name].url.rsplit("/", 1)[1] if name else None
@pytest.mark.parametrize("names,platform,expected", [
(TWITCH, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_PORTRAIT, "twitch", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_936, "twitch", {"best": "936p60", "1440p": "936p60", "1080p": "936p60", "720p": "720p60", "480p": "480p30"}),
(TWITCH_30, "twitch", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p30", "480p": "480p30"}),
(TWITCH_2K, "twitch", {"best": "1440p60", "1440p": "1440p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p30"}),
(KICK, "kick", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
(YOUTUBE, "youtube", {"best": "1080p", "1440p": "1080p", "1080p": "1080p", "720p": "720p", "480p": "480p"}),
(YOUTUBE_60, "youtube", {"best": "1080p60", "1440p": "1080p60", "1080p": "1080p60", "720p": "720p60", "480p": "480p"}),
])
def test_preference_picks_largest_under_the_ceiling(names, platform, expected):
"""Medido nas lives reais com os mesmos argumentos (skipnho, kagura0mea, hpduketv, hotrodd, westcol): mesmo
resultado. Variantes verticais (`*_portrait`) e `audio_only` nunca são escolhidas."""
assert {q: _pick(names, capture.stream_choice(q, platform)) for q in capture.QUALITIES} == expected
def test_ceiling_with_nothing_below_takes_the_closest_above():
assert _pick(["audio_only", "1080p60"], capture.stream_choice("480p", "twitch")) == "1080p60"
assert _pick(["720p60", "1080p60"], capture.stream_choice("480p", "kick")) == "720p60"
# ---------------------------------------------------------------- resolução gravada de fato
def _make_ts(path: Path, size: str, seconds: float, codec: str = "libx264", rate: int = 60, lum: str | None = None) -> Path:
"""Bloco .ts sintético com GOP de 2 s (como a Twitch). `lum` = expressão do brilho no tempo (geq)."""
src = f"color=c=gray:s={size}:r={rate}:d={seconds}" + (f",geq=lum='{lum}':cb=128:cr=128" if lum else "")
codec_args = ["-c:v", codec, "-g", str(2 * rate), "-bf", "0"]
if codec == "libx265":
codec_args += ["-x265-params", f"keyint={2 * rate}:min-keyint={2 * rate}:open-gop=0:bframes=0:log-level=error"]
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", src, "-f", "lavfi", "-i",
f"sine=frequency=440:sample_rate=48000:duration={seconds}", *codec_args, "-pix_fmt", "yuv420p",
"-c:a", "aac", "-shortest", "-f", "mpegts", str(path)], check=True, capture_output=True)
return path
@needs_ffmpeg
def test_probe_block_reads_resolution_fps_codec(tmp_path):
info = capture.probe_block(FFPROBE, _make_ts(tmp_path / "a.ts", "320x180", 2))
assert (info["width"], info["height"], info["fps"], info["codec"]) == (320, 180, 60, "h264")
assert info["kbps"] and info["gbPerHour"] > 0
def test_record_run_keeps_runs_and_flags_mixed_resolution():
p1 = {"width": 1920, "height": 1080, "fps": 60, "codec": "h264", "kbps": 8000, "gbPerHour": 3.6}
first = capture.record_run(None, "best", 0, p1, "t1")
assert first["width"] == 1920 and first["quality"] == "best" and first["mixed"] is False and len(first["runs"]) == 1
same = capture.record_run(first, "best", 40, p1, "t2")
assert same["mixed"] is False and [r["fromIdx"] for r in same["runs"]] == [0, 40]
p2 = {**p1, "width": 1280, "height": 720}
mixed = capture.record_run(same, "720p", 80, p2, "t3")
assert mixed["height"] == 720 and mixed["fromIdx"] == 80 and mixed["mixed"] is True
assert capture.label(mixed) == "1280×720 · 60 qps"
@needs_ffmpeg
def test_capture_records_real_resolution_on_first_block(env, tmp_path, monkeypatch): # noqa: F811
from dataclasses import replace
from app.sources import parse_source
from app.worker import Capture
client, engine = env
sid = seed_session(engine, duration=60)
engine.db.run("DELETE FROM segments WHERE session_id = ?", sid)
engine.settings = replace(engine.settings, ffprobe=FFPROBE)
work = tmp_path / "cap"
work.mkdir()
_make_ts(work / "seg_00000.ts", "640x360", 2)
(work / "segments.csv").write_text("seg_00000.ts,0.000000,2.000000\n", encoding="utf-8")
cap = Capture(engine, sid, parse_source("https://www.twitch.tv/alanzoka"), work)
cap.quality = "1440p"
import app.worker as worker_module
monkeypatch.setattr(worker_module, "rel", lambda path: path.as_posix()) # bloco fora do repositório (tmp)
assert cap._collect(work / "segments.csv", 0) == 1
info = loads(engine.db.get("SELECT capture_json FROM sessions WHERE id = ?", sid)["capture_json"], None)
assert (info["quality"], info["width"], info["height"], info["fps"], info["fromIdx"]) == ("1440p", 640, 360, 60, 0)
view = client.get(f"/v1/sessions/{sid}", headers=auth()).json()
assert view["capture"]["width"] == 640 and view["capture"]["mixed"] is False
def test_session_without_capture_info_reports_none(env): # noqa: F811
client, engine = env
sid = seed_session(engine, duration=60)
assert client.get(f"/v1/sessions/{sid}", headers=auth()).json()["capture"] is None
def test_engine_quality_follows_channel_then_session(env): # noqa: F811
client, engine = env
client.post("/v1/channels", json={"url": "https://www.twitch.tv/alanzoka"}, headers=auth())
sid = seed_session(engine, duration=60)
engine.db.run("UPDATE sessions SET channel_id = 'twitch-alanzoka' WHERE id = ?", sid)
assert engine.capture_quality(sid) == "best" # padrão novo
r = client.put("/v1/channels/twitch-alanzoka/settings", json={"capture": {"quality": "720p"}}, headers=auth())
assert r.status_code == 200 and r.json()["effective"]["capture"]["quality"] == "720p"
assert engine.capture_quality(sid) == "720p"
r = client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "1080p"}}, headers=auth())
assert r.json()["effective"]["capture"]["quality"] == "1080p"
assert engine.capture_quality(sid) == "1080p"
assert client.put(f"/v1/sessions/{sid}/settings", json={"capture": {"quality": "8k"}}, headers=auth()).status_code == 400
def test_settings_route_lists_capture_qualities(env): # noqa: F811
client, engine = env
sid = seed_session(engine, duration=60)
body = client.get(f"/v1/sessions/{sid}/settings", headers=auth()).json()
assert [o["id"] for o in body["captureQualities"]] == list(capture.QUALITIES)
assert body["defaults"]["capture"] == {"quality": "best"}
# ---------------------------------------------------------------- busca exata de quadro em .ts
@needs_ffmpeg
@pytest.mark.parametrize("codec", ["libx264", "libx265"])
def test_grab_frame_is_exact_in_ts(tmp_path, codec):
"""Antes: `-ss` antes do `-i` num .ts dava o PRÓXIMO quadro-chave no H.264 e um quadro CINZA no HEVC."""
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
capture_output=True, text=True).stdout:
pytest.skip("FFmpeg sem libx265")
ts = _make_ts(tmp_path / "b.ts", "160x96", 12, codec=codec, rate=30, lum="min(235,16+T*18)")
for t in (3.0, 7.5, 9.3):
out = media.grab_frame(FFMPEG, [(ts, 0.0, 12.0)], t, tmp_path / f"f{t}.png", width=0)
raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(out), "-f", "rawvideo", "-pix_fmt", "gray", "-"],
capture_output=True, check=True).stdout
mean = sum(raw) / len(raw)
expected = t * 18 * 255 / 219 # Y de faixa limitada (16 + 18·t) → cinza de faixa cheia
assert abs(mean - expected) < 6, (t, mean, expected) # 6 ≈ 0,3 s; o próximo quadro-chave daria até 42
def test_seek_args_prerolls_and_selects_absolute_time():
assert media.seek_args(10.0) == (["-ss", "6.000", "-copyts", "-start_at_zero"], "select='gte(t,10.000)'")
assert media.seek_args(1.5) == (["-ss", "0.000", "-copyts", "-start_at_zero"], "select='gte(t,1.500)'")
# ---------------------------------------------------------------- render que atravessa a troca de resolução
@needs_ffmpeg
@pytest.mark.parametrize("second", [("640x360", "libx264"), ("960x540", "libx265")])
def test_render_across_resolution_change_keeps_whole_video(tmp_path, second):
"""Retomada em outra qualidade (ou fonte que muda de resolução). Antes o vídeo parava na emenda (corte de 35 s
com 20 s de vídeo; 15 s na troca H.264 → HEVC)."""
size, codec = second
if codec == "libx265" and "libx265" not in subprocess.run([FFMPEG, "-hide_banner", "-encoders"],
capture_output=True, text=True).stdout:
pytest.skip("FFmpeg sem libx265")
a = _make_ts(tmp_path / "seg_00000.ts", "320x180", 4)
b = _make_ts(tmp_path / "seg_00001.ts", size, 4, codec=codec)
segs = [(a, 0.0, 4.0), (b, 4.0, 8.0)]
same, created = editor_render.uniform_segments(FFMPEG, FFPROBE, [(a, 0.0, 4.0), (a, 4.0, 8.0)], tmp_path, "x")
assert created is None and same == [(a, 0.0, 4.0), (a, 4.0, 8.0)] # blocos iguais: caminho de sempre
clip = {"session_id": 1, "start_s": 1.0, "end_s": 7.0, "peak_s": 4.0, "title": "Emenda"}
project = editor.validate_project(editor.default_project(clip, [Word(1.2, 1.5, "oi")], 8.0), session_id=1,
session_duration=8.0, repo_root=tmp_path, tts_dir=tmp_path, assets_dir=tmp_path)
project["cover"]["enabled"] = False
out = tmp_path / "clip.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], segs, project,
layout.merge(), "canal", out, tmp_path)
streams = json.loads(subprocess.run([FFPROBE, "-v", "error", "-select_streams", "v", "-show_entries",
"stream=duration,width,height", "-of", "json", str(out)],
capture_output=True, text=True, check=True).stdout)["streams"][0]
assert (streams["width"], streams["height"]) == (1080, 1920)
assert float(streams["duration"]) == pytest.approx(6.0, abs=0.15)
assert not list(tmp_path.glob("*.uniform.mkv")) # intermediário apagado