/* * Copyright (c) 2017 - 2021, 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_vebox_iecp.cpp //! \brief VPHAL VEBOX Image Enhancement and Color Processing (IECP) interfaces //! \details VPHAL VEBOX Image Enhancement and Color Processing (IECP) interfaces //! #include "vphal_render_vebox_procamp.h" #include "vphal_render_vebox_ste.h" #include "vphal_render_vebox_tcc.h" #include "vphal_render_vebox_util_base.h" //! //! \brief Initial IECP filters //! \details Initial IECP filters. //! All avaliable opened IECP filters should add to m_filters array here. //! VPHAL_VEBOX_IECP_RENDERER::VPHAL_VEBOX_IECP_RENDERER() { int32_t i = 0; // add all avaliable opened IECP filters, max size is 15. #if VPHAL_RENDER_VEBOX_TCC_ENABLE m_filters[i++] = MOS_New(VPHAL_VEBOX_IECP_TCC); #endif // VPHAL_RENDER_VEBOX_TCC_ENABLE #if VPHAL_RENDER_VEBOX_STE_ENABLE m_filters[i++] = MOS_New(VPHAL_VEBOX_IECP_STE); #endif // VPHAL_RENDER_VEBOX_STE_ENABLE #if VPHAL_RENDER_VEBOX_PROCAMP_ENABLE m_filters[i++] = MOS_New(VPHAL_VEBOX_IECP_ProcAmp); #endif // VPHAL_RENDER_VEBOX_PROCAMP_ENABLE m_filters[i] = nullptr; m_filterCount = i; // Initial pointers as nullptr m_veboxState = nullptr; m_renderData = nullptr; } //! //! \brief Destroy IECP filters //! \details Destroy IECP filters. //! Delete allocated IECP filters. //! VPHAL_VEBOX_IECP_RENDERER::~VPHAL_VEBOX_IECP_RENDERER() { int32_t i = 0; for (i = 0; i < m_filterCount; i++) { if (m_filters[i]) { MOS_Delete(m_filters[i]); m_filters[i] = nullptr; } } } //! //! \brief Vebox set alpha parameter //! \details Setup Alpha Params //! \param [in] pOutSurface //! Pointer to output surface of Vebox //! \param [in,out] pVphalVeboxIecpParams //! Pointer to IECP parameter //! \return void //! void VPHAL_VEBOX_IECP_RENDERER::VeboxSetAlphaParams( PVPHAL_SURFACE pOutSurface, PVPHAL_VEBOX_IECP_PARAMS pVphalVeboxIecpParams) { PVPHAL_VEBOX_RENDER_DATA pRenderData = m_renderData; if (pRenderData->pAlphaParams != nullptr) { switch (pRenderData->pAlphaParams->AlphaMode) { case VPHAL_ALPHA_FILL_MODE_NONE: if (pOutSurface->Format == Format_A8R8G8B8 || pOutSurface->Format == Format_A8B8G8R8 || pOutSurface->Format == Format_R10G10B10A2 || pOutSurface->Format == Format_B10G10R10A2 || pOutSurface->Format == Format_AYUV) { pVphalVeboxIecpParams->wAlphaValue = (uint8_t)(0xff * pRenderData->pAlphaParams->fAlpha); } else if (pOutSurface->Format == Format_Y416) { pVphalVeboxIecpParams->wAlphaValue = (uint16_t)(0xffff * pRenderData->pAlphaParams->fAlpha); } else { pVphalVeboxIecpParams->wAlphaValue = 0xff; } break; // VEBOX does not support Background Color case VPHAL_ALPHA_FILL_MODE_BACKGROUND: // VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM case is hit when the // input does not have alpha // So we set Opaque alpha channel. case VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM: case VPHAL_ALPHA_FILL_MODE_OPAQUE: default: if (pOutSurface->Format == Format_Y416) { pVphalVeboxIecpParams->wAlphaValue = 0xffff; } else { pVphalVeboxIecpParams->wAlphaValue = 0xff; } break; } } else { pVphalVeboxIecpParams->wAlphaValue = 0xff; } } //! //! \brief Initial Vebox IECP state parameter //! \param [in] VphalColorSpace //! Vphal color space //! \param [in] pMhwVeboxIecpParams //! Pointer to Mhw Vebox IECP parameters //! \return MOS_STATUS //! MOS_STATUS VPHAL_VEBOX_IECP_RENDERER::InitParams( VPHAL_CSPACE VphalColorSpace, PMHW_VEBOX_IECP_PARAMS pMhwVeboxIecpParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PVPHAL_VEBOX_IECP_PARAMS pVphalVeboxIecpParams = m_renderData->GetVeboxIECPParams(); int32_t i = 0; VPHAL_RENDER_CHK_NULL(pMhwVeboxIecpParams); MOS_ZeroMemory(pMhwVeboxIecpParams, sizeof(*pMhwVeboxIecpParams)); for (i = 0; i < m_filterCount; i++) { VPHAL_RENDER_CHK_NULL(m_filters[i]); m_filters[i]->InitParams(pVphalVeboxIecpParams, pMhwVeboxIecpParams); } pMhwVeboxIecpParams->ColorSpace = VPHal_VpHalCspace2MhwCspace(VphalColorSpace); pMhwVeboxIecpParams->dstFormat = pVphalVeboxIecpParams->dstFormat; pMhwVeboxIecpParams->srcFormat = pVphalVeboxIecpParams->srcFormat; pMhwVeboxIecpParams->bCSCEnable = pVphalVeboxIecpParams->bCSCEnable; pMhwVeboxIecpParams->pfCscCoeff = pVphalVeboxIecpParams->pfCscCoeff; pMhwVeboxIecpParams->pfCscInOffset = pVphalVeboxIecpParams->pfCscInOffset; pMhwVeboxIecpParams->pfCscOutOffset = pVphalVeboxIecpParams->pfCscOutOffset; pMhwVeboxIecpParams->bAlphaEnable = pVphalVeboxIecpParams->bAlphaEnable; pMhwVeboxIecpParams->wAlphaValue = pVphalVeboxIecpParams->wAlphaValue; // Front End CSC pMhwVeboxIecpParams->bFeCSCEnable = pVphalVeboxIecpParams->bFeCSCEnable; pMhwVeboxIecpParams->pfFeCscCoeff = pVphalVeboxIecpParams->pfFeCscCoeff; pMhwVeboxIecpParams->pfFeCscInOffset = pVphalVeboxIecpParams->pfFeCscInOffset; pMhwVeboxIecpParams->pfFeCscOutOffset = pVphalVeboxIecpParams->pfFeCscOutOffset; finish: return eStatus; } //! //! \brief Vebox set IECP parameter //! \details Set Vebox IECP state parameter //! \param [in] pSrcSurface //! Pointer to input surface of Vebox //! \param [in] pOutSurface //! Pointer to output surface of Vebox //! \return void //! void VPHAL_VEBOX_IECP_RENDERER::SetParams( PVPHAL_SURFACE pSrcSurface, PVPHAL_SURFACE pOutSurface) { PVPHAL_VEBOX_STATE pVeboxState = m_veboxState; PVPHAL_VEBOX_RENDER_DATA pRenderData = m_renderData; PVPHAL_VEBOX_IECP_PARAMS pVphalVeboxIecpParams = m_renderData->GetVeboxIECPParams(); int32_t i = 0; for (i = 0; i < m_filterCount; i++) { if (m_filters[i]) { m_filters[i]->SetParams(pSrcSurface, m_renderData); } } pRenderData->GetVeboxStateParams()->pVphalVeboxIecpParams = pVphalVeboxIecpParams; // Check if Back End CSC is enabled in VEBOX if (pRenderData->bBeCsc) { // Calculate matrix if not done so before. CSC is expensive! if ((pVeboxState->CscInputCspace != pSrcSurface->ColorSpace) || (pVeboxState->CscOutputCspace != pOutSurface->ColorSpace)) { // Get the matrix to use for conversion pVeboxState->VeboxGetBeCSCMatrix( pSrcSurface, pOutSurface); // Store it for next BLT pVeboxState->CscInputCspace = pSrcSurface->ColorSpace; pVeboxState->CscOutputCspace = pOutSurface->ColorSpace; } // Copy the values into IECP Params pVphalVeboxIecpParams->bCSCEnable = true; pVphalVeboxIecpParams->pfCscCoeff = pVeboxState->fCscCoeff; pVphalVeboxIecpParams->pfCscInOffset = pVeboxState->fCscInOffset; pVphalVeboxIecpParams->pfCscOutOffset = pVeboxState->fCscOutOffset; // Set Alpha State if ((pOutSurface->Format == Format_A8R8G8B8) || (pOutSurface->Format == Format_A8B8G8R8) || (pOutSurface->Format == Format_X8R8G8B8)) { pVphalVeboxIecpParams->bAlphaEnable = true; VeboxSetAlphaParams(pOutSurface, pVphalVeboxIecpParams); } else { pVphalVeboxIecpParams->bAlphaEnable = false; } // Set the output format which can be referred by YUV_Channel_Swap bit pVphalVeboxIecpParams->dstFormat = pOutSurface->Format; // Set input foramt pVphalVeboxIecpParams->srcFormat = pSrcSurface->Format; } // If 3DLUT is enabled, Front End CSC needs to be enabled explicitly for YUV output if (pRenderData->bHdr3DLut) { if (IS_YUV_FORMAT(pOutSurface->Format) && (pVeboxState->CscOutputCspace != pOutSurface->ColorSpace)) { VPHAL_CSPACE outColorSpace = pOutSurface->ColorSpace; VPHAL_CSPACE inColorSpace = (IS_COLOR_SPACE_BT2020_YUV(pOutSurface->ColorSpace)) ? CSpace_BT2020_RGB : CSpace_sRGB; // Get the matrix to use for conversion VpHal_GetCscMatrix( inColorSpace, outColorSpace, pVeboxState->fFeCscCoeff, pVeboxState->fFeCscInOffset, pVeboxState->fFeCscOutOffset); // Copy the values into IECP Params pVphalVeboxIecpParams->bFeCSCEnable = true; pVphalVeboxIecpParams->pfFeCscCoeff = pVeboxState->fFeCscCoeff; pVphalVeboxIecpParams->pfFeCscInOffset = pVeboxState->fFeCscInOffset; pVphalVeboxIecpParams->pfFeCscOutOffset = pVeboxState->fFeCscOutOffset; } } else { pVphalVeboxIecpParams->bFeCSCEnable = false; } }