/* * Copyright (c) 2011-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_renderer.cpp //! \brief VPHAL top level rendering component and the entry to low level renderers //! \details The top renderer is responsible for coordinating the sequence of calls to low level renderers, e.g. DNDI or Comp //! #include "vphal_renderer.h" #include "vp_debug.h" #include "vpkrnheader.h" #include "vphal_render_composite.h" // Slice Shutdown User feature keys #define VPHAL_SSD_CONTROL "SSD Control" //=================================================================== //! //! \brief Initialize AVS parameters shared by Renderers //! \details Initialize the members of the AVS parameter and allocate memory for its coefficient tables //! \param [in,out] pAVS_Params //! Pointer to MHW AVS parameter //! \param [in] uiYCoeffTableSize //! Size of the Y coefficient table //! \param [in] uiUVCoeffTableSize //! Size of the UV coefficient table //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VpHal_RenderInitAVSParams( PMHW_AVS_PARAMS pAVS_Params, uint32_t uiYCoeffTableSize, uint32_t uiUVCoeffTableSize) { MOS_STATUS eStatus; int32_t size; char* ptr; VPHAL_RENDER_ASSERT(pAVS_Params); VPHAL_RENDER_ASSERT(uiYCoeffTableSize > 0); VPHAL_RENDER_ASSERT(uiUVCoeffTableSize > 0); eStatus = MOS_STATUS_SUCCESS; // Init AVS parameters pAVS_Params->Format = Format_None; pAVS_Params->fScaleX = 0.0F; pAVS_Params->fScaleY = 0.0F; pAVS_Params->piYCoefsX = nullptr; // Allocate AVS coefficients, One set each for X and Y size = (uiYCoeffTableSize + uiUVCoeffTableSize) * 2; ptr = (char*)MOS_AllocAndZeroMemory(size); if (ptr == nullptr) { VPHAL_RENDER_ASSERTMESSAGE("No memory to allocate AVS coefficient tables."); eStatus = MOS_STATUS_NO_SPACE; goto finish; } pAVS_Params->piYCoefsX = (int32_t*)ptr; ptr += uiYCoeffTableSize; pAVS_Params->piUVCoefsX = (int32_t*)ptr; ptr += uiUVCoeffTableSize; pAVS_Params->piYCoefsY = (int32_t*)ptr; ptr += uiYCoeffTableSize; pAVS_Params->piUVCoefsY = (int32_t*)ptr; finish: return eStatus; } //! //! \brief Destroy AVS parameters shared by Renderers //! \details Free the memory of AVS parameter's coefficient tables //! \param [in,out] pAVS_Params //! Pointer to VPHAL AVS parameter //! \return void //! void VpHal_RenderDestroyAVSParams( PMHW_AVS_PARAMS pAVS_Params) { MOS_SafeFreeMemory(pAVS_Params->piYCoefsX); pAVS_Params->piYCoefsX = nullptr; } //! //! \brief Get the size in byte from that in pixel //! \details Size_in_byte = size_in_pixel x byte/pixel //! \param [in] pOsInterface //! Pointer to OS interface //! \param [in] Format //! The format which determines the value of byte/pixel //! \param [in] dwPixels //! The size in pixel //! \return uint32_t //! Return the size in byte //! uint32_t VpHal_PixelsToBytes( PMOS_INTERFACE pOsInterface, MOS_FORMAT Format, uint32_t dwPixels) { MOS_STATUS eStatus; uint32_t iBpp; uint32_t dwBpp; eStatus = MOS_STATUS_SUCCESS; dwBpp = 0; VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnGetBitsPerPixel(pOsInterface, Format, &iBpp)); dwBpp = dwPixels * (iBpp>>3); finish: return dwBpp; } //! //! \brief Save/Restore fwd references for the primary //! \details Based on the flag passed in to save or restore the forward references //! of the primary //! \param [in,out] pRenderer //! VPHAL renderer pointer //! \param [in,out] pPrimarySurf //! Pointer to the primary surface //! \param [in] bSave //! Save - true or restore - false the fwd references //! \return void //! void VpHal_SaveRestorePrimaryFwdRefs( VphalRenderer *pRenderer, PVPHAL_SURFACE pPrimarySurf, bool bSave) { PVPHAL_SURFACE pFwdRef; uint32_t uiSources; uint32_t uiIndex; VPHAL_RENDER_ASSERT(pRenderer); VPHAL_RENDER_ASSERT(pPrimarySurf && (pPrimarySurf->SurfType == SURF_IN_PRIMARY)); pFwdRef = nullptr; uiSources = 0; uiIndex = 0; if (bSave) { pFwdRef = pPrimarySurf->pFwdRef; while(pFwdRef) { pRenderer->pPrimaryFwdRef[uiIndex] = pFwdRef; pFwdRef = pFwdRef->pFwdRef; uiIndex++; if (uiIndex >= VPHAL_MAX_FUTURE_FRAMES) { break; } } } else { pFwdRef = pPrimarySurf; while (pRenderer->pPrimaryFwdRef[uiIndex]) { pFwdRef->pFwdRef = pRenderer->pPrimaryFwdRef[uiIndex]; pRenderer->pPrimaryFwdRef[uiIndex] = nullptr; pFwdRef = pFwdRef->pFwdRef; uiIndex++; if (uiIndex >= VPHAL_MAX_FUTURE_FRAMES) { break; } } } } //! //! \brief Align the src/dst surface rectangle and surface width/height //! \details The surface rects and width/height need to be aligned according to the surface format //! \param [in,out] pSurface //! Pointer to the surface //! \param [in] formatForDstRect //! Format for Dst Rect //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VpHal_RndrRectSurfaceAlignment( PVPHAL_SURFACE pSurface, MOS_FORMAT formatForDstRect) { uint16_t wWidthAlignUnit; uint16_t wHeightAlignUnit; uint16_t wWidthAlignUnitForDstRect; uint16_t wHeightAlignUnitForDstRect; MOS_STATUS eStatus; eStatus = MOS_STATUS_SUCCESS; VpHal_RndrGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pSurface->Format); VpHal_RndrGetAlignUnit(&wWidthAlignUnitForDstRect, &wHeightAlignUnitForDstRect, formatForDstRect); // The source rectangle is floored to the aligned unit to // get rid of invalid data(ex: an odd numbered src rectangle with NV12 format // will have invalid UV data for the last line of Y data). pSurface->rcSrc.bottom = MOS_ALIGN_FLOOR((uint32_t)pSurface->rcSrc.bottom, wHeightAlignUnit); pSurface->rcSrc.right = MOS_ALIGN_FLOOR((uint32_t)pSurface->rcSrc.right, wWidthAlignUnit); pSurface->rcSrc.top = MOS_ALIGN_CEIL((uint32_t)pSurface->rcSrc.top, wHeightAlignUnit); pSurface->rcSrc.left = MOS_ALIGN_CEIL((uint32_t)pSurface->rcSrc.left, wWidthAlignUnit); // The Destination rectangle is rounded to the upper alignment unit to prevent the loss of // data which was present in the source rectangle pSurface->rcDst.bottom = MOS_ALIGN_CEIL((uint32_t)pSurface->rcDst.bottom, wHeightAlignUnitForDstRect); pSurface->rcDst.right = MOS_ALIGN_CEIL((uint32_t)pSurface->rcDst.right, wWidthAlignUnitForDstRect); pSurface->rcDst.top = MOS_ALIGN_FLOOR((uint32_t)pSurface->rcDst.top, wHeightAlignUnitForDstRect); pSurface->rcDst.left = MOS_ALIGN_FLOOR((uint32_t)pSurface->rcDst.left, wWidthAlignUnitForDstRect); if (pSurface->SurfType == SURF_OUT_RENDERTARGET) { pSurface->dwHeight = MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit); pSurface->dwWidth = MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit); } else { pSurface->dwHeight = MOS_ALIGN_FLOOR(pSurface->dwHeight, wHeightAlignUnit); pSurface->dwWidth = MOS_ALIGN_FLOOR(pSurface->dwWidth, wWidthAlignUnit); } if ((pSurface->rcSrc.top == pSurface->rcSrc.bottom) || (pSurface->rcSrc.left == pSurface->rcSrc.right) || (pSurface->rcDst.top == pSurface->rcDst.bottom) || (pSurface->rcDst.left == pSurface->rcDst.right) || (pSurface->dwWidth == 0) || (pSurface->dwHeight == 0)) { VPHAL_RENDER_ASSERTMESSAGE("Surface Parameter is invalid."); eStatus = MOS_STATUS_INVALID_PARAMETER; } return eStatus; } //! //! \brief Prepare input surface list for top level render processing //! \details Prepare the inputs, e.g. adjust src/dst rectangles of stereo input or allocate //! and copy intermediate surfaces. //! \param [in,out] pRenderParams //! Pointer to VPHAL render parameter //! \param [in,out] pSrcLeft //! Pointer to left frame list //! \param [in,out] pSrcRight //! Pointer to right frame list //! \param [out] puiRenderPasses //! Pointer to times of the rendering. //! The value is 2 for S3D and 1 for the other cases. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::PrepareSources( PVPHAL_RENDER_PARAMS pRenderParams, PVPHAL_SURFACE *pSrcLeft, PVPHAL_SURFACE *pSrcRight, uint32_t *puiRenderPasses) { MOS_STATUS eStatus; PVPHAL_SURFACE pcSrc; uint32_t uiLeftCount; uint32_t uiRightCount; uint32_t uiSources; uint32_t uiTargets; uint32_t uiIndex; PMOS_RESOURCE ppSource[VPHAL_MAX_SOURCES] = { nullptr }; PMOS_RESOURCE ppTarget[VPHAL_MAX_TARGETS] = { nullptr }; eStatus = MOS_STATUS_SUCCESS; uiLeftCount = 0; uiRightCount = 0; uiIndex = 0; uiSources = 0; uiTargets = 0; VPHAL_RENDER_CHK_NULL(m_pOsInterface); for (uiSources=0, uiIndex=0; (uiIndex < pRenderParams->uSrcCount) && (uiIndex < VPHAL_MAX_SOURCES); uiIndex++) { pcSrc = pRenderParams->pSrc[uiIndex]; if (pcSrc == nullptr) { continue; } ppSource[uiSources] = &pcSrc->OsResource; pSrcLeft[uiLeftCount++] = pcSrc; uiSources++; } //gather render target list for (uiTargets = 0, uiIndex = 0; (uiIndex < pRenderParams->uDstCount) && (uiIndex < VPHAL_MAX_TARGETS); uiIndex++) { pcSrc = pRenderParams->pTarget[uiIndex]; if (pcSrc) { ppTarget[uiTargets] = &pcSrc->OsResource; uiTargets++; } } VPHAL_RENDER_ASSERT(uiRightCount == 0); pRenderParams->uSrcCount = uiLeftCount; *puiRenderPasses = 1; finish: VPHAL_RENDER_ASSERT(eStatus == MOS_STATUS_SUCCESS); if ((nullptr != m_pOsInterface) && (nullptr != m_pOsInterface->osCpInterface)) { eStatus = m_pOsInterface->osCpInterface->PrepareResources( (void **)ppSource, uiSources, (void **)ppTarget, uiTargets); } return eStatus; } //! //! \brief Get surface info for all input source //! \details Get surface info for the input surface and its reference surfaces //! \param [in] pRenderParams //! Pointer to VPHAL render parameter //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::GetSurfaceInfoForSrc( PVPHAL_RENDER_PARAMS pRenderParams) { MOS_STATUS eStatus; PVPHAL_SURFACE pSrcSurface; // Current source surface PVPHAL_SURFACE pSurface; // Ptr to surface uint32_t uiSources; // Number of Sources uint32_t uiIndex; // Current source index uint32_t i; VPHAL_GET_SURFACE_INFO Info; eStatus = MOS_STATUS_SUCCESS; pSrcSurface = nullptr; // Loop through the sources for (uiSources = 0, uiIndex = 0; uiSources < pRenderParams->uSrcCount && uiIndex < VPHAL_MAX_SOURCES; uiIndex++) { pSrcSurface = pRenderParams->pSrc[uiIndex]; if (pSrcSurface == nullptr) { continue; } uiSources++; if (Mos_ResourceIsNull(&pSrcSurface->OsResource)) { VPHAL_RENDER_ASSERTMESSAGE("Input resource is not valid."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo( m_pOsInterface, &Info, pSrcSurface)); // Get resource info for Backward References, if any pSurface = pSrcSurface->pBwdRef; for (i = 0; i < pSrcSurface->uBwdRefCount; i++) { VPHAL_RENDER_ASSERT(pSurface); // Must have valid reference pointer if (pSurface) { MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo( m_pOsInterface, &Info, pSurface)); // point to the next bwd ref pSurface = pSurface->pBwdRef; } } // Get resource info for Forward References, if any pSurface = pSrcSurface->pFwdRef; for (i = 0; i < pSrcSurface->uFwdRefCount; i++) { VPHAL_RENDER_ASSERT(pSurface); // Must have valid reference pointer if (pSurface) { MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo( m_pOsInterface, &Info, pSurface)); // point to the next fwd ref pSurface = pSurface->pFwdRef; } } } finish: return eStatus; } //! //! \brief Adjust surface parameter //! \param [in] pRenderParams //! Pointer to VPHAL render parameter //! \param [in,out] pSrcSurface //! Pointer to VPHAL surface //! \param [in] pGtSystemInfo //! Pointer to GT system information structure //! \param [in] bHybridDecoderFlag //! Hybrid Decoder or not //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::AdjustSurfaceParam( PVPHAL_RENDER_PARAMS pRenderParams, PVPHAL_SURFACE pSrcSurface, MEDIA_SYSTEM_INFO *pGtSystemInfo, bool bHybridDecoderFlag) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; VPHAL_RENDER_CHK_NULL(pSrcSurface); VPHAL_RENDER_CHK_NULL(pRenderParams); VPHAL_RENDER_CHK_NULL(pGtSystemInfo); // Disable VP features for 4K (Sku flag or Hybrid) if (pSrcSurface->rcSrc.bottom >= pSrcSurface->rcSrc.top + VPHAL_RNDR_4K_HEIGHT) { // VEBOX timing on KBL ULT might be about 2x ms when DN is on, and it seems to be // in relation to the lag problem on WMP after scaling up & down the playback window. // Disable DN for 4K to resolve this phenomenon. if (bSkuDisableDNFor4K && pSrcSurface->pDenoiseParams) { pSrcSurface->pDenoiseParams->bAutoDetect = false; pSrcSurface->pDenoiseParams->bEnableChroma = false; pSrcSurface->pDenoiseParams->bEnableLuma = false; } // Disable features if needed if (bSkuDisableVpFor4K || bHybridDecoderFlag) { // Denoise if (pSrcSurface->pDenoiseParams) { pSrcSurface->pDenoiseParams->bAutoDetect = false; pSrcSurface->pDenoiseParams->bEnableChroma = false; pSrcSurface->pDenoiseParams->bEnableLuma = false; } // Sharpness(IEF) if (pSrcSurface->pIEFParams) { pSrcSurface->pIEFParams->bEnabled = false; } // STE, TCC if (pSrcSurface->pColorPipeParams) { pSrcSurface->pColorPipeParams->bEnableSTE = false; pSrcSurface->pColorPipeParams->bEnableTCC = false; } } } // IEF is only for Y luma component if (IS_RGB_FORMAT(pSrcSurface->Format) && pSrcSurface->pIEFParams) { VPHAL_RENDER_NORMALMESSAGE("IEF is only for Y luma component, and IEF is always disabled for RGB input."); pSrcSurface->pIEFParams->bEnabled = false; pSrcSurface->pIEFParams->fIEFFactor = 0.0f; } finish: return eStatus; } //! //! \brief Process render parameter //! \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 VphalRenderer::ProcessRenderParameter( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { MOS_STATUS eStatus; MEDIA_SYSTEM_INFO *pGtSystemInfo; uint32_t uiIndex; PVPHAL_SURFACE pSrcSurface; PVPHAL_SURFACE pPrimarySurface; PVPHAL_PROCAMP_PARAMS pProcampParams; bool bSingleSliceMode; bool bSliceReconfig; bool bHybridDecoderFlag; int32_t decoderFlag; #ifdef ANDROID RECT PrimOrigDstRect; bool bDstRectWANeeded = false; #endif eStatus = MOS_STATUS_SUCCESS; bHybridDecoderFlag = false; bSliceReconfig = false; pPrimarySurface = nullptr; // Get the hybrid decoder flag VPHAL_RENDER_CHK_STATUS(m_pOsInterface->pfnGetHybridDecoderRunningFlag(m_pOsInterface, &decoderFlag)); bHybridDecoderFlag = decoderFlag ? true : false; // Get the GT system information pGtSystemInfo = m_pOsInterface->pfnGetGtSystemInfo(m_pOsInterface); VPHAL_RENDER_CHK_NULL(pGtSystemInfo); pRender[VPHAL_RENDER_ID_COMPOSITE]->SetStatusReportParams(this, pRenderParams); pRender[VPHAL_RENDER_ID_VEBOX+uiCurrentChannel]->SetStatusReportParams(this, pRenderParams); // Decide whether Hdr path should be chosen. VPHAL_RENDER_CHK_STATUS(GetHdrPathNeededFlag(pRenderParams, pRenderPassData)); if (pRenderPassData->bHdrNeeded) { VPHAL_RNDR_SET_STATUS_REPORT_PARAMS(pHdrState, this, pRenderParams); } VPHAL_RNDR_SET_STATUS_REPORT_PARAMS(&Align16State, this, pRenderParams); // Loop through the sources for (uiIndex = 0; uiIndex < VPHAL_MAX_SOURCES && uiIndex < pRenderParams->uSrcCount; uiIndex++) { pSrcSurface = pRenderParams->pSrc[uiIndex]; if (pSrcSurface == nullptr) { continue; } // We need to block invalid frame sizes of 0 or negative values from // entering the VP render core since IVB hardware had problem of // handling these cases. EU payload of the same values, U, V, // deltaU, deltaV, are all 0s, and are the same for 16 thread entries, // which will be discarded by the kernel. if ((pSrcSurface->rcSrc.top >= pSrcSurface->rcSrc.bottom) || (pSrcSurface->rcSrc.left >= pSrcSurface->rcSrc.right) || (pSrcSurface->rcDst.top >= pSrcSurface->rcDst.bottom) || (pSrcSurface->rcDst.left >= pSrcSurface->rcDst.right)) { eStatus = MOS_STATUS_INVALID_PARAMETER; VPHAL_RENDER_ASSERTMESSAGE("Invalid Rectangle Values."); goto finish; } #ifdef ANDROID // If the dst rect of primary layer is exactly covered by sublayers, say primary.left == sublayer.left, // the primary layer should not be seen from the left side. But VpHal_RndrRectSurfaceAlignment() might adjust // the primary layer dst rect for alignment. It looks like the primary layer is shifted left for one or two pixels, // and user will see a thin line on the left side, which is a bad user experience. // In such cases, just make the sublayer's dst rect still aligned with primary layer. if (bDstRectWANeeded) { pSrcSurface->rcDst.left = (pSrcSurface->rcDst.left == PrimOrigDstRect.left ) ? pPrimarySurface->rcDst.left : pSrcSurface->rcDst.left; pSrcSurface->rcDst.top = (pSrcSurface->rcDst.top == PrimOrigDstRect.top ) ? pPrimarySurface->rcDst.top : pSrcSurface->rcDst.top; pSrcSurface->rcDst.right = (pSrcSurface->rcDst.right == PrimOrigDstRect.right ) ? pPrimarySurface->rcDst.right : pSrcSurface->rcDst.right; pSrcSurface->rcDst.bottom = (pSrcSurface->rcDst.bottom == PrimOrigDstRect.bottom) ? pPrimarySurface->rcDst.bottom : pSrcSurface->rcDst.bottom; } #endif if (pSrcSurface->SurfType == SURF_IN_PRIMARY) { #ifdef ANDROID bDstRectWANeeded = true; PrimOrigDstRect = pSrcSurface->rcDst; #endif pRenderPassData->pPrimarySurface = pPrimarySurface = pSrcSurface; pRenderPassData->uiPrimaryIndex = uiIndex; // align rectangle and source surface VPHAL_RENDER_CHK_STATUS(VpHal_RndrRectSurfaceAlignment(pSrcSurface, pRenderParams->pTarget[0] ? pRenderParams->pTarget[0]->Format : pSrcSurface->Format)); // update max Src rect in both pRenderer and primary surface VpHal_RenderInitMaxRect(this, pSrcSurface); } // Add Procamp limitation before Render pass selected // Brightness[-100.0,100.0], Contrast & Saturation[0.0,10.0] pProcampParams = pSrcSurface->pProcampParams; if (pProcampParams && pProcampParams->bEnabled) { pProcampParams->fBrightness = MOS_MIN(MOS_MAX(-100.0f, pProcampParams->fBrightness), 100.0f); pProcampParams->fContrast = MOS_MIN(MOS_MAX( 0.0f, pProcampParams->fContrast), 10.0f); pProcampParams->fSaturation = MOS_MIN(MOS_MAX( 0.0f, pProcampParams->fSaturation), 10.0f); } AdjustSurfaceParam(pRenderParams, pSrcSurface, pGtSystemInfo, bHybridDecoderFlag); } // Check if Slice Shutdown can be enabled // Vebox performance is not impacted by slice shutdown if (!(pPrimarySurface == nullptr || // Valid Layer pRenderPassData->bHdrNeeded || // HDR Disabled pRenderParams->Component == COMPONENT_VPreP)) // VpostP usage { bSliceReconfig = true; } // Check if Slice Shutdown can be enabled if ((uiSsdControl == VPHAL_SSD_ENABLE) || // Force Enable in User feature keys (bSliceReconfig && // Default mode uiSsdControl == VPHAL_SSD_DEFAULT)) { bSingleSliceMode = true; } else { bSingleSliceMode = false; } pRender[VPHAL_RENDER_ID_COMPOSITE]->SetSingleSliceMode(bSingleSliceMode); finish: return eStatus; } //! //! \brief Render function for the pass //! \details The render function coordinates the advanced renderers and basic //! renders in one pass //! \param [in,out] pRenderParams //! Pointer to VPHAL render parameter //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::RenderPass( PVPHAL_RENDER_PARAMS pRenderParams) { MOS_STATUS eStatus; uint32_t uiIndex_in; // Current source index uint32_t uiIndex_out; // current target index PVPHAL_VEBOX_EXEC_STATE pVeboxExecState; RenderpassData RenderPassData; VPHAL_RENDER_ASSERT(m_pRenderHal); eStatus = MOS_STATUS_SUCCESS; uiIndex_in = 0; uiIndex_out = 0; pVeboxExecState = &VeboxExecState[uiCurrentChannel]; MOS_ZeroMemory(&RenderPassData, sizeof(RenderPassData)); RenderPassData.AllocateTempOutputSurfaces(); RenderPassData.bCompNeeded = true; // Get surface info for all input source VPHAL_RENDER_CHK_STATUS(GetSurfaceInfoForSrc(pRenderParams)); // Process render parameters VPHAL_RENDER_CHK_STATUS(ProcessRenderParameter(pRenderParams, &RenderPassData)); // Loop through the sources for (uiIndex_in = 0; uiIndex_in < pRenderParams->uSrcCount; uiIndex_in++) { if (pRenderParams->pSrc[uiIndex_in] == nullptr) { continue; } //------------------------------------------ VPHAL_RNDR_DUMP_SURF( this, uiIndex_in, VPHAL_DBG_DUMP_TYPE_PRE_ALL, pRenderParams->pSrc[uiIndex_in]); //------------------------------------------ RenderPassData.pOriginalSrcSurface = pRenderParams->pSrc[uiIndex_in]; RenderPassData.pSrcSurface = pRenderParams->pSrc[uiIndex_in]; RenderPassData.uiSrcIndex = uiIndex_in; if (VpHal_RndrIsFast1toNSupport(&Fast1toNState, pRenderParams, pRenderParams->pSrc[uiIndex_in])) { // new 1toN path for multi ouput with scaling only case. VPHAL_RENDER_NORMALMESSAGE("Enter fast 1to N render."); VPHAL_RENDER_CHK_STATUS(RenderFast1toNComposite(pRenderParams, &RenderPassData)); } else { // loop through the dst for every src input. // backup the render params to execute as dst_count=1 to compatible with legacy logic. VPHAL_RENDER_PARAMS StoreRenderParams = *pRenderParams; pRenderParams->uDstCount = 1; for (uiIndex_out = 0; uiIndex_out < StoreRenderParams.uDstCount; uiIndex_out++) { if (StoreRenderParams.pTarget[uiIndex_out] == nullptr) { continue; } // update the first target point pRenderParams->pTarget[0] = StoreRenderParams.pTarget[uiIndex_out]; pRenderParams->pTarget[0]->b16UsrPtr = StoreRenderParams.pTarget[uiIndex_out]->b16UsrPtr; if (StoreRenderParams.uDstCount > 1) { // for multi output, support different scaling ratio but doesn't support cropping. RenderPassData.pSrcSurface->rcDst.top = pRenderParams->pTarget[0]->rcSrc.top; RenderPassData.pSrcSurface->rcDst.left = pRenderParams->pTarget[0]->rcSrc.left; RenderPassData.pSrcSurface->rcDst.bottom = pRenderParams->pTarget[0]->rcSrc.bottom; RenderPassData.pSrcSurface->rcDst.right = pRenderParams->pTarget[0]->rcSrc.right; } RenderSingleStream(pRenderParams, &RenderPassData); if (!RenderPassData.bCompNeeded && pRenderParams->pTarget[0] && pRenderParams->pTarget[0]->bFastColorFill) { // with fast color fill enabled, we seperate target surface into two parts: // (1) upper rectangle rendered by vebox // (2) bottom rectangle with back ground color fill by composition pRenderParams->uSrcCount = 0; // set to zero for color fill pRenderParams->pTarget[0]->rcDst.top = pRenderParams->pSrc[0]->rcDst.bottom; RenderPassData.bCompNeeded = true; VPHAL_RENDER_ASSERTMESSAGE("Critical: enter fast color fill"); } if (RenderPassData.b2CSCNeeded) { // Second CSC in render, set input of render with output of vebox. pRenderParams->pSrc[uiIndex_in] = RenderPassData.pOutSurface; } if (RenderPassData.bCompNeeded && (uiIndex_in == pRenderParams->uSrcCount-1 || // compatible with N:1 case, only render at the last input. pRenderParams->uSrcCount == 0)) // fast color fill { VPHAL_RENDER_CHK_STATUS(RenderComposite(pRenderParams, &RenderPassData)); } else if (VpHal_RndrIsHdrPathNeeded(this, pRenderParams, &RenderPassData) && (pHdrState && !pHdrState->bBypassHdrKernelPath)) { VPHAL_RENDER_CHK_STATUS(VpHal_RndrRenderHDR(this, pRenderParams, &RenderPassData)); } } // restore render pointer and count. pRenderParams->pTarget[0] = StoreRenderParams.pTarget[0]; pRenderParams->pTarget[0]->b16UsrPtr = StoreRenderParams.pTarget[0]->b16UsrPtr; pRenderParams->uDstCount = StoreRenderParams.uDstCount; } } // Report Render modes UpdateReport(pRenderParams, &RenderPassData); //------------------------------------------ VPHAL_RNDR_DUMP_SURF_PTR_ARRAY( this, pRenderParams->pTarget, VPHAL_MAX_TARGETS, pRenderParams->uDstCount, VPHAL_DBG_DUMP_TYPE_POST_ALL); //------------------------------------------ if (RenderPassData.pPrimarySurface) { VpHal_SaveRestorePrimaryFwdRefs( this, pRenderParams->pSrc[RenderPassData.uiPrimaryIndex] = RenderPassData.pPrimarySurface, false /*restore*/); } finish: return eStatus; } //! //! \brief Render single stream //! \param [in] 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 VphalRenderer::RenderSingleStream( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { MOS_STATUS eStatus; eStatus = MOS_STATUS_SUCCESS; if (pRenderPassData->pSrcSurface->SurfType == SURF_IN_PRIMARY) { VpHal_SaveRestorePrimaryFwdRefs( this, pRenderPassData->pPrimarySurface, true /*save*/); //-- DNDI/IECP----------------------------------------------------- VPHAL_RNDR_DUMP_SURF( this, pRenderPassData->uiSrcIndex, VPHAL_DBG_DUMP_TYPE_PRE_DNDI, pRenderPassData->pSrcSurface); VPHAL_RENDER_CHK_STATUS(VpHal_RndrRenderVebox( this, pRenderParams, pRenderPassData)); if (pRenderPassData->bSFCScalingOnly) { // set the output surface which from the Vebox+SFC as input surface, and let comp to do composite. VPHAL_RENDER_CHK_NULL(pRenderPassData->pOutSurface); pRenderPassData->bCompNeeded = true; pRenderPassData->bSFCScalingOnly = false; pRenderPassData->pSrcSurface = pRenderPassData->pOutSurface; pRenderPassData->pSrcSurface->SurfType = SURF_IN_PRIMARY; } if (pRenderPassData->bOutputGenerated) { pRenderPassData->pSrcSurface = pRenderPassData->pOutSurface; pRenderPassData->MoveToNextTempOutputSurface(); } else { // Do not perform any more operations if Comp is not needed if (pRenderPassData->bCompNeeded == false) { VPHAL_RENDER_NORMALMESSAGE("VEBOX/SFC modified Render Target, skipping further processing."); goto finish; } } VPHAL_RNDR_DUMP_SURF( this, pRenderPassData->uiSrcIndex, VPHAL_DBG_DUMP_TYPE_POST_DNDI, pRenderPassData->pSrcSurface); // We'll continue even if Advanced render fails if ((eStatus == MOS_STATUS_SUCCESS) && (pRenderPassData->bCompNeeded || pRenderPassData->bHdrNeeded)) { pRenderParams->pSrc[pRenderPassData->uiSrcIndex] = pRenderPassData->pSrcSurface; } if (pRenderPassData->bHdrNeeded && (pHdrState && !pHdrState->bBypassHdrKernelPath)) { pRenderPassData->bCompNeeded = false; } } finish: return eStatus; } //! //! \brief Compose input streams as fast 1toN //! \details Use composite render to multi output streams //! \param [in] 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 VphalRenderer::RenderFast1toNComposite( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { MOS_STATUS eStatus; eStatus = MOS_STATUS_SUCCESS; if (pRenderPassData->pSrcSurface->SurfType == SURF_IN_PRIMARY) { VpHal_SaveRestorePrimaryFwdRefs( this, pRenderPassData->pPrimarySurface, true /*save*/); pRenderParams->pSrc[pRenderPassData->uiSrcIndex] = pRenderPassData->pSrcSurface; eStatus = Fast1toNState.pfnRender(&Fast1toNState, pRenderParams); } return eStatus; } //! //! \brief Compose input streams //! \details Use composite render to compose input streams //! \param [in] 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 VphalRenderer::RenderComposite( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { MOS_STATUS eStatus; eStatus = MOS_STATUS_SUCCESS; //------------------------------------------ VPHAL_RNDR_DUMP_SURF_PTR_ARRAY( this, pRenderParams->pSrc, VPHAL_MAX_SOURCES, pRenderParams->uSrcCount, VPHAL_DBG_DUMP_TYPE_PRE_COMP); //------------------------------------------ if (pRenderPassData->pSrcSurface && (pRenderPassData->pSrcSurface->b16UsrPtr || pRenderParams->pTarget[0]->b16UsrPtr) && (VpHal_RndrIs16Align(&Align16State, pRenderParams))) { // process 16aligned usrptr mode. VPHAL_RENDER_CHK_STATUS(Align16State.pfnRender(&Align16State, pRenderParams)); } else { // fallback to legacy path VPHAL_RENDER_CHK_STATUS(pRender[VPHAL_RENDER_ID_COMPOSITE]->Render(pRenderParams, nullptr)); } //------------------------------------------ VPHAL_RNDR_DUMP_SURF_PTR_ARRAY( this, pRenderParams->pSrc, VPHAL_MAX_SOURCES, pRenderParams->uSrcCount, VPHAL_DBG_DUMP_TYPE_POST_COMP); VPHAL_RNDR_DUMP_SURF_PTR_ARRAY( this, pRenderParams->pTarget, VPHAL_MAX_TARGETS, pRenderParams->uDstCount, VPHAL_DBG_DUMP_TYPE_POST_COMP); //------------------------------------------ finish: return eStatus; } //! //! \brief Update report data //! \details Update report data from each feature render //! \param [in] 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 //! void VphalRenderer::UpdateReport( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { VPHAL_GET_SURFACE_INFO Info; pRender[VPHAL_RENDER_ID_COMPOSITE]->CopyReporting(m_reporting); if (pRenderPassData->pPrimarySurface && pRenderPassData->pPrimarySurface->bCompressible) { m_reporting->GetFeatures().primaryCompressible = true; m_reporting->GetFeatures().primaryCompressMode = (uint8_t)(pRenderPassData->pPrimarySurface->CompressionMode); } if (pRenderParams->pTarget[0]->bCompressible) { MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); MOS_STATUS status = VpHal_GetSurfaceInfo(m_pOsInterface, &Info, pRenderParams->pTarget[0]); if (MOS_STATUS_SUCCESS != status) { VPHAL_PUBLIC_ASSERTMESSAGE("VpHal_GetSurfaceInfo failed!"); return; } m_reporting->GetFeatures().rtCompressible = true; m_reporting->GetFeatures().rtCompressMode = (uint8_t)(pRenderParams->pTarget[0]->CompressionMode); } m_reporting->GetFeatures().rtCacheSetting = (uint8_t)(pRenderParams->pTarget[0]->CacheSetting); #if (_DEBUG || _RELEASE_INTERNAL) m_reporting->GetFeatures().rtOldCacheSetting = (uint8_t)(m_pRenderHal->oldCacheSettingForTargetSurface); #endif } //! //! \brief Check if Vphal renderer support some formats //! \param [in] pcRenderParams //! Const pointer to VPHAL render parameter //! \return bool //! Return true if successful, false failed //! bool VphalRenderer::IsFormatSupported( PCVPHAL_RENDER_PARAMS pcRenderParams) { bool bFormatSupported = true; VPHAL_RENDER_ASSERT(pcRenderParams); // Protection mechanism // P010 output support from SKL+ if (m_pSkuTable) { if (pcRenderParams->pTarget[0]) { switch (pcRenderParams->pTarget[0]->Format) { case Format_P010: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVpP010Output) ? true : false; break; case Format_P016: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVpP010Output) ? true : false; break; case Format_Y210: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVp10BitSupport) ? true : false; break; case Format_Y410: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVp10BitSupport) ? true : false; break; case Format_Y216: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVp16BitSupport) ? true : false; break; case Format_Y416: bFormatSupported = MEDIA_IS_SKU(m_pSkuTable, FtrVp16BitSupport) ? true : false; break; default: break; } } } return bFormatSupported; } //! //! \brief Main render function //! \details The top level renderer function, which may contain multiple //! passes of rendering //! \param [in] pcRenderParams //! Const pointer to VPHAL render parameter //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::Render( PCVPHAL_RENDER_PARAMS pcRenderParams) { MOS_STATUS eStatus; PMOS_INTERFACE pOsInterface; PRENDERHAL_INTERFACE pRenderHal; VPHAL_RENDER_PARAMS RenderParams; // Make a copy of render params PVPHAL_SURFACE pSrcLeft[VPHAL_MAX_SOURCES]; // Array of sources referring to left view stereo content PVPHAL_SURFACE pSrcRight[VPHAL_MAX_SOURCES]; // Array of sources referring to right view stereo content uint32_t uiRenderPasses; // Number of rendering passes in this one call to VpHal_RndrRender() uint32_t uiCurrentRenderPass; // Current render pass uint32_t uiDst; VPHAL_GET_SURFACE_INFO Info; //-------------------------------------------- VPHAL_RENDER_ASSERT(pcRenderParams); VPHAL_RENDER_ASSERT(m_pOsInterface); VPHAL_RENDER_ASSERT(m_pRenderHal); VPHAL_RENDER_ASSERT(pKernelDllState); VPHAL_RENDER_ASSERT(pRender[VPHAL_RENDER_ID_COMPOSITE]); //-------------------------------------------- eStatus = MOS_STATUS_SUCCESS; pOsInterface = m_pOsInterface; pRenderHal = m_pRenderHal; // Validate render target if (pcRenderParams->pTarget[0] == nullptr || Mos_ResourceIsNull(&(pcRenderParams->pTarget[0]->OsResource))) { VPHAL_RENDER_ASSERTMESSAGE("Invalid Render Target."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } // Protection mechanism, Only SKL+ support P010 output. if (IsFormatSupported(pcRenderParams) == false) { VPHAL_RENDER_ASSERTMESSAGE("Invalid Render Target Output Format."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } VPHAL_DBG_STATE_DUMP_SET_CURRENT_FRAME_COUNT(uiFrameCounter); // Validate max number sources if (pcRenderParams->uSrcCount > VPHAL_MAX_SOURCES) { VPHAL_RENDER_ASSERTMESSAGE("Invalid number of samples."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } // Validate max number targets if (pcRenderParams->uDstCount > VPHAL_MAX_TARGETS) { VPHAL_RENDER_ASSERTMESSAGE("Invalid number of targets."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } // Copy the Render Params structure (so we can update it) RenderParams = *pcRenderParams; VPHAL_DBG_PARAMETERS_DUMPPER_DUMP_XML(&RenderParams); VPHAL_DBG_OCA_DUMPER_SET_RENDER_PARAM(pRenderHal, &RenderParams); // Get resource information for render target MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); for (uiDst = 0; uiDst < RenderParams.uDstCount; uiDst++) { VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo( m_pOsInterface, &Info, RenderParams.pTarget[uiDst])); } // Set the component info m_pOsInterface->Component = pcRenderParams->Component; // Init component(DDI entry point) info for perf measurement m_pOsInterface->pfnSetPerfTag(m_pOsInterface, VPHAL_NONE); // Increment frame ID for performance measurement m_pOsInterface->pfnIncPerfFrameID(m_pOsInterface); // Enable Turbo mode if sku present and DDI requests it if (m_pSkuTable && MEDIA_IS_SKU(m_pSkuTable, FtrMediaTurboMode)) { m_pRenderHal->bTurboMode = RenderParams.bTurboMode; } // Reset feature reporting m_reporting->InitReportValue(); MOS_ZeroMemory(pSrcLeft, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES); MOS_ZeroMemory(pSrcRight, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES); VPHAL_RENDER_CHK_STATUS(PrepareSources( &RenderParams, pSrcLeft, pSrcRight, &uiRenderPasses)); //Update GpuContext if (MEDIA_IS_SKU(m_pSkuTable, FtrCCSNode)) { MOS_GPU_CONTEXT currentGpuContext = m_pOsInterface->pfnGetGpuContext(m_pOsInterface); UpdateRenderGpuContext(currentGpuContext); } // align rectangle and source surface for (uiDst = 0; uiDst < RenderParams.uDstCount; uiDst++) { VPHAL_RENDER_CHK_STATUS(VpHal_RndrRectSurfaceAlignment(RenderParams.pTarget[uiDst], RenderParams.pTarget[uiDst]->Format)); } for (uiCurrentRenderPass = 0; uiCurrentRenderPass < uiRenderPasses; uiCurrentRenderPass++) { // Assign source surfaces for current rendering pass MOS_SecureMemcpy( RenderParams.pSrc, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES, (uiCurrentRenderPass == 0) ? pSrcLeft : pSrcRight, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES); MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO)); for (uiDst = 0; uiDst < RenderParams.uDstCount; uiDst++) { Info.S3dChannel = RenderParams.pTarget[uiDst]->Channel; Info.ArraySlice = uiCurrentRenderPass; VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo( m_pOsInterface, &Info, RenderParams.pTarget[uiDst])); } // Update channel. 0 = mono or stereo left, 1 = stereo right uiCurrentChannel = uiCurrentRenderPass; VPHAL_RENDER_CHK_STATUS(RenderPass(&RenderParams)); } finish: uiFrameCounter++; return eStatus; } //! //! \brief Update Render Gpu Context //! \details Update Render Gpu Context //! \param [in] renderGpuContext //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::UpdateRenderGpuContext(MOS_GPU_CONTEXT currentGpuContext) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MOS_GPU_CONTEXT renderGpuContext; MOS_GPU_NODE renderGpuNode; MOS_GPUCTX_CREATOPTIONS_ENHANCED createOption = {}; PVPHAL_VEBOX_STATE pVeboxState = nullptr; int i = 0; if ((MEDIA_IS_SKU(m_pSkuTable, FtrRAMode) || MEDIA_IS_SKU(m_pSkuTable, FtrProtectedEnableBitRequired)) && m_pOsInterface->osCpInterface->IsCpEnabled() && (m_pOsInterface->osCpInterface->IsHMEnabled() || m_pOsInterface->osCpInterface->IsSMEnabled())) { if (currentGpuContext == MOS_GPU_CONTEXT_COMPUTE || currentGpuContext == MOS_GPU_CONTEXT_COMPUTE_RA) // CCS { renderGpuContext = MOS_GPU_CONTEXT_COMPUTE_RA; renderGpuNode = MOS_GPU_NODE_COMPUTE; } else // RCS { renderGpuContext = MOS_GPU_CONTEXT_RENDER_RA; renderGpuNode = MOS_GPU_NODE_3D; } createOption.RAMode = MEDIA_IS_SKU(m_pSkuTable, FtrRAMode); createOption.ProtectMode = MEDIA_IS_SKU(m_pSkuTable, FtrProtectedEnableBitRequired); } else { if (currentGpuContext == MOS_GPU_CONTEXT_COMPUTE || currentGpuContext == MOS_GPU_CONTEXT_COMPUTE_RA) // CCS { renderGpuContext = MOS_GPU_CONTEXT_COMPUTE; renderGpuNode = MOS_GPU_NODE_COMPUTE; } else // RCS { renderGpuContext = MOS_GPU_CONTEXT_RENDER; renderGpuNode = MOS_GPU_NODE_3D; } createOption.RAMode = 0; createOption.ProtectMode = 0; } // no gpucontext will be created if the gpu context has been created before. VPHAL_PUBLIC_CHK_STATUS(m_pOsInterface->pfnCreateGpuContext( m_pOsInterface, renderGpuContext, renderGpuNode, &createOption)); VPHAL_PUBLIC_CHK_STATUS(m_pOsInterface->pfnSetGpuContext( m_pOsInterface, renderGpuContext)); // Register Render GPU context with the event VPHAL_PUBLIC_CHK_STATUS(m_pOsInterface->pfnRegisterBBCompleteNotifyEvent( m_pOsInterface, renderGpuContext)); //update sub render status one by one for (i = 0; i < VPHAL_RENDER_ID_COUNT - 1; i++) { // VPHAL_RENDER_ID_COMPOSITE is not inherited from vphal_vebox_state, skip it. pVeboxState = (PVPHAL_VEBOX_STATE)(pRender[i]); if (pVeboxState != nullptr) { pVeboxState->UpdateRenderGpuContext(renderGpuContext); } } finish: VPHAL_RENDER_NORMALMESSAGE("gpucontext switch from %d to %d", currentGpuContext, renderGpuContext); return eStatus; } MOS_STATUS VphalRenderer::SetRenderGpuContext(VPHAL_RENDER_PARAMS& RenderParams) { MOS_GPU_CONTEXT currentGpuContext = m_renderGpuContext; if (currentGpuContext != MOS_GPU_CONTEXT_RENDER) { bool bLumaKeyEnabled = false; for (uint32_t uiSources = 0; uiSources < RenderParams.uSrcCount; uiSources++) { VPHAL_SURFACE* pSrc = (VPHAL_SURFACE*)RenderParams.pSrc[uiSources]; bLumaKeyEnabled = (pSrc && pSrc->pLumaKeyParams) ? true : false; if (bLumaKeyEnabled) { break; } } if (bLumaKeyEnabled) { currentGpuContext = MOS_GPU_CONTEXT_RENDER; } } UpdateRenderGpuContext(currentGpuContext); return MOS_STATUS_SUCCESS; } //! //! \brief Release intermediate surfaces //! \details Release intermediate surfaces created for main render function //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::FreeIntermediateSurfaces() { // Free IntermediateSurface if (m_pOsInterface) { m_pOsInterface->pfnFreeResource(m_pOsInterface, &IntermediateSurface.OsResource); } MOS_SafeFreeMemory(IntermediateSurface.pBlendingParams); MOS_SafeFreeMemory(IntermediateSurface.pIEFParams); MOS_SafeFreeMemory(IntermediateSurface.pHDRParams); return MOS_STATUS_SUCCESS; } //! //! \brief Initialize the VPHAL renderer //! \details Initialize all the renderers supported including VEBOX, Composite. //! \param [in] pSettings //! Const pointer to VPHAL settings //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::Initialize( const VphalSettings *pSettings, bool isApoEnabled) { void* pKernelBin; void* pFcPatchBin; MOS_STATUS eStatus; PMOS_INTERFACE pOsInterface; PRENDERHAL_INTERFACE pRenderHal; int32_t iResult; MHW_KERNEL_PARAM MhwKernelParam; Kdll_KernelCache *pKernelCache; Kdll_CacheEntry *pCacheEntryTable; pKernelBin = nullptr; pFcPatchBin = nullptr; eStatus = MOS_STATUS_UNKNOWN; pOsInterface = m_pOsInterface; pRenderHal = m_pRenderHal; iResult = 0; pKernelBin = nullptr; pFcPatchBin = nullptr; MOS_ZeroMemory(&MhwKernelParam, sizeof(MHW_KERNEL_PARAM)); //--------------------------------------- VPHAL_RENDER_CHK_NULL(pSettings); VPHAL_RENDER_CHK_NULL(m_pOsInterface); VPHAL_RENDER_CHK_NULL(m_pRenderHal); //--------------------------------------- m_isApoEnabled = isApoEnabled; m_renderGpuContext = m_pOsInterface->pfnGetGpuContext(m_pOsInterface); m_clearVideoViewMode = pSettings->clearVideoViewMode; Align16State.pPerfData = &PerfData; Fast1toNState.pPerfData = &PerfData; // Current KDLL expects a writable memory for kernel binary. For that reason, // we need to copy the memory to a new location so that KDLL can overwrite. // !!! WARNING !!! // We MUST NOT create a writable global memory since it can cause issues // in multi-device cases (multiple threads operating on the memory) // NOTE: KDLL will release the allocated memory. // NOTE: Need to check kernel binary pointer and bin size firstly, // Because calling malloc(0) will usually returns a valid pointer, and any usage of this pointer excluding free memory is undefined in C/C++. if(pcKernelBin == nullptr || dwKernelBinSize == 0) { eStatus = MOS_STATUS_NULL_POINTER; VPHAL_RENDER_ASSERTMESSAGE("Could not allocate KDLL state with no kernel binary"); goto finish; } pKernelBin = MOS_AllocMemory(dwKernelBinSize); VPHAL_RENDER_CHK_NULL(pKernelBin); MOS_SecureMemcpy(pKernelBin, dwKernelBinSize, pcKernelBin, dwKernelBinSize); if ((pcFcPatchBin != nullptr) && (dwFcPatchBinSize != 0)) { pFcPatchBin = MOS_AllocMemory(dwFcPatchBinSize); VPHAL_RENDER_CHK_NULL(pFcPatchBin); MOS_SecureMemcpy(pFcPatchBin, dwFcPatchBinSize, pcFcPatchBin, dwFcPatchBinSize); } // Allocate KDLL state (Kernel Dynamic Linking) pKernelDllState = KernelDll_AllocateStates( pKernelBin, dwKernelBinSize, pFcPatchBin, dwFcPatchBinSize, pKernelDllRules, m_modifyKdllFunctionPointers); if (!pKernelDllState) { eStatus = MOS_STATUS_NULL_POINTER; VPHAL_RENDER_ASSERTMESSAGE("Failed to allocate KDLL state."); goto finish; } // Set up SIP debug kernel if enabled if (m_pRenderHal->bIsaAsmDebugEnable) { pKernelCache = &pKernelDllState->ComponentKernelCache; pCacheEntryTable = pKernelCache->pCacheEntries; VPHAL_RENDER_CHK_NULL(pCacheEntryTable); MOS_ZeroMemory(&MhwKernelParam, sizeof(MhwKernelParam)); MhwKernelParam.pBinary = pCacheEntryTable[IDR_VP_SIP_Debug].pBinary; MhwKernelParam.iSize = pCacheEntryTable[IDR_VP_SIP_Debug].iSize; iResult = m_pRenderHal->pfnLoadDebugKernel( m_pRenderHal, &MhwKernelParam); if (iResult != 0) { m_pRenderHal->bIsaAsmDebugEnable = false; } } // Initialize Compositing renderer VPHAL_RENDER_CHK_STATUS(pRender[VPHAL_RENDER_ID_COMPOSITE]->Initialize( pSettings, pKernelDllState)); if (!m_clearVideoViewMode) { VeboxExecState[0].Mode = VEBOX_EXEC_MODE_0; VeboxExecState[0].bDIOutputPair01 = true; VeboxExecState[0].bSpeculativeCopy = false; VeboxExecState[0].bEnable = (pSettings->veboxParallelExecution == VEBOX_EXECUTION_OVERRIDE_ENABLE); VeboxExecState[1] = VeboxExecState[0]; // Initialize VEBOX renderer VPHAL_RENDER_CHK_STATUS(pRender[VPHAL_RENDER_ID_VEBOX]->Initialize( pSettings, pKernelDllState)); VPHAL_RENDER_CHK_STATUS(pRender[VPHAL_RENDER_ID_VEBOX2]->Initialize( pSettings, pKernelDllState)); // Initialize 16 Alignment Interface and renderer VpHal_16AlignInitInterface(&Align16State, m_pRenderHal); VPHAL_RENDER_CHK_STATUS(Align16State.pfnInitialize( &Align16State, pSettings, pKernelDllState)) // Initialize fast 1to N Interface and render VpHal_Fast1toNInitInterface(&Fast1toNState, m_pRenderHal); VPHAL_RENDER_CHK_STATUS(Fast1toNState.pfnInitialize( &Fast1toNState, pSettings, pKernelDllState)) } eStatus = AllocateDebugDumper(); if (eStatus != MOS_STATUS_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Debug dumper allocate failed!"); goto finish; } if (MEDIA_IS_SKU(m_pSkuTable, FtrVpDisableFor4K)) { bSkuDisableVpFor4K = true; } else { bSkuDisableVpFor4K = false; } // Initialize Hdr renderer if (MEDIA_IS_SKU(m_pSkuTable, FtrHDR) && pHdrState && !m_clearVideoViewMode) { VPHAL_RENDER_CHK_STATUS(pHdrState->pfnInitialize( pHdrState, pSettings, pKernelDllState)); } eStatus = MOS_STATUS_SUCCESS; finish: if (eStatus != MOS_STATUS_SUCCESS) { if (pKernelBin) { MOS_SafeFreeMemory(pKernelBin); if (pKernelDllState && pKernelDllState->ComponentKernelCache.pCache == pKernelBin) { pKernelDllState->ComponentKernelCache.pCache = nullptr; } pKernelBin = nullptr; } if (pFcPatchBin) { MOS_SafeFreeMemory(pFcPatchBin); if (pKernelDllState && pKernelDllState->CmFcPatchCache.pCache == pFcPatchBin) { pKernelDllState->CmFcPatchCache.pCache = nullptr; } pFcPatchBin = nullptr; } } return eStatus; } //! //! \brief VPHAL renderer destructor //! \details Destory the resources allocated for the renderers //! including VEBOX and Composite. //! VphalRenderer::~VphalRenderer() { VPHAL_RENDER_CHK_NULL_NO_STATUS(m_pOsInterface); FreeIntermediateSurfaces(); MOS_Delete(m_reporting); for (int32_t i = 0; i < VPHAL_RENDER_ID_COUNT; i++) { if (pRender[i]) { pRender[i]->Destroy(); MOS_Delete(pRender[i]); pRender[i] = nullptr; } } // Destroy Kernel DLL objects (cache, hash table, states) if (pKernelDllState) { KernelDll_ReleaseStates(pKernelDllState); } // Destroy resources allocated for 16 Alignment if (Align16State.pfnDestroy) { Align16State.pfnDestroy(&Align16State); } // Destory resources allocated for fast1toN if (Fast1toNState.pfnDestroy) { Fast1toNState.pfnDestroy(&Fast1toNState); } // Destroy resources allocated for Hdr if (MEDIA_IS_SKU(m_pSkuTable, FtrHDR) && pHdrState && pHdrState->pfnDestroy) { pHdrState->pfnDestroy(pHdrState); MOS_Delete(pHdrState); } // Destroy surface dumper VPHAL_DBG_SURF_DUMP_DESTORY(m_surfaceDumper); // Destroy state dumper VPHAL_DBG_STATE_DUMPPER_DESTORY(m_pRenderHal->pStateDumper); // Destroy vphal parameter dump VPHAL_DBG_PARAMETERS_DUMPPER_DESTORY(m_parameterDumper); VPHAL_DBG_OCA_DUMPER_DESTORY(m_pRenderHal); finish: return; } //! //! \brief Get the aligned the surface height and width unit //! \details Accoring to the format of the surface, get the aligned unit for the surface //! width and height //! \param [in,out] pwWidthAlignUnit //! Pointer to the surface width alignment unit //! \param [in,out] pwHeightAlignUnit //! Pointer to the surface height alignment unit //! \param [in] format //! The format of the surface //! \return void //! void VpHal_RndrGetAlignUnit( uint16_t* pwWidthAlignUnit, uint16_t* pwHeightAlignUnit, MOS_FORMAT format) { switch (format) { case Format_YV12: case Format_I420: case Format_IYUV: case Format_IMC1: case Format_IMC2: case Format_IMC3: case Format_IMC4: case Format_NV12: case Format_P010: case Format_P016: *pwWidthAlignUnit = 2; *pwHeightAlignUnit = 2; break; case Format_YVU9: *pwWidthAlignUnit = 4; *pwHeightAlignUnit = 4; break; case Format_YUY2: case Format_UYVY: case Format_YUYV: case Format_YVYU: case Format_VYUY: case Format_P208: case Format_Y210: case Format_Y216: *pwWidthAlignUnit = 2; *pwHeightAlignUnit = 1; break; case Format_NV11: *pwWidthAlignUnit = 4; *pwHeightAlignUnit = 1; break; default: *pwWidthAlignUnit = 1; *pwHeightAlignUnit = 1; break; } } //! //! \brief Set packed YUV component offsets //! \details Accoring to the format of the surface, set packed YUV component offsets //! \param [in] format //! The format of the surface //! \param [in,out] pOffsetY //! The offset of Y //! \param [in,out] pOffsetU //! The offset of U //! \param [in,out] pOffsetV //! The offset of V //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VpHal_RndrSetYUVComponents( MOS_FORMAT format, uint8_t* pOffsetY, uint8_t* pOffsetU, uint8_t* pOffsetV) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; switch (format) { case Format_PA: case Format_YUY2: case Format_YUYV: *pOffsetY = 0; *pOffsetU = 1; *pOffsetV = 3; break; case Format_UYVY: *pOffsetY = 1; *pOffsetU = 0; *pOffsetV = 2; break; case Format_YVYU: *pOffsetY = 0; *pOffsetU = 3; *pOffsetV = 1; break; case Format_VYUY: *pOffsetY = 1; *pOffsetU = 2; *pOffsetV = 0; break; case Format_Y210: *pOffsetY = 0; *pOffsetU = 2; *pOffsetV = 6; break; default: VPHAL_RENDER_ASSERTMESSAGE("Unknown Packed YUV Format."); eStatus = MOS_STATUS_UNKNOWN; } return eStatus; } //! //! \brief VphalRenderer constructor //! \details Based on the HW and OS info, initialize the renderer interfaces //! \param [in] pRenderHal //! Pointer to RenderHal Interface Structure //! \param [in,out] pStatus //! Pointer to the MOS_STATUS flag. //! Will assign this flag to MOS_STATUS_SUCCESS if successful, otherwise failed //! VphalRenderer::VphalRenderer( PRENDERHAL_INTERFACE pRenderHal, MOS_STATUS *pStatus) : Align16State(), Fast1toNState(), VeboxExecState(), pRender(), pPrimaryFwdRef(), bVeboxUsedForCapPipe(false), uiCurrentChannel(0), pKernelDllRules(nullptr), pKernelDllState(nullptr), pcKernelBin(nullptr), dwKernelBinSize(0), pcFcPatchBin(nullptr), dwFcPatchBinSize(0), uiFrameCounter(0), #if (_DEBUG || _RELEASE_INTERNAL) m_surfaceDumper(nullptr), m_parameterDumper(nullptr), #endif m_statusTable(nullptr), maxSrcRect(), pHdrState(nullptr), m_pRenderHal((PRENDERHAL_INTERFACE_LEGACY)pRenderHal), m_pOsInterface(pRenderHal ? pRenderHal->pOsInterface : nullptr), m_pSkuTable(nullptr), m_pWaTable(nullptr), m_modifyKdllFunctionPointers(nullptr), uiSsdControl(0), bDpRotationUsed(false), bSkuDisableVpFor4K(false), bSkuDisableLaceFor4K(false), bSkuDisableDNFor4K(false), PerfData(), m_reporting(nullptr), m_renderGpuContext(MOS_GPU_CONTEXT_INVALID_HANDLE) { MOS_STATUS eStatus; uint32_t ssdControl = 0; VPHAL_RENDER_CHK_NULL(m_pRenderHal); VPHAL_RENDER_CHK_NULL(m_pOsInterface); m_userSettingPtr = m_pOsInterface->pfnGetUserSettingInstance(m_pOsInterface); MOS_ZeroMemory(&pRender, sizeof(pRender)); // Read Slice Shutdown (SSD Control) User Feature Key once during initialization eStatus = ReadUserSetting( m_userSettingPtr, ssdControl, __VPHAL_RNDR_SSD_CONTROL, MediaUserSetting::Group::Sequence); if (eStatus == MOS_STATUS_SUCCESS) { uiSsdControl = ssdControl; } // Do not fail if User feature keys is not present eStatus = MOS_STATUS_SUCCESS; // Get SKU table m_pSkuTable = m_pOsInterface->pfnGetSkuTable(m_pOsInterface); m_pWaTable = m_pOsInterface->pfnGetWaTable(m_pOsInterface); finish: if (pStatus) { *pStatus = eStatus; } } //! //! \brief Search for the best match BB according to the render BB arguments //! \details Based on the params of the BB, search the BB table and try to get //! the best match //! \param [in] pBatchBufferTable //! Point to the BB table to be searched //! \param [in] pInputBbParams //! Point to the BB params required for the BB needed //! \param [in] iBbSize //! The BB size required for the BB needed //! \param [out] ppBatchBuffer //! Point to the addr of the best matched BB. Point to nullptr if there's no. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VpHal_RenderGetBestMatchBB( PVPHAL_BATCH_BUFFER_TABLE pBatchBufferTable, PVPHAL_BATCH_BUFFER_PARAMS pInputBbParams, int32_t iBbSize, PMHW_BATCH_BUFFER *ppBatchBuffer) { PMHW_BATCH_BUFFER pBbEntry; PMHW_BATCH_BUFFER pBestMatch; PVPHAL_BATCH_BUFFER_PARAMS pSearchBbParams; void* pInputBbArgs; void* pSearchBbArgs; VPHAL_BB_TYPE BbType; int32_t i; int32_t iBbCount; int32_t iBbArgSize; MOS_STATUS eStatus; pBestMatch = nullptr; pBbEntry = pBatchBufferTable->pBatchBufferHeader; iBbCount = *pBatchBufferTable->piBatchBufferCount; BbType = pInputBbParams->iType; pInputBbArgs = &pInputBbParams->BbArgs; iBbArgSize = pInputBbParams->iSize; eStatus = MOS_STATUS_UNKNOWN; for (i = iBbCount; i > 0; i--, pBbEntry++) { pSearchBbParams = (PVPHAL_BATCH_BUFFER_PARAMS)pBbEntry->pPrivateData; // Must have adequate size and the batch buffer type must be the same if (!pSearchBbParams || pBbEntry->iSize < iBbSize || pSearchBbParams->iType != BbType) { continue; } // Point to the start address of the union pSearchBbArgs = &(pSearchBbParams->BbArgs); // BB args must be the same to find the best match(DnDi, Frc and Istab) if (memcmp(pInputBbArgs, pSearchBbArgs, iBbArgSize)) { continue; } // Match -> reuse the BB regardless of the running state pBestMatch = pBbEntry; ((PVPHAL_BATCH_BUFFER_PARAMS)pBestMatch->pPrivateData)->bMatch = true; break; } *ppBatchBuffer = pBestMatch; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Search from existing BBs for a match. If none, allocate new BB //! \details Based on the params of the BB, search the BB table and try to get //! the best match. If none, try to get an old unused BB to reuse. If //! still none, allocate one new BB //! \param [in] pBatchBufferTable //! Pointer to the BB table to be searched //! \param [in] pInputBbParams //! Pointer to the BB params required for the BB needed //! \param [in] iBbSize //! The BB size required for the BB needed //! \param [in] pRenderHal //! Pointer to RenderHal Interface Structure //! \param [out] ppBatchBuffer //! Pointer to the addr of the available BB. Point to nullptr if there's no //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VpHal_RenderAllocateBB( PVPHAL_BATCH_BUFFER_TABLE pBatchBufferTable, PVPHAL_BATCH_BUFFER_PARAMS pInputBbParams, int32_t iBbSize, PRENDERHAL_INTERFACE pRenderHal, PMHW_BATCH_BUFFER *ppBatchBuffer) { PMHW_BATCH_BUFFER pOldest; // Oldest BB entry PMHW_BATCH_BUFFER pBatchBuffer; // Available BB allocation PMHW_BATCH_BUFFER pBbEntry; // 2nd level BBs array entry PVPHAL_BATCH_BUFFER_PARAMS pSearchBbParams; // Search BB parameters PVPHAL_BATCH_BUFFER_PARAMS pBbParams; int32_t i; int32_t iBbCount; VPHAL_BB_TYPE BbType; int32_t iBbArgSize; MOS_STATUS eStatus; pOldest = nullptr; pBatchBuffer = nullptr; pBbEntry = pBatchBufferTable->pBatchBufferHeader; iBbCount = *pBatchBufferTable->piBatchBufferCount; BbType = pInputBbParams->iType; iBbArgSize = pInputBbParams->iSize; eStatus = MOS_STATUS_UNKNOWN; switch (BbType) { case VPHAL_BB_TYPE_COMPOSITING: VPHAL_RENDER_CHK_STATUS(CompositeState::GetBestMatchBB( pBatchBufferTable, pInputBbParams, iBbSize, &pBatchBuffer)); break; case VPHAL_BB_TYPE_ADVANCED: VPHAL_RENDER_CHK_STATUS(VpHal_RenderGetBestMatchBB( pBatchBufferTable, pInputBbParams, iBbSize, &pBatchBuffer)); break; case VPHAL_BB_TYPE_GENERIC: break; default: VPHAL_RENDER_ASSERTMESSAGE("Unsupported batch buffer type."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } if (pBatchBuffer) { // Best available batch buffer found eStatus = MOS_STATUS_SUCCESS; goto finish; } // Search for an old unused BB to reuse for (i = iBbCount; i > 0; i--, pBbEntry++) { pSearchBbParams = (PVPHAL_BATCH_BUFFER_PARAMS)pBbEntry->pPrivateData; if (pSearchBbParams == nullptr || pSearchBbParams->iType != BbType) { continue; } // Save oldest entry, regardless of size/in-use if (pOldest == nullptr || (int32_t)(pBbEntry->dwSyncTag - pOldest->dwSyncTag) < 0) { pOldest = pBbEntry; } // Skip busy or small batch buffers if (pBbEntry->bBusy || pBbEntry->iSize < iBbSize) { continue; } // Use the oldest BB with suitable size and not in use if (pBatchBuffer == nullptr || (int32_t)(pBbEntry->dwSyncTag - pBatchBuffer->dwSyncTag) < 0) { pBatchBuffer = pBbEntry; pBatchBuffer->iCurrent = 0; pBatchBuffer->iRemaining = pBatchBuffer->iSize; } } // No available BB to use - allocate new if (!pBatchBuffer) { iBbSize = MOS_ALIGN_CEIL(iBbSize, VPHAL_BB_ALIGN_SIZE); if (pOldest == nullptr || (pOldest->bBusy && iBbCount < pBatchBufferTable->iBbCountMax)) { pOldest = nullptr; i = iBbCount++; pBatchBuffer = pBatchBufferTable->pBatchBufferHeader + i; pBatchBuffer->pPrivateData = pBatchBufferTable->pBbParamsHeader + i; *pBatchBufferTable->piBatchBufferCount = iBbCount; } // Release old buffer - may be even in use (delayed release) if (pOldest) { if (pRenderHal->pfnFreeBB(pRenderHal, pOldest) != MOS_STATUS_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to release batch buffer."); eStatus = MOS_STATUS_UNKNOWN; goto finish; } pBatchBuffer = pOldest; } // Allocate new buffer if (pRenderHal->pfnAllocateBB(pRenderHal, pBatchBuffer, iBbSize) != MOS_STATUS_SUCCESS) { VPHAL_RENDER_ASSERTMESSAGE("Failed to allocate batch buffer."); pBatchBuffer = nullptr; eStatus = MOS_STATUS_UNKNOWN; goto finish; } } // Set batch buffer args pBbParams = (PVPHAL_BATCH_BUFFER_PARAMS)pBatchBuffer->pPrivateData; pBbParams->bMatch = false; pBbParams->iType = BbType; pBbParams->iSize = iBbArgSize; pBbParams->BbArgs = pInputBbParams->BbArgs; eStatus = MOS_STATUS_SUCCESS; finish: *ppBatchBuffer = pBatchBuffer; return eStatus; } //! //! \brief Update max src rect in VphalRenderer and primary surface based //! on src rectangle info from primary video //! \details Add max src rect for consistent statistics surface layout. Update //! the max src rect of the surface and its reference surfaces //! \param [in,out] pRenderer //! VPHAL renderer pointer //! \param [in,out] pSurface //! Pointer to the surface //! \return void //! void VpHal_RenderInitMaxRect( VphalRenderer *pRenderer, PVPHAL_SURFACE pSurface) { PVPHAL_SURFACE pRef; uint32_t i; pSurface->bMaxRectChanged = (pSurface->rcSrc.right > pRenderer->maxSrcRect.right || pSurface->rcSrc.bottom > pRenderer->maxSrcRect.bottom) ? true : false; // calcualte max srcRect in pRenderParams pRenderer->maxSrcRect.right = MOS_MAX( pRenderer->maxSrcRect.right, pSurface->rcSrc.right); pRenderer->maxSrcRect.bottom = MOS_MAX( pRenderer->maxSrcRect.bottom, pSurface->rcSrc.bottom); // copy max src rect to primary video pSurface->rcMaxSrc = pRenderer->maxSrcRect; // copy max src rect to forward reference video pRef = pSurface->pFwdRef; for (i = 0; i < pSurface->uFwdRefCount; i++) { // check surface validity VPHAL_RENDER_CHK_NULL_NO_STATUS(pRef); pRef->rcMaxSrc = pRenderer->maxSrcRect; // get next forward reference pRef = pRef->pFwdRef; } // copy max src rect to backward reference video pRef = pSurface->pBwdRef; for (i = 0; i < pSurface->uBwdRefCount; i++) { // check surface validity VPHAL_RENDER_CHK_NULL_NO_STATUS(pRef); pRef->rcMaxSrc = pRenderer->maxSrcRect; // get next backward reference pRef = pRef->pBwdRef; } finish: return; } //! //! \brief Allocate surface dumper //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::CreateSurfaceDumper() { #if (_DEBUG || _RELEASE_INTERNAL) VPHAL_DBG_SURF_DUMP_CREATE() VPHAL_RENDER_CHK_NULL_RETURN(m_surfaceDumper); #endif return MOS_STATUS_SUCCESS; } MOS_STATUS VphalRenderer::AllocateDebugDumper() { PRENDERHAL_INTERFACE pRenderHal = m_pRenderHal; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; // Allocate feature report m_reporting = MOS_New(VphalFeatureReport); if (m_reporting == nullptr) { VPHAL_RENDER_ASSERTMESSAGE("Invalid null pointer!"); eStatus = MOS_STATUS_NULL_POINTER; goto finish; } #if (_DEBUG || _RELEASE_INTERNAL) // Initialize Surface Dumper VPHAL_RENDER_CHK_STATUS(CreateSurfaceDumper()); // Initialize State Dumper VPHAL_DBG_STATE_DUMPPER_CREATE() if (pRenderHal->pStateDumper == nullptr) { VPHAL_RENDER_ASSERTMESSAGE("Invalid null pointer!"); eStatus = MOS_STATUS_NULL_POINTER; goto finish; } VPHAL_DBG_PARAMETERS_DUMPPER_CREATE() if (m_parameterDumper == nullptr) { VPHAL_RENDER_ASSERTMESSAGE("Invalid null pointer!"); eStatus = MOS_STATUS_NULL_POINTER; goto finish; } // if m_isApoEnabled is false dump in legacy path, otherwise in APO path if (!m_isApoEnabled) { SkuWaTable_DUMPPER_DUMP_XML(m_pSkuTable, m_pWaTable); } #endif // vphal oca dumper object should also be created for release driver. VPHAL_DBG_OCA_DUMPER_CREATE(pRenderHal) if (nullptr == pRenderHal->pVphalOcaDumper) { VPHAL_RENDER_ASSERTMESSAGE("Invalid null pointer!"); eStatus = MOS_STATUS_NULL_POINTER; goto finish; } finish: if (eStatus != MOS_STATUS_SUCCESS) { if (m_reporting) { MOS_Delete(m_reporting); m_reporting = nullptr; } #if (_DEBUG || _RELEASE_INTERNAL) if (m_surfaceDumper) { VPHAL_DBG_SURF_DUMP_DESTORY(m_surfaceDumper) } if (pRenderHal->pStateDumper) { VPHAL_DBG_STATE_DUMPPER_DESTORY(pRenderHal->pStateDumper) } #endif VPHAL_DBG_OCA_DUMPER_DESTORY(pRenderHal) } return eStatus; } //! //! \brief Get Hdr path needed flag //! \details Get Hdr path needed flag //! \param pRenderParams //! [in] Pointer to VPHAL render parameter //! \param pRenderPassData //! [in,out] Pointer to the VPHAL render pass data //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalRenderer::GetHdrPathNeededFlag( PVPHAL_RENDER_PARAMS pRenderParams, RenderpassData *pRenderPassData) { MOS_STATUS eStatus; uint32_t uiIndex; PVPHAL_SURFACE pSrcSurface; PVPHAL_SURFACE pTargetSurface; bool bToneMapping; bool bBt2020Output; bool bMultiLayerBt2020; //-------------------------------------------- VPHAL_RENDER_CHK_NULL(pRenderParams); VPHAL_RENDER_CHK_NULL(pRenderPassData); VPHAL_RENDER_CHK_NULL(pRenderParams->pTarget[0]); //-------------------------------------------- eStatus = MOS_STATUS_SUCCESS; uiIndex = 0; pSrcSurface = nullptr; pTargetSurface = nullptr; bToneMapping = false; bBt2020Output = false; bMultiLayerBt2020 = false; // Loop through the sources for (uiIndex = 0; uiIndex < VPHAL_MAX_SOURCES && uiIndex < pRenderParams->uSrcCount; uiIndex++) { pSrcSurface = pRenderParams->pSrc[uiIndex]; if (pSrcSurface == nullptr) { continue; } pTargetSurface = pRenderParams->pTarget[0]; // Need to use HDR to process BT601/BT709->BT2020 if (IS_COLOR_SPACE_BT2020(pRenderParams->pTarget[0]->ColorSpace) && !IS_COLOR_SPACE_BT2020(pSrcSurface->ColorSpace)) { bBt2020Output = true; } if ((pSrcSurface->pHDRParams && (pSrcSurface->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR)) || (pTargetSurface->pHDRParams && (pTargetSurface->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR))) { bToneMapping = true; } if (IS_COLOR_SPACE_BT2020(pSrcSurface->ColorSpace) && pRenderParams->uSrcCount > 1) { bMultiLayerBt2020 = true; } } pRenderPassData->bHdrNeeded = bBt2020Output || bToneMapping || bMultiLayerBt2020; // Error handling for illegal Hdr cases on unsupported m_Platform if ((pRenderPassData->bHdrNeeded) && (!MEDIA_IS_SKU(m_pSkuTable, FtrHDR))) { eStatus = MOS_STATUS_SUCCESS; VPHAL_RENDER_ASSERTMESSAGE("Illegal Hdr cases on unsupported m_Platform, turn off HDR."); pRenderPassData->bHdrNeeded = false; } if (pRenderPassData->bHdrNeeded) { pRenderPassData->bCompNeeded = false; } if (!pRenderPassData->bHdrNeeded && pRenderParams->pSrc[0] && pRenderParams->pTarget[0] && IS_COLOR_SPACE_BT2020(pRenderParams->pSrc[0]->ColorSpace) && !IS_COLOR_SPACE_BT2020(pRenderParams->pTarget[0]->ColorSpace) && MEDIA_IS_SKU(m_pSkuTable, FtrDisableVEBoxFeatures)) { eStatus = MOS_STATUS_INVALID_PARAMETER; VPHAL_RENDER_ASSERTMESSAGE("Invalid Params for This Platform."); } finish: return eStatus; }