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