"""Reenquadramento do jogo no tempo (keyframes) e camadas inseridas (pedido do dono, 17/11/2026, corte 61).""" import shutil import subprocess from pathlib import Path import pytest from app import editor, editor_render, layout, reframe from .test_editor import make_project, validate FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe") needs_ffmpeg = pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado") SRC_W, SRC_H = 1280, 720 DOT = (808.0, 308.0) # centro do quadrado branco de 16 px no vídeo de teste def _project(**over): base = make_project(source={"sessionId": 1, "lo": 0, "hi": 8}, cuts=[{"start": 0, "end": 4, "mode": None}], overlays=[], captions={"enabled": False, "preset": "pop", "style": {}, "emphColor": "#22E36B", "words": []}, progress={"enabled": False}, cover={"enabled": False, "t": 1}) base.update(over) return base # ---------------------------------------------------------------- interpolação e validação def test_interpolation_semantics(): keys = [{"t": 1.0, "cx": 0.2, "ease": "linear"}, {"t": 3.0, "cx": 0.6, "ease": "hold"}, {"t": 5.0, "cx": 0.9, "ease": "smooth"}, {"t": 7.0, "cx": 0.1, "ease": "smooth"}] assert reframe.interp(keys, 0.0, "cx") == 0.2 # antes do 1º: segura assert reframe.interp(keys, 2.0, "cx") == pytest.approx(0.4) # linear assert reframe.interp(keys, 4.99, "cx") == 0.6 and reframe.interp(keys, 5.0, "cx") == 0.9 # hold salta no key seguinte assert reframe.interp(keys, 6.0, "cx") == pytest.approx(0.5) # smooth: meio exato no meio assert reframe.interp(keys, 6.5, "cx") < 0.9 - 0.8 * 0.75 + 0.05 # smooth acelera no meio (mais que linear) assert reframe.interp(keys, 9.0, "cx") == 0.1 # depois do último: segura def test_window_keeps_aspect_and_stays_inside(): keys = [{"t": 0, "cx": 0.98, "cy": 0.02, "w": 0.4, "ease": "smooth"}] x, y, w, h = reframe.window(keys, 0, SRC_W, SRC_H, 1080 / 1268) assert w / h == pytest.approx(1080 / 1268) and x + w <= SRC_W + 1e-6 and y >= 0 and x >= 0 big = [{"t": 0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"}] x, y, w, h = reframe.window(big, 0, SRC_W, SRC_H, 1080 / 1920) # zoom que não cabe: encolhe, não deforma assert h == pytest.approx(SRC_H) and w == pytest.approx(SRC_H * 1080 / 1920) def test_validation(tmp_path): keys = [{"t": 3, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1, "cx": 0.2, "cy": 0.3, "w": 1, "ease": "hold"}] p = validate(_project(reframe={"keys": keys}), tmp_path) assert [k["t"] for k in p["reframe"]["keys"]] == [1, 3] and p["reframe"]["keys"][1]["ease"] == "smooth" assert "reframe" not in validate(_project(), tmp_path) and "reframe" not in validate(_project(reframe={"keys": []}), tmp_path) inset = {"id": "i", "kind": "inset", "start": 1, "end": 3, "src": {"x": 0.7, "y": 0.0, "w": 0.3, "h": 0.25}, "x": 0.5, "y": 0.3, "size": 0.5, "border": "#ffffff"} q = validate(_project(overlays=[inset]), tmp_path)["overlays"][0] assert q["border"] == "#FFFFFF" and q["borderW"] == 6 and q["radius"] == 18 and q["shadow"] is True and q["keys"] == [] bad = [ {"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.01}]}}, {"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5, "ease": "bounce"}]}}, {"reframe": {"keys": [{"t": 1, "cx": 0.5, "cy": 0.5, "w": 0.5}, {"t": 1.01, "cx": 0.5, "cy": 0.5, "w": 0.5}]}}, {"reframe": {"keys": [{"t": 1 + i * 0.05, "cx": 0.5, "cy": 0.5, "w": 0.5} for i in range(61)]}}, {"overlays": [{**inset, "src": {"x": 0.9, "y": 0, "w": 0.3, "h": 0.2}}]}, # fora do quadro {"overlays": [{**inset, "size": 0.05}]}, {"overlays": [{**inset, "anim": "spin"}]}, {"overlays": [{**inset, "src": None}]}, {"overlays": [{**inset, "id": f"i{n}"} for n in range(13)]}, # mais de 12 camadas ] for change in bad: with pytest.raises(editor.EditError): validate(_project(**change), tmp_path) def test_old_project_graph_unchanged_and_inset_not_in_ass(tmp_path): p = validate(make_project(), tmp_path) cfg = editor.effective_settings(layout.merge(), p) graph = editor_render.build_filter(p, cfg, editor.pieces(p["cuts"]), 10.0, "e.ass", []) assert "perspective" not in graph and "[vraw]" not in graph and "split=2[tl" not in graph inset = {"id": "i", "kind": "inset", "start": 11, "end": 13, "src": {"x": 0, "y": 0, "w": 0.3, "h": 0.3}} q = validate(make_project(overlays=[inset]), tmp_path) assert "Dialogue: 2" not in editor_render.build_project_ass(q, cfg, "") # ---------------------------------------------------------------- render real @pytest.fixture(scope="module") def dot_video(tmp_path_factory): if not FFMPEG: pytest.skip("FFmpeg não instalado") folder = tmp_path_factory.mktemp("reframe") seg = folder / "dot.ts" subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0x101010:s={SRC_W}x{SRC_H}:r=30:d=8", "-f", "lavfi", "-i", "sine=frequency=440:duration=8", "-vf", "drawbox=x=800:y=300:w=16:h=16:color=white:t=fill", "-c:v", "libx264", "-preset", "ultrafast", "-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True) return seg def _frames(video: Path, size: tuple[int, int]): import numpy as np raw = subprocess.run([FFMPEG, "-v", "error", "-i", str(video), "-f", "rawvideo", "-pix_fmt", "gray", "-"], capture_output=True, check=True).stdout return np.frombuffer(raw, np.uint8).reshape(-1, size[1], size[0]).astype(float) def _centroid(frame): import numpy as np m = np.where(frame > 128, frame, 0) s = m.sum() if not s: return None ys, xs = np.mgrid[0:frame.shape[0], 0:frame.shape[1]] return (m * xs).sum() / s, (m * ys).sum() / s def _expected(keys, t, dest): x, y, w, h = reframe.window(keys, t, SRC_W, SRC_H, dest[0] / dest[1]) return (DOT[0] - x) / w * dest[0], (DOT[1] - y) / h * dest[1] def _render(tmp_path, video, project, settings=None, name="out.mp4"): p = validate(project, tmp_path, duration=8.0) out = tmp_path / name editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "12"], [(video, 0.0, 8.0)], p, layout.merge(settings or {}), "", out, tmp_path) return p, out @needs_ffmpeg @pytest.mark.parametrize("aspect", ["vertical", "horizontal"]) def test_reframe_window_follows_keys_smoothly(tmp_path, dot_video, aspect): keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "smooth"}, {"t": 2.0, "cx": 0.62, "cy": 0.42, "w": 0.3, "ease": "hold"}, {"t": 3.0, "cx": 0.66, "cy": 0.45, "w": 0.45, "ease": "linear"}] settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only"}} _, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings)) size = layout.FRAME_SIZES[aspect] frames = _frames(out, size) for n in (0, 15, 30, 45, 60, 75, 89, 91, 105): # quadro n = sessão n/30 (um trecho só) got = _centroid(frames[n]) want = _expected(keys, n / 30, size) assert got and abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (n, got, want) xs = [_centroid(f)[0] for f in frames[1:60]] steps = [b - a for a, b in zip(xs, xs[1:])] assert all(s <= 0.05 for s in steps) or all(s >= -0.05 for s in steps) # sempre no mesmo sentido: sem tremida jump_before, jump_after = _centroid(frames[89]), _centroid(frames[91]) # hold: salta no key de 3,0 s assert abs(jump_after[0] - jump_before[0]) > 20 @needs_ffmpeg def test_reframe_uses_session_time_across_cuts(tmp_path, dot_video): keys = [{"t": 0.0, "cx": 0.5, "cy": 0.5, "w": 1.0, "ease": "linear"}, {"t": 6.0, "cx": 0.66, "cy": 0.45, "w": 0.35}] cuts = [{"start": 0.0, "end": 1.5, "mode": None}, {"start": 3.0, "end": 5.0, "mode": None}] settings = {"layout": {"mode": "game_only"}} _, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, cuts=cuts, settings=settings)) frames = _frames(out, (1080, 1920)) for out_t, session_t in ((0.5, 0.5), (2.0, 3.5), (3.0, 4.5)): got, want = _centroid(frames[int(out_t * 30)]), _expected(keys, session_t, (1080, 1920)) assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4, (out_t, got, want) @needs_ffmpeg def test_reframe_in_cam_top_uses_game_area_and_cover(tmp_path, dot_video): keys = [{"t": 0.0, "cx": 0.62, "cy": 0.42, "w": 0.3}] settings = {"layout": {"mode": "cam_top", "cam": {"x": 0.0, "y": 0.0, "w": 0.2, "h": 0.25}}} p, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings=settings)) top = layout.cam_panel_height(layout.merge(settings)) got = _centroid(_frames(out, (1080, 1920))[10][top:]) want = _expected(keys, 0, (1080, 1920 - top)) assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4 cover = editor_render.render_cover(FFMPEG, [(dot_video, 0.0, 8.0)], {**p, "cover": {**p["cover"], "t": 1.0}}, layout.merge(settings), "", tmp_path / "cover.jpg") assert cover.is_file() @pytest.fixture(scope="module") def color_video(tmp_path_factory): if not FFMPEG: pytest.skip("FFmpeg não instalado") folder = tmp_path_factory.mktemp("insets") seg = folder / "colors.ts" boxes = ("drawbox=x=0:y=0:w=300:h=200:color=0x00FF00:t=fill," "drawbox=x=900:y=500:w=380:h=220:color=0x0000FF:t=fill") subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", f"color=c=0xFF0000:s={SRC_W}x{SRC_H}:r=30:d=8", "-f", "lavfi", "-i", "sine=frequency=440:duration=8", "-vf", boxes, "-c:v", "libx264", "-preset", "ultrafast", "-crf", "8", "-g", "15", "-c:a", "aac", "-shortest", str(seg)], check=True) return seg def _rgb(video: Path, t: float, size: tuple[int, int]): import numpy as np raw = subprocess.run([FFMPEG, "-v", "error", "-ss", f"{t:.3f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout return np.frombuffer(raw, np.uint8).reshape(size[1], size[0], 3).astype(int) def _is(px, color, tol=60): return all(abs(int(a) - b) < tol for a, b in zip(px, color)) @needs_ffmpeg @pytest.mark.parametrize("aspect", ["vertical", "horizontal"]) def test_two_overlapping_insets_with_border_and_anim(tmp_path, color_video, aspect): green = {"id": "g", "kind": "inset", "start": 0.5, "end": 3.5, "src": {"x": 0.0, "y": 0.0, "w": 0.2344, "h": 0.2778}, "x": 0.25, "y": 0.25, "size": 0.4, "border": "#FFFFFF", "borderW": 8, "radius": 20, "shadow": True, "anim": "fade"} blue = {"id": "b", "kind": "inset", "start": 1.0, "end": 3.5, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056}, "x": 0.45, "y": 0.35, "size": 0.4, "border": "#FFFF00", "borderW": 8, "radius": 0, "shadow": False, "anim": "pop"} settings = {"format": {"aspect": aspect}, "layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}} _, out = _render(tmp_path, color_video, _project(overlays=[green, blue], settings=settings)) w, h = size = layout.FRAME_SIZES[aspect] frame = _rgb(out, 2.0, size) gx, gy = int(0.25 * w), int(0.25 * h) gw = 0.4 * w gh = gw * (0.2778 * SRC_H) / (0.2344 * SRC_W) bw = 0.4 * w bh = bw * (0.3056 * SRC_H) / (0.2969 * SRC_W) bx0, by0 = 0.45 * w - bw / 2, 0.35 * h - bh / 2 assert _is(frame[gy, int(gx - gw / 2 + 12)], (0, 255, 0)) # camada verde (dentro, longe da azul) assert _is(frame[gy, int(gx - gw / 2 - 3)], (255, 255, 255)) # borda branca do lado de fora assert _is(frame[int(by0 + bh / 2), int(0.45 * w)], (0, 0, 255)) # camada azul ox, oy = int(bx0 + 15), int(by0 + 15) # canto da azul que cai em cima da verde: a azul (última) fica por cima assert gx - gw / 2 < ox < gx + gw / 2 and gy - gh / 2 < oy < gy + gh / 2 assert _is(frame[oy, ox], (0, 0, 255)) assert _is(frame[int(0.9 * h), int(0.9 * w)], (255, 0, 0)) # fora das camadas: o jogo (vermelho) early = _rgb(out, 0.56, size)[gy, int(gx - gw / 2 + 12)] # fade: no começo a verde ainda está entrando assert not _is(early, (0, 255, 0), tol=30) assert _is(_rgb(out, 3.8, size)[gy, gx], (255, 0, 0)) # depois do fim: some @needs_ffmpeg def test_inset_keys_move_it_in_session_time(tmp_path, color_video): blue = {"id": "b", "kind": "inset", "start": 0.0, "end": 6.0, "src": {"x": 0.7031, "y": 0.6944, "w": 0.2969, "h": 0.3056}, "x": 0.3, "y": 0.5, "size": 0.3, "border": None, "shadow": False, "anim": "none", "keys": [{"t": 1.0, "x": 0.3, "y": 0.5, "size": 0.3, "ease": "linear"}, {"t": 5.0, "x": 0.7, "y": 0.5, "size": 0.3}]} cuts = [{"start": 0.0, "end": 2.0, "mode": None}, {"start": 3.0, "end": 6.0, "mode": None}] settings = {"layout": {"mode": "game_only", "game": {"x": 0.35, "y": 0.3, "w": 0.3, "h": 0.4}}} _, out = _render(tmp_path, color_video, _project(overlays=[blue], cuts=cuts, settings=settings)) frame = _rgb(out, 2.0, (1080, 1920)) # saída 2,0 s = sessão 3,0 s → x = 0,3 + 0,4 × (2/4) = 0,5 assert _is(frame[960, 540], (0, 0, 255)) and _is(frame[960, int(0.3 * 1080) - 120], (255, 0, 0)) @needs_ffmpeg def test_sixty_keys_render_through_graph_file(tmp_path, dot_video): """60 keyframes num trecho: o grafo passa do limite da linha de comando e vai por arquivo (-/filter_complex).""" keys = [{"t": i * 0.06, "cx": 0.5 + 0.1 * (i % 2), "cy": 0.5, "w": 0.4 + 0.3 * (i % 3) / 2, "ease": "linear"} for i in range(60)] p = validate(_project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}}), tmp_path, duration=8.0) graph = editor_render.build_filter(p, editor.effective_settings(layout.merge(), p), editor.pieces(p["cuts"]), 0.0, None, []) assert len(graph) > 20000 _, out = _render(tmp_path, dot_video, _project(reframe={"keys": keys}, settings={"layout": {"mode": "game_only"}})) got, want = _centroid(_frames(out, (1080, 1920))[100]), _expected(keys, 100 / 30, (1080, 1920)) assert abs(got[0] - want[0]) < 4 and abs(got[1] - want[1]) < 4 assert not list(tmp_path.glob("*.graph.txt")) # arquivo temporário apagado