nvmedia_common_encode.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
 
#ifndef NVMEDIA_COMMON_ENCODE_H
#define NVMEDIA_COMMON_ENCODE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <stdbool.h>
 
#include "nvmedia_core.h"
#include "nvmedia_common_encode_decode.h"
 
#define NVMEDIA_ENCODE_TIMEOUT_INFINITE         0xFFFFFFFFU
 
#define NVMEDIA_ENCODE_INFINITE_GOPLENGTH       0xFFFFFFFFU
 
typedef enum {
    NVMEDIA_ENCODER_INSTANCE_0 = 0,
    NVMEDIA_ENCODER_INSTANCE_1,
    NVMEDIA_ENCODER_INSTANCE_AUTO,
} NvMediaEncoderInstanceId;
 
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; 
    bool 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,
    NVMEDIA_ENCODE_LEVEL_H264_5             = 50,
    NVMEDIA_ENCODE_LEVEL_H264_51            = 51,
    NVMEDIA_ENCODE_LEVEL_H264_52            = 52,
    NVMEDIA_ENCODE_LEVEL_H264_END           = 255
} NvMediaEncodeLevel;
 
typedef enum {
    NVMEDIA_ENCODE_LEVEL_H265_AUTOSELECT    = 0,
 
    NVMEDIA_ENCODE_LEVEL_H265_1             = 30,
    NVMEDIA_ENCODE_LEVEL_H265_2             = 60,
    NVMEDIA_ENCODE_LEVEL_H265_21            = 63,
    NVMEDIA_ENCODE_LEVEL_H265_3             = 90,
    NVMEDIA_ENCODE_LEVEL_H265_31            = 93,
    NVMEDIA_ENCODE_LEVEL_H265_4             = 120,
    NVMEDIA_ENCODE_LEVEL_H265_41            = 123,
    NVMEDIA_ENCODE_LEVEL_H265_5             = 150,
    NVMEDIA_ENCODE_LEVEL_H265_51            = 153,
    NVMEDIA_ENCODE_LEVEL_H265_52            = 156,
    NVMEDIA_ENCODE_LEVEL_H265_6             = 180,
    NVMEDIA_ENCODE_LEVEL_H265_61            = 183,
    NVMEDIA_ENCODE_LEVEL_H265_62            = 186,
    NVMEDIA_ENCODE_LEVEL_H265_END           = 255
 
} NvMediaEncodeLevelH265;
 
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_ENC_PRESET_HQ                      = 0x0,
    NVMEDIA_ENC_PRESET_HP                      = 0x10,
    NVMEDIA_ENC_PRESET_UHP                     = 0x20,
    NVMEDIA_ENC_PRESET_DEFAULT                 = 0x7FFFFFFF
} NvMediaEncPreset;
 
 
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 {
    bool aspectRatioInfoPresentFlag;
    uint8_t aspectRatioIdc;
    uint16_t aspectSARWidth;
    uint16_t aspectSARHeight;
    bool overscanInfoPresentFlag;
    bool overscanAppropriateFlag;
    bool videoSignalTypePresentFlag;
    uint8_t videoFormat;
    bool videoFullRangeFlag;
    bool colourDescriptionPresentFlag;
    uint8_t colourPrimaries;
    uint8_t transferCharacteristics;
    uint8_t colourMatrix;
    bool timingInfoPresentFlag;
    bool 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),
    NVMEDIA_ENCODE_CONFIG_H264_ENABLE_MV_BUFFER_DUMP_V2         = (1 << 15),
} 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;
    NvMediaEncodeH264POCType pocType;
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
    uint8_t enableWeightedPrediction;
    NvMediaEncPreset encPreset;
} 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;
    bool enableLimitedRGB;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t profile;
    uint8_t level;
    uint8_t maxNumRefFrames;
    bool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    bool enableReconCRC;
    bool enableMVC;
    bool enableROIEncode;
    bool enableSliceEncode;
    uint8_t useBFramesAsRef;
    uint8_t reserved3[3];
    bool enableTwoPassRC;
    bool enableSourceHalfScaled;
    uint32_t mvcNumViews             : 4;
    uint32_t enableExternalPictureRC : 1;
    uint32_t enableAllIFrames : 1;
    uint32_t enableMemoryOptimization : 1;
    uint32_t reserved                : 25;
} 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 {
    bool aspectRatioInfoPresentFlag;
    uint8_t aspectRatioIdc;
    uint16_t aspectSARWidth;
    uint16_t aspectSARHeight;
    bool overscanInfoPresentFlag;
    bool overscanAppropriateFlag;
    bool videoSignalTypePresentFlag;
    uint8_t videoFormat;
    bool videoFullRangeFlag;
    bool colourDescriptionPresentFlag;
    uint8_t colourPrimaries;
    uint8_t transferCharacteristics;
    uint8_t matrixCoeffs;
    bool vuiTimingInfoPresentFlag;
    bool 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),
    NVMEDIA_ENCODE_CONFIG_H265_ENABLE_MV_BUFFER_DUMP_V2         = (1 << 15),
} 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;
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
    NvMediaEncPreset encPreset;
} NvMediaEncodeConfigH265;
 
typedef struct {
    uint16_t encodeWidth;
    uint16_t reserved1;
    uint16_t encodeHeight;
    uint16_t reserved2;
    bool enableLimitedRGB;
    bool enableSliceLevelEncode;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t profile;
    uint8_t level;
    uint8_t levelTier;
    uint8_t maxNumRefFrames;
    bool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    bool enableReconCRC;
    bool enableMVC;
    bool enableROIEncode;
    bool enableSliceEncode;
    uint32_t useBFramesAsRef;
    bool enableTwoPassRC;
    bool enableSourceHalfScaled;
    uint32_t mvNumViews              : 4;
    uint32_t enableExternalPictureRC : 1;
    uint32_t enableAllIFrames : 1;
    uint32_t reserved                : 26;
    bool ampDisable;
} 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];
    bool bmode_ref_lf_delta_enabled;
    bool bmode_ref_lf_delta_update;
 
    uint32_t base_qindex;
    int32_t delta_y_dc_q;
    int32_t delta_uv_dc;
    int32_t delta_uv_ac;
 
    uint32_t transform_mode;
 
    uint32_t high_prec_mv;
 
    bool error_resilient;
 
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
} NvMediaEncodeConfigVP9;
 
typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    bool enableLimitedRGB;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t maxNumRefFrames;
    bool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    uint8_t numEpCores;
    uint32_t log2TileRows;
    uint32_t log2TileCols;
    uint32_t vp9SkipChroma;
} NvMediaEncodeInitializeParamsVP9;
 
typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    NvMediaEncodeExternalMEHint *meExternalHints;
} NvMediaEncodePicParamsVP9;
 
typedef enum {
    NVMEDIA_ENCODE_CONFIG_AV1_ENABLE_QUANTIZATION_PARAMS              = (1 << 1),
    NVMEDIA_ENCODE_CONFIG_AV1_DISABLE_CDF_UPDATE                      = (1 << 2),
    NVMEDIA_ENCODE_CONFIG_AV1_FRAME_END_CDF_UPDATE                    = (1 << 3),
    NVMEDIA_ENCODE_CONFIG_AV1_ENABLE_PROFILING                        = (1 << 5),
    NVMEDIA_ENCODE_CONFIG_AV1_INIT_QP                                 = (1 << 6),
    NVMEDIA_ENCODE_CONFIG_AV1_QP_MAX                                  = (1 << 7)
} NvMediaEncodeAV1Features;
 
typedef enum {
    NVMEDIA_ENCODE_SEQUENCEHDR_REPEAT_DISABLED          = 0,
    NVMEDIA_ENCODE_SEQUENCEHDR_REPEAT_INTRA_FRAMES      = 1,
    NVMEDIA_ENCODE_SEQUENCEHDR_REPEAT_IDR_FRAMES        = 2
} NvMediaEncodeAV1SeqHdrRepeatMode;
 
typedef struct {
    uint32_t features;
    uint32_t gopLength;
    NvMediaEncodeRCParams rcParams;
    uint32_t idrPeriod;
 
    /* Set the feature flag \ref
       NVMEDIA_ENCODE_CONFIG_AV1_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;
 
    NvMediaEncodeQP initQP;
    NvMediaEncodeQP maxQP;
    NvMediaBool disableCdfUpdate;
    NvMediaEncPreset encPreset;
 
    NvMediaEncodeAV1SeqHdrRepeatMode repeatSeqHdr;
    uint32_t reserved[17];
} NvMediaEncodeConfigAV1;
 
typedef struct {
    uint32_t encodeWidth;
    uint32_t encodeHeight;
    bool enableLimitedRGB;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint8_t profile;
    uint8_t level;
    uint8_t maxNumRefFrames;
    bool enableSsimRdo;
    bool enableTileEncode;
    uint8_t log2NumTilesInRow;
    uint8_t log2NumTilesInCol;
    /* Holds the frame restoration filter type*/
    uint8_t frameRestorationType;
    /* Set to true to enable bi-compound for B-frames (Currently not
       supported)*/
    bool enableBiCompound;
    /* Set to true to enable uni-compound for P/B-frames (only
       support in Pframes)*/
    bool enableUniCompound;
    /* Set to true to enable Internal High Bit depth*/
    bool enableInternalHighBitDepth;
    bool enableExternalMEHints;
    NvMediaEncodeExternalMeHintCountsPerBlocktype maxMEHintCountsPerBlock[2];
    uint32_t reserved[20];
} NvMediaEncodeInitializeParamsAV1;
 
typedef struct {
    NvMediaEncodePicType pictureType;
    uint32_t encodePicFlags;
    uint32_t nextBFrames;
    NvMediaEncodeRCParams rcParams;
    NvMediaEncodeExternalMeHintCountsPerBlocktype meHintCountsPerBlock[2];
    NvMediaEncodeExternalMEHint *meExternalHints;
    uint32_t frameRateNum;
    uint32_t frameRateDen;
    uint32_t reserved[18];
} NvMediaEncodePicParamsAV1;
 
#ifdef __cplusplus
}     /* extern "C" */
#endif
 
#endif /* NVMEDIA_COMMON_ENCODE_H */