mvdata 0.9.0__tar.gz → 0.9.2__tar.gz

{mvdata-0.9.0 → mvdata-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mvdata
-Version: 0.9.0
+Version: 0.9.2
 Summary: Gracia Dataset Convention - Python library for working with multi-view video datasets
 Author: Gracia Team
 License: MIT

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/__init__.py

@@ -37,13 +37,6 @@ from .gpu_support import (
     supports_gpu_decode,
 )
 from .image_metrics import calculate_psnr
-from .multivideo_decode_benchmark import (
-    MultiVideoDecodeBenchmarkResult,
-    NvdecRuntimeInfo,
-    benchmark_multivideo_decode,
-    inspect_nvdec_runtime,
-    summarize_multivideo_dataset,
-)
 
 
 def _build_missing_class(class_name: str, install_hint: str, import_error: Exception):
@@ -138,11 +131,6 @@ __all__ = [
     'MultiVideoStreamEligibility',
     'MultiVideoStreamSliceInfo',
     'calculate_psnr',
-    'NvdecRuntimeInfo',
-    'MultiVideoDecodeBenchmarkResult',
-    'inspect_nvdec_runtime',
-    'summarize_multivideo_dataset',
-    'benchmark_multivideo_decode',
     'GpuDecodeMediaSupport',
     'GpuDecodeSupportReport',
     'gpu_decode_support',

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/codec/__init__.py

@@ -5,6 +5,7 @@ This subpackage is split into small modules:
 - :mod:`mvdata.codec._imports` – lazy optional-dep imports and constants
 - :mod:`mvdata.codec.probe`    – bit-depth probing and GPU capability checks
 - :mod:`mvdata.codec.frames`   – decoded-frame → HWC RGB (numpy and cupy)
+- :mod:`mvdata.codec.native_yuv` – native high-bit-depth NVDEC YUV → RGB
 - :mod:`mvdata.codec.encode`   – RGB → NVENC elementary stream → MP4
 - :mod:`mvdata.codec.decode`   – NVDEC / PyAV decode of MP4
 - :mod:`mvdata.codec.select`   – round-trip PSNR and auto codec selection
@@ -57,6 +58,7 @@ from .frames import (
     _pyav_frame_to_rgb,
     numpy_to_cupy_rgb,
 )
+from .native_yuv import native_nvdec_to_rgb_cupy, native_nvdec_to_rgb_numpy
 from .probe import (
     infer_video_bit_depth_from_frame,
     infer_video_bit_depth_from_pixel_format_name,
@@ -66,6 +68,7 @@ from .probe import (
     nvdec_decode_compatibility_issue_for_path,
     nvenc_encode_compatibility_issue,
     nvenc_encode_compatibility_issue_for_rgb,
+    probe_video_color_metadata_pyav,
     probe_video_bit_depth,
     probe_video_bit_depth_pyav,
     probe_video_stream_metadata,
@@ -99,6 +102,8 @@ __all__ = [
     "infer_video_bit_depth_from_video_format",
     "mux_elementary_to_mp4",
     "normalize_codec_name",
+    "native_nvdec_to_rgb_cupy",
+    "native_nvdec_to_rgb_numpy",
     "numpy_to_cupy_rgb",
     "nvdec_decode_compatibility_issue",
     "nvdec_decode_compatibility_issue_for_path",
@@ -106,6 +111,7 @@ __all__ = [
     "nvenc_encode_compatibility_issue_for_rgb",
     "pad_rgb_for_nvenc",
     "preferred_decoder_for_mp4",
+    "probe_video_color_metadata_pyav",
     "probe_video_bit_depth",
     "probe_video_bit_depth_pyav",
     "probe_video_stream_metadata",

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/codec/decode.py

@@ -10,20 +10,30 @@ import numpy as np
 from ..gpu_policy import nvdec_decode_allowed
 from ._imports import try_import_av, try_import_cupy, try_import_pynvvideocodec, try_import_torch
 from .frames import _decoded_frame_to_rgb_numpy, _pyav_frame_to_rgb
+from .native_yuv import native_nvdec_to_rgb_numpy
 from .probe import (
     infer_video_bit_depth_from_stream,
     nvdec_decode_compatibility_issue,
     nvdec_decode_compatibility_issue_for_path,
+    probe_video_color_metadata_pyav,
+    probe_video_bit_depth,
     probe_video_stream_metadata,
 )
 
 
-def _try_open_nvdec(nvc, path_str: str, gpu_id: int, use_device_memory: bool):
+def _try_open_nvdec(
+    nvc,
+    path_str: str,
+    gpu_id: int,
+    use_device_memory: bool,
+    *,
+    output_color_type=None,
+):
     """Open a SimpleDecoder, tolerating API-version differences in the kwarg surface."""
     base = dict(
         gpu_id=gpu_id,
         use_device_memory=use_device_memory,
-        output_color_type=nvc.OutputColorType.RGB,
+        output_color_type=output_color_type or nvc.OutputColorType.RGB,
     )
     for extra in ({}, {"need_scanned_stream_metadata": True}):
         try:
@@ -69,14 +79,27 @@ def decode_mp4_to_rgb_nvdec(nvc, mp4_path: Path, gpu_id: int, expect_count: int)
     )
     if issue is not None:
         raise RuntimeError(f"NVDEC decode unsupported for {mp4_path}: {issue}")
+    source_bit_depth = probe_video_bit_depth(mp4_path, nvc=nvc)
+    color_metadata = probe_video_color_metadata_pyav(mp4_path)
 
     torch_mod = try_import_torch()
     has_dlpack = torch_mod is not None or try_import_cupy() is not None
     path_str = str(mp4_path)
+    output_color_type = nvc.OutputColorType.NATIVE if source_bit_depth > 8 else nvc.OutputColorType.RGB
+    use_dev_options = [True] if source_bit_depth > 8 else ([True, False] if has_dlpack else [False])
 
     last_err: Exception | None = None
-    for use_dev in ([True, False] if has_dlpack else [False]):
-        dec = _try_open_nvdec(nvc, path_str, gpu_id, use_dev)
+    for use_dev in use_dev_options:
+        if source_bit_depth > 8:
+            dec = _try_open_nvdec(
+                nvc,
+                path_str,
+                gpu_id,
+                use_dev,
+                output_color_type=output_color_type,
+            )
+        else:
+            dec = _try_open_nvdec(nvc, path_str, gpu_id, use_dev)
         if dec is None:
             continue
         try:
@@ -84,7 +107,18 @@ def decode_mp4_to_rgb_nvdec(nvc, mp4_path: Path, gpu_id: int, expect_count: int)
             frames: List[np.ndarray] = []
             for i in range(n):
                 raw = dec.get_batch_frames_by_index([i])[0]
-                frames.append(_decoded_frame_to_rgb_numpy(raw, torch_mod, bit_depth=bit_depth))
+                if source_bit_depth > 8:
+                    frames.append(
+                        native_nvdec_to_rgb_numpy(
+                            raw,
+                            bit_depth=source_bit_depth,
+                            **color_metadata,
+                        )
+                    )
+                else:
+                    frames.append(
+                        _decoded_frame_to_rgb_numpy(raw, torch_mod, bit_depth=source_bit_depth)
+                    )
             return frames
         except Exception as e:
             last_err = e

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/codec/frames.py

@@ -52,6 +52,10 @@ def _device_and_stream_ctx(
 
 def _target_dtype_for(arr_dtype, *, bit_depth: int | None):
     if arr_dtype == np.uint8:
+        if (bit_depth or 8) > 8:
+            raise ValueError(
+                f"High-bit-depth decode returned uint8 output for {bit_depth}-bit source"
+            )
         return np.uint8
     if arr_dtype == np.uint16:
         return np.uint16
@@ -83,6 +87,9 @@ def _normalize_rgb_numpy_output(
         arr = arr.astype(target, copy=False)
         copy_result = True
 
+    arr, scaled = _normalize_uint16_source_depth_scale(arr, bit_depth=bit_depth)
+    copy_result = copy_result or scaled
+
     if copy_result:
         return np.array(arr, copy=True, order="C")
     if not arr.flags.c_contiguous:
@@ -95,15 +102,17 @@ def _decoded_frame_to_rgb_numpy(frame, torch_mod, *, bit_depth: int | None = Non
     if hasattr(frame, "__dlpack__"):
         try:
             arr = np.from_dlpack(frame)
-            return _normalize_rgb_numpy_output(arr, bit_depth=bit_depth, copy_result=True)
         except Exception:
             pass
+        else:
+            return _normalize_rgb_numpy_output(arr, bit_depth=bit_depth, copy_result=True)
         if torch_mod is not None:
             try:
                 arr = torch_mod.from_dlpack(frame).detach().cpu().numpy()
-                return _normalize_rgb_numpy_output(arr, bit_depth=bit_depth)
             except Exception:
                 pass
+            else:
+                return _normalize_rgb_numpy_output(arr, bit_depth=bit_depth)
         cp = try_import_cupy()
         if cp is not None:
             arr = cp.asnumpy(cp.from_dlpack(frame))
@@ -161,11 +170,72 @@ def numpy_to_cupy_rgb(
     return out
 
 
+def _source_depth_rgb_format(depth: int) -> str:
+    return "rgb24" if depth <= 8 else f"gbrp{depth}le"
+
+
+def _pyav_source_color_range(frame):
+    color_range = getattr(frame, "color_range", None)
+    text = str(color_range)
+    try:
+        from av.video.reformatter import ColorRange
+    except Exception:
+        return color_range
+    if text in {"2", "JPEG", "jpeg", "pc"}:
+        return ColorRange.JPEG
+    if text in {"1", "MPEG", "mpeg", "tv"}:
+        return ColorRange.MPEG
+    return color_range
+
+
+def _pyav_to_source_depth_rgb(frame, *, bit_depth: int):
+    fmt = _source_depth_rgb_format(bit_depth)
+    reformat = getattr(frame, "reformat", None)
+    if callable(reformat):
+        try:
+            return reformat(
+                format=fmt,
+                src_color_range=_pyav_source_color_range(frame),
+            ).to_ndarray()
+        except Exception:
+            pass
+    return frame.to_ndarray(format=fmt)
+
+
+def _normalize_uint16_source_depth_scale(
+    arr: np.ndarray, *, bit_depth: int | None
+) -> tuple[np.ndarray, bool]:
+    if bit_depth is None or bit_depth <= 8 or bit_depth >= 16 or arr.dtype != np.uint16:
+        return arr, False
+
+    source_max = (1 << bit_depth) - 1
+    if arr.size == 0 or int(arr.max()) <= source_max:
+        return arr, False
+
+    shift = 16 - bit_depth
+    out = np.right_shift(arr, shift)
+    return np.clip(out, 0, source_max).astype(np.uint16, copy=False), True
+
+
+def _rgb48_to_source_depth(arr: np.ndarray, *, bit_depth: int) -> np.ndarray:
+    arr = np.asarray(arr)
+    arr, _ = _ensure_hwc(arr)
+    if bit_depth >= 16:
+        return _normalize_rgb_numpy_output(arr, bit_depth=bit_depth, copy_result=True)
+
+    shift = 16 - bit_depth
+    source_max = (1 << bit_depth) - 1
+    out = np.right_shift(arr, shift)
+    return np.clip(out, 0, source_max).astype(np.uint16, copy=False)
+
+
 def _pyav_frame_to_rgb(frame, *, bit_depth: int | None = None) -> np.ndarray:
     """Convert a PyAV VideoFrame to an HWC RGB numpy array.
 
     Full-range yuv444p streams are converted manually to dodge swscale's
-    limited-range default when VUI is unspecified.
+    limited-range default when VUI is unspecified. High-bit-depth outputs use
+    source-depth scale, matching pyavif: 10-bit values are 0..1023, 12-bit
+    values are 0..4095, stored in uint16 arrays.
     """
     pf = str(frame.format.name)
     depth = int(bit_depth) if bit_depth is not None else infer_video_bit_depth_from_frame(frame)
@@ -176,24 +246,34 @@ def _pyav_frame_to_rgb(frame, *, bit_depth: int | None = None) -> np.ndarray:
     if pf.startswith("yuv444p") and (
         is_full or cr is None or cr_text in ("0", "UNSPECIFIED", "unspecified")
     ):
-        yuv = frame.to_ndarray(format=pf)
-        y = yuv[0].astype(np.float32)
-        max_value = float((1 << depth) - 1)
-        center = (max_value + 1.0) / 2.0
-        cb = yuv[1].astype(np.float32) - center
-        crv = yuv[2].astype(np.float32) - center
-
-        if depth > 8:
-            max_out = 65535.0
-            target_dtype = np.uint16
-        else:
-            max_out = 255.0
-            target_dtype = np.uint8
-        scale = max_out / max_value
-
-        r = np.clip((y + 1.402 * crv) * scale + 0.5, 0, max_out).astype(target_dtype)
-        g = np.clip((y - 0.344136 * cb - 0.714136 * crv) * scale + 0.5, 0, max_out).astype(target_dtype)
-        b = np.clip((y + 1.772 * cb) * scale + 0.5, 0, max_out).astype(target_dtype)
-        return np.stack([r, g, b], axis=-1)
-
-    return frame.to_ndarray(format="rgb48le" if depth > 8 else "rgb24")
+        try:
+            yuv = frame.to_ndarray(format=pf)
+        except ValueError:
+            yuv = None
+        if yuv is not None:
+            y = yuv[0].astype(np.float32)
+            max_value = float((1 << depth) - 1)
+            center = (max_value + 1.0) / 2.0
+            cb = yuv[1].astype(np.float32) - center
+            crv = yuv[2].astype(np.float32) - center
+
+            max_out = max_value
+            target_dtype = np.uint16 if depth > 8 else np.uint8
+            scale = max_out / max_value
+
+            r = np.clip((y + 1.402 * crv) * scale + 0.5, 0, max_out).astype(target_dtype)
+            g = np.clip((y - 0.344136 * cb - 0.714136 * crv) * scale + 0.5, 0, max_out).astype(target_dtype)
+            b = np.clip((y + 1.772 * cb) * scale + 0.5, 0, max_out).astype(target_dtype)
+            return np.stack([r, g, b], axis=-1)
+
+    if depth <= 8:
+        return frame.to_ndarray(format="rgb24")
+
+    try:
+        return _normalize_rgb_numpy_output(
+            _pyav_to_source_depth_rgb(frame, bit_depth=depth),
+            bit_depth=depth,
+            copy_result=True,
+        )
+    except ValueError:
+        return _rgb48_to_source_depth(frame.to_ndarray(format="rgb48le"), bit_depth=depth)

mvdata-0.9.2/mvdata/codec/native_yuv.py

@@ -0,0 +1,169 @@
+"""Native NVDEC YUV surface conversion helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from ._imports import try_import_cupy
+
+
+class _CaiView:
+    def __init__(self, view: Any, *, data_offset_bytes: int = 0):
+        self._view = view
+        self._data_offset_bytes = int(data_offset_bytes)
+
+    @property
+    def __cuda_array_interface__(self):
+        cai = dict(self._view.__cuda_array_interface__)
+        cai["shape"] = tuple(cai["shape"])
+
+        typestr = str(cai.get("typestr", ""))
+        itemsize = np.dtype(typestr).itemsize if typestr else 1
+        # PyNvVideoCodec reports these strides in samples for native planes.
+        cai["strides"] = tuple(int(stride) * itemsize for stride in cai["strides"])
+        if self._data_offset_bytes:
+            ptr, readonly = cai["data"]
+            cai["data"] = (int(ptr) + self._data_offset_bytes, readonly)
+        return cai
+
+
+def _cupy_or_raise():
+    cp = try_import_cupy()
+    if cp is None:
+        raise RuntimeError(
+            "Native high-bit-depth NVDEC conversion requires CuPy. "
+            "Install mvdata[cuda] or use the PyAV fallback."
+        )
+    return cp
+
+
+def _format_name(frame: Any) -> str:
+    return str(getattr(frame, "format", "")).split(".")[-1]
+
+
+def _coefficients(color_space: Any) -> tuple[float, float]:
+    text = str(color_space).lower()
+    if "2020" in text or text == "9":
+        return 0.2627, 0.0593
+    if "709" in text or text == "1":
+        return 0.2126, 0.0722
+    return 0.299, 0.114
+
+
+def _is_limited_range(color_range: Any) -> bool:
+    text = str(color_range).lower()
+    return "mpeg" in text or text == "1"
+
+
+def _native_planes(frame: Any):
+    return [_CaiView(view) for view in frame.cuda()]
+
+
+def _native_yuv444_planes(frame: Any):
+    views = frame.cuda()
+    if len(views) != 3:
+        raise ValueError(f"Expected 3 native YUV444 planes, got {len(views)}")
+    cai = dict(views[0].__cuda_array_interface__)
+    shape = tuple(cai["shape"])
+    strides = tuple(cai["strides"])
+    itemsize = np.dtype(cai.get("typestr", "|u2")).itemsize
+    plane_bytes = int(shape[0]) * int(strides[0]) * itemsize
+    return [_CaiView(views[0], data_offset_bytes=i * plane_bytes) for i in range(3)]
+
+
+def _plane_to_source_float(cp, plane, *, bit_depth: int):
+    shift = 16 - int(bit_depth)
+    values = cp.asarray(plane)
+    if shift > 0:
+        values = cp.right_shift(values, shift)
+    return values.astype(cp.float32, copy=False)
+
+
+def _single_channel(values):
+    return values[..., 0] if values.ndim == 3 and values.shape[-1] == 1 else values
+
+
+def _yuv_to_rgb(cp, y, cb, cr, *, bit_depth: int, color_range: Any, color_space: Any):
+    source_max = float((1 << int(bit_depth)) - 1)
+    if _is_limited_range(color_range):
+        scale = 1 << (int(bit_depth) - 8)
+        y = (y - 16.0 * scale) * (source_max / (219.0 * scale))
+        center = 128.0 * scale
+        chroma_scale = ((source_max + 1.0) / 2.0) / (112.0 * scale)
+        cb = (cb - center) * chroma_scale
+        cr = (cr - center) * chroma_scale
+    else:
+        center = (source_max + 1.0) / 2.0
+        cb = cb - center
+        cr = cr - center
+
+    kr, kb = _coefficients(color_space)
+    kg = 1.0 - kr - kb
+    r_cr = 2.0 * (1.0 - kr)
+    b_cb = 2.0 * (1.0 - kb)
+    g_cb = 2.0 * kb * (1.0 - kb) / kg
+    g_cr = 2.0 * kr * (1.0 - kr) / kg
+
+    r = y + r_cr * cr
+    g = y - g_cb * cb - g_cr * cr
+    b = y + b_cb * cb
+    rgb = cp.stack([r, g, b], axis=-1)
+    return cp.clip(rgb + 0.5, 0, source_max).astype(cp.uint16)
+
+
+def native_nvdec_to_rgb_cupy(
+    frame: Any,
+    *,
+    bit_depth: int,
+    color_range: Any = None,
+    color_space: Any = None,
+    cuda_stream: int | None = None,
+):
+    """Convert a native high-bit-depth NVDEC frame to HWC RGB on the GPU."""
+    if int(bit_depth) <= 8:
+        raise ValueError("Native high-bit-depth conversion requires bit_depth > 8")
+
+    cp = _cupy_or_raise()
+    stream_ctx = (
+        cp.cuda.ExternalStream(int(cuda_stream))
+        if cuda_stream is not None and int(cuda_stream) != 0
+        else None
+    )
+
+    def _convert():
+        fmt = _format_name(frame)
+        planes = _native_planes(frame)
+        if fmt in {"P016", "P010"}:
+            y_view, uv_view = planes
+            y = _single_channel(_plane_to_source_float(cp, y_view, bit_depth=bit_depth))
+            uv = _plane_to_source_float(cp, uv_view, bit_depth=bit_depth)
+            cb = cp.repeat(cp.repeat(uv[..., 0], 2, axis=0), 2, axis=1)[: y.shape[0], : y.shape[1]]
+            cr = cp.repeat(cp.repeat(uv[..., 1], 2, axis=0), 2, axis=1)[: y.shape[0], : y.shape[1]]
+        elif fmt == "YUV444_16Bit":
+            y_view, cb_view, cr_view = _native_yuv444_planes(frame)
+            y = _single_channel(_plane_to_source_float(cp, y_view, bit_depth=bit_depth))
+            cb = _single_channel(_plane_to_source_float(cp, cb_view, bit_depth=bit_depth))
+            cr = _single_channel(_plane_to_source_float(cp, cr_view, bit_depth=bit_depth))
+        else:
+            raise ValueError(f"Unsupported native NVDEC format for high-bit RGB: {fmt}")
+
+        return _yuv_to_rgb(
+            cp,
+            y,
+            cb,
+            cr,
+            bit_depth=bit_depth,
+            color_range=color_range,
+            color_space=color_space,
+        )
+
+    if stream_ctx is None:
+        return _convert()
+    with stream_ctx:
+        return _convert()
+
+
+def native_nvdec_to_rgb_numpy(frame: Any, **kwargs) -> np.ndarray:
+    return native_nvdec_to_rgb_cupy(frame, **kwargs).get()

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/codec/probe.py

@@ -80,7 +80,30 @@ def probe_video_bit_depth_pyav(path: Path) -> int:
         return infer_video_bit_depth_from_stream(container.streams.video[0])
 
 
+def probe_video_color_metadata_pyav(path: Path) -> dict[str, Any]:
+    av = try_import_av()
+    if av is None:
+        return {"color_range": None, "color_space": None}
+    try:
+        with av.open(str(path)) as container:
+            if not container.streams.video:
+                return {"color_range": None, "color_space": None}
+            stream = container.streams.video[0]
+            return {
+                "color_range": getattr(stream, "color_range", None),
+                "color_space": getattr(stream, "colorspace", None),
+            }
+    except Exception:
+        return {"color_range": None, "color_space": None}
+
+
 def probe_video_bit_depth(path: Path, nvc: Any | None = None) -> int:
+    pyav_error: Exception | None = None
+    try:
+        return probe_video_bit_depth_pyav(path)
+    except Exception as exc:
+        pyav_error = exc
+
     if nvc is None:
         try:
             nvc = try_import_pynvvideocodec()
@@ -91,7 +114,8 @@ def probe_video_bit_depth(path: Path, nvc: Any | None = None) -> int:
             return int(probe_video_stream_metadata(nvc, path)["bitdepth"])
         except Exception:
             pass
-    return probe_video_bit_depth_pyav(path)
+
+    raise RuntimeError(f"Could not probe video bit depth for {path}") from pyav_error
 
 
 def probe_video_stream_metadata(nvc, path: Path | str) -> dict[str, Any]:

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata/video_stream_reader.py

@@ -53,8 +53,14 @@ class _VideoNvdecFrameSource:
         self._bit_depth = bit_depth
         self._nvenc_codec = nvenc_codec
         self._torch_mod = nvenc_codec.try_import_torch()
+        self._native_high_bit = self._bit_depth > 8
+        self._color_metadata = (
+            nvenc_codec.probe_video_color_metadata_pyav(path) if self._native_high_bit else {}
+        )
+        if self._native_high_bit and nvenc_codec.try_import_cupy() is None:
+            raise RuntimeError("Native high-bit-depth NVDEC conversion requires CuPy")
         has_dlpack = self._torch_mod is not None or nvenc_codec.try_import_cupy() is not None
-        use_dev_options = [True, False] if has_dlpack else [False]
+        use_dev_options = [True] if self._native_high_bit else ([True, False] if has_dlpack else [False])
 
         nvc = nvenc_codec.try_import_pynvvideocodec()
         issue = nvenc_codec.nvdec_decode_compatibility_issue_for_path(nvc, path, gpu_id)
@@ -63,7 +69,16 @@ class _VideoNvdecFrameSource:
 
         self._decoder = None
         for use_dev in use_dev_options:
-            self._decoder = nvenc_codec._try_open_nvdec(nvc, str(path), gpu_id, use_dev)
+            if self._native_high_bit:
+                self._decoder = nvenc_codec._try_open_nvdec(
+                    nvc,
+                    str(path),
+                    gpu_id,
+                    use_dev,
+                    output_color_type=nvc.OutputColorType.NATIVE,
+                )
+            else:
+                self._decoder = nvenc_codec._try_open_nvdec(nvc, str(path), gpu_id, use_dev)
             if self._decoder is not None:
                 break
         if self._decoder is None:
@@ -103,6 +118,15 @@ class _VideoNvdecFrameSource:
         return self._decode_sequential(index)
 
     def _materialize(self, raw, *, device: Device, cuda_stream: int | None):
+        if self._native_high_bit:
+            kwargs = {
+                "bit_depth": self._bit_depth,
+                "cuda_stream": cuda_stream,
+                **self._color_metadata,
+            }
+            if device == "cuda":
+                return self._nvenc_codec.native_nvdec_to_rgb_cupy(raw, **kwargs)
+            return self._nvenc_codec.native_nvdec_to_rgb_numpy(raw, **kwargs)
         if device == "cuda":
             return self._nvenc_codec._decoded_frame_to_rgb_cupy(
                 raw,

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mvdata
-Version: 0.9.0
+Version: 0.9.2
 Summary: Gracia Dataset Convention - Python library for working with multi-view video datasets
 Author: Gracia Team
 License: MIT

{mvdata-0.9.0 → mvdata-0.9.2}/mvdata.egg-info/SOURCES.txt

@@ -9,7 +9,6 @@ mvdata/gpu_support.py
 mvdata/image_metrics.py
 mvdata/legacy_writer.py
 mvdata/multivideo.py
-mvdata/multivideo_decode_benchmark.py
 mvdata/multivideo_slicer.py
 mvdata/multivideo_writer.py
 mvdata/nvdec_parallel.py
@@ -32,6 +31,7 @@ mvdata/codec/_imports.py
 mvdata/codec/decode.py
 mvdata/codec/encode.py
 mvdata/codec/frames.py
+mvdata/codec/native_yuv.py
 mvdata/codec/probe.py
 mvdata/codec/select.py
 tests/test_dataset_base_defaults.py
@@ -39,7 +39,6 @@ tests/test_gpu_policy.py
 tests/test_gpu_support.py
 tests/test_image_metrics.py
 tests/test_multivideo_bit_depth.py
-tests/test_multivideo_decode_benchmark.py
 tests/test_multivideo_slicer.py
 tests/test_nvdec_parallel.py
 tests/test_per_camera.py

{mvdata-0.9.0 → mvdata-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mvdata"
-version = "0.9.0"
+version = "0.9.2"
 description = "Gracia Dataset Convention - Python library for working with multi-view video datasets"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"