Upload folder using huggingface_hub

.gitattributes

@@ -6341,3 +6341,7 @@ sqlite_gui/translations/qtbase_pl.qm filter=lfs diff=lfs merge=lfs -text
 sqlite_gui/translations/qtbase_ru.qm filter=lfs diff=lfs merge=lfs -text
 sqlite_gui/translations/qtbase_uk.qm filter=lfs diff=lfs merge=lfs -text
 sqlite_gui/translations/qtxmlpatterns_cs.qm filter=lfs diff=lfs merge=lfs -text
+video_codec_sdk/Doc/NVDEC_VideoDecoder_API_ProgGuide.pdf filter=lfs diff=lfs merge=lfs -text
+video_codec_sdk/Doc/NVENC_Preset_Migration_Guide.pdf filter=lfs diff=lfs merge=lfs -text
+video_codec_sdk/Doc/NVENC_VideoEncoder_API_ProgGuide.pdf filter=lfs diff=lfs merge=lfs -text
+video_codec_sdk/Read_Me.pdf filter=lfs diff=lfs merge=lfs -text

video_codec_sdk/Doc/NVDEC_VideoDecoder_API_ProgGuide.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eda5d74f4be28f0a46b670a6423e102c69e9830f27d5aeb0b0382d4ec7391332
+size 179138

video_codec_sdk/Doc/NVENC_Preset_Migration_Guide.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:573b70ddfecd1b3be50ea98348f8aa7414535ce090b579b6bedd88fded4b68a4
+size 198767

video_codec_sdk/Doc/NVENC_VideoEncoder_API_ProgGuide.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83952743e36e90afbd50ee92aa17fc8a4cf38b9efb949010add3ee9d9515ae8c
+size 223336

video_codec_sdk/Interface/cuviddec.h

@@ -0,0 +1,1209 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2024 NVIDIA Corporation
+ *
+ * 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.
+ */
+
+/*****************************************************************************************************/
+//! \file cuviddec.h
+//! NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! This file contains constants, structure definitions and function prototypes used for decoding.
+/*****************************************************************************************************/
+
+#if !defined(__CUDA_VIDEO_H__)
+#define __CUDA_VIDEO_H__
+
+#ifndef __cuda_cuda_h__
+#include <cuda.h>
+#endif // __cuda_cuda_h__
+
+#if defined(_WIN64) || defined(__LP64__) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+#if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))
+#define __CUVID_DEVPTR64
+#endif
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+typedef void *CUvideodecoder;
+typedef struct _CUcontextlock_st *CUvideoctxlock;
+
+/*********************************************************************************/
+//! \enum cudaVideoCodec
+//! Video codec enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+/*********************************************************************************/
+typedef enum cudaVideoCodec_enum {
+    cudaVideoCodec_MPEG1=0,                                         /**<  MPEG1             */
+    cudaVideoCodec_MPEG2,                                           /**<  MPEG2             */
+    cudaVideoCodec_MPEG4,                                           /**<  MPEG4             */
+    cudaVideoCodec_VC1,                                             /**<  VC1               */
+    cudaVideoCodec_H264,                                            /**<  H264              */
+    cudaVideoCodec_JPEG,                                            /**<  JPEG              */
+    cudaVideoCodec_H264_SVC,                                        /**<  H264-SVC          */
+    cudaVideoCodec_H264_MVC,                                        /**<  H264-MVC          */
+    cudaVideoCodec_HEVC,                                            /**<  HEVC              */
+    cudaVideoCodec_VP8,                                             /**<  VP8               */
+    cudaVideoCodec_VP9,                                             /**<  VP9               */
+    cudaVideoCodec_AV1,                                             /**<  AV1               */
+    cudaVideoCodec_NumCodecs,                                       /**<  Max codecs        */
+    // Uncompressed YUV
+    cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)      */
+    cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)      */
+    cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)      */
+    cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */
+    cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)       */
+} cudaVideoCodec;
+
+/*********************************************************************************/
+//! \enum cudaVideoSurfaceFormat
+//! Video surface format enums used for output format of decoded output
+//! These enums are used in CUVIDDECODECREATEINFO structure
+/*********************************************************************************/
+typedef enum cudaVideoSurfaceFormat_enum {
+    cudaVideoSurfaceFormat_NV12=0,          /**< Semi-Planar YUV [Y plane followed by interleaved UV plane]     */
+    cudaVideoSurfaceFormat_P016=1,          /**< 16 bit Semi-Planar YUV [Y plane followed by interleaved UV plane].
+                                                 Can be used for 10 bit(6LSB bits 0), 12 bit (4LSB bits 0)      */
+    cudaVideoSurfaceFormat_YUV444=2,        /**< Planar YUV [Y plane followed by U and V planes]                */
+    cudaVideoSurfaceFormat_YUV444_16Bit=3,  /**< 16 bit Planar YUV [Y plane followed by U and V planes].
+                                                 Can be used for 10 bit(6LSB bits 0), 12 bit (4LSB bits 0)      */
+    cudaVideoSurfaceFormat_NV16=4,          /**< Semi-Planar YUV 422 [Y plane followed by interleaved UV plane] */
+    cudaVideoSurfaceFormat_P216=5           /**< 16 bit Semi-Planar YUV 422[Y plane followed by interleaved UV plane].
+                                                 Can be used for 10 bit(6LSB bits 0), 12 bit (4LSB bits 0)      */
+} cudaVideoSurfaceFormat;
+
+/******************************************************************************************************************/
+//! \enum cudaVideoDeinterlaceMode
+//! Deinterlacing mode enums
+//! These enums are used in CUVIDDECODECREATEINFO structure
+//! Use cudaVideoDeinterlaceMode_Weave for progressive content and for content that doesn't need deinterlacing
+//! cudaVideoDeinterlaceMode_Adaptive needs more video memory than other DImodes
+/******************************************************************************************************************/
+typedef enum cudaVideoDeinterlaceMode_enum {
+    cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */
+    cudaVideoDeinterlaceMode_Bob,       /**< Drop one field                       */
+    cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing               */
+} cudaVideoDeinterlaceMode;
+
+/**************************************************************************************************************/
+//! \enum cudaVideoChromaFormat
+//! Chroma format enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+/**************************************************************************************************************/
+typedef enum cudaVideoChromaFormat_enum {
+    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
+    cudaVideoChromaFormat_420,           /**< YUV 4:2:0  */
+    cudaVideoChromaFormat_422,           /**< YUV 4:2:2  */
+    cudaVideoChromaFormat_444            /**< YUV 4:4:4  */
+} cudaVideoChromaFormat;
+
+/*************************************************************************************************************/
+//! \enum cudaVideoCreateFlags
+//! Decoder flag enums to select preferred decode path
+//! cudaVideoCreate_Default and cudaVideoCreate_PreferCUVID are most optimized, use these whenever possible
+/*************************************************************************************************************/
+typedef enum cudaVideoCreateFlags_enum {
+    cudaVideoCreate_Default     = 0x00,     /**< Default operation mode: use dedicated video engines                        */
+    cudaVideoCreate_PreferCUDA  = 0x01,     /**< Use CUDA-based decoder (requires valid vidLock object for multi-threading) */
+    cudaVideoCreate_PreferDXVA  = 0x02,     /**< Go through DXVA internally if possible (requires D3D9 interop)             */
+    cudaVideoCreate_PreferCUVID = 0x04      /**< Use dedicated video engines directly                                       */
+} cudaVideoCreateFlags;
+
+
+/*************************************************************************/
+//! \enum cuvidDecodeStatus
+//! Decode status enums
+//! These enums are used in CUVIDGETDECODESTATUS structure
+/*************************************************************************/
+typedef enum cuvidDecodeStatus_enum
+{
+    cuvidDecodeStatus_Invalid         = 0,   // Decode status is not valid
+    cuvidDecodeStatus_InProgress      = 1,   // Decode is in progress
+    cuvidDecodeStatus_Success         = 2,   // Decode is completed without any errors
+    // 3 to 7 enums are reserved for future use
+    cuvidDecodeStatus_Error           = 8,   // Decode is completed with an error (error is not concealed)
+    cuvidDecodeStatus_Error_Concealed = 9,   // Decode is completed with an error and error is concealed
+} cuvidDecodeStatus;
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECAPS;
+//! This structure is used in cuvidGetDecoderCaps API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECAPS
+{
+    cudaVideoCodec          eCodecType;                 /**< IN: cudaVideoCodec_XXX                                             */
+    cudaVideoChromaFormat   eChromaFormat;              /**< IN: cudaVideoChromaFormat_XXX                                      */
+    unsigned int            nBitDepthMinus8;            /**< IN: The Value "BitDepth minus 8"                                   */
+    unsigned int            reserved1[3];               /**< Reserved for future use - set to zero                              */
+
+    unsigned char           bIsSupported;               /**< OUT: 1 if codec supported, 0 if not supported                      */
+    unsigned char           nNumNVDECs;                 /**< OUT: Number of NVDECs that can support IN params                   */
+    unsigned short          nOutputFormatMask;          /**< OUT: each bit represents corresponding cudaVideoSurfaceFormat enum */
+    unsigned int            nMaxWidth;                  /**< OUT: Max supported coded width in pixels                           */
+    unsigned int            nMaxHeight;                 /**< OUT: Max supported coded height in pixels                          */
+    unsigned int            nMaxMBCount;                /**< OUT: Max supported macroblock count
+                                                                  CodedWidth*CodedHeight/256 must be <= nMaxMBCount             */
+    unsigned short          nMinWidth;                  /**< OUT: Min supported coded width in pixels                           */
+    unsigned short          nMinHeight;                 /**< OUT: Min supported coded height in pixels                          */
+    unsigned char           bIsHistogramSupported;      /**< OUT: 1 if Y component histogram output is supported, 0 if not
+                                                                  Note: histogram is computed on original picture data before
+                                                                  any post-processing like scaling, cropping, etc. is applied   */
+    unsigned char           nCounterBitDepth;           /**< OUT: histogram counter bit depth                                   */
+    unsigned short          nMaxHistogramBins;          /**< OUT: Max number of histogram bins                                  */
+    unsigned int            reserved3[10];              /**< Reserved for future use - set to zero                              */
+} CUVIDDECODECAPS;
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECREATEINFO
+//! This structure is used in cuvidCreateDecoder API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECREATEINFO
+{
+    unsigned long ulWidth;              /**< IN: Coded sequence width in pixels                                             */
+    unsigned long ulHeight;             /**< IN: Coded sequence height in pixels                                            */
+    unsigned long ulNumDecodeSurfaces;  /**< IN: Maximum number of internal decode surfaces                                 */
+    cudaVideoCodec CodecType;           /**< IN: cudaVideoCodec_XXX                                                         */
+    cudaVideoChromaFormat ChromaFormat; /**< IN: cudaVideoChromaFormat_XXX                                                  */
+    unsigned long ulCreationFlags;      /**< IN: Decoder creation flags (cudaVideoCreateFlags_XXX)                          */
+    unsigned long bitDepthMinus8;       /**< IN: The value "BitDepth minus 8"                                               */
+    unsigned long ulIntraDecodeOnly;    /**< IN: Set 1 only if video has all intra frames (default value is 0). This will
+                                             optimize video memory for Intra frames only decoding. The support is limited
+                                             to specific codecs - H264, HEVC, VP9, the flag will be ignored for codecs which
+                                             are not supported. However decoding might fail if the flag is enabled in case
+                                             of supported codecs for regular bit streams having P and/or B frames.          */
+    unsigned long ulMaxWidth;           /**< IN: Coded sequence max width in pixels used with reconfigure Decoder           */
+    unsigned long ulMaxHeight;          /**< IN: Coded sequence max height in pixels used with reconfigure Decoder          */
+    unsigned long Reserved1;            /**< Reserved for future use - set to zero                                          */
+    /**
+    * IN: area of the frame that should be displayed
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } display_area;
+
+    cudaVideoSurfaceFormat OutputFormat;       /**< IN: cudaVideoSurfaceFormat_XXX                                     */
+    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< IN: cudaVideoDeinterlaceMode_XXX                                   */
+    unsigned long ulTargetWidth;               /**< IN: Post-processed output width (Should be aligned to 2)           */
+    unsigned long ulTargetHeight;              /**< IN: Post-processed output height (Should be aligned to 2)          */
+    unsigned long ulNumOutputSurfaces;         /**< IN: Maximum number of output surfaces simultaneously mapped        */
+    CUvideoctxlock vidLock;                    /**< IN: If non-NULL, context lock used for synchronizing ownership of
+                                                    the cuda context. Needed for cudaVideoCreate_PreferCUDA decode     */
+    /**
+    * IN: target rectangle in the output frame (for aspect ratio conversion)
+    * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } target_rect;
+
+    unsigned long enableHistogram;             /**< IN: enable histogram output, if supported */
+    unsigned long Reserved2[4];                /**< Reserved for future use - set to zero */
+} CUVIDDECODECREATEINFO;
+
+/*********************************************************/
+//! \struct CUVIDH264DPBENTRY
+//! H.264 DPB entry
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264DPBENTRY
+{
+    int PicIdx;                 /**< picture index of reference frame                                        */
+    int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term)                    */
+    int is_long_term;           /**< 0=short term reference, 1=long term reference                           */
+    int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */
+    int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields                    */
+    int FieldOrderCnt[2];       /**< field order count of top and bottom fields                              */
+} CUVIDH264DPBENTRY;
+
+/************************************************************/
+//! \struct CUVIDH264MVCEXT
+//! H.264 MVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/************************************************************/
+typedef struct _CUVIDH264MVCEXT
+{
+    int num_views_minus1;                  /**< Max number of coded views minus 1 in video : Range - 0 to 1023              */
+    int view_id;                           /**< view identifier                                                             */
+    unsigned char inter_view_flag;         /**< 1 if used for inter-view prediction, 0 if not                               */
+    unsigned char num_inter_view_refs_l0;  /**< number of inter-view ref pics in RefPicList0                                */
+    unsigned char num_inter_view_refs_l1;  /**< number of inter-view ref pics in RefPicList1                                */
+    unsigned char MVCReserved8Bits;        /**< Reserved bits                                                               */
+    int InterViewRefsL0[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList0 */
+    int InterViewRefsL1[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList1 */
+} CUVIDH264MVCEXT;
+
+/*********************************************************/
+//! \struct CUVIDH264SVCEXT
+//! H.264 SVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264SVCEXT
+{
+    unsigned char profile_idc;
+    unsigned char level_idc;
+    unsigned char DQId;
+    unsigned char DQIdMax;
+    unsigned char disable_inter_layer_deblocking_filter_idc;
+    unsigned char ref_layer_chroma_phase_y_plus1;
+    signed char   inter_layer_slice_alpha_c0_offset_div2;
+    signed char   inter_layer_slice_beta_offset_div2;
+
+    unsigned short DPBEntryValidFlag;
+    unsigned char inter_layer_deblocking_filter_control_present_flag;
+    unsigned char extended_spatial_scalability_idc;
+    unsigned char adaptive_tcoeff_level_prediction_flag;
+    unsigned char slice_header_restriction_flag;
+    unsigned char chroma_phase_x_plus1_flag;
+    unsigned char chroma_phase_y_plus1;
+
+    unsigned char tcoeff_level_prediction_flag;
+    unsigned char constrained_intra_resampling_flag;
+    unsigned char ref_layer_chroma_phase_x_plus1_flag;
+    unsigned char store_ref_base_pic_flag;
+    unsigned char Reserved8BitsA;
+    unsigned char Reserved8BitsB;
+
+    short scaled_ref_layer_left_offset;
+    short scaled_ref_layer_top_offset;
+    short scaled_ref_layer_right_offset;
+    short scaled_ref_layer_bottom_offset;
+    unsigned short Reserved16Bits;
+    struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded.
+                                             Linked list ends at the target layer. */
+    int bRefBaseLayer;                  /**< whether to store ref base pic */
+} CUVIDH264SVCEXT;
+
+/******************************************************/
+//! \struct CUVIDH264PICPARAMS
+//! H.264 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/******************************************************/
+typedef struct _CUVIDH264PICPARAMS
+{
+    // SPS
+    int log2_max_frame_num_minus4;
+    int pic_order_cnt_type;
+    int log2_max_pic_order_cnt_lsb_minus4;
+    int delta_pic_order_always_zero_flag;
+    int frame_mbs_only_flag;
+    int direct_8x8_inference_flag;
+    int num_ref_frames;
+    unsigned char residual_colour_transform_flag;
+    unsigned char bit_depth_luma_minus8;
+    unsigned char bit_depth_chroma_minus8;
+    unsigned char qpprime_y_zero_transform_bypass_flag;
+    // PPS
+    int entropy_coding_mode_flag;
+    int pic_order_present_flag;
+    int num_ref_idx_l0_active_minus1;
+    int num_ref_idx_l1_active_minus1;
+    int weighted_pred_flag;
+    int weighted_bipred_idc;
+    int pic_init_qp_minus26;
+    int deblocking_filter_control_present_flag;
+    int redundant_pic_cnt_present_flag;
+    int transform_8x8_mode_flag;
+    int MbaffFrameFlag;
+    int constrained_intra_pred_flag;
+    int chroma_qp_index_offset;
+    int second_chroma_qp_index_offset;
+    int ref_pic_flag;
+    int frame_num;
+    int CurrFieldOrderCnt[2];
+    // DPB
+    CUVIDH264DPBENTRY dpb[16];                      // List of reference frames within the DPB
+    // Quantization Matrices (raster-order)
+    unsigned char WeightScale4x4[6][16];
+    unsigned char WeightScale8x8[2][64];
+    // FMO/ASO
+    unsigned char fmo_aso_enable;
+    unsigned char num_slice_groups_minus1;
+    unsigned char slice_group_map_type;
+    signed char pic_init_qs_minus26;
+    unsigned int slice_group_change_rate_minus1;
+    union
+    {
+        unsigned long long slice_group_map_addr;
+        const unsigned char *pMb2SliceGroupMap;
+    } fmo;
+    unsigned int mb_adaptive_frame_field_flag : 2;  // bit 0 represent SPS flag mb_adaptive_frame_field_flag
+                                                    // if bit 1 is not set, flag is ignored. Bit 1 is set to maintain backward compatibility
+    unsigned int Reserved1 : 30;
+    unsigned int  Reserved[11];
+    // SVC/MVC
+    union
+    {
+        CUVIDH264MVCEXT mvcext;
+        CUVIDH264SVCEXT svcext;
+    };
+} CUVIDH264PICPARAMS;
+
+
+/********************************************************/
+//! \struct CUVIDMPEG2PICPARAMS
+//! MPEG-2 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDMPEG2PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    int picture_coding_type;
+    int full_pel_forward_vector;
+    int full_pel_backward_vector;
+    int f_code[2][2];
+    int intra_dc_precision;
+    int frame_pred_frame_dct;
+    int concealment_motion_vectors;
+    int q_scale_type;
+    int intra_vlc_format;
+    int alternate_scan;
+    int top_field_first;
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+} CUVIDMPEG2PICPARAMS;
+
+// MPEG-4 has VOP types instead of Picture types
+#define I_VOP 0
+#define P_VOP 1
+#define B_VOP 2
+#define S_VOP 3
+
+/*******************************************************/
+//! \struct CUVIDMPEG4PICPARAMS
+//! MPEG-4 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDMPEG4PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    // VOL
+    int video_object_layer_width;
+    int video_object_layer_height;
+    int vop_time_increment_bitcount;
+    int top_field_first;
+    int resync_marker_disable;
+    int quant_type;
+    int quarter_sample;
+    int short_video_header;
+    int divx_flags;
+    // VOP
+    int vop_coding_type;
+    int vop_coded;
+    int vop_rounding_type;
+    int alternate_vertical_scan_flag;
+    int interlaced;
+    int vop_fcode_forward;
+    int vop_fcode_backward;
+    int trd[2];
+    int trb[2];
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+    int gmc_enabled;
+} CUVIDMPEG4PICPARAMS;
+
+/********************************************************/
+//! \struct CUVIDVC1PICPARAMS
+//! VC1 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDVC1PICPARAMS
+{
+    int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */
+    int BackwardRefIdx;     /**< Picture index of backward reference (B-frames)  */
+    int FrameWidth;         /**< Actual frame width                              */
+    int FrameHeight;        /**< Actual frame height                             */
+    // PICTURE
+    int intra_pic_flag;     /**< Set to 1 for I,BI frames */
+    int ref_pic_flag;       /**< Set to 1 for I,P frames  */
+    int progressive_fcm;    /**< Progressive frame        */
+    // SEQUENCE
+    int profile;
+    int postprocflag;
+    int pulldown;
+    int interlace;
+    int tfcntrflag;
+    int finterpflag;
+    int psf;
+    int multires;
+    int syncmarker;
+    int rangered;
+    int maxbframes;
+    // ENTRYPOINT
+    int panscan_flag;
+    int refdist_flag;
+    int extended_mv;
+    int dquant;
+    int vstransform;
+    int loopfilter;
+    int fastuvmc;
+    int overlap;
+    int quantizer;
+    int extended_dmv;
+    int range_mapy_flag;
+    int range_mapy;
+    int range_mapuv_flag;
+    int range_mapuv;
+    int rangeredfrm;    // range reduction state
+} CUVIDVC1PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDJPEGPICPARAMS
+//! JPEG picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDJPEGPICPARAMS
+{
+    unsigned char numComponents;
+    unsigned char bitDepth;
+    unsigned char quantizationTableSelector[4];
+    unsigned int scanOffset[4];
+    unsigned int scanSize[4];
+
+    unsigned short restartInterval;
+    unsigned char componentIdentifier[4];
+
+    unsigned char hasQMatrix;
+    unsigned char hasHuffman;
+    unsigned short quantvals[4][64];
+
+    unsigned char bits_ac[4][16];
+    unsigned char table_ac[4][256]; // there can only be max of 162 ac symbols
+
+    unsigned char bits_dc[4][16];
+    unsigned char table_dc[4][256];  // there can only be max of 12 dc symbols
+} CUVIDJPEGPICPARAMS;
+
+
+/*******************************************************/
+//! \struct CUVIDHEVCPICPARAMS
+//! HEVC picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDHEVCPICPARAMS
+{
+    // sps
+    int pic_width_in_luma_samples;
+    int pic_height_in_luma_samples;
+    unsigned char log2_min_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_luma_coding_block_size;
+    unsigned char log2_min_transform_block_size_minus2;
+    unsigned char log2_diff_max_min_transform_block_size;
+    unsigned char pcm_enabled_flag;
+    unsigned char log2_min_pcm_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_pcm_luma_coding_block_size;
+    unsigned char pcm_sample_bit_depth_luma_minus1;
+
+    unsigned char pcm_sample_bit_depth_chroma_minus1;
+    unsigned char pcm_loop_filter_disabled_flag;
+    unsigned char strong_intra_smoothing_enabled_flag;
+    unsigned char max_transform_hierarchy_depth_intra;
+    unsigned char max_transform_hierarchy_depth_inter;
+    unsigned char amp_enabled_flag;
+    unsigned char separate_colour_plane_flag;
+    unsigned char log2_max_pic_order_cnt_lsb_minus4;
+
+    unsigned char num_short_term_ref_pic_sets;
+    unsigned char long_term_ref_pics_present_flag;
+    unsigned char num_long_term_ref_pics_sps;
+    unsigned char sps_temporal_mvp_enabled_flag;
+    unsigned char sample_adaptive_offset_enabled_flag;
+    unsigned char scaling_list_enable_flag;
+    unsigned char IrapPicFlag;
+    unsigned char IdrPicFlag;
+
+    unsigned char bit_depth_luma_minus8;
+    unsigned char bit_depth_chroma_minus8;
+    //sps/pps extension fields
+    unsigned char log2_max_transform_skip_block_size_minus2;
+    unsigned char log2_sao_offset_scale_luma;
+    unsigned char log2_sao_offset_scale_chroma;
+    unsigned char high_precision_offsets_enabled_flag;
+    unsigned char reserved1[10];
+
+    // pps
+    unsigned char dependent_slice_segments_enabled_flag;
+    unsigned char slice_segment_header_extension_present_flag;
+    unsigned char sign_data_hiding_enabled_flag;
+    unsigned char cu_qp_delta_enabled_flag;
+    unsigned char diff_cu_qp_delta_depth;
+    signed char init_qp_minus26;
+    signed char pps_cb_qp_offset;
+    signed char pps_cr_qp_offset;
+
+    unsigned char constrained_intra_pred_flag;
+    unsigned char weighted_pred_flag;
+    unsigned char weighted_bipred_flag;
+    unsigned char transform_skip_enabled_flag;
+    unsigned char transquant_bypass_enabled_flag;
+    unsigned char entropy_coding_sync_enabled_flag;
+    unsigned char log2_parallel_merge_level_minus2;
+    unsigned char num_extra_slice_header_bits;
+
+    unsigned char loop_filter_across_tiles_enabled_flag;
+    unsigned char loop_filter_across_slices_enabled_flag;
+    unsigned char output_flag_present_flag;
+    unsigned char num_ref_idx_l0_default_active_minus1;
+    unsigned char num_ref_idx_l1_default_active_minus1;
+    unsigned char lists_modification_present_flag;
+    unsigned char cabac_init_present_flag;
+    unsigned char pps_slice_chroma_qp_offsets_present_flag;
+
+    unsigned char deblocking_filter_override_enabled_flag;
+    unsigned char pps_deblocking_filter_disabled_flag;
+    signed char   pps_beta_offset_div2;
+    signed char   pps_tc_offset_div2;
+    unsigned char tiles_enabled_flag;
+    unsigned char uniform_spacing_flag;
+    unsigned char num_tile_columns_minus1;
+    unsigned char num_tile_rows_minus1;
+
+    unsigned short column_width_minus1[21];
+    unsigned short row_height_minus1[21];
+
+    // sps and pps extension HEVC-main 444
+    unsigned char sps_range_extension_flag;
+    unsigned char transform_skip_rotation_enabled_flag;
+    unsigned char transform_skip_context_enabled_flag;
+    unsigned char implicit_rdpcm_enabled_flag;
+
+    unsigned char explicit_rdpcm_enabled_flag;
+    unsigned char extended_precision_processing_flag;
+    unsigned char intra_smoothing_disabled_flag;
+    unsigned char persistent_rice_adaptation_enabled_flag;
+
+    unsigned char cabac_bypass_alignment_enabled_flag;
+    unsigned char pps_range_extension_flag;
+    unsigned char cross_component_prediction_enabled_flag;
+    unsigned char chroma_qp_offset_list_enabled_flag;
+
+    unsigned char diff_cu_chroma_qp_offset_depth;
+    unsigned char chroma_qp_offset_list_len_minus1;
+    signed char cb_qp_offset_list[6];
+
+    signed char cr_qp_offset_list[6];
+    unsigned char reserved2[2];
+
+    unsigned int   reserved3[8];
+
+    // RefPicSets
+    int NumBitsForShortTermRPSInSlice;
+    int NumDeltaPocsOfRefRpsIdx;
+    int NumPocTotalCurr;
+    int NumPocStCurrBefore;
+    int NumPocStCurrAfter;
+    int NumPocLtCurr;
+    int CurrPicOrderCntVal;
+    int RefPicIdx[16];                      // [refpic] Indices of valid reference pictures (-1 if unused for reference)
+    int PicOrderCntVal[16];                 // [refpic]
+    unsigned char IsLongTerm[16];           // [refpic] 0=not a long-term reference, 1=long-term reference
+    unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)
+    unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)
+    unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)
+    unsigned char RefPicSetInterLayer0[8];
+    unsigned char RefPicSetInterLayer1[8];
+    unsigned int  reserved4[12];
+
+    // scaling lists (diag order)
+    unsigned char ScalingList4x4[6][16];       // [matrixId][i]
+    unsigned char ScalingList8x8[6][64];       // [matrixId][i]
+    unsigned char ScalingList16x16[6][64];     // [matrixId][i]
+    unsigned char ScalingList32x32[2][64];     // [matrixId][i]
+    unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]
+    unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]
+} CUVIDHEVCPICPARAMS;
+
+
+/***********************************************************/
+//! \struct CUVIDVP8PICPARAMS
+//! VP8 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP8PICPARAMS
+{
+    int width;
+    int height;
+    unsigned int first_partition_size;
+    //Frame Indexes
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    union {
+        struct {
+            unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */
+            unsigned char version : 3;
+            unsigned char show_frame : 1;
+            unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */
+            unsigned char Reserved2Bits : 2;
+        }vp8_frame_tag;
+        unsigned char wFrameTagFlags;
+    };
+    unsigned char Reserved1[4];
+    unsigned int  Reserved2[3];
+} CUVIDVP8PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDVP9PICPARAMS
+//! VP9 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP9PICPARAMS
+{
+    unsigned int width;
+    unsigned int height;
+
+    //Frame Indices
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    unsigned char colorSpace;
+
+    unsigned short profile : 3;
+    unsigned short frameContextIdx : 2;
+    unsigned short frameType : 1;
+    unsigned short showFrame : 1;
+    unsigned short errorResilient : 1;
+    unsigned short frameParallelDecoding : 1;
+    unsigned short subSamplingX : 1;
+    unsigned short subSamplingY : 1;
+    unsigned short intraOnly : 1;
+    unsigned short allow_high_precision_mv : 1;
+    unsigned short refreshEntropyProbs : 1;
+    unsigned short reserved2Bits : 2;
+
+    unsigned short reserved16Bits;
+
+    unsigned char  refFrameSignBias[4];
+
+    unsigned char bitDepthMinus8Luma;
+    unsigned char bitDepthMinus8Chroma;
+    unsigned char loopFilterLevel;
+    unsigned char loopFilterSharpness;
+
+    unsigned char modeRefLfEnabled;
+    unsigned char log2_tile_columns;
+    unsigned char log2_tile_rows;
+
+    unsigned char segmentEnabled : 1;
+    unsigned char segmentMapUpdate : 1;
+    unsigned char segmentMapTemporalUpdate : 1;
+    unsigned char segmentFeatureMode : 1;
+    unsigned char reserved4Bits : 4;
+
+
+    unsigned char segmentFeatureEnable[8][4];
+    short         segmentFeatureData[8][4];
+    unsigned char mb_segment_tree_probs[7];
+    unsigned char segment_pred_probs[3];
+    unsigned char reservedSegment16Bits[2];
+
+    int qpYAc;
+    int qpYDc;
+    int qpChDc;
+    int qpChAc;
+
+    unsigned int activeRefIdx[3];
+    unsigned int resetFrameContext;
+    unsigned int mcomp_filter_type;
+    unsigned int mbRefLfDelta[4];
+    unsigned int mbModeLfDelta[2];
+    unsigned int frameTagSize;
+    unsigned int offsetToDctParts;
+    unsigned int reserved128Bits[4];
+
+} CUVIDVP9PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDAV1PICPARAMS
+//! AV1 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDAV1PICPARAMS
+{
+    unsigned int   width;                               // coded width, if superres enabled then it is upscaled width
+    unsigned int   height;                              // coded height
+    unsigned int   frame_offset;                        // defined as order_hint in AV1 specification
+    int            decodePicIdx;                        // decoded output pic index, if film grain enabled, it will keep decoded (without film grain) output
+                                                        // It can be used as reference frame for future frames
+
+    // sequence header
+    unsigned int   profile : 3;                         // 0 = profile0, 1 = profile1, 2 = profile2
+    unsigned int   use_128x128_superblock : 1;          // superblock size 0:64x64, 1: 128x128
+    unsigned int   subsampling_x : 1;                   // (subsampling_x, _y) 1,1 = 420, 1,0 = 422, 0,0 = 444
+    unsigned int   subsampling_y : 1;
+    unsigned int   mono_chrome : 1;                     // for monochrome content, mono_chrome = 1 and (subsampling_x, _y) should be 1,1
+    unsigned int   bit_depth_minus8 : 4;                // bit depth minus 8
+    unsigned int   enable_filter_intra : 1;             // tool enable in seq level, 0 : disable 1: frame header control
+    unsigned int   enable_intra_edge_filter : 1;        // intra edge filtering process, 0 : disable 1: enabled
+    unsigned int   enable_interintra_compound : 1;      // interintra, 0 : not present 1: present
+    unsigned int   enable_masked_compound : 1;          // 1: mode info for inter blocks may contain the syntax element compound_type.
+                                                        // 0: syntax element compound_type will not be present
+    unsigned int   enable_dual_filter : 1;              // vertical and horiz filter selection, 1: enable and 0: disable
+    unsigned int   enable_order_hint : 1;               // order hint, and related tools, 1: enable and 0: disable
+    unsigned int   order_hint_bits_minus1 : 3;          // is used to compute OrderHintBits
+    unsigned int   enable_jnt_comp : 1;                 // joint compound modes, 1: enable and 0: disable
+    unsigned int   enable_superres : 1;                 // superres in seq level, 0 : disable 1: frame level control
+    unsigned int   enable_cdef : 1;                     // cdef filtering in seq level, 0 : disable 1: frame level control
+    unsigned int   enable_restoration : 1;              // loop restoration filtering in seq level, 0 : disable 1: frame level control
+    unsigned int   enable_fgs : 1;                      // defined as film_grain_params_present in AV1 specification
+    unsigned int   reserved0_7bits : 7;                 // reserved bits; must be set to 0
+
+    // frame header
+    unsigned int   frame_type : 2 ;                     // 0:Key frame, 1:Inter frame, 2:intra only, 3:s-frame
+    unsigned int   show_frame : 1 ;                     // show_frame = 1 implies that frame should be immediately output once decoded
+    unsigned int   disable_cdf_update : 1;              // CDF update during symbol decoding, 1: disabled, 0: enabled
+    unsigned int   allow_screen_content_tools : 1;      // 1: intra blocks may use palette encoding, 0: palette encoding is never used
+    unsigned int   force_integer_mv : 1;                // 1: motion vectors will always be integers, 0: can contain fractional bits
+    unsigned int   coded_denom : 3;                     // coded_denom of the superres scale as specified in AV1 specification
+    unsigned int   allow_intrabc : 1;                   // 1: intra block copy may be used, 0: intra block copy is not allowed
+    unsigned int   allow_high_precision_mv : 1;         // 1/8 precision mv enable
+    unsigned int   interp_filter : 3;                   // interpolation filter. Refer to section 6.8.9 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned int   switchable_motion_mode : 1;          // defined as is_motion_mode_switchable in AV1 specification
+    unsigned int   use_ref_frame_mvs : 1;               // 1: current frame can use the previous frame mv information, 0: will not use.
+    unsigned int   disable_frame_end_update_cdf : 1;    // 1: indicates that the end of frame CDF update is disabled
+    unsigned int   delta_q_present : 1;                 // quantizer index delta values are present in the block level
+    unsigned int   delta_q_res : 2;                     // left shift which should be applied to decoded quantizer index delta values
+    unsigned int   using_qmatrix : 1;                   // 1: quantizer matrix will be used to compute quantizers
+    unsigned int   coded_lossless : 1;                  // 1: all segments use lossless coding
+    unsigned int   use_superres : 1;                    // 1: superres enabled for frame
+    unsigned int   tx_mode : 2;                         // 0: ONLY4x4,1:LARGEST,2:SELECT
+    unsigned int   reference_mode : 1;                  // 0: SINGLE, 1: SELECT
+    unsigned int   allow_warped_motion : 1;             // 1: allow_warped_motion may be present, 0: allow_warped_motion will not be present
+    unsigned int   reduced_tx_set : 1;                  // 1: frame is restricted to subset of the full set of transform types, 0: no such restriction
+    unsigned int   skip_mode : 1;                       // 1: most of the mode info is skipped, 0: mode info is not skipped
+    unsigned int   reserved1_3bits : 3;                 // reserved bits; must be set to 0
+
+    // tiling info
+    unsigned int   num_tile_cols : 8;                   // number of tiles across the frame., max is 64
+    unsigned int   num_tile_rows : 8;                   // number of tiles down the frame., max is 64
+    unsigned int   context_update_tile_id : 16;         // specifies which tile to use for the CDF update
+    unsigned short tile_widths[64];                     // Width of each column in superblocks
+    unsigned short tile_heights[64];                    // height of each row in superblocks
+
+    // CDEF - refer to section 6.10.14 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned char  cdef_damping_minus_3 : 2;            // controls the amount of damping in the deringing filter
+    unsigned char  cdef_bits : 2;                       // the number of bits needed to specify which CDEF filter to apply
+    unsigned char  reserved2_4bits : 4;                 // reserved bits; must be set to 0
+    unsigned char  cdef_y_strength[8];                  // 0-3 bits: y_pri_strength, 4-7 bits y_sec_strength
+    unsigned char  cdef_uv_strength[8];                 // 0-3 bits: uv_pri_strength, 4-7 bits uv_sec_strength
+
+    // SkipModeFrames
+    unsigned char   SkipModeFrame0 : 4;                 // specifies the frames to use for compound prediction when skip_mode is equal to 1.
+    unsigned char   SkipModeFrame1 : 4;
+
+    // qp information - refer to section 6.8.11 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned char  base_qindex;                         // indicates the base frame qindex. Defined as base_q_idx in AV1 specification
+    char           qp_y_dc_delta_q;                     // indicates the Y DC quantizer relative to base_q_idx. Defined as DeltaQYDc in AV1 specification
+    char           qp_u_dc_delta_q;                     // indicates the U DC quantizer relative to base_q_idx. Defined as DeltaQUDc in AV1 specification
+    char           qp_v_dc_delta_q;                     // indicates the V DC quantizer relative to base_q_idx. Defined as DeltaQVDc in AV1 specification
+    char           qp_u_ac_delta_q;                     // indicates the U AC quantizer relative to base_q_idx. Defined as DeltaQUAc in AV1 specification
+    char           qp_v_ac_delta_q;                     // indicates the V AC quantizer relative to base_q_idx. Defined as DeltaQVAc in AV1 specification
+    unsigned char  qm_y;                                // specifies the level in the quantizer matrix that should be used for luma plane decoding
+    unsigned char  qm_u;                                // specifies the level in the quantizer matrix that should be used for chroma U plane decoding
+    unsigned char  qm_v;                                // specifies the level in the quantizer matrix that should be used for chroma V plane decoding
+
+    // segmentation - refer to section 6.8.13 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned char segmentation_enabled : 1;             // 1 indicates that this frame makes use of the segmentation tool
+    unsigned char segmentation_update_map : 1;          // 1 indicates that the segmentation map are updated during the decoding of this frame
+    unsigned char segmentation_update_data : 1;         // 1 indicates that new parameters are about to be specified for each segment
+    unsigned char segmentation_temporal_update : 1;     // 1 indicates that the updates to the segmentation map are coded relative to the existing segmentation map
+    unsigned char reserved3_4bits : 4;                  // reserved bits; must be set to 0
+    short         segmentation_feature_data[8][8];      // specifies the feature data for a segment feature
+    unsigned char segmentation_feature_mask[8];         // indicates that the corresponding feature is unused or feature value is coded
+
+    // loopfilter - refer to section 6.8.10 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned char  loop_filter_level[2];                // contains loop filter strength values
+    unsigned char  loop_filter_level_u;                 // loop filter strength value of U plane
+    unsigned char  loop_filter_level_v;                 // loop filter strength value of V plane
+    unsigned char  loop_filter_sharpness;               // indicates the sharpness level
+    char           loop_filter_ref_deltas[8];           // contains the adjustment needed for the filter level based on the chosen reference frame
+    char           loop_filter_mode_deltas[2];          // contains the adjustment needed for the filter level based on the chosen mode
+    unsigned char  loop_filter_delta_enabled : 1;       // indicates that the filter level depends on the mode and reference frame used to predict a block
+    unsigned char  loop_filter_delta_update : 1;        // indicates that additional syntax elements are present that specify which mode and
+                                                        // reference frame deltas are to be updated
+    unsigned char  delta_lf_present : 1;                // specifies whether loop filter delta values are present in the block level
+    unsigned char  delta_lf_res : 2;                    // specifies the left shift to apply to the decoded loop filter values
+    unsigned char  delta_lf_multi  : 1;                 // separate loop filter deltas for Hy,Vy,U,V edges
+    unsigned char  reserved4_2bits : 2;                 // reserved bits; must be set to 0
+
+    // restoration - refer to section 6.10.15 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned char lr_unit_size[3];                     // specifies the size of loop restoration units: 0: 32, 1: 64, 2: 128, 3: 256
+    unsigned char lr_type[3] ;                         // used to compute FrameRestorationType
+
+    // reference frames
+    unsigned char primary_ref_frame;                    // specifies which reference frame contains the CDF values and other state that should be
+                                                        // loaded at the start of the frame
+    unsigned char ref_frame_map[8];                     // frames in dpb that can be used as reference for current or future frames
+
+    unsigned char temporal_layer_id : 4;                // temporal layer id
+    unsigned char spatial_layer_id : 4;                 // spatial layer id
+
+    unsigned char reserved5_32bits[4];                  // reserved bits; must be set to 0
+
+    // ref frame list
+    struct
+    {
+        unsigned int   width;
+        unsigned int   height;
+        unsigned char  index;
+        unsigned char  reserved24Bits[3];               // reserved bits; must be set to 0
+    } ref_frame[7];                                     // frames used as reference frame for current frame.
+
+    // global motion
+    struct {
+        unsigned char invalid : 1;
+        unsigned char wmtype : 2;                       // defined as GmType in AV1 specification
+        unsigned char reserved5Bits : 5;                // reserved bits; must be set to 0
+        char          reserved24Bits[3];                // reserved bits; must be set to 0
+        int           wmmat[6];                         // defined as gm_params[] in AV1 specification
+    } global_motion[7];                                 // global motion params for reference frames
+
+    // film grain params - refer to section 6.8.20 of the AV1 specification Version 1.0.0 with Errata 1
+    unsigned short apply_grain : 1;
+    unsigned short overlap_flag : 1;
+    unsigned short scaling_shift_minus8 : 2;
+    unsigned short chroma_scaling_from_luma : 1;
+    unsigned short ar_coeff_lag : 2;
+    unsigned short ar_coeff_shift_minus6 : 2;
+    unsigned short grain_scale_shift : 2;
+    unsigned short clip_to_restricted_range : 1;
+    unsigned short reserved6_4bits : 4;                 // reserved bits; must be set to 0
+    unsigned char  num_y_points;
+    unsigned char  scaling_points_y[14][2];
+    unsigned char  num_cb_points;
+    unsigned char  scaling_points_cb[10][2];
+    unsigned char  num_cr_points;
+    unsigned char  scaling_points_cr[10][2];
+    unsigned char  reserved7_8bits;                     // reserved bits; must be set to 0
+    unsigned short random_seed;
+    short          ar_coeffs_y[24];
+    short          ar_coeffs_cb[25];
+    short          ar_coeffs_cr[25];
+    unsigned char  cb_mult;
+    unsigned char  cb_luma_mult;
+    short          cb_offset;
+    unsigned char  cr_mult;
+    unsigned char  cr_luma_mult;
+    short          cr_offset;
+
+    int            reserved[7];                       // reserved bits; must be set to 0
+} CUVIDAV1PICPARAMS;
+
+/******************************************************************************************/
+//! \struct CUVIDPICPARAMS
+//! Picture parameters for decoding
+//! This structure is used in cuvidDecodePicture API
+//! IN  for cuvidDecodePicture
+/******************************************************************************************/
+typedef struct _CUVIDPICPARAMS
+{
+    int PicWidthInMbs;                     /**< IN: Coded frame size in macroblocks                           */
+    int FrameHeightInMbs;                  /**< IN: Coded frame height in macroblocks                         */
+    int CurrPicIdx;                        /**< IN: Output index of the current picture                       */
+    int field_pic_flag;                    /**< IN: 0=frame picture, 1=field picture                          */
+    int bottom_field_flag;                 /**< IN: 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
+    int second_field;                      /**< IN: Second field of a complementary field pair                */
+    // Bitstream data
+    unsigned int nBitstreamDataLen;        /**< IN: Number of bytes in bitstream data buffer                  */
+    const unsigned char *pBitstreamData;   /**< IN: Ptr to bitstream data for this picture (slice-layer)      */
+    unsigned int nNumSlices;               /**< IN: Number of slices in this picture                          */
+    const unsigned int *pSliceDataOffsets; /**< IN: nNumSlices entries, contains offset of each slice within
+                                                        the bitstream data buffer                             */
+    int ref_pic_flag;                      /**< IN: This picture is a reference picture                       */
+    int intra_pic_flag;                    /**< IN: This picture is entirely intra coded                      */
+    unsigned int Reserved[30];             /**< Reserved for future use                                       */
+    // IN: Codec-specific data
+    union {
+        CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */
+        CUVIDH264PICPARAMS  h264;
+        CUVIDVC1PICPARAMS   vc1;
+        CUVIDMPEG4PICPARAMS mpeg4;
+        CUVIDJPEGPICPARAMS  jpeg;
+        CUVIDHEVCPICPARAMS  hevc;
+        CUVIDVP8PICPARAMS   vp8;
+        CUVIDVP9PICPARAMS   vp9;
+        CUVIDAV1PICPARAMS   av1;
+        unsigned int CodecReserved[1024];
+    } CodecSpecific;
+} CUVIDPICPARAMS;
+
+
+/******************************************************/
+//! \struct CUVIDPROCPARAMS
+//! Picture parameters for postprocessing
+//! This structure is used in cuvidMapVideoFrame API
+/******************************************************/
+typedef struct _CUVIDPROCPARAMS
+{
+    int progressive_frame;                        /**< IN: Input is progressive (deinterlace_mode will be ignored)                */
+    int second_field;                             /**< IN: Output the second field (ignored if deinterlace mode is Weave)         */
+    int top_field_first;                          /**< IN: Input frame is top field first (1st field is top, 2nd field is bottom) */
+    int unpaired_field;                           /**< IN: Input only contains one field (2nd field is invalid)                   */
+    // The fields below are used for raw YUV input
+    unsigned int reserved_flags;                  /**< Reserved for future use (set to zero)                                      */
+    unsigned int reserved_zero;                   /**< Reserved (set to zero)                                                     */
+    unsigned long long raw_input_dptr;            /**< IN: Input CUdeviceptr for raw YUV extensions                               */
+    unsigned int raw_input_pitch;                 /**< IN: pitch in bytes of raw YUV input (should be aligned appropriately)      */
+    unsigned int raw_input_format;                /**< IN: Input YUV format (cudaVideoCodec_enum)                                 */
+    unsigned long long raw_output_dptr;           /**< IN: Output CUdeviceptr for raw YUV extensions                              */
+    unsigned int raw_output_pitch;                /**< IN: pitch in bytes of raw YUV output (should be aligned appropriately)     */
+    unsigned int Reserved1;                       /**< Reserved for future use (set to zero)                                      */
+    CUstream output_stream;                       /**< IN: stream object used by cuvidMapVideoFrame                               */
+    unsigned int Reserved[46];                    /**< Reserved for future use (set to zero)                                      */
+    unsigned long long *histogram_dptr;           /**< OUT: Output CUdeviceptr for histogram extensions                           */
+    void *Reserved2[1];                           /**< Reserved for future use (set to zero)                                      */
+} CUVIDPROCPARAMS;
+
+/*********************************************************************************************************/
+//! \struct CUVIDGETDECODESTATUS
+//! Struct for reporting decode status.
+//! This structure is used in cuvidGetDecodeStatus API.
+/*********************************************************************************************************/
+typedef struct _CUVIDGETDECODESTATUS
+{
+    cuvidDecodeStatus decodeStatus;
+    unsigned int reserved[31];
+    void *pReserved[8];
+} CUVIDGETDECODESTATUS;
+
+/****************************************************/
+//! \struct CUVIDRECONFIGUREDECODERINFO
+//! Struct for decoder reset
+//! This structure is used in cuvidReconfigureDecoder() API
+/****************************************************/
+typedef struct _CUVIDRECONFIGUREDECODERINFO
+{
+    unsigned int ulWidth;             /**< IN: Coded sequence width in pixels, MUST be < = ulMaxWidth defined at CUVIDDECODECREATEINFO  */
+    unsigned int ulHeight;            /**< IN: Coded sequence height in pixels, MUST be < = ulMaxHeight defined at CUVIDDECODECREATEINFO  */
+    unsigned int ulTargetWidth;       /**< IN: Post processed output width */
+    unsigned int ulTargetHeight;      /**< IN: Post Processed output height */
+    unsigned int ulNumDecodeSurfaces; /**< IN: Maximum number of internal decode surfaces */
+    unsigned int reserved1[12];       /**< Reserved for future use. Set to Zero */
+    /**
+    * IN: Area of frame to be displayed. Use-case : Source Cropping
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } display_area;
+    /**
+    * IN: Target Rectangle in the OutputFrame. Use-case : Aspect ratio Conversion
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } target_rect;
+    unsigned int reserved2[11]; /**< Reserved for future use. Set to Zero */
+} CUVIDRECONFIGUREDECODERINFO;
+
+
+/***********************************************************************************************************/
+//! VIDEO_DECODER
+//!
+//! In order to minimize decode latencies, there should be always at least 2 pictures in the decode
+//! queue at any time, in order to make sure that all decode engines are always busy.
+//!
+//! Overall data flow:
+//!  - cuvidGetDecoderCaps(...)
+//!  - cuvidCreateDecoder(...)
+//!  - For each picture:
+//!    + cuvidDecodePicture(N)
+//!    + cuvidMapVideoFrame(N-4)
+//!    + do some processing in cuda
+//!    + cuvidUnmapVideoFrame(N-4)
+//!    + cuvidDecodePicture(N+1)
+//!    + cuvidMapVideoFrame(N-3)
+//!    + ...
+//!  - cuvidDestroyDecoder(...)
+//!
+//! NOTE:
+//! - When the cuda context is created from a D3D device, the D3D device must also be created
+//!   with the D3DCREATE_MULTITHREADED flag.
+//! - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)
+//! - cuvidDecodePicture may block the calling thread if there are too many pictures pending
+//!   in the decode queue
+/***********************************************************************************************************/
+
+
+/**********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetDecoderCaps(CUVIDDECODECAPS *pdc)
+//! Queries decode capabilities of NVDEC-HW based on CodecType, ChromaFormat and BitDepthMinus8 parameters.
+//! 1. Application fills IN parameters CodecType, ChromaFormat and BitDepthMinus8 of CUVIDDECODECAPS structure
+//! 2. On calling cuvidGetDecoderCaps, driver fills OUT parameters if the IN parameters are supported
+//!    If IN parameters passed to the driver are not supported by NVDEC-HW, then all OUT params are set to 0.
+//! E.g. on Geforce GTX 960:
+//!   App fills - eCodecType = cudaVideoCodec_H264; eChromaFormat = cudaVideoChromaFormat_420; nBitDepthMinus8 = 0;
+//!   Given IN parameters are supported, hence driver fills: bIsSupported = 1; nMinWidth   = 48; nMinHeight  = 16;
+//!   nMaxWidth = 4096; nMaxHeight = 4096; nMaxMBCount = 65536;
+//! CodedWidth*CodedHeight/256 must be less than or equal to nMaxMBCount
+/**********************************************************************************************************************/
+extern CUresult CUDAAPI cuvidGetDecoderCaps(CUVIDDECODECAPS *pdc);
+
+/*****************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
+//! Create the decoder object based on pdci. A handle to the created decoder is returned
+/*****************************************************************************************************/
+extern CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
+
+/*****************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
+//! Destroy the decoder object
+/*****************************************************************************************************/
+extern CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder);
+
+/*****************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
+//! Decode a single picture (field or frame)
+//! Kicks off HW decoding
+/*****************************************************************************************************/
+extern CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
+
+/************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetDecodeStatus(CUvideodecoder hDecoder, int nPicIdx);
+//! Get the decode status for frame corresponding to nPicIdx
+//! API is supported for Maxwell and above generation GPUs.
+//! API is currently supported for HEVC, H264 and JPEG codecs.
+//! API returns CUDA_ERROR_NOT_SUPPORTED error code for unsupported GPU or codec.
+/************************************************************************************************************/
+extern CUresult CUDAAPI cuvidGetDecodeStatus(CUvideodecoder hDecoder, int nPicIdx, CUVIDGETDECODESTATUS* pDecodeStatus);
+
+/*********************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidReconfigureDecoder(CUvideodecoder hDecoder, CUVIDRECONFIGUREDECODERINFO *pDecReconfigParams)
+//! Used to reuse single decoder for multiple clips. Currently supports resolution change, resize params, display area
+//! params, target area params change for same codec. Must be called during CUVIDPARSERPARAMS::pfnSequenceCallback
+/*********************************************************************************************************/
+extern CUresult CUDAAPI cuvidReconfigureDecoder(CUvideodecoder hDecoder, CUVIDRECONFIGUREDECODERINFO *pDecReconfigParams);
+
+
+#if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)
+/************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr,
+//!                                         unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/************************************************************************************************************************/
+extern CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,
+                                           unsigned int *pDevPtr, unsigned int *pPitch,
+                                           CUVIDPROCPARAMS *pVPP);
+
+/*****************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)
+//! Unmap a previously mapped video frame
+/*****************************************************************************************************/
+extern CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
+#endif
+
+/****************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+//!                                           unsigned int * pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/****************************************************************************************************************************/
+extern CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+                                             unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+
+/**************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+//! Unmap a previously mapped video frame
+/**************************************************************************************************/
+extern CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+
+#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
+#define cuvidMapVideoFrame      cuvidMapVideoFrame64
+#define cuvidUnmapVideoFrame    cuvidUnmapVideoFrame64
+#endif
+
+
+
+/********************************************************************************************************************/
+//!
+//! Context-locking: to facilitate multi-threaded implementations, the following 4 functions
+//! provide a simple mutex-style host synchronization. If a non-NULL context is specified
+//! in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given
+//! context before making any cuda calls.
+//! A multi-threaded application could create a lock associated with a context handle so that
+//! multiple threads can safely share the same cuda context:
+//!  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context
+//!    that can be passed to cuvidCtxLockCreate.
+//!  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.
+//!
+//! NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video
+//! decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).
+/********************************************************************************************************************/
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)
+//! This API is used to create CtxLock object
+/********************************************************************************************************************/
+extern CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
+//! This API is used to free CtxLock object
+/********************************************************************************************************************/
+extern CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to acquire ctxlock
+/********************************************************************************************************************/
+extern CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to release ctxlock
+/********************************************************************************************************************/
+extern CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+// Auto-lock helper for C++ applications
+class CCtxAutoLock
+{
+private:
+    CUvideoctxlock m_ctx;
+public:
+    CCtxAutoLock(CUvideoctxlock ctx):m_ctx(ctx) { cuvidCtxLock(m_ctx,0); }
+    ~CCtxAutoLock() { cuvidCtxUnlock(m_ctx,0); }
+};
+#endif /* __cplusplus */
+
+#endif // __CUDA_VIDEO_H__

video_codec_sdk/Interface/nvcuvid.h

@@ -0,0 +1,554 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2024 NVIDIA Corporation
+ *
+ * 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.
+ */
+
+/********************************************************************************************************************/
+//! \file nvcuvid.h
+//!   NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! \date 2015-2024
+//!  This file contains the interface constants, structure definitions and function prototypes.
+/********************************************************************************************************************/
+
+#if !defined(__NVCUVID_H__)
+#define __NVCUVID_H__
+
+#include "cuviddec.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+#define MAX_CLOCK_TS 3
+
+/***********************************************/
+//!
+//! High-level helper APIs for video sources
+//!
+/***********************************************/
+
+typedef void *CUvideosource;
+typedef void *CUvideoparser;
+typedef long long CUvideotimestamp;
+
+
+/************************************************************************/
+//! \enum cudaVideoState
+//! Video source state enums
+//! Used in cuvidSetVideoSourceState and cuvidGetVideoSourceState APIs
+/************************************************************************/
+typedef enum {
+    cudaVideoState_Error   = -1,    /**< Error state (invalid source)                  */
+    cudaVideoState_Stopped = 0,     /**< Source is stopped (or reached end-of-stream)  */
+    cudaVideoState_Started = 1      /**< Source is running and delivering data         */
+} cudaVideoState;
+
+/************************************************************************/
+//! \enum cudaAudioCodec
+//! Audio compression enums
+//! Used in CUAUDIOFORMAT structure
+/************************************************************************/
+typedef enum {
+    cudaAudioCodec_MPEG1=0,         /**< MPEG-1 Audio               */
+    cudaAudioCodec_MPEG2,           /**< MPEG-2 Audio               */
+    cudaAudioCodec_MP3,             /**< MPEG-1 Layer III Audio     */
+    cudaAudioCodec_AC3,             /**< Dolby Digital (AC3) Audio  */
+    cudaAudioCodec_LPCM,            /**< PCM Audio                  */
+    cudaAudioCodec_AAC,             /**< AAC Audio                  */
+} cudaAudioCodec;
+
+/************************************************************************/
+//! \ingroup STRUCTS
+//! \struct TIMECODESET
+//! Used to store Time code set extracted from H264 and HEVC codecs
+/************************************************************************/
+typedef struct _TIMECODESET
+{
+    unsigned int time_offset_value;
+    unsigned short n_frames;
+    unsigned char clock_timestamp_flag;
+    unsigned char units_field_based_flag;
+    unsigned char counting_type;
+    unsigned char full_timestamp_flag;
+    unsigned char discontinuity_flag;
+    unsigned char cnt_dropped_flag;
+    unsigned char seconds_value;
+    unsigned char minutes_value;
+    unsigned char hours_value;
+    unsigned char seconds_flag;
+    unsigned char minutes_flag;
+    unsigned char hours_flag;
+    unsigned char time_offset_length;
+    unsigned char reserved;
+} TIMECODESET;
+
+/************************************************************************/
+//! \ingroup STRUCTS
+//! \struct TIMECODE
+//! Used to extract Time code in H264 and HEVC codecs
+/************************************************************************/
+typedef struct _TIMECODE
+{
+    TIMECODESET time_code_set[MAX_CLOCK_TS];
+    unsigned char num_clock_ts;
+} TIMECODE;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct SEIMASTERINGDISPLAYINFO
+//! Used to extract mastering display color volume SEI in H264 and HEVC codecs
+/**********************************************************************************/
+typedef struct _SEIMASTERINGDISPLAYINFO
+{
+    unsigned short display_primaries_x[3];
+    unsigned short display_primaries_y[3];
+    unsigned short white_point_x;
+    unsigned short white_point_y;
+    unsigned int max_display_mastering_luminance;
+    unsigned int min_display_mastering_luminance;
+} SEIMASTERINGDISPLAYINFO;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct SEICONTENTLIGHTLEVELINFO
+//! Used to extract content light level info SEI in H264 and HEVC codecs
+/**********************************************************************************/
+typedef struct _SEICONTENTLIGHTLEVELINFO
+{
+    unsigned short max_content_light_level;
+    unsigned short max_pic_average_light_level;
+    unsigned int reserved;
+} SEICONTENTLIGHTLEVELINFO;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct TIMECODEMPEG2
+//! Used to extract Time code in MPEG2 codec
+/**********************************************************************************/
+typedef struct _TIMECODEMPEG2
+{
+    unsigned char drop_frame_flag;
+    unsigned char time_code_hours;
+    unsigned char time_code_minutes;
+    unsigned char marker_bit;
+    unsigned char time_code_seconds;
+    unsigned char time_code_pictures;
+} TIMECODEMPEG2;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct SEIALTERNATIVETRANSFERCHARACTERISTICS
+//! Used to extract alternative transfer characteristics SEI in H264 and HEVC codecs
+/**********************************************************************************/
+typedef struct _SEIALTERNATIVETRANSFERCHARACTERISTICS
+{
+    unsigned char preferred_transfer_characteristics;
+} SEIALTERNATIVETRANSFERCHARACTERISTICS;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUSEIMESSAGE;
+//! Used in CUVIDSEIMESSAGEINFO structure
+/**********************************************************************************/
+typedef struct _CUSEIMESSAGE
+{
+    unsigned char sei_message_type; /**< OUT: SEI Message Type      */
+    unsigned char reserved[3];
+    unsigned int sei_message_size;  /**< OUT: SEI Message Size      */
+} CUSEIMESSAGE;
+
+/************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMAT
+//! Video format
+//! Used in cuvidGetSourceVideoFormat API
+/************************************************************************************************/
+typedef struct
+{
+    cudaVideoCodec codec;                   /**< OUT: Compression format          */
+   /**
+    * OUT: frame rate = numerator / denominator (for example: 30000/1001)
+    */
+    struct {
+        /**< OUT: frame rate numerator   (0 = unspecified or variable frame rate) */
+        unsigned int numerator;
+        /**< OUT: frame rate denominator (0 = unspecified or variable frame rate) */
+        unsigned int denominator;
+    } frame_rate;
+    unsigned char progressive_sequence;     /**< OUT: 0=interlaced, 1=progressive                                      */
+    unsigned char bit_depth_luma_minus8;    /**< OUT: high bit depth luma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth   */
+    unsigned char bit_depth_chroma_minus8;  /**< OUT: high bit depth chroma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth */
+    unsigned char min_num_decode_surfaces;  /**< OUT: Minimum number of decode surfaces to be allocated for correct
+                                                      decoding. The client can send this value in ulNumDecodeSurfaces
+                                                      (in CUVIDDECODECREATEINFO structure).
+                                                      This guarantees correct functionality and optimal video memory
+                                                      usage but not necessarily the best performance, which depends on
+                                                      the design of the overall application. The optimal number of
+                                                      decode surfaces (in terms of performance and memory utilization)
+                                                      should be decided by experimentation for each application, but it
+                                                      cannot go below min_num_decode_surfaces.
+                                                      If this value is used for ulNumDecodeSurfaces then it must be
+                                                      returned to parser during sequence callback.                     */
+    unsigned int coded_width;               /**< OUT: coded frame width in pixels                                      */
+    unsigned int coded_height;              /**< OUT: coded frame height in pixels                                     */
+   /**
+    * area of the frame that should be displayed
+    * typical example:
+    * coded_width = 1920, coded_height = 1088
+    * display_area = { 0,0,1920,1080 }
+    */
+    struct {
+        int left;                           /**< OUT: left position of display rect    */
+        int top;                            /**< OUT: top position of display rect     */
+        int right;                          /**< OUT: right position of display rect   */
+        int bottom;                         /**< OUT: bottom position of display rect  */
+    } display_area;
+    cudaVideoChromaFormat chroma_format;    /**< OUT:  Chroma format                   */
+    unsigned int bitrate;                   /**< OUT: video bitrate (bps, 0=unknown)   */
+   /**
+    * OUT: Display Aspect Ratio = x:y (4:3, 16:9, etc)
+    */
+    struct {
+        int x;
+        int y;
+    } display_aspect_ratio;
+    /**
+    * Video Signal Description
+    * Refer section E.2.1 (VUI parameters semantics) of H264 spec file
+    */
+    struct {
+        unsigned char video_format          : 3; /**< OUT: 0-Component, 1-PAL, 2-NTSC, 3-SECAM, 4-MAC, 5-Unspecified     */
+        unsigned char video_full_range_flag : 1; /**< OUT: indicates the black level and luma and chroma range           */
+        unsigned char reserved_zero_bits    : 4; /**< Reserved bits                                                      */
+        unsigned char color_primaries;           /**< OUT: chromaticity coordinates of source primaries                  */
+        unsigned char transfer_characteristics;  /**< OUT: opto-electronic transfer characteristic of the source picture */
+        unsigned char matrix_coefficients;       /**< OUT: used in deriving luma and chroma signals from RGB primaries   */
+    } video_signal_description;
+    unsigned int seqhdr_data_length;             /**< OUT: Additional bytes following (CUVIDEOFORMATEX)                  */
+} CUVIDEOFORMAT;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDOPERATINGPOINTINFO
+//! Operating point information of scalable bitstream
+/****************************************************************/
+typedef struct
+{
+    cudaVideoCodec codec;
+    union
+    {
+        struct
+        {
+            unsigned char  operating_points_cnt;
+            unsigned char  reserved24_bits[3];
+            unsigned short operating_points_idc[32];
+        } av1;
+        unsigned char CodecReserved[1024];
+    };
+} CUVIDOPERATINGPOINTINFO;
+
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSEIMESSAGEINFO
+//! Used in cuvidParseVideoData API with PFNVIDSEIMSGCALLBACK pfnGetSEIMsg
+/**********************************************************************************/
+typedef struct _CUVIDSEIMESSAGEINFO
+{
+    void *pSEIData;                 /**< OUT: SEI Message Data      */
+    CUSEIMESSAGE *pSEIMessage;      /**< OUT: SEI Message Info      */
+    unsigned int sei_message_count; /**< OUT: SEI Message Count     */
+    unsigned int picIdx;            /**< OUT: SEI Message Pic Index */
+} CUVIDSEIMESSAGEINFO;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDAV1SEQHDR
+//! AV1 specific sequence header information
+/****************************************************************/
+typedef struct {
+    unsigned int max_width;
+    unsigned int max_height;
+    unsigned char reserved[1016];
+} CUVIDAV1SEQHDR;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMATEX
+//! Video format including raw sequence header information
+//! Used in cuvidGetSourceVideoFormat API
+/****************************************************************/
+typedef struct
+{
+    CUVIDEOFORMAT format;                 /**< OUT: CUVIDEOFORMAT structure */
+    union {
+        CUVIDAV1SEQHDR av1;
+        unsigned char raw_seqhdr_data[1024];  /**< OUT: Sequence header data    */
+    };
+} CUVIDEOFORMATEX;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUAUDIOFORMAT
+//! Audio formats
+//! Used in cuvidGetSourceAudioFormat API
+/****************************************************************/
+typedef struct
+{
+    cudaAudioCodec codec;       /**< OUT: Compression format                                              */
+    unsigned int channels;      /**< OUT: number of audio channels                                        */
+    unsigned int samplespersec; /**< OUT: sampling frequency                                              */
+    unsigned int bitrate;       /**< OUT: For uncompressed, can also be used to determine bits per sample */
+    unsigned int reserved1;     /**< Reserved for future use                                              */
+    unsigned int reserved2;     /**< Reserved for future use                                              */
+} CUAUDIOFORMAT;
+
+
+/***************************************************************/
+//! \enum CUvideopacketflags
+//! Data packet flags
+//! Used in CUVIDSOURCEDATAPACKET structure
+/***************************************************************/
+typedef enum {
+    CUVID_PKT_ENDOFSTREAM   = 0x01,   /**< Set when this is the last packet for this stream                              */
+    CUVID_PKT_TIMESTAMP     = 0x02,   /**< Timestamp is valid                                                            */
+    CUVID_PKT_DISCONTINUITY = 0x04,   /**< Set when a discontinuity has to be signalled                                  */
+    CUVID_PKT_ENDOFPICTURE  = 0x08,   /**< Set when the packet contains exactly one frame or one field                   */
+    CUVID_PKT_NOTIFY_EOS    = 0x10,   /**< If this flag is set along with CUVID_PKT_ENDOFSTREAM, an additional (dummy)
+                                           display callback will be invoked with null value of CUVIDPARSERDISPINFO which
+                                           should be interpreted as end of the stream.                                   */
+} CUvideopacketflags;
+
+/*****************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEDATAPACKET
+//! Data Packet
+//! Used in cuvidParseVideoData API
+//! IN for cuvidParseVideoData
+/*****************************************************************************/
+typedef struct _CUVIDSOURCEDATAPACKET
+{
+    unsigned long flags;            /**< IN: Combination of CUVID_PKT_XXX flags                              */
+    unsigned long payload_size;     /**< IN: number of bytes in the payload (may be zero if EOS flag is set) */
+    const unsigned char *payload;   /**< IN: Pointer to packet payload data (may be NULL if EOS flag is set) */
+    CUvideotimestamp timestamp;     /**< IN: Presentation time stamp (10MHz clock), only valid if
+                                             CUVID_PKT_TIMESTAMP flag is set                                 */
+} CUVIDSOURCEDATAPACKET;
+
+// Callback for packet delivery
+typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);
+
+/**************************************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEPARAMS
+//! Describes parameters needed in cuvidCreateVideoSource API
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+typedef struct _CUVIDSOURCEPARAMS
+{
+    unsigned int ulClockRate;                   /**< IN: Time stamp units in Hz (0=default=10000000Hz)      */
+    unsigned int bAnnexb : 1;                   /**< IN: AV1 annexB stream                                  */
+    unsigned int uReserved : 31;                /**< Reserved for future use - set to zero                  */
+    unsigned int uReserved1[6];                 /**< Reserved for future use - set to zero                  */
+    void *pUserData;                            /**< IN: User private data passed in to the data handlers   */
+    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< IN: Called to deliver video packets                    */
+    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< IN: Called to deliver audio packets.                   */
+    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL                  */
+} CUVIDSOURCEPARAMS;
+
+
+/**********************************************/
+//! \ingroup ENUMS
+//! \enum CUvideosourceformat_flags
+//! CUvideosourceformat_flags
+//! Used in cuvidGetSourceVideoFormat API
+/**********************************************/
+typedef enum {
+    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */
+} CUvideosourceformat_flags;
+
+#if !defined(__APPLE__)
+/***************************************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create CUvideosource object. CUvideosource spawns demultiplexer thread that provides two callbacks:
+//! pfnVideoDataHandler() and pfnAudioDataHandler()
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/***************************************************************************************************************************/
+CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/***************************************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create video source
+/***************************************************************************************************************************/
+CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/********************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)
+//! Destroy video source
+/********************************************************************/
+CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj);
+
+/******************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)
+//! Set video source state to:
+//! cudaVideoState_Started - to signal the source to run and deliver data
+//! cudaVideoState_Stopped - to stop the source from delivering the data
+//! cudaVideoState_Error   - invalid source
+/******************************************************************************************/
+CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);
+
+/******************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)
+//! Get video source state
+//! Returns:
+//! cudaVideoState_Started - if Source is running and delivering data
+//! cudaVideoState_Stopped - if Source is stopped or reached end-of-stream
+//! cudaVideoState_Error   - if Source is in error state
+/******************************************************************************************/
+cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj);
+
+/******************************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)
+//! Gets video source format in pvidfmt, flags is set to combination of CUvideosourceformat_flags as per requirement
+/******************************************************************************************************************/
+CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);
+
+/**************************************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)
+//! Get audio source format
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);
+
+#endif
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERDISPINFO
+//! Used in cuvidParseVideoData API with PFNVIDDISPLAYCALLBACK pfnDisplayPicture
+/**********************************************************************************/
+typedef struct _CUVIDPARSERDISPINFO
+{
+    int picture_index;          /**< OUT: Index of the current picture                                                         */
+    int progressive_frame;      /**< OUT: 1 if progressive frame; 0 otherwise                                                  */
+    int top_field_first;        /**< OUT: 1 if top field is displayed first; 0 otherwise                                       */
+    int repeat_first_field;     /**< OUT: Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling,
+                                     -1=unpaired field)                                                                        */
+    CUvideotimestamp timestamp; /**< OUT: Presentation time stamp                                                              */
+} CUVIDPARSERDISPINFO;
+
+/***********************************************************************************************************************/
+//! Parser callbacks
+//! The parser will call these synchronously from within cuvidParseVideoData(), whenever there is sequence change or a picture
+//! is ready to be decoded and/or displayed. First argument in functions is "void *pUserData" member of structure CUVIDSOURCEPARAMS
+//! Return values from these callbacks are interpreted as below. If the callbacks return failure, it will be propagated by
+//! cuvidParseVideoData() to the application.
+//! Parser picks default operating point as 0 and outputAllLayers flag as 0 if PFNVIDOPPOINTCALLBACK is not set or return value is
+//! -1 or invalid operating point.
+//! PFNVIDSEQUENCECALLBACK : 0: fail, 1: succeeded, > 1: override dpb size of parser (set by CUVIDPARSERPARAMS::ulMaxNumDecodeSurfaces
+//! while creating parser)
+//! PFNVIDDECODECALLBACK   : 0: fail, >=1: succeeded
+//! PFNVIDDISPLAYCALLBACK  : 0: fail, >=1: succeeded
+//! PFNVIDOPPOINTCALLBACK  : <0: fail, >=0: succeeded (bit 0-9: OperatingPoint, bit 10-10: outputAllLayers, bit 11-30: reserved)
+//! PFNVIDSEIMSGCALLBACK   : 0: fail, >=1: succeeded
+/***********************************************************************************************************************/
+typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);
+typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);
+typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);
+typedef int (CUDAAPI *PFNVIDOPPOINTCALLBACK)(void *, CUVIDOPERATINGPOINTINFO*);
+typedef int (CUDAAPI *PFNVIDSEIMSGCALLBACK) (void *, CUVIDSEIMESSAGEINFO *);
+
+/**************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERPARAMS
+//! Used in cuvidCreateVideoParser API
+/**************************************/
+typedef struct _CUVIDPARSERPARAMS
+{
+    cudaVideoCodec CodecType;                   /**< IN: cudaVideoCodec_XXX                                                  */
+    unsigned int ulMaxNumDecodeSurfaces;        /**< IN: Max # of decode surfaces (parser will cycle through these)          */
+    unsigned int ulClockRate;                   /**< IN: Timestamp units in Hz (0=default=10000000Hz)                        */
+    unsigned int ulErrorThreshold;              /**< IN: % Error threshold (0-100) for calling pfnDecodePicture (100=always
+                                                     IN: call pfnDecodePicture even if picture bitstream is fully corrupted) */
+    unsigned int ulMaxDisplayDelay;             /**< IN: Max display queue delay (improves pipelining of decode with display)
+                                                         0=no delay (recommended values: 2..4)                               */
+    unsigned int bAnnexb         : 1;           /**< IN: AV1 annexB stream                                                   */
+    unsigned int bMemoryOptimize : 1;           /**< IN: Utilize minimum picIdx from dpb to allow memory saving at the
+                                                         decoder layer, use cuvidReconfigureDecoder() to increase the
+                                                         decode surfaces if needed  (perf may get impacted)                  */
+    unsigned int uReserved       : 30;          /**< Reserved for future use - set to zero                                   */
+    unsigned int uReserved1[4];                 /**< IN: Reserved for future use - set to 0                                  */
+    void *pUserData;                            /**< IN: User data for callbacks                                             */
+    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< IN: Called before decoding frames and/or whenever there is a fmt change */
+    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< IN: Called when a picture is ready to be decoded (decode order)         */
+    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< IN: Called whenever a picture is ready to be displayed (display order)  */
+    PFNVIDOPPOINTCALLBACK pfnGetOperatingPoint; /**< IN: Called from AV1 sequence header to get operating point of a AV1
+                                                         scalable bitstream                                                  */
+    PFNVIDSEIMSGCALLBACK pfnGetSEIMsg;          /**< IN: Called when all SEI messages are parsed for particular frame        */
+    void *pvReserved2[5];                       /**< Reserved for future use - set to NULL                                   */
+    CUVIDEOFORMATEX *pExtVideoInfo;             /**< IN: [Optional] sequence header data from system layer                   */
+} CUVIDPARSERPARAMS;
+
+/************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)
+//! Create video parser object and initialize
+/************************************************************************************************/
+CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);
+
+/************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)
+//! Parse the video data from source data packet in pPacket
+//! Extracts parameter sets like SPS, PPS, bitstream etc. from pPacket and
+//! calls back pfnDecodePicture with CUVIDPICPARAMS data for kicking of HW decoding
+//! calls back pfnSequenceCallback with CUVIDEOFORMAT data for initial sequence header or when
+//! the decoder encounters a video format change
+//! calls back pfnDisplayPicture with CUVIDPARSERDISPINFO data to display a video frame
+/************************************************************************************************/
+CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);
+
+/************************************************************************************************/
+//! \ingroup FUNCTS
+//! \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)
+//! Destroy the video parser
+/************************************************************************************************/
+CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __NVCUVID_H__

video_codec_sdk/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.

video_codec_sdk/Read_Me.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f794785ac920951fcb5cac95821ea58e2b63c51494c72c777bc62a87c1f8914c
+size 107645

video_codec_sdk/Samples/AppDecode/AppDec/AppDec.cpp

@@ -0,0 +1,423 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDec.cpp
+//! \brief Source file for AppDec sample
+//!
+//! This sample application illustrates the demuxing and decoding of a media file followed by resize and crop of the output frames.
+//! The application supports both planar (YUV420P and YUV420P16) and non-planar (NV12 and P016) output formats.
+//---------------------------------------------------------------------------
+
+#include <iostream>
+#include <algorithm>
+#include <thread>
+#include <cuda.h>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+
+void ConvertSemiplanarToPlanar(uint8_t *pHostFrame, int nWidth, int nHeight, int nBitDepth, uint8_t nChromaFormat) {
+    if (nBitDepth == 8) {
+        YuvConverter<uint8_t> converter8(nWidth, nHeight, nChromaFormat);
+        converter8.UVInterleavedToPlanar(pHostFrame);
+    } else {
+        YuvConverter<uint16_t> converter16(nWidth, nHeight, nChromaFormat);
+        converter16.UVInterleavedToPlanar((uint16_t *)pHostFrame);
+    }
+}
+
+/**
+*   @brief  Function to decode media file and write raw frames into an output file.
+*   @param  cuContext     - Handle to CUDA context
+*   @param  szInFilePath  - Path to file to be decoded
+*   @param  szOutFilePath - Path to output file into which raw frames are stored
+*   @param  bOutPlanar    - Flag to indicate whether output needs to be converted to planar format
+*   @param  cropRect      - Cropping rectangle coordinates
+*   @param  resizeDim     - Resizing dimensions for output
+*   @param  opPoint       - Select an operating point of an AV1 scalable bitstream
+*   @param  bDispAllLayers - Output all decoded frames of an AV1 scalable bitstream
+*   @param  bExtractUserSEIMessage - Output unregistered user SEI messages in display order
+    @param  bExtStream    - Flag to indicate whether to create the cuda stream in the App.
+*/
+void DecodeMediaFile(CUcontext cuContext, const char *szInFilePath, const char *szOutFilePath, bool bOutPlanar,
+    const Rect &cropRect, const Dim &resizeDim, const unsigned int opPoint, const bool bDispAllLayers, const bool bExtractUserSEIMessage,
+    unsigned int decsurf,bool bExtStream)
+{
+    std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+    if (!fpOut)
+    {
+        std::ostringstream err;
+        err << "Unable to open output file: " << szOutFilePath << std::endl;
+        throw std::invalid_argument(err.str());
+    }
+    CUstream cuStream = NULL;
+    
+    if(bExtStream)
+    {
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuStreamCreate(&cuStream, CU_STREAM_DEFAULT));
+    }
+    
+    FFmpegDemuxer demuxer(szInFilePath);
+    NvDecoder dec(cuContext, false, FFmpeg2NvCodecId(demuxer.GetVideoCodec()), false, false, &cropRect, &resizeDim, bExtractUserSEIMessage, 0, 0, 1000, false, decsurf, cuStream);
+
+    /* Set operating point for AV1 SVC. It has no impact for other profiles or codecs
+     * PFNVIDOPPOINTCALLBACK Callback from video parser will pick operating point set to NvDecoder  */
+    dec.SetOperatingPoint(opPoint, bDispAllLayers);
+
+    int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0;
+    uint8_t *pVideo = NULL, *pFrame;
+    bool bDecodeOutSemiPlanar = false;
+    do {
+        demuxer.Demux(&pVideo, &nVideoBytes);
+        nFrameReturned = dec.Decode(pVideo, nVideoBytes);
+        if (!nFrame && nFrameReturned)
+            LOG(INFO) << dec.GetVideoInfo();
+        
+        bDecodeOutSemiPlanar = (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12) || (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                               || (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV16) || (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P216);
+        
+        for (int i = 0; i < nFrameReturned; i++) {
+            pFrame = dec.GetFrame();
+            if(bExtStream)
+            {   
+                // If using external stream App needs to wait for memcpy to complete. 
+                ck(cuStreamSynchronize(cuStream));          
+            }
+            if (bOutPlanar && bDecodeOutSemiPlanar) {
+                ConvertSemiplanarToPlanar(pFrame, dec.GetWidth(), dec.GetHeight(), dec.GetBitDepth(), dec.GetOutputChromaFormat());
+            }
+            // dump YUV to disk
+            if (dec.GetWidth() == dec.GetDecodeWidth())
+            {
+                fpOut.write(reinterpret_cast<char*>(pFrame), dec.GetFrameSize());
+            }
+            else
+            {
+                // 4:2:0/4:2:2 output width is 2 byte aligned. If decoded width is odd , luma has 1 pixel padding
+                // Remove padding from luma while dumping it to disk
+                // dump luma
+                for (auto i = 0; i < dec.GetHeight(); i++)
+                {
+                    fpOut.write(reinterpret_cast<char*>(pFrame), dec.GetDecodeWidth()*dec.GetBPP());
+                    pFrame += dec.GetWidth() * dec.GetBPP();
+                }
+                // dump Chroma
+                fpOut.write(reinterpret_cast<char*>(pFrame), dec.GetChromaPlaneSize());
+            }
+        }
+        nFrame += nFrameReturned;
+    } while (nVideoBytes);
+    
+    if(cuStream)
+    {
+        ck(cuStreamDestroy(cuStream));
+        cuStream = NULL;
+        CUcontext tempCuContext;
+        ck(cuCtxPopCurrent(&tempCuContext));
+    }
+
+    std::vector <std::string> aszDecodeOutFormat = { "NV12", "P016", "YUV444", "YUV444P16", "NV16", "P216" };
+    if (bOutPlanar) {
+        aszDecodeOutFormat[0] = "iyuv";     aszDecodeOutFormat[1] = "yuv420p16";
+        aszDecodeOutFormat[4] = "yuv422p";  aszDecodeOutFormat[5] = "yuv422p16";
+    }
+    std::cout << "Total frame decoded: " << nFrame << std::endl
+            << "Saved in file " << szOutFilePath << " in "
+            << aszDecodeOutFormat[dec.GetOutputFormat()]
+            << " format" << std::endl;
+    fpOut.close();
+}
+
+void ShowBriefHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Sample Application\n";
+    oss << "====================================\n\n";
+    
+    oss << "Usage: AppDec -i <input_file> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << "N/A\n";
+    oss << std::left << std::setw(25) << "-o <path>" 
+        << std::setw(12) << "Optional"
+        << "out.native/.planar\n";
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+void ShowDetailedHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Sample Application - Detailed Help\n";
+    oss << "================================================\n\n";
+    
+    oss << "Usage: AppDec -i <input_file> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Example\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-i input.h264\n";
+
+    // Optional arguments
+    oss << std::left << std::setw(25) << "-o <path>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "out.native/.planar"
+        << "-o output.yuv\n";
+    oss << std::left << std::setw(25) << "-outplanar" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-outplanar\n";
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-gpu 1\n";
+    oss << std::left << std::setw(25) << "-crop <l,t,r,b>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "No cropping"
+        << "-crop 0,0,1920,1080\n";
+    oss << std::left << std::setw(25) << "-resize <WxH>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "No resizing"
+        << "-resize 1280x720\n";
+    oss << std::left << std::setw(25) << "-oppoint <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-oppoint 2\n";
+    oss << std::left << std::setw(25) << "-alllayers" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-alllayers\n";
+    oss << std::left << std::setw(25) << "-extractUserSEIMessage" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-extractUserSEIMessage\n";
+    oss << std::left << std::setw(25) << "-decsurf <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-decsurf 8\n";
+    oss << std::left << std::setw(25) << "-extCudaStrm" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-extCudaStrm\n";
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-i" << ": Input file path\n";
+    oss << std::left << std::setw(25) << "-o" << ": Output file path (defaults based on -outplanar flag)\n";
+    oss << std::left << std::setw(25) << "-outplanar" << ": Convert output to planar format\n";
+    oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n";
+    oss << std::left << std::setw(25) << "-crop" << ": Crop rectangle in left,top,right,bottom (ignored for case 0)\n";
+    oss << std::left << std::setw(25) << "-resize" << ": Resize to dimension W times H (ignored for case 0)\n";
+    oss << std::left << std::setw(25) << "-oppoint" << ": Select an operating point of an AV1 scalable bitstream\n";
+    oss << std::left << std::setw(25) << "-alllayers" << ": Output all decoded frames of an AV1 scalable bitstream\n";
+    oss << std::left << std::setw(25) << "-extractUserSEIMessage" << ": Output unregistered user SEI messages in display order\n";
+    oss << std::left << std::setw(25) << "-decsurf" << ": Allocate n number of decode surfaces at initialization\n";
+    oss << std::left << std::setw(25) << "-extCudaStrm" << ": Use external CUDA stream for memory operations\n";
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print usage information for common commandline options\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print usage information for common and advanced commandline options\n";
+    oss << std::left << std::setw(25) << "-dc/--decode-caps" << ": Print decode capabilities of GPU\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    oss << "* Width and height for crop and resize must be even numbers\n";
+    oss << "* Output format will be out.native unless -outplanar is specified\n";
+    oss << std::endl;
+
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+void ShowHelpAndExit(const char *szBadOption = NULL)
+{
+    if (szBadOption) 
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+void ParseCommandLine(int argc, char *argv[], char *szInputFileName, char *szOutputFileName,
+    bool &bOutPlanar, int &iGpu, Rect &cropRect, Dim &resizeDim, unsigned int &opPoint, bool &bDispAllLayers, bool &bExtractUserSEIMessage, unsigned int &decsurf, bool &bExtStream)
+{
+    std::ostringstream oss;
+    int i;
+    bDispAllLayers = false;
+    opPoint = 0;
+    if (argc == 1) {
+        std::cout << "No Arguments provided! Please refer to the following for options:" << "\"\n";
+        ShowBriefHelp();
+    }
+
+    for (i = 1; i < argc; i++) {
+        if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+            ShowBriefHelp();
+        }
+        if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+            ShowDetailedHelp();
+        }
+        if (!_stricmp(argv[i], "-dc") || !_stricmp(argv[i], "--decode-caps")) {
+            ShowDecoderCapability();
+        }
+        if (!_stricmp(argv[i], "-i")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-i");
+            }
+            sprintf(szInputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-o")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-o");
+            }
+            sprintf(szOutputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-outplanar")) {
+            bOutPlanar = true;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-gpu")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-gpu");
+            }
+            iGpu = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-crop")) {
+            if (++i == argc || 4 != sscanf(
+                    argv[i], "%d,%d,%d,%d",
+                    &cropRect.l, &cropRect.t, &cropRect.r, &cropRect.b)) {
+                ShowHelpAndExit("-crop");
+            }
+            if ((cropRect.r - cropRect.l) % 2 == 1 || (cropRect.b - cropRect.t) % 2 == 1) {
+                std::cout << "Cropping rect must have width and height of even numbers" << std::endl;
+                exit(1);
+            }
+            continue;
+        }
+        if (!_stricmp(argv[i], "-resize")) {
+            if (++i == argc || 2 != sscanf(argv[i], "%dx%d", &resizeDim.w, &resizeDim.h)) {
+                ShowHelpAndExit("-resize");
+            }
+            if (resizeDim.w % 2 == 1 || resizeDim.h % 2 == 1) {
+                std::cout << "Resizing rect must have width and height of even numbers" << std::endl;
+                exit(1);
+            }
+            continue;
+        }
+        if (!_stricmp(argv[i], "-oppoint")) {
+            if (++i == argc ) {
+                ShowHelpAndExit("-oppoint");
+            }
+            opPoint = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-alllayers")) {
+            
+            bDispAllLayers = true;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-extractUserSEIMessage")) {
+            bExtractUserSEIMessage = true;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-decsurf")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-decsurf");
+            }
+            decsurf = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-extCudaStrm")) {
+            bExtStream = true;
+            continue;
+        }
+        ShowHelpAndExit(argv[i]);
+    }
+}
+
+int main(int argc, char **argv) 
+{
+    char szInFilePath[256] = "", szOutFilePath[256] = "";
+    bool bOutPlanar = false;
+    int iGpu = 0;
+    Rect cropRect = {};
+    Dim resizeDim = {};
+    unsigned int opPoint = 0;
+    bool bDispAllLayers = false;
+    bool bExtractUserSEIMessage = false;
+    unsigned int decsurf = 0;
+    bool bExtStream = false;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, szOutFilePath, bOutPlanar, iGpu, cropRect, resizeDim, opPoint, bDispAllLayers, bExtractUserSEIMessage, decsurf, bExtStream);
+        CheckInputFile(szInFilePath);
+
+        if (!*szOutFilePath) {
+            sprintf(szOutFilePath, bOutPlanar ? "out.planar" : "out.native");
+        }
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu) {
+            std::cout << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            return 1;
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        std::cout << "Decode with demuxing." << std::endl;
+        DecodeMediaFile(cuContext, szInFilePath, szOutFilePath, bOutPlanar, cropRect, resizeDim, opPoint, bDispAllLayers, bExtractUserSEIMessage, decsurf, bExtStream);
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDec/CMakeLists.txt

@@ -0,0 +1,105 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDec)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDec.cpp
+)
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} )
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+if(MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_DEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+ ${NV_CODEC_DIR}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+endif()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB})
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecD3D/AppDecD3D.cpp

@@ -0,0 +1,163 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecD3D.cpp
+//! \brief Source file for AppDecD3D sample
+//!
+//! This sample application illustrates the decoding of media file and display of decoded frames in a window.
+//! This is done by CUDA interop with D3D(both D3D9 and D3D11).
+//! For a detailed list of supported codecs on your NVIDIA GPU, refer : https://developer.nvidia.com/nvidia-video-codec-sdk#NVDECFeatures
+
+
+#include <cuda.h>
+#include <iostream>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "FramePresenterD3D9.h"
+#include "FramePresenterD3D11.h"
+#include "../Common/AppDecUtils.h"
+#include "../Utils/ColorSpace.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+/**
+*   @brief Function template to decode media file pointed to by szInFilePath parameter.
+           The decoded frames are displayed by using the D3D-CUDA interop.
+           In this app FramePresenterType is either FramePresenterD3D9 or FramePresenterD3D11.
+           The presentation rate is based on per frame time stamp.
+*   @param  cuContext - Handle to CUDA context
+*   @param  szInFilePath - Path to file to be decoded
+*   @return 0 on success
+*/
+template<class FramePresenterType, typename = std::enable_if<std::is_base_of<FramePresenterD3D, FramePresenterType>::value>>
+int NvDecD3D(CUcontext cuContext, char *szInFilePath)
+{
+    unsigned int timescale = 1000; // get timestamp in milisecond
+    FFmpegDemuxer demuxer(szInFilePath, timescale);
+    NvDecoder dec(cuContext, true, FFmpeg2NvCodecId(demuxer.GetVideoCodec()), false, false, NULL, NULL, false, 0, 0, timescale);
+    int nRGBWidth = (demuxer.GetWidth() + 1) & ~1;
+    FramePresenterType presenter(cuContext, nRGBWidth, demuxer.GetHeight());
+    CUdeviceptr dpFrame = 0;
+    ck(cuMemAlloc(&dpFrame, nRGBWidth * demuxer.GetHeight() * 4));
+    int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0;
+    uint8_t *pVideo = NULL, *pFrame;
+    int64_t pts, timestamp = 0;
+    bool m_bFirstFrame = true;
+    int64_t firstPts = 0, startTime = 0;
+    LARGE_INTEGER m_Freq;
+    int iMatrix = 0;
+
+    QueryPerformanceFrequency(&m_Freq);
+
+    do
+    {
+        demuxer.Demux(&pVideo, &nVideoBytes, &pts);
+        nFrameReturned = dec.Decode(pVideo, nVideoBytes, 0, pts);
+        if (!nFrame && nFrameReturned)
+            LOG(INFO) << dec.GetVideoInfo();
+
+        for (int i = 0; i < nFrameReturned; i++)
+        {
+            pFrame = dec.GetFrame(&timestamp);
+            iMatrix = dec.GetVideoFormatInfo().video_signal_description.matrix_coefficients;
+            if (dec.GetBitDepth() == 8)
+            {
+                 if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                    YUV444ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                    Nv12ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else
+                    Nv16ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+            }
+            else
+            {
+                if(dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                    YUV444P16ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                    P016ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else
+                    P216ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, 4 * nRGBWidth, dec.GetWidth(), dec.GetHeight(), iMatrix);
+            }
+
+            LARGE_INTEGER counter;
+            if (m_bFirstFrame)
+            {
+                firstPts = timestamp;
+                QueryPerformanceCounter(&counter);
+                startTime = 1000 * counter.QuadPart / m_Freq.QuadPart;
+                m_bFirstFrame = false;
+            }
+
+            QueryPerformanceCounter(&counter);
+            int64_t curTime = timescale * counter.QuadPart / m_Freq.QuadPart;
+
+            int64_t expectedRenderTime = timestamp - firstPts + startTime;
+            int64_t delay = expectedRenderTime - curTime;
+            if (timestamp == 0)
+                delay = 0;
+            if (delay < 0)
+                continue;
+
+            presenter.PresentDeviceFrame((uint8_t *)dpFrame, nRGBWidth * 4, delay);
+        }
+        nFrame += nFrameReturned;
+    } while (nVideoBytes);
+    ck(cuMemFree(dpFrame));
+    std::cout << "Total frame decoded: " << nFrame << std::endl;
+    return 0;
+}
+
+int main(int argc, char **argv) 
+{
+    char szInFilePath[256] = "";
+    int iGpu = 0;
+    int iD3d = 0;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, NULL, iGpu, NULL, &iD3d);
+        CheckInputFile(szInFilePath);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+        CUdevice cuDevice = 0;
+        ck(cuDeviceGet(&cuDevice, iGpu));
+        char szDeviceName[80];
+        ck(cuDeviceGetName(szDeviceName, sizeof(szDeviceName), cuDevice));
+        std::cout << "GPU in use: " << szDeviceName << std::endl;
+        CUcontext cuContext = NULL;
+        ck(NVCODEC_CUDA_CTX_CREATE(&cuContext, CU_CTX_SCHED_BLOCKING_SYNC, cuDevice));
+
+        switch (iD3d) {
+        default:
+        case 9:
+            std::cout << "Display with D3D9." << std::endl;
+            return NvDecD3D<FramePresenterD3D9>(cuContext, szInFilePath);
+        case 11:
+            std::cout << "Display with D3D11." << std::endl;
+            return NvDecD3D<FramePresenterD3D11>(cuContext, szInFilePath);
+        }
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecD3D/CMakeLists.txt

@@ -0,0 +1,136 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecD3D)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecD3D.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_ENC_CUDA_UTILS
+ ${NVCODEC_UTILS_DIR}/ColorSpace.cu
+)
+
+set(NV_DEC_COMMON_HDR_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/../Common)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NVCODEC_UTILS_DIR}/ColorSpace.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+# CUDA 11.7 and later is compiled with /MT option (staticaly linked with C runtime), 
+# since we are statically linking cudart_static.lib with the app, 
+# we need to make sure that all .obj files linked are compiled with /MT to avoid linker warning LNK4098
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-Xcompiler /MT)
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+if(MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    target_compile_options(${PROJECT_NAME} PRIVATE "/MT")
+endif()
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+set(D3D9_LIBS d3d9.lib dxva2.lib d3dcompiler.lib)
+set(D3D11_LIBS d3d11.lib dxgi.lib d3dcompiler.lib)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.lib")
+
+endif ()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB} ${D3D9_LIBS} ${D3D11_LIBS})
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecD3D/FramePresenterD3D.h

@@ -0,0 +1,139 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+#pragma once
+#include <cuda.h>
+#include "../Utils/NvCodecUtils.h"
+
+/**
+* @brief Base class for D3D presentation of decoded frames
+*/
+class FramePresenterD3D {
+public:
+    /**
+    *   @brief  FramePresenterD3D constructor.
+    *   @param  cuContext - CUDA context handle
+    *   @param  nWidth - Width of D3D Surface
+    *   @param  nHeight - Height of D3D Surface
+    */
+    FramePresenterD3D(CUcontext cuContext, int nWidth, int nHeight) : cuContext(cuContext), nWidth(nWidth), nHeight(nHeight) {}
+    /**
+    *   @brief  FramePresenterD3D destructor.
+    */
+    virtual ~FramePresenterD3D() {};
+    /**
+    *   @brief  Pure virtual to be implemented by derived classes. Should present decoded frames available in device memory
+    *   @param  dpBgra - CUDA device pointer to BGRA surface
+    *   @param  nPitch - pitch of the BGRA surface. Typically width in pixels * number of bytes per pixel
+    *   @param  delay  - presentation delay. Cue to D3D presenter to inform about the time at which this frame needs to be presented
+    *   @return true on success
+    *   @return false on failure
+    */
+    virtual bool PresentDeviceFrame(unsigned char *dpBgra, int nPitch, int64_t delay) = 0;
+
+protected:
+    /**
+    *   @brief  Create and show D3D window.
+    *   @param  nWidth   - Width of the window
+    *   @param  nHeight  - Height of the window
+    *   @return hwndMain - handle to the created window
+    */
+    static HWND CreateAndShowWindow(int nWidth, int nHeight) {
+        double r = max(nWidth / 1280.0, nHeight / 720.0);
+        if (r > 1.0) {
+            nWidth = (int)(nWidth / r);
+            nHeight = (int)(nHeight / r);
+        }
+
+        static char szAppName[] = "D3DPresenter";
+        WNDCLASS wndclass;
+        wndclass.style = CS_HREDRAW | CS_VREDRAW;
+        wndclass.lpfnWndProc = WndProc;
+        wndclass.cbClsExtra = 0;
+        wndclass.cbWndExtra = 0;
+        wndclass.hInstance = (HINSTANCE)GetModuleHandle(NULL);
+        wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+        wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+        wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+        wndclass.lpszMenuName = NULL;
+        wndclass.lpszClassName = szAppName;
+        RegisterClass(&wndclass);
+
+        RECT rc{
+            (GetSystemMetrics(SM_CXSCREEN) - nWidth) / 2,
+            (GetSystemMetrics(SM_CYSCREEN) - nHeight) / 2,
+            (GetSystemMetrics(SM_CXSCREEN) + nWidth) / 2,
+            (GetSystemMetrics(SM_CYSCREEN) + nHeight) / 2
+        };
+        AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
+
+        HWND hwndMain = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW,
+            rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
+            NULL, NULL, wndclass.hInstance, NULL);
+        ShowWindow(hwndMain, SW_SHOW);
+        UpdateWindow(hwndMain);
+
+        return hwndMain;
+    }
+
+    /**
+    *   @brief  Copy device frame to cuda registered D3D surface. More specifically, this function maps the
+    *           D3D swap chain backbuffer into a cuda array and copies the contents of dpBgra into it.
+    *           This ensures that the swap chain back buffer will contain the next surface to be presented.
+    *   @param  dpBgra  - CUDA device pointer to BGRA surface
+    *   @param  nPitch  - pitch of the BGRA surface. Typically width in pixels * number of bytes per pixel
+    */
+    void CopyDeviceFrame(unsigned char *dpBgra, int nPitch) {
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuGraphicsMapResources(1, &cuResource, 0));
+        CUarray dstArray;
+        ck(cuGraphicsSubResourceGetMappedArray(&dstArray, cuResource, 0, 0));
+
+        CUDA_MEMCPY2D m = { 0 };
+        m.srcMemoryType = CU_MEMORYTYPE_DEVICE;
+        m.srcDevice = (CUdeviceptr)dpBgra;
+        m.srcPitch = nPitch ? nPitch : nWidth * 4;
+        m.dstMemoryType = CU_MEMORYTYPE_ARRAY;
+        m.dstArray = dstArray;
+        m.WidthInBytes = nWidth * 4;
+        m.Height = nHeight;
+        ck(cuMemcpy2D(&m));
+
+        ck(cuGraphicsUnmapResources(1, &cuResource, 0));
+        ck(cuCtxPopCurrent(NULL));
+    }
+
+private:
+    /**
+    *   @brief  Callback called by D3D runtime. This callback is registered during window creation.
+    *           On Window close this function posts a quit message. The thread runs to completion once
+    *           it retrieves this quit message in its message queue. Refer to Run() function in each of the
+    *           derived classes.
+    *   @param  hwnd   - handle to the window
+    *   @param  msg    - The message sent to this window
+    *   @param  wParam - Message specific additional information (No Op in this case)
+    *   @param  lParam - Message specific additional information (No Op on this case)
+    *   @return 0 on posting quit message
+    *   @return result of default window procedure in cases other than the above
+    */
+    static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+        switch (msg) {
+        case WM_CLOSE:
+            PostQuitMessage(0);
+            return 0;
+        }
+        return DefWindowProc(hwnd, msg, wParam, lParam);
+    }
+
+protected:
+    int nWidth = 0, nHeight = 0;
+    CUcontext cuContext = NULL;
+    CUgraphicsResource cuResource = NULL;
+};

video_codec_sdk/Samples/AppDecode/AppDecD3D/FramePresenterD3D11.h

@@ -0,0 +1,236 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <d3d11.h>
+#include <cuda.h>
+#include <cudaD3D11.h>
+#include "FramePresenterD3D.h"
+#include "../Utils/NvCodecUtils.h"
+
+/**
+* @brief D3D11 presenter class derived from FramePresenterD3D
+*/
+class FramePresenterD3D11 : public FramePresenterD3D
+{
+public:
+    /**
+    *   @brief  FramePresenterD3D11 constructor. This will launch a rendering thread which will be fed with decoded frames
+    *   @param  cuContext - CUDA context handle
+    *   @param  nWidth - Width of D3D surface
+    *   @param  nHeight - Height of D3D surface
+    */
+    FramePresenterD3D11(CUcontext cuContext, int nWidth, int nHeight) : 
+        FramePresenterD3D(cuContext, nWidth, nHeight) 
+    {
+        pthMsgLoop = new std::thread(ThreadProc, this);
+        while (!bReady) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        hTimerQueue = CreateTimerQueue();
+        hPresentEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    }
+
+    /**
+    *   @brief  FramePresenterD3D11 destructor.
+    */
+    ~FramePresenterD3D11() {
+        if (hTimerQueue)
+        {
+            DeleteTimerQueue(hTimerQueue);
+        }
+        if (hPresentEvent)
+        {
+            CloseHandle(hPresentEvent);
+        }
+        bQuit = true;
+        pthMsgLoop->join();
+        delete pthMsgLoop;
+    }
+
+    /**
+    *   @brief  Presents a frame present in host memory. More specifically, it copies the host surface
+    *           data to a d3d staging texture and then copies it to the swap chain backbuffer for presentation
+    *   @param  pData - pointer to host surface data
+    *   @param  nBytes - number of bytes to copy
+    *   @return true on success
+    *   @return false when the windowing thread is not ready to be served
+    */
+    bool PresentHostFrame(BYTE *pData, int nBytes) {
+        mtx.lock();
+        if (!bReady) {
+            mtx.unlock();
+            return false;
+        }
+
+        D3D11_MAPPED_SUBRESOURCE mappedTexture;
+        ck(pContext->Map(pStagingTexture, 0, D3D11_MAP_WRITE, 0, &mappedTexture));
+        memcpy(mappedTexture.pData, pData, min(nWidth * nHeight * 4, nBytes));
+        pContext->Unmap(pStagingTexture, 0);
+        pContext->CopyResource(pBackBuffer, pStagingTexture);
+        ck(pSwapChain->Present(0, 0));
+        mtx.unlock();
+        return true;
+    }
+
+    bool PresentDeviceFrame(unsigned char *dpBgra, int nPitch, int64_t delay) {
+        mtx.lock();
+        if (!bReady) {
+            mtx.unlock();
+            return false;
+        }
+        CopyDeviceFrame(dpBgra, nPitch);
+        if (!CreateTimerQueueTimer(&hTimer, hTimerQueue,
+            (WAITORTIMERCALLBACK)PresentRoutine, this, (DWORD)delay, 0, 0))
+        {
+            std::cout << "Problem in createtimer" << std::endl;
+        }
+        while (WaitForSingleObject(hPresentEvent, 0) != WAIT_OBJECT_0)
+        {
+        }
+        if (hTimer)
+        {
+            DeleteTimerQueueTimer(hTimerQueue, hTimer, nullptr);
+        }
+        mtx.unlock();
+        return true;
+    }
+
+private:
+    /**
+    *   @brief  Launches the windowing functionality
+    *   @param  This - pointer to FramePresenterD3D11 object
+    */
+    static void ThreadProc(FramePresenterD3D11 *This) {
+        This->Run();
+    }
+    /**
+    *   @brief  Callback called by D3D runtime. This callback is registered during call to
+    *           CreateTimerQueueTimer in PresentDeviceFrame. In CreateTimerQueueTimer we also
+    *           set a timer. When this timer expires this callback is called. This functionality
+    *           is present to facilitate timestamp based presentation.
+    *   @param  lpParam - void pointer to client data
+    *   @param  TimerOrWaitFired - TRUE for this callback as this is a Timer based callback (Refer:https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms687066(v=vs.85))
+    */
+    static VOID CALLBACK PresentRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired)
+    {
+        if (!lpParam) return;
+        FramePresenterD3D11* presenter = (FramePresenterD3D11 *)lpParam;
+        presenter->pSwapChain->Present(1, 0);
+        SetEvent(presenter->hPresentEvent);
+    }
+
+    /**
+    *   @brief This function is on a thread spawned during FramePresenterD3D11 construction.
+    *          It creates the D3D window and monitors window messages in a loop. This function
+    *          also creates swap chain for presentation and also registers the swap chain backbuffer
+    *          with cuda.
+    */
+    void Run() {
+        HWND hwndMain = CreateAndShowWindow(nWidth, nHeight);
+
+        DXGI_SWAP_CHAIN_DESC sc = { 0 };
+        sc.BufferCount = 1;
+        sc.BufferDesc.Width = nWidth;
+        sc.BufferDesc.Height = nHeight;
+        sc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+        sc.BufferDesc.RefreshRate.Numerator = 0;
+        sc.BufferDesc.RefreshRate.Denominator = 1;
+        sc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        sc.OutputWindow = hwndMain;
+        sc.SampleDesc.Count = 1;
+        sc.SampleDesc.Quality = 0;
+        sc.Windowed = TRUE;
+
+        ID3D11Device *pDevice = NULL;
+        ck(D3D11CreateDeviceAndSwapChain(GetAdapterByContext(cuContext), D3D_DRIVER_TYPE_UNKNOWN,
+            NULL, 0, NULL, 0, D3D11_SDK_VERSION, &sc, &pSwapChain, &pDevice, NULL, &pContext));
+        ck(pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer));
+
+        D3D11_TEXTURE2D_DESC td;
+        pBackBuffer->GetDesc(&td);
+        td.BindFlags = 0;
+        td.Usage = D3D11_USAGE_STAGING;
+        td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        ck(pDevice->CreateTexture2D(&td, NULL, &pStagingTexture));
+
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuGraphicsD3D11RegisterResource(&cuResource, pBackBuffer, CU_GRAPHICS_REGISTER_FLAGS_NONE));
+        ck(cuGraphicsResourceSetMapFlags(cuResource, CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD));
+        ck(cuCtxPopCurrent(NULL));
+
+        bReady = true;
+        MSG msg = { 0 };
+        while (!bQuit && msg.message != WM_QUIT) {
+            if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+        }
+
+        mtx.lock();
+        bReady = false;
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuGraphicsUnregisterResource(cuResource));
+        ck(cuCtxPopCurrent(NULL));
+        pStagingTexture->Release();
+        pBackBuffer->Release();
+        pContext->Release();
+        pDevice->Release();
+        pSwapChain->Release();
+        DestroyWindow(hwndMain);
+        mtx.unlock();
+    }
+
+    /**
+    *   @brief  Gets the DXGI adapter on which the given cuda context is current
+    *   @param   CUcontext - handle to cuda context
+    *   @return  pAdapter - pointer to DXGI adapter
+    *   @return  NULL - In case there is no adapter corresponding to the supplied cuda context
+    */
+    static IDXGIAdapter *GetAdapterByContext(CUcontext cuContext) {
+        CUdevice cuDeviceTarget;
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuCtxGetDevice(&cuDeviceTarget));
+        ck(cuCtxPopCurrent(NULL));
+
+        IDXGIFactory1 *pFactory = NULL;
+        ck(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&pFactory));
+        IDXGIAdapter *pAdapter = NULL;
+        for (unsigned i = 0; pFactory->EnumAdapters(i, &pAdapter) != DXGI_ERROR_NOT_FOUND; i++) {
+            CUdevice cuDevice;
+            ck(cuD3D11GetDevice(&cuDevice, pAdapter));
+            if (cuDevice == cuDeviceTarget) {
+                pFactory->Release();
+                return pAdapter;
+            }
+            pAdapter->Release();
+        }
+        pFactory->Release();
+        return NULL;
+    }
+
+private:
+    bool bReady = false;
+    bool bQuit = false;
+    std::mutex mtx;
+    std::thread *pthMsgLoop = NULL;
+
+    IDXGISwapChain *pSwapChain = NULL;
+    ID3D11DeviceContext *pContext = NULL;
+    ID3D11Texture2D *pBackBuffer = NULL, *pStagingTexture = NULL;
+    HANDLE hTimer;
+    HANDLE hTimerQueue;
+    HANDLE hPresentEvent;
+};

video_codec_sdk/Samples/AppDecode/AppDecD3D/FramePresenterD3D9.h

@@ -0,0 +1,226 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <d3d9.h>
+#include <cuda.h>
+#include <cudaD3D9.h>
+#include "FramePresenterD3D.h"
+#include "../Utils/NvCodecUtils.h"
+
+/**
+* @brief D3D9 presenter class derived from FramePresenterD3D
+*/
+class FramePresenterD3D9 : public FramePresenterD3D
+{
+public:
+    /**
+    *   @brief  FramePresenterD3D9 constructor. This will launch a rendering thread which will be fed with decoded frames
+    *   @param  cuContext - CUDA context handle
+    *   @param  nWidth - Width of D3D surface
+    *   @param  nHeight - Height of D3D surface
+    */
+    FramePresenterD3D9(CUcontext cuContext, int nWidth, int nHeight) : 
+        FramePresenterD3D(cuContext, nWidth, nHeight) 
+    {
+        pthMsgLoop = new std::thread(ThreadProc, this);
+        while (!bReady) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        hTimerQueue = CreateTimerQueue();
+        hPresentEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    }
+
+    /**
+    *   @brief  FramePresenterD3D9 destructor.
+    */
+    ~FramePresenterD3D9() {
+        if (hTimerQueue)
+        {
+            DeleteTimerQueue(hTimerQueue);
+        }
+        if (hPresentEvent)
+        {
+            CloseHandle(hPresentEvent);
+        }
+        bQuit = true;
+        pthMsgLoop->join();
+        delete pthMsgLoop;
+    }
+
+    /**
+    *   @brief  Presents a frame present in host memory. More specifically, it copies the host surface
+    *           data to a d3d offscreenplain surface and then copies it to the swap chain backbuffer for presentation
+    *   @param  pData - pointer to host surface data
+    *   @param  nBytes - number of bytes to copy
+    *   @return true on success
+    *   @return false when the windowing thread is not ready to be served
+    */
+    bool PresentHostFrame(BYTE *pData, int nBytes) {
+        mtx.lock();
+        if (!bReady) {
+            mtx.unlock();
+            return false;
+        }
+
+        D3DLOCKED_RECT lockedRect;
+        ck(pSurface->LockRect(&lockedRect, NULL, 0));
+        for (int y = 0; y < nHeight; y++) {
+            memcpy((uint8_t *)lockedRect.pBits + y * lockedRect.Pitch, pData + y * nWidth * 4, nWidth * 4);
+        }
+        ck(pSurface->UnlockRect());
+        pDevice->UpdateSurface(pSurface, NULL, pBackBuffer, NULL);
+        mtx.unlock();
+        return true;
+    }
+
+    bool PresentDeviceFrame(unsigned char *dpBgra, int nPitch, int64_t delay) {
+        mtx.lock();
+        if (!bReady) {
+            mtx.unlock();
+            return false;
+        }
+        CopyDeviceFrame(dpBgra, nPitch);
+        if (!CreateTimerQueueTimer(&hTimer, hTimerQueue,
+            (WAITORTIMERCALLBACK)PresentRoutine, this, (DWORD)delay, 0, 0))
+        {
+            std::cout << "Problem in createtimer" << std::endl;
+        }
+        while (WaitForSingleObject(hPresentEvent, 0) != WAIT_OBJECT_0)
+        {
+        }
+        if (hTimer)
+        {
+            DeleteTimerQueueTimer(hTimerQueue, hTimer, nullptr);
+        }
+        mtx.unlock();
+        return true;
+    }
+
+private:
+    /**
+    *   @brief  Launches the windowing functionality
+    *   @param  This - pointer to FramePresenterD3D9 object
+    */
+    static void ThreadProc(FramePresenterD3D9 *This) {
+        This->Run();
+    }
+    /**
+    *   @brief  Callback called by D3D runtime. This callback is registered during call to
+    *           CreateTimerQueueTimer in PresentDeviceFrame. In CreateTimerQueueTimer we also
+    *           set a timer. When this timer expires this callback is called. This functionality
+    *           is present to facilitate timestamp based presentation.
+    *   @param  lpParam - void pointer to client data
+    *   @param  TimerOrWaitFired - TRUE for this callback as this is a Timer based callback (Refer:https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms687066(v=vs.85))
+    */
+    static VOID CALLBACK PresentRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired)
+    {
+        if (!lpParam) return;
+        FramePresenterD3D9* presenter = (FramePresenterD3D9 *)lpParam;
+        ck(presenter->pDevice->Present(NULL, NULL, NULL, NULL));
+        SetEvent(presenter->hPresentEvent);
+    }
+
+    /**
+    *   @brief This function is on a thread spawned during FramePresenterD3D9 construction.
+    *          It creates the D3D window and monitors window messages in a loop. This function
+    *          also creates swap chain for presentation and also registers the swap chain backbuffer
+    *          with cuda.
+    */
+    void Run() {
+        HWND hwndMain = CreateAndShowWindow(nWidth, nHeight);
+
+        IDirect3D9Ex* pD3D = NULL;
+        ck(Direct3DCreate9Ex(D3D_SDK_VERSION, &pD3D));
+        D3DPRESENT_PARAMETERS d3dpp = { 0 };
+        d3dpp.BackBufferWidth = nWidth;
+        d3dpp.BackBufferHeight = nHeight;
+        d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
+        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+        d3dpp.EnableAutoDepthStencil = FALSE;
+        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+        d3dpp.Windowed = TRUE;
+        d3dpp.hDeviceWindow = hwndMain;
+        ck(pD3D->CreateDevice(GetAdapterByContext(cuContext), D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &pDevice));
+        pD3D->Release();
+
+        ck(pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer));
+        ck(pDevice->CreateOffscreenPlainSurface(nWidth, nHeight, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &pSurface, NULL));
+
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuGraphicsD3D9RegisterResource(&cuResource, pBackBuffer, CU_GRAPHICS_REGISTER_FLAGS_NONE));
+        ck(cuGraphicsResourceSetMapFlags(cuResource, CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD));
+        ck(cuCtxPopCurrent(NULL));
+
+        bReady = true;
+        MSG msg = { 0 };
+        while (!bQuit && msg.message != WM_QUIT) {
+            if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+        }
+
+        mtx.lock();
+        bReady = false;
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuGraphicsUnregisterResource(cuResource));
+        ck(cuCtxPopCurrent(NULL));
+        pSurface->Release();
+        pBackBuffer->Release();
+        pDevice->Release();
+        DestroyWindow(hwndMain);
+        mtx.unlock();
+    }
+
+    /**
+    *   @brief  Gets the D3D9 adapter ID on which the given cuda context is current
+    *   @param   CUcontext - handle to cuda context
+    *   @return  pAdapter - pointer to DXGI adapter
+    *   @return  NULL - In case there is no adapter corresponding to the supplied cuda context
+    */
+    static UINT GetAdapterByContext(CUcontext cuContext) {
+        CUdevice cuDeviceTarget;
+        ck(cuCtxPushCurrent(cuContext));
+        ck(cuCtxGetDevice(&cuDeviceTarget));
+        ck(cuCtxPopCurrent(NULL));
+
+        IDirect3D9Ex* pD3D = NULL;
+        ck(Direct3DCreate9Ex(D3D_SDK_VERSION, &pD3D));
+        for (unsigned i = 0; i < pD3D->GetAdapterCount(); i++) {
+            D3DADAPTER_IDENTIFIER9 identifier;
+            pD3D->GetAdapterIdentifier(i, 0, &identifier);
+            CUdevice cuDevice;
+            ck(cuD3D9GetDevice(&cuDevice, identifier.DeviceName));
+            if (cuDevice == cuDeviceTarget) {
+                return i;
+            }
+        }
+        pD3D->Release();
+        return NULL;
+    }
+
+private:
+    bool bReady = false;
+    bool bQuit = false;
+    std::mutex mtx;
+    std::thread *pthMsgLoop = NULL;
+
+    IDirect3DDevice9 *pDevice = NULL;
+    IDirect3DSurface9 *pBackBuffer = NULL, *pSurface = NULL;
+    HANDLE hTimer;
+    HANDLE hTimerQueue;
+    HANDLE hPresentEvent;
+};

video_codec_sdk/Samples/AppDecode/AppDecGL/AppDecGL.cpp

@@ -0,0 +1,145 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecGL.cpp
+//! \brief Source file for AppDecGL sample
+//!
+//! This sample application illustrates the decoding of media file and display of decoded frames in a window.
+//! This is done by CUDA interop with OpenGL.
+//! Synchronization between rendering and decode thread is achieved using ConcurrentQueue implementation.
+//! For a detailed list of supported codecs on your NVIDIA GPU, refer : https://developer.nvidia.com/nvidia-video-codec-sdk#NVDECFeatures
+//---------------------------------------------------------------------------
+
+#include <cuda.h>
+#include <iostream>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+#include "../Utils/ColorSpace.h"
+
+#include "FramePresenter.h"
+#include "FramePresenterGLUT.h"
+
+#if !defined (_WIN32)
+#include "FramePresenterGLX.h"
+#endif
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+/**
+*   @brief  Function to decode media file pointed by "szInFilePath" parameter.
+*           The decoded frames are displayed by using the OpenGL-CUDA interop.
+*   @param  cuContext - Handle to CUDA context
+*   @param  szInFilePath - Path to file to be decoded
+*   @return 0 on failure
+*   @return 1 on success
+*/
+int Decode(CUcontext cuContext, char *szInFilePath) {
+
+    FFmpegDemuxer demuxer(szInFilePath);
+    NvDecoder dec(cuContext, true, FFmpeg2NvCodecId(demuxer.GetVideoCodec()));
+
+    // Presenter need aligned width
+    int nWidth = (demuxer.GetWidth() + 1) & ~1;
+    int nPitch = nWidth * 4;
+
+#if defined (_WIN32)
+    FramePresenterGLUT gInstance(cuContext, nWidth, demuxer.GetHeight());
+#else
+    FramePresenterGLX gInstance(nWidth, demuxer.GetHeight());
+#endif
+
+    int &nFrame = gInstance.nFrame;
+
+    // Check whether we have valid NVIDIA libraries installed
+    if (!gInstance.isVendorNvidia()) {
+        std::cout<<"\nFailed to find NVIDIA libraries\n";
+        return 0;
+    }
+
+    CUdeviceptr dpFrame;
+    int nVideoBytes = 0, nFrameReturned = 0, iMatrix = 0;
+    uint8_t *pVideo = NULL;
+    uint8_t *pFrame;
+    do {
+        demuxer.Demux(&pVideo, &nVideoBytes);
+        nFrameReturned = dec.Decode(pVideo, nVideoBytes);
+        if (!nFrame && nFrameReturned)
+            LOG(INFO) << dec.GetVideoInfo();
+
+        for (int i = 0; i < nFrameReturned; i++) {
+            pFrame = dec.GetFrame();
+            gInstance.GetDeviceFrameBuffer(&dpFrame, &nPitch);
+            iMatrix = dec.GetVideoFormatInfo().video_signal_description.matrix_coefficients;
+            // Launch cuda kernels for colorspace conversion from raw video to raw image formats which OpenGL textures can work with
+            if (dec.GetBitDepth() == 8) {
+                if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                    YUV444ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                    Nv12ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else
+                    Nv16ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);      
+            }
+            else {
+                if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                    YUV444P16ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                    P016ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);
+                else
+                    P216ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t *)dpFrame, nPitch, dec.GetWidth(), dec.GetHeight(), iMatrix);
+            }
+
+            gInstance.ReleaseDeviceFrameBuffer();
+
+        }
+        nFrame += nFrameReturned;
+    } while (nVideoBytes);
+
+    std::cout << "Total frame decoded: " << nFrame << std::endl;
+    return 1;
+}
+
+int main(int argc, char **argv)
+{
+    char szInFilePath[256] = "";
+    int iGpu = 0;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, NULL, iGpu, NULL, NULL);
+        CheckInputFile(szInFilePath);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, CU_CTX_SCHED_BLOCKING_SYNC);
+
+        std::cout << "Decode with NvDecoder." << std::endl;
+        Decode(cuContext, szInFilePath);
+
+        ck(cuCtxDestroy(cuContext));
+    }
+    catch(const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecGL/CMakeLists.txt

@@ -0,0 +1,199 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecGL)
+
+if(WIN32)
+    set(APP_SOURCES
+        ${CMAKE_CURRENT_SOURCE_DIR}/AppDecGL.cpp
+    )
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+else ()
+    set(APP_SOURCES
+        ${CMAKE_CURRENT_SOURCE_DIR}/AppDecGL.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/FramePresenterGLX.cpp
+    )
+endif()
+
+if(WIN32)
+    set(NV_GL_HDRS ${CMAKE_CURRENT_SOURCE_DIR}/../../External/)
+    set(NV_GLEW_HDRS ${GLEW_DIR}/include)
+	set(NV_GLUT_HDRS ${GLUT_INC})
+else ()
+    set(NV_GL_HDRS "")
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_ENC_CUDA_UTILS
+ ${NVCODEC_UTILS_DIR}/ColorSpace.cu
+)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NVCODEC_UTILS_DIR}/ColorSpace.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/FramePresenter.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/FramePresenterGLUT.h
+)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(NV_DEC_HDRS ${NV_DEC_HDRS} ${CMAKE_CURRENT_SOURCE_DIR}/FramePresenterGLX.h)
+endif()
+
+source_group( "headers" FILES ${NV_DEC_HDRS})
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+# CUDA 11.7 and later is compiled with /MT option (staticaly linked with C runtime), 
+# since we are statically linking cudart_static.lib with the app, 
+# we need to make sure that all .obj files linked are compiled with /MT to avoid linker warning LNK4098
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-Xcompiler /MT)
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    target_compile_options(${PROJECT_NAME} PRIVATE "/MT")
+endif()
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+ ${NV_GL_HDRS}
+ ${NV_GLEW_HDRS}
+ ${NV_GLUT_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    Set(FREEGLUT_LIB ${GLUT_DIR}/lib/Release/freeglut.lib)
+    Set(FREEGLUT_STATIC_LIB ${GLUT_DIR}/lib/Release/freeglut_static.lib)
+    Set(FREEGLUT_STATICD_LIB ${GLUT_DIR}/lib/Debug/freeglut_staticd.lib)
+    Set(FREEGLUTD_LIB ${GLUT_DIR}/lib/Debug/freeglutd.lib)
+	if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    	Set(GLEW32_LIB ${GLEW_DIR}/lib/Release/x64/glew32.lib)
+    	Set(GLEW32S_LIB ${GLEW_DIR}/lib/Release/x64/glew32s.lib)
+        Set(GLEW_DLL_DIR ${GLEW_DIR}/bin/Release/x64/)
+        Set(GLEW_LIB_DIR ${GLEW_DIR}/lib/Release/x64/)
+    else()
+    	Set(GLEW32_LIB ${GLEW_DIR}/lib/Release/Win32/glew32.lib)
+    	Set(GLEW32S_LIB ${GLEW_DIR}/lib/Release/Win32/glew32s.lib)
+        Set(GLEW_DLL_DIR ${GLEW_DIR}/bin/Release/Win32/)
+        Set(GLEW_LIB_DIR ${GLEW_DIR}/lib/Release/Win32/)
+    endif()
+
+    Set(GLUT_LIB_DIR ${GLUT_DIR}/lib)
+    Set(GLUT_DLL_DIR ${GLUT_DIR}/bin)
+    
+    #copy .dll and .lib files
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+    
+    install(DIRECTORY ${GLUT_LIB_DIR}/Release/ DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+    install(DIRECTORY ${GLUT_DLL_DIR}/Release/ DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${GLUT_LIB_DIR}/Debug/ DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+    install(DIRECTORY ${GLUT_DLL_DIR}/Debug/ DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    
+    install(DIRECTORY ${GLEW_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+    install(DIRECTORY ${GLEW_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    
+    target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+        ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB} ${FREEGLUT_LIB} ${FREEGLUT_STATIC_LIB} ${FREEGLUT_STATICD_LIB}
+        ${FREEGLUTD_LIB} ${GLEW32_LIB} ${GLEW32S_LIB})
+else ()
+    find_library(FREEGLUT_LIB glut)
+    find_library(GLEW32_LIB GLEW)
+    find_library(X11_LIB X11)
+    find_library(GL_LIB GL)
+    find_library(CUDART_LIB cudart HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64)
+    target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CUDART_LIB} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+        ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB} ${FREEGLUT_LIB} ${GLEW32_LIB} ${X11_LIB} ${GL_LIB})
+endif()
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    
+    # copy ffmpeg, GLUT and GLEW .dll and .lib files
+    file(GLOB externalLibList 
+        ${GLUT_LIB_DIR}/Release/*.lib
+        ${GLUT_LIB_DIR}/Debug/*.lib
+        ${GLUT_DLL_DIR}/Release/*.dll
+        ${GLUT_DLL_DIR}/Debug/*.dll
+        ${GLEW_LIB_DIR}/*.lib 
+        ${GLEW_DLL_DIR}/*.dll
+    )
+    
+    foreach(externalLib ${externalLibList})
+        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD  COMMAND ${CMAKE_COMMAND} -E copy ${externalLib} ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/)
+    endforeach()
+    
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecGL/FramePresenter.h

@@ -0,0 +1,44 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+#include <atomic>
+
+#pragma once
+
+// Base class for GLX and GLUT code paths.
+// Declares essintial function as pure virtual.
+class FramePresenter {
+
+    public:
+
+    FramePresenter(): nFrame(0), width(0), height(0) {
+    }
+
+    virtual ~FramePresenter(){
+    }
+
+    std::atomic<bool> endOfDecoding ; /*!< Indicates end of decoding for rendering thread to exit */
+    std::atomic<bool> endOfRendering; /*!< Indicates end of rendering to ensure main thread does not
+                              release graphics resources when they are being used by rendering thread */
+
+    int nFrame;          /*!< Variable to indicate the current count of decoded frames */
+
+    int width, height;   /*!< Denotes dimensions of the decoded frame */
+
+    virtual void initWindowSystem() = 0;
+    virtual void initOpenGLResources() = 0;
+    virtual void releaseWindowSystem() = 0;
+
+    virtual void Render() = 0;
+    virtual bool isVendorNvidia() = 0;
+    virtual int getWidth() = 0;
+    virtual bool GetDeviceFrameBuffer(CUdeviceptr*, int *) = 0;
+    virtual void ReleaseDeviceFrameBuffer() = 0;
+};

video_codec_sdk/Samples/AppDecode/AppDecGL/FramePresenterGLUT.h

@@ -0,0 +1,357 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+#pragma once
+
+#include <iostream>
+#include <algorithm>
+#include <string.h>
+#include <stdlib.h>
+#include <mutex>
+#include <thread>
+#include <chrono>
+#include <GL/glew.h>
+#include <GL/glut.h>
+#include <GL/freeglut_ext.h>
+#include <cuda.h>
+#include <cudaGL.h>
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/Logger.h"
+#include "FramePresenter.h"
+
+class FramePresenterGLUT;
+static FramePresenterGLUT *pInstance;
+
+/**
+* @brief OpenGL utility class to display decoded frames using OpenGL textures
+*/
+class FramePresenterGLUT : public FramePresenter
+{
+public:
+    /**
+    *   @brief  FramePresenterGLUT constructor function. This will launch a rendering thread which will be fed by decoded frames
+    *   @param  cuContext - CUDA Context handle
+    *   @param  nWidth - Width of OpenGL texture
+    *   @param  nHeight - Height of OpenGL texture
+    */
+    FramePresenterGLUT(CUcontext cuContext, int nWidth, int nHeight) :
+        cuContext(cuContext), nWidth(nWidth), nHeight(nHeight)
+    {
+        pthMessageLoop = new NvThread(std::thread(ThreadProc, this));
+
+        // This loop will ensure that OpenGL/glew/glut initialization is finished before we return from this constructor
+        while (!pInstance) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+    }
+
+    /**
+    *   @brief  Destructor function. Also breaks glutMainLoopEvent
+    */
+    ~FramePresenterGLUT() {
+        bStop = true;
+        pthMessageLoop->join();
+        delete pthMessageLoop;
+    }
+
+    /**
+    *   @brief  Writes CUdeviceptr handle which is later used for OpenGL rendering
+    *   @param  pdpFrame - Pointer to frame data into which decoded frame is written
+    *   @param  pnPitch - Pointer to pitch value. This function will write pitch value based on nWidth
+    *   @return False if dpFrame is NULL or rendering loop is exited
+    *   @return True when input params are successfully updated
+    */
+    bool GetDeviceFrameBuffer(CUdeviceptr *pdpFrame, int *pnPitch) {
+        if (bStop || !dpFrame) {
+            return false;
+        }
+
+        *pdpFrame = (CUdeviceptr) dpFrame;
+        *pnPitch = nWidth * 4;
+        return true;
+    }
+
+    void SetText(std::string strText) {
+        this->strText = strText;
+    }
+
+     /**
+     *   @brief  Function to check whether underlying vendor is NVIDIA or not
+     *   @return True if OpenGL vendor is NVIDIA
+     *   @return False if OpenGL vendor is not NVIDIA
+     */
+     bool isVendorNvidia() {
+        return this->vendorStatus;
+     }
+
+     void initWindowSystem() {
+         // No op in GLUT
+     }
+
+     void initOpenGLResources() {
+         // No op in GLUT
+     }
+
+     void releaseWindowSystem() {
+         // No op in GLUT
+     }
+
+     void ReleaseDeviceFrameBuffer() {
+        // No op in GLUT
+     }
+
+     int getWidth() {
+        return this->nWidth;
+     }
+
+private:
+     /**
+     *   @brief  Thread launcher function. Launches the graphics initialization code
+     *   @param  This - Pointer to FramePresenterGLUT object
+     *   @return void
+     */
+     static void ThreadProc(FramePresenterGLUT *This) {
+        This->Run();
+    }
+
+     /**
+     *   @brief  Registered with glutDisplayFunc() as rendering function
+     *   @return void
+     */
+     static void DisplayProc() {
+        if (!pInstance) {
+            return;
+        }
+        pInstance->Render();
+    }
+
+    static void CloseWindowProc() {
+        if (!pInstance) {
+            return;
+        }
+        // Enable the flag to break glutMainLoopEvent
+        pInstance->bStop = true;
+    }
+
+    /**
+    *   @brief  This function is responsible for OpenGL/glew/glut initialization and also for initiating display loop
+    *   @return void
+    */
+    void Run() {
+        int w = nWidth, h = nHeight;
+
+        // Calculate the ratio to restrict viewport dimensions to 1280x720
+        double r = (std::max)(nWidth / 1280.0, nHeight / 720.0);
+        if (r > 1.0) {
+            w = (int)(nWidth / r);
+            h = (int)(nHeight / r);
+        }
+
+        int argc = 1;
+        const char *argv[] = {"dummy"};
+        glutInit(&argc, (char **)argv);
+        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
+        glutInitWindowSize(w, h);
+        glutCreateWindow("FramePresenterGLUT");
+        glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
+
+        char * vendor = (char*) glGetString(GL_VENDOR);
+
+        if (!strcmp(vendor, "NVIDIA Corporation")) {
+            this->vendorStatus = true;
+        } else {
+            // To prevent infinite loop in constructor, initialize pInstance
+            pInstance = this;
+            this->vendorStatus = false;
+            return;
+        }
+
+        glViewport(0, 0, w, h);
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
+
+        glewInit();
+        // Prepare OpenGL buffer object for uploading texture data
+        glGenBuffersARB(1, &pbo);
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+        glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, nWidth * nHeight * 4, NULL, GL_STREAM_DRAW_ARB);
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+        // Create OpenGL texture and upload frame data
+        glGenTextures(1, &tex);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
+        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
+
+        // Create and initialize fragment program
+        static const char *code =
+            "!!ARBfp1.0\n"
+            "TEX result.color, fragment.texcoord, texture[0], RECT; \n"
+            "END";
+        glGenProgramsARB(1, &shader);
+        glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader);
+        glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(code), (GLubyte *)code);
+
+        // Register display function
+        glutDisplayFunc(DisplayProc);
+        // Register window close event callback function
+        glutCloseFunc(CloseWindowProc);
+
+        ck(cuCtxSetCurrent(cuContext));
+        ck(cuMemAlloc(&dpFrame, nWidth * nHeight * 4));
+        ck(cuMemsetD8(dpFrame, 0, nWidth * nHeight * 4));
+
+        pInstance = this;
+
+        // Launch the rendering loop
+        while (!bStop) {
+            glutMainLoopEvent();
+        }
+        pInstance = NULL;
+
+        ck(cuMemFree(dpFrame));
+
+        glDeleteBuffersARB(1, &pbo);
+        glDeleteTextures(1, &tex);
+        glDeleteProgramsARB(1, &shader);
+    }
+
+    /**
+    *   @brief  Rendering function called by glut
+    *   @return void
+    */
+    void Render(void) {
+
+        // Register the OpenGL buffer object with CUDA and map a CUdeviceptr onto it
+        // The decoder code will receive this CUdeviceptr and copy the decoded frame into the associated device memory allocation
+        CUgraphicsResource cuResource;
+        ck(cuGraphicsGLRegisterBuffer(&cuResource, pbo, CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD));
+        ck(cuGraphicsMapResources(1, &cuResource, 0));
+        CUdeviceptr dpBackBuffer;
+        size_t nSize = 0;
+        ck(cuGraphicsResourceGetMappedPointer(&dpBackBuffer, &nSize, cuResource));
+
+        CUDA_MEMCPY2D m = { 0 };
+        m.srcMemoryType = CU_MEMORYTYPE_DEVICE;
+
+        // Source is dpFrame into which Decode() function writes data of individual frame present in BGRA32 format
+        // Destination is OpenGL buffer object mapped as a CUDA resource
+        m.srcDevice = dpFrame;
+        m.srcPitch = nWidth * 4;
+        m.dstMemoryType = CU_MEMORYTYPE_DEVICE;
+        m.dstDevice = dpBackBuffer;
+        m.dstPitch = nSize / nHeight;
+        m.WidthInBytes = nWidth * 4;
+        m.Height = nHeight;
+        ck(cuMemcpy2DAsync(&m, 0));
+
+        ck(cuGraphicsUnmapResources(1, &cuResource, 0));
+        ck(cuGraphicsUnregisterResource(cuResource));
+
+        // Bind OpenGL buffer object and upload the data
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
+        glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, nWidth, nHeight, GL_BGRA, GL_UNSIGNED_BYTE, 0);
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+        glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader);
+        glEnable(GL_FRAGMENT_PROGRAM_ARB);
+        glDisable(GL_DEPTH_TEST);
+
+        // Specify vertex and texture co-ordinates
+        glBegin(GL_QUADS);
+        glTexCoord2f(0, (GLfloat)nHeight);
+        glVertex2f(0, 0);
+        glTexCoord2f((GLfloat)nWidth, (GLfloat)nHeight);
+        glVertex2f(1, 0);
+        glTexCoord2f((GLfloat)nWidth, 0);
+        glVertex2f(1, 1);
+        glTexCoord2f(0, 0);
+        glVertex2f(0, 1);
+        glEnd();
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
+        glDisable(GL_FRAGMENT_PROGRAM_ARB);
+
+        if (!strText.empty()) {
+            PrintText(0, strText, 0, 0, true);
+        }
+
+        glutSwapBuffers();
+        glutPostRedisplay();
+    }
+
+    static void PrintText(int iFont, std::string strText, int x, int y, bool bFillBackground) {
+        struct {void *font; int d1; int d2;} fontData[] = {
+            /*0*/ GLUT_BITMAP_9_BY_15,        13, 4,
+            /*1*/ GLUT_BITMAP_8_BY_13,        11, 4,
+            /*2*/ GLUT_BITMAP_TIMES_ROMAN_10, 9,  3,
+            /*3*/ GLUT_BITMAP_TIMES_ROMAN_24, 20, 7,
+            /*4*/ GLUT_BITMAP_HELVETICA_10,   10, 3,
+            /*5*/ GLUT_BITMAP_HELVETICA_12,   11, 4,
+            /*6*/ GLUT_BITMAP_HELVETICA_18,   16, 5,
+        };
+        const int nFont = sizeof(fontData) / sizeof(fontData[0]);
+
+        if (iFont >= nFont) {
+            iFont = 0;
+        }
+        void *font = fontData[iFont].font;
+        int d1 = fontData[iFont].d1, d2 = fontData[iFont].d2, d = d1 + d2,
+            w = glutGet(GLUT_WINDOW_WIDTH), h = glutGet(GLUT_WINDOW_HEIGHT);
+
+        glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+        glLoadIdentity();
+        glOrtho(0.0, w, 0.0, h, 0.0, 1.0);
+
+        std::stringstream ss(strText);
+        std::string str;
+        int iLine = 0;
+        while (std::getline(ss, str)) {
+            glColor3f(1.0, 1.0, 1.0);
+            if (bFillBackground) {
+                glRasterPos2i(x, h - y - iLine * d - d1);
+                for (char c : str) {
+                    glutBitmapCharacter(font, c);
+                }
+                GLint pos[4];
+                glGetIntegerv(GL_CURRENT_RASTER_POSITION, pos);
+                glRecti(x, h - y - iLine * d, pos[0], h - y - (iLine + 1) * d);
+                glColor3f(0.0, 0.0, 0.0);
+            }
+            glRasterPos2i(x, h - y - iLine * d - d1);
+            for (char c : str) {
+                glutBitmapCharacter(font, c);
+            }
+            iLine++;
+        }
+
+        glPopMatrix();
+    }
+
+private:
+    bool bStop = false;         /*!< Variable to control rendering loop */
+    int nWidth = 0, nHeight = 0;/*!< Dimensions of the frame being decoded */
+    CUcontext cuContext = NULL;
+    CUdeviceptr dpFrame = 0;    /*!< CUdeviceptr referenced by main thread to write decoded frames into */
+    NvThread *pthMessageLoop = NULL;
+    std::string strText;
+    GLuint pbo;                 /*!< Buffer object to upload texture data */
+    GLuint tex;                 /*!< OpenGL texture handle */
+    GLuint shader;
+    bool vendorStatus = false;  /*!< true if OpenGL vendor is NVIDIA, false otherwise */
+
+};

video_codec_sdk/Samples/AppDecode/AppDecGL/FramePresenterGLX.cpp

@@ -0,0 +1,360 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+#include "FramePresenterGLX.h"
+#include <iostream>
+#include <cstring>
+#include <thread>
+
+#include "../Utils/NvCodecUtils.h"
+/**
+ *   @brief  Constructor to initialize GLX, OpenGL and CUDA resources. Also launches rendering thread.
+ *   @param  None
+ *   @return None
+ */
+FramePresenterGLX::FramePresenterGLX(int w, int h) {
+
+    frameFeeder.setSize(BUFFER_COUNT);
+
+    currentFrame = 0;
+    endOfDecoding = false;
+    endOfRendering = false;
+
+    cuResource[0] = 0;
+    cuResource[1] = 0;
+
+    // Initialize the width and height to be used in texture updates
+    setDimensions(w, h);
+
+    // Initliaze GLX window, context
+    initWindowSystem();
+
+    // Initialize OpenGL resources
+    initOpenGLResources();
+
+    for (int i = 0; i < BUFFER_COUNT; i++) {
+
+        // Attach pbo to each of the cuda graphics resource
+        ck(cuGraphicsGLRegisterBuffer(&cuResource[i], pbo[i], CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD));
+    }
+
+    // Create a thread handle using Render function of the class for execution
+    renderingThread = NvThread(std::thread(&FramePresenterGLX::Render, this));
+}
+
+/**
+ *   @brief  Check if valid NVIDIA libraries are installed.
+ *   @param  None
+ *   @return None
+ */
+bool FramePresenterGLX::isVendorNvidia() {
+
+    char * vendor = (char*) glGetString(GL_VENDOR);
+
+    if (!strcmp(vendor, "NVIDIA Corporation")) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ *   @brief  Create PBO and CUResource binding.
+ *   @param  None
+ *   @return None
+ */
+bool FramePresenterGLX::GetDeviceFrameBuffer(CUdeviceptr *dpFrame, int *pitch) {
+
+    mapBufferObject(dpFrame);
+    *pitch = getWidth()*4;
+
+    return true;
+}
+
+/**
+ *   @brief  Release the mapping so that, Rendering thread can consume the updated PBO.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::ReleaseDeviceFrameBuffer() {
+
+    unmapBufferObject();
+}
+
+/**
+ *   @brief  Binds CUResource to PBO and returns the CUdeviceptr that caller can work with.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::mapBufferObject(CUdeviceptr* dpBuffer) {
+
+    ck(cuGraphicsMapResources(1, &cuResource[currentFrame], 0));
+
+    size_t nSize = 0;
+    ck(cuGraphicsResourceGetMappedPointer(dpBuffer, &nSize, cuResource[currentFrame]));
+}
+
+/**
+ *   @brief  Unmap the binding between CUResource and PBO.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::unmapBufferObject() {
+
+    ck(cuGraphicsUnmapResources(1, &cuResource[currentFrame], 0));
+
+    frameFeeder.push_back(currentFrame);
+
+    // CurrentFrame goes from between 0 and (BUFFER_COUNT - 1)
+    currentFrame = (currentFrame + 1) % BUFFER_COUNT;
+}
+
+/**
+ *   @brief  Function to render decoded frame using OpenGL calls.
+ *           The PBO used here is populated by Decode function.
+ *           Rendering is done using shared GLX context.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::Render() {
+
+    int w = getWidth();
+    int h = getHeight();
+
+    glXMakeCurrent(display, win, shared_ctx);
+
+    int currentRender = 0;
+
+    glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program);
+    glEnable(GL_FRAGMENT_PROGRAM_ARB);
+    glDisable(GL_DEPTH_TEST);
+
+    while (!endOfDecoding) {
+
+        currentRender = frameFeeder.front();
+
+        // Bind OpenGL buffer object and upload the data
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo[currentRender]);
+
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex[currentRender]);
+        glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, w, h, GL_BGRA, GL_UNSIGNED_BYTE, 0);
+
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+        glBegin(GL_QUADS);
+        glTexCoord2f(0, (GLfloat)h);
+        glVertex2f(-1.0f, -1.0f);
+        glTexCoord2f((GLfloat)w, (GLfloat)h);
+        glVertex2f(1.0f, -1.0f);
+        glTexCoord2f((GLfloat)w, 0);
+        glVertex2f(1.0f, 1.0f);
+        glTexCoord2f(0, 0);
+        glVertex2f(-1.0f, 1.0f);
+        glEnd();
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
+
+        glXSwapBuffers(display, win);
+
+        frameFeeder.pop_front();
+    }
+
+    glDisable(GL_FRAGMENT_PROGRAM_ARB);
+
+    glXMakeCurrent(display, 0, 0);
+
+    endOfRendering = true;
+}
+
+/**
+ *   @brief  Function to release GLX resources like display, window, context and colormap.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::releaseWindowSystem() {
+
+    glXMakeCurrent(display, 0, 0);
+    glXDestroyContext(display, ctx);
+    glXDestroyContext(display, shared_ctx);
+
+    XDestroyWindow(display, win);
+    XFreeColormap(display, cmap);
+    XCloseDisplay(display);
+}
+
+/**
+ *   @brief  Function to create GLX resources like display, window, context and colormap.
+ *           Exits the app in case any GLX API fails.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::initWindowSystem() {
+
+    XInitThreads();
+
+	XVisualInfo *visinfo;
+	GLXFBConfig config;
+
+    display = XOpenDisplay(NULL);
+    if (display == NULL) {
+		std::cout << "\nDisplay not found ! Make sure X server is running and DISPLAY environment variable set appropriately !\n";
+		exit(1);
+    }
+
+    int configAttr[] = {
+        GLX_CONFIG_CAVEAT   ,GLX_NONE,
+        GLX_RENDER_TYPE     ,GLX_RGBA_BIT,
+        GLX_RED_SIZE        , 8,
+        GLX_GREEN_SIZE      , 8,
+        GLX_BLUE_SIZE       , 8,
+        GLX_ALPHA_SIZE      , 8,
+        GLX_DEPTH_SIZE      , 24,
+        GLX_STENCIL_SIZE    , 8,
+        GLX_DOUBLEBUFFER    , True,
+        None,
+    };
+
+    GLXFBConfig *configs = NULL;
+    int numConfigs = 0;
+
+	int screen = DefaultScreen(display);
+
+    configs = glXChooseFBConfig(display, screen, configAttr, &numConfigs);
+    if (numConfigs <= 0 || configs == NULL) {
+        std::cout << "\nFailed to find a suitable GLXFBConfig!\n";
+		exit(1);
+    }
+
+    config = configs[0];
+    XFree(configs);
+
+    visinfo = glXGetVisualFromFBConfig(display, config);
+    if (!visinfo) {
+        std::cout << "\nFailed to find a suitable visual!\n";
+        exit(1);
+    }
+
+    Window root;
+    XSetWindowAttributes wattr;
+    int wattr_mask;
+
+    root = RootWindow(display, screen);
+
+    cmap = XCreateColormap(display, root, visinfo->visual, AllocNone);
+
+    if (!cmap) {
+        std::cout << "\nFailed to create colormap!\n";
+        exit(1);
+    }
+
+    wattr_mask = CWBackPixmap | CWBorderPixel | CWColormap;
+    wattr.background_pixmap = None;
+    wattr.border_pixel = 0;
+    wattr.bit_gravity = StaticGravity;
+    wattr.colormap = cmap;
+
+    win = XCreateWindow(display, root, 0, 0, 640, 480, 0,
+                            visinfo->depth, InputOutput,
+                            visinfo->visual, wattr_mask, &wattr);
+
+    if (!win) {
+        std::cout << "\nFailed to create window!\n";
+		exit(1);
+    }
+
+	XMapWindow(display, win);
+
+	ctx = glXCreateNewContext(display, config, GLX_RGBA_TYPE, 0, True);
+
+	if (!ctx) {
+		std::cout << "\nFailed to create GLX context !\n";
+		exit(1);
+	}
+
+    shared_ctx = glXCreateNewContext(display, config, GLX_RGBA_TYPE, ctx, True);
+
+	if (!shared_ctx) {
+		std::cout << "\nFailed to create shared GLX context !\n";
+		exit(1);
+	}
+
+    glXMakeCurrent(display, win, ctx);
+}
+
+/**
+ *   @brief  Function to create OpenGL resources viz. pixel buffer objects, textures, program objects.
+ *   @param  None
+ *   @return None
+ */
+void FramePresenterGLX::initOpenGLResources() {
+
+    glewInit();
+
+    GLuint &shader = getProgramObject();
+
+    glGenTextures(BUFFER_COUNT, tex);
+    glGenBuffers(BUFFER_COUNT, pbo);
+
+    for (int i=0; i<BUFFER_COUNT; i++) {
+
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo[i]);
+        glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * 4, NULL, GL_DYNAMIC_DRAW_ARB);
+        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex[i]);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
+    }
+
+    // Create and initialize fragment program
+    static const char *code =
+        "!!ARBfp1.0\n"
+        "TEX result.color, fragment.texcoord, texture[0], RECT; \n"
+        "END";
+
+    glGenProgramsARB(1, &shader);
+    glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader);
+    glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(code), (GLubyte *)code);
+}
+
+/**
+ *   @brief  Function to release OpenGL resources viz. pixel buffer objects, textures, program objects.
+ *   @param  None
+ *   @return None
+ */
+FramePresenterGLX::~FramePresenterGLX() {
+
+    endOfDecoding = true;
+
+    // Don't release resources till rendering is finished.
+    while (!endOfRendering) {
+    }
+
+    renderingThread.join();
+
+    for (int i = 0; i < BUFFER_COUNT; i++) {
+        ck(cuGraphicsUnregisterResource(cuResource[i]));
+    }
+
+    GLuint &shader = getProgramObject();
+
+    // Release OpenGL resources
+    glDeleteBuffersARB(BUFFER_COUNT, pbo);
+    glDeleteTextures(BUFFER_COUNT, tex);
+    glDeleteProgramsARB(1, &shader);
+
+    // Release GLX resources
+    releaseWindowSystem();
+}
+
+

video_codec_sdk/Samples/AppDecode/AppDecGL/FramePresenterGLX.h

@@ -0,0 +1,125 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glew.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <iostream>
+#include <mutex>
+
+#include <cuda.h>
+#include <cudaGL.h>
+
+#include "../Utils/NvCodecUtils.h"
+#include "FramePresenter.h"
+
+#include <thread>
+#include <queue>
+
+#pragma once
+
+// Controls the number of OpenGL and CUDA resources to be created.
+// Increasing this will increase the GPU memory utilization.
+#define BUFFER_COUNT 2
+
+// Singleton class to manage graphics resources
+class FramePresenterGLX : public FramePresenter {
+
+    CUgraphicsResource cuResource[BUFFER_COUNT];
+    GLuint pbo[BUFFER_COUNT];                 /*!< Buffer object to upload texture data */
+    GLuint tex[BUFFER_COUNT];                 /*!< OpenGL texture handle */
+    GLuint program;
+
+    // GLX resources
+    Display *display;
+    Window win;
+    GLXContext ctx;
+    GLXContext shared_ctx;
+    Colormap cmap;
+
+    CUcontext cuContext;
+
+    int currentFrame;
+    float totalWaitTime;
+
+    NvThread renderingThread;
+
+    public:
+
+    FramePresenterGLX(int w, int h);
+
+    ~FramePresenterGLX();
+
+    void init(int w, int h, CUcontext context);
+
+    // Following are pure virtual functions in FramePresenter class
+    void initWindowSystem();
+    void initOpenGLResources();
+    void releaseWindowSystem();
+
+    bool isVendorNvidia();
+    void Render();
+
+    bool GetDeviceFrameBuffer(CUdeviceptr*, int *);
+    void ReleaseDeviceFrameBuffer();
+
+    ConcurrentQueue<int> frameFeeder;
+
+    Display*& getDisplay() {
+        return this->display;
+    }
+
+    Window& getWindow() {
+        return this->win;
+    }
+
+    GLXContext& getContext() {
+        return this->ctx;
+    }
+
+    GLXContext& getSharedContext() {
+        return this->shared_ctx;
+    }
+
+    Colormap& getColorMap() {
+        return this->cmap;
+    }
+
+    GLuint* getPBO() {
+        return this->pbo;
+    }
+
+    GLuint* getTextures() {
+        return this->tex;
+    }
+
+    GLuint& getProgramObject() {
+        return this->program;
+    }
+
+    void setDimensions(unsigned int w, unsigned int h) {
+
+        this->width = w;
+        this->height = h;
+    }
+
+    int getWidth() {
+        return this->width;
+    }
+
+    int getHeight() {
+        return this->height;
+    }
+
+    void mapBufferObject(CUdeviceptr*);
+    void unmapBufferObject();
+};

video_codec_sdk/Samples/AppDecode/AppDecImageProvider/AppDecImageProvider.cpp

@@ -0,0 +1,498 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecImageProvider.cpp
+//! \brief Source file for AppDecImageProvider sample
+//!
+//! This sample application illustrates the decoding of a media file in a desired color format.
+//! The application supports native (nv12 or p016), bgra, bgrp and bgra64 output formats.
+//---------------------------------------------------------------------------
+
+#include <cuda.h>
+#include <iostream>
+#include <algorithm>
+#include <memory>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Utils/ColorSpace.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+/**
+*   @brief  Function to copy image data from CUDA device pointer to host buffer
+*   @param  dpSrc   - CUDA device pointer which holds decoded raw frame
+*   @param  pDst    - Pointer to host buffer which acts as the destination for the copy
+*   @param  nWidth  - Width of decoded frame
+*   @param  nHeight - Height of decoded frame
+*/
+void GetImage(CUdeviceptr dpSrc, uint8_t *pDst, int nWidth, int nHeight)
+{
+    CUDA_MEMCPY2D m = { 0 };
+    m.WidthInBytes = nWidth;
+    m.Height = nHeight;
+    m.srcMemoryType = CU_MEMORYTYPE_DEVICE;
+    m.srcDevice = (CUdeviceptr)dpSrc;
+    m.srcPitch = m.WidthInBytes;
+    m.dstMemoryType = CU_MEMORYTYPE_HOST;
+    m.dstDevice = (CUdeviceptr)(m.dstHost = pDst);
+    m.dstPitch = m.WidthInBytes;
+    cuMemcpy2D(&m);
+}
+
+enum OutputFormat
+{
+    native = 0, bgrp, rgbp, bgra, rgba, bgra64, rgba64, rgb, bgr
+};
+
+std::vector<std::string> vstrOutputFormatName =
+{
+    "native", "bgrp", "rgbp", "bgra", "rgba", "bgra64", "rgba64", "rgb", "bgr"
+};
+
+std::string GetSupportedFormats()
+{
+    std::ostringstream oss;
+    for (auto& v : vstrOutputFormatName)
+    {
+        oss << " " << v;
+    }
+
+    return oss.str();
+}
+
+static void ShowBriefHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Image Provider Sample Application\n";
+    oss << "================================================\n\n";
+    
+    oss << "Usage: AppDecImageProvider -i <input_file> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << "N/A\n";
+
+    oss << std::left << std::setw(25) << "-o <path>" 
+        << std::setw(12) << "Optional"
+        << "out.<format>\n";
+
+    oss << std::left << std::setw(25) << "-of <format>" 
+        << std::setw(12) << "Optional"
+        << "native\n";
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << "\nSupported output formats:" << GetSupportedFormats() << "\n";
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowDetailedHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Image Provider Sample Application - Detailed Help\n";
+    oss << "=============================================================\n\n";
+    
+    oss << "Usage: AppDecImageProvider -i <input_file> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Description\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "Input video file path\n";
+
+    // Optional arguments
+    oss << std::left << std::setw(25) << "-o <path>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "out.<format>"
+        << "Output file path\n";
+
+    oss << std::left << std::setw(25) << "-of <format>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "native"
+        << "Output format\n";
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "GPU device ordinal\n";
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-i" << ": Input video file path. Supported formats include H.264, HEVC, MPEG-2, VP8, VP9, AV1\n";
+    oss << std::left << std::setw(25) << "-o" << ": Output file path. If not specified, defaults to 'out.<format>'\n";
+    oss << std::left << std::setw(25) << "-of" << ": Output format for decoded frames. See supported formats below\n";
+    oss << std::left << std::setw(25) << "-gpu" << ": GPU device ordinal for decoding. Must be within available GPU range\n";
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print usage information for common commandline options\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print usage information for common and advanced commandline options\n";
+    oss << std::left << std::setw(25) << "-dc/--decode-caps" << ": Print decode capabilities of GPU\n";
+
+    // Output format details
+    oss << "\nSupported Output Formats:\n";
+    oss << "----------------------\n";
+    oss << "native    : Original decoded format (NV12/P016)\n";
+    oss << "bgrp     : Planar BGR\n";
+    oss << "rgbp     : Planar RGB\n";
+    oss << "bgra     : Interleaved BGRA-8bit\n";
+    oss << "rgba     : Interleaved RGBA-8bit\n";
+    oss << "bgra64   : Interleaved BGRA-16bit\n";
+    oss << "rgba64   : Interleaved RGBA-16bit\n";
+    oss << "rgb      : Interleaved RGB-8bit\n";
+    oss << "bgr      : Interleaved BGR-8bit\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    oss << "* Native format is used by default if -of is not specified\n";
+    oss << "* Output filename will be 'out.<format>' if -o is not specified\n";
+    oss << "* GPU ordinal must be within available GPU range\n";
+    oss << std::endl;
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowHelpAndExit(const char *szBadOption = NULL)
+{
+    if (szBadOption) 
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+void ParseCommandLine(int argc, char *argv[], char *szInputFileName,
+    OutputFormat &eOutputFormat, char *szOutputFileName, int &iGpu)
+{
+    std::ostringstream oss;
+    if (argc == 1) {
+        std::cout << "No Arguments provided! Please refer to the following for options:" << "\"\n";
+        ShowBriefHelp();
+    }
+
+    int i;
+    for (i = 1; i < argc; i++) {
+        if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+            ShowBriefHelp();
+        }
+        if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+            ShowDetailedHelp();
+        }
+        if (!_stricmp(argv[i], "-dc") || !_stricmp(argv[i], "--decode-caps")) {
+            ShowDecoderCapability();
+        }
+        if (!_stricmp(argv[i], "-i")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-i");
+            }
+            sprintf(szInputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-o")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-o");
+            }
+            sprintf(szOutputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-of")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-of");
+            }
+            auto it = find(vstrOutputFormatName.begin(), vstrOutputFormatName.end(), argv[i]);
+            if (it == vstrOutputFormatName.end()) {
+                ShowHelpAndExit("-of");
+            }
+            eOutputFormat = (OutputFormat)(it - vstrOutputFormatName.begin());
+            continue;
+        }
+        if (!_stricmp(argv[i], "-gpu")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-gpu");
+            }
+            iGpu = atoi(argv[i]);
+            continue;
+        }
+        ShowHelpAndExit(argv[i]);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    char szInFilePath[256] = "", szOutFilePath[256] = "";
+    OutputFormat eOutputFormat = native;
+    int iGpu = 0;
+    bool bReturn = 1;
+    CUdeviceptr pTmpImage = 0;
+
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, eOutputFormat, szOutFilePath, iGpu);
+        CheckInputFile(szInFilePath);
+
+        if (!*szOutFilePath)
+        {
+            sprintf(szOutFilePath, "out.%s", vstrOutputFormatName[eOutputFormat].c_str());
+        }
+
+        std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+        if (!fpOut)
+        {
+            std::ostringstream err;
+            err << "Unable to open output file: " << szOutFilePath << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]";
+            throw std::invalid_argument(err.str());
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        FFmpegDemuxer demuxer(szInFilePath);
+        NvDecoder dec(cuContext, true, FFmpeg2NvCodecId(demuxer.GetVideoCodec()));
+        int nWidth = 0, nHeight = 0, nFrameSize = 0;
+        int anSize[] = { 0, 3, 3, 4, 4, 8, 8, 3, 3 };
+        std::unique_ptr<uint8_t[]> pImage;
+
+        int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0, iMatrix = 0;
+        uint8_t *pVideo = nullptr;
+        uint8_t *pFrame;
+
+        do {
+            demuxer.Demux(&pVideo, &nVideoBytes);
+            nFrameReturned = dec.Decode(pVideo, nVideoBytes);
+            if (!nFrame && nFrameReturned)
+            {
+                LOG(INFO) << dec.GetVideoInfo();
+                // Get output frame size from decoder
+                nWidth = dec.GetWidth(); nHeight = dec.GetHeight();
+                nFrameSize = eOutputFormat == native ? dec.GetFrameSize() : nWidth * nHeight * anSize[eOutputFormat];
+                std::unique_ptr<uint8_t[]> pTemp(new uint8_t[nFrameSize]);
+                pImage = std::move(pTemp);
+                cuMemAlloc(&pTmpImage, nWidth * nHeight * anSize[eOutputFormat]);
+            }
+
+            for (int i = 0; i < nFrameReturned; i++)
+            {
+                iMatrix = dec.GetVideoFormatInfo().video_signal_description.matrix_coefficients;
+                pFrame = dec.GetFrame();
+                if (dec.GetBitDepth() == 8) {
+                    switch (eOutputFormat) {
+                    case native:
+                        GetImage((CUdeviceptr)pFrame, reinterpret_cast<uint8_t*>(pImage.get()), dec.GetWidth(), dec.GetHeight() + (dec.GetChromaHeight() * dec.GetNumChromaPlanes()));
+                        break;
+                    case bgrp:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColorPlanar<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColorPlanar<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColorPlanar<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), dec.GetWidth(), 3 * dec.GetHeight());
+                        break;
+                    case rgbp:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColorPlanar<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColorPlanar<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColorPlanar<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), dec.GetWidth(), 3 * dec.GetHeight());
+                        break;
+                    case bgra:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12) 
+                            Nv12ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor32<BGRA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 4 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgba:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor32<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColor32<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor32<RGBA32>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 4 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgb:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor24<RGB24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColor24<RGB24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor24<RGB24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 3 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case bgr:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor24<BGR24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColor24<BGR24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor24<BGR24>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 3 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case bgra64:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor64<BGRA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColor64<BGRA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor64<BGRA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 8 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgba64:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444)
+                            YUV444ToColor64<RGBA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_NV12)
+                            Nv12ToColor64<RGBA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            Nv16ToColor64<RGBA64>(pFrame, dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);                           
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 8 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    }
+                }
+                else
+                {
+                    switch (eOutputFormat) {
+                    case native:
+                        GetImage((CUdeviceptr)pFrame, reinterpret_cast<uint8_t*>(pImage.get()), 2 * dec.GetWidth(), dec.GetHeight() + (dec.GetChromaHeight() * dec.GetNumChromaPlanes()));
+                        break;
+                    case bgrp:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColorPlanar<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColorPlanar<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColorPlanar<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), dec.GetWidth(), 3 * dec.GetHeight());
+                        break;
+                    case rgbp:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColorPlanar<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColorPlanar<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColorPlanar<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), dec.GetWidth(), 3 * dec.GetHeight());
+                        break;
+                    case bgra:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor32<BGRA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 4 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgba:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor32<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor32<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor32<RGBA32>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 4 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 4 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgb:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor24<RGB24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor24<RGB24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor24<RGB24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 3 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case bgr:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor24<BGR24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor24<BGR24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor24<BGR24>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 3 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 3 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case bgra64:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor64<BGRA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor64<BGRA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor64<BGRA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 8 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    case rgba64:
+                        if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_YUV444_16Bit)
+                            YUV444P16ToColor64<RGBA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else if (dec.GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                            P016ToColor64<RGBA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        else
+                            P216ToColor64<RGBA64>(pFrame, 2 * dec.GetWidth(), (uint8_t*)pTmpImage, 8 * dec.GetWidth(), dec.GetWidth(), dec.GetHeight(), iMatrix);
+                        GetImage(pTmpImage, reinterpret_cast<uint8_t*>(pImage.get()), 8 * dec.GetWidth(), dec.GetHeight());
+                        break;
+                    }
+                }
+
+                fpOut.write(reinterpret_cast<char*>(pImage.get()), nFrameSize);
+            }
+            nFrame += nFrameReturned;
+        } while (nVideoBytes);
+
+        if (pTmpImage) {
+            cuMemFree(pTmpImage);
+        }
+
+        std::cout << "Total frame decoded: " << nFrame << std::endl << "Saved in file " << szOutFilePath << std::endl;
+        fpOut.close();
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecImageProvider/CMakeLists.txt

@@ -0,0 +1,129 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecImageProvider)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecImageProvider.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_ENC_CUDA_UTILS
+ ${NVCODEC_UTILS_DIR}/ColorSpace.cu
+)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NVCODEC_UTILS_DIR}/ColorSpace.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+# CUDA 11.7 and later is compiled with /MT option (staticaly linked with C runtime), 
+# since we are statically linking cudart_static.lib with the app, 
+# we need to make sure that all .obj files linked are compiled with /MT to avoid linker warning LNK4098
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-Xcompiler /MT)
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    target_compile_options(${PROJECT_NAME} PRIVATE "/MT")
+endif()
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+
+endif ()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB} )
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecLowLatency/AppDecLowLatency.cpp

@@ -0,0 +1,113 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecLowLatency.cpp
+//! \brief Source file for AppDecLowLatency sample
+//!
+//! This sample application demonstrates low latency decoding feature.
+//! This feature helps to get output frame as soon as it is decoded without any delay.
+//! The feature will work for streams having I and P frames only.
+//---------------------------------------------------------------------------
+
+#include <vector>
+#include <cuda.h>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+int main(int argc, char *argv[]) 
+{
+    char szInFilePath[256] = "", szOutFilePath[256] = "out.yuv";
+    int iGpu = 0;
+    bool bVerbose = false;
+    // With zero latency flag enabled, HandlePictureDisplay() callback happens immediately for 
+    // the All-Intra/IPPP streams
+    bool force_zero_latency = false;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, szOutFilePath, iGpu, &bVerbose, NULL, &force_zero_latency);
+        CheckInputFile(szInFilePath);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        FFmpegDemuxer demuxer(szInFilePath);
+        // Here set bLowLatency=true in the constructor.
+        // Please don't use this flag except for low latency, it is harder to get 100% utilization of
+        // hardware decoder with this flag set.
+        NvDecoder dec(cuContext, false, FFmpeg2NvCodecId(demuxer.GetVideoCodec()), true, false, NULL, NULL, false, 0, 0, 1000, force_zero_latency);
+
+        int nFrame = 0;
+        uint8_t *pVideo = NULL;
+        int nVideoBytes = 0;
+        std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+        if (!fpOut)
+        {
+            std::ostringstream err;
+            err << "Unable to open output file: " << szOutFilePath << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        int n = 0;
+        bool bOneInOneOut = true;
+        int nFrameReturned = 0;
+        int64_t timestamp = 0;
+        do {
+            demuxer.Demux(&pVideo, &nVideoBytes);
+            // Set flag CUVID_PKT_ENDOFPICTURE to signal that a complete packet has been sent to decode
+            nFrameReturned = dec.Decode(pVideo, nVideoBytes, CUVID_PKT_ENDOFPICTURE, n++);
+            if (!nFrame && nFrameReturned)
+                LOG(INFO) << dec.GetVideoInfo();
+
+            nFrame += nFrameReturned;
+            // For a stream without B-frames, "one in and one out" is expected, and nFrameReturned should be always 1 for each input packet
+            if (bVerbose)
+            {
+                std::cout << "Decode: nVideoBytes=" << nVideoBytes << ", nFrameReturned=" << nFrameReturned << ", total=" << nFrame << std::endl;
+            }
+            if (nVideoBytes && nFrameReturned != 1)
+            {
+                bOneInOneOut = false;
+            }
+            for (int i = 0; i < nFrameReturned; i++) 
+            {
+                fpOut.write(reinterpret_cast<char*>(dec.GetFrame(&timestamp)), dec.GetFrameSize());
+                if (bVerbose)
+                {
+                    std::cout << "Timestamp: " << timestamp << std::endl;
+                }
+            }
+        } while (nVideoBytes);
+
+        fpOut.close();
+        std::cout << "One packet in and one frame out: " << (bOneInOneOut ? "true" : "false") << std::endl;
+    }
+    catch(const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecLowLatency/CMakeLists.txt

@@ -0,0 +1,112 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecLowLatency)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecLowLatency.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} FILES_MATCHING PATTERN "*.lib")
+endif ()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB})
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()

video_codec_sdk/Samples/AppDecode/AppDecMem/AppDecMem.cpp

@@ -0,0 +1,123 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecMem.cpp
+//! \brief Source file for AppDecMem sample
+//!
+//! This sample application is similar to AppDec. It illustrates how to demux and decode media content from memory buffer.
+//! It allocates AVIOContext explicitely and also defines method to read data packets from input file.
+//! For simplicity, this application reads the input stream and stores it in a buffer before invoking the demuxer.
+//---------------------------------------------------------------------------
+
+#include <cuda.h>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+class FileDataProvider : public FFmpegDemuxer::DataProvider {
+public:
+    FileDataProvider(const char *szInFilePath) {
+        fpIn.open(szInFilePath, std::ifstream::in | std::ifstream::binary);
+        if (!fpIn)
+        {
+            std::cout << "Unable to open input file: " << szInFilePath << std::endl;
+            return;
+        }
+    }
+    ~FileDataProvider() {
+        fpIn.close();
+    }
+    // Fill in the buffer owned by the demuxer/decoder
+    int GetData(uint8_t *pBuf, int nBuf) {
+        if (fpIn.eof())
+        {
+            return AVERROR_EOF;
+        }
+
+        // We read a file for this example. You may get your data from network or somewhere else
+        return (int)fpIn.read(reinterpret_cast<char*>(pBuf), nBuf).gcount();
+    }
+
+private:
+    std::ifstream fpIn;
+};
+
+int main(int argc, char *argv[])
+{
+    char szInFilePath[256] = "", szOutFilePath[256] = "out.yuv";
+    int iGpu = 0;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, szOutFilePath, iGpu);
+        CheckInputFile(szInFilePath);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        FileDataProvider dp(szInFilePath);
+        // Instead of passing in a media file path, here we pass in a DataProvider, which reads from the file.
+        // Note that the data is passed into the demuxer chunk-by-chunk sequentially. If the meta data is at the end of the file
+        // (as for MP4) and the buffer isn't large enough to hold the whole file, the file may never get demuxed.
+        // Allocated buffer size is 32 MB. Please increase buffer size (avioc_buffer_size) in CreateFormatContext(DataProvider *pDataProvider)
+        // if this limitation is faced.
+        FFmpegDemuxer demuxer(&dp);
+        NvDecoder dec(cuContext, false, FFmpeg2NvCodecId(demuxer.GetVideoCodec()));
+
+        int nFrame = 0;
+        uint8_t *pVideo = NULL;
+        int nVideoBytes = 0;
+        uint8_t *pFrame;
+        int nFrameReturned = 0;
+        std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+        if (!fpOut)
+        {
+            std::ostringstream err;
+            err << "Unable to open output file: " << szOutFilePath << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+        do
+        {
+            demuxer.Demux(&pVideo, &nVideoBytes);
+            nFrameReturned = dec.Decode(pVideo, nVideoBytes);
+            if (!nFrame && nFrameReturned)
+                LOG(INFO) << dec.GetVideoInfo();
+
+            nFrame += nFrameReturned;
+            for (int i = 0; i < nFrameReturned; i++) {
+                pFrame = dec.GetFrame();
+                fpOut.write(reinterpret_cast<char*>(pFrame), dec.GetFrameSize());
+            }
+        } while (nVideoBytes);
+        fpOut.close();
+        const char *aszDecodeOutFormat[] = { "NV12", "P016", "YUV444", "YUV444P16", "NV16", "P216"};
+        std::cout << "Total frame decoded: " << nFrame << std::endl << "Saved in file " << szOutFilePath << " in format " << aszDecodeOutFormat[dec.GetOutputFormat()] << std::endl;
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecMem/CMakeLists.txt

@@ -0,0 +1,114 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecMem)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecMem.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_APPDEC_COMMON_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.lib")
+endif()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB})
+
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecMultiFiles/AppDecMultiFiles.cpp

@@ -0,0 +1,452 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecMultiFiles.cpp
+//! \brief Source file for AppDecMultiFiles sample
+//!
+//!  This sample application illustrates the decoding of multiple files with/without using the decoder Reconfigure API.
+//!  It also displays the time taken for decoder creation and destruction.
+//!  Multiple files are specified using '-filelist' commandline option.
+//!  The app will decode files in a sequential manner.
+//---------------------------------------------------------------------------
+
+#include <iostream>
+#include <algorithm>
+#include <thread>
+#include <cuda.h>
+#include <deque>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+typedef struct
+{
+    char inFile[256];
+    char outFile[256];
+    Dim resizeDim;
+    Rect cropRect;
+    bool outplanar;
+} FILEINFO;
+
+void ConvertToPlanar(uint8_t *pHostFrame, int nWidth, int nHeight, int nBitDepth, uint8_t nChromaFormat) {
+    if (nBitDepth == 8) {
+        YuvConverter<uint8_t> converter8(nWidth, nHeight, nChromaFormat);
+        converter8.UVInterleavedToPlanar(pHostFrame);
+    } else {
+        YuvConverter<uint16_t> converter16(nWidth, nHeight, nChromaFormat);
+        converter16.UVInterleavedToPlanar((uint16_t *)pHostFrame);
+    }
+}
+
+void getMaxWidthandMaxHeight(int &maxWidth, int &maxHeight, cudaVideoCodec aeCodec, int anBitDepthMinus8)
+{
+    CUVIDDECODECAPS decodeCaps = {};
+    decodeCaps.eCodecType = aeCodec;
+    decodeCaps.eChromaFormat = cudaVideoChromaFormat_420;
+    decodeCaps.nBitDepthMinus8 = anBitDepthMinus8;
+
+    cuvidGetDecoderCaps(&decodeCaps);
+
+    maxWidth = decodeCaps.nMaxWidth;
+    maxHeight = decodeCaps.nMaxHeight;
+
+}
+
+/**
+*   @brief  Function to decode media file and write raw frames into another file.
+*   @param  cuContext      - Handle to CUDA context
+*   @param  pDec           - Handle to NvDecoder
+*   @param  fileData       - FILEINFO variable which holds various file details
+*   @param  useReconfigure - Flag to enable/disable reconfigure api for decoding multiple files
+*   @param  maxWidth       - The maximum width that the decoder session can be reconfigured to.
+*                            The widths of all the input streams in the files specified by the -filelist option,
+*                            must not exceed this value. This value defaults to 0.
+*   @param  maxHeight      - The maximum height that the decoder session can be reconfigured to.
+*                            The heights of all the input streams in the files specified by the -filelist option,
+*                            must not exceed this value. This value defaults to 0.
+*/
+void DecodeMediaFile(CUcontext cuContext, NvDecoder **pDec, FILEINFO fileData, int useReconfigure, int maxWidth = 0, int maxHeight = 0)
+{
+    std::ofstream fpOut(fileData.outFile, std::ios::out | std::ios::binary);
+    if (!fpOut)
+    {
+        std::ostringstream err;
+        err << "Unable to open output file: " << fileData.outFile << std::endl;
+        throw std::invalid_argument(err.str());
+    }
+
+    FFmpegDemuxer demuxer(fileData.inFile);
+    NvDecoder *dec = *pDec;
+
+    if (useReconfigure)
+    {
+        if (dec == NULL)
+        {
+            if ((!maxWidth) || (!maxHeight))
+            {
+                // Get MaxWidth/MaxHeight for particular codec and bitdepth if not set in commandline
+                getMaxWidthandMaxHeight(maxWidth, maxHeight, FFmpeg2NvCodecId(demuxer.GetVideoCodec()), demuxer.GetBitDepth() - 8);
+            }
+
+            dec = new NvDecoder(cuContext, false, FFmpeg2NvCodecId(demuxer.GetVideoCodec()),
+                false, false, &fileData.cropRect, &fileData.resizeDim, false, maxWidth, maxHeight);
+            *pDec = dec;
+        }
+        else
+        {
+            dec->setReconfigParams(&fileData.cropRect, &fileData.resizeDim);
+        }
+
+    }
+    else
+    {
+        dec = new NvDecoder(cuContext, false, FFmpeg2NvCodecId(demuxer.GetVideoCodec()),
+            false, false, &fileData.cropRect, &fileData.resizeDim);
+    }
+
+    int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0;
+    uint8_t *pVideo = NULL, *pFrame;
+    bool bDecodeOutSemiPlanar = false;
+    do {
+        demuxer.Demux(&pVideo, &nVideoBytes);
+        nFrameReturned = dec->Decode(pVideo, nVideoBytes);
+        if (!nFrame && nFrameReturned)
+            LOG(INFO) << dec->GetVideoInfo();
+
+        bDecodeOutSemiPlanar = (dec->GetOutputFormat() == cudaVideoSurfaceFormat_NV12) || (dec->GetOutputFormat() == cudaVideoSurfaceFormat_P016)
+                               || (dec->GetOutputFormat() == cudaVideoSurfaceFormat_NV16) || (dec->GetOutputFormat() == cudaVideoSurfaceFormat_P216);
+        for (int i = 0; i < nFrameReturned; i++) {
+            pFrame = dec->GetFrame();
+            if (fileData.outplanar && bDecodeOutSemiPlanar) {
+                ConvertToPlanar(pFrame, dec->GetWidth(), dec->GetHeight(), dec->GetBitDepth(), dec->GetOutputChromaFormat());
+            }
+            fpOut.write(reinterpret_cast<char*>(pFrame), dec->GetFrameSize());
+        }
+        nFrame += nFrameReturned;
+    } while (nVideoBytes);
+
+    std::vector<std::string> aszDecodeOutFormat = { "NV12", "P016", "YUV444", "YUV444P16", "NV16", "P216" };
+    if (fileData.outplanar) {
+        aszDecodeOutFormat[0] = "iyuv";      aszDecodeOutFormat[1] = "yuv420p16";
+        aszDecodeOutFormat[4] = "yuv422p";   aszDecodeOutFormat[5] = "yuv422p16";
+    }
+    std::cout << "Total frame decoded: " << nFrame << std::endl
+            << "Saved in file " << fileData.outFile << " in "
+            << aszDecodeOutFormat[dec->GetOutputFormat()]
+            << " format" << std::endl;
+    if (!useReconfigure)
+    {
+        delete dec;
+        dec = NULL;
+    }
+    fpOut.close();
+}
+
+static void ShowBriefHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Multi-File Sample Application\n";
+    oss << "============================================\n\n";
+    
+    oss << "Usage: AppDecMultiFiles -filelist <list.txt> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-filelist <path>" 
+        << std::setw(12) << "Required"
+        << "N/A\n";
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << std::left << std::setw(25) << "-usereconfigure <n>" 
+        << std::setw(12) << "Optional"
+        << "1\n";
+
+    oss << std::left << std::setw(25) << "-maxwidth <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << std::left << std::setw(25) << "-maxheight <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowDetailedHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Multi-File Sample Application - Detailed Help\n";
+    oss << "========================================================\n\n";
+    
+    oss << "Usage: AppDecMultiFiles -filelist <list.txt> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Usage\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-filelist <path>" 
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-filelist list.txt\n";
+
+    // Optional arguments
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-gpu 1\n";
+
+    oss << std::left << std::setw(25) << "-usereconfigure <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "1"
+        << "-usereconfigure 0\n";
+
+    oss << std::left << std::setw(25) << "-maxwidth <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-maxwidth 1920\n";
+
+    oss << std::left << std::setw(25) << "-maxheight <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-maxheight 1080\n";
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-filelist" << ": Input file path\n";
+    oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n";
+    oss << std::left << std::setw(25) << "-usereconfigure" << ": Use decoder reconfigure API\n";
+    oss << std::left << std::setw(25) << "-maxwidth" << ": Maximum width for reconfigure\n";
+    oss << std::left << std::setw(25) << "-maxheight" << ": Maximum height for reconfigure\n";
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print usage information for common commandline options\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print usage information for common and advanced commandline options\n";
+    oss << std::left << std::setw(25) << "-dc/--decode-caps" << ": Print decode capabilities of GPU\n";
+
+    // File list format
+    oss << "\nFile List Format:\n";
+    oss << "-----------------\n";
+    oss << "infile  input1.h264    (Input file path)\n";
+    oss << "outfile out1.yuv       (Output file path)\n";
+    oss << "outplanar 1            (Convert output to planar format)\n";
+    oss << "resize WxH             (Resize to dimension Width x Height)\n";
+    oss << "crop l,t,r,b           (Crop rectangle in left,top,right,bottom)\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    oss << "* Reconfigure API is enabled by default for decoding multiple files\n";
+    oss << "* Width and height in resize must be even numbers\n";
+    oss << "* Crop rectangle dimensions must be even numbers\n";
+    oss << "* When using reconfigure, all input files must be same codec\n";
+    oss << std::endl;
+
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowHelpAndExit(const char *szBadOption = NULL)
+{
+    if (szBadOption) 
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+void ParseCommandLine(std::deque<FILEINFO> *multiFileData, int &maxWidth, int &maxHeight, int &iGpu, bool &useReconfigure, int argc, char *argv[])
+{
+    FILEINFO fileData;
+    if (argc == 1) {
+        std::cout << "No Arguments provided! Please refer to the following for options:" << "\"\n";
+        ShowBriefHelp();
+    }
+
+    char filelistPath[256];
+
+    for (int i = 1; i < argc; i++) {
+        if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+            ShowBriefHelp();
+        }
+        if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+            ShowDetailedHelp();
+        }
+        if (!_stricmp(argv[i], "-dc") || !_stricmp(argv[i], "--decode-caps")) {
+            ShowDecoderCapability();
+        }
+        if (!_stricmp(argv[i], "-filelist")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-filelist");
+            }
+            sprintf(filelistPath, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-gpu")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-gpu");
+            }
+            iGpu = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-usereconfigure")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-usereconfigure");
+            }
+            useReconfigure = atoi(argv[i]) ? true : false;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-maxwidth")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-maxwidth");
+            }
+            maxWidth = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-maxheight")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-maxheight");
+            }
+            maxHeight = atoi(argv[i]);
+            continue;
+        }
+        ShowHelpAndExit(argv[i]);
+    }
+
+    // Parse the input filelist
+    std::ifstream filestream(filelistPath);
+    std::string line;
+    char* str;
+    char param[256];
+    char value[256];
+    int fileIdx = 0;
+    while (std::getline(filestream, line))
+    {
+        str = (char *)line.c_str();
+        sscanf(str,"%s %s", param, value);
+        if (0 == _stricmp(param, "infile"))
+        {
+            if (fileIdx > 0)
+            {
+                multiFileData->push_back(fileData);
+            }
+            sprintf(fileData.inFile, "%s", value);
+            fileIdx++;
+            fileData.resizeDim = { 0, 0 };
+            fileData.cropRect = { 0, 0, 0, 0 };
+            fileData.outplanar = 0;
+        }
+        else if (0 == _stricmp(param, "outfile"))
+        {
+            sprintf(fileData.outFile, "%s", value);
+        }
+        else if (0 == _stricmp(param, "outplanar"))
+        {
+            fileData.outplanar = atoi(value) ? true : false;
+        }
+        else if (0 == _stricmp(param, "resize"))
+        {
+            sscanf(value, "%dx%d", &fileData.resizeDim.w, &fileData.resizeDim.h);
+            if (fileData.resizeDim.w % 2 == 1 || fileData.resizeDim.h % 2 == 1) {
+                std::cout << "Resizing rect must have width and height of even numbers" << std::endl;
+                exit(1);
+            }
+        }
+        else if (0 == _stricmp(param, "crop"))
+        {
+            sscanf(value, "%d,%d,%d,%d", &fileData.cropRect.l, &fileData.cropRect.t, &fileData.cropRect.r, &fileData.cropRect.b);
+            if ((fileData.cropRect.r - fileData.cropRect.l) % 2 == 1 || (fileData.cropRect.b - fileData.cropRect.t) % 2 == 1) {
+                std::cout << "Cropping rect must have width and height of even numbers" << std::endl;
+                exit(1);
+            }
+        }
+    }
+    if (fileIdx > 0)
+    {
+        multiFileData->push_back(fileData);
+    }
+}
+
+int main(int argc, char **argv) 
+{
+    std::deque<FILEINFO> multiFileData;
+
+    int iGpu = 0;
+    int maxWidth = 0, maxHeight = 0;
+    bool useReconfigure = true;
+    FILEINFO fileData;
+    try
+    {
+        ParseCommandLine(&multiFileData, maxWidth, maxHeight, iGpu, useReconfigure, argc, argv);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu) {
+            std::cout << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            return 1;
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        std::cout << "Decode with demuxing." << std::endl;
+        NvDecoder* dec = NULL;
+
+        while (!multiFileData.empty())
+        {
+            fileData = multiFileData.front();
+            multiFileData.pop_front();
+
+            CheckInputFile(fileData.inFile);
+
+            DecodeMediaFile(cuContext, &dec, fileData, useReconfigure, maxWidth, maxHeight);
+
+        }
+
+        if (dec != NULL)
+        {
+            delete dec;
+            dec = NULL;
+        }
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+   
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecMultiFiles/CMakeLists.txt

@@ -0,0 +1,118 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecMultiFiles)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecMultiFiles.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_COMMON_HDR_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/../Common)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_DEC_COMMON_HDR_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.lib")
+endif()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB})
+
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecMultiInput/AppDecMultiInput.cpp

@@ -0,0 +1,234 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecMultiInput.cpp
+//! \brief Source file for AppDecMultiInput sample
+//!
+//! This sample application demonstrates how to decode multiple raw video files and
+//! post-process them with CUDA kernels on different CUDA streams.
+//! This sample applies Ripple effect as a part of post processing.
+//! The effect consists of ripples expanding across the surface of decoded frames
+//---------------------------------------------------------------------------
+
+#include <iostream>
+#include <algorithm>
+#include <thread>
+#include <memory>
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <cuda_profiler_api.h>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+void LaunchRipple(cudaStream_t stream, uint8_t *dpImage, int nWidth, int nHeight, int xCenter, int yCenter, int iTime);
+void LaunchOverlayRipple(cudaStream_t stream, uint8_t *dpNv12, uint8_t *dpRipple, int nWidth, int nHeight);
+void LaunchMerge(cudaStream_t stream, uint8_t *dpNv12Merged, uint8_t **pdpNv12, int nImage, int nWidth, int nHeight);
+
+/**
+*   @brief  Function to decode frame from media file and post process it using CUDA kernels. 
+*   @param  pDec          - Pointer to NvDecoder object which is already initialized
+*   @param  szInFilePath  - Path to file to be decoded
+*   @param  nWidth        - Width of the decoded video
+*   @param  nHeight       - Height of the decoded video
+*   @param  apFrameBuffer - Pointer to decoded frame
+*   @param  nFrameBuffer  - Capacity of decoder's own circular queue
+*   @param  piEnd         - Pointer to hold value of queue's end
+*   @param  piHead        - Pointer to hold value of queue's start
+*   @param  pbStop        - Boolean to mark the end of post processing by this function
+*   @param  stream        - Pointer to CUDA stream
+*   @param  xCenter       - X co-ordinate of ripple center
+*   @param  yCenter       - Y co-ordinate of ripple center
+*   @param  ex            - Stores exception value in case exception is raised
+*
+*/
+void DecProc(NvDecoder *pDec, const char *szInFilePath, int nWidth, int nHeight, uint8_t **apFrameBuffer,
+    int nFrameBuffer, int *piEnd, int *piHead, bool *pbStop, cudaStream_t stream, 
+    int xCenter, int yCenter, std::exception_ptr &ex) 
+{
+    try
+    {
+        FFmpegDemuxer demuxer(szInFilePath);
+        ck(cuCtxSetCurrent(pDec->GetContext()));
+        uint8_t *dpRippleImage;
+        ck(cudaMalloc(&dpRippleImage, (size_t)nWidth * nHeight));
+        int iTime = 0;
+        // Render a ripple image on dpRippleImage
+        LaunchRipple(stream, dpRippleImage, nWidth, nHeight, xCenter, yCenter, iTime++);
+        int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0;
+        uint8_t *pVideo = NULL, *pFrame;
+
+        do
+        {
+            demuxer.Demux(&pVideo, &nVideoBytes);
+            nFrameReturned = pDec->Decode(pVideo, nVideoBytes);
+
+            for (int i = 0; i < nFrameReturned; i++) {
+                pFrame = pDec->GetLockedFrame();
+                // For each decoded frame
+                while (*piHead == *piEnd) {
+                    // Queue is full
+                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                }
+                // Frame buffer is locked, so no data copy is needed here
+                apFrameBuffer[*piHead % nFrameBuffer] = pFrame;
+                // Overlay dpRippleImage onto the frame buffer
+                LaunchOverlayRipple(stream, apFrameBuffer[*piHead % nFrameBuffer], dpRippleImage, nWidth, nHeight);
+                // Make sure CUDA kernel is finished before marking the current position as ready
+                ck(cudaStreamSynchronize(stream));
+                // Mark as ready
+                ++*piHead;
+                LaunchRipple(stream, dpRippleImage, nWidth, nHeight, xCenter, yCenter, iTime++);
+            }
+        } while (nVideoBytes);
+
+        ck(cudaFree(dpRippleImage));
+        *pbStop = true;
+    }
+    catch (std::exception&)
+    {
+        ex = std::current_exception();
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    char szInFilePath[256] = "", szOutFilePath[256] = "out.nv12";
+    int iGpu = 0;
+    std::vector<std::exception_ptr> vExceptionPtrs;
+    try
+    {
+        ParseCommandLine(argc, argv, szInFilePath, szOutFilePath, iGpu);
+        CheckInputFile(szInFilePath);
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu)
+        {
+            std::ostringstream err;
+            err << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            throw std::invalid_argument(err.str());
+
+        }
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        FFmpegDemuxer demuxer(szInFilePath);
+        // 4:2:0 output need 2 byte width alignment
+        int nWidth = (demuxer.GetWidth() + 1) & ~1, nHeight = demuxer.GetHeight(), nByte = nWidth * nHeight * 3 / 2;
+        Dim decodeDim = { nWidth , nHeight };
+        // Number of decoders
+        const int n = 4;
+        // Every decoder has its own round queue
+        uint8_t *aapFrameBuffer[n][8];
+        // Queue capacity
+        const int nFrameBuffer = sizeof(aapFrameBuffer[0]) / sizeof(aapFrameBuffer[0][0]);
+        int iEnd = nFrameBuffer;
+        bool abStop[n] = {};
+        int aiHead[n] = {};
+        std::vector <NvThread> vThreads;
+        std::vector <std::unique_ptr<NvDecoder>> vDecoders;
+        // Coordinate of the ripple center for each decoder
+        int axCenter[] = { nWidth / 4, nWidth / 4 * 3, nWidth / 4, nWidth / 4 * 3 };
+        int ayCenter[] = { nHeight / 4, nHeight / 4, nHeight / 4 * 3, nHeight / 4 * 3 };
+        cudaStream_t aStream[n];
+        vExceptionPtrs.resize(n);
+        for (int i = 0; i < n; i++)
+        {
+            ck(cudaStreamCreate(&aStream[i]));
+            std::unique_ptr<NvDecoder> dec(new NvDecoder(cuContext, true, FFmpeg2NvCodecId(demuxer.GetVideoCodec()), false, false, NULL, &decodeDim));
+            vDecoders.push_back(std::move(dec));
+            vThreads.push_back(NvThread(std::thread(DecProc, vDecoders[i].get(), szInFilePath, nWidth, nHeight, aapFrameBuffer[i],
+                nFrameBuffer, &iEnd, aiHead + i, abStop + i, aStream[i], axCenter[i], ayCenter[i], std::ref(vExceptionPtrs[i]))));
+        }
+
+        std::unique_ptr<uint8_t[]> pImage(new uint8_t[nByte]);
+        uint8_t* dpImage = nullptr;
+        ck(cudaMalloc(&dpImage, nByte));
+        std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+        if (!fpOut)
+        {
+            std::ostringstream err;
+            err << "Unable to open output file: " << szOutFilePath << std::endl;
+            throw std::invalid_argument(err.str());
+        }
+
+        int nFrame = 0;
+        for (int i = 0;; i++)
+        {
+            // For each decoded frame #i
+            // iHead is used for ensuring all decoders have made progress
+            int iHead = INT_MAX;
+            for (int j = 0; j < n; j++)
+            {
+                while (!abStop[j] && aiHead[j] <= i)
+                {
+                    // Decoder #j hasn't decoded frame #i
+                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                }
+                iHead = (std::min)(iHead, aiHead[j]);
+            }
+            if (iHead <= i)
+            {
+                // Some decoder stops
+                nFrame = i;
+                break;
+            }
+
+            std::cout << "Merge frames at #" << i << "\r";
+            uint8_t *apNv12[] = { aapFrameBuffer[0][i % nFrameBuffer], aapFrameBuffer[1][i % nFrameBuffer], aapFrameBuffer[2][i % nFrameBuffer], aapFrameBuffer[3][i % nFrameBuffer] };
+            // Merge all frames into dpImage
+            LaunchMerge(0, dpImage, apNv12, n, nWidth, nHeight);
+            ck(cudaMemcpy(pImage.get(), dpImage, nByte, cudaMemcpyDeviceToHost));
+            fpOut.write(reinterpret_cast<char*>(pImage.get()), nByte);
+
+            for (int j = 0; j < n; j++)
+            {
+                vDecoders[j]->UnlockFrame(&aapFrameBuffer[j][i % nFrameBuffer]);
+            }
+            iEnd++;
+        }
+        fpOut.close();
+        ck(cudaFree(dpImage));
+
+        for (int i = 0; i < n; i++)
+        {
+            if (vExceptionPtrs[i])
+            {
+                std::rethrow_exception(vExceptionPtrs[i]);
+            }
+        }
+
+        ck(cudaProfilerStop());
+        if (nFrame)
+        {
+            std::cout << "Merged video saved in " << szOutFilePath << ". A total of " << nFrame << " frames were decoded." << std::endl;
+            return 0;
+        }
+        else
+        {
+            std::cout << "Warning: no video frame decoded. Please don't use container formats (such as mp4/avi/webm) as the input, but use raw elementary stream file instead." << std::endl;
+            return 1;
+        }
+    }
+    catch (const std::exception &ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecMultiInput/CMakeLists.txt

@@ -0,0 +1,125 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecMultiInput)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecMultiInput.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Image.cu
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_COMMON_HDR_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/../Common)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_DEC_COMMON_HDR_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+# CUDA 11.7 and later is compiled with /MT option (staticaly linked with C runtime), 
+# since we are statically linking cudart_static.lib with the app, 
+# we need to make sure that all .obj files linked are compiled with /MT to avoid linker warning LNK4098
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-Xcompiler /MT)
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+if (WIN32 AND CUDA_VERSION_MAJOR GREATER_EQUAL 11 AND CUDA_VERSION_MINOR GREATER_EQUAL 7)
+    target_compile_options(${PROJECT_NAME} PRIVATE "/MT")
+endif()
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll" )
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.lib")
+endif()
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB} )
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/AppDecMultiInput/Image.cu

@@ -0,0 +1,87 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+#include <stdint.h>
+#include <cuda_runtime.h>
+#include "../Utils/NvCodecUtils.h"
+
+#define SLEEP_TIME 0
+
+inline __device__ double sleep(int n) {
+    double d = 1.0;
+    for (int i = 0; i < n; i++) {
+        d += sin(d);
+    }
+    return d;
+}
+
+static __global__ void Ripple(uint8_t *pImage, int nWidth, int nHeight, int xCenter, int yCenter, int iTime) {
+    int ix = blockIdx.x * blockDim.x + threadIdx.x,
+        iy = blockIdx.y * blockDim.y + threadIdx.y;
+    if (ix >= nWidth || iy >= nHeight) {
+        return;
+    }
+    float dx = ix - xCenter, dy = iy - yCenter, d = sqrtf(dx * dx + dy * dy), dmax = sqrtf(nWidth * nWidth + nHeight * nHeight) / 2.0f;
+    pImage[iy * nWidth + ix] = (uint8_t)(127.0f * (1.0f - d / dmax) * sinf((d - iTime * 10)* 0.1) + 128.0f);
+    sleep(SLEEP_TIME);
+}
+
+void LaunchRipple(cudaStream_t stream, uint8_t *dpImage, int nWidth, int nHeight, int xCenter, int yCenter, int iTime) {
+    Ripple<<<dim3((nWidth + 15) / 16, (nHeight + 15) / 16), dim3(16, 16), 0, stream>>>(dpImage, nWidth, nHeight, xCenter, yCenter, iTime);
+}
+
+inline __device__ uint8_t clamp(int i) {
+    return (uint8_t)min(max(i, 0), 255);
+}
+
+static __global__ void OverlayRipple(uint8_t *pNv12, uint8_t *pRipple, int nWidth, int nHeight) {
+    int ix = blockIdx.x * blockDim.x + threadIdx.x,
+        iy = blockIdx.y * blockDim.y + threadIdx.y;
+    if (ix >= nWidth || iy >= nHeight) {
+        return;
+    }
+    pNv12[iy * nWidth + ix] = clamp(pNv12[iy * nWidth + ix] + (pRipple[iy * nWidth + ix] - 127.0f) * 0.8f);
+    sleep(SLEEP_TIME);
+}
+
+void LaunchOverlayRipple(cudaStream_t stream, uint8_t *dpNv12, uint8_t *dpRipple, int nWidth, int nHeight) {
+    OverlayRipple<<<dim3((nWidth + 15) / 16, (nHeight + 15) / 16), dim3(16, 16), 0, stream>>>(dpNv12, dpRipple, nWidth, nHeight);
+}
+
+static __global__ void Merge(uint8_t *pNv12Merged, uint8_t **apNv12, int nImage, int nWidth, int nHeight) {
+    int ix = blockIdx.x * blockDim.x + threadIdx.x,
+        iy = blockIdx.y * blockDim.y + threadIdx.y;
+    if (ix >= nWidth / 2 || iy >= nHeight / 2) {
+        return;
+    }
+    uint2 y01 = {}, y23 = {}, uv = {};
+    for (int i = 0; i < nImage; i++) {
+        uchar2 c2;
+        c2 = *(uchar2 *)(apNv12[i] + nWidth * iy * 2 + ix * 2);
+        y01.x += c2.x; y01.y += c2.y;
+        c2 = *(uchar2 *)(apNv12[i] + nWidth * (iy * 2 + 1) + ix * 2);
+        y23.x += c2.x; y23.y += c2.y;
+        c2 = *(uchar2 *)(apNv12[i] + nWidth * (nHeight + iy) + ix * 2);
+        uv.x += c2.x; uv.y += c2.y;
+    }
+    *(uchar2 *)(pNv12Merged + nWidth * iy * 2 + ix * 2) = uchar2 {(uint8_t)(y01.x / nImage), (uint8_t)(y01.y / nImage)};
+    *(uchar2 *)(pNv12Merged + nWidth * (iy * 2 + 1) + ix * 2) = uchar2 {(uint8_t)(y23.x / nImage), (uint8_t)(y23.y / nImage)};
+    *(uchar2 *)(pNv12Merged + nWidth * (nHeight + iy) + ix * 2) = uchar2 {(uint8_t)(uv.x / nImage), (uint8_t)(uv.y / nImage)};
+    sleep(SLEEP_TIME);
+}
+
+void LaunchMerge(cudaStream_t stream, uint8_t *dpNv12Merged, uint8_t **pdpNv12, int nImage, int nWidth, int nHeight) {
+    uint8_t **dadpNv12;
+    ck(cudaMalloc(&dadpNv12, sizeof(uint8_t *) * nImage));
+    ck(cudaMemcpy(dadpNv12, pdpNv12, sizeof(uint8_t *) * nImage, cudaMemcpyHostToDevice));
+    Merge<<<dim3((nWidth + 15) / 16, (nHeight + 15) / 16), dim3(8, 8), 0, stream>>>(dpNv12Merged, dadpNv12, nImage, nWidth, nHeight);
+    ck(cudaFree(dadpNv12));
+}

video_codec_sdk/Samples/AppDecode/AppDecPerf/AppDecPerf.cpp

@@ -0,0 +1,451 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecPerf.cpp
+//! \brief Source file for AppDecPerf sample
+//!
+//!  This sample application measures decoding performance in FPS.
+//!  The application creates multiple host threads and runs a different decoding session on each thread.
+//!  The number of threads can be controlled by the CLI option "-thread".
+//!  The application creates 2 host threads, each with a separate decode session, by default.
+//!  The application supports measuring the decode performance only (keeping decoded
+//!  frames in device memory as well as measuring the decode performance including transfer
+//!  of frames to the host memory.
+//---------------------------------------------------------------------------
+
+#include <cuda.h>
+#include <cudaProfiler.h>
+#include <stdio.h>
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include <string.h>
+#include <memory>
+#include "NvDecoder/NvDecoder.h"
+#include "../Utils/NvCodecUtils.h"
+#include "../Utils/FFmpegDemuxer.h"
+#include "../Common/AppDecUtils.h"
+#include <chrono>
+#include <future>
+#include <iomanip>
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+struct SessionStats
+{
+    int64_t initTime;   // session initialization time
+    int64_t decodeTime; // time taken by actual decoding operation
+    int frames;     // number of frames decoded
+};
+
+using NvDecodePromise = std::promise<SessionStats>;
+using NvDecodeFuture = std::future<SessionStats>;
+
+
+class NvDecoderPerf : public NvDecoder
+{
+public:
+    NvDecoderPerf(CUcontext cuContext, bool bUseDeviceFrame, cudaVideoCodec eCodec);
+    void SetSessionInitTime(int64_t duration) { m_sessionInitTime = duration; }
+    int64_t GetSessionInitTime() { return m_sessionInitTime; }
+
+    static void IncrementSessionInitCounter() { m_sessionInitCounter++; }
+    static uint32_t GetSessionInitCounter() { return m_sessionInitCounter; }
+    static void SetSessionCount(uint32_t count) { m_sessionCount = count; }
+    static uint32_t GetSessionCount(void) { return m_sessionCount; }
+
+protected:
+    int HandleVideoSequence(CUVIDEOFORMAT *pVideoFormat);
+
+    int64_t m_sessionInitTime;
+    static std::mutex m_initMutex;
+    static std::condition_variable m_cvInit;
+    static uint32_t m_sessionInitCounter;
+    static uint32_t m_sessionCount;
+};
+
+std::mutex NvDecoderPerf::m_initMutex;
+std::condition_variable NvDecoderPerf::m_cvInit;
+uint32_t NvDecoderPerf::m_sessionInitCounter = 0;
+uint32_t NvDecoderPerf::m_sessionCount = 1;
+
+NvDecoderPerf::NvDecoderPerf(CUcontext cuContext, bool bUseDeviceFrame, cudaVideoCodec eCodec)
+: NvDecoder(cuContext, bUseDeviceFrame, eCodec)
+{
+}
+
+int NvDecoderPerf::HandleVideoSequence(CUVIDEOFORMAT *pVideoFormat)
+{
+    auto sessionStart = std::chrono::high_resolution_clock::now();
+
+    int nDecodeSurface = NvDecoder::HandleVideoSequence(pVideoFormat);
+
+    std::unique_lock<std::mutex> lock(m_initMutex);
+
+    IncrementSessionInitCounter();
+
+    // Wait for all threads to finish initialization of the decoder session.
+    // This ensures that all threads start decoding frames at the same
+    // time and saturate the decoder engines. This also leads to more
+    // accurate measurement of decoding performance.
+    if (GetSessionInitCounter() == GetSessionCount())
+    {
+        m_cvInit.notify_all();
+    }
+    else
+    {
+        m_cvInit.wait(lock, [] { return NvDecoderPerf::GetSessionInitCounter() >= NvDecoderPerf::GetSessionCount(); });
+    }
+
+    auto sessionEnd = std::chrono::high_resolution_clock::now();
+    int64_t elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(sessionEnd - sessionStart).count();
+
+    SetSessionInitTime(elapsedTime);
+    return nDecodeSurface;
+}
+
+
+/**
+*   @brief  Function to decode media file using NvDecoder interface
+*   @param  pDec    - Handle to NvDecoder
+*   @param  demuxer - Pointer to an FFmpegDemuxer instance
+*   @param  pnFrame - Variable to record the number of frames decoded
+*   @param  ex      - Stores current exception in case of failure
+*/
+void DecProc(NvDecoderPerf *pDec, FFmpegDemuxer *demuxer, NvDecodePromise& promise, std::exception_ptr &ex)
+{
+    SessionStats stats = {0, 0, 0};
+    auto sessionStart = std::chrono::high_resolution_clock::now();
+
+    try
+    {
+        int nVideoBytes = 0, nFrameReturned = 0, nFrame = 0;
+        uint8_t *pVideo = NULL, *pFrame = NULL;
+
+        do {
+            demuxer->Demux(&pVideo, &nVideoBytes);
+            nFrameReturned = pDec->Decode(pVideo, nVideoBytes);
+            if (!nFrame && nFrameReturned)
+                LOG(INFO) << pDec->GetVideoInfo();
+
+            nFrame += nFrameReturned;
+        } while (nVideoBytes);
+        stats.frames = nFrame;
+        stats.initTime = pDec->GetSessionInitTime();
+    }
+    catch (std::exception&)
+    {
+        ex = std::current_exception();
+    }
+
+    auto sessionEnd = std::chrono::high_resolution_clock::now();
+    stats.decodeTime = std::chrono::duration_cast<std::chrono::milliseconds>(sessionEnd - sessionStart).count();
+
+    promise.set_value(stats);
+}
+
+static void ShowBriefHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Performance Sample Application\n";
+    oss << "============================================\n\n";
+    
+    oss << "Usage: AppDecPerf -i <input_file> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << "N/A\n";
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << std::left << std::setw(25) << "-thread <n>" 
+        << std::setw(12) << "Optional"
+        << "2\n";
+
+    oss << std::left << std::setw(25) << "-single" 
+        << std::setw(12) << "Optional"
+        << "false\n";
+
+    oss << std::left << std::setw(25) << "-host" 
+        << std::setw(12) << "Optional"
+        << "false\n";
+
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowDetailedHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Performance Sample Application - Detailed Help\n";
+    oss << "========================================================\n\n";
+    
+    oss << "Usage: AppDecPerf -i <input_file> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Usage\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-i input.h264\n";
+
+    // Optional arguments
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-gpu 1\n";
+
+    oss << std::left << std::setw(25) << "-thread <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "2"
+        << "-thread 4\n";
+
+    oss << std::left << std::setw(25) << "-single" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-single\n";
+
+    oss << std::left << std::setw(25) << "-host" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "false"
+        << "-host\n";
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-i" << ": Input file path\n";
+    oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n";
+    oss << std::left << std::setw(25) << "-thread" << ": Number of decoding threads\n";
+    oss << std::left << std::setw(25) << "-single" << ": Use single context\n";
+    oss << std::left << std::setw(25) << "-host" << ": Copy frame to host memory\n";
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print usage information for common commandline options\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print usage information for common and advanced commandline options\n";
+    oss << std::left << std::setw(25) << "-dc/--decode-caps" << ": Print decode capabilities of GPU\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    oss << "* Single context may result in suboptimal performance\n";
+    oss << "* Host memory copy may result in suboptimal performance\n";
+    oss << "* Multiple contexts are used by default\n";
+    oss << "* Device memory is used by default\n";
+    oss << std::endl;
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowHelpAndExit(const char *szBadOption = NULL)
+{
+    if (szBadOption) 
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+void ParseCommandLine(int argc, char *argv[], char *szInputFileName, int &iGpu, int &nThread, bool &bSingle, bool &bHost) 
+{
+    if (argc == 1) {
+        std::cout << "No Arguments provided! Please refer to the following for options:" << "\"\n";
+        ShowBriefHelp();
+    }
+    for (int i = 1; i < argc; i++) {
+        if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+            ShowBriefHelp();
+        }
+        if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+            ShowDetailedHelp();
+        }
+        if (!_stricmp(argv[i], "-dc") || !_stricmp(argv[i], "--decode-caps")) {
+            ShowDecoderCapability();
+        }
+        if (!_stricmp(argv[i], "-i")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-i");
+            }
+            sprintf(szInputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-gpu")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-gpu");
+            }
+            iGpu = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-thread")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-thread");
+            }
+            nThread = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-single")) {
+            bSingle = true;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-host")) {
+            bHost = true;
+            continue;
+        }
+        ShowHelpAndExit(argv[i]);
+    }
+}
+
+struct NvDecPerfData
+{
+    uint8_t *pBuf;
+    std::vector<uint8_t *> *pvpPacketData; 
+    std::vector<int> *pvpPacketDataSize;
+};
+
+int CUDAAPI HandleVideoData(void *pUserData, CUVIDSOURCEDATAPACKET *pPacket) {
+    NvDecPerfData *p = (NvDecPerfData *)pUserData;
+    memcpy(p->pBuf, pPacket->payload, pPacket->payload_size);
+    p->pvpPacketData->push_back(p->pBuf);
+    p->pvpPacketDataSize->push_back(pPacket->payload_size);
+    p->pBuf += pPacket->payload_size;
+    return 1;
+}
+
+int main(int argc, char **argv)
+{
+    char szInFilePath[256] = "";
+    int iGpu = 0;
+    int nThread = 2; 
+    bool bSingle = false;
+    bool bHost = false;
+    std::vector<std::exception_ptr> vExceptionPtrs;
+    std::vector<NvDecodePromise> vPromise;
+    std::vector<NvDecodeFuture> vFuture;
+
+    try {
+        ParseCommandLine(argc, argv, szInFilePath, iGpu, nThread, bSingle, bHost);
+        CheckInputFile(szInFilePath);
+
+        struct stat st;
+        if (stat(szInFilePath, &st) != 0) {
+            return 1;
+        }
+        int nBufSize = st.st_size;
+
+        uint8_t *pBuf = NULL;
+        try {
+            pBuf = new uint8_t[nBufSize];
+        }
+        catch (std::bad_alloc) {
+            std::cout << "Failed to allocate memory in BufferedReader" << std::endl;
+            return 1;
+        }
+        std::vector<uint8_t *> vpPacketData;
+        std::vector<int> vnPacketData;
+
+        NvDecPerfData userData = { pBuf, &vpPacketData, &vnPacketData };
+
+        ck(cuInit(0));
+        int nGpu = 0;
+        ck(cuDeviceGetCount(&nGpu));
+        if (iGpu < 0 || iGpu >= nGpu) {
+            std::cout << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+            return 1;
+        }
+        CUdevice cuDevice = 0;
+        ck(cuDeviceGet(&cuDevice, iGpu));
+        char szDeviceName[80];
+        ck(cuDeviceGetName(szDeviceName, sizeof(szDeviceName), cuDevice));
+        std::cout << "GPU in use: " << szDeviceName << std::endl;
+
+        std::vector<std::unique_ptr<FFmpegDemuxer>> vDemuxer;
+        std::vector<std::unique_ptr<NvDecoderPerf>> vDec;
+        CUcontext cuContext = NULL;
+        ck(NVCODEC_CUDA_CTX_CREATE(&cuContext, 0, cuDevice));
+        vExceptionPtrs.resize(nThread);
+        vPromise.resize(nThread);
+
+        for (int i = 0; i < nThread; i++)
+        {
+            if (!bSingle)
+            {
+                ck(NVCODEC_CUDA_CTX_CREATE(&cuContext, 0, cuDevice));
+            }
+            std::unique_ptr<FFmpegDemuxer> demuxer(new FFmpegDemuxer(szInFilePath));
+
+            NvDecoderPerf* sessionObject = new NvDecoderPerf(cuContext, !bHost, FFmpeg2NvCodecId(demuxer->GetVideoCodec()));
+            std::unique_ptr<NvDecoderPerf> dec(sessionObject);
+            vDemuxer.push_back(std::move(demuxer));
+            vDec.push_back(std::move(dec));
+        }
+
+        NvDecoderPerf::SetSessionCount(nThread);
+
+        float totalFPS = 0;
+        std::vector<NvThread> vThread;
+
+        for (int i = 0; i < nThread; i++)
+        {
+            vThread.push_back(NvThread(std::thread(DecProc, vDec[i].get(), vDemuxer[i].get(), std::ref(vPromise[i]), std::ref(vExceptionPtrs[i]))));
+            vFuture.push_back(vPromise[i].get_future());
+        }
+
+        int nTotal = 0;
+        for (int i = 0; i < nThread; i++)
+        {
+            SessionStats stats = vFuture[i].get();
+            nTotal += stats.frames;
+
+            totalFPS += (stats.frames / ((stats.decodeTime - stats.initTime) / 1000.0f));
+
+            vThread[i].join();
+            vDec[i].reset(nullptr);
+        }
+
+        std::cout << "Total Frames Decoded=" << nTotal << " FPS = " << totalFPS << std::endl;
+
+        ck(cuProfilerStop());
+
+        for (int i = 0; i < nThread; i++)
+        {
+            if (vExceptionPtrs[i])
+            {
+                std::rethrow_exception(vExceptionPtrs[i]);
+            }
+        }
+    }
+    catch (const std::exception& ex)
+    {
+        std::cout << ex.what();
+        exit(1);
+    }
+    return 0;
+}

video_codec_sdk/Samples/AppDecode/AppDecPerf/CMakeLists.txt

@@ -0,0 +1,116 @@
+# Copyright 2020-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+
+# 3.7 is required for FindVulkan module support in CMake.
+cmake_minimum_required(VERSION 3.7)
+
+project(AppDecPerf)
+
+set(APP_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/AppDecPerf.cpp
+)
+
+if(WIN32)
+    set(NV_FFMPEG_HDRS ${FFMPEG_DIR}/include)
+endif()
+
+set(NV_DEC_SOURCES
+ ${NV_DEC_DIR}/NvDecoder.cpp
+)
+
+set(NV_DEC_COMMON_HDR_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/../Common)
+
+set(NV_DEC_HDRS
+ ${NV_DEC_DIR}/NvDecoder.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/cuviddec.h
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}/nvcuvid.h
+ ${NVCODEC_UTILS_DIR}/NvCodecUtils.h
+ ${NVCODEC_UTILS_DIR}/FFmpegDemuxer.h
+ ${NV_DEC_COMMON_HDR_DIR}/AppDecUtils.h
+)
+
+source_group( "headers" FILES ${NV_DEC_HDRS} )
+source_group( "sources" FILES ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_ENC_CUDA_UTILS})
+
+# Try modern CUDAToolkit first for CMake 3.17+, fallback to deprecated CUDA module
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        # Map CUDAToolkit variables to legacy CUDA variable names
+        set(CUDA_CUDA_LIBRARY CUDA::cuda_driver)
+        set(CUDA_TOOLKIT_ROOT_DIR ${CUDAToolkit_TARGET_DIR})
+        set(CUDA_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+        set(CUDA_VERSION_MAJOR ${CUDAToolkit_VERSION_MAJOR})
+        set(CUDA_VERSION_MINOR ${CUDAToolkit_VERSION_MINOR})
+    endif()
+endif()
+if(NOT CUDAToolkit_FOUND)
+    find_package(CUDA)
+endif()
+
+set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+
+if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_75,code=\"sm_75,compute_75\")
+else()
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS};-gencode arch=compute_50,code=\"sm_50,compute_50\")
+endif()
+if ( CMAKE_COMPILER_IS_GNUCC )
+    if(NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
+        list(APPEND CUDA_NVCC_FLAGS -std=c++11)
+    endif()
+endif()
+
+# Use modern approach with CUDAToolkit when available, fallback to legacy FindCUDA
+if(CUDAToolkit_FOUND AND CUDAToolkit_NVCC_EXECUTABLE)
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+    enable_language(CUDA)
+    add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+    set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_STANDARD 11)
+    if(NVCODEC_CUDA_VERSION_13_OR_GREATER)
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "75")
+    else()
+        set_property(TARGET ${PROJECT_NAME} PROPERTY CUDA_ARCHITECTURES "50")
+    endif()
+else()
+    cuda_add_executable(${PROJECT_NAME} ${APP_SOURCES} ${NV_DEC_SOURCES} ${NV_DEC_HDRS} ${NV_ENC_CUDA_UTILS})
+endif()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}
+ ${NVCODEC_PUBLIC_INTERFACE_DIR}
+ ${NVCODEC_UTILS_DIR}
+ ${NV_CODEC_DIR}
+ ${NV_APPDEC_COMMON_DIR}
+ ${NV_FFMPEG_HDRS}
+)
+
+if(WIN32)
+    Set(AVCODEC_LIB ${FFMPEG_DIR}/lib/avcodec.lib)
+    Set(AVFORMAT_LIB ${FFMPEG_DIR}/lib/avformat.lib)
+    Set(AVUTIL_LIB ${FFMPEG_DIR}/lib/avutil.lib)
+    Set(SWRESAMPLE_LIB ${FFMPEG_DIR}/lib/swresample.lib)
+    #copy dll's
+    install(DIRECTORY ${FFMPEG_DLL_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.dll")
+    install(DIRECTORY ${FFMPEG_LIB_DIR} DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR} OPTIONAL FILES_MATCHING PATTERN "*.lib")
+endif()
+
+
+target_link_libraries(${PROJECT_NAME} ${CUDA_CUDA_LIBRARY} ${CMAKE_DL_LIBS} ${NVENCODEAPI_LIB} ${CUVID_LIB} ${AVCODEC_LIB}
+ ${AVFORMAT_LIB} ${AVUTIL_LIB} ${SWRESAMPLE_LIB})
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR})
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    set_target_properties( ${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${NVCODEC_SAMPLES_INSTALL_DIR}/$<CONFIG>/ )
+    add_dependencies(${PROJECT_NAME} copyFFMPEGFiles)
+    #copy pdb's
+    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${NVCODEC_SAMPLES_INSTALL_DIR}  CONFIGURATIONS Debug)
+endif()
+

video_codec_sdk/Samples/AppDecode/Common/AppDecUtils.h

@@ -0,0 +1,385 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+//---------------------------------------------------------------------------
+//! \file AppDecUtils.h
+//! \brief Header file containing definitions of miscellaneous functions used by Decode samples
+//---------------------------------------------------------------------------
+
+#pragma once
+#include <sstream>
+#include <iostream>
+
+static void ShowDecoderCapability();
+static void getOutputFormatNames(unsigned short nOutputFormatMask, char *OutputFormats);
+static void createCudaContext(CUcontext* cuContext, int iGpu, unsigned int flags);
+
+static void ShowBriefHelp(char *szOutputFileName, bool *pbVerbose, int *piD3d, bool *pbForce_zero_latency)
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Sample Application\n";
+    oss << "====================================\n\n";
+    
+    oss << "Usage: AppDec -i <input_file> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << "N/A\n";
+
+    if (szOutputFileName) {
+        oss << std::left << std::setw(25) << "-o <path>" 
+            << std::setw(12) << "Optional"
+            << "out.native/.planar\n";
+    }
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    if (pbVerbose) {
+        oss << std::left << std::setw(25) << "-v" 
+            << std::setw(12) << "Optional"
+            << "false\n";
+    }
+
+    if (piD3d) {
+        oss << std::left << std::setw(25) << "-d3d <n>" 
+            << std::setw(12) << "Optional"
+            << "9\n";
+    }
+
+    if (pbForce_zero_latency) {
+        oss << std::left << std::setw(25) << "-force_zero_latency" 
+            << std::setw(12) << "Optional"
+            << "false\n";
+    }
+
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowDetailedHelp(char *szOutputFileName, bool *pbVerbose, int *piD3d, bool *pbForce_zero_latency)
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Decoder Sample Application - Detailed Help\n";
+    oss << "================================================\n\n";
+    
+    oss << "Usage: AppDec -i <input_file> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument" 
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Example\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-i <path>" 
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-i input.h264\n";
+
+    // Optional arguments
+    if (szOutputFileName) {
+        oss << std::left << std::setw(25) << "-o <path>" 
+            << std::setw(12) << "Optional"
+            << std::setw(20) << "out.native/.planar"
+            << "-o output.yuv\n";
+    }
+
+    oss << std::left << std::setw(25) << "-gpu <n>" 
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-gpu 1\n";
+
+    if (pbVerbose) {
+        oss << std::left << std::setw(25) << "-v" 
+            << std::setw(12) << "Optional"
+            << std::setw(20) << "false"
+            << "-v\n";
+    }
+
+    if (piD3d) {
+        oss << std::left << std::setw(25) << "-d3d <n>" 
+            << std::setw(12) << "Optional"
+            << std::setw(20) << "9"
+            << "-d3d 11\n";
+    }
+
+    if (pbForce_zero_latency) {
+        oss << std::left << std::setw(25) << "-force_zero_latency" 
+            << std::setw(12) << "Optional"
+            << std::setw(20) << "false"
+            << "-force_zero_latency\n";
+    }
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-i" << ": Input file path\n";
+    if (szOutputFileName) {
+        oss << std::left << std::setw(25) << "-o" << ": Output file path\n";
+    }
+    oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n";
+    if (pbVerbose) {
+        oss << std::left << std::setw(25) << "-v" << ": Enable verbose message output\n";
+    }
+    if (piD3d) {
+        oss << std::left << std::setw(25) << "-d3d" << ": DirectX version to use (9 or 11)\n";
+    }
+    if (pbForce_zero_latency) {
+        oss << std::left << std::setw(25) << "-force_zero_latency" << ": Enable zero latency for All-Intra/IPPP streams\n";
+    }
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print usage information for common commandline options\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print usage information for common and advanced commandline options\n";
+    oss << std::left << std::setw(25) << "-dc/--decode-caps" << ": Print decode capabilities of GPU\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    if (pbForce_zero_latency) {
+        oss << "* Do not use -force_zero_latency if the stream contains B-frames\n";
+    }
+    if (piD3d) {
+        oss << "* D3D version 9 is used by default\n";
+    }
+    oss << std::endl;
+    oss << "To view decode capabilities, use -dc/--decode-caps\n";
+
+    std::cout << oss.str();
+    exit(0);
+}
+
+static void ShowHelpAndExit(const char *szBadOption, char *szOutputFileName, bool *pbVerbose, int *piD3d, bool *pbForce_zero_latency)
+{
+    if (szBadOption) 
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+static void ParseCommandLine(int argc, char *argv[], char *szInputFileName,
+    char *szOutputFileName, int &iGpu, bool *pbVerbose = NULL, int *piD3d = NULL,
+    bool *pbForce_zero_latency = NULL)
+{
+    std::ostringstream oss;
+    if (argc == 1) {
+        std::cout << "No Arguments provided! Please refer to the following for options:" << "\"\n";
+        ShowBriefHelp(szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+    }
+    int i;
+    for (i = 1; i < argc; i++) {
+        if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+            ShowBriefHelp(szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+        }
+        if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+            ShowDetailedHelp(szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+        }
+        if (!_stricmp(argv[i], "-dc") || !_stricmp(argv[i], "--decode-caps")) {
+            ShowDecoderCapability();
+        }
+        if (!_stricmp(argv[i], "-i")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-i", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            sprintf(szInputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-o")) {
+            if (++i == argc || !szOutputFileName) {
+                ShowHelpAndExit("-o", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            sprintf(szOutputFileName, "%s", argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-gpu")) {
+            if (++i == argc) {
+                ShowHelpAndExit("-gpu", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            iGpu = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-v")) {
+            if (!pbVerbose) {
+                ShowHelpAndExit("-v", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            *pbVerbose = true;
+            continue;
+        }
+        if (!_stricmp(argv[i], "-d3d")) {
+            if (++i == argc || !piD3d) {
+                ShowHelpAndExit("-d3d", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            *piD3d = atoi(argv[i]);
+            continue;
+        }
+        if (!_stricmp(argv[i], "-force_zero_latency")) {
+            if (!pbForce_zero_latency) {
+                ShowHelpAndExit("-force_zero_latency", szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+            }
+            *pbForce_zero_latency = true;
+            continue;
+        }
+        ShowHelpAndExit(argv[i], szOutputFileName, pbVerbose, piD3d, pbForce_zero_latency);
+    }
+}
+
+/**
+*   @brief  Function to generate space-separated list of supported video surface formats
+*   @param  nOutputFormatMask - Bit mask to represent supported cudaVideoSurfaceFormat in decoder
+*   @param  OutputFormats     - Variable into which output string is written
+*/
+static void getOutputFormatNames(unsigned short nOutputFormatMask, char *OutputFormats)
+{
+    if (nOutputFormatMask == 0) {
+        strcpy(OutputFormats, "N/A");
+        return;
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_NV12)) {
+        strcat(OutputFormats, "NV12 ");
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_P016)) {
+        strcat(OutputFormats, "P016 ");
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_YUV444)) {
+        strcat(OutputFormats, "YUV444 ");
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_YUV444_16Bit)) {
+        strcat(OutputFormats, "YUV444P16 ");
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_NV16)) {
+        strcat(OutputFormats, "NV16 ");
+    }
+
+    if (nOutputFormatMask & (1U << cudaVideoSurfaceFormat_P216)) {
+        strcat(OutputFormats, "P216 ");
+    }
+    return;
+}
+
+/**
+*   @brief  Utility function to create CUDA context
+*   @param  cuContext - Pointer to CUcontext. Updated by this function.
+*   @param  iGpu      - Device number to get handle for
+*/
+static void createCudaContext(CUcontext* cuContext, int iGpu, unsigned int flags)
+{
+    CUdevice cuDevice = 0;
+    ck(cuDeviceGet(&cuDevice, iGpu));
+    char szDeviceName[80];
+    ck(cuDeviceGetName(szDeviceName, sizeof(szDeviceName), cuDevice));
+    std::cout << "GPU in use: " << szDeviceName << std::endl;
+    ck(NVCODEC_CUDA_CTX_CREATE(cuContext, flags, cuDevice));
+}
+
+/**
+*   @brief  Print decoder capabilities on std::cout
+*/
+static void ShowDecoderCapability()
+{
+    ck(cuInit(0));
+    int nGpu = 0;
+    ck(cuDeviceGetCount(&nGpu));
+    std::cout << "Decoder Capability" << std::endl << std::endl;
+    
+    struct caps {
+        const char *aszCodecName;
+        cudaVideoCodec aeCodec;
+        cudaVideoChromaFormat aeChromaFormat;
+        int anBitDepthMinus8;
+    };
+    
+    caps queryList[] = {
+        {"JPEG",     cudaVideoCodec_JPEG,     cudaVideoChromaFormat_420,          0},
+        {"MPEG1",    cudaVideoCodec_MPEG1,    cudaVideoChromaFormat_420,          0},
+        {"MPEG2",    cudaVideoCodec_MPEG2,    cudaVideoChromaFormat_420,          0},
+        {"MPEG4",    cudaVideoCodec_MPEG4,    cudaVideoChromaFormat_420,          0},
+        {"H264",     cudaVideoCodec_H264,     cudaVideoChromaFormat_420,          0},
+        {"H264",     cudaVideoCodec_H264,     cudaVideoChromaFormat_420,          2},
+        {"H264",     cudaVideoCodec_H264,     cudaVideoChromaFormat_422,          0},
+        {"H264",     cudaVideoCodec_H264,     cudaVideoChromaFormat_422,          2},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_420,          0},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_420,          2},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_420,          4},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_422,          0},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_422,          2},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_422,          4},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_444,          0},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_444,          2},
+        {"HEVC",     cudaVideoCodec_HEVC,     cudaVideoChromaFormat_444,          4},
+        {"VC1",      cudaVideoCodec_VC1,      cudaVideoChromaFormat_420,          0},
+        {"VP8",      cudaVideoCodec_VP8,      cudaVideoChromaFormat_420,          0},
+        {"VP9",      cudaVideoCodec_VP9,      cudaVideoChromaFormat_420,          0},
+        {"VP9",      cudaVideoCodec_VP9,      cudaVideoChromaFormat_420,          2},
+        {"VP9",      cudaVideoCodec_VP9,      cudaVideoChromaFormat_420,          4},
+        {"AV1",      cudaVideoCodec_AV1,      cudaVideoChromaFormat_420,          0},
+        {"AV1",      cudaVideoCodec_AV1,      cudaVideoChromaFormat_420,          2},
+        {"AV1",      cudaVideoCodec_AV1,      cudaVideoChromaFormat_Monochrome,   0},
+        {"AV1",      cudaVideoCodec_AV1,      cudaVideoChromaFormat_Monochrome,   2},
+    };
+
+    const char *aszChromaFormat[] = { "4:0:0", "4:2:0", "4:2:2", "4:4:4" };
+    char strOutputFormats[64];
+
+    for (int iGpu = 0; iGpu < nGpu; iGpu++) {
+
+        CUcontext cuContext = NULL;
+        createCudaContext(&cuContext, iGpu, 0);
+
+        for (int i = 0; i < sizeof(queryList) / sizeof(queryList[0]); i++) {
+
+            CUVIDDECODECAPS decodeCaps = {};
+            decodeCaps.eCodecType = queryList[i].aeCodec;
+            decodeCaps.eChromaFormat = queryList[i].aeChromaFormat;
+            decodeCaps.nBitDepthMinus8 = queryList[i].anBitDepthMinus8;
+
+            cuvidGetDecoderCaps(&decodeCaps);
+
+            strOutputFormats[0] = '\0';
+            getOutputFormatNames(decodeCaps.nOutputFormatMask, strOutputFormats);
+
+            // setw() width = maximum_width_of_string + 2 spaces
+            std::cout << "Codec  " << std::left << std::setw(7) << queryList[i].aszCodecName <<
+                "BitDepth  " << std::setw(4) << decodeCaps.nBitDepthMinus8 + 8 <<
+                "ChromaFormat  " << std::setw(7) << aszChromaFormat[decodeCaps.eChromaFormat] <<
+                "Supported  " << std::setw(3) << (int)decodeCaps.bIsSupported <<
+                "MaxWidth  " << std::setw(7) << decodeCaps.nMaxWidth <<
+                "MaxHeight  " << std::setw(7) << decodeCaps.nMaxHeight <<
+                "MaxMBCount  " << std::setw(10) << decodeCaps.nMaxMBCount <<
+                "MinWidth  " << std::setw(5) << decodeCaps.nMinWidth <<
+                "MinHeight  " << std::setw(5) << decodeCaps.nMinHeight <<
+                "SurfaceFormat  " << std::setw(11) << strOutputFormats << std::endl;
+        }
+
+        std::cout << std::endl;
+
+        ck(cuCtxDestroy(cuContext));
+    }
+    exit(0);
+}

video_codec_sdk/Samples/AppEncode/AppEncCuda/AppEncCuda.cpp

@@ -0,0 +1,727 @@
+/*
+* Copyright 2017-2024 NVIDIA Corporation.  All rights reserved.
+*
+* Please refer to the NVIDIA end user license agreement (EULA) associated
+* with this source code for terms and conditions that govern your use of
+* this software. Any use, reproduction, disclosure, or distribution of
+* this software and related documentation outside the terms of the EULA
+* is strictly prohibited.
+*
+*/
+
+/**
+*  This sample application illustrates encoding of frames in CUDA device buffers.
+*  The application reads the image data from file and loads it to CUDA input
+*  buffers obtained from the encoder using NvEncoder::GetNextInputFrame().
+*  The encoder subsequently maps the CUDA buffers for encoder using NvEncodeAPI
+*  and submits them to NVENC hardware for encoding as part of EncodeFrame() function.
+*  The NVENC hardware output is written in system memory for this case.
+*
+*  This sample application also illustrates the use of video memory buffer allocated
+*  by the application to get the NVENC hardware output. This feature can be used
+*  for H264 ME-only mode, H264 encode and HEVC encode. This application copies the NVENC output
+*  from video memory buffer to host memory buffer in order to dump to a file, but this
+*  is not needed if application choose to use it in some other way.
+*
+*  Since, encoding may involve CUDA pre-processing on the input and post-processing on
+*  output, use of CUDA streams is also illustrated to pipeline the CUDA pre-processing
+*  and post-processing tasks, for output in video memory case.
+*
+*  CUDA streams can be used for H.264 ME-only, HEVC ME-only, H264 encode, HEVC encode and AV1 encode.
+*/
+
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <cuda.h>
+#include "../Utils/NvCodecUtils.h"
+#include "NvEncoder/NvEncoderCuda.h"
+#include "NvEncoder/NvEncoderOutputInVidMemCuda.h"
+#include "../Utils/Logger.h"
+#include "../Utils/NvEncoderCLIOptions.h"
+#include "../Common/AppEncUtils.h"
+
+simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger();
+
+// This class allocates CUStream.
+// It also sets the input and output CUDA stream in the driver, which will be used for pipelining
+// pre and post processing CUDA tasks
+class NvCUStream
+{
+public:
+	NvCUStream(CUcontext cuDevice, int cuStreamType, std::unique_ptr<NvEncoderOutputInVidMemCuda> &pEnc)
+	{
+		device = cuDevice;
+		CUDA_DRVAPI_CALL(cuCtxPushCurrent(device));
+
+		// Create CUDA streams
+		if (cuStreamType == 1)
+		{
+			ck(cuStreamCreate(&inputStream, CU_STREAM_DEFAULT));
+			outputStream = inputStream;
+		}
+		else if (cuStreamType == 2)
+		{
+			ck(cuStreamCreate(&inputStream, CU_STREAM_DEFAULT));
+			ck(cuStreamCreate(&outputStream, CU_STREAM_DEFAULT));
+		}
+
+		CUDA_DRVAPI_CALL(cuCtxPopCurrent(NULL));
+
+		// Set input and output CUDA streams in driver
+		pEnc->SetIOCudaStreams((NV_ENC_CUSTREAM_PTR)&inputStream, (NV_ENC_CUSTREAM_PTR)&outputStream);
+	}
+
+	~NvCUStream()
+	{
+		ck(cuCtxPushCurrent(device));
+
+		if (inputStream == outputStream)
+		{
+			if (inputStream != NULL)
+				ck(cuStreamDestroy(inputStream));
+		}
+		else
+		{
+			if (inputStream != NULL)
+				ck(cuStreamDestroy(inputStream));
+
+			if (outputStream != NULL)
+				ck(cuStreamDestroy(outputStream));
+		}
+
+		ck(cuCtxPopCurrent(NULL));
+	}
+
+	CUstream GetOutputCUStream() { return outputStream; };
+	CUstream GetInputCUStream() { return inputStream; };
+
+private:
+	CUcontext device;
+	CUstream inputStream = NULL, outputStream = NULL;
+};
+
+// This class computes CRC of encode frame using CUDA kernel
+class CRC
+{
+public:
+	CRC(CUcontext cuDevice, uint32_t bufferSize)
+	{
+		device = cuDevice;
+
+		ck(cuCtxPushCurrent(device));
+
+		// Allocate video memory buffer to store CRC of encoded frame
+		ck(cuMemAlloc(&crcVidMem, bufferSize));
+
+		ck(cuCtxPopCurrent(NULL));
+	}
+
+	~CRC()
+	{
+		ck(cuCtxPushCurrent(device));
+
+		ck(cuMemFree(crcVidMem));
+
+		ck(cuCtxPopCurrent(NULL));
+	}
+
+	void GetCRC(NV_ENC_OUTPUT_PTR pVideoMemBfr, CUstream outputStream)
+	{
+		ComputeCRC((uint8_t *)pVideoMemBfr, (uint32_t *)crcVidMem, outputStream);
+	}
+
+	CUdeviceptr GetCRCVidMemPtr() { return crcVidMem; };
+
+private:
+	CUcontext device;
+	CUdeviceptr crcVidMem = 0;
+};
+
+// This class dumps the output - CRC and encoded stream, to a file.
+// Output is first copied to host buffer and then dumped to a file.
+class DumpVidMemOutput
+{
+public:
+	DumpVidMemOutput(CUcontext cuDevice, uint32_t size, char *outFilePath, bool bUseCUStream)
+	{
+		device = cuDevice;
+		bfrSize = size;
+		bCRC = bUseCUStream;
+
+		ck(cuCtxPushCurrent(device));
+
+		// Allocate host memory buffer to copy encoded output and CRC
+		ck(cuMemAllocHost((void **)&pHostMemEncOp, (bfrSize + (bCRC ? 4 : 0))));
+
+		ck(cuCtxPopCurrent(NULL));
+
+		// Open file to dump CRC
+		if (bCRC)
+		{
+			crcFile = std::string(outFilePath) + "_crc.txt";
+			fpCRCOut.open(crcFile, std::ios::out);
+			pHostMemCRC = (uint32_t *)((uint8_t *)pHostMemEncOp + bfrSize);
+		}
+	}
+
+	~DumpVidMemOutput()
+	{
+		ck(cuCtxPushCurrent(device));
+
+		ck(cuMemFreeHost(pHostMemEncOp));
+
+		ck(cuCtxPopCurrent(NULL));
+
+		if (bCRC)
+		{
+			fpCRCOut.close();
+			std::cout << "CRC saved in file: " << crcFile << std::endl;
+		}
+	}
+
+	void DumpOutputToFile(CUdeviceptr pEncFrameBfr, CUdeviceptr pCRCBfr, std::ofstream &fpOut, uint32_t nFrame, bool &bWriteIVFFileHeader, NV_ENC_INITIALIZE_PARAMS &pInitializeParams)
+	{
+		ck(cuCtxPushCurrent(device));
+
+		// Copy encoded frame from video memory buffer to host memory buffer
+		ck(cuMemcpyDtoH(pHostMemEncOp, pEncFrameBfr, bfrSize));
+
+		// Copy encoded frame CRC from video memory buffer to host memory buffer
+		if (bCRC)
+		{
+			ck(cuMemcpyDtoH(pHostMemCRC, pCRCBfr, 4));
+		}
+
+		ck(cuCtxPopCurrent(NULL));
+
+		// Write encoded bitstream in file
+		uint32_t offset = sizeof(NV_ENC_ENCODE_OUT_PARAMS);
+		uint32_t bitstream_size = ((NV_ENC_ENCODE_OUT_PARAMS *)pHostMemEncOp)->bitstreamSizeInBytes;
+		uint8_t * ptr = pHostMemEncOp + offset;
+
+		IVFUtils iVFUtils;
+		int64_t pts = 0;
+		std::vector<uint8_t> vPacket;
+		if (pInitializeParams.encodeGUID == NV_ENC_CODEC_AV1_GUID)
+		{
+			if (bWriteIVFFileHeader)
+			{
+				iVFUtils.WriteFileHeader(vPacket, MAKE_FOURCC('A', 'V', '0', '1'), pInitializeParams.encodeWidth, pInitializeParams.encodeHeight, pInitializeParams.frameRateNum, pInitializeParams.frameRateDen, 0xFFFF);
+				fpOut.write(reinterpret_cast<char*>(vPacket.data()), vPacket.size());
+				bWriteIVFFileHeader = false;
+				vPacket.clear();
+			}
+			iVFUtils.WriteFrameHeader(vPacket, bitstream_size, pts);
+			fpOut.write(reinterpret_cast<char*>(vPacket.data()), vPacket.size());
+		}
+
+		fpOut.write((const char *)ptr, bitstream_size);
+
+		// Write CRC in file
+		if (bCRC)
+		{
+			if (!nFrame)
+			{
+				fpCRCOut << "Frame num" << std::setw(10) << "CRC" << std::endl;
+			}
+			fpCRCOut << std::dec << std::setfill(' ') << std::setw(5) << nFrame << "          ";
+			fpCRCOut << std::hex << std::setfill('0') << std::setw(8) << *pHostMemCRC << std::endl;
+		}
+	}
+private:
+	CUcontext device;
+	uint32_t bfrSize;
+	uint8_t *pHostMemEncOp = NULL;
+	uint32_t *pHostMemCRC = NULL;
+	bool bCRC;
+	std::string crcFile;
+	std::ofstream fpCRCOut;
+};
+
+void ShowEncoderBriefHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Encoder AppEncCuda Sample Application\n";
+    oss << "============================================\n\n";
+
+    oss << "Usage: AppEncCuda -i <input_file> [options]\n\n";
+
+    // Brief table of core arguments
+    oss << "Common Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument"
+        << std::setw(12) << "Type"
+        << "Default Value\n";
+    oss << std::string(50, '-') << "\n";
+
+    oss << std::left << std::setw(25) << "-i <path>"
+        << std::setw(12) << "Required"
+        << "N/A\n";
+    oss << std::left << std::setw(25) << "-o <path>"
+        << std::setw(12) << "Optional"
+        << "codec-based (out.h264/hevc/av1)\n";
+    oss << std::left << std::setw(25) << "-s <WxH>"
+        << std::setw(12) << "Required"
+        << "N/A\n";
+    oss << std::left << std::setw(25) << "-if <format>"
+        << std::setw(12) << "Optional"
+        << "iyuv\n";
+    oss << std::left << std::setw(25) << "-gpu <n>"
+        << std::setw(12) << "Optional"
+        << "0\n";
+
+    oss << "\nFor detailed help, use -A/--advanced-options\n";
+    oss << "To view encoder capabilities, use -ec/--encode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+void ShowEncoderDetailedHelp()
+{
+    std::ostringstream oss;
+    oss << "NVIDIA Video Encoder AppEncCuda Sample Application - Detailed Help\n";
+    oss << "=======================================================\n\n";
+
+    oss << "Usage: AppEncCuda -i <input_file> [options]\n\n";
+
+    // Full table of all arguments
+    oss << "All Arguments:\n";
+    oss << std::left << std::setw(25) << "Argument"
+        << std::setw(12) << "Type"
+        << std::setw(20) << "Default Value"
+        << "Example\n";
+    oss << std::string(80, '-') << "\n";
+
+    // Required arguments
+    oss << std::left << std::setw(25) << "-i <path>"
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-i input.yuv\n";
+    oss << std::left << std::setw(25) << "-s <WxH>"
+        << std::setw(12) << "Required"
+        << std::setw(20) << "N/A"
+        << "-s 1920x1080\n";
+
+    // Optional arguments
+    oss << std::left << std::setw(25) << "-o <path>"
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "codec-based"
+        << "-o output.h264\n";
+    oss << std::left << std::setw(25) << "-if <format>"
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "iyuv"
+        << "-if yuv444\n";
+    oss << std::left << std::setw(25) << "-gpu <n>"
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-gpu 1\n";
+    oss << std::left << std::setw(25) << "-outputInVidMem <n>"
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "0"
+        << "-outputInVidMem 1\n";
+    oss << std::left << std::setw(25) << "-cuStreamType <n>"
+        << std::setw(12) << "Optional"
+        << std::setw(20) << "disabled"
+        << "-cuStreamType 1\n";
+
+    // Detailed descriptions
+    oss << "\nDetailed Descriptions:\n";
+    oss << "-------------------\n";
+    oss << std::left << std::setw(25) << "-i" << ": Input file path\n";
+    oss << std::left << std::setw(25) << "-o" << ": Output file path\n";
+    oss << std::left << std::setw(25) << "-s" << ": Input resolution in WxH format\n";
+    oss << std::left << std::setw(25) << "-if" << ": Input format (iyuv/nv12/nv16/yuv444/p010/p210/yuv444p16/bgra/bgra10/ayuv/abgr/abgr10)\n";
+    oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n";
+    oss << std::left << std::setw(25) << "-outputInVidMem" << ": Enable output in Video Memory (0/1)\n";
+    oss << std::left << std::setw(25) << "-cuStreamType" << ": CUDA stream type for pre/post processing (0: NULL, 1: SAME, 2: DIFFERENT)\n";
+    oss << std::left << std::setw(25) << "-h/--help" << ": Print basic usage information\n";
+    oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print detailed usage information\n";
+    oss << std::left << std::setw(25) << "-ec/--encode-caps" << ": Print encode capabilities of GPU\n";
+
+    // Important notes
+    oss << "\nNotes:\n";
+    oss << "------\n";
+    oss << "* When outputInVidMem is enabled, CRC of encoded frames will be computed\n";
+    oss << "  and dumped to file with suffix '_crc.txt' added to output file\n";
+    oss << "* Width and height must be specified for encoding\n";
+    oss << std::endl;
+
+    oss << NvEncoderInitParam().GetHelpMessage(false, false, false, false, true, false, false, false) << std::endl;
+    oss << "\nTo view encode capabilities, use -ec/--encode-caps\n";
+    std::cout << oss.str();
+    exit(0);
+}
+
+void ShowHelpAndExit(const char *szBadOption = NULL)
+{
+    if (szBadOption)
+    {
+        std::ostringstream oss;
+        oss << "Error parsing \"" << szBadOption << "\"\n";
+        oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n";
+        throw std::invalid_argument(oss.str());
+    }
+}
+
+void ParseCommandLine(int argc, char *argv[], char *szInputFileName, int &nWidth, int &nHeight,
+	NV_ENC_BUFFER_FORMAT &eFormat, char *szOutputFileName, NvEncoderInitParam &initParam, int &iGpu,
+	bool &bOutputInVidMem, int32_t &cuStreamType)
+{
+	std::ostringstream oss;
+	int i;
+
+	if (argc == 1) {
+		std::cout << "No Arguments provided! Please refer to the following for options:\n";
+		ShowEncoderBriefHelp();
+	}
+
+	for (i = 1; i < argc; i++)
+	{
+		if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) {
+			ShowEncoderBriefHelp();
+		}
+		if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) {
+			ShowEncoderDetailedHelp();
+		}
+		if (!_stricmp(argv[i], "-ec") || !_stricmp(argv[i], "--encode-caps")) {
+			ShowEncoderCapability();
+		}
+		if (!_stricmp(argv[i], "-i"))
+		{
+			if (++i == argc)
+			{
+				ShowHelpAndExit("-i");
+			}
+			sprintf(szInputFileName, "%s", argv[i]);
+			continue;
+		}
+		if (!_stricmp(argv[i], "-o"))
+		{
+			if (++i == argc)
+			{
+				ShowHelpAndExit("-o");
+			}
+			sprintf(szOutputFileName, "%s", argv[i]);
+			continue;
+		}
+		if (!_stricmp(argv[i], "-s"))
+		{
+			if (++i == argc || 2 != sscanf(argv[i], "%dx%d", &nWidth, &nHeight))
+			{
+				ShowHelpAndExit("-s");
+			}
+			continue;
+		}
+		std::vector<std::string> vszFileFormatName =
+		{
+			"iyuv", "nv12", "yv12", "nv16", "yuv444", "p010", "p210", "yuv444p16", "bgra", "bgra10", "ayuv", "abgr", "abgr10"
+		};
+		NV_ENC_BUFFER_FORMAT aFormat[] =
+		{
+			NV_ENC_BUFFER_FORMAT_IYUV,
+			NV_ENC_BUFFER_FORMAT_NV12,
+			NV_ENC_BUFFER_FORMAT_YV12,
+			NV_ENC_BUFFER_FORMAT_NV16,
+			NV_ENC_BUFFER_FORMAT_YUV444,
+			NV_ENC_BUFFER_FORMAT_YUV420_10BIT,
+			NV_ENC_BUFFER_FORMAT_P210,
+			NV_ENC_BUFFER_FORMAT_YUV444_10BIT,
+			NV_ENC_BUFFER_FORMAT_ARGB,
+			NV_ENC_BUFFER_FORMAT_ARGB10,
+			NV_ENC_BUFFER_FORMAT_AYUV,
+			NV_ENC_BUFFER_FORMAT_ABGR,
+			NV_ENC_BUFFER_FORMAT_ABGR10,
+		};
+		if (!_stricmp(argv[i], "-if"))
+		{
+			if (++i == argc) {
+				ShowHelpAndExit("-if");
+			}
+			auto it = std::find(vszFileFormatName.begin(), vszFileFormatName.end(), argv[i]);
+			if (it == vszFileFormatName.end())
+			{
+				ShowHelpAndExit("-if");
+			}
+			eFormat = aFormat[it - vszFileFormatName.begin()];
+			continue;
+		}
+		if (!_stricmp(argv[i], "-gpu"))
+		{
+			if (++i == argc)
+			{
+				ShowHelpAndExit("-gpu");
+			}
+			iGpu = atoi(argv[i]);
+			continue;
+		}
+		if (!_stricmp(argv[i], "-outputInVidMem"))
+		{
+			if (++i == argc)
+			{
+				ShowHelpAndExit("-outputInVidMem");
+			}
+			bOutputInVidMem = (atoi(argv[i]) != 0) ? true : false;
+			continue;
+		}
+		if (!_stricmp(argv[i], "-cuStreamType"))
+		{
+			if (++i == argc)
+			{
+				ShowHelpAndExit("-cuStreamType");
+			}
+			cuStreamType = atoi(argv[i]);
+			continue;
+		}
+
+		// Regard as encoder parameter
+		if (argv[i][0] != '-')
+		{
+			ShowHelpAndExit(argv[i]);
+		}
+		oss << argv[i] << " ";
+		while (i + 1 < argc && argv[i + 1][0] != '-')
+		{
+			oss << argv[++i] << " ";
+		}
+	}
+	initParam = NvEncoderInitParam(oss.str().c_str());
+}
+
+template<class EncoderClass>
+void InitializeEncoder(EncoderClass &pEnc, NvEncoderInitParam encodeCLIOptions, NV_ENC_BUFFER_FORMAT eFormat)
+{
+	NV_ENC_INITIALIZE_PARAMS initializeParams = { NV_ENC_INITIALIZE_PARAMS_VER };
+	NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER };
+
+	initializeParams.encodeConfig = &encodeConfig;
+	pEnc->CreateDefaultEncoderParams(&initializeParams, encodeCLIOptions.GetEncodeGUID(), encodeCLIOptions.GetPresetGUID(), encodeCLIOptions.GetTuningInfo());
+	encodeCLIOptions.SetInitParams(&initializeParams, eFormat);
+
+	pEnc->CreateEncoder(&initializeParams);
+}
+
+void EncodeCuda(int nWidth, int nHeight, NV_ENC_BUFFER_FORMAT eFormat, NvEncoderInitParam encodeCLIOptions, CUcontext cuContext, std::ifstream &fpIn, std::ofstream &fpOut)
+{
+	std::unique_ptr<NvEncoderCuda> pEnc(new NvEncoderCuda(cuContext, nWidth, nHeight, eFormat));
+
+	InitializeEncoder(pEnc, encodeCLIOptions, eFormat);
+
+	int nFrameSize = pEnc->GetFrameSize();
+
+    uint32_t enableMVHEVC = pEnc->IsMVHEVC();
+    int nTotalFrameSize = nFrameSize;
+    if (enableMVHEVC)
+    {
+        nTotalFrameSize = nTotalFrameSize << 1;
+    }
+    int viewID = 0;
+    std::streamsize nRead = 0;
+
+    std::unique_ptr<uint8_t[]> pHostFrame(new uint8_t[nTotalFrameSize]);
+    int nFrame = 0;
+    while (true)
+    {
+        if (viewID == 0)
+        {
+            // Load the next frame or two frames from disk depending upon enableMVHEVC
+            nRead = fpIn.read(reinterpret_cast<char*>(pHostFrame.get()), nTotalFrameSize).gcount();
+        }
+        // For receiving encoded packets
+        std::vector<NvEncOutputFrame> vPacket;
+        if (nRead == nTotalFrameSize)
+        {
+            const NvEncInputFrame* encoderInputFrame = pEnc->GetNextInputFrame();
+            NvEncoderCuda::CopyToDeviceFrame(cuContext,
+                pHostFrame.get() + viewID * nFrameSize, 0,
+                (CUdeviceptr)encoderInputFrame->inputPtr,
+                (int)encoderInputFrame->pitch,
+                pEnc->GetEncodeWidth(),
+                pEnc->GetEncodeHeight(),
+                CU_MEMORYTYPE_HOST,
+                encoderInputFrame->bufferFormat,
+                encoderInputFrame->chromaOffsets,
+                encoderInputFrame->numChromaPlanes);
+
+            pEnc->EncodeFrame(vPacket);
+        }
+        else
+        {
+            // If we couldn't read both frames, signal the end of encoding
+            pEnc->EndEncode(vPacket);
+        }
+        nFrame += (int)vPacket.size();
+        for (const NvEncOutputFrame &packet : vPacket)
+        {
+            // For each encoded packet
+            fpOut.write(reinterpret_cast<const char*>(packet.frame.data()), packet.frame.size());
+        }
+
+        if (nRead != nTotalFrameSize) break;
+        if (enableMVHEVC)
+        {
+            viewID = viewID ^ 1;
+        }
+    }
+	pEnc->DestroyEncoder();
+
+	std::cout << "Total frames encoded: " << nFrame << std::endl;
+}
+
+void EncodeCudaOpInVidMem(int nWidth, int nHeight, NV_ENC_BUFFER_FORMAT eFormat, NvEncoderInitParam encodeCLIOptions, CUcontext cuContext, std::ifstream &fpIn, std::ofstream &fpOut, char *outFilePath, int32_t cuStreamType)
+{
+	std::unique_ptr<NvEncoderOutputInVidMemCuda> pEnc(new NvEncoderOutputInVidMemCuda(cuContext, nWidth, nHeight, eFormat));
+
+	InitializeEncoder(pEnc, encodeCLIOptions, eFormat);
+
+	int nFrameSize = pEnc->GetFrameSize();
+	bool bUseCUStream = cuStreamType != -1 ? true : false;
+
+	NV_ENC_INITIALIZE_PARAMS initializeParams = pEnc->GetinitializeParams();
+	bool bWriteIVFFileHeader = true;
+
+	std::unique_ptr<CRC> pCRC;
+	std::unique_ptr<NvCUStream> pCUStream;
+	if (bUseCUStream)
+	{
+		// Allocate CUDA streams
+		pCUStream.reset(new NvCUStream(reinterpret_cast<CUcontext>(pEnc->GetDevice()), cuStreamType, pEnc));
+
+		// When CUDA streams are used, the encoded frame's CRC is computed using cuda kernel
+		pCRC.reset(new CRC(reinterpret_cast<CUcontext>(pEnc->GetDevice()), pEnc->GetOutputBufferSize()));
+	}
+
+	// For dumping output - encoded frame and CRC, to a file
+	std::unique_ptr<DumpVidMemOutput> pDumpVidMemOutput(new DumpVidMemOutput(reinterpret_cast<CUcontext>(pEnc->GetDevice()), pEnc->GetOutputBufferSize(), outFilePath, bUseCUStream));
+
+	std::unique_ptr<uint8_t[]> pHostFrame(new uint8_t[nFrameSize]);
+	int nFrame = 0;
+
+	// Encoding loop
+	while (true)
+	{
+		// Load the next frame from disk
+		std::streamsize nRead = fpIn.read(reinterpret_cast<char*>(pHostFrame.get()), nFrameSize).gcount();
+		// For receiving encoded packets
+		std::vector<NV_ENC_OUTPUT_PTR>pVideoMemBfr;
+
+		if (nRead == nFrameSize)
+		{
+			const NvEncInputFrame* encoderInputFrame = pEnc->GetNextInputFrame();
+			NvEncoderCuda::CopyToDeviceFrame(cuContext, pHostFrame.get(), 0, (CUdeviceptr)encoderInputFrame->inputPtr,
+				(int)encoderInputFrame->pitch,
+				pEnc->GetEncodeWidth(),
+				pEnc->GetEncodeHeight(),
+				CU_MEMORYTYPE_HOST,
+				encoderInputFrame->bufferFormat,
+				encoderInputFrame->chromaOffsets,
+				encoderInputFrame->numChromaPlanes,
+				false,
+				bUseCUStream ? pCUStream->GetInputCUStream() : NULL);
+
+			pEnc->EncodeFrame(pVideoMemBfr);
+		}
+		else
+		{
+			pEnc->EndEncode(pVideoMemBfr);
+		}
+
+		for (uint32_t i = 0; i < pVideoMemBfr.size(); ++i)
+		{
+			if (bUseCUStream)
+			{
+				// Compute CRC of encoded stream
+				pCRC->GetCRC(pVideoMemBfr[i], pCUStream->GetOutputCUStream());
+			}
+
+			pDumpVidMemOutput->DumpOutputToFile((CUdeviceptr)(pVideoMemBfr[i]), bUseCUStream ? pCRC->GetCRCVidMemPtr() : 0, fpOut, nFrame, bWriteIVFFileHeader, initializeParams);
+
+			nFrame++;
+		}
+
+		if (nRead != nFrameSize) break;
+	}
+
+	pEnc->DestroyEncoder();
+
+	std::cout << "Total frames encoded: " << nFrame << std::endl;
+}
+
+int main(int argc, char **argv)
+{
+	char szInFilePath[256] = "",
+		szOutFilePath[256] = "";
+	int nWidth = 0, nHeight = 0;
+	NV_ENC_BUFFER_FORMAT eFormat = NV_ENC_BUFFER_FORMAT_IYUV;
+	int iGpu = 0;
+	try
+	{
+		NvEncoderInitParam encodeCLIOptions;
+		int cuStreamType = -1;
+		bool bOutputInVideoMem = false;
+		ParseCommandLine(argc, argv, szInFilePath, nWidth, nHeight, eFormat, szOutFilePath, encodeCLIOptions, iGpu,
+			bOutputInVideoMem, cuStreamType);
+
+		CheckInputFile(szInFilePath);
+		ValidateResolution(nWidth, nHeight);
+
+		if (!*szOutFilePath)
+		{
+			sprintf(szOutFilePath, encodeCLIOptions.IsCodecH264() ? "out.h264" : encodeCLIOptions.IsCodecHEVC() ? "out.hevc" : "out.av1");
+		}
+
+		ck(cuInit(0));
+		int nGpu = 0;
+		ck(cuDeviceGetCount(&nGpu));
+		if (iGpu < 0 || iGpu >= nGpu)
+		{
+			std::cout << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl;
+			return 1;
+		}
+		CUdevice cuDevice = 0;
+		ck(cuDeviceGet(&cuDevice, iGpu));
+		char szDeviceName[80];
+		ck(cuDeviceGetName(szDeviceName, sizeof(szDeviceName), cuDevice));
+		std::cout << "GPU in use: " << szDeviceName << std::endl;
+		CUcontext cuContext = NULL;
+        ck(NVCODEC_CUDA_CTX_CREATE(&cuContext, 0, cuDevice));
+
+		// Open input file
+		std::ifstream fpIn(szInFilePath, std::ifstream::in | std::ifstream::binary);
+		if (!fpIn)
+		{
+			std::ostringstream err;
+			err << "Unable to open input file: " << szInFilePath << std::endl;
+			throw std::invalid_argument(err.str());
+		}
+
+		// Open output file
+		std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary);
+		if (!fpOut)
+		{
+			std::ostringstream err;
+			err << "Unable to open output file: " << szOutFilePath << std::endl;
+			throw std::invalid_argument(err.str());
+		}
+
+		// Encode
+		if (bOutputInVideoMem)
+		{
+			EncodeCudaOpInVidMem(nWidth, nHeight, eFormat, encodeCLIOptions, cuContext, fpIn, fpOut, szOutFilePath, cuStreamType);
+		}
+		else
+		{
+			EncodeCuda(nWidth, nHeight, eFormat, encodeCLIOptions, cuContext, fpIn, fpOut);
+		}
+
+		fpOut.close();
+		fpIn.close();
+
+		std::cout << "Bitstream saved in file " << szOutFilePath << std::endl;
+	}
+	catch (const std::exception &ex)
+	{
+		std::cout << ex.what();
+		return 1;
+	}
+	return 0;
+}