PyNvVideoCodec 2.0.0__cp313-cp313-win_amd64.whl

samples/SimpleDecoder/SubsamplingAndReconfigure.py

@@ -0,0 +1,341 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 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.
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+import numpy as np
+import pycuda.driver as cuda
+import PyNvVideoCodec as nvc
+from os.path import join, dirname, abspath
+
+# Add the parent directory to Python path in a way that works from any working directory
+current_dir = dirname(abspath(__file__))
+parent_dir = dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from Utils import cast_address_to_1d_bytearray
+
+
+class CUDAInitializationError(Exception):
+    """Exception raised when CUDA initialization fails."""
+    def __init__(self, message: str, gpu_id: int):
+        self.message = message
+        self.gpu_id = gpu_id
+        super().__init__(f"{message} (GPU ID: {gpu_id})")
+
+
+class SubsamplingAndReconfigure:
+    """
+    A class that handles video frame subsampling and decoder reconfiguration.
+    
+    This class provides functionality to:
+    1. Extract frames from videos at specified target frame rates
+    2. Reuse the same decoder instance for multiple video files
+    3. Verify decoded frames against golden reference files
+    4. Save decoded frames in YUV format
+    """
+    
+    def __init__(self, create_cuda: bool, gpu_id: int) -> None: 
+        """
+        Initialize the SubsamplingAndReconfigure instance.
+        
+        Args:
+            create_cuda: If True, performs CUDA initialization in the sample app
+            gpu_id: ID of the GPU to use
+            
+        Raises:
+            CUDAInitializationError: If CUDA initialization fails due to invalid GPU ID
+        """
+        self.simple_decoder: Optional[nvc.SimpleDecoder] = None
+        self.cuda_ctx: Optional[cuda.Context] = None
+        self.cuda_stream: Optional[cuda.Stream] = None
+        self.cuda_device: Optional[cuda.Device] = None
+        self.gpu_id: int = gpu_id
+
+        if create_cuda:
+            try:
+                device_id = self.gpu_id
+                self.cuda_device = cuda.Device(device_id)
+                self.cuda_ctx = self.cuda_device.retain_primary_context()
+            except Exception as e:
+                raise CUDAInitializationError(str(e), gpu_id)
+
+    def _process_frame_data(self, frame, decoded_frame_size: int, use_device_memory: bool) -> np.ndarray:
+        """
+        Process frame data from either device or host memory.
+        
+        Args:
+            frame: Frame object to process
+            decoded_frame_size: Size of the frame in bytes
+            use_device_memory: Whether to fetch frame data from device memory
+            
+        Returns:
+            numpy.ndarray: Processed frame data
+        """
+        reference = np.ndarray(shape=decoded_frame_size, dtype=np.uint8)
+        luma_base_addr = frame.GetPtrToPlane(0)
+        
+        if use_device_memory:
+            cuda.memcpy_dtoh(reference, luma_base_addr)
+        else:
+            reference = cast_address_to_1d_bytearray(
+                base_address=luma_base_addr,
+                size=decoded_frame_size
+            )
+        
+        return reference
+
+    def verify(self, input_file_name: str, indices_list: List[int], 
+              target_frames: List[nvc.DecodedFrame], decoded_frame_size: int, 
+              use_device_memory: bool) -> bool:
+        """
+        Verify decoded frames against a golden reference YUV file.
+        
+        The golden file should be generated using the Decode sample application and follow
+        the naming convention: <base_name_of_input_file>_golden.yuv
+        
+        Args:
+            input_file_name: Base name to derive the golden file name
+            indices_list: List of frame indices to verify
+            target_frames: Decoded frame objects
+            decoded_frame_size: Size of each decoded frame in bytes
+            use_device_memory: Whether to fetch frame data from device memory
+            
+        Returns:
+            bool: True if all frames match the golden reference, False otherwise
+        """
+        golden_file = f"{input_file_name}_golden.yuv"
+        matching = True
+        
+        try:
+            with open(golden_file, "rb") as testfile:
+                for i, frame in zip(indices_list, target_frames):
+                    testfile.seek(i * decoded_frame_size, 0)
+                    golden = testfile.read(decoded_frame_size)
+                    npgolden = np.frombuffer(golden, dtype=np.uint8)
+                    
+                    reference = self._process_frame_data(frame, decoded_frame_size, use_device_memory)
+                    
+                    if not (npgolden == reference).all():
+                        matching = False
+                        print(f"Reference for frame {i} does not match golden file")
+        except FileNotFoundError:
+            print(f"Warning: Golden reference file {golden_file} not found")
+            matching = False
+        
+        return matching
+
+
+    def _initialize_decoder(self, input_file_path: str, create_cuda: bool, 
+                          use_device_memory: bool) -> None:
+        """
+        Initialize or reconfigure the decoder.
+        
+        Args:
+            input_file_path: Path to the input video file
+            create_cuda: Whether to create CUDA context and stream
+            use_device_memory: Whether to use device memory for frame processing
+        """
+        try:
+            if self.simple_decoder is None:
+                if create_cuda:
+                    print("Initializing CUDA in the sample application...")
+                    self.cuda_stream = cuda.Stream()
+                    self.simple_decoder = nvc.SimpleDecoder(
+                        input_file_path,
+                        gpu_id=self.gpu_id,
+                        cuda_context=self.cuda_ctx.handle,
+                        cuda_stream=self.cuda_stream.handle,
+                        use_device_memory=use_device_memory
+                    )
+                else:
+                    print("Using default CUDA initialization...")
+                    self.simple_decoder = nvc.SimpleDecoder(
+                        input_file_path,
+                        gpu_id=self.gpu_id,
+                        use_device_memory=use_device_memory
+                    )
+            else:
+                print("Reconfiguring existing decoder...")
+                self.simple_decoder.reconfigure_decoder(input_file_path)
+        except Exception as e:
+            print(f"Error initializing decoder: {e}")
+
+    def sub_sampling(self, input_file_path: str, target_fps: float, create_cuda: bool, 
+                    use_device_memory: bool, verify_with_golden_yuv: int = 0) -> None:
+        """
+        Extract frames from a video at a specified target frame rate.
+        
+        This method calculates which frames to extract to achieve the desired frame rate,
+        creates batches of frame indices (up to 8 frames per batch) for efficient processing,
+        and optionally verifies the output against a golden reference file.
+        
+        Args:
+            input_file_path: Path to the input video file
+            target_fps: Desired output frame rate in frames per second
+            create_cuda: If True, performs CUDA initialization in the sample app
+            use_device_memory: Whether to use device memory for frame processing
+            verify_with_golden_yuv: If 1, verifies output against golden reference file
+            
+        Example:
+            If video_fps = 30, target_fps = 10, and total_frames = 100:
+            - Will extract every 3rd frame (30/10 = 3)
+        """
+        try:
+            if create_cuda and self.cuda_ctx is not None:
+                self.cuda_ctx.push()
+
+            self._initialize_decoder(input_file_path, create_cuda, use_device_memory)
+
+            # Get video metadata
+            metadata = self.simple_decoder.get_stream_metadata()
+            total_frames = metadata.num_frames
+            video_fps = metadata.average_fps
+
+            print(f"Video FPS = {video_fps}, Total Frames = {total_frames}")
+            
+            # Calculate frame indices for target FPS
+            step = int(video_fps / target_fps)
+            step_list = list(range(0, total_frames, step))
+            
+            # Split into batches of up to 8 frames
+            step_list_of_lists = [step_list[i:i + 8] for i in range(0, len(step_list), 8)]
+
+            input_file_name = os.path.splitext(os.path.basename(input_file_path))[0]
+            matching = True
+            
+            # Open output file once for all batches
+            dec_file_path = f"{str(input_file_name)}.yuv"
+            with open(dec_file_path, "wb") as decFile:
+                # Process each batch
+                for batch_indices in step_list_of_lists:
+                    batch_frames = self.simple_decoder.get_batch_frames_by_index(batch_indices)
+                    
+                    if verify_with_golden_yuv:
+                        matching = (matching and self.verify(
+                            input_file_name,
+                            batch_indices,
+                            batch_frames,
+                            batch_frames[0].framesize(),
+                            use_device_memory
+                        ))
+                    
+                    # Save frames to the already open file
+                    for frame in batch_frames:
+                        decoded_frame_size = frame.framesize()
+                        reference = self._process_frame_data(frame, decoded_frame_size, use_device_memory)
+                        decFile.write(bytearray(reference))
+
+            if verify_with_golden_yuv and matching:
+                print(f"All frames match golden reference for {input_file_name}.yuv")
+            
+            if create_cuda and self.cuda_ctx is not None:
+                self.cuda_ctx.pop()
+            
+            print(f"Frames saved successfully in {input_file_name}.yuv\n")
+        
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+            if create_cuda and self.cuda_ctx is not None:
+                self.cuda_ctx.pop()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This sample application demonstrates reusing the same decoder instance "
+                   "for subsampling multiple video files using Simple Decoder."
+    )
+
+    parser.add_argument(
+        "-i", "--input_file_list",
+        type=Path,
+        default=join(current_dir, "fileLists.txt"),
+        help="Text file containing video file paths, one per line. "
+             "Each line should contain the absolute or relative path to a video file. "
+             "Default: fileLists.txt in the same directory"
+    )
+    
+    parser.add_argument(
+        "-fps", "--target_fps",
+        default=2,
+        type=int,
+        help="Desired output frame rate in frames per second. Default is 2."
+    )
+
+    parser.add_argument(
+        "-c", "--create_cuda",
+        type=int,
+        choices=[0, 1],
+        default=1,
+        help="Set to 1 to enable CUDA stream and context, 0 for using default initializations. Default is 1."
+    )
+
+    parser.add_argument(
+        "-d", "--use_device_memory",
+        choices=[0, 1],
+        default=1,
+        type=int,
+        help="Decoder output surface is in device memory (1) else in host memory (0). Default is 1."
+    )
+    
+    parser.add_argument(
+        "-v", "--verify_with_golden_yuv",
+        choices=[0, 1],
+        default=0,
+        type=int,
+        help="Set to 1 to enable verification against a golden YUV file; default is 0."
+    )
+
+    parser.add_argument(
+        "-g", "--gpu_id",
+        type=int,
+        default=0,
+        help="GPU ID to use. Default is 0."
+    )   
+
+    args = parser.parse_args()
+    
+    try:
+        simple_dec_reconfigure = SubsamplingAndReconfigure(args.create_cuda, args.gpu_id)
+
+        with open(args.input_file_list, 'r') as file:
+            for line in file:
+                if line.strip():
+                    input_file_path = line.strip()
+                    simple_dec_reconfigure.sub_sampling(
+                        input_file_path,
+                        args.target_fps,
+                        args.create_cuda,
+                        args.use_device_memory,
+                        args.verify_with_golden_yuv
+                    )
+    except CUDAInitializationError as e:
+        print(f"Error initializing CUDA: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        sys.exit(1)

samples/SimpleDecoder/fileLists.txt

@@ -0,0 +1,4 @@
+humming_bird_1s_keyframes_only_no_audio.mp4
+reordered.mp4
+mandelbrot_1920x1080_120s_60fps_600gop_libx264_yuv420p.mp4
+

samples/SimpleDecoder/segments.txt

@@ -0,0 +1,3 @@
+0.3 0.8
+2 4
+3 8

samples/SimpleDecoder/timeListInSeconds.txt

@@ -0,0 +1,5 @@
+0.2
+0.4
+0.6
+0.8
+0.9

samples/SimpleDecoder/transcode_config.json

@@ -0,0 +1,6 @@
+{
+    "codec" : "h264",
+    "preset" : "P3",
+    "tuning_info" : "high_quality",
+    "bf" : "3"
+}

samples/Utils.py

@@ -0,0 +1,290 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 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.
+
+import sys
+import logging
+
+from struct import pack
+import sys
+import os
+import argparse
+from pathlib import Path
+from enum import Enum
+
+import pycuda.driver as cuda
+import PyNvVideoCodec as nvc
+import numpy as np
+from pycuda.compiler import SourceModule
+import ctypes as C
+
+import pycuda.autoinit as context
+import json
+
+from contextlib import contextmanager
+
+import io
+import tempfile
+
+SERVICE_LOGGING_FORMAT = (
+        "[{filename:s}][{funcName:s}:{lineno:d}]" + "[{levelname:s}] {message:s}"
+)
+SERVICE_LOGGING_STREAM = sys.stdout
+
+
+def get_logger(logger_name, log_level="info"):
+    SERVICE_LOGGING_LEVEL = getattr(logging, log_level.upper(), None)
+
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(SERVICE_LOGGING_LEVEL)
+    ch = logging.StreamHandler(SERVICE_LOGGING_STREAM)
+    formatter = logging.Formatter(SERVICE_LOGGING_FORMAT, style="{")
+    ch.setFormatter(formatter)
+    ch.setLevel(SERVICE_LOGGING_LEVEL)
+    logger.addHandler(ch)
+    logger.propagate = False
+
+    return logger
+
+
+logger = get_logger(__file__)
+
+
+def cast_address_to_1d_bytearray(base_address, size):
+    return np.ctypeslib.as_array(C.cast(base_address, C.POINTER(C.c_uint8)),
+                                 shape=(size,))
+
+
+from contextlib import contextmanager
+import ctypes
+import io
+import os, sys
+import tempfile
+
+class AppCAI:
+    def __init__(self, shape, stride, typestr, gpualloc):
+        shape_int = tuple([int(x) for x in shape])
+        stride_int = tuple([int(x) for x in stride])
+        self.__cuda_array_interface__ = {"shape": shape_int, "strides": stride_int, "data": (int(gpualloc), False),
+                                         "typestr": typestr, "version": 3}
+
+
+class AppFrame:
+    def __init__(self, width, height, format):
+        if format == "NV12":
+            nv12_frame_size = int(width * height * 3 / 2)
+            self.gpuAlloc = cuda.mem_alloc(nv12_frame_size)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            chroma_alloc = int(self.gpuAlloc) + width * height
+            self.cai.append(AppCAI((int(height / 2), int(width / 2), 2), (width, 2, 1), "|u1", chroma_alloc))
+            self.frameSize = nv12_frame_size
+        if format == "ARGB" or format == "ABGR":
+            self.frameSize = width * height * 4
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = AppCAI((height, width, 4), (4 * width, 4, 1), "|u1", self.gpuAlloc)
+        if format == "YUV444":
+            self.frameSize = width * height * 3
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", int(self.gpuAlloc) + width * height))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", int(self.gpuAlloc) + 2 * width * height))
+        if format == "YUV420":
+            self.frameSize = int(width * height * 3 / 2)
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(
+                AppCAI((height / 2, width / 2, 1), (width / 2, 1, 1), "|u1", int(self.gpuAlloc) + width * height))
+            self.cai.append(AppCAI((height / 2, width / 2, 1), (width / 2, 1, 1), "|u1",
+                                   int(self.gpuAlloc) + width * height + width / 2 * height / 2))
+        if format == "P010" or format == "YUV420_10BIT":
+            self.frameSize = int(width * height * 3 / 2 * 2)
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            chroma_alloc = int(self.gpuAlloc) + width * height * 2
+            self.cai.append(AppCAI((int(height / 2), int(width / 2), 2), (width*2, 2, 1), "|u2", chroma_alloc))
+        if format == "P016" or format == "YUV444_16BIT":
+            self.frameSize = int(width * height * 3 * 2)
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            self.cai.append(
+                AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 2))
+            self.cai.append(
+                AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 4))
+        
+        if format == "NV16":
+            self.frameSize = width * height * 2
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1 ), "|u1", int(self.gpuAlloc) + width * height))
+
+        if format == "P210":
+            self.frameSize = width * height * 2 * 2
+            self.gpuAlloc = cuda.mem_alloc(self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 2))
+
+        
+
+    def cuda(self):
+        return self.cai
+
+
+class AppFramePerf:
+    def __init__(self, width, height, format, dataptr, frame_idx):
+        if format == "NV12":
+            nv12_frame_size = int(width * height * 3 / 2)
+            self.gpuAlloc = int(dataptr) + (frame_idx * nv12_frame_size)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            chroma_alloc = int(self.gpuAlloc) + width * height
+            self.cai.append(AppCAI((int(height / 2), int(width / 2), 2), (width, 2, 1), "|u1", chroma_alloc))
+            self.frameSize = nv12_frame_size
+        if format == "ARGB" or format == "ABGR":
+            self.frameSize = width * height * 4
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = AppCAI((height, width, 4), (4 * width, 4, 1), "|u1", self.gpuAlloc)
+        if format == "YUV444":
+            self.frameSize = width * height * 3
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", int(self.gpuAlloc) + width * height))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", int(self.gpuAlloc) + 2 * width * height))
+        if format == "YUV420":
+            self.frameSize = int(width * height * 3 / 2)
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(
+                AppCAI((height / 2, width / 2, 1), (width / 2, 1, 1), "|u1", int(self.gpuAlloc) + width * height))
+            self.cai.append(AppCAI((height / 2, width / 2, 1), (width / 2, 1, 1), "|u1",
+                                   int(self.gpuAlloc) + width * height + width / 2 * height / 2))
+        if format == "P010" or format == "YUV420_10BIT":
+            self.frameSize = int(width * height * 3 / 2 * 2)
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            chroma_alloc = int(self.gpuAlloc) + width * height * 2
+            self.cai.append(AppCAI((int(height / 2), int(width / 2), 2), (width*2, 2, 1), "|u2", chroma_alloc))
+        if format == "P016" or format == "YUV444_16BIT":
+            self.frameSize = int(width * height * 3 * 2)
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            self.cai.append(
+                AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 2))
+            self.cai.append(
+                AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 4))
+        if format == "NV16":
+            self.frameSize = width * height * 2
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width, 1, 1), "|u1", int(self.gpuAlloc) + width * height))
+        if format == "P210":
+            self.frameSize = width * height * 2 * 2
+            self.gpuAlloc = int(dataptr) + (frame_idx * self.frameSize)
+            self.cai = []
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", self.gpuAlloc))
+            self.cai.append(AppCAI((height, width, 1), (width * 2, 2, 1), "|u2", int(self.gpuAlloc) + width * height * 2))
+
+    def cuda(self):
+        return self.cai
+
+
+def FetchGPUFrame(input_frame_list, GetCPUFrameFunc, num_frames):
+    for i in range(num_frames):
+        n = i % len(input_frame_list)
+        raw_frame = GetCPUFrameFunc()
+        if not raw_frame.size:
+            return
+        cuda.memcpy_htod(input_frame_list[n].gpuAlloc, raw_frame)
+        cuda.Context.synchronize()
+        yield input_frame_list[n]
+
+
+
+def FetchCPUFrame(dec_file, frame_size):
+    def InnerFunc():
+        return np.fromfile(dec_file, np.uint8, count=frame_size)
+
+    return InnerFunc
+
+def GetChromaFormat(demuxer):
+    strFormat = "NV12"
+
+    bitdepth = demuxer.BitDepth()
+    chromaformat = demuxer.ChromaFormat()
+
+    #print (" bitdepth : " + str(bitdepth))
+    #print (" chromaformat : " + str(chromaformat))
+    
+    if str(chromaformat)  == str("cudaVideoChromaFormat.444"):
+        if bitdepth == 10:
+            strFormat = "YUV444_10BIT"
+        elif bitdepth == 16:
+            strFormat = "YUV444_16BIT"
+        elif bitdepth == 12:
+            strFormat = "YUV444_16BIT"            
+            print ("Unsupported bitdepth for YUV444 12BIT. It will be treated as YUV444_16BIT" )
+        elif bitdepth == 8:
+            strFormat = "YUV444"
+    elif str(chromaformat)  == str("cudaVideoChromaFormat.420"):
+        if bitdepth == 8:
+            strFormat = "NV12"
+        elif bitdepth == 10:
+            strFormat = "YUV420_10BIT"
+        elif bitdepth == 16:
+            strFormat = "P016"
+    elif str(chromaformat)  == str("cudaVideoChromaFormat.422"):
+        if bitdepth == 10:
+            strFormat = "YUV422_10BIT"
+        elif bitdepth == 16:
+            strFormat = "YUV422_16BIT"
+        elif bitdepth == 8:
+            strFormat = "YUV422"
+
+    #print (" strFormat : " + str(strFormat))
+
+    return strFormat
+
+
+def GetVideoCodec(demuxer):
+    codec=str(demuxer.GetNvCodecId())
+    #print (" codec : " + str(codec))
+    
+    # Common prefix to remove
+    common_prefix = "cudaVideoCodec."
+    
+    strCodec = codec.removeprefix(common_prefix)
+
+    #print (" codec : " + str(strCodec))
+    return str(strCodec)
+
+

samples/encode_config.json

@@ -0,0 +1,16 @@
+{
+	"gpu_id": 0,
+    "preset" : "P3",
+    "tuning_info" : "high_quality",
+    "rc": "vbr",
+    "fps"  : 30,
+    "gop" : 250,
+    "bf" : 3,
+    "bitrate" : "10M",
+    "maxbitrate" : 0,
+    "vbvinit" : 0,
+    "vbvbufsize" : 0,
+    "qmin"         : "0,0,0",
+    "qmax"         : "0,0,0",
+    "initqp"       : "0,0,0"
+}

samples/encode_config_lowlatency.json

@@ -0,0 +1,11 @@
+{
+  "preset": "P3",
+  "tuning_info": "low_latency",
+  "rc": "cbr",
+  "fps": 30,
+  "bf": 1,
+  "multipass":"fullres",
+  "bitrate": 3000000,
+  "maxbitrate": 3000000,
+  "vbvbufsize": 100000
+}