PyNvVideoCodec 2.2.1__cp311-cp311-win_arm64.whl

PyNvVideoCodec/__init__.py

@@ -0,0 +1,251 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+"""
+
+"""
+
+__author__ = "NVIDIA"
+__copyright__ = "Copyright 2026, NVIDIA"
+__credits__ = []
+__license__ = "MIT"
+__version__ = "2.2.1"
+__maintainer__ = "NVIDIA"
+__email__ = "TODO"
+__status__ = "Production"
+
+from ast import Str
+import string
+import os
+import platform
+import sys
+import sysconfig
+import site
+from pathlib import Path
+import importlib.util
+import logging
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+def _setup_environment():
+    """Setup environment variables and paths"""
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    machine = platform.machine()
+    cuda_lib_dir = "arm64" if machine.lower() in ("arm64", "aarch64") else "x64"
+    
+    if platform.system() == 'Windows':
+        try:
+            # Add CUDA path if available
+            cuda_path = os.environ.get('CUDA_PATH')
+            if cuda_path:
+                dll_paths = [
+                    os.path.join(cuda_path, "bin"),
+                    os.path.join(cuda_path, "lib", cuda_lib_dir),
+                    package_dir,  # Package directory for ffmpeg DLLs
+                    os.path.join(package_dir, "lib")  # Additional lib directory
+                ]
+                
+                # Add paths to DLL search path
+                if hasattr(os, 'add_dll_directory'):
+                    for path in dll_paths:
+                        if os.path.exists(path):
+                            os.add_dll_directory(path)
+                            logger.debug(f"Added DLL directory: {path}")
+        except Exception as e:
+            logger.error(f"Error setting up DLL paths: {e}")
+
+def _get_module_path(module_suffix):
+    """Get the appropriate module file path"""
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    py_version = f"{sys.version_info.major}{sys.version_info.minor}"
+    machine = platform.machine()
+    
+    if platform.system() == "Windows":
+        ext = ".pyd"
+        platform_tag = sysconfig.get_platform().replace("-", "_")
+        if platform_tag not in ("win_amd64", "win_arm64"):
+            platform_tag = "win_arm64" if machine.lower() in ("arm64", "aarch64") else "win_amd64"
+        possible_names = [
+            f"PyNvVideoCodec{module_suffix}.cp{py_version}-{platform_tag}{ext}"
+        ]
+    else:
+        ext = ".so"
+        if machine == 'aarch64':
+            possible_names = [
+                f"PyNvVideoCodec{module_suffix}.cpython-{py_version}-aarch64-linux-gnu{ext}",
+                f"PyNvVideoCodec{module_suffix}.cpython-{py_version}-aarch64-linux{ext}",
+                f"PyNvVideoCodec{module_suffix}.cp{py_version}-manylinux_2_28_aarch64{ext}"
+            ]
+        else:  # x86_64
+            possible_names = [
+                f"PyNvVideoCodec{module_suffix}.cpython-{py_version}-x86_64-linux-gnu{ext}",
+                f"PyNvVideoCodec{module_suffix}.cpython-{py_version}-x86_64-linux{ext}",
+                f"PyNvVideoCodec{module_suffix}.cp{py_version}-manylinux_2_28_x86_64{ext}"
+            ]
+    
+    # Try each possible name
+    for name in possible_names:
+        path = os.path.join(package_dir, name)
+        if os.path.exists(path):
+            logger.debug(f"Found module: {path}")
+            return path
+    
+    # If no module found, list directory contents for debugging
+    logger.error(f"Available files in {package_dir}:")
+    try:
+        for file in os.listdir(package_dir):
+            logger.error(f"  {file}")
+    except Exception as e:
+        logger.error(f"Error listing directory: {e}")
+    
+    # Return the first name for error message
+    return os.path.join(package_dir, possible_names[0])
+
+def _get_driver_version():
+    """Get the driver version using VersionCheck"""
+    try:
+        from .VersionCheck import DriverWrapper
+        driver = DriverWrapper()
+        version = driver.GetDriverVersion()
+        logger.info(f"Supported NVENC Driver Version: {version}")
+        return version
+    except Exception as e:
+        error_msg = str(e)
+        
+        # Provide troubleshooting guidance
+        troubleshooting = "\n\n=== TROUBLESHOOTING STEPS ===\n"
+        
+        if "libnvidia-encode.so" in error_msg or "cannot open shared object file" in error_msg:
+            troubleshooting += "\nThe NVENC library could not be found. This usually means:\n"
+            troubleshooting += "\n1. **Running in Docker?**"
+            troubleshooting += "\n   - Ensure your container was launched with: NVIDIA_DRIVER_CAPABILITIES=compute,utility,video"
+            troubleshooting += "\n   - Example: docker run --gpus all -e NVIDIA_DRIVER_CAPABILITIES=compute,utility,video ..."
+            troubleshooting += "\n   - Or add to docker-compose.yml:"
+            troubleshooting += "\n     environment:"
+            troubleshooting += "\n       - NVIDIA_DRIVER_CAPABILITIES=compute,utility,video"
+            troubleshooting += "\n\n2. **NVIDIA drivers not installed or outdated**"
+            troubleshooting += "\n   - Check driver installation: nvidia-smi"
+            troubleshooting += "\n   - Ensure NVENC-capable GPU is present"
+            troubleshooting += "\n   - Update to latest NVIDIA drivers if needed"
+            troubleshooting += "\n\n3. **Library path issues**"
+            troubleshooting += "\n   - Check if library exists: find /usr -name 'libnvidia-encode.so*' 2>/dev/null"
+            troubleshooting += "\n   - Verify LD_LIBRARY_PATH includes NVIDIA library directories"
+        else:
+            troubleshooting += f"\nOriginal error: {error_msg}\n"
+            troubleshooting += "\nPlease ensure:"
+            troubleshooting += "\n1. NVIDIA drivers are properly installed"
+            troubleshooting += "\n2. NVENC-capable GPU is available"
+            troubleshooting += "\n3. If using Docker, NVIDIA_DRIVER_CAPABILITIES includes 'video'"
+        
+        raise RuntimeError(f"{error_msg}{troubleshooting}") from e
+
+try:
+    # Setup environment
+    _setup_environment()
+
+    # Get driver version
+    supportedNvEncVersion = _get_driver_version()
+
+    # Define driver version thresholds
+    NVENC_VER_13 = 13 * 16  # Driver version for NVENC 13
+    NVENC_VER_12 = 12 * 16 + 1  # Driver version for NVENC 12.1
+
+    # Determine which version to use
+    if supportedNvEncVersion >= NVENC_VER_13:
+        module_suffix = "_130"
+        logger.info("Using NVENC 13.0 version")
+    elif supportedNvEncVersion >= NVENC_VER_12:
+        module_suffix = "_121"
+        logger.info("Using NVENC 12.1 version")
+    else:
+        raise RuntimeError("Driver version is too old")
+
+    # Get module path
+    module_path = _get_module_path(module_suffix)
+    if not os.path.exists(module_path):
+        raise ImportError(f"Module not found: {module_path}")
+
+    # Import the module
+    spec = importlib.util.spec_from_file_location("_PyNvVideoCodec", module_path)
+    if spec is None:
+        raise ImportError(f"Could not create module spec for {module_path}")
+        
+    _PyNvVideoCodec = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(_PyNvVideoCodec)
+
+    # Import all symbols into current namespace
+    globals().update({name: getattr(_PyNvVideoCodec, name) for name in dir(_PyNvVideoCodec) 
+                     if not name.startswith('_')})
+    
+    # Import submodules
+    from .decoders.SimpleDecoder import SimpleDecoder
+    from .decoders.ThreadedDecoder import ThreadedDecoder
+    from .transcoder.Transcoder import Transcoder
+
+except Exception as e:
+    # Only log additional diagnostics if troubleshooting steps not already included
+    if "TROUBLESHOOTING STEPS" not in str(e):
+        logger.error(f"Error importing PyNvVideoCodec: {e}")
+        logger.error(f"System: {platform.system()}")
+        logger.error(f"Python version: {sys.version}")
+        if platform.system() == "Linux":
+            logger.error(f"LD_LIBRARY_PATH: {os.environ.get('LD_LIBRARY_PATH', 'Not set')}")
+    raise
+
+def tostring(val):
+    if type(val) == dict:
+        x = dict(map(lambda x: (x[0], tostring(x[1])), val.items()))
+    else:
+        x = str(val)
+        x = x.replace("]", "")
+        x = x.replace("[", "")
+    return x
+
+def format_optional_params(optional_param):
+    param = tostring(optional_param)
+
+    if "slice" in param:
+        param["slice_mode"] = param["slice"]["mode"]
+        param["slice_data"] = param["slice"]["data"]
+        del param["slice"]
+
+    if "timinginfo" in param:
+        param["num_unit_in_ticks"] = param["timinginfo"]["num_unit_in_ticks"]
+        param["timescale"] = param["timinginfo"]["timescale"]
+        del param["timinginfo"]
+
+    return param
+
+def CreateEncoder(width, height, fmt, usecpuinputbuffer, **kwargs):
+    cudacontext = 0
+    cudastream = 0
+    if "cudacontext" in kwargs:
+        cudacontext = int(kwargs["cudacontext"])
+        del kwargs["cudacontext"]
+    if "cudastream" in kwargs:
+        cudastream = int(kwargs["cudastream"])
+        del kwargs["cudastream"]
+
+    optional_args = format_optional_params(kwargs)
+    return PyNvEncoder(width, height, fmt, cudacontext, cudastream, usecpuinputbuffer, optional_args)

PyNvVideoCodec/decoders/SimpleDecoder.py

@@ -0,0 +1,273 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+from typing import Union
+from pathlib import Path
+# from  ._SimpleDecoderImpl import SimpleDecoderImpl
+import PyNvVideoCodec as nvc
+import warnings
+import logging
+
+class SimpleDecoder:
+    """
+     A simple class for decoding a video stream and accessing frames in varied ways.
+
+     Args:
+        enc_file_path (str, bytes, bytearray, memoryview, or Path): Encoded file path
+            or in-memory video data. When bytes/bytearray/memoryview is provided, the
+            entire buffer is copied once into native memory for seekable decoding.
+        gpu_id (int) : gpu id on which to decode on.
+        cuda_context(pycuda._driver.Context): Cuda context under which the source is decoded
+        cuda_stream(pycuda._driver.Stream): Cuda stream used by the decoder
+        use_device_memory (bool): If set to 'True' output decoded frame is CUDeviceptr wrapped in CUDA Array Interface else its Host memory.
+        max_width(int): maximum width that the decoder must support
+        max_height(int): maximum height that the decoder must support
+        need_scanned_stream_metadata(bool): If set to 'True', the stream metadata will be collected by going through each of the packets. This
+        runs on a different thread and its running time depends on the total size of input stream.
+        decoder_cache_size(int): LRU cache size for the number of decoders to cache.
+        output_color_type (OutputColorType): Output format type of the decoded frames. By default it is OutputColorType::NATIVE which
+        implies decoded output is returned in native format(NV12, YUV444 etc.). Other supported values are OutputColorType::RGB(which implies
+        the decoded output is converted to interleaved RGB(HWC)) and OutputColorType::RGBP(which implies decoded output is converted to planar
+        RGB(CHW))
+        enableDecodeStats (bool): If set to 'True', decode statistics will be available for each decoded frame. Default is False.
+    """
+
+    def __init__(self, enc_file_path,
+                 gpu_id = 0, cuda_context = 0,
+                 cuda_stream = 0, use_device_memory = True,
+                 max_width = 0,
+                 max_height = 0,
+                 need_scanned_stream_metadata = 0,
+                 decoder_cache_size = 4,
+                 output_color_type = nvc.OutputColorType.NATIVE,
+                 bWaitForSessionWarmUp = False,
+                 enableDecodeStats = False):
+
+        self.need_scanned_stream_metadata = need_scanned_stream_metadata
+
+        # Normalize input: Path -> str, bytearray/memoryview -> bytes
+        if isinstance(enc_file_path, Path):
+            enc_file_path = str(enc_file_path)
+
+        if hasattr(enc_file_path, 'read') and hasattr(enc_file_path, 'seek'):
+            # BinaryIO stream: reads on-demand, no up-front copy
+            if hasattr(enc_file_path, 'seekable') and not enc_file_path.seekable():
+                raise ValueError(
+                    "SimpleDecoder requires a seekable stream. "
+                    "The provided stream reports seekable() == False."
+                )
+            if need_scanned_stream_metadata:
+                raise ValueError(
+                    "need_scanned_stream_metadata is not supported for BinaryIO stream "
+                    "input, because the metadata scan cannot share a Python stream across "
+                    "threads. Use a file path or bytes/bytearray/memoryview input if you "
+                    "need scanned stream metadata."
+                )
+            self.simple_decoder = nvc.CreateSimpleDecoder(enc_file_path, gpu_id,
+                                                          cuda_context, cuda_stream,
+                                                          use_device_memory, max_width,
+                                                          max_height,
+                                                          decoder_cache_size, output_color_type,
+                                                          bWaitForSessionWarmUp, enableDecodeStats)
+        elif isinstance(enc_file_path, (bytes, bytearray, memoryview)):
+            source_bytes = bytes(enc_file_path)
+            if len(source_bytes) > 8 * 1024 * 1024:
+                warnings.warn(
+                    f"SimpleDecoder: in-memory buffer is {len(source_bytes) / (1024*1024):.1f} MiB. "
+                    "Large buffers consume additional memory since the data is copied into native storage."
+                )
+            self.simple_decoder = nvc.CreateSimpleDecoder(source_bytes, gpu_id,
+                                                          cuda_context, cuda_stream,
+                                                          use_device_memory, max_width,
+                                                          max_height, need_scanned_stream_metadata,
+                                                          decoder_cache_size, output_color_type,
+                                                          bWaitForSessionWarmUp, enableDecodeStats)
+        elif isinstance(enc_file_path, str):
+            self.simple_decoder = nvc.CreateSimpleDecoder(enc_file_path, gpu_id,
+                                                          cuda_context, cuda_stream,
+                                                          use_device_memory, max_width,
+                                                          max_height, need_scanned_stream_metadata,
+                                                          decoder_cache_size, output_color_type,
+                                                          bWaitForSessionWarmUp, enableDecodeStats)
+        else:
+            raise TypeError(
+                f"enc_file_path must be str, bytes, bytearray, memoryview, Path, "
+                f"or a seekable file-like object (BinaryIO), "
+                f"got {type(enc_file_path).__name__}"
+            )
+
+        total_frames = self.__len__()
+        if total_frames == 0:
+            raise Exception("Elementary streams not supported by Simple Decoder. Invalid input stream.")
+
+    def __getitem__(self, key: Union[int, slice]):
+        """
+        Return frame or batch of frames depending on the key.
+        Supports Python slice semantics: stop is exclusive, so dec[0:len(dec)]
+        returns all frames.
+        Args:
+        key (int or slice): The index or range of indices to get the frames
+        Returns:
+        DecodedFrame: Decoded frame(s) based on the key
+        """
+        if isinstance(key, int):
+            self.validate_index(key)
+            return self.simple_decoder[key]
+        elif isinstance(key, slice):
+            start, stop, step = key.indices(len(self))
+            indices = list(range(start, stop, step))
+            if not indices:
+                return self.get_batch_frames_by_index([]) 
+            return self.get_batch_frames_by_index(indices)
+        else:
+            raise TypeError(
+                f"Unsupported key type: {type(key)}. Supported types are int and slice."
+            )
+
+
+    def __len__(self):
+        """
+        Returns the total number of frames in the video
+        """
+        stream_meta = self.simple_decoder.get_stream_metadata()
+        if stream_meta.num_frames == 0 and self.need_scanned_stream_metadata == True:
+            scanned_stream_data = self.simple_decoder.get_scanned_stream_metadata()
+            return scanned_stream_data.num_frames
+        return stream_meta.num_frames
+
+
+    def get_batch_frames(self, batch_size):
+        """
+        Returns a batch of frames based on the batch size
+        Args:
+        batch_size(int): Number of frames in the batch
+        Returns:
+        DecodedFrame[] : A list of decoded frames
+        """
+        return self.simple_decoder.get_batch_frames(batch_size)
+
+    def stop(self):
+        return self.simple_decoder.stop()
+
+
+    def get_batch_frames_by_index(self, indices):
+        """
+        Returns a batch of frames based on the indices
+        Args:
+        indices(list): A list containing the frame indices to be retrieved
+        Returns:
+        DecodedFrame[] : A list of decoded frames
+        """
+        total_frames = self.__len__()
+        validated_indices = []
+        seen = set()
+        for index in indices:
+            if 0 <= index < total_frames:
+                if index not in seen:
+                    seen.add(index)
+                    validated_indices.append(index)
+            else:
+                warnings.warn(
+                    f"Skipping index {index}: Out of valid range [0, {total_frames-1}]")
+            
+        sorted_validated_indices = sorted(validated_indices)               
+        sorted_frames = self.simple_decoder.get_batch_frames_by_index(sorted_validated_indices)
+        mapping = {val: sorted_frames[idx] for idx, val in enumerate(sorted_validated_indices)} 
+        reordered_frames = [mapping[val] for val in validated_indices]
+        return reordered_frames
+
+
+    def get_stream_metadata(self):
+        """
+        Returns stream metadata
+        Returns:
+        StreamMetadata : StreamMetadata structure with metadata info
+        """
+        stream_meta = self.simple_decoder.get_stream_metadata()
+        return stream_meta
+
+    def get_scanned_stream_metadata(self):
+        """
+        Returns stream metadata by performing entitre stream scan.
+        Returns:
+        ScannedStreamMetadata : ScannedStreamMetadata structure with
+        metadata info
+        """
+        if self.need_scanned_stream_metadata == 0:
+            raise Exception("Invalid call to funtion. Decoder was created with \
+            need_scanned_stream_metadata = 0.")
+        stream_meta = self.simple_decoder.get_scanned_stream_metadata()
+        return stream_meta
+
+    def seek_to_index(self, index):
+        """
+        Moves the demuxer marker to the specified index
+        Args:
+        index(int): The index to which the marker needs to be set
+        """
+        self.validate_index(index)
+        return self.simple_decoder.seek_to_index(index)
+
+    def get_index_from_time_in_seconds(self, time_in_seconds):
+        """
+        Gives the frame index corresponding to the time in seconds
+        Args:
+        timestamp(float): Frame timestamp
+        """
+        return self.simple_decoder.get_index_from_time_in_seconds(time_in_seconds)
+    
+    def validate_index(self, index):
+         total_frames = self.__len__()
+         if not (0 <= index < total_frames):
+            raise IndexError(f"Index {index} is out of range [0, {total_frames-1}]")
+
+    def reconfigure_decoder(self, new_source):
+        """
+        Reconfigures the current decoder to use the new source. Internally it
+        holds a cache of decoders. The best available is choosen else a new decoder is
+        created.
+        Args:
+        new_source(str): Encoded source
+        """
+        return self.simple_decoder.reconfigure_decoder(new_source)
+
+    def get_session_init_time(self):
+        """
+        Returns the session initialization time in milliseconds.
+        This is useful for performance measurement.
+        
+        Returns:
+            int64_t: Session initialization time in milliseconds
+        """
+        return self.simple_decoder.get_session_init_time()
+
+    @staticmethod
+    def set_session_count(count):
+        """
+        Sets the number of decoder sessions to be created.
+        This is useful for multi-threaded scenarios.
+        
+        Args:
+            count (int): Number of decoder sessions
+        """
+        nvc.SimpleDecoder.set_session_count(count)

PyNvVideoCodec/decoders/ThreadedDecoder.py

@@ -0,0 +1,129 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+from typing import Union
+#from  ._SimpleDecoderImpl import SimpleDecoderImpl
+import PyNvVideoCodec as nvc
+
+class ThreadedDecoder():
+    """
+     Class for decoding video in background thread. This can be used for linear access in pipeines which are
+     CPU bound. In such a pipeline this decoder offes near zero frame fetch latency.
+
+     Args:
+        enc_file_path (str): Encoded file path.
+        gpu_id (int) : gpu id on which to decode on.
+        cuda_context(pycuda._driver.Context): Cuda context under which the source is decoded
+        cuda_stream(pycuda._driver.Stream): Cuda stream used by the decoder
+        use_device_memory (bool): If set to 'True' output decoded frame is CUDeviceptr wrapped in CUDA Array Interface else its Host memory.
+        max_width(int): maximum width that the decoder must support
+        max_height(int): maximum height that the decoder must support
+        need_scanned_stream_metadata(bool): If set to 'True', the stream metadata will be collected by going through each of the packets. This
+        runs on a different thread and its running time depends on the total size of input stream.
+        decoder_cache_size(int): LRU cache size for the number of decoders to cache.
+        output_color_type (OutputColorType): Output format type of the decoded frames. By default it is OutputColorType::NATIVE which
+        implies decoded output is returned in native format(NV12, YUV444 etc.). Other supported values are OutputColorType::RGB(which implies
+        the decoded output is converted to interleaved RGB(HWC)) and OutputColorType::RGBP(which implies decoded output is converted to planar
+        RGB(CHW))
+        start_frame (int): Frame number to start decoding from (uses seeking)
+        enableDecodeStats (bool): If set to 'True', decode statistics will be available for each decoded frame. Default is False.
+    """
+    def __init__(self, enc_file_path, buffer_size,
+                 gpu_id = 0, cuda_context = 0,
+                 cuda_stream = 0, use_device_memory = True,
+                 max_width = 0,
+                 max_height = 0,
+                 need_scanned_stream_metadata = 0,
+                 decoder_cache_size = 4,
+                 output_color_type = nvc.OutputColorType.NATIVE,
+                 start_frame = 0,
+                 enableDecodeStats = False):
+        self.buffer_size = buffer_size
+        self.need_scanned_stream_metadata = need_scanned_stream_metadata
+        self.start_frame = start_frame
+        self.threaded_decoder = nvc.CreateThreadedDecoder(enc_file_path, buffer_size, gpu_id,
+                                                cuda_context, cuda_stream,
+                                                use_device_memory, max_width,
+                                                max_height, need_scanned_stream_metadata,
+                                                decoder_cache_size, output_color_type,
+                                                start_frame, enableDecodeStats)
+    
+    def __len__(self):
+        stream_meta = self.threaded_decoder.get_stream_metadata()
+        if stream_meta.num_frames == 0 and self.need_scanned_stream_metadata == True:
+            scanned_stream_data = self.threaded_decoder.get_scanned_stream_metadata()
+            return scanned_stream_data.num_frames
+        return stream_meta.num_frames
+
+    def get_batch_frames(self, batch_size):
+        """
+        Returns a batch of frames based on the batch size
+        Args:
+        batch_size(int): Number of frames in the batch
+        Returns:
+        DecodedFrame[] : A list of decoded frames
+        """
+        if batch_size > self.buffer_size:
+            raise Exception(f"batch_size cannot be greater than buffer_size. \
+            Got batch_size = {batch_size} whereas buffer_size = {self.buffer_size}")
+        return self.threaded_decoder.get_batch_frames(batch_size)
+
+    def end(self):
+        return self.threaded_decoder.end()
+
+
+    def get_stream_metadata(self):
+        """
+        Returns stream metadata      
+        Returns:
+        StreamMetadata : StreamMetadata structure with metadata info
+        """
+        stream_meta = self.threaded_decoder.get_stream_metadata()
+        return stream_meta
+    
+    def get_scanned_stream_metadata(self):
+        """
+        Returns stream metadata by performing entitre stream scan.     
+        Returns:
+        ScannedStreamMetadata : ScannedStreamMetadata structure with
+        metadata info
+        """
+        if self.need_scanned_stream_metadata == 0:
+            raise Exception("Invalid call to funtion. Decoder was created with \
+            need_scanned_stream_metadata = 0.")
+        stream_meta = self.threaded_decoder.get_scanned_stream_metadata()
+        return stream_meta
+    
+    def reconfigure_decoder(self, new_source, start_frame=0):
+        """
+        Reconfigures the current decoder to use the new source and optionally
+        start from a specific frame. Internally it holds a cache of decoders.
+        The best available is chosen else a new decoder is created.
+        
+        Args:
+            new_source (str): Path to new encoded video file
+            start_frame (int): Frame number to start decoding from (default 0).
+                              Uses seeking to efficiently skip to the target frame.
+        """
+        self.start_frame = start_frame
+        return self.threaded_decoder.reconfigure_decoder(new_source, start_frame)