/*
* Copyright (c) 2014-2022, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file      mhw_utilities.c
//! \brief         This modules implements utilities which are shared by both the HW interface     and the state heap interface.
//!

#include <math.h>
#include <set>
#include "mhw_utilities_next.h"
#include "mhw_state_heap.h"
#include "mos_interface.h"
#include "hal_oca_interface_next.h"
#include "media_skuwa_specific.h"
#include "mhw_itf.h"
#include "mhw_mi.h"
#include "mhw_mi_cmdpar.h"
#include "mhw_mi_itf.h"

#define MHW_NS_PER_TICK_RENDER_ENGINE 80  // 80 nano seconds per tick in render engine

static const std::set<MOS_HW_COMMAND> s_OCAResourceInfoType = {
    MOS_MI_BATCH_BUFFER_START,
    MOS_VEBOX_STATE,
    MOS_VEBOX_DI_IECP,
    MOS_VEBOX_TILING_CONVERT,
    MOS_SFC_STATE,
    MOS_STATE_BASE_ADDR,
    MOS_SURFACE_STATE,
    MOS_SURFACE_STATE_ADV,
    MOS_MFX_PIPE_BUF_ADDR,
    MOS_MFX_INDIRECT_OBJ_BASE_ADDR,
    MOS_MFX_BSP_BUF_BASE_ADDR,
    MOS_MFX_AVC_DIRECT_MODE,
    MOS_MFX_VP8_PIC,
    MOS_HUC_IND_OBJ_BASE_ADDR,
    MOS_HUC_DMEM,
    MOS_HUC_VIRTUAL_ADDR,
    MOS_VDENC_PIPE_BUF_ADDR,
    MOS_BINDLESS_STATELESS_SURFACE,
};

//!
//! \brief    Set mocs index
//! \details  Set mocs index
//!           command buffer or indirect state
//! \param    PMOS_INTERFACE osInterface
//!           [in] OS interface
//! \param    PMOS_RESOURCE resource
//!           [in] resource
//! \param    MHW_MOCS_PARAMS &mocsParams
//!           [in] mocsParams
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_SetMocsTableIndex(
    PMOS_INTERFACE       osInterface,
    PMOS_RESOURCE        resource,
    MHW_MOCS_PARAMS      &mocsParams)
{
    MHW_CHK_NULL_RETURN(resource);
    MHW_CHK_NULL_RETURN(osInterface);

    // Index is defined in bit 1:6
    const uint8_t indexBitFieldLow      = 1;
    const uint8_t indexMask             = 0x3F;
    uint32_t      memObjCtrlStateValue  = 0;

    uint32_t    *data                   = mocsParams.mocsTableIndex;
    uint32_t    value                   = 0;
    uint32_t    mask                    = 0;
    uint8_t     bitFieldLow             = mocsParams.bitFieldLow;
    uint8_t     bitFieldHigh            = mocsParams.bitFieldHigh;

    if (data == nullptr)
    {
        MHW_NORMALMESSAGE("skip to set the mocs");
        return MOS_STATUS_SUCCESS;
    }

    if (bitFieldLow > bitFieldHigh || bitFieldHigh > 31)
    {
        MOS_OS_ASSERTMESSAGE("invalid bit field");
        return MOS_STATUS_INVALID_PARAMETER;
    }

    value = *data;

    auto memObjCtrlState = osInterface->pfnGetResourceCachePolicyMemoryObject(osInterface, resource);
    memObjCtrlStateValue = (memObjCtrlState.DwordValue >> indexBitFieldLow) & indexMask;

    if (bitFieldHigh == 31)
    {
        mask = (1 << bitFieldLow) - 1;
    }
    else
    {
        mask = (~((1 << (bitFieldHigh + 1)) - 1)) | ((1 << bitFieldLow) - 1);
    }
    value = value & mask;
    *data = value | (memObjCtrlStateValue << bitFieldLow);

    return MOS_STATUS_SUCCESS;
}

//!
//! \brief    Adds graphics address of a resource to the command buffer or indirect state
//! \details  Internal MHW function to add the graphics address of resources to the
//!           command buffer or indirect state
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] OS interface
//! \param    PMOS_COMMAND_BUFFER pCmdBuffer
//!           [in] Command buffer
//! \param    PMHW_RESOURCE_PARAMS pParams
//!           [in] Parameters necessary to insert the graphics address
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_AddResourceToCmd_GfxAddress(
    PMOS_INTERFACE              pOsInterface,
    PMOS_COMMAND_BUFFER         pCmdBuffer,
    PMHW_RESOURCE_PARAMS        pParams)
{
    uint32_t                dwAlign, dwMask;
    uint32_t                dwGfxAddrBottom, dwGfxAddrTop = 0;
    uint64_t                ui64GfxAddress, ui64GfxAddressUpperBound;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;
    int32_t                 iAllocationIndex = 0;
    uint32_t                uiPatchOffset = 0;
    uint8_t                 *pbCmdBufBase = nullptr;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pParams);
    MHW_CHK_NULL_RETURN(pParams->presResource);
    MHW_CHK_NULL_RETURN(pCmdBuffer);
    MHW_CHK_NULL_RETURN(pCmdBuffer->pCmdBase);

    pbCmdBufBase = (uint8_t*)pCmdBuffer->pCmdBase;

    MHW_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
        pOsInterface,
        pParams->presResource,
        pParams->bIsWritable ? true : false,
        pParams->bIsWritable ? true : false));

    dwAlign = ( 1 << pParams->dwLsbNum);
    dwMask  = (-1 << pParams->dwLsbNum);

    pParams->dwOffset = MOS_ALIGN_CEIL(pParams->dwOffset, dwAlign);
    ui64GfxAddress =
        pOsInterface->pfnGetResourceGfxAddress(pOsInterface, pParams->presResource) + pParams->dwOffset;
    MHW_CHK_COND(ui64GfxAddress == 0, "Driver can't add resource with ui64GfxAddress == 0. DW location in cmd == %d.", pParams->dwLocationInCmd);

    dwGfxAddrBottom = (uint32_t)(ui64GfxAddress & 0x00000000FFFFFFFF);
    dwGfxAddrTop = (uint32_t)((ui64GfxAddress & 0xFFFFFFFF00000000) >> 32);

    *pParams->pdwCmd = (*pParams->pdwCmd & ~dwMask) | (dwGfxAddrBottom & dwMask);
    // this is next DW for top part of the address
    *(pParams->pdwCmd + 1) = dwGfxAddrTop;

    Mhw_SetMocsTableIndex(pOsInterface, pParams->presResource, pParams->mocsParams);

#if (_DEBUG || _RELEASE_INTERNAL)
    {
        uint32_t evtData[4] ={(uint32_t)pParams->HwCommandType, pParams->dwLocationInCmd, pParams->dwOffset, pParams->dwSize};
        MOS_TraceEventExt(EVENT_RESOURCE_REGISTER, EVENT_TYPE_INFO2, evtData, sizeof(evtData), &ui64GfxAddress, sizeof(ui64GfxAddress));
    }
#endif

    if (pParams->dwOffsetInSSH > 0)
    {
        // Calculate the patch offset to command buffer
        uiPatchOffset = pParams->dwOffsetInSSH + (pParams->dwLocationInCmd * sizeof(uint32_t));
    }
    else
    {
        // Calculate the patch offset to command buffer
        uiPatchOffset = pCmdBuffer->iOffset + (pParams->dwLocationInCmd * sizeof(uint32_t));
    }

    MOS_PATCH_ENTRY_PARAMS PatchEntryParams;

    iAllocationIndex = pOsInterface->pfnGetResourceAllocationIndex(pOsInterface, pParams->presResource);
    MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
    PatchEntryParams.uiAllocationIndex = iAllocationIndex;
    PatchEntryParams.uiResourceOffset = pParams->dwOffset;
    PatchEntryParams.uiPatchOffset    = uiPatchOffset;
    PatchEntryParams.bWrite           = pParams->bIsWritable;
    PatchEntryParams.HwCommandType    = pParams->HwCommandType;
    PatchEntryParams.forceDwordOffset = pParams->dwSharedMocsOffset;
    PatchEntryParams.cmdBufBase       = pbCmdBufBase;
    PatchEntryParams.presResource     = pParams->presResource;
    PatchEntryParams.cmdBuffer        = pCmdBuffer;

    // Add patch entry
    MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
        pOsInterface,
        &PatchEntryParams));

    if (pParams->dwUpperBoundLocationOffsetFromCmd > 0)
    {
        pParams->dwSize = MOS_ALIGN_CEIL(pParams->dwSize, dwAlign);

        ui64GfxAddressUpperBound = ui64GfxAddress + pParams->dwSize;
        dwGfxAddrBottom          = (uint32_t)(ui64GfxAddressUpperBound & 0x00000000FFFFFFFF);
        dwGfxAddrTop             = (uint32_t)((ui64GfxAddressUpperBound & 0xFFFFFFFF00000000) >> 32);

        pParams->pdwCmd += pParams->dwUpperBoundLocationOffsetFromCmd;
        *pParams->pdwCmd = (*pParams->pdwCmd & ~dwMask) | (dwGfxAddrBottom & dwMask);
        // this is next DW for top part of the address
        *(pParams->pdwCmd + 1) = dwGfxAddrTop;

        MOS_PATCH_ENTRY_PARAMS PatchEntryParams;

        // Calculate the patch offset to command buffer
        uiPatchOffset += pParams->dwUpperBoundLocationOffsetFromCmd * sizeof(uint32_t);

        MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
        PatchEntryParams.uiAllocationIndex = iAllocationIndex;
        PatchEntryParams.uiResourceOffset = pParams->dwOffset + pParams->dwSize;
        PatchEntryParams.uiPatchOffset    = uiPatchOffset;
        PatchEntryParams.bUpperBoundPatch = true;
        PatchEntryParams.presResource     = pParams->presResource;

        // Add patch entry (CP won't register this patch point since bUpperBoundPatch = true)
        MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
            pOsInterface,
            &PatchEntryParams));
    }

    if (s_OCAResourceInfoType.count(pParams->HwCommandType))
    {
        HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *pParams->presResource, pParams->HwCommandType,
            pParams->dwLocationInCmd, pParams->dwOffset);
    }

    return eStatus;
}

//!
//! \brief    Adds resources to a patch list
//! \details  Internal MHW function to put resources to be added to the command
//!           buffer or indirect state into a patch list for patch later
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] OS interface
//! \param    PMOS_COMMAND_BUFFER pCmdBuffer
//!           [in] Command buffer
//! \param    PMHW_RESOURCE_PARAMS pParams
//!           [in] Parameters necessary to add the resource to the patch list
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_AddResourceToCmd_PatchList(
    PMOS_INTERFACE              pOsInterface,
    PMOS_COMMAND_BUFFER         pCmdBuffer,
    PMHW_RESOURCE_PARAMS        pParams)
{
    MOS_GPU_CONTEXT         GpuContext;
    int32_t                 iAllocationIndex;
    uint32_t                dwLsbNum, dwUpperBoundOffset;
    uint32_t                dwOffset;
    uint32_t                uiPatchOffset;
    MOS_PATCH_ENTRY_PARAMS  PatchEntryParams;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pParams);
    MHW_CHK_NULL_RETURN(pParams->presResource);
    MHW_CHK_NULL_RETURN(pCmdBuffer);

    MOS_TraceEventExt(EVENT_RESOURCE_REGISTER, EVENT_TYPE_INFO2, &pParams->HwCommandType, sizeof(uint32_t), &pParams->dwLocationInCmd, sizeof(uint32_t));

    MHW_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
        pOsInterface,
        pParams->presResource,
        pParams->bIsWritable ? true : false,
        pParams->bIsWritable ? true : false));

    GpuContext = pOsInterface->pfnGetGpuContext(pOsInterface);
    iAllocationIndex = pOsInterface->pfnGetResourceAllocationIndex(pOsInterface, pParams->presResource);
    dwLsbNum = pParams->dwLsbNum;

    // Offset and command LSB parameters
    dwOffset = pParams->dwOffset | ((*pParams->pdwCmd) & ((1 << dwLsbNum) - 1));

    Mhw_SetMocsTableIndex(pOsInterface, pParams->presResource, pParams->mocsParams);
    
    if (pParams->dwOffsetInSSH > 0)
    {
        // Calculate the patch offset to command buffer
        uiPatchOffset = pParams->dwOffsetInSSH + (pParams->dwLocationInCmd * sizeof(uint32_t));
    }
    else
    {
        // Calculate the patch offset to command buffer
        uiPatchOffset = pCmdBuffer->iOffset + (pParams->dwLocationInCmd * sizeof(uint32_t));
    }

    MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
    PatchEntryParams.uiAllocationIndex = iAllocationIndex;
    if(pParams->patchType == MOS_PATCH_TYPE_UV_Y_OFFSET ||
       pParams->patchType == MOS_PATCH_TYPE_PITCH ||
       pParams->patchType == MOS_PATCH_TYPE_V_Y_OFFSET)
    {
        PatchEntryParams.uiResourceOffset = *pParams->pdwCmd;
    }
    else
    {
        PatchEntryParams.uiResourceOffset = dwOffset;
    }
    PatchEntryParams.uiPatchOffset    = uiPatchOffset;
    PatchEntryParams.bWrite           = pParams->bIsWritable;
    PatchEntryParams.HwCommandType    = pParams->HwCommandType;
    PatchEntryParams.forceDwordOffset = pParams->dwSharedMocsOffset;
    PatchEntryParams.cmdBufBase       = (uint8_t*)pCmdBuffer->pCmdBase;
    PatchEntryParams.presResource     = pParams->presResource;
    PatchEntryParams.patchType        = pParams->patchType;
    PatchEntryParams.shiftAmount      = pParams->shiftAmount;
    PatchEntryParams.shiftDirection   = pParams->shiftDirection;
    PatchEntryParams.offsetInSSH      = pParams->dwOffsetInSSH;
    PatchEntryParams.cmdBuffer        = pCmdBuffer;

    // Add patch entry to patch the address field for this command
    MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
        pOsInterface,
        &PatchEntryParams));

    if (pParams->dwUpperBoundLocationOffsetFromCmd > 0)
    {
        pParams->pdwCmd += pParams->dwUpperBoundLocationOffsetFromCmd;
        dwUpperBoundOffset = pParams->dwUpperBoundLocationOffsetFromCmd;

        // Offset and command LSB parameters
        dwOffset = MOS_ALIGN_CEIL((pParams->dwOffset + pParams->dwSize), (1 << dwLsbNum));
        dwOffset = dwOffset | ((*pParams->pdwCmd) & ((1 << dwLsbNum) - 1));

        // Calculate the patch offset to command buffer
        uiPatchOffset += dwUpperBoundOffset * sizeof(uint32_t);

        MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
        PatchEntryParams.uiAllocationIndex = iAllocationIndex;
        PatchEntryParams.uiResourceOffset = dwOffset;
        PatchEntryParams.uiPatchOffset    = uiPatchOffset;
        PatchEntryParams.bUpperBoundPatch = true;
        PatchEntryParams.presResource     = pParams->presResource;
        PatchEntryParams.patchType        = pParams->patchType;
        PatchEntryParams.shiftAmount      = pParams->shiftAmount;
        PatchEntryParams.shiftDirection   = pParams->shiftDirection;
        PatchEntryParams.offsetInSSH      = pParams->dwOffsetInSSH;
        PatchEntryParams.cmdBuffer        = pCmdBuffer;

        if(dwLsbNum)
        {
            PatchEntryParams.shiftAmount = dwLsbNum;
            PatchEntryParams.shiftDirection = 0;
        }

        // Add patch entry to patch the address field for this command
        MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
            pOsInterface,
            &PatchEntryParams));
    }

    if (s_OCAResourceInfoType.count(pParams->HwCommandType))
    {
        HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *pParams->presResource, pParams->HwCommandType,
            pParams->dwLocationInCmd, pParams->dwOffset);
    }

    return eStatus;
}

//!
//! \brief    Derive Surface Type from Surface Format
//! \details  Internal MHW function to dervie surface type from surface format
//! \param    uint32_t dwForceSurfaceFormat
//!           [in] surface format information
//! \param    PMOS_SURFACE psSurface
//!           [in] surface which have depth information
//! \param    uint32_t* pdwSurfaceType
//!           [out] Surface type
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_SurfaceFormatToType(
    uint32_t                       dwForceSurfaceFormat,
    PMOS_SURFACE                   psSurface,
    uint32_t                       *pdwSurfaceType)
{
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(psSurface);
    MHW_CHK_NULL_RETURN(pdwSurfaceType);

    switch ( dwForceSurfaceFormat )
    {
        // 1D Surface
        case MHW_GFX3DSTATE_SURFACEFORMAT_RAW:
        case MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT:
        case MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM:
            *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_BUFFER;
            break;

        // 2D Surface for Codec: GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL, GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY
        // GFX3DSTATE_SURFACEFORMAT_R32_UNORM, GFX3DSTATE_SURFACEFORMAT_R16_UNORM, GFX3DSTATE_SURFACEFORMAT_R8_UNORM

        // 2D & 3D Surface
        default:
            (psSurface->dwDepth > 1) ?
                *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_3D:
                *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_2D;
    }

    return eStatus;
}

//!
//! \brief    Send native fence sync batch buffer start command
//! \details  Emits MI_BATCH_BUFFER_START for the native fence sync batch buffer
//!           if the GPU context supports sync-by-command. After emitting the
//!           command, sets bNativeFenceSyncBBAdded flag on the command buffer
//!           to prevent double emission in subsequent prolog functions.
//!           This function MUST be called before any other commands
//!           (MI_FORCE_WAKEUP, watchdog, cache flush) in the command buffer.
//! \param    PMOS_COMMAND_BUFFER pCmdBuffer
//!           [in] Command buffer
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] OS interface
//! \param    std::shared_ptr<void> pMiItf
//!           [in] MI interface
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_SendNativeFenceSyncBBStartCmd(
    PMOS_COMMAND_BUFFER           pCmdBuffer,
    PMOS_INTERFACE                pOsInterface,
    std::shared_ptr<void>         pMiItf)
{
    MHW_FUNCTION_ENTER;

    // Skip if not fully initialized
    if (pCmdBuffer == nullptr || pOsInterface == nullptr)
    {
        return MOS_STATUS_SUCCESS;
    }

    // Early out if native fence sync is not applicable
    if (pOsInterface->pfnIsGpuSyncByCmd == nullptr ||
        !pOsInterface->pfnIsGpuSyncByCmd(pOsInterface, pOsInterface->CurrentGpuContextHandle) ||
        pCmdBuffer->syncMhwBatchBuffer == nullptr ||
        pCmdBuffer->bNativeFenceSyncBBAdded)
    {
        return MOS_STATUS_SUCCESS;
    }

    // Native fence sync is needed - validate MI interface
    std::shared_ptr<mhw::mi::Itf> miItf = std::static_pointer_cast<mhw::mi::Itf>(pMiItf);
    MHW_CHK_NULL_RETURN(miItf);

    auto &miBatchBufferStartParams = miItf->MHW_GETPAR_F(MI_BATCH_BUFFER_START)();
    uint64_t gfxAddr = pOsInterface->pfnGetResourceGfxAddress(pOsInterface, &pCmdBuffer->OsResource);
    pOsInterface->pfnOnNativeFenceSyncBBAdded(pCmdBuffer, gfxAddr);
    miBatchBufferStartParams = {};
    MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_BATCH_BUFFER_START)(pCmdBuffer, pCmdBuffer->syncMhwBatchBuffer));

    pCmdBuffer->bNativeFenceSyncBBAdded = true;

    return MOS_STATUS_SUCCESS;
}

//!
//! \brief    Inserts the generic prologue command for a command buffer
//! \details  Client facing function to add the generic prologue commands:
//!               - the command buffer header (if necessary)
//!               - flushes for the read/write caches (MI_FLUSH_DW or PIPE_CONTROL)
//!               - CP prologue if necessary
//! \param    PMOS_COMMAND_BUFFER pCmdBuffer
//!           [in] Command buffer
//! \param    PMHW_GENERIC_PROLOG_PARAMS pParams
//!           [in] Parameters necessary to add the generic prologue commands
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_SendGenericPrologCmdNext(
    PMOS_COMMAND_BUFFER           pCmdBuffer,
    PMHW_GENERIC_PROLOG_PARAMS    pParams,
    std::shared_ptr<void>         pMiItf,
    MHW_MI_MMIOREGISTERS          *pMmioReg)
{
    PMOS_INTERFACE                  pOsInterface;
    MEDIA_FEATURE_TABLE             *pSkuTable;
    MEDIA_WA_TABLE                  *pWaTable;
    MOS_GPU_CONTEXT                 GpuContext;
    MHW_PIPE_CONTROL_PARAMS         PipeControlParams;
    MHW_MI_FLUSH_DW_PARAMS          FlushDwParams;
    bool                            bRcsEngineUsed = false;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;
    std::shared_ptr<mhw::mi::Itf>   miItf = std::static_pointer_cast<mhw::mi::Itf>(pMiItf);
    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(pCmdBuffer);
    MHW_CHK_NULL_RETURN(pParams);
    MHW_CHK_NULL_RETURN(pParams->pOsInterface);
    MHW_CHK_NULL_RETURN(miItf);

    pOsInterface = pParams->pOsInterface;

    pSkuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
    MHW_CHK_NULL_RETURN(pSkuTable);
    pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
    MHW_CHK_NULL_RETURN(pWaTable);
    GpuContext = pOsInterface->pfnGetGpuContext(pOsInterface);
    MHW_CHK_STATUS_RETURN(Mhw_SendNativeFenceSyncBBStartCmd(pCmdBuffer, pOsInterface, pMiItf));

    if ( pOsInterface->Component != COMPONENT_CM )
    {
        if (    GpuContext == MOS_GPU_CONTEXT_RENDER        ||
                GpuContext == MOS_GPU_CONTEXT_RENDER2       ||
                GpuContext == MOS_GPU_CONTEXT_RENDER3       ||
                GpuContext == MOS_GPU_CONTEXT_RENDER4       ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO         ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO2        ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO3        ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO4        ||
                GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO  ||
                GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO2 ||
                GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO3 ||
                GpuContext == MOS_GPU_CONTEXT_VEBOX         ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO5        ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO6        ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO7        ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO_DEC_FULL ||
                GpuContext == MOS_GPU_CONTEXT_VIDEO_ENC_FULL )
        {
            MHW_CHK_STATUS_RETURN(miItf->AddWatchdogTimerStartCmd(pCmdBuffer));
        }
    }

    bRcsEngineUsed = MOS_RCS_ENGINE_USED(GpuContext);

    if (bRcsEngineUsed)
    {
        auto& par = miItf->MHW_GETPAR_F(PIPE_CONTROL)();
        par = {};
        par.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
        MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));

        auto& par1 = miItf->MHW_GETPAR_F(PIPE_CONTROL)();
        par1 = {};
        par1.dwFlushMode = MHW_FLUSH_READ_CACHE;
        par1.presDest = pParams->presStoreData;
        par1.dwResourceOffset = pParams->dwStoreDataOffset;
        par1.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
        MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));

        if(pCmdBuffer->Attributes.bUmdSSEUEnable)
        {
            MHW_MI_LOAD_REGISTER_IMM_PARAMS MiLoadRegImmParams;
            MHW_RENDER_PWR_CLK_STATE_PARAMS params;

            MOS_ZeroMemory(&params, sizeof(params));
            params.PowerClkStateEn  = true;
            params.SCountEn         = true;
            params.SSCountEn        = true;
            params.SliceCount       = pCmdBuffer->Attributes.dwNumRequestedEUSlices;
            params.SubSliceCount    = pCmdBuffer->Attributes.dwNumRequestedSubSlices;
            params.EUmax            = pCmdBuffer->Attributes.dwNumRequestedEUs;
            params.EUmin            = pCmdBuffer->Attributes.dwNumRequestedEUs;

            auto& par = miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
            par = {};
            par.dwRegister = MHW__PWR_CLK_STATE_REG;
            par.dwData = params.Data;
            MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
        }
    }
    else
    {
        // Send MI_FLUSH with protection bit off, which will FORCE exit protected mode for MFX
        auto& params = miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
        params = {};
        params.bVideoPipelineCacheInvalidate = true;
        params.pOsResource = pParams->presStoreData;
        params.dwResourceOffset = pParams->dwStoreDataOffset;
        params.dwDataDW1 = pParams->dwStoreDataValue;
        MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
    }

    MHW_CHK_STATUS_RETURN(miItf->AddProtectedProlog(pCmdBuffer));

    if (pMmioReg)
    {
        HalOcaInterfaceNext::On1stLevelBBStart(
            *pCmdBuffer,
            (MOS_CONTEXT_HANDLE)pOsInterface->pOsContext,
            pOsInterface->CurrentGpuContextHandle,
            miItf,
            *pMmioReg);
    }

    return eStatus;
}

//!
//! \brief      Sets Nearest Mode Table for Gen75/9, across SFC and Render engine to set the sampler states
//! \details    This function sets Coefficients for Nearest Mode
//! \param      int32_t*   iCoefs
//!             [out]   Polyphase Table to fill
//! \param      uint32_t   dwPlane
//!             [in]    Number of Polyphase tables
//! \param      bool    bBalancedFilter
//!             [in]    If Filter is balanced, set true
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_SetNearestModeTable(
    int32_t         *iCoefs,
    uint32_t        dwPlane,
    bool            bBalancedFilter)
{
    uint32_t                dwNumEntries;
    uint32_t                dwOffset;
    uint32_t                i;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(iCoefs);

    if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
    {
        dwNumEntries = NUM_POLYPHASE_Y_ENTRIES;
        dwOffset = 3;
    }
    else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE)
    {
        dwNumEntries = NUM_POLYPHASE_UV_ENTRIES;
        dwOffset = 1;
    }

    for (i = 0; i <= NUM_HW_POLYPHASE_TABLES / 2; i++)
    {
        iCoefs[i * dwNumEntries + dwOffset] = 0x40;
    }

    if (bBalancedFilter)
    {
        // Fix offset so that filter is balanced
        for (i = (NUM_HW_POLYPHASE_TABLES / 2 + 1); i < NUM_HW_POLYPHASE_TABLES; i++)
        {
            iCoefs[i * dwNumEntries + dwOffset + 1] = 0x40;
        }
    }

    return eStatus;
}

//!
//! \brief      Calculate Polyphase tables for Y , across SFC and Render engine to set the sampler states
//! \details    Calculate Polyphase tables for Y
//!             This function uses 17 phases.
//!             MHW_NUM_HW_POLYPHASE_TABLES reflects the phases to program coefficients in HW, and
//!             NUM_POLYPHASE_TABLES reflects the number of phases used for internal calculations.
//! \param      int32_t*   iCoefs
//!             [out]   Polyphase Table to fill
//! \param      float   fScaleFactor
//!             [in]    Scaling factor
//! \param      uint32_t   dwPlane
//!             [in]    Plane Info
//! \param      MOS_FORMAT srcFmt
//!             [in]    Source Format
//! \param      float   fHPStrength
//!             [in]    High Pass Strength
//! \param      bool    bUse8x8Filter
//!             [in]    is 8x8 Filter used
//! \param      uint32_t   dwHwPhase
//!             [in]    Number of phases in HW
//! \param      float      fLanczosT
//!             [in]    Lanczos factor
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_CalcPolyphaseTablesY(
    int32_t         *iCoefs,
    float           fScaleFactor,
    uint32_t        dwPlane,
    MOS_FORMAT      srcFmt,
    float           fHPStrength,
    bool            bUse8x8Filter,
    uint32_t        dwHwPhase,
    float           fLanczosT)
{
    uint32_t                dwNumEntries;
    uint32_t                dwTableCoefUnit;
    uint32_t                i, j;
    int32_t                 k;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;
    float                   fPhaseCoefs[NUM_POLYPHASE_Y_ENTRIES];
    float                   fPhaseCoefsCopy[NUM_POLYPHASE_Y_ENTRIES];
    float                   fStartOffset;
    float                   fHPFilter[3], fHPSum, fHPHalfPhase; // Only used for Y_PLANE
    float                   fBase, fPos, fSumCoefs;
    int32_t                 iCenterPixel;
    int32_t                 iSumQuantCoefs;

    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(iCoefs);
    MHW_ASSERT((dwHwPhase == MHW_NUM_HW_POLYPHASE_TABLES) || (dwHwPhase == NUM_HW_POLYPHASE_TABLES));

    if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
    {
        dwNumEntries = NUM_POLYPHASE_Y_ENTRIES;
    }
    else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE)
    {
        dwNumEntries = NUM_POLYPHASE_UV_ENTRIES;
    }

    MOS_ZeroMemory(fPhaseCoefs    , sizeof(fPhaseCoefs));
    MOS_ZeroMemory(fPhaseCoefsCopy, sizeof(fPhaseCoefsCopy));

    dwTableCoefUnit = 1 << MHW_AVS_TBL_COEF_PREC;
    iCenterPixel = dwNumEntries / 2 - 1;
    fStartOffset = (float)(-iCenterPixel);

    if ((IS_YUV_FORMAT(srcFmt)    &&
        dwPlane != MHW_U_PLANE    &&
        dwPlane != MHW_V_PLANE)   ||
        ((IS_RGB32_FORMAT(srcFmt) ||
        srcFmt == Format_Y410     ||
        srcFmt == Format_AYUV)    &&
        dwPlane == MHW_Y_PLANE))
    {
        if (fScaleFactor < 1.0F)
        {
            fLanczosT = 4.0F;
        }
        else
        {
            fLanczosT = 8.0F;
        }
    }
    else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE || (IS_RGB_FORMAT(srcFmt) && dwPlane != MHW_V_PLANE))
    {
        fLanczosT = 2.0F;
    }

    for (i = 0; i < dwHwPhase; i++)
    {
        fBase = fStartOffset - (float)i / (float)NUM_POLYPHASE_TABLES;
        fSumCoefs = 0.0F;

        for (j = 0; j < dwNumEntries; j++)
        {
            fPos = fBase + (float)j;

            if (bUse8x8Filter)
            {
                fPhaseCoefs[j] = fPhaseCoefsCopy[j] = MosUtilities::MosLanczos(fPos * fScaleFactor, dwNumEntries, fLanczosT);
            }
            else
            {
                fPhaseCoefs[j] = fPhaseCoefsCopy[j] = MosUtilities::MosLanczosG(fPos * fScaleFactor, NUM_POLYPHASE_5x5_Y_ENTRIES, fLanczosT);
            }

            fSumCoefs += fPhaseCoefs[j];
        }

        // Convolve with HP
        if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
        {
            if (i <= NUM_POLYPHASE_TABLES / 2)
            {
                fHPHalfPhase = (float)i / (float)NUM_POLYPHASE_TABLES;
            }
            else
            {
                fHPHalfPhase = (float)(NUM_POLYPHASE_TABLES - i) / (float)NUM_POLYPHASE_TABLES;
            }
            fHPFilter[0] = fHPFilter[2] = -fHPStrength * MosUtilities::MosSinc(fHPHalfPhase * MOS_PI);
            fHPFilter[1] = 1.0F + 2.0F * fHPStrength;

            for (j = 0; j < dwNumEntries; j++)
            {
                fHPSum = 0.0F;
                for (k = -1; k <= 1; k++)
                {
                    if ((((long)j + k) >= 0) && (j + k < dwNumEntries))
                    {
                        fHPSum += fPhaseCoefsCopy[(int32_t)j+k] * fHPFilter[k+1];
                    }
                    fPhaseCoefs[j] = fHPSum;
                }
            }
        }

        // Normalize coefs and save
        iSumQuantCoefs = 0;
        for (j = 0; j < dwNumEntries; j++)
        {
            iCoefs[i * dwNumEntries + j] = (int32_t)floor(0.5F + (float)dwTableCoefUnit * fPhaseCoefs[j] / fSumCoefs);
            iSumQuantCoefs += iCoefs[i * dwNumEntries + j];
        }

        // Fix center coef so that filter is balanced
        if (i <= NUM_POLYPHASE_TABLES / 2)
        {
            iCoefs[i * dwNumEntries + iCenterPixel] -= iSumQuantCoefs - dwTableCoefUnit;
        }
        else
        {
            iCoefs[i * dwNumEntries + iCenterPixel + 1] -= iSumQuantCoefs - dwTableCoefUnit;
        }
    }

    return eStatus;
}

//!
//! \brief      Calculate Polyphase tables for UV for Gen9, across SFC and Render engine to set the sampler states
//! \details    Calculate Polyphase tables for UV
//! \param      int32_t*   piCoefs
//!             [out]   Polyphase Table to fill
//! \param      float   fLanczosT
//!             [in]    Lanczos modifying factor
//! \param      float   fInverseScaleFactor
//!             [in]    Inverse scaling factor
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_CalcPolyphaseTablesUV(
    int32_t    *piCoefs,
    float      fLanczosT,
    float      fInverseScaleFactor)
{
    int32_t     phaseCount, tableCoefUnit, centerPixel, sumQuantCoefs;
    double      phaseCoefs[MHW_SCALER_UV_WIN_SIZE];
    double      startOffset, sf, base, sumCoefs, pos;
    int32_t     minCoef[MHW_SCALER_UV_WIN_SIZE];
    int32_t     maxCoef[MHW_SCALER_UV_WIN_SIZE];
    int32_t     i, j;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(piCoefs);

    phaseCount      = MHW_TABLE_PHASE_COUNT;
    centerPixel     = (MHW_SCALER_UV_WIN_SIZE / 2) - 1;
    startOffset     = (double)(-centerPixel);
    tableCoefUnit   = 1 << MHW_TBL_COEF_PREC;
    sf              = MOS_MIN(1.0, fInverseScaleFactor); // Sf isn't used for upscaling

    MOS_ZeroMemory(piCoefs, sizeof(int32_t) * MHW_SCALER_UV_WIN_SIZE * phaseCount);
    MOS_ZeroMemory(minCoef, sizeof(minCoef));
    MOS_ZeroMemory(maxCoef, sizeof(maxCoef));

    if (sf < 1.0F)
    {
        fLanczosT = 2.0F;
    }

    for(i = 0; i < phaseCount; ++i, piCoefs += MHW_SCALER_UV_WIN_SIZE)
    {
        // Write all
        // Note - to shift by a half you need to a half to each phase.
        base     = startOffset - (double)(i) / (double)(phaseCount);
        sumCoefs = 0.0;

        for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            pos             = base + (double) j;
            phaseCoefs[j]   = MosUtilities::MosLanczos((float)(pos * sf), MHW_SCALER_UV_WIN_SIZE, fLanczosT);
            sumCoefs        += phaseCoefs[j];
        }
        // Normalize coefs and save
        for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            piCoefs[j] = (int32_t) floor((0.5 + (double)(tableCoefUnit) * (phaseCoefs[j] / sumCoefs)));

            //For debug purposes:
            minCoef[j] = MOS_MIN(minCoef[j], piCoefs[j]);
            maxCoef[j] = MOS_MAX(maxCoef[j], piCoefs[j]);
        }

        // Recalc center coef
        sumQuantCoefs = 0;
        for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            sumQuantCoefs += piCoefs[j];
        }

        // Fix center coef so that filter is balanced
        if (i <= phaseCount/2)
        {
            piCoefs[centerPixel]     -= sumQuantCoefs - tableCoefUnit;
        }
        else
        {
            piCoefs[centerPixel + 1] -= sumQuantCoefs - tableCoefUnit;
        }
    }

    return eStatus;
}

//!
//! \brief      Calculate polyphase tables UV offset for Gen9, across SFC and Render engine to set the sampler states
//! \details    Calculate Polyphase tables for UV with chroma siting for
//!             420 to 444 conversion
//! \param      int32_t*   piCoefs
//!             [out]   Polyphase Table to fill
//! \param      float   fLanczosT
//!             [in]    Lanczos modifying factor
//! \param      float   fInverseScaleFactor
//!             [in]    Inverse scaling factor
//! \param      int32_t     iUvPhaseOffset
//!             [in]    UV Phase Offset
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS Mhw_CalcPolyphaseTablesUVOffset(
    int32_t     *piCoefs,
    float       fLanczosT,
    float       fInverseScaleFactor,
    int32_t     iUvPhaseOffset)
{
    int32_t     phaseCount, tableCoefUnit, centerPixel, sumQuantCoefs;
    double      phaseCoefs[MHW_SCALER_UV_WIN_SIZE];
    double      startOffset, sf, pos, sumCoefs, base;
    int32_t     minCoef[MHW_SCALER_UV_WIN_SIZE];
    int32_t     maxCoef[MHW_SCALER_UV_WIN_SIZE];
    int32_t     i, j;
    int32_t     adjusted_phase;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_FUNCTION_ENTER;

    MHW_CHK_NULL_RETURN(piCoefs);

    phaseCount = MHW_TABLE_PHASE_COUNT;
    centerPixel = (MHW_SCALER_UV_WIN_SIZE / 2) - 1;
    startOffset = (double)(-centerPixel +
        (double)iUvPhaseOffset / (double)(phaseCount));
    tableCoefUnit = 1 << MHW_TBL_COEF_PREC;

    MOS_ZeroMemory(minCoef, sizeof(minCoef));
    MOS_ZeroMemory(maxCoef, sizeof(maxCoef));
    MOS_ZeroMemory(piCoefs, sizeof(int32_t)* MHW_SCALER_UV_WIN_SIZE * phaseCount);

    sf = MOS_MIN(1.0, fInverseScaleFactor); // Sf isn't used for upscaling
    if (sf < 1.0)
    {
        fLanczosT = 3.0;
    }

    for (i = 0; i < phaseCount; ++i, piCoefs += MHW_SCALER_UV_WIN_SIZE)
    {
        // Write all
        // Note - to shift by a half you need to a half to each phase.
        base = startOffset - (double)(i) / (double)(phaseCount);
        sumCoefs = 0.0;

        for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            pos = base + (double)j;
            phaseCoefs[j] = MosUtilities::MosLanczos((float)(pos * sf), 6/*MHW_SCALER_UV_WIN_SIZE*/, fLanczosT);
            sumCoefs += phaseCoefs[j];
        }
        // Normalize coefs and save
        for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            piCoefs[j] = (int32_t)floor((0.5 + (double)(tableCoefUnit)* (phaseCoefs[j] / sumCoefs)));

            // For debug purposes:
            minCoef[j] = MOS_MIN(minCoef[j], piCoefs[j]);
            maxCoef[j] = MOS_MAX(maxCoef[j], piCoefs[j]);
        }

        // Recalc center coef
        sumQuantCoefs = 0;
        for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
        {
            sumQuantCoefs += piCoefs[j];
        }

        // Fix center coef so that filter is balanced
        adjusted_phase = i - iUvPhaseOffset;
        if (adjusted_phase <= phaseCount / 2)
        {
            piCoefs[centerPixel] -= sumQuantCoefs - tableCoefUnit;
        }
        else // if(adjusted_phase < phaseCount)
        {
            piCoefs[centerPixel + 1] -= sumQuantCoefs - tableCoefUnit;
        }
    }

    return eStatus;
}

//!
//! \brief    Allocate BB
//! \details  Allocated Batch Buffer
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] Pointer to OS Interface
//! \param    PMHW_BATCH_BUFFER pBatchBuffer
//!           [in/out] Pointer to Batch Buffer
//! \param    PMHW_BATCH_BUFFER pBatchBufferList
//!           [in/out] If valid, represents the batch buffer list maintained by the client
//! \param    uint32_t dwSize
//!           [in] Sixe of the batch vuffer to be allocated
//! \param    bool notLockable
//!           [in] Indicate if the batch buffer not lockable, by default is false
//! \param    bool inSystemMem
//!           [in] Indicate if the batch buffer in system memory, by default is false
//! \return   MOS_STATUS
//!           true  if the Batch Buffer was successfully allocated
//!           false if failed
//!
MOS_STATUS Mhw_AllocateBb(
    PMOS_INTERFACE          pOsInterface,
    PMHW_BATCH_BUFFER       pBatchBuffer,
    PMHW_BATCH_BUFFER       pBatchBufferList,
    uint32_t                dwSize,
    uint32_t                batchCount,
    bool                    notLockable,
    bool                    inSystemMem)
{
    MHW_FUNCTION_ENTER;

    MOS_RESOURCE                        OsResource;
    MOS_ALLOC_GFXRES_PARAMS             AllocParams;
    uint32_t                            allocSize;
    MOS_STATUS                          eStatus = MOS_STATUS_SUCCESS;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pBatchBuffer);
    MHW_ASSERT(!(notLockable && inSystemMem)); // Notlockable system memory doesn't make sense

    dwSize += 8 * MHW_CACHELINE_SIZE;
    dwSize = MOS_ALIGN_CEIL(dwSize, MOS_PAGE_SIZE);
    allocSize = dwSize * batchCount;

    MOS_ZeroMemory(&OsResource, sizeof(OsResource));
    MOS_ZeroMemory(&AllocParams, sizeof(AllocParams));
    AllocParams.Type     = MOS_GFXRES_BUFFER;
    AllocParams.TileType = MOS_TILE_LINEAR;
    AllocParams.Format   = Format_Buffer;
    AllocParams.dwBytes  = allocSize;
    AllocParams.pBufName = "BatchBuffer";
    AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS;
    AllocParams.Flags.bNotLockable = notLockable ? 1 : 0;
    if (notLockable)
    {
        AllocParams.dwMemType = MOS_MEMPOOL_DEVICEMEMORY;
    }
    else if (inSystemMem)
    {
        AllocParams.dwMemType = MOS_MEMPOOL_SYSTEMMEMORY;
    }
    else
    {
        AllocParams.dwMemType = MOS_MEMPOOL_VIDEOMEMORY;
    }

    MHW_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource(
        pOsInterface,
        &AllocParams,
        &OsResource));

    // Reset Allocation
    pOsInterface->pfnResetResourceAllocationIndex(pOsInterface, &OsResource);

    pBatchBuffer->OsResource        = OsResource;
    pBatchBuffer->iSize             = (int32_t)dwSize;
    pBatchBuffer->count             = batchCount;
    pBatchBuffer->iRemaining        = pBatchBuffer->iSize;
    pBatchBuffer->iCurrent          = 0;
    pBatchBuffer->bLocked           = false;
#if (_DEBUG || _RELEASE_INTERNAL)
    pBatchBuffer->iLastCurrent      = 0;
#endif

    // Link BB for synchronization
    pBatchBuffer->bBusy             = false;
    pBatchBuffer->dwCmdBufId        = 0;

    if (pBatchBufferList)
    {
        pBatchBuffer->pNext = pBatchBufferList;
        pBatchBufferList = pBatchBuffer;
        if (pBatchBuffer->pNext)
        {
            pBatchBuffer->pNext->pPrev = pBatchBuffer;
        }
    }

    return eStatus;
}

//!
//! \brief    Free BB
//! \details  Frees Batch Buffer
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] Pointer to OS Interface
//! \param    PMHW_BATCH_BUFFER pBatchBuffer
//!           [in] Pointer to Batch Buffer
//! \param    PMHW_BATCH_BUFFER pBatchBufferList
//!           [in/out] If valid, represents the batch buffer list maintained by the client
//! \return   MOS_STATUS
//!
MOS_STATUS Mhw_FreeBb(
    PMOS_INTERFACE          pOsInterface,
    PMHW_BATCH_BUFFER       pBatchBuffer,
    PMHW_BATCH_BUFFER       pBatchBufferList)
{
    MHW_FUNCTION_ENTER;

    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pBatchBuffer);

    if (pBatchBuffer->bLocked)
    {
        MHW_CHK_STATUS_RETURN(Mhw_UnlockBb(pOsInterface, pBatchBuffer, true));
    }

    pOsInterface->pfnFreeResource(pOsInterface, &pBatchBuffer->OsResource);

    pBatchBuffer->dwCmdBufId       = 0;
    pBatchBuffer->iSize            = 0;
    pBatchBuffer->count            = 0;
    pBatchBuffer->iCurrent         = 0;
#if (_DEBUG || _RELEASE_INTERNAL)
    pBatchBuffer->iLastCurrent     = 0;
#endif

    if (pBatchBufferList)
    {
        // Unlink BB from synchronization list
        if (pBatchBuffer->pNext)
        {
            pBatchBuffer->pNext->pPrev = pBatchBuffer->pPrev;
        }

        if (pBatchBuffer->pPrev)
        {
            pBatchBuffer->pPrev->pNext = pBatchBuffer->pNext;
        }
        else
        {
            pBatchBufferList = pBatchBuffer->pNext;
        }

        pBatchBuffer->pPrev = pBatchBuffer->pNext = nullptr;
    }

    return eStatus;
}

//!
//! \brief    Lock BB
//! \details  Locks Batch Buffer
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] Pointer to OS Interface
//! \param    PMHW_BATCH_BUFFER pBatchBuffer
//!           [in] Pointer to Batch Buffer
//! \return   MOS_STATUS
//!
MOS_STATUS Mhw_LockBb(
    PMOS_INTERFACE          pOsInterface,
    PMHW_BATCH_BUFFER       pBatchBuffer)
{
    MHW_FUNCTION_ENTER;

    MOS_LOCK_PARAMS         LockFlags;
    MOS_STATUS              eStatus;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pBatchBuffer);

    eStatus         = MOS_STATUS_UNKNOWN;

    if (pBatchBuffer->bLocked)
    {
        MHW_ASSERTMESSAGE("Batch Buffer is already locked.");
        return eStatus;
    }

    MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
    LockFlags.WriteOnly = 1;
    pBatchBuffer->pData = (uint8_t*)pOsInterface->pfnLockResource(
        pOsInterface,
        &pBatchBuffer->OsResource,
        &LockFlags);

    MHW_CHK_NULL_RETURN(pBatchBuffer->pData);

    pBatchBuffer->bLocked   = true;
    eStatus                 = MOS_STATUS_SUCCESS;

    return eStatus;
}

//!
//! \brief    Unlock BB
//! \details  Unlocks Batch Buffer
//! \param    PMOS_INTERFACE pOsInterface
//!           [in] Pointer to OS Interface
//! \param    PMHW_BATCH_BUFFER pBatchBuffer
//!           [in] Pointer to Batch Buffer
//! \param    bool bResetBuffer
//!           [in] Reset BB information concerning current offset and size
//! \return   MOS_STATUS
//!
MOS_STATUS Mhw_UnlockBb(
    PMOS_INTERFACE          pOsInterface,
    PMHW_BATCH_BUFFER       pBatchBuffer,
    bool                    bResetBuffer)
{
    MHW_FUNCTION_ENTER;

    MOS_STATUS              eStatus;

    MHW_CHK_NULL_RETURN(pOsInterface);
    MHW_CHK_NULL_RETURN(pBatchBuffer);

    eStatus = MOS_STATUS_UNKNOWN;

    if (!pBatchBuffer->bLocked)
    {
        MHW_ASSERTMESSAGE("Batch buffer is locked.");
        return eStatus;
    }

    if (bResetBuffer)
    {
        pBatchBuffer->iRemaining    = pBatchBuffer->iSize;
        pBatchBuffer->iCurrent      = 0;
    }

    MHW_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
        pOsInterface,
        &pBatchBuffer->OsResource));

    pBatchBuffer->bLocked = false;
    pBatchBuffer->pData   = nullptr;

    eStatus = MOS_STATUS_SUCCESS;

    return eStatus;
}

//!
//! \brief    Convert To Nano Seconds
//! \details  Convert to Nano Seconds
//! \param    PVPHAL_HW_int32_tERFACE pHwInterface
//!           [in] Pointer to Hardware Interface Structure
//! \param    uint64_t iTicks
//!           [in] Ticks
//! \param    uint64_t* piNs
//!           [in] Nano Seconds
//! \return   MOS_STATUS
//!
MOS_STATUS Mhw_ConvertToNanoSeconds(
    uint64_t                              iTicks,
    uint64_t                              *piNs)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    MHW_CHK_NULL_RETURN(piNs);

    *piNs = iTicks * MHW_NS_PER_TICK_RENDER_ENGINE;

    return eStatus;
}

//!
//! \brief    Convert Mos Tile Type to TR Mode
//! \details  Convert Mos Tile Type to TR Mode
//! \param    MOS_TILE_TYPE  Type
//!           [in] MOS tile type
//! \return   uint32_t
//!           Tile Resouece Mode
//!
uint32_t Mhw_ConvertToTRMode(MOS_TILE_TYPE  Type)
{
    switch (Type)
    {
    case MOS_TILE_YS:
        return TRMODE_TILEYS;
    case MOS_TILE_YF:
        return TRMODE_TILEYF;
    default:
        return TRMODE_NONE;
    }
}
