nvmedia_common.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017-2018 NVIDIA CORPORATION. All rights reserved. All
 * information contained herein is proprietary and confidential to NVIDIA
 * Corporation.  Any use, reproduction, or disclosure without the written
 * permission of NVIDIA Corporation is prohibited.
 */


#ifndef _NVMEDIA_COMMON_H
#define _NVMEDIA_COMMON_H

#ifdef __cplusplus
extern "C" {
#endif

#include "nvmedia_core.h"

#define NVMEDIA_COMMON_VERSION_MAJOR   1

#define NVMEDIA_COMMON_VERSION_MINOR   21

#define NVMEDIA_MIN_CAPTURE_FRAME_BUFFERS   2u

#define NVMEDIA_MAX_CAPTURE_FRAME_BUFFERS   32u

typedef enum  {
    NVMEDIA_DECODER_INSTANCE_0 = 0,
    NVMEDIA_DECODER_INSTANCE_1,
    NVMEDIA_DECODER_INSTANCE_AUTO,
} NvMediaDecoderInstanceId;

typedef enum {
    NVMEDIA_ENCODER_INSTANCE_0 = 0,
    NVMEDIA_ENCODER_INSTANCE_1,
    NVMEDIA_ENCODER_INSTANCE_AUTO,
} NvMediaEncoderInstanceId;

typedef enum {
    NVMEDIA_VIDEO_CODEC_H264,
    NVMEDIA_VIDEO_CODEC_VC1,
    NVMEDIA_VIDEO_CODEC_VC1_ADVANCED,
    NVMEDIA_VIDEO_CODEC_MPEG1,
    NVMEDIA_VIDEO_CODEC_MPEG2,
    NVMEDIA_VIDEO_CODEC_MPEG4,
    NVMEDIA_VIDEO_CODEC_MJPEG,
    NVMEDIA_VIDEO_CODEC_VP8,
    NVMEDIA_VIDEO_CODEC_HEVC,
    NVMEDIA_VIDEO_CODEC_VP9,
    NVMEDIA_VIDEO_CODEC_H264_MVC,
    NVMEDIA_VIDEO_CODEC_HEVC_MV,
} NvMediaVideoCodec;

typedef struct {
    uint8_t *bitstream;
    uint32_t bitstreamBytes;
    uint32_t bitstreamSize;
} NvMediaBitstreamBuffer;

enum
{
    NVMEDIA_SLH_PRESENT = 0x1,
    NVMEDIA_SPS_PRESENT = 0x2,
    NVMEDIA_PPS_PRESENT = 0x4
};

typedef void NvMediaPictureInfo;

typedef void NvMediaRefSurface;

typedef struct {
    NvMediaRefSurface   *surface;
    NvMediaBool         is_long_term;
    NvMediaBool         top_is_reference;
    NvMediaBool         bottom_is_reference;
    int32_t                 field_order_cnt[2];
    uint16_t     FrameIdx;

    uint16_t     not_existing;
} NvMediaReferenceFrameH264;

#define MAX_USER_SEI_PAYLOAD    128

typedef struct {
    uint8_t frame_packing_arrangement_type;
    uint8_t quincunx_sampling_flag;
    uint8_t content_interpretation_flag;
    uint8_t spatial_flipping_flag;
    uint8_t frame0_flipped_flag;
    uint8_t field_views_flag;
    uint8_t current_frame_is_frame0_flag;
    NvMediaBool bStereoEnabled;
    uint32_t uUserSeiPayloadLength;
    uint8_t UserDefinedSeiPayload[MAX_USER_SEI_PAYLOAD];
} NvMediaSEIPayloadH264;

typedef struct {
    int32_t            field_order_cnt[2];
    NvMediaBool    is_reference;

    uint16_t chroma_format_idc;
    uint16_t frame_num;
    uint8_t  field_pic_flag;
    uint8_t  bottom_field_flag;
    uint8_t  num_ref_frames;
    uint8_t  mb_adaptive_frame_field_flag;
    uint8_t  constrained_intra_pred_flag;
    uint8_t  weighted_pred_flag;
    uint8_t  weighted_bipred_idc;
    uint8_t  frame_mbs_only_flag;
    uint8_t  transform_8x8_mode_flag;
    int8_t           chroma_qp_index_offset;
    int8_t           second_chroma_qp_index_offset;
    int8_t           pic_init_qp_minus26;
    uint8_t  num_ref_idx_l0_active_minus1;
    uint8_t  num_ref_idx_l1_active_minus1;
    uint8_t  log2_max_frame_num_minus4;
    uint8_t  pic_order_cnt_type;
    uint8_t  log2_max_pic_order_cnt_lsb_minus4;
    uint8_t  delta_pic_order_always_zero_flag;
    uint8_t  direct_8x8_inference_flag;
    uint8_t  entropy_coding_mode_flag;
    uint8_t  pic_order_present_flag;
    uint8_t  deblocking_filter_control_present_flag;
    uint8_t  redundant_pic_cnt_present_flag;
    uint8_t  num_slice_groups_minus1;
    uint8_t  slice_group_map_type;
    uint32_t   slice_group_change_rate_minus1;
    uint8_t *slice_group_map;
    uint8_t fmo_aso_enable;
    uint8_t scaling_matrix_present;

    uint8_t  scaling_lists_4x4[6][16];
    uint8_t  scaling_lists_8x8[2][64];

    NvMediaReferenceFrameH264 referenceFrames[16];
    uint32_t nNumSlices;
    uint32_t *pSliceDataOffsets;
    uint8_t frameType;

    struct {
        uint16_t num_views_minus1;
        uint16_t view_id;
        uint8_t inter_view_flag;
        uint8_t num_inter_view_refs_l0;
        uint8_t num_inter_view_refs_l1;
        uint8_t MVCReserved8Bits;
        uint16_t InterViewRefsL0[16];
        uint16_t InterViewRefsL1[16];
    } mvcext;

    NvMediaSEIPayloadH264 seiPayloadInfo;
    uint32_t pic_width_in_mbs_minus1;
    uint32_t pic_height_in_map_units_minus1;
    int32_t last_sps_id;
    int32_t last_pps_id;
    int32_t qpprime_y_zero_transform_bypass_flag;
} NvMediaPictureInfoH264;

typedef struct
{
    uint16_t display_primaries_x[3];
    uint16_t display_primaries_y[3];
    uint16_t white_point_x;
    uint16_t white_point_y;
    uint32_t max_display_parameter_luminance;
    uint32_t min_display_parameter_luminance;
} NvMediaMasteringDisplayData;


typedef struct
{
    uint32_t uBitstreamDataLen;
    uint8_t *pBitstreamData;
    uint32_t uNumSlices;
    uint32_t *pSliceDataOffsets;
    uint32_t uCTBCount;
    uint32_t uFirstCtbAddr;
    NvMediaBool bFirstSlice;
    NvMediaBool bLastSlice;
    NvMediaBool bErrorFlag;
} NvMediaSliceDecodeData;

typedef struct {
    // sps
    uint32_t pic_width_in_luma_samples;
    uint32_t pic_height_in_luma_samples;
    uint8_t log2_min_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_luma_coding_block_size;
    uint8_t log2_min_transform_block_size_minus2;
    uint8_t log2_diff_max_min_transform_block_size;
    uint8_t pcm_enabled_flag;
    uint8_t log2_min_pcm_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_pcm_luma_coding_block_size;
    uint8_t bit_depth_luma;
    uint8_t bit_depth_chroma;
    uint8_t pcm_sample_bit_depth_luma_minus1;
    uint8_t pcm_sample_bit_depth_chroma_minus1;
    uint8_t pcm_loop_filter_disabled_flag;
    uint8_t strong_intra_smoothing_enabled_flag;
    uint8_t max_transform_hierarchy_depth_intra;
    uint8_t max_transform_hierarchy_depth_inter;
    uint8_t amp_enabled_flag;
    uint8_t separate_colour_plane_flag;
    uint8_t log2_max_pic_order_cnt_lsb_minus4;
    uint8_t num_short_term_ref_pic_sets;
    uint8_t long_term_ref_pics_present_flag;
    uint8_t num_long_term_ref_pics_sps;
    uint8_t sps_temporal_mvp_enabled_flag;
    uint8_t sample_adaptive_offset_enabled_flag;
    uint8_t scaling_list_enable_flag;
    uint8_t chroma_format_idc;
    uint8_t reserved1[3];

    // pps
    uint8_t dependent_slice_segments_enabled_flag;
    uint8_t slice_segment_header_extension_present_flag;
    uint8_t sign_data_hiding_enabled_flag;
    uint8_t cu_qp_delta_enabled_flag;
    uint8_t diff_cu_qp_delta_depth;
    int8_t init_qp_minus26;
    int8_t pps_cb_qp_offset;
    int8_t pps_cr_qp_offset;

    uint8_t constrained_intra_pred_flag;
    uint8_t weighted_pred_flag;
    uint8_t weighted_bipred_flag;
    uint8_t transform_skip_enabled_flag;
    uint8_t transquant_bypass_enabled_flag;
    uint8_t entropy_coding_sync_enabled_flag;
    uint8_t log2_parallel_merge_level_minus2;
    uint8_t num_extra_slice_header_bits;

    uint8_t loop_filter_across_tiles_enabled_flag;
    uint8_t loop_filter_across_slices_enabled_flag;
    uint8_t output_flag_present_flag;
    uint8_t num_ref_idx_l0_default_active_minus1;
    uint8_t num_ref_idx_l1_default_active_minus1;
    uint8_t lists_modification_present_flag;
    uint8_t cabac_init_present_flag;
    uint8_t pps_slice_chroma_qp_offsets_present_flag;

    uint8_t deblocking_filter_control_present_flag;
    uint8_t deblocking_filter_override_enabled_flag;
    uint8_t pps_deblocking_filter_disabled_flag;
    int8_t pps_beta_offset_div2;
    int8_t pps_tc_offset_div2;
    uint8_t tiles_enabled_flag;
    uint8_t uniform_spacing_flag;
    uint8_t num_tile_columns_minus1;
    uint8_t num_tile_rows_minus1;

    uint16_t column_width_minus1[22];
    uint16_t row_height_minus1[20];

    // RefPicSets
    uint32_t iCur;
    uint32_t IDRPicFlag;
    uint32_t RAPPicFlag;
    uint32_t NumDeltaPocsOfRefRpsIdx;
    uint32_t NumPocTotalCurr;
    uint32_t NumPocStCurrBefore;
    uint32_t NumPocStCurrAfter;
    uint32_t NumPocLtCurr;
    uint32_t NumBitsToSkip;
    int32_t CurrPicOrderCntVal;
    NvMediaRefSurface *RefPics[16];
    int32_t PicOrderCntVal[16];
    uint8_t IsLongTerm[16];
    int8_t RefPicSetStCurrBefore[8];
    int8_t RefPicSetStCurrAfter[8];
    int8_t RefPicSetLtCurr[8];

    // scaling lists (diag order)
    uint8_t ScalingList4x4[6][16];
    uint8_t ScalingList8x8[6][64];
    uint8_t ScalingList16x16[6][64];
    uint8_t ScalingList32x32[2][64];
    uint8_t ScalingListDCCoeff16x16[6];
    uint8_t ScalingListDCCoeff32x32[2];

    uint32_t NumDeltaPocs[64];

    uint8_t sps_range_extension_present_flag;
    // sps extension HEVC-main 444
    uint8_t transformSkipRotationEnableFlag;
    uint8_t transformSkipContextEnableFlag;
    uint8_t implicitRdpcmEnableFlag;
    uint8_t explicitRdpcmEnableFlag;
    uint8_t extendedPrecisionProcessingFlag;
    uint8_t intraSmoothingDisabledFlag;
    uint8_t highPrecisionOffsetsEnableFlag;
    uint8_t fastRiceAdaptationEnableFlag;
    uint8_t cabacBypassAlignmentEnableFlag;
    uint8_t intraBlockCopyEnableFlag;

    uint8_t pps_range_extension_present_flag;
    // pps extension HEVC-main 444
    uint8_t log2MaxTransformSkipSize;
    uint8_t crossComponentPredictionEnableFlag;
    uint8_t chromaQpAdjustmentEnableFlag;
    uint8_t diffCuChromaQpAdjustmentDepth;
    uint8_t chromaQpAdjustmentTableSize;
    uint8_t log2SaoOffsetScaleLuma;
    uint8_t log2SaoOffsetScaleChroma;
    int8_t cb_qp_adjustment[6];
    int8_t cr_qp_adjustment[6];
    uint8_t reserved2;
    uint8_t frameType;

    uint8_t masterin_display_data_present;
    NvMediaMasteringDisplayData MasteringDispData;
    NvMediaBool  bSliceDecEnable;
    NvMediaSliceDecodeData sliceDecData;

    struct {
        uint32_t mv_hevc_enable;
        uint32_t nuh_layer_id;
        uint32_t default_ref_layers_active_flag;
        uint32_t NumDirectRefLayers;
        uint32_t max_one_active_ref_layer_flag;
        uint32_t NumActiveRefLayerPics;
        uint32_t poc_lsb_not_present_flag;
        uint32_t  NumActiveRefLayerPics0;
        uint32_t  NumActiveRefLayerPics1;
        int32_t  RefPicSetInterLayer0[32];
        int32_t  RefPicSetInterLayer1[32];
    } mvext;
} NvMediaPictureInfoH265;
typedef struct {
    NvMediaRefSurface *forward_reference;
    NvMediaRefSurface *backward_reference;

    uint8_t picture_structure;
    uint8_t picture_coding_type;
    uint8_t intra_dc_precision;
    uint8_t frame_pred_frame_dct;
    uint8_t concealment_motion_vectors;
    uint8_t intra_vlc_format;
    uint8_t alternate_scan;
    uint8_t q_scale_type;
    uint8_t top_field_first;
    uint8_t full_pel_forward_vector;
    uint8_t full_pel_backward_vector;
    uint8_t f_code[2][2];
    uint8_t intra_quantizer_matrix[64];
    uint8_t non_intra_quantizer_matrix[64];
    uint32_t nNumSlices;
    uint32_t *pSliceDataOffsets;
    uint8_t flag_slices_across_multiple_rows;
} NvMediaPictureInfoMPEG1Or2;

typedef struct {
    NvMediaRefSurface *forward_reference;
    NvMediaRefSurface *backward_reference;

    int32_t            trd[2];
    int32_t            trb[2];
    uint16_t vop_time_increment_resolution;
    uint32_t   vop_time_increment_bitcount;
    uint8_t  vop_coding_type;
    uint8_t  vop_fcode_forward;
    uint8_t  vop_fcode_backward;
    uint8_t  resync_marker_disable;
    uint8_t  interlaced;
    uint8_t  quant_type;
    uint8_t  quarter_sample;
    uint8_t  short_video_header;
    uint8_t  rounding_control;
    uint8_t  alternate_vertical_scan_flag;
    uint8_t  top_field_first;
    uint8_t  intra_quantizer_matrix[64];
    uint8_t  non_intra_quantizer_matrix[64];
    uint8_t  data_partitioned;
    uint8_t  reversible_vlc;
    uint32_t nNumSlices;
    uint32_t *pSliceDataOffsets;

    uint16_t video_object_layer_width;
    uint16_t video_object_layer_height;
    uint32_t divx_flags;
    NvMediaBool bGMCConceal;
} NvMediaPictureInfoMPEG4Part2;

typedef struct {
    NvMediaRefSurface *forward_reference;
    NvMediaRefSurface *backward_reference;
    NvMediaRefSurface *range_mapped;

    uint8_t  picture_type;
    uint8_t  frame_coding_mode;
    uint8_t  bottom_field_flag;


    uint8_t postprocflag;
    uint8_t pulldown;
    uint8_t interlace;
    uint8_t tfcntrflag;
    uint8_t finterpflag;
    uint8_t psf;
    uint8_t dquant;
    uint8_t panscan_flag;
    uint8_t refdist_flag;
    uint8_t quantizer;
    uint8_t extended_mv;
    uint8_t extended_dmv;
    uint8_t overlap;
    uint8_t vstransform;
    uint8_t loopfilter;
    uint8_t fastuvmc;
    uint8_t range_mapy_flag;
    uint8_t range_mapy;
    uint8_t range_mapuv_flag;
    uint8_t range_mapuv;

    uint8_t multires;
    uint8_t syncmarker;
    uint8_t rangered;
    uint8_t rangeredfrm;
    uint8_t maxbframes;
    uint32_t nNumSlices;
    uint32_t *pSliceDataOffsets;

    uint8_t profile;
    uint16_t frameWidth;
    uint16_t frameHeight;
} NvMediaPictureInfoVC1;
typedef struct {
    NvMediaRefSurface *LastReference;
    NvMediaRefSurface *GoldenReference;
    NvMediaRefSurface *AltReference;
    uint8_t key_frame;
    uint8_t version;
    uint8_t show_frame;
    uint8_t clamp_type;
    uint8_t segmentation_enabled;
    uint8_t update_mb_seg_map;
    uint8_t update_mb_seg_data;
    uint8_t update_mb_seg_abs;
    uint8_t filter_type;
    uint8_t loop_filter_level;
    uint8_t sharpness_level;
    uint8_t mode_ref_lf_delta_enabled;
    uint8_t mode_ref_lf_delta_update;
    uint8_t num_of_partitions;
    uint8_t dequant_index;
    int8_t deltaq[5];

    uint8_t golden_ref_frame_sign_bias;
    uint8_t alt_ref_frame_sign_bias;
    uint8_t refresh_entropy_probs;
    uint8_t CbrHdrBedValue;
    uint8_t CbrHdrBedRange;
    uint8_t mb_seg_tree_probs [3];

    int8_t seg_feature[2][4];
    int8_t ref_lf_deltas[4];
    int8_t mode_lf_deltas[4];

    uint8_t BitsConsumed;
    uint8_t AlignByte[3];
    uint32_t hdr_partition_size;
    uint32_t hdr_start_offset;
    uint32_t hdr_processed_offset;
    uint32_t coeff_partition_size[8];
    uint32_t coeff_partition_start_offset[8];
    uint32_t nNumSlices;
    uint32_t *pSliceDataOffsets;
    uint32_t uCoeffPartitionDataLen;
    uint32_t uCoeffPartitionBufferHandle;

    uint32_t RetRefreshGoldenFrame;
    uint32_t RetRefreshAltFrame;
    uint32_t RetRefreshLastFrame;
} NvMediaPictureInfoVP8;
typedef struct {
    uint32_t inter_mode_counts[7][3][2];
    uint32_t sb_ymode_counts[4][10];
    uint32_t uv_mode_counts[10][10];
    uint32_t partition_counts[16][4];
    uint32_t switchable_interp_counts[4][3];
    uint32_t intra_inter_count[4][2];
    uint32_t comp_inter_count[5][2];
    uint32_t single_ref_count[5][2][2];
    uint32_t comp_ref_count[5][2];
    uint32_t tx32x32_count[2][4];
    uint32_t tx16x16_count[2][3];
    uint32_t tx8x8_count[2][2];
    uint32_t mbskip_count[3][2];
    uint32_t joints[4];
    uint32_t sign[2][2];
    uint32_t classes[2][11];
    uint32_t class0[2][2];
    uint32_t bits[2][10][2];
    uint32_t class0_fp[2][2][4];
    uint32_t fp[2][4];
    uint32_t class0_hp[2][2];
    uint32_t hp[2][2];
    uint32_t countCoeffs[2][2][6][6][4];
    uint32_t countCoeffs8x8[2][2][6][6][4];
    uint32_t countCoeffs16x16[2][2][6][6][4];
    uint32_t countCoeffs32x32[2][2][6][6][4];
    uint32_t countEobs[4][2][2][6][6];
} NvMediaVP9BackwardUpdates;

typedef struct {

    uint8_t kf_bmode_prob[10][10][8];
    uint8_t kf_bmode_probB[10][10][1];
    uint8_t ref_pred_probs[3];
    uint8_t mb_segment_tree_probs[7];
    uint8_t segment_pred_probs[3];
    uint8_t ref_scores[4];
    uint8_t prob_comppred[2];
    uint8_t pad1[9];

    uint8_t kf_uv_mode_prob[10][8];
    uint8_t kf_uv_mode_probB[10][1];
    uint8_t pad2[6];

    uint8_t inter_mode_prob[7][4];
    uint8_t intra_inter_prob[4];

    uint8_t uv_mode_prob[10][8];
    uint8_t tx8x8_prob[2][1];
    uint8_t tx16x16_prob[2][2];
    uint8_t tx32x32_prob[2][3];
    uint8_t sb_ymode_probB[4][1];
    uint8_t sb_ymode_prob[4][8];

    uint8_t partition_prob[2][16][4];

    uint8_t uv_mode_probB[10][1];
    uint8_t switchable_interp_prob[4][2];
    uint8_t comp_inter_prob[5];
    uint8_t mbskip_probs[3];
    uint8_t pad3[1];

    uint8_t joints[3];
    uint8_t sign[2];
    uint8_t class0[2][1];
    uint8_t fp[2][3];
    uint8_t class0_hp[2];
    uint8_t hp[2];
    uint8_t classes[2][10];
    uint8_t class0_fp[2][2][3];
    uint8_t bits[2][10];

    uint8_t single_ref_prob[5][2];
    uint8_t comp_ref_prob[5];
    uint8_t pad4[17];

    uint8_t probCoeffs[2][2][6][6][4];
    uint8_t probCoeffs8x8[2][2][6][6][4];
    uint8_t probCoeffs16x16[2][2][6][6][4];
    uint8_t probCoeffs32x32[2][2][6][6][4];
} NvmediaVP9EntropyProbs;

typedef struct {
    NvMediaRefSurface *LastReference;
    NvMediaRefSurface *GoldenReference;
    NvMediaRefSurface *AltReference;
    uint32_t    width;
    uint32_t    height;
    uint32_t    ref0_width;
    uint32_t    ref0_height;
    uint32_t    ref1_width;
    uint32_t    ref1_height;
    uint32_t    ref2_width;
    uint32_t    ref2_height;
    uint32_t keyFrame;
    uint32_t bit_depth;
    uint32_t prevIsKeyFrame;
    uint32_t PrevShowFrame;
    uint32_t resolutionChange;
    uint32_t errorResilient;
    uint32_t intraOnly;
    uint8_t frameContextIdx;
    uint8_t refFrameSignBias[4];
    uint32_t loopFilterLevel;
    uint32_t loopFilterSharpness;
    int32_t qpYAc;
    int32_t qpYDc;
    int32_t qpChAc;
    int32_t qpChDc;
    uint32_t lossless;
    uint32_t transform_mode;
    uint32_t allow_high_precision_mv;
    uint32_t allow_comp_inter_inter;
    uint32_t mcomp_filter_type;
    uint32_t comp_pred_mode;
    uint32_t comp_fixed_ref;
    uint32_t comp_var_ref[2];
    uint32_t log2_tile_columns;
    uint32_t log2_tile_rows;
    uint32_t segmentEnabled;
    uint32_t segmentMapUpdate;
    int32_t segmentMapTemporalUpdate;
    uint32_t segmentFeatureMode;
    uint8_t segmentFeatureEnable[8][4];
    short segmentFeatureData[8][4];
    uint32_t modeRefLfEnabled;
    uint32_t mbRefLfDelta[4];
    uint32_t mbModeLfDelta[2];
    uint32_t offsetToDctParts;
    uint32_t frameTagSize;
    NvmediaVP9EntropyProbs entropy;

    NvMediaVP9BackwardUpdates backwardUpdateCounts;
} NvMediaPictureInfoVP9;
#define NVMEDIA_VIDEO_ENCODER_TIMEOUT_INFINITE  0xFFFFFFFF

#define NVMEDIA_ENCODE_INFINITE_GOPLENGTH       0xFFFFFFFF

typedef struct {
    uint32_t qpInterP;
    uint32_t qpInterB;
    uint32_t qpIntra;
} NvMediaEncodeQP;

typedef enum
{
    NVMEDIA_ENCODE_PARAMS_RC_CBR          = 0,
    NVMEDIA_ENCODE_PARAMS_RC_CONSTQP      = 1,
    NVMEDIA_ENCODE_PARAMS_RC_VBR          = 2,
    NVMEDIA_ENCODE_PARAMS_RC_VBR_MINQP    = 3,
    NVMEDIA_ENCODE_PARAMS_RC_CBR_MINQP    = 4
} NvMediaEncodeParamsRCMode;

typedef struct {
    NvMediaEncodeParamsRCMode rateControlMode;
    uint32_t numBFrames;
    union {
        struct {
            uint32_t averageBitRate;
            uint32_t vbvBufferSize;
            uint32_t vbvInitialDelay;
        } cbr; 
        struct {
            NvMediaEncodeQP constQP;
        } const_qp; 
        struct {
            uint32_t averageBitRate;
            uint32_t maxBitRate;
            uint32_t vbvBufferSize;
            uint32_t vbvInitialDelay;
        } vbr; 
        struct {
            uint32_t averageBitRate;
            uint32_t maxBitRate;
            uint32_t vbvBufferSize;
            uint32_t vbvInitialDelay;
            NvMediaEncodeQP minQP;
        } vbr_minqp; 
        struct {
            uint32_t averageBitRate;
            uint32_t vbvBufferSize;
            uint32_t vbvInitialDelay;
            NvMediaEncodeQP minQP;
        } cbr_minqp; 
    } params; 
    NvMediaBool bConstFrameQP;
    uint32_t maxSessionQP;
 } NvMediaEncodeRCParams;

typedef enum {
    NVMEDIA_ENCODE_BLOCKING_TYPE_NEVER,
    NVMEDIA_ENCODE_BLOCKING_TYPE_IF_PENDING,
    NVMEDIA_ENCODE_BLOCKING_TYPE_ALWAYS
} NvMediaBlockingType;

typedef enum {
    NVMEDIA_ENCODE_PIC_TYPE_AUTOSELECT      = 0,
    NVMEDIA_ENCODE_PIC_TYPE_P               = 1,
    NVMEDIA_ENCODE_PIC_TYPE_B               = 2,
    NVMEDIA_ENCODE_PIC_TYPE_I               = 3,
    NVMEDIA_ENCODE_PIC_TYPE_IDR             = 4,
    NVMEDIA_ENCODE_PIC_TYPE_P_INTRA_REFRESH = 5
} NvMediaEncodePicType;

typedef enum {
    NVMEDIA_ENCODE_PROFILE_AUTOSELECT  = 0,

    NVMEDIA_ENCODE_PROFILE_BASELINE    = 66,
    NVMEDIA_ENCODE_PROFILE_MAIN        = 77,
    NVMEDIA_ENCODE_PROFILE_EXTENDED    = 88,
    NVMEDIA_ENCODE_PROFILE_HIGH        = 100,
    NVMEDIA_ENCODE_PROFILE_HIGH444     = 244
} NvMediaEncodeProfile;

typedef enum {
    NVMEDIA_ENCODE_LEVEL_AUTOSELECT         = 0,

    NVMEDIA_ENCODE_LEVEL_H264_1             = 10,
    NVMEDIA_ENCODE_LEVEL_H264_1b            = 9,
    NVMEDIA_ENCODE_LEVEL_H264_11            = 11,
    NVMEDIA_ENCODE_LEVEL_H264_12            = 12,
    NVMEDIA_ENCODE_LEVEL_H264_13            = 13,
    NVMEDIA_ENCODE_LEVEL_H264_2             = 20,
    NVMEDIA_ENCODE_LEVEL_H264_21            = 21,
    NVMEDIA_ENCODE_LEVEL_H264_22            = 22,
    NVMEDIA_ENCODE_LEVEL_H264_3             = 30,
    NVMEDIA_ENCODE_LEVEL_H264_31            = 31,
    NVMEDIA_ENCODE_LEVEL_H264_32            = 32,
    NVMEDIA_ENCODE_LEVEL_H264_4             = 40,
    NVMEDIA_ENCODE_LEVEL_H264_41            = 41,
    NVMEDIA_ENCODE_LEVEL_H264_42            = 42,
} NvMediaEncodeLevel;

typedef enum {
    NVMEDIA_ENCODE_PIC_FLAG_OUTPUT_SPSPPS      = (1 << 0),
    NVMEDIA_ENCODE_PIC_FLAG_RATECONTROL_CHANGE = (1 << 1),
    NVMEDIA_ENCODE_PIC_FLAG_CONSTRAINED_FRAME  = (1 << 2)
} NvMediaEncodePicFlags;

typedef enum {
    NVMEDIA_ENCODE_QUALITY_L0                  = 0,
    NVMEDIA_ENCODE_QUALITY_L1                  = 1,
    NVMEDIA_ENCODE_QUALITY_L2                  = 2
} NvMediaEncodeQuality;

typedef enum {
    NVMEDIA_ENCODE_H264_ENTROPY_CODING_MODE_CAVLC = 0,
    NVMEDIA_ENCODE_H264_ENTROPY_CODING_MODE_CABAC = 1
} NvMediaEncodeH264EntropyCodingMode;

typedef enum {
    NVMEDIA_ENCODE_H264_BDIRECT_MODE_SPATIAL  = 0,
    NVMEDIA_ENCODE_H264_BDIRECT_MODE_DISABLE  = 1,
    NVMEDIA_ENCODE_H264_BDIRECT_MODE_TEMPORAL = 2
} NvMediaEncodeH264BDirectMode;

typedef enum {
    NVMEDIA_ENCODE_H264_ADAPTIVE_TRANSFORM_AUTOSELECT = 0,
    NVMEDIA_ENCODE_H264_ADAPTIVE_TRANSFORM_DISABLE    = 1,
    NVMEDIA_ENCODE_H264_ADAPTIVE_TRANSFORM_ENABLE     = 2
} NvMediaEncodeH264AdaptiveTransformMode;

typedef enum {
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_VERTICAL_PREDICTION               = (1 << 0),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_HORIZONTAL_PREDICTION             = (1 << 1),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_DC_PREDICTION                     = (1 << 2),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_DIAGONAL_DOWN_LEFT_PREDICTION     = (1 << 3),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_DIAGONAL_DOWN_RIGHT_PREDICTION    = (1 << 4),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_VERTICAL_RIGHT_PREDICTION         = (1 << 5),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_HORIZONTAL_DOWN_PREDICTION        = (1 << 6),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_VERTICAL_LEFT_PREDICTION          = (1 << 7),
    NVMEDIA_ENCODE_DISABLE_INTRA_4x4_HORIZONTAL_UP_PREDICTION          = (1 << 8),

    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_VERTICAL_PREDICTION               = (1 << 9),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_HORIZONTAL_PREDICTION             = (1 << 10),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_DC_PREDICTION                     = (1 << 11),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_DIAGONAL_DOWN_LEFT_PREDICTION     = (1 << 12),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_DIAGONAL_DOWN_RIGHT_PREDICTION    = (1 << 13),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_VERTICAL_RIGHT_PREDICTION         = (1 << 14),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_HORIZONTAL_DOWN_PREDICTION        = (1 << 15),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_VERTICAL_LEFT_PREDICTION          = (1 << 16),
    NVMEDIA_ENCODE_DISABLE_INTRA_8x8_HORIZONTAL_UP_PREDICTION          = (1 << 17),

    NVMEDIA_ENCODE_DISABLE_INTRA_16x16_VERTICAL_PREDICTION             = (1 << 18),
    NVMEDIA_ENCODE_DISABLE_INTRA_16x16_HORIZONTAL_PREDICTION           = (1 << 19),
    NVMEDIA_ENCODE_DISABLE_INTRA_16x16_DC_PREDICTION                   = (1 << 20),
    NVMEDIA_ENCODE_DISABLE_INTRA_16x16_PLANE_PREDICTION                = (1 << 21),

    NVMEDIA_ENCODE_DISABLE_INTRA_CHROMA_VERTICAL_PREDICTION            = (1 << 22),
    NVMEDIA_ENCODE_DISABLE_INTRA_CHROMA_HORIZONTAL_PREDICTION          = (1 << 23),
    NVMEDIA_ENCODE_DISABLE_INTRA_CHROMA_DC_PREDICTION                  = (1 << 24),
    NVMEDIA_ENCODE_DISABLE_INTRA_CHROMA_PLANE_PREDICTION               = (1 << 25),

    NVMEDIA_ENCODE_DISABLE_INTER_L0_16x16_PREDICTION                   = (1 << 26),
    NVMEDIA_ENCODE_DISABLE_INTER_L0_16x8_PREDICTION                    = (1 << 27),
    NVMEDIA_ENCODE_DISABLE_INTER_L0_8x16_PREDICTION                    = (1 << 28),
    NVMEDIA_ENCODE_DISABLE_INTER_L0_8x8_PREDICTION                     = (1 << 29)
} NvMediaEncodeH264MotionPredictionExclusionFlags;

typedef enum {
    NVMEDIA_ENCODE_ENABLE_IP_SEARCH_INTRA_4x4                 = (1 << 0),
    NVMEDIA_ENCODE_ENABLE_IP_SEARCH_INTRA_8x8                 = (1 << 1),
    NVMEDIA_ENCODE_ENABLE_IP_SEARCH_INTRA_16x16               = (1 << 2),
    NVMEDIA_ENCODE_ENABLE_SELF_TEMPORAL_REFINE               = (1 << 3),
    NVMEDIA_ENCODE_ENABLE_SELF_SPATIAL_REFINE                = (1 << 4),
    NVMEDIA_ENCODE_ENABLE_COLOC_REFINE                       = (1 << 5),
    NVMEDIA_ENCODE_ENABLE_EXTERNAL_REFINE                    = (1 << 6),
    NVMEDIA_ENCODE_ENABLE_CONST_MV_REFINE                    = (1 << 7),
    NVMEDIA_ENCODE_MOTION_SEARCH_CONTROL_FLAG_VALID          = (1 << 31)
} NvMediaEncodeH264MotionSearchControlFlags;

typedef enum {
    NVMEDIA_ENCODE_SPSPPS_REPEAT_DISABLED          = 0,
    NVMEDIA_ENCODE_SPSPPS_REPEAT_INTRA_FRAMES      = 1,
    NVMEDIA_ENCODE_SPSPPS_REPEAT_IDR_FRAMES        = 2
} NvMediaEncodeH264SPSPPSRepeatMode;

typedef enum {
    NvMediaEncAttr_GetSPS = 1,
    NvMediaEncAttr_GetPPS,
    NvMediaEncAttr_GetVPS
} NvMediaEncAttrType;

typedef enum {
    NVMEDIA_ENCODE_H264_POC_TYPE_AUTOSELECT     = 0,
    NVMEDIA_ENCODE_H264_POC_TYPE_0              = 1,
    NVMEDIA_ENCODE_H264_POC_TYPE_2              = 2
} NvMediaEncodeH264POCType;

#define MAX_NON_SLICE_DATA_SIZE 2048

typedef struct {
    uint32_t ulNalSize;
    uint8_t data[MAX_NON_SLICE_DATA_SIZE];
} NvMediaNalData;

typedef struct {
    NvMediaBool aspectRatioInfoPresentFlag;
    uint8_t aspectRatioIdc;
    uint16_t aspectSARWidth;
    uint16_t aspectSARHeight;
    NvMediaBool overscanInfoPresentFlag;
    NvMediaBool overscanAppropriateFlag;
    NvMediaBool videoSignalTypePresentFlag;
    uint8_t videoFormat;
    NvMediaBool videoFullRangeFlag;
    NvMediaBool colourDescriptionPresentFlag;
    uint8_t colourPrimaries;
    uint8_t transferCharacteristics;
    uint8_t colourMatrix;
    NvMediaBool timingInfoPresentFlag;
    NvMediaBool bitstreamRestrictionFlag;
} NvMediaEncodeConfigH264VUIParams;

typedef struct {
    uint32_t   numCandsPerBlk16x16;
    uint32_t   numCandsPerBlk16x8;
    uint32_t   numCandsPerBlk8x16;
    uint32_t   numCandsPerBlk8x8;
} NvMediaEncodeExternalMeHintCountsPerBlocktype;

typedef struct {
    int32_t mvx        : 12;
    int32_t mvy        : 10;
    uint32_t refidx     : 5;
    uint32_t dir        : 1;
    uint32_t partType   : 2;
    uint32_t lastofPart : 1;
    uint32_t lastOfMB   : 1;
} NvMediaEncodeExternalMEHint;

typedef enum {
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_OUTPUT_AUD               = (1 << 0),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_INTRA_REFRESH            = (1 << 1),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_DYNAMIC_SLICE_MODE       = (1 << 2),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_CONSTRANED_ENCODING      = (1 << 3),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_LOSSLESS_COMPRESSION     = (1 << 4),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_SLICE_LEVEL_OUTPUT       = (1 << 5),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_RTP_MODE_OUTPUT          = (1 << 6),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_EXT_PIC_RC_HINT          = (1 << 7),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_DYNAMIC_RPS              = (1 << 8),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_MV_BUFFER_DUMP           = (1 << 9),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_PROFILING                = (1 << 10),
    NVMEDIA_ENCODE_CONFIG_H264_INIT_QP                         = (1 << 11),
    NVMEDIA_ENCODE_CONFIG_H264_QP_MAX                          = (1 << 12),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_FOUR_BYTE_START_CODE     = (1 << 13),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_ULTRA_FAST_ENCODE        = (1 << 14)
} NvMediaEncodeH264Features;

typedef struct {
    uint32_t features;
    uint32_t gopLength;
    NvMediaEncodeRCParams rcParams;
    NvMediaEncodeH264SPSPPSRepeatMode repeatSPSPPS;
    uint32_t idrPeriod;
    uint16_t numSliceCountMinus1;
    uint8_t disableDeblockingFilterIDC;
    NvMediaEncodeH264AdaptiveTransformMode adaptiveTransformMode;
    NvMediaEncodeH264BDirectMode bdirectMode;
    NvMediaEncodeH264EntropyCodingMode entropyCodingMode;
    uint32_t intraRefreshPeriod;
    uint32_t intraRefreshCnt;
    uint32_t maxSliceSizeInBytes;
    uint32_t numMacroblocksPerSlice;
    NvMediaEncodeConfigH264VUIParams *h264VUIParameters;
    uint32_t motionPredictionExclusionFlags;
    NvMediaEncodeQuality quality;
    NvMediaEncodeH264POCType pocType;
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
    uint8_t enableWeightedPrediction;
} NvMediaEncodeConfigH264;

typedef struct {
    uint32_t payloadSize;
    uint32_t payloadType;
    uint8_t *payload;
} NvMediaEncodeH264SEIPayload;

typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    NvMediaBool enableLimitedRGB;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t profile;
    uint8_t level;
    uint8_t maxNumRefFrames;
    NvMediaBool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    NvMediaBool enableReconCRC;
    NvMediaBool enableMVC;
    NvMediaBool enableROIEncode;
    NvMediaBool enableSliceEncode;
    uint32_t useBFramesAsRef;
    NvMediaBool enableTwoPassRC;
    NvMediaBool enableSourceHalfScaled;
    uint32_t mvcNumViews;
} NvMediaEncodeInitializeParamsH264;

typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    uint32_t seiPayloadArrayCnt;
    NvMediaEncodeH264SEIPayload *seiPayloadArray;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    NvMediaEncodeExternalMEHint *meExternalHints;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint32_t viewId;
} NvMediaEncodePicParamsH264;
typedef struct {
    NvMediaBool aspectRatioInfoPresentFlag;
    uint8_t aspectRatioIdc;
    uint16_t aspectSARWidth;
    uint16_t aspectSARHeight;
    NvMediaBool overscanInfoPresentFlag;
    NvMediaBool overscanAppropriateFlag;
    NvMediaBool videoSignalTypePresentFlag;
    uint8_t videoFormat;
    NvMediaBool videoFullRangeFlag;
    NvMediaBool colourDescriptionPresentFlag;
    uint8_t colourPrimaries;
    uint8_t transferCharacteristics;
    uint8_t matrixCoeffs;
    /* Holds that num_units_in_tick, time_scale and fixed_frame_rate_flag are present
       in the bitstream (as defined in Annex E of the ITU-T Specification). */
    NvMediaBool vuiTimingInfoPresentFlag;
    /* Specified the bitstream restriction info (as defined in Annex E of the ITU-T Specification). */
    NvMediaBool bitstreamRestrictionFlag;
} NvMediaEncodeConfigH265VUIParams;

typedef enum {
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_OUTPUT_AUD               = (1 << 0),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_INTRA_REFRESH            = (1 << 1),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_DYNAMIC_SLICE_MODE       = (1 << 2),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_CONSTRANED_ENCODING      = (1 << 3),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_LOSSLESS_COMPRESSION     = (1 << 4),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_SLICE_LEVEL_OUTPUT       = (1 << 5),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_RTP_MODE_OUTPUT          = (1 << 6),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_EXT_PIC_RC_HINT          = (1 << 7),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_DYNAMIC_RPS              = (1 << 8),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_MV_BUFFER_DUMP           = (1 << 9),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_PROFILING                = (1 << 10),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_ULTRA_FAST_ENCODE        = (1 << 11),
    NVMEDIA_ENCODE_CONFIG_H265_INIT_QP                         = (1 << 12),
    NVMEDIA_ENCODE_CONFIG_H265_QP_MAX                        = (1 << 13),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_FOUR_BYTE_START_CODE     = (1 << 14)
} NvMediaEncodeH265Features;

typedef struct {
    uint32_t features;
    uint32_t gopLength;
    NvMediaEncodeRCParams rcParams;
    NvMediaEncodeH264SPSPPSRepeatMode repeatSPSPPS;
    uint32_t idrPeriod;
    uint16_t numSliceCountMinus1;
    uint8_t disableDeblockingFilter;
    uint8_t enableWeightedPrediction;
    uint32_t intraRefreshPeriod;
    uint32_t intraRefreshCnt;
    uint32_t maxSliceSizeInBytes;
    uint32_t numCTUsPerSlice;
    NvMediaEncodeConfigH265VUIParams *h265VUIParameters;
    NvMediaEncodeQuality quality;
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
} NvMediaEncodeConfigH265;

typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    NvMediaBool enableLimitedRGB;
    NvMediaBool enableSliceLevelEncode;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t profile;
    uint8_t level;
    uint8_t levelTier;
    uint8_t maxNumRefFrames;
    NvMediaBool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    NvMediaBool enableReconCRC;
    NvMediaBool enableMVC;
    NvMediaBool enableROIEncode;
    NvMediaBool enableSliceEncode;
    uint32_t useBFramesAsRef;
    NvMediaBool enableTwoPassRC;
    NvMediaBool enableSourceHalfScaled;
    uint32_t mvNumViews;
} NvMediaEncodeInitializeParamsH265;

typedef struct {
    uint32_t payloadSize;
    uint32_t payloadType;
    uint32_t nalUnitType;
    uint8_t *payload;
} NvMediaEncodeH265SEIPayload;

typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    uint32_t seiPayloadArrayCnt;
    NvMediaEncodeH265SEIPayload *seiPayloadArray;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    NvMediaEncodeExternalMEHint *meExternalHints;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint32_t viewId;
} NvMediaEncodePicParamsH265;

typedef enum {
    NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_LOOP_FILTER_PARAMS               = (1 << 0),
    NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_QUANTIZATION_PARAMS              = (1 << 1),
    NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_TRANSFORM_MODE                   = (1 << 2),
    NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_HIGH_PRECISION_MV                = (1 << 3),
    NVMEDIA_ENCODE_CONFIG_VP9_DISABLE_ERROR_RESILIENT                 = (1 << 4),
    NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_PROFILING                        = (1 << 5),
    NVMEDIA_ENCODE_CONFIG_VP9_INIT_QP                                 = (1 << 6),
    NVMEDIA_ENCODE_CONFIG_VP9_QP_MAX                                = (1 << 7)
} NvMediaEncodeVP9Features;

typedef struct {
    uint32_t features;
    uint32_t gopLength;
    NvMediaEncodeRCParams rcParams;
    uint32_t idrPeriod;

    uint32_t filter_type;
    uint32_t filter_level;
    uint32_t sharpness_level;
    int8_t ref_lf_deltas[4];
    int8_t mode_lf_deltas[2];
    NvMediaBool bmode_ref_lf_delta_enabled;
    NvMediaBool bmode_ref_lf_delta_update;

    /* Set the feature flag \ref NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_QUANTIZATION_PARAMS
       to set the following parameters */
    uint32_t base_qindex;
    int32_t delta_y_dc_q;
    int32_t delta_uv_dc;
    int32_t delta_uv_ac;

    /* Set the feature flag \ref NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_TRANSFORM_MODE to
       set the following parameter */
    uint32_t transform_mode;

    /* Set the feature flag \ref NVMEDIA_ENCODE_CONFIG_VP9_ENABLE_HIGH_PRECISION_MV
       to set the following parameter */
    uint32_t high_prec_mv;

    /* Set the feature flag \ref NVMEDIA_ENCODE_CONFIG_VP9_DISABLE_ERROR_RESILIENT to
       set the following parameter */
    NvMediaBool error_resilient;

    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
} NvMediaEncodeConfigVP9;

typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    NvMediaBool enableLimitedRGB;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t maxNumRefFrames;
    NvMediaBool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
} NvMediaEncodeInitializeParamsVP9;

typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    NvMediaEncodeExternalMEHint *meExternalHints;
} NvMediaEncodePicParamsVP9;

typedef enum {
    NVMEDIA_ENCODE_CONFIG_VP8_ENABLE_LOOP_FILTER_PARAMS               = (1 << 0),
    NVMEDIA_ENCODE_CONFIG_VP8_ENABLE_QUANTIZATION_PARAMS              = (1 << 1),
    NVMEDIA_ENCODE_CONFIG_VP8_ENABLE_SEGMENTATION                     = (1 << 2),
    NVMEDIA_ENCODE_CONFIG_VP8_ENABLE_PROFILING                        = (1 << 3),
    NVMEDIA_ENCODE_CONFIG_VP8_INIT_QP                                 = (1 << 4),
    NVMEDIA_ENCODE_CONFIG_VP8_QP_MAX                                  = (1 << 5)
} NvMediaEncodeVP8Features;

typedef struct {
    uint32_t features;
    uint32_t gopLength;
    uint32_t numReferenceFrames;
    uint32_t version;
    NvMediaEncodeRCParams rcParams;
    uint32_t filter_type;
    uint32_t filter_level;
    uint32_t sharpness_level;
    int8_t ref_lf_deltas[4];
    int8_t mode_lf_deltas[4];
    NvMediaBool bmode_ref_lf_delta_enabled;
    NvMediaBool bmode_ref_lf_delta_update;
    uint32_t base_qindex;
    uint32_t y1dc_delta_q;
    uint32_t y2dc_delta_q;
    uint32_t y2ac_delta_q;
    uint32_t uvdc_delta_q;
    uint32_t uvac_delta_q;
    uint32_t refresh_entropy_probs;
    uint32_t update_mb_segmentation_map;
    uint32_t update_mb_segmentation_data;
    uint32_t mb_segment_abs_delta;
    int8_t seg_filter_level[4];
    int8_t seg_qindex[4];
    NvMediaBool mb_no_coeff_skip_flag;
    NvMediaBool no_temporal_mv_hints;
    NvMediaBool stop_prob_update;
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
    NvMediaEncodeQuality quality;
} NvMediaEncodeConfigVP8;

typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t maxNumRefFrames;
} NvMediaEncodeInitializeParamsVP8;

typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    NvMediaEncodeRCParams rcParams;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
} NvMediaEncodePicParamsVP8;

typedef enum {
    NVMEDIA_FILTER_QUALITY_LOW = 0,
    NVMEDIA_FILTER_QUALITY_MEDIUM,
    NVMEDIA_FILTER_QUALITY_HIGH
} NvMediaFilterQuality;

#define NVMEDIA_DISP_ATTR_BRIGHTNESS      (1<<0)

#define NVMEDIA_DISP_ATTR_CONTRAST        (1<<1)

#define NVMEDIA_DISP_ATTR_SATURATION      (1<<2)

#define NVMEDIA_DISP_ATTR_HUE             (1<<3)

#define NVMEDIA_DISP_ATTR_COLOR_STANDARD  (1<<4)

#define NVMEDIA_DISP_ATTR_LIMITED_RGB     (1<<5)

#define NVMEDIA_DISP_ATTR_COMPOSITION     (1<<6)

#define NVMEDIA_DISP_ATTR_SET_DEPTH       (1<<7)

#define NVMEDIA_DISP_ATTR_SET_POSITION    (1<<8)

typedef enum {
    NVMEDIA_DISP_COMP_MODE_OPAQUE,
    NVMEDIA_DISP_COMP_MODE_SRC_ALPHA,
    NVMEDIA_DISP_COMP_MODE_PREMULTI_SRC_ALPHA
} NvMediaDispCompMode;

typedef struct {
    float_t brightness;
    float_t contrast;
    float_t saturation;
    float_t hue;
    NvMediaColorStandard colorStandard;
    NvMediaBool limitedRGB;
    NvMediaDispCompMode compositionMode;
    uint32_t depth;
    NvMediaRect position;
} NvMediaDispAttributes;

typedef enum
{
    NVMEDIA_TRANSFORM_NONE = 0x0,
    NVMEDIA_TRANSFORM_ROTATE_90,
    NVMEDIA_TRANSFORM_ROTATE_180,
    NVMEDIA_TRANSFORM_ROTATE_270,
    NVMEDIA_TRANSFORM_FLIP_HORIZONTAL,
    NVMEDIA_TRANSFORM_INV_TRANSPOSE,
    NVMEDIA_TRANSFORM_FLIP_VERTICAL,
    NVMEDIA_TRANSFORM_TRANSPOSE
} NvMediaTransform;

typedef enum {
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_ORIGINAL = 0,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_OUTDOOR_LOW_LIGHT,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_OUTDOOR_MEDIUM_LIGHT,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_OUTDOOR_HIGH_LIGHT,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_INDOOR_LOW_LIGHT,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_INDOOR_MEDIUM_LIGHT,
    NVMEDIA_NOISE_REDUCTION_ALGORITHM_INDOOR_HIGH_LIGHT
} NvMediaNoiseReductionAlgorithm;

/*
 * \defgroup history_nvmedia_common History
 * Provides change history for the NvMedia Common Types.
 *
 * \section history_nvmedia_common Version History
 *
 * <b> Version 1.0 </b> March 21, 2017
 * - Initial release
 *
 * <b> Version 1.1 </b> April 18, 2017
 * - Added \ref NvMediaDecoderInstanceId enum and
 *   \ref NvMediaEncoderInstanceId enum
 * - Changed to use standard data types
 * - Removed input surface rotation and mirroring enumerations and members from
 *   \ref NvMediaEncodeInitializeParamsH264 and \ref NvMediaEncodeInitializeParamsH265
 *
 * <b> Version 1.2 </b> May 4, 2017
 * - Added SLICE_LEVEL_OUTPUT, RTP_MODE_OUTPUT, EXT_PIC_RC_HINT, DYNAMIC_RPS,
 *   MV_BUFFER_DUMP and RECON_CRC features for \ref NvMediaEncodeH264Features
 *   and \ref NvMediaEncodeH265Features
 * - Add bConstFrameQP parameter in \ref NvMediaEncodeRCParams.
 * - Add NvMediaEncAttrType enum and NvMediaNalData data structure.
 *
 * <b> Version 1.3 </b> May 8, 2017
 * - Added \ref numMacroblocksPerSlice in \ref NvMediaEncodeConfigH264
 *   and \ref numCTUsPerSlice in \ref NvMediaEncodeConfigH265.
 *
 * <b> Version 1.4 </b> May 10, 2017
 * - Added LOOP_FILTER_PARAMS, QUANTIZATION_PARAMS, TRANSFORM_MODE, HIGH_PRECISION_MV
 *   and ERROR_RESILIENT features in \ref NvMediaEncodeVP9Features.
 * - Added filter_type, filter_level, sharpness_level, ref_lf_deltas, mode_lf_deltas,
 *   bmode_ref_lf_delta_enabled, bmode_ref_lf_delta_update, base_qindex, delta_y_dc_q,
 *   delta_uv_dc, delta_uv_ac, transform_mode, high_prec_mv and error_resilient
 *   parameters in \ref NvMediaEncodeConfigVP9.
 *
 * <b> Version 1.5 </b> May 17, 2017
 * - Added display_attributes enum defines
 * - Added \ref NvMediaDispCompMode and \ref NvMediaDispAttributes
 *
 * <b> Version 1.6 </b> May 18, 2017
 * - Added NvMediaTransform enum defines
 *
 * <b> Version 1.7 </b> June 05, 2017
 * - Add \ref bSliceDecEnable and \ref NvMediaSliceDecodeData structure member in
 *   \ref NvMediaPictureInfoH265 structure.
 *
 * <b> Version 1.8 </b> June 07, 2017
 * - Added \ref NvMediaEncodeH264POCType enum for H.264 pic_order_cnt_type.
 *   The support is added for pic_order_cnt_type 0 and 2. pic_order_cnt_type 1 is not
 *   not supported.
 * - Added variable pocType of type \ref NvMediaEncodeH264POCType in \ref NvMediaEncodeConfigH264.
 *
 * <b> Version 1.9 </b> June 09, 2017
 * -Added PROFILING feature in \ref NvMediaEncodeH264Features,
 *  \ref NvMediaEncodeH265Features and \ref NvMediaEncodeVP9Features.
 *
 * <b> Version 1.10 </b> June 09, 2017
 * - Removed RECON_CRC features from \ref NvMediaEncodeH264Features
 *   and \ref NvMediaEncodeH265Features and added it as enableReconCRC
 *   for \ref NvMediaEncodeInitializeParamsH264 and \ref
 *   NvMediaEncodeInitializeParamsH265.
 * - Added enableMVC, enableROIEncode and enableSliceEncode
 *   in \ref NvMediaEncodeInitializeParamsH264 and \ref
 *   NvMediaEncodeInitializeParamsH265.
 *
 * <b> Version 1.11 </b> June 22, 2017
 * -Added levelTier parameter in \ref NvMediaEncodeInitializeParamsH265
 *  Added initQP, maxQP parameters in \ref NvMediaEncodeConfigH264,
 *  \ref NvMediaEncodeConfigH265 and \ref NvMediaEncodeConfigVP9.
 *
 * <b> Version 1.12 </b> June 29, 2017
 * -Added feature in \ref NvMediaEncodeH264Features and \ref NvMediaEncodeH265Features,
 *  to enable 4 byte start code.
 *
 * <b> Version 1.13</b> June 30, 2017
 * -Added HEVC MV interface members in \ref NvMediaPictureInfoH265 structure
 *
 * <b> Version 1.14</b> July 26, 2017
 * -Added enableWeightedPrediction in \ref NvMediaEncodeConfigH264 structure *
 *
 * <b> Version 1.15</b> Sept 1, 2017
 * -Added NvMediaEncodeVP8Features, NvMediaEncodeConfigVP8, NvMediaEncodeInitializeParamsVP8
 *  and NvMediaEncodePicParamsVP8 structures *
 *
 * <b> Version 1.16 </b> Sept 13, 2017
 * -Added frameRateNum and frameRateDen parameters in \ref NvMediaEncodePicParamsVP8
 *
 * <b> Version 1.17 </b> Oct 26, 2017
 * -Added useBFramesAsRef parameter in \ref NvMediaEncodeInitializeParamsH264
 *  and \ref NvMediaEncodeInitializeParamsH265
 *
 * <b> Version 1.18 </b> Nov 6, 2017
 * - Added enableTwoPassRC and enableSourceHalfScaled for \ref NvMediaEncodeInitializeParamsH264 and
 *   \ref NvMediaEncodeInitializeParamsH265.
 *
 * <b> Version 1.19 </b> Nov 24, 2017
 * - Added mvNumViews for \ref NvMediaEncodeInitializeParamsH265 and viewId for
 *   \ref NvMediaEncodePicParamsH265. Added mvcNumViews for \ref NvMediaEncodeInitializeParamsH264
 *   and viewId for \ref NvMediaEncodePicParamsH264.
 *
 * <b> Version 1.20 </b> March 16, 2018
 * - Added \ref NvMediaNoiseReductionAlgorithm structure
 *
 * <b> Version 1.21 </b> October 4, 2018
 * - Added Ultrafast encoding support for H.264 for platforms >=T194 in
 *   \ref NvMediaEncodeH264Features
 */


#ifdef __cplusplus
};     /* extern "C" */
#endif

#endif /* _NVMEDIA_COMMON_H */