nvidia-codec 0.0.17__tar.gz → 0.0.19__tar.gz

{nvidia_codec-0.0.17/src/nvidia_codec.egg-info → nvidia_codec-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-codec
-Version: 0.0.17
+Version: 0.0.19
 Summary: Pythonic interface to Nvidia Codec
 Home-page: https://github.com/riaqn/python-nvidia-codec
 Author: Zesen Qian

{nvidia_codec-0.0.17 → nvidia_codec-0.0.19}/setup.cfg

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

{nvidia_codec-0.0.17 → nvidia_codec-0.0.19}/src/nvidia_codec/core/decode.py

@@ -1,46 +1,22 @@
-"""Low-level NVDEC decoder with Picture/Surface memory management.
-
-This module provides the core decoding interface using NVIDIA's CUVID API.
-The decoding pipeline has two stages:
-
-1. **Picture**: Raw decoded frame in GPU memory (not directly accessible)
-2. **Surface**: Post-processed frame that can be accessed as a CUDA array
-
-Workflow:
-    1. Send compressed packets to BaseDecoder.send()
-    2. Receive Picture objects via the on_recv callback
-    3. Call Picture.map() to get a Surface (applies cropping/scaling)
-    4. Access Surface data via __cuda_array_interface__ (works with PyTorch, CuPy)
-    5. Call Surface.free() and Picture.free() when done (or let them be garbage collected)
-
-Memory Management:
-    - Pictures and Surfaces are backed by pre-allocated GPU memory pools
-    - `num_pictures` controls the decode buffer size (max 32)
-    - `num_surfaces` controls the output buffer size (no hard limit)
-    - Calling free() marks the slot as reusable, but memory stays allocated
-    - The decoder owns all memory until BaseDecoder.free() is called
-
-Example:
-    decoder = BaseDecoder(cudaVideoCodec.H264, decide=my_decide_callback)
-    def on_recv(picture, pts, result):
-        if picture is None:  # End of stream
-            return result
-        surface = picture.map(cuda_stream)
-        tensor = torch.as_tensor(surface, device='cuda')
-        picture.free()
-        surface.free()
-        return tensor
-    result = decoder.send(packet_data, on_recv, pts=12345)
+"""Low-level NVDEC decoder — thin wrapper around CUVID API.
+
+This module provides the core decoding interface. It does NOT manage
+threading or slot ownership; that is the caller's responsibility
+(see nvidia_codec.utils.player for the higher-level interface).
+
+Callbacks:
+    pre_decode(pic_idx): Called before cuvidDecodePicture. The caller
+        should block here if the picture slot is in use.
+    post_decode(pic): Called when a decoded frame is ready for display
+        (the "display callback"). pic is a Picture or None (EOS).
 """
 
 from . import cuda
 from .nvcuvid import *
 from .common import *
 from .. import CodecNotSupportedError
-from queue import Empty, Queue
 import numpy as np
 from ctypes import *
-from threading import Condition, Semaphore
 
 import logging
 
@@ -52,87 +28,57 @@ nvcuvid = cdll.LoadLibrary("libnvcuvid.so")
 class Surface:
     """Post-processed decoded frame accessible as a CUDA array.
 
-    A Surface contains the final decoded frame data after cropping and scaling.
-    It implements __cuda_array_interface__ for zero-copy access from PyTorch,
-    CuPy, and other CUDA-aware libraries.
-
     Do not instantiate directly; use Picture.map() instead.
-
-    Attributes:
-        format: Surface pixel format (NV12, P016, YUV444, etc.)
-        width: Frame width in pixels
-        height: Frame height in pixels
-        shape: Array shape for __cuda_array_interface__
     """
 
-    def __init__(self, decoder, index, params, stream):
-        """Internal constructor. Use Picture.map() instead."""
-
+    def __init__(self, decoder, index, params, stream, pts):
         self.decoder = decoder
+        self.pts = pts
 
         self.params = CUVIDPROCPARAMS()
         memmove(byref(self.params), byref(params), sizeof(CUVIDEOFORMAT))
 
         self.params.output_stream = stream
 
-        self.c_devptr = (
-            c_ulonglong()
-        )  # according to cuviddec, the argument type of cuvidmapvideoframe64
+        self.c_devptr = c_ulonglong()
         self.c_pitch = c_uint()
 
-        with self.decoder.condition:
-            self.decoder.condition.wait_for(lambda: self.decoder.surfaces_sem > 0)
-            with cuda.Device(self.decoder.device):
-                cuda.check(
-                    nvcuvid.cuvidMapVideoFrame64(
-                        self.decoder.cuvid_decoder,
-                        c_int(index),
-                        byref(self.c_devptr),
-                        byref(self.c_pitch),
-                        byref(self.params),
-                    )
+        with cuda.Device(self.decoder.device):
+            cuda.check(
+                nvcuvid.cuvidMapVideoFrame64(
+                    self.decoder.cuvid_decoder,
+                    c_int(index),
+                    byref(self.c_devptr),
+                    byref(self.c_pitch),
+                    byref(self.params),
                 )
-                # log.warning('mapped')
-                self.decoder.surfaces_sem -= 1
-            self.decoder.condition.notify_all()
+            )
 
     @property
     def format(self) -> cudaVideoSurfaceFormat:
-        """Surface pixel format (NV12, P016, YUV444, or YUV444_16Bit)."""
         return self.decoder.surface_format
 
     @property
     def height(self):
-        """Frame height in pixels."""
         return self.decoder.target_height
 
     @property
     def width(self):
-        """Frame width in pixels."""
         return self.decoder.target_width
 
     @property
     def size(self):
-        """Frame dimensions as {'width': int, 'height': int}."""
         return {"width": self.width, "height": self.height}
 
     def free(self):
-        """Release this surface back to the decoder's pool.
-
-        The underlying GPU memory remains allocated by the decoder and will be
-        reused for future frames. Called automatically on garbage collection.
-        """
-        with self.decoder.condition:
-            if self.c_devptr and self.decoder.cuvid_decoder:
-                with cuda.Device(self.decoder.device):
-                    cuda.check(
-                        nvcuvid.cuvidUnmapVideoFrame64(
-                            self.decoder.cuvid_decoder, self.c_devptr
-                        )
+        if self.c_devptr and self.decoder.cuvid_decoder:
+            with cuda.Device(self.decoder.device):
+                cuda.check(
+                    nvcuvid.cuvidUnmapVideoFrame64(
+                        self.decoder.cuvid_decoder, self.c_devptr
                     )
-                    self.decoder.surfaces_sem += 1
-                    self.c_devptr = c_ulonglong()
-                    self.decoder.condition.notify_all()
+                )
+                self.c_devptr = c_ulonglong()
 
     def __del__(self):
         self.free()
@@ -169,7 +115,7 @@ class Surface:
             "typestr": typestr,
             "strides": strides,
             "version": 3,
-            "data": (self.c_devptr.value, False),  # false = not read-only
+            "data": (self.c_devptr.value, False),
             "stream": self.params.output_stream,
         }
 
@@ -177,76 +123,28 @@ class Surface:
 class Picture:
     """Decoded frame before post-processing.
 
-    A Picture holds a reference to a decoded frame in the decoder's internal
-    buffer. The frame data is not directly accessible; call map() to create
-    a Surface that can be read.
-
-    Do not instantiate directly; Pictures are created by the decoder and
-    passed to your on_recv callback.
+    A data object — does not own the picture slot. Slot ownership is
+    managed by the caller via pre_decode/pic_release callbacks.
     """
 
     def __init__(self, decoder, index, proc_params, pts):
-        """Internal constructor. Pictures are created by the decoder."""
         self.decoder = decoder
         self.index = index
         self.params = proc_params
         self.pts = pts
-        with self.decoder.condition:
-            self.decoder.pictures_used.add(self.index)
 
     def free(self):
-        """Release this picture back to the decoder's pool.
-
-        The underlying GPU memory remains allocated by the decoder and will be
-        reused for future frames. Called automatically on garbage collection.
-        """
-        log.debug(f"freeing picture {self.index}")
-
-        with self.decoder.condition:
-            # discard instead of remove
-            # so this won't trigger exception
-            # which is possible
-            self.decoder.pictures_used.discard(self.index)
-            self.decoder.condition.notify_all()
-
-    def __del__(self):
-        self.free()
+        """No-op. Slot ownership is managed by the caller (player.py)."""
+        pass
 
     def map(self, stream: int = 0):
-        """Post-process this picture and create an accessible Surface.
-
-        Applies cropping, scaling, and color format conversion as configured
-        in the decoder. The operation is queued on the specified CUDA stream.
-
-        Args:
-            stream: CUDA stream for the operation. Pass 0 or 2 for the
-                per-thread default stream, or a stream pointer/handle.
-
-        Returns:
-            Surface that can be accessed via __cuda_array_interface__.
-        """
-        return Surface(self.decoder, self.index, self.params, stream)
+        return Surface(self.decoder, self.index, self.params, stream, self.pts)
 
 
 def decide_surface_format(
     chroma_format, bit_depth, supported_surface_formats, allow_high=False
 ):
-    """Select the best surface format for the given video parameters.
-
-    Args:
-        chroma_format: Video chroma subsampling (YUV420, YUV444, etc.)
-        bit_depth: Bits per color channel (usually 8 or 10)
-        supported_surface_formats: Formats supported by this GPU/codec combination
-        allow_high: If True, use 16-bit output for >8-bit video. If False,
-            always use 8-bit output (lossy for HDR content).
-
-    Returns:
-        The selected cudaVideoSurfaceFormat.
-
-    Raises:
-        Exception: If the chroma format is unsupported or no compatible
-            surface format is available.
-    """
+    """Select the best surface format for the given video parameters."""
     if chroma_format in [
         cudaVideoChromaFormat.YUV420,
         cudaVideoChromaFormat.MONOCHROME,
@@ -267,7 +165,6 @@ def decide_surface_format(
     else:
         raise Exception(f"unexpected chroma format {chroma_format}")
 
-    # check if the selected format is supported. If not, check fallback options
     if f not in supported_surface_formats:
         if cudaVideoSurfaceFormat.NV12 in supported_surface_formats:
             f = cudaVideoSurfaceFormat.NV12
@@ -287,26 +184,19 @@ def decide_surface_format(
 
 
 class BaseDecoder:
-    """NVDEC hardware decoder with callback-based frame delivery.
-
-    Decodes video packets using NVIDIA's CUVID API. For each decoded frame,
-    the provided on_recv callback is invoked with a Picture object. This
-    is the low-level decoder; most users should use Player
-    from nvidia_codec.utils instead.
+    """NVDEC hardware decoder — thin wrapper around CUVID API.
 
-    The decoder manages GPU memory pools for Pictures and Surfaces. Configure
-    pool sizes via the decide callback to balance memory usage and throughput.
+    Threading and slot ownership are NOT managed here. The caller provides
+    callbacks (pre_decode, pic_release, surface_acquire, surface_release)
+    to handle synchronization.
     """
 
     def catch_exception(self, func, return_on_error=0):
-        """Wrap callbacks to capture exceptions and return error codes."""
-
         def wrapper(*args, **kwargs):
             try:
                 return func(*args, **kwargs)
-            except BaseException as e:  # catch keyboard interrupt as well
+            except BaseException as e:
                 log.debug(f"callback exception logged {e}")
-                # we record the exception; to be checked when nvcuvid propagate the error return code
                 self.exception = e
                 log.debug(f"returning error code {return_on_error}")
                 return return_on_error
@@ -318,8 +208,6 @@ class BaseDecoder:
         vf = pVideoFormat.contents
 
         if self.cuvid_decoder:
-            # Only compare fields that affect decoder configuration
-            # frame_rate and other metadata can vary after seek within the same video
             essential = [
                 "codec",
                 "coded_width",
@@ -340,7 +228,6 @@ class BaseDecoder:
                     f"decoder already initialized with different format: {diff}"
                 )
         memmove(byref(self.video_format), byref(vf), sizeof(CUVIDEOFORMAT))
-        # save for user use
 
         caps = CUVIDDECODECAPS(
             eCodecType=vf.codec,
@@ -363,7 +250,7 @@ class BaseDecoder:
         ) <= caps.nMaxMBCount, "too many macroblocks"
 
         supported_surface_formats = []
-        for surface_format in range(4):  # cudaVideoSurfaceFormat:
+        for surface_format in range(4):
             if caps.nOutputFormatMask & (1 << surface_format):
                 supported_surface_formats.append(cudaVideoSurfaceFormat(surface_format))
 
@@ -374,14 +261,13 @@ class BaseDecoder:
             "min_num_pictures": vf.min_num_decode_surfaces,
         }
 
-        # the default values
         decision = {
-            "num_pictures": p["min_num_pictures"] + 1,  # for simplicity
-            "num_surfaces": 1 + 1,  # for simplicity
+            "num_pictures": p["min_num_pictures"] + 1,
+            "num_surfaces": 1 + 1,
             "surface_format": decide_surface_format(
                 p["chroma_format"], p["bit_depth"], p["supported_surface_formats"]
             ),
-            "cropping": lambda height, width: {  # by default no cropping
+            "cropping": lambda height, width: {
                 "left": 0,
                 "right": width,
                 "top": 0,
@@ -390,8 +276,8 @@ class BaseDecoder:
             "target_size": lambda cropped_height, cropped_width: (
                 cropped_height,
                 cropped_width,
-            ),  # by default no scaling
-            "target_rect": lambda target_height, target_width: {  # by default no margin
+            ),
+            "target_rect": lambda target_height, target_width: {
                 "left": 0,
                 "right": target_width,
                 "top": 0,
@@ -414,7 +300,6 @@ class BaseDecoder:
         ), f"surface format {decision['surface_format']} not supported for codec {caps.eCodecType} chroma {caps.eChromaFormat} depth {caps.nBitDepthMinus8 + 8}"
         assert decision["num_surfaces"] >= 0, "number of surfaces must be non-negative"
         da = vf.display_area
-        # the provided cropping is offsetted
         display_area = SRECT(
             left=da.left + c["left"],
             top=da.top + c["top"],
@@ -451,9 +336,6 @@ class BaseDecoder:
             enableHistogram=0,
         )
 
-        # for field_name, filed_type in p._fields_:
-        #     print(field_name, getattr(p, field_name))
-
         with cuda.Device(self.device):
             cuda.check(
                 nvcuvid.cuvidCreateDecoder(
@@ -461,77 +343,64 @@ class BaseDecoder:
                 )
             )
 
-        # this contains all picture indices that are still being used
-        # including the ones in above, and the ones passed to user via on_recv
-        self.pictures_used = set()
-
-        self.surfaces_sem = decision["num_surfaces"]  # number of surfaces available
-
         log.debug("sequence successful")
         return decision["num_pictures"]
 
     @property
     def codec(self):
-        """Video codec (cudaVideoCodec enum)."""
         return self.decode_create_info.CodecType
 
     @property
     def height(self):
-        """Original video height in pixels (before scaling)."""
         return (
             self.video_format.display_area.bottom - self.video_format.display_area.top
         )
 
     @property
     def width(self):
-        """Original video width in pixels (before scaling)."""
         return (
             self.video_format.display_area.right - self.video_format.display_area.left
         )
 
     @property
     def target_width(self):
-        """Output width in pixels (after scaling)."""
         return self.decode_create_info.ulTargetWidth
 
     @property
     def target_height(self):
-        """Output height in pixels (after scaling)."""
         return self.decode_create_info.ulTargetHeight
 
     @property
     def surface_format(self):
-        """Output surface format (NV12, P016, YUV444, etc.)."""
         return self.decode_create_info.OutputFormat
 
+    def pre_decode(self, idx):
+        """NVDEC is reclaiming picture slot idx. After this returns,
+        slot ownership is transferred back to NVDEC."""
+        raise NotImplementedError
+
+    def post_decode(self, pic):
+        """NVDEC is releasing picture slot for display.
+        pic is a Picture or None (EOS)."""
+        raise NotImplementedError
+
     def handlePictureDecode(self, pUserData, pPicParams):
         log.debug("decode")
         pp = pPicParams.contents
-        # assert self.cuvid_decoder, "decoder not initialized"
         log.debug(f"decode picture index: {pp.CurrPicIdx}")
 
-        if pp.CurrPicIdx in self.pictures_used:
-            log.info(f"{self.pictures_used}")
-        with self.condition:
-            # wait until picture slot is available again
-            log.debug("wait_for_pictures started")
-            self.condition.wait_for(lambda: pp.CurrPicIdx not in self.pictures_used)
-            log.debug("wait_for_pictures finished")
+        self.pre_decode(pp.CurrPicIdx)
 
-            # now we know that the user no longer need this picture
-            # we can overwrite it
-            with cuda.Device(self.device):
-                cuda.check(nvcuvid.cuvidDecodePicture(self.cuvid_decoder, byref(pp)))
+        with cuda.Device(self.device):
+            cuda.check(nvcuvid.cuvidDecodePicture(self.cuvid_decoder, byref(pp)))
 
         return 1
 
     def handlePictureDisplay(self, pUserData, pDispInfo):
         log.debug("display")
         if not bool(pDispInfo):
-            # EOS notification
-            self.on_recv(None)
+            self.post_decode(None)
             return 1
-        # di = cast(pDispInfo, POINTER(CUVIDPARSERDISPINFO)).contents
         di = pDispInfo.contents
 
         params = CUVIDPROCPARAMS(
@@ -542,15 +411,10 @@ class BaseDecoder:
         )
 
         picture = Picture(self, di.picture_index, params, di.timestamp)
-        try:
-            self.on_recv(picture)
-        except:
-            picture.free()
-            raise
+        self.post_decode(picture)
         return 1
 
     def handleOperatingPoint(self, pUserData, pOPInfo):
-        """Handle AV1 operating point selection (internal callback)."""
         opi = pOPInfo.contents
         if opi.codec == cudaVideoCodec.AV1:
             if opi.av1.operating_points_cnt > 1:
@@ -568,40 +432,17 @@ class BaseDecoder:
         coded_width=0,
         coded_height=0,
     ):
-        """Initialize the decoder.
-
-        Args:
-            codec: Video codec (e.g., cudaVideoCodec.H264, cudaVideoCodec.HEVC)
-            decide: Callback to configure decoder parameters. Called with a dict:
-                - 'chroma_format': cudaVideoChromaFormat (YUV420, YUV444, etc.)
-                - 'bit_depth': int (8 or 10)
-                - 'supported_surface_formats': list of cudaVideoSurfaceFormat
-                - 'min_num_pictures': int (minimum decode buffer size)
-
-                Return a dict with any of these optional overrides:
-                - 'num_pictures': Decode buffer size (default: min + 1, max: 32)
-                - 'num_surfaces': Output buffer size (default: 2)
-                - 'surface_format': Output format (default: auto-selected)
-                - 'cropping': Function (h, w) -> {'left', 'top', 'right', 'bottom'}
-                - 'target_size': Function (h, w) -> (new_h, new_w) for scaling
-                - 'target_rect': Function (h, w) -> {'left', 'top', 'right', 'bottom'}
-
-            device: CUDA device ID (default: current device)
-            extradata: Codec sequence header from container (required for VC1/WMV3)
-            coded_width: Video width hint for codecs needing extradata
-            coded_height: Video height hint for codecs needing extradata
-        """
         self.dirty = False
         self.decide = decide
         self.exception = None
-        self.cuvid_parser = CUvideoparser()  # NULL
-        self.cuvid_decoder = CUvideodecoder()  # NULL
+        self.cuvid_parser = CUvideoparser()
+        self.cuvid_decoder = CUvideodecoder()
+
 
         self.operating_point = 0
         self.disp_all_layers = False
-        self.condition = Condition()
 
-        self.video_format = CUVIDEOFORMAT()  # NULL, to be filled in later
+        self.video_format = CUVIDEOFORMAT()
 
         self.handleVideoSequenceCallback = PFNVIDSEQUENCECALLBACK(
             self.catch_exception(self.handleVideoSequence)
@@ -616,17 +457,14 @@ class BaseDecoder:
             self.catch_exception(self.handleOperatingPoint, -1)
         )
 
-        # Prepare extended video info with sequence header for codecs like VC1/WMV3
         self.ext_video_info = None
         pExtVideoInfo = None
         if extradata is not None and len(extradata) > 0:
             self.ext_video_info = CUVIDEOFORMATEX()
-            # Set format info from container (needed for VC1 Simple/Main which lacks in-band headers)
             self.ext_video_info.format.codec = codec
             self.ext_video_info.format.coded_width = coded_width
             self.ext_video_info.format.coded_height = coded_height
-            self.ext_video_info.format.chroma_format = 1  # YUV420 - most common
-            # Copy extradata into raw_seqhdr_data (max 1024 bytes)
+            self.ext_video_info.format.chroma_format = 1
             copy_len = min(len(extradata), 1024)
             memmove(self.ext_video_info.raw_seqhdr_data, extradata, copy_len)
             self.ext_video_info.format.seqhdr_data_length = copy_len
@@ -650,11 +488,8 @@ class BaseDecoder:
 
         self.device = cuda.get_current_device(device)
 
-        # Early codec support check before creating parser
-        # (cuvidCreateVideoParser may succeed even for unsupported codecs,
-        # then cuvidParseVideoData fails with an unhelpful "unknown error")
         caps = CUVIDDECODECAPS(
-            eCodecType=codec, eChromaFormat=1, nBitDepthMinus8=0  # YUV420 — most common
+            eCodecType=codec, eChromaFormat=1, nBitDepthMinus8=0
         )
         with cuda.Device(self.device):
             cuda.check(nvcuvid.cuvidGetDecoderCaps(byref(caps)))
@@ -663,28 +498,19 @@ class BaseDecoder:
                 f"Codec not supported: {cudaVideoCodec(codec)}"
             )
 
-        with self.condition:
-            cuda.check(
-                nvcuvid.cuvidCreateVideoParser(byref(self.cuvid_parser), byref(p))
-            )
-            self.condition.notify_all()
+        cuda.check(
+            nvcuvid.cuvidCreateVideoParser(byref(self.cuvid_parser), byref(p))
+        )
 
-    def send(self, packet, on_recv):
+    def send(self, packet):
         """Send a compressed packet to the decoder.
 
-        The decoder will parse the packet and invoke on_recv for each decoded
-        frame. Frames are delivered in display order (after B-frame reordering).
+        Calls self.pre_decode(idx) before each decode and
+        self.post_decode(pic) for each displayed frame.
 
         Args:
-            packet: Either (pts, data) tuple where data is a 1D numpy array,
-                or None to signal end-of-stream (triggers EOS callback with picture=None).
-            on_recv: Callback function(picture) called for each decoded frame.
-                - picture: Picture object (with .pts field), or None at end of stream
-
-        Note:
-            The packet buffer can be reused immediately after send() returns.
+            packet: (pts, data) tuple or None for end-of-stream.
         """
-
         if packet is None:
             p = CUVIDSOURCEDATAPACKET(
                 flags=(
@@ -703,37 +529,24 @@ class BaseDecoder:
                 timestamp=pts,
             )
         self.exception = None
-        self.on_recv = on_recv
         with cuda.Device(self.device):
             try:
                 cuda.check(nvcuvid.cuvidParseVideoData(self.cuvid_parser, byref(p)))
             except cuda.CUError:
-                # If a callback stored an exception, raise that instead of CUError
                 if self.exception is not None:
                     raise self.exception
                 raise
-        # catch: cuvidParseVideoData will not propagate error return code 0 of HandleVideoSequenceCallback
-        # it still returns CUDA_SUCCESS and simply ignore all future incoming packets
-        # therefore we must check the exception here, even if the last call succeeded
         if self.exception is not None:
-            # the exception is caused by our callback, not by cuvid
             raise self.exception
 
     def free(self):
-        """Release all decoder resources.
-
-        Destroys the CUVID parser and decoder, freeing all GPU memory.
-        The decoder cannot be used after calling free().
-        """
-        with self.condition:
-            if self.cuvid_parser:
-                cuda.check(nvcuvid.cuvidDestroyVideoParser(self.cuvid_parser))
-                self.cuvid_parser = CUvideoparser()
-            if self.cuvid_decoder:
-                with cuda.Device(self.device):
-                    cuda.check(nvcuvid.cuvidDestroyDecoder(self.cuvid_decoder))
-                    self.cuvid_decoder = CUvideodecoder()
-            self.condition.notify_all()
+        if getattr(self, 'cuvid_parser', None):
+            cuda.check(nvcuvid.cuvidDestroyVideoParser(self.cuvid_parser))
+            self.cuvid_parser = CUvideoparser()
+        if getattr(self, 'cuvid_decoder', None):
+            with cuda.Device(self.device):
+                cuda.check(nvcuvid.cuvidDestroyDecoder(self.cuvid_decoder))
+                self.cuvid_decoder = CUvideodecoder()
 
     def __del__(self):
         self.free()