/*
* Copyright (c) 2010-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      vphal_render_hdr_base.cpp
//! \brief     Unified VP HAL HDR Implementation 
//!
//!
//! \file     vphal_render_hdr_base.cpp
//! \brief    Common interface and structure used in HDR
//! \details  Common interface and structure used in HDR which are platform independent
//!

#include "vphal.h"
#include "vphal_renderer.h"
#include "vphal_render_hdr_base.h"
#include "renderhal_platform_interface.h"
#include "vphal_render_hdr_g9_base.h"


#if (_DEBUG || _RELEASE_INTERNAL)
static bool sEnableKernelDump = false;
#endif

//!
//! \brief    Initialize HDR state
//! \details  Initialize HDR state
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in,out] HDR State pointer
//! \param    const VphalSettings* pSettings
//!           [in] Pointer to VPHAL Setting
//! \param    Kdll_KernelCache * pKernelCache
//!           [in] Pointer to kernel cache
//! \return   void
//!
MOS_STATUS VpHal_HdrInitialize(
    PVPHAL_HDR_STATE         pHdrState,
    const VphalSettings      *pSettings,
    Kdll_State               *pKernelDllState)
{
    int32_t    i;
    uint32_t   dwSize = 0;
    bool       bAllocated = false;
    MOS_NULL_RENDERING_FLAGS    NullRenderingFlags;
    MOS_STATUS                  eStatus;
    PRENDERHAL_INTERFACE        pRenderHal;
    MOS_USER_FEATURE_VALUE_DATA UserFeatureData;

    eStatus = MOS_STATUS_SUCCESS;

    VPHAL_PUBLIC_CHK_NULL(pHdrState);
    VPHAL_PUBLIC_CHK_NULL(pHdrState->pOsInterface);
    VPHAL_PUBLIC_CHK_NULL(pHdrState->pSkuTable);
    VPHAL_PUBLIC_CHK_NULL(pKernelDllState);

    NullRenderingFlags          = 
                    pHdrState->pOsInterface->pfnGetNullHWRenderFlags(pHdrState->pOsInterface);
    pHdrState->bNullHwRenderHdr = false;
    pRenderHal                  = pHdrState->pRenderHal;

    VPHAL_PUBLIC_CHK_NULL(pRenderHal);

    // Setup disable render flag controlled by a user feature key for validation purpose
    pHdrState->bDisableRender = (pSettings->disableHdr) ? true : false;

    // Setup interface to KDLL
    pHdrState->pKernelCache   = &pKernelDllState->ComponentKernelCache;

    eStatus = MOS_STATUS_SUCCESS;

    pHdrState->uiSplitFramePortions = 1;

    // If user set the user feature key, then the uiSplitFramePortions specified will always be used,
    // no matter HW support preemption or not.
    // If it is not set, and HW doesn't support preemption, then the split portions
    // will be calculted based on resolution.
    if (!pHdrState->bForceSplitFrame)
    {
        if (MEDIA_IS_SKU(pHdrState->pSkuTable, FtrMediaMidBatchPreempt) ||
            MEDIA_IS_SKU(pHdrState->pSkuTable, FtrMediaThreadGroupLevelPreempt) ||
            MEDIA_IS_SKU(pHdrState->pSkuTable, FtrMediaMidThreadLevelPreempt))
        {
            pHdrState->uiSplitFramePortions = 1;
            pHdrState->bForceSplitFrame     = true;
        }
    }

    pHdrState->bFtrComputeWalker = false;
    pHdrState->uiSplitFramePortions = 1;

    pHdrState->bVeboxpreprocessed = false;

    VpHal_HdrInitInterface_g9(pHdrState);            // Total number of slices
    
finish:
    return eStatus;
}

//!
//! \brief    Destroy HDR state
//! \details  Release local resources.
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to HDR state
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrDestroy(
    PVPHAL_HDR_STATE    pHdrState)
{
    MOS_STATUS                  eStatus = MOS_STATUS_SUCCESS;
    VPHAL_PUBLIC_CHK_NULL(pHdrState);

    VpHal_HdrDestroyInterface_g9(pHdrState);

    // Free allocations
    if (pHdrState->pfnFreeResources)
    {
        pHdrState->pfnFreeResources(pHdrState);
    }

finish:
    return eStatus;
}

//!
//! \brief    Assemble the HDR kernel per layer stages
//! \details  Contruct a case id from the input information, and look up the configuration entry in the table.
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to HDR state
//! \param    PVPHAL_SURFACE pSource
//!           [in] Pointer to source surface
//! \param    PVPHAL_SURFACE pTarget
//!           [in] Pointer to target surface
//! \param    HDRStageConfigEntry *pConfigEntry
//!           [out] Pointer to configuration entry
//! \return   bool
//!           True if find proper configuration entry, otherwise false
//!
static bool Vphal_HdrToneMappingStagesAssemble(
    PVPHAL_HDR_STATE       pHdrState,
    PVPHAL_SURFACE         pSource,
    PVPHAL_SURFACE         pTarget,
    HDRStageConfigEntry   *pConfigEntry)
{
    HDRCaseID id = { 0 };

    VPHAL_RENDER_ASSERT(pHdrState);
    VPHAL_RENDER_ASSERT(pSource);
    VPHAL_RENDER_ASSERT(pTarget);
    VPHAL_RENDER_ASSERT(pConfigEntry);

    if (!pHdrState || !pSource || !pTarget || !pConfigEntry)
        return false;

    // Because FP16 format can represent both SDR or HDR, we need do judgement here.
    // We need this information because we dont have unified tone mapping algorithm for various scenarios(H2S/H2H).
    // To do this, we make two assumptions:
    // 1. This colorspace will be set to BT709/Gamma1.0 from APP, so such information can NOT be used to check HDR.
    // 2. If APP pass any HDR metadata, it indicates this is HDR.
    id.InputXDR     = (pSource->pHDRParams &&
                      ((pSource->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084) || IS_RGB64_FLOAT_FORMAT(pSource->Format))) ? 1 : 0;
    id.InputGamut   = IS_COLOR_SPACE_BT2020(pSource->ColorSpace);
    id.OutputXDR    = (pTarget->pHDRParams &&
                      ((pTarget->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084) || IS_RGB64_FLOAT_FORMAT(pTarget->Format))) ? 1 : 0;
    id.OutputGamut  = IS_COLOR_SPACE_BT2020(pTarget->ColorSpace);
    id.OutputLinear = IS_RGB64_FLOAT_FORMAT(pTarget->Format) ? 1 : 0;

    if (pHdrState->pHDRStageConfigTable)
    {
        pConfigEntry->value = pHdrState->pHDRStageConfigTable[id.index];
    }
    else
    {
        pConfigEntry->Invalid = 1;
    }

    if (pConfigEntry->Invalid == 1)
    {
        VPHAL_RENDER_ASSERTMESSAGE("Tone mapping stages assembling failed, please reexamine the usage case(case id %d)! "
            "If it is definitely a correct usage, please add an entry in HDRStageEnableTable.", id.index);
    }

    return (pConfigEntry->Invalid != 1);
}

//!
//! \brief    Update per layer pipeline states and return update mask for each layer
//! \details  Update per layer pipeline states and return update mask for each layer
//! \param    PVPHAL_HDR_STATE pHdrStatee
//!           [in] Pointer to HDR state
//! \param    uint32_t* pdwUpdateMask
//!           [out] Pointer to update mask
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrUpdatePerLayerPipelineStates(
    PVPHAL_HDR_STATE    pHdrState,
    uint32_t*           pdwUpdateMask)
{
    MOS_STATUS           eStatus              = MOS_STATUS_UNKNOWN;
    uint32_t             i                    = 0;
    PVPHAL_SURFACE       pSrc                 = nullptr;
    PVPHAL_SURFACE       pTarget              = nullptr;
    VPHAL_HDR_LUT_MODE   CurrentLUTMode       = VPHAL_HDR_LUT_MODE_NONE;
    VPHAL_GAMMA_TYPE     CurrentEOTF          = VPHAL_GAMMA_NONE;            //!< EOTF
    VPHAL_GAMMA_TYPE     CurrentOETF          = VPHAL_GAMMA_NONE;            //!< OETF
    VPHAL_HDR_MODE       CurrentHdrMode       = VPHAL_HDR_MODE_NONE;      //!< Hdr Mode
    VPHAL_HDR_CCM_TYPE   CurrentCCM           = VPHAL_HDR_CCM_NONE;           //!< CCM Mode
    VPHAL_HDR_CCM_TYPE   CurrentCCMExt1       = VPHAL_HDR_CCM_NONE;       //!< CCM Ext1 Mode
    VPHAL_HDR_CCM_TYPE   CurrentCCMExt2       = VPHAL_HDR_CCM_NONE;       //!< CCM Ext2 Mode
    VPHAL_HDR_CSC_TYPE   CurrentPriorCSC      = VPHAL_HDR_CSC_NONE;      //!< Prior CSC Mode
    VPHAL_HDR_CSC_TYPE   CurrentPostCSC       = VPHAL_HDR_CSC_NONE;       //!< Post CSC Mode
    HDRStageConfigEntry  ConfigEntry          = { 0 };
    HDRStageEnables      StageEnables         = { 0 };

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pdwUpdateMask);
    VPHAL_PUBLIC_CHK_NULL(pHdrState->pTargetSurf[0]);

    *pdwUpdateMask = 0;

    pTarget = (PVPHAL_SURFACE)pHdrState->pTargetSurf[0];

    for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
    {
        if (pHdrState->pSrcSurf[i] == nullptr)
        {
            pHdrState->LUTMode[i]   = VPHAL_HDR_LUT_MODE_NONE;
            pHdrState->EOTFGamma[i] = VPHAL_GAMMA_NONE;
            pHdrState->OETFGamma[i] = VPHAL_GAMMA_NONE;
            pHdrState->CCM[i]       = VPHAL_HDR_CCM_NONE;
            pHdrState->CCMExt1[i]   = VPHAL_HDR_CCM_NONE;
            pHdrState->CCMExt2[i]   = VPHAL_HDR_CCM_NONE;
            pHdrState->HdrMode[i]   = VPHAL_HDR_MODE_NONE;
            pHdrState->PriorCSC[i]  = VPHAL_HDR_CSC_NONE;
            pHdrState->PostCSC[i]   = VPHAL_HDR_CSC_NONE;

            pHdrState->StageEnableFlags[i].value = 0;
            MOS_ZeroMemory(&pHdrState->HDRLastFrameSourceParams[i], sizeof(VPHAL_HDR_PARAMS));

            continue;
        }

        pSrc = (PVPHAL_SURFACE)pHdrState->pSrcSurf[i];

        CurrentLUTMode  = VPHAL_HDR_LUT_MODE_NONE;
        CurrentEOTF     = VPHAL_GAMMA_NONE;
        CurrentOETF     = VPHAL_GAMMA_NONE;
        CurrentHdrMode  = VPHAL_HDR_MODE_NONE;
        CurrentCCM      = VPHAL_HDR_CCM_NONE;
        CurrentCCMExt1  = VPHAL_HDR_CCM_NONE;
        CurrentCCMExt2  = VPHAL_HDR_CCM_NONE;
        CurrentPriorCSC = VPHAL_HDR_CSC_NONE;
        CurrentPostCSC  = VPHAL_HDR_CSC_NONE;

        if (!Vphal_HdrToneMappingStagesAssemble(pHdrState, pSrc, pTarget, &ConfigEntry))
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            goto finish;
        }

        CurrentHdrMode = (VPHAL_HDR_MODE)ConfigEntry.PWLF;
        CurrentCCM     = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCM;
        CurrentCCMExt1 = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCMExt1;
        CurrentCCMExt2 = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCMExt2;

        // So far only enable auto mode in H2S cases.
        if (CurrentHdrMode == VPHAL_HDR_MODE_TONE_MAPPING &&
            pSrc->pHDRParams                              &&
            pSrc->pHDRParams->bAutoMode                   &&
            pSrc->SurfType == SURF_IN_PRIMARY)
        {
            CurrentHdrMode = VPHAL_HDR_MODE_TONE_MAPPING_AUTO_MODE;
        }

        StageEnables.value             = 0;
        StageEnables.CCMEnable         = (CurrentCCM     != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
        StageEnables.PWLFEnable        = (CurrentHdrMode != VPHAL_HDR_MODE_NONE) ? 1 : 0;
        StageEnables.CCMExt1Enable     = (CurrentCCMExt1 != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
        StageEnables.CCMExt2Enable     = (CurrentCCMExt2 != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
        StageEnables.GamutClamp1Enable = ConfigEntry.GamutClamp1;
        StageEnables.GamutClamp2Enable = ConfigEntry.GamutClamp2;

        if (IS_YUV_FORMAT(pSrc->Format) || IS_ALPHA_YUV_FORMAT(pSrc->Format))
        {
            StageEnables.PriorCSCEnable = 1;
        }

        if (!IS_RGB64_FLOAT_FORMAT(pSrc->Format) &&
            (StageEnables.CCMEnable || StageEnables.PWLFEnable || StageEnables.CCMExt1Enable || StageEnables.CCMExt2Enable))
        {
            StageEnables.EOTFEnable = 1;
        }

        if (!IS_RGB64_FLOAT_FORMAT(pTarget->Format) && StageEnables.EOTFEnable)
        {
            StageEnables.OETFEnable = 1;
        }

        if (IS_YUV_FORMAT(pTarget->Format))
        {
            StageEnables.PostCSCEnable = 1;
        }

        if (pSrc->SurfType == SURF_IN_PRIMARY && pHdrState->GlobalLutMode != VPHAL_HDR_LUT_MODE_3D)
        {
            CurrentLUTMode = VPHAL_HDR_LUT_MODE_2D;
        }
        else
        {
            CurrentLUTMode = VPHAL_HDR_LUT_MODE_3D;
        }

        // Neither 1D nor 3D LUT is needed in linear output case.
        if (IS_RGB64_FLOAT_FORMAT(pHdrState->pTargetSurf[0]->Format))
        {
            CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
        }

        // EOTF/CCM/Tone Mapping/OETF require RGB input
        // So if prior CSC is needed, it will always be YUV to RGB conversion
        if (StageEnables.PriorCSCEnable)
        {
            if (pSrc->ColorSpace == CSpace_BT601)
            {
                CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT601;
            }
            else if (pSrc->ColorSpace == CSpace_BT709)
            {
                CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT709;
            }
            else if (pSrc->ColorSpace == CSpace_BT2020)
            {
                CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT2020;
            }
            else if (pSrc->ColorSpace == CSpace_BT2020_FullRange)
            {
                CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT2020;
            }
            else
            {
                VPHAL_RENDER_ASSERTMESSAGE("Color Space Not found.");
                eStatus = MOS_STATUS_INVALID_PARAMETER;
                goto finish;
            }
        }

        if (StageEnables.EOTFEnable)
        {
            if ((!pSrc->pHDRParams) ||
                (pSrc->pHDRParams &&
                 (pSrc->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
                  pSrc->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR)))
            {
                // Mark tranditional HDR/SDR gamma as the same type
                CurrentEOTF = VPHAL_GAMMA_TRADITIONAL_GAMMA;
            }
            else if (pSrc->pHDRParams &&
                     pSrc->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
            {
                CurrentEOTF = VPHAL_GAMMA_SMPTE_ST2084;
            }
            else if (pSrc->pHDRParams &&
                     pSrc->pHDRParams->EOTF == VPHAL_HDR_EOTF_BT1886)
            {
                CurrentEOTF = VPHAL_GAMMA_BT1886;
            }
            else
            {
                VPHAL_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
                eStatus = MOS_STATUS_INVALID_PARAMETER;
                goto finish;
            }
        }

        if (StageEnables.OETFEnable)
        {
            if ((!pTarget->pHDRParams) ||
                (pTarget->pHDRParams &&
                 (pTarget->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
                  pTarget->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR)))
            {
                CurrentOETF = VPHAL_GAMMA_SRGB;
            }
            else if (pTarget->pHDRParams &&
                     pTarget->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
            {
                CurrentOETF = VPHAL_GAMMA_SMPTE_ST2084;
            }
            else
            {
                VPHAL_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
                eStatus = MOS_STATUS_INVALID_PARAMETER;
                goto finish;
            }
        }

        // OETF will output RGB surface
        // So if post CSC is needed, it will always be RGB to YUV conversion
        if (StageEnables.PostCSCEnable)
        {
            if (pTarget->ColorSpace == CSpace_BT601)
            {
                CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT601;
            }
            else if (pTarget->ColorSpace == CSpace_BT709)
            {
                CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT709;
            }
            else if (pHdrState->bVeboxpreprocessed && pTarget->ColorSpace == CSpace_BT709_FullRange)
            {
                // CSC for target BT709_FULLRANGE is only exposed to Vebox Preprocessed HDR cases.
                CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT709_FULLRANGE;
            }
            else if (pTarget->ColorSpace == CSpace_BT2020 ||
                     pTarget->ColorSpace == CSpace_BT2020_FullRange)
            {
                CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT2020;
            }
            else
            {
                VPHAL_RENDER_ASSERTMESSAGE("Color Space Not found.");
                eStatus = MOS_STATUS_INVALID_PARAMETER;
                goto finish;
            }
        }

        if (pHdrState->LUTMode[i]   != CurrentLUTMode  ||
            pHdrState->EOTFGamma[i] != CurrentEOTF     ||
            pHdrState->OETFGamma[i] != CurrentOETF     ||
            pHdrState->CCM[i]       != CurrentCCM      ||
            pHdrState->CCMExt1[i]   != CurrentCCMExt1  ||
            pHdrState->CCMExt2[i]   != CurrentCCMExt2  ||
            pHdrState->HdrMode[i]   != CurrentHdrMode  ||
            pHdrState->PriorCSC[i]  != CurrentPriorCSC ||
            pHdrState->PostCSC[i]   != CurrentPostCSC)
        {
            *pdwUpdateMask |= (1 << i);
        }
        
        if (pSrc->pHDRParams)
        {
            if (memcmp(pSrc->pHDRParams, &pHdrState->HDRLastFrameSourceParams[i], sizeof(VPHAL_HDR_PARAMS)))
            {
                *pdwUpdateMask |= (1 << i);
                pHdrState->HDRLastFrameSourceParams[i] = *pSrc->pHDRParams;
            }
        }
        else
        {
            MOS_ZeroMemory(&pHdrState->HDRLastFrameSourceParams[i], sizeof(VPHAL_HDR_PARAMS));
        }

        pHdrState->LUTMode[i]          = CurrentLUTMode;
        pHdrState->EOTFGamma[i]        = CurrentEOTF;
        pHdrState->OETFGamma[i]        = CurrentOETF;
        pHdrState->CCM[i]              = CurrentCCM;
        pHdrState->CCMExt1[i]          = CurrentCCMExt1;
        pHdrState->CCMExt2[i]          = CurrentCCMExt2;
        pHdrState->HdrMode[i]          = CurrentHdrMode;
        pHdrState->PriorCSC[i]         = CurrentPriorCSC;
        pHdrState->PostCSC[i]          = CurrentPostCSC;
        pHdrState->StageEnableFlags[i] = StageEnables;
    }

    if (pTarget->pHDRParams)
    {
        if (memcmp(pTarget->pHDRParams, &pHdrState->HDRLastFrameTargetParams, sizeof(VPHAL_HDR_PARAMS)))
        {
            *pdwUpdateMask |= (1 << VPHAL_MAX_HDR_INPUT_LAYER);
            pHdrState->HDRLastFrameTargetParams = *pTarget->pHDRParams;
        }
    }
    else
    {
        MOS_ZeroMemory(&pHdrState->HDRLastFrameTargetParams, sizeof(VPHAL_HDR_PARAMS));
    }
    pHdrState->dwUpdateMask = *pdwUpdateMask;
    eStatus = MOS_STATUS_SUCCESS;

finish:
    return eStatus;
}

//!
//! \brief    Checks to see if HDR is needed and supported
//! \details  Checks to see if HDR is needed and supported
//! \param    pRenderer
//            [in] Pointer to VphalRenderer
//! \param    pBeNeeded
//!           [out] 1 Needed 0 not Needed
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrIsNeeded(
    VphalRenderer         *pRenderer,
    bool*                  pBeNeeded)
{
    MOS_STATUS                  eStatus;
    eStatus = MOS_STATUS_SUCCESS;

    VPHAL_PUBLIC_CHK_NULL(pRenderer);
    VPHAL_PUBLIC_CHK_NULL(pBeNeeded);

    // Check whether Hdr is supported by platform
    if (!MEDIA_IS_SKU(pRenderer->GetSkuTable(), FtrHDR) ||
         pRenderer->pHdrState->bDisableRender)
    {
        *pBeNeeded = false;
        VPHAL_RENDER_ASSERTMESSAGE("Hdr not enabled or disabled for this platform.");
        goto finish;
    }

    *pBeNeeded = true;

finish:
    return eStatus;
}

//!
//! \brief    Set up HDR Render Data
//! \details  Set up HDR render data, including kernel information, input surface's block size
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to HDR state
//! \param    PVPHAL_HDR_RENDER_DATA pRenderData
//!           [out] Pointer to HDR render data
//! \param    int32_t iKUID
//!           [in] Kernel unique ID
//! \param    int32_t iKDTIndex
//            [in] KDT index.
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrSetupRenderData(
    PVPHAL_HDR_STATE        pHdrState,
    PVPHAL_HDR_RENDER_DATA  pRenderData,
    int32_t                 iKUID,
    int32_t                 iKDTIndex)
{
    int32_t                         iBlockWd;                                       // Block width
    int32_t                         iBlockHt;                                       // Block Height
    MOS_STATUS                      eStatus;                                        // Return code
    PRENDERHAL_INTERFACE            pRenderHal;
    Kdll_CacheEntry                 *pCacheEntryTable;                              // Kernel Cache Entry table
    PVPHAL_SURFACE                  pSrcSurface;
    uint32_t                        dwSrcWidth;
    uint32_t                        dwSrcHeight;
    uint32_t                        i;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pHdrState->pRenderHal);

    MOS_ZeroMemory(pRenderData, sizeof(VPHAL_HDR_RENDER_DATA));

    // Initialize Variables
    eStatus = MOS_STATUS_SUCCESS;

    if (iKDTIndex == KERNEL_HDR_MANDATORY_G9)
    {
        for (i = 0; i < pHdrState->uSourceCount; i++)
        {
            if (pHdrState->pSrcSurf[i])
            {
                if (pHdrState->pSrcSurf[i]->SurfType == SURF_IN_PRIMARY)
                {
                    if (pHdrState->pSrcSurf[i]->pIEFParams)
                    {
                        pRenderData->pIEFParams = pHdrState->pSrcSurf[i]->pIEFParams;
                    }


                    if (pHdrState->pSrcSurf[i]->Rotation == VPHAL_ROTATION_IDENTITY ||
                        pHdrState->pSrcSurf[i]->Rotation == VPHAL_ROTATION_180 ||
                        pHdrState->pSrcSurf[i]->Rotation == VPHAL_MIRROR_HORIZONTAL ||
                        pHdrState->pSrcSurf[i]->Rotation == VPHAL_MIRROR_VERTICAL)
                    {
                        pRenderData->fPrimaryLayerScaleX = (float)(pHdrState->pSrcSurf[i]->rcDst.right - pHdrState->pSrcSurf[i]->rcDst.left) /
                                                           (float)(pHdrState->pSrcSurf[i]->rcSrc.right - pHdrState->pSrcSurf[i]->rcSrc.left);
                        pRenderData->fPrimaryLayerScaleY = (float)(pHdrState->pSrcSurf[i]->rcDst.bottom - pHdrState->pSrcSurf[i]->rcDst.top) /
                                                           (float)(pHdrState->pSrcSurf[i]->rcSrc.bottom - pHdrState->pSrcSurf[i]->rcSrc.top);
                    }
                    else
                    {
                        // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 || 
                        // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
                        pRenderData->fPrimaryLayerScaleX = (float)(pHdrState->pSrcSurf[i]->rcDst.right - pHdrState->pSrcSurf[i]->rcDst.left) /
                                                           (float)(pHdrState->pSrcSurf[i]->rcSrc.bottom - pHdrState->pSrcSurf[i]->rcSrc.top);
                        pRenderData->fPrimaryLayerScaleY = (float)(pHdrState->pSrcSurf[i]->rcDst.bottom - pHdrState->pSrcSurf[i]->rcDst.top) /
                                                           (float)(pHdrState->pSrcSurf[i]->rcSrc.right - pHdrState->pSrcSurf[i]->rcSrc.left);
                    }

                    pRenderData->PrimaryLayerFormat = pHdrState->pSrcSurf[i]->Format;
                }
            }
        }

        // Store pointer to Kernel Parameter
        pRenderData->pKernelParam[iKDTIndex] = &pHdrState->pKernelParamTable[iKDTIndex];
        pCacheEntryTable                     = pHdrState->pKernelCache->pCacheEntries;

        VPHAL_RENDER_CHK_NULL(pCacheEntryTable);

        // Set Parameters for Kernel Entry
        MOS_ZeroMemory(&pRenderData->KernelEntry[iKDTIndex], sizeof(Kdll_CacheEntry));

        // Set the curbe length
        pRenderData->iCurbeLength = (pRenderData->pKernelParam[iKDTIndex]->CURBE_Length) * GRF_SIZE;

        // Set Parameters for Kernel Entry
        pRenderData->KernelEntry[iKDTIndex].iKUID   = iKUID;
        pRenderData->KernelEntry[iKDTIndex].iKCID   = -1;
        pRenderData->KernelEntry[iKDTIndex].iSize   = pCacheEntryTable[iKUID].iSize;
        pRenderData->KernelEntry[iKDTIndex].pBinary = pCacheEntryTable[iKUID].pBinary;
        pRenderData->KernelEntry[iKDTIndex].szName  = pCacheEntryTable[iKUID].szName;

        pRenderData->PerfTag  = (VPHAL_PERFTAG)(VPHAL_HDR_GENERIC + pHdrState->uSourceCount);

        // Get per block resulution
        iBlockWd = pRenderData->pKernelParam[iKDTIndex]->block_width;
        iBlockHt = pRenderData->pKernelParam[iKDTIndex]->block_height;

        // Calcualte block numbers to process
        dwSrcWidth            = pHdrState->pTargetSurf[0]->rcDst.right - pHdrState->pTargetSurf[0]->rcDst.left;
        dwSrcHeight           = pHdrState->pTargetSurf[0]->rcDst.bottom - pHdrState->pTargetSurf[0]->rcDst.top;
        pRenderData->iBlocksX = (dwSrcWidth + iBlockWd - 1) / iBlockWd;
        pRenderData->iBlocksY = (dwSrcHeight + iBlockHt -1) / iBlockHt;

        // Set up Scoreboard parameters
        pRenderData->ScoreboardParams.ScoreboardMask = 0;
        pRenderData->ScoreboardParams.ScoreboardType = 1;

        // Set up AVS parameters
        pRenderData->pAVSParameters[0] = &pHdrState->AVSParameters[0];
        pRenderData->pAVSParameters[1] = &pHdrState->AVSParameters[1];
    }
    else if (iKDTIndex == KERNEL_HDR_PREPROCESS)
    {
        // Store pointer to Kernel Parameter
        pRenderData->pKernelParam[iKDTIndex] = &pHdrState->pKernelParamTable[iKDTIndex];
        pCacheEntryTable = pHdrState->pKernelCache->pCacheEntries;

        VPHAL_RENDER_CHK_NULL(pCacheEntryTable);

        // Set Parameters for Kernel Entry
        MOS_ZeroMemory(&pRenderData->KernelEntry[iKDTIndex], sizeof(Kdll_CacheEntry));

        // Set the curbe length
        pRenderData->iCurbeLength = (pRenderData->pKernelParam[iKDTIndex]->CURBE_Length) * GRF_SIZE;

        // Set Parameters for Kernel Entry
        pRenderData->KernelEntry[iKDTIndex].iKUID = iKUID;
        pRenderData->KernelEntry[iKDTIndex].iKCID = -1;
        pRenderData->KernelEntry[iKDTIndex].iSize = pCacheEntryTable[iKUID].iSize;
        pRenderData->KernelEntry[iKDTIndex].pBinary = pCacheEntryTable[iKUID].pBinary;
        pRenderData->KernelEntry[iKDTIndex].szName = pCacheEntryTable[iKUID].szName;

        // Set up Scoreboard parameters
        pRenderData->ScoreboardParams.ScoreboardMask = 0;
        pRenderData->ScoreboardParams.ScoreboardType = 1;
    }
    else
    {
        VPHAL_RENDER_ASSERTMESSAGE("Unknown HDR kernel");
        eStatus = MOS_STATUS_UNKNOWN;
        goto finish;
    }

finish:
    return eStatus;
}

//!
//! \brief    HDR HW States Setup
//! \details  Setup HW states for HDR
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to the HDR State
//! \param    PVPHAL_HDR_RENDER_DATA pRenderData
//!           [in,out] Pointer to HDR render data
//! \param    PVPHAL_HDR_RENDER_DATA pRenderData
//!           [in,out] Pointer to HDR render data
//! \param    uint32_t HDRKernelID
//!           [in] HDR Kernel ID
//! \return   MOS_STATUS
//!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrSetupHwStates(
    PVPHAL_HDR_STATE            pHdrState,
    PVPHAL_HDR_RENDER_DATA      pRenderData,
    uint32_t                    HDRKernelID)
{
    PRENDERHAL_INTERFACE        pRenderHal           = nullptr;
    int32_t                     iKrnAllocation       = 0;
    int32_t                     iCurbeOffset         = 0;
    MOS_STATUS                  eStatus              = MOS_STATUS_SUCCESS;
    MHW_KERNEL_PARAM            MhwKernelParam       = {};
    PMOS_INTERFACE              pOsInterface         = nullptr;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pHdrState->pOsInterface);
    
    pRenderHal   = pHdrState->pRenderHal;
    pOsInterface = pHdrState->pOsInterface;
    VPHAL_RENDER_CHK_NULL(pRenderHal);

    //----------------------------------
    // Allocate and reset media state
    //----------------------------------
    pRenderData->pMediaState = pRenderHal->pfnAssignMediaState(pRenderHal, (RENDERHAL_COMPONENT)RENDERHAL_COMPONENT_HDR);
    MOS_OS_CHK_NULL(pRenderData->pMediaState);

    //----------------------------------
    // Allocate and reset SSH instance
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignSshInstance(pRenderHal));

    //----------------------------------
    // Assign and Reset Binding Table
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignBindingTable(
        pRenderHal, 
        &pRenderData->iBindingTable));

    //----------------------------------
    // Setup Surface states
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnSetupSurfaceStates(
        pHdrState,
        pRenderData));

    //----------------------------------
    // Load Static data
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnLoadStaticData(
        pHdrState,
        pRenderData,
        &iCurbeOffset));

    //----------------------------------
    // Setup VFE State params. Each Renderer MUST call pfnSetVfeStateParams().
    // See comment in VpHal_HwSetVfeStateParams() for details.
    //----------------------------------
    pRenderHal->pfnSetVfeStateParams(
        pRenderHal,
        MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING,
        pRenderData->pKernelParam[HDRKernelID]->Thread_Count,
        pRenderData->iCurbeLength,
        0,
        nullptr);

    //----------------------------------
    // Load kernel to GSH
    //----------------------------------
    INIT_MHW_KERNEL_PARAM(MhwKernelParam, &pRenderData->KernelEntry[HDRKernelID]);    

    iKrnAllocation = pRenderHal->pfnLoadKernel(
        pRenderHal,
        pRenderData->pKernelParam[HDRKernelID],
        &MhwKernelParam,
        nullptr);

    if (iKrnAllocation < 0)
    {
        VPHAL_RENDER_ASSERTMESSAGE("HDR Load kernel to GSH failed");
        eStatus = MOS_STATUS_UNKNOWN;
        goto finish;
    }

    //----------------------------------
    // Allocate Media ID, link to kernel
    //----------------------------------
    pRenderData->iMediaID = pRenderHal->pfnAllocateMediaID(
        pRenderHal,
        iKrnAllocation,
        pRenderData->iBindingTable,
        iCurbeOffset,
        pRenderData->iCurbeLength,
        0,
        nullptr);

    if (pRenderData->iMediaID < 0) 
    {
        VPHAL_RENDER_ASSERTMESSAGE("HDR Allocate Media ID failed");
        eStatus = MOS_STATUS_UNKNOWN;
        goto finish;
    }

    //----------------------------------
    // Setup Sampler states
    //----------------------------------
    if (HDRKernelID != KERNEL_HDR_PREPROCESS)
    {
        VPHAL_RENDER_CHK_STATUS(pHdrState->pfnSetSamplerStates(
            pHdrState,
            pRenderData));
    }

finish:
    VPHAL_RENDER_ASSERT(eStatus == MOS_STATUS_SUCCESS);
    return eStatus;
}

//!
//! \brief    Setup media walker command for HDR
//! \details  Setup media walker command for HDR
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to HDR state
//! \param    PVPHAL_HDR_RENDER_DATA pRenderData
//!           [in] Pointer to render data
//! \param    PMHW_WALKER_PARAMS pWalkerParams
//!           [out] Pointer to media walker parameters
//! \param    int32_t iKDTIndex
//            [in] KDT index.
//! \param    uint32_t uiPortionIndex
//            [in] Frame split portion index.
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_PreprocessHdrSetupWalkerObject(
    PVPHAL_HDR_STATE            pHdrState,
    PVPHAL_HDR_RENDER_DATA      pRenderData,
    PMHW_WALKER_PARAMS          pWalkerParams,
    int32_t                     iKDTIndex,
    uint32_t                    uiPortionIndex)
{
    MOS_STATUS  eStatus       = MOS_STATUS_SUCCESS;
    uint32_t threadswidth     = 1;
    uint32_t threadsheight    = VPHAL_MAX_HDR_INPUT_LAYER;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pWalkerParams);

    // Setup Media Walker cmd. Raster scan with no dependency
    MOS_ZeroMemory(pWalkerParams, sizeof(MHW_WALKER_PARAMS));
    pWalkerParams->InterfaceDescriptorOffset = pRenderData->iMediaID;
    pWalkerParams->dwGlobalLoopExecCount = 1;
    pWalkerParams->dwLocalLoopExecCount  = 1;
    pWalkerParams->BlockResolution.x  = threadswidth;
    pWalkerParams->BlockResolution.y  = threadsheight;
    pWalkerParams->GlobalResolution.x = threadswidth;
    pWalkerParams->GlobalResolution.y = threadsheight;


    pWalkerParams->GlobalStart.x = 0;
    pWalkerParams->GlobalStart.y = 0;
    pWalkerParams->GlobalOutlerLoopStride.x = threadswidth;
    pWalkerParams->GlobalOutlerLoopStride.y = 0;
    pWalkerParams->GlobalInnerLoopUnit.x = 0;
    pWalkerParams->GlobalInnerLoopUnit.y = threadsheight;
    pWalkerParams->LocalStart.x = 0;
    pWalkerParams->LocalStart.y = 0;
    pWalkerParams->LocalOutLoopStride.x = 1;
    pWalkerParams->LocalOutLoopStride.y = 0;
    pWalkerParams->LocalInnerLoopUnit.x = 0;
    pWalkerParams->LocalInnerLoopUnit.y = 1;
    pWalkerParams->LocalEnd.x = 0;
    pWalkerParams->LocalEnd.y = threadsheight - 1;

    eStatus = MOS_STATUS_SUCCESS;

finish:
    return eStatus;
}

//!
//! \brief    Render GpGpu Walker Buffer
//! \details  Render GpGpu Walker Buffer, fill Walker static data fields and set walker
//!           cmd params
//! \param    [in] pHdrState
//!           Pointer to HdrState
//! \param    [in] pRenderingData
//!           Pointer to Rendering Data
//! \param    [in] pWalkerParams
//!           Pointer to Walker parameters
//! \return   MOS_STATUS
//!           Return MOS_STATUS_SUCCESS if successful, otherwise false
//!
MOS_STATUS Vphal_HdrSetupComputeWalker(
    PVPHAL_HDR_STATE                pHdrState,
    PVPHAL_HDR_RENDER_DATA          pRenderData,
    PMHW_GPGPU_WALKER_PARAMS        pWalkerParams)
{
    MOS_STATUS                          eStatus                 = MOS_STATUS_UNINITIALIZED;
    PRENDERHAL_INTERFACE                pRenderHal              = nullptr;
    PVPHAL_BB_COMP_ARGS                 pBbArgs                 = nullptr;
    bool                                bResult                 = false;
    int32_t                             iLayers                 = 0;
    uint32_t                            uiMediaWalkerBlockSize  = 0;
    uint32_t*                           pdwDestXYTopLeft        = nullptr;
    uint32_t*                           pdwDestXYBottomRight    = nullptr;
    RECT                                AlignedRect             = {};
    bool                                bVerticalPattern        = false;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pHdrState->pTargetSurf[0]);
    VPHAL_RENDER_CHK_NULL(pHdrState->pSrcSurf[0]);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pWalkerParams);

    pRenderHal              = pHdrState->pRenderHal;
    VPHAL_RENDER_CHK_NULL(pRenderHal);

    bVerticalPattern        = false;
    AlignedRect             = pHdrState->pTargetSurf[0]->rcDst;

    // Get media walker kernel block size
    uiMediaWalkerBlockSize  = pRenderHal->pHwSizes->dwSizeMediaWalkerBlock;

    // Calculate aligned output area in order to determine the total # blocks
    // to process in case of non-16x16 aligned target.
    AlignedRect.right       += uiMediaWalkerBlockSize - 1;
    AlignedRect.bottom      += uiMediaWalkerBlockSize - 1;
    AlignedRect.left        -= AlignedRect.left   % uiMediaWalkerBlockSize;
    AlignedRect.top         -= AlignedRect.top    % uiMediaWalkerBlockSize;
    AlignedRect.right       -= AlignedRect.right  % uiMediaWalkerBlockSize;
    AlignedRect.bottom      -= AlignedRect.bottom % uiMediaWalkerBlockSize;

    // Set walker cmd params - Rasterscan
    pWalkerParams->InterfaceDescriptorOffset = pRenderData->iMediaID;

    if (pHdrState->uSourceCount == 1 &&
        pHdrState->pSrcSurf[0]->TileType == MOS_TILE_LINEAR &&
        (pHdrState->pSrcSurf[0]->Rotation == VPHAL_ROTATION_90 || pHdrState->pSrcSurf[0]->Rotation == VPHAL_ROTATION_270))
    {
        pWalkerParams->GroupStartingX       = (AlignedRect.top / uiMediaWalkerBlockSize);
        pWalkerParams->GroupStartingY       = (AlignedRect.left / uiMediaWalkerBlockSize);
        pWalkerParams->GroupWidth           = pRenderData->iBlocksY;
        pWalkerParams->GroupHeight          = pRenderData->iBlocksX;
    }
    else
    {
        pWalkerParams->GroupStartingX       = (AlignedRect.left / uiMediaWalkerBlockSize);
        pWalkerParams->GroupStartingY       = (AlignedRect.top / uiMediaWalkerBlockSize);
        pWalkerParams->GroupWidth           = pRenderData->iBlocksX;
        pWalkerParams->GroupHeight          = pRenderData->iBlocksY;
    }

    pWalkerParams->ThreadWidth              = 1;
    pWalkerParams->ThreadHeight             = 1;
    pWalkerParams->ThreadDepth              = 1;
    pWalkerParams->IndirectDataStartAddress = pRenderData->iCurbeOffset;
    // Indirect Data Length is a multiple of 64 bytes (size of L3 cacheline). Bits [5:0] are zero.
    pWalkerParams->IndirectDataLength       = MOS_ALIGN_CEIL(pRenderData->iCurbeLength, 1 << MHW_COMPUTE_INDIRECT_SHIFT);
    pWalkerParams->BindingTableID           = pRenderData->iBindingTable;

    eStatus = MOS_STATUS_SUCCESS;

finish:
    return eStatus;
}

//!
//! \brief    HDR render
//! \details  Launch HDR kernel to render output picture
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Poniter to HDR state
//! \param    PVPHAL_RENDER_PARAMS pRenderParams
//!           [in,out] Pointer to Render parameters
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrRender(
    PVPHAL_HDR_STATE             pHdrState,
    PVPHAL_RENDER_PARAMS         pRenderParams)
{
    PRENDERHAL_INTERFACE            pRenderHal              = nullptr;
    PMOS_INTERFACE                  pOsInterface            = nullptr;
    MHW_WALKER_PARAMS               WalkerParams            = {};
    PMHW_WALKER_PARAMS              pWalkerParams           = nullptr;
    MHW_GPGPU_WALKER_PARAMS         ComputeWalkerParams     = {};
    PMHW_GPGPU_WALKER_PARAMS        pComputeWalkerParams    = nullptr;
    int32_t                         iKUID                   = 0;
    int32_t                         iKDTIndex               = 0;
    uint32_t                        i                       = 0;
    bool                            bSupported              = true;
    MOS_STATUS                      eStatus                 = MOS_STATUS_UNKNOWN;
    uint32_t                        HdrKernel               = 0;
    VPHAL_HDR_RENDER_DATA           RenderData              = {};
    MOS_GPU_CONTEXT                 RenderGpuContext        = MOS_GPU_CONTEXT_RENDER;
    bool                            bLastSummit             = true;

    VPHAL_RENDER_FUNCTION_ENTER;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pRenderParams);
    VPHAL_RENDER_CHK_NULL(pHdrState->pRenderHal);
    VPHAL_RENDER_CHK_NULL(pHdrState->pOsInterface);

    // Initialize Variables
    pRenderHal                = pHdrState->pRenderHal;
    pOsInterface              = pHdrState->pOsInterface;
    pWalkerParams             = &WalkerParams;
    pHdrState->uSourceCount   = 0;
    pHdrState->uTargetCount   = 0;
    pRenderParams             = (VPHAL_RENDER_PARAMS*)pRenderParams;

    RenderGpuContext          = pOsInterface ? (pOsInterface->CurrentGpuContextOrdinal) : MOS_GPU_CONTEXT_RENDER;
    pComputeWalkerParams      = nullptr;
    MOS_ZeroMemory(&ComputeWalkerParams, sizeof(ComputeWalkerParams));

    if (pRenderParams->uSrcCount > VPHAL_MAX_HDR_INPUT_LAYER)
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        goto finish;
    }
    if (pRenderParams->uDstCount > VPHAL_MAX_HDR_OUTPUT_LAYER)
    {
        eStatus = MOS_STATUS_INVALID_PARAMETER;
        goto finish;
    }

    HdrKernel = KERNEL_HDR_MANDATORY;
    
    for (i = 0; i < pRenderParams->uSrcCount; i++)
    {
        if (pRenderParams->pSrc[i] == nullptr)
        {
            continue;
        }

        VPHAL_RENDER_CHK_STATUS(pHdrState->pfnIsInputFormatSupported(pRenderParams->pSrc[i], &bSupported));

        if (!bSupported)
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            goto finish;
        }

        pHdrState->pSrcSurf[i] = pRenderParams->pSrc[i];
        pHdrState->uSourceCount++;

        // Ensure the input is ready to be read
        pOsInterface->pfnSyncOnResource(
            pOsInterface, 
            &pHdrState->pSrcSurf[i]->OsResource,
            RenderGpuContext,
            false);
    }

    for (i = 0; i < pRenderParams->uDstCount; i++)
    {
        if (pRenderParams->pTarget[i] == nullptr)
        {
            continue;
        }

        VPHAL_RENDER_CHK_STATUS(pHdrState->pfnIsOutputFormatSupported(pRenderParams->pTarget[i], &bSupported));

        if (!bSupported)
        {
            eStatus = MOS_STATUS_INVALID_PARAMETER;
            goto finish;
        }


        pHdrState->pTargetSurf[i] = pRenderParams->pTarget[i];
        pHdrState->uTargetCount++;

        // Ensure the output is ready to be written
        pOsInterface->pfnSyncOnResource(
            pOsInterface, 
            &pHdrState->pTargetSurf[i]->OsResource,
            RenderGpuContext,
            true);

        // Sync Render Target with Overlay Context
        if (pHdrState->pTargetSurf[i]->bOverlay)
        {
            pOsInterface->pfnSyncOnOverlayResource(
                pOsInterface,
                &pHdrState->pTargetSurf[i]->OsResource,
                RenderGpuContext);
        }
    }

    pHdrState->pColorFillParams = pRenderParams->pColorFillParams;
    // Allocate resources needed by Hdr
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnAllocateResources(pHdrState));
    VPHAL_RENDER_CHK_STATUS(VpHal_HdrPreprocess(pHdrState, pRenderParams));    

    for (i = 0; i < pHdrState->uiSplitFramePortions; i++)
    {
        // Reset states before rendering
        // (clear allocations, get GSH allocation index + any additional housekeeping)
        pOsInterface->pfnResetOsStates(pOsInterface);
        VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnReset(pRenderHal));

        // Get the Kernel Parameter (Platform Specific)
        VPHAL_RENDER_CHK_STATUS(pHdrState->pfnGetKernelParam(
            HdrKernel,
            &iKUID,
            &iKDTIndex));

        // Setup Hdr render data
        VPHAL_RENDER_CHK_STATUS(VpHal_HdrSetupRenderData(
            pHdrState,
            &RenderData,
            iKUID,
            iKDTIndex));

        // Set up HW States and Commands
        VPHAL_RENDER_CHK_STATUS(VpHal_HdrSetupHwStates(pHdrState, &RenderData, iKDTIndex));

        // Set Perf Tag
        pOsInterface->pfnResetPerfBufferID(pOsInterface);
        pOsInterface->pfnSetPerfTag(pOsInterface, RenderData.PerfTag);

        if (pHdrState->bFtrComputeWalker)
        {
            // Setup Compute Walker
            pWalkerParams = nullptr;
            pComputeWalkerParams = &ComputeWalkerParams;

            VPHAL_RENDER_CHK_STATUS(Vphal_HdrSetupComputeWalker(
                pHdrState,
                &RenderData,
                &ComputeWalkerParams));
        }
        else
        {
            // Setup Media Walker Object
            VpHal_HdrSetupWalkerObject(
                pHdrState,
                &RenderData,
                &WalkerParams,
                iKDTIndex,
                i);
        }

        bLastSummit = (i == (pHdrState->uiSplitFramePortions - 1) ? true : false);
        // Submit all media states to HW
        VPHAL_RENDER_CHK_STATUS(VpHal_RndrSubmitCommands(
            pRenderHal,
            nullptr,
            pHdrState->bNullHwRenderHdr,
            pWalkerParams,
            pComputeWalkerParams,
            &pHdrState->StatusTableUpdateParams,
            (VpKernelID)kernelHdrMandatory,
            0,
            nullptr,
            bLastSummit));
    }

    eStatus = MOS_STATUS_SUCCESS;

finish:
    VPHAL_RENDER_EXITMESSAGE("eStatus %d", eStatus);
    return eStatus;
}

//!
//! \brief    Hdr init renderer interface
//! \details  Initializes the Hdr interface
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to Hdr state
//! \param    PRENDERHAL_INTERFACE pRenderHal
//!           [in] Pointer to RENDERHAL interface
//! \return   void
//!
MOS_STATUS VpHal_HdrInitInterface(
    PVPHAL_HDR_STATE          pHdrState,
    PRENDERHAL_INTERFACE      pRenderHal)
{
    MOS_STATUS                  eStatus         = MOS_STATUS_SUCCESS;
    PMOS_INTERFACE              pOsInterface    = nullptr;

    VPHAL_PUBLIC_CHK_NULL(pHdrState);
    VPHAL_PUBLIC_CHK_NULL(pRenderHal);

    MOS_ZeroMemory(pHdrState, sizeof(VPHAL_HDR_STATE));

    pOsInterface = pRenderHal->pOsInterface;

    VPHAL_PUBLIC_CHK_NULL(pOsInterface);

    // Set interface to OS and HW interfaces
    pHdrState->pRenderHal                 = pRenderHal;
    pHdrState->pOsInterface               = pOsInterface;
    pHdrState->pSkuTable                  = pOsInterface->pfnGetSkuTable(pOsInterface);

    // Setup Function Pointers
    pHdrState->pfnInitialize              = VpHal_HdrInitialize;
    pHdrState->pfnDestroy                 = VpHal_HdrDestroy;
    pHdrState->pfnRender                  = VpHal_HdrRender;
    pHdrState->pfnIsNeeded                = VpHal_HdrIsNeeded;

    eStatus = MOS_STATUS_SUCCESS;

finish:
    return eStatus;
}

//! \brief    Perform Rendering HDR step
//! \details  Check whether HDR is needed. When it's needed, perform HDR
//!           operation
//! \param    [in,out] pRenderer
//!           VPHAL renderer pointer
//! \param    [in,out] pRenderParams
//!           Pointer to VPHAL render parameter
//! \param    [in,out] pRenderPassData
//!           Pointer to the VPHAL render pass data
//! \return   MOS_STATUS
//!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_RndrRenderHDR(
    VphalRenderer           *pRenderer,
    PVPHAL_RENDER_PARAMS    pRenderParams,
    RenderpassData          *pRenderPassData)
{
    PRENDERHAL_INTERFACE    *pRenderHal = nullptr;
    MOS_STATUS              eStatus     = MOS_STATUS_SUCCESS;
    bool                    bEnabled    = false;

    VPHAL_RENDER_FUNCTION_ENTER;

    VPHAL_RENDER_CHK_NULL(pRenderer);
    VPHAL_RENDER_CHK_NULL(pRenderParams);
    VPHAL_RENDER_CHK_NULL(pRenderPassData);
    VPHAL_RENDER_CHK_NULL(pRenderer->pHdrState);

    pRenderHal = &pRenderer->pHdrState->pRenderHal;
    VPHAL_RENDER_CHK_NULL(pRenderHal);

    // Disable bEnableP010SinglePass for HDR path, to avoid AVS sampler and 1 planes 3D sampler path in kernel.
    // Kernel solution only support 2 planes rendering of 3D sampler.
    if ((*pRenderHal)->bEnableP010SinglePass)
    {
        bEnabled = true;
        (*pRenderHal)->bEnableP010SinglePass = false;
    }
    eStatus = pRenderer->pHdrState->pfnRender(pRenderer->pHdrState, pRenderParams);

    if (bEnabled)
       (*pRenderHal)->bEnableP010SinglePass = true;

finish:
    VPHAL_RENDER_EXITMESSAGE("eStatus %d", eStatus);
    return eStatus;
}

//!
//! \brief    Check if HDR path is needed
//! \details  Check if HDR path is needed
//! \param    [in] pRenderer
//!           VPHAL renderer pointer
//! \param    [in] pRenderParams
//!           Pointer to VPHAL render parameter
//! \param    [in] pRenderPassData
//!           Pointer to VPHAL render pass data
//! \return   bool
//!
bool VpHal_RndrIsHdrPathNeeded(
    VphalRenderer           *pRenderer,
    PVPHAL_RENDER_PARAMS    pRenderParams,
    RenderpassData          *pRenderPassData)
{
    if (!pRenderer || !pRenderParams || !pRenderPassData)
    {
        return false;
    }

    if (pRenderPassData->bHdrNeeded && pRenderer->pHdrState)
    {
        // Hdr kernel render will be disabled for 1 layer H2H bypass case for PnP optimization
        if (!pRenderer->pHdrState->bBypassHdrKernelPath)
        {
            return true;
        }
    }

    return false;
}

//!
//! \brief    Setup media walker command for HDR
//! \details  Setup media walker command for HDR
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Pointer to HDR state
//! \param    PVPHAL_HDR_RENDER_DATA pRenderData
//!           [in] Pointer to render data
//! \param    PMHW_WALKER_PARAMS pWalkerParams
//!           [out] Pointer to media walker parameters
//! \param    int32_t iKDTIndex
//            [in] KDT index.
//! \param    uint32_t uiPortionIndex
//            [in] Frame split portion index.
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrSetupWalkerObject(
    PVPHAL_HDR_STATE            pHdrState,
    PVPHAL_HDR_RENDER_DATA      pRenderData,
    PMHW_WALKER_PARAMS          pWalkerParams,
    int32_t                     iKDTIndex,
    uint32_t                    uiPortionIndex)
{
    MOS_STATUS                  eStatus        =  MOS_STATUS_SUCCESS;
    RECT                        AlignedRect    = {};
    int32_t                     iBlockWd       = 0;                                       // Block Width
    int32_t                     iBlockHt       = 0;                                       // Block Height

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pHdrState->pTargetSurf[0]);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pWalkerParams);

    AlignedRect = pHdrState->pTargetSurf[0]->rcDst;
    iBlockWd = pRenderData->pKernelParam[iKDTIndex]->block_width;
    iBlockHt = pRenderData->pKernelParam[iKDTIndex]->block_height;

    AlignedRect.right += iBlockWd - 1;
    AlignedRect.bottom += iBlockHt - 1;
    AlignedRect.left -= AlignedRect.left   % iBlockWd;
    AlignedRect.top -= AlignedRect.top    % iBlockHt;
    AlignedRect.right -= AlignedRect.right  % iBlockWd;
    AlignedRect.bottom -= AlignedRect.bottom % iBlockHt;

    // Setup Media Walker cmd. Raster scan with no dependency
    MOS_ZeroMemory(pWalkerParams, sizeof(MHW_WALKER_PARAMS));
    pWalkerParams->InterfaceDescriptorOffset = pRenderData->iMediaID;
    pWalkerParams->dwGlobalLoopExecCount = 1;
    pWalkerParams->dwLocalLoopExecCount = pRenderData->iBlocksX - 1;
    pWalkerParams->BlockResolution.x = pRenderData->iBlocksX;
    pWalkerParams->BlockResolution.y = pRenderData->iBlocksY;

    if (AlignedRect.left != 0 || AlignedRect.top != 0)
    {
        // if the rect starts from any other macro block other than the first
        // then the global resolution should be the whole frame and the global 
        // start should be the rect start.
        pWalkerParams->GlobalResolution.x =
            (AlignedRect.right / iBlockWd);
        pWalkerParams->GlobalResolution.y =
            (AlignedRect.bottom / iBlockHt);
    }
    else
    {
        pWalkerParams->GlobalResolution.x = pRenderData->iBlocksX;
        pWalkerParams->GlobalResolution.y = pRenderData->iBlocksY;
    }

    pWalkerParams->GlobalStart.x = (AlignedRect.left / iBlockWd);
    pWalkerParams->GlobalStart.y = (AlignedRect.top / iBlockHt);
    pWalkerParams->GlobalOutlerLoopStride.x = pRenderData->iBlocksX;
    pWalkerParams->GlobalOutlerLoopStride.y = 0;
    pWalkerParams->GlobalInnerLoopUnit.x = 0;
    pWalkerParams->GlobalInnerLoopUnit.y = pRenderData->iBlocksY;
    pWalkerParams->LocalStart.x = 0;
    pWalkerParams->LocalStart.y = 0;
    pWalkerParams->LocalOutLoopStride.x = 1;
    pWalkerParams->LocalOutLoopStride.y = 0;
    pWalkerParams->LocalInnerLoopUnit.x = 0;
    pWalkerParams->LocalInnerLoopUnit.y = 1;
    pWalkerParams->LocalEnd.x = 0;
    pWalkerParams->LocalEnd.y = pRenderData->iBlocksY - 1;

    if (pHdrState->uiSplitFramePortions > 1)
    {
        pWalkerParams->GlobalStart.x = MOS_MAX(MOS_ROUNDUP_DIVIDE(pWalkerParams->GlobalResolution.x, pHdrState->uiSplitFramePortions) * (uiPortionIndex),
            pWalkerParams->GlobalStart.x);
        pWalkerParams->GlobalResolution.x = MOS_MIN(MOS_ROUNDUP_DIVIDE(pWalkerParams->GlobalResolution.x, pHdrState->uiSplitFramePortions) * (uiPortionIndex + 1),
            pWalkerParams->GlobalResolution.x);
    }

    eStatus = MOS_STATUS_SUCCESS;

finish:
    return eStatus;
}

//!
//! \brief    HDR preprocess
//! \details  Launch HDR pre process kernel to render hdr coefficients surface
//! \param    PVPHAL_HDR_STATE pHdrState
//!           [in] Poniter to HDR state
//! \param    PVPHAL_RENDER_PARAMS pRenderParams
//!           [in,out] Pointer to Render parameters
//! \return   MOS_STATUS
//!           MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS VpHal_HdrPreprocess(
    PVPHAL_HDR_STATE        pHdrState,
    PVPHAL_RENDER_PARAMS    pRenderParams)
{
    MOS_STATUS                    eStatus               = MOS_STATUS_UNKNOWN;
    PRENDERHAL_INTERFACE          pRenderHal            = nullptr;
    PMOS_INTERFACE                pOsInterface          = nullptr;
    uint32_t                      HdrKernel             = KERNEL_HDR_PREPROCESS;
    MOS_GPU_CONTEXT               RenderGpuContext      = MOS_GPU_CONTEXT_RENDER;
    int32_t                       iKUID                 = 0;
    int32_t                       iKDTIndex             = 0;
    VPHAL_HDR_RENDER_DATA         RenderData            = {};
    bool                          bLastSummit           = true;
    MHW_WALKER_PARAMS             WalkerParams          = {};
    PMHW_WALKER_PARAMS            pWalkerParams         = nullptr;
    MHW_GPGPU_WALKER_PARAMS       ComputeWalkerParams   = {};
    PMHW_GPGPU_WALKER_PARAMS      pComputeWalkerParams  = nullptr;
    uint32_t                      i                     = 0;
    int32_t                       iCurbeOffset          = 0;
    const uint32_t                HDRKernelID           = KERNEL_HDR_PREPROCESS;
    MHW_KERNEL_PARAM              MhwKernelParam        = {};
    int32_t                       iKrnAllocation        = 0;

    VPHAL_RENDER_FUNCTION_ENTER;

    VPHAL_RENDER_CHK_NULL(pHdrState);
    VPHAL_RENDER_CHK_NULL(pRenderParams);
    VPHAL_RENDER_CHK_NULL(pHdrState->pRenderHal);
    VPHAL_RENDER_CHK_NULL(pHdrState->pOsInterface);

    // HDR PreProcess Kernel is needed only if HDR metada is changed.
    if (!pHdrState->dwUpdateMask)
    {
        VPHAL_RENDER_EXITMESSAGE("pHdrState->dwUpdateMask is false, no need to update coefficients, exit with MOS_STATUS_SUCCESS!");
        return MOS_STATUS_SUCCESS;
    }

    // Initialize Variables
    pRenderHal          = pHdrState->pRenderHal;
    pOsInterface        = pHdrState->pOsInterface;
    RenderGpuContext    = pOsInterface->CurrentGpuContextOrdinal;

    // Reset states before rendering
    // (clear allocations, get GSH allocation index + any additional housekeeping)
    pOsInterface->pfnResetOsStates(pOsInterface);
    VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnReset(pRenderHal));

    // Get the Kernel Parameter (Platform Specific)
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnGetKernelParam(
        HdrKernel,
        &iKUID,
        &iKDTIndex));

    // Setup Hdr render data
    VPHAL_RENDER_CHK_STATUS(VpHal_HdrSetupRenderData(
        pHdrState,
        &RenderData,
        iKUID,
        iKDTIndex));

    //----------------------------------
    // Allocate and reset media state
    //----------------------------------
    RenderData.pMediaState = pRenderHal->pfnAssignMediaState(pRenderHal, (RENDERHAL_COMPONENT)RENDERHAL_COMPONENT_HDR);
    MOS_OS_CHK_NULL(RenderData.pMediaState);

    //----------------------------------
    // Allocate and reset SSH instance
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignSshInstance(pRenderHal));

    //----------------------------------
    // Assign and Reset Binding Table
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnAssignBindingTable(
        pRenderHal,
        &RenderData.iBindingTable));

    //----------------------------------
   // Setup Surface states
   //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnSetupPreSurfaceStates(
        pHdrState,
        &RenderData));

    //----------------------------------
    // Load Static data
    //----------------------------------
    VPHAL_RENDER_CHK_STATUS(pHdrState->pfnLoadPreStaticData(
        pHdrState,
        &RenderData,
        &iCurbeOffset));

    //----------------------------------
    // Setup VFE State params. Each Renderer MUST call pfnSetVfeStateParams().
    // See comment in VpHal_HwSetVfeStateParams() for details.
    //----------------------------------
    pRenderHal->pfnSetVfeStateParams(
        pRenderHal,
        MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING,
        RenderData.pKernelParam[HDRKernelID]->Thread_Count,
        RenderData.iCurbeLength,
        0,
        nullptr);

    //----------------------------------
    // Load kernel to GSH
    //----------------------------------
    INIT_MHW_KERNEL_PARAM(MhwKernelParam, &RenderData.KernelEntry[HDRKernelID]);

    iKrnAllocation = pRenderHal->pfnLoadKernel(
        pRenderHal,
        RenderData.pKernelParam[HDRKernelID],
        &MhwKernelParam,
        nullptr);

    if (iKrnAllocation < 0)
    {
        VPHAL_RENDER_ASSERTMESSAGE("HDR Load kernel to GSH failed");
        eStatus = MOS_STATUS_UNKNOWN;
        goto finish;
    }

    //----------------------------------
    // Allocate Media ID, link to kernel
    //----------------------------------
    RenderData.iMediaID = pRenderHal->pfnAllocateMediaID(
        pRenderHal,
        iKrnAllocation,
        RenderData.iBindingTable,
        iCurbeOffset,
        RenderData.iCurbeLength,
        0,
        nullptr);

    if (RenderData.iMediaID < 0)
    {
        VPHAL_RENDER_ASSERTMESSAGE("HDR Allocate Media ID failed");
        eStatus = MOS_STATUS_UNKNOWN;
        goto finish;
    }

    // Set Perf Tag
    pOsInterface->pfnResetPerfBufferID(pOsInterface);
    pOsInterface->pfnSetPerfTag(pOsInterface, RenderData.PerfTag);

    if (pHdrState->bFtrComputeWalker)
    {
        // Setup Compute Walker
        pWalkerParams = nullptr;
        pComputeWalkerParams = &ComputeWalkerParams;

        VPHAL_RENDER_CHK_STATUS(Vphal_HdrSetupComputeWalker(
            pHdrState,
            &RenderData,
            &ComputeWalkerParams));
    }
    else
    {
        // Setup Media Walker Object
        VpHal_PreprocessHdrSetupWalkerObject(
            pHdrState,
            &RenderData,
            &WalkerParams,
            iKDTIndex,
            0);
    }

    // Submit all media states to HW
    VPHAL_RENDER_CHK_STATUS(VpHal_RndrSubmitCommands(
        pRenderHal,
        nullptr,
        pHdrState->bNullHwRenderHdr,
        &WalkerParams,
        &ComputeWalkerParams,
        &pHdrState->StatusTableUpdateParams,
        (VpKernelID)kernelHdrPreprocess,
        0,
        nullptr,
        bLastSummit));

#if (_DEBUG || _RELEASE_INTERNAL)
    if (sEnableKernelDump)
    {
        VphalSurfaceDumper surfaceDumper(pOsInterface);
        std::string fileName("Preprocessed_HDRMandatory_coefficient_8x98");
        surfaceDumper.DumpSurfaceToFile(pOsInterface, &pHdrState->CoeffSurface, fileName.c_str(), 0, true, false, nullptr);
    }
#endif

    eStatus = MOS_STATUS_SUCCESS;

finish:
    VPHAL_RENDER_EXITMESSAGE("eStatus %d", eStatus);
    return eStatus;
}


//!
//! \brief    Calculate Yuv Range and Offest
//! \details  Calculate Yuv Range and Offest
//! \param    VPHAL_CSPACE cspace
//!           [in] Source color space
//! \param    float* pLumaOffset
//!           [out] Pointer to Luma Offset
//! \param    float* pLumaExcursion 
//!           [out] Pointer to Luma Excursion
//! \param    float* pChromaZero
//!           [out] Pointer to Chroma Offset
//! \param    float* pChromaExcursion
//!           [out] Pointer to Chroma Excursion
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrGetYuvRangeAndOffset(
    VPHAL_CSPACE cspace,
    float*       pLumaOffset,
    float*       pLumaExcursion,
    float*       pChromaZero,
    float*       pChromaExcursion)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    VPHAL_PUBLIC_CHK_NULL(pLumaOffset);
    VPHAL_PUBLIC_CHK_NULL(pLumaExcursion);
    VPHAL_PUBLIC_CHK_NULL(pChromaZero);
    VPHAL_PUBLIC_CHK_NULL(pChromaExcursion);

    switch (cspace)
    {
    case CSpace_BT601_FullRange:
    case CSpace_BT709_FullRange:
    case CSpace_BT601Gray_FullRange:
        *pLumaOffset = 0.0f;
        *pLumaExcursion = 255.0f;
        *pChromaZero = 128.0f;
        *pChromaExcursion = 255.0f;
        break;

    case CSpace_BT601:
    case CSpace_BT709:
    case CSpace_xvYCC601: // since matrix is the same as 601, use the same range
    case CSpace_xvYCC709: // since matrix is the same as 709, use the same range
    case CSpace_BT601Gray:
    case CSpace_BT2020:
    case CSpace_BT2020_FullRange:
        *pLumaOffset = 16.0f;
        *pLumaExcursion = 219.0f;
        *pChromaZero = 128.0f;
        *pChromaExcursion = 224.0f;
        break;

    default:
        *pLumaOffset = 0.0f;
        *pLumaExcursion = 255.0f;
        *pChromaZero = 128.0f;
        *pChromaExcursion = 255.0f;
        break;
    }

    *pLumaOffset /= 255.0f;
    *pLumaExcursion /= 255.0f;
    *pChromaZero /= 255.0f;
    *pChromaExcursion /= 255.0f;

finish:
    return eStatus;
}

//!
//! \brief    Calculate Rgb Range and Offest
//! \details  Calculate Rgb Range and Offest
//! \param    VPHAL_CSPACE cspace
//!           [in] Source color space
//! \param    float* pLumaOffset
//!           [out] Pointer to Rgb Offset
//! \param    float* pLumaExcursion 
//!           [out] Pointer to Rgb Excursion
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrGetRgbRangeAndOffset(
    VPHAL_CSPACE cspace,
    float*       pRgbOffset,
    float*       pRgbExcursion)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    VPHAL_PUBLIC_CHK_NULL(pRgbOffset);
    VPHAL_PUBLIC_CHK_NULL(pRgbExcursion);

    switch (cspace)
    {
    case CSpace_sRGB:
        *pRgbOffset = 0.0f;
        *pRgbExcursion = 255.0f;
        break;

    case CSpace_stRGB:
    case CSpace_BT2020_stRGB:
        *pRgbOffset = 16.0f;
        *pRgbExcursion = 219.0f;
        break;

    default:
        *pRgbOffset = 0.0f;
        *pRgbExcursion = 255.0f;
        break;
    }

    *pRgbOffset /= 255.0f;
    *pRgbExcursion /= 255.0f;

finish:
    return eStatus;
}

//!
//! \brief    Calculate Yuv To Rgb Matrix
//! \details  Calculate Yuv To Rgb Matrix
//! \param    VPHAL_CSPACE src
//!           [in] Source color space
//! \param    VPHAL_CSPACE dst
//!           [in] Dest color space
//! \param    float* pTransferMatrix
//!           [in] Pointer to input transfer matrix
//! \param    float* pOutMatrix
//!           [out] Pointer to output transfer matrix for curbe
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrCalcYuvToRgbMatrix(
    VPHAL_CSPACE    src,
    VPHAL_CSPACE    dst,
    float*          pTransferMatrix,
    float*          pOutMatrix)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
    float   Y_o = 0.0f, Y_e = 0.0f, C_z = 0.0f, C_e = 0.0f;
    float   R_o = 0.0f, R_e = 0.0f;

    VPHAL_PUBLIC_CHK_NULL(pTransferMatrix);
    VPHAL_PUBLIC_CHK_NULL(pOutMatrix);

    VpHal_HdrGetRgbRangeAndOffset(dst, &R_o, &R_e);
    VpHal_HdrGetYuvRangeAndOffset(src, &Y_o, &Y_e, &C_z, &C_e);

    // after + (3x3)(3x3)
    pOutMatrix[0] = pTransferMatrix[0] * R_e / Y_e;
    pOutMatrix[4] = pTransferMatrix[4] * R_e / Y_e;
    pOutMatrix[8] = pTransferMatrix[8] * R_e / Y_e;
    pOutMatrix[1] = pTransferMatrix[1] * R_e / C_e;
    pOutMatrix[5] = pTransferMatrix[5] * R_e / C_e;
    pOutMatrix[9] = pTransferMatrix[9] * R_e / C_e;
    pOutMatrix[2] = pTransferMatrix[2] * R_e / C_e;
    pOutMatrix[6] = pTransferMatrix[6] * R_e / C_e;
    pOutMatrix[10] = pTransferMatrix[10] * R_e / C_e;

    // (3x1) - (3x3)(3x3)(3x1)
    pOutMatrix[3] = R_o - (pOutMatrix[0] * Y_o + pOutMatrix[1] * C_z + pOutMatrix[2] * C_z);
    pOutMatrix[7] = R_o - (pOutMatrix[4] * Y_o + pOutMatrix[5] * C_z + pOutMatrix[6] * C_z);
    pOutMatrix[11] = R_o - (pOutMatrix[8] * Y_o + pOutMatrix[9] * C_z + pOutMatrix[10] * C_z);

finish:
    return eStatus;
}

//!
//! \brief    Calculate Rgb To Yuv Matrix
//! \details  Calculate Rgb To Yuv Matrix
//! \param    VPHAL_CSPACE src
//!           [in] Source color space
//! \param    VPHAL_CSPACE dst
//!           [in] Dest color space
//! \param    float* pTransferMatrix
//!           [in] Pointer to input transfer matrix
//! \param    float* pOutMatrix
//!           [out] Pointer to output transfer matrix for curbe
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrCalcRgbToYuvMatrix(
    VPHAL_CSPACE    src,
    VPHAL_CSPACE    dst,
    float*          pTransferMatrix,
    float*          pOutMatrix)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
    float   Y_o = 0.0f, Y_e = 0.0f, C_z = 0.0f, C_e = 0.0f;
    float   R_o = 0.0f, R_e = 0.0f;

    VPHAL_PUBLIC_CHK_NULL(pTransferMatrix);
    VPHAL_PUBLIC_CHK_NULL(pOutMatrix);

    VpHal_HdrGetRgbRangeAndOffset(src, &R_o, &R_e);
    VpHal_HdrGetYuvRangeAndOffset(dst, &Y_o, &Y_e, &C_z, &C_e);

    // multiplication of + onwards
    pOutMatrix[0] = pTransferMatrix[0] * Y_e / R_e;
    pOutMatrix[1] = pTransferMatrix[1] * Y_e / R_e;
    pOutMatrix[2] = pTransferMatrix[2] * Y_e / R_e;
    pOutMatrix[4] = pTransferMatrix[4] * C_e / R_e;
    pOutMatrix[5] = pTransferMatrix[5] * C_e / R_e;
    pOutMatrix[6] = pTransferMatrix[6] * C_e / R_e;
    pOutMatrix[8] = pTransferMatrix[8] * C_e / R_e;
    pOutMatrix[9] = pTransferMatrix[9] * C_e / R_e;
    pOutMatrix[10] = pTransferMatrix[10] * C_e / R_e;

    pOutMatrix[7] = Y_o - Y_e * R_o / R_e;
    pOutMatrix[3] = C_z;
    pOutMatrix[11] = C_z;

finish:
    return eStatus;
}

//!
//! \brief    Calculate CCM Matrix
//! \details  Calculate CCM Matrix
//! \param    float* pTransferMatrix
//!           [in] Pointer to input transfer matrix
//! \param    float* pOutMatrix
//!           [out] Pointer to output transfer matrix for curbe
//! \return   MOS_STATUS
//!
MOS_STATUS VpHal_HdrCalcCCMMatrix(
    float*          pTransferMatrix,
    float*          pOutMatrix)
{
    MOS_STATUS  eStatus = MOS_STATUS_SUCCESS;

    VPHAL_PUBLIC_CHK_NULL(pTransferMatrix);
    VPHAL_PUBLIC_CHK_NULL(pOutMatrix);

    // multiplication of + onwards
    pOutMatrix[0] = pTransferMatrix[1];
    pOutMatrix[1] = pTransferMatrix[2];
    pOutMatrix[2] = pTransferMatrix[0];
    pOutMatrix[4] = pTransferMatrix[5];
    pOutMatrix[5] = pTransferMatrix[6];
    pOutMatrix[6] = pTransferMatrix[4];
    pOutMatrix[8] = pTransferMatrix[9];
    pOutMatrix[9] = pTransferMatrix[10];
    pOutMatrix[10] = pTransferMatrix[8];

    pOutMatrix[3] = pTransferMatrix[11];
    pOutMatrix[7] = pTransferMatrix[3];
    pOutMatrix[11] = pTransferMatrix[7];

finish:
    return eStatus;
}