/*===================== begin_copyright_notice ==================================

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.

======================= end_copyright_notice ==================================*/

//! \file     mhw_vdbox_vdenc_g12_X.h
//! \details  Defines functions for constructing Vdbox Vdenc commands on Gen12-based platforms
//!

#ifndef __MHW_VDBOX_VDENC_G12_X_H__
#define __MHW_VDBOX_VDENC_G12_X_H__

#include "mhw_vdbox_vdenc_generic.h"
#include "mhw_vdbox_vdenc_hwcmd_g12_X.h"
#include "mhw_vdbox_g12_X.h"
#include "mos_interface.h"

#define VDENCHEVC_RSC_OFFSET_C420OR422_DXX_LCU32OR64_4K_G12               1824
#define VDENCHEVC_RSC_OFFSET_C420OR422_DXX_LCU32OR64_8K_G12               2304
#define VDENCHEVC_RSC_OFFSET_C444_D8_LCU32OR64_4K_G12                     1568
#define VDENCHEVC_RSC_OFFSET_C444_D8_LCU32OR64_8K_G12                     2112
#define VDENCHEVC_RSC_OFFSET_C444_D10_LCU32OR64_4K_G12                    2336
#define VDENCHEVC_RSC_OFFSET_C444_D10_LCU32OR64_8K_G12                    1600
#define VDENCHEVC_RSC_OFFSET_C444_D12_LCU32OR64_4K_G12                    2336
#define VDENCHEVC_RSC_OFFSET_C444_D12_LCU32OR64_8K_G12                    1600

// TGL rowstore Cache Values
#define VP9VDENCROWSTORE_BASEADDRESS_1536                                 1536
#define VP9VDENCROWSTORE_BASEADDRESS_2304                                 2304
#define VP9VDENCROWSTORE_BASEADDRESS_2368                                 2368
#define VP9VDENCROWSTORE_BASEADDRESS_2112                                 2112
#define VP9VDENCROWSTORE_BASEADDRESS_1920                                 1920
#define VP9VDENCROWSTORE_BASEADDRESS_768                                  768
#define RESERVED_VDENC_ROWSTORE_BASEADDRESS                               2370
#define RESERVED_VDENC_IPDL_ROWSTORE_BASEADDRESS                          384
#define AVC_VDENC_IPDL_ROWSTORE_BASEADDRESS                               512

#define GEN12_AVC_VDENC_ROWSTORE_BASEADDRESS                                  1280
#define GEN12_AVC_VDENC_ROWSTORE_BASEADDRESS_MBAFF                            1536
#define GEN12_VP8_VDENC_ROWSTORE_BASEADDRESS                                  1536

#define OFFSET_OF(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER )

typedef struct _MHW_VDBOX_VDENC_CONTROL_STATE_PARAMS
{
    bool      bVdencInitialization;
}MHW_VDBOX_VDENC_CONTROL_STATE_PARAMS, *PMHW_VDBOX_VDENC_CONTROL_STATE_PARAMS;

struct MHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12 : public MHW_VDBOX_VDENC_WALKER_STATE_PARAMS
{
    // GEN11+ tiling support
    PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12   pTileCodingParams = nullptr;
    uint32_t                                dwNumberOfPipes = 0;
    uint32_t                                dwTileId = 0;
    uint32_t                                IBCControl = 0;
    uint32_t                                RowStaticInfo_31_0 = 0;
    uint32_t                                RowStaticInfo_63_32 = 0;
    uint32_t                                RowStaticInfo_95_64 = 0;
    uint32_t                                RowStaticInfo_127_96 = 0;
    uint32_t                                ctbSize = 0;
    uint32_t                                minCodingBlkSize = 0;
    uint32_t                                frameWidthMinus1 = 0;
    uint32_t                                frameHeightMinus1 = 0;
};
using PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12 = MHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12 *;

struct MHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12
{
    union
    {
        struct
        {
            uint16_t       bWaitDoneHEVC            : 1;
            uint16_t       bWaitDoneVDENC           : 1;
            uint16_t       bWaitDoneMFL             : 1;
            uint16_t       bWaitDoneMFX             : 1;
            uint16_t       bWaitDoneVDCmdMsgParser  : 1;
            uint16_t       bFlushHEVC               : 1;
            uint16_t       bFlushVDENC              : 1;
            uint16_t       bFlushMFL                : 1;
            uint16_t       bFlushMFX                : 1;
            uint16_t       bWaitDoneAV1             : 1;
            uint16_t       bFlushAV1                : 1;
            uint16_t                                : 5;
        };
        struct
        {
            uint16_t       Value;
        };
    }Flags;
};
using PMHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12 = MHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12 *;

//!  MHW Vdbox Vdenc interface for Gen12
/*!
This class defines the Vdenc command construction functions for Gen12 platforms as template
*/
template <typename TVdencCmds>
class MhwVdboxVdencInterfaceG12 : public MhwVdboxVdencInterfaceGeneric<TVdencCmds>
{
protected:
    enum CommandsNumberOfAddresses
    {
        MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES = 1,
        MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES = 1,
        VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 21
    };

    enum VdencSurfaceFormat
    {
        vdencSurfaceFormatYuv422          = 0x0,
        vdencSurfaceFormatRgba4444        = 0x1,
        vdencSurfaceFormatYuv444          = 0x2,
        vdencSurfaceFormatP010Variant     = 0x3,
        vdencSurfaceFormatPlanar420_8     = 0x4,
        vdencSurfaceFormatYcrcbSwapy422   = 0x5,
        vdencSurfaceFormatYcrcbSwapuv422  = 0x6,
        vdencSurfaceFormatYcrcbSwapuvy422 = 0x7,
        vdencSurfaceFormatY216            = 0x8,
        vdencSurfaceFormatY210            = 0x8,  // Same value is used to represent Y216 and Y210
        vdencSurfaceFormatRgba_10_10_10_2 = 0x9,
        vdencSurfaceFormatY410            = 0xa,
        vdencSurfaceFormatNv21            = 0xb,
        vdencSurfaceFormatY416            = 0xc,
        vdencSurfaceFormatP010            = 0xd,
        vdencSurfaceFormatPlanarP016      = 0xe,
        vdencSurfaceFormatY8Unorm         = 0xf,
        vdencSurfaceFormatY16             = 0x10,
        vdencSurfaceFormatY216Variant     = 0x11,
        vdencSurfaceFormatY416Variant     = 0x12,
        vdencSurfaceFormatYuyvVariant     = 0x13,
        vdencSurfaceFormatAyuvVariant     = 0x14,
    };

    enum VDENC_WALKER_STATE_IBC_CONTROL
    {
        VDENC_WALKER_STATE_COMMAND_IBC_CONTROL_IBC_DISABLED_G12 = 0x0,
        VDENC_WALKER_STATE_COMMAND_IBC_CONTROL_IBC_ONLY_LBC_G12 = 0x1,
        VDENC_WALKER_STATE_COMMAND_IBC_CONTROL_IBC_ENABLED_TBCLBC_G12 = 0x3,
    };

    MOS_STATUS InitRowstoreUserFeatureSettings() override
    {
        MHW_FUNCTION_ENTER;

        MOS_USER_FEATURE_VALUE_DATA userFeatureData;
        MEDIA_FEATURE_TABLE *skuTable = this->m_osInterface->pfnGetSkuTable(this->m_osInterface);

        MHW_MI_CHK_NULL(skuTable);

        MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
        if (this->m_osInterface->bSimIsActive)
        {
            // Disable RowStore Cache on simulation by default
            userFeatureData.u32Data = 1;
        }
        else
        {
            userFeatureData.u32Data = 0;
        }

        userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
#if (_DEBUG || _RELEASE_INTERNAL)
        MOS_UserFeature_ReadValue_ID(
            nullptr,
            __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
            &userFeatureData,
            this->m_osInterface->pOsContext);
#endif // _DEBUG || _RELEASE_INTERNAL
        this->m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;

        if (this->m_rowstoreCachingSupported)
        {
            MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
#if (_DEBUG || _RELEASE_INTERNAL)
            MOS_UserFeature_ReadValue_ID(
                nullptr,
                __MEDIA_USER_FEATURE_VALUE_VDENCROWSTORECACHE_DISABLE_ID,
                &userFeatureData,
                this->m_osInterface->pOsContext);
#endif // _DEBUG || _RELEASE_INTERNAL
            this->m_vdencRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
        }

        return MOS_STATUS_SUCCESS;
    }

    //!
    //! \brief    Translate MOS type format to vdenc surface raw format
    //! \details  VDBOX protected function to translate mos format to media state format
    //! \param    MOS_FORMAT  Format
    //!           [in] MOS type format
    //! \return   VdencSurfaceFormat
    //!           media state surface format
    //!
    VdencSurfaceFormat MosFormatToVdencSurfaceRawFormat(MOS_FORMAT format)
    {
        MHW_FUNCTION_ENTER;

        switch (format)
        {
        case Format_A8R8G8B8:
        case Format_X8R8G8B8:
        case Format_A8B8G8R8:
            return vdencSurfaceFormatRgba4444;
        case Format_NV12:
        case Format_NV11:
        case Format_P208:
        case Format_IMC1:
        case Format_IMC2:
        case Format_IMC3:
        case Format_IMC4:
            return vdencSurfaceFormatPlanar420_8;
        case Format_400P:
        case Format_P8:
            return vdencSurfaceFormatY8Unorm;
        case Format_UYVY:
            return vdencSurfaceFormatYcrcbSwapy422;
        case Format_YVYU:
            return vdencSurfaceFormatYcrcbSwapuv422;
        case Format_VYUY:
            return vdencSurfaceFormatYcrcbSwapuvy422;
        case Format_444P:
        case Format_AYUV:
            return vdencSurfaceFormatYuv444;
        case Format_YUY2:
        case Format_YUYV:
            return vdencSurfaceFormatYuv422;
        case Format_P010:
            return vdencSurfaceFormatP010;
        case Format_R10G10B10A2:
        case Format_B10G10R10A2:
            return vdencSurfaceFormatRgba_10_10_10_2;
            // Only Y210 supported now, allocated as Y216 format by 3D driver
        case Format_Y210:
        case Format_Y216:
            return vdencSurfaceFormatY216;
        case Format_Y410:
            return vdencSurfaceFormatY410;
        case Format_NV21:
            return vdencSurfaceFormatNv21;
        default:
            return vdencSurfaceFormatPlanar420_8;
        }

        return vdencSurfaceFormatYuv422;
    }

    //!
    //! \brief    Translate MOS type format to vdenc surface recon format
    //! \details  VDBOX protected function to translate mos format to media state recon format
    //! \param    MOS_FORMAT  Format
    //!           [in] MOS type format
    //! \return   VdencSurfaceFormat
    //!           media state surface format
    //!
    VdencSurfaceFormat MosFormatToVdencSurfaceReconFormat(MOS_FORMAT format)
    {
        MHW_FUNCTION_ENTER;

        switch (format)
        {
        case Format_A8R8G8B8:
        case Format_X8R8G8B8:
        case Format_A8B8G8R8:
            return vdencSurfaceFormatRgba4444;
        case Format_NV12:
        case Format_IMC1:
        case Format_IMC2:
        case Format_IMC3:
        case Format_IMC4:
            return vdencSurfaceFormatPlanar420_8;
        case Format_400P:
        case Format_P8:
            return vdencSurfaceFormatY8Unorm;
        case Format_UYVY:
            return vdencSurfaceFormatYcrcbSwapy422;
        case Format_YVYU:
            return vdencSurfaceFormatYcrcbSwapuv422;
        case Format_VYUY:
            return vdencSurfaceFormatYcrcbSwapuvy422;
        case Format_444P:
        case Format_AYUV:
            return vdencSurfaceFormatAyuvVariant;
        case Format_YUY2:
        case Format_YUYV:
            return vdencSurfaceFormatYuyvVariant;
        case Format_P010:
            return vdencSurfaceFormatP010Variant;
        case Format_R10G10B10A2:
            return vdencSurfaceFormatRgba_10_10_10_2;
        case Format_Y216:
            return vdencSurfaceFormatY216Variant;
        case Format_Y410:
            return vdencSurfaceFormatY416Variant;
        case Format_NV21:
            return vdencSurfaceFormatNv21;
        default:
            return vdencSurfaceFormatPlanar420_8;
        }
    }

    //!
    //! \brief    Adds VD Pipeline Flush command in command buffer
    //! \details  Client facing function to add VD Pipeline Flush command in command buffer
    //! \param    [in] cmdBuffer
    //!           Command buffer to which HW command is added
    //! \param    [in] params
    //!           Params structure used to populate the HW command
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail type
    //!
    MOS_STATUS AddVdPipelineFlushCmd(
        PMOS_COMMAND_BUFFER             cmdBuffer,
        PMHW_VDBOX_VD_PIPE_FLUSH_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

        typename TVdencCmds::VD_PIPELINE_FLUSH_CMD cmd;
        PMHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12 paramsG12 = (PMHW_VDBOX_VD_PIPE_FLUSH_PARAMS_G12)params;

        cmd.DW1.HevcPipelineDone           = params->Flags.bWaitDoneHEVC;
        cmd.DW1.VdencPipelineDone          = params->Flags.bWaitDoneVDENC;
        cmd.DW1.MflPipelineDone            = params->Flags.bWaitDoneMFL;
        cmd.DW1.MfxPipelineDone            = params->Flags.bWaitDoneMFX;
        cmd.DW1.VdCommandMessageParserDone = params->Flags.bWaitDoneVDCmdMsgParser;
        cmd.DW1.HevcPipelineCommandFlush   = params->Flags.bFlushHEVC;
        cmd.DW1.VdencPipelineCommandFlush  = params->Flags.bFlushVDENC;
        cmd.DW1.MflPipelineCommandFlush    = params->Flags.bFlushMFL;
        cmd.DW1.MfxPipelineCommandFlush    = params->Flags.bFlushMFX;
        cmd.DW1.AvpPipelineDone            = paramsG12->Flags.bWaitDoneAV1;
        cmd.DW1.AvpPipelineCommandFlush    = paramsG12->Flags.bFlushAV1;

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

public:
    //!
    //! \brief  Constructor
    //!
    MhwVdboxVdencInterfaceG12(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceGeneric<TVdencCmds>(osInterface)
    {
        MHW_FUNCTION_ENTER;

        this->m_rhoDomainStatsEnabled = true;
        InitRowstoreUserFeatureSettings();
    }

    inline virtual uint32_t GetVdencCmd1Size() override
    {
        return 0;
    }

    inline virtual uint32_t GetVdencCmd2Size() override
    {
        return 0;
    }

    //!
    //! \brief    Destructor
    //!
    virtual ~MhwVdboxVdencInterfaceG12() { }

    MOS_STATUS GetRowstoreCachingAddrs(
        PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(rowstoreParams);

        bool is8bit = rowstoreParams->ucBitDepthMinus8 == 0;
        bool is10bit = rowstoreParams->ucBitDepthMinus8 == 1 || rowstoreParams->ucBitDepthMinus8 == 2;
        bool is12bit = rowstoreParams->ucBitDepthMinus8 > 2;
        bool isLcu32or64 = rowstoreParams->ucLCUSize == 32 || rowstoreParams->ucLCUSize == 64;
        bool isGt2k = rowstoreParams->dwPicWidth > 2048;
        bool isGt4k = rowstoreParams->dwPicWidth > 4096;
        bool isGt8k = rowstoreParams->dwPicWidth > 8192;
        uint32_t index = 0;

        bool avc = rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC;
        bool vp8 = rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP8;
        bool widthLE4K = rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K;
        bool mbaffOrField = rowstoreParams->bMbaff || !rowstoreParams->bIsFrame;
        this->m_vdencRowStoreCache.bEnabled = false;
        this->m_vdencRowStoreCache.dwAddress = 0;

        //VDENC row store cache setting for AVC and VP8
        this->m_vdencRowStoreCache.bEnabled = this->m_vdencRowStoreCache.bSupported && widthLE4K && (avc || vp8);
        this->m_vdencRowStoreCache.dwAddress = avc ? (mbaffOrField ? GEN12_AVC_VDENC_ROWSTORE_BASEADDRESS_MBAFF :
            GEN12_AVC_VDENC_ROWSTORE_BASEADDRESS) : GEN12_VP8_VDENC_ROWSTORE_BASEADDRESS;
        this->m_vdencRowStoreCache.dwAddress = this->m_vdencRowStoreCache.bEnabled ? this->m_vdencRowStoreCache.dwAddress : 0;

        if (this->m_vdencRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_ENCODE_MODE_HEVC)
        {
            if (rowstoreParams->ucChromaFormat != HCP_CHROMA_FORMAT_YUV444)
            {
                index = 2 * isGt4k + isLcu32or64;
            }
            else
            {
                uint32_t subidx = is12bit ? 2 : (is10bit ? 1 : 0);
                index = 4 + 6 * isLcu32or64 + 2 * subidx + isGt4k;
            }

            if (!isGt8k)
            {
                this->m_vdencRowStoreCache.bEnabled  = RowStoreCacheEnableHEVC[index][3];
                this->m_vdencRowStoreCache.dwAddress = RowStoreCacheAddrHEVC[index][3];
            }
        }

        //VP9 VDENC
        if (this->m_vdencRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP9)
        {
            if ((rowstoreParams->ucChromaFormat >= HCP_CHROMA_FORMAT_YUV420) &&
                (rowstoreParams->ucChromaFormat <= HCP_CHROMA_FORMAT_YUV444))
            {
                index = 4 * (rowstoreParams->ucChromaFormat - HCP_CHROMA_FORMAT_YUV420) + 2 * (!is8bit) + isGt4k;
            }
            else
            {
                return MOS_STATUS_SUCCESS;
            }

            if (rowstoreParams->ucChromaFormat == HCP_CHROMA_FORMAT_YUV444 && !is8bit)
            {
                index += isGt2k;
            }

            if (!isGt8k)
            {
                this->m_vdencRowStoreCache.bEnabled = RowStoreCacheEnableVP9[index][3];
                this->m_vdencRowStoreCache.dwAddress = RowStoreCacheAddrVP9[index][3];
            }
        }

        if (this->m_vdencRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AV1)
        {
            this->m_vdencRowStoreCache.bEnabled  = true;
            this->m_vdencRowStoreCache.dwAddress = RESERVED_VDENC_ROWSTORE_BASEADDRESS;

            //IPDL
            this->m_vdencIpdlRowstoreCache.dwAddress = RESERVED_VDENC_IPDL_ROWSTORE_BASEADDRESS;

        }
        else if (this->m_vdencRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC)
        {
            this->m_vdencRowStoreCache.bEnabled = true;

            //IPDL
            this->m_vdencIpdlRowstoreCache.dwAddress = AVC_VDENC_IPDL_ROWSTORE_BASEADDRESS;

        }

        return MOS_STATUS_SUCCESS;
    }

    uint32_t GetAvcMaxSize(uint32_t waAddDelayInVDEncDynamicSlice)
    {
        uint32_t maxSize =
            TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
            TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
            TVdencCmds::VDENC_CONST_QPT_STATE_CMD::byteSize +
            TVdencCmds::VDENC_IMG_STATE_CMD::byteSize +
            TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
            TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;

        if (waAddDelayInVDEncDynamicSlice)
        {
            maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
        }

        return maxSize;
    }

    uint32_t GetReserved0MaxSize()
    {
       uint32_t maxSize =
            TVdencCmds::VDENC_CONTROL_STATE_CMD::byteSize +
            TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
            TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
            TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
            TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
            TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;;

        return maxSize;
    }

    MOS_STATUS GetVdencStateCommandsDataSize(
        uint32_t mode,
        uint32_t waAddDelayInVDEncDynamicSlice,
        uint32_t *commandsSize,
        uint32_t *patchListSize) override
    {
        MHW_FUNCTION_ENTER;

        uint32_t            maxSize = 0;
        uint32_t            patchListMaxSize = 0;
        uint32_t            standard = CodecHal_GetStandardFromMode(mode);

        if (standard == CODECHAL_AVC)
        {
            maxSize = GetAvcMaxSize(waAddDelayInVDEncDynamicSlice);
            patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
        }
        else if (standard == CODECHAL_HEVC)
        {
            maxSize =
                TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
                TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
                TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize +
                TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
                TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;

            if (waAddDelayInVDEncDynamicSlice)
            {
                maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
            }

            patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
        }
        else if (standard == CODECHAL_VP9)
        {
            maxSize =
                TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
                TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
                TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
                TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
                TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;

            if (waAddDelayInVDEncDynamicSlice)
            {
                maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
            }

            patchListMaxSize =
                MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES +
                MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES +
                VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
        }
        else if (standard == CODECHAL_AV1)
        {
            maxSize = GetReserved0MaxSize();

            patchListMaxSize =
                MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES +
                MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES +
                VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
        }
        else
        {
            MHW_ASSERTMESSAGE("Unsupported encode mode.");
            *commandsSize = 0;
            *patchListSize = 0;
            return MOS_STATUS_UNKNOWN;
        }

        *commandsSize = maxSize;
        *patchListSize = patchListMaxSize;

        return MOS_STATUS_SUCCESS;
    }

    uint32_t GetAvcSliceMaxSize()
    {
        uint32_t maxSize =
            TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize +
            TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
            TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;

        return maxSize;
    }

    uint32_t GetReserved0TileMaxSize()
    {
        uint32_t maxSize = GetVdencCmd1Size() +
            GetVdencCmd2Size() +
            TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize;

        return maxSize;
    }

    MOS_STATUS GetVdencPrimitiveCommandsDataSize(
        uint32_t                        mode,
        uint32_t                        *commandsSize,
        uint32_t                        *patchListSize) override
    {
        MHW_FUNCTION_ENTER;

        uint32_t            maxSize = 0;
        uint32_t            patchListMaxSize = 0;
        uint32_t            standard = CodecHal_GetStandardFromMode(mode);

        if (standard == CODECHAL_AVC)
        {
            maxSize = GetAvcSliceMaxSize();
            patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
        }
        else if (standard == CODECHAL_AV1)
        {
            maxSize = GetReserved0TileMaxSize();
        }
        else
        {
            MHW_ASSERTMESSAGE("Unsupported encode mode.");
            *commandsSize = 0;
            *patchListSize = 0;
            return MOS_STATUS_UNKNOWN;
        }

        *commandsSize = maxSize;
        *patchListSize = patchListMaxSize;

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencPipeModeSelectCmd(
        PMOS_COMMAND_BUFFER                cmdBuffer,
        PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);
        auto paramsG12 = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(params);
        MHW_MI_CHK_NULL(paramsG12);
        typename TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD cmd;

        cmd.DW1.StandardSelect                 = CodecHal_GetStandardFromMode(params->Mode);
        cmd.DW1.ScalabilityMode                = !(paramsG12->MultiEngineMode == MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY);
        if (CODECHAL_ENCODE_MODE_HEVC == params->Mode || CODECHAL_ENCODE_MODE_AV1 == params->Mode)
        {
            cmd.DW1.FrameStatisticsStreamOutEnable = paramsG12->bBRCEnabled || paramsG12->bLookaheadPass;
        }
        // AVC VENC to be optimized later
        else
        {
            cmd.DW1.FrameStatisticsStreamOutEnable = 1;
        }
        cmd.DW1.VdencPakObjCmdStreamOutEnable  = params->bVdencPakObjCmdStreamOutEnable;
        cmd.DW1.TlbPrefetchEnable              = 1;
        cmd.DW1.PakThresholdCheckEnable        = params->bDynamicSliceEnable;
        cmd.DW1.VdencStreamInEnable            = params->bVdencStreamInEnable;
        cmd.DW1.BitDepth                       = params->ucVdencBitDepthMinus8;

        if (CODECHAL_ENCODE_MODE_HEVC == params->Mode || CODECHAL_ENCODE_MODE_VP9 == params->Mode || CODECHAL_ENCODE_MODE_AV1 == params->Mode)
        {
            cmd.DW1.PakChromaSubSamplingType = params->ChromaType;
        }
        // by default RGB to YUV using full to studio range
        // can add a DDI flag to control if needed
        cmd.DW1.OutputRangeControlAfterColorSpaceConversion = 1;

        // for tile encoding
        cmd.DW1.TileReplayEnable = paramsG12->bTileBasedReplayMode;

        cmd.DW1.IsRandomAccess = paramsG12->bIsRandomAccess;

        //Restriction: When this pre-fetch is enabled,TLB Prefetch Enable in VDENC_PIPE_MODE select (DW 1 bit 7) should be disabled.
        cmd.DW2.HmeRegionPreFetchenable = 0;

        // TLB prefetch performance improvement
        if (params->Mode == CODECHAL_ENCODE_MODE_AVC)
        {
            cmd.DW3.PreFetchoffsetforsource = 7;
            cmd.DW3.Numverticalreqminus1Src = 0;
        }
        else if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || CODECHAL_ENCODE_MODE_AV1 == params->Mode)
        {
            cmd.DW3.PreFetchoffsetforsource = 4;
            cmd.DW3.Numverticalreqminus1Src = 1;
        }

        //Restriction : This field can be set only to planar source formats.
        if (params->Format != Format_NV12 && params->Format != Format_P010)
        {
            cmd.DW3.SourceChromaTlbPreFetchenable = 0;
        }

        // For RGB encoding
        if (paramsG12->bRGBEncodingMode)
        {
            cmd.DW1.RgbEncodingEnable    = 1;
            // To add the primary channel selection later here
        }

        // For parallel encode from display
        if (paramsG12->bWirelessEncodeEnabled)
        {
            cmd.DW5.CaptureMode                        = TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::CAPTURE_MODE_UNNAMED1;
            cmd.DW5.ParallelCaptureAndEncodeSessionId  = paramsG12->ucWirelessSessionId;
            cmd.DW5.TailPointerReadFrequency           = 0x50;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencPipeBufAddrCmd(
        PMOS_COMMAND_BUFFER             cmdBuffer,
        PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params) override
    {
        MOS_SURFACE details;
        uint8_t     refIdx;

        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD cmd;

        MOS_MEMCOMP_STATE   mmcMode = MOS_MEMCOMP_DISABLED;
        MHW_RESOURCE_PARAMS resourceParams;
        MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
        resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
        resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

        if (params->psRawSurface != nullptr)
        {
            cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(params->RawSurfMmcState) ? 1 : 0;
            cmd.OriginalUncompressedPicture.PictureFields.DW0.CompressionType = MmcIsRc(params->RawSurfMmcState) ? 1 : 0;
            cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState =
                this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;

            cmd.OriginalUncompressedPicture.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);

            resourceParams.presResource    = &params->psRawSurface->OsResource;
            resourceParams.dwOffset        = params->psRawSurface->dwOffset;
            resourceParams.pdwCmd          = (uint32_t*)&(cmd.OriginalUncompressedPicture.LowerAddress);
            resourceParams.dwLocationInCmd = 10;
            resourceParams.bIsWritable     = false;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (this->m_vdencRowStoreCache.bEnabled)
        {
            cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = TVdencCmds::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
            cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value              = this->m_vdencRowStoreCache.dwAddress << 6;
        }
        else if (!Mos_ResourceIsNull(params->presVdencIntraRowStoreScratchBuffer))
        {
            cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
                this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;

            resourceParams.presResource    = params->presVdencIntraRowStoreScratchBuffer;
            resourceParams.dwOffset        = 0;
            resourceParams.pdwCmd          = (uint32_t*)&(cmd.RowStoreScratchBuffer.LowerAddress);
            resourceParams.dwLocationInCmd = 16;
            resourceParams.bIsWritable     = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }
        if (params->psFwdRefSurface0)
        {
            resourceParams.presResource = &params->psFwdRefSurface0->OsResource;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef0.LowerAddress);
            resourceParams.dwLocationInCmd = 22;
            resourceParams.bIsWritable = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (params->psFwdRefSurface1)
        {
            resourceParams.presResource = &params->psFwdRefSurface1->OsResource;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef1.LowerAddress);
            resourceParams.dwLocationInCmd = 25;
            resourceParams.bIsWritable = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (params->psFwdRefSurface2)
        {
            resourceParams.presResource = &params->psFwdRefSurface2->OsResource;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef2.LowerAddress);
            resourceParams.dwLocationInCmd = 28;
            resourceParams.bIsWritable = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }
        if (params->presVdencStreamOutBuffer != nullptr)
        {
            cmd.VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState =
                this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;

            resourceParams.presResource    = params->presVdencStreamOutBuffer;
            resourceParams.dwOffset        = params->dwVdencStatsStreamOutOffset;
            resourceParams.pdwCmd          = (uint32_t*)&(cmd.VdencStatisticsStreamout.LowerAddress);
            resourceParams.dwLocationInCmd = 34;
            resourceParams.bIsWritable     = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (params->presVdencStreamInBuffer != nullptr)
        {
            cmd.StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState =
                this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;

            resourceParams.presResource    = params->presVdencStreamInBuffer;
            resourceParams.dwOffset        = 0;
            resourceParams.pdwCmd          = (uint32_t*)&(cmd.StreaminDataPicture.LowerAddress);
            resourceParams.dwLocationInCmd = 13;
            resourceParams.bIsWritable     = false;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        for (refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++)
        {
            if (params->presVdencReferences[refIdx])
            {
                // L0 references
                MOS_ZeroMemory(&details, sizeof(details));
                details.Format = Format_Invalid;
                MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdencReferences[refIdx], &details));

                resourceParams.presResource    = params->presVdencReferences[refIdx];
                resourceParams.dwOffset        = details.RenderOffset.YUV.Y.BaseOffset;
                resourceParams.dwLocationInCmd = (refIdx * 3) + 22;
                resourceParams.bIsWritable     = false;
                switch (refIdx)
                {
                case 0:
                    resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef0.LowerAddress);
                    break;
                case 1:
                    resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef1.LowerAddress);
                    break;
                case 2:
                    resourceParams.pdwCmd = (uint32_t*)&(cmd.FwdRef2.LowerAddress);
                    break;
                case 3:
                    resourceParams.pdwCmd = (uint32_t*)&(cmd.BwdRef0.LowerAddress);
                    break;
                default:
                    break;
                }

                mmcMode = (params->PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ?
                    params->PostDeblockSurfMmcState : params->PreDeblockSurfMmcState;
                switch (refIdx)
                {
                case 0:
                    cmd.FwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                    cmd.FwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                    cmd.FwdRef0.PictureFields.DW0.MemoryObjectControlState =
                        this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                    cmd.FwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                    break;
                case 1:
                    cmd.FwdRef1.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                    cmd.FwdRef1.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                    cmd.FwdRef1.PictureFields.DW0.MemoryObjectControlState =
                        this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                    cmd.FwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                    break;
                case 2:
                    cmd.FwdRef2.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                    cmd.FwdRef2.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                    cmd.FwdRef2.PictureFields.DW0.MemoryObjectControlState =
                        this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                    cmd.FwdRef2.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                    break;
                case 3:
                    cmd.BwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                    cmd.BwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                    cmd.BwdRef0.PictureFields.DW0.MemoryObjectControlState =
                        this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                    cmd.BwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                    break;
                default:
                    break;
                }

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            // so far VDEnc only support 2 4x/8x DS Ref Pictures
            if ((refIdx <= 1) && params->presVdenc4xDsSurface[refIdx])
            {
                if (params->Mode == CODECHAL_ENCODE_MODE_AVC)
                {
                    // 4x DS surface for VDEnc
                    MOS_ZeroMemory(&details, sizeof(details));
                    details.Format = Format_Invalid;
                    MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));

                    resourceParams.presResource    = params->presVdenc4xDsSurface[refIdx];
                    resourceParams.dwOffset        = details.RenderOffset.YUV.Y.BaseOffset;
                    resourceParams.dwLocationInCmd = (refIdx * 3) + 1;
                    resourceParams.bIsWritable     = false;
                    switch (refIdx)
                    {
                    case 0:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef0.LowerAddress);
                        break;
                    case 1:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef1.LowerAddress);
                        break;
                    default:
                        break;
                    }

                    mmcMode = params->Ps4xDsSurfMmcState;
                    switch (refIdx)
                    {
                    case 0:
                        cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef0.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    case 1:
                        cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef1.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef1.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    default:
                        break;
                    }

                    MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                        this->m_osInterface,
                        cmdBuffer,
                        &resourceParams));
                }
                else if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_VP9 || params->Mode == CODECHAL_ENCODE_MODE_AV1)
                {
                    // 8x DS surface
                    MOS_ZeroMemory(&details, sizeof(details));
                    details.Format = Format_Invalid;
                    MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc8xDsSurface[refIdx], &details));

                    resourceParams.presResource    = params->presVdenc8xDsSurface[refIdx];
                    resourceParams.dwOffset        = details.RenderOffset.YUV.Y.BaseOffset;
                    resourceParams.dwLocationInCmd = (refIdx * 3) + 1;
                    resourceParams.bIsWritable     = false;
                    switch (refIdx)
                    {
                    case 0:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef0.LowerAddress);
                        break;
                    case 1:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef1.LowerAddress);
                        break;
                    default:
                        break;
                    }

                    mmcMode = params->Ps8xDsSurfMmcState;
                    switch (refIdx)
                    {
                    case 0:
                        cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef0.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    case 1:
                        cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef1.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef1.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    default:
                        break;
                    }

                    MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                        this->m_osInterface,
                        cmdBuffer,
                        &resourceParams));

                    // 4x DS surface
                    MOS_ZeroMemory(&details, sizeof(details));
                    details.Format = Format_Invalid;
                    MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));

                    resourceParams.presResource    = params->presVdenc4xDsSurface[refIdx];
                    resourceParams.dwOffset        = details.RenderOffset.YUV.Y.BaseOffset;
                    resourceParams.dwLocationInCmd = (refIdx * 3) + 37;
                    resourceParams.bIsWritable     = false;
                    switch (refIdx)
                    {
                    case 0:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef04X.LowerAddress);
                        break;
                    case 1:
                        resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef14X.LowerAddress);
                        break;
                    default:
                        break;
                    }

                    mmcMode = params->Ps8xDsSurfMmcState;
                    switch (refIdx)
                    {
                    case 0:
                        cmd.DsFwdRef04X.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef04X.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef04X.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef04X.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    case 1:
                        cmd.DsFwdRef14X.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef14X.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                        cmd.DsFwdRef14X.PictureFields.DW0.MemoryObjectControlState =
                            this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                        cmd.DsFwdRef14X.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                        break;
                    default:
                        break;
                    }

                    MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                        this->m_osInterface,
                        cmdBuffer,
                        &resourceParams));
                }
                else
                {
                    MHW_ASSERTMESSAGE("Encode mode = %d not supported", params->Mode);
                    return MOS_STATUS_INVALID_PARAMETER;
                }
            }
        }

        if (!params->isLowDelayB && (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_AV1))
        {
            if (params->presVdencReferences[refIdx])
            {
                // L1 references
                MOS_ZeroMemory(&details, sizeof(details));
                details.Format = Format_Invalid;
                MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdencReferences[refIdx], &details));

                resourceParams.presResource = params->presVdencReferences[refIdx];
                resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
                resourceParams.dwLocationInCmd = OFFSET_OF(typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD, BwdRef0) / sizeof(uint32_t);
                resourceParams.bIsWritable = false;
                resourceParams.pdwCmd = (uint32_t*)&(cmd.BwdRef0.LowerAddress);

                mmcMode = (params->PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ?
                    params->PostDeblockSurfMmcState : params->PreDeblockSurfMmcState;

                cmd.BwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                cmd.BwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                cmd.BwdRef0.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                cmd.BwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->presVdenc8xDsSurface[refIdx])
            {
                // 8x DS surface
                MOS_ZeroMemory(&details, sizeof(details));
                details.Format = Format_Invalid;
                MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc8xDsSurface[refIdx], &details));

                resourceParams.presResource = params->presVdenc8xDsSurface[refIdx];
                resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
                resourceParams.dwLocationInCmd = OFFSET_OF(typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD, DsBwdRef0) / sizeof(uint32_t);
                resourceParams.bIsWritable = false;
                resourceParams.pdwCmd = (uint32_t*)&(cmd.DsBwdRef0.LowerAddress);

                mmcMode = params->Ps8xDsSurfMmcState;

                cmd.DsBwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                cmd.DsBwdRef0.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                cmd.DsBwdRef0.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                cmd.DsBwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->presVdenc4xDsSurface[refIdx])
            {
                // 4x DS surface
                MOS_ZeroMemory(&details, sizeof(details));
                details.Format = Format_Invalid;
                MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));

                resourceParams.presResource = params->presVdenc4xDsSurface[refIdx];
                resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
                resourceParams.dwLocationInCmd = OFFSET_OF(typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD, DsBwdRef04X) / sizeof(uint32_t);
                resourceParams.bIsWritable = false;
                resourceParams.pdwCmd = (uint32_t*)&(cmd.DsBwdRef04X.LowerAddress);

                mmcMode = params->Ps4xDsSurfMmcState;
                cmd.DsBwdRef04X.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(mmcMode) ? 1 : 0;
                cmd.DsBwdRef04X.PictureFields.DW0.CompressionType         = MmcIsRc(mmcMode) ? 1 : 0;
                cmd.DsBwdRef04X.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
                cmd.DsBwdRef04X.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }
        }

        // extra surface for HEVC/VP9
        if ((params->Mode == CODECHAL_ENCODE_MODE_HEVC) || (params->Mode == CODECHAL_ENCODE_MODE_VP9) || (params->Mode == CODECHAL_ENCODE_MODE_AV1))
        {
            if (params->presColMvTempBuffer[0] != nullptr)
            {
                resourceParams.presResource    = params->presColMvTempBuffer[0];
                resourceParams.dwOffset        = 0;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.ColocatedMv.LowerAddress);
                resourceParams.dwLocationInCmd = 19;
                resourceParams.bIsWritable     = true;

                cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
                cmd.ColocatedMv.PictureFields.DW0.CompressionType = 0;
                cmd.ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->ps8xDsSurface != nullptr)
            {
                resourceParams.presResource    = &params->ps8xDsSurface->OsResource;
                resourceParams.dwOffset        = params->ps8xDsSurface->dwOffset;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.ScaledReferenceSurface8X.LowerAddress);
                resourceParams.dwLocationInCmd = 49;
                resourceParams.bIsWritable     = true;

                cmd.ScaledReferenceSurface8X.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(params->Ps8xDsSurfMmcState) ? 1 : 0;
                cmd.ScaledReferenceSurface8X.PictureFields.DW0.CompressionType         = MmcIsRc(params->Ps8xDsSurfMmcState) ? 1 : 0;
                cmd.ScaledReferenceSurface8X.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->ps4xDsSurface != nullptr)
            {
                resourceParams.presResource    = &params->ps4xDsSurface->OsResource;
                resourceParams.dwOffset        = params->ps4xDsSurface->dwOffset;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.ScaledReferenceSurface4X.LowerAddress);
                resourceParams.dwLocationInCmd = 52;
                resourceParams.bIsWritable     = true;

                cmd.ScaledReferenceSurface4X.PictureFields.DW0.MemoryCompressionEnable = MmcEnable(params->Ps4xDsSurfMmcState) ? 1 : 0;
                cmd.ScaledReferenceSurface4X.PictureFields.DW0.CompressionType = MmcIsRc(params->Ps4xDsSurfMmcState) ? 1 : 0;
                cmd.ScaledReferenceSurface4X.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            // CuRecord stream-out buffer, not used so far
            if (params->presVdencCuObjStreamOutBuffer)
            {
                resourceParams.presResource    = params->presVdencCuObjStreamOutBuffer;
                resourceParams.dwOffset        = 0;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.VdencCuRecordStreamOutBuffer.LowerAddress);
                resourceParams.dwLocationInCmd = 43;
                resourceParams.bIsWritable     = true;

                cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
                cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.CompressionType = 0;
                cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->presVdencPakObjCmdStreamOutBuffer)
            {
                resourceParams.presResource    = params->presVdencPakObjCmdStreamOutBuffer;
                resourceParams.dwOffset        = 0;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.VdencLcuPakObjCmdBuffer.LowerAddress);
                resourceParams.dwLocationInCmd = 46;
                resourceParams.bIsWritable     = true;

                cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
                cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.CompressionType = 0;
                cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryObjectControlState =
                    this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }

            if (params->presSegmentMapStreamOut)
            {
                resourceParams.presResource = params->presSegmentMapStreamOut;
                resourceParams.dwOffset        = 0;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.Vp9SegmentationMapStreaminBuffer.LowerAddress);
                resourceParams.dwLocationInCmd = 55;
                resourceParams.bIsWritable     = true;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));

                resourceParams.presResource    = params->presSegmentMapStreamOut;
                resourceParams.dwOffset        = 0;
                resourceParams.pdwCmd          = (uint32_t*)&(cmd.Vp9SegmentationMapStreamoutBuffer.LowerAddress);
                resourceParams.dwLocationInCmd = 58;
                resourceParams.bIsWritable     = true;

                MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                    this->m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }
        }

        // DW61: Weights Histogram Streamout offset
        // This parameter specifies the 64 byte aligned offset in the VDEnc
        // Statistics Streamout buffer where the luma and chroma histogram for
        // the weights/offsets determination is written out.

        // The first 2 CLs(cacheline=64bytes) are ENC frame statistics data.
        // The 3rd CL is for VDL1* stats (hits & misses which doesn't model).
        // Hence it's a dummy CL for us. Histogram stats start from 4th CL onwards.
        cmd.DW61.WeightsHistogramStreamoutOffset = 3 * MHW_CACHELINE_SIZE;

        if (params->presVdencTileRowStoreBuffer != nullptr)
        {
            cmd.VdencTileRowStoreBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
                this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;

            resourceParams.presResource = params->presVdencTileRowStoreBuffer;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (uint32_t*)&(cmd.VdencTileRowStoreBuffer.LowerAddress);
            resourceParams.dwLocationInCmd = 62;
            resourceParams.bIsWritable = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (params->presVdencCumulativeCuCountStreamoutSurface != nullptr)
        {
            resourceParams.presResource = params->presVdencCumulativeCuCountStreamoutSurface;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (uint32_t*)&(cmd.VdencCumulativeCuCountStreamoutSurface.LowerAddress);
            resourceParams.dwLocationInCmd = 65;
            resourceParams.bIsWritable = true;

            MHW_MI_CHK_STATUS(this->AddResourceToCmd(
                this->m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    uint32_t GetHWTileType(MOS_TILE_TYPE tileType, MOS_TILE_MODE_GMM tileModeGMM, bool gmmTileEnabled)
    {
        uint32_t tileMode = 0;

        if (gmmTileEnabled)
        {
            return tileModeGMM;
        }

        switch (tileType)
        {
        case MOS_TILE_LINEAR:
            tileMode = 0;
            break;
        case MOS_TILE_YS:
            tileMode = 1;
            break;
        case MOS_TILE_X:
            tileMode = 2;
            break;
        default:
            tileMode = 3;
            break;
        }
        return tileMode;
    }

    MOS_STATUS AddVdencSrcSurfaceStateCmd(
        PMOS_COMMAND_BUFFER       cmdBuffer,
        PMHW_VDBOX_SURFACE_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);
        MHW_MI_CHK_NULL(params->psSurface);

        typename TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD cmd;

        cmd.Dwords25.DW0.Width               = params->dwActualWidth - 1;
        cmd.Dwords25.DW0.Height              = params->dwActualHeight - 1;
        cmd.Dwords25.DW0.ColorSpaceSelection = params->bColorSpaceSelection;

        cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;

        uint32_t tilemode             = GetHWTileType(params->psSurface->TileType, params->psSurface->TileModeGMM, params->psSurface->bGMMTileEnabled);
        cmd.Dwords25.DW1.TiledSurface = (tilemode & 0x2) >> 1;
        cmd.Dwords25.DW1.TileWalk     = tilemode & 0x1;

        cmd.Dwords25.DW1.SurfaceFormat            = MosFormatToVdencSurfaceRawFormat(params->psSurface->Format);
        cmd.Dwords25.DW0.SurfaceFormatByteSwizzle = params->bDisplayFormatSwizzle;
        cmd.Dwords25.DW1.SurfacePitch             = params->psSurface->dwPitch - 1;
        cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr =
            MOS_ALIGN_CEIL((params->psSurface->UPlaneOffset.iSurfaceOffset - params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.U.YOffset, MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9);
        cmd.Dwords25.DW1.ChromaDownsampleFilterControl = 7;

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencRefSurfaceStateCmd(
        PMOS_COMMAND_BUFFER       cmdBuffer,
        PMHW_VDBOX_SURFACE_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);
        MHW_MI_CHK_NULL(params->psSurface);

        typename TVdencCmds::VDENC_REF_SURFACE_STATE_CMD cmd;

        if (params->bVdencDynamicScaling)
        {
            if (params->ucSurfaceStateId == CODECHAL_HCP_LAST_SURFACE_ID)
            {
                cmd.DW1.SurfaceId = 4;
            }
            else if (params->ucSurfaceStateId == CODECHAL_HCP_GOLDEN_SURFACE_ID)
            {
                cmd.DW1.SurfaceId = 5;
            }
            else if (params->ucSurfaceStateId == CODECHAL_HCP_ALTREF_SURFACE_ID)
            {
                cmd.DW1.SurfaceId = 6;
            }
        }

        if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_AV1)
        {
            cmd.Dwords25.DW0.Width  = params->dwActualWidth - 1;
            cmd.Dwords25.DW0.Height = params->dwActualHeight - 1;
        }
        else
        {
            cmd.Dwords25.DW0.Width  = params->psSurface->dwWidth - 1;
            cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
        }

        cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;

        uint32_t tilemode             = GetHWTileType(params->psSurface->TileType, params->psSurface->TileModeGMM, params->psSurface->bGMMTileEnabled);
        cmd.Dwords25.DW1.TiledSurface = (tilemode & 0x2) >> 1;
        cmd.Dwords25.DW1.TileWalk     = tilemode & 0x1;

        cmd.Dwords25.DW1.SurfaceFormat = MosFormatToVdencSurfaceReconFormat(params->psSurface->Format);

        if (cmd.Dwords25.DW1.SurfaceFormat == TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_P010)
        {
            cmd.Dwords25.DW1.SurfaceFormat = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_P010_VARIANT;
        }

        cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
        cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = 
            (params->psSurface->UPlaneOffset.iSurfaceOffset - params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.U.YOffset;

        if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY416Variant ||
            cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatAyuvVariant)
        {
            /* Y410/Y416 Reconstructed format handling */
            if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY416Variant)
                cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch / 2 - 1;
            /* AYUV Reconstructed format handling */
            if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatAyuvVariant)
                cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch / 4 - 1;

            cmd.Dwords25.DW2.YOffsetForUCb = params->dwReconSurfHeight;
            cmd.Dwords25.DW3.YOffsetForVCr = params->dwReconSurfHeight << 1;
        }
        else if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY216Variant ||
            cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatYuyvVariant)
        {
            cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->dwReconSurfHeight;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencDsRefSurfaceStateCmd(
        PMOS_COMMAND_BUFFER       cmdBuffer,
        PMHW_VDBOX_SURFACE_PARAMS params,
        uint8_t                   numSurfaces) override
    {
        uint32_t tilemode = 0;
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);
        MHW_MI_CHK_NULL(params->psSurface);

        typename TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD cmd;

        if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_AV1)
        {
            cmd.Dwords25.DW0.Width  = params->dwActualWidth - 1;
            cmd.Dwords25.DW0.Height = params->dwActualHeight - 1;
        }
        else
        {
            cmd.Dwords25.DW0.Width  = params->psSurface->dwWidth - 1;
            cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
        }
        cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;

        tilemode                      = GetHWTileType(params->psSurface->TileType, params->psSurface->TileModeGMM, params->psSurface->bGMMTileEnabled);
        cmd.Dwords25.DW1.TiledSurface = (tilemode & 0x2) >> 1;
        cmd.Dwords25.DW1.TileWalk     = tilemode & 0x1;

        cmd.Dwords25.DW1.SurfaceFormat    = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8;
        cmd.Dwords25.DW1.SurfacePitch     = params->psSurface->dwPitch - 1;
        cmd.Dwords25.DW2.YOffsetForUCb    = cmd.Dwords25.DW3.YOffsetForVCr = 
            (params->psSurface->UPlaneOffset.iSurfaceOffset - params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.U.YOffset;

        // 2nd surface
        if (numSurfaces > 1)
        {
            params = params + 1;          // Increment pointer to move from 1st surface to 2nd surface.
            MHW_MI_CHK_NULL(params);
            MHW_MI_CHK_NULL(params->psSurface);

            if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_AV1)
            {
                cmd.Dwords69.DW0.Width  = params->dwActualWidth - 1;
                cmd.Dwords69.DW0.Height = params->dwActualHeight - 1;
            }
            else
            {
                cmd.Dwords69.DW0.Width  = params->psSurface->dwWidth - 1;
                cmd.Dwords69.DW0.Height = params->psSurface->dwHeight - 1;
            }
            cmd.Dwords69.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;

            tilemode                          = GetHWTileType(params->psSurface->TileType, params->psSurface->TileModeGMM, params->psSurface->bGMMTileEnabled);
            cmd.Dwords69.DW1.TiledSurface     = (tilemode & 0x2) >> 1;
            cmd.Dwords69.DW1.TileWalk         = tilemode & 0x1;

            cmd.Dwords69.DW1.SurfaceFormat    = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8;
            cmd.Dwords69.DW1.SurfacePitch     = params->psSurface->dwPitch - 1;
            cmd.Dwords69.DW2.YOffsetForUCb    = cmd.Dwords69.DW3.YOffsetForVCr = 
                (params->psSurface->UPlaneOffset.iSurfaceOffset - params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.U.YOffset;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencImgStateCmd(
        PMOS_COMMAND_BUFFER       cmdBuffer,
        PMHW_BATCH_BUFFER         batchBuffer,
        PMHW_VDBOX_AVC_IMG_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(params);
        MHW_MI_CHK_NULL(params->pEncodeAvcSeqParams);
        MHW_MI_CHK_NULL(params->pEncodeAvcPicParams);
 
        auto paramsG12 = dynamic_cast<PMHW_VDBOX_AVC_IMG_PARAMS_G12>(params);
        MHW_MI_CHK_NULL(paramsG12);

        typename TVdencCmds::VDENC_IMG_STATE_CMD cmd;

        auto avcSeqParams   = params->pEncodeAvcSeqParams;
        auto avcPicParams   = params->pEncodeAvcPicParams;
        auto avcSliceParams = params->pEncodeAvcSliceParams;

        // initialize
        cmd.DW1.VdencExtendedPakObjCmdEnable         = 1;
        cmd.DW2.UnidirectionalMixDisable             = false;
        cmd.DW4.IntraSadMeasureAdjustment            = 2;
        cmd.DW4.SubMacroblockSubPartitionMask        = 0x70;
        cmd.DW8.BilinearFilterEnable                 = false;
        cmd.DW9.Mode0Cost                            = 10;
        cmd.DW9.Mode1Cost                            = 0;
        cmd.DW9.Mode2Cost                            = 3;
        cmd.DW9.Mode3Cost                            = 30;
        cmd.DW20.PenaltyForIntra16X16NondcPrediction = 36;
        cmd.DW20.PenaltyForIntra8X8NondcPrediction   = 12;
        cmd.DW20.PenaltyForIntra4X4NondcPrediction   = 4;
        cmd.DW22.Smallmbsizeinword                   = 0xff;
        cmd.DW22.Largembsizeinword                   = 0xff;
        cmd.DW27.MaxHmvR                             = 0x2000;
        cmd.DW27.MaxVmvR                             = 0x200;
        cmd.DW33.Maxdeltaqp                          = 0x0f;

        // initialize for P frame
        if (avcPicParams->CodingType != I_TYPE)
        {
            cmd.DW2.BidirectionalWeight       = 0x20;
            cmd.DW4.SubPelMode                = (avcPicParams->bEnableSubPelMode) ? avcPicParams->SubPelMode : 3;
            cmd.DW4.BmeDisableForFbrMessage   = 1;
            cmd.DW4.InterSadMeasureAdjustment = 2;
            cmd.DW5.CrePrefetchEnable         = 1;
            cmd.DW8.NonSkipZeroMvCostAdded    = 1;
            cmd.DW8.NonSkipMbModeCostAdded    = 1;
            cmd.DW9.Mode0Cost                 = 7;
            cmd.DW9.Mode1Cost                 = 26;
            cmd.DW9.Mode2Cost                 = 30;
            cmd.DW9.Mode3Cost                 = 57;
            cmd.DW10.Mode4Cost                = 8;
            cmd.DW10.Mode5Cost                = 2;
            cmd.DW10.Mode6Cost                = 4;
            cmd.DW10.Mode7Cost                = 6;
            cmd.DW11.Mode8Cost                = 5;
            cmd.DW11.Mode9Cost                = 0;
            cmd.DW11.RefIdCost                = 4;
            cmd.DW12.MvCost0                  = 0;
            cmd.DW12.MvCost1                  = 6;
            cmd.DW12.MvCost2                  = 6;
            cmd.DW12.MvCost3                  = 9;
            cmd.DW13.MvCost4                  = 10;
            cmd.DW13.MvCost5                  = 13;
            cmd.DW13.MvCost6                  = 14;
            cmd.DW13.MvCost7                  = 24;
            cmd.DW31.SadHaarThreshold0        = 800;
            cmd.DW32.SadHaarThreshold1        = 1600;
            cmd.DW32.SadHaarThreshold2        = 2400;
            cmd.DW34.MidpointSadHaar          = 0x640;
        }

        cmd.DW1.VdencPerfmode                   = params->bVDEncPerfModeEnabled;
        cmd.DW1.Transform8X8Flag                = avcPicParams->transform_8x8_mode_flag;
        cmd.DW3.PictureWidth                    = params->wPicWidthInMb;
        cmd.DW4.ForwardTransformSkipCheckEnable = this->m_vdencFTQEnabled[avcSeqParams->TargetUsage];
        cmd.DW4.BlockBasedSkipEnabled           = this->m_vdencBlockBasedSkipEnabled[avcSeqParams->TargetUsage];
        cmd.DW5.CrePrefetchEnable               = params->bCrePrefetchEnable;
        cmd.DW5.PictureHeightMinusOne           = params->wPicHeightInMb - 1;
        cmd.DW5.PictureType                     = avcPicParams->CodingType - 1;
        cmd.DW5.ConstrainedIntraPredictionFlag  = avcPicParams->constrained_intra_pred_flag;

        if (paramsG12->bVDEncUltraModeEnabled)
        {
            cmd.DW1.VdencPerfmode  = true;
            cmd.DW1.VdencUltraMode = true;
        }

        // HME Ref1 Disable should be set as 0 when VDEnc Perf Mode is enabled 
        if ((avcPicParams->CodingType != I_TYPE) && 
            (!params->pEncodeAvcSliceParams->num_ref_idx_l0_active_minus1) &&
            (!params->bVDEncPerfModeEnabled))
        {
            cmd.DW5.HmeRef1Disable = true;
        }

        if (avcSeqParams->EnableSliceLevelRateCtrl)
        {
            cmd.DW5.MbSliceThresholdValue = params->dwMbSlcThresholdValue;
        }

        cmd.DW6.SliceMacroblockHeightMinusOne = params->wPicHeightInMb - 1;

        cmd.DW8.LumaIntraPartitionMask = avcPicParams->transform_8x8_mode_flag ? 0 : TVdencCmds::VDENC_IMG_STATE_CMD::LUMA_INTRA_PARTITION_MASK_UNNAMED2;

        cmd.DW14.QpPrimeY = avcPicParams->QpY + avcSliceParams->slice_qp_delta;

        if (params->pVDEncModeCost)
        {
            cmd.DW9.Mode0Cost  = *(params->pVDEncModeCost);
            cmd.DW9.Mode1Cost  = *(params->pVDEncModeCost + 1);
            cmd.DW9.Mode2Cost  = *(params->pVDEncModeCost + 2);
            cmd.DW9.Mode3Cost  = *(params->pVDEncModeCost + 3);

            cmd.DW10.Mode4Cost = *(params->pVDEncModeCost + 4);
            cmd.DW10.Mode5Cost = *(params->pVDEncModeCost + 5);
            cmd.DW10.Mode6Cost = *(params->pVDEncModeCost + 6);
            cmd.DW10.Mode7Cost = *(params->pVDEncModeCost + 7);

            cmd.DW11.Mode8Cost = *(params->pVDEncModeCost + 8);
            cmd.DW11.RefIdCost = *(params->pVDEncModeCost + 10);
        }
        if (params->pVDEncMvCost)
        {
            cmd.DW12.MvCost0 = *(params->pVDEncMvCost);
            cmd.DW12.MvCost1 = *(params->pVDEncMvCost + 1);
            cmd.DW12.MvCost2 = *(params->pVDEncMvCost + 2);
            cmd.DW12.MvCost3 = *(params->pVDEncMvCost + 3);
            cmd.DW13.MvCost4 = *(params->pVDEncMvCost + 4);
            cmd.DW13.MvCost5 = *(params->pVDEncMvCost + 5);
            cmd.DW13.MvCost6 = *(params->pVDEncMvCost + 6);
            cmd.DW13.MvCost7 = *(params->pVDEncMvCost + 7);
        }

        cmd.DW27.MaxVmvR = params->dwMaxVmvR;

        if (params->pVDEncHmeMvCost)
        {
            cmd.DW28.HmeMvCost0 = *(params->pVDEncHmeMvCost);
            cmd.DW28.HmeMvCost1 = *(params->pVDEncHmeMvCost + 1);
            cmd.DW28.HmeMvCost2 = *(params->pVDEncHmeMvCost + 2);
            cmd.DW28.HmeMvCost3 = *(params->pVDEncHmeMvCost + 3);
            cmd.DW29.HmeMvCost4 = *(params->pVDEncHmeMvCost + 4);
            cmd.DW29.HmeMvCost5 = *(params->pVDEncHmeMvCost + 5);
            cmd.DW29.HmeMvCost6 = *(params->pVDEncHmeMvCost + 6);
            cmd.DW29.HmeMvCost7 = *(params->pVDEncHmeMvCost + 7);
        }

        // HMEOffset is in range of -128 to 127, clip value to within range
        if (avcPicParams->bEnableHMEOffset)
        {
            cmd.DW7.Hme0XOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[0][0][0], -128, 127);
            cmd.DW7.Hme0YOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[0][0][1], -128, 127);
            cmd.DW7.Hme1XOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[1][0][0], -128, 127);
            cmd.DW7.Hme1YOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[1][0][1], -128, 127);
        }

        // Rolling-I settings
        if ((avcPicParams->CodingType != I_TYPE) && (avcPicParams->EnableRollingIntraRefresh != ROLLING_I_DISABLED))
        {
            cmd.DW21.IntraRefreshEnableRollingIEnable = avcPicParams->EnableRollingIntraRefresh != ROLLING_I_DISABLED ? 1 : 0;
            cmd.DW21.IntraRefreshMode                 = avcPicParams->EnableRollingIntraRefresh == ROLLING_I_ROW ? 0 : 1;        // 0->Row based ; 1->Column based
            cmd.DW21.IntraRefreshMBPos                = avcPicParams->IntraRefreshMBNum;
            cmd.DW21.IntraRefreshMBSizeMinusOne       = avcPicParams->IntraRefreshUnitinMB;
            cmd.DW21.QpAdjustmentForRollingI          = avcPicParams->IntraRefreshQPDelta;

            auto waTable = this->m_osInterface->pfnGetWaTable(this->m_osInterface);
            MHW_MI_CHK_NULL(waTable);

            // WA to prevent error propagation from top-right direction.
            // Disable prediction modes 3, 7 for 4x4
            // and modes 0, 2, 3, 4, 5, 7 for 8x8 (due to filtering)
            if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_COLUMN &&
                MEDIA_IS_WA(waTable, Wa_18011246551))
            {
                cmd.DW17.AvcIntra4X4ModeMask = 0x88;
                cmd.DW17.AvcIntra8X8ModeMask = 0xBD;
            }
        }

        // Setting MinMaxQP values if they are presented
        if (avcPicParams->ucMaximumQP && avcPicParams->ucMinimumQP)
        {
            cmd.DW33.MaxQp = avcPicParams->ucMaximumQP;
            cmd.DW33.MinQp = avcPicParams->ucMinimumQP;
        }
        else
        {
            // Set default values
            cmd.DW33.MaxQp = 0x33;
            cmd.DW33.MinQp = 0x0a;
        }

        // VDEnc CQP case ROI settings, BRC ROI will be handled in HuC FW
        if (!params->bVdencBRCEnabled && avcPicParams->NumROI)
        {
            MHW_ASSERT(avcPicParams->NumROI < 4);

            int8_t priorityLevelOrDQp[ENCODE_VDENC_AVC_MAX_ROI_NUMBER_G9] = { 0 };

            for (uint8_t i = 0; i < avcPicParams->NumROI; i++)
            {
                int8_t dQpRoi = avcPicParams->ROIDistinctDeltaQp[i];

                // clip delta qp roi to VDEnc supported range
                priorityLevelOrDQp[i] = (char)CodecHal_Clip3(
                    ENCODE_VDENC_AVC_MIN_ROI_DELTA_QP_G9, ENCODE_VDENC_AVC_MAX_ROI_DELTA_QP_G9, dQpRoi);
            }

            cmd.DW34.RoiEnable = true;

            // Zone0 is reserved for non-ROI region
            cmd.DW30.RoiQpAdjustmentForZone1 = priorityLevelOrDQp[0];
            cmd.DW30.RoiQpAdjustmentForZone2 = priorityLevelOrDQp[1];
            cmd.DW30.RoiQpAdjustmentForZone3 = priorityLevelOrDQp[2];
        }

        if (avcSeqParams->RateControlMethod != RATECONTROL_CQP)
        {
            cmd.DW30.QpAdjustmentForShapeBestIntra4X4Winner = 0;
            cmd.DW30.QpAdjustmentForShapeBestIntra8X8Winner = 0;
            cmd.DW30.QpAdjustmentForShapeBestIntra16X16Winner = 0;

            cmd.DW31.BestdistortionQpAdjustmentForZone0 = 0;
            cmd.DW31.BestdistortionQpAdjustmentForZone1 = 1;
            cmd.DW31.BestdistortionQpAdjustmentForZone2 = 2;
            cmd.DW31.BestdistortionQpAdjustmentForZone3 = 3;
        }

        if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED && params->bVdencStreamInEnabled &&
            (avcPicParams->NumDirtyROI && params->bVdencBRCEnabled || avcPicParams->NumROI && avcPicParams->bNativeROI ||
                (avcPicParams->TargetFrameSize > 0 && !avcSeqParams->LookaheadDepth)))  // TCBRC (for AdaptiveRegionBoost)
        {
            cmd.DW34.RoiEnable = true;
        }

        if (params->bVdencStreamInEnabled)
        {
            cmd.DW34.FwdPredictor0MvEnable = 1;
            cmd.DW34.PpmvDisable           = 1;

            // non-native ROI in ForceQP mode (VDEnc StreamIn filled by HuC in BRC mode and by UMD driver in CQP) or MBQP
            if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED &&
                ((avcPicParams->NumROI && !avcPicParams->bNativeROI) || paramsG12->bStreamInMbQpEnabled))
            {
                cmd.DW34.MbLevelQpEnable = 1;
            }
        }

        if (cmdBuffer == nullptr && batchBuffer == nullptr)
        {
            MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
            return MOS_STATUS_NULL_POINTER;
        }

        MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencWalkerStateCmd(
        PMOS_COMMAND_BUFFER                  cmdBuffer,
        PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename TVdencCmds::VDENC_WALKER_STATE_CMD cmd;

        if (params->Mode == CODECHAL_ENCODE_MODE_AVC)
        {
            MHW_MI_CHK_NULL(params->pAvcSeqParams);
            MHW_MI_CHK_NULL(params->pAvcSlcParams);

            auto avcSeqParams = params->pAvcSeqParams;
            auto avcSlcParams = params->pAvcSlcParams;

            cmd.DW1.MbLcuStartYPosition = avcSlcParams->first_mb_in_slice / CODECHAL_GET_WIDTH_IN_MACROBLOCKS(avcSeqParams->FrameWidth);

            cmd.DW2.NextsliceMbStartYPosition = (avcSlcParams->first_mb_in_slice + avcSlcParams->NumMbsForSlice) / CODECHAL_GET_WIDTH_IN_MACROBLOCKS(avcSeqParams->FrameWidth);

            if (cmd.DW2.NextsliceMbStartYPosition > (uint32_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(avcSeqParams->FrameHeight))
            {
                cmd.DW2.NextsliceMbStartYPosition = (uint32_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(avcSeqParams->FrameHeight);
            }

            cmd.DW3.Log2WeightDenomLuma = avcSlcParams->luma_log2_weight_denom;

            cmd.DW5.TileWidth = avcSeqParams->FrameWidth - 1;
        }
        else if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
        {
            auto paramsG12 = dynamic_cast<PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12>(params);
            MHW_MI_CHK_NULL(paramsG12);

            MHW_MI_CHK_NULL(params->pHevcEncSeqParams);
            MHW_MI_CHK_NULL(params->pHevcEncPicParams);
            MHW_MI_CHK_NULL(params->pEncodeHevcSliceParams);

            auto seqParams   = params->pHevcEncSeqParams;
            auto picParams   = params->pHevcEncPicParams;
            auto sliceParams = params->pEncodeHevcSliceParams;

            uint32_t ctbSize     = 1 << (seqParams->log2_max_coding_block_size_minus3 + 3);
            uint32_t widthInPix  = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameWidthInMinCbMinus1 + 1);
            uint32_t widthInCtb  = (widthInPix / ctbSize) + ((widthInPix % ctbSize) ? 1 : 0);  // round up
            uint32_t heightInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameHeightInMinCbMinus1 + 1);
            uint32_t heightInCtb = (heightInPix / ctbSize) + ((heightInPix % ctbSize) ? 1 : 0);  // round up
            uint32_t shift     = seqParams->log2_max_coding_block_size_minus3 - seqParams->log2_min_coding_block_size_minus3;

            cmd.DW3.Log2WeightDenomLuma = cmd.DW3.HevcLog2WeightDemonLuma =
                (picParams->weighted_pred_flag || picParams->weighted_bipred_flag) ? (picParams->bEnableGPUWeightedPrediction ? 6 : sliceParams->luma_log2_weight_denom) : 0;

            if (paramsG12->pTileCodingParams == nullptr)
            {
                // No tiling support
                cmd.DW1.MbLcuStartYPosition          = sliceParams->slice_segment_address / widthInCtb;
                cmd.DW2.NextsliceMbLcuStartXPosition = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / heightInCtb;
                cmd.DW2.NextsliceMbStartYPosition    = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / widthInCtb;
                cmd.DW5.TileWidth                    = widthInPix - 1;
                cmd.DW5.TileHeight                   = heightInPix - 1;
            }
            else
            {
                cmd.DW1.MbLcuStartXPosition          = paramsG12->pTileCodingParams->TileStartLCUX;
                cmd.DW1.MbLcuStartYPosition          = paramsG12->pTileCodingParams->TileStartLCUY;

                cmd.DW2.NextsliceMbLcuStartXPosition = paramsG12->pTileCodingParams->TileStartLCUX + (paramsG12->pTileCodingParams->TileWidthInMinCbMinus1 >> shift) + 1;
                cmd.DW2.NextsliceMbStartYPosition    = paramsG12->pTileCodingParams->TileStartLCUY + (paramsG12->pTileCodingParams->TileHeightInMinCbMinus1 >> shift) + 1;

                cmd.DW4.TileStartCtbX                = paramsG12->pTileCodingParams->TileStartLCUX * ctbSize;
                cmd.DW4.TileStartCtbY                = paramsG12->pTileCodingParams->TileStartLCUY * ctbSize;

                cmd.DW5.TileWidth                    = ((paramsG12->pTileCodingParams->TileWidthInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) - 1;
                cmd.DW5.TileHeight                   = ((paramsG12->pTileCodingParams->TileHeightInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) - 1;
                cmd.DW1.FirstSuperSlice              = 1;
                cmd.DW3.NumParEngine                 = paramsG12->dwNumberOfPipes;
                cmd.DW3.TileNumber                   = paramsG12->dwTileId;
                cmd.DW3.TileRowStoreSelect           = paramsG12->pTileCodingParams->TileRowStoreSelect;
                cmd.DW8.TileStreamoutOffsetEnable    = 1;
                cmd.DW8.TileStreamoutOffset          = paramsG12->dwTileId * 19;

                cmd.DW6.StreaminOffsetEnable         = 1;
                cmd.DW6.TileStreaminOffset           = paramsG12->pTileCodingParams->TileStreaminOffset;

                // PAK Object StreamOut Offset Computation 
                uint32_t tileLCUStreamOutByteOffset = 0;
                if (paramsG12->pTileCodingParams->TileStartLCUX != 0 || paramsG12->pTileCodingParams->TileStartLCUY != 0)
                {
                    uint32_t ctbSize = 1 << (seqParams->log2_max_coding_block_size_minus3 + 3);
                    uint32_t NumOfCUInLCU = (ctbSize >> 3) * (ctbSize >> 3);  // Min CU size is 8
                    uint32_t ImgWidthInLCU = (((seqParams->wFrameWidthInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) + ctbSize - 1) / ctbSize;
                    uint32_t ImgHeightInLCU = (((seqParams->wFrameHeightInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) + ctbSize - 1) / ctbSize;
                    uint32_t NumLCUsCurLocation = paramsG12->pTileCodingParams->TileStartLCUY * ImgWidthInLCU + paramsG12->pTileCodingParams->TileStartLCUX * 
                                                  ((((paramsG12->pTileCodingParams->TileHeightInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) + ctbSize - 1) / ctbSize);
                    //For PAKObject Surface
                    tileLCUStreamOutByteOffset = 2 * BYTES_PER_DWORD * NumLCUsCurLocation * (NUM_PAK_DWS_PER_LCU + NumOfCUInLCU * NUM_DWS_PER_CU);
                    //Add 1 CL for size info at the beginning of each tile
                    tileLCUStreamOutByteOffset += MHW_CACHELINE_SIZE;
                    //CL alignment at end of every tile
                    tileLCUStreamOutByteOffset = MOS_ROUNDUP_DIVIDE(tileLCUStreamOutByteOffset, MHW_CACHELINE_SIZE);
                }

                cmd.DW9.TileLcuStreamOutOffset = tileLCUStreamOutByteOffset;
                cmd.DW9.LcuStreamOutOffsetEnable = 0x1;

                if (cmd.DW4.TileStartCtbY == 0)
                {
                    //RowStore Offset Computation
                    uint32_t num32x32InX = (cmd.DW4.TileStartCtbX) / 32;
                    cmd.DW7.RowStoreOffsetEnable = 1;
                    cmd.DW7.TileRowstoreOffset = num32x32InX;
                }
            }

            // for IBC
            cmd.DW11.Value &= 0xfffc00ff;
            cmd.DW12.Value = (cmd.DW12.Value & 0xfcffffff) | 0x1000000;
            cmd.DW12.IbcControl = params->pHevcEncPicParams->pps_curr_pic_ref_enabled_flag ?
                paramsG12->IBCControl : VDENC_WALKER_STATE_COMMAND_IBC_CONTROL_IBC_DISABLED_G12;

            cmd.DW12.PaletteModeEnable = (seqParams->palette_mode_enabled_flag != 0) ? 1 : 0;
            uint32_t sliceQP = picParams->QpY + sliceParams->slice_qp_delta;
            uint32_t index;
            if (sliceQP <= 12)
            {
                index = 0;
            }
            else if (sliceQP > 12 && sliceQP <= 47)
            {
                index = (sliceQP - 8) / 5;
            }
            else if (sliceQP > 47 && sliceQP <= 49)
            {
                index = 8;
            }
            else
            {
                index = 9;
            }
            const uint32_t table1[10] = {0x50001,0x50001,0x50001,0x50002,0x90002,0x90002,0x90002,0xd0002,0x190002,0x210003};
            cmd.DW12.Value = (cmd.DW12.Value & 0xff80fff8) | table1[index];
            const uint32_t table2[10] = {0x2000a,0x2000a,0x2000a,0x4000a,0x8000a,0xc0010,0xc0018,0xc0018,0x100020,0x180030};
            cmd.DW13.Value = table2[index];
            const uint32_t table3[10] = {0x101004,0x101004,0x101004,0xc1008,0x42004,0x42006,0x13f06,0x13f06,0x13f0c,0x13006};
            cmd.DW14.Value = (cmd.DW14.Value & 0xffe0c0c0) | table3[index];
            const uint32_t table4[10] = {0x100004,0x100004,0x100004,0x100004,0x200004,0x300004,0x400004,0x600004,0x800004,0x1000004};
            cmd.DW15.Value = (cmd.DW15.Value & 0xfc00) | table4[index];

            if (seqParams->bit_depth_luma_minus8 > 0 && seqParams->palette_mode_enabled_flag)
            {

                const uint32_t table1[10] = {0x3,0x3,0x3,0x4,0x4,0x4,0x4,0x4,0x4,0x5};
                cmd.DW12.Value  = (cmd.DW12.Value & 0xfffffff8) | table1[index];
                const uint32_t table2[10] = {0x80028,0x80028,0x80028,0x100028,0x200028,0x300040,0x300060,0x300060,0x400080,0x6000c0};
                cmd.DW13.Value  = table2[index];
                const uint32_t table3[10] = {0x400000,0x400000,0x400000,0x400000,0x800000,0xc00000,0x1000000,0x1800000,0x2000000,0x4000000};
                cmd.DW15.Value = (cmd.DW15.Value & 0xffff) | table3[index];
            }

            cmd.DW12.Value &= 0xffff00ff;
            cmd.DW14.Value = (cmd.DW14.Value & 0x9fffff) | 0xc8400000;
            cmd.DW16.Value = (cmd.DW16.Value & 0xffffff) | 0xa6000000;
            if (seqParams->TargetUsage == 7)
            {
                cmd.DW16.Value = (cmd.DW16.Value & 0xffc0c0c0) | 0x313131;
            }
            else
            {
                cmd.DW16.Value = (cmd.DW16.Value & 0xffc0c0c0) | 0x3f3f3f;
            }
        }
        else if (params->Mode == CODECHAL_ENCODE_MODE_VP9)
        {
            auto paramsG12 = dynamic_cast<PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12>(params);
            MHW_MI_CHK_NULL(paramsG12);
            MHW_MI_CHK_NULL(params->pVp9EncPicParams);
            auto vp9PicParams = params->pVp9EncPicParams;
            auto tileCodingParams = paramsG12->pTileCodingParams;

            if (tileCodingParams == nullptr)
            {
                cmd.DW2.NextsliceMbLcuStartXPosition = CODECHAL_GET_WIDTH_IN_BLOCKS(vp9PicParams->SrcFrameWidthMinus1, CODEC_VP9_SUPER_BLOCK_WIDTH);
                cmd.DW2.NextsliceMbStartYPosition    = CODECHAL_GET_HEIGHT_IN_BLOCKS(vp9PicParams->SrcFrameHeightMinus1, CODEC_VP9_SUPER_BLOCK_HEIGHT);
                cmd.DW5.TileWidth                    = vp9PicParams->SrcFrameWidthMinus1;
                cmd.DW5.TileHeight                   = vp9PicParams->SrcFrameHeightMinus1;
                cmd.DW1.FirstSuperSlice              = 1;
            }
            else
            {
                cmd.DW1.MbLcuStartXPosition          = tileCodingParams->TileStartLCUX;
                cmd.DW1.MbLcuStartYPosition          = tileCodingParams->TileStartLCUY;

                cmd.DW5.TileWidth                    = ((tileCodingParams->TileWidthInMinCbMinus1 + 1) * CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
                cmd.DW5.TileHeight                   = ((tileCodingParams->TileHeightInMinCbMinus1 + 1) * CODEC_VP9_MIN_BLOCK_HEIGHT) - 1;

                cmd.DW4.TileStartCtbX                = tileCodingParams->TileStartLCUX * CODEC_VP9_SUPER_BLOCK_WIDTH;
                cmd.DW4.TileStartCtbY                = tileCodingParams->TileStartLCUY * CODEC_VP9_SUPER_BLOCK_HEIGHT;

                cmd.DW2.NextsliceMbLcuStartXPosition = CODECHAL_GET_WIDTH_IN_BLOCKS((cmd.DW4.TileStartCtbX + cmd.DW5.TileWidth + 1), CODEC_VP9_SUPER_BLOCK_WIDTH);
                cmd.DW2.NextsliceMbStartYPosition    = CODECHAL_GET_HEIGHT_IN_BLOCKS((cmd.DW4.TileStartCtbY + cmd.DW5.TileHeight + 1), CODEC_VP9_SUPER_BLOCK_HEIGHT);

                cmd.DW1.FirstSuperSlice              = 1;
                cmd.DW3.NumParEngine                 = paramsG12->dwNumberOfPipes;
                cmd.DW3.TileNumber                   = paramsG12->dwTileId;

                //Frame Stats Offset
                cmd.DW8.TileStreamoutOffsetEnable = 1;
                cmd.DW8.TileStreamoutOffset = (paramsG12->dwTileId * 19); // 3 CLs or 48 DWs of statistics data + 16CLs or 256 DWs of Histogram data

                uint32_t tileStartXInSBs = (cmd.DW4.TileStartCtbX / CODEC_VP9_SUPER_BLOCK_WIDTH);
                uint32_t tileStartYInSBs = (cmd.DW4.TileStartCtbY / CODEC_VP9_SUPER_BLOCK_HEIGHT);
                //Aligned Tile height & frame width
                uint32_t tileHeightInSBs = (cmd.DW5.TileHeight + 1 + (CODEC_VP9_SUPER_BLOCK_HEIGHT - 1)) / CODEC_VP9_SUPER_BLOCK_HEIGHT;
                uint32_t frameWidthInSBs = (vp9PicParams->SrcFrameWidthMinus1 + 1 + (CODEC_VP9_SUPER_BLOCK_WIDTH - 1)) / CODEC_VP9_SUPER_BLOCK_WIDTH;

                cmd.DW6.StreaminOffsetEnable = 1;
                //StreamIn data is 4 CLs per LCU
                cmd.DW6.TileStreaminOffset = (tileStartYInSBs * frameWidthInSBs + tileStartXInSBs * tileHeightInSBs) * (4);

                //Compute PAK Object StreamOut Offsets
                uint32_t tileLCUStreamOutOffsetInCachelines = 0;
                if (cmd.DW4.TileStartCtbY != 0 || cmd.DW4.TileStartCtbX != 0)
                {
                    //Aligned Tile width & frame height
                    uint32_t numOfSBs = tileStartYInSBs * frameWidthInSBs + tileStartXInSBs * tileHeightInSBs;
                    //max LCU size is 64, min Cu size is 8
                    uint32_t maxNumOfCUInSB = (CODEC_VP9_SUPER_BLOCK_HEIGHT / CODEC_VP9_MIN_BLOCK_HEIGHT) * (CODEC_VP9_SUPER_BLOCK_WIDTH / CODEC_VP9_MIN_BLOCK_WIDTH);
                    //(num of SBs in a tile) *  (num of cachelines needed per SB)
                    tileLCUStreamOutOffsetInCachelines = numOfSBs * (MOS_ROUNDUP_DIVIDE((2 * BYTES_PER_DWORD * (NUM_PAK_DWS_PER_LCU + maxNumOfCUInSB * NUM_DWS_PER_CU)), MHW_CACHELINE_SIZE));
                }

                cmd.DW9.LcuStreamOutOffsetEnable = 1;
                cmd.DW9.TileLcuStreamOutOffset = tileLCUStreamOutOffsetInCachelines;

                if (cmd.DW4.TileStartCtbY == 0)
                {
                    //RowStore Offset Computation
                    uint32_t num32x32sInX = (cmd.DW4.TileStartCtbX) / 32;
                    cmd.DW7.RowStoreOffsetEnable = 1;
                    cmd.DW7.TileRowstoreOffset = num32x32sInX;
                }
            }
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencAvcWeightsOffsetsStateCmd(
        PMOS_COMMAND_BUFFER                cmdBuffer,
        PMHW_VDBOX_AVC_WEIGHTOFFSET_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);
        MHW_MI_CHK_NULL(params->pAvcPicParams);

        typename TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD cmd;

        auto avcPicParams = params->pAvcPicParams;

        if (avcPicParams->weighted_pred_flag == 1)
        {
            cmd.DW1.WeightsForwardReference0 = params->Weights[0][0][0][0];
            cmd.DW1.OffsetForwardReference0  = params->Weights[0][0][0][1];
            cmd.DW1.WeightsForwardReference1 = params->Weights[0][1][0][0];
            cmd.DW1.OffsetForwardReference1  = params->Weights[0][1][0][1];
            cmd.DW2.WeightsForwardReference2 = params->Weights[0][2][0][0];
            cmd.DW2.OffsetForwardReference2  = params->Weights[0][2][0][1];
        }
        //set to default value when weighted prediction not enabled
        else
        {
            cmd.DW1.WeightsForwardReference0 = 1;
            cmd.DW1.OffsetForwardReference0  = 0;
            cmd.DW1.WeightsForwardReference1 = 1;
            cmd.DW1.OffsetForwardReference1  = 0;
            cmd.DW2.WeightsForwardReference2 = 1;
            cmd.DW2.OffsetForwardReference2  = 0;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencWeightsOffsetsStateCmd(
        PMOS_COMMAND_BUFFER                   cmdBuffer,
        PMHW_BATCH_BUFFER                     batchBuffer,
        PMHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(params);

        typename TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD cmd;

        cmd.DW1.WeightsForwardReference0         = 1;
        cmd.DW1.OffsetForwardReference0          = 0;
        cmd.DW1.WeightsForwardReference1         = 1;
        cmd.DW1.OffsetForwardReference1          = 0;
        cmd.DW2.WeightsForwardReference2         = 1;
        cmd.DW2.OffsetForwardReference2          = 0;
        cmd.DW2.HevcVp9WeightsBackwardReference0 = 1;
        cmd.DW2.HevcVp9OffsetBackwardReference0  = 0;

        // Luma Offsets and Weights
        if (params->bWeightedPredEnabled)
        {
            uint32_t  refPicListNum = 0;
            // DWORD 1
            cmd.DW1.WeightsForwardReference0 = CodecHal_Clip3(-128, 127,
                params->LumaWeights[refPicListNum][0] + params->dwDenom);
            cmd.DW1.OffsetForwardReference0  = params->LumaOffsets[refPicListNum][0];
            cmd.DW1.WeightsForwardReference1 = CodecHal_Clip3(-128, 127,
                params->LumaWeights[refPicListNum][1] + params->dwDenom);
            cmd.DW1.OffsetForwardReference1  = params->LumaOffsets[refPicListNum][1];

            // DWORD 2
            cmd.DW2.WeightsForwardReference2 = CodecHal_Clip3(-128, 127,
                params->LumaWeights[refPicListNum][2] + params->dwDenom);
            cmd.DW2.OffsetForwardReference2  = params->LumaOffsets[refPicListNum][2];
            if (!params->isLowDelay)
            {
                refPicListNum = 1;
                cmd.DW2.HevcVp9WeightsBackwardReference0 = CodecHal_Clip3(-128, 127,
                    params->LumaWeights[refPicListNum][0] + params->dwDenom);
                cmd.DW2.HevcVp9OffsetBackwardReference0 = params->LumaOffsets[refPicListNum][0];
            }
            else
            {
                cmd.DW2.HevcVp9WeightsBackwardReference0 = cmd.DW1.WeightsForwardReference0;
                cmd.DW2.HevcVp9OffsetBackwardReference0 = cmd.DW1.OffsetForwardReference0;
            }
        }

        if (cmdBuffer == nullptr && batchBuffer == nullptr)
        {
            MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
            return MOS_STATUS_NULL_POINTER;
        }

        MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

   MOS_STATUS AddVdencCmd1Cmd(
        PMOS_COMMAND_BUFFER                  cmdBuffer,
        PMHW_BATCH_BUFFER                    batchBuffer,
        PMHW_VDBOX_VDENC_CMD1_PARAMS  params) override
    {
        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencCmd2Cmd(
        PMOS_COMMAND_BUFFER                 cmdBuffer,
        PMHW_BATCH_BUFFER                   batchBuffer,
        PMHW_VDBOX_VDENC_CMD2_STATE params) override
    {
        return MOS_STATUS_SUCCESS;
    }

    //!
    //! \brief    Adds VDEnc Pipe Control State command in command buffer
    //! \details  Client facing function to add VDEnc Pipe Control State command in command buffer
    //! \param    PMOS_COMMAND_BUFFER  cmdBuffer
    //!           [in] Command buffer to which HW command is added
    //! \param    PMHW_VDBOX_VDENC_CONTROL_STATE_PARAMS params
    //!           [in] Params structure used to populate the HW command
    //! \return   MOS_STATUS
    //!           MOS_STATUS_SUCCESS if success, else fail reason
    //!
    MOS_STATUS AddVdencControlStateCmd(
        PMOS_COMMAND_BUFFER                   cmdBuffer,
        PMHW_VDBOX_VDENC_CONTROL_STATE_PARAMS params)
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename TVdencCmds::VDENC_CONTROL_STATE_CMD    cmd;


        if (params->bVdencInitialization)
        {
            cmd.DW1.VdencInitialization     = 1;
        }
        else
        {
            MHW_ASSERTMESSAGE("Invalid parameter for VDENC_CONTROL_STATE.");
            return MOS_STATUS_INVALID_PARAMETER;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS CreateMhwVdboxPipeModeSelectParams() override
    {
        auto pipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12);

        return pipeModeSelectParams;
    }

    void ReleaseMhwVdboxPipeModeSelectParams(PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams) override
    {
        MOS_Delete(pipeModeSelectParams);
    }
};

//!  MHW Vdbox Vdenc interface for Gen12 X
/*!
This class defines the Vdenc command construction functions for Gen12 common platforms
*/
class MhwVdboxVdencInterfaceG12X : public MhwVdboxVdencInterfaceG12<mhw_vdbox_vdenc_g12_X>
{
public:
        //!
    //! \brief  Constructor
    //!
    MhwVdboxVdencInterfaceG12X(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceG12(osInterface)
    {
        MHW_FUNCTION_ENTER;
    }

    inline uint32_t GetVdencCmd1Size() override
    {
        return mhw_vdbox_vdenc_g12_X::VDENC_CMD1_CMD::byteSize;
    }

    inline uint32_t GetVdencCmd2Size() override
    {
        return mhw_vdbox_vdenc_g12_X::VDENC_CMD2_CMD::byteSize;
    }

    //!
    //! \brief    Destructor
    //!
    virtual ~MhwVdboxVdencInterfaceG12X()
    {
        MHW_FUNCTION_ENTER;
    }

    MOS_STATUS AddVdencCmd1Cmd(
        PMOS_COMMAND_BUFFER                  cmdBuffer,
        PMHW_BATCH_BUFFER                    batchBuffer,
        PMHW_VDBOX_VDENC_CMD1_PARAMS  params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(params);

        typename mhw_vdbox_vdenc_g12_X::VDENC_CMD1_CMD cmd;

        cmd.DW22.Value = 0x10101010;
        cmd.DW23.Value = 0x10101010;
        cmd.DW24.Value = 0x10101010;
        cmd.DW25.Value = 0x10101010;
        cmd.DW26.Value = 0x10101010;
        cmd.DW27.Value = 0x10101010;
        cmd.DW28.Value = 0x10101010;
        cmd.DW29.Value = 0x10101010;
        if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
        {
            MHW_MI_CHK_NULL(params->pHevcEncPicParams);
            auto hevcPicParams = params->pHevcEncPicParams;
            MHW_MI_CHK_NULL(params->pHevcEncSlcParams);
            auto hevcSlcParams = params->pHevcEncSlcParams;

            const uint32_t table1[3] = {0x5030200,0x5030200,0x5030200};
            const uint8_t indexTable1[3] = {0,1,2};
            cmd.DW1.Value = table1[indexTable1[hevcPicParams->CodingType - 1]];
            const uint32_t table2[3] = {0xb090806,0xb090806,0xb090806};
            const uint8_t indexTable2[3] = {0,1,2};
            cmd.DW2.Value = table2[indexTable2[hevcPicParams->CodingType - 1]];

            cmd.DW3.Value = 0x1c140c04;
            cmd.DW4.Value = 0x3c342c24;
            cmd.DW5.Value = 0x5c544c44;
            cmd.DW6.Value = 0x1c140c04;
            cmd.DW7.Value = 0x3c342c24;
            cmd.DW8.Value = 0x5c544c44;
            cmd.DW14.Value = 0x0;
            cmd.DW15.Value = 0x0;
            cmd.DW16.Value &= 0xffff0000;
            cmd.DW19.Value = (cmd.DW19.Value & 0xff0000ff) | 0x140400;
            cmd.DW20.Value = 0x14141414;
            cmd.DW21.Value = 0x14141414;
            if (params->bHevcVisualQualityImprovement)
            {
                auto qpPrimeYac = CodecHal_Clip3(10, 51, hevcPicParams->QpY + hevcSlcParams->slice_qp_delta);
                if (qpPrimeYac >= 22 && qpPrimeYac <= 51)
                {
                    const uint32_t table3[30] = {0x0,0x60000,0xc0000,0x120000,0x190000,0x1f0000,0x250000,0x2c0000,0x320000,0x380000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000,0x3f0000};
                    cmd.DW14.Value = (cmd.DW14.Value & 0xff00ffff) |table3[qpPrimeYac - 22];
                }
            }

            if (params->pHevcEncPicParams->CodingType == I_TYPE)
            {
                cmd.DW10.Value = 0x23131f0f;
                cmd.DW11.Value = (cmd.DW11.Value & 0xffff0000) | 0x2313;
                cmd.DW12.Value = 0x3e5c445c;
                cmd.DW13.Value = (cmd.DW13.Value & 0xff00) | 0x1e040044;
                cmd.DW16.Value = (cmd.DW16.Value & 0xffff) | 0x70000;
                cmd.DW17.Value = 0xd0e1007;
                cmd.DW18.Value = (cmd.DW18.Value & 0xffffff00) | 0x32;
                cmd.DW18.Value = (cmd.DW18.Value & 0xffff00ff) | (hevcPicParams->NumROI ? 0 : 0x1e00);
                cmd.DW30.Value = (cmd.DW30.Value & 0xff000000) | 0x101010;
            }
            else if (params->pHevcEncPicParams->CodingType == B_TYPE)
            {
                cmd.DW10.Value = 0x23131f0f;
                cmd.DW11.Value = 0x331b2313;
                cmd.DW12.Value = 0x476e4d6e;
                cmd.DW13.Value = 0x3604004d;
                cmd.DW16.Value = (cmd.DW16.Value & 0xffff) | 0x4150000;
                cmd.DW17.Value = 0x23231415;
                cmd.DW18.Value = (cmd.DW18.Value & 0xffffff00) | 0x3f;
                cmd.DW18.Value = (cmd.DW18.Value & 0xffff00ff) | (hevcPicParams->NumROI ? 0 : 0x4400);
                cmd.DW30.Value = (cmd.DW30.Value & 0xff000000) | 0x232323;
            }
        }
        else if (params->Mode == CODECHAL_ENCODE_MODE_VP9)
        {
            MHW_MI_CHK_NULL(params->pVp9EncPicParams);

            auto vp9PicParams = params->pVp9EncPicParams;
            auto qp = vp9PicParams->LumaACQIndex;
            auto vp9FrameType = vp9PicParams->PicFlags.fields.frame_type;

            const uint32_t table1[2][256] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
                                            0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
            const uint8_t indexTable1[2] = {0,1};
            cmd.DW1.Value = table1[indexTable1[vp9FrameType]][qp];
            const uint32_t table2[2][256] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
                                            0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
            const uint8_t indexTable2[2] = {0,1};
            cmd.DW2.Value = table2[indexTable2[vp9FrameType]][qp];

            cmd.DW3.Value = 0x1a130b04;
            cmd.DW4.Value = 0x3f312922;
            cmd.DW5.Value = 0x7164584b;
            cmd.DW6.Value = 0x1a130b04;
            cmd.DW7.Value = 0x3f312922;
            cmd.DW8.Value = 0x7164584b;
            cmd.DW20.Value = 0xc0c0c0c;
            cmd.DW21.Value = 0xc0c0c0c;
            cmd.DW22.Value = 0x10101010;
            cmd.DW23.Value = 0x10101010;
            cmd.DW24.Value = 0x10101010;
            cmd.DW25.Value = 0x10101010;
            cmd.DW26.Value = 0x10101010;
            cmd.DW27.Value = 0x10101010;
            cmd.DW28.Value = 0x10101010;
            cmd.DW29.Value = 0x10101010;
            if(vp9FrameType == CODEC_VP9_KEY_FRAME)
            {
                cmd.DW9.Value &= 0xff000000;
                cmd.DW10.Value = 0x0;
                cmd.DW11.Value = 0x0;
                cmd.DW12.Value = 0x0;
                cmd.DW13.Value = 0x32000000;
                cmd.DW14.Value = 0x1f5e0000;
                cmd.DW15.Value = 0x1f5e0000;
                cmd.DW16.Value = (cmd.DW16.Value & 0xff000000) | 0x4b0000;
                cmd.DW17.Value = 0x3219194b;
                cmd.DW18.Value = 0x4b5e0026;
                cmd.DW19.Value = (cmd.DW19.Value & 0xff) | 0x7d7d0000;
            }
            else
            {
                cmd.DW9.Value = (cmd.DW9.Value & 0xff000000) | 0x26191f;
                cmd.DW10.Value = 0x1e0b1e0b;
                cmd.DW11.Value = 0x19001e0b;
                cmd.DW12.Value = 0x19321f4b;
                cmd.DW13.Value = 0x4404001f;
                cmd.DW14.Value = 0x30900000;
                cmd.DW15.Value = 0x30900000;
                cmd.DW16.Value = (cmd.DW16.Value & 0xff000000) | 0x260000;
                cmd.DW17.Value = 0x13194b26;
                cmd.DW18.Value = 0x3f5e0d5e;
                cmd.DW19.Value = (cmd.DW19.Value & 0xff) | 0x4e320f00;
            }
        }

        if (cmdBuffer == nullptr && batchBuffer == nullptr)
        {
            MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
            return MOS_STATUS_NULL_POINTER;
        }

        MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddVdencCmd2Cmd(
        PMOS_COMMAND_BUFFER                 cmdBuffer,
        PMHW_BATCH_BUFFER                   batchBuffer,
        PMHW_VDBOX_VDENC_CMD2_STATE params) override
    {
        MHW_FUNCTION_ENTER;

        MHW_MI_CHK_NULL(params);
        auto extParams = std::static_pointer_cast<MHW_VDBOX_VDENC_CMD2_STATE>(params);
        MHW_MI_CHK_NULL(extParams);

        typename mhw_vdbox_vdenc_g12_X::VDENC_CMD2_CMD cmd;

        cmd.DW2.Value = (cmd.DW2.Value & 0xdff00000) | 0x2005aff3;
        cmd.DW3.Value = 0xfe02ff01;
        cmd.DW4.Value = 0xfc04fd03;
        cmd.DW5.Value = (cmd.DW5.Value & 0xff7e03ff) | 0x80ac00;
        cmd.DW7.Value = (cmd.DW7.Value & 0xffd90ff0) | 0x62003;
        cmd.DW9.Value = (cmd.DW9.Value & 0xffff) | 0x43840000;
        cmd.DW12.Value = 0xffffffff;
        cmd.DW15.Value = 0x4e201f40;
        cmd.DW16.Value = (cmd.DW16.Value & 0xf0ff0000) | 0xf003300;
        cmd.DW17.Value = (cmd.DW17.Value & 0xfff00000) | 0x2710;
        cmd.DW19.Value = (cmd.DW19.Value & 0x80ffffff) | 0x18000000;
        cmd.DW21.Value &= 0xfffffff;
        cmd.DW22.Value = 0x1f001102;
        cmd.DW23.Value = 0xaaaa1f00;
        cmd.DW27.Value = (cmd.DW27.Value & 0xffff0000) | 0x1a1a;
        if (params->pHevcEncPicParams && params->pHevcEncSeqParams)
        {
            MHW_MI_CHK_NULL(params->pHevcEncSeqParams);
            MHW_MI_CHK_NULL(params->pHevcEncPicParams);
            MHW_MI_CHK_NULL(params->pHevcEncSlcParams);
            auto hevcSeqParams = params->pHevcEncSeqParams;
            auto hevcPicParams = params->pHevcEncPicParams;
            auto hevcSlcParams = params->pHevcEncSlcParams;

            bool vdencROIEnabled = params->bROIStreamInEnabled;
            bool vdencStreamInEnabled = params->bStreamInEnabled;

            cmd.DW1.FrameWidthInPixelsMinusOne = ((hevcSeqParams->wFrameWidthInMinCbMinus1 + 1) <<
                (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)) - 1;
            cmd.DW1.FrameHeightInPixelsMinusOne = ((hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) <<
                (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)) - 1;

            cmd.DW2.PictureType = (hevcPicParams->CodingType == I_TYPE) ? 0 : (extParams->bIsLowDelayB ? 3 : 2);
            cmd.DW2.TemporalMvpEnableFlag = (hevcPicParams->CodingType == I_TYPE) ? 0 : params->pHevcEncSeqParams->sps_temporal_mvp_enable_flag;
            cmd.DW2.TransformSkip = hevcPicParams->transform_skip_enabled_flag;

            cmd.DW5.NumRefIdxL0Minus1 = hevcSlcParams->num_ref_idx_l0_active_minus1;
            cmd.DW5.NumRefIdxL1Minus1 = hevcSlcParams->num_ref_idx_l1_active_minus1;

            cmd.DW5.Value = (cmd.DW5.Value & 0xff83ffff) | 0x400000;
            cmd.DW14.Value = (cmd.DW14.Value & 0xffff) | 0x7d00000;
            cmd.DW15.Value = 0x4e201f40;
            cmd.DW17.Value = (cmd.DW17.Value & 0xfff00000) | 0x2710;
            cmd.DW18.Value = (cmd.DW18.Value & 0xffff) | 0x600000;
            cmd.DW19.Value = (cmd.DW19.Value & 0xffff0000) | 0xc0;
            cmd.DW20.Value &= 0xfffeffff;
            cmd.DW7.TilingEnable = hevcPicParams->tiles_enabled_flag;
            cmd.DW37.TileReplayEnable = extParams->bTileReplayEnable;

            if (hevcPicParams->CodingType != I_TYPE)
            {
                uint8_t   refFrameId;
                int8_t    diffPoc;

                refFrameId = hevcSlcParams->RefPicList[0][0].FrameIdx;
                diffPoc = ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0x0 : hevcPicParams->RefFramePOCList[refFrameId]) - hevcPicParams->CurrPicOrderCnt;
                cmd.DW3.PocNumberForRefid0InL0    = CodecHal_Clip3(-16, 16, -diffPoc);
                cmd.DW2.LongTermReferenceFlagsL0  = (refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0 : CodecHal_PictureIsLongTermRef(hevcPicParams->RefFrameList[refFrameId]);
                refFrameId = hevcSlcParams->RefPicList[0][1].FrameIdx;
                diffPoc = ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0x0 : hevcPicParams->RefFramePOCList[refFrameId]) - hevcPicParams->CurrPicOrderCnt;
                cmd.DW3.PocNumberForRefid1InL0    = CodecHal_Clip3(-16, 16, -diffPoc);
                cmd.DW2.LongTermReferenceFlagsL0 |= ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0 : CodecHal_PictureIsLongTermRef(hevcPicParams->RefFrameList[refFrameId])) << 1;
                refFrameId = hevcSlcParams->RefPicList[0][2].FrameIdx;
                diffPoc                        = ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0x0 : hevcPicParams->RefFramePOCList[refFrameId]) - hevcPicParams->CurrPicOrderCnt;
                cmd.DW4.PocNumberForRefid2InL0 = CodecHal_Clip3(-16, 16, -diffPoc);
                cmd.DW2.LongTermReferenceFlagsL0 |= ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0 : CodecHal_PictureIsLongTermRef(hevcPicParams->RefFrameList[refFrameId])) << 2;

                refFrameId = hevcSlcParams->RefPicList[1][0].FrameIdx;
                diffPoc                          = ((refFrameId >= CODEC_MAX_NUM_REF_FRAME_HEVC) ? 0x0 : hevcPicParams->RefFramePOCList[refFrameId]) - hevcPicParams->CurrPicOrderCnt;
                cmd.DW3.PocNumberForRefid0InL1   = CodecHal_Clip3(-16, 16, -diffPoc);
                cmd.DW2.LongTermReferenceFlagsL1 = CodecHal_PictureIsLongTermRef(hevcPicParams->RefFrameList[refFrameId]);

                cmd.DW3.PocNumberForRefid1InL1 = cmd.DW3.PocNumberForRefid1InL0;
                cmd.DW4.PocNumberForRefid2InL1 = cmd.DW4.PocNumberForRefid2InL0;
                cmd.DW5.SubPelMode = (params->bEnableSubPelMode) ? params->SubPelMode : 3;
            }
            else
            {
                cmd.DW3.Value = cmd.DW4.Value = 0;
            }

            switch (hevcSeqParams->TargetUsage)
            {
            case 1:                                 // Quality mode
                cmd.DW2.Value &= 0xdfffffff;
                cmd.DW2.Value = (cmd.DW2.Value & 0xfffffffc) | (hevcPicParams->CodingType == I_TYPE ? 2 : 3);
                cmd.DW7.Value &= 0xfffffeff;
                cmd.DW7.Value = (cmd.DW7.Value & 0xfffff7ff) | (hevcPicParams->CodingType == I_TYPE ? 0x800 : 0);
                cmd.DW9.Value = (cmd.DW9.Value & 0xfffff) | 0x43800000;
                cmd.DW12.Value = 0xffffffff;
                cmd.DW34.Value = (cmd.DW34.Value & 0xffffff) | 0x21000000;
                break;
            case 4:                                 // Normal mode
                cmd.DW2.Value &= 0xdfffffff;
                cmd.DW7.Value &= 0xfffffeff;
                cmd.DW9.Value = (cmd.DW9.Value & 0xfffff) | 0x43800000;
                cmd.DW12.Value = 0xce4014a0;
                cmd.DW34.Value = (cmd.DW34.Value & 0xffffff) | 0x21000000;
                break;
            case 7:                                 // Speed mode
                cmd.DW2.Value = (cmd.DW2.Value & 0xdfffffff) | 0x20000000;
                cmd.DW7.Value = (cmd.DW7.Value & 0xfff7feff) | 0x80100;
                cmd.DW9.Value = (cmd.DW9.Value & 0xffff) | 0x22420000;
                cmd.DW12.Value = 0x89800dc0;
                cmd.DW34.Value = (cmd.DW34.Value & 0xffffff) | 0x20000000;
                break;
            default:
                MHW_ASSERTMESSAGE("Invalid TU provided!");
                return MOS_STATUS_INVALID_PARAMETER;
            }

            if (hevcSlcParams->num_ref_idx_l0_active_minus1 == 0)
            {
                cmd.DW7.Value = (cmd.DW7.Value & 0xfff7ffff) | 0x80000;
            }

            if (!extParams->bIsLowDelayB)
            {
                cmd.DW7.Value &= 0xfff7feff;
            }

            cmd.DW7.VdencStreamInEnable = vdencStreamInEnabled;
            cmd.DW7.PakOnlyMultiPassEnable = params->bPakOnlyMultipassEnable;

            if (extParams->bIsLowDelayB)
            {
                cmd.DW8.Value = 0;
                cmd.DW9.Value &= 0xffff0000;
            }
            else
            {
                cmd.DW8.Value = 0x54555555;
                cmd.DW9.Value = (cmd.DW9.Value & 0xffff0000) | 0x5555;
            }

            cmd.DW16.MinQp = hevcPicParams->BRCMinQp < 0x0a ? 10 : hevcPicParams->BRCMinQp;
            cmd.DW16.MaxQp = hevcPicParams->BRCMaxQp < 0x0a ? 51 : (hevcPicParams->BRCMaxQp > 0x33 ? 0x33 : hevcPicParams->BRCMaxQp);
            cmd.DW17.TemporalMVEnableForIntegerSearch = cmd.DW2.TemporalMvpEnableFlag & extParams->bIsLowDelayB;

            if (vdencROIEnabled)
            {
                int8_t priorityLevelOrDQp[ENCODE_VDENC_HEVC_MAX_STREAMINROI_G10] = { 0 };

                cmd.DW5.StreaminRoiEnable = vdencROIEnabled;

                for (uint8_t i = 0; i < ENCODE_VDENC_HEVC_MAX_STREAMINROI_G10; i++)
                {
                    priorityLevelOrDQp[i] = (int8_t)CodecHal_Clip3(
                        ENCODE_VDENC_HEVC_MIN_ROI_DELTA_QP_G10, ENCODE_VDENC_HEVC_MAX_ROI_DELTA_QP_G10, hevcPicParams->ROIDistinctDeltaQp[i]);
                }

                cmd.DW13.RoiQpAdjustmentForZone1Stage3 = priorityLevelOrDQp[0];
                cmd.DW13.RoiQpAdjustmentForZone2Stage3 = priorityLevelOrDQp[1];
                cmd.DW13.RoiQpAdjustmentForZone3Stage3 = priorityLevelOrDQp[2];
            }

            if ((hevcPicParams->bEnableRollingIntraRefresh) && (hevcPicParams->CodingType != I_TYPE))
            {
                uint32_t rollingILimit = (hevcPicParams->bEnableRollingIntraRefresh == ROLLING_I_ROW) ?
                    MOS_ROUNDUP_DIVIDE(cmd.DW1.FrameHeightInPixelsMinusOne + 1, 32) :
                    MOS_ROUNDUP_DIVIDE(cmd.DW1.FrameWidthInPixelsMinusOne + 1, 32);

                cmd.DW7.Value = (cmd.DW7.Value & 0xfffffbff) | 0x400;
                cmd.DW7.Value = (cmd.DW7.Value & 0xfffffbff) | ((hevcSeqParams->TargetUsage == 1) ? 0x400 : 0);
                cmd.DW21.Value = (cmd.DW21.Value & 0xfdffffff) | 0x2000000;
                cmd.DW21.QpAdjustmentForRollingI = MOS_CLAMP_MIN_MAX(hevcPicParams->QpDeltaForInsertedIntra, -8, 7);
                cmd.DW21.IntraRefreshMode = (hevcPicParams->bEnableRollingIntraRefresh == ROLLING_I_ROW) ? 0 : 1;
                cmd.DW21.IntraRefreshMBSizeMinusOne = hevcPicParams->IntraInsertionSize - 1;
                cmd.DW21.IntraRefreshPos = hevcPicParams->IntraInsertionLocation;
                cmd.DW36.IntraRefreshBoundaryRef0 = CodecHal_Clip3(0, rollingILimit, hevcPicParams->RollingIntraReferenceLocation[0] - 1);
                cmd.DW36.IntraRefreshBoundaryRef1 = CodecHal_Clip3(0, rollingILimit, hevcPicParams->RollingIntraReferenceLocation[1] - 1);
                cmd.DW36.IntraRefreshBoundaryRef2 = CodecHal_Clip3(0, rollingILimit, hevcPicParams->RollingIntraReferenceLocation[2] - 1);
            }

            const uint32_t table1[3][42] = {0x30002,0x30002,0x30002,0x30003,0x40004,0x40005,0x50006,0x60008,0x6000a,0x7000c,0x8000f,0x90013,0xa0018,0xb001e,0xc0026,0xe0030,0x10003d,0x12004d,0x140061,0x16007a,0x19009a,0x1c00c2,0x1f00f4,0x230133,0x270183,0x2c01e8,0x320266,0x380306,0x3e03cf,0x4604cd,0x4f060c,0x58079f,0x63099a,0x6f0c18,0x7d0f3d,0x8c1333,0x9d1831,0xb11e7a,0xc62666,0xdf3062,0xfa3cf5,0x1184ccd,
                                           0x30003,0x30003,0x30003,0x40003,0x40004,0x50005,0x50007,0x60008,0x6000a,0x7000d,0x80011,0x90015,0xa001a,0xb0021,0xd002a,0xe0034,0x100042,0x120053,0x140069,0x170084,0x1a00a6,0x1d00d2,0x210108,0x24014d,0x2901a3,0x2e0210,0x34029a,0x3a0347,0x410421,0x490533,0x52068d,0x5c0841,0x670a66,0x740d1a,0x821082,0x9214cd,0xa41a35,0xb82105,0xce299a,0xe8346a,0x1044209,0x1245333,
                                           0x30003,0x30003,0x30003,0x40003,0x40004,0x50005,0x50007,0x60008,0x6000a,0x7000d,0x80011,0x90015,0xa001a,0xb0021,0xd002a,0xe0034,0x100042,0x120053,0x140069,0x170084,0x1a00a6,0x1d00d2,0x210108,0x24014d,0x2901a3,0x2e0210,0x34029a,0x3a0347,0x410421,0x490533,0x52068d,0x5c0841,0x670a66,0x740d1a,0x821082,0x9214cd,0xa41a35,0xb82105,0xce299a,0xe8346a,0x1044209,0x1245333};
            const uint8_t indexTable1[3] = {0,1,2};
            cmd.DW26.Value = (cmd.DW26.Value & 0xfe000000) | table1[indexTable1[hevcPicParams->CodingType - 1]][hevcPicParams->QpY + hevcSlcParams->slice_qp_delta - 10];

            if (params->bHevcVisualQualityImprovement)
            {
                auto qpPrimeYac = CodecHal_Clip3(10, 51, hevcPicParams->QpY + hevcSlcParams->slice_qp_delta);
                if (qpPrimeYac >= 22 && qpPrimeYac <= 51 && hevcSlcParams->slice_type == SLICE_I)
                {
                    const uint32_t table2[3][30] = {0xa,0xb,0xd,0xf,0x11,0x14,0x17,0x1a,0x1e,0x22,0x27,0x2d,0x33,0x3b,0x43,0x4d,0x57,0x64,0x72,0x82,0x95,0xa7,0xbb,0xd2,0xec,0x109,0x129,0x14e,0x177,0x1a5,
                                                    0xa,0xc,0xe,0x10,0x12,0x15,0x18,0x1b,0x1f,0x23,0x29,0x2f,0x35,0x3d,0x46,0x50,0x5b,0x68,0x77,0x88,0x9b,0xae,0xc3,0xdb,0xf6,0x114,0x136,0x15c,0x186,0x1b6,
                                                    0xa,0xc,0xe,0x10,0x12,0x15,0x18,0x1b,0x1f,0x23,0x29,0x2f,0x35,0x3d,0x46,0x50,0x5b,0x68,0x77,0x88,0x9b,0xae,0xc3,0xdb,0xf6,0x114,0x136,0x15c,0x186,0x1b6};
                    const uint8_t indexTable2[3] = {0,1,2};
                    cmd.DW26.SadQpLambda  = table2[indexTable2[hevcPicParams->CodingType - 1]][qpPrimeYac - 22];
                }

                if (hevcPicParams->QpY >= 22 && hevcPicParams->QpY <= 51)
                {
                    cmd.DW6.Value = (cmd.DW6.Value & 0xc00fffff) | 0x1fb00000;
                }
            }
            cmd.DW27.QpPrimeYAc = hevcPicParams->QpY + hevcSlcParams->slice_qp_delta;
            cmd.DW27.Value &= 0xffffff00;
            cmd.DW35.Value = (cmd.DW35.Value & 0xfffff0ff) | 0x700;

            if (params->bUseDefaultQpDeltas)
            {
                cmd.DW13.Value = (cmd.DW13.Value & 0xffff) | 0xf0120000;
                if (hevcPicParams->CodingType == I_TYPE)
                {
                    cmd.DW14.Value = (cmd.DW14.Value & 0xffff0000) | 0x21db;
                    cmd.DW16.Value = (cmd.DW16.Value & 0xf00ffff) | 0x10000;
                    cmd.DW18.Value = 0x600000;
                    cmd.DW19.Value = (cmd.DW19.Value & 0xffff0000) | 0xc0;
                }
                else // LDB frames
                {
                    cmd.DW14.Value = (cmd.DW14.Value & 0xffff0000) | 0x21ed;
                    cmd.DW16.Value = (cmd.DW16.Value & 0xf00ffff) | 0xd0010000;
                    cmd.DW18.Value = 0x60010f;
                    cmd.DW19.Value = (cmd.DW19.Value & 0xffff0000) | 0xc0;
                }
            }

            if (params->bRoundingEnabled)
            {
                cmd.DW28.Value = 0x7d00fa0;
                cmd.DW29.Value = 0x2bc0bb8;
                cmd.DW30.Value = 0x32003e8;
                cmd.DW31.Value = 0x1f4012c;
                cmd.DW32.Value = (cmd.DW32.Value & 0xffff0000) | 0x190;

                const uint32_t table3[3][3] = {0x88220000,0x99220000,0xaa220000,
                                              0x88330000,0x99330000,0xaa330000,
                                              0x88440000,0x99440000,0xaa440000};
                cmd.DW32.Value = (cmd.DW32.Value & 0xffff) | table3[params->roundInterValue - 2][params->roundIntraValue - 8];

                const uint32_t table4[3][3] = {0x22882222,0x22992222,0x22aa2222,
                                              0x33883333,0x33993333,0x33aa3333,
                                              0x44884444,0x44994444,0x44aa4444};
                cmd.DW33.Value = table4[params->roundInterValue - 2][params->roundIntraValue - 8];

                const uint32_t table5[3][3] = {0x228822,0x229922,0x22aa22,
                                              0x338833,0x339933,0x33aa33,
                                              0x448844,0x449944,0x44aa44};
                cmd.DW34.Value = (cmd.DW34.Value & 0xff000000) | table5[params->roundInterValue - 2][params->roundIntraValue - 8];
            }

            if (hevcPicParams->pps_curr_pic_ref_enabled_flag)
            {
                cmd.DW5.NumRefIdxL0Minus1++;
                cmd.DW35.Value &= 0xffff1fff;
                cmd.DW37.Value = (cmd.DW37.Value & 0xffffff9f) | 0x40;

                if (hevcPicParams->CodingType == I_TYPE)
                {
                    cmd.DW2.Value = (cmd.DW2.Value & 0xf8fffffc) | 0x1000002;
                    cmd.DW3.Value &= 0xffffff00;
                    cmd.DW5.Value &= 0xf0ffffff;
                }
                else
                {
                    switch (cmd.DW5.NumRefIdxL0Minus1)
                    {
                    case 0:
                        cmd.DW2.Value |= 0x1000000;
                        cmd.DW3.Value &= 0xffffff00;
                        break;
                    case 1:
                        cmd.DW2.Value |= 0x2000000;
                        cmd.DW3.Value &= 0xff00ffff;
                        break;
                    case 2:
                        cmd.DW2.Value |= 0x4000000;
                        cmd.DW4.Value &= 0xffffff00;
                        break;
                    case 3:
                        cmd.DW2.Value |= 0x0;
                        cmd.DW4.Value &= 0xff00ffff;
                        break;
                    default:
                        MHW_ASSERTMESSAGE("Invalid NumRefIdxL0");
                        return MOS_STATUS_INVALID_PARAMETER;
                    }
                }
            }
            if (hevcSeqParams->palette_mode_enabled_flag)
            {
                cmd.DW37.Value &= 0xffe0ffe0;
                cmd.DW38.Value &= 0xffffffbf;
                uint32_t index = hevcSeqParams->bit_depth_luma_minus8 == 0 ? 0 : 1;
                const uint32_t table1[2] = {0x8000fc,0x20003f0};
                cmd.DW39.Value = table1[index];

                const uint32_t table2[2] = {0xb10080,0x2c40200};
                cmd.DW40.Value = table2[index];

                const uint32_t table3[2] = {0x300aa,0xc02a8};
                cmd.DW41.Value = table3[index];

                const uint32_t table4[2] = {0xd30069,0x34c01a4};
                cmd.DW42.Value = table4[index];
                const uint32_t table5[2] = {0xe000e9,0x38003a4};
                cmd.DW43.Value = table5[index];

                const uint32_t table6[2] = {0x940003,0x250000c};
                cmd.DW44.Value = table6[index];

                const uint32_t table7[2] = {0x56004d,0x1580134};
                cmd.DW45.Value = table7[index];
                const uint32_t table8[2] = {0x9500fd,0x25403f4};
                cmd.DW46.Value = table8[index];

                const uint32_t table9[2] = {0x17002d,0x5c00b4};
                cmd.DW47.Value = table9[index];

                const uint32_t table10[2] = {0xfd001f,0x3f4007c};
                cmd.DW48.Value = table10[index];
                const uint32_t table11[2] = {0x2006c,0x801b0};
                cmd.DW49.Value = table11[index];

                const uint32_t table12[2] = {0x800080,0x2000200};
                cmd.DW50.Value = table12[index];
            }

            MHW_MI_CHK_NULL(extParams->pRefIdxMapping);
            for (int i = 0; i < params->ucNumRefIdxL0ActiveMinus1 + 1; i++)
            {
                uint8_t refFrameIDx = hevcSlcParams->RefPicList[0][i].FrameIdx;
                if (refFrameIDx < CODEC_MAX_NUM_REF_FRAME_HEVC)
                {
                    *((uint8_t *)&cmd.DW11.Value + i) = *(extParams->pRefIdxMapping + refFrameIDx);
                }
            }
            for (int i = params->ucNumRefIdxL0ActiveMinus1 + 1; i < 3; i++)
            {
                *((uint8_t *)&cmd.DW11.Value + i) = 0x7;
            }
            if (hevcPicParams->pps_curr_pic_ref_enabled_flag)
            {
                *((uint8_t *)&cmd.DW11.Value + params->ucNumRefIdxL0ActiveMinus1 + 1) = extParams->recNotFilteredID;
            }
            if (!extParams->bIsLowDelayB)
            {
                 uint8_t refFrameIDx = hevcSlcParams->RefPicList[1][0].FrameIdx;
                 if (refFrameIDx < CODEC_MAX_NUM_REF_FRAME_HEVC)
                 {
                     const uint8_t bwdOffset = 3;
                     *((uint8_t *)&cmd.DW11.Value + bwdOffset) = *(extParams->pRefIdxMapping + refFrameIDx);
                 }
            }
            cmd.DW11.Value = (cmd.DW11.Value & 0x7fffffff) | 0x80000000;
        }
        else if (params->pVp9EncPicParams)
        {
            MHW_MI_CHK_NULL(params->pVp9EncPicParams);
            auto vp9PicParams = params->pVp9EncPicParams;
            MHW_MI_CHK_NULL(params->pVp9EncSeqParams);
            auto vp9SeqParams = params->pVp9EncSeqParams;

            cmd.DW1.FrameWidthInPixelsMinusOne = MOS_ALIGN_CEIL(vp9PicParams->SrcFrameWidthMinus1 + 1, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
            cmd.DW1.FrameHeightInPixelsMinusOne = MOS_ALIGN_CEIL(vp9PicParams->SrcFrameHeightMinus1 + 1, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;

            cmd.DW2.Value = (cmd.DW2.Value & 0x8ff00000) | 0x5aff3;
            cmd.DW5.Value = (cmd.DW5.Value & 0xf000300) | 0x80ac00;
            cmd.DW6.Value = 0x20080200;
            cmd.DW7.Value = (cmd.DW7.Value & 0x190fd0) | 0x62003;
            cmd.DW9.Value = (cmd.DW9.Value & 0xfff0ffff) | 0x40000;
            cmd.DW14.Value = (cmd.DW14.Value & 0xffff) | 0x1f40000;
            cmd.DW15.Value = 0x138807d0;
            cmd.DW16.Value = (cmd.DW16.Value & 0xff0000) | 0xf00ff00;
            cmd.DW17.Value = (cmd.DW17.Value & 0xfff00000) | 0x2710;
            cmd.DW18.Value = 0x80000;
            cmd.DW19.Value = (cmd.DW19.Value & 0xffff0000) | 0x40;
            cmd.DW22.Value = 0x1f001f00;
            cmd.DW23.Value = 0x6a1a1f00;
            cmd.DW28.Value = 0x7d00fa0;
            cmd.DW29.Value = 0x2bc0bb8;
            cmd.DW30.Value = 0x32003e8;
            cmd.DW31.Value = 0x1f4012c;
            cmd.DW32.Value = 0x55220190;
            cmd.DW33.Value = 0x22552222;
            cmd.DW34.Value = 0x21225522;
            cmd.DW2.PictureType = vp9PicParams->PicFlags.fields.frame_type;
            cmd.DW2.TemporalMvpEnableFlag = params->temporalMVpEnable;

            if (vp9PicParams->PicFlags.fields.frame_type) // P_FRAME
            {
                cmd.DW5.NumRefIdxL0Minus1 = params->ucNumRefIdxL0ActiveMinus1;
                cmd.DW7.Value = (cmd.DW7.Value & 0xfff7ffff) | 0x80000;
            }
            else // I_FRAME
            {
                cmd.DW5.Value &= 0xf0ffffff;
                cmd.DW7.Value &= 0xfff7ffff;
            }

            cmd.DW7.SegmentationEnable = (vp9PicParams->PicFlags.fields.frame_type == 0) ? 0 : vp9PicParams->PicFlags.fields.segmentation_enabled;
            cmd.DW7.TilingEnable = (vp9PicParams->log2_tile_columns != 0) || (vp9PicParams->log2_tile_rows != 0);
            cmd.DW7.PakOnlyMultiPassEnable = params->bPakOnlyMultipassEnable;
            cmd.DW7.VdencStreamInEnable = params->bStreamInEnabled;

            if (params->bSegmentationEnabled)
            {
                cmd.DW7.SegmentationEnable = true;
                cmd.DW7.SegmentationMapTemporalPredictionEnable = vp9PicParams->PicFlags.fields.frame_type ? (params->bPrevFrameSegEnabled ? 1 : 0) : 0;
                cmd.DW7.VdencStreamInEnable = params->bStreamInEnabled;

                MHW_MI_CHK_NULL(params->pVp9SegmentState);
                MHW_MI_CHK_NULL(params->pVp9SegmentState->pVp9EncodeSegmentParams);

                cmd.DW24.QpForSeg0 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[0].SegmentQIndexDelta;
                cmd.DW24.QpForSeg1 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[1].SegmentQIndexDelta;
                cmd.DW24.QpForSeg2 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[2].SegmentQIndexDelta;
                cmd.DW24.QpForSeg3 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[3].SegmentQIndexDelta;

                cmd.DW25.QpForSeg4 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[4].SegmentQIndexDelta;
                cmd.DW25.QpForSeg5 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[5].SegmentQIndexDelta;
                cmd.DW25.QpForSeg6 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[6].SegmentQIndexDelta;
                cmd.DW25.QpForSeg7 = vp9PicParams->LumaACQIndex + params->pVp9SegmentState->pVp9EncodeSegmentParams->SegData[7].SegmentQIndexDelta;
            }
            else
            {
                cmd.DW24.QpForSeg0 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW24.QpForSeg1 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW24.QpForSeg2 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW24.QpForSeg3 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;

                cmd.DW25.QpForSeg4 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW25.QpForSeg5 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW25.QpForSeg6 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
                cmd.DW25.QpForSeg7 = vp9PicParams->LumaACQIndex + vp9PicParams->LumaDCQIndexDelta;
            }

            cmd.DW26.SadQpLambda = params->usSADQPLambda;
            cmd.DW26.RdQpLambda = params->usRDQPLambda;
            cmd.DW26.Vp9DynamicSliceEnable = params->bDynamicScalingEnabled;

            cmd.DW27.QpPrimeYAc = vp9PicParams->LumaACQIndex;
            cmd.DW27.QpPrimeYDc = cmd.DW27.QpPrimeYAc + vp9PicParams->LumaDCQIndexDelta;

            switch (vp9SeqParams->TargetUsage)
            {
            case 1:     // Quality mode
            case 4:     // Normal mode
                cmd.DW2.Value &= 0xdfffffff;
                cmd.DW7.Value &= 0xfff7feff;
                cmd.DW9.Value = (cmd.DW9.Value & 0xfffff) | 0x43800000;
                cmd.DW34.Value = (cmd.DW34.Value & 0xffffff) | 0x21000000;
                break;
            case 7:     // Speed mode
                cmd.DW2.Value = (cmd.DW2.Value & 0xdfffffff) | 0x20000000;
                cmd.DW7.Value = (cmd.DW7.Value & 0xfff7feff) | 0x80100;
                cmd.DW9.Value = (cmd.DW9.Value & 0xffff) | 0x22420000;
                cmd.DW34.Value = (cmd.DW34.Value & 0xffffff) | 0x20000000;
                break;
            default:
                MHW_ASSERTMESSAGE("Invalid TU provided!");
                return MOS_STATUS_INVALID_PARAMETER;
            }

            if (params->ucNumRefIdxL0ActiveMinus1 == 0)
            {
                cmd.DW7.Value = (cmd.DW7.Value & 0xfff7ffff) | 0x80000;
            }
        }

        if (cmdBuffer == nullptr && batchBuffer == nullptr)
        {
            MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
            return MOS_STATUS_NULL_POINTER;
        }

        MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));

        return MOS_STATUS_SUCCESS;
    }
};

struct MHW_VDBOX_VDENC_HEVC_VP9_TILE_SLICE_STATE_PARAMS
{
    uint32_t ctbSize          = 0;
    uint32_t widthInPix       = 0;
    uint32_t heightInPix      = 0;
    uint32_t minCodingBlkSize = 0;

    PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 pTileCodingParams     = nullptr;
    uint32_t                              dwNumberOfPipes       = 0;
    uint32_t                              dwTileId              = 0;
    uint32_t                              IBCControl            = 0;
    uint32_t                              PaletteModeEnable     = 0;
    uint32_t                              sliceQP               = 0;
    uint32_t                              bit_depth_luma_minus8 = 0;
    uint32_t                              RowStaticInfo_31_0    = 0;
    uint32_t                              RowStaticInfo_63_32   = 0;
    uint32_t                              RowStaticInfo_95_64   = 0;
    uint32_t                              RowStaticInfo_127_96  = 0;
    uint32_t                              Log2WeightDenomLuma   = 0;
    uint32_t                              Log2WeightDenomChroma = 0;
    uint8_t                               TargetUsage           = 0;
    virtual ~MHW_VDBOX_VDENC_HEVC_VP9_TILE_SLICE_STATE_PARAMS() {}
};
using PMHW_VDBOX_VDENC_HEVC_VP9_TILE_SLICE_STATE_PARAMS = MHW_VDBOX_VDENC_HEVC_VP9_TILE_SLICE_STATE_PARAMS *;

#endif // __MHW_VDBOX_VDENC_G12_X_H__
