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

// Max number of source info to be dumped into OCA.
#define MAX_NUMBER_OF_SOURCE_INFO_IN_OCA_BUFFER 8
// Max number of target info to be dumped into OCA.
#define MAX_NUMBER_OF_TARGET_INFO_IN_OCA_BUFFER 4

VphalOcaDumper::VphalOcaDumper()
{
}

VphalOcaDumper::~VphalOcaDumper()
{
    MOS_DeleteArray(m_pOcaRenderParam);
}

void VphalOcaDumper::Delete(void *&p)
{
    VphalOcaDumper *pOcaDumpter =  (VphalOcaDumper *)p;
    MOS_Delete(pOcaDumpter);
    p = nullptr;
}

void VphalOcaDumper::SetRenderParam(VPHAL_RENDER_PARAMS *pRenderParams)
{
    if (nullptr == pRenderParams)
    {
        return;
    }

    uint32_t uSrcCountDumped = MOS_MIN(pRenderParams->uSrcCount, MAX_NUMBER_OF_SOURCE_INFO_IN_OCA_BUFFER);
    uint32_t uDstCountDumped = MOS_MIN(pRenderParams->uDstCount, MAX_NUMBER_OF_TARGET_INFO_IN_OCA_BUFFER);

    uint32_t size = sizeof(VPHAL_OCA_RENDER_PARAM) + uSrcCountDumped * sizeof(VPHAL_OCA_SOURCE_INFO) +
        uDstCountDumped * sizeof(VPHAL_OCA_TARGET_INFO);
    uint32_t allocSize = size;

    if (m_pOcaRenderParam)
    {
        if (allocSize > m_pOcaRenderParam->Header.allocSize)
        {
            MOS_DeleteArray(m_pOcaRenderParam);
        }
        else
        {
            // Reuse previous buffer.
            allocSize = m_pOcaRenderParam->Header.allocSize;
        }
    }

    if (nullptr == m_pOcaRenderParam)
    {
        m_pOcaRenderParam = (VPHAL_OCA_RENDER_PARAM *)MOS_NewArray(char, allocSize);
        if (nullptr == m_pOcaRenderParam)
        {
            return;
        }
    }
    MOS_ZeroMemory(m_pOcaRenderParam, size);

    m_pOcaRenderParam->Header.size          = size;
    m_pOcaRenderParam->Header.allocSize     = allocSize;
    m_pOcaRenderParam->Component            = pRenderParams->Component;

    if (pRenderParams->uSrcCount > 0 && pRenderParams->pSrc[0])
    {
        m_pOcaRenderParam->FrameID = pRenderParams->pSrc[0]->FrameID;
    }

    m_pOcaRenderParam->Pid = MosUtilities::MosGetPid();

    m_pOcaRenderParam->uSrcCount = pRenderParams->uSrcCount;
    m_pOcaRenderParam->uDstCount = pRenderParams->uDstCount;
    m_pOcaRenderParam->uSrcCountDumped = uSrcCountDumped;
    m_pOcaRenderParam->uDstCountDumped = uDstCountDumped;

    if (pRenderParams->pColorFillParams)
    {
        m_pOcaRenderParam->ColorFillParams.params = *pRenderParams->pColorFillParams;
        m_pOcaRenderParam->ColorFillParams.bValid = true;
    }

    uint32_t offset = sizeof(VPHAL_OCA_RENDER_PARAM);
    VPHAL_OCA_SOURCE_INFO *pSource = uSrcCountDumped > 0 ? (VPHAL_OCA_SOURCE_INFO *)((char*)m_pOcaRenderParam + offset) : nullptr;
    offset += uSrcCountDumped * sizeof(VPHAL_OCA_SOURCE_INFO);
    VPHAL_OCA_TARGET_INFO *pTarget = uDstCountDumped > 0 ? (VPHAL_OCA_TARGET_INFO *)((char*)m_pOcaRenderParam + offset) : nullptr;

    if (pSource)
    {
        for (uint32_t i = 0; i < uSrcCountDumped; ++i)
        {
            if (pRenderParams->pSrc[i])
            {
                InitSourceInfo(pSource[i], *(VPHAL_SURFACE *)pRenderParams->pSrc[i]);
            }
        }
    }

    if (pTarget)
    {
        for (uint32_t i = 0; i < uDstCountDumped; ++i)
        {
            if (pRenderParams->pTarget[i])
            {
                InitTargetInfo(pTarget[i], *(VPHAL_SURFACE *)pRenderParams->pTarget[i]);
            }
        }
    }
}

void VphalOcaDumper::InitSurfInfo(VPHAL_OCA_SURFACE_INFO &surfInfo, VPHAL_SURFACE &surf)
{
    surfInfo.Format        = surf.Format;
    surfInfo.SurfType      = surf.SurfType;
    surfInfo.SampleType    = surf.SampleType;
    surfInfo.ColorSpace    = surf.ColorSpace;
    surfInfo.ScalingMode   = surf.ScalingMode;
    surfInfo.TileType      = surf.TileType;
    surfInfo.dwWidth       = surf.dwWidth;
    surfInfo.dwHeight      = surf.dwHeight;
    surfInfo.dwPitch       = surf.dwPitch;
    surfInfo.rcSrc         = surf.rcSrc;
    surfInfo.rcDst         = surf.rcDst;
}

void VphalOcaDumper::InitSourceInfo(VPHAL_OCA_SOURCE_INFO &sourceInfo, VPHAL_SURFACE &source)
{
    InitSurfInfo(sourceInfo.surfInfo, source);
    sourceInfo.Rotation         = source.Rotation;
    sourceInfo.iPalette         = source.iPalette;
    sourceInfo.PaletteParams    = source.Palette;

    if (source.pBlendingParams)
    {
        sourceInfo.BlendingParams.params = *source.pBlendingParams;
        sourceInfo.BlendingParams.bValid = true;
    }

    if (source.pLumaKeyParams)
    {
        sourceInfo.LumaKeyParams.params = *source.pLumaKeyParams;
        sourceInfo.LumaKeyParams.bValid = true;
    }

    if (source.pProcampParams)
    {
        sourceInfo.ProcampParams.params = *source.pProcampParams;
        sourceInfo.ProcampParams.bValid = true;
    }

    if (source.pIEFParams)
    {
        sourceInfo.IEFParams.params = *source.pIEFParams;
        sourceInfo.IEFParams.bValid = true;
    }

    if (source.pDeinterlaceParams)
    {
        sourceInfo.DIParams.params = *source.pDeinterlaceParams;
        sourceInfo.DIParams.bValid = true;
    }

    if (source.pDenoiseParams)
    {
        sourceInfo.DNParams.params = *source.pDenoiseParams;
        sourceInfo.DNParams.bValid = true;
    }

    if (source.pColorPipeParams)
    {
        sourceInfo.ColorPipeParams.params = *source.pColorPipeParams;
        sourceInfo.ColorPipeParams.bValid = true;
    }

    if (source.uBwdRefCount > 0)
    {
        sourceInfo.BwdRefInfo.uBwdRefCount  = source.uBwdRefCount;
        sourceInfo.BwdRefInfo.bValid        = true;
    }

    if (source.uFwdRefCount > 0)
    {
        sourceInfo.FwdRefInfo.uFwdRefCount  = source.uFwdRefCount;
        sourceInfo.FwdRefInfo.bValid        = true;
    }

    if (source.pHDRParams)
    {
        sourceInfo.HDRParams.params = *source.pHDRParams;
        sourceInfo.HDRParams.bValid = true;
    }
}

void VphalOcaDumper::InitTargetInfo(VPHAL_OCA_TARGET_INFO &targetInfo, VPHAL_SURFACE &target)
{
    InitSurfInfo(targetInfo.surfInfo, target);

    if (target.pHDRParams)
    {
        targetInfo.HDRParams.params = *target.pHDRParams;
        targetInfo.HDRParams.bValid = true;
    }
}