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

//==<Functions>=======================================================
//!
//! \brief    calculate secondary cmd buffer index
//! \details  calculate secondary cmd buffer index to get or return secondary cmd buffer
//! \param    [in]  pScalabilityState
//!                pointer to scalability decode state
//! \param    [in]  pdwBufIdxPlus1
//!                pointer to buf index, will contain the returned buf index value.
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if success, else fail reason
//!
static MOS_STATUS CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    uint32_t                           *pdwBufIdxPlus1)
{
    uint32_t                        HcpDecPhaseForBufIdx;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pdwBufIdxPlus1);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());

    if (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
    {
        *pdwBufIdxPlus1 = pScalabilityState->u8RtCurPipe + 1;
        if(pScalabilityStateBase->pHwInterface->GetOsInterface()->phasedSubmission)
        {
            /*  3 tiles 2 pipe for example:
                cur phase               cur pip
                0                       0, 1                2 cmd buffer needed
                1                       0                   1 cmd buffer needed
                all of 3 tiles cmd ready, submit 3 cmd togather
             */
            *pdwBufIdxPlus1 += (pScalabilityState->u8RtCurPhase * pScalabilityState->u8RtPhaseNum);
        }
    }
    else
    {
        HcpDecPhaseForBufIdx = pScalabilityState->HcpDecPhase;
        if (pScalabilityState->HcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyS2L)
        {
            //S2L commands put in the FE secondary command buffer.
            CODECHAL_DECODE_ASSERT(pScalabilityState->bShortFormatInUse);
            HcpDecPhaseForBufIdx = CODECHAL_HCP_DECODE_PHASE_FE;
        }

        //buffer index order is same as the buffer order in resScalableBatchBufs[] of MOS_VIRTUALENGINE_HINT_PARAMS
        *pdwBufIdxPlus1 = HcpDecPhaseForBufIdx - (pScalabilityState->bFESeparateSubmission ?
            CODECHAL_HCP_DECODE_PHASE_BE0 : CODECHAL_HCP_DECODE_PHASE_FE) + 1;
    }

finish:
    return eStatus;
}

//!
//! \brief    check if valid decode phase
//! \param    [in]  pScalabilityState
//!                pointer to scalability decode state
//! \param    [in]  HcpDecPhase
//!                Hcp Decode Phase
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if valid decode phase, else fail reason
//!
static MOS_STATUS CodecHalDecodeScalability_CheckDecPhaseValidity_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    uint32_t                            HcpDecPhase)
{
    bool                bInValidPhase = false;
    MOS_STATUS          eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);

    switch (HcpDecPhase)
    {
    case CodechalDecode::CodechalHcpDecodePhaseInitialized:
        break;
    case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
        if (!pScalabilityState->bShortFormatInUse)
        {
            bInValidPhase = true;
        }
        break;
    case CodechalDecode::CodechalHcpDecodePhaseLegacyLong:
        if (pScalabilityState->bScalableDecodeMode)
        {
            bInValidPhase = true;
        }
        break;
    case CODECHAL_HCP_DECODE_PHASE_FE:
    case CODECHAL_HCP_DECODE_PHASE_BE0:
        if (!pScalabilityState->bScalableDecodeMode)
        {
            bInValidPhase = true;
        }
        else if (pScalabilityState->ucScalablePipeNum < 2)
        {
            //at least 2 pipe
            bInValidPhase = true;
        }
        break;
    case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
        if (pScalabilityState->ucScalablePipeNum <= pScalabilityState->u8RtCurPipe)
        {
            bInValidPhase = true;
        }
        break;
    default:
        if(HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0 &&
            HcpDecPhase != CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
        {
            if (!pScalabilityState->bScalableDecodeMode)
            {
                bInValidPhase = true;
            }
            else if (pScalabilityState->ucScalablePipeNum < (HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE0 + 1))
            {
                bInValidPhase = true;
            }
        }
        else
        {
            bInValidPhase = true;
        }
        break;
    }

    if (bInValidPhase)
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase : %d !", HcpDecPhase);
    }

finish:
    return eStatus;
}

 MOS_STATUS CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityState,
    PMOS_COMMAND_BUFFER                 pSdryCmdBuf)
{
    PMOS_INTERFACE                  pOsInterface;
    uint32_t                        HcpDecPhase;
    uint32_t                        dwBufIdxPlus1 = 0;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface->GetOsInterface());

    pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
    HcpDecPhase = pScalabilityState->HcpDecPhase;

    //calculate bufidx for getting secondary cmd buffer.
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
    //Check if valid decode phase
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, HcpDecPhase));

    //Get batch buffer according to current decode phase
    switch (HcpDecPhase)
    {
    case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
        //Note: no break here, S2L and FE commands put in one secondary command buffer.
    case CODECHAL_HCP_DECODE_PHASE_FE:
        if (!pScalabilityState->bFESeparateSubmission)
        {
            CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnGetCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1));
            CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
        }
        else
        {
            //if FE separate submission, S2L and FE cmd buffer are in primary cmd buffer, shall not call this function to get secondary cmd buffer
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            CODECHAL_DECODE_ASSERTMESSAGE("S2L or FE does not need secondary cmd buffer in FE separate submission!");
        }
        break;
    default:
        if(((HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && ((HcpDecPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum)) ||
            (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE))
        {
            CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnGetCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1));
            CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
        }
        else
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
        }
        break;
    }

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_GetCmdBufferToUse_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    PMOS_COMMAND_BUFFER                 pScdryCmdBuf,
    PMOS_COMMAND_BUFFER                 *ppCmdBufToUse)
{
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(ppCmdBufToUse);

    if (!CodecHalDecodeScalabilityIsFESeparateSubmission(pScalabilityState) ||
        CodecHalDecodeScalabilityIsBEPhaseG12(pScalabilityState))
    {
        pScalabilityState->bUseSecdryCmdBuffer = true;
        CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(pScalabilityState, pScdryCmdBuf));
        *ppCmdBufToUse = pScdryCmdBuf;
    }
    else
    {
        pScalabilityState->bUseSecdryCmdBuffer = false;
    }

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityState,
    PMOS_COMMAND_BUFFER                 pSdryCmdBuf)
{
    PMOS_INTERFACE                  pOsInterface;
    uint32_t                        HcpDecPhase;
    uint32_t                        dwBufIdxPlus1;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface->GetOsInterface());

    pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();

    if (!pScalabilityState->bUseSecdryCmdBuffer)
    {
        goto finish;
    }

    HcpDecPhase = pScalabilityState->HcpDecPhase;

    //calculate bufidx for getting secondary cmd buffer.
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
    //Check if valid decode phase
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, HcpDecPhase));

    //Get batch buffer according to current decode phase
    switch (HcpDecPhase)
    {
    case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
        //Note: no break here, S2L and FE commands put in one secondary command buffer.
    case CODECHAL_HCP_DECODE_PHASE_FE:
        if (!pScalabilityState->bFESeparateSubmission)
        {
            pOsInterface->pfnReturnCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1);
        }
        else
        {
            //if FE separate submission, S2L and FE cmd buffer are in primary cmd buffer, shall not call this function to get secondary cmd buffer
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            CODECHAL_DECODE_ASSERTMESSAGE("S2L or FE does not need secondary cmd buffer in FE separate submission!");
        }
        break;
    default:
        if(((HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && ((HcpDecPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum)) ||
          (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE))
        {
            pOsInterface->pfnReturnCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1);
        }
        else
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
        }
        break;
    }

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_DetermineDecodePhase_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    uint32_t                            *pHcpDecPhase)
{
    uint32_t                        CurPhase;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pHcpDecPhase);

    CurPhase = *pHcpDecPhase;
    //Check if valid decode phase
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, CurPhase));

    if (pScalabilityState->bIsRtMode)
    {
        switch (CurPhase)
        {
        case CodechalDecode::CodechalHcpDecodePhaseInitialized:
            if (pScalabilityState->bShortFormatInUse)
            {
                *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
            }
            else
            {
                *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_REAL_TILE;
            }
            break;
        case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
        case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
            *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_REAL_TILE;
            break;
        default:
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            break;
        }
    }
    else if (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState))
    {
        switch (CurPhase)
        {
        case CodechalDecode::CodechalHcpDecodePhaseInitialized:
            if (pScalabilityState->bShortFormatInUse)
            {
                *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
            }
            else
            {
                *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_FE;
            }
            break;
        case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
            *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_FE;
            break;
        case CODECHAL_HCP_DECODE_PHASE_FE:
            *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_BE0;
            break;
        default:
            if(CurPhase >= CODECHAL_HCP_DECODE_PHASE_BE0 && ((CurPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum))
            {
                *pHcpDecPhase = CurPhase + 1;
            }
            else
            {
                eStatus = MOS_STATUS_INVALID_PARAMETER;
            }
            break;
        }
    }
    else
    {
        switch (CurPhase)
        {
        case CodechalDecode::CodechalHcpDecodePhaseInitialized:
            if (pScalabilityState->bShortFormatInUse)
            {
                *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
            }
            else
            {
                *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyLong;
            }
            break;
        case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
        case CodechalDecode::CodechalHcpDecodePhaseLegacyLong:
            *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyLong;
            break;
        default:
            //never comes here because other decode phase already checked invalid in function CodecHalDecodeScalability_CheckDecPhaseValidity,
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            break;
        }
    }

    pScalabilityState->HcpDecPhase = *pHcpDecPhase;

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_InitScalableParams_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE         pScalabilityStateBase,
    PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS   pInitParamsBase,
    uint16_t                                   *pucDecPassNum)
{
    PMOS_INTERFACE                  pOsInterface;
    PMOS_VIRTUALENGINE_INTERFACE    pVEInterface;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
    PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 pInitParams = static_cast<PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12>(pInitParamsBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());

    pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
    pVEInterface = pScalabilityStateBase->pVEInterface;

    if (!pOsInterface->bSupportVirtualEngine)
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("Scalability decode must run with virtual engine interface.\n");
        goto finish;
    }

    pScalabilityState->bScalableDecodeMode = false; // initialized to false
    pScalabilityState->bIsRtMode = false;

#if (_DEBUG || _RELEASE_INTERNAL)
    if (pOsInterface->bEnableDbgOvrdInVE)
    {
        if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
        {
            if (pOsInterface->apoMosEnabled)
            {
                CODECHAL_DECODE_CHK_NULL(pVEInterface->veInterface);
                pScalabilityState->ucScalablePipeNum = pVEInterface->veInterface->GetEngineCount() - 1;
            }
            else
            {
                pScalabilityState->ucScalablePipeNum = pVEInterface->ucEngineCount - 1;
            }
            pScalabilityState->bScalableDecodeMode = true;
        }
        else
        {
            // do nothing since pipe number already decided at the gpu context creation.
        }
    }
    else
#endif
    {
        // Decide pipe number
        CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pfnDecidePipeNum(pScalabilityState, pInitParams));
    }

    // Decide scalable mode or single pipe mode
    if (pScalabilityState->ucScalablePipeNum > 1)
    {
        pScalabilityState->bScalableDecodeMode = true;
    }

    CODECHAL_DECODE_CHK_NULL(pucDecPassNum);
    // Decide Decode pass number - pucDecPassNum
    if (pScalabilityState->bScalableDecodeMode)
    {
        bool        bCanEnableRealTile = true;
        uint8_t     u8MaxTileColumn = HEVC_NUM_MAX_TILE_COLUMN;

#if (_DEBUG || _RELEASE_INTERNAL)
        bCanEnableRealTile = !pScalabilityState->bDisableRtMode;
        if (!pScalabilityState->bEnableRtMultiPhase)
            u8MaxTileColumn = pScalabilityState->ucScalablePipeNum;
#endif
        bCanEnableRealTile = bCanEnableRealTile && pInitParams->bIsTileEnabled && (pInitParams->u8NumTileColumns > 1) &&
            (pInitParams->u8NumTileColumns <= u8MaxTileColumn) && (pInitParams->u8NumTileRows <= HEVC_NUM_MAX_TILE_ROW) &&
            pInitParams->bHasSubsetParams;
        if (bCanEnableRealTile)
        {
            pScalabilityState->bIsRtMode = true;
            //WA: No FE for real tile decoding and need to disable FE separate submission
            pScalabilityState->bFESeparateSubmission = false;
            pScalabilityState->u8RtPhaseNum =
                (pInitParams->u8NumTileColumns + pScalabilityState->ucScalablePipeNum - 1) / pScalabilityState->ucScalablePipeNum;
            pScalabilityState->u8RtPipeInLastPhase = pInitParams->u8NumTileColumns - pScalabilityState->ucScalablePipeNum * (pScalabilityState->u8RtPhaseNum - 1);
            pScalabilityState->u8RtCurPipe = 0;
            pScalabilityState->u8RtCurPhase = 0;

            *pucDecPassNum = pInitParams->u8NumTileColumns;
        }
        else if (pInitParams->bIsSccDecoding) // No virtual tile support for SCC, fallback to legacy mode
        {
            pScalabilityState->bScalableDecodeMode = false;
            *pucDecPassNum = 1;
        }
        else
        {
            *pucDecPassNum = pScalabilityState->ucScalablePipeNum + 1; // FE + all BEs
            pScalabilityState->bFESeparateSubmission = pScalabilityState->bFESeparateSubmissionVT;
        }
    }
    else
    {
        *pucDecPassNum = 1;
    }

    // Add one pass for S2L conversion in short format.
    if (pScalabilityState->bShortFormatInUse)
    {
        *pucDecPassNum = *pucDecPassNum + 1;
    }

    pScalabilityState->VideoContext = pInitParams->gpuCtxInUse;

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_SetHintParams_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE         pScalabilityStateBase,
    PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS pSetHintParms)
{
    PMOS_VIRTUALENGINE_INTERFACE    pVEInterface;
    MOS_VIRTUALENGINE_SET_PARAMS    VEParams;
    PMOS_INTERFACE                  pOsInterface;
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pSetHintParms);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());

    pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
    pVEInterface = pScalabilityStateBase->pVEInterface;

    MOS_ZeroMemory(&VEParams, sizeof(VEParams));
    if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
    {
        //not used by VE2.0
        VEParams.bNeedSyncWithPrevious = pSetHintParms->bNeedSyncWithPrevious;
        VEParams.bSameEngineAsLastSubmission = pSetHintParms->bSameEngineAsLastSubmission;
        VEParams.bSFCInUse = pSetHintParms->bSFCInUse;
    }

    VEParams.ucScalablePipeNum = pScalabilityState->ucScalablePipeNum;

    if (pScalabilityState->bScalableDecodeMode)
    {
        if (pScalabilityState->bFESeparateSubmission)
        {
            //set Hint parameter for FE submission
            VEParams.bScalableMode = false;
            if (pVEInterface->pfnVESetHintParams)
            {
                CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
            }
        }

        VEParams.bScalableMode = true;
        VEParams.bHaveFrontEndCmds = pScalabilityState->bIsRtMode ? false : (pScalabilityState->bFESeparateSubmission ? false : true);
        if (pVEInterface->pfnVESetHintParams)
        {
            CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
        }
    }
    else
    {
        VEParams.bScalableMode = false;
        if (pVEInterface->pfnVESetHintParams)
        {
            CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
        }
    }

finish:
    return eStatus;
}

#if (_DEBUG || _RELEASE_INTERNAL)
MOS_STATUS CodecHalDecodeScalability_DbgDumpCmdBuffer_G12(
    CodechalDecode                      *pDecoder,
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityState,
    CodechalDebugInterface              *debugInterface,
    PMOS_COMMAND_BUFFER                 pPrimCmdBuf)
{
    MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;
    MOS_COMMAND_BUFFER              ScdryCmdBuffer;
    PMOS_COMMAND_BUFFER             pCmdBufferInUse;
    std::string                     cmdName = "DEC";

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL(pDecoder);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL(pPrimCmdBuf);

    if (!pScalabilityState->bScalableDecodeMode)
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("Invalid decode parameters!");
        goto finish;
    }

    if (CodecHalDecodeScalabilityIsFESeparateSubmission(pScalabilityState)
        && CodecHalDecodeScalabilityIsFEPhase(pScalabilityState))
    {
        pCmdBufferInUse = pPrimCmdBuf;
    }
    else
    {
        //calculate bufidx for getting secondary cmd buffer.
        uint32_t dwBufIdxPlus1 = 0;
        CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
        cmdName = cmdName + "_secondary_" + std::to_string(dwBufIdxPlus1);
        CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(pScalabilityState, &ScdryCmdBuffer));
        pCmdBufferInUse = &ScdryCmdBuffer;
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(debugInterface->DumpCmdBuffer(
        pCmdBufferInUse,
        CODECHAL_NUM_MEDIA_STATES,
        cmdName.c_str()));

finish:
    return eStatus;
}
#endif

MOS_STATUS CodecHalDecodeScalability_FEBESync_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    PMOS_COMMAND_BUFFER                 pCmdBufferInUse,
    bool phasedSubmission)
{
    PMOS_INTERFACE                      pOsInterface;
    MhwMiInterface                      *pMiInterface;
    uint32_t                            HcpDecPhase;
    uint32_t                            curPipeInUse = 0;
    MOS_STATUS                          eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetMiInterface());
    CODECHAL_DECODE_CHK_NULL(pCmdBufferInUse);

    pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
    pMiInterface = pScalabilityState->pHwInterface->GetMiInterface();
    HcpDecPhase = pScalabilityStateBase->HcpDecPhase;

    //FE& BE0 Sync. to refine (ucNumVdbox > )for GT3
    if (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0 && pScalabilityState->pHwInterface->GetMfxInterface()->GetNumVdbox() > 2)
    {
        if (pScalabilityState->bFESeparateSubmission)
        {
            MOS_SYNC_PARAMS SyncParams;

            SyncParams = g_cInitSyncParams;
            SyncParams.GpuContext = pScalabilityState->VideoContext;
            SyncParams.presSyncResource = &pScalabilityState->resFeBeSyncObject;

            CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnEngineWait(pOsInterface, &SyncParams));
        }
        else
        {
            CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(&pScalabilityState->resSemaMemFEBE, 1, MHW_MI_SAD_EQUAL_SDD, pCmdBufferInUse));
            //reset semaphore. mi atomic decrease 1
            CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemFEBE, 1, MHW_MI_ATOMIC_DEC, pCmdBufferInUse));
        }
    }

    if (CodecHalDecodeScalabilityIsBEPhaseG12(pScalabilityState) ||
        CodecHalDecodeScalabilityIsFirstRealTilePhase(pScalabilityState))
    {
        // Stop Watchdog before BEs wait
        pMiInterface->AddWatchdogTimerStopCmd(pCmdBufferInUse);

        //HW Semaphore for BEs Starting at the same time
        CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEs, 1, MHW_MI_ATOMIC_INC, pCmdBufferInUse));
        uint8_t u8PipeNum = pScalabilityState->ucScalablePipeNum;

        if (phasedSubmission && pScalabilityState->bIsRtMode)
        {
            if (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1)
            {
                u8PipeNum = pScalabilityState->u8RtPipeInLastPhase;
            }
        }

        CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(
            &pScalabilityState->resSemaMemBEs,
            u8PipeNum,
            MHW_MI_SAD_EQUAL_SDD,
            pCmdBufferInUse));

        //add additional BEs Sync for two pipes
        if (u8PipeNum == 2 && !phasedSubmission)
        {
            if (pScalabilityState->bIsRtMode)
            {
                curPipeInUse = pScalabilityState->u8RtCurPipe;
            }
            else
            {
                curPipeInUse = HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0 ? 0 : 1;
            }
            //pipe 0: resSemaMemBEsAdditional[0] + 1, pipe 1: resSemaMemBEsAdditional[1] + 1
            CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEsAdditional[curPipeInUse],
                1,
                MHW_MI_ATOMIC_INC,
                pCmdBufferInUse));
        }

        // Program some placeholder cmds to resolve the hazard between BEs sync
        MHW_MI_STORE_DATA_PARAMS dataParams;
        dataParams.pOsResource = &pScalabilityState->resDelayMinus;
        dataParams.dwResourceOffset = 0;
        dataParams.dwValue = 0xDE1A;
        for (uint32_t i = 0; i < pScalabilityState->numDelay; i++)
        {
            CODECHAL_DECODE_CHK_STATUS_RETURN(pScalabilityState->pHwInterface->GetMiInterface()->AddMiStoreDataImmCmd(
                pCmdBufferInUse,
                &dataParams));
        }
        //additional Semaphore Wait: pipe 0 wait resSemaMemBEsAdditional[1] == 1, pipe 1 wait resSemaMemBEsAdditional[0] == 1
        if (u8PipeNum == 2 && !phasedSubmission)
        {
            CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(
                &pScalabilityState->resSemaMemBEsAdditional[CODECHAL_SCALABILITY_MAX_PIPE_INDEX_OF_TWO_PIPE - curPipeInUse],
                1,
                MHW_MI_SAD_EQUAL_SDD,
                pCmdBufferInUse));
        }
        //reset HW semaphore
        CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEs, 1, MHW_MI_ATOMIC_DEC, pCmdBufferInUse));
        //pipe 0 reset resSemaMemBEsAdditional[1], pipe 1 reset resSemaMemBEsAdditional[0]
        if (u8PipeNum == 2 && !phasedSubmission)
        {
            CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(
                &pScalabilityState->resSemaMemBEsAdditional[CODECHAL_SCALABILITY_MAX_PIPE_INDEX_OF_TWO_PIPE - curPipeInUse],
                1,
                MHW_MI_ATOMIC_DEC,
                pCmdBufferInUse));
        }

        if (!pScalabilityState->bIsRtMode)
        {
            if (pScalabilityState->bIsEnableEndCurrentBatchBuffLevel)
            {
                // Enhanced Condidtional BB END for streamout buffer writing over allocated size
                CODECHAL_DECODE_CHK_STATUS(static_cast<CodechalHwInterfaceG12*>(pScalabilityState->pHwInterface)->SendCondBbEndCmd(
                    &pScalabilityState->resFEStatusBuffer,
                    CODECHAL_OFFSETOF(CODECHAL_DECODE_SCALABILITY_FE_CABAC_STREAMOUT_BUFF_SIZE, dwCabacStreamoutBuffSize),
                    pScalabilityState->dwCABACSyntaxStreamOutBufferSize,
                    true,
                    pScalabilityState->bIsEnableEndCurrentBatchBuffLevel,
                    mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADLESSTHANIDD,
                    pCmdBufferInUse));
                CODECHAL_DECODE_NORMALMESSAGE("pScalabilityState->bIsEnableEndCurrentBatchBuffLevel: %s\n", "true");
            }
            else
            {
                // Condidtional BB END for streamout buffer writing over allocated size
                CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendCondBbEndCmd(
                    &pScalabilityState->resFEStatusBuffer,
                    CODECHAL_OFFSETOF(CODECHAL_DECODE_SCALABILITY_FE_STATUS, dwCarryFlagOfReportedSizeMinusAllocSize),
                    0,
                    true,
                    pCmdBufferInUse));
            }
        }
    }

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_ReadCSEngineIDReg_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
    CodechalDecodeStatusBuffer        *pDecodeStatusBuf,
    PMOS_COMMAND_BUFFER                pCmdBufferInUse)
{
    MHW_MI_STORE_REGISTER_MEM_PARAMS  StoreRegParams;
    MhwMiInterface                    *pMiInterface;
    MhwVdboxMfxInterface              *vdboxMfxInterface;
    MmioRegistersHcp                  *pMmioRegisters;
    uint8_t                           ucPhaseIndex;
    uint8_t                           hcpDecMaxPhaseNum;
    uint32_t                          dwOffset, dwCurrIndex, dwPreIndex;
    MOS_STATUS                        eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pDecodeStatusBuf);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
    CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetMiInterface());

    pMiInterface = pScalabilityStateBase->pHwInterface->GetMiInterface();
    pMmioRegisters = pScalabilityStateBase->pHwInterface->GetHcpInterface()->GetMmioRegisters(MHW_VDBOX_NODE_1); //relative mmio addressing.

    vdboxMfxInterface = pScalabilityStateBase->pHwInterface->GetMfxInterface();
    CODECHAL_DECODE_CHK_NULL(vdboxMfxInterface);
    hcpDecMaxPhaseNum = vdboxMfxInterface->GetNumVdbox();

    if (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
    {
        ucPhaseIndex = pScalabilityState->u8RtCurPipe;
        dwCurrIndex = pDecodeStatusBuf->m_currIndex;
    }
    else
    {
        ucPhaseIndex = (pScalabilityState->HcpDecPhase < CODECHAL_HCP_DECODE_PHASE_FE) ?
            0 : (pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE);

        if (ucPhaseIndex > hcpDecMaxPhaseNum)
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            CODECHAL_DECODE_ASSERTMESSAGE("Invalid HCP decode phase!");
            goto finish;
        }

        if (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState) &&
            pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0)
        {
            if (pDecodeStatusBuf->m_currIndex == 0)
            {
                dwPreIndex = CODECHAL_DECODE_STATUS_NUM - 1;
            }
            else
            {
                dwPreIndex = pDecodeStatusBuf->m_currIndex - 1;
            }
        }

        dwCurrIndex = (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState) &&
            pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0) ?
            dwPreIndex : pDecodeStatusBuf->m_currIndex;
    }

    dwOffset = (dwCurrIndex * sizeof(CodechalDecodeStatus)) +
        pDecodeStatusBuf->m_csEngineIdOffset + sizeof(uint32_t)* ucPhaseIndex +
        sizeof(uint32_t) * 2;

    StoreRegParams.presStoreBuffer = &pDecodeStatusBuf->m_statusBuffer;
    StoreRegParams.dwOffset = dwOffset;
    StoreRegParams.dwRegister = pMmioRegisters->csEngineIdOffset;
    CODECHAL_DECODE_CHK_STATUS(pMiInterface->AddMiStoreRegisterMemCmd(pCmdBufferInUse, &StoreRegParams));

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_InitializeState_G12(
    CodechalDecode                     *pDecoder,
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    CodechalHwInterface                *hwInterface,
    bool                                bShortFormat,
    CodechalSetting                    *settings)
{
    PMOS_VIRTUALENGINE_INTERFACE   pVEInterface;
    MOS_VIRTUALENGINE_INIT_PARAMS  VEInitParms;
    MOS_USER_FEATURE_VALUE_DATA    UserFeatureData;
    PMOS_INTERFACE                 osInterface;
    MhwVdboxMfxInterface           *vdboxMfxInterface;
    uint8_t                        vdboxNum;
    MOS_STATUS                     eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL(pDecoder);
    CODECHAL_DECODE_CHK_NULL(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL(hwInterface);
    osInterface = hwInterface->GetOsInterface();
    CODECHAL_DECODE_CHK_NULL(osInterface);

    vdboxMfxInterface = hwInterface->GetMfxInterface();
    CODECHAL_DECODE_CHK_NULL(vdboxMfxInterface);
    vdboxNum = vdboxMfxInterface->GetNumVdbox();

    if (vdboxNum < 2
#if (_DEBUG || _RELEASE_INTERNAL)
        || !osInterface->bHcpDecScalabilityMode
#endif
        )
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("not support scalability on this platform.");
        goto finish;
    }

    pScalabilityState->VideoContextForSP = MOS_GPU_CONTEXT_VIDEO;
    pScalabilityState->VideoContextForMP = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;
    pScalabilityState->VideoContextFor3P = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;

    pScalabilityState->numDelay = 15;

#if (_DEBUG || _RELEASE_INTERNAL)
    // Reg key of the threshold for mode switch single pipe <-> 2 pipe. Using pic width value to control mode switch for now
    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD1_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->dwHcpDecModeSwtichTh1Width = UserFeatureData.u32Data;

    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD2_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->dwHcpDecModeSwtichTh2Width = UserFeatureData.u32Data;

    // Reg key to control hevc real tile decoding
    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_DISABLE_HEVC_REALTILE_DECODE_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->bDisableRtMode = (UserFeatureData.u32Data != 0);

    // Reg key to control hevc real tile multi-phase decoding
    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_ENABLE_HEVC_REALTILE_MULTI_PHASE_DECODE_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->bEnableRtMultiPhase = (UserFeatureData.u32Data != 0);

    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_SCALABILITY_OVERRIDE_SPLIT_WIDTH_IN_MINCB,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->dbgOvrdWidthInMinCb = UserFeatureData.u32Data;

    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_USER_PIPE_NUM_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->dbgOverUserPipeNum = (uint8_t)UserFeatureData.u32Data;
#endif

    // enable FE separate submission by default in multi-pipe mode
    if((vdboxNum > 2) && osInterface->phasedSubmission)
    {
        pScalabilityState->bFESeparateSubmission = true;
    }
    else if ((vdboxNum > 2)
#if (_DEBUG || _RELEASE_INTERNAL)
        && (((pScalabilityState->dbgOverUserPipeNum >= 3)
        && (pScalabilityState->dbgOverUserPipeNum <= vdboxNum)))
#endif
        )
    {
        pScalabilityState->bFESeparateSubmission = true;
    }
    else
    {
        pScalabilityState->bFESeparateSubmission = false;
    }

#if (_DEBUG || _RELEASE_INTERNAL)
    if (osInterface->bEnableDbgOvrdInVE)
    {
        //if DbgOverride is enabled, FE separate submission is not supported
        pScalabilityState->bFESeparateSubmission = false;
    }
#endif

    pScalabilityState->bFESeparateSubmissionVT = pScalabilityState->bFESeparateSubmission;

    if (pScalabilityState->bFESeparateSubmission)
    {
        MOS_GPU_CONTEXT         GpuContext = MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO : MOS_GPU_CONTEXT_VIDEO4;
        GpuContext                         = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO4 : GpuContext;

        MOS_GPUCTX_CREATOPTIONS_ENHANCED createOpts;
        createOpts.UsingSFC = settings->sfcInUseHinted && settings->downsamplingHinted
                              && (MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrSFCPipe)
                              && !MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrDisableVDBox2SFC));
        CODECHAL_DECODE_CHK_STATUS(osInterface->pfnCreateGpuContext(
              osInterface,
              GpuContext,
              MOS_GPU_NODE_VIDEO,
              &createOpts));

        pScalabilityState->VideoContextForFE = GpuContext;
    }

    pScalabilityState->Standard = pDecoder->GetStandard();
    pScalabilityState->VideoContext = pDecoder->GetVideoContext();
    pScalabilityState->bShortFormatInUse = bShortFormat;
    pScalabilityState->ucNumVdbox = vdboxNum;
    pScalabilityState->pHwInterface = hwInterface;

    //virtual engine init with scalability
    MOS_ZeroMemory(&VEInitParms, sizeof(VEInitParms));
    VEInitParms.bScalabilitySupported = true;
    VEInitParms.bFESeparateSubmit = pScalabilityState->bFESeparateSubmission;
    VEInitParms.ucMaxNumPipesInUse = CodecHalDecodeMaxNumPipesInUseG12(vdboxNum);
    VEInitParms.ucNumOfSdryCmdBufSets = CODECHAL_SCALABILITY_DECODE_SECONDARY_CMDBUFSET_NUM;
    VEInitParms.ucMaxNumOfSdryCmdBufInOneFrame = pScalabilityState->bFESeparateSubmission ? VEInitParms.ucMaxNumPipesInUse : (VEInitParms.ucMaxNumPipesInUse + 1);
    CODECHAL_DECODE_CHK_STATUS(Mos_VirtualEngineInterface_Initialize(osInterface, &VEInitParms));
    pScalabilityState->pVEInterface = pVEInterface = osInterface->pVEInterf;

    if (pVEInterface->pfnVEGetHintParams)
    {
        CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVEGetHintParams(pVEInterface, true, &pScalabilityState->pScalHintParms));
    }
    if (pVEInterface->pfnVEGetHintParams)
    {
        CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVEGetHintParams(pVEInterface, false, &pScalabilityState->pSingleHintParms));
    }

#if (_DEBUG || _RELEASE_INTERNAL)
    MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
    MOS_UserFeature_ReadValue_ID(
        nullptr,
        __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_ALWAYS_FRAME_SPLIT_ID,
        &UserFeatureData,
        osInterface->pOsContext);
    pScalabilityState->bAlwaysFrameSplit = UserFeatureData.u32Data ? true : false;
#endif

    pScalabilityState->bIsEvenSplit = true;

    pScalabilityState->bIsEnableEndCurrentBatchBuffLevel = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrConditionalBatchBuffEnd);

    if (pDecoder->GetStandard() == CODECHAL_HEVC)
    {
        pScalabilityState->pfnGetHcpBufferSize = GetHevcBufferSize;
        pScalabilityState->pfnIsHcpBufferReallocNeeded = IsHevcBufferReallocNeeded;
    }
    else if (pDecoder->GetStandard() == CODECHAL_VP9)
    {
        pScalabilityState->pfnGetHcpBufferSize = GetVp9BufferSize;
        pScalabilityState->pfnIsHcpBufferReallocNeeded = IsVp9BufferReallocNeeded;
    }
    else
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("unsupported decode format for scalability mode.");
        goto finish;
    }

    pScalabilityState->bToggleCABACStreamOutBuffer = false;
    pScalabilityState->pfnDecidePipeNum = CodecHalDecodeScalability_DecidePipeNum_G12;
    pScalabilityState->pfnMapPipeNumToLRCACount = CodechalDecodeScalability_MapPipeNumToLRCACount_G12;
#if (_DEBUG || _RELEASE_INTERNAL)
    pScalabilityState->pfnDebugOvrdDecidePipeNum = CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12;
#endif

    pScalabilityState->sliceStateCLs = CODECHAL_SCALABILITY_SLICE_STATE_CACHELINES_PER_SLICE_TGL;
    CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(pScalabilityState));

finish:
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_AdvanceRealTilePass(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase)
{
    auto eStatus = MOS_STATUS_SUCCESS;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityStateBase);
    CODECHAL_DECODE_ASSERT(pScalabilityState->bIsRtMode);
    CODECHAL_DECODE_ASSERT(pScalabilityState->u8RtCurPhase < pScalabilityState->u8RtPhaseNum);

    pScalabilityState->u8RtCurPipe++;
    if (pScalabilityState->u8RtCurPipe >= pScalabilityState->ucScalablePipeNum)
    {
        pScalabilityState->u8RtCurPipe = 0;
        pScalabilityState->u8RtCurPhase++;
    }

    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_GetCurrentRealTileColumnId(
    PCODECHAL_DECODE_SCALABILITY_STATE  pScalabilityStateBase,
    uint8_t                             &col)
{
    auto eStatus = MOS_STATUS_SUCCESS;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityStateBase);

    col = pScalabilityState->u8RtCurPipe + pScalabilityState->u8RtCurPhase * pScalabilityState->ucScalablePipeNum;
    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_SetSfcState(
    PCODECHAL_DECODE_SCALABILITY_STATE          scalabilityStateBase,
    void                                       *picParams,
    CodecRectangle                             *srcRegion,
    CodecRectangle                             *dstRegion,
    PCODECHAL_DECODE_SFC_SCALABILITY_PARAMS     sfcScalabilityParams)
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;
    uint32_t    minCbSize, maxCbSize, widthInPixel, widthInMaxCb;
    uint32_t    srcStartX = 0, srcEndX = 0;
    uint32_t    engMode, tileType;
    uint32_t    tileColumnIndex = 0;
    uint32_t    tileColumnCount = 0;
    bool        isInput444;
    uint32_t    ildbXOffset;
    uint64_t    oneBySf;
    double      xLandingPoint;
    uint32_t    srcEndXTemp;
    uint32_t    xOffset;
    uint32_t    tileEndX;
    uint32_t    dstStartX, dstEndX;

    PCODECHAL_DECODE_SCALABILITY_STATE_G12 scalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(scalabilityStateBase);

    CODECHAL_DECODE_CHK_NULL_RETURN(scalabilityStateBase);
    CODECHAL_DECODE_CHK_NULL_RETURN(sfcScalabilityParams);
    CODECHAL_DECODE_CHK_NULL_RETURN(srcRegion);
    CODECHAL_DECODE_CHK_NULL_RETURN(dstRegion);
    CODECHAL_DECODE_CHK_NULL_RETURN(picParams);

    if (!CodecHalDecodeScalabilityIsScalableMode(scalabilityState))
    {
        return MOS_STATUS_SUCCESS;
    }

    if (scalabilityState->Standard == CODECHAL_HEVC)
    {
        PCODEC_HEVC_PIC_PARAMS  hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;

        minCbSize = 1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
        maxCbSize = (minCbSize << hevcPicParams->log2_diff_max_min_luma_coding_block_size);
        widthInPixel = hevcPicParams->PicWidthInMinCbsY * minCbSize;
        widthInMaxCb = MOS_ROUNDUP_DIVIDE(widthInPixel, maxCbSize);
        isInput444 = (hevcPicParams->chroma_format_idc == HCP_CHROMA_FORMAT_YUV444);
    }
    else if (scalabilityState->Standard == CODECHAL_VP9)
    {
        PCODEC_VP9_PIC_PARAMS vp9PicParams = (PCODEC_VP9_PIC_PARAMS)picParams;

        minCbSize = CODEC_VP9_MIN_BLOCK_WIDTH;
        maxCbSize = CODEC_VP9_SUPER_BLOCK_WIDTH;
        widthInPixel = vp9PicParams->FrameWidthMinus1 + 1;
        widthInMaxCb = MOS_ROUNDUP_DIVIDE(widthInPixel, maxCbSize);
        isInput444 = (vp9PicParams->subsampling_x == 0 && vp9PicParams->subsampling_y == 0);
    }
    else
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        CODECHAL_DECODE_ASSERTMESSAGE("invalid codec type, only HEVC/VP9 are supported in scalability mode.");
        return eStatus;
    }

    if (scalabilityState->bIsRtMode)
    {
        PCODEC_HEVC_PIC_PARAMS  hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
        uint8_t col = scalabilityState->u8RtCurPipe + scalabilityState->u8RtCurPhase * scalabilityState->ucScalablePipeNum;

        if (scalabilityState->u8RtCurPipe == 0)
        {
            engMode = 1;
        }
        else if (scalabilityState->u8RtCurPipe == scalabilityState->ucScalablePipeNum - 1)
        {
            engMode = 2;
        }
        else
        {
            engMode = 3;
        }

        if (hevcPicParams->uniform_spacing_flag == 1)
        {
            srcStartX = (col * widthInMaxCb) / (hevcPicParams->num_tile_columns_minus1 + 1) * maxCbSize;
            srcEndX = ((col + 1) * widthInMaxCb) / (hevcPicParams->num_tile_columns_minus1 + 1) * maxCbSize - 1;
        }
        else
        {
            for (uint8_t i = 0; i < col; i++)
            {
                srcStartX += (hevcPicParams->column_width_minus1[i] + 1) * maxCbSize;
            }
            if (col == hevcPicParams->num_tile_columns_minus1)
            {
                srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
            }
            else
            {
                srcEndX = srcStartX + (hevcPicParams->column_width_minus1[col] + 1) * maxCbSize - 1;
            }
        }

        tileType = 0;
        tileColumnIndex = col;
        tileColumnCount = hevcPicParams->num_tile_columns_minus1 + 1;
    }
    else if (CodecHalDecodeScalabilityIsBEPhaseG12(scalabilityState))
    {
        uint8_t pipeIndex = scalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE0;

        if (pipeIndex == 0)
        {
            engMode = 1;
        }
        else if (pipeIndex == scalabilityState->ucScalablePipeNum - 1)
        {
            engMode = 2;
        }
        else
        {
            engMode = 3;
        }

        srcStartX = pipeIndex * widthInMaxCb / scalabilityState->ucScalablePipeNum;
        srcStartX *= maxCbSize;
        if (pipeIndex == scalabilityState->ucScalablePipeNum - 1)
        {
            srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
        }
        else
        {
            srcEndX = (pipeIndex + 1) * widthInMaxCb / scalabilityState->ucScalablePipeNum;
            srcEndX = srcEndX * maxCbSize - 1;
        }
#if (_DEBUG || _RELEASE_INTERNAL)
        if (scalabilityState->dbgOvrdWidthInMinCb && scalabilityState->ucScalablePipeNum == 2)
        {
            if (pipeIndex == 1)
            {
                srcStartX = scalabilityState->dbgOvrdWidthInMinCb * minCbSize;
                srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
            }
            else
            {
                srcStartX = 0;
                srcEndX = scalabilityState->dbgOvrdWidthInMinCb * minCbSize - 1;
            }
        }
#endif

        tileType = 1;
        tileColumnIndex = pipeIndex;
        tileColumnCount = scalabilityState->ucScalablePipeNum;
    }
    else
    {
        engMode = 0;
        tileType = 0;
        srcStartX = 0;
        srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
    }

    // Clamp srcStartX, srcEndX into source region
    if (srcStartX < srcRegion->m_x)
        srcStartX = srcRegion->m_x;
    if (srcEndX > srcRegion->m_x + srcRegion->m_width - 1)
        srcEndX = srcRegion->m_x + srcRegion->m_width - 1;

    if (tileColumnIndex == 0)
    {
        scalabilityState->fistValidTileIndex = 0;
        scalabilityState->lastValidTileIndex = tileColumnCount - 1;
        scalabilityState->dstXLandingCount = 0;
    }

    ildbXOffset = (scalabilityState->Standard == CODECHAL_HEVC) ? 5 : 8;  // 1 : HEVC; 0 : VP9
    oneBySf = (uint64_t)((double)((uint64_t)(srcRegion->m_width) * 524288 / (dstRegion->m_width)));

    //------------------ start ildb offset correction -----------------------------//
    srcEndXTemp = srcEndX - ildbXOffset;

    //---------------------- destination startX determination logic ---------------//
    if ((srcRegion->m_x + srcRegion->m_width - 1) <= srcEndXTemp)
    {
        xOffset = 0;
        tileEndX = (srcRegion->m_x + srcRegion->m_width);
    }
    else
    {
        xOffset = isInput444 ? 3 : (scalabilityState->Standard == CODECHAL_HEVC) ? 8 : 11;
        tileEndX = srcEndXTemp;
    }

    while (true)
    {
        if (srcEndXTemp - srcRegion->m_x < (xOffset + 1))
        {
            dstEndX = 0;
            break;
        }
        if (scalabilityState->dstXLandingCount == 0)
        {
            scalabilityState->fistValidTileIndex = tileColumnIndex;
        }

        // xLandingpoint = (float)(((max(0, (((float)dest_cntX * (float)one_by_sf) + Xphaseshift)) + ((float)1 << (one_by sf_fraction_precision - beta_precision - 1))) / 524288) + SourceRegionHorizontalOffset)
        //
        {
            const uint32_t one_by_sf_fraction_precision = 19;
            const uint32_t beta_precision = 5;
            uint32_t xPhaseShift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)srcRegion->m_width / dstRegion->m_width - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1));

            double tempDestCntx = (((double)scalabilityState->dstXLandingCount * (double)oneBySf) + xPhaseShift);
            if (tempDestCntx < 0)
            {
                tempDestCntx = 0;
            }
            xLandingPoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288) + srcRegion->m_x);
        }

        if (xLandingPoint >= (double)(tileEndX - xOffset))
        {
            dstEndX = scalabilityState->dstXLandingCount - 1;
            break;
        }
        else
        {
            scalabilityState->dstXLandingCount++;
        }
    }

    if (xOffset == 0)
    {
        scalabilityState->lastValidTileIndex = tileColumnIndex;
    }

    // Last column end at destination region right border.
    if (tileColumnIndex == scalabilityState->lastValidTileIndex)
    {
        dstEndX = dstRegion->m_x + dstRegion->m_width - 1;
    }

    if (tileColumnIndex <= scalabilityState->fistValidTileIndex)
        dstStartX = 0;
    else if (tileColumnIndex <= scalabilityState->lastValidTileIndex)
    {
        dstStartX = scalabilityState->lastDstEndX + 1;
    }
    else
    {
        dstStartX = 0;
        dstEndX = 0;
    }
    scalabilityState->lastDstEndX = dstEndX;

    sfcScalabilityParams->engineMode = engMode;
    sfcScalabilityParams->tileType = tileType;
    sfcScalabilityParams->srcStartX = srcStartX;
    sfcScalabilityParams->srcEndX = srcEndX;
    sfcScalabilityParams->dstStartX = dstStartX;
    sfcScalabilityParams->dstEndX = dstEndX;

    return eStatus;
}

bool CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)
{
    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);

    if (pScalabilityState == nullptr)
    {
        return false;
    }
    else
    {
        return (CodecHalDecodeScalabilityIsFinalBEPhaseG12(pScalabilityState) ||
            (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE && pScalabilityState->bFESeparateSubmission) ||
            CodecHalDecodeScalabilityIsLastRealTilePass(pScalabilityState));
    }
}

MOS_STATUS CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE   pScalabilityState,
    PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS    pHcpBufSizeParam,
    PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam)
{
    MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
    PMOS_INTERFACE          pOsInterface;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
    CODECHAL_DECODE_CHK_NULL_RETURN(pHcpBufSizeParam);
    CODECHAL_DECODE_CHK_NULL_RETURN(pAllocParam);

    CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_VariableSizes(pScalabilityState, pHcpBufSizeParam, pAllocParam));

    // for multi-pipe scalability mode
    if (pScalabilityState->ucNumVdbox > 2)
    {
        if (pScalabilityState->bFESeparateSubmission)
        {
            for (int i = 1; i < CODECHAL_HCP_STREAMOUT_BUFFER_MAX_NUM; i++)
            {
                CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateCABACStreamOutBuffer(pScalabilityState,
                    pHcpBufSizeParam,
                    pAllocParam,
                    &pScalabilityState->resCABACSyntaxStreamOutBuffer[i]));
            }

            pScalabilityState->presCABACStreamOutBuffer =
                pScalabilityState->bToggleCABACStreamOutBuffer ? &pScalabilityState->resCABACSyntaxStreamOutBuffer[1] : &pScalabilityState->resCABACSyntaxStreamOutBuffer[0];

            pScalabilityState->bToggleCABACStreamOutBuffer = !pScalabilityState->bToggleCABACStreamOutBuffer;
        }
    }

    return eStatus;
}

MOS_STATUS CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
{
    PMOS_INTERFACE          pOsInterface;
    MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
    MOS_LOCK_PARAMS         LockFlagsWriteOnly;
    uint8_t *               pData = nullptr;
    MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());

    pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();

    MOS_ZeroMemory(&LockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
    LockFlagsWriteOnly.WriteOnly = 1;

    // initiate allocation paramters
    MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
    AllocParamsForBufferLinear.Type     = MOS_GFXRES_BUFFER;
    AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
    AllocParamsForBufferLinear.Format   = Format_Buffer;

    CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_FixedSizes(pScalabilityState));

    //Allocate additional BEs Semaphore memory for two pipes to avoid race condition
    if (!pOsInterface->phasedSubmission)
    {
        AllocParamsForBufferLinear.pBufName = "AdditionalBESemaphoreMemory";
        AllocParamsForBufferLinear.dwBytes  = sizeof(uint32_t);
        for (uint32_t i = 0; i < 2; i++)
        {
            eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
                pOsInterface,
                &AllocParamsForBufferLinear,
                &pScalabilityState->resSemaMemBEsAdditional[i]);

            if (eStatus != MOS_STATUS_SUCCESS)
            {
                CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate Additional BE Semaphore memory.");
                return eStatus;
            }

            pData = (uint8_t *)pOsInterface->pfnLockResource(
                pOsInterface,
                &pScalabilityState->resSemaMemBEsAdditional[i],
                &LockFlagsWriteOnly);

            CODECHAL_DECODE_CHK_NULL_RETURN(pData);

            MOS_ZeroMemory(pData, sizeof(uint32_t));

            CODECHAL_DECODE_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
                pOsInterface,
                &pScalabilityState->resSemaMemBEsAdditional[i]));
        }
    }

    return eStatus;
}

void CodecHalDecodeScalability_Destroy_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
{
    PMOS_INTERFACE pOsInterface;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState);
    CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
    pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();

    CodecHalDecodeScalability_Destroy(pScalabilityState);

    for (int i = 0; i < 2; i++)
    {
        pOsInterface->pfnFreeResource(
            pOsInterface,
            &pScalabilityState->resSemaMemBEsAdditional[i]);
    }

    return;
}

MOS_STATUS CodecHalDecodeScalability_DecidePipeNum_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE         pScalState,
    PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS   pInitParams)
{
    PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
    MOS_STATUS                   eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);
    CODECHAL_DECODE_CHK_NULL_RETURN(pInitParams);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface->GetOsInterface());

    pVEInterface                                                     = pScalState->pVEInterface;
    pScalState->ucScalablePipeNum                                    = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
    PCODECHAL_DECODE_SCALABILITY_STATE_G12       pScalStateG12        = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState);
    PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 pInitParamsG12       = static_cast<PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12>(pInitParams);
    uint8_t                                      u8MaxTileColumn      = HEVC_NUM_MAX_TILE_COLUMN;
    bool                                         bCanEnableRealTile   = true;
    bool                                         bCanEnableScalability = !pScalState->pHwInterface->IsDisableScalability();
    PMOS_INTERFACE pOsInterface                                        = pScalState->pHwInterface->GetOsInterface();

#if (_DEBUG || _RELEASE_INTERNAL)
    bCanEnableRealTile = !(static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bDisableRtMode;
    if (!pScalStateG12->bEnableRtMultiPhase)
        u8MaxTileColumn = 2;
    if(!bCanEnableScalability
        && pOsInterface
        && (pOsInterface->bHcpDecScalabilityMode == MOS_SCALABILITY_ENABLE_MODE_USER_FORCE))
    {
        bCanEnableScalability = true;
    }
#endif
    bCanEnableRealTile = bCanEnableRealTile && pInitParamsG12->bIsTileEnabled && (pInitParams->u8NumTileColumns > 1) &&
                         (pInitParams->u8NumTileColumns <= u8MaxTileColumn) && (pInitParams->u8NumTileRows <= HEVC_NUM_MAX_TILE_ROW) &&
                         pInitParamsG12->bHasSubsetParams;

    if (pInitParams->usingSFC || !bCanEnableScalability)
    {
        return MOS_STATUS_SUCCESS;
    }

#if (_DEBUG || _RELEASE_INTERNAL)
    if (pScalState->bAlwaysFrameSplit)
    {
        if (pScalState->ucNumVdbox != 1)
        {
            if (pScalState->ucNumVdbox == 2)
            {
                pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
            }
            else
            {
                uint8_t dbgOverUserPipeNum    = pScalStateG12->dbgOverUserPipeNum;
                pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
                if ((dbgOverUserPipeNum >= CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2) && (dbgOverUserPipeNum <= pScalState->ucNumVdbox))
                {
                    pScalState->ucScalablePipeNum = dbgOverUserPipeNum;
                }
            }
        }
    }
    else
#endif
    {
        if (pScalState->ucNumVdbox != 1)
        {
            if (pScalState->ucNumVdbox == 2)
            {
                if (pScalState->dwHcpDecModeSwtichTh1Width != 0)
                {
                    if (pInitParams->u32PicWidthInPixel >= pScalState->dwHcpDecModeSwtichTh1Width)
                    {
                        pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
                    }
                }
                else if ((!pInitParams->usingHistogram) && ((!CodechalDecodeNonRextFormat(pInitParams->format)
                                    && CodechalDecodeResolutionEqualLargerThan4k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
                                || (CodechalDecodeNonRextFormat(pInitParams->format)
                                    && CodechalDecodeResolutionEqualLargerThan5k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
                                || (bCanEnableRealTile && (!pOsInterface->osCpInterface->IsCpEnabled() || pOsInterface->bCanEnableSecureRt))))
                {
                    pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
                }

                if (pScalState->bIsEvenSplit == false)
                {
                    // disable scalability for clips with width less than split condition when MMC is on
                    if (pInitParams->u32PicWidthInPixel <= CODEC_SCALABILITY_FIRST_TILE_WIDTH_4K)
                    {
                        pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
                    }
                }
            }
            else
            {
                pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
            }
        }
    }

    return eStatus;
}


MOS_STATUS CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(
    PCODECHAL_DECODE_SCALABILITY_STATE         pScalState,
    PMOS_GPUCTX_CREATOPTIONS_ENHANCED          gpuCtxCreatOpts,
    CodechalSetting *                          codecHalSetting)
{
    PMOS_INTERFACE                           pOsInterface;
    CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12  initParams;
    MOS_STATUS                               eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
    CODECHAL_DECODE_CHK_NULL_RETURN(gpuCtxCreatOpts);
    CODECHAL_DECODE_CHK_NULL_RETURN(codecHalSetting);
    bool sfcInUse = codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
                       && (MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrSFCPipe)
                       && !MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrDisableVDBox2SFC));
    pOsInterface    = pScalState->pHwInterface->GetOsInterface();
    MEDIA_FEATURE_TABLE *m_skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
#if (_DEBUG || _RELEASE_INTERNAL)
    if (pOsInterface->bEnableDbgOvrdInVE)
    {
        PMOS_VIRTUALENGINE_INTERFACE pVEInterface = pScalState->pVEInterface;
        CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface);
        gpuCtxCreatOpts->DebugOverride      = true;
        if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
        {
            gpuCtxCreatOpts->UsingSFC = false;// this param ignored when dbgoverride enabled
        }
        else
        {
            gpuCtxCreatOpts->UsingSFC = sfcInUse;  // this param ignored when dbgoverride enabled
        }
        CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDebugOvrdDecidePipeNum(pScalState));

        if (pOsInterface->apoMosEnabled)
        {
            CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
            for (uint32_t i = 0; i < pVEInterface->veInterface->GetEngineCount(); i++)
            {
                gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->veInterface->GetEngineLogicId(i);
            }
        }
        else
        {
            for (uint32_t i = 0; i < pVEInterface->ucEngineCount; i++)
            {
                gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->EngineLogicId[i];
            }
        }
    }
    else
#endif
    {
        if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
        {
            gpuCtxCreatOpts->UsingSFC = false;
        }
        else
        {
            gpuCtxCreatOpts->UsingSFC = sfcInUse;
        }

        MOS_ZeroMemory(&initParams, sizeof(initParams));
        initParams.u32PicWidthInPixel   = MOS_ALIGN_CEIL(codecHalSetting->width, 8);
        initParams.u32PicHeightInPixel  = MOS_ALIGN_CEIL(codecHalSetting->height, 8);
        if (((codecHalSetting->standard == CODECHAL_VP9) || (codecHalSetting->standard == CODECHAL_HEVC))
                && (codecHalSetting->chromaFormat == HCP_CHROMA_FORMAT_YUV420))
        {
            initParams.format = Format_NV12;
            if (codecHalSetting->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_10_BITS)
            {
                initParams.format = Format_P010;
            }
        }
        initParams.usingSFC             = sfcInUse;
        initParams.usingSecureDecode    = codecHalSetting->secureMode;
        CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDecidePipeNum(
            pScalState,
            &initParams));
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnMapPipeNumToLRCACount(
        pScalState,
        &gpuCtxCreatOpts->LRCACount));

    return eStatus;
}


MOS_STATUS CodechalDecodeScalability_MapPipeNumToLRCACount_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE   pScalState,
    uint32_t                             *LRCACount)
{
    MOS_STATUS    eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
    CODECHAL_DECODE_CHK_NULL_RETURN(LRCACount);

    *LRCACount = 1; // initialzed to 1.

    switch (pScalState->ucScalablePipeNum)
    {
    case CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2:
        // on GT2 or debug override enabled, FE separate submission = false, FE run on the same engine of BEs;
        // on GT3, FE separate submission = true, scalability submission includes only BEs.
        *LRCACount = 2;
        break;
    case CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1:
        *LRCACount = 1;
        break;
    default:
        // in release driver bFESeparateSubmission is always false since this is on GT3 or GT4.
        // bFESeparateSubmission could be false if debug override enabled.
        if (pScalState->bFESeparateSubmission || (static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bIsRtMode)
        {
            *LRCACount = pScalState->ucScalablePipeNum;
        }
        else
        {
            *LRCACount = pScalState->ucScalablePipeNum + 1;
        }
    }

    if (*LRCACount > pScalState->ucNumVdbox)
    {
        CODECHAL_DECODE_ASSERTMESSAGE("LRCA count can not exceed vdbox number.");
        return MOS_STATUS_INVALID_PARAMETER;
    }

    return eStatus;
}

#if (_DEBUG || _RELEASE_INTERNAL)
MOS_STATUS CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE         pScalState)
{
    PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
    MOS_STATUS                   eStatus        = MOS_STATUS_SUCCESS;
    PMOS_INTERFACE               pOsInterface   = nullptr;
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
    CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);

    pVEInterface = pScalState->pVEInterface;
    pOsInterface = pVEInterface->pOsInterface;
    CODECHAL_DECODE_CHK_NULL_RETURN(pOsInterface);

    if (pOsInterface->apoMosEnabled)
    {
        CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
        auto veInterface = pVEInterface->veInterface;
        if (veInterface->GetEngineCount() > pScalState->ucNumVdbox)
        {
            CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
            return MOS_STATUS_INVALID_PARAMETER;
        }
        else if (veInterface->GetEngineCount() == 1)
        {
            pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
        }
        else if (veInterface->GetEngineCount() == 2)
        {
            //engine count = 2, only support FE run on the same engine as one of BE for now.
            pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
        }
        else
        {
            bool bEngineLogicIdValid = false;
            for (uint8_t i = 0; i < veInterface->GetEngineCount() - 1; i++)
            {
                if (veInterface->GetEngineLogicId(veInterface->GetEngineCount() - 1) !=
                    veInterface->GetEngineLogicId(i))
                {
                    bEngineLogicIdValid = true;
                }
                else
                {
                    bEngineLogicIdValid = false;
                    break;
                }
            }
            if (bEngineLogicIdValid)
            {
                pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
            }
        }

        return eStatus;
    }

    // debug override for virtual tile
    if (pVEInterface->ucEngineCount > pScalState->ucNumVdbox)
    {
        CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
        return MOS_STATUS_INVALID_PARAMETER;
    }
    else if (pVEInterface->ucEngineCount == 1)
    {
        pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
    }
    else if (pVEInterface->ucEngineCount == 2)
    {
        //engine count = 2, only support FE run on the same engine as one of BE for now.
        pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
    }
    else
    {
        bool bEngineLogicIdValid = false;
        for (uint8_t i = 0; i < pVEInterface->ucEngineCount - 1; i++)
        {
            if (pVEInterface->EngineLogicId[pVEInterface->ucEngineCount - 1] != pVEInterface->EngineLogicId[i])
            {
                bEngineLogicIdValid = true;
            }
            else
            {
                bEngineLogicIdValid = false;
                break;
            }
        }
        if (bEngineLogicIdValid)
        {
            pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
        }
    }

    return eStatus;
}
#endif

void CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(
    PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState,
    PMOS_COMMAND_BUFFER pCmdBuffer)
{
    switch (pScalabilityState->HcpDecPhase)
    {
        case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
            //Note: no break here, S2L and FE commands put in one secondary command buffer.
        case CODECHAL_HCP_DECODE_PHASE_FE:
            pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
            break;
        case CODECHAL_HCP_DECODE_PHASE_BE0:
            pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
            break;
        case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
            if (pScalabilityState->u8RtCurPipe == 0)
            {
                pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
            }
            else
            {
                pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
                pCmdBuffer->iSubmissionType |= ((pScalabilityState->u8RtCurPipe - 1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
            }

            if (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1)
            {
                if (pScalabilityState->u8RtCurPipe == pScalabilityState->u8RtPipeInLastPhase - 1)
                {
                    pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
                }
            }
            else
            {
                if (pScalabilityState->u8RtCurPipe == pScalabilityState->ucScalablePipeNum-1)
                {
                    pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
                }
            }
            break;
        default:
            if((pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0) &&
                ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum))
            {
                pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
                pCmdBuffer->iSubmissionType |= ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
                if ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) == pScalabilityState->ucScalablePipeNum)
                {
                    pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
                }
            }
            else
            {
                pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
            }
    }
}