peter
4d1cf66d96
- A tag counts the followed channels the Subscriptions tab shows: hidden ones are left out, and a subscribe, unsubscribe, hide or tag toggle refreshes the count. The Tag manager's row and its hover list count the same channels as the chip; /api/tags sends both counts under their names. - A chip's count keeps the chip's colour after a dot (a dimmed count fell under 4.5:1). A pick in the open "+N" fold closes it; a chip that leaves the list hands the focus to the one in its place. The fold is a dialog of toggle buttons, not an empty menu. - Upload: a folder name left by a press is made once the press is over, if the dialog is still open, instead of guessing a dismissal from Modal's markup. While the folder is made, its place holds the focus and a live region says so. - Share: an expired link has no Copy and a warn badge; the link made on open goes into the cached list, so a reopen makes no second one; the New link form survives the link made on open. - Watch: a repeated Enter sends one unlock while one is on its way. See all buttons are named with their rail. - An unsized clip of a rotated file gets the upright size its crop cut.
210 lines
8.1 KiB
Python
210 lines
8.1 KiB
Python
"""The editor's crop lands on the part of the picture the frame was drawn on, also when a video's
|
|
pixels are not square. The browser reports such a video by its shown size (320 stored, 640 shown),
|
|
and ffmpeg's `crop` counts stored pixels: measured on a real clip, a frame over the middle half kept
|
|
half the frame's red surroundings. So a crop carries the size it was measured on.
|
|
|
|
Real ffmpeg: the pixels of the output are the oracle.
|
|
"""
|
|
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from app.config import settings
|
|
from app.downloads import edit, pipeline, service, storage
|
|
from app.downloads import upload as uploadmod
|
|
from app.downloads.models import DownloadJob, MediaAsset
|
|
|
|
pytestmark = pytest.mark.skipif(shutil.which("ffmpeg") is None, reason="ffmpeg not available")
|
|
|
|
|
|
def _source(path: Path, size: str, box: str, sar: int, rotate: int = 0) -> None:
|
|
"""Red, with a green box: a crop of the box holds no red. `rotate` tags the file to be shown
|
|
turned by that many degrees counter-clockwise, as a phone records a portrait video."""
|
|
tag = ["-display_rotation:v:0", str(rotate)] if rotate else []
|
|
subprocess.run(
|
|
[
|
|
"ffmpeg", "-y", "-loglevel", "error",
|
|
"-f", "lavfi", "-i", f"color=c=red:s={size}:d=2:r=10",
|
|
"-f", "lavfi", "-i", "sine=duration=2",
|
|
"-vf", f"drawbox={box}:c=lime:t=fill,setsar={sar}",
|
|
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", str(path),
|
|
],
|
|
check=True,
|
|
) # fmt: skip
|
|
if tag:
|
|
tagged = path.with_name("tagged-" + path.name)
|
|
subprocess.run(
|
|
["ffmpeg", "-y", "-loglevel", "error", *tag, "-i", str(path), "-c", "copy", str(tagged)],
|
|
check=True,
|
|
) # fmt: skip
|
|
tagged.replace(path)
|
|
|
|
|
|
def _red_and_green(path: Path) -> tuple[int, int]:
|
|
raw = subprocess.run(
|
|
["ffmpeg", "-loglevel", "error", "-i", str(path), "-frames:v", "1",
|
|
"-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
|
|
check=True,
|
|
capture_output=True,
|
|
).stdout # fmt: skip
|
|
red = green = 0
|
|
for i in range(0, len(raw) - 2, 3):
|
|
if raw[i] > 180 and raw[i + 1] < 80:
|
|
red += 1
|
|
elif raw[i + 1] > 180 and raw[i] < 80:
|
|
green += 1
|
|
return red, green
|
|
|
|
|
|
def _cut_asset(db, make_user, src: Path, spec: dict, then=lambda: None) -> MediaAsset:
|
|
user = make_user()
|
|
source = uploadmod.ingest_upload(
|
|
db, user.id, filename="clip.mp4", src_path=src, size=src.stat().st_size
|
|
)
|
|
assert source.status == "done"
|
|
then()
|
|
job = service.enqueue_edit(db, user.id, source, spec)
|
|
asset = db.get(MediaAsset, job.asset_id)
|
|
job.status, asset.status = "running", "downloading" # the worker's claim
|
|
db.commit()
|
|
|
|
pipeline._process_edit(job.id, asset.id)
|
|
|
|
db.expire_all()
|
|
job, asset = db.get(DownloadJob, job.id), db.get(MediaAsset, job.asset_id)
|
|
assert (job.status, job.error, asset.status) == ("done", None, "ready")
|
|
return asset
|
|
|
|
|
|
def _cut(db, make_user, tmp_path, src: Path, crop: dict, **spec) -> Path:
|
|
asset = _cut_asset(db, make_user, src, {"crop": crop, **spec})
|
|
return storage.abs_path(str(tmp_path), asset.rel_path)
|
|
|
|
|
|
def test_a_crop_of_a_video_with_wide_pixels_keeps_what_the_frame_showed(
|
|
db, make_user, tmp_path, monkeypatch
|
|
):
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
_source(src, "320x240", "x=80:y=60:w=160:h=120", sar=2)
|
|
|
|
# What the editor sends for the middle half of this video: the browser shows it at 640 x 240.
|
|
final = _cut(
|
|
db, make_user, tmp_path, src,
|
|
{"x": 160, "y": 60, "w": 320, "h": 120, "frame_w": 640, "frame_h": 240},
|
|
) # fmt: skip
|
|
|
|
red, green = _red_and_green(final)
|
|
assert (red, green) == (0, 160 * 120)
|
|
|
|
|
|
def test_a_crop_of_square_pixels_is_cut_where_it_was_drawn(db, make_user, tmp_path, monkeypatch):
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
_source(src, "480x640", "x=120:y=160:w=240:h=320", sar=1)
|
|
|
|
final = _cut(
|
|
db, make_user, tmp_path, src,
|
|
{"x": 120, "y": 160, "w": 240, "h": 320, "frame_w": 480, "frame_h": 640},
|
|
) # fmt: skip
|
|
|
|
assert _red_and_green(final) == (0, 240 * 320)
|
|
|
|
|
|
def test_a_crop_stored_before_it_carried_its_frame_is_cut_as_it_always_was():
|
|
spec = edit.normalize_edit_spec({"crop": {"x": 4, "y": 6, "w": 100, "h": 50}})
|
|
assert spec["crop"] == {"x": 4, "y": 6, "w": 100, "h": 50}
|
|
cmd = edit.build_edit_cmd(Path("in.mp4"), Path("out.mp4"), spec, "mp4")
|
|
assert cmd[cmd.index("-vf") + 1].startswith("crop=100:50:4:6,")
|
|
|
|
|
|
@pytest.mark.parametrize("frame", [{"frame_w": 0, "frame_h": 240}, {"frame_w": "x", "frame_h": 2}])
|
|
def test_a_frame_that_cannot_be_read_is_not_divided_by(frame):
|
|
spec = edit.normalize_edit_spec({"crop": {"x": 4, "y": 6, "w": 100, "h": 50, **frame}})
|
|
assert spec["crop"] == {"x": 4, "y": 6, "w": 100, "h": 50}
|
|
|
|
|
|
def test_a_crop_of_a_join_keeps_what_the_frame_showed(db, make_user, tmp_path, monkeypatch):
|
|
"""A cut-list joins through `filter_complex`, a crop path of its own."""
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
_source(src, "320x240", "x=80:y=60:w=160:h=120", sar=2)
|
|
|
|
final = _cut(
|
|
db, make_user, tmp_path, src,
|
|
{"x": 160, "y": 60, "w": 320, "h": 120, "frame_w": 640, "frame_h": 240},
|
|
segments=[{"start_s": 0, "end_s": 0.5}, {"start_s": 1, "end_s": 1.5}], accurate=True,
|
|
) # fmt: skip
|
|
|
|
assert _red_and_green(final) == (0, 160 * 120)
|
|
|
|
|
|
def test_a_crop_of_a_rotated_video_is_cut_where_it_was_drawn(db, make_user, tmp_path, monkeypatch):
|
|
"""The browser shows a rotated file upright, so the frame was drawn on the upright picture."""
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
# Stored 320 x 240, green on its left half; shown turned a quarter, 240 x 320.
|
|
_source(src, "320x240", "x=0:y=0:w=160:h=240", sar=1, rotate=90)
|
|
|
|
# Turned counter-clockwise, the stored left half is the shown bottom half.
|
|
final = _cut(
|
|
db, make_user, tmp_path, src,
|
|
{"x": 0, "y": 160, "w": 240, "h": 160, "frame_w": 240, "frame_h": 320},
|
|
) # fmt: skip
|
|
|
|
assert _red_and_green(final) == (0, 240 * 160)
|
|
|
|
|
|
def test_a_clip_ffprobe_cannot_size_gets_the_size_its_crop_cut(
|
|
db, make_user, tmp_path, monkeypatch
|
|
):
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
_source(src, "320x240", "x=80:y=60:w=160:h=120", sar=2)
|
|
|
|
def probe_fails():
|
|
monkeypatch.setattr(pipeline.probe, "probe_media", lambda _p: (None,) * 5)
|
|
|
|
asset = _cut_asset(
|
|
db, make_user, src,
|
|
{"crop": {"x": 160, "y": 60, "w": 320, "h": 120, "frame_w": 640, "frame_h": 240}},
|
|
then=probe_fails,
|
|
) # fmt: skip
|
|
|
|
# Half the shown width of a 320-wide file: 160 stored, not the 320 the frame counted.
|
|
assert (asset.width, asset.height) == (160, 120)
|
|
|
|
|
|
def test_a_rotated_clip_ffprobe_cannot_size_gets_the_upright_size_its_crop_cut(
|
|
db, make_user, tmp_path, monkeypatch
|
|
):
|
|
"""The frame was drawn on the upright picture, which is the stored one turned: so is its cut."""
|
|
monkeypatch.setattr(settings, "files_root", str(tmp_path))
|
|
src = tmp_path / "in.mp4"
|
|
_source(src, "320x240", "x=0:y=0:w=160:h=240", sar=1, rotate=90)
|
|
|
|
def probe_fails():
|
|
monkeypatch.setattr(pipeline.probe, "probe_media", lambda _p: (None,) * 5)
|
|
|
|
asset = _cut_asset(
|
|
db, make_user, src,
|
|
{"crop": {"x": 0, "y": 160, "w": 240, "h": 160, "frame_w": 240, "frame_h": 320}},
|
|
then=probe_fails,
|
|
) # fmt: skip
|
|
|
|
# What ffmpeg cut (the rotated test above): 240 x 160, not the stored 320 x 120.
|
|
assert (asset.width, asset.height) == (240, 160)
|
|
|
|
|
|
@pytest.mark.parametrize("key", ["frame_w", "x"])
|
|
def test_an_infinite_number_in_a_crop_is_dropped_not_a_crash(key):
|
|
crop = {"x": 4, "y": 6, "w": 100, "h": 50, "frame_w": 640, "frame_h": 240}
|
|
spec = edit.normalize_edit_spec({"crop": {**crop, key: float("inf")}})
|
|
if key == "frame_w":
|
|
assert spec["crop"] == {"x": 4, "y": 6, "w": 100, "h": 50}
|
|
else:
|
|
assert "crop" not in spec
|