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