/*
* Copyright (c) 2017-2021, Intel 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     codechal_encode_avc_base.h
//! \brief    Defines base class for AVC encoder.
//!

#ifndef __CODECHAL_ENCODE_AVC_BASE_H__
#define __CODECHAL_ENCODE_AVC_BASE_H__

#include "codechal_encoder_base.h"
#include "codechal_kernel_hme.h"
#if USE_CODECHAL_DEBUG_TOOL
#include "codechal_debug_encode_par.h"
#include "codechal_debug_kernel.h"
#endif

#define CODECHAL_ENCODE_AVC_INVALID_ROUNDING                0xFF
#define CODECHAL_ENCODE_AVC_NUM_SYNC_TAGS                   64
#define CODECHAL_ENCODE_AVC_INIT_DSH_SIZE                   MHW_PAGE_SIZE * 3
#define CODECHAL_ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR     11
#define CODECHAL_ENCODE_AVC_DEFAULT_AVBR_ACCURACY           30
#define CODECHAL_ENCODE_AVC_MIN_AVBR_CONVERGENCE            100
#define CODECHAL_ENCODE_AVC_DEFAULT_AVBR_CONVERGENCE        150
#define CODECHAL_ENCODE_AVC_REF_PIC_SELECT_ENTRIES          (CODEC_AVC_MAX_NUM_REF_FRAME + 1) // one extra for current picture
// Invalid AVC PicID
#define CODECHAL_ENCODE_AVC_INVALID_PIC_ID                      CODEC_AVC_NUM_UNCOMPRESSED_SURFACE

#define CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE_COMMON   128

#if USE_CODECHAL_DEBUG_TOOL
#define CODECHAL_DEBUG_ENCODE_AVC_NAL_START_CODE_SEI        0x00000106
#define CODECHAL_DEBUG_ENCODE_AVC_NAL_START_CODE_PPS        0x00000128

struct EncodeAvcPar
{
    // DDI Params
    uint8_t                     ProfileIDC;
    uint8_t                     LevelIDC;
    uint8_t                     CabacInitIDC;
    uint8_t                     ChromaFormatIDC;
    uint8_t                     PictureCodingType;
    uint8_t                     MaxRefIdxL0;
    uint8_t                     MaxRefIdxL1;
    uint8_t                     MaxBRefIdxL0;
    uint8_t                     BRCMethod;
    uint8_t                     BRCType;
    uint8_t                     DeblockingIDC;
    uint8_t                     WeightedPred;
    uint8_t                     WeightedBiPred;
    char                        ChromaQpOffset;
    char                        SecondChromaQpOffset;
    char                        ISliceQP;
    char                        PSliceQP;
    char                        BSliceQP;
    char                        DeblockingFilterAlpha;
    char                        DeblockingFilterBeta;
    bool                        EnableSEI;
    bool                        DisableVUIHeader;
    bool                        EnableWeightPredictionDetection;
    bool                        EntropyCodingMode;
    bool                        DirectInference;
    bool                        Transform8x8Mode;
    bool                        UseOrigAsRef;
    bool                        BiSubMbPartMask;
    uint16_t                    NumP;
    uint16_t                    NumB;
    uint16_t                    FrameRateM;
    uint16_t                    FrameRateD;
    uint16_t                    CRFQualityFactor;
    uint32_t                    NumSlices;
    uint32_t                    SliceHeight;
    uint32_t                    NumSuperSlices;
    uint32_t                    SuperSliceHeight[CODECHAL_ENCODE_AVC_MAX_SLICES_SUPPORTED];
    bool                        ConstrainedIntraPred;
    uint8_t                     SliceMode;
    int16_t                     hme0XOffset;
    int16_t                     hme0YOffset;
    int16_t                     hme1XOffset;
    int16_t                     hme1YOffset;

    // HME Params
    uint8_t                     SuperCombineDist;
    bool                        SuperHME;
    bool                        UltraHME;
    bool                        StreamInEnable;
    uint8_t                     StreamInL0FromNewRef;
    uint8_t                     StreamInL1FromNewRef;

    // BRC init Params
    bool                        MBBRCEnable;
    bool                        MBRC;
    uint16_t                    AvbrAccuracy;
    uint16_t                    AvbrConvergence;
    uint32_t                    BitRate;
    uint32_t                    InitVbvFullnessInBit;
    uint32_t                    MaxBitRate;
    uint32_t                    VbvSzInBit;
    uint32_t                    SlidingWindowEnable;
    uint32_t                    SlidingWindowSize;
    uint32_t                    SlidingWindowMaxRateRatio;
    uint32_t                    LowDelayGoldenFrameBoost;
    uint32_t                    TopQPDeltaThrforAdaptive2Pass;
    uint32_t                    BotQPDeltaThrforAdaptive2Pass;
    uint32_t                    TopFrmSzPctThrforAdaptive2Pass;
    uint32_t                    BotFrmSzPctThrforAdaptive2Pass;
    uint32_t                    MBHeaderCompensation;
    uint32_t                    QPSelectMethodforFirstPass;
    bool                        MBQpCtrl;
    bool                        ICQReEncode;
    bool                        AdaptiveCostAdjustEnable;
    bool                        AdaptiveHMEExtension;
    uint32_t                    QPMin;
    uint32_t                    QPMax;
    bool                        HrdConformanceCheckDisable;
    uint8_t                     StreamInStaticRegion;
    uint8_t                     ScenarioInfo;
    bool                        SliceSizeWA;
    uint32_t                    INumMbsLag;
    uint32_t                    PNumMbsLag;
    uint32_t                    LongTermInterval;

    // BRC frame update Params
    bool                        EnableMultipass;
    uint8_t                     MaxNumPakPasses;
    uint32_t                    UserMaxFrame;
    uint32_t                    UserMaxFrameP;
    bool                        FrameSkipEnable;
    bool                        SceneChgDetectEn;
    uint32_t                    SceneChgPrevIntraPctThresh;
    uint32_t                    SceneChgCurIntraPctThresh;
    uint32_t                    SceneChgWidth0;
    uint32_t                    SceneChgWidth1;
    bool                        Transform8x8PDisable;
    uint32_t                    SliceSizeThr;
    uint32_t                    SliceMaxSize;

    // Enc Params
    uint8_t                     SubPelMode;
    uint8_t                     MaxLenSP;
    uint8_t                     MEMethod;
    uint8_t                     BMEMethod;
    uint8_t                     HMECombineOverlap;
    uint8_t                     SearchX;
    uint8_t                     SearchY;
    uint8_t                     BSearchX;
    uint8_t                     BSearchY;
    uint8_t                     SearchControl;
    uint8_t                     BSearchControl;
    uint8_t                     BiMixDisable;
    uint32_t                    BiWeight;
    bool                        DisableExtendedMvCostRange;
    bool                        EnableAdaptiveSearch;
    bool                        EnableFBRBypass;
    bool                        BlockBasedSkip;
    bool                        MADEnableFlag;
    bool                        EnableMBFlatnessCheckOptimization;
    bool                        EnableArbitrarySliceSize;
    bool                        EnableWavefrontOptimization;
    bool                        BSkipType;
    bool                        EnableAdaptiveTxDecision;
    bool                        EnablePerMBStaticCheck;
    bool                        EnableAdaptiveSearchWindowSize;
    bool                        EnableIntraCostScalingForStaticFrame;
    uint32_t                    StaticFrameZMVPercent;
    uint32_t                    StaticFrameIntraCostScalingRatioP;
    uint32_t                    StaticFrameIntraCostScalingRatioB;
    bool                        AdaptiveMvStreamIn;
    uint32_t                    LargeMvThresh;
    uint32_t                    LargeMvPctThreshold;
    bool                        UniMixDisable;
    bool                        DirectMode;
    uint16_t                    RefThresh;
    uint16_t                    MBTextureThreshold;
    uint16_t                    TxDecisionThr;
    uint32_t                    MRDisableQPCheck;
    uint32_t                    AllFractional;
    uint32_t                    DisableAllFractionalCheckForHighRes;
    uint32_t                    HMECombineLen;
    uint32_t                    HMEBCombineLen;
    uint32_t                    FTQBasedSkip;
    uint32_t                    MultiplePred;
    uint32_t                    EnableAdaptiveIntraScaling;
    uint32_t                    SurvivedSkipCost;
    bool                        VDEncPerfMode;
    bool                        VdencExtPakObjDisable;
    bool                        PPMVDisable;
    uint8_t                     LeftNbrPelMode;
    uint8_t                     DisPSubPartMask;
    uint8_t                     DisPSubMbMask;
    uint8_t                     DisBSubPartMask;
    uint8_t                     DisBSubMbMask;
    uint8_t                     ImePredOverlapThr;
    uint8_t                     MBSizeEstScalingRatioINTRA;
    bool                        IntraMBHdrScaleFactor;
    uint8_t                     MBSizeEstScalingRatioINTER;
    bool                        InterMBHdrScaleFactor;
    uint8_t                     PFrameMaxNumImePred;
    uint8_t                     BFrameMaxNumImePred;
    uint8_t                     HMERefWindowSize;
    uint8_t                     IMELeftPredDep;
    uint8_t                     NumFMECandCheck;
    uint8_t                     PFrameImePredLargeSW;
    uint8_t                     BFrameImePredLargeSW;
    bool                        RdoChromaEnable;
    uint16_t                    Intra4x4ModeMask;
    uint16_t                    Intra8x8ModeMask;
    bool                        RdoIntraChromaSearch;
    uint8_t                     Intra16x16ModeMask;
    uint8_t                     InitMBBudgetTr4x4;
    bool                        ROIEnable;
    uint8_t                     PFrameZeroCbfEn;
    uint8_t                     BFrameZeroCbfEn;
    uint8_t                     ForceIPCMMinQP;
    uint8_t                     IntraTr4x4Percent;
    bool                        MultiPassHmeEnable;
    uint32_t                    IntraPredictionIFrame;
    uint32_t                    IntraPrediction;

    // PAK Params
    uint8_t                     RoundingIntra;
    bool                        RoundingIntraEnabled;
    bool                        EnableAdaptiveRounding;
    bool                        RoundingInterEnabled;
    bool                        EnableAdaptiveTrellisQuantization;
    bool                        TrellisQuantizationEnable;
    bool                        TrellisQuantizationChromaDisable;
    uint32_t                    RoundingInter;
    uint32_t                    RoundingInterB;
    uint32_t                    TrellisQuantizationRounding;
    uint8_t                     FrmHdrEncodingFrequency;
    bool                        ExtendedRhoDomainEn;
};
#endif

static const uint8_t CodecHal_TargetUsageToMode_AVC[NUM_TARGET_USAGE_MODES] =
{ encodeNormalMode,  encodeQualityMode,  encodeQualityMode, encodeNormalMode,
encodeNormalMode, encodeNormalMode, encodeNormalMode, encodePerformanceMode };

typedef struct _CODEC_AVC_REF_PIC_SELECT_LIST
{
    uint8_t                 FrameIdx;
    MOS_SURFACE             sBuffer;
} CODEC_AVC_REF_PIC_SELECT_LIST, *PCODEC_AVC_REF_PIC_SELECT_LIST;

typedef struct _CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS
{
    PMOS_SURFACE                psPreDeblockSurface;
    PMOS_SURFACE                psPostDeblockSurface;
    PMOS_RESOURCE               presMacroblockIldbStreamOutBuffer1;
    PMOS_RESOURCE               presMacroblockIldbStreamOutBuffer2;

    bool                        bBrcEnabled;
    PMHW_BATCH_BUFFER           pImgStateBatchBuffer;
    PMOS_RESOURCE               presBrcHistoryBuffer;

    bool                        bDeblockerStreamOutEnable;
    bool                        bPostDeblockOutEnable;
    bool                        bPreDeblockOutEnable;
    bool                        bPerMBStreamOutEnable;
} CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS, *PCODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS;

typedef struct _CODECHAL_ENCODE_AVC_ME_CURBE
{
    // DW0
    union
    {
        struct
        {
            uint32_t   SkipModeEn                          : MOS_BITFIELD_BIT(       0 );
            uint32_t   AdaptiveEn                          : MOS_BITFIELD_BIT(       1 );
            uint32_t   BiMixDis                            : MOS_BITFIELD_BIT(       2 );
            uint32_t                                       : MOS_BITFIELD_RANGE(  3, 4 );
            uint32_t   EarlyImeSuccessEn                   : MOS_BITFIELD_BIT(       5 );
            uint32_t                                       : MOS_BITFIELD_BIT(       6 );
            uint32_t   T8x8FlagForInterEn                  : MOS_BITFIELD_BIT(       7 );
            uint32_t                                       : MOS_BITFIELD_RANGE(  8,23 );
            uint32_t   EarlyImeStop                        : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW0;

    // DW1
    union
    {
        struct
        {
            uint32_t   MaxNumMVs                           : MOS_BITFIELD_RANGE(  0, 5 );
            uint32_t                                       : MOS_BITFIELD_RANGE(  6,15 );
            uint32_t   BiWeight                            : MOS_BITFIELD_RANGE( 16,21 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 22,27 );
            uint32_t   UniMixDisable                       : MOS_BITFIELD_BIT(      28 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 29,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW1;

    // DW2
    union
    {
        struct
        {
            uint32_t   MaxLenSP                            : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   MaxNumSU                            : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 16,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW2;

    // DW3
    union
    {
        struct
        {
            uint32_t   SrcSize                             : MOS_BITFIELD_RANGE(  0, 1 );
            uint32_t                                       : MOS_BITFIELD_RANGE(  2, 3 );
            uint32_t   MbTypeRemap                         : MOS_BITFIELD_RANGE(  4, 5 );
            uint32_t   SrcAccess                           : MOS_BITFIELD_BIT(       6 );
            uint32_t   RefAccess                           : MOS_BITFIELD_BIT(       7 );
            uint32_t   SearchCtrl                          : MOS_BITFIELD_RANGE(  8,10 );
            uint32_t   DualSearchPathOption                : MOS_BITFIELD_BIT(      11 );
            uint32_t   SubPelMode                          : MOS_BITFIELD_RANGE( 12,13 );
            uint32_t   SkipType                            : MOS_BITFIELD_BIT(      14 );
            uint32_t   DisableFieldCacheAlloc              : MOS_BITFIELD_BIT(      15 );
            uint32_t   InterChromaMode                     : MOS_BITFIELD_BIT(      16 );
            uint32_t   FTEnable                            : MOS_BITFIELD_BIT(      17 );
            uint32_t   BMEDisableFBR                       : MOS_BITFIELD_BIT(      18 );
            uint32_t   BlockBasedSkipEnable                : MOS_BITFIELD_BIT(      19 );
            uint32_t   InterSAD                            : MOS_BITFIELD_RANGE( 20,21 );
            uint32_t   IntraSAD                            : MOS_BITFIELD_RANGE( 22,23 );
            uint32_t   SubMbPartMask                       : MOS_BITFIELD_RANGE( 24,30 );
            uint32_t                                       : MOS_BITFIELD_BIT(      31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW3;

    // DW4
    union
    {
        struct
        {
            uint32_t                                       : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   PictureHeightMinus1                 : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   PictureWidth                        : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW4;

    // DW5
    union
    {
        struct
        {
            uint32_t                                       : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   QpPrimeY                            : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   RefWidth                            : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   RefHeight                           : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW5;

    // DW6
    union
    {
        struct
        {
            uint32_t                                       : MOS_BITFIELD_RANGE(  0, 2 );
            uint32_t   WriteDistortions                    : MOS_BITFIELD_BIT(       3 );
            uint32_t   UseMvFromPrevStep                   : MOS_BITFIELD_BIT(       4 );
            uint32_t                                       : MOS_BITFIELD_RANGE(  5, 7 );
            uint32_t   SuperCombineDist                    : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   MaxVmvR                             : MOS_BITFIELD_RANGE( 16,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW6;

    // DW7
    union
    {
        struct
        {
            uint32_t                                       : MOS_BITFIELD_RANGE(  0,15 );
            uint32_t   MVCostScaleFactor                   : MOS_BITFIELD_RANGE( 16,17 );
            uint32_t   BilinearEnable                      : MOS_BITFIELD_BIT(      18 );
            uint32_t   SrcFieldPolarity                    : MOS_BITFIELD_BIT(      19 );
            uint32_t   WeightedSADHAAR                     : MOS_BITFIELD_BIT(      20 );
            uint32_t   AConlyHAAR                          : MOS_BITFIELD_BIT(      21 );
            uint32_t   RefIDCostMode                       : MOS_BITFIELD_BIT(      22 );
            uint32_t                                       : MOS_BITFIELD_BIT(      23 );
            uint32_t   SkipCenterMask                      : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW7;

    // DW8
    union
    {
        struct
        {
            uint32_t   Mode0Cost                           : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   Mode1Cost                           : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   Mode2Cost                           : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   Mode3Cost                           : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW8;

    // DW9
    union
    {
        struct
        {
            uint32_t   Mode4Cost                           : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   Mode5Cost                           : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   Mode6Cost                           : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   Mode7Cost                           : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW9;

    // DW10
    union
    {
        struct
        {
            uint32_t   Mode8Cost                           : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   Mode9Cost                           : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   RefIDCost                           : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   ChromaIntraModeCost                 : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW10;

    // DW11
    union
    {
        struct
        {
            uint32_t   MV0Cost                             : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   MV1Cost                             : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   MV2Cost                             : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   MV3Cost                             : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW11;

    // DW12
    union
    {
        struct
        {
            uint32_t   MV4Cost                             : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   MV5Cost                             : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   MV6Cost                             : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   MV7Cost                             : MOS_BITFIELD_RANGE( 24,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW12;

    // DW13
    union
    {
        struct
        {
            uint32_t   NumRefIdxL0MinusOne                 : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   NumRefIdxL1MinusOne                 : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   RefStreaminCost                     : MOS_BITFIELD_RANGE( 16,23 );
            uint32_t   ROIEnable                           : MOS_BITFIELD_RANGE( 24,26 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 27,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW13;

    // DW14
    union
    {
        struct
        {
            uint32_t   List0RefID0FieldParity              : MOS_BITFIELD_BIT(       0 );
            uint32_t   List0RefID1FieldParity              : MOS_BITFIELD_BIT(       1 );
            uint32_t   List0RefID2FieldParity              : MOS_BITFIELD_BIT(       2 );
            uint32_t   List0RefID3FieldParity              : MOS_BITFIELD_BIT(       3 );
            uint32_t   List0RefID4FieldParity              : MOS_BITFIELD_BIT(       4 );
            uint32_t   List0RefID5FieldParity              : MOS_BITFIELD_BIT(       5 );
            uint32_t   List0RefID6FieldParity              : MOS_BITFIELD_BIT(       6 );
            uint32_t   List0RefID7FieldParity              : MOS_BITFIELD_BIT(       7 );
            uint32_t   List1RefID0FieldParity              : MOS_BITFIELD_BIT(       8 );
            uint32_t   List1RefID1FieldParity              : MOS_BITFIELD_BIT(       9 );
            uint32_t                                       : MOS_BITFIELD_RANGE( 10,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW14;

    // DW15
    union
    {
        struct
        {
            uint32_t   PrevMvReadPosFactor                 : MOS_BITFIELD_RANGE(  0, 7 );
            uint32_t   MvShiftFactor                       : MOS_BITFIELD_RANGE(  8,15 );
            uint32_t   Reserved                            : MOS_BITFIELD_RANGE( 16,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW15;

    struct
    {
        // DW16
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_0;
                SearchPathDelta   SPDelta_1;
                SearchPathDelta   SPDelta_2;
                SearchPathDelta   SPDelta_3;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW16;

        // DW17
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_4;
                SearchPathDelta   SPDelta_5;
                SearchPathDelta   SPDelta_6;
                SearchPathDelta   SPDelta_7;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW17;

        // DW18
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_8;
                SearchPathDelta   SPDelta_9;
                SearchPathDelta   SPDelta_10;
                SearchPathDelta   SPDelta_11;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW18;

        // DW19
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_12;
                SearchPathDelta   SPDelta_13;
                SearchPathDelta   SPDelta_14;
                SearchPathDelta   SPDelta_15;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW19;

        // DW20
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_16;
                SearchPathDelta   SPDelta_17;
                SearchPathDelta   SPDelta_18;
                SearchPathDelta   SPDelta_19;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW20;

        // DW21
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_20;
                SearchPathDelta   SPDelta_21;
                SearchPathDelta   SPDelta_22;
                SearchPathDelta   SPDelta_23;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW21;

        // DW22
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_24;
                SearchPathDelta   SPDelta_25;
                SearchPathDelta   SPDelta_26;
                SearchPathDelta   SPDelta_27;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW22;

        // DW23
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_28;
                SearchPathDelta   SPDelta_29;
                SearchPathDelta   SPDelta_30;
                SearchPathDelta   SPDelta_31;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW23;

        // DW24
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_32;
                SearchPathDelta   SPDelta_33;
                SearchPathDelta   SPDelta_34;
                SearchPathDelta   SPDelta_35;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW24;

        // DW25
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_36;
                SearchPathDelta   SPDelta_37;
                SearchPathDelta   SPDelta_38;
                SearchPathDelta   SPDelta_39;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW25;

        // DW26
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_40;
                SearchPathDelta   SPDelta_41;
                SearchPathDelta   SPDelta_42;
                SearchPathDelta   SPDelta_43;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW26;

        // DW27
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_44;
                SearchPathDelta   SPDelta_45;
                SearchPathDelta   SPDelta_46;
                SearchPathDelta   SPDelta_47;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW27;

        // DW28
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_48;
                SearchPathDelta   SPDelta_49;
                SearchPathDelta   SPDelta_50;
                SearchPathDelta   SPDelta_51;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW28;

        // DW29
        union
        {
            struct
            {
                SearchPathDelta   SPDelta_52;
                SearchPathDelta   SPDelta_53;
                SearchPathDelta   SPDelta_54;
                SearchPathDelta   SPDelta_55;
            };
            struct
            {
                uint32_t   Value;
            };
        } DW29;
    } SPDelta;

    // DW30
    union
    {
        struct
        {
            uint32_t   ActualMBWidth                            : MOS_BITFIELD_RANGE(  0,15 );
            uint32_t   ActualMBHeight                           : MOS_BITFIELD_RANGE( 16,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW30;

    // DW31
    union
    {
        struct
        {
            uint32_t   Reserved                                 : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW31;

    // DW32
    union
    {
        struct
        {
            uint32_t   _4xMeMvOutputDataSurfIndex               : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW32;

    // DW33
    union
    {
        struct
        {
            uint32_t   _16xOr32xMeMvInputDataSurfIndex          : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW33;

    // DW34
    union
    {
        struct
        {
            uint32_t   _4xMeOutputDistSurfIndex                 : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW34;

    // DW35
    union
    {
        struct
        {
            uint32_t   _4xMeOutputBrcDistSurfIndex              : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW35;

    // DW36
    union
    {
        struct
        {
            uint32_t   VMEFwdInterPredictionSurfIndex           : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW36;

    // DW37
    union
    {
        struct
        {
            uint32_t   VMEBwdInterPredictionSurfIndex           : MOS_BITFIELD_RANGE( 0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW37;

    // DW38
    union
    {
        struct
        {
            uint32_t   VDEncStreamInSurfIndex                   : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW38;

} CODECHAL_ENCODE_AVC_ME_CURBE, *PCODECHAL_ENCODE_AVC_ME_CURBE;
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_ENCODE_AVC_ME_CURBE)) == 39);

// AVC ME CURBE init data for G9 CM Kernel
static const uint32_t g_cInit_CODECHAL_ENCODE_AVC_ME_CURBE[39] =
{
    0x00000000, 0x00200010, 0x00003939, 0x77a43000, 0x00000000, 0x28300000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
};

// CURBE for Static Frame Detection kernel
typedef struct _CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON
{
    union
    {
        struct
        {
            uint32_t   VDEncModeDisable                            : MOS_BITFIELD_BIT(        0 );
            uint32_t   BRCModeEnable                               : MOS_BITFIELD_BIT(        1 );
            uint32_t   SliceType                                   : MOS_BITFIELD_RANGE(  2,  3 );
            uint32_t                                               : MOS_BITFIELD_BIT(        4 );
            uint32_t   StreamInType                                : MOS_BITFIELD_RANGE(  5,  8 );
            uint32_t   EnableAdaptiveMvStreamIn                    : MOS_BITFIELD_BIT(        9 );
            uint32_t                                               : MOS_BITFIELD_BIT(       10 );
            uint32_t   EnableIntraCostScalingForStaticFrame        : MOS_BITFIELD_BIT(       11 );
            uint32_t   Reserved                                    : MOS_BITFIELD_RANGE( 12, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW0;

    union
    {
        struct
        {
            uint32_t   QPValue                                     : MOS_BITFIELD_RANGE(  0,  7 );
            uint32_t   NumOfRefs                                   : MOS_BITFIELD_RANGE(  8, 15 );
            uint32_t   HMEStreamInRefCost                          : MOS_BITFIELD_RANGE( 16, 23 );
            uint32_t   Reserved                                    : MOS_BITFIELD_RANGE( 24, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW1;

    union
    {
        struct
        {
            uint32_t   FrameWidthInMBs                             : MOS_BITFIELD_RANGE(  0, 15 );     // round-up to 4-MB aligned
            uint32_t   FrameHeightInMBs                            : MOS_BITFIELD_RANGE( 16, 31 );     // round-up to 4-MB aligned
        };
        struct
        {
            uint32_t   Value;
        };
    } DW2;

    union
    {
        struct
        {
            uint32_t   LargeMvThresh                               : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW3;

    union
    {
        struct
        {
            uint32_t   TotalLargeMvThreshold                       : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW4;

    union
    {
        struct
        {
            uint32_t   ZMVThreshold                                : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW5;

    union
    {
        struct
        {
            uint32_t   TotalZMVThreshold                           : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW6;

    union
    {
        struct
        {
            uint32_t   MinDistThreshold                            : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW7;

    uint8_t                                                        CostTable[52];

    union
    {
        struct
        {
            uint32_t   ActualWidthInMB                             : MOS_BITFIELD_RANGE(  0, 15 );
            uint32_t   ActualHeightInMB                            : MOS_BITFIELD_RANGE( 16, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW21;

    union
    {
        struct
        {
            uint32_t   Reserved                                    : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW22;

    union
    {
        struct
        {
            uint32_t   Reserved                                    : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW23;

    union
    {
        struct
        {
            uint32_t   VDEncInputImagStateIndex                    : MOS_BITFIELD_RANGE( 0, 31 );      // used in VDEnc CQP mode
        };
        struct
        {
            uint32_t   Value;
        };
    } DW24;

    union
    {
        struct
        {
            uint32_t   Reserved                                    : MOS_BITFIELD_RANGE(  0,31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW25;

    union
    {
        struct
        {
            uint32_t   MVDataSurfaceIndex                          : MOS_BITFIELD_RANGE( 0, 31 );      // contains HME MV Data generated by HME kernel
        };
        struct
        {
            uint32_t   Value;
        };
    } DW26;

    union
    {
        struct
        {
            uint32_t   InterDistortionSurfaceIndex                 : MOS_BITFIELD_RANGE( 0, 31 );      // contains HME Inter Distortion generated by HME kernel
        };
        struct
        {
            uint32_t   Value;
        };
    } DW27;

    union
    {
        struct
        {
            uint32_t   OutputDataSurfaceIndex                      : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW28;

    union
    {
        struct
        {
            uint32_t   VDEncOutputImagStateIndex                   : MOS_BITFIELD_RANGE( 0, 31 );
        };
        struct
        {
            uint32_t   Value;
        };
    } DW29;

} CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON, *PCODECHAL_ENCODE_AVC_SFD_CURBE_COMMON;
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON)) == 30);

typedef struct _CODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS
{
    uint32_t                                dwDownscaledWidthInMb4x;
    uint32_t                                dwDownscaledHeightInMb4x;
    uint32_t                                dwMeMvBottomFieldOffset;
    uint32_t                                dwMeDistortionBottomFieldOffset;
    PMOS_RESOURCE                           presVDEncImageStateInputBuffer;
    PMOS_SURFACE                            psMeMvDataSurface;
    PMOS_SURFACE                            psMeDistortionSurface;
    PMOS_RESOURCE                           presOutputBuffer;
    PMOS_RESOURCE                           presVDEncImageStateOutputBuffer;
    PMHW_KERNEL_STATE                       pKernelState;
    bool                                    bVdencActive;
    bool                                    bVdencBrcEnabled;
} CODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS, *PCODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS;

typedef struct _CODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS
{
    PMHW_KERNEL_STATE                       pKernelState;
} CODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS, *PCODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS;

     //!
     //! \brief    Vertical MV component range based on levelIdc
     //! \details  VDBOX private function to get vertical MV componet range
     //! \param    [in] levelIdc
     //!           AVC level
     //! \return   uint32_t
     //!           return the max vertical mv component base on input level
     //!
     uint32_t CodecHalAvcEncode_GetMaxVmvR(uint8_t levelIdc);

     //!
     //! \brief    Get MV component range based on levelIdc
     //! \details  VDBOX private function to get MV componet range
     //! \param    [in] levelIdc
     //!           AVC level
     //! \return   uint32_t
     //!           return the max mv component base on input level
     //!
     uint32_t CodecHalAvcEncode_GetMaxMvLen(uint8_t levelIdc);

     //!
     //! \brief    Get the filed parity: Top filed or Bottom filed
     //! \details  Client facing function to get the filed parity: Top filed or Bottom filed
     //! \param    [in] params
     //!           PCODEC_AVC_ENCODE_SLICE_PARAMS pSlcParams
     //! \param    [list] list
     //!           forword or backword reference
     //! \param    [in] index
     //!           reference frame index
     //! \return   uint32_t
     //!           Bottom field or Top field
     //!
     bool CodecHalAvcEncode_GetFieldParity(
        PCODEC_AVC_ENCODE_SLICE_PARAMS      params,
        uint32_t                            list,
        uint32_t                            index);

     //!
     //! \brief    Get profile level max frame size
     //! \param    [in] seqParams
     //!           Encoder Sequence params
     //! \param    [in] encoder
     //!           Encoder structure
     //! \param    [in] profileLevelMaxFrame
     //!           Profile Level Max Frame
     //! \return   MOS_STATUS
     //!           MOS_STATUS_SUCCESS if success, else fail reason
     //!
     MOS_STATUS CodecHalAvcEncode_GetProfileLevelMaxFrameSize(
        PCODEC_AVC_ENCODE_SEQUENCE_PARAMS   seqParams,
        CodechalEncoderState*               encoder,
        uint32_t*                           profileLevelMaxFrame);

     //! \brief    Get the max number of allowed slice
     //! \param    [in] profileIdc
     //!           AVC profile idc
     //! \param    [in] levelIdc
     //!           AVC level idc
     //! \param    [in] framesPer100Sec
     //!           frame Per 100Sec
     //! \return   uint16_t
     //!           return uiMaxAllowedNumSlices
     //!
     uint16_t CodecHalAvcEncode_GetMaxNumSlicesAllowed(
        CODEC_AVC_PROFILE_IDC profileIdc,
        CODEC_AVC_LEVEL_IDC   levelIdc,
        uint32_t                 framesPer100Sec);

     //!
     //! \brief    Use to pack picture header related params
     //! \param    [in] params
     //!           picture header pack params
     //! \return   MOS_STATUS
     //!           MOS_STATUS_SUCCESS if success, else fail reason
     //!
     MOS_STATUS CodecHalAvcEncode_PackPictureHeader(
        PCODECHAL_ENCODE_AVC_PACK_PIC_HEADER_PARAMS    params);

     //!
     //! \brief    Use to pack slice header related params
     //! \param    [in] params
     //!           slice header pack params
     //! \return   MOS_STATUS
     //!           MOS_STATUS_SUCCESS if success, else fail reason
     //!
     MOS_STATUS CodecHalAvcEncode_PackSliceHeader(
        PCODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS    params);

     //!
     //! \brief    Use to get picture num of slice header to be packed
     //! \param    [in] params
     //!           pack slice header pack params
     //! \param    [in] list
     //!           forword or backword reference
     //! \return   void
     //!
     static void CodecHal_PackSliceHeader_GetPicNum (
        PCODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS     params,
        uint8_t                                         list);

//!
//! \class    CodechalEncodeAvcBase
//! \brief    CodechalE encode Avc base
//!
class CodechalEncodeAvcBase : public CodechalEncoderState
{
public:
    // AvcState functions.
    //!
    //! \brief    Constructor
    //!
    CodechalEncodeAvcBase(
        CodechalHwInterface *   hwInterface,
        CodechalDebugInterface *debugInterface,
        PCODECHAL_STANDARD_INFO standardInfo);

    //!
    //! \brief    Copy constructor
    //!
    CodechalEncodeAvcBase(const CodechalEncodeAvcBase&) = delete;

    //!
    //! \brief    Copy assignment operator
    //!
    CodechalEncodeAvcBase& operator=(const CodechalEncodeAvcBase&) = delete;

    //!
    //! \brief    Destructor
    //!
    virtual ~CodechalEncodeAvcBase();

    //Encode interface definitions
    //!
    //! \brief    Initialize standard related members.
    //! \details  Initialize members, set proper value
    //!           to involved variables, allocate resources.
    //! \param    [in] settings
    //!           Encode settings.
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS Initialize(CodechalSetting * settings);

    virtual MOS_STATUS GetStatusReport(
        EncodeStatus       *encodeStatus,
        EncodeStatusReport *encodeStatusReport);

    //!
    //! \brief    Encode User Feature Key Report.
    //! \details  Report user feature values set by encode.
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS UserFeatureKeyReport();

    //!
    //! \brief    Initialize Encode ME kernel state
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS InitKernelStateMe() = 0;

    //!
    //! \brief    Set Encode ME kernel Curbe data.
    //!
    //! \param    [in] params
    //!           Pointer to the MeCurbeParams
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetCurbeMe( MeCurbeParams* params ) = 0;

    //!
    //! \brief    Set Encode ME kernel Surfaces
    //!
    //! \param    [in] cmdBuffer
    //!           Pointer to the MOS_COMMAND_BUFFER
    //! \param    [in] params
    //!           Pointer to the CODECHAL_ME_SURFACE_PARAMS
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SendMeSurfaces(
        PMOS_COMMAND_BUFFER         cmdBuffer,
        MeSurfaceParams* params) = 0;
    //!
    //! \brief    AVC State Initialization.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS Initialize();


    //!
    //! \brief    AVC Resource Allocation for ENC.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS AllocateEncResources();

    //!
    //! \brief    AVC Resource Allocation for Encoder.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS AllocateResources();

    //!
    //! \brief    Set AVC Sequence Structs.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetSequenceStructs();

    //!
    //! \brief    Set AVC Picture Structs.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetPictureStructs();

    //!
    //! \brief    Set AVC Slice Structs.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetSliceStructs();

    //!
    //! \brief    Run Encode ME kernel
    //!
    //! \param    [in] brcBuffers
    //!           Pointer to the EncodeBrcBuffers
    //! \param    [in] hmeLevel
    //!           Hme level
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS EncodeMeKernel(
        EncodeBrcBuffers* brcBuffers,
        HmeLevel          hmeLevel);

    //!
    //! \brief    Allocate Batch Buffer For PakSlice.
    //! 
    //! \param    [in] numSlices
    //!           Number of Slice
    //! \param    [in] numPakPasses
    //!           Number of PAK pass.
    //! \param    [in] currRecycledBufIdx
    //!           Current Recycle Buffer Index.
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS AllocateBatchBufferForPakSlices(
        uint32_t numSlices,
        uint8_t numPakPasses,
        uint8_t currRecycledBufIdx);

    //!
    //! \brief    Release Batch Buffer For PakSlice.
    //! 
    //! \param    [in] currRecycledBufIdx
    //!           Current Recycle Buffer Index.
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS ReleaseBatchBufferForPakSlices( uint8_t currRecycledBufIdx);

    //!
    //! \brief    Initialize kernel binary size info.
    //! 
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    MOS_STATUS AddIshSize(uint32_t kuid, uint8_t* kernelBase);

    //!
    //! \brief    Calculate scaling list
    //!
    //! \return   void
    //!
    void ScalingListFlat();

    //!
    //! \brief    Calculate scaling list
    //!
    //! \return   void
    //!
    void ScalingListFallbackRuleA();

    //!
    //! \brief    Get Dist Scale factor
    //!
    //! \return   void
    //!
    void GetDistScaleFactor();

    //!
    //! \brief    Initialize MMC state
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS InitMmcState();

    //!
    //! \brief    Get bidirectional weight
    //!
    //! \param    [in] distScaleFactorRefID0List0
    //!           DistScaleFactorRefID0List0
    //! \param    [in] weightedBiPredIdc
    //!           Same as AVC syntax element.
    //!
    //! \return   int32_t
    //!           Bidirectional weight
    //!
    int32_t GetBiWeight(
        uint32_t distScaleFactorRefID0List0,
        uint16_t weightedBiPredIdc);

    //!
    //! \brief    Update the slice count according to the slice shutdown policy
    //!
    virtual void UpdateSSDSliceCount();

    //!
    //! \brief    Build slices with header insertion
    //! \param    [in] cmdBuffer
    //!           command buffer
    //! \param    [in] params
    //!           VDBOX AVC slice state params
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS SendSlice(
        PMOS_COMMAND_BUFFER             cmdBuffer,
        PMHW_VDBOX_AVC_SLICE_STATE      params);

    //!
    //! \brief      Store number passes
    //! 
    //! \param      [in] encodeStatusBuf
    //!             Encode status buffer
    //! \param      [in] miInterface
    //!             Mi interface
    //! \param      [in] cmdBuffer
    //!             Command buffer
    //! \param      [in] currPass
    //!             Curr pass
    //!
    //! \return     MOS_STATUS
    //!             MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS StoreNumPasses(
        EncodeStatusBuffer             *encodeStatusBuf,
        MhwMiInterface                 *miInterface,
        PMOS_COMMAND_BUFFER            cmdBuffer,
        uint32_t                       currPass);

    virtual MOS_STATUS AddMfxAvcSlice(
        PMOS_COMMAND_BUFFER        cmdBuffer,
        PMHW_BATCH_BUFFER          batchBuffer,
        PMHW_VDBOX_AVC_SLICE_STATE avcSliceState);

    virtual MOS_STATUS AddVdencSliceStateCmd(
        PMOS_COMMAND_BUFFER        cmdBuffer,
        PMHW_VDBOX_AVC_SLICE_STATE params);

#if USE_CODECHAL_DEBUG_TOOL
    MOS_STATUS DumpSeqParams(
        PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams,
        PCODEC_AVC_IQ_MATRIX_PARAMS    matrixParams);

    MOS_STATUS DumpPicParams(
        PCODEC_AVC_ENCODE_PIC_PARAMS   picParams,
        PCODEC_AVC_IQ_MATRIX_PARAMS matrixParams);

    MOS_STATUS DumpFeiPicParams(
        CodecEncodeAvcFeiPicParams *feiPicParams);

    MOS_STATUS DumpSliceParams(
        PCODEC_AVC_ENCODE_SLICE_PARAMS sliceParams,
        PCODEC_AVC_ENCODE_PIC_PARAMS   picParams);

    MOS_STATUS DumpVuiParams(
        PCODECHAL_ENCODE_AVC_VUI_PARAMS avcVuiParams);

#endif

protected:
    //!
    //! \brief    Set MFX_PIPE_MODE_SELECT parameter
    //!
    //! \param    [in] genericParam
    //!           CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS
    //! \param    [out] param
    //!           reference to MHW_VDBOX_PIPE_MODE_SELECT_PARAMS
    //!
    //! \return   void
    //!
    virtual void SetMfxPipeModeSelectParams(
        const CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS& genericParam,
        MHW_VDBOX_PIPE_MODE_SELECT_PARAMS& param);

    //!
    //! \brief    set MFX_PIPE_BUF_ADDR_STATE parameter
    //!
    //! \param    [in] genericParam
    //!           CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS
    //! \param    [out] param
    //!           reference to MHW_VDBOX_PIPE_BUF_ADDR_PARAMS
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetMfxPipeBufAddrStateParams(
        CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS genericParam,
        MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& param);

    //!
    //! \brief    Set MFX_IND_OBJ_BASE_ADDR_STATE parameter
    //!
    //! \param    [out] param
    //!           reference to MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS
    //!
    //! \return   void
    //!
    virtual void SetMfxIndObjBaseAddrStateParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS& param);

    //!
    //! \brief    Set MHW_VDBOX_BSP_BUF_BASE_ADDR_STATE parameter
    //!
    //! \param    [out] param
    //!           reference to MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS
    //!
    //! \return   void
    //!
    virtual void SetMfxBspBufBaseAddrStateParams(MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS& param);

    //!
    //! \brief    Set MHW_VDBOX_QM_STATE parameter
    //!
    //! \param    [out] qmParams
    //!           reference to MHW_VDBOX_QM_PARAMS
    //! \param    [out] fqmParams
    //!           reference to MHW_VDBOX_QM_PARAMS
    //!
    //! \return   void
    //!
    virtual void SetMfxQmStateParams(MHW_VDBOX_QM_PARAMS& qmParams, MHW_VDBOX_QM_PARAMS & fqmParams);

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [out] param
    //!           reference to MHW_VDBOX_AVC_IMG_PARAMS
    //!
    //! \return   void
    //!
    virtual void SetMfxAvcImgStateParams(MHW_VDBOX_AVC_IMG_PARAMS& param);

public:
    PMOS_INTERFACE                              m_origOsInterface           = nullptr;    //!< Os Interface
    CodechalHwInterface                         *m_origHwInterface          = nullptr;    //!< Hw Interface
    PMHW_STATE_HEAP_INTERFACE                   m_origStateHeapInterface    = nullptr;    //!< StateHeap Interface

    // Parameters passed by application
    PCODEC_AVC_ENCODE_PIC_PARAMS                m_avcPicParams[CODEC_AVC_MAX_PPS_NUM];    //!< Pointer to array of picture parameter, could be removed
    PCODEC_AVC_ENCODE_SEQUENCE_PARAMS           m_avcSeqParams[CODEC_AVC_MAX_SPS_NUM];    //!< Pointer to array of sequence parameter, could be removed
    PCODEC_AVC_ENCODE_PIC_PARAMS                m_avcPicParam           = nullptr;  //!< Pointer to AVC picture parameter
    PCODEC_AVC_ENCODE_SEQUENCE_PARAMS           m_avcSeqParam           = nullptr;  //!< Pointer to AVC sequence parameter
    PCODECHAL_ENCODE_AVC_QUALITY_CTRL_PARAMS    m_avcQCParams           = nullptr;  //!< Pointer to video quality control parameter
    PCODECHAL_ENCODE_AVC_ROUNDING_PARAMS        m_avcRoundingParams     = nullptr;  //!< Pointer to AVC rounding parameter
    PCODECHAL_ENCODE_AVC_VUI_PARAMS             m_avcVuiParams          = nullptr;  //!< Pointer to AVC Uvi parameter
    PCODEC_AVC_ENCODE_SLICE_PARAMS              m_avcSliceParams        = nullptr;  //!< Pointer to AVC slice parameter
    CodecEncodeAvcFeiPicParams                  *m_avcFeiPicParams       = nullptr;  //!< Pointer to FEI picture parameter
    PCODEC_AVC_IQ_MATRIX_PARAMS              m_avcIQMatrixParams     = nullptr;  //!< Pointer to IQMaxtrix parameter
    PCODEC_AVC_ENCODE_IQ_WEIGTHSCALE_LISTS      m_avcIQWeightScaleLists = nullptr;  //!< Pointer to IQWidght ScaleLists
    CODEC_AVC_ENCODE_USER_FLAGS                 m_userFlags;                        //!< Encoder user flag settings
    uint32_t                                    m_reconFrameSurfaceId[CODEC_AVC_NUM_UNCOMPRESSED_SURFACE];
    CODECHAL_ENCODE_AVC_ENCODER_USAGE           m_encoderUsage = CODECHAL_ENCODE_AVC_SINGLE_PASS;

    CODEC_PIC_ID                                m_picIdx[CODEC_AVC_MAX_NUM_REF_FRAME];              //!< Picture index
    PCODEC_REF_LIST                             m_refList[CODEC_AVC_NUM_UNCOMPRESSED_SURFACE];   //!< Pointer to reference list
    CODEC_AVC_FRAME_STORE_ID                 m_avcFrameStoreID[CODEC_AVC_MAX_NUM_REF_FRAME];     //!< Refer to CODEC_AVC_FRAME_STORE_ID
    CODECHAL_ENCODE_AVC_NAL_UNIT_TYPE           m_nalUnitType;                      //!< Nal unit type
    PCODECHAL_NAL_UNIT_PARAMS                   *m_nalUnitParams    = nullptr;      //!< Pointers to NAL unit parameters array
    uint16_t                                    m_sliceHeight       = 0;            //!< Slice height
    uint8_t                                     m_biWeightNumB      = 0;            //!< Bi direction Weight B frames num
    bool                                        m_deblockingEnabled = false;        //!< Enable deblocking flag
    bool                                        m_mbaffEnabled      = false;        //!< Enable MBAFF flag
    bool                                        m_firstFieldIdrPic  = false;        //!< First field IDR flag
    bool                                        m_hmeEnabled        = false;        //!< Enable HME flag
    bool                                        m_16xMeEnabled      = false;        //!< Enable 16x ME flag
    bool                                        m_32xMeEnabled      = false;        //!< Enable 32x ME flag
    bool                                        m_skipBiasAdjustmentEnable  = false;//!< Enable SkipBiasAdjustment flag
    bool                                        m_staticFrameDetectionInUse = false;//!< Enable Static Frame Detection flag
    uint32_t                                    m_sliceStructCaps = 0;              //!< Slice struct

    CODECHAL_ENCODE_AVC_TQ_PARAMS               m_trellisQuantParams;               //!< Trellis Quantization params

    // B-frame
    uint32_t                                    m_distScaleFactorList0[CODEC_AVC_MAX_NUM_REF_FRAME * 2];    //!< the DistScaleFactor used to derive temporal direct motion vector
    uint32_t                                    m_biWeight = 0;                     //!< Bidirectional Weight

    // Batch Buffers
    MHW_BATCH_BUFFER                            m_batchBufferForVdencImgStat[CODECHAL_ENCODE_RECYCLED_BUFFER_NUM]; //!< VDEnc image state batch buffers

    // ME
    CodechalKernelHme                           *m_hmeKernel = nullptr;           //!< ME kernel object
    MOS_SURFACE                                 m_4xMeMvDataBuffer;               //!< 4x motion estimation MV data buffer
    uint32_t                                    m_meMvBottomFieldOffset = 0;      //!< ME MV bottom filed offset
    MOS_SURFACE                                 m_16xMeMvDataBuffer;              //!< 16x motion estimation MV data buffer
    uint32_t                                    m_meMv16xBottomFieldOffset = 0;   //!< 16x motion estimation MV bottom filed offset
    MOS_SURFACE                                 m_32xMeMvDataBuffer;              //!< 32x motion estimation MV data buffer
    uint32_t                                    m_meMv32xBottomFieldOffset = 0;   //!< 32x motion estimation MV bottom filed offset
    MOS_SURFACE                                 m_4xMeDistortionBuffer;           //!< 4x ME distortion buffer
    uint32_t                                    m_meDistortionBottomFieldOffset = 0; //!< ME distortion bottom field offset
    uint8_t                                     *m_bmeMethodTable = nullptr;      //!< Point to BME Method table
    uint8_t                                     *m_meMethodTable  = nullptr;      //!< Pointer to ME Method table

    // PAK Scratch Buffers
    MOS_RESOURCE                                m_intraRowStoreScratchBuffer;                                   //!< Handle of intra row store surface
    MHW_BATCH_BUFFER                            m_batchBufferForPakSlices[CODECHAL_ENCODE_RECYCLED_BUFFER_NUM]; //!< PAK Slice batch buffers
    uint32_t                                    m_pakSliceSize = 0;               //!< PAK Slice Size
    uint32_t                                    m_pakSlicePatchListSize = 0;      //!< PAK Slice patch list size
    uint32_t                                    m_currPakSliceIdx = 0;            //!< Current PAK slice index

    bool                                        m_4xMeDistortionBufferSupported = false;  //!< Generation Specific Support Flags & User Feature Key Reads

    bool                                        m_sliceSizeStreamoutSupported = false;    //!< Enable PAK slice size streamout, valid for AVC VDEnc on KBL/CNL+
    MOS_RESOURCE                                m_pakSliceSizeStreamoutBuffer;            //!< PAK slice size streamout buffer

    bool                                        m_crePrefetchEnable = false;              //!< Enable CRE prefetch flag
    bool                                        m_tlbPrefetchEnable = false;              //!< Enable TLB prefetch flag

    const uint8_t m_codechalEncodeAvcSfdCostTablePFrame[CODEC_AVC_NUM_QP] =
        {
            44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 60, 60, 60, 60, 73, 73, 73, 76, 76, 76, 88, 89, 89, 91, 92, 93, 104, 104, 106, 107, 108, 109, 120, 120, 122, 123, 124, 125, 136, 136, 138, 139, 140, 141, 143, 143};

    const uint8_t m_codechalEncodeAvcSfdCostTableBFrame[CODEC_AVC_NUM_QP] =
        {
            57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 73, 73, 73, 73, 77, 77, 77, 89, 89, 89, 91, 93, 93, 95, 105, 106, 107, 108, 110, 111, 121, 122, 123, 124, 125, 127, 137, 138, 139, 140, 142, 143, 143, 143, 143, 143};

    const uint8_t m_codechalEncodeAvcSfdCostTableVdEnc[CODEC_AVC_NUM_QP] =
        {
            45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 56, 57, 59, 44, 45, 47, 56, 44, 47, 47, 45, 47, 47, 47, 47, 45, 47, 47, 56, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47};

#if USE_CODECHAL_DEBUG_TOOL
protected:
    //!
    //! \brief    Create AVC PAR
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS CreateAvcPar();

    //!
    //! \brief    Destroy AVC PAR
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS DestroyAvcPar();

    //!
    //! \brief    Dump sequence PAR file
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS DumpSeqParFile() { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Dump frame PAR file
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS DumpFrameParFile() { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Populate const parameters
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS PopulateConstParam();

    //!
    //! \brief    Populate target usage as the first parameter of dumped par file
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS PopulateTargetUsage();

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] avcSeqParams
    //!           pointer to AVC encode sequence parameters
    //! \param    [in] avcPicParams
    //!           pointer to AVC encode picture parameters
    //! \param    [in] avcSlcParams
    //!           pointer to AVC encode slice parameters
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS PopulateDdiParam(
        PCODEC_AVC_ENCODE_SEQUENCE_PARAMS avcSeqParams,
        PCODEC_AVC_ENCODE_PIC_PARAMS      avcPicParams,
        PCODEC_AVC_ENCODE_SLICE_PARAMS    avcSlcParams);

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] adaptiveRoundingInterEnable
    //!           adaptive rounding inter enable flag
    //! \param    [in] sliceState
    //!           pointer to slice state
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS PopulateSliceStateParam(
        bool                       adaptiveRoundingInterEnable,
        PMHW_VDBOX_AVC_SLICE_STATE sliceState);

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] *cmd
    //!           pointer to command
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS PopulateSfdParam(
        void *cmd);

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] is16xMeEnabled
    //!           16x ME enabled flag
    //! \param    [in] is32xMeEnabled
    //!           32x ME enabled flag
    //! \param    [in] meMethod
    //!           ME method
    //! \param    [in] *cmd
    //!           pointer to command
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS PopulateHmeParam(
        bool    is16xMeEnabled,
        bool    is32xMeEnabled,
        uint8_t meMethod,
        void    *cmd) { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] *cmd
    //!           pointer to command
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS PopulateBrcInitParam(
        void *cmd) { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] *cmd
    //!           pointer to command
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS PopulateBrcUpdateParam(
        void *cmd) { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] meMethod
    //!           ME method
    //! \param    [in] *cmd
    //!           pointer to command
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS PopulateEncParam(
        uint8_t meMethod,
        void    *cmd) { return MOS_STATUS_SUCCESS; }

    //!
    //! \brief    Set MHW_VDBOX_AVC_IMG_STATE parameter
    //!
    //! \param    [in] cmdBuffer
    //!           pointer to command buffer
    //! \param    [in] secondLevelBatchBuffer
    //!           pointer to second level batch buffer
    //!
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    virtual MOS_STATUS PopulatePakParam(
        PMOS_COMMAND_BUFFER cmdBuffer,
        PMHW_BATCH_BUFFER   secondLevelBatchBuffer) { return MOS_STATUS_SUCCESS; }

    EncodeAvcPar *m_avcPar             = nullptr;  //!< AVC PAR parameters
    bool         m_populateTargetUsage = false;
#endif

    //!
    //! \brief    Set frame store Id for avc codec.
    //! \details
    //! \return   frameIdx
    //!           [in] frame index
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS SetFrameStoreIds(uint8_t frameIdx);
};
#endif // __CODECHAL_ENCODE_AVC_BASE_H__
