/* * Copyright (c) 2009-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.cpp //! \brief Vphal Interface Definition //! \details Vphal Interface Definition Including: //! const and function //! #include "vphal.h" #include "mos_os.h" #include "mos_interface.h" #include "mhw_vebox.h" #include "renderhal_legacy.h" #include "vphal_renderer.h" #include "mos_solo_generic.h" #include "media_interfaces_vphal.h" #include "media_interfaces_mhw.h" #include "mhw_vebox_itf.h" #include "mos_oca_rtlog_mgr.h" #include "vp_user_setting.h" //! //! \brief Allocate VPHAL Resources //! \details Allocate VPHAL Resources //! - Allocate and initialize HW states //! - Allocate and initialize renderer states //! \param [in] pVpHalSettings //! Pointer to VPHAL Settings //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalState::Allocate( const VphalSettings *pVpHalSettings) { MHW_VEBOX_GPUNODE_LIMIT GpuNodeLimit; RENDERHAL_SETTINGS_LEGACY RenderHalSettings; MOS_GPU_NODE VeboxGpuNode; MOS_GPU_CONTEXT VeboxGpuContext; bool checkGpuCtxOverwriten = false; bool addGpuCtxToCheckList = false; MOS_STATUS eStatus; VPHAL_PUBLIC_CHK_NULL(m_osInterface); VPHAL_PUBLIC_CHK_NULL(pVpHalSettings); VPHAL_PUBLIC_CHK_NULL(m_renderHal); m_clearVideoViewMode = pVpHalSettings->clearVideoViewMode; if ((MEDIA_IS_SKU(m_skuTable, FtrVERing) || MEDIA_IS_SKU(m_skuTable, FtrSFCPipe)) && !m_clearVideoViewMode) { MhwInterfaces * mhwInterfaces = nullptr; MhwInterfaces::CreateParams params; MOS_ZeroMemory(¶ms, sizeof(params)); params.Flags.m_sfc = MEDIA_IS_SKU(m_skuTable, FtrSFCPipe); params.Flags.m_vebox = MEDIA_IS_SKU(m_skuTable, FtrVERing); mhwInterfaces = MhwInterfaces::CreateFactory(params, m_osInterface); if (mhwInterfaces) { SetMhwVeboxInterface(mhwInterfaces->m_veboxInterface); SetMhwSfcInterface(mhwInterfaces->m_sfcInterface); // MhwInterfaces always create CP and MI interfaces, so we have to delete those we don't need. MOS_Delete(mhwInterfaces->m_miInterface); m_osInterface->pfnDeleteMhwCpInterface(mhwInterfaces->m_cpInterface); mhwInterfaces->m_cpInterface = nullptr; MOS_Delete(mhwInterfaces); } else { VPHAL_DEBUG_ASSERTMESSAGE("Allocate MhwInterfaces failed"); eStatus = MOS_STATUS_NO_SPACE; MT_ERR1(MT_VP_HAL_INIT, MT_CODE_LINE, __LINE__); } } if (IsApoEnabled() && m_osInterface->apoMosEnabled && m_osInterface->bSetHandleInvalid) { checkGpuCtxOverwriten = true; } addGpuCtxToCheckList = checkGpuCtxOverwriten && !IsGpuContextReused(m_renderGpuContext); if (IsRenderContextBasedSchedulingNeeded()) { Mos_SetVirtualEngineSupported(m_osInterface, true); m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true); } // Create Render GPU Context { MOS_GPUCTX_CREATOPTIONS_ENHANCED createOption = {}; VPHAL_PUBLIC_CHK_STATUS(m_osInterface->pfnCreateGpuContext( m_osInterface, m_renderGpuContext, m_renderGpuNode, &createOption)); } // Set current GPU context VPHAL_PUBLIC_CHK_STATUS(m_osInterface->pfnSetGpuContext( m_osInterface, m_renderGpuContext)); // Add gpu context entry, including stream 0 gpu contexts // In legacy path, stream 0 gpu contexts could be reused, and will keep these stream 0 gpu contexts alive // But its mapping relation could be overwritten in APO path // Now, don't reuse these stream 0 gpu contexts overwritten by MediaContext in APO path // Can not add reused GPU context if (addGpuCtxToCheckList) { AddGpuContextToCheckList(m_renderGpuContext); } // Register Render GPU context with the event VPHAL_PUBLIC_CHK_STATUS(m_osInterface->pfnRegisterBBCompleteNotifyEvent( m_osInterface, m_renderGpuContext)); if (MEDIA_IS_SKU(m_skuTable, FtrVERing) && m_veboxInterface && !m_clearVideoViewMode) { GpuNodeLimit.bSfcInUse = MEDIA_IS_SKU(m_skuTable, FtrSFCPipe); if (m_veboxItf) { // Check GPU Node decide logic together in this function VPHAL_HW_CHK_STATUS(m_veboxItf->FindVeboxGpuNodeToUse(&GpuNodeLimit)); VeboxGpuNode = (MOS_GPU_NODE)(GpuNodeLimit.dwGpuNodeToUse); VeboxGpuContext = (VeboxGpuNode == MOS_GPU_NODE_VE) ? MOS_GPU_CONTEXT_VEBOX : MOS_GPU_CONTEXT_VEBOX2; VPHAL_PUBLIC_CHK_STATUS(m_veboxItf->CreateGpuContext( m_osInterface, VeboxGpuContext, VeboxGpuNode)); } // Check GPU Node decide logic together in this function VPHAL_HW_CHK_STATUS(m_veboxInterface->FindVeboxGpuNodeToUse(&GpuNodeLimit)); VeboxGpuNode = (MOS_GPU_NODE)(GpuNodeLimit.dwGpuNodeToUse); VeboxGpuContext = (VeboxGpuNode == MOS_GPU_NODE_VE) ? MOS_GPU_CONTEXT_VEBOX : MOS_GPU_CONTEXT_VEBOX2; addGpuCtxToCheckList = checkGpuCtxOverwriten && !IsGpuContextReused(VeboxGpuContext); // Create VEBOX/VEBOX2 Context VPHAL_PUBLIC_CHK_STATUS(m_veboxInterface->CreateGpuContext( m_osInterface, VeboxGpuContext, VeboxGpuNode)); // Add gpu context entry, including stream 0 gpu contexts if (addGpuCtxToCheckList) { AddGpuContextToCheckList(VeboxGpuContext); } // Register Vebox GPU context with the Batch Buffer completion event // Ignore if creation fails VPHAL_PUBLIC_CHK_STATUS(m_osInterface->pfnRegisterBBCompleteNotifyEvent( m_osInterface, MOS_GPU_CONTEXT_VEBOX)); } // Allocate and initialize HW states RenderHalSettings.iMediaStates = pVpHalSettings->mediaStates; VPHAL_PUBLIC_CHK_STATUS(m_renderHal->pfnInitialize(m_renderHal, &RenderHalSettings)); if (!m_clearVideoViewMode) { if (m_veboxItf) { const MHW_VEBOX_HEAP *veboxHeap = nullptr; m_veboxItf->GetVeboxHeapInfo(&veboxHeap); uint32_t uiNumInstances = m_veboxItf->GetVeboxNumInstances(); if (uiNumInstances > 0 && veboxHeap == nullptr) { // Allocate VEBOX Heap VPHAL_PUBLIC_CHK_STATUS(m_veboxItf->CreateHeap()); } } if (m_veboxInterface && m_veboxInterface->m_veboxSettings.uiNumInstances > 0 && m_veboxInterface->m_veboxHeap == nullptr) { VPHAL_PUBLIC_CHK_STATUS(m_veboxInterface->CreateHeap()); } } // Create renderer VPHAL_RENDER_CHK_STATUS(CreateRenderer()); // Allocate and initialize renderer states VPHAL_PUBLIC_CHK_STATUS(m_renderer->Initialize(pVpHalSettings, IsApoEnabled())); finish: return eStatus; } //! //! \brief Check if need to apply AVS for specified surface //! \details Check if need to apply AVS for specified surface //! \param pSurf //! [in] Pointer to VPHAL_SURFACE //! \return bool //! Return true if the input surface needs AVS scaling //! static bool IsSurfNeedAvs( PVPHAL_SURFACE pSurf) { VPHAL_PUBLIC_CHK_NULL_NO_STATUS(pSurf); // Not perform AVS for surface with alpha channel. if (IS_ALPHA_YUV_FORMAT(pSurf->Format)) { return false; } if (pSurf->SurfType == SURF_IN_PRIMARY || pSurf->SurfType == SURF_IN_SUBSTREAM) { if (pSurf->pBlendingParams) { return false; } if (IS_YUV_FORMAT(pSurf->Format)) { // Not perform AVS for surface with VPHAL_SCALING_NEAREST // or VPHAL_SCALING_BILINEAR scaling mode. if (pSurf->ScalingMode == VPHAL_SCALING_AVS || pSurf->ScalingMode == VPHAL_SCALING_ADV_QUALITY) { return true; } } } finish: return false; } //! //! \brief Check if all surfaces format order in pcRenderParams is suitable to enable multiple avs rendering (YUV is prior than RGB) //! \details In VpHal_RenderWithAvsForMultiStreams() we group YUV surfaces in phase one and the others in phase two. //! However, if there are 2+ overlapped source surfaces, e.g., pSrc[0]=B8G8R8A8 and pSrc[1]=NV12. //! We don't enable multiple avs rendering for such case since we expect pSrc[1] is above pSrc[0] on target. //! If multiple avs rendering is enabled, the compositing order is reverse and turns out pSrc[1] is below pSrc[0], //! which is the case need to prevent. //! \param pcRenderParams //! [in] Pointer to const VPHAL_RENDER_PARAMS //! \return bool //! Allow to enable multiple avs rendering //! static bool IsYuvPriorRgbInCompositeOrder( PCVPHAL_RENDER_PARAMS pcRenderParams) { bool bHasRgbSurface = false; uint32_t uiLastYuvIdx = 0; uint32_t uiFirstRgbIdx = 0; uint32_t iSourceIdx; VPHAL_PUBLIC_CHK_NULL_NO_STATUS(pcRenderParams); for (iSourceIdx = 0; iSourceIdx < pcRenderParams->uSrcCount; iSourceIdx++) { PVPHAL_SURFACE pSurf = pcRenderParams->pSrc[iSourceIdx]; if (IsSurfNeedAvs(pSurf)) { uiLastYuvIdx = iSourceIdx; } else if (!bHasRgbSurface) { bHasRgbSurface = true; uiFirstRgbIdx = iSourceIdx; } } finish: if (!bHasRgbSurface) { // return true if not contain any RGB surface return true; } return (uiLastYuvIdx < uiFirstRgbIdx); } //! //! \brief Check if need to apply AVS scaling for multiple surfaces //! \details Check if need to apply AVS scaling for multiple surfaces //! \param pcRenderParams //! [in] Pointer to const VPHAL_RENDER_PARAMS //! \return bool //! Return true if neeeded to enable AVS for all primary surfaces. //! static bool VpHal_IsAvsSampleForMultiStreamsEnabled( PCVPHAL_RENDER_PARAMS pcRenderParams) { uint32_t uSourceIdx; uint32_t uSourceBIdx; uint32_t uAvsSurfaceCnt = 0; bool bEnableAvsForMultiSurface = false; VPHAL_PUBLIC_CHK_NULL_NO_STATUS(pcRenderParams); //disable if only one, zero or invalid number source if (pcRenderParams->uSrcCount <= 1 || pcRenderParams->uSrcCount > VPHAL_MAX_SOURCES) { goto finish; } for (uSourceIdx = 0; uSourceIdx < pcRenderParams->uSrcCount; uSourceIdx++) { PVPHAL_SURFACE pSrcSurf = pcRenderParams->pSrc[uSourceIdx]; if (pSrcSurf && pSrcSurf->SurfType == SURF_IN_PRIMARY) { // VPHAL_SCALING_PREFER_SFC_FOR_VEBOX means scaling mode is FastMode, don't apply AVS for multiples if (pSrcSurf->ScalingPreference == VPHAL_SCALING_PREFER_SFC_FOR_VEBOX) { goto finish; } if (!IS_YUV_FORMAT(pSrcSurf->Format)) { goto finish; } // disabled if need denoise or deinterlace if (pSrcSurf->pDenoiseParams || pSrcSurf->pDeinterlaceParams) { goto finish; } if (0 < pSrcSurf->uFwdRefCount || 0 < pSrcSurf->uBwdRefCount) { goto finish; } } if (pSrcSurf && IsSurfNeedAvs(pSrcSurf)) { uAvsSurfaceCnt++; } } if (uAvsSurfaceCnt <= 1) { goto finish; } if (!IsYuvPriorRgbInCompositeOrder(pcRenderParams)) { goto finish; } // disable if any AVS surface overlay to other AVS surface. for (uSourceIdx = 0; uSourceIdx < pcRenderParams->uSrcCount; uSourceIdx++) { PVPHAL_SURFACE pSrcSurfA = pcRenderParams->pSrc[uSourceIdx]; if (pSrcSurfA && IsSurfNeedAvs(pSrcSurfA)) { for (uSourceBIdx = uSourceIdx + 1; uSourceBIdx < pcRenderParams->uSrcCount; uSourceBIdx++) { PVPHAL_SURFACE pSrcSurfB = pcRenderParams->pSrc[uSourceBIdx]; if (pSrcSurfB && IsSurfNeedAvs(pSrcSurfB) && !RECT1_OUTSIDE_RECT2(pSrcSurfA->rcDst, pSrcSurfB->rcDst)) // not outside means overlay { goto finish; } } } } bEnableAvsForMultiSurface = true; finish: return bEnableAvsForMultiSurface; } //! //! \brief Rendering with AVS scaling for multiple surfaces //! \details Rendering with AVS scaling for multiple surfaces //! Currently composition kernel only allows first primary surface with AVS. //! To apply AVS for multiple surfaces, this function do the following steps: //! (1) separating each AVS surface into different phases containing only one primary //! (2) rendering with individual primary, and let first pass with color filler //! (3) rendering remaining non-AVS substreams, if any, with intermediate surface in one phase to allow alpha blending. //! \param pRenderer //! [in] Pointer to VphalRenderer //! \param pcRenderParams //! [in] Pointer to const VPHAL_RENDER_PARAMS //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! static MOS_STATUS VpHal_RenderWithAvsForMultiStreams( VphalRenderer *pRenderer, PCVPHAL_RENDER_PARAMS pcRenderParams) { uint32_t uSourceIdx; VPHAL_RENDER_PARAMS RenderParams; VPHAL_COLORFILL_PARAMS colorFillForFirstRenderPass; bool bColorFillForFirstRender; bool bHasNonAvsSubstream; MOS_STATUS eStatusSingleRender; PVPHAL_SURFACE pIntermediateSurface; PVPHAL_SURFACE pBackGroundSurface; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; VPHAL_SCALING_PREFERENCE ePrimaryScalingPreference = VPHAL_SCALING_PREFER_SFC; VPHAL_RENDER_PARAMS *pRenderParams; VPHAL_PUBLIC_CHK_NULL(pRenderer); VPHAL_PUBLIC_CHK_NULL(pRenderer->GetOsInterface()); VPHAL_PUBLIC_CHK_NULL(pcRenderParams); VPHAL_PUBLIC_CHK_NULL(pcRenderParams->pTarget[0]); pRenderParams = (VPHAL_RENDER_PARAMS*)pcRenderParams; if (pcRenderParams->pColorFillParams) { colorFillForFirstRenderPass = *pcRenderParams->pColorFillParams; } else { colorFillForFirstRenderPass.bYCbCr = false; colorFillForFirstRenderPass.Color = 0; colorFillForFirstRenderPass.CSpace = CSpace_sRGB; } pIntermediateSurface = &pRenderer->IntermediateSurface; // check if having non-AVS substream bHasNonAvsSubstream = false; pBackGroundSurface = nullptr; for (uSourceIdx = 0; uSourceIdx < pcRenderParams->uSrcCount; uSourceIdx++) { PVPHAL_SURFACE pSurf = (PVPHAL_SURFACE)pcRenderParams->pSrc[uSourceIdx]; if (pSurf && pSurf->SurfType == SURF_IN_SUBSTREAM) { if (!IS_YUV_FORMAT(pSurf->Format)) { bHasNonAvsSubstream = true; } } if (pSurf && pSurf->SurfType == SURF_IN_BACKGROUND) { pBackGroundSurface = pSurf; } // keep scaling preference of primary for later usage if (pSurf && pSurf->SurfType == SURF_IN_PRIMARY) { ePrimaryScalingPreference = pSurf->ScalingPreference; } } // create an intermediate surface if having non-AVS substream, as phase 1 output and phase 2 input. if (bHasNonAvsSubstream) { bool bAllocated; uint32_t dwTempWidth = pcRenderParams->pTarget[0]->dwWidth; uint32_t dwTempHeight = pcRenderParams->pTarget[0]->dwHeight; // Allocate/Reallocate temporary output if (dwTempWidth > pRenderer->IntermediateSurface.dwWidth || dwTempHeight > pRenderer->IntermediateSurface.dwHeight) { dwTempWidth = MOS_MAX(dwTempWidth , pRenderer->IntermediateSurface.dwWidth); dwTempHeight = MOS_MAX(dwTempHeight, pRenderer->IntermediateSurface.dwHeight); dwTempWidth = MOS_ALIGN_CEIL(dwTempWidth , VPHAL_BUFFER_SIZE_INCREMENT); dwTempHeight = MOS_ALIGN_CEIL(dwTempHeight, VPHAL_BUFFER_SIZE_INCREMENT); eStatusSingleRender = VpHal_ReAllocateSurface( pRenderer->GetOsInterface(), &pRenderer->IntermediateSurface, "RenderIntermediateSurface", pcRenderParams->pTarget[0]->Format, MOS_GFXRES_2D, pcRenderParams->pTarget[0]->TileType, dwTempWidth, dwTempHeight, false, MOS_MMC_DISABLED, &bAllocated); if (MOS_SUCCEEDED(eStatusSingleRender)) { pIntermediateSurface->SurfType = SURF_IN_PRIMARY; pIntermediateSurface->SampleType = SAMPLE_PROGRESSIVE; pIntermediateSurface->ColorSpace = pcRenderParams->pTarget[0]->ColorSpace; pIntermediateSurface->ExtendedGamut = pcRenderParams->pTarget[0]->ExtendedGamut; pIntermediateSurface->rcSrc = pcRenderParams->pTarget[0]->rcSrc; pIntermediateSurface->rcDst = pcRenderParams->pTarget[0]->rcDst; pIntermediateSurface->ScalingMode = VPHAL_SCALING_AVS; pIntermediateSurface->bIEF = false; } else { eStatus = eStatusSingleRender; bHasNonAvsSubstream = false; VPHAL_PUBLIC_ASSERTMESSAGE("Failed to create intermediate surface, eStatus: %d.\n", eStatus); MT_ERR1(MT_VP_HAL_REALLOC_SURF, MT_CODE_LINE, __LINE__); } } } // phase 1: render each AVS surface in separated pass bColorFillForFirstRender = true; RenderParams = *pRenderParams; RenderParams.uDstCount = 1; MOS_ZeroMemory(RenderParams.pSrc, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES); for (uSourceIdx = 0; uSourceIdx < pcRenderParams->uSrcCount; uSourceIdx++) { VPHAL_SURFACE SinglePassSource; PVPHAL_SURFACE pSurf = (PVPHAL_SURFACE)pcRenderParams->pSrc[uSourceIdx]; RenderParams.uSrcCount = 0; if (pSurf && IsSurfNeedAvs(pSurf)) { SinglePassSource = *(pSurf); SinglePassSource.SurfType = SURF_IN_PRIMARY; SinglePassSource.ScalingMode = VPHAL_SCALING_AVS; SinglePassSource.ScalingPreference = ePrimaryScalingPreference; RenderParams.pTarget[0] = (bHasNonAvsSubstream ? pIntermediateSurface : pcRenderParams->pTarget[0]); if (bColorFillForFirstRender) // apply color-fill for the first rendering { bColorFillForFirstRender = false; RenderParams.pColorFillParams = &colorFillForFirstRenderPass; if (pBackGroundSurface) { RenderParams.pSrc[RenderParams.uSrcCount] = pBackGroundSurface; RenderParams.uSrcCount++; } } else if (!bColorFillForFirstRender && SinglePassSource.pLumaKeyParams) // colorfill is needed if lumakey enabled on a single pass { RenderParams.pColorFillParams = &colorFillForFirstRenderPass; RenderParams.pTarget[0]->rcDst = SinglePassSource.rcDst; } else { RenderParams.pTarget[0]->rcDst = SinglePassSource.rcDst; RenderParams.pColorFillParams = nullptr; } RenderParams.pSrc[RenderParams.uSrcCount] = &SinglePassSource; RenderParams.uSrcCount++; // continue the next pfnRender even if single pass failed, but return eStatus failed. eStatusSingleRender = pRenderer->Render((PCVPHAL_RENDER_PARAMS)(&RenderParams)); if (MOS_FAILED(eStatusSingleRender)) { eStatus = eStatusSingleRender; VPHAL_PUBLIC_ASSERTMESSAGE("Failed to redner for primary streams, eStatus: %d.\n", eStatus); MT_ERR2(MT_VP_HAL_RENDER, MT_ERROR_CODE, eStatus, MT_CODE_LINE, __LINE__); } } } // phase 2: if having non-AVS substream, render them with previous output in one pass. if (bHasNonAvsSubstream) { RenderParams = *pRenderParams; MOS_ZeroMemory(RenderParams.pSrc, sizeof(PVPHAL_SURFACE) * VPHAL_MAX_SOURCES); pIntermediateSurface->rcSrc = pcRenderParams->pTarget[0]->rcSrc; pIntermediateSurface->rcDst = pcRenderParams->pTarget[0]->rcDst; RenderParams.pSrc[0] = pIntermediateSurface; RenderParams.uSrcCount = 1; RenderParams.uDstCount = 1; for (uSourceIdx = 0; uSourceIdx < pcRenderParams->uSrcCount; uSourceIdx++) { PVPHAL_SURFACE pSurf = pcRenderParams->pSrc[uSourceIdx]; bool bIsSurfForPhase2 = (pSurf && (!IsSurfNeedAvs(pSurf)) && (pSurf->SurfType != SURF_IN_BACKGROUND)); if (bIsSurfForPhase2) { RenderParams.pSrc[RenderParams.uSrcCount] = pSurf; RenderParams.uSrcCount++; } } eStatusSingleRender = pRenderer->Render((PCVPHAL_RENDER_PARAMS)(&RenderParams)); if (MOS_FAILED(eStatusSingleRender)) { eStatus = eStatusSingleRender; VPHAL_PUBLIC_ASSERTMESSAGE("Failed to redner for substreams, eStatus: %d.\n", eStatus); MT_ERR2(MT_VP_HAL_RENDER, MT_ERROR_CODE, eStatus, MT_CODE_LINE, __LINE__); } } finish: return eStatus; } //! //! \brief Performs VP Rendering //! \details Performs VP Rendering //! - call default render of video //! \param [in] pcRenderParams //! Pointer to Render Params //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalState::Render( PCVPHAL_RENDER_PARAMS pcRenderParams) { MOS_STATUS eStatus; VPHAL_RENDER_PARAMS RenderParams; VPHAL_PUBLIC_CHK_NULL(pcRenderParams); RenderParams = *pcRenderParams; // Explicitly initialize the maxSrcRect of VphalRenderer // so that the maxSrcRect for the last set of surfaces does not get // re-used for the current set of surfaces. m_renderer->InitMaxSrcRect(); if (VpHal_IsAvsSampleForMultiStreamsEnabled(pcRenderParams)) { eStatus = VpHal_RenderWithAvsForMultiStreams(m_renderer, pcRenderParams); goto finish; } // default render of video RenderParams.bIsDefaultStream = true; eStatus = m_renderer->Render((PCVPHAL_RENDER_PARAMS)(&RenderParams)); finish: return eStatus; } //! //! \brief Get feature reporting from renderer //! \details Get feature reporting from renderer //! \return VphalFeatureReport* //! Pointer to VphalFeatureReport: rendering features reported //! VphalFeatureReport* VphalState::GetRenderFeatureReport() { VPHAL_PUBLIC_ASSERT(m_renderer); return m_renderer->GetReport(); } //! //! \brief VphalState Constructor //! \details Creates instance of VphalState //! - Return pointer to initialized VPHAL state, but not yet fully allocated //! - Caller must call pfnAllocate to allocate all VPHAL states and objects. //! \param [in] pOsInterface //! OS interface, if provided externally - may be nullptr //! \param [in,out] peStatus //! Pointer to the MOS_STATUS flag. //! Will assign this flag to MOS_STATUS_SUCCESS if successful, otherwise failed //! VphalState::VphalState( PMOS_INTERFACE pOsInterface, MOS_STATUS *peStatus) : m_platform(), m_skuTable(nullptr), m_waTable(nullptr), m_osInterface(pOsInterface), m_renderHal(nullptr), m_veboxInterface(nullptr), m_cpInterface(nullptr), m_sfcInterface(nullptr), m_renderer(nullptr), m_renderGpuNode(MOS_GPU_NODE_3D), m_renderGpuContext(MOS_GPU_CONTEXT_RENDER) { MOS_STATUS eStatus; eStatus = MOS_STATUS_UNKNOWN; VPHAL_PUBLIC_CHK_NULL(m_osInterface); // Initialize platform, sku, wa tables m_osInterface->pfnGetPlatform(m_osInterface, &m_platform); m_skuTable = m_osInterface->pfnGetSkuTable(m_osInterface); m_waTable = m_osInterface->pfnGetWaTable (m_osInterface); m_userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface); VpUserSetting::InitVpUserSetting(m_userSettingPtr); m_renderHal = (PRENDERHAL_INTERFACE_LEGACY)MOS_AllocAndZeroMemory(sizeof(RENDERHAL_INTERFACE_LEGACY)); VPHAL_PUBLIC_CHK_NULL(m_renderHal); VPHAL_PUBLIC_CHK_STATUS(RenderHal_InitInterface_Legacy( m_renderHal, &m_cpInterface, m_osInterface)); finish: if(peStatus) { *peStatus = eStatus; } } //! //! \brief Vphal Destructor //! \details Destroys VPHAL and all internal states and objects //! \return void //! VphalState::~VphalState() { MOS_STATUS eStatus; // Wait for all cmd before destroy gpu resource if (m_osInterface && m_osInterface->pfnWaitAllCmdCompletion && m_osInterface->bDeallocateOnExit) { VP_PUBLIC_NORMALMESSAGE("WaitAllCmdCompletion in VphalState::~VphalState"); m_osInterface->pfnWaitAllCmdCompletion(m_osInterface); } // Destroy rendering objects (intermediate surfaces, BBs, etc) if (m_renderer) { MOS_Delete(m_renderer); m_renderer = nullptr; } if (m_renderHal) { if (m_renderHal->pfnDestroy) { eStatus = m_renderHal->pfnDestroy(m_renderHal); if (eStatus != MOS_STATUS_SUCCESS) { VPHAL_PUBLIC_ASSERTMESSAGE("Failed to destroy RenderHal, eStatus:%d.\n", eStatus); MT_ERR1(MT_VP_HAL_DESTROY, MT_CODE_LINE, __LINE__); } } MOS_FreeMemory(m_renderHal); } if (m_cpInterface) { if (m_osInterface) { m_osInterface->pfnDeleteMhwCpInterface(m_cpInterface); m_cpInterface = nullptr; } else { VPHAL_PUBLIC_ASSERTMESSAGE("Failed to destroy cpInterface."); } } if (m_sfcInterface) { MOS_Delete(m_sfcInterface); m_sfcInterface = nullptr; } if (m_veboxInterface) { if (m_veboxItf) { eStatus = m_veboxItf->DestroyHeap(); if (eStatus != MOS_STATUS_SUCCESS) { VPHAL_PUBLIC_ASSERTMESSAGE("Failed to destroy Vebox Interface, eStatus:%d.\n", eStatus); MT_ERR1(MT_VP_HAL_DESTROY, MT_CODE_LINE, __LINE__); } } eStatus = m_veboxInterface->DestroyHeap(); MOS_Delete(m_veboxInterface); m_veboxInterface = nullptr; m_veboxItf = nullptr; if (eStatus != MOS_STATUS_SUCCESS) { VPHAL_PUBLIC_ASSERTMESSAGE("Failed to destroy Vebox Interface, eStatus:%d.\n", eStatus); MT_ERR1(MT_VP_HAL_DESTROY, MT_CODE_LINE, __LINE__); } } // Destroy OS interface objects (CBs, etc) if (m_osInterface) { if (m_osInterface->bDeallocateOnExit) { //Clear some overwriten gpucontext resources if (!m_gpuContextCheckList.empty()) { DestroyGpuContextWithInvalidHandle(); m_gpuContextCheckList.clear(); } m_osInterface->pfnDestroy(m_osInterface, true); // Deallocate OS interface structure (except if externally provided) MOS_FreeMemory(m_osInterface); } } } VphalState* VphalState::VphalStateFactory( PMOS_INTERFACE pOsInterface, PMOS_CONTEXT pOsDriverContext, MOS_STATUS *peStatus) { VphalState* vphalState = dynamic_cast(VphalDevice::CreateFactory(pOsInterface, pOsDriverContext, peStatus)); if(nullptr == vphalState) { VPHAL_PUBLIC_ASSERTMESSAGE("vphal state pointer is nullptr"); *peStatus = MOS_STATUS_NULL_POINTER; } return vphalState; } //! //! \brief Get Status Report //! \details Get Status Report, will return back to app indicating if related frame id is done by gpu //! \param [out] pQueryReport //! Pointer to pQueryReport, the status query report array. //! \param [in] wStatusNum //! The size of array pQueryReport. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed MOS_STATUS VphalState::GetStatusReport( PQUERY_STATUS_REPORT_APP pQueryReport, uint16_t wStatusNum) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; #if (!EMUL) // this function is dummy for emul uint32_t i; uint32_t uiTableLen; PVPHAL_STATUS_TABLE pStatusTable; PMOS_CONTEXT pOsContext; uint32_t uiIndex; uint32_t uiNewHead; PVPHAL_STATUS_ENTRY pStatusEntry; bool bMarkNotReadyForRemains = false; VPHAL_PUBLIC_CHK_NULL(pQueryReport); VPHAL_PUBLIC_CHK_NULL(m_osInterface); VPHAL_PUBLIC_CHK_NULL(m_osInterface->pOsContext); // it should be ok if we don't consider the null render // eNullRender = m_pOsInterface->pfnGetNullHWRenderFlags(m_pOsInterface); pOsContext = m_osInterface->pOsContext; pStatusTable = &m_statusTable; uiNewHead = pStatusTable->uiHead; // uiNewHead start from previous head value // entry length from head to tail if (pStatusTable->uiCurrent < pStatusTable->uiHead) { uiTableLen = pStatusTable->uiCurrent + VPHAL_STATUS_TABLE_MAX_SIZE - pStatusTable->uiHead; } else { uiTableLen = pStatusTable->uiCurrent - pStatusTable->uiHead; } // step 1 - update pStatusEntry from driver if command associated with the dwTag is done by gpu for (i = 0; i < wStatusNum && i < uiTableLen; i++) { uint32_t dwGpuTag; // hardware tag updated by gpu command pipectl bool bDoneByGpu; bool bFailedOnSubmitCmd; uiIndex = (pStatusTable->uiHead + i) & (VPHAL_STATUS_TABLE_MAX_SIZE - 1); pStatusEntry = &pStatusTable->aTableEntries[uiIndex]; // for tasks using CM, different streamIndexes may be used uint32_t oldStreamIndex = m_osInterface->streamIndex; if (pStatusEntry->isStreamIndexSet) { m_osInterface->streamIndex = pStatusEntry->streamIndex; } if (bMarkNotReadyForRemains) { // the status is set as VPREP_NOTREADY while submitting commands pQueryReport[i].dwStatus = pStatusEntry->dwStatus; pQueryReport[i].StatusFeedBackID = pStatusEntry->StatusFeedBackID; continue; } dwGpuTag = m_osInterface->pfnGetGpuStatusSyncTag(m_osInterface, pStatusEntry->GpuContextOrdinal); bDoneByGpu = (dwGpuTag >= pStatusEntry->dwTag); bFailedOnSubmitCmd = (pStatusEntry->dwStatus == VPREP_ERROR); #if (_DEBUG || _RELEASE_INTERNAL) MOS_NULL_RENDERING_FLAGS NullRender = m_osInterface->pfnGetNullHWRenderFlags(m_osInterface); if (NullRender.Value != 0) { bDoneByGpu = true; } #endif if (bFailedOnSubmitCmd) { uiNewHead = (uiIndex + 1) & (VPHAL_STATUS_TABLE_MAX_SIZE - 1); } else if (bDoneByGpu) { pStatusEntry->dwStatus = VPREP_OK; uiNewHead = (uiIndex + 1) & (VPHAL_STATUS_TABLE_MAX_SIZE - 1); } else { // here we have the first not ready entry. #if (LINUX || ANDROID) uiNewHead = (uiIndex + 1) & (VPHAL_STATUS_TABLE_MAX_SIZE - 1); #else uiNewHead = uiIndex; #endif bMarkNotReadyForRemains = true; } if (m_osInterface->pfnIsGPUHung(m_osInterface)) { pStatusEntry->dwStatus = VPREP_NOTREADY; } pQueryReport[i].dwStatus = pStatusEntry->dwStatus; pQueryReport[i].StatusFeedBackID = pStatusEntry->StatusFeedBackID; if (pStatusEntry->isStreamIndexSet) { m_osInterface->streamIndex = oldStreamIndex; } } pStatusTable->uiHead = uiNewHead; // step 2 - mark VPREP_NOTAVAILABLE for unused entry for (/* continue from previous i */; i < wStatusNum; i++) { pQueryReport[i].dwStatus = VPREP_NOTAVAILABLE; pQueryReport[i].StatusFeedBackID = 0; } finish: #else MOS_UNUSED(pQueryReport); MOS_UNUSED(wStatusNum); #endif // end (!EMUL && !ANDROID) return eStatus; } //! //! \brief Get Status Report's entry length from head to tail //! \details Get Status Report's entry length from head to tail //! \param [out] puiLength //! Pointer to the entry length //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalState::GetStatusReportEntryLength( uint32_t* puiLength) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; #if(!EMUL) // this function is dummy for emul PVPHAL_STATUS_TABLE pStatusTable; VPHAL_PUBLIC_CHK_NULL(puiLength); pStatusTable = &m_statusTable; // entry length from head to tail if (pStatusTable->uiCurrent < pStatusTable->uiHead) { *puiLength = pStatusTable->uiCurrent + VPHAL_STATUS_TABLE_MAX_SIZE - pStatusTable->uiHead; } else { *puiLength = pStatusTable->uiCurrent - pStatusTable->uiHead; } finish: #else MOS_UNUSED(puiLength); #endif return eStatus; } MOS_STATUS VphalState::GetVpMhwInterface( VP_MHWINTERFACE &vpMhwinterface) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; vpMhwinterface.m_platform = m_platform; vpMhwinterface.m_waTable = m_waTable; vpMhwinterface.m_skuTable = m_skuTable; vpMhwinterface.m_osInterface = m_osInterface; vpMhwinterface.m_renderHal = m_renderHal; vpMhwinterface.m_veboxInterface = m_veboxInterface; vpMhwinterface.m_sfcInterface = m_sfcInterface; vpMhwinterface.m_cpInterface = m_cpInterface; vpMhwinterface.m_mhwMiInterface = m_renderHal->pMhwMiInterface; vpMhwinterface.m_statusTable = &m_statusTable; return eStatus; } //! //! \brief Put GPU context entry //! \details Put GPU context entry in the m_gpuContextCheckList //! \param MOS_GPU_CONTEXT mosGpuConext //! [in] Mos GPU context //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalState::AddGpuContextToCheckList( MOS_GPU_CONTEXT mosGpuConext) { #if !EMUL MOS_GPU_CONTEXT originalGpuCtxOrdinal = m_osInterface->CurrentGpuContextOrdinal; if (mosGpuConext != originalGpuCtxOrdinal) { // Set GPU context temporarily VPHAL_PUBLIC_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext( m_osInterface, mosGpuConext)); } VPHAL_GPU_CONTEXT_ENTRY tmpEntry; tmpEntry.gpuCtxForMos = mosGpuConext; tmpEntry.gpuContextHandle = m_osInterface->CurrentGpuContextHandle; tmpEntry.pGpuContext = m_osInterface->pfnGetGpuContextbyHandle(m_osInterface, m_osInterface->CurrentGpuContextHandle); m_gpuContextCheckList.push_back(tmpEntry); if (mosGpuConext != originalGpuCtxOrdinal) { //Recover original settings VPHAL_PUBLIC_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext( m_osInterface, originalGpuCtxOrdinal)); } #endif return MOS_STATUS_SUCCESS; } //! //! \brief Destroy GPU context entry with invalid handle //! \details Release these GPU context overwritten by MediaContext //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS VphalState::DestroyGpuContextWithInvalidHandle() { #if !EMUL MOS_GPU_CONTEXT originalGpuCtxOrdinal = m_osInterface->CurrentGpuContextOrdinal; for (auto &curGpuEntry : m_gpuContextCheckList) { //Failure in switching GPU Context indicates that we can't find and release gpu context in normal flow later //So if failed to switch GPU Context, just need to check GPU context, and release it here //If switch GPU Context successfully, need to check both handle and GPU context if ((MOS_FAILED(m_osInterface->pfnSetGpuContext(m_osInterface, curGpuEntry.gpuCtxForMos)) || m_osInterface->CurrentGpuContextHandle != curGpuEntry.gpuContextHandle) && m_osInterface->pfnGetGpuContextbyHandle(m_osInterface, curGpuEntry.gpuContextHandle) == curGpuEntry.pGpuContext) { m_osInterface->pfnWaitForCmdCompletion(m_osInterface->osStreamState, curGpuEntry.gpuContextHandle); m_osInterface->pfnDestroyGpuContextByHandle(m_osInterface, curGpuEntry.gpuContextHandle); } } if (m_osInterface->CurrentGpuContextOrdinal != originalGpuCtxOrdinal) { //Recover original settings if (m_osInterface->pfnSetGpuContext(m_osInterface, originalGpuCtxOrdinal) != MOS_STATUS_SUCCESS) { VPHAL_PUBLIC_NORMALMESSAGE("Have not recovered original GPU Context settings in m_osInterface"); } } #endif return MOS_STATUS_SUCCESS; } //! //! \brief Check whether GPU context is reused or not //! \details Check whether GPU context is reused or not //! \param MOS_GPU_CONTEXT mosGpuConext //! [in] Mos GPU context //! \return bool //! Return true if is reused, otherwise false //! bool VphalState::IsGpuContextReused( MOS_GPU_CONTEXT mosGpuContext) { bool reuseContextFlag = false; #if !EMUL MOS_GPU_CONTEXT originalGpuCtxOrdinal = m_osInterface->CurrentGpuContextOrdinal; if (MOS_SUCCEEDED(m_osInterface->pfnSetGpuContext(m_osInterface, mosGpuContext))) { VPHAL_PUBLIC_NORMALMESSAGE("Reuse mos GPU context %d. GPU handle %d", (uint32_t)mosGpuContext, m_osInterface->CurrentGpuContextHandle); reuseContextFlag = true; } if (originalGpuCtxOrdinal < MOS_GPU_CONTEXT_MAX && m_osInterface->CurrentGpuContextOrdinal != originalGpuCtxOrdinal) { //Recover original settings if (m_osInterface->pfnSetGpuContext(m_osInterface, originalGpuCtxOrdinal) != MOS_STATUS_SUCCESS) { VPHAL_PUBLIC_NORMALMESSAGE("Have not recovered original GPU Context settings in m_osInterface"); } } #endif return reuseContextFlag; }