/* * Copyright (c) 2017, 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 codechal_decode_histogram_vebox.cpp //! \brief implements the decode histogram through vebox. //! \details decode histogram through vebox. //! #include "codechal_decode_histogram_vebox.h" #include "mos_utilities.h" CodechalDecodeHistogramVebox::CodechalDecodeHistogramVebox( CodechalHwInterface *hwInterface, MOS_INTERFACE *osInterface): CodechalDecodeHistogram(hwInterface, osInterface), m_veboxInterface(hwInterface->GetVeboxInterface()) { MOS_ZeroMemory(&m_resSyncObject, sizeof(m_resSyncObject)); MOS_ZeroMemory(&m_resStatisticsOutput, sizeof(m_resStatisticsOutput)); MOS_ZeroMemory(&m_outputSurface, sizeof(m_outputSurface)); // allocate heap MOS_STATUS status = m_veboxInterface->CreateHeap(); if (status != MOS_STATUS_SUCCESS) { CODECHAL_DECODE_ASSERTMESSAGE("Failed to CreateHeap."); } // create Vebox context MOS_GPUCTX_CREATOPTIONS createOpts; m_osInterface->pfnCreateGpuContext( m_osInterface, MOS_GPU_CONTEXT_VEBOX, MOS_GPU_NODE_VE, &createOpts); // register Vebox GPU context with the Batch Buffer completion event m_osInterface->pfnRegisterBBCompleteNotifyEvent( m_osInterface, MOS_GPU_CONTEXT_VEBOX); } CodechalDecodeHistogramVebox::~CodechalDecodeHistogramVebox() { if (!Mos_ResourceIsNull(&m_resSyncObject)) { m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObject); } if (!Mos_ResourceIsNull(&m_resStatisticsOutput)) { m_osInterface->pfnFreeResource(m_osInterface, &m_resStatisticsOutput); } if (!Mos_ResourceIsNull(&m_outputSurface.OsResource)) { m_osInterface->pfnFreeResource(m_osInterface, &m_outputSurface.OsResource); } } MOS_STATUS CodechalDecodeHistogramVebox::AllocateResources() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; // allocate sync object if (Mos_ResourceIsNull(&m_resSyncObject)) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource( m_osInterface, &m_resSyncObject)); } uint32_t size = 0; // allocate internal histogram resource if (Mos_ResourceIsNull(&m_resHistogram) || m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { // Need to reallocate if (m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { m_osInterface->pfnFreeResource(m_osInterface, &m_resHistogram); } m_hwInterface->GetHcpInterface()->GetOsResLaceOrAceOrRgbHistogramBufferSize( m_inputSurface->dwWidth, m_inputSurface->dwHeight, &size); MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear; MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS)); allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER; allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR; allocParamsForBufferLinear.Format = Format_Buffer; allocParamsForBufferLinear.dwBytes = size; allocParamsForBufferLinear.pBufName = "ResLaceOrAceOrRgbHistogram"; eStatus = m_osInterface->pfnAllocateResource( m_osInterface, &allocParamsForBufferLinear, &m_resHistogram); if (eStatus != MOS_STATUS_SUCCESS) { CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate histogram buffer."); return eStatus; } } // allocate statistics output resource to avoid Page Fault issue since HW will access it if (Mos_ResourceIsNull(&m_resStatisticsOutput) || m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { // Need to reallocate if (m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { m_osInterface->pfnFreeResource(m_osInterface, &m_resStatisticsOutput); } m_hwInterface->GetHcpInterface()->GetOsResStatisticsOutputBufferSize( m_inputSurface->dwWidth, m_inputSurface->dwHeight, &size); MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear; MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS)); allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER; allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR; allocParamsForBufferLinear.Format = Format_Buffer; allocParamsForBufferLinear.dwBytes = size; allocParamsForBufferLinear.pBufName = "m_resStatisticsOutput"; eStatus = m_osInterface->pfnAllocateResource( m_osInterface, &allocParamsForBufferLinear, &m_resStatisticsOutput); if (eStatus != MOS_STATUS_SUCCESS) { CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate statistics output buffer."); return eStatus; } } // allocate vebox output surface if (Mos_ResourceIsNull(&m_outputSurface.OsResource) || m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { // Need to reallocate if (m_preWidth != m_inputSurface->dwWidth || m_preHeight != m_inputSurface->dwHeight) { m_osInterface->pfnFreeResource(m_osInterface, &m_outputSurface.OsResource); } CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(m_decoder->AllocateSurface( &m_outputSurface, m_inputSurface->dwWidth, m_inputSurface->dwHeight, "VeboxOutputBuffer"), "Failed to allocate vebox output surface buffer."); } m_preWidth = m_inputSurface->dwWidth; m_preHeight = m_inputSurface->dwHeight; return eStatus; } MOS_STATUS CodechalDecodeHistogramVebox::SetVeboxStateParams( PMHW_VEBOX_STATE_CMD_PARAMS veboxCmdParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; veboxCmdParams->bNoUseVeboxHeap = 0; veboxCmdParams->VeboxMode.ColorGamutExpansionEnable = 0; veboxCmdParams->VeboxMode.ColorGamutCompressionEnable = 0; // On SKL, GlobalIECP must be enabled when the output pipe is Vebox or SFC veboxCmdParams->VeboxMode.GlobalIECPEnable = 1; veboxCmdParams->VeboxMode.DNEnable = 0; veboxCmdParams->VeboxMode.DIEnable = 0; veboxCmdParams->VeboxMode.DNDIFirstFrame = 0; veboxCmdParams->VeboxMode.DIOutputFrames = 0; veboxCmdParams->VeboxMode.PipeSynchronizeDisable = 0; veboxCmdParams->VeboxMode.DemosaicEnable = 0; veboxCmdParams->VeboxMode.VignetteEnable = 0; veboxCmdParams->VeboxMode.AlphaPlaneEnable = 0; veboxCmdParams->VeboxMode.HotPixelFilteringEnable = 0; // 0-both slices enabled 1-Slice 0 enabled 2-Slice 1 enabled // On SKL GT3 and GT4, there are 2 Veboxes. But only Vebox0 can be used,Vebox1 cannot be used veboxCmdParams->VeboxMode.SingleSliceVeboxEnable = 1; veboxCmdParams->VeboxMode.LACECorrectionEnable = 0; veboxCmdParams->VeboxMode.DisableEncoderStatistics = 1; veboxCmdParams->VeboxMode.DisableTemporalDenoiseFilter = 1; veboxCmdParams->VeboxMode.SinglePipeIECPEnable = 0; veboxCmdParams->VeboxMode.SFCParallelWriteEnable = 0; veboxCmdParams->VeboxMode.ScalarMode = 0; veboxCmdParams->VeboxMode.ForwardGammaCorrectionEnable = 0; return eStatus; } MOS_STATUS CodechalDecodeHistogramVebox::SetVeboxSurfaceStateParams( PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS veboxSurfParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; // Initialize SurfInput veboxSurfParams->SurfInput.bActive = true; veboxSurfParams->SurfInput.Format = m_inputSurface->Format; veboxSurfParams->SurfInput.dwWidth = m_inputSurface->dwWidth; veboxSurfParams->SurfInput.dwHeight = m_inputSurface->UPlaneOffset.iYOffset; // For Planar formats, pParams->SurfInput.dwHeight will be assigned to VEBOX U.Y offset, which is only used for PLANAR surface formats. veboxSurfParams->SurfInput.dwUYoffset = m_inputSurface->UPlaneOffset.iYOffset; veboxSurfParams->SurfInput.dwPitch = m_inputSurface->dwPitch; veboxSurfParams->SurfInput.TileType = m_inputSurface->TileType; veboxSurfParams->SurfInput.TileModeGMM = m_inputSurface->TileModeGMM; veboxSurfParams->SurfInput.bGMMTileEnabled = m_inputSurface->bGMMTileEnabled; veboxSurfParams->SurfInput.pOsResource = &m_inputSurface->OsResource; veboxSurfParams->SurfInput.rcMaxSrc.left = 0; veboxSurfParams->SurfInput.rcMaxSrc.top = 0; veboxSurfParams->SurfInput.rcMaxSrc.right = MOS_ALIGN_CEIL(m_inputSurface->dwWidth, MHW_SFC_VE_WIDTH_ALIGN); veboxSurfParams->SurfInput.rcMaxSrc.bottom = MOS_ALIGN_CEIL(m_inputSurface->dwHeight, MHW_SFC_VE_HEIGHT_ALIGN); // Initialize SurfSTMM veboxSurfParams->SurfSTMM.dwPitch = m_inputSurface->dwPitch; veboxSurfParams->bDIEnable = false; veboxSurfParams->bOutputValid = false; return eStatus; } MOS_STATUS CodechalDecodeHistogramVebox::SetVeboxDiIecpParams( PMHW_VEBOX_DI_IECP_CMD_PARAMS veboxDiIecpParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; veboxDiIecpParams->dwStartingX = 0; veboxDiIecpParams->dwEndingX = m_inputSurface->dwWidth - 1; veboxDiIecpParams->dwCurrInputSurfOffset = m_inputSurface->dwOffset; veboxDiIecpParams->pOsResCurrInput = &m_inputSurface->OsResource; veboxDiIecpParams->pOsResCurrOutput = &m_outputSurface.OsResource; veboxDiIecpParams->CurrInputSurfCtrl.Value = 0; veboxDiIecpParams->CurrOutputSurfCtrl.Value = 0; CodecHalGetResourceInfo(m_osInterface, m_inputSurface); CodecHalGetResourceInfo(m_osInterface, &m_outputSurface); veboxDiIecpParams->CurInputSurfMMCState = (MOS_MEMCOMP_STATE)(m_inputSurface->CompressionMode); veboxDiIecpParams->pOsResLaceOrAceOrRgbHistogram = &m_resHistogram; veboxDiIecpParams->pOsResStatisticsOutput = &m_resStatisticsOutput; return eStatus; } MOS_STATUS CodechalDecodeHistogramVebox::SetVeboxIecpParams( PMHW_VEBOX_IECP_PARAMS veboxIecpParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; veboxIecpParams->ColorPipeParams.bActive = true; veboxIecpParams->ColorPipeParams.bEnableACE = true; veboxIecpParams->AceParams.bActive = true; veboxIecpParams->srcFormat = m_inputSurface->Format; veboxIecpParams->bCSCEnable = false; return eStatus; } MOS_STATUS CodechalDecodeHistogramVebox::RenderHistogram( CodechalDecode *codechalDecoder, MOS_SURFACE *inputSurface) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_HW_FUNCTION_ENTER; if (Mos_ResourceIsNull(&m_inputHistogramSurfaces[m_histogramComponent].OsResource)) { CODECHAL_DECODE_VERBOSEMESSAGE("Input histogram surface is null"); return MOS_STATUS_INVALID_PARAMETER; } m_decoder = codechalDecoder; m_inputSurface = inputSurface; AllocateResources(); MOS_SYNC_PARAMS syncParams = g_cInitSyncParams; syncParams.GpuContext = m_decoder->GetVideoContext(); syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal( m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = MOS_GPU_CONTEXT_VEBOX; syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait( m_osInterface, &syncParams)); // Switch GPU context to VEBOX m_osInterface->pfnSetGpuContext(m_osInterface, MOS_GPU_CONTEXT_VEBOX); // Reset allocation list and house keeping m_osInterface->pfnResetOsStates(m_osInterface); // Send command buffer header at the beginning MOS_COMMAND_BUFFER cmdBuffer; MOS_ZeroMemory(&cmdBuffer, sizeof(MOS_COMMAND_BUFFER)); CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer( m_osInterface, &cmdBuffer, 0)); CODECHAL_HW_CHK_STATUS_RETURN(m_decoder->SendPrologWithFrameTracking( &cmdBuffer, true)); // Setup cmd prameters MHW_VEBOX_STATE_CMD_PARAMS veboxStateCmdParams; MOS_ZeroMemory(&veboxStateCmdParams, sizeof(veboxStateCmdParams)); CODECHAL_HW_CHK_STATUS_RETURN(SetVeboxStateParams(&veboxStateCmdParams)); MHW_VEBOX_SURFACE_STATE_CMD_PARAMS veboxSurfaceStateCmdParams; MOS_ZeroMemory(&veboxSurfaceStateCmdParams, sizeof(veboxSurfaceStateCmdParams)); CODECHAL_HW_CHK_STATUS_RETURN(SetVeboxSurfaceStateParams(&veboxSurfaceStateCmdParams)); MHW_VEBOX_DI_IECP_CMD_PARAMS veboxDiIecpCmdParams; MOS_ZeroMemory(&veboxDiIecpCmdParams, sizeof(veboxDiIecpCmdParams)); CODECHAL_HW_CHK_STATUS_RETURN(SetVeboxDiIecpParams(&veboxDiIecpCmdParams)); MHW_VEBOX_IECP_PARAMS veboxIecpParams; MOS_ZeroMemory(&veboxIecpParams, sizeof(veboxIecpParams)); CODECHAL_HW_CHK_STATUS_RETURN(SetVeboxIecpParams(&veboxIecpParams)); // send Vebox cmd CODECHAL_HW_CHK_STATUS_RETURN(m_veboxInterface->AddVeboxIecpState( &veboxIecpParams)); CODECHAL_HW_CHK_STATUS_RETURN(m_veboxInterface->AddVeboxState( &cmdBuffer, &veboxStateCmdParams, 0)); CODECHAL_HW_CHK_STATUS_RETURN(m_veboxInterface->AddVeboxSurfaces( &cmdBuffer, &veboxSurfaceStateCmdParams)); CODECHAL_HW_CHK_STATUS_RETURN(m_veboxInterface->AddVeboxDiIecp( &cmdBuffer, &veboxDiIecpCmdParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiBatchBufferEnd( &cmdBuffer, nullptr)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer( m_osInterface, &cmdBuffer, m_decoder->GetVideoContextUsesNullHw())); m_osInterface->pfnFreeResource( m_osInterface, &veboxStateCmdParams.DummyIecpResource); // copy histogram to input buffer CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext( m_osInterface, m_decoder->GetVideoWAContext())); m_osInterface->pfnResetOsStates(m_osInterface); m_osInterface->pfnSetPerfTag( m_osInterface, (uint16_t)(((m_decoder->GetMode() << 4) & 0xF0) | COPY_TYPE)); m_osInterface->pfnResetPerfBufferID(m_osInterface); MOS_ZeroMemory(&cmdBuffer, sizeof(MOS_COMMAND_BUFFER)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer( m_osInterface, &cmdBuffer, 0)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_decoder->SendPrologWithFrameTracking( &cmdBuffer, false)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_decoder->HucCopy( &cmdBuffer, &m_resHistogram, &m_inputHistogramSurfaces[m_histogramComponent].OsResource, HISTOGRAM_BINCOUNT * 4, m_veboxHistogramOffset, m_inputHistogramSurfaces[m_histogramComponent].dwOffset)); MHW_MI_FLUSH_DW_PARAMS flushDwParams; MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiFlushDwCmd( &cmdBuffer, &flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiBatchBufferEnd( &cmdBuffer, nullptr)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); // sync resource syncParams = g_cInitSyncParams; syncParams.GpuContext = MOS_GPU_CONTEXT_VEBOX; syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal( m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = m_decoder->GetVideoWAContext(); syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait( m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer( m_osInterface, &cmdBuffer, m_decoder->GetVideoContextUsesNullHw())); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext( m_osInterface, m_decoder->GetVideoContext())); MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData; MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData)); userFeatureWriteData.Value.i32Data = 1; userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_DECODE_HISTOGRAM_FROM_VEBOX_ID; MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext); return eStatus; }