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

#include "codechal_encode_hevc_mbenc_g12.h"
#include "codechal_encode_hevc_brc_g12.h"
#include "codechal_encode_hevc_g12.h"
#include "mhw_vdbox_hcp_g12_X.h"
#include "Gen12_HEVC_B_LCU32.h"
#include "Gen12_HEVC_B_LCU64.h"
#include "cm_wrapper.h"

#include "Gen12_HEVC_BRC_INIT.h"
#include "Gen12_HEVC_BRC_RESET.h"
#include "Gen12_HEVC_BRC_UPDATE.h"
#include "Gen12_HEVC_BRC_LCUQP.h"

#include "codechal_debug.h"

#if USE_PROPRIETARY_CODE
#include "cm_device_rt.h"
#endif

#if MOS_MEDIASOLO_SUPPORTED
#include "mos_os_solo.h"
#endif // (_DEBUG || _RELEASE_INTERNAL)

MOS_STATUS CodecHalHevcBrcG12::AllocateBrcResources()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_ENCODE_FUNCTION_ENTER;

    return MOS_STATUS_SUCCESS;
}

MOS_STATUS CodecHalHevcBrcG12::FreeBrcResources()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_ENCODE_FUNCTION_ENTER;
    // Destroy the container for BRC buffers
    if (m_histBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_histBufferBrc));
        m_histBufferBrc = nullptr;
    }
    if (m_PAKStatsBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_PAKStatsBufferBrc));
        m_PAKStatsBufferBrc = nullptr;
    }
    if (m_PICStateInBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_PICStateInBufferBrc));
        m_PICStateInBufferBrc = nullptr;
    }
    if (m_PICStateOutBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_PICStateOutBufferBrc));
        m_PICStateOutBufferBrc = nullptr;
    }
    if (m_CombinedEncBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_CombinedEncBufferBrc));
        m_CombinedEncBufferBrc = nullptr;
    }
    if (m_PixelMBStatsBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_PixelMBStatsBufferBrc));
        m_PixelMBStatsBufferBrc = nullptr;
    }
    if (m_ConstDataBufferBRC)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_ConstDataBufferBRC));
        m_ConstDataBufferBRC = nullptr;
    }
    if (m_BrcMbQp)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_BrcMbQp));
        m_BrcMbQp = nullptr;
    }
    if (m_BrcROISurf)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroySurface(m_BrcROISurf));
        m_BrcROISurf = nullptr;
    }

    if (m_cmKrnBrcInit)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyKernel(m_cmKrnBrcInit));
        m_cmKrnBrcInit = nullptr;
    }
    if (m_cmProgramBrcInit)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyProgram(m_cmProgramBrcInit));
        m_cmProgramBrcInit = nullptr;
    }
    if (m_cmKrnBrcReset)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyKernel(m_cmKrnBrcReset));
        m_cmKrnBrcReset = nullptr;
    }
    if (m_cmProgramBrcReset)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyProgram(m_cmProgramBrcReset));
        m_cmProgramBrcReset = nullptr;
    }
    if (m_cmKrnBrcUpdate)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyKernel(m_cmKrnBrcUpdate));
        m_cmKrnBrcUpdate = nullptr;
    }
    if (m_cmProgramBrcUpdate)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyProgram(m_cmProgramBrcUpdate));
        m_cmProgramBrcUpdate = nullptr;
    }
    if (m_cmKrnBrcLCUQP)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyKernel(m_cmKrnBrcLCUQP));
        m_cmKrnBrcLCUQP = nullptr;
    }
    if (m_cmProgramBrcLCUQP)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyProgram(m_cmProgramBrcLCUQP));
        m_cmProgramBrcLCUQP = nullptr;
    }
    if (m_threadSpaceBrcInitReset)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyThreadSpace(m_threadSpaceBrcInitReset));
        m_threadSpaceBrcInitReset = nullptr;
    }
    if (m_threadSpaceBrcUpdate)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyThreadSpace(m_threadSpaceBrcUpdate));
        m_threadSpaceBrcUpdate = nullptr;
    }
    if (m_threadSpaceBrcLCUQP)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyThreadSpace(m_threadSpaceBrcLCUQP));
        m_threadSpaceBrcLCUQP = nullptr;
    }
    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::InitBrcKernelState()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_ENCODE_FUNCTION_ENTER;

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->LoadProgram((void *)HEVC_BRC_INIT_GENX,
        HEVC_BRC_INIT_GENX_SIZE,
        m_cmProgramBrcInit,
        "-nojitter"));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateKernel(m_cmProgramBrcInit,
        "HEVC_brc_init",
        m_cmKrnBrcInit));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->LoadProgram((void *)HEVC_BRC_RESET_GENX,
        HEVC_BRC_RESET_GENX_SIZE,
        m_cmProgramBrcReset,
        "-nojitter"));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateKernel(m_cmProgramBrcReset,
        "HEVC_brc_reset",
        m_cmKrnBrcReset));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->LoadProgram((void *)HEVC_BRC_UPDATE_GENX,
        HEVC_BRC_UPDATE_GENX_SIZE,
        m_cmProgramBrcUpdate,
        "-nojitter"));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateKernel(m_cmProgramBrcUpdate,
        "HEVC_brc_update",
        m_cmKrnBrcUpdate));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->LoadProgram((void *)HEVC_BRC_LCUQP_GENX,
        HEVC_BRC_LCUQP_GENX_SIZE,
        m_cmProgramBrcLCUQP,
        "-nojitter"));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateKernel(m_cmProgramBrcLCUQP,
        "HEVC_brc_lcuqp",
        m_cmKrnBrcLCUQP));

    return eStatus;
}
MOS_STATUS CodecHalHevcBrcG12::SetupKernelArgsBrcInit()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    //Setup surfaces

    int idx = 0;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrc->SetKernelArg(idx++, sizeof(encoderBrc->curbe), &encoderBrc->curbe));

    SurfaceIndex *pIndex0 = nullptr;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_histBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrc->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    //Setup Distortion 2D surface
    CmSurface2D *brcDistortion = (encoderBrc->m_pictureCodingType == I_TYPE) ? encoderBrc->m_brcBuffers.brcIntraDistortionSurface
                                                                             : encoderBrc->m_brcBuffers.meBrcDistortionSurface;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(brcDistortion->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrc->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupThreadSpace(CmKernel *cmKernel, CmThreadSpace *& threadSpace)
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_ENCODE_CHK_STATUS_RETURN(cmKernel->SetThreadCount(1));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateThreadSpace(1, 1, threadSpace));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(cmKernel->AssociateThreadSpace(threadSpace));
    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupBrcLcuqpThreadSpace(CmKernel *cmKernel, CmThreadSpace *& threadSpace)
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;
    uint32_t xThread = (encoderBrc->m_downscaledWidthInMb4x * SCALE_FACTOR_4x + 15) >> 4;
    uint32_t yThread = (encoderBrc->m_downscaledHeightInMb4x * SCALE_FACTOR_4x + 7) >> 3;

    CODECHAL_ENCODE_CHK_STATUS_RETURN(cmKernel->SetThreadCount(xThread * yThread));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateThreadSpace(xThread, yThread, threadSpace));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(cmKernel->AssociateThreadSpace(threadSpace));

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::InitCurbeDataBrcInit()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;
    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupSurfacesBrcInit()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    if (!m_histBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateBuffer(
            &encoderBrc->m_brcBuffers.resBrcHistoryBuffer, //m_brcHistoryBufferSize,
            m_histBufferBrc));
    }

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::EncodeBrcInitResetKernel()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;
    // Setup curbe for BrcInitReset kernel
    if (encoderBrc->m_brcInit)
    {
        m_cmKrnBrc = m_cmKrnBrcInit;
    }
    else
    {
        m_cmKrnBrc = m_cmKrnBrcReset;
    }

    /* Only one CM kernel is used to switch between brcInit and brcReset, same rule for threadSpace.
       Destroy old one and create a new threadSpace when only brcReset is triggered. */
    if (encoderBrc->m_brcReset && m_threadSpaceBrcInitReset)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyThreadSpace(m_threadSpaceBrcInitReset));
        m_threadSpaceBrcInitReset = nullptr;
    }

    if (!m_threadSpaceBrcInitReset)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupThreadSpace(m_cmKrnBrc, m_threadSpaceBrcInitReset));
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(BrcInitResetCurbe());

    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesBrcInit());
    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupKernelArgsBrcInit());

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->AddKernel(m_cmKrnBrc));

    if (!encoderBrc->m_singleTaskPhaseSupported || encoderBrc->m_lastTaskInPhase)
    {
        CmEvent * event = CM_NO_EVENT;
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmQueue->EnqueueFast(encoderBrc->m_cmTask, event));

        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->Reset());

        encoderBrc->m_lastTaskInPhase = false;
    }
    else
    {
        encoderBrc->m_cmTask->AddSync();
    }

    encoderBrc->m_brcInit = encoderBrc->m_brcReset = false;
    // End FW
    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::BrcInitResetCurbe()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    // Initialize the CURBE data
    encoderBrc->curbe = encoderBrc->m_brcInitResetCurbeInit;

    uint32_t   profileLevelMaxFrame = encoderBrc->GetProfileLevelMaxFrameSize();

    if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_CBR ||
        encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_VBR ||
        encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_AVBR)
    {
        if (encoderBrc->m_hevcSeqParams->InitVBVBufferFullnessInBit == 0)
        {
            CODECHAL_ENCODE_ASSERTMESSAGE("Initial VBV Buffer Fullness is zero\n");
            return MOS_STATUS_INVALID_PARAMETER;
        }

        if (encoderBrc->m_hevcSeqParams->VBVBufferSizeInBit == 0)
        {
            CODECHAL_ENCODE_ASSERTMESSAGE("VBV buffer size in bits is zero\n");
            return MOS_STATUS_INVALID_PARAMETER;
        }
    }

    encoderBrc->curbe.DW0_ProfileLevelMaxFrame = profileLevelMaxFrame;
    encoderBrc->curbe.DW1_InitBufFull = encoderBrc->m_hevcSeqParams->InitVBVBufferFullnessInBit;
    encoderBrc->curbe.DW2_BufSize = encoderBrc->m_hevcSeqParams->VBVBufferSizeInBit;
    encoderBrc->curbe.DW3_TargetBitRate = encoderBrc->m_hevcSeqParams->TargetBitRate * CODECHAL_ENCODE_BRC_KBPS;    //DDI in Kbits
    encoderBrc->curbe.DW4_MaximumBitRate = encoderBrc->m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS;
    encoderBrc->curbe.DW5_MinimumBitRate = 0;
    encoderBrc->curbe.DW6_FrameRateM = encoderBrc->m_hevcSeqParams->FrameRate.Numerator;
    encoderBrc->curbe.DW7_FrameRateD = encoderBrc->m_hevcSeqParams->FrameRate.Denominator;
    encoderBrc->curbe.DW8_BRCFlag = encoderBrc->BRCINIT_IGNORE_PICTURE_HEADER_SIZE;  // always ignore the picture header size set in BRC Update curbe;

    if (encoderBrc->m_hevcPicParams->NumROI)
    {
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_DISABLE_MBBRC; // BRC ROI need disable MBBRC logic in LcuBrc Kernel
    }
    else
    {
        encoderBrc->curbe.DW8_BRCFlag |= (encoderBrc->m_lcuBrcEnabled) ? 0 : encoderBrc->BRCINIT_DISABLE_MBBRC;
    }

    encoderBrc->curbe.DW8_BRCFlag |= (encoderBrc->m_brcEnabled && encoderBrc->m_numPipe > 1) ? encoderBrc->BRCINIT_USEHUCBRC : 0;
    encoderBrc->curbe.DW8_BRCFlag |= (encoderBrc->m_enableFramePanicMode) ? encoderBrc->BRCINIT_PANIC_MODE_ISENABLED : 0;

    // For non-ICQ, ACQP Buffer always set to 1
    encoderBrc->curbe.DW25_ACQPBuffer = 1;

    encoderBrc->curbe.DW25_SlidingWindowSize = encoderBrc->m_slidingWindowSize;

    if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_CBR)
    {
        encoderBrc->curbe.DW4_MaximumBitRate = encoderBrc->curbe.DW3_TargetBitRate;
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_ISCBR;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_VBR)
    {
        if (encoderBrc->curbe.DW4_MaximumBitRate < encoderBrc->curbe.DW3_TargetBitRate)
        {
            encoderBrc->curbe.DW4_MaximumBitRate = 2 * encoderBrc->curbe.DW3_TargetBitRate;
        }
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_ISVBR;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_AVBR)
    {
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_ISAVBR;
        // For AVBR, max bitrate = target bitrate,
        encoderBrc->curbe.DW3_TargetBitRate = encoderBrc->m_hevcSeqParams->TargetBitRate * CODECHAL_ENCODE_BRC_KBPS;    //DDI in Kbits
        encoderBrc->curbe.DW4_MaximumBitRate = encoderBrc->m_hevcSeqParams->TargetBitRate * CODECHAL_ENCODE_BRC_KBPS;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_ICQ)
    {
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_ISICQ;
        encoderBrc->curbe.DW25_ACQPBuffer = encoderBrc->m_hevcSeqParams->ICQQualityFactor;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_VCM)
    {
        encoderBrc->curbe.DW4_MaximumBitRate = encoderBrc->curbe.DW3_TargetBitRate;
        encoderBrc->curbe.DW8_BRCFlag |= encoderBrc->BRCINIT_ISVCM;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_CQP)
    {
        encoderBrc->curbe.DW8_BRCFlag = encoderBrc->BRCINIT_ISCQP;
    }
    else if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_QVBR)
    {
        if (encoderBrc->curbe.DW4_MaximumBitRate < encoderBrc->curbe.DW3_TargetBitRate)
        {
            encoderBrc->curbe.DW4_MaximumBitRate = encoderBrc->curbe.DW3_TargetBitRate; // Use max bit rate for HRD compliance
        }
        encoderBrc->curbe.DW8_BRCFlag = encoderBrc->curbe.DW8_BRCFlag | encoderBrc->BRCINIT_ISQVBR | encoderBrc->BRCINIT_ISVBR; // We need to make sure that VBR is used for QP determination.
        // use ICQQualityFactor to determine the larger Qp for each MB
        encoderBrc->curbe.DW25_ACQPBuffer = encoderBrc->m_hevcSeqParams->ICQQualityFactor;
    }

    encoderBrc->curbe.DW9_FrameWidth = encoderBrc->m_oriFrameWidth;
    encoderBrc->curbe.DW10_FrameHeight = encoderBrc->m_oriFrameHeight;
    encoderBrc->curbe.DW10_AVBRAccuracy = encoderBrc->m_usAvbrAccuracy;
    encoderBrc->curbe.DW11_AVBRConvergence = encoderBrc->m_usAvbrConvergence;
    encoderBrc->curbe.DW12_NumberSlice = encoderBrc->m_numSlices;

    /**********************************************************************
    In case of non-HB/BPyramid Structure
    BRC_Param_A = GopP
    BRC_Param_B = GopB
    In case of HB/BPyramid GOP Structure
    BRC_Param_A, BRC_Param_B, BRC_Param_C, BRC_Param_D are
    BRC Parameters set as follows as per CModel equation
    ***********************************************************************/
    // BPyramid GOP
    const auto GopPicSize = encoderBrc->m_hevcSeqParams->GopPicSize;
    const auto GopRefDist = encoderBrc->m_hevcSeqParams->GopRefDist;

    encoderBrc->m_HierchGopBRCEnabled = false;
    if(encoderBrc->m_hevcSeqParams->HierarchicalFlag && GopRefDist > 1 && GopRefDist <= 8 )
    {      
        uint32_t numB[9]      = {0, 0, 1, 1, 1, 1, 1, 1, 1};
        uint32_t numB1[9]     = {0, 0, 0, 1, 2, 2, 2, 2, 2};
        uint32_t numB2[9]     = {0, 0, 0, 0, 0, 1, 2, 3, 4};

        uint32_t numOfPyramid = (GopPicSize - 1) / GopRefDist;
        uint32_t remOfPyramid = (GopPicSize - 1) % GopRefDist;

        encoderBrc->curbe.DW8_BRCGopP   = numOfPyramid * numB[GopRefDist] + numB[remOfPyramid + 1];
        encoderBrc->curbe.DW9_BRCGopB   = numOfPyramid * numB[GopRefDist] + numB[remOfPyramid];
        encoderBrc->curbe.DW13_BRCGopB1 = numOfPyramid * numB1[GopRefDist] + numB1[remOfPyramid];
        encoderBrc->curbe.DW14_BRCGopB2 = numOfPyramid * numB2[GopRefDist] + numB2[remOfPyramid];

        encoderBrc->m_HierchGopBRCEnabled = true;
     
        // B1 Level GOP
        if (GopRefDist <= 4 || encoderBrc->curbe.DW14_BRCGopB2 == 0)
        {
            encoderBrc->curbe.DW14_MaxBRCLevel = 3;
        }
        // B2 Level GOP
        else
        {
            encoderBrc->curbe.DW14_MaxBRCLevel = 4;
        }       
    }
    // For Regular GOP - No BPyramid
    else
    {
        encoderBrc->curbe.DW14_MaxBRCLevel = 1;
        encoderBrc->curbe.DW8_BRCGopP      = (GopRefDist) ? MOS_ROUNDUP_DIVIDE(GopPicSize - 1, GopRefDist) : 0;
        encoderBrc->curbe.DW9_BRCGopB      = GopPicSize - 1 - encoderBrc->curbe.DW8_BRCGopP;
    }

    // Set dynamic thresholds
    double inputBitsPerFrame = (double)((double)encoderBrc->curbe.DW4_MaximumBitRate * (double)encoderBrc->curbe.DW7_FrameRateD);
    inputBitsPerFrame = (double)(inputBitsPerFrame / encoderBrc->curbe.DW6_FrameRateM);

    if (encoderBrc->curbe.DW2_BufSize < (uint32_t)inputBitsPerFrame * 4)
    {
        encoderBrc->curbe.DW2_BufSize = (uint32_t)inputBitsPerFrame * 4;
    }

    if (encoderBrc->curbe.DW1_InitBufFull == 0)
    {
        encoderBrc->curbe.DW1_InitBufFull = 7 * encoderBrc->curbe.DW2_BufSize / 8;
    }
    if (encoderBrc->curbe.DW1_InitBufFull < (uint32_t)(inputBitsPerFrame * 2))
    {
        encoderBrc->curbe.DW1_InitBufFull = (uint32_t)(inputBitsPerFrame * 2);
    }
    if (encoderBrc->curbe.DW1_InitBufFull > encoderBrc->curbe.DW2_BufSize)
    {
        encoderBrc->curbe.DW1_InitBufFull = encoderBrc->curbe.DW2_BufSize;
    }

    if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_AVBR)
    {
        // For AVBR, Buffer size =  2*Bitrate, InitVBV = 0.75 * BufferSize
        encoderBrc->curbe.DW2_BufSize = 2 * encoderBrc->m_hevcSeqParams->TargetBitRate * CODECHAL_ENCODE_BRC_KBPS;
        encoderBrc->curbe.DW1_InitBufFull = (uint32_t)(0.75 * encoderBrc->curbe.DW2_BufSize);
    }

    if (encoderBrc->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
    {
        encoderBrc->curbe.DW15_LongTermInterval = 0; // no LTR for low delay brc
    }
    else
    {
        encoderBrc->curbe.DW15_LongTermInterval = (encoderBrc->m_enableBrcLTR && encoderBrc->m_ltrInterval) ?
                                                   encoderBrc->m_ltrInterval : encoderBrc->m_enableBrcLTR ? HEVC_BRC_LONG_TERM_REFRENCE_FLAG : 0;
    }

    double bpsRatio = ( (double) inputBitsPerFrame / (( (double) encoderBrc->curbe.DW2_BufSize) / 30));
    bpsRatio = (bpsRatio < 0.1) ? 0.1 : (bpsRatio > 3.5) ? 3.5 : bpsRatio;

    encoderBrc->curbe.DW19_DeviationThreshold0_PBframe = (uint32_t)(-50 * pow(0.90, bpsRatio));
    encoderBrc->curbe.DW19_DeviationThreshold1_PBframe = (uint32_t)(-50 * pow(0.66, bpsRatio));
    encoderBrc->curbe.DW19_DeviationThreshold2_PBframe = (uint32_t)(-50 * pow(0.46, bpsRatio));
    encoderBrc->curbe.DW19_DeviationThreshold3_PBframe = (uint32_t)(-50 * pow(0.3, bpsRatio));

    encoderBrc->curbe.DW20_DeviationThreshold4_PBframe = (uint32_t)(50 * pow(0.3, bpsRatio));
    encoderBrc->curbe.DW20_DeviationThreshold5_PBframe = (uint32_t)(50 * pow(0.46, bpsRatio));
    encoderBrc->curbe.DW20_DeviationThreshold6_PBframe = (uint32_t)(50 * pow(0.7, bpsRatio));
    encoderBrc->curbe.DW20_DeviationThreshold7_PBframe = (uint32_t)(50 * pow(0.9, bpsRatio));

    encoderBrc->curbe.DW21_DeviationThreshold0_VBRcontrol = (uint32_t)(-50 * pow(0.9, bpsRatio));
    encoderBrc->curbe.DW21_DeviationThreshold1_VBRcontrol = (uint32_t)(-50 * pow(0.7, bpsRatio));
    encoderBrc->curbe.DW21_DeviationThreshold2_VBRcontrol = (uint32_t)(-50 * pow(0.5, bpsRatio));
    encoderBrc->curbe.DW21_DeviationThreshold3_VBRcontrol = (uint32_t)(-50 * pow(0.3, bpsRatio));

    encoderBrc->curbe.DW22_DeviationThreshold4_VBRcontrol = (uint32_t)(100 * pow(0.4, bpsRatio));
    encoderBrc->curbe.DW22_DeviationThreshold5_VBRcontrol = (uint32_t)(100 * pow(0.5, bpsRatio));
    encoderBrc->curbe.DW22_DeviationThreshold6_VBRcontrol = (uint32_t)(100 * pow(0.75, bpsRatio));
    encoderBrc->curbe.DW22_DeviationThreshold7_VBRcontrol = (uint32_t)(100 * pow(0.9, bpsRatio));

    encoderBrc->curbe.DW23_DeviationThreshold0_Iframe = (uint32_t)(-50 * pow(0.8, bpsRatio));
    encoderBrc->curbe.DW23_DeviationThreshold1_Iframe = (uint32_t)(-50 * pow(0.6, bpsRatio));
    encoderBrc->curbe.DW23_DeviationThreshold2_Iframe = (uint32_t)(-50 * pow(0.34, bpsRatio));
    encoderBrc->curbe.DW23_DeviationThreshold3_Iframe = (uint32_t)(-50 * pow(0.2, bpsRatio));

    encoderBrc->curbe.DW24_DeviationThreshold4_Iframe = (uint32_t)(50 * pow(0.2, bpsRatio));
    encoderBrc->curbe.DW24_DeviationThreshold5_Iframe = (uint32_t)(50 * pow(0.4, bpsRatio));
    encoderBrc->curbe.DW24_DeviationThreshold6_Iframe = (uint32_t)(50 * pow(0.66, bpsRatio));
    encoderBrc->curbe.DW24_DeviationThreshold7_Iframe = (uint32_t)(50 * pow(0.9, bpsRatio));

    if (encoderBrc->m_hevcSeqParams->HierarchicalFlag && !encoderBrc->m_hevcSeqParams->LowDelayMode &&
        (encoderBrc->m_hevcSeqParams->GopRefDist == 4 || encoderBrc->m_hevcSeqParams->GopRefDist == 8))
    {
        encoderBrc->curbe.DW26_RandomAccess = true;
    }
    else
    {
        encoderBrc->curbe.DW26_RandomAccess = false;
    }

    if (encoderBrc->m_brcInit)
    {
        encoderBrc->m_dBrcInitCurrentTargetBufFullInBits = encoderBrc->curbe.DW1_InitBufFull;
    }

    encoderBrc->m_brcInitResetBufSizeInBits = encoderBrc->curbe.DW2_BufSize;
    encoderBrc->m_dBrcInitResetInputBitsPerFrame = inputBitsPerFrame;

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::BrcUpdateCurbe()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    // Initialize the CURBE data
    encoderBrc->curbeBrcUpdate = encoderBrc->m_brcUpdateCurbeInit;

    encoderBrc->curbeBrcUpdate.DW5_TargetSize_Flag = 0;

    if (encoderBrc->m_dBrcInitCurrentTargetBufFullInBits > (double)encoderBrc->m_brcInitResetBufSizeInBits)
    {
        encoderBrc->m_dBrcInitCurrentTargetBufFullInBits -= (double)encoderBrc->m_brcInitResetBufSizeInBits;
        encoderBrc->curbeBrcUpdate.DW5_TargetSize_Flag = 1;
    }

    if (encoderBrc->m_numSkipFrames)
    {
        // pass num/size of skipped frames to update BRC
        encoderBrc->curbeBrcUpdate.DW6_NumSkippedFrames = encoderBrc->m_numSkipFrames;
        encoderBrc->curbeBrcUpdate.DW15_SizeOfSkippedFrames = encoderBrc->m_sizeSkipFrames;

        // account for skipped frame in calculating CurrentTargetBufFullInBits
        encoderBrc->m_dBrcInitCurrentTargetBufFullInBits += encoderBrc->m_dBrcInitResetInputBitsPerFrame * encoderBrc->m_numSkipFrames;
    }

    encoderBrc->curbeBrcUpdate.DW0_TargetSize = (uint32_t)(encoderBrc->m_dBrcInitCurrentTargetBufFullInBits);
    encoderBrc->curbeBrcUpdate.DW1_FrameNumber = encoderBrc->m_storeData - 1; // Check if we can remove this (set to 0)

    uint32_t picHdrSize = encoderBrc->GetPicHdrSize();
    encoderBrc->curbeBrcUpdate.DW2_PictureHeaderSize = picHdrSize;

    encoderBrc->curbeBrcUpdate.DW5_CurrFrameBrcLevel = encoderBrc->m_currFrameBrcLevel;

    encoderBrc->curbeBrcUpdate.DW5_MaxNumPAKs = m_brcNumPakPasses;

    if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_CQP)
    {
        encoderBrc->curbeBrcUpdate.DW6_CqpValue = encoderBrc->m_hevcPicParams->QpY + encoderBrc->m_hevcSliceParams->slice_qp_delta;
    }

    encoderBrc->curbeBrcUpdate.DW6_SlidingWindowEnable = (encoderBrc->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW);

    if (encoderBrc->m_hevcPicParams->NumROI)
    {
        encoderBrc->curbeBrcUpdate.DW6_ROIEnable = encoderBrc->m_brcEnabled ? false : true;
        encoderBrc->curbeBrcUpdate.DW6_BRCROIEnable = encoderBrc->m_brcEnabled ? true : false;
        encoderBrc->curbeBrcUpdate.DW6_RoiRatio = encoderBrc->CalculateROIRatio();
    }

    if (encoderBrc->m_minMaxQpControlEnabled)
    {
        if (encoderBrc->m_hevcPicParams->CodingType == I_TYPE)
        {
            encoderBrc->curbeBrcUpdate.DW7_FrameMaxQP = encoderBrc->m_maxQpForI;
            encoderBrc->curbeBrcUpdate.DW7_FrameMinQP = encoderBrc->m_minQpForI;
        }
        else if (encoderBrc->m_hevcPicParams->CodingType == P_TYPE)
        {
            encoderBrc->curbeBrcUpdate.DW7_FrameMaxQP = encoderBrc->m_maxQpForP;
            encoderBrc->curbeBrcUpdate.DW7_FrameMinQP = encoderBrc->m_minQpForP;
        }
        else if (encoderBrc->m_hevcPicParams->CodingType == B_TYPE)
        {
            encoderBrc->curbeBrcUpdate.DW7_FrameMaxQP = encoderBrc->m_maxQpForB;
            encoderBrc->curbeBrcUpdate.DW7_FrameMinQP = encoderBrc->m_minQpForB;
        }
    }

    //for low delay brc
    encoderBrc->curbeBrcUpdate.DW6_LowDelayEnable      = (encoderBrc->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW);
    encoderBrc->curbeBrcUpdate.DW16_UserMaxFrameSize   = encoderBrc->GetProfileLevelMaxFrameSize();

    encoderBrc->curbeBrcUpdate.DW14_ParallelMode = encoderBrc->m_hevcSeqParams->ParallelBRC;

    if (encoderBrc->m_hevcSeqParams->RateControlMethod == RATECONTROL_AVBR)
    {
        encoderBrc->curbeBrcUpdate.DW3_StartGAdjFrame0 = (uint32_t)((10 * encoderBrc->m_usAvbrConvergence) / (double)150);
        encoderBrc->curbeBrcUpdate.DW3_StartGAdjFrame1 = (uint32_t)((50 * encoderBrc->m_usAvbrConvergence) / (double)150);
        encoderBrc->curbeBrcUpdate.DW4_StartGAdjFrame2 = (uint32_t)((100 * encoderBrc->m_usAvbrConvergence) / (double)150);
        encoderBrc->curbeBrcUpdate.DW4_StartGAdjFrame3 = (uint32_t)((150 * encoderBrc->m_usAvbrConvergence) / (double)150);

        encoderBrc->curbeBrcUpdate.DW11_gRateRatioThreshold0 =
            (uint32_t)((100 - (encoderBrc->m_usAvbrAccuracy / (double)30)*(100 - 40)));
        encoderBrc->curbeBrcUpdate.DW11_gRateRatioThreshold1 =
            (uint32_t)((100 - (encoderBrc->m_usAvbrAccuracy / (double)30)*(100 - 75)));
        encoderBrc->curbeBrcUpdate.DW12_gRateRatioThreshold2 = (uint32_t)((100 - (encoderBrc->m_usAvbrAccuracy / (double)30)*(100 - 97)));
        encoderBrc->curbeBrcUpdate.DW12_gRateRatioThreshold3 = (uint32_t)((100 + (encoderBrc->m_usAvbrAccuracy / (double)30)*(103 - 100)));
        encoderBrc->curbeBrcUpdate.DW12_gRateRatioThreshold4 = (uint32_t)((100 + (encoderBrc->m_usAvbrAccuracy / (double)30)*(125 - 100)));
        encoderBrc->curbeBrcUpdate.DW12_gRateRatioThreshold5 = (uint32_t)((100 + (encoderBrc->m_usAvbrAccuracy / (double)30)*(160 - 100)));
    }

    if (encoderBrc->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
    {
        encoderBrc->curbeBrcUpdate.DW17_LongTerm_Current = 0; // no LTR for low delay brc
    }
    else
    {
        encoderBrc->m_isFrameLTR = (CodecHal_PictureIsLongTermRef(encoderBrc->m_currReconstructedPic));
        encoderBrc->curbeBrcUpdate.DW17_LongTerm_Current = (encoderBrc->m_enableBrcLTR && encoderBrc->m_isFrameLTR) ? 1 : 0;
    }

    return eStatus;
}
MOS_STATUS CodecHalHevcBrcG12::EncodeBrcFrameUpdateKernel()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
    CODECHAL_ENCODE_FUNCTION_ENTER;

    PerfTagSetting perfTag;
    perfTag.Value = 0;
    perfTag.Mode = (uint16_t)encoderBrc->m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
    perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE;
    perfTag.PictureCodingType = encoderBrc->m_pictureCodingType;
    encoderBrc->GetOsInterface()->pfnSetPerfTag(encoderBrc->GetOsInterface(), perfTag.Value);
    encoderBrc->GetOsInterface()->pfnIncPerfBufferID(encoderBrc->GetOsInterface());

    if (!m_threadSpaceBrcUpdate)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupThreadSpace(m_cmKrnBrcUpdate, m_threadSpaceBrcUpdate));
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(BrcUpdateCurbe());
    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesBrcUpdate());
    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupKernelArgsBrcUpdate());
    CODECHAL_DEBUG_TOOL(
        CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpBrcInputBuffers()));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->AddKernel(m_cmKrnBrcUpdate));

    if (!encoderBrc->m_singleTaskPhaseSupported || encoderBrc->m_lastTaskInPhase)
    {
        CmEvent * event = CM_NO_EVENT;
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmQueue->EnqueueFast(encoderBrc->m_cmTask, event));

        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->Reset());

        encoderBrc->m_lastTaskInPhase = false;
    }
    else
    {
        encoderBrc->m_cmTask->AddSync();
    }
    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupSurfacesBrcUpdate()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    // Fill HCP_IMG_STATE so that BRC kernel can use it to generate the write buffer for PAK
    PMOS_RESOURCE brcHcpStateReadBuffer = &encoderBrc->m_brcBuffers.resBrcImageStatesReadBuffer[encoderBrc->m_currRecycledBufIdx];
    MHW_VDBOX_HEVC_PIC_STATE_G12 mhwHevcPicState;
    mhwHevcPicState.pHevcEncSeqParams = encoderBrc->m_hevcSeqParams;
    mhwHevcPicState.pHevcEncPicParams = encoderBrc->m_hevcPicParams;
    mhwHevcPicState.brcNumPakPasses = m_brcNumPakPasses;
    mhwHevcPicState.rhodomainRCEnable = encoderBrc->m_brcEnabled && (encoderBrc->m_numPipe > 1);
    mhwHevcPicState.bSAOEnable = encoderBrc->m_hevcSeqParams->SAO_enabled_flag ? (encoderBrc->m_hevcSliceParams->slice_sao_luma_flag || encoderBrc->m_hevcSliceParams->slice_sao_chroma_flag) : 0;
    mhwHevcPicState.bTransformSkipEnable = encoderBrc->m_hevcPicParams->transform_skip_enabled_flag;
    mhwHevcPicState.bHevcRdoqEnabled      = encoderBrc->m_hevcRdoqEnabled;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_hcpInterface->AddHcpHevcPicBrcBuffer(brcHcpStateReadBuffer, &mhwHevcPicState));

    PMOS_SURFACE brcConstantData = &encoderBrc->m_brcBuffers.sBrcConstantDataBuffer[encoderBrc->m_currRecycledBufIdx];
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->SetupBrcConstantTable(brcConstantData));

    if (!m_histBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateBuffer(
            &encoderBrc->m_brcBuffers.resBrcHistoryBuffer, //m_brcHistoryBufferSize,
            m_histBufferBrc));
    }

    // BRC Prev PAK statistics output buffer
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->UpdateBuffer(
        &encoderBrc->m_brcBuffers.resBrcPakStatisticBuffer[encoderBrc->m_brcBuffers.uiCurrBrcPakStasIdxForRead],
        m_PAKStatsBufferBrc));

    // BRC HCP_PIC_STATE read
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->UpdateBuffer(
        brcHcpStateReadBuffer,
        m_PICStateInBufferBrc));

    // BRC HCP_PIC_STATE write
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->UpdateBuffer(
        &encoderBrc->m_brcBuffers.resBrcImageStatesWriteBuffer[encoderBrc->m_currRecycledBufIdx],
        m_PICStateOutBufferBrc));

    // BRC Data Surface
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->UpdateSurface2D(
        &brcConstantData->OsResource,
        m_ConstDataBufferBRC));

    // Pixel MB Statistics surface
    if (!m_PixelMBStatsBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateBuffer(
            &encoderBrc->m_resMbStatsBuffer,
            m_PixelMBStatsBufferBrc));
    }

    // Combined ENC-parameter buffer
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->UpdateBuffer(
        &encoderBrc->m_brcInputForEncKernelBuffer->sResource,
        m_CombinedEncBufferBrc));

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupKernelArgsBrcUpdate()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    int idx = 0;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(encoderBrc->m_brcUpdateCurbeInit), &encoderBrc->curbeBrcUpdate));

    SurfaceIndex *pIndex0 = nullptr;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_histBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_PAKStatsBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_PICStateInBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_PICStateOutBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_CombinedEncBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    //Setup Distortion 2D surface
    CmSurface2D *brcDistortion = (encoderBrc->m_pictureCodingType == I_TYPE) ? encoderBrc->m_brcBuffers.brcIntraDistortionSurface
                                                                             : encoderBrc->m_brcBuffers.meBrcDistortionSurface;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(brcDistortion->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_ConstDataBufferBRC->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_PixelMBStatsBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_brcBuffers.mvAndDistortionSumSurface->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcUpdate->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::EncodeBrcLcuUpdateKernel()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
    CODECHAL_ENCODE_FUNCTION_ENTER;

    PerfTagSetting perfTag;
    perfTag.Value = 0;
    perfTag.Mode = (uint16_t)encoderBrc->m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
    perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE_LCU;
    perfTag.PictureCodingType = encoderBrc->m_pictureCodingType;
    encoderBrc->GetOsInterface()->pfnSetPerfTag(encoderBrc->GetOsInterface(), perfTag.Value);
    encoderBrc->GetOsInterface()->pfnIncPerfBufferID(encoderBrc->GetOsInterface());

    CODECHAL_ENCODE_CHK_STATUS_RETURN(BrcUpdateCurbe());
    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesBrcLcuQp());

    if (encoderBrc->m_hevcPicParams->NumROI)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->SetupROISurface());
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupKernelArgsBrcLcuQp());

    if (encoderBrc->m_resolutionChanged && m_threadSpaceBrcLCUQP)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->DestroyThreadSpace(m_threadSpaceBrcLCUQP));
        m_threadSpaceBrcLCUQP = nullptr;
    }

    if (!m_threadSpaceBrcLCUQP)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupBrcLcuqpThreadSpace(m_cmKrnBrcLCUQP, m_threadSpaceBrcLCUQP));
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->AddKernel(m_cmKrnBrcLCUQP));

    if (!encoderBrc->m_singleTaskPhaseSupported || encoderBrc->m_lastTaskInPhase)
    {
        CmEvent * event = CM_NO_EVENT;
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmQueue->EnqueueFast(encoderBrc->m_cmTask, event));

        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmTask->Reset());

        encoderBrc->m_lastTaskInPhase = false;
    }
    else
    {
        encoderBrc->m_cmTask->AddSync();
    }

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupSurfacesBrcLcuQp()
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    if (!m_histBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateBuffer(
             &encoderBrc->m_brcBuffers.resBrcHistoryBuffer,
             m_histBufferBrc));
    }

    // Pixel MB Statistics surface
    if (!m_PixelMBStatsBufferBrc)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateBuffer(
             &encoderBrc->m_resMbStatsBuffer,
             m_PixelMBStatsBufferBrc));
    }

    if (!m_BrcMbQp) {

        // BRC Data Surface
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateSurface2D(
            &encoderBrc->m_brcBuffers.sBrcMbQpBuffer.OsResource,
            m_BrcMbQp));
    }

    if (!m_BrcROISurf)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->m_cmDev->CreateSurface2D(
            &encoderBrc->m_brcBuffers.sBrcRoiSurface.OsResource,
            m_BrcROISurf));
    }

    return eStatus;
}

MOS_STATUS CodecHalHevcBrcG12::SetupKernelArgsBrcLcuQp()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    int idx = 0;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(encoderBrc->m_brcUpdateCurbeInit), &encoderBrc->curbeBrcUpdate));

    SurfaceIndex *pIndex0 = nullptr;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_histBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    //Setup Distortion 2D surface
    CmSurface2D *brcDistortion = (encoderBrc->m_pictureCodingType == I_TYPE) ? encoderBrc->m_brcBuffers.brcIntraDistortionSurface
                                                                             : encoderBrc->m_brcBuffers.meBrcDistortionSurface;
    CODECHAL_ENCODE_CHK_STATUS_RETURN(brcDistortion->GetIndex(pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_PixelMBStatsBufferBrc->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_BrcMbQp->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_BrcROISurf->GetIndex(pIndex0));
    CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnBrcLCUQP->SetKernelArg(idx++, sizeof(SurfaceIndex), pIndex0));
    return eStatus;
}

#if USE_CODECHAL_DEBUG_TOOL
MOS_STATUS CodecHalHevcBrcG12::DumpBrcInputBuffers()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpBuffer(
        &encoderBrc->m_mvAndDistortionSumSurface.sResource,
        CodechalDbgAttr::attrInput,
        "MvDistSum",
        encoderBrc->m_mvAndDistortionSumSurface.dwSize,
        0,
        CODECHAL_MEDIA_STATE_BRC_UPDATE));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpBuffer(
        &encoderBrc->m_brcBuffers.resBrcImageStatesReadBuffer[encoderBrc->m_currRecycledBufIdx],
        CodechalDbgAttr::attrInput,
        "ImgStateRead",
        BRC_IMG_STATE_SIZE_PER_PASS * encoderBrc->GetHwInterface()->GetMfxInterface()->GetBrcNumPakPasses(),
        0,
        CODECHAL_MEDIA_STATE_BRC_UPDATE));

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpSurface(
        &encoderBrc->m_brcBuffers.sBrcConstantDataBuffer[encoderBrc->m_currRecycledBufIdx],
        CodechalDbgAttr::attrInput,
        "ConstData",
        CODECHAL_MEDIA_STATE_BRC_UPDATE));

    // PAK statistics buffer is only dumped for BrcUpdate kernel input
    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpBuffer(
        &encoderBrc->m_brcBuffers.resBrcPakStatisticBuffer[encoderBrc->m_brcBuffers.uiCurrBrcPakStasIdxForRead],
        CodechalDbgAttr::attrInput,
        "PakStats",
        HEVC_BRC_PAK_STATISTCS_SIZE,
        0,
        CODECHAL_MEDIA_STATE_BRC_UPDATE));
    // HEVC maintains a ptr to its own distortion surface, as it may be a couple different surfaces
    if (encoderBrc->m_brcDistortion)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(
            encoderBrc->GetDebugInterface()->DumpBuffer(
                &encoderBrc->m_brcDistortion->OsResource,
                CodechalDbgAttr::attrInput,
                "BrcDist_BeforeFrameBrc",
                encoderBrc->m_brcBuffers.sMeBrcDistortionBuffer.dwPitch * encoderBrc->m_brcBuffers.sMeBrcDistortionBuffer.dwHeight,
                encoderBrc->m_brcBuffers.dwMeBrcDistortionBottomFieldOffset,
                CODECHAL_MEDIA_STATE_BRC_UPDATE));
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpBuffer(&encoderBrc->m_brcBuffers.resBrcHistoryBuffer,
        CodechalDbgAttr::attrInput,
        "HistoryRead_beforeFramBRC",
        encoderBrc->m_brcHistoryBufferSize,
        0,
        CODECHAL_MEDIA_STATE_BRC_UPDATE));

    if (encoderBrc->m_brcBuffers.pMbEncKernelStateInUse)
    {
        CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpCurbe(
            CODECHAL_MEDIA_STATE_BRC_UPDATE,
            encoderBrc->m_brcBuffers.pMbEncKernelStateInUse));
    }

    CODECHAL_ENCODE_CHK_STATUS_RETURN(encoderBrc->GetDebugInterface()->DumpBuffer(&encoderBrc->m_resMbStatsBuffer,
        CodechalDbgAttr::attrInput,
        "MBStatsSurf",
        encoderBrc->GetHwInterface()->m_avcMbStatBufferSize,
        0,
        CODECHAL_MEDIA_STATE_BRC_UPDATE));

    return eStatus;
}
#endif