PyNvVideoCodec 2.2.1__cp313-cp313-win_arm64.whl

samples/advanced/decode_perf.py

@@ -0,0 +1,299 @@
+# 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.
+
+'''
+This sample demonstrates how to measure video decoding performance by utilizing multiple NVDEC engines in parallel.
+
+It shows how to:
+1. Maximize GPU utilization using multiple decoder instances
+2. Measure decoding performance (FPS) accurately for different modes
+3. Scale decoding across available NVDEC engines
+4. Use either threading or multiprocessing for parallelization
+5. Track and report performance metrics
+
+The sample implements two parallel execution modes:
+Thread Mode:
+- Better for: Higher performance (lower overhead), shared memory access (decoder instances can share the same GPU memory)
+- Ideal when: Running on same GPU, memory constraints exist
+- Benefits: Faster initialization, lower memory footprint, cuda context is shared between decoder instances
+- Note: Python GIL is not a bottleneck as decoder operations are GIL-free
+
+Process Mode:
+- Better for: Complete isolation between decoder instances (each decoder instance has its own GPU memory)
+- Ideal when: Running on multiple GPUs, need memory isolation
+- Benefits: Better fault isolation, independent memory management
+- Tradeoff: Higher memory usage, longer initialization time, cuda context is not shared between decoder instances
+
+Usage: python decode_perf.py -i <input_file> -n <num_instances> -m <mode>
+Example: python decode_perf.py -i input.mp4 -n 4 -m thread
+
+Arguments:
+  -i: Input video file
+  -n: Number of parallel instances (default: 1)
+  -m: Execution mode: 'thread' or 'process' (default: thread)
+  -d: Use device memory (1) or host memory (0) (default: 1)
+  -g: GPU ID to use (default: 0)
+  -f: Number of frames to decode per instance (optional)
+
+Note: This performance testing app does not write output files.
+      It only measures decoding throughput.
+'''
+
+import sys
+import os
+import time
+import threading
+import multiprocessing
+from pathlib import Path
+import PyNvVideoCodec as nvc
+from os.path import join, dirname, abspath
+
+# Set multiprocessing start method at the very beginning
+# 'spawn' is required for CUDA operations and works consistently across platforms
+if __name__ == '__main__':
+    multiprocessing.set_start_method('spawn')
+
+# 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)
+
+# Import utilities for decoding
+from utils.decode_parser import parse_multi_instance_args
+
+
+# Global variables for tracking performance metrics in threading mode
+total_fps = 0
+num_frames = 0
+perf_lock = threading.Lock()
+
+def decode_thread(gpu_id, enc_file_path, frame_count=None):
+    """
+    Function to decode media file and measure performance in a thread.
+    
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be decoded
+        frame_count (int, optional): Maximum number of frames to decode
+    """
+    global total_fps, num_frames
+    
+    try:
+        # Normalize frame count
+        decode_all = frame_count is None or frame_count <= 0
+        if decode_all:
+            print(f"Thread {threading.current_thread().name}: Decoding all available frames")
+            frame_count = None
+
+        nv_dmx = nvc.CreateDemuxer(filename=enc_file_path)
+        nv_dec = nvc.CreateDecoder(
+            gpuid=gpu_id,
+            codec=nv_dmx.GetNvCodecId(),
+            usedevicememory=True,
+            bWaitForSessionWarmUp=True
+        )
+        
+        start = time.perf_counter()
+        num_decoded_frames = 0
+
+        for packet in nv_dmx:
+            for _ in nv_dec.Decode(packet):
+                num_decoded_frames += 1
+                if frame_count is not None and num_decoded_frames >= frame_count:
+                    print(f"Thread {threading.current_thread().name}: Successfully decoded requested {frame_count} frames")
+                    break
+            
+            if frame_count is not None and num_decoded_frames >= frame_count:
+                break
+        
+        # If we get here, we've decoded all available frames
+        if frame_count is not None and num_decoded_frames < frame_count:
+            print(f"Thread {threading.current_thread().name}: Warning: Video ended before reaching requested frame count. Requested: {frame_count}, Decoded: {num_decoded_frames}")
+        else:
+            print(f"Thread {threading.current_thread().name}: Successfully decoded all {num_decoded_frames} frames")
+            
+        # Calculate accurate elapsed time by subtracting initialization time
+        elapsed_time = time.perf_counter() - start
+        init_time = nv_dec.GetSessionInitTime() / 1000.0  # Convert to seconds
+        elapsed_time -= init_time
+        
+        fps = num_decoded_frames / elapsed_time
+        print(f"Thread {threading.current_thread().name}: {num_decoded_frames} frames in {elapsed_time:.2f}s ({fps:.2f} FPS)")
+        
+        # Update performance metrics with thread-safe operation
+        with perf_lock:
+            global total_fps, num_frames
+            total_fps += fps
+            num_frames += num_decoded_frames
+        
+    except Exception as e:
+        print(f"Thread {threading.current_thread().name} error: {e}")
+
+def decode_process(gpu_id, enc_file_path, frame_count=None, result_queue=None):
+    """
+    Function to decode media file and measure performance in a separate process.
+    
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be decoded
+        frame_count (int, optional): Maximum number of frames to decode
+        result_queue (Queue): Queue to store performance results
+    """
+    try:
+        # Normalize frame count
+        decode_all = frame_count is None or frame_count <= 0
+        if decode_all:
+            print(f"Process {multiprocessing.current_process().name}: Decoding all available frames")
+            frame_count = None
+
+        nv_dmx = nvc.CreateDemuxer(filename=enc_file_path)
+        nv_dec = nvc.CreateDecoder(
+            gpuid=gpu_id,
+            codec=nv_dmx.GetNvCodecId(),
+            usedevicememory=True,
+        )
+        
+        start = time.perf_counter()
+        num_decoded_frames = 0
+
+        for packet in nv_dmx:
+            for _ in nv_dec.Decode(packet):
+                num_decoded_frames += 1
+                if frame_count is not None and num_decoded_frames >= frame_count:
+                    print(f"Process {multiprocessing.current_process().name}: Successfully decoded requested {frame_count} frames")
+                    break
+            
+            if frame_count is not None and num_decoded_frames >= frame_count:
+                break
+        
+        # If we get here, we've decoded all available frames
+        if frame_count is not None and num_decoded_frames < frame_count:
+            print(f"Process {multiprocessing.current_process().name}: Warning: Video ended before reaching requested frame count. Requested: {frame_count}, Decoded: {num_decoded_frames}")
+        else:
+            print(f"Process {multiprocessing.current_process().name}: Successfully decoded all {num_decoded_frames} frames")
+            
+        elapsed_time = time.perf_counter() - start
+        fps = num_decoded_frames / elapsed_time
+        print(f"Process {multiprocessing.current_process().name}: {num_decoded_frames} frames in {elapsed_time:.2f}s ({fps:.2f} FPS)")
+        
+        # Send results back through queue
+        if result_queue:
+            result_queue.put((fps, num_decoded_frames))
+        
+    except Exception as e:
+        print(f"Process {multiprocessing.current_process().name} error: {e}")
+        if result_queue:
+            result_queue.put((0, 0))  # Send zero metrics on error
+
+def run_parallel_decode(mode, num_instances, gpu_id, enc_file_path, frame_count=None):
+    """
+    Run parallel video decoding using either threads or processes.
+    
+    Parameters:
+        mode (str): 'thread' or 'process' to specify parallel execution mode
+        num_instances (int): Number of parallel decode instances to run
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be decoded
+        frame_count (int, optional): Maximum number of frames to decode per instance
+    """
+    global total_fps, num_frames
+    total_fps = 0
+    num_frames = 0
+    
+    start_time = time.perf_counter()
+    
+    if mode == 'thread':
+        # Threading mode
+        threads = []
+        nvc.PyNvDecoder.SetSessionCount(num_instances)
+        
+        for i in range(num_instances):
+            t = threading.Thread(
+                target=decode_thread,
+                args=(gpu_id, enc_file_path, frame_count)
+            )
+            print(f"Starting decode thread {i+1}/{num_instances}")
+            t.start()
+            threads.append(t)
+
+        for t in threads:
+            t.join()
+            
+        # Performance metrics are collected via global variables
+        
+    else:  # mode == 'process'
+        # Multiprocessing mode
+        processes = []
+        result_queue = multiprocessing.Queue()
+        
+        for i in range(num_instances):
+            p = multiprocessing.Process(
+                target=decode_process,
+                args=(gpu_id, enc_file_path, frame_count, result_queue)
+            )
+            print(f"Starting decode process {i+1}/{num_instances}")
+            p.start()
+            processes.append(p)
+
+        for p in processes:
+            p.join()
+            
+        # Collect results from queue
+        while not result_queue.empty():
+            fps, frames = result_queue.get()
+            total_fps += fps
+            num_frames += frames
+    
+    total_time = time.perf_counter() - start_time
+    
+    # Print performance summary
+    print("\n=== Performance Summary ===")
+    print(f"Mode: {mode.capitalize()}")
+    print(f"Number of instances: {num_instances}")
+    print(f"Total frames decoded: {num_frames}")
+    print(f"Total FPS: {total_fps:.2f}")
+    print(f"Average FPS per instance: {total_fps/num_instances:.2f}")
+    print(f"Total wall time: {total_time:.2f}s")
+    print("========================\n")
+
+if __name__ == "__main__":
+    
+    args = parse_multi_instance_args()
+    
+    print("=" * 60)
+    print("Configuration:")
+    print(f"Input: {args.encoded_file_path}")
+    print(f"GPU ID: {args.gpu_id}")
+    print(f"Mode: {args.mode.upper()}")
+    print(f"Number of Instances: {args.num_instances}")
+    print(f"Frame Count: {args.frame_count if args.frame_count else 'All frames'}")
+    print("=" * 60)
+
+    run_parallel_decode(
+        mode=args.mode,
+        num_instances=args.num_instances,
+        gpu_id=args.gpu_id,
+        enc_file_path=args.encoded_file_path,
+        frame_count=args.frame_count
+    )

samples/advanced/decode_reconfigure.py

@@ -0,0 +1,184 @@
+# 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.
+
+'''
+This sample demonstrates dynamic decoder reconfiguration for handling resolution changes.
+It shows how to:
+1. Create a decoder that can handle multiple resolutions
+2. Switch between input streams with different dimensions
+3. Reconfigure decoder parameters on the fly
+4. Handle decoder state during reconfiguration
+
+
+Usage: python decode_reconfigure.py -i1 <input1> -i2 <input2> -o1 <output1> -o2 <output2>
+Example: python decode_reconfigure.py -i1 video1.mp4 -i2 video2.mp4
+
+Arguments:
+  -i1: First input video file
+  -i2: Second input video file (different resolution)
+  -o1: First output raw video file (default: <input1_name>.yuv)
+  -o2: Second output raw video file (default: <input2_name>.yuv)
+  -d: Use device memory (1) or host memory (0) (default: 1)
+  -g: GPU ID to use (default: 0)
+  -f: Number of frames to decode per stream (optional)
+'''
+
+import sys
+from pathlib import Path
+import PyNvVideoCodec as nvc
+from os.path import join, dirname, abspath, splitext
+
+# 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.decode_parser import parse_reconfigure_args
+from utils.Utils import get_frame_data
+
+def decode_stream(nv_dec, demuxer, output_file, use_device_memory, frame_count=None):
+    """
+    Helper function to decode a single stream and write frames to output file.
+    
+    Parameters:
+        nv_dec: NvDecoder instance
+        demuxer: Demuxer instance for the input stream
+        output_file: File object to write decoded frames to
+        use_device_memory (int): If set to 1, output decoded frame is CUDeviceptr wrapped in CUDA Array Interface
+        frame_count (int, optional): Maximum number of frames to decode. If None, 0, or negative, decode all frames.
+        
+    Returns:
+        int: Number of frames decoded
+    """
+    frames_decoded = 0
+    for packet in demuxer:
+        for decoded_frame in nv_dec.Decode(packet):
+            frame_data = get_frame_data(decoded_frame, use_device_memory)
+            output_file.write(bytearray(frame_data))
+            frames_decoded += 1
+            if frame_count is not None and frame_count > 0 and frames_decoded >= frame_count:
+                break
+        if frame_count is not None and frame_count > 0 and frames_decoded >= frame_count:
+            break
+    return frames_decoded
+
+def decode_with_reconfigure(gpu_id, enc_file_path1, enc_file_path2, dec_file_path1, dec_file_path2, use_device_memory, frame_count=None):
+    """
+    Function to decode media files with dynamic decoder reconfiguration.
+    Demonstrates switching between two different input streams with different dimensions.
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path1 (str): Path to first input encoded file
+        enc_file_path2 (str): Path to second input encoded file with different dimensions
+        dec_file_path1 (str): Path to first output file into which raw frames are stored
+        dec_file_path2 (str): Path to second output file into which raw frames are stored
+        use_device_memory (int): If set to 1, output decoded frame is CUDeviceptr wrapped in CUDA Array Interface
+        frame_count (int, optional): Maximum number of frames to decode per stream. If None, 0, or negative, decode all frames.
+    """
+    try:
+        # Create first demuxer and get stream info
+        nv_dmx1 = nvc.CreateDemuxer(filename=enc_file_path1)
+        stream1_codec = nv_dmx1.GetNvCodecId()
+        stream1_width = nv_dmx1.Width()
+        stream1_height = nv_dmx1.Height()
+        print(f"\nStream 1 info:")
+        print(f"Dimensions: {stream1_width}x{stream1_height}")
+        print(f"Codec: {stream1_codec}")
+        print(f"FPS: {nv_dmx1.FrameRate()}")
+
+        # Create second demuxer and get stream info
+        nv_dmx2 = nvc.CreateDemuxer(filename=enc_file_path2)
+        stream2_codec = nv_dmx2.GetNvCodecId()
+        stream2_width = nv_dmx2.Width()
+        stream2_height = nv_dmx2.Height()
+        print(f"\nStream 2 info:")
+        print(f"Dimensions: {stream2_width}x{stream2_height}")
+        print(f"Codec: {stream2_codec}")
+        print(f"FPS: {nv_dmx2.FrameRate()}\n")
+
+        # Create decoder
+        nv_dec = nvc.CreateDecoder(
+            gpuid=gpu_id,
+            codec=stream1_codec,
+            usedevicememory=use_device_memory,
+            maxwidth=max(stream1_width, stream2_width),
+            maxheight=max(stream1_height, stream2_height)
+        )
+        
+        # Open output files for writing decoded frames
+        with open(dec_file_path1, "wb") as decFile1, open(dec_file_path2, "wb") as decFile2:
+            # First decode stream 1
+            print("Decoding stream 1...")
+            frames_decoded = decode_stream(nv_dec, nv_dmx1, decFile1, use_device_memory, frame_count)
+            print(f"\nCompleted stream 1: {frames_decoded} frames decoded")
+            if frames_decoded > 0:
+                print(f"Decoded frames written to {dec_file_path1}\n")
+            else:
+                print("No frames were decoded from stream 1\n")
+            print("Reconfiguring decoder for stream 2...")
+
+            # Reconfigure decoder for stream 2
+            nv_dec.setReconfigParams(stream2_width, stream2_height)
+            print(f"Decoder reconfigured to dimensions: {stream2_width}x{stream2_height}\n")
+
+            # Now decode stream 2
+            print("Decoding stream 2...")
+            frames_decoded = decode_stream(nv_dec, nv_dmx2, decFile2, use_device_memory, frame_count)
+            print(f"\nCompleted stream 2: {frames_decoded} frames decoded")
+            if frames_decoded > 0:
+                print(f"Decoded frames written to {dec_file_path2}")
+            else:
+                print("No frames were decoded from stream 2")
+
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"CreateDecoder failure: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+if __name__ == "__main__":
+    args = parse_reconfigure_args(
+        "This sample application demonstrates decoder reconfiguration between two input streams with different dimensions."
+    )
+    
+    print("=" * 60)
+    print("Configuration:")
+    print(f"Input 1: {args.input_file1}")
+    print(f"Input 2: {args.input_file2}")
+    print(f"Output 1: {args.raw_file_path1}")
+    print(f"Output 2: {args.raw_file_path2}")
+    print(f"GPU ID: {args.gpu_id}")
+    print(f"Use Device Memory: {args.use_device_memory}")
+    print(f"Frame Count: {args.frame_count if args.frame_count else 'All frames'}")
+    print("=" * 60)
+
+    decode_with_reconfigure(
+        args.gpu_id,
+        args.input_file1,
+        args.input_file2,
+        args.raw_file_path1,
+        args.raw_file_path2,
+        args.use_device_memory,
+        args.frame_count
+    )

samples/advanced/decode_sei_msg.py

@@ -0,0 +1,193 @@
+# 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.
+
+'''
+This sample demonstrates how to extract and parse Supplemental Enhancement Information (SEI) from video streams.
+
+It shows how to:
+1. Access SEI messages from decoded frames and write them to a file
+2. Parse different SEI message types
+
+
+SEI messages are additional data embedded in video streams that provide supplementary information:
+- HDR/Display Metadata: Color volume, light levels, and transfer characteristics for HDR content
+- Timecode Data: Frame timing and sequence information
+- Custom Metadata: User-defined data for application-specific needs
+
+Common Use Cases:
+- Video Playback: HDR display configuration and color management
+- Content Creation: Frame accurate editing and post-processing
+- Broadcast: Timing synchronization and content identification
+- Custom Applications: Embedding application-specific metadata in the video stream
+
+
+Usage: python decode_sei_msg.py -i <input_file> -s <sei_file>
+Example: python decode_sei_msg.py -i input.mp4 -s sei_data.bin
+
+Arguments:
+  -i: Input video file
+  -s: Output SEI message file (default: sei_message.bin).
+  -st: Output SEI type message file (default: sei_type_message.bin)
+  -d: Use device memory (1) or host memory (0) (default: 1)
+  -g: GPU ID to use (default: 0)
+'''
+
+import sys
+import numpy as np
+import pickle
+import ctypes
+import argparse
+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.decode_parser import parse_sei_args
+
+from utils.sei_message_parser import (
+    TIMECODE, TIMECODEMPEG2, SEICONTENTLIGHTLEVELINFO,
+    SEIMASTERINGDISPLAYINFO, SEIALTERNATIVETRANSFERCHARACTERISTICS
+)
+
+def extract_sei_messages(gpu_id, enc_file_path, sei_file_path, sei_type_file_path, use_device_memory):
+    """
+    Function to extract SEI messages from a video file.
+
+    This function decodes a video file and extracts SEI messages, producing three output files:
+    1. sei_message.bin - Raw binary SEI messages
+    2. sei_type_message.bin - Pickled SEI type information
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be decoded
+        sei_file_path (str): Path to output file for SEI messages. Sei type message is written to sei_type_message.bin
+        sei_type_file_path (str): Path to output file for SEI type messages.
+        use_device_memory (int): If set to 1, output decoded frame is CUDeviceptr wrapped in CUDA Array Interface
+
+    Returns:
+        None
+    """
+    cuda_ctx = None
+
+    # Open files for storing SEI data
+    file_message = open(sei_file_path, "wb")
+    file_type_message = open(sei_type_file_path, "wb")
+
+    try:
+        cuda.init()
+        device_id = gpu_id
+        cuda_device = cuda.Device(device_id)  # pyright: ignore[reportAttributeAccessIssue]
+        cuda_ctx = cuda_device.retain_primary_context()
+        cuda_ctx.push()
+        cuda_stream = cuda.Stream()
+        
+        nv_dmx = nvc.CreateDemuxer(filename=enc_file_path)
+        
+        nv_dec = nvc.CreateDecoder(
+            gpuid=gpu_id,
+            codec=nv_dmx.GetNvCodecId(),
+            cudacontext=cuda_ctx.handle,
+            cudastream=cuda_stream.handle,
+            usedevicememory=use_device_memory,
+            enableSEIMessage=1
+        )
+
+        sei_message_found = False
+        print(f"FPS = {nv_dmx.FrameRate()}")
+        
+        
+        for packet in nv_dmx:
+            for decoded_frame in nv_dec.Decode(packet):
+
+                    # Process SEI messages
+                    seiMessage = decoded_frame.getSEIMessage()
+                    if seiMessage:
+                        sei_message_found = True
+                        for sei_info, sei_message in seiMessage:
+                            sei_type = sei_info["sei_type"]
+                            sei_uncompressed = sei_info["sei_uncompressed"]
+                            
+                            if sei_uncompressed == 1:
+                                buffer = (ctypes.c_ubyte * len(sei_message))(*sei_message)
+                                sei_struct = None
+                                
+                                # Handle different SEI message types
+                                if sei_type in (nvc.SEI_TYPE.TIME_CODE_H264, nvc.SEI_TYPE.TIME_CODE):
+                                    sei_struct = ctypes.cast(
+                                        buffer,
+                                        ctypes.POINTER(TIMECODEMPEG2 if nv_dmx.GetNvCodecId() == nvc.cudaVideoCodec.MPEG2 else TIMECODE)
+                                    ).contents
+                                elif sei_type == nvc.SEI_TYPE.MASTERING_DISPLAY_COLOR_VOLUME:
+                                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEIMASTERINGDISPLAYINFO)).contents
+                                elif sei_type == nvc.SEI_TYPE.CONTENT_LIGHT_LEVEL_INFO:
+                                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEICONTENTLIGHTLEVELINFO)).contents
+                                elif sei_type == nvc.SEI_TYPE.ALTERNATIVE_TRANSFER_CHARACTERISTICS:
+                                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEIALTERNATIVETRANSFERCHARACTERISTICS)).contents
+                                
+                                    
+                            file_message.write(bytearray(sei_message))
+                        pickle.dump(seiMessage, file_type_message)
+
+        if sei_message_found:
+            print(f"SEI message written to:")
+            print(f"  Binary data: {sei_file_path}")
+            print(f"  Type info: {sei_type_file_path}")
+        else:
+            print("No SEI message found")
+
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"CreateDecoder failure: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+    finally:
+        file_message.close()
+        file_type_message.close()
+        if cuda_ctx is not None:
+            cuda_ctx.pop()
+
+if __name__ == "__main__":
+    args = parse_sei_args(
+        "This sample application demonstrates extracting SEI messages from video files."
+    )
+    
+    print("=" * 60)
+    print("Configuration:")
+    print(f"Input: {args.encoded_file_path}")
+    print(f"SEI Output: {args.sei_file_path}")
+    print(f"SEI Type Output: {args.sei_type_file_path}")
+    print(f"GPU ID: {args.gpu_id}")
+    print(f"Use Device Memory: {args.use_device_memory}")
+    print("=" * 60)
+    
+    extract_sei_messages(
+        args.gpu_id,
+        args.encoded_file_path,
+        args.sei_file_path,
+        args.sei_type_file_path,
+        args.use_device_memory
+    )