compat/cuda: convert to unix line endings
authorTimo Rothenpieler <timo@rothenpieler.org>
Fri, 23 Sep 2016 09:43:00 +0000 (11:43 +0200)
committerTimo Rothenpieler <timo@rothenpieler.org>
Fri, 23 Sep 2016 09:43:00 +0000 (11:43 +0200)
compat/cuda/cuviddec.h
compat/cuda/nvcuvid.h

index a66826f..f9257ea 100644 (file)
-/*\r
- * This copyright notice applies to this header file only:\r
- *\r
- * Copyright (c) 2010-2016 NVIDIA Corporation\r
- *\r
- * Permission is hereby granted, free of charge, to any person\r
- * obtaining a copy of this software and associated documentation\r
- * files (the "Software"), to deal in the Software without\r
- * restriction, including without limitation the rights to use,\r
- * copy, modify, merge, publish, distribute, sublicense, and/or sell\r
- * copies of the software, and to permit persons to whom the\r
- * software is furnished to do so, subject to the following\r
- * conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be\r
- * included in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\r
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\r
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\r
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\r
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\r
- * OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-/**\r
- * \file cuviddec.h\r
- * NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.\r
- * \date 2015-2016\r
- * This file contains constants, structure definitions and function prototypes used for decoding.\r
- */\r
-\r
-#if !defined(__CUDA_VIDEO_H__)\r
-#define __CUDA_VIDEO_H__\r
-\r
-#ifndef __cuda_cuda_h__\r
-#include <cuda.h>\r
-#endif // __cuda_cuda_h__\r
-\r
-#if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)\r
-#if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))\r
-#define __CUVID_DEVPTR64\r
-#endif\r
-#endif\r
-\r
-#if defined(__cplusplus)\r
-extern "C" {\r
-#endif /* __cplusplus */\r
-\r
-typedef void *CUvideodecoder;\r
-typedef struct _CUcontextlock_st *CUvideoctxlock;\r
-\r
-/**\r
- * \addtogroup VIDEO_DECODER Video Decoder\r
- * @{\r
- */\r
-\r
-/*!\r
- * \enum cudaVideoCodec\r
- * Video Codec Enums\r
- */\r
-typedef enum cudaVideoCodec_enum {\r
-    cudaVideoCodec_MPEG1=0,                 /**<  MPEG1   */\r
-    cudaVideoCodec_MPEG2,                   /**<  MPEG2  */\r
-    cudaVideoCodec_MPEG4,                   /**<  MPEG4   */\r
-    cudaVideoCodec_VC1,                     /**<  VC1   */\r
-    cudaVideoCodec_H264,                    /**<  H264   */\r
-    cudaVideoCodec_JPEG,                    /**<  JPEG   */\r
-    cudaVideoCodec_H264_SVC,                /**<  H264-SVC   */\r
-    cudaVideoCodec_H264_MVC,                /**<  H264-MVC   */\r
-    cudaVideoCodec_HEVC,                    /**<  HEVC   */\r
-    cudaVideoCodec_VP8,                     /**<  VP8   */\r
-    cudaVideoCodec_VP9,                     /**<  VP9   */\r
-    cudaVideoCodec_NumCodecs,               /**<  Max COdecs   */\r
-    // Uncompressed YUV\r
-    cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)  */\r
-    cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)  */\r
-    cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)  */\r
-    cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */\r
-    cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)  */\r
-} cudaVideoCodec;\r
-\r
-/*!\r
- * \enum cudaVideoSurfaceFormat\r
- * Video Surface Formats Enums\r
- */\r
-typedef enum cudaVideoSurfaceFormat_enum {\r
-    cudaVideoSurfaceFormat_NV12=0       /**< NV12 (currently the only supported output format)  */\r
-} cudaVideoSurfaceFormat;\r
-\r
-/*!\r
- * \enum cudaVideoDeinterlaceMode\r
- * Deinterlacing Modes Enums\r
- */\r
-typedef enum cudaVideoDeinterlaceMode_enum {\r
-    cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */\r
-    cudaVideoDeinterlaceMode_Bob,       /**< Drop one field  */\r
-    cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing  */\r
-} cudaVideoDeinterlaceMode;\r
-\r
-/*!\r
- * \enum cudaVideoChromaFormat\r
- * Chroma Formats Enums\r
- */\r
-typedef enum cudaVideoChromaFormat_enum {\r
-    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */\r
-    cudaVideoChromaFormat_420,           /**< 4:2:0 */\r
-    cudaVideoChromaFormat_422,           /**< 4:2:2 */\r
-    cudaVideoChromaFormat_444            /**< 4:4:4 */\r
-} cudaVideoChromaFormat;\r
-\r
-/*!\r
- * \enum cudaVideoCreateFlags\r
- * Decoder Flags Enums\r
- */\r
-typedef enum cudaVideoCreateFlags_enum {\r
-    cudaVideoCreate_Default = 0x00,     /**< Default operation mode: use dedicated video engines */\r
-    cudaVideoCreate_PreferCUDA = 0x01,  /**< Use a CUDA-based decoder if faster than dedicated engines (requires a valid vidLock object for multi-threading) */\r
-    cudaVideoCreate_PreferDXVA = 0x02,  /**< Go through DXVA internally if possible (requires D3D9 interop) */\r
-    cudaVideoCreate_PreferCUVID = 0x04  /**< Use dedicated video engines directly */\r
-} cudaVideoCreateFlags;\r
-\r
-/*!\r
- * \struct CUVIDDECODECREATEINFO\r
- * Struct used in create decoder\r
- */\r
-typedef struct _CUVIDDECODECREATEINFO\r
-{\r
-    unsigned long ulWidth;              /**< Coded Sequence Width */\r
-    unsigned long ulHeight;             /**< Coded Sequence Height */\r
-    unsigned long ulNumDecodeSurfaces;  /**< Maximum number of internal decode surfaces */\r
-    cudaVideoCodec CodecType;           /**< cudaVideoCodec_XXX */\r
-    cudaVideoChromaFormat ChromaFormat; /**< cudaVideoChromaFormat_XXX (only 4:2:0 is currently supported) */\r
-    unsigned long ulCreationFlags;      /**< Decoder creation flags (cudaVideoCreateFlags_XXX) */\r
-    unsigned long bitDepthMinus8;\r
-    unsigned long Reserved1[4];         /**< Reserved for future use - set to zero */\r
-    /**\r
-    * area of the frame that should be displayed\r
-    */\r
-    struct {\r
-        short left;\r
-        short top;\r
-        short right;\r
-        short bottom;\r
-    } display_area;\r
-\r
-    cudaVideoSurfaceFormat OutputFormat;       /**< cudaVideoSurfaceFormat_XXX */\r
-    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< cudaVideoDeinterlaceMode_XXX */\r
-    unsigned long ulTargetWidth;               /**< Post-processed Output Width (Should be aligned to 2) */\r
-    unsigned long ulTargetHeight;              /**< Post-processed Output Height (Should be aligbed to 2) */\r
-    unsigned long ulNumOutputSurfaces;         /**< Maximum number of output surfaces simultaneously mapped */\r
-    CUvideoctxlock vidLock;                    /**< If non-NULL, context lock used for synchronizing ownership of the cuda context */\r
-    /**\r
-    * target rectangle in the output frame (for aspect ratio conversion)\r
-    * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used\r
-    */\r
-    struct {\r
-        short left;\r
-        short top;\r
-        short right;\r
-        short bottom;\r
-    } target_rect;\r
-    unsigned long Reserved2[5];                /**< Reserved for future use - set to zero */\r
-} CUVIDDECODECREATEINFO;\r
-\r
-/*!\r
- * \struct CUVIDH264DPBENTRY\r
- * H.264 DPB Entry\r
- */\r
-typedef struct _CUVIDH264DPBENTRY\r
-{\r
-    int PicIdx;                 /**< picture index of reference frame */\r
-    int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term) */\r
-    int is_long_term;           /**< 0=short term reference, 1=long term reference */\r
-    int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */\r
-    int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields */\r
-    int FieldOrderCnt[2];       /**< field order count of top and bottom fields */\r
-} CUVIDH264DPBENTRY;\r
-\r
-/*!\r
- * \struct CUVIDH264MVCEXT\r
- * H.264 MVC Picture Parameters Ext\r
- */\r
-typedef struct _CUVIDH264MVCEXT\r
-{\r
-    int num_views_minus1;\r
-    int view_id;\r
-    unsigned char inter_view_flag;\r
-    unsigned char num_inter_view_refs_l0;\r
-    unsigned char num_inter_view_refs_l1;\r
-    unsigned char MVCReserved8Bits;\r
-    int InterViewRefsL0[16];\r
-    int InterViewRefsL1[16];\r
-} CUVIDH264MVCEXT;\r
-\r
-/*!\r
- * \struct CUVIDH264SVCEXT\r
- * H.264 SVC Picture Parameters Ext\r
- */\r
-typedef struct _CUVIDH264SVCEXT\r
-{\r
-    unsigned char profile_idc;\r
-    unsigned char level_idc;\r
-    unsigned char DQId;\r
-    unsigned char DQIdMax;\r
-    unsigned char disable_inter_layer_deblocking_filter_idc;\r
-    unsigned char ref_layer_chroma_phase_y_plus1;\r
-    signed char   inter_layer_slice_alpha_c0_offset_div2;\r
-    signed char   inter_layer_slice_beta_offset_div2;\r
-\r
-    unsigned short DPBEntryValidFlag;\r
-    unsigned char inter_layer_deblocking_filter_control_present_flag;\r
-    unsigned char extended_spatial_scalability_idc;\r
-    unsigned char adaptive_tcoeff_level_prediction_flag;\r
-    unsigned char slice_header_restriction_flag;\r
-    unsigned char chroma_phase_x_plus1_flag;\r
-    unsigned char chroma_phase_y_plus1;\r
-\r
-    unsigned char tcoeff_level_prediction_flag;\r
-    unsigned char constrained_intra_resampling_flag;\r
-    unsigned char ref_layer_chroma_phase_x_plus1_flag;\r
-    unsigned char store_ref_base_pic_flag;\r
-    unsigned char Reserved8BitsA;\r
-    unsigned char Reserved8BitsB;\r
-    // For the 4 scaled_ref_layer_XX fields below,\r
-    // if (extended_spatial_scalability_idc == 1), SPS field, G.7.3.2.1.4, add prefix "seq_"\r
-    // if (extended_spatial_scalability_idc == 2), SLH field, G.7.3.3.4,\r
-    short scaled_ref_layer_left_offset;\r
-    short scaled_ref_layer_top_offset;\r
-    short scaled_ref_layer_right_offset;\r
-    short scaled_ref_layer_bottom_offset;\r
-    unsigned short Reserved16Bits;\r
-    struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded. Linked list ends at the target layer. */\r
-    int bRefBaseLayer;                  /**< whether to store ref base pic */\r
-} CUVIDH264SVCEXT;\r
-\r
-/*!\r
- * \struct CUVIDH264PICPARAMS\r
- * H.264 Picture Parameters\r
- */\r
-typedef struct _CUVIDH264PICPARAMS\r
-{\r
-    // SPS\r
-    int log2_max_frame_num_minus4;\r
-    int pic_order_cnt_type;\r
-    int log2_max_pic_order_cnt_lsb_minus4;\r
-    int delta_pic_order_always_zero_flag;\r
-    int frame_mbs_only_flag;\r
-    int direct_8x8_inference_flag;\r
-    int num_ref_frames;             // NOTE: shall meet level 4.1 restrictions\r
-    unsigned char residual_colour_transform_flag;\r
-    unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)\r
-    unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)\r
-    unsigned char qpprime_y_zero_transform_bypass_flag;\r
-    // PPS\r
-    int entropy_coding_mode_flag;\r
-    int pic_order_present_flag;\r
-    int num_ref_idx_l0_active_minus1;\r
-    int num_ref_idx_l1_active_minus1;\r
-    int weighted_pred_flag;\r
-    int weighted_bipred_idc;\r
-    int pic_init_qp_minus26;\r
-    int deblocking_filter_control_present_flag;\r
-    int redundant_pic_cnt_present_flag;\r
-    int transform_8x8_mode_flag;\r
-    int MbaffFrameFlag;\r
-    int constrained_intra_pred_flag;\r
-    int chroma_qp_index_offset;\r
-    int second_chroma_qp_index_offset;\r
-    int ref_pic_flag;\r
-    int frame_num;\r
-    int CurrFieldOrderCnt[2];\r
-    // DPB\r
-    CUVIDH264DPBENTRY dpb[16];          // List of reference frames within the DPB\r
-    // Quantization Matrices (raster-order)\r
-    unsigned char WeightScale4x4[6][16];\r
-    unsigned char WeightScale8x8[2][64];\r
-    // FMO/ASO\r
-    unsigned char fmo_aso_enable;\r
-    unsigned char num_slice_groups_minus1;\r
-    unsigned char slice_group_map_type;\r
-    signed char pic_init_qs_minus26;\r
-    unsigned int slice_group_change_rate_minus1;\r
-    union\r
-    {\r
-        unsigned long long slice_group_map_addr;\r
-        const unsigned char *pMb2SliceGroupMap;\r
-    } fmo;\r
-    unsigned int  Reserved[12];\r
-    // SVC/MVC\r
-    union\r
-    {\r
-        CUVIDH264MVCEXT mvcext;\r
-        CUVIDH264SVCEXT svcext;\r
-    };\r
-} CUVIDH264PICPARAMS;\r
-\r
-\r
-/*!\r
- * \struct CUVIDMPEG2PICPARAMS\r
- * MPEG-2 Picture Parameters\r
- */\r
-typedef struct _CUVIDMPEG2PICPARAMS\r
-{\r
-    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)\r
-    int BackwardRefIdx;         // Picture index of backward reference (B-frames)\r
-    int picture_coding_type;\r
-    int full_pel_forward_vector;\r
-    int full_pel_backward_vector;\r
-    int f_code[2][2];\r
-    int intra_dc_precision;\r
-    int frame_pred_frame_dct;\r
-    int concealment_motion_vectors;\r
-    int q_scale_type;\r
-    int intra_vlc_format;\r
-    int alternate_scan;\r
-    int top_field_first;\r
-    // Quantization matrices (raster order)\r
-    unsigned char QuantMatrixIntra[64];\r
-    unsigned char QuantMatrixInter[64];\r
-} CUVIDMPEG2PICPARAMS;\r
-\r
-////////////////////////////////////////////////////////////////////////////////////////////////\r
-//\r
-// MPEG-4 Picture Parameters\r
-//\r
-\r
-// MPEG-4 has VOP types instead of Picture types\r
-#define I_VOP 0\r
-#define P_VOP 1\r
-#define B_VOP 2\r
-#define S_VOP 3\r
-\r
-/*!\r
- * \struct CUVIDMPEG4PICPARAMS\r
- * MPEG-4 Picture Parameters\r
- */\r
-typedef struct _CUVIDMPEG4PICPARAMS\r
-{\r
-    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)\r
-    int BackwardRefIdx;         // Picture index of backward reference (B-frames)\r
-    // VOL\r
-    int video_object_layer_width;\r
-    int video_object_layer_height;\r
-    int vop_time_increment_bitcount;\r
-    int top_field_first;\r
-    int resync_marker_disable;\r
-    int quant_type;\r
-    int quarter_sample;\r
-    int short_video_header;\r
-    int divx_flags;\r
-    // VOP\r
-    int vop_coding_type;\r
-    int vop_coded;\r
-    int vop_rounding_type;\r
-    int alternate_vertical_scan_flag;\r
-    int interlaced;\r
-    int vop_fcode_forward;\r
-    int vop_fcode_backward;\r
-    int trd[2];\r
-    int trb[2];\r
-    // Quantization matrices (raster order)\r
-    unsigned char QuantMatrixIntra[64];\r
-    unsigned char QuantMatrixInter[64];\r
-    int gmc_enabled;\r
-} CUVIDMPEG4PICPARAMS;\r
-\r
-/*!\r
- * \struct CUVIDVC1PICPARAMS\r
- * VC1 Picture Parameters\r
- */\r
-typedef struct _CUVIDVC1PICPARAMS\r
-{\r
-    int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */\r
-    int BackwardRefIdx;     /**< Picture index of backward reference (B-frames) */\r
-    int FrameWidth;         /**< Actual frame width */\r
-    int FrameHeight;        /**< Actual frame height */\r
-    // PICTURE\r
-    int intra_pic_flag;     /**< Set to 1 for I,BI frames */\r
-    int ref_pic_flag;       /**< Set to 1 for I,P frames */\r
-    int progressive_fcm;    /**< Progressive frame */\r
-    // SEQUENCE\r
-    int profile;\r
-    int postprocflag;\r
-    int pulldown;\r
-    int interlace;\r
-    int tfcntrflag;\r
-    int finterpflag;\r
-    int psf;\r
-    int multires;\r
-    int syncmarker;\r
-    int rangered;\r
-    int maxbframes;\r
-    // ENTRYPOINT\r
-    int panscan_flag;\r
-    int refdist_flag;\r
-    int extended_mv;\r
-    int dquant;\r
-    int vstransform;\r
-    int loopfilter;\r
-    int fastuvmc;\r
-    int overlap;\r
-    int quantizer;\r
-    int extended_dmv;\r
-    int range_mapy_flag;\r
-    int range_mapy;\r
-    int range_mapuv_flag;\r
-    int range_mapuv;\r
-    int rangeredfrm;    // range reduction state\r
-} CUVIDVC1PICPARAMS;\r
-\r
-/*!\r
- * \struct CUVIDJPEGPICPARAMS\r
- * JPEG Picture Parameters\r
- */\r
-typedef struct _CUVIDJPEGPICPARAMS\r
-{\r
-    int Reserved;\r
-} CUVIDJPEGPICPARAMS;\r
-\r
-\r
- /*!\r
- * \struct CUVIDHEVCPICPARAMS\r
- * HEVC Picture Parameters\r
- */\r
-typedef struct _CUVIDHEVCPICPARAMS\r
-{\r
-    // sps\r
-    int pic_width_in_luma_samples;\r
-    int pic_height_in_luma_samples;\r
-    unsigned char log2_min_luma_coding_block_size_minus3;\r
-    unsigned char log2_diff_max_min_luma_coding_block_size;\r
-    unsigned char log2_min_transform_block_size_minus2;\r
-    unsigned char log2_diff_max_min_transform_block_size;\r
-    unsigned char pcm_enabled_flag;\r
-    unsigned char log2_min_pcm_luma_coding_block_size_minus3;\r
-    unsigned char log2_diff_max_min_pcm_luma_coding_block_size;\r
-    unsigned char pcm_sample_bit_depth_luma_minus1;\r
-\r
-    unsigned char pcm_sample_bit_depth_chroma_minus1;\r
-    unsigned char pcm_loop_filter_disabled_flag;\r
-    unsigned char strong_intra_smoothing_enabled_flag;\r
-    unsigned char max_transform_hierarchy_depth_intra;\r
-    unsigned char max_transform_hierarchy_depth_inter;\r
-    unsigned char amp_enabled_flag;\r
-    unsigned char separate_colour_plane_flag;\r
-    unsigned char log2_max_pic_order_cnt_lsb_minus4;\r
-\r
-    unsigned char num_short_term_ref_pic_sets;\r
-    unsigned char long_term_ref_pics_present_flag;\r
-    unsigned char num_long_term_ref_pics_sps;\r
-    unsigned char sps_temporal_mvp_enabled_flag;\r
-    unsigned char sample_adaptive_offset_enabled_flag;\r
-    unsigned char scaling_list_enable_flag;\r
-    unsigned char IrapPicFlag;\r
-    unsigned char IdrPicFlag;\r
-\r
-    unsigned char bit_depth_luma_minus8;\r
-    unsigned char bit_depth_chroma_minus8;\r
-    unsigned char reserved1[14];\r
-\r
-    // pps\r
-    unsigned char dependent_slice_segments_enabled_flag;\r
-    unsigned char slice_segment_header_extension_present_flag;\r
-    unsigned char sign_data_hiding_enabled_flag;\r
-    unsigned char cu_qp_delta_enabled_flag;\r
-    unsigned char diff_cu_qp_delta_depth;\r
-    signed char init_qp_minus26;\r
-    signed char pps_cb_qp_offset;\r
-    signed char pps_cr_qp_offset;\r
-\r
-    unsigned char constrained_intra_pred_flag;\r
-    unsigned char weighted_pred_flag;\r
-    unsigned char weighted_bipred_flag;\r
-    unsigned char transform_skip_enabled_flag;\r
-    unsigned char transquant_bypass_enabled_flag;\r
-    unsigned char entropy_coding_sync_enabled_flag;\r
-    unsigned char log2_parallel_merge_level_minus2;\r
-    unsigned char num_extra_slice_header_bits;\r
-\r
-    unsigned char loop_filter_across_tiles_enabled_flag;\r
-    unsigned char loop_filter_across_slices_enabled_flag;\r
-    unsigned char output_flag_present_flag;\r
-    unsigned char num_ref_idx_l0_default_active_minus1;\r
-    unsigned char num_ref_idx_l1_default_active_minus1;\r
-    unsigned char lists_modification_present_flag;\r
-    unsigned char cabac_init_present_flag;\r
-    unsigned char pps_slice_chroma_qp_offsets_present_flag;\r
-\r
-    unsigned char deblocking_filter_override_enabled_flag;\r
-    unsigned char pps_deblocking_filter_disabled_flag;\r
-    signed char pps_beta_offset_div2;\r
-    signed char pps_tc_offset_div2;\r
-    unsigned char tiles_enabled_flag;\r
-    unsigned char uniform_spacing_flag;\r
-    unsigned char num_tile_columns_minus1;\r
-    unsigned char num_tile_rows_minus1;\r
-\r
-    unsigned short column_width_minus1[21];\r
-    unsigned short row_height_minus1[21];\r
-    unsigned int reserved3[15];\r
-\r
-    // RefPicSets\r
-    int NumBitsForShortTermRPSInSlice;\r
-    int NumDeltaPocsOfRefRpsIdx;\r
-    int NumPocTotalCurr;\r
-    int NumPocStCurrBefore;\r
-    int NumPocStCurrAfter;\r
-    int NumPocLtCurr;\r
-    int CurrPicOrderCntVal;\r
-    int RefPicIdx[16];                  // [refpic] Indices of valid reference pictures (-1 if unused for reference)\r
-    int PicOrderCntVal[16];             // [refpic]\r
-    unsigned char IsLongTerm[16];       // [refpic] 0=not a long-term reference, 1=long-term reference\r
-    unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)\r
-    unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)\r
-    unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)\r
-    unsigned char RefPicSetInterLayer0[8];\r
-    unsigned char RefPicSetInterLayer1[8];\r
-    unsigned int reserved4[12];\r
-\r
-    // scaling lists (diag order)\r
-    unsigned char ScalingList4x4[6][16];       // [matrixId][i]\r
-    unsigned char ScalingList8x8[6][64];       // [matrixId][i]\r
-    unsigned char ScalingList16x16[6][64];     // [matrixId][i]\r
-    unsigned char ScalingList32x32[2][64];     // [matrixId][i]\r
-    unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]\r
-    unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]\r
-} CUVIDHEVCPICPARAMS;\r
-\r
-\r
-/*!\r
- * \struct CUVIDVP8PICPARAMS\r
- * VP8 Picture Parameters\r
- */\r
-typedef struct _CUVIDVP8PICPARAMS\r
-{\r
-    int width;\r
-    int height;\r
-    unsigned int first_partition_size;\r
-    //Frame Indexes\r
-    unsigned char LastRefIdx;\r
-    unsigned char GoldenRefIdx;\r
-    unsigned char AltRefIdx;\r
-    union {\r
-        struct {\r
-            unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */\r
-            unsigned char version : 3;\r
-            unsigned char show_frame : 1;\r
-            unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */\r
-            unsigned char Reserved2Bits : 2;\r
-        };\r
-        unsigned char wFrameTagFlags;\r
-    };\r
-    unsigned char Reserved1[4];\r
-    unsigned int  Reserved2[3];\r
-} CUVIDVP8PICPARAMS;\r
-\r
-/*!\r
- * \struct CUVIDVP9PICPARAMS\r
- * VP9 Picture Parameters\r
- */\r
-typedef struct _CUVIDVP9PICPARAMS\r
-{\r
-    unsigned int width;\r
-    unsigned int height;\r
-\r
-    //Frame Indices\r
-    unsigned char LastRefIdx;\r
-    unsigned char GoldenRefIdx;\r
-    unsigned char AltRefIdx;\r
-    unsigned char colorSpace;\r
-\r
-    unsigned short profile : 3;\r
-    unsigned short frameContextIdx : 2;\r
-    unsigned short frameType : 1;\r
-    unsigned short showFrame : 1;\r
-    unsigned short errorResilient : 1;\r
-    unsigned short frameParallelDecoding : 1;\r
-    unsigned short subSamplingX : 1;\r
-    unsigned short subSamplingY : 1;\r
-    unsigned short intraOnly : 1;\r
-    unsigned short allow_high_precision_mv : 1;\r
-    unsigned short refreshEntropyProbs : 1;\r
-    unsigned short reserved2Bits : 2;\r
-\r
-    unsigned short reserved16Bits;\r
-\r
-    unsigned char  refFrameSignBias[4];\r
-\r
-    unsigned char bitDepthMinus8Luma;\r
-    unsigned char bitDepthMinus8Chroma;\r
-    unsigned char loopFilterLevel;\r
-    unsigned char loopFilterSharpness;\r
-\r
-    unsigned char modeRefLfEnabled;\r
-    unsigned char log2_tile_columns;\r
-    unsigned char log2_tile_rows;\r
-\r
-    unsigned char segmentEnabled : 1;\r
-    unsigned char segmentMapUpdate : 1;\r
-    unsigned char segmentMapTemporalUpdate : 1;\r
-    unsigned char segmentFeatureMode : 1;\r
-    unsigned char reserved4Bits : 4;\r
-\r
-\r
-    unsigned char segmentFeatureEnable[8][4];\r
-    short segmentFeatureData[8][4];\r
-    unsigned char mb_segment_tree_probs[7];\r
-    unsigned char segment_pred_probs[3];\r
-    unsigned char reservedSegment16Bits[2];\r
-\r
-    int qpYAc;\r
-    int qpYDc;\r
-    int qpChDc;\r
-    int qpChAc;\r
-\r
-    unsigned int activeRefIdx[3];\r
-    unsigned int resetFrameContext;\r
-    unsigned int mcomp_filter_type;\r
-    unsigned int mbRefLfDelta[4];\r
-    unsigned int mbModeLfDelta[2];\r
-    unsigned int frameTagSize;\r
-    unsigned int offsetToDctParts;\r
-    unsigned int reserved128Bits[4];\r
-\r
-} CUVIDVP9PICPARAMS;\r
-\r
-\r
-/*!\r
- * \struct CUVIDPICPARAMS\r
- * Picture Parameters for Decoding\r
- */\r
-typedef struct _CUVIDPICPARAMS\r
-{\r
-    int PicWidthInMbs;                    /**< Coded Frame Size */\r
-    int FrameHeightInMbs;                 /**< Coded Frame Height */\r
-    int CurrPicIdx;                       /**< Output index of the current picture */\r
-    int field_pic_flag;                   /**< 0=frame picture, 1=field picture */\r
-    int bottom_field_flag;                /**< 0=top field, 1=bottom field (ignored if field_pic_flag=0) */\r
-    int second_field;                     /**< Second field of a complementary field pair */\r
-    // Bitstream data\r
-    unsigned int nBitstreamDataLen;        /**< Number of bytes in bitstream data buffer */\r
-    const unsigned char *pBitstreamData;   /**< Ptr to bitstream data for this picture (slice-layer) */\r
-    unsigned int nNumSlices;               /**< Number of slices in this picture */\r
-    const unsigned int *pSliceDataOffsets; /**< nNumSlices entries, contains offset of each slice within the bitstream data buffer */\r
-    int ref_pic_flag;                      /**< This picture is a reference picture */\r
-    int intra_pic_flag;                    /**< This picture is entirely intra coded */\r
-    unsigned int Reserved[30];             /**< Reserved for future use */\r
-    // Codec-specific data\r
-    union {\r
-        CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */\r
-        CUVIDH264PICPARAMS h264;\r
-        CUVIDVC1PICPARAMS vc1;\r
-        CUVIDMPEG4PICPARAMS mpeg4;\r
-        CUVIDJPEGPICPARAMS jpeg;\r
-        CUVIDHEVCPICPARAMS hevc;\r
-        CUVIDVP8PICPARAMS vp8;\r
-        CUVIDVP9PICPARAMS vp9;\r
-        unsigned int CodecReserved[1024];\r
-    } CodecSpecific;\r
-} CUVIDPICPARAMS;\r
-\r
-\r
-/*!\r
- * \struct CUVIDPROCPARAMS\r
- * Picture Parameters for Postprocessing\r
- */\r
-typedef struct _CUVIDPROCPARAMS\r
-{\r
-    int progressive_frame;  /**< Input is progressive (deinterlace_mode will be ignored)  */\r
-    int second_field;       /**< Output the second field (ignored if deinterlace mode is Weave) */\r
-    int top_field_first;    /**< Input frame is top field first (1st field is top, 2nd field is bottom) */\r
-    int unpaired_field;     /**< Input only contains one field (2nd field is invalid) */\r
-    // The fields below are used for raw YUV input\r
-    unsigned int reserved_flags;        /**< Reserved for future use (set to zero) */\r
-    unsigned int reserved_zero;         /**< Reserved (set to zero) */\r
-    unsigned long long raw_input_dptr;  /**< Input CUdeviceptr for raw YUV extensions */\r
-    unsigned int raw_input_pitch;       /**< pitch in bytes of raw YUV input (should be aligned appropriately) */\r
-    unsigned int raw_input_format;      /**< Reserved for future use (set to zero) */\r
-    unsigned long long raw_output_dptr; /**< Reserved for future use (set to zero) */\r
-    unsigned int raw_output_pitch;      /**< Reserved for future use (set to zero) */\r
-    unsigned int Reserved[48];\r
-    void *Reserved3[3];\r
-} CUVIDPROCPARAMS;\r
-\r
-\r
-/**\r
- *\r
- * In order to minimize decode latencies, there should be always at least 2 pictures in the decode\r
- * queue at any time, in order to make sure that all decode engines are always busy.\r
- *\r
- * Overall data flow:\r
- *  - cuvidCreateDecoder(...)\r
- *  For each picture:\r
- *  - cuvidDecodePicture(N)\r
- *  - cuvidMapVideoFrame(N-4)\r
- *  - do some processing in cuda\r
- *  - cuvidUnmapVideoFrame(N-4)\r
- *  - cuvidDecodePicture(N+1)\r
- *  - cuvidMapVideoFrame(N-3)\r
- *    ...\r
- *  - cuvidDestroyDecoder(...)\r
- *\r
- * NOTE:\r
- * - When the cuda context is created from a D3D device, the D3D device must also be created\r
- *   with the D3DCREATE_MULTITHREADED flag.\r
- * - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)\r
- * - cuVidDecodePicture may block the calling thread if there are too many pictures pending\r
- *   in the decode queue\r
- */\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)\r
- * Create the decoder object\r
- */\r
-CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)\r
- * Destroy the decoder object\r
- */\r
-CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)\r
- * Decode a single picture (field or frame)\r
- */\r
-CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);\r
-\r
-\r
-#if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)\r
-/**\r
- * \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);\r
- * Post-process and map a video frame for use in cuda\r
- */\r
-CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,\r
-                                           unsigned int *pDevPtr, unsigned int *pPitch,\r
-                                           CUVIDPROCPARAMS *pVPP);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)\r
- * Unmap a previously mapped video frame\r
- */\r
-CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);\r
-#endif\r
-\r
-#if defined(WIN64) || defined(_WIN64) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)\r
-/**\r
- * \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);\r
- * map a video frame\r
- */\r
-CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,\r
-                                             unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);\r
- * Unmap a previously mapped video frame\r
- */\r
-CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);\r
-\r
-#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)\r
-#define cuvidMapVideoFrame      cuvidMapVideoFrame64\r
-#define cuvidUnmapVideoFrame    cuvidUnmapVideoFrame64\r
-#endif\r
-#endif\r
-\r
-\r
-\r
-/**\r
- *\r
- * Context-locking: to facilitate multi-threaded implementations, the following 4 functions\r
- * provide a simple mutex-style host synchronization. If a non-NULL context is specified\r
- * in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given\r
- * context before making any cuda calls.\r
- * A multi-threaded application could create a lock associated with a context handle so that\r
- * multiple threads can safely share the same cuda context:\r
- *  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context\r
- *    that can be passed to cuvidCtxLockCreate.\r
- *  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.\r
- *\r
- * NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video\r
- * decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).\r
-*/\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)\r
- */\r
-CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)\r
- */\r
-CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)\r
- */\r
-CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)\r
- */\r
-CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);\r
-\r
-/** @} */  /* End VIDEO_DECODER */\r
-////////////////////////////////////////////////////////////////////////////////////////////////\r
-\r
-#if defined(__cplusplus)\r
-\r
-// Auto-lock helper for C++ applications\r
-class CCtxAutoLock\r
-{\r
-private:\r
-    CUvideoctxlock m_ctx;\r
-public:\r
-    CCtxAutoLock(CUvideoctxlock ctx);\r
-    ~CCtxAutoLock();\r
-};\r
-\r
-}\r
-\r
-#endif /* __cplusplus */\r
-\r
-#endif // __CUDA_VIDEO_H__\r
-\r
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2016 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
+ * NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.
+ * \date 2015-2016
+ * 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(__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;
+
+/**
+ * \addtogroup VIDEO_DECODER Video Decoder
+ * @{
+ */
+
+/*!
+ * \enum cudaVideoCodec
+ * Video Codec Enums
+ */
+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_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 Formats Enums
+ */
+typedef enum cudaVideoSurfaceFormat_enum {
+    cudaVideoSurfaceFormat_NV12=0       /**< NV12 (currently the only supported output format)  */
+} cudaVideoSurfaceFormat;
+
+/*!
+ * \enum cudaVideoDeinterlaceMode
+ * Deinterlacing Modes Enums
+ */
+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 Formats Enums
+ */
+typedef enum cudaVideoChromaFormat_enum {
+    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
+    cudaVideoChromaFormat_420,           /**< 4:2:0 */
+    cudaVideoChromaFormat_422,           /**< 4:2:2 */
+    cudaVideoChromaFormat_444            /**< 4:4:4 */
+} cudaVideoChromaFormat;
+
+/*!
+ * \enum cudaVideoCreateFlags
+ * Decoder Flags Enums
+ */
+typedef enum cudaVideoCreateFlags_enum {
+    cudaVideoCreate_Default = 0x00,     /**< Default operation mode: use dedicated video engines */
+    cudaVideoCreate_PreferCUDA = 0x01,  /**< Use a CUDA-based decoder if faster than dedicated engines (requires a 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;
+
+/*!
+ * \struct CUVIDDECODECREATEINFO
+ * Struct used in create decoder
+ */
+typedef struct _CUVIDDECODECREATEINFO
+{
+    unsigned long ulWidth;              /**< Coded Sequence Width */
+    unsigned long ulHeight;             /**< Coded Sequence Height */
+    unsigned long ulNumDecodeSurfaces;  /**< Maximum number of internal decode surfaces */
+    cudaVideoCodec CodecType;           /**< cudaVideoCodec_XXX */
+    cudaVideoChromaFormat ChromaFormat; /**< cudaVideoChromaFormat_XXX (only 4:2:0 is currently supported) */
+    unsigned long ulCreationFlags;      /**< Decoder creation flags (cudaVideoCreateFlags_XXX) */
+    unsigned long bitDepthMinus8;
+    unsigned long Reserved1[4];         /**< Reserved for future use - set to zero */
+    /**
+    * area of the frame that should be displayed
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } display_area;
+
+    cudaVideoSurfaceFormat OutputFormat;       /**< cudaVideoSurfaceFormat_XXX */
+    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< cudaVideoDeinterlaceMode_XXX */
+    unsigned long ulTargetWidth;               /**< Post-processed Output Width (Should be aligned to 2) */
+    unsigned long ulTargetHeight;              /**< Post-processed Output Height (Should be aligbed to 2) */
+    unsigned long ulNumOutputSurfaces;         /**< Maximum number of output surfaces simultaneously mapped */
+    CUvideoctxlock vidLock;                    /**< If non-NULL, context lock used for synchronizing ownership of the cuda context */
+    /**
+    * 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 Reserved2[5];                /**< Reserved for future use - set to zero */
+} CUVIDDECODECREATEINFO;
+
+/*!
+ * \struct CUVIDH264DPBENTRY
+ * H.264 DPB Entry
+ */
+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
+ */
+typedef struct _CUVIDH264MVCEXT
+{
+    int num_views_minus1;
+    int view_id;
+    unsigned char inter_view_flag;
+    unsigned char num_inter_view_refs_l0;
+    unsigned char num_inter_view_refs_l1;
+    unsigned char MVCReserved8Bits;
+    int InterViewRefsL0[16];
+    int InterViewRefsL1[16];
+} CUVIDH264MVCEXT;
+
+/*!
+ * \struct CUVIDH264SVCEXT
+ * H.264 SVC Picture Parameters Ext
+ */
+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;
+    // For the 4 scaled_ref_layer_XX fields below,
+    // if (extended_spatial_scalability_idc == 1), SPS field, G.7.3.2.1.4, add prefix "seq_"
+    // if (extended_spatial_scalability_idc == 2), SLH field, G.7.3.3.4,
+    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
+ */
+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;             // NOTE: shall meet level 4.1 restrictions
+    unsigned char residual_colour_transform_flag;
+    unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)
+    unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)
+    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  Reserved[12];
+    // SVC/MVC
+    union
+    {
+        CUVIDH264MVCEXT mvcext;
+        CUVIDH264SVCEXT svcext;
+    };
+} CUVIDH264PICPARAMS;
+
+
+/*!
+ * \struct CUVIDMPEG2PICPARAMS
+ * MPEG-2 Picture Parameters
+ */
+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 Picture Parameters
+//
+
+// 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
+ */
+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
+ */
+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
+ */
+typedef struct _CUVIDJPEGPICPARAMS
+{
+    int Reserved;
+} CUVIDJPEGPICPARAMS;
+
+
+ /*!
+ * \struct CUVIDHEVCPICPARAMS
+ * HEVC Picture Parameters
+ */
+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;
+    unsigned char reserved1[14];
+
+    // 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];
+    unsigned int reserved3[15];
+
+    // 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
+ */
+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;
+        };
+        unsigned char wFrameTagFlags;
+    };
+    unsigned char Reserved1[4];
+    unsigned int  Reserved2[3];
+} CUVIDVP8PICPARAMS;
+
+/*!
+ * \struct CUVIDVP9PICPARAMS
+ * VP9 Picture Parameters
+ */
+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 CUVIDPICPARAMS
+ * Picture Parameters for Decoding
+ */
+typedef struct _CUVIDPICPARAMS
+{
+    int PicWidthInMbs;                    /**< Coded Frame Size */
+    int FrameHeightInMbs;                 /**< Coded Frame Height */
+    int CurrPicIdx;                       /**< Output index of the current picture */
+    int field_pic_flag;                   /**< 0=frame picture, 1=field picture */
+    int bottom_field_flag;                /**< 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
+    int second_field;                     /**< Second field of a complementary field pair */
+    // Bitstream data
+    unsigned int nBitstreamDataLen;        /**< Number of bytes in bitstream data buffer */
+    const unsigned char *pBitstreamData;   /**< Ptr to bitstream data for this picture (slice-layer) */
+    unsigned int nNumSlices;               /**< Number of slices in this picture */
+    const unsigned int *pSliceDataOffsets; /**< nNumSlices entries, contains offset of each slice within the bitstream data buffer */
+    int ref_pic_flag;                      /**< This picture is a reference picture */
+    int intra_pic_flag;                    /**< This picture is entirely intra coded */
+    unsigned int Reserved[30];             /**< Reserved for future use */
+    // 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;
+        unsigned int CodecReserved[1024];
+    } CodecSpecific;
+} CUVIDPICPARAMS;
+
+
+/*!
+ * \struct CUVIDPROCPARAMS
+ * Picture Parameters for Postprocessing
+ */
+typedef struct _CUVIDPROCPARAMS
+{
+    int progressive_frame;  /**< Input is progressive (deinterlace_mode will be ignored)  */
+    int second_field;       /**< Output the second field (ignored if deinterlace mode is Weave) */
+    int top_field_first;    /**< Input frame is top field first (1st field is top, 2nd field is bottom) */
+    int unpaired_field;     /**< 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;  /**< Input CUdeviceptr for raw YUV extensions */
+    unsigned int raw_input_pitch;       /**< pitch in bytes of raw YUV input (should be aligned appropriately) */
+    unsigned int raw_input_format;      /**< Reserved for future use (set to zero) */
+    unsigned long long raw_output_dptr; /**< Reserved for future use (set to zero) */
+    unsigned int raw_output_pitch;      /**< Reserved for future use (set to zero) */
+    unsigned int Reserved[48];
+    void *Reserved3[3];
+} CUVIDPROCPARAMS;
+
+
+/**
+ *
+ * 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:
+ *  - 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 cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
+ * Create the decoder object
+ */
+CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
+
+/**
+ * \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
+ * Destroy the decoder object
+ */
+CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder);
+
+/**
+ * \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
+ * Decode a single picture (field or frame)
+ */
+CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
+
+
+#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 a video frame for use in cuda
+ */
+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
+ */
+CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
+#endif
+
+#if defined(WIN64) || defined(_WIN64) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+/**
+ * \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+ * map a video frame
+ */
+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
+ */
+CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+
+#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
+#define cuvidMapVideoFrame      cuvidMapVideoFrame64
+#define cuvidUnmapVideoFrame    cuvidUnmapVideoFrame64
+#endif
+#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)
+ */
+CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
+
+/**
+ * \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
+ */
+CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck);
+
+/**
+ * \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
+ */
+CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/**
+ * \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
+ */
+CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/** @} */  /* End VIDEO_DECODER */
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__cplusplus)
+
+// Auto-lock helper for C++ applications
+class CCtxAutoLock
+{
+private:
+    CUvideoctxlock m_ctx;
+public:
+    CCtxAutoLock(CUvideoctxlock ctx);
+    ~CCtxAutoLock();
+};
+
+}
+
+#endif /* __cplusplus */
+
+#endif // __CUDA_VIDEO_H__
+
index 61d66ce..738d8e3 100644 (file)
-/*\r
- * This copyright notice applies to this header file only:\r
- *\r
- * Copyright (c) 2010-2016 NVIDIA Corporation\r
- *\r
- * Permission is hereby granted, free of charge, to any person\r
- * obtaining a copy of this software and associated documentation\r
- * files (the "Software"), to deal in the Software without\r
- * restriction, including without limitation the rights to use,\r
- * copy, modify, merge, publish, distribute, sublicense, and/or sell\r
- * copies of the software, and to permit persons to whom the\r
- * software is furnished to do so, subject to the following\r
- * conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be\r
- * included in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\r
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\r
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\r
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\r
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\r
- * OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-/**\r
- * \file nvcuvid.h\r
- *   NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.\r
- * \date 2015-2015\r
- *  This file contains the interface constants, structure definitions and function prototypes.\r
- */\r
-\r
-#if !defined(__NVCUVID_H__)\r
-#define __NVCUVID_H__\r
-\r
-#include "compat/cuda/cuviddec.h"\r
-\r
-#if defined(__cplusplus)\r
-extern "C" {\r
-#endif /* __cplusplus */\r
-\r
-/*********************************\r
-** Initialization\r
-*********************************/\r
-CUresult  CUDAAPI cuvidInit(unsigned int Flags);\r
-    \r
-////////////////////////////////////////////////////////////////////////////////////////////////\r
-//\r
-// High-level helper APIs for video sources\r
-//\r
-\r
-typedef void *CUvideosource;\r
-typedef void *CUvideoparser;\r
-typedef long long CUvideotimestamp;\r
-\r
-/**\r
- * \addtogroup VIDEO_PARSER Video Parser\r
- * @{\r
- */\r
-\r
-/*!\r
- * \enum cudaVideoState\r
- * Video Source State\r
- */\r
-typedef enum {\r
-    cudaVideoState_Error   = -1,    /**< Error state (invalid source)  */\r
-    cudaVideoState_Stopped = 0,     /**< Source is stopped (or reached end-of-stream)  */\r
-    cudaVideoState_Started = 1      /**< Source is running and delivering data  */\r
-} cudaVideoState;\r
-\r
-/*!\r
- * \enum cudaAudioCodec\r
- * Audio compression\r
- */\r
-typedef enum {\r
-    cudaAudioCodec_MPEG1=0,         /**< MPEG-1 Audio  */\r
-    cudaAudioCodec_MPEG2,           /**< MPEG-2 Audio  */\r
-    cudaAudioCodec_MP3,             /**< MPEG-1 Layer III Audio  */\r
-    cudaAudioCodec_AC3,             /**< Dolby Digital (AC3) Audio  */\r
-    cudaAudioCodec_LPCM             /**< PCM Audio  */\r
-} cudaAudioCodec;\r
-\r
-/*!\r
- * \struct CUVIDEOFORMAT\r
- * Video format\r
- */\r
-typedef struct\r
-{\r
-    cudaVideoCodec codec;                   /**< Compression format  */\r
-   /**\r
-    * frame rate = numerator / denominator (for example: 30000/1001)\r
-    */\r
-    struct {\r
-        unsigned int numerator;             /**< frame rate numerator   (0 = unspecified or variable frame rate) */\r
-        unsigned int denominator;           /**< frame rate denominator (0 = unspecified or variable frame rate) */\r
-    } frame_rate;\r
-    unsigned char progressive_sequence;     /**< 0=interlaced, 1=progressive */\r
-    unsigned char bit_depth_luma_minus8;    /**< high bit depth Luma */\r
-    unsigned char bit_depth_chroma_minus8;  /**< high bit depth Chroma */\r
-    unsigned char reserved1;                /**< Reserved for future use */\r
-    unsigned int coded_width;               /**< coded frame width */\r
-    unsigned int coded_height;              /**< coded frame height  */\r
-   /**\r
-    *   area of the frame that should be displayed\r
-    * typical example:\r
-    *   coded_width = 1920, coded_height = 1088\r
-    *   display_area = { 0,0,1920,1080 }\r
-    */\r
-    struct {\r
-        int left;                           /**< left position of display rect  */\r
-        int top;                            /**< top position of display rect  */\r
-        int right;                          /**< right position of display rect  */\r
-        int bottom;                         /**< bottom position of display rect  */\r
-    } display_area;\r
-    cudaVideoChromaFormat chroma_format;    /**<  Chroma format */\r
-    unsigned int bitrate;                   /**< video bitrate (bps, 0=unknown) */\r
-   /**\r
-    * Display Aspect Ratio = x:y (4:3, 16:9, etc)\r
-    */\r
-    struct {\r
-        int x;\r
-        int y;\r
-    } display_aspect_ratio;\r
-    /**\r
-    * Video Signal Description\r
-    */\r
-    struct {\r
-        unsigned char video_format          : 3;\r
-        unsigned char video_full_range_flag : 1;\r
-        unsigned char reserved_zero_bits    : 4;\r
-        unsigned char color_primaries;\r
-        unsigned char transfer_characteristics;\r
-        unsigned char matrix_coefficients;\r
-    } video_signal_description;\r
-    unsigned int seqhdr_data_length;          /**< Additional bytes following (CUVIDEOFORMATEX)  */\r
-} CUVIDEOFORMAT;\r
-\r
-/*!\r
- * \struct CUVIDEOFORMATEX\r
- * Video format including raw sequence header information\r
- */\r
-typedef struct\r
-{\r
-    CUVIDEOFORMAT format;\r
-    unsigned char raw_seqhdr_data[1024];\r
-} CUVIDEOFORMATEX;\r
-\r
-/*!\r
- * \struct CUAUDIOFORMAT\r
- * Audio Formats\r
- */\r
-typedef struct\r
-{\r
-    cudaAudioCodec codec;       /**< Compression format  */\r
-    unsigned int channels;      /**< number of audio channels */\r
-    unsigned int samplespersec; /**< sampling frequency */\r
-    unsigned int bitrate;       /**< For uncompressed, can also be used to determine bits per sample */\r
-    unsigned int reserved1;     /**< Reserved for future use */\r
-    unsigned int reserved2;     /**< Reserved for future use */\r
-} CUAUDIOFORMAT;\r
-\r
-\r
-/*!\r
- * \enum CUvideopacketflags\r
- * Data packet flags\r
- */\r
-typedef enum {\r
-    CUVID_PKT_ENDOFSTREAM   = 0x01,   /**< Set when this is the last packet for this stream  */\r
-    CUVID_PKT_TIMESTAMP     = 0x02,   /**< Timestamp is valid  */\r
-    CUVID_PKT_DISCONTINUITY = 0x04    /**< Set when a discontinuity has to be signalled  */\r
-} CUvideopacketflags;\r
-\r
-/*!\r
- * \struct CUVIDSOURCEDATAPACKET\r
- * Data Packet\r
- */\r
-typedef struct _CUVIDSOURCEDATAPACKET\r
-{\r
-    unsigned long flags;            /**< Combination of CUVID_PKT_XXX flags */\r
-    unsigned long payload_size;     /**< number of bytes in the payload (may be zero if EOS flag is set) */\r
-    const unsigned char *payload;   /**< Pointer to packet payload data (may be NULL if EOS flag is set) */\r
-    CUvideotimestamp timestamp;     /**< Presentation timestamp (10MHz clock), only valid if CUVID_PKT_TIMESTAMP flag is set */\r
-} CUVIDSOURCEDATAPACKET;\r
-\r
-// Callback for packet delivery\r
-typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);\r
-\r
-/*!\r
- * \struct CUVIDSOURCEPARAMS\r
- * Source Params\r
- */\r
-typedef struct _CUVIDSOURCEPARAMS\r
-{\r
-    unsigned int ulClockRate;                   /**< Timestamp units in Hz (0=default=10000000Hz)  */\r
-    unsigned int uReserved1[7];                 /**< Reserved for future use - set to zero  */\r
-    void *pUserData;                            /**< Parameter passed in to the data handlers  */\r
-    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< Called to deliver audio packets  */\r
-    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< Called to deliver video packets  */\r
-    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL */\r
-} CUVIDSOURCEPARAMS;\r
-\r
-/*!\r
- * \enum CUvideosourceformat_flags\r
- * CUvideosourceformat_flags\r
- */\r
-typedef enum {\r
-    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */\r
-} CUvideosourceformat_flags;\r
-\r
-#if !defined(__APPLE__)\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)\r
- * Create Video Source\r
- */\r
-CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams)\r
- * Create Video Source\r
- */\r
-CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)\r
- * Destroy Video Source\r
- */\r
-CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)\r
- * Set Video Source state\r
- */\r
-CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);\r
-\r
-/**\r
- * \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)\r
- * Get Video Source state\r
- */\r
-cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)\r
- * Get Video Source Format\r
- */\r
-CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)\r
- * Set Video Source state\r
- */\r
-CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);\r
-\r
-#endif\r
-\r
-/**\r
- * \struct CUVIDPARSERDISPINFO\r
- */\r
-typedef struct _CUVIDPARSERDISPINFO\r
-{\r
-    int picture_index;         /**<                 */\r
-    int progressive_frame;     /**<                 */\r
-    int top_field_first;       /**<                 */\r
-    int repeat_first_field;    /**< Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling, -1=unpaired field)  */\r
-    CUvideotimestamp timestamp; /**<     */\r
-} CUVIDPARSERDISPINFO;\r
-\r
-//\r
-// Parser callbacks\r
-// The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to\r
-// be decoded and/or displayed.\r
-//\r
-typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);\r
-typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);\r
-typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);\r
-\r
-/**\r
- * \struct CUVIDPARSERPARAMS\r
- */\r
-typedef struct _CUVIDPARSERPARAMS\r
-{\r
-    cudaVideoCodec CodecType;               /**< cudaVideoCodec_XXX  */\r
-    unsigned int ulMaxNumDecodeSurfaces;    /**< Max # of decode surfaces (parser will cycle through these) */\r
-    unsigned int ulClockRate;               /**< Timestamp units in Hz (0=default=10000000Hz) */\r
-    unsigned int ulErrorThreshold;          /**< % Error threshold (0-100) for calling pfnDecodePicture (100=always call pfnDecodePicture even if picture bitstream is fully corrupted) */\r
-    unsigned int ulMaxDisplayDelay;         /**< Max display queue delay (improves pipelining of decode with display) - 0=no delay (recommended values: 2..4) */\r
-    unsigned int uReserved1[5];             /**< Reserved for future use - set to 0 */\r
-    void *pUserData;                        /**< User data for callbacks */\r
-    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< Called before decoding frames and/or whenever there is a format change */\r
-    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< Called when a picture is ready to be decoded (decode order) */\r
-    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< Called whenever a picture is ready to be displayed (display order)  */\r
-    void *pvReserved2[7];                       /**< Reserved for future use - set to NULL */\r
-    CUVIDEOFORMATEX *pExtVideoInfo;             /**< [Optional] sequence header data from system layer */\r
-} CUVIDPARSERPARAMS;\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)\r
- */\r
-CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)\r
- */\r
-CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);\r
-\r
-/**\r
- * \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)\r
- */\r
-CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj);\r
-\r
-/** @} */  /* END VIDEO_PARSER */\r
-////////////////////////////////////////////////////////////////////////////////////////////////\r
-\r
-#if defined(__cplusplus)\r
-}\r
-#endif /* __cplusplus */\r
-\r
-#endif // __NVCUVID_H__\r
-\r
-\r
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2016 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
+ *   NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.
+ * \date 2015-2015
+ *  This file contains the interface constants, structure definitions and function prototypes.
+ */
+
+#if !defined(__NVCUVID_H__)
+#define __NVCUVID_H__
+
+#include "compat/cuda/cuviddec.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+/*********************************
+** Initialization
+*********************************/
+CUresult  CUDAAPI cuvidInit(unsigned int Flags);
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// High-level helper APIs for video sources
+//
+
+typedef void *CUvideosource;
+typedef void *CUvideoparser;
+typedef long long CUvideotimestamp;
+
+/**
+ * \addtogroup VIDEO_PARSER Video Parser
+ * @{
+ */
+
+/*!
+ * \enum cudaVideoState
+ * Video Source State
+ */
+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
+ */
+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;
+
+/*!
+ * \struct CUVIDEOFORMAT
+ * Video format
+ */
+typedef struct
+{
+    cudaVideoCodec codec;                   /**< Compression format  */
+   /**
+    * frame rate = numerator / denominator (for example: 30000/1001)
+    */
+    struct {
+        unsigned int numerator;             /**< frame rate numerator   (0 = unspecified or variable frame rate) */
+        unsigned int denominator;           /**< frame rate denominator (0 = unspecified or variable frame rate) */
+    } frame_rate;
+    unsigned char progressive_sequence;     /**< 0=interlaced, 1=progressive */
+    unsigned char bit_depth_luma_minus8;    /**< high bit depth Luma */
+    unsigned char bit_depth_chroma_minus8;  /**< high bit depth Chroma */
+    unsigned char reserved1;                /**< Reserved for future use */
+    unsigned int coded_width;               /**< coded frame width */
+    unsigned int coded_height;              /**< coded frame height  */
+   /**
+    *   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;                           /**< left position of display rect  */
+        int top;                            /**< top position of display rect  */
+        int right;                          /**< right position of display rect  */
+        int bottom;                         /**< bottom position of display rect  */
+    } display_area;
+    cudaVideoChromaFormat chroma_format;    /**<  Chroma format */
+    unsigned int bitrate;                   /**< video bitrate (bps, 0=unknown) */
+   /**
+    * Display Aspect Ratio = x:y (4:3, 16:9, etc)
+    */
+    struct {
+        int x;
+        int y;
+    } display_aspect_ratio;
+    /**
+    * Video Signal Description
+    */
+    struct {
+        unsigned char video_format          : 3;
+        unsigned char video_full_range_flag : 1;
+        unsigned char reserved_zero_bits    : 4;
+        unsigned char color_primaries;
+        unsigned char transfer_characteristics;
+        unsigned char matrix_coefficients;
+    } video_signal_description;
+    unsigned int seqhdr_data_length;          /**< Additional bytes following (CUVIDEOFORMATEX)  */
+} CUVIDEOFORMAT;
+
+/*!
+ * \struct CUVIDEOFORMATEX
+ * Video format including raw sequence header information
+ */
+typedef struct
+{
+    CUVIDEOFORMAT format;
+    unsigned char raw_seqhdr_data[1024];
+} CUVIDEOFORMATEX;
+
+/*!
+ * \struct CUAUDIOFORMAT
+ * Audio Formats
+ */
+typedef struct
+{
+    cudaAudioCodec codec;       /**< Compression format  */
+    unsigned int channels;      /**< number of audio channels */
+    unsigned int samplespersec; /**< sampling frequency */
+    unsigned int bitrate;       /**< 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
+ */
+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  */
+} CUvideopacketflags;
+
+/*!
+ * \struct CUVIDSOURCEDATAPACKET
+ * Data Packet
+ */
+typedef struct _CUVIDSOURCEDATAPACKET
+{
+    unsigned long flags;            /**< Combination of CUVID_PKT_XXX flags */
+    unsigned long payload_size;     /**< number of bytes in the payload (may be zero if EOS flag is set) */
+    const unsigned char *payload;   /**< Pointer to packet payload data (may be NULL if EOS flag is set) */
+    CUvideotimestamp timestamp;     /**< Presentation timestamp (10MHz clock), only valid if CUVID_PKT_TIMESTAMP flag is set */
+} CUVIDSOURCEDATAPACKET;
+
+// Callback for packet delivery
+typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);
+
+/*!
+ * \struct CUVIDSOURCEPARAMS
+ * Source Params
+ */
+typedef struct _CUVIDSOURCEPARAMS
+{
+    unsigned int ulClockRate;                   /**< Timestamp units in Hz (0=default=10000000Hz)  */
+    unsigned int uReserved1[7];                 /**< Reserved for future use - set to zero  */
+    void *pUserData;                            /**< Parameter passed in to the data handlers  */
+    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< Called to deliver audio packets  */
+    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< Called to deliver video packets  */
+    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL */
+} CUVIDSOURCEPARAMS;
+
+/*!
+ * \enum CUvideosourceformat_flags
+ * CUvideosourceformat_flags
+ */
+typedef enum {
+    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */
+} CUvideosourceformat_flags;
+
+#if !defined(__APPLE__)
+/**
+ * \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)
+ * Create Video Source
+ */
+CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/**
+ * \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);
+
+/**
+ * \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)
+ * Destroy Video Source
+ */
+CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj);
+
+/**
+ * \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)
+ * Set Video Source state
+ */
+CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);
+
+/**
+ * \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)
+ * Get Video Source state
+ */
+cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj);
+
+/**
+ * \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)
+ * Get Video Source Format
+ */
+CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);
+
+/**
+ * \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)
+ * Set Video Source state
+ */
+CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);
+
+#endif
+
+/**
+ * \struct CUVIDPARSERDISPINFO
+ */
+typedef struct _CUVIDPARSERDISPINFO
+{
+    int picture_index;         /**<                 */
+    int progressive_frame;     /**<                 */
+    int top_field_first;       /**<                 */
+    int repeat_first_field;    /**< Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling, -1=unpaired field)  */
+    CUvideotimestamp timestamp; /**<     */
+} CUVIDPARSERDISPINFO;
+
+//
+// Parser callbacks
+// The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to
+// be decoded and/or displayed.
+//
+typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);
+typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);
+typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);
+
+/**
+ * \struct CUVIDPARSERPARAMS
+ */
+typedef struct _CUVIDPARSERPARAMS
+{
+    cudaVideoCodec CodecType;               /**< cudaVideoCodec_XXX  */
+    unsigned int ulMaxNumDecodeSurfaces;    /**< Max # of decode surfaces (parser will cycle through these) */
+    unsigned int ulClockRate;               /**< Timestamp units in Hz (0=default=10000000Hz) */
+    unsigned int ulErrorThreshold;          /**< % Error threshold (0-100) for calling pfnDecodePicture (100=always call pfnDecodePicture even if picture bitstream is fully corrupted) */
+    unsigned int ulMaxDisplayDelay;         /**< Max display queue delay (improves pipelining of decode with display) - 0=no delay (recommended values: 2..4) */
+    unsigned int uReserved1[5];             /**< Reserved for future use - set to 0 */
+    void *pUserData;                        /**< User data for callbacks */
+    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< Called before decoding frames and/or whenever there is a format change */
+    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< Called when a picture is ready to be decoded (decode order) */
+    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< Called whenever a picture is ready to be displayed (display order)  */
+    void *pvReserved2[7];                       /**< Reserved for future use - set to NULL */
+    CUVIDEOFORMATEX *pExtVideoInfo;             /**< [Optional] sequence header data from system layer */
+} CUVIDPARSERPARAMS;
+
+/**
+ * \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)
+ */
+CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);
+
+/**
+ * \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)
+ */
+CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);
+
+/**
+ * \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)
+ */
+CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj);
+
+/** @} */  /* END VIDEO_PARSER */
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __NVCUVID_H__
+
+