text: /*
  * Copyright (c) 2017, 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"
  #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_MAX_SLICE_QP                    (CODEC_AVC_NUM_QP - 1) // 0 - 51 inclusive
  #define CODECHAL_ENCODE_AVC_MIN_ICQ_QUALITYFACTOR           1
  #define CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR           51
  #define CODECHAL_ENCODE_AVC_MAX_SLICES_SUPPORTED            256
  #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_TQ_PARAMS
  {
      uint32_t    dwTqEnabled;
      uint32_t    dwTqRounding;
  } CODECHAL_ENCODE_AVC_TQ_PARAMS, *PCODECHAL_ENCODE_AVC_TQ_PARAMS;
  
  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_PACK_PIC_HEADER_PARAMS
  {
      PBSBuffer                               pBsBuffer;
      PCODEC_AVC_ENCODE_PIC_PARAMS            pPicParams;     // pAvcPicParams[ucPPSIdx]
      PCODEC_AVC_ENCODE_SEQUENCE_PARAMS       pSeqParams;     // pAvcSeqParams[ucSPSIdx]
      PCODECHAL_ENCODE_AVC_VUI_PARAMS         pAvcVuiParams;
      PCODEC_AVC_IQ_MATRIX_PARAMS          pAvcIQMatrixParams;
      PCODECHAL_NAL_UNIT_PARAMS               *ppNALUnitParams;
      CodechalEncodeSeiData*                  pSeiData;
      uint32_t                                dwFrameHeight;
      uint32_t                                dwOriFrameHeight;
      uint16_t                                wPictureCodingType;
      bool                                    bNewSeq;
      bool                                   *pbNewPPSHeader;
      bool                                   *pbNewSeqHeader;
  } CODECHAL_ENCODE_AVC_PACK_PIC_HEADER_PARAMS, *PCODECHAL_ENCODE_AVC_PACK_PIC_HEADER_PARAMS;
  
  typedef struct _CODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS
  {
      PBSBuffer                               pBsBuffer;
      PCODEC_AVC_ENCODE_PIC_PARAMS            pPicParams;     // pAvcPicParams[ucPPSIdx]
      PCODEC_AVC_ENCODE_SEQUENCE_PARAMS       pSeqParams;     // pAvcSeqParams[ucSPSIdx]
      PCODEC_AVC_ENCODE_SLICE_PARAMS          pAvcSliceParams;
      PCODEC_REF_LIST                         *ppRefList;
      CODEC_PICTURE                           CurrPic;
      CODEC_PICTURE                           CurrReconPic;
      CODEC_AVC_ENCODE_USER_FLAGS             UserFlags;
      CODECHAL_ENCODE_AVC_NAL_UNIT_TYPE       NalUnitType;
      uint16_t                                wPictureCodingType;
      bool                                    bVdencEnabled;
  } CODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS, *PCODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS;
  
  typedef struct _CODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS
  {
      PCODEC_AVC_ENCODE_SEQUENCE_PARAMS       pSeqParams;     // pAvcSeqParams[ucSPSIdx]
      PCODEC_AVC_ENCODE_PIC_PARAMS            pPicParams;
      PCODEC_AVC_ENCODE_SLICE_PARAMS          pAvcSliceParams;
      uint16_t                                wPictureCodingType;
      uint16_t                                wPicHeightInMB;
      uint16_t                                wFrameFieldHeightInMB;
      bool                                    bFirstFieldIPic;
      bool                                    bVDEncEnabled;
      bool                                    bPAKonly;
  } CODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS, *PCODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS;
  
  typedef struct _CODECHAL_ENCODE_AVC_TQ_INPUT_PARAMS
  {
      uint16_t  wPictureCodingType;
      uint8_t   ucTargetUsage;
      uint8_t   ucQP;
      bool      bBrcEnabled;
      bool      bVdEncEnabled;
  } CODECHAL_ENCODE_AVC_TQ_INPUT_PARAMS, *PCODECHAL_ENCODE_AVC_TQ_INPUT_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)
      {
          return MOS_STATUS_SUCCESS;
      }
  
      //!
      //! \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);
  
  #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__
  