4d237643a1e4ca1bdb17b370811c3c542f9ee452
[ffmpeg.git] / compat / cuda / dynlink_cuviddec.h
1 /*
2  * This copyright notice applies to this header file only:
3  *
4  * Copyright (c) 2010-2016 NVIDIA Corporation
5  *
6  * Permission is hereby granted, free of charge, to any person
7  * obtaining a copy of this software and associated documentation
8  * files (the "Software"), to deal in the Software without
9  * restriction, including without limitation the rights to use,
10  * copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the software, and to permit persons to whom the
12  * software is furnished to do so, subject to the following
13  * conditions:
14  *
15  * The above copyright notice and this permission notice shall be
16  * included in all copies or substantial portions of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
20  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25  * OTHER DEALINGS IN THE SOFTWARE.
26  */
27
28 /**
29  * \file cuviddec.h
30  * NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.
31  * \date 2015-2016
32  * This file contains constants, structure definitions and function prototypes used for decoding.
33  */
34
35 #if !defined(__CUDA_VIDEO_H__)
36 #define __CUDA_VIDEO_H__
37
38 #if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
39 #if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))
40 #define __CUVID_DEVPTR64
41 #endif
42 #endif
43
44 #if defined(__cplusplus)
45 extern "C" {
46 #endif /* __cplusplus */
47
48 #if defined(__CYGWIN__)
49 typedef unsigned int tcu_ulong;
50 #else
51 typedef unsigned long tcu_ulong;
52 #endif
53
54 typedef void *CUvideodecoder;
55 typedef struct _CUcontextlock_st *CUvideoctxlock;
56
57 /**
58  * \addtogroup VIDEO_DECODER Video Decoder
59  * @{
60  */
61
62 /*!
63  * \enum cudaVideoCodec
64  * Video Codec Enums
65  */
66 typedef enum cudaVideoCodec_enum {
67     cudaVideoCodec_MPEG1=0,                 /**<  MPEG1   */
68     cudaVideoCodec_MPEG2,                   /**<  MPEG2  */
69     cudaVideoCodec_MPEG4,                   /**<  MPEG4   */
70     cudaVideoCodec_VC1,                     /**<  VC1   */
71     cudaVideoCodec_H264,                    /**<  H264   */
72     cudaVideoCodec_JPEG,                    /**<  JPEG   */
73     cudaVideoCodec_H264_SVC,                /**<  H264-SVC   */
74     cudaVideoCodec_H264_MVC,                /**<  H264-MVC   */
75     cudaVideoCodec_HEVC,                    /**<  HEVC   */
76     cudaVideoCodec_VP8,                     /**<  VP8   */
77     cudaVideoCodec_VP9,                     /**<  VP9   */
78     cudaVideoCodec_NumCodecs,               /**<  Max COdecs   */
79     // Uncompressed YUV
80     cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)  */
81     cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)  */
82     cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)  */
83     cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */
84     cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)  */
85 } cudaVideoCodec;
86
87 /*!
88  * \enum cudaVideoSurfaceFormat
89  * Video Surface Formats Enums
90  */
91 typedef enum cudaVideoSurfaceFormat_enum {
92     cudaVideoSurfaceFormat_NV12=0,      /**< NV12  */
93     cudaVideoSurfaceFormat_P016=1       /**< P016  */
94 } cudaVideoSurfaceFormat;
95
96 /*!
97  * \enum cudaVideoDeinterlaceMode
98  * Deinterlacing Modes Enums
99  */
100 typedef enum cudaVideoDeinterlaceMode_enum {
101     cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */
102     cudaVideoDeinterlaceMode_Bob,       /**< Drop one field  */
103     cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing  */
104 } cudaVideoDeinterlaceMode;
105
106 /*!
107  * \enum cudaVideoChromaFormat
108  * Chroma Formats Enums
109  */
110 typedef enum cudaVideoChromaFormat_enum {
111     cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
112     cudaVideoChromaFormat_420,           /**< 4:2:0 */
113     cudaVideoChromaFormat_422,           /**< 4:2:2 */
114     cudaVideoChromaFormat_444            /**< 4:4:4 */
115 } cudaVideoChromaFormat;
116
117 /*!
118  * \enum cudaVideoCreateFlags
119  * Decoder Flags Enums
120  */
121 typedef enum cudaVideoCreateFlags_enum {
122     cudaVideoCreate_Default = 0x00,     /**< Default operation mode: use dedicated video engines */
123     cudaVideoCreate_PreferCUDA = 0x01,  /**< Use a CUDA-based decoder if faster than dedicated engines (requires a valid vidLock object for multi-threading) */
124     cudaVideoCreate_PreferDXVA = 0x02,  /**< Go through DXVA internally if possible (requires D3D9 interop) */
125     cudaVideoCreate_PreferCUVID = 0x04  /**< Use dedicated video engines directly */
126 } cudaVideoCreateFlags;
127
128 /*!
129  * \struct CUVIDDECODECREATEINFO
130  * Struct used in create decoder
131  */
132 typedef struct _CUVIDDECODECREATEINFO
133 {
134     tcu_ulong ulWidth;                  /**< Coded Sequence Width */
135     tcu_ulong ulHeight;                 /**< Coded Sequence Height */
136     tcu_ulong ulNumDecodeSurfaces;      /**< Maximum number of internal decode surfaces */
137     cudaVideoCodec CodecType;           /**< cudaVideoCodec_XXX */
138     cudaVideoChromaFormat ChromaFormat; /**< cudaVideoChromaFormat_XXX (only 4:2:0 is currently supported) */
139     tcu_ulong ulCreationFlags;          /**< Decoder creation flags (cudaVideoCreateFlags_XXX) */
140     tcu_ulong bitDepthMinus8;
141     tcu_ulong Reserved1[4];             /**< Reserved for future use - set to zero */
142     /**
143     * area of the frame that should be displayed
144     */
145     struct {
146         short left;
147         short top;
148         short right;
149         short bottom;
150     } display_area;
151
152     cudaVideoSurfaceFormat OutputFormat;       /**< cudaVideoSurfaceFormat_XXX */
153     cudaVideoDeinterlaceMode DeinterlaceMode;  /**< cudaVideoDeinterlaceMode_XXX */
154     tcu_ulong ulTargetWidth;                   /**< Post-processed Output Width (Should be aligned to 2) */
155     tcu_ulong ulTargetHeight;                  /**< Post-processed Output Height (Should be aligbed to 2) */
156     tcu_ulong ulNumOutputSurfaces;             /**< Maximum number of output surfaces simultaneously mapped */
157     CUvideoctxlock vidLock;                    /**< If non-NULL, context lock used for synchronizing ownership of the cuda context */
158     /**
159     * target rectangle in the output frame (for aspect ratio conversion)
160     * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used
161     */
162     struct {
163         short left;
164         short top;
165         short right;
166         short bottom;
167     } target_rect;
168     tcu_ulong Reserved2[5];                    /**< Reserved for future use - set to zero */
169 } CUVIDDECODECREATEINFO;
170
171 /*!
172  * \struct CUVIDH264DPBENTRY
173  * H.264 DPB Entry
174  */
175 typedef struct _CUVIDH264DPBENTRY
176 {
177     int PicIdx;                 /**< picture index of reference frame */
178     int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term) */
179     int is_long_term;           /**< 0=short term reference, 1=long term reference */
180     int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */
181     int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields */
182     int FieldOrderCnt[2];       /**< field order count of top and bottom fields */
183 } CUVIDH264DPBENTRY;
184
185 /*!
186  * \struct CUVIDH264MVCEXT
187  * H.264 MVC Picture Parameters Ext
188  */
189 typedef struct _CUVIDH264MVCEXT
190 {
191     int num_views_minus1;
192     int view_id;
193     unsigned char inter_view_flag;
194     unsigned char num_inter_view_refs_l0;
195     unsigned char num_inter_view_refs_l1;
196     unsigned char MVCReserved8Bits;
197     int InterViewRefsL0[16];
198     int InterViewRefsL1[16];
199 } CUVIDH264MVCEXT;
200
201 /*!
202  * \struct CUVIDH264SVCEXT
203  * H.264 SVC Picture Parameters Ext
204  */
205 typedef struct _CUVIDH264SVCEXT
206 {
207     unsigned char profile_idc;
208     unsigned char level_idc;
209     unsigned char DQId;
210     unsigned char DQIdMax;
211     unsigned char disable_inter_layer_deblocking_filter_idc;
212     unsigned char ref_layer_chroma_phase_y_plus1;
213     signed char   inter_layer_slice_alpha_c0_offset_div2;
214     signed char   inter_layer_slice_beta_offset_div2;
215
216     unsigned short DPBEntryValidFlag;
217     unsigned char inter_layer_deblocking_filter_control_present_flag;
218     unsigned char extended_spatial_scalability_idc;
219     unsigned char adaptive_tcoeff_level_prediction_flag;
220     unsigned char slice_header_restriction_flag;
221     unsigned char chroma_phase_x_plus1_flag;
222     unsigned char chroma_phase_y_plus1;
223
224     unsigned char tcoeff_level_prediction_flag;
225     unsigned char constrained_intra_resampling_flag;
226     unsigned char ref_layer_chroma_phase_x_plus1_flag;
227     unsigned char store_ref_base_pic_flag;
228     unsigned char Reserved8BitsA;
229     unsigned char Reserved8BitsB;
230     // For the 4 scaled_ref_layer_XX fields below,
231     // if (extended_spatial_scalability_idc == 1), SPS field, G.7.3.2.1.4, add prefix "seq_"
232     // if (extended_spatial_scalability_idc == 2), SLH field, G.7.3.3.4,
233     short scaled_ref_layer_left_offset;
234     short scaled_ref_layer_top_offset;
235     short scaled_ref_layer_right_offset;
236     short scaled_ref_layer_bottom_offset;
237     unsigned short Reserved16Bits;
238     struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded. Linked list ends at the target layer. */
239     int bRefBaseLayer;                  /**< whether to store ref base pic */
240 } CUVIDH264SVCEXT;
241
242 /*!
243  * \struct CUVIDH264PICPARAMS
244  * H.264 Picture Parameters
245  */
246 typedef struct _CUVIDH264PICPARAMS
247 {
248     // SPS
249     int log2_max_frame_num_minus4;
250     int pic_order_cnt_type;
251     int log2_max_pic_order_cnt_lsb_minus4;
252     int delta_pic_order_always_zero_flag;
253     int frame_mbs_only_flag;
254     int direct_8x8_inference_flag;
255     int num_ref_frames;             // NOTE: shall meet level 4.1 restrictions
256     unsigned char residual_colour_transform_flag;
257     unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)
258     unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)
259     unsigned char qpprime_y_zero_transform_bypass_flag;
260     // PPS
261     int entropy_coding_mode_flag;
262     int pic_order_present_flag;
263     int num_ref_idx_l0_active_minus1;
264     int num_ref_idx_l1_active_minus1;
265     int weighted_pred_flag;
266     int weighted_bipred_idc;
267     int pic_init_qp_minus26;
268     int deblocking_filter_control_present_flag;
269     int redundant_pic_cnt_present_flag;
270     int transform_8x8_mode_flag;
271     int MbaffFrameFlag;
272     int constrained_intra_pred_flag;
273     int chroma_qp_index_offset;
274     int second_chroma_qp_index_offset;
275     int ref_pic_flag;
276     int frame_num;
277     int CurrFieldOrderCnt[2];
278     // DPB
279     CUVIDH264DPBENTRY dpb[16];          // List of reference frames within the DPB
280     // Quantization Matrices (raster-order)
281     unsigned char WeightScale4x4[6][16];
282     unsigned char WeightScale8x8[2][64];
283     // FMO/ASO
284     unsigned char fmo_aso_enable;
285     unsigned char num_slice_groups_minus1;
286     unsigned char slice_group_map_type;
287     signed char pic_init_qs_minus26;
288     unsigned int slice_group_change_rate_minus1;
289     union
290     {
291         unsigned long long slice_group_map_addr;
292         const unsigned char *pMb2SliceGroupMap;
293     } fmo;
294     unsigned int  Reserved[12];
295     // SVC/MVC
296     union
297     {
298         CUVIDH264MVCEXT mvcext;
299         CUVIDH264SVCEXT svcext;
300     } svcmvc;
301 } CUVIDH264PICPARAMS;
302
303
304 /*!
305  * \struct CUVIDMPEG2PICPARAMS
306  * MPEG-2 Picture Parameters
307  */
308 typedef struct _CUVIDMPEG2PICPARAMS
309 {
310     int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
311     int BackwardRefIdx;         // Picture index of backward reference (B-frames)
312     int picture_coding_type;
313     int full_pel_forward_vector;
314     int full_pel_backward_vector;
315     int f_code[2][2];
316     int intra_dc_precision;
317     int frame_pred_frame_dct;
318     int concealment_motion_vectors;
319     int q_scale_type;
320     int intra_vlc_format;
321     int alternate_scan;
322     int top_field_first;
323     // Quantization matrices (raster order)
324     unsigned char QuantMatrixIntra[64];
325     unsigned char QuantMatrixInter[64];
326 } CUVIDMPEG2PICPARAMS;
327
328 ////////////////////////////////////////////////////////////////////////////////////////////////
329 //
330 // MPEG-4 Picture Parameters
331 //
332
333 // MPEG-4 has VOP types instead of Picture types
334 #define I_VOP 0
335 #define P_VOP 1
336 #define B_VOP 2
337 #define S_VOP 3
338
339 /*!
340  * \struct CUVIDMPEG4PICPARAMS
341  * MPEG-4 Picture Parameters
342  */
343 typedef struct _CUVIDMPEG4PICPARAMS
344 {
345     int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
346     int BackwardRefIdx;         // Picture index of backward reference (B-frames)
347     // VOL
348     int video_object_layer_width;
349     int video_object_layer_height;
350     int vop_time_increment_bitcount;
351     int top_field_first;
352     int resync_marker_disable;
353     int quant_type;
354     int quarter_sample;
355     int short_video_header;
356     int divx_flags;
357     // VOP
358     int vop_coding_type;
359     int vop_coded;
360     int vop_rounding_type;
361     int alternate_vertical_scan_flag;
362     int interlaced;
363     int vop_fcode_forward;
364     int vop_fcode_backward;
365     int trd[2];
366     int trb[2];
367     // Quantization matrices (raster order)
368     unsigned char QuantMatrixIntra[64];
369     unsigned char QuantMatrixInter[64];
370     int gmc_enabled;
371 } CUVIDMPEG4PICPARAMS;
372
373 /*!
374  * \struct CUVIDVC1PICPARAMS
375  * VC1 Picture Parameters
376  */
377 typedef struct _CUVIDVC1PICPARAMS
378 {
379     int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */
380     int BackwardRefIdx;     /**< Picture index of backward reference (B-frames) */
381     int FrameWidth;         /**< Actual frame width */
382     int FrameHeight;        /**< Actual frame height */
383     // PICTURE
384     int intra_pic_flag;     /**< Set to 1 for I,BI frames */
385     int ref_pic_flag;       /**< Set to 1 for I,P frames */
386     int progressive_fcm;    /**< Progressive frame */
387     // SEQUENCE
388     int profile;
389     int postprocflag;
390     int pulldown;
391     int interlace;
392     int tfcntrflag;
393     int finterpflag;
394     int psf;
395     int multires;
396     int syncmarker;
397     int rangered;
398     int maxbframes;
399     // ENTRYPOINT
400     int panscan_flag;
401     int refdist_flag;
402     int extended_mv;
403     int dquant;
404     int vstransform;
405     int loopfilter;
406     int fastuvmc;
407     int overlap;
408     int quantizer;
409     int extended_dmv;
410     int range_mapy_flag;
411     int range_mapy;
412     int range_mapuv_flag;
413     int range_mapuv;
414     int rangeredfrm;    // range reduction state
415 } CUVIDVC1PICPARAMS;
416
417 /*!
418  * \struct CUVIDJPEGPICPARAMS
419  * JPEG Picture Parameters
420  */
421 typedef struct _CUVIDJPEGPICPARAMS
422 {
423     int Reserved;
424 } CUVIDJPEGPICPARAMS;
425
426
427  /*!
428  * \struct CUVIDHEVCPICPARAMS
429  * HEVC Picture Parameters
430  */
431 typedef struct _CUVIDHEVCPICPARAMS
432 {
433     // sps
434     int pic_width_in_luma_samples;
435     int pic_height_in_luma_samples;
436     unsigned char log2_min_luma_coding_block_size_minus3;
437     unsigned char log2_diff_max_min_luma_coding_block_size;
438     unsigned char log2_min_transform_block_size_minus2;
439     unsigned char log2_diff_max_min_transform_block_size;
440     unsigned char pcm_enabled_flag;
441     unsigned char log2_min_pcm_luma_coding_block_size_minus3;
442     unsigned char log2_diff_max_min_pcm_luma_coding_block_size;
443     unsigned char pcm_sample_bit_depth_luma_minus1;
444
445     unsigned char pcm_sample_bit_depth_chroma_minus1;
446     unsigned char pcm_loop_filter_disabled_flag;
447     unsigned char strong_intra_smoothing_enabled_flag;
448     unsigned char max_transform_hierarchy_depth_intra;
449     unsigned char max_transform_hierarchy_depth_inter;
450     unsigned char amp_enabled_flag;
451     unsigned char separate_colour_plane_flag;
452     unsigned char log2_max_pic_order_cnt_lsb_minus4;
453
454     unsigned char num_short_term_ref_pic_sets;
455     unsigned char long_term_ref_pics_present_flag;
456     unsigned char num_long_term_ref_pics_sps;
457     unsigned char sps_temporal_mvp_enabled_flag;
458     unsigned char sample_adaptive_offset_enabled_flag;
459     unsigned char scaling_list_enable_flag;
460     unsigned char IrapPicFlag;
461     unsigned char IdrPicFlag;
462
463     unsigned char bit_depth_luma_minus8;
464     unsigned char bit_depth_chroma_minus8;
465     unsigned char reserved1[14];
466
467     // pps
468     unsigned char dependent_slice_segments_enabled_flag;
469     unsigned char slice_segment_header_extension_present_flag;
470     unsigned char sign_data_hiding_enabled_flag;
471     unsigned char cu_qp_delta_enabled_flag;
472     unsigned char diff_cu_qp_delta_depth;
473     signed char init_qp_minus26;
474     signed char pps_cb_qp_offset;
475     signed char pps_cr_qp_offset;
476
477     unsigned char constrained_intra_pred_flag;
478     unsigned char weighted_pred_flag;
479     unsigned char weighted_bipred_flag;
480     unsigned char transform_skip_enabled_flag;
481     unsigned char transquant_bypass_enabled_flag;
482     unsigned char entropy_coding_sync_enabled_flag;
483     unsigned char log2_parallel_merge_level_minus2;
484     unsigned char num_extra_slice_header_bits;
485
486     unsigned char loop_filter_across_tiles_enabled_flag;
487     unsigned char loop_filter_across_slices_enabled_flag;
488     unsigned char output_flag_present_flag;
489     unsigned char num_ref_idx_l0_default_active_minus1;
490     unsigned char num_ref_idx_l1_default_active_minus1;
491     unsigned char lists_modification_present_flag;
492     unsigned char cabac_init_present_flag;
493     unsigned char pps_slice_chroma_qp_offsets_present_flag;
494
495     unsigned char deblocking_filter_override_enabled_flag;
496     unsigned char pps_deblocking_filter_disabled_flag;
497     signed char pps_beta_offset_div2;
498     signed char pps_tc_offset_div2;
499     unsigned char tiles_enabled_flag;
500     unsigned char uniform_spacing_flag;
501     unsigned char num_tile_columns_minus1;
502     unsigned char num_tile_rows_minus1;
503
504     unsigned short column_width_minus1[21];
505     unsigned short row_height_minus1[21];
506     unsigned int reserved3[15];
507
508     // RefPicSets
509     int NumBitsForShortTermRPSInSlice;
510     int NumDeltaPocsOfRefRpsIdx;
511     int NumPocTotalCurr;
512     int NumPocStCurrBefore;
513     int NumPocStCurrAfter;
514     int NumPocLtCurr;
515     int CurrPicOrderCntVal;
516     int RefPicIdx[16];                  // [refpic] Indices of valid reference pictures (-1 if unused for reference)
517     int PicOrderCntVal[16];             // [refpic]
518     unsigned char IsLongTerm[16];       // [refpic] 0=not a long-term reference, 1=long-term reference
519     unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)
520     unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)
521     unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)
522     unsigned char RefPicSetInterLayer0[8];
523     unsigned char RefPicSetInterLayer1[8];
524     unsigned int reserved4[12];
525
526     // scaling lists (diag order)
527     unsigned char ScalingList4x4[6][16];       // [matrixId][i]
528     unsigned char ScalingList8x8[6][64];       // [matrixId][i]
529     unsigned char ScalingList16x16[6][64];     // [matrixId][i]
530     unsigned char ScalingList32x32[2][64];     // [matrixId][i]
531     unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]
532     unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]
533 } CUVIDHEVCPICPARAMS;
534
535
536 /*!
537  * \struct CUVIDVP8PICPARAMS
538  * VP8 Picture Parameters
539  */
540 typedef struct _CUVIDVP8PICPARAMS
541 {
542     int width;
543     int height;
544     unsigned int first_partition_size;
545     //Frame Indexes
546     unsigned char LastRefIdx;
547     unsigned char GoldenRefIdx;
548     unsigned char AltRefIdx;
549     union {
550         struct {
551             unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */
552             unsigned char version : 3;
553             unsigned char show_frame : 1;
554             unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */
555             unsigned char Reserved2Bits : 2;
556         };
557         unsigned char wFrameTagFlags;
558     } tagflags;
559     unsigned char Reserved1[4];
560     unsigned int  Reserved2[3];
561 } CUVIDVP8PICPARAMS;
562
563 /*!
564  * \struct CUVIDVP9PICPARAMS
565  * VP9 Picture Parameters
566  */
567 typedef struct _CUVIDVP9PICPARAMS
568 {
569     unsigned int width;
570     unsigned int height;
571
572     //Frame Indices
573     unsigned char LastRefIdx;
574     unsigned char GoldenRefIdx;
575     unsigned char AltRefIdx;
576     unsigned char colorSpace;
577
578     unsigned short profile : 3;
579     unsigned short frameContextIdx : 2;
580     unsigned short frameType : 1;
581     unsigned short showFrame : 1;
582     unsigned short errorResilient : 1;
583     unsigned short frameParallelDecoding : 1;
584     unsigned short subSamplingX : 1;
585     unsigned short subSamplingY : 1;
586     unsigned short intraOnly : 1;
587     unsigned short allow_high_precision_mv : 1;
588     unsigned short refreshEntropyProbs : 1;
589     unsigned short reserved2Bits : 2;
590
591     unsigned short reserved16Bits;
592
593     unsigned char  refFrameSignBias[4];
594
595     unsigned char bitDepthMinus8Luma;
596     unsigned char bitDepthMinus8Chroma;
597     unsigned char loopFilterLevel;
598     unsigned char loopFilterSharpness;
599
600     unsigned char modeRefLfEnabled;
601     unsigned char log2_tile_columns;
602     unsigned char log2_tile_rows;
603
604     unsigned char segmentEnabled : 1;
605     unsigned char segmentMapUpdate : 1;
606     unsigned char segmentMapTemporalUpdate : 1;
607     unsigned char segmentFeatureMode : 1;
608     unsigned char reserved4Bits : 4;
609
610
611     unsigned char segmentFeatureEnable[8][4];
612     short segmentFeatureData[8][4];
613     unsigned char mb_segment_tree_probs[7];
614     unsigned char segment_pred_probs[3];
615     unsigned char reservedSegment16Bits[2];
616
617     int qpYAc;
618     int qpYDc;
619     int qpChDc;
620     int qpChAc;
621
622     unsigned int activeRefIdx[3];
623     unsigned int resetFrameContext;
624     unsigned int mcomp_filter_type;
625     unsigned int mbRefLfDelta[4];
626     unsigned int mbModeLfDelta[2];
627     unsigned int frameTagSize;
628     unsigned int offsetToDctParts;
629     unsigned int reserved128Bits[4];
630
631 } CUVIDVP9PICPARAMS;
632
633
634 /*!
635  * \struct CUVIDPICPARAMS
636  * Picture Parameters for Decoding
637  */
638 typedef struct _CUVIDPICPARAMS
639 {
640     int PicWidthInMbs;                    /**< Coded Frame Size */
641     int FrameHeightInMbs;                 /**< Coded Frame Height */
642     int CurrPicIdx;                       /**< Output index of the current picture */
643     int field_pic_flag;                   /**< 0=frame picture, 1=field picture */
644     int bottom_field_flag;                /**< 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
645     int second_field;                     /**< Second field of a complementary field pair */
646     // Bitstream data
647     unsigned int nBitstreamDataLen;        /**< Number of bytes in bitstream data buffer */
648     const unsigned char *pBitstreamData;   /**< Ptr to bitstream data for this picture (slice-layer) */
649     unsigned int nNumSlices;               /**< Number of slices in this picture */
650     const unsigned int *pSliceDataOffsets; /**< nNumSlices entries, contains offset of each slice within the bitstream data buffer */
651     int ref_pic_flag;                      /**< This picture is a reference picture */
652     int intra_pic_flag;                    /**< This picture is entirely intra coded */
653     unsigned int Reserved[30];             /**< Reserved for future use */
654     // Codec-specific data
655     union {
656         CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */
657         CUVIDH264PICPARAMS h264;
658         CUVIDVC1PICPARAMS vc1;
659         CUVIDMPEG4PICPARAMS mpeg4;
660         CUVIDJPEGPICPARAMS jpeg;
661         CUVIDHEVCPICPARAMS hevc;
662         CUVIDVP8PICPARAMS vp8;
663         CUVIDVP9PICPARAMS vp9;
664         unsigned int CodecReserved[1024];
665     } CodecSpecific;
666 } CUVIDPICPARAMS;
667
668
669 /*!
670  * \struct CUVIDPROCPARAMS
671  * Picture Parameters for Postprocessing
672  */
673 typedef struct _CUVIDPROCPARAMS
674 {
675     int progressive_frame;  /**< Input is progressive (deinterlace_mode will be ignored)  */
676     int second_field;       /**< Output the second field (ignored if deinterlace mode is Weave) */
677     int top_field_first;    /**< Input frame is top field first (1st field is top, 2nd field is bottom) */
678     int unpaired_field;     /**< Input only contains one field (2nd field is invalid) */
679     // The fields below are used for raw YUV input
680     unsigned int reserved_flags;        /**< Reserved for future use (set to zero) */
681     unsigned int reserved_zero;         /**< Reserved (set to zero) */
682     unsigned long long raw_input_dptr;  /**< Input CUdeviceptr for raw YUV extensions */
683     unsigned int raw_input_pitch;       /**< pitch in bytes of raw YUV input (should be aligned appropriately) */
684     unsigned int raw_input_format;      /**< Reserved for future use (set to zero) */
685     unsigned long long raw_output_dptr; /**< Reserved for future use (set to zero) */
686     unsigned int raw_output_pitch;      /**< Reserved for future use (set to zero) */
687     unsigned int Reserved[48];
688     void *Reserved3[3];
689 } CUVIDPROCPARAMS;
690
691
692 /**
693  *
694  * In order to minimize decode latencies, there should be always at least 2 pictures in the decode
695  * queue at any time, in order to make sure that all decode engines are always busy.
696  *
697  * Overall data flow:
698  *  - cuvidCreateDecoder(...)
699  *  For each picture:
700  *  - cuvidDecodePicture(N)
701  *  - cuvidMapVideoFrame(N-4)
702  *  - do some processing in cuda
703  *  - cuvidUnmapVideoFrame(N-4)
704  *  - cuvidDecodePicture(N+1)
705  *  - cuvidMapVideoFrame(N-3)
706  *    ...
707  *  - cuvidDestroyDecoder(...)
708  *
709  * NOTE:
710  * - When the cuda context is created from a D3D device, the D3D device must also be created
711  *   with the D3DCREATE_MULTITHREADED flag.
712  * - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)
713  * - cuVidDecodePicture may block the calling thread if there are too many pictures pending
714  *   in the decode queue
715  */
716
717 /**
718  * \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
719  * Create the decoder object
720  */
721 typedef CUresult CUDAAPI tcuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
722
723 /**
724  * \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
725  * Destroy the decoder object
726  */
727 typedef CUresult CUDAAPI tcuvidDestroyDecoder(CUvideodecoder hDecoder);
728
729 /**
730  * \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
731  * Decode a single picture (field or frame)
732  */
733 typedef CUresult CUDAAPI tcuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
734
735
736 #if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)
737 /**
738  * \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
739  * Post-process and map a video frame for use in cuda
740  */
741 typedef CUresult CUDAAPI tcuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,
742                                              unsigned int *pDevPtr, unsigned int *pPitch,
743                                              CUVIDPROCPARAMS *pVPP);
744
745 /**
746  * \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)
747  * Unmap a previously mapped video frame
748  */
749 typedef CUresult CUDAAPI tcuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
750 #endif
751
752 #if defined(WIN64) || defined(_WIN64) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
753 /**
754  * \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
755  * map a video frame
756  */
757 typedef CUresult CUDAAPI tcuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
758                                                unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
759
760 /**
761  * \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
762  * Unmap a previously mapped video frame
763  */
764 typedef CUresult CUDAAPI tcuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
765
766 #if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
767 #define tcuvidMapVideoFrame      tcuvidMapVideoFrame64
768 #define tcuvidUnmapVideoFrame    tcuvidUnmapVideoFrame64
769 #endif
770 #endif
771
772
773 /**
774  *
775  * Context-locking: to facilitate multi-threaded implementations, the following 4 functions
776  * provide a simple mutex-style host synchronization. If a non-NULL context is specified
777  * in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given
778  * context before making any cuda calls.
779  * A multi-threaded application could create a lock associated with a context handle so that
780  * multiple threads can safely share the same cuda context:
781  *  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context
782  *    that can be passed to cuvidCtxLockCreate.
783  *  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.
784  *
785  * NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video
786  * decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).
787 */
788
789 /**
790  * \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)
791  */
792 typedef CUresult CUDAAPI tcuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
793
794 /**
795  * \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
796  */
797 typedef CUresult CUDAAPI tcuvidCtxLockDestroy(CUvideoctxlock lck);
798
799 /**
800  * \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
801  */
802 typedef CUresult CUDAAPI tcuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
803
804 /**
805  * \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
806  */
807 typedef CUresult CUDAAPI tcuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
808
809 /** @} */  /* End VIDEO_DECODER */
810
811 #if defined(__cplusplus)
812 }
813 #endif /* __cplusplus */
814
815 #endif // __CUDA_VIDEO_H__