Files
CenaForge/clipper/tests/test_capture_quality.py
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

265 lines
15 KiB
Python
Raw Permalink 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.
"""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