peter
8383459f70
- Share: a link that expired is never copied (the dialog and one-click Share pick a live one, else make one), says it expired, and the copy-on-open claim clears on the next copy. - A password-protected file link asks to open a file, not to watch a video. - Upload: Cancel, the close button or the backdrop while naming a folder makes no folder; a failed refetch keeps the target; a folder being made says so. - Crop: an infinite number is dropped, not a 500; an unprobed clip's size follows a shown-size crop; the edit_spec docs name frame_w/frame_h; the join and rotated paths are tested. - Auto-skip: the wait gives way on a marker too short for it, so the skip still fires. - Tag chips count the followed channels (subscribed_count) and a toggled chip keeps the focus. - Continue watching's See all sorts by last watched when in progress was already on.
189 lines
7.3 KiB
Python
189 lines
7.3 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)
|
|
|
|
|
|
@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
|