PyNvVideoCodec 2.2.1__cp314-cp314-win_arm64.whl

pynvvideocodec-2.2.1.dist-info/RECORD

@@ -0,0 +1,63 @@
+PyNvVideoCodec/PyNvVideoCodec_121.cp314-win_arm64.pyd,sha256=kmHnTQrHMgJVIeVxuM44hQlMnz7HGO1e3PmJKRd5yVI,1570304
+PyNvVideoCodec/PyNvVideoCodec_130.cp314-win_arm64.pyd,sha256=Y6vkDtmJExJFO2cBsjVeN7KRe8hD6CMAMJrh0Hba5jM,1575936
+PyNvVideoCodec/VersionCheck.cp314-win_arm64.pyd,sha256=iQRPIY3a4pBwvw4NDdcyplfgXG1MUzxfNoVU7rsVXQ0,140800
+PyNvVideoCodec/__init__.py,sha256=id6Kqu3Mg3kL_IB7aplk_nD3mkvzHtdq2umTHEVC2Yg,10523
+PyNvVideoCodec/avformat-62.dll,sha256=GMn2UAqurlBBH0XYEKfAXiYYAGzEJwwc703WiwxWjj4,4007936
+PyNvVideoCodec/avutil-60.dll,sha256=lD33ywf7bKiTdgfIgJ1nFZM0JvS4n6qgQ4pJC8Za2Pw,821248
+PyNvVideoCodec/decoders/SimpleDecoder.py,sha256=17Lm0QXXfFjHBMJp9zthV9v9dOifAguQb9RgPJamk1o,13003
+PyNvVideoCodec/decoders/ThreadedDecoder.py,sha256=KeQj3IDL03Yc3-MnoO2EsFIfzXTNRfRo7h3U46tLoi0,6805
+PyNvVideoCodec/decoders/__init__.py,sha256=opQYWVM7fVcCedCrl6J_3eWGbKN4q55ffvnJKgwq6co,1259
+PyNvVideoCodec/transcoder/Transcoder.py,sha256=0Pc81-paVtxZwArHb2FJ9luhD2WYgLoiL_cQw515pFA,2443
+PyNvVideoCodec/transcoder/__init__.py,sha256=2nkwMgry3-aPl_MNzdh6wCDR9bGJWzUzN9mHgbqX6Uk,1261
+benchmarks/cached_decoder_benchmark.py,sha256=Bu3O7G_fGudgxs5ZLrjYYdpQlppaoHBOi-d_kEEXNLA,33544
+benchmarks/frame_sampling_benchmark.py,sha256=PdkUKeG1uwMkkhULnQChQA_V3U2jNRtuXEt7cdr14Ek,33583
+benchmarks/requirements.txt,sha256=jlnVPYFJKzOo9GtHvy1SmwLf-V6E1TMWaVvI_GW9crg,2443
+benchmarks/segmented_transcode_benchmark.py,sha256=zZVviIwIsCwJgutiqMq6Ik1AF-QS8V7cz2bVPvHyjag,68582
+benchmarks/setup_pycuda_win_arm64.bat,sha256=SUMucfvlMWtS264irb9h4-XNjx0fWPcOVDpCw4y60iQ,18786
+pynvvideocodec-2.2.1.data/data/external/ffmpeg/readme.txt,sha256=EUUsG8ITVm9o9-SiOYI5DQ1fw_SrPjH13YQWyg2F_F0,2513
+pynvvideocodec-2.2.1.data/data/external/ffmpeg/src/ffmpeg-8.1.2.tar.xz,sha256=RkvrXnvwwxHmi0WuLwTpzCr4iFGrtAgiMXQqdNl7Ukw,11710924
+pynvvideocodec-2.2.1.dist-info/licenses/LICENSE.txt,sha256=2zbykdcROaQUD-lZ0yCXhia2szvXi5rnNgA-JV1hP4o,1174
+pynvvideocodec-2.2.1.dist-info/licenses/NOTICES.txt,sha256=YO5BKdOKsY_HJTtamtqg6o7RoHOzl87HY2zsCUdICdk,7886
+samples/requirements.txt,sha256=Pqgfageq8r_8cBAYOmcbwIgKs5aKB_z1fgkY5NqrtO0,3645
+samples/setup_pycuda_win_arm64.bat,sha256=SUMucfvlMWtS264irb9h4-XNjx0fWPcOVDpCw4y60iQ,18786
+samples/advanced/decode.py,sha256=diX6orPXRWT4jz0tgIhGHzvMgcB8cKm1Pdo8PsX96I8,7720
+samples/advanced/decode_from_memory_buffer.py,sha256=cmQBQ63L3wQpYQagrF4XSIpiPyL_hsr8ZZdbIRANM7g,7811
+samples/advanced/decode_perf.py,sha256=KkNbQ8DziAWWZEpWDWcoUGxOJZsJTeUxdNbCeId9ZdI,12267
+samples/advanced/decode_reconfigure.py,sha256=dmy7k_Aq8Ke9Ok0Uwu-RYeuHVywrK9MbGgVzxaRT8HY,8309
+samples/advanced/decode_sei_msg.py,sha256=xWR-_yRCb4LbQvKAfkD18YBldUrkZo8gloq4Yz9Rllc,8257
+samples/advanced/decode_with_cuda_control.py,sha256=G9PQcjUl4wRLt4lB0F-vf3b9Ic1oh0sG4iVNTS77Zoo,9258
+samples/advanced/decode_with_low_latency.py,sha256=mqMRQI29yLzRJ8CBL38Xc9enSG3hBAhSCiByCuZ7y1g,8292
+samples/advanced/encode_config.json,sha256=GU2-GNZnw4L839yisJp5TeZawEVQ0vjvpL2_0A9BrGY,199
+samples/advanced/encode_config_lowlatency.json,sha256=-EFHJtDnS0zw7bovb3tY4E_ww4EnD2KRgwgvQpIYCvY,233
+samples/advanced/encode_perf.py,sha256=SxgYxVOR7eJVHhlK8qBYJv2Pu9-7I-BwCVT0vdrujXQ,13288
+samples/advanced/encode_reconfigure.py,sha256=T0A-FjwHJPURYG91u5Q0QyFhjYZD54nYQTEsErRsX3E,8739
+samples/advanced/encode_sei_msg.py,sha256=7NnBGjXcgK3QF3CHZcKiXfivFHpiOK-O3wGwJ1b1cw0,8056
+samples/advanced/simple_decode_from_memory.py,sha256=LdJdFtzrO_q0fEjUR_ACwIkzj24DV5yFucQCUi80hW4,6913
+samples/advanced/simple_decode_stats.py,sha256=wt3HADZGAbWuAmmezFMCgljqRQiaA6XsVDy9sZL_Cu4,7171
+samples/advanced/transcode.py,sha256=0dyOHiNVSh_sBvIZz4jTw411SZBznOednN93ViM0HSk,11548
+samples/basic/create_video_segments.py,sha256=COthhME8KfHGJhL_rGpdKkjS-HzjvRHxtrOn5L8z5bs,7631
+samples/basic/encode.py,sha256=tN1eyhzpzwk-UF2YqLv0Irq3f2T-syi535fLwYKPGlc,22785
+samples/basic/segments.txt,sha256=URKw_1BeqiMV2vYaPc213Z1YnUbnyYPzCONRJ5qAXmU,17
+samples/basic/simple_decode_sampling.py,sha256=oj7Ve9jNWTJQYN-U3ZelP6KvSknz4INE0Yw9SUNvBmI,6990
+samples/basic/transcode_config.json,sha256=mSnYYW5KOVlMC6pmG3guLtAqBn1PQzcLXPy2Gl7vObU,102
+samples/jupyter/ReconfigureDecoder.png,sha256=DsEFxg0RBPucx_Ky_HaZ5iE21TJ-aTQlOMAOenIHDco,114179
+samples/jupyter/SimpleDecoderAPIs.png,sha256=uJM1EAI1xg6Om0PCP6joLo1W4i0A0Xp9YUqTuEgq2ic,54815
+samples/jupyter/ThreadedDecoder.png,sha256=Ts4MpymKaKjNJlSQdlzeO_uBxce5_aZe14_VlZKqSvU,98415
+samples/jupyter/coco_classes.pickle,sha256=kkzIHUQ4Xz8CDISRbPmClEqM86WeV9i16SCs-vYM-jg,838
+samples/jupyter/face_protect_tutorial.ipynb,sha256=iZ73kk9Fitiz2jIMfryrH39-8DeiEpDw-vhvM-WjGdc,37447
+samples/jupyter/object_detection_tutorial.ipynb,sha256=e_kYnbguhGZOhbvN6da5dsIbFIIRKN5Y_faQ-ott-4k,392290
+samples/jupyter/simple_decode_tutorial.ipynb,sha256=NQlbOWgo8EbB340jERHvrp2bkDeMY-xvc_ZT0fvLxcQ,5286941
+samples/utils/Utils.py,sha256=yeMrz4BSg_P4Xzt9jx7m7cRzMnNKqp9GGhRXPRtgo0A,17773
+samples/utils/__init__.py,sha256=w8rVqKtCUkDPxAyGvUn33Pij74bSkbGIthq13OsKVZs,1915
+samples/utils/decode_parser.py,sha256=QDZmbYvaBfn7oozvQHnAC93F1Qy8jTtpkdDgmgv5cmI,25347
+samples/utils/decode_stats_writer.py,sha256=HZe2J6MBgbeg_rjZHFf_Y3naEU4Qc7S7Gz_hkHikal0,7996
+samples/utils/encode_parallel_utils.py,sha256=Y4rHnZAEkdE_MilRRfGqNZENB5qP9ePJQsOQs7JIwyc,6590
+samples/utils/encode_parser.py,sha256=LPvfo9GaqGyoFV91BovSsSlME3PXT9hWJYYkhaubkM0,13076
+samples/utils/frame_utils.py,sha256=a_-JC7NuBLvANTjMY50NBKOj1YXtdB4L_JVInKp2rmI,3478
+samples/utils/sei_message_parser.py,sha256=Z5mZxat-PFKClrNcDHKfwmJYZoNLOok2qZnDCD5FJ0M,10079
+samples/utils/sei_parser.py,sha256=Z5mZxat-PFKClrNcDHKfwmJYZoNLOok2qZnDCD5FJ0M,10079
+samples/utils/transcode_parser.py,sha256=vmOqcYDRuEROWe8eC_z59nNRDUvOEGuBiRa0bxa24Hw,8410
+pynvvideocodec-2.2.1.dist-info/METADATA,sha256=dZDhtG1j3jqG_iDGrdok-k5xEiMJUY6GOZ442OVtdcw,7393
+pynvvideocodec-2.2.1.dist-info/WHEEL,sha256=fkyl4vyYuWLLIMFl4O-VCp5wj5uPuRDj1taCfThTvxw,96
+pynvvideocodec-2.2.1.dist-info/top_level.txt,sha256=L7cP7N5LjGw80fJ7i2c9HYNZk7U3G80zVXDKNaffjLg,34
+pynvvideocodec-2.2.1.dist-info/RECORD,,

pynvvideocodec-2.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: skbuild 0.18.1
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_arm64
+

pynvvideocodec-2.2.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+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.
+
+

pynvvideocodec-2.2.1.dist-info/licenses/NOTICES.txt

@@ -0,0 +1,167 @@
+This SDK includes portions of FFMPEG, under the following license:
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pynvvideocodec-2.2.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+PyNvVideoCodec
+benchmarks
+samples

samples/advanced/decode.py

@@ -0,0 +1,173 @@
+# 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 basic video decoding using the native decoder in PyNvVideoCodec.
+
+It shows how to:
+1. Create and use a demuxer to extract packets from a video file
+2. Set up a basic decoder for hardware-accelerated decoding
+3. Process packets and decode frames
+4. Write raw decoded frames to a file
+
+Key Learning Outcomes:
+1. Basic demuxer usage for extracting video packets
+2. Setting up hardware decoder with default configuration
+3. Understanding the decode pipeline: Video File -> Demuxer -> Packets -> Decoder -> Raw Frames
+4. Working with both device and host memory for frame data
+5. Managing frame count and early termination
+
+
+Usage: python decode.py -i <input_video_file> -o <output_file> -d <use_device_memory>
+Example: python decode.py -i input.mp4 -o output.yuv -d 1
+
+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, default: all frames)
+'''
+
+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)
+
+# Import utilities for decoding
+from utils.decode_parser import parse_decode_args
+from utils.Utils import get_frame_data
+
+
+
+def decode(gpu_id, enc_file_path, dec_file_path, use_device_memory, frame_count=None):
+    """
+    Function to decode media file and write raw frames into an output file.
+
+    This function demonstrates basic hardware-accelerated video decoding. Here's how it works:
+    1. Creates a demuxer that reads the video file and extracts encoded frame packets
+    2. Sets up a GPU decoder with default configuration
+    3. The demuxer automatically extracts frame packets as you iterate over it
+    4. Each packet is sent to the GPU decoder for hardware-accelerated decoding
+    5. The decoder outputs raw YUV frames that can be processed or saved
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be decoded
+        dec_file_path (str): Path to 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. If None, 0, or negative, decode all frames.
+
+            Example:
+            >>> decode(0, "path/to/input/media/file","path/to/output/yuv", 1)
+            Function to decode media file and write raw frames into an output file.
+    """
+    # Normalize frame count
+    decode_all = frame_count is None or frame_count <= 0
+    if decode_all:
+        print("Decoding all available frames")
+        frame_count = None
+
+    try:
+        nv_dmx = nvc.CreateDemuxer(filename=enc_file_path)
+
+        caps = nvc.GetDecoderCaps(
+            gpuid=gpu_id,
+            codec=nv_dmx.GetNvCodecId(),
+            chromaformat=nv_dmx.ChromaFormat(),
+            bitdepth=nv_dmx.BitDepth()
+        )
+        if "num_decoder_engines" in caps:
+            print("Number of NVDECs:", caps["num_decoder_engines"])
+
+        nv_dec = nvc.CreateDecoder(gpuid=gpu_id,
+                               codec=nv_dmx.GetNvCodecId(),
+                               usedevicememory=use_device_memory)
+
+        # printing out FPS and pixel format of the stream for convenience
+        print("FPS =", nv_dmx.FrameRate())
+        # open the file to be decoded in write mode
+        with open(dec_file_path, "wb") as decFile:
+            # demuxer can be iterated, fetch the packet from demuxer
+            frames_decoded = 0
+            for packet in nv_dmx:
+                # Decode returns a list of packets, range of this list is from [0, size of (decode picture buffer)]
+                # size of (decode picture buffer) depends on GPU, fur Turing series its 8
+                for decoded_frame in nv_dec.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 {dec_file_path}")
+                        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 {dec_file_path}")
+            else:
+                print(f"Successfully decoded all {frames_decoded} frames to {dec_file_path}")
+                
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"Operation or configuration not supported: {e}")
+        raise
+    except cuda.Error as e:
+        print(f"CUDA error (context/stream/memory): {e}")
+        raise
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        raise
+    finally:
+        # Cleanup resources in reverse order of creation
+        if nv_dec is not None:
+            del nv_dec
+        if nv_dmx is not None:
+            del nv_dmx
+
+if __name__ == "__main__":
+    args = parse_decode_args(
+        "Basic video demuxing and decoding example. "
+        "Shows how to extract packets from a video file and decode them using the NVIDIA decoder."
+    )
+    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(
+        gpu_id=args.gpu_id,
+        enc_file_path=args.encoded_file_path,
+        dec_file_path=args.raw_file_path,
+        use_device_memory=args.use_device_memory,
+        frame_count=args.frame_count
+    )

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