PyNvVideoCodec 2.0.4__cp314-cp314-win_amd64.whl

samples/advanced/decode_from_memory_buffer.py

@@ -0,0 +1,204 @@
+# 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 buffer-based video decoding using memory chunks.
+
+This approach is useful when video data comes from memory buffers
+rather than direct file access (e.g., network streams, memory-mapped files). This saves file I/O overhead.
+
+It shows how to:
+1. Create a custom data feeder for memory-based video input
+2. Set up a demuxer that reads from memory buffers
+3. Process video data without direct file I/O
+4. Handle streaming data in chunks
+
+Key Learning Outcomes:
+1. Using callback-based demuxer for custom data sources
+2. Managing video data buffers and chunk sizes efficiently
+3. Implementing proper buffer position tracking and EOF handling
+4. Working with both device and host memory for decoded frames
+
+
+Usage: python decode_from_memory_buffer.py -i <input_file> -o <output_file>
+Example: python decode_from_memory_buffer.py -i input.mp4 -o output.yuv
+
+Arguments:
+  -i: Input video file
+  -o: Output raw video file (default: <input_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 (optional)
+
+'''
+
+
+from pathlib import Path
+import pycuda.driver as cuda
+import PyNvVideoCodec as nvc
+import pycuda.autoinit as context
+import sys
+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)
+
+# Import utilities for decoding
+from utils.decode_parser import parse_decode_args
+from utils.Utils import get_frame_data
+
+
+
+class VideoStreamFeeder:
+    """
+    Class to handle feeding video data in chunks to the demuxer.
+    
+    This class reads a video file into memory and provides a method to feed
+    chunks of data to the demuxer buffer.
+    """
+    def __init__(self, file_path):
+        """
+        Initialize the VideoStreamFeeder with a video file.
+
+        Args:
+            file_path (str): Path to the video file to be read
+        """
+        with open(file_path, 'rb') as f:
+            self.video_buffer = bytearray(f.read())
+        self.current_pos = 0
+        self.bytes_remaining = len(self.video_buffer)
+        self.chunk_size = 0
+
+    def feed_chunk(self, demuxer_buffer):
+        """
+        Feed next chunk of video data to demuxer buffer.
+
+        Args:
+            demuxer_buffer: Pre-allocated buffer provided by demuxer
+
+        Returns:
+            int: Number of bytes copied to buffer, 0 if no more data
+        """
+        buffer_capacity = len(demuxer_buffer)
+        
+        if self.bytes_remaining < buffer_capacity:
+            self.chunk_size = self.bytes_remaining
+        else:
+            self.chunk_size = buffer_capacity
+
+        if self.chunk_size == 0:
+            return 0
+
+        demuxer_buffer[:] = self.video_buffer[self.current_pos:self.current_pos + self.chunk_size]
+
+        self.current_pos += self.chunk_size
+        self.bytes_remaining -= self.chunk_size
+        return self.chunk_size
+
+
+def decode_from_byte_array(input_file, yuv_file, use_device_memory, gpu_id, frame_count=None):
+    """
+    Implement buffer-based pipeline that reads the input file in chunks.
+
+    This function demonstrates how to decode video by processing data directly
+    from memory buffers instead of reading from disk.
+
+    Parameters:
+        input_file (str): Path to the input video file to be decoded
+        yuv_file (str): Path where the buffer-based pipeline output will be saved
+        use_device_memory (int): If set to 1, output decoded frame is CUDeviceptr wrapped in CUDA Array Interface
+        gpu_id (int): GPU device ID to use
+        frame_count (int, optional): Maximum number of frames to decode. If None, 0, or negative, decode all frames.
+
+    Returns:
+        None: Decoded frames are written to a raw file.
+    """
+    try:
+        print("Starting buffer-based decoding...")
+        data_feeder = VideoStreamFeeder(input_file)
+        buffer_demuxer = nvc.CreateDemuxer(data_feeder.feed_chunk)
+
+        buffer_decoder = nvc.CreateDecoder(
+            gpuid=gpu_id,
+            codec=buffer_demuxer.GetNvCodecId(),
+            cudacontext=0,
+            cudastream=0,
+            usedevicememory=use_device_memory
+        )
+
+        # Normalize frame count
+        decode_all = frame_count is None or frame_count <= 0
+        if decode_all:
+            print("Decoding all available frames")
+            frame_count = None
+
+        frames_decoded = 0
+
+        with open(yuv_file, 'wb') as decFile:
+            for packet in buffer_demuxer:
+                for decoded_frame in buffer_decoder.Decode(packet):
+
+                    frame_data = get_frame_data(decoded_frame, use_device_memory)
+                    decFile.write(bytearray(frame_data))
+                    
+                    frames_decoded += 1
+                    if frame_count is not None and frames_decoded >= frame_count:
+                        print(f"Successfully decoded requested {frame_count} frames to {yuv_file}")
+                        return
+            
+            # If we get here, we've decoded all available frames
+            if frame_count is not None and frames_decoded < frame_count:
+                print(f"Warning: Video ended before reaching requested frame count. Requested: {frame_count}, Decoded: {frames_decoded}")
+                print(f"Decoded frames written to {yuv_file}")
+            else:
+                print(f"Successfully decoded all {frames_decoded} frames to {yuv_file}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+if __name__ == "__main__":
+    
+    args = parse_decode_args(
+        "Demonstrates video demuxing by processing video data directly from memory buffers."
+    )
+    
+    print("=" * 60)
+    print("Configuration:")
+    print(f"Input: {args.encoded_file_path}")
+    print(f"Output: {args.raw_file_path}")
+    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_from_byte_array(
+        input_file=args.encoded_file_path,
+        yuv_file=args.raw_file_path,
+        use_device_memory=args.use_device_memory,
+        gpu_id=args.gpu_id,
+        frame_count=args.frame_count
+    )

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
+    )