nvmedia_common_encode.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 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_ENCODE_H
#define NVMEDIA_COMMON_ENCODE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "nvmedia_core.h"
#include "nvmedia_common_encode_decode.h"
#include "nvmedia_common_encode_ofst.h"
 
#define NVMEDIA_COMMON_ENCODE_VERSION_MAJOR   1
 
#define NVMEDIA_COMMON_ENCODE_VERSION_MINOR   2
 
#define NVMEDIA_VIDEO_ENCODER_TIMEOUT_INFINITE  0xFFFFFFFFU
 
#define NVMEDIA_ENCODE_INFINITE_GOPLENGTH       0xFFFFFFFFU
 
typedef struct {
    int16_t qpInterP;
    int16_t qpInterB;
    int16_t qpIntra;
 
    int16_t reserved[3];
} 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;
    int8_t maxSessionQP;
    int8_t reserved[3];
 } NvMediaEncodeRCParams;
 
typedef enum {
    NVMEDIA_ENCODE_BLOCKING_TYPE_NEVER,
    NVMEDIA_ENCODE_BLOCKING_TYPE_IF_PENDING
} 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 2048U
 
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 {
    uint16_t encodeWidth;
    uint16_t reserved1;
    uint16_t encodeHeight;
    uint16_t reserved2;
    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;
    uint8_t useBFramesAsRef;
    uint8_t reserved3[3];
    NvMediaBool enableTwoPassRC;
    NvMediaBool enableSourceHalfScaled;
    uint32_t mvcNumViews             : 4;
    uint32_t enableExternalPictureRC : 1;
    uint32_t enableAllIFrames : 1;
    uint32_t reserved                : 26;
} NvMediaEncodeInitializeParamsH264;
 
typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    uint32_t seiPayloadArrayCnt;
    NvMediaEncodeH264SEIPayload *seiPayloadArray;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    union
    {
        NvMediaEncodeExternalMEHint *meExternalHints;
        uint8_t *meHints;
    };
    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 {
    uint16_t encodeWidth;
    uint16_t reserved1;
    uint16_t encodeHeight;
    uint16_t reserved2;
    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              : 4;
    uint32_t enableExternalPictureRC : 1;
    uint32_t enableAllIFrames : 1;
    uint32_t reserved                : 26;
} 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;
 
/*
 * \defgroup history_nvmedia_common_encode History
 * Provides change history for the NvMedia Common Encode Types.
 *
 * \section history_nvmedia_common_encode Version History
 *
 * <b> Version 1.0 </b> July 10, 2019
 * - Initial release
 *
 * <b> Version 1.1 </b> July 13, 2019
 * - Removed support for NVMEDIA_ENCODE_BLOCKING_TYPE_ALWAYS NvMediaBlockingType
 *
 * <b> Version 1.2 </b> July 15, 2019
 * - Update the size of qpInterP, qpInterB and qpIntra, and added reserved to struture NvMediaEncodeQP
 * - Updated size of maxSessionQP, encodeWidth, encodeHeight and useBFramesAsRef with proper reserved variable.
 * - Moved meExternalHints in a Union with uint8_t* member. This is to avoid cast.
 *
 */
 
 
#ifdef __cplusplus
};     /* extern "C" */
#endif
 
#endif /* NVMEDIA_COMMON_ENCODE_H */