nvidia-codec 0.0.21__tar.gz → 0.0.22__tar.gz

{nvidia_codec-0.0.21/src/nvidia_codec.egg-info → nvidia_codec-0.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-codec
-Version: 0.0.21
+Version: 0.0.22
 Summary: Pythonic interface to Nvidia Codec
 Home-page: https://github.com/riaqn/python-nvidia-codec
 Author: Zesen Qian
@@ -26,7 +26,7 @@ A Pythonic library for NVIDIA Video Codec (NVDEC).
 - Python 3.10+
 - NVIDIA GPU with NVDEC support
 - NVIDIA driver with `libnvcuvid.so`
-- FFmpeg 8.x (for demuxing)
+- FFmpeg 9.x (for demuxing)
 
 ## Installation
 
@@ -57,6 +57,11 @@ for timestamp, frame in player.frames(torch.uint8):
     print(f'{timestamp}: {frame.shape}')
 ```
 
+`frames()` without `start` continues from the demuxer's current position; it
+only begins at the first frame on a freshly opened player. After a
+`screenshot()` or a previous `frames()` pass, pass `start=timedelta(0)` to
+decode from the beginning again.
+
 ### Screenshot (single frame extraction)
 
 ```python

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/README.md

@@ -9,7 +9,7 @@ A Pythonic library for NVIDIA Video Codec (NVDEC).
 - Python 3.10+
 - NVIDIA GPU with NVDEC support
 - NVIDIA driver with `libnvcuvid.so`
-- FFmpeg 8.x (for demuxing)
+- FFmpeg 9.x (for demuxing)
 
 ## Installation
 
@@ -40,6 +40,11 @@ for timestamp, frame in player.frames(torch.uint8):
     print(f'{timestamp}: {frame.shape}')
 ```
 
+`frames()` without `start` continues from the demuxer's current position; it
+only begins at the first frame on a freshly opened player. After a
+`screenshot()` or a previous `frames()` pass, pass `start=timedelta(0)` to
+decode from the beginning again.
+
 ### Screenshot (single frame extraction)
 
 ```python

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = nvidia-codec
-version = 0.0.21
+version = 0.0.22
 author = Zesen Qian
 author_email = nvidia-codec@riaqn.org
 description = Pythonic interface to Nvidia Codec

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/__init__.py

@@ -19,7 +19,7 @@ Quick Start:
 Requirements:
     - NVIDIA GPU with NVDEC support
     - NVIDIA driver with libnvcuvid.so
-    - FFmpeg 8.x (for demuxing)
+    - FFmpeg 9.x (for demuxing)
     - PyTorch with CUDA support
 
 Supported Codecs:

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/core/cuda.py

@@ -8,7 +8,7 @@ CUcontext = c_void_p
 CUresult = c_int
 cudaError = c_int
 
-CUdeviceptr = c_uint
+CUdeviceptr = c_ulonglong  # CUdeviceptr_v2: unsigned long long
 
 lib = cdll.LoadLibrary('libcuda.so')
 librt = cdll.LoadLibrary('libcudart.so')

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/core/decode.py

@@ -37,7 +37,7 @@ class Surface:
         self.pts = pts
 
         self.params = CUVIDPROCPARAMS()
-        memmove(byref(self.params), byref(params), sizeof(CUVIDEOFORMAT))
+        memmove(byref(self.params), byref(params), sizeof(CUVIDPROCPARAMS))
 
         self.params.output_stream = stream
 
@@ -117,7 +117,9 @@ class Surface:
             "strides": strides,
             "version": 3,
             "data": (self.c_devptr.value, False),
-            "stream": self.params.output_stream,
+            # CAI v3 forbids stream 0; CUDA's stream 0 is the legacy
+            # default stream, which the protocol spells as 1.
+            "stream": self.params.output_stream or 1,
         }
 
 

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/core/nvcuvid.py

@@ -120,23 +120,6 @@ class CUVIDPARSERPARAMS(Structure):
     ]
 CUstream = c_void_p # according to /opt/cuda/include/cuda.h
 CUvideoparser = c_void_p # according to nvcuvid.h
-class CUVIDPROCPARAMS(Structure):
-    _fields_ = [('progressive_frame', c_int),
-                ('second_field', c_int),
-                ('top_field_first', c_int),
-                ('unpaired_field', c_int),
-                ('reserved_flags', c_uint),
-                ('reserved_zero', c_uint),
-                ('raw_input_dptr', c_ulonglong),
-                ('raw_input_pitch', c_uint),
-                ('raw_input_format', c_uint),
-                ('raw_output_dptr', c_ulonglong),
-                ('raw_output_pitch', c_uint),
-                ('Reserved1', c_uint),
-                ('output_stream', CUstream),
-                ('Reserved', c_uint * 46),
-                ('histogram_dptr', POINTER(c_ulonglong)),
-                ('Reserved2', c_void_p*1) ]
 class CUvideopacketflags(Flag):
     ENDOFSTREAM = 1
     TIMESTAMP = auto()

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/ffmpeg/libavformat.py

@@ -17,14 +17,16 @@ import logging
 
 log = logging.getLogger(__name__)
 
-lib = cdll.LoadLibrary("libavformat.so")
+# Pin the ABI major to ffmpeg 9 (libavformat 63), matching the libavcodec.so.63
+# pin in ffmpeg/libavcodec.py: struct layouts + enum values in include/ track
+# ffmpeg 9, so a system upgrade fails loudly at load instead of mis-reading.
+lib = cdll.LoadLibrary("libavformat.so.63")
 
-# Check FFmpeg version compatibility (requires FFmpeg 8.x / libavformat 62+)
 _version = lib.avformat_version()
 _major = _version >> 16
-if _major < 62:
+if _major != 63:
     raise ImportError(
-        f"nvidia-codec requires FFmpeg 8.x (libavformat 62+), "
+        f"nvidia-codec requires FFmpeg 9.x (libavformat 63), "
         f"but found libavformat {_major}.{(_version >> 8) & 0xff}.{_version & 0xff}"
     )
 

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/utils/color.py

@@ -103,7 +103,6 @@ def convert(surface : Surface,
         assert height % 2 == 0
         assert width % 2 == 0
         assert height // 2 * 3 == h
-        assert YUV.dtype == torch.uint8
 
         Y = YUV[:height,:]
         UV = YUV[height:,:]
@@ -134,8 +133,8 @@ def convert(surface : Surface,
     #normalize
     if source_range == AVColorRange.MPEG:
         y = (Y.type(torch.float) - (16 << bit8)) / (220 << bit8)
-        u = (U.type(torch.float) - (128 << bit8)) / (225 << bit8)
-        v = (V.type(torch.float) - (128 << bit8)) / (225 << bit8)
+        u = (U.type(torch.float) - (128 << bit8)) / (224 << bit8)
+        v = (V.type(torch.float) - (128 << bit8)) / (224 << bit8)
     elif source_range == AVColorRange.JPEG:
         y = Y.type(torch.float) / (256 << bit8)
         u = (U.type(torch.float) - (128 << bit8)) / (256 << bit8)

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/utils/decode.py

@@ -13,11 +13,9 @@ from ..ffmpeg.include.libavutil import (
     AV_NOPTS_VALUE,
     AVColorRange,
     AVColorSpace,
-    AVDISCARD_NONE,
-    AVDISCARD_NONKEY,
 )
 from .compat import av2cuda, extract_stream_ptr
-from ..core.decode import BaseDecoder, Picture, Surface
+from ..core.decode import BaseDecoder, Picture, Surface, decide_surface_format
 from ..ffmpeg.common import AVException
 from .color import convert, to_yuv420p
 from .demux import VideoTrack
@@ -33,11 +31,21 @@ log = logging.getLogger(__name__)
 
 
 class OwnedSurface:
-    """Wraps a Surface with semaphore ownership. Releases on free."""
+    """Maps a Picture under the decoder's output-surface semaphore.
 
-    def __init__(self, surface):
-        surface.decoder._surface_sem.acquire()
-        self._surface = surface
+    The semaphore (sized to ulNumOutputSurfaces) must be held BEFORE
+    cuvidMapVideoFrame64 runs — two concurrent maps with one output
+    surface would overwrite each other — so the map happens here, not
+    in the caller. free() unmaps and releases.
+    """
+
+    def __init__(self, decoder, pic, stream):
+        decoder._surface_sem.acquire()
+        try:
+            self._surface = decoder.map(pic, stream)
+        except BaseException:
+            decoder._surface_sem.release()
+            raise
 
     def __getattr__(self, name):
         return getattr(self._surface, name)
@@ -83,7 +91,7 @@ class OwnedPicture:
 
     def map(self, stream=0):
         assert self._pic is not None, "Picture already freed"
-        return OwnedSurface(self._decoder.map(self._pic, stream))
+        return OwnedSurface(self._decoder, self._pic, stream)
 
 
 class Decoder(BaseDecoder):
@@ -100,7 +108,10 @@ class Decoder(BaseDecoder):
         num_pictures: Callable(min_pics) -> int, returns the total number of
             picture slots (must be >= min_pics and <= 32). Higher values allow
             better pipelining between decode and consumer threads.
-            Default: lambda min_pics: min_pics * 2 (double the minimum).
+            Default: lambda min_pics: min_pics + 4.
+        allow_high: Keep >8-bit sources at 16 bits (P016 / YUV444_16Bit
+            surfaces) instead of letting NVDEC round them to 8-bit NV12 /
+            YUV444. convert() handles both; to_yuv420p() is 8-bit only.
     """
 
     def __init__(
@@ -111,6 +122,7 @@ class Decoder(BaseDecoder):
         cropping=None,
         target_rect=None,
         device=None,
+        allow_high=False,
     ):
         self.track = track
         self._slot_locks = None  # initialized in decide(), after we know num_pictures
@@ -147,6 +159,10 @@ class Decoder(BaseDecoder):
                 "num_pictures": num_pics,
                 "num_surfaces": 1,
             }
+            if allow_high:
+                d["surface_format"] = decide_surface_format(
+                    p["chroma_format"], p["bit_depth"],
+                    p["supported_surface_formats"], allow_high=True)
             if target_size is not None:
                 d["target_size"] = target_size
             if cropping is not None:
@@ -242,25 +258,6 @@ class Decoder(BaseDecoder):
         self.with_callbacks(lambda: self.send(None), post_decode=lambda pic: None)
         self._recent.clear()
 
-    def _decode_packets(self, keyframes_only=False):
-        """Read packets from current position, filter, decode.
-
-        Calls self.post_decode(pic) for each frame.
-        """
-        self.track.stream.discard = AVDISCARD_NONKEY if keyframes_only else AVDISCARD_NONE
-        packets = self.track.fc.read_packets(self.track.stream)
-        it = self.bsf.filter(packets, flush=True, reuse=True)
-        self.with_callbacks(lambda: self.send(None), post_decode=lambda pic: None)
-
-        for pkt in it:
-            pts = pkt.av.pts if pkt.av.pts != AV_NOPTS_VALUE else pkt.av.dts
-            arr = np.ctypeslib.as_array(pkt.av.data, (pkt.av.size,))
-            self.send((pts, arr))
-            if keyframes_only:
-                self.bsf.flush()
-                self.send(None)
-        self.send(None)
-
     def _map_and_convert(self, pic, dtype, pixel_format='rgb'):
         """Map a Picture (or OwnedPicture) to a tensor. Frees pic and surface.
         Returns (timedelta, frame) on success, (timedelta, exception) on error.
@@ -268,16 +265,16 @@ class Decoder(BaseDecoder):
         pixel_format='rgb' (default) → (3,H,W) RGB via convert() (color matrix).
         pixel_format='yuv420p' → 1D planar I420 uint8 via to_yuv420p() (no color
         math, half the bytes) — for piping straight to an encoder."""
+        t = None
         try:
             t = self.track.pts2time(pic.pts)
             stream = extract_stream_ptr(torch.cuda.current_stream(self.device))
-            # OwnedPicture carries its own slot+surface ownership (→
-            # OwnedSurface); a bare Picture maps via the decoder (→ plain
-            # Surface). Both expose .free().
+            # Both OwnedPicture (owns its slot) and bare Picture map under
+            # the output-surface semaphore; .free() on either is safe.
             if isinstance(pic, OwnedPicture):
                 surface = pic.map(stream)
             else:
-                surface = self.map(pic, stream)
+                surface = OwnedSurface(self, pic, stream)
         except Exception as e:
             return (t, e)
         finally:
@@ -683,6 +680,13 @@ class Decoder(BaseDecoder):
         """Yield (int_pts, frame_or_exception) for every decoded frame in
         display order. Decodes ALL frames (B-frames included).
 
+        POSITION: without `start` / `start_pts` this does NOT rewind. It
+        decodes from wherever the demuxer currently is — the beginning on
+        a fresh Decoder, but after a `screenshot()`, `screenshots()` or an
+        exhausted `frames()` it resumes from there (and yields nothing if
+        that was EOF). Pass `start=timedelta(0)` to decode from the start
+        of the file regardless of what ran before.
+
         The yielded `int_pts` is the raw track pts (same units as
         `pic.pts`, including the demuxer's `start_time` offset). Pass
         through `track.pts2time(pts)` if you need a `timedelta`. Yielding

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec/utils/player.py

@@ -20,6 +20,7 @@ class Player(Decoder):
         target_rect=None,
         device=None,
         track_idx=None,
+        **decoder_kwargs,
     ):
         tracks = [t for t in parse(url) if isinstance(t, VideoTrack)]
         if not tracks:
@@ -38,5 +39,6 @@ class Player(Decoder):
             cropping=cropping,
             target_rect=target_rect,
             device=device,
+            **decoder_kwargs,
         )
         self.url = url

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22/src/nvidia_codec.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-codec
-Version: 0.0.21
+Version: 0.0.22
 Summary: Pythonic interface to Nvidia Codec
 Home-page: https://github.com/riaqn/python-nvidia-codec
 Author: Zesen Qian
@@ -26,7 +26,7 @@ A Pythonic library for NVIDIA Video Codec (NVDEC).
 - Python 3.10+
 - NVIDIA GPU with NVDEC support
 - NVIDIA driver with `libnvcuvid.so`
-- FFmpeg 8.x (for demuxing)
+- FFmpeg 9.x (for demuxing)
 
 ## Installation
 
@@ -57,6 +57,11 @@ for timestamp, frame in player.frames(torch.uint8):
     print(f'{timestamp}: {frame.shape}')
 ```
 
+`frames()` without `start` continues from the demuxer's current position; it
+only begins at the first frame on a freshly opened player. After a
+`screenshot()` or a previous `frames()` pass, pass `start=timedelta(0)` to
+decode from the beginning again.
+
 ### Screenshot (single frame extraction)
 
 ```python

{nvidia_codec-0.0.21 → nvidia_codec-0.0.22}/src/nvidia_codec.egg-info/SOURCES.txt

@@ -31,4 +31,5 @@ src/nvidia_codec/utils/color.py
 src/nvidia_codec/utils/compat.py
 src/nvidia_codec/utils/decode.py
 src/nvidia_codec/utils/demux.py
-src/nvidia_codec/utils/player.py
+src/nvidia_codec/utils/player.py
+tests/test_smoke.py

nvidia_codec-0.0.22/tests/test_smoke.py

@@ -0,0 +1,131 @@
+"""Smoke test: synthesize a short H.264 clip with ffmpeg, decode it with NVDEC.
+
+Requires an NVIDIA GPU, libnvcuvid, FFmpeg 9 libraries and the `ffmpeg` CLI.
+Run with:  python -m pytest tests/  (or simply: python tests/test_smoke.py)
+"""
+from datetime import timedelta
+import os
+import shutil
+import subprocess
+import tempfile
+
+import pytest
+import torch
+
+from nvidia_codec.core.cuviddec import cudaVideoSurfaceFormat
+from nvidia_codec.utils import Player, parse, VideoTrack
+
+W, H, FPS, SECONDS = 320, 240, 25, 2
+
+pytestmark = pytest.mark.skipif(
+    not (shutil.which("ffmpeg") and torch.cuda.is_available()),
+    reason="needs ffmpeg CLI and a CUDA GPU",
+)
+
+
+@pytest.fixture(scope="module")
+def clip():
+    d = tempfile.mkdtemp(prefix="nvc-smoke-")
+    path = os.path.join(d, "clip.mp4")
+    subprocess.run(
+        ["ffmpeg", "-v", "error", "-y", "-f", "lavfi",
+         f"-i", f"testsrc=size={W}x{H}:rate={FPS}:duration={SECONDS}",
+         "-pix_fmt", "yuv420p", "-c:v", "libx264", "-g", "12", path],
+        check=True, timeout=60,
+    )
+    yield path
+    shutil.rmtree(d, ignore_errors=True)
+
+
+def test_parse(clip):
+    tracks = [t for t in parse(clip) if isinstance(t, VideoTrack)]
+    assert len(tracks) == 1
+    t = tracks[0]
+    assert (t.width, t.height) == (W, H)
+    assert t.mime_codec.startswith("avc1.")
+    assert abs(t.duration.total_seconds() - SECONDS) < 0.2
+
+
+def test_frames_rgb(clip):
+    with Player(clip) as p:
+        n = 0
+        last = -1
+        for pts, frame in p.frames(torch.uint8):
+            assert not isinstance(frame, Exception), frame
+            assert frame.shape == (3, H, W) and frame.dtype == torch.uint8
+            assert frame.is_cuda
+            assert pts > last
+            last = pts
+            n += 1
+    assert n == FPS * SECONDS
+
+
+def test_frames_yuv420p_window(clip):
+    with Player(clip) as p:
+        out = list(p.frames(torch.uint8, start=timedelta(seconds=0.5),
+                            end=timedelta(seconds=1.0), pixel_format="yuv420p"))
+    assert 0 < len(out) <= FPS // 2 + 2
+    for _, frame in out:
+        assert frame.shape == (H * W * 3 // 2,)
+
+
+def test_screenshot(clip):
+    with Player(clip, target_size=lambda h, w: (h // 2, w // 2)) as p:
+        t, frame = p.screenshot(timedelta(seconds=1), torch.float32, accurate=True)
+        assert frame.shape == (3, H // 2, W // 2)
+        assert abs(t.total_seconds() - 1.0) < 1 / FPS + 1e-3
+        assert 0.0 <= frame.min() and frame.max() <= 1.0
+
+
+def test_screenshots(clip):
+    with Player(clip) as p:
+        shots = [s for s in p.screenshots(torch.uint8, timedelta(seconds=0.5))]
+    assert len(shots) >= 3
+    for _, frame, _ in shots:
+        assert not isinstance(frame, Exception), frame
+        assert frame.shape == (3, H, W)
+
+
+def _has_encoder(name):
+    out = subprocess.run(["ffmpeg", "-hide_banner", "-encoders"],
+                         capture_output=True, text=True, timeout=30).stdout
+    return f" {name} " in out
+
+
+@pytest.fixture(scope="module")
+def clip10():
+    if not _has_encoder("libx265"):
+        pytest.skip("ffmpeg lacks libx265")
+    d = tempfile.mkdtemp(prefix="nvc-smoke10-")
+    path = os.path.join(d, "clip10.mp4")
+    subprocess.run(
+        ["ffmpeg", "-v", "error", "-y", "-f", "lavfi",
+         "-i", f"testsrc=size={W}x{H}:rate={FPS}:duration=1",
+         "-pix_fmt", "yuv420p10le", "-c:v", "libx265",
+         "-x265-params", "log-level=none", "-g", "12", path],
+        check=True, timeout=120,
+    )
+    yield path
+    shutil.rmtree(d, ignore_errors=True)
+
+
+def test_10bit_allow_high_matches_8bit(clip10):
+    """P016 (allow_high) and NV12 paths must agree on the same 10-bit source."""
+    with Player(clip10) as p:
+        _, lo = p.screenshot(timedelta(seconds=0.5), torch.float32, accurate=True)
+        assert p.surface_format == cudaVideoSurfaceFormat.NV12
+    with Player(clip10, allow_high=True) as p:
+        _, hi = p.screenshot(timedelta(seconds=0.5), torch.float32, accurate=True)
+        assert p.surface_format == cudaVideoSurfaceFormat.P016
+        assert hi.shape == (3, H, W)
+        assert 0.0 <= hi.min() and hi.max() <= 1.0
+        # yuv420p export is 8-bit only: the error is reported in-band
+        _, r = next(iter(p.frames(torch.uint8, start=timedelta(0),
+                                  pixel_format="yuv420p")))
+        assert isinstance(r, ValueError)
+    # 10-bit rounds to 8-bit at most 1/255 off, plus matrix rounding
+    assert (hi - lo).abs().max() < 0.02
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([__file__, "-v"]))