From 9064c137b527883e592be3b73be8d573b33e5b78 Mon Sep 17 00:00:00 2001 From: Austin Mroz Date: Mon, 9 Nov 2026 17:11:23 -0800 Subject: [PATCH] Generate previews for ProRes outputs --- app/assets/api/routes.py | 20 +---- app/assets/manager.py | 1 + app/assets/previews.py | 24 +++-- app/assets/services/ingest.py | 53 ++++++++--- app/assets/services/schemas.py | 1 + app/assets/services/video_metadata.py | 5 +- app/assets/services/video_proxy.py | 87 +++++++++++++++++++ server.py | 2 +- .../assets_test/services/preview_helpers.py | 30 +++++++ .../services/test_output_previews.py | 46 +++++++++- .../assets_test/services/test_previews.py | 2 +- .../services/test_upload_previews.py | 38 ++++++-- .../services/test_video_metadata.py | 1 + .../assets_test/services/test_video_proxy.py | 48 ++++++++++ 14 files changed, 313 insertions(+), 45 deletions(-) create mode 100644 app/assets/services/video_proxy.py create mode 100644 tests-unit/assets_test/services/test_video_proxy.py diff --git a/app/assets/api/routes.py b/app/assets/api/routes.py index c32e65b71bd..923ea3d6c28 100644 --- a/app/assets/api/routes.py +++ b/app/assets/api/routes.py @@ -268,7 +268,7 @@ def _validate_sort_field(requested: str | None) -> RecordSortField: async def _with_upload_preview(result: schemas.UploadResult) -> schemas.UploadResult: - preview_id = await generate_upload_preview(result.ref.id, result.ref.file_path, result.ref.preview_id) + preview_id = await generate_upload_preview(result.ref.id, result.ref.file_path, result.ref.preview_id, result.ref.system_metadata) if preview_id == result.ref.preview_id: return result return dataclasses.replace(result, ref=dataclasses.replace(result.ref, preview_id=preview_id)) @@ -602,23 +602,11 @@ async def download_asset_content(request: web.Request) -> web.Response: # debug, not info: preview_url points here, so every thumbnail render is a fetch. logging.debug("download_asset_content: path=%s, type=%s, name=%s", abs_path, content_type, filename) - file_size = os.path.getsize(abs_path) - - async def stream_file_chunks(): - chunk_size = 64 * 1024 - with open(abs_path, "rb") as f: - while True: - chunk = f.read(chunk_size) - if not chunk: - break - yield chunk - - return web.Response( - body=stream_file_chunks(), - content_type=content_type, + return web.FileResponse( + abs_path, headers={ + "Content-Type": content_type, "Content-Disposition": cd, - "Content-Length": str(file_size), "X-Content-Type-Options": "nosniff", **extra_headers, }, diff --git a/app/assets/manager.py b/app/assets/manager.py index f9bbf17a3c1..fd4f87b4530 100644 --- a/app/assets/manager.py +++ b/app/assets/manager.py @@ -213,6 +213,7 @@ def register_upload( size=result.asset.size_bytes, mime_type=result.asset.mime_type, tags=result.tags, + system_metadata=result.ref.system_metadata, ) except Exception: logging.warning("Failed to register uploaded image as asset", exc_info=True) diff --git a/app/assets/previews.py b/app/assets/previews.py index 119dae0e82f..fe273ef1f58 100644 --- a/app/assets/previews.py +++ b/app/assets/previews.py @@ -1,5 +1,5 @@ -"""Previews of uploaded EXRs: decoded, stored and linked on upload. Best-effort, since an -asset without a preview is a normal state.""" +"""Previews of uploads browsers can't show, EXRs and ProRes: made, stored and linked on upload. +Best-effort, since an asset without a preview is a normal state.""" from __future__ import annotations @@ -20,6 +20,8 @@ from app.assets.database.queries.records import create_content, create_record from app.assets.event_log import emit, error_type from app.assets.services.image_dimensions import read_exr_windows +from app.assets.services.ingest import link_preview +from app.assets.services.video_proxy import needs_video_proxy, write_video_proxy from app.database.db import create_write_session from comfy_execution.preview_tonemap import linear_to_preview @@ -105,14 +107,22 @@ def _emit_error(reason: str, exc: BaseException) -> None: emit("previews.generation_failed", reason=reason, error_type=error_type(exc)) -async def generate_upload_preview(asset_id: str, path: str | None, preview_id: str | None) -> str | None: - """The preview_id an upload ends with: the one it has, else one made now for an EXR.""" - if preview_id is not None or not path or not is_exr(path): +async def generate_upload_preview( + asset_id: str, path: str | None, preview_id: str | None, system_metadata: dict | None +) -> str | None: + """The preview_id an upload ends with: the one it has, else one made now for an EXR or ProRes.""" + if preview_id is not None or not path: return preview_id + if is_exr(path): + make, link = _make_preview, lambda made: _store_and_link(asset_id, *made) + elif needs_video_proxy(system_metadata): + make, link = write_video_proxy, lambda made: link_preview(asset_id, made) + else: + return None started = time.monotonic() try: async with _DECODE_SLOTS: - webp, width, height = await asyncio.to_thread(_make_preview, path) + made = await asyncio.to_thread(make, path) except PreviewSkipped as skipped: _emit_failed(skipped.args[0]) return None @@ -120,7 +130,7 @@ async def generate_upload_preview(asset_id: str, path: str | None, preview_id: s _emit_error("decode_failed", exc) return None try: - linked = await asyncio.to_thread(_store_and_link, asset_id, webp, width, height) + linked = await asyncio.to_thread(link, made) except Exception as exc: _emit_error("write_failed", exc) return None diff --git a/app/assets/services/ingest.py b/app/assets/services/ingest.py index d98eee529fa..57ca30a1c3d 100644 --- a/app/assets/services/ingest.py +++ b/app/assets/services/ingest.py @@ -52,6 +52,7 @@ UserMetadata, ) from app.assets.services.snapshot_hash import snapshot_hash +from app.assets.services.video_proxy import needs_video_proxy, write_video_proxy from app.database.db import create_session, create_write_session @@ -108,11 +109,12 @@ def _live_sibling_preview_id(session: Session, content_id: str) -> str | None: return next((preview_id for preview_id, path in rows if os.path.isfile(path)), None) -_PREVIEW_FILENAME = re.compile(r"[0-9a-f]{64}\.(jpg|webp)") +_PREVIEW_FILENAME = re.compile(r"[0-9a-f]{64}\.(jpg|webp|mp4)") +_PREVIEW_MEDIA = {"jpg": ("image/jpeg", "image"), "webp": ("image/webp", "image"), "mp4": ("video/mp4", "video")} -def _probe_output_preview(preview_ref: dict | None) -> tuple[str, str, int, int, os.stat_result] | None: - """The file a save node named as its output's preview: trusted by name, so stat only.""" +def _probe_preview(preview_ref: dict | None) -> tuple[str, str, int, int, os.stat_result] | None: + """The file named as an asset's preview: trusted by name, so stat only.""" if preview_ref is None: return None try: @@ -122,12 +124,12 @@ def _probe_output_preview(preview_ref: dict | None) -> tuple[str, str, int, int, path = os.path.join(folder_paths.get_previews_directory(), filename) return path, filename, int(preview_ref["width"]), int(preview_ref["height"]), os.stat(path) except Exception: - logging.warning("Ignoring the preview named for an output: %r", preview_ref, exc_info=True) + logging.warning("Ignoring the preview named for an asset: %r", preview_ref, exc_info=True) return None -def _link_output_preview(session: Session, record: Asset, preview: tuple[str, str, int, int, os.stat_result]) -> None: - """Link the output to its preview's record, creating it on first use; never fails the output.""" +def _link_preview(session: Session, record: Asset, preview: tuple[str, str, int, int, os.stat_result]) -> None: + """Link the asset to its preview's record, creating it on first use; never fails the asset.""" path, filename, width, height, stat_result = preview try: with session.begin_nested(): @@ -143,13 +145,14 @@ def _link_output_preview(session: Session, record: Asset, preview: tuple[str, st .limit(1) ) if preview_id is None: + mime_type, kind = _PREVIEW_MEDIA[filename.rpartition(".")[2]] preview_id = create_record( session, content.id, filename, - mime_type="image/webp" if filename.endswith(".webp") else "image/jpeg", + mime_type=mime_type, tags=["preview"], - system_metadata={"kind": "image", "width": width, "height": height}, + system_metadata={"kind": kind, "width": width, "height": height}, ).id record.preview_id = preview_id session.flush() @@ -157,6 +160,32 @@ def _link_output_preview(session: Session, record: Asset, preview: tuple[str, st logging.warning("Could not link the preview %s", filename, exc_info=True) +def _write_preview_proxy(abs_path: str, system_metadata: dict | None) -> dict | None: + """The preview ref of a browser-playable proxy, for a video that needs one.""" + if not needs_video_proxy(system_metadata): + return None + try: + return write_video_proxy(abs_path) + except Exception: + logging.warning("Could not write a preview proxy for %s", abs_path, exc_info=True) + return None + + +def link_preview(asset_id: str, preview_ref: dict) -> str | None: + """Link a generated preview to an asset that has none; None if it is gone or got one meanwhile.""" + preview = _probe_preview(preview_ref) + if preview is None: + return None + with create_write_session() as session: + record = session.get(Asset, asset_id) + if record is None or record.preview_id is not None: + return None + _link_preview(session, record, preview) + preview_id = record.preview_id + session.commit() + return preview_id + + def _discard_unreferenced_content(session: Session, content_id: str) -> None: """Remove a content row left orphaned by a failed registration. @@ -715,7 +744,9 @@ def create_from_hash( return None content_id = content.id # Read the file before the claim below opens the write transaction. - system_metadata = _extract_system_metadata_sync(content.path, mime_type) + system_metadata = _extract_system_metadata_sync( + content.path, mime_type or mimetypes.guess_type(content.path, strict=False)[0] + ) if not claim_qualified_content(session, content_id, stored_hash): session.rollback() return None @@ -815,7 +846,6 @@ def register_executed_output( abs_path: str, job_id: str | None = None, preview_ref: dict | None = None ) -> RegisteredAsset | None: locator = os.path.abspath(abs_path) - preview = _probe_output_preview(preview_ref) try: stat_result = os.stat(locator, follow_symlinks=True) size_bytes = stat_result.st_size @@ -825,6 +855,7 @@ def register_executed_output( system_metadata = _extract_system_metadata_sync( locator, mime_type, stat_result ) + preview = _probe_preview(preview_ref or _write_preview_proxy(locator, system_metadata)) with create_write_session() as session: created_content_id: str | None = None try: @@ -852,7 +883,7 @@ def register_executed_output( system_metadata=system_metadata, ) if preview is not None: - _link_output_preview(session, record, preview) + _link_preview(session, record, preview) # Read before commit: expiry would reload them in a second write transaction. record_id = record.id record_content_id = record.content_id diff --git a/app/assets/services/schemas.py b/app/assets/services/schemas.py index 0b77daf40a8..57520a7070c 100644 --- a/app/assets/services/schemas.py +++ b/app/assets/services/schemas.py @@ -112,6 +112,7 @@ class UploadAssetView: size: int | None mime_type: str | None tags: list[str] + system_metadata: dict[str, Any] | None @dataclass(frozen=True) diff --git a/app/assets/services/video_metadata.py b/app/assets/services/video_metadata.py index 31c1ffe1e22..0b1c1cd8023 100644 --- a/app/assets/services/video_metadata.py +++ b/app/assets/services/video_metadata.py @@ -23,7 +23,7 @@ def extract_video_metadata( with ``video/``, extraction is skipped without touching the file. Returns: - ``{"kind": "video", "width": W, "height": H, ...}`` with optional + ``{"kind": "video", "width": W, "height": H, "codec": C, ...}`` with optional ``duration`` (seconds), ``fps`` and ``frame_count`` keys when the file has a recognizable video stream, otherwise ``None``. """ @@ -57,6 +57,7 @@ def extract_video_metadata( width = stream.codec_context.width height = stream.codec_context.height + codec = stream.codec_context.name except (OSError, ValueError, av.error.FFmpegError) as exc: logger.debug("Failed to read video metadata from %s: %s", file_path, exc) return None @@ -69,7 +70,7 @@ def extract_video_metadata( ): return None - metadata: dict[str, Any] = {"kind": "video", "width": width, "height": height} + metadata: dict[str, Any] = {"kind": "video", "width": width, "height": height, "codec": codec} if duration is not None: metadata["duration"] = duration if fps is not None: diff --git a/app/assets/services/video_proxy.py b/app/assets/services/video_proxy.py new file mode 100644 index 00000000000..963c0034921 --- /dev/null +++ b/app/assets/services/video_proxy.py @@ -0,0 +1,87 @@ +"""Browser-playable H.264 proxies of videos browsers can't play, written to previews/ under their blake3.""" + +import os +import uuid + +import av +from av.video.reformatter import ColorPrimaries, Colorspace, ColorTrc + +import folder_paths +from app.assets.services.hashing import compute_blake3_hash + +PROXY_LONG_SIDE = 1920 +PROXY_SHORT_SIDE = 1080 + + +def needs_video_proxy(system_metadata: dict | None) -> bool: + return (system_metadata or {}).get("codec") == "prores" + + +def _proxy_size(width: int, height: int) -> tuple[int, int]: + scale = min(1.0, PROXY_LONG_SIDE / max(width, height), PROXY_SHORT_SIDE / min(width, height)) + return max(2, round(width * scale / 2) * 2), max(2, round(height * scale / 2) * 2) + + +def _transcode(source: str, dest: str) -> tuple[int, int]: + with av.open(source) as src, av.open(dest, "w", format="mp4", options={"movflags": "+faststart"}) as out: + video = src.streams.video[0] + video.thread_type = "AUTO" + audio = src.streams.audio[0] if src.streams.audio else None + width, height = _proxy_size(video.codec_context.width, video.codec_context.height) + + out_video = out.add_stream("libx264", rate=video.average_rate or video.guessed_rate) + out_video.width, out_video.height, out_video.pix_fmt = width, height, "yuv420p" + out_video.options = {"preset": "veryfast", "crf": "18"} + out_video.codec_context.color_primaries = ColorPrimaries.BT709 + out_video.codec_context.color_trc = ColorTrc.IEC61966_2_1 + out_video.codec_context.colorspace = Colorspace.ITU709 + out_audio = out.add_stream("aac", rate=audio.rate, layout=audio.layout) if audio is not None else None + + graph = av.filter.Graph() + graph.link_nodes( + graph.add_buffer(template=video), + graph.add( + "scale", + f"w={width}:h={height}:out_color_matrix=bt709:out_range=tv:out_primaries=bt709:out_transfer=iec61966-2-1:intent=perceptual", + ), + graph.add("format", "yuv420p"), + graph.add("buffersink"), + ).configure() + + def encode_filtered(): + while True: + try: + frame = graph.pull() + except (av.BlockingIOError, av.EOFError): + return + out.mux(out_video.encode(frame)) + + for packet in src.demux(*(s for s in (video, audio) if s is not None)): + for frame in packet.decode(): + if packet.stream is video: + graph.push(frame) + encode_filtered() + else: + out.mux(out_audio.encode(frame)) + graph.push(None) + encode_filtered() + out.mux(out_video.encode(None)) + if out_audio is not None: + out.mux(out_audio.encode(None)) + return width, height + + +def write_video_proxy(source: str) -> dict: + """Transcode ``source`` to previews/.mp4 and return its preview ref.""" + directory = folder_paths.get_previews_directory() + os.makedirs(directory, exist_ok=True) + temp_path = os.path.join(directory, f"{uuid.uuid4().hex}.mp4.tmp") + try: + width, height = _transcode(source, temp_path) + digest, _ = compute_blake3_hash(temp_path) + filename = f"{digest}.mp4" + os.replace(temp_path, os.path.join(directory, filename)) + finally: + if os.path.exists(temp_path): + os.remove(temp_path) + return {"filename": filename, "width": width, "height": height} diff --git a/server.py b/server.py index 3eb75d925bb..5b4bd698b0f 100644 --- a/server.py +++ b/server.py @@ -538,7 +538,7 @@ async def upload_image(request): post = await request.post() resp, view, filepath = store_image_upload(post) if view is not None: - preview_id = await generate_upload_preview(view.asset.id, filepath, view.asset.preview_id) + preview_id = await generate_upload_preview(view.asset.id, filepath, view.asset.preview_id, view.system_metadata) live_previews = get_preview_file_paths([preview_id]) if preview_id else {} preview_id, preview_url = preview_fields( view.asset.id, preview_id, view.mime_type, filepath, False, live_previews diff --git a/tests-unit/assets_test/services/preview_helpers.py b/tests-unit/assets_test/services/preview_helpers.py index 41e365b9285..ad2a2f5b36e 100644 --- a/tests-unit/assets_test/services/preview_helpers.py +++ b/tests-unit/assets_test/services/preview_helpers.py @@ -53,3 +53,33 @@ def duplicate_data_window(data: bytes) -> bytes: at = data.find(key) end = at + len(key) + 4 + 16 return data[:end] + data[at:end] + data[end:] + + +def write_prores(path: Path, width: int, height: int, frames: int = 2, value=0.5, transfer=None, alpha=False, audio=False) -> Path: + """A ProRes MOV the way SaveVideo writes one; BT.2020 with ``transfer`` given, PCM audio with ``audio``.""" + from av.video.reformatter import ColorPrimaries + + with av.open(str(path), "w", format="mov") as out: + stream = out.add_stream("prores_ks", rate=24) + stream.width, stream.height = width, height + stream.pix_fmt = "yuva444p10le" if alpha else "yuv422p10le" + if alpha: + stream.options = {"profile": "4444"} + if transfer is not None: + stream.codec_context.color_trc, stream.codec_context.color_primaries, stream.codec_context.colorspace = transfer, ColorPrimaries.BT2020, 9 + sound = out.add_stream("pcm_s16le", rate=48000, layout="stereo") if audio else None + pixels = np.full((height, width, 4 if alpha else 3), value, np.float32) + for i in range(frames): + frame = av.VideoFrame.from_ndarray(pixels, format="gbrapf32le" if alpha else "gbrpf32le") + frame = frame.reformat(format=stream.pix_fmt, dst_colorspace=9 if transfer is not None else 1) + if transfer is not None: + frame.color_trc, frame.color_primaries = transfer, ColorPrimaries.BT2020 + frame.pts = i + out.mux(stream.encode(frame)) + out.mux(stream.encode(None)) + if sound is not None: + samples = av.AudioFrame.from_ndarray(np.zeros((1, 2 * 2000 * frames), np.int16), format="s16", layout="stereo") + samples.sample_rate, samples.pts = 48000, 0 + out.mux(sound.encode(samples)) + out.mux(sound.encode(None)) + return path diff --git a/tests-unit/assets_test/services/test_output_previews.py b/tests-unit/assets_test/services/test_output_previews.py index 74a6262313b..c1ca53a28c8 100644 --- a/tests-unit/assets_test/services/test_output_previews.py +++ b/tests-unit/assets_test/services/test_output_previews.py @@ -1,12 +1,15 @@ """An output registers already linked to the preview its save node named.""" +from unittest.mock import patch + from sqlalchemy import event from sqlalchemy.orm import Session from app.assets.database.models import Asset, AssetContent +from app.assets.services import ingest from app.assets.services.ingest import register_executed_output -from .preview_helpers import write_exr, write_preview +from .preview_helpers import write_exr, write_preview, write_prores def test_the_output_row_is_never_committed_without_its_preview(session, mock_create_session, roots): @@ -31,3 +34,44 @@ def before_commit(s): assert [t.name for t in preview.tags] == ["preview"] assert preview.system_metadata == {"kind": "image", "width": 4, "height": 3} assert session.get(AssetContent, preview.content_id).hash == f"blake3:{ref['filename'][:64]}" + + +def test_a_prores_output_registers_linked_to_its_proxy_made_before_the_write_lock(session, mock_create_session, roots): + source = write_prores(roots / "output" / "clip.mov", 64, 48) + calls: list[str] = [] + write_session, write_proxy = ingest.create_write_session, ingest.write_video_proxy + + def proxy(path): + calls.append("proxy") + return write_proxy(path) + + def locked(): + calls.append("write_session") + return write_session() + + with patch.object(ingest, "write_video_proxy", proxy), patch.object(ingest, "create_write_session", locked): + result = register_executed_output(str(source), "job") + + assert calls == ["proxy", "write_session"] + preview = session.get(Asset, result.preview_id) + assert preview.name.endswith(".mp4") and preview.mime_type == "video/mp4" + assert [t.name for t in preview.tags] == ["preview"] + assert preview.system_metadata == {"kind": "video", "width": 64, "height": 48} + + +def test_a_video_browsers_play_gets_no_proxy(session, mock_create_session, roots): + import av + + path = roots / "output" / "clip.mp4" + with av.open(str(path), "w") as out: + stream = out.add_stream("libx264", rate=8) + stream.width, stream.height, stream.pix_fmt = 64, 48, "yuv420p" + frame = av.VideoFrame(64, 48, "yuv420p") + frame.pts = 0 + out.mux(stream.encode(frame)) + out.mux(stream.encode(None)) + + with patch.object(ingest, "write_video_proxy") as proxy: + result = register_executed_output(str(path), "job") + + assert not proxy.called and result.preview_id is None diff --git a/tests-unit/assets_test/services/test_previews.py b/tests-unit/assets_test/services/test_previews.py index 062778b29ed..ff34c6615f9 100644 --- a/tests-unit/assets_test/services/test_previews.py +++ b/tests-unit/assets_test/services/test_previews.py @@ -36,7 +36,7 @@ def make(path): async def uploads(): # A semaphore made inside this loop, at the module's limit, so the module's stays unbound. with patch.object(previews, "_DECODE_SLOTS", asyncio.Semaphore(previews._DECODE_SLOTS._value)): - await asyncio.gather(*(previews.generate_upload_preview(f"id{i}", str(tmp_path / f"{i}.exr"), None) for i in range(6))) + await asyncio.gather(*(previews.generate_upload_preview(f"id{i}", str(tmp_path / f"{i}.exr"), None, None) for i in range(6))) with patch.object(previews, "_make_preview", make), patch.object(previews, "_store_and_link", return_value="linked") as store: asyncio.run(uploads()) diff --git a/tests-unit/assets_test/services/test_upload_previews.py b/tests-unit/assets_test/services/test_upload_previews.py index 7ca25a86e2b..5d0561dbd21 100644 --- a/tests-unit/assets_test/services/test_upload_previews.py +++ b/tests-unit/assets_test/services/test_upload_previews.py @@ -2,6 +2,7 @@ import json from unittest.mock import MagicMock, patch +import av import pytest from aiohttp import FormData from aiohttp.test_utils import TestClient, TestServer @@ -9,7 +10,7 @@ from app.assets.manager import AssetsEnabled -from .preview_helpers import duplicate_data_window, write_exr +from .preview_helpers import duplicate_data_window, write_exr, write_prores class _Args: @@ -67,15 +68,15 @@ def assets_routes_on(): yield -async def _upload(route: str, exr: bytes, roots, session) -> dict: +async def _upload(route: str, exr: bytes, roots, session, name: str = "frame.exr") -> dict: if route == "/upload/image": async with await _client(AssetsEnabled(_Args())) as client: - asset = (await (await client.post(route, data=_form("frame.exr", exr))).json())["asset"] + asset = (await (await client.post(route, data=_form(name, exr))).json())["asset"] return asset | {"preview": await (await client.get(asset["preview_url"])).read()} async with await _assets_client() as client: if route == "multipart": form = FormData() - form.add_field("file", exr, filename="frame.exr") + form.add_field("file", exr, filename=name) form.add_field("tags", json.dumps(["input"])) resp = await client.post("/api/assets", data=form) else: # from-hash, over content a previous run already stored @@ -86,12 +87,12 @@ class _HashingOn: enable_asset_hashing = True mode.init(_HashingOn()) - path = roots / "input" / "frame.exr" + path = roots / "input" / name path.write_bytes(exr) digest = "blake3:" + "ab" * 32 create_content(session, str(path), hash=digest, size_bytes=len(exr), mtime_ns=path.stat().st_mtime_ns) session.commit() - resp = await client.post("/api/assets/from-hash", json={"hash": digest, "name": "frame.exr", "tags": ["input"]}) + resp = await client.post("/api/assets/from-hash", json={"hash": digest, "name": name, "tags": ["input"]}) asset = await resp.json() assert resp.status == 201, asset return asset | {"preview": await (await client.get(asset["preview_url"])).read()} @@ -118,6 +119,31 @@ async def test_an_uploaded_exr_comes_back_with_its_preview(mock_create_session, assert (preview.format, preview.mode, preview.size) == ("WEBP", mode, (64, 48)), "alpha is kept" +@pytest.mark.asyncio +@pytest.mark.parametrize("route", ["/upload/image", "multipart", "from-hash"]) +async def test_an_uploaded_prores_comes_back_with_a_playable_proxy(mock_create_session, roots, tmp_path, assets_routes_on, session, route): + mov = write_prores(tmp_path / "src.mov", 64, 48).read_bytes() + asset = await _upload(route, mov, roots, session, name="clip.mov") + + assert asset["preview_id"] not in (None, asset["id"]) + proxy = tmp_path / "proxy.mp4" + proxy.write_bytes(asset["preview"]) + with av.open(str(proxy)) as container: + assert container.streams.video[0].codec_context.name == "h264" + + +@pytest.mark.asyncio +async def test_asset_content_serves_byte_ranges(mock_create_session, roots, tmp_path, assets_routes_on, session): + asset = await _upload("multipart", write_prores(tmp_path / "src.mov", 64, 48).read_bytes(), roots, session, name="clip.mov") + async with await _assets_client() as client: + resp = await client.get(f"/api/assets/{asset['preview_id']}/content", headers={"Range": "bytes=4-11"}) + body = await resp.read() + + assert resp.status == 206 + assert resp.headers["Content-Type"] == "video/mp4" + assert body == asset["preview"][4:12] + + @pytest.mark.asyncio @pytest.mark.parametrize("bad", [b"not an exr", "duplicated window"]) async def test_an_exr_that_cant_be_previewed_still_uploads(mock_create_session, roots, tmp_path, bad): diff --git a/tests-unit/assets_test/services/test_video_metadata.py b/tests-unit/assets_test/services/test_video_metadata.py index 7ca1faadca9..1654d678633 100644 --- a/tests-unit/assets_test/services/test_video_metadata.py +++ b/tests-unit/assets_test/services/test_video_metadata.py @@ -51,6 +51,7 @@ def test_extracts_stream_metadata(self, tmp_path: Path): assert result["kind"] == "video" assert result["width"] == 64 assert result["height"] == 48 + assert result["codec"] == "h264" assert result["frame_count"] == 12 assert result["fps"] == pytest.approx(8.0) assert result["duration"] == pytest.approx(12 / 8, abs=0.1) diff --git a/tests-unit/assets_test/services/test_video_proxy.py b/tests-unit/assets_test/services/test_video_proxy.py new file mode 100644 index 00000000000..c1a48f67c91 --- /dev/null +++ b/tests-unit/assets_test/services/test_video_proxy.py @@ -0,0 +1,48 @@ +"""ProRes proxies: H.264 in a faststart MP4 that every browser plays, tonemapped to SDR.""" + +import av +import pytest +from av.video.reformatter import ColorTrc + +from app.assets.services import video_proxy + +from .preview_helpers import write_prores + + +def _first_pixel(path) -> list[int]: + with av.open(str(path)) as container: + return next(container.decode(video=0)).to_ndarray(format="rgb24")[0, 0].tolist() + + +@pytest.mark.parametrize(("size", "proxy"), [((3840, 2160), (1920, 1080)), ((1080, 1920), (1080, 1920)), ((2160, 3840), (1080, 1920)), ((641, 361), (640, 360))]) +def test_proxies_fit_1080p_with_even_sides_and_never_upscale(size, proxy): + assert video_proxy._proxy_size(*size) == proxy + + +def test_a_proxy_is_browser_playable_h264(roots, tmp_path): + source = write_prores(tmp_path / "clip.mov", 64, 48, frames=3, alpha=True, audio=True) + ref = video_proxy.write_video_proxy(str(source)) + + path = roots / "previews" / ref["filename"] + assert ref == {"filename": ref["filename"], "width": 64, "height": 48} + assert [p.name for p in (roots / "previews").iterdir()] == [ref["filename"]], "no temp file is left" + data = path.read_bytes() + assert data.find(b"moov") < data.find(b"mdat"), "faststart" + with av.open(str(path)) as container: + video, audio = container.streams.video[0], container.streams.audio[0] + assert (video.codec_context.name, video.codec_context.pix_fmt, video.frames) == ("h264", "yuv420p", 3) + assert (video.codec_context.color_primaries, video.codec_context.color_trc) == (1, ColorTrc.IEC61966_2_1) + assert audio.codec_context.name == "aac" + + +def test_hdr_is_tonemapped_not_clipped(tmp_path): + for name, transfer in (("pq", ColorTrc.SMPTE2084), ("hlg", ColorTrc.ARIB_STD_B67)): + dest = tmp_path / f"{name}.mp4" + video_proxy._transcode(str(write_prores(tmp_path / f"{name}.mov", 16, 16, value=0.75, transfer=transfer)), str(dest)) + assert all(100 < c < 240 for c in _first_pixel(dest)), name + + +def test_sdr_keeps_its_values(tmp_path): + dest = tmp_path / "sdr.mp4" + video_proxy._transcode(str(write_prores(tmp_path / "sdr.mov", 16, 16, value=0.5)), str(dest)) + assert all(abs(c - 128) <= 2 for c in _first_pixel(dest))