1 /*
2 * Copyright (c) 2019-2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file vphal_render_vebox_xe_xpm.cpp
24 //! \brief Interface and structure specific for Xe_XPM Vebox
25 //! \details Interface and structure specific for Xe_XPM Vebox
26 //!
27 #include "vphal.h"
28 #include "vphal_render_vebox_base.h"
29 #include "vphal_render_vebox_xe_xpm.h"
30 #include "vphal_render_sfc_xe_xpm.h"
31 #include "vphal_render_vebox_util_base.h"
32 #include "renderhal_g12_base.h"
33 #include "hal_oca_interface.h"
34 #include "mos_interface.h"
35 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
36 #include "igvpkrn_isa_xe_xpm.h"
37 #include "igvpkrn_isa_xe_hpg.h"
38 #endif
39
VPHAL_VEBOX_STATE_XE_XPM(PMOS_INTERFACE pOsInterface,PMHW_VEBOX_INTERFACE pVeboxInterface,PMHW_SFC_INTERFACE pSfcInterface,PRENDERHAL_INTERFACE pRenderHal,PVPHAL_VEBOX_EXEC_STATE pVeboxExecState,PVPHAL_RNDR_PERF_DATA pPerfData,const VPHAL_DNDI_CACHE_CNTL & dndiCacheCntl,MOS_STATUS * peStatus)40 VPHAL_VEBOX_STATE_XE_XPM::VPHAL_VEBOX_STATE_XE_XPM(
41 PMOS_INTERFACE pOsInterface,
42 PMHW_VEBOX_INTERFACE pVeboxInterface,
43 PMHW_SFC_INTERFACE pSfcInterface,
44 PRENDERHAL_INTERFACE pRenderHal,
45 PVPHAL_VEBOX_EXEC_STATE pVeboxExecState,
46 PVPHAL_RNDR_PERF_DATA pPerfData,
47 const VPHAL_DNDI_CACHE_CNTL &dndiCacheCntl,
48 MOS_STATUS *peStatus) :
49 VPHAL_VEBOX_STATE(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus),
50 VPHAL_VEBOX_STATE_G12_BASE(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus)
51 {
52 uint32_t i;
53 uint32_t veboxMaxPipeNum = 0;
54 MEDIA_SYSTEM_INFO *gtSystemInfo = nullptr;
55
56 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
57 m_hvsKernelBinary = (uint8_t *)IGVPHVS_DENOISE_XE_HPG;
58 m_hvsKernelBinarySize = IGVPHVS_DENOISE_XE_HPG_SIZE;
59 m_hdr3DLutKernelBinary = (uint32_t *)IGVP3DLUT_GENERATION_XE_XPM;
60 m_hdr3DLutKernelBinarySize = IGVP3DLUT_GENERATION_XE_XPM_SIZE;
61 #endif
62
63 // Vebox Scalability
64 bVeboxScalableMode = false; //!< Vebox Scalable Mode
65 if(!pOsInterface)
66 {
67 *peStatus = MOS_STATUS_NULL_POINTER;
68 return;
69 }
70
71 gtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
72 if (gtSystemInfo)
73 {
74 veboxMaxPipeNum = gtSystemInfo->MaxVECS;
75 }
76
77 for (i = 0; i < veboxMaxPipeNum; i++)
78 {
79 PMOS_COMMAND_BUFFER pCmdBuffer = (PMOS_COMMAND_BUFFER)MOS_AllocAndZeroMemory(sizeof(MOS_COMMAND_BUFFER));
80 if (pCmdBuffer == nullptr)
81 {
82 *peStatus = MOS_STATUS_NO_SPACE;
83 return;
84 }
85 m_veCmdBuffers.emplace_back(pCmdBuffer);
86 }
87
88 dwVECmdBufSize = 0; //!< Command Buffer Size
89 for (i = 0; i < MHW_VEBOX_MAX_SEMAPHORE_NUM_G12; i++)
90 {
91 VESemaMemS[i] = {};
92 VESemaMemSAdd[i] = {};
93 }
94 dwNumofVebox = 0;
95
96 #if LINUX
97 char* ScalingHQPerfMode = getenv("SET_SCALINGHQ_AS_PERFMODE");
98 if (ScalingHQPerfMode)
99 {
100 bScalingHQPefMode = strcmp(ScalingHQPerfMode, "ON")?false:true;
101 }
102 #endif
103 }
104
~VPHAL_VEBOX_STATE_XE_XPM()105 VPHAL_VEBOX_STATE_XE_XPM::~VPHAL_VEBOX_STATE_XE_XPM()
106 {
107 for (auto &icmdBuffer : m_veCmdBuffers)
108 {
109 if (icmdBuffer)
110 {
111 MOS_FreeMemory(icmdBuffer);
112 }
113 icmdBuffer = nullptr;
114 }
115
116 if (m_hvsDenoiser)
117 {
118 MOS_Delete(m_hvsDenoiser);
119 }
120
121 m_veCmdBuffers.clear();
122 return;
123 }
124
CreateSfcState()125 VphalSfcState* VPHAL_VEBOX_STATE_XE_XPM::CreateSfcState()
126 {
127 #if __VPHAL_SFC_SUPPORTED
128 VphalSfcState *sfcState = MOS_New(VphalSfcStateXe_Xpm, m_pOsInterface, m_pRenderHal, m_pSfcInterface);
129 #else
130 VphalSfcState *sfcState = nullptr;
131 #endif
132
133 return sfcState;
134 }
135
GetOutputPipe(PCVPHAL_RENDER_PARAMS pcRenderParams,PVPHAL_SURFACE pSrcSurface,RenderpassData * pRenderData)136 VPHAL_OUTPUT_PIPE_MODE VPHAL_VEBOX_STATE_XE_XPM::GetOutputPipe(
137 PCVPHAL_RENDER_PARAMS pcRenderParams,
138 PVPHAL_SURFACE pSrcSurface,
139 RenderpassData* pRenderData)
140 {
141 VPHAL_RENDER_FUNCTION_ENTER;
142
143 VPHAL_OUTPUT_PIPE_MODE OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
144 bool bHDRToneMappingNeed = false;
145 bool bScalingNeeded = false;
146
147 VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams);
148 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
149 VPHAL_RENDER_CHK_NULL_NO_STATUS(m_sfcPipeState);
150
151 if (pSrcSurface->SurfType == SURF_IN_PRIMARY && pcRenderParams->uSrcCount > 1)
152 {
153 if (pSrcSurface->Rotation == VPHAL_ROTATION_IDENTITY ||
154 pSrcSurface->Rotation == VPHAL_ROTATION_180 ||
155 pSrcSurface->Rotation == VPHAL_MIRROR_HORIZONTAL ||
156 pSrcSurface->Rotation == VPHAL_MIRROR_VERTICAL)
157 {
158 bScalingNeeded = ((pSrcSurface->rcDst.right - pSrcSurface->rcDst.left) != (pSrcSurface->rcSrc.right - pSrcSurface->rcSrc.left)) ||
159 ((pSrcSurface->rcDst.bottom - pSrcSurface->rcDst.top) != (pSrcSurface->rcSrc.bottom - pSrcSurface->rcSrc.top));
160 }
161 else
162 {
163 bScalingNeeded = ((pSrcSurface->rcDst.right - pSrcSurface->rcDst.left) != (pSrcSurface->rcSrc.bottom - pSrcSurface->rcSrc.top)) ||
164 ((pSrcSurface->rcDst.bottom - pSrcSurface->rcDst.top) != (pSrcSurface->rcSrc.right - pSrcSurface->rcSrc.left));
165 }
166
167 // Using SFC for scaling with the highest priority due to AVS removal from Render on XeHP, just other SFC has HW limation:
168 // input/output surface <128 and unsupport formates will use bilinear or nereast.
169 if (bScalingNeeded)
170 {
171 // enable SFC output temp surf for render enabled cases, make temp surf format the same as input.
172 MOS_FORMAT targetFormat = pcRenderParams->pTarget[0]->Format;
173
174 pcRenderParams->pTarget[0]->Format = pSrcSurface->Format;
175 OutputPipe = m_sfcPipeState->GetOutputPipe(pSrcSurface, pcRenderParams->pTarget[0], pcRenderParams);
176 pcRenderParams->pTarget[0]->Format = targetFormat;
177 if (OutputPipe == VPHAL_OUTPUT_PIPE_MODE_SFC)
178 {
179 pRenderData->bSFCScalingOnly = true;
180 pRenderData->bCompNeeded = false;
181
182 // Use temp to save input surface's cspace and format; keep the SFC Scaling don't do CSC for multi-layers
183 // to save the BW on SFC.
184 VPHAL_RENDER_NORMALMESSAGE("Use SFCScalingOnly: input Surface cspace %d, formate %d; output cspace %d, output Format %d",
185 pSrcSurface->ColorSpace, pSrcSurface->Format, pcRenderParams->pTarget[0]->ColorSpace, pcRenderParams->pTarget[0]->Format);
186 return OutputPipe;
187 }
188 }
189 }
190
191 // For interlaced scaling, output pipe should be SFC
192 if (pSrcSurface->InterlacedScalingType != ISCALING_NONE)
193 {
194 OutputPipe = m_sfcPipeState->GetOutputPipe(pSrcSurface, pcRenderParams->pTarget[0], pcRenderParams);
195 if (OutputPipe == VPHAL_OUTPUT_PIPE_MODE_SFC)
196 {
197 pRenderData->bCompNeeded = false;
198 return OutputPipe;
199 }
200 else if (OutputPipe == VPHAL_OUTPUT_PIPE_MODE_COMP)
201 {
202 pRenderData->bCompNeeded = true;
203 return OutputPipe;
204 }
205 else
206 {
207 return VPHAL_OUTPUT_PIPE_MODE_INVALID;
208 }
209 }
210
211 return VPHAL_VEBOX_STATE_G12_BASE::GetOutputPipe(pcRenderParams, pSrcSurface, pRenderData);
212
213 finish:
214 return VPHAL_OUTPUT_PIPE_MODE_INVALID;
215 }
216
IsNeeded(PCVPHAL_RENDER_PARAMS pcRenderParams,RenderpassData * pRenderPassData)217 bool VPHAL_VEBOX_STATE_XE_XPM::IsNeeded(
218 PCVPHAL_RENDER_PARAMS pcRenderParams,
219 RenderpassData *pRenderPassData)
220 {
221 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
222 MhwVeboxInterfaceXe_Xpm * pVeboxInterfaceXe_Xpm;
223 PMHW_VEBOX_INTERFACE pVeboxInterface;
224 PMOS_INTERFACE pOsInterface;
225 PVPHAL_SURFACE pRenderTarget;
226 PVPHAL_SURFACE pSrcSurface;
227 bool hr = false;
228
229 // Check whether VEBOX is available
230 // VTd doesn't support VEBOX
231 if (!MEDIA_IS_SKU(m_pSkuTable, FtrVERing))
232 {
233 pRenderPassData->bCompNeeded = true;
234 goto finish;
235 }
236
237 if (pRenderPassData == nullptr || pRenderPassData->pSrcSurface == nullptr)
238 {
239 VPHAL_RENDER_ASSERTMESSAGE("Invalid input parameter");
240 return false;
241 }
242
243 // Xe_XPM doesn't support AVS Scaling on Render, HQ scaling should go to SFC.
244 // And Ief should only do by SFC.
245 // for fast mode, if no vebox feature involved, should go to render path, otherwise goto render path.
246 if (!bScalingHQPefMode && (pRenderPassData->pSrcSurface->ScalingPreference == VPHAL_SCALING_PREFER_COMP))
247 {
248 pRenderPassData->pSrcSurface->ScalingPreference = VPHAL_SCALING_PREFER_SFC;
249 }
250
251 VPHAL_RENDER_CHK_NULL_NO_STATUS(pVeboxState);
252 VPHAL_RENDER_CHK_NULL_NO_STATUS(pVeboxState->m_pVeboxInterface);
253 VPHAL_RENDER_CHK_NULL_NO_STATUS(pVeboxState->m_pOsInterface);
254 VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams);
255 VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams->pTarget[0]);
256
257 if (pcRenderParams->bForceToRender)
258 {
259 pRenderPassData->bCompNeeded = true;
260 goto finish;
261 }
262
263 pVeboxInterface = pVeboxState->m_pVeboxInterface;
264 pVeboxInterfaceXe_Xpm = (MhwVeboxInterfaceXe_Xpm *)pVeboxInterface;
265 pOsInterface = pVeboxState->m_pOsInterface;
266 pRenderTarget = pcRenderParams->pTarget[0];
267 pSrcSurface = pRenderPassData->pSrcSurface;
268
269 if (pOsInterface->bVeboxScalabilityMode)
270 {
271 // use the vebox scalability mode read from registy key if set override
272 }
273 else
274 {
275 if (((MOS_MIN(pSrcSurface->dwWidth, (uint32_t)pSrcSurface->rcSrc.right) > MHW_VEBOX_4K_PIC_WIDTH_G12) &&
276 (MOS_MIN(pSrcSurface->dwHeight, (uint32_t)pSrcSurface->rcSrc.bottom) > MHW_VEBOX_4K_PIC_HEIGHT_G12)) ||
277 ((MOS_MIN(pRenderTarget->dwWidth, (uint32_t)pRenderTarget->rcSrc.right) > MHW_VEBOX_4K_PIC_WIDTH_G12) &&
278 (MOS_MIN(pRenderTarget->dwHeight, (uint32_t)pRenderTarget->rcSrc.bottom) > MHW_VEBOX_4K_PIC_HEIGHT_G12)))
279 {
280 pOsInterface->bVeboxScalabilityMode = pVeboxInterfaceXe_Xpm->m_veboxScalabilitywith4K;
281 }
282 }
283
284 hr = VPHAL_VEBOX_STATE_G12_BASE::IsNeeded(pcRenderParams, pRenderPassData);
285
286 finish:
287 return hr;
288 }
289
290 //!
291 //! \brief Setup Vebox_DI_IECP Command params for Xe_XPM
292 //! \details Setup Vebox_DI_IECP Command params for Xe_XPM
293 //! \param [in] bDiScdEnable
294 //! Is DI/Variances report enabled
295 //! \param [in,out] pVeboxDiIecpCmdParams
296 //! Pointer to VEBOX_DI_IECP command parameters
297 //! \return MOS_STATUS
298 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
299 //!
SetupDiIecpState(bool bDiScdEnable,PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)300 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::SetupDiIecpState(
301 bool bDiScdEnable,
302 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
303 {
304 uint32_t dwWidth;
305 uint32_t dwHeight;
306 bool bDIEnable;
307 MOS_STATUS eStatus;
308 MHW_VEBOX_SURFACE_PARAMS MhwVeboxSurfaceParam;
309 PMHW_VEBOX_INTERFACE pVeboxInterface;
310 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
311 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
312
313 VPHAL_RENDER_CHK_NULL(pVeboxDiIecpCmdParams);
314 VPHAL_RENDER_CHK_NULL(pVeboxState);
315 VPHAL_RENDER_CHK_NULL(pRenderData);
316
317 pVeboxInterface = pVeboxState->m_pVeboxInterface;
318 MOS_ZeroMemory(pVeboxDiIecpCmdParams, sizeof(*pVeboxDiIecpCmdParams));
319
320 VPHAL_RENDER_CHK_NULL(pVeboxInterface);
321
322 VPHAL_RENDER_CHK_STATUS(VPHAL_VEBOX_STATE_G12_BASE::SetupDiIecpState(bDiScdEnable, pVeboxDiIecpCmdParams));
323
324 // Align dwEndingX with surface state
325 bDIEnable = pRenderData->bDeinterlace || IsQueryVarianceEnabled();
326
327 VPHAL_RENDER_CHK_STATUS(VpHal_InitVeboxSurfaceParams(pVeboxState->m_currentSurface, &MhwVeboxSurfaceParam));
328 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->VeboxAdjustBoundary(
329 &MhwVeboxSurfaceParam,
330 &dwWidth,
331 &dwHeight,
332 bDIEnable));
333
334 pVeboxDiIecpCmdParams->dwStartingX = 0;
335 pVeboxDiIecpCmdParams->dwEndingX = dwWidth - 1;
336
337 finish:
338 return eStatus;
339 }
340
InitCmdBufferWithVeParams(PRENDERHAL_INTERFACE pRenderHal,MOS_COMMAND_BUFFER & CmdBuffer,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)341 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::InitCmdBufferWithVeParams(
342 PRENDERHAL_INTERFACE pRenderHal,
343 MOS_COMMAND_BUFFER & CmdBuffer,
344 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
345 {
346 MOS_STATUS eStatus;
347 RENDERHAL_GENERIC_PROLOG_PARAMS_G12 genericPrologParamsG12 = {};
348 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
349 uint8_t i;
350
351 genericPrologParamsG12.bEnableMediaFrameTracking = pGenericPrologParams->bEnableMediaFrameTracking;
352 genericPrologParamsG12.bMmcEnabled = pGenericPrologParams->bMmcEnabled;
353 genericPrologParamsG12.dwMediaFrameTrackingAddrOffset = pGenericPrologParams->dwMediaFrameTrackingAddrOffset;
354 genericPrologParamsG12.dwMediaFrameTrackingTag = pGenericPrologParams->dwMediaFrameTrackingTag;
355 genericPrologParamsG12.presMediaFrameTrackingSurface = pGenericPrologParams->presMediaFrameTrackingSurface;
356
357 genericPrologParamsG12.VEngineHintParams.BatchBufferCount = dwNumofVebox;
358
359 if (m_veCmdBuffers.size() < dwNumofVebox)
360 {
361 VPHAL_RENDER_ASSERTMESSAGE("m_veCmdBuffers.size() < dwNumofVebox", m_veCmdBuffers.size(), dwNumofVebox);
362 return MOS_STATUS_INVALID_PARAMETER;
363 }
364
365 for (i = 0; i < dwNumofVebox; i++)
366 {
367 if (!m_veCmdBuffers[i])
368 {
369 VPHAL_RENDER_ASSERTMESSAGE("m_veCmdBuffers[%d] == nullptr", i);
370 return MOS_STATUS_INVALID_PARAMETER;
371 }
372 genericPrologParamsG12.VEngineHintParams.resScalableBatchBufs[i] = m_veCmdBuffers[i]->OsResource;
373 genericPrologParamsG12.VEngineHintParams.EngineInstance[i] = i;
374 }
375
376 genericPrologParamsG12.VEngineHintParams.UsingFrameSplit = true;
377 genericPrologParamsG12.VEngineHintParams.UsingSFC = IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData);
378
379 pRenderHal->pOsInterface->VEEnable = true;
380
381 // Initialize command buffer and insert prolog
382 VPHAL_RENDER_CHK_STATUS(pRenderHal->pfnInitCommandBuffer(
383 pRenderHal,
384 &CmdBuffer,
385 (PRENDERHAL_GENERIC_PROLOG_PARAMS)&genericPrologParamsG12));
386
387 finish:
388 return eStatus;
389 }
390
391 //!
392 //! \brief Vebox allocate resources
393 //! \details Allocate resources that will be used in Vebox
394 //! \return MOS_STATUS
395 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
396 //!
AllocateResources()397 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::AllocateResources()
398 {
399 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
400 PMOS_INTERFACE pOsInterface;
401 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
402 PMHW_VEBOX_INTERFACE pVeboxInterface;
403 MhwVeboxInterfaceXe_Xpm * pVeboxInterfaceXe_Xpm;
404 PVPHAL_VEBOX_RENDER_DATA pRenderData;
405 bool bAllocated;
406
407 VPHAL_RENDER_CHK_NULL(pVeboxState);
408 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
409 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
410
411 pOsInterface = pVeboxState->m_pOsInterface;
412 pVeboxInterface = pVeboxState->m_pVeboxInterface;
413 pRenderData = GetLastExecRenderData();
414
415 VPHAL_RENDER_CHK_STATUS(VPHAL_VEBOX_STATE_G12_BASE::AllocateResources());
416
417 // Allocate bottom field surface for interleaved to field
418 if (pVeboxState->m_currentSurface->InterlacedScalingType == ISCALING_INTERLEAVED_TO_FIELD)
419 {
420 if (!pRenderData->pOutputTempField)
421 {
422 pRenderData->pOutputTempField = (VPHAL_SURFACE *)MOS_AllocAndZeroMemory(sizeof(VPHAL_SURFACE));
423 }
424 VPHAL_RENDER_CHK_NULL(pRenderData->pOutputTempField);
425
426 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
427 pOsInterface,
428 pRenderData->pOutputTempField,
429 "OutputBottomFieldSurface_xe_xpm",
430 pRenderData->pRenderTarget->Format,
431 MOS_GFXRES_2D,
432 pRenderData->pRenderTarget->TileType,
433 pRenderData->pRenderTarget->dwWidth,
434 pRenderData->pRenderTarget->dwHeight,
435 pRenderData->pRenderTarget->bIsCompressed,
436 pRenderData->pRenderTarget->CompressionMode,
437 &bAllocated));
438 }
439 else
440 {
441 if (pRenderData->pOutputTempField)
442 {
443 pOsInterface->pfnFreeResource(
444 pOsInterface,
445 &pRenderData->pOutputTempField->OsResource);
446
447 MOS_FreeMemAndSetNull(pRenderData->pOutputTempField);
448 }
449 }
450
451 pVeboxInterfaceXe_Xpm = (MhwVeboxInterfaceXe_Xpm *)pVeboxInterface;
452 if (pVeboxInterfaceXe_Xpm->IsScalabilitySupported() && pOsInterface->bVeboxScalabilityMode)
453 {
454 // Allocate resource for Batch buffer to store commands, initialize batch buffer
455 VPHAL_RENDER_CHK_STATUS(AllocVESecondaryCmdBuffers());
456
457 // Allocate semaphore resources for Virtual Engine
458 VPHAL_RENDER_CHK_STATUS(AllocVESemaphoreResources());
459 }
460 else
461 {
462 // Free Virtual Engine related resources
463 VPHAL_RENDER_CHK_STATUS(FreeVEResources());
464 }
465
466 finish:
467 if (eStatus != MOS_STATUS_SUCCESS)
468 {
469 pVeboxState->FreeResources();
470 }
471
472 return eStatus;
473 }
474
475 //!
476 //! \brief Vebox free resources
477 //! \details Free resources that are used in Vebox
478 //! \return void
479 //!
FreeResources()480 void VPHAL_VEBOX_STATE_XE_XPM::FreeResources()
481 {
482 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
483 PMOS_INTERFACE pOsInterface;
484 PMHW_VEBOX_INTERFACE pVeboxInterface;
485 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
486 int32_t i;
487 MhwVeboxInterfaceXe_Xpm * pVeboxInterfaceXe_Xpm;
488 PVPHAL_VEBOX_RENDER_DATA pRenderData;
489
490 VPHAL_RENDER_CHK_NULL(pVeboxState);
491 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
492 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
493
494 pOsInterface = pVeboxState->m_pOsInterface;
495 pVeboxInterface = pVeboxState->m_pVeboxInterface;
496 pRenderData = GetLastExecRenderData();
497
498 VPHAL_VEBOX_STATE_G12_BASE::FreeResources();
499
500 // Free bottom field surface
501 if (pRenderData->pOutputTempField)
502 {
503 pOsInterface->pfnFreeResource(
504 pOsInterface,
505 &pRenderData->pOutputTempField->OsResource);
506
507 MOS_FreeMemAndSetNull(pRenderData->pOutputTempField);
508 }
509
510 // Free Virtual Engine related resources
511 VPHAL_RENDER_CHK_STATUS(FreeVEResources());
512
513 finish:
514 return;
515 }
516
517 //!
518 //! \brief Alloc Batch Buffers with VE interface
519 //! \details Allocate Batch Buffers with VE interface
520 //! \return MOS_STATUS
521 //! MOS_STATUS_SUCCESS if success, else fail reason
522 //!
AllocVESecondaryCmdBuffers()523 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::AllocVESecondaryCmdBuffers()
524 {
525 PMOS_INTERFACE pOsInterface;
526 uint32_t dwSize;
527 int32_t i;
528 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
529 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
530 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
531 MEDIA_SYSTEM_INFO * pGtSystemInfo;
532
533 VPHAL_RENDER_CHK_NULL(pVeboxState);
534 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
535
536 pOsInterface = pVeboxState->m_pOsInterface;
537
538 // Initiate allocation paramters
539 MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(AllocParamsForBufferLinear));
540 AllocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
541 AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
542 AllocParamsForBufferLinear.Format = Format_Buffer;
543
544 // Allocate resource for Batch buffer to store commands
545 dwSize = MHW_VEBOX_MAX_PIPE_SIZE_G12;
546 AllocParamsForBufferLinear.dwBytes = dwSize;
547 AllocParamsForBufferLinear.pBufName = "VEBatchBuffer";
548
549 for (auto &icmdBuffer : pVeboxState->m_veCmdBuffers)
550 {
551 VPHAL_RENDER_CHK_NULL(icmdBuffer);
552
553 if (Mos_ResourceIsNull(&icmdBuffer->OsResource))
554 {
555 eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
556 pOsInterface,
557 &AllocParamsForBufferLinear,
558 &icmdBuffer->OsResource);
559 }
560
561 if (eStatus != MOS_STATUS_SUCCESS)
562 {
563 VPHAL_RENDER_ASSERTMESSAGE("Failed to allocate VE Batch Buffer.");
564 goto finish;
565 }
566 }
567
568 pVeboxState->dwVECmdBufSize = dwSize;
569
570 #if (_DEBUG || _RELEASE_INTERNAL)
571 bool bUseVE1, bUseVE2, bUseVE3, bUseVE4;
572 MOS_FORCE_VEBOX eForceVebox;
573
574 bUseVE1 = bUseVE2 = bUseVE3 = bUseVE4 = false;
575 eForceVebox = pOsInterface->eForceVebox;
576
577 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_1, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE1);
578 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_2, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE2);
579 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_3, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE3);
580 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_4, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE4);
581
582 pVeboxState->dwNumofVebox = bUseVE1 + bUseVE2 + bUseVE3 + bUseVE4;
583 if (pVeboxState->dwNumofVebox == 0)
584 #endif
585 {
586 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
587 VPHAL_RENDER_CHK_NULL(pGtSystemInfo);
588 pVeboxState->dwNumofVebox = pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled;
589 }
590
591 finish:
592 return eStatus;
593 }
594
595 //!
596 //! \brief Alloc Semaphore Resources with VE interface
597 //! \details Allocate Semaphore Resources with VE interface
598 //! \return MOS_STATUS
599 //! MOS_STATUS_SUCCESS if success, else fail reason
600 //!
AllocVESemaphoreResources()601 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::AllocVESemaphoreResources()
602 {
603 PMOS_INTERFACE pOsInterface;
604 int32_t i;
605 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
606 MOS_LOCK_PARAMS LockFlagsWriteOnly;
607 uint8_t * pData;
608 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
609 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
610
611 VPHAL_RENDER_CHK_NULL(pVeboxState);
612 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
613
614 pOsInterface = pVeboxState->m_pOsInterface;
615 MOS_ZeroMemory(&LockFlagsWriteOnly, sizeof(LockFlagsWriteOnly));
616 LockFlagsWriteOnly.WriteOnly = 1;
617
618 // Initiate allocation paramters
619 MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(AllocParamsForBufferLinear));
620 AllocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
621 AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
622 AllocParamsForBufferLinear.Format = Format_Buffer;
623
624 // Allocate resource for semaphore buffer
625 AllocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
626 AllocParamsForBufferLinear.pBufName = "VESemaphore";
627
628 for (i = 0; i < MHW_VEBOX_MAX_SEMAPHORE_NUM_G12; i++)
629 {
630 if (Mos_ResourceIsNull(&pVeboxState->VESemaMemS[i]))
631 {
632 eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
633 pOsInterface,
634 &AllocParamsForBufferLinear,
635 &pVeboxState->VESemaMemS[i]);
636 }
637
638 if (eStatus != MOS_STATUS_SUCCESS)
639 {
640 VPHAL_RENDER_ASSERTMESSAGE("Failed to allocate VE Semaphore S%d.", i);
641 goto finish;
642 }
643
644 pData = (uint8_t *)pOsInterface->pfnLockResource(
645 pOsInterface,
646 &pVeboxState->VESemaMemS[i],
647 &LockFlagsWriteOnly);
648 VPHAL_RENDER_CHK_NULL(pData);
649
650 MOS_ZeroMemory(pData, sizeof(uint32_t));
651
652 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnUnlockResource(
653 pOsInterface,
654 &pVeboxState->VESemaMemS[i]));
655 }
656
657 // Allocate resource for semaphore buffer addition
658 AllocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
659 AllocParamsForBufferLinear.pBufName = "VESemaphoreAdd";
660
661 for (i = 0; i < MHW_VEBOX_MAX_SEMAPHORE_NUM_G12; i++)
662 {
663 if (Mos_ResourceIsNull(&pVeboxState->VESemaMemSAdd[i]))
664 {
665 eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
666 pOsInterface,
667 &AllocParamsForBufferLinear,
668 &pVeboxState->VESemaMemSAdd[i]);
669 }
670
671 if (eStatus != MOS_STATUS_SUCCESS)
672 {
673 VPHAL_RENDER_ASSERTMESSAGE("Failed to allocate VE Semaphore S%d.", i);
674 goto finish;
675 }
676
677 pData = (uint8_t *)pOsInterface->pfnLockResource(
678 pOsInterface,
679 &pVeboxState->VESemaMemSAdd[i],
680 &LockFlagsWriteOnly);
681 VPHAL_RENDER_CHK_NULL(pData);
682
683 MOS_ZeroMemory(pData, sizeof(uint32_t));
684
685 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnUnlockResource(
686 pOsInterface,
687 &pVeboxState->VESemaMemSAdd[i]));
688 }
689
690 finish:
691 return eStatus;
692 }
693
694 //!
695 //! \brief Init Batch Buffers with VE interface
696 //! \details Init Batch Buffers with VE interface
697 //! \return MOS_STATUS
698 //! MOS_STATUS_SUCCESS if success, else fail reason
699 //!
InitVESecondaryCmdBuffers()700 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::InitVESecondaryCmdBuffers()
701 {
702 PMOS_INTERFACE pOsInterface;
703 MOS_LOCK_PARAMS LockFlagsWriteOnly;
704 uint8_t * pData;
705 int32_t i;
706 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
707 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
708
709 VPHAL_RENDER_CHK_NULL(pVeboxState);
710 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
711
712 pOsInterface = pVeboxState->m_pOsInterface;
713
714 MOS_ZeroMemory(&LockFlagsWriteOnly, sizeof(LockFlagsWriteOnly));
715 LockFlagsWriteOnly.WriteOnly = 1;
716
717 for (auto &icmdBuffer : pVeboxState->m_veCmdBuffers)
718 {
719 VPHAL_RENDER_CHK_NULL(icmdBuffer);
720 pData = (uint8_t *)pOsInterface->pfnLockResource(
721 pOsInterface,
722 &icmdBuffer->OsResource,
723 &LockFlagsWriteOnly);
724 VPHAL_RENDER_CHK_NULL(pData);
725
726 icmdBuffer->pCmdBase = (uint32_t *)pData;
727 icmdBuffer->pCmdPtr = icmdBuffer->pCmdBase;
728 icmdBuffer->iOffset = 0;
729 icmdBuffer->iRemaining = pVeboxState->dwVECmdBufSize;
730 }
731
732 finish:
733 return eStatus;
734 }
735
736 //!
737 //! \brief Unlock Batch Buffers with VE interface
738 //! \details Unlock Batch Buffers with VE interface
739 //! \return MOS_STATUS
740 //! MOS_STATUS_SUCCESS if success, else fail reason
741 //!
UnLockVESecondaryCmdBuffers()742 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::UnLockVESecondaryCmdBuffers()
743 {
744 PMOS_INTERFACE pOsInterface;
745 int32_t i;
746 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
747 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
748
749 VPHAL_RENDER_CHK_NULL(pVeboxState);
750 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
751
752 pOsInterface = pVeboxState->m_pOsInterface;
753
754 for (auto &icmdBuffer : pVeboxState->m_veCmdBuffers)
755 {
756 VPHAL_RENDER_CHK_NULL(icmdBuffer);
757
758 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnUnlockResource(
759 pOsInterface,
760 &icmdBuffer->OsResource));
761 }
762
763 finish:
764 return eStatus;
765 }
766
767 //!
768 //! \brief Free Resources with VE interface
769 //! \details Free Resources with VE interface
770 //! \return MOS_STATUS
771 //! MOS_STATUS_SUCCESS if success, else fail reason
772 //!
FreeVEResources()773 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::FreeVEResources()
774 {
775 PMOS_INTERFACE pOsInterface;
776 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
777 PMHW_VEBOX_INTERFACE pVeboxInterface;
778 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
779 int32_t i;
780 MhwVeboxInterfaceXe_Xpm * pVeboxInterfaceXe_Xpm;
781
782 VPHAL_RENDER_CHK_NULL(pVeboxState);
783 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
784 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
785
786 pOsInterface = pVeboxState->m_pOsInterface;
787 pVeboxInterface = pVeboxState->m_pVeboxInterface;
788
789 // Free Virtual Engine related resources
790 pVeboxInterfaceXe_Xpm = (MhwVeboxInterfaceXe_Xpm *)pVeboxInterface;
791 if (pVeboxInterfaceXe_Xpm->IsScalabilitySupported())
792 {
793 for (auto &icmdBuffer : pVeboxState->m_veCmdBuffers)
794 {
795 if (!icmdBuffer)
796 {
797 VPHAL_RENDER_ASSERTMESSAGE("Invalid icmdBuffer");
798
799 continue;
800 }
801 pOsInterface->pfnFreeResource(
802 pOsInterface,
803 &icmdBuffer->OsResource);
804 }
805
806 for (i = 0; i < MHW_VEBOX_MAX_SEMAPHORE_NUM_G12; i++)
807 {
808 pOsInterface->pfnFreeResource(
809 pOsInterface,
810 &pVeboxState->VESemaMemS[i]);
811
812 pOsInterface->pfnFreeResource(
813 pOsInterface,
814 &pVeboxState->VESemaMemSAdd[i]);
815 }
816 }
817
818 finish:
819 return eStatus;
820 }
821
VeboxRenderVeboxCmd(MOS_COMMAND_BUFFER & CmdBuffer,MHW_VEBOX_DI_IECP_CMD_PARAMS & VeboxDiIecpCmdParams,VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS & VeboxSurfaceStateCmdParams,MHW_VEBOX_SURFACE_STATE_CMD_PARAMS & MhwVeboxSurfaceStateCmdParams,MHW_VEBOX_STATE_CMD_PARAMS & VeboxStateCmdParams,MHW_MI_FLUSH_DW_PARAMS & FlushDwParams,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)822 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::VeboxRenderVeboxCmd(
823 MOS_COMMAND_BUFFER & CmdBuffer,
824 MHW_VEBOX_DI_IECP_CMD_PARAMS & VeboxDiIecpCmdParams,
825 VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS &VeboxSurfaceStateCmdParams,
826 MHW_VEBOX_SURFACE_STATE_CMD_PARAMS & MhwVeboxSurfaceStateCmdParams,
827 MHW_VEBOX_STATE_CMD_PARAMS & VeboxStateCmdParams,
828 MHW_MI_FLUSH_DW_PARAMS & FlushDwParams,
829 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
830 {
831 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
832 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
833 MhwVeboxInterfaceXe_Xpm * pVeboxInterfaceXe_Xpm;
834 PMHW_VEBOX_INTERFACE pVeboxInterface;
835 MHW_MI_ATOMIC_PARAMS AtomicParams;
836 MHW_MI_SEMAPHORE_WAIT_PARAMS MiSemaphoreWaitParams;
837 PVPHAL_VEBOX_STATE_XE_XPM pVeboxState = this;
838 PRENDERHAL_INTERFACE_LEGACY pRenderHal;
839 bool bDiVarianceEnable;
840 PMOS_INTERFACE pOsInterface;
841 uint32_t IdxofVebox;
842 PMOS_COMMAND_BUFFER pCmdBufferInUse;
843 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
844 PMHW_MI_INTERFACE pMhwMiInterface;
845 MHW_MI_LOAD_REGISTER_IMM_PARAMS RegisterImmParams;
846 const MHW_VEBOX_HEAP * pVeboxHeap = nullptr;
847 MOS_CONTEXT *pOsContext = nullptr;
848 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
849 MOS_COMMAND_BUFFER CmdBufferInUse = {};
850 bool veboxEnableScalability = true;
851
852 VPHAL_RENDER_CHK_NULL(pVeboxState);
853 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
854 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pVeboxInterface);
855 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal);
856 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal->pMhwMiInterface);
857 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal->pMhwMiInterface->GetMmioRegisters());
858 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal->pOsInterface);
859 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal->pOsInterface->pOsContext);
860
861 pVeboxInterface = pVeboxState->m_pVeboxInterface;
862 pRenderHal = pVeboxState->m_pRenderHal;
863 pOsInterface = pVeboxState->m_pOsInterface;
864 pMhwMiInterface = pRenderHal->pMhwMiInterface;
865 pVeboxInterfaceXe_Xpm = (MhwVeboxInterfaceXe_Xpm *)pVeboxInterface;
866 pOsContext = pOsInterface->pOsContext;
867 pMmioRegisters = pMhwMiInterface->GetMmioRegisters();
868
869 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->GetVeboxHeapInfo(
870 &pVeboxHeap));
871 VPHAL_RENDER_CHK_NULL(pVeboxHeap);
872 VPHAL_RENDER_CHK_NULL(pGenericPrologParams);
873
874 if (pOsInterface->bVeboxScalabilityMode)
875 {
876 // get configuration value
877 pVeboxState->bVeboxScalableMode = true;
878 }
879 else
880 {
881 if (pVeboxInterfaceXe_Xpm->m_veboxScalabilitywith4K)
882 {
883 if (((MOS_MIN(m_currentSurface->dwWidth, (uint32_t)m_currentSurface->rcSrc.right) > MHW_VEBOX_4K_PIC_WIDTH_G12) &&
884 (MOS_MIN(m_currentSurface->dwHeight, (uint32_t)m_currentSurface->rcSrc.bottom)> MHW_VEBOX_4K_PIC_HEIGHT_G12)) ||
885 ((MOS_MIN(pRenderData->pRenderTarget->dwWidth, (uint32_t)pRenderData->pRenderTarget->rcSrc.right) > MHW_VEBOX_4K_PIC_WIDTH_G12) &&
886 (MOS_MIN(pRenderData->pRenderTarget->dwHeight, (uint32_t)pRenderData->pRenderTarget->rcSrc.bottom)> MHW_VEBOX_4K_PIC_HEIGHT_G12)))
887 {
888 bVeboxScalableMode = ((pVeboxInterfaceXe_Xpm->IsScalabilitySupported() == true) ? true : false);
889 }
890 else
891 {
892 bVeboxScalableMode = false;
893 }
894 }
895 else
896 {
897 bVeboxScalableMode = pOsInterface->bVeboxScalabilityMode;
898 }
899 }
900
901 if (pVeboxInterfaceXe_Xpm->IsScalabilitySupported() &&
902 pVeboxState->bVeboxScalableMode &&
903 (m_currentSurface->dwWidth > dwNumofVebox * 64) &&
904 (pRenderData->pRenderTarget->dwWidth > dwNumofVebox * 64))
905 {
906 if (CmdBuffer.Attributes.pAttriVe == nullptr)
907 {
908 if (pOsInterface->apoMosEnabled)
909 {
910 VPHAL_RENDER_CHK_NULL(pOsInterface->osStreamState);
911 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnSetupAttributeVeBuffer(pOsInterface->osStreamState, &CmdBuffer));
912 }
913 CmdBuffer.Attributes.pAttriVe = &pOsInterface->bufAttriVe[pOsInterface->CurrentGpuContextOrdinal];
914 }
915
916 #ifdef _MMC_SUPPORTED
917 VPHAL_RENDER_CHK_STATUS(pVeboxInterfaceXe_Xpm->setVeboxPrologCmd(m_pRenderHal->pMhwMiInterface, &CmdBuffer));
918 #endif
919
920 // Initialize command buffer and insert prolog with VE params
921 VPHAL_RENDER_CHK_STATUS(InitCmdBufferWithVeParams(pRenderHal, CmdBuffer, pGenericPrologParams));
922
923 // Initialize the scalability state
924 pVeboxInterfaceXe_Xpm->SetVeboxIndex(0, dwNumofVebox, IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData));
925
926 bDiVarianceEnable = pRenderData->bDeinterlace || IsQueryVarianceEnabled();
927
928 pVeboxState->SetupSurfaceStates(
929 bDiVarianceEnable,
930 &VeboxSurfaceStateCmdParams);
931
932 pVeboxState->SetupVeboxState(
933 bDiVarianceEnable,
934 &VeboxStateCmdParams);
935
936 // Ensure LACE LUT table is ready to be read
937 if (VeboxStateCmdParams.pLaceLookUpTables)
938 {
939 pOsInterface->pfnSyncOnResource(
940 pOsInterface,
941 VeboxStateCmdParams.pLaceLookUpTables,
942 MOS_GPU_CONTEXT_VEBOX,
943 false);
944 }
945
946 VPHAL_RENDER_CHK_STATUS(pVeboxState->SetupDiIecpState(
947 bDiVarianceEnable,
948 &VeboxDiIecpCmdParams));
949
950 VPHAL_RENDER_CHK_STATUS(pVeboxState->VeboxIsCmdParamsValid(
951 VeboxStateCmdParams,
952 VeboxDiIecpCmdParams,
953 VeboxSurfaceStateCmdParams));
954
955 // Ensure output is ready to be written
956 if (VeboxDiIecpCmdParams.pOsResCurrOutput)
957 {
958 pOsInterface->pfnSyncOnResource(
959 pOsInterface,
960 VeboxDiIecpCmdParams.pOsResCurrOutput,
961 MOS_GPU_CONTEXT_VEBOX,
962 true);
963
964 // Synchronize overlay if overlay is used because output could be Render Target
965 if (VeboxSurfaceStateCmdParams.pSurfOutput &&
966 VeboxSurfaceStateCmdParams.pSurfOutput->bOverlay)
967 {
968 pOsInterface->pfnSyncOnOverlayResource(
969 pOsInterface,
970 VeboxDiIecpCmdParams.pOsResCurrOutput,
971 MOS_GPU_CONTEXT_VEBOX);
972 }
973 }
974
975 if (VeboxDiIecpCmdParams.pOsResPrevOutput)
976 {
977 pOsInterface->pfnSyncOnResource(
978 pOsInterface,
979 VeboxDiIecpCmdParams.pOsResPrevOutput,
980 MOS_GPU_CONTEXT_VEBOX,
981 true);
982 }
983
984 if (VeboxDiIecpCmdParams.pOsResDenoisedCurrOutput)
985 {
986 pOsInterface->pfnSyncOnResource(
987 pOsInterface,
988 VeboxDiIecpCmdParams.pOsResDenoisedCurrOutput,
989 MOS_GPU_CONTEXT_VEBOX,
990 true);
991 }
992
993 if (VeboxDiIecpCmdParams.pOsResStatisticsOutput)
994 {
995 pOsInterface->pfnSyncOnResource(
996 pOsInterface,
997 VeboxDiIecpCmdParams.pOsResStatisticsOutput,
998 MOS_GPU_CONTEXT_VEBOX,
999 true);
1000 }
1001
1002 VPHAL_RENDER_CHK_STATUS(VpHal_InitVeboxSurfaceStateCmdParams(
1003 &VeboxSurfaceStateCmdParams, &MhwVeboxSurfaceStateCmdParams));
1004
1005 // InitVESecondaryCmdBuffers() should be on parity with UnLockVESecondaryCmdBuffer() since InitVESecondaryCmdBuffers() contains Lock.
1006 VPHAL_RENDER_CHK_STATUS(InitVESecondaryCmdBuffers());
1007
1008 if (pVeboxState->m_veCmdBuffers.size() < dwNumofVebox)
1009 {
1010 VPHAL_RENDER_ASSERTMESSAGE("pVeboxState->m_veCmdBuffers.size() (%d) < dwNumofVebox(%d)", pVeboxState->m_veCmdBuffers.size(), dwNumofVebox);
1011 return MOS_STATUS_INVALID_PARAMETER;
1012 }
1013
1014 for (IdxofVebox = 0; IdxofVebox < dwNumofVebox; IdxofVebox++)
1015 {
1016 if (pOsInterface->bParallelSubmission)
1017 {
1018 // initialize the command buffer struct
1019 MOS_ZeroMemory(&CmdBufferInUse, sizeof(MOS_COMMAND_BUFFER));
1020 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnGetCommandBuffer(pOsInterface, &CmdBufferInUse, 1 + IdxofVebox));
1021 pCmdBufferInUse = &CmdBufferInUse;
1022 }
1023 else
1024 {
1025 pCmdBufferInUse = pVeboxState->m_veCmdBuffers[IdxofVebox];
1026 }
1027 VPHAL_RENDER_CHK_NULL(pCmdBufferInUse);
1028
1029 pVeboxInterfaceXe_Xpm->SetVeboxIndex(IdxofVebox, dwNumofVebox, IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData));
1030
1031 HalOcaInterface::On1stLevelBBStart(*pCmdBufferInUse, *pOsContext, pOsInterface->CurrentGpuContextHandle,
1032 *pRenderHal->pMhwMiInterface, *pMmioRegisters);
1033
1034 // Add vphal param to log.
1035 HalOcaInterface::DumpVphalParam(*pCmdBufferInUse, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->pVphalOcaDumper);
1036
1037 // Profiler start cmd
1038 if (pRenderHal->pPerfProfiler)
1039 {
1040 VPHAL_RENDER_CHK_STATUS(pRenderHal->pPerfProfiler->AddPerfCollectStartCmd((void*)pRenderHal, pOsInterface, pRenderHal->pMhwMiInterface, pCmdBufferInUse));
1041 }
1042
1043 VPHAL_RENDER_CHK_STATUS(NullHW::StartPredicate(pOsInterface, pRenderHal->pMhwMiInterface, pCmdBufferInUse));
1044
1045 // Insert prolog with VE params
1046 VPHAL_RENDER_CHK_STATUS(pVeboxInterfaceXe_Xpm->setVeboxPrologCmd(m_pRenderHal->pMhwMiInterface, pCmdBufferInUse));
1047 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
1048 genericPrologParams.pOsInterface = pRenderHal->pOsInterface;
1049 genericPrologParams.pvMiInterface = pRenderHal->pMhwMiInterface;
1050 genericPrologParams.bMmcEnabled = pGenericPrologParams->bMmcEnabled;
1051 MHW_RENDERHAL_CHK_STATUS(Mhw_SendGenericPrologCmd(pCmdBufferInUse, &genericPrologParams));
1052
1053 for (uint32_t tmpIdx = 0; tmpIdx < dwNumofVebox; tmpIdx++)
1054 {
1055 // MI Atomic S[All] Increase 1
1056 MOS_ZeroMemory(&AtomicParams, sizeof(AtomicParams));
1057 AtomicParams.pOsResource = &pVeboxState->VESemaMemS[tmpIdx];
1058 AtomicParams.dwDataSize = sizeof(uint32_t);
1059 AtomicParams.Operation = MHW_MI_ATOMIC_INC;
1060 AtomicParams.bInlineData = true;
1061 AtomicParams.dwOperand1Data[0] = 1;
1062 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiAtomicCmd(pCmdBufferInUse, &AtomicParams));
1063 }
1064
1065 // MI Atomic S[IdxofVebox] Wait dwNumofVebox
1066 MOS_ZeroMemory(&MiSemaphoreWaitParams, sizeof(MiSemaphoreWaitParams));
1067 MiSemaphoreWaitParams.presSemaphoreMem = &pVeboxState->VESemaMemS[IdxofVebox];
1068 MiSemaphoreWaitParams.bPollingWaitMode = true;
1069 MiSemaphoreWaitParams.dwSemaphoreData = dwNumofVebox;
1070 MiSemaphoreWaitParams.CompareOperation = MHW_MI_SAD_EQUAL_SDD;
1071 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiSemaphoreWaitCmd(pCmdBufferInUse, &MiSemaphoreWaitParams));
1072
1073 // Enable Watchdog Timer
1074 MOS_ZeroMemory(&RegisterImmParams, sizeof(RegisterImmParams));
1075 if (pRenderData->pRenderTarget->dwWidth * pRenderData->pRenderTarget->dwHeight > MHW_VEBOX_4K_PIC_WIDTH_G12 * MHW_VEBOX_4K_PIC_HEIGHT_G12 * dwNumofVebox)
1076 {
1077 RegisterImmParams.dwData = MHW_VEBOX_TIMESTAMP_CNTS_PER_SEC_G12 * MHW_VEBOX_TIMEOUT_MS / 333;
1078 }
1079 else
1080 {
1081 RegisterImmParams.dwData = MHW_VEBOX_TIMESTAMP_CNTS_PER_SEC_G12 * MHW_VEBOX_TIMEOUT_MS / 1000;
1082 }
1083 RegisterImmParams.dwRegister = WATCHDOG_COUNT_THRESTHOLD_OFFSET_VECS_G12;
1084 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiLoadRegisterImmCmd(
1085 pCmdBufferInUse,
1086 &RegisterImmParams));
1087
1088 RegisterImmParams.dwData = MHW_VEBOX_WATCHDOG_ENABLE_COUNTER;
1089 RegisterImmParams.dwRegister = WATCHDOG_COUNT_CTRL_OFFSET_VECS_G12;
1090 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiLoadRegisterImmCmd(
1091 pCmdBufferInUse,
1092 &RegisterImmParams));
1093
1094 #if (_DEBUG || _RELEASE_INTERNAL)
1095 // Add noop for simu no output issue
1096 if (IdxofVebox > 0)
1097 {
1098 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1099 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1100 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1101 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1102 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
1103 {
1104 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1105 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1106 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1107 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
1108 }
1109 }
1110 #endif
1111
1112 //---------------------------------
1113 // Send CMD: Vebox_State
1114 //---------------------------------
1115 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxState(
1116 pCmdBufferInUse,
1117 &VeboxStateCmdParams,
1118 0));
1119
1120 //---------------------------------
1121 // Send CMD: Vebox_Surface_State
1122 //---------------------------------
1123 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaces(
1124 pCmdBufferInUse,
1125 &MhwVeboxSurfaceStateCmdParams));
1126
1127 //---------------------------------
1128 // Send CMD: SFC pipe commands
1129 //---------------------------------
1130 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
1131 {
1132 m_sfcPipeState->SetSfcIndex(IdxofVebox, dwNumofVebox);
1133 VPHAL_RENDER_CHK_STATUS(m_sfcPipeState->SendSfcCmd(
1134 pRenderData,
1135 pCmdBufferInUse));
1136 }
1137
1138 HalOcaInterface::OnDispatch(*pCmdBufferInUse, *pOsInterface, *pRenderHal->pMhwMiInterface, *pMmioRegisters);
1139
1140 //---------------------------------
1141 // Send CMD: Vebox_DI_IECP
1142 //---------------------------------
1143 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxDiIecp(
1144 pCmdBufferInUse,
1145 &VeboxDiIecpCmdParams));
1146
1147 // MI FlushDw, for vebox output green block issue
1148 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
1149 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiFlushDwCmd(pCmdBufferInUse, &FlushDwParams));
1150
1151 for (uint32_t tmpIdx = 0; tmpIdx < dwNumofVebox; tmpIdx++)
1152 {
1153 // MI Atomic SAdd[All] Increase 1
1154 MOS_ZeroMemory(&AtomicParams, sizeof(AtomicParams));
1155 AtomicParams.pOsResource = &pVeboxState->VESemaMemSAdd[tmpIdx];
1156 AtomicParams.dwDataSize = sizeof(uint32_t);
1157 AtomicParams.Operation = MHW_MI_ATOMIC_INC;
1158 AtomicParams.bInlineData = true;
1159 AtomicParams.dwOperand1Data[0] = 1;
1160 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiAtomicCmd(pCmdBufferInUse, &AtomicParams));
1161 }
1162
1163 // MI Atomic SAdd[IdxofVebox] Wait dwNumofVebox
1164 MOS_ZeroMemory(&MiSemaphoreWaitParams, sizeof(MiSemaphoreWaitParams));
1165 MiSemaphoreWaitParams.presSemaphoreMem = &pVeboxState->VESemaMemSAdd[IdxofVebox];
1166 MiSemaphoreWaitParams.bPollingWaitMode = true;
1167 MiSemaphoreWaitParams.dwSemaphoreData = dwNumofVebox;
1168 MiSemaphoreWaitParams.CompareOperation = MHW_MI_SAD_EQUAL_SDD;
1169 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiSemaphoreWaitCmd(pCmdBufferInUse, &MiSemaphoreWaitParams));
1170
1171 //---------------------------------
1172 // Write GPU Status Tag for Tag based synchronization
1173 //---------------------------------
1174 if (!pOsInterface->bEnableKmdMediaFrameTracking)
1175 {
1176 VPHAL_RENDER_CHK_STATUS(VeboxSendVecsStatusTag(
1177 pMhwMiInterface,
1178 pOsInterface,
1179 pCmdBufferInUse));
1180 }
1181
1182 //---------------------------------
1183 // Write Sync tag for Vebox Heap Synchronization
1184 // If KMD frame tracking is on, the synchrinization of Vebox Heap will use Status tag which
1185 // is updated using KMD frame tracking.
1186 //---------------------------------
1187 if (!pOsInterface->bEnableKmdMediaFrameTracking)
1188 {
1189 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
1190 FlushDwParams.pOsResource = (PMOS_RESOURCE)&pVeboxHeap->DriverResource;
1191 FlushDwParams.dwResourceOffset = pVeboxHeap->uiOffsetSync;
1192 FlushDwParams.dwDataDW1 = pVeboxHeap->dwNextTag;
1193 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiFlushDwCmd(
1194 pCmdBufferInUse,
1195 &FlushDwParams));
1196 }
1197
1198 // Disable Watchdog Timer
1199 RegisterImmParams.dwData = MHW_VEBOX_WATCHDOG_DISABLE_COUNTER;
1200 RegisterImmParams.dwRegister = WATCHDOG_COUNT_CTRL_OFFSET_VECS_G12;
1201 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiLoadRegisterImmCmd(
1202 pCmdBufferInUse,
1203 &RegisterImmParams));
1204
1205 // MI Atomic S[IdxofVebox] Reset
1206 MHW_MI_STORE_DATA_PARAMS dataParams = {};
1207 dataParams.pOsResource = &pVeboxState->VESemaMemS[IdxofVebox];
1208 dataParams.dwResourceOffset = 0;
1209 dataParams.dwValue = 0;
1210 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiStoreDataImmCmd(
1211 pCmdBufferInUse, &dataParams));
1212
1213 // MI Atomic SAdd[IdxofVebox] Reset
1214 dataParams.pOsResource = &pVeboxState->VESemaMemSAdd[IdxofVebox];
1215 dataParams.dwResourceOffset = 0;
1216 dataParams.dwValue = 0;
1217 VPHAL_RENDER_CHK_STATUS(pMhwMiInterface->AddMiStoreDataImmCmd(
1218 pCmdBufferInUse, &dataParams));
1219
1220 VPHAL_RENDER_CHK_STATUS(NullHW::StopPredicate(pOsInterface, pRenderHal->pMhwMiInterface, &CmdBuffer));
1221
1222 // Profiler end cmd
1223 if (pRenderHal->pPerfProfiler)
1224 {
1225 VPHAL_RENDER_CHK_STATUS(pRenderHal->pPerfProfiler->AddPerfCollectEndCmd((void*)pRenderHal, pOsInterface, pRenderHal->pMhwMiInterface, pCmdBufferInUse));
1226 }
1227
1228 HalOcaInterface::On1stLevelBBEnd(*pCmdBufferInUse, *pOsInterface);
1229
1230 VPHAL_RENDER_CHK_STATUS(AddMiBatchBufferEnd(pOsInterface, pMhwMiInterface, pCmdBufferInUse));
1231
1232 // Submit the secondary cmdbuffer seperately
1233 if (pOsInterface->phasedSubmission)
1234 {
1235 int32_t submissiontype[4] = {SUBMISSION_TYPE_MULTI_PIPE_MASTER,
1236 SUBMISSION_TYPE_MULTI_PIPE_SLAVE,
1237 SUBMISSION_TYPE_MULTI_PIPE_SLAVE,
1238 SUBMISSION_TYPE_MULTI_PIPE_SLAVE};
1239
1240 pCmdBufferInUse->iSubmissionType = submissiontype[IdxofVebox];
1241 pCmdBufferInUse->iVeboxNodeIndex = (MOS_VEBOX_NODE_IND)IdxofVebox;
1242 bPhasedSubmission = true;
1243
1244 if (IdxofVebox == dwNumofVebox - 1)
1245 {
1246 pCmdBufferInUse->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
1247 }
1248
1249 if (pOsInterface->bParallelSubmission)
1250 {
1251 // Return unused command buffer space to OS
1252 pOsInterface->pfnReturnCommandBuffer(
1253 pOsInterface,
1254 &CmdBufferInUse,
1255 1 + IdxofVebox);
1256
1257 if (IdxofVebox == dwNumofVebox - 1)
1258 {
1259 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnSubmitCommandBuffer(
1260 pOsInterface,
1261 pCmdBufferInUse,
1262 pVeboxState->bNullHwRenderDnDi));
1263 }
1264 }
1265 else
1266 {
1267 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnSubmitCommandBuffer(
1268 pOsInterface,
1269 pCmdBufferInUse,
1270 pVeboxState->bNullHwRenderDnDi));
1271 }
1272 }
1273 else
1274 {
1275 bPhasedSubmission = false;
1276 }
1277 }
1278
1279 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED // dump the secondry command buffers for scalable vebox troubleshoot.
1280 if (pOsInterface->bDumpCommandBuffer && pOsInterface->pfnDumpCommandBuffer)
1281 {
1282 if (pVeboxState->m_veCmdBuffers.size() < dwNumofVebox)
1283 {
1284 VPHAL_RENDER_ASSERTMESSAGE("pVeboxState->m_veCmdBuffers.size() (%d) < dwNumofVebox(%d)", pVeboxState->m_veCmdBuffers.size(), dwNumofVebox);
1285 return MOS_STATUS_INVALID_PARAMETER;
1286 }
1287 for (IdxofVebox = 0; IdxofVebox < dwNumofVebox; IdxofVebox++)
1288 {
1289 pOsInterface->pfnDumpCommandBuffer(pOsInterface, pVeboxState->m_veCmdBuffers[IdxofVebox]);
1290 }
1291 }
1292 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
1293
1294 VPHAL_RENDER_CHK_STATUS(UnLockVESecondaryCmdBuffers());
1295
1296 #if (_DEBUG || _RELEASE_INTERNAL)
1297 ReportUserSetting(
1298 m_userSettingPtr,
1299 __MEDIA_USER_FEATURE_VALUE_ENABLE_VEBOX_SCALABILITY_MODE,
1300 veboxEnableScalability,
1301 MediaUserSetting::Group::Device);
1302 #endif
1303 }
1304 else
1305 {
1306 CmdBuffer.iSubmissionType = SUBMISSION_TYPE_SINGLE_PIPE;
1307 bPhasedSubmission = false;
1308
1309 if (CmdBuffer.Attributes.pAttriVe)
1310 {
1311 PMOS_CMD_BUF_ATTRI_VE pAttriVe = (PMOS_CMD_BUF_ATTRI_VE)(CmdBuffer.Attributes.pAttriVe);
1312 pAttriVe->bUseVirtualEngineHint = false;
1313 }
1314
1315 pVeboxInterfaceXe_Xpm->SetVeboxIndex(0, 1, IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData));
1316 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
1317 {
1318 m_sfcPipeState->SetSfcIndex(0, 1);
1319 }
1320
1321 VPHAL_RENDER_CHK_STATUS(VPHAL_VEBOX_STATE_G12_BASE::VeboxRenderVeboxCmd(
1322 CmdBuffer,
1323 VeboxDiIecpCmdParams,
1324 VeboxSurfaceStateCmdParams,
1325 MhwVeboxSurfaceStateCmdParams,
1326 VeboxStateCmdParams,
1327 FlushDwParams,
1328 pGenericPrologParams));
1329
1330 veboxEnableScalability = false;
1331 #if (_DEBUG || _RELEASE_INTERNAL)
1332 ReportUserSetting(
1333 m_userSettingPtr,
1334 __MEDIA_USER_FEATURE_VALUE_ENABLE_VEBOX_SCALABILITY_MODE,
1335 veboxEnableScalability,
1336 MediaUserSetting::Group::Device);
1337 #endif
1338 }
1339
1340 finish:
1341 return eStatus;
1342 }
1343
1344
AddMiBatchBufferEnd(PMOS_INTERFACE pOsInterface,PMHW_MI_INTERFACE pMhwMiInterface,PMOS_COMMAND_BUFFER pCmdBufferInUse)1345 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::AddMiBatchBufferEnd(
1346 PMOS_INTERFACE pOsInterface,
1347 PMHW_MI_INTERFACE pMhwMiInterface,
1348 PMOS_COMMAND_BUFFER pCmdBufferInUse)
1349 {
1350 if (pOsInterface->bNoParsingAssistanceInKmd)
1351 {
1352 return pMhwMiInterface->AddMiBatchBufferEnd(
1353 pCmdBufferInUse,
1354 nullptr);
1355 }
1356 return MOS_STATUS_SUCCESS;
1357 }
1358
GetSurfOutput(bool bDiVarianceEnable)1359 PVPHAL_SURFACE VPHAL_VEBOX_STATE_XE_XPM::GetSurfOutput(bool bDiVarianceEnable)
1360 {
1361 PVPHAL_SURFACE pSurface = nullptr;
1362 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1363 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1364
1365 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData)) // Vebox output pipe
1366 {
1367 pSurface = pRenderData->pRenderTarget;
1368 }
1369 else if (bDiVarianceEnable) // DNDI, DI, DI + IECP
1370 {
1371 pSurface = pVeboxState->FFDISurfaces[pRenderData->iFrame0];
1372 }
1373 else if (IsIECPEnabled()) // DN + IECP or IECP only
1374 {
1375 pSurface = pVeboxState->FFDISurfaces[pRenderData->iCurDNOut];
1376 }
1377 else if (pRenderData->bDenoise) // DN only
1378 {
1379 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData) && !bDiVarianceEnable)
1380 {
1381 pSurface = pVeboxState->FFDISurfaces[pRenderData->iCurDNOut];
1382 }
1383 else
1384 {
1385 pSurface = pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut];
1386 }
1387 }
1388 else if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData)) // Write to SFC
1389 {
1390 // Vebox o/p should not be written to memory
1391 pSurface = nullptr;
1392 }
1393 else
1394 {
1395 VPHAL_RENDER_ASSERTMESSAGE("Unable to determine Vebox Output Surface.");
1396 }
1397
1398 return pSurface;
1399 }
1400
VeboxSetHVSDNParams(PVPHAL_DENOISE_PARAMS pDNParams)1401 MOS_STATUS VPHAL_VEBOX_STATE_XE_XPM::VeboxSetHVSDNParams(
1402 PVPHAL_DENOISE_PARAMS pDNParams)
1403 {
1404 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
1405 PRENDERHAL_INTERFACE pRenderHal = nullptr;
1406 PVPHAL_VEBOX_STATE pVeboxState = this;
1407 PVPHAL_VEBOX_RENDER_DATA pRenderData = nullptr;
1408 MhwVeboxInterfaceG12::MHW_VEBOX_CHROMA_PARAMS *veboxChromaParams = nullptr;
1409
1410 pRenderHal = pVeboxState->m_pRenderHal;
1411 pRenderData = GetLastExecRenderData();
1412
1413 VPHAL_RENDER_CHK_NULL_RETURN(pDNParams);
1414 VPHAL_RENDER_CHK_NULL_RETURN(pRenderHal);
1415 VPHAL_RENDER_CHK_NULL_RETURN(pRenderData);
1416
1417 // Populate the VEBOX DNDI parameters
1418 veboxChromaParams = (MhwVeboxInterfaceG12::MHW_VEBOX_CHROMA_PARAMS *)&pRenderData->VeboxChromaParams;
1419
1420 if (nullptr == m_hvsDenoiser)
1421 {
1422 m_hvsDenoiser = MOS_New(VphalHVSDenoiserHpm, pRenderHal);
1423 if (m_hvsDenoiser)
1424 {
1425 m_hvsDenoiser->InitKernelParams(m_hvsKernelBinary, m_hvsKernelBinarySize);
1426 }
1427 else
1428 {
1429 VPHAL_RENDER_ASSERTMESSAGE("New VphalHVSDenoiser Failed!");
1430 eStatus = MOS_STATUS_NULL_POINTER;
1431 return eStatus;
1432 }
1433 }
1434
1435 if (m_hvsDenoiser)
1436 {
1437 m_hvsDenoiser->Render(pDNParams);
1438 uint32_t *pHVSDenoiseParam = (uint32_t *)m_hvsDenoiser->GetDenoiseParams();
1439 if (pHVSDenoiseParam)
1440 {
1441 // Media kernel computed the HVS Denoise Parameters according to the specific mapping function.
1442 // Programming these Parameters to VEBOX for processing.
1443 VPHAL_RENDER_NORMALMESSAGE("Set HVS Denoised Parameters to VEBOX DNDI params");
1444 // DW0
1445 pRenderData->VeboxDNDIParams.dwDenoiseMaximumHistory = (pHVSDenoiseParam[0] & 0x000000ff);
1446 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseMaximumHistory %d", pRenderData->VeboxDNDIParams.dwDenoiseMaximumHistory);
1447 pRenderData->VeboxDNDIParams.dwDenoiseSTADThreshold = (pHVSDenoiseParam[0] & 0xfffe0000) >> 17;
1448 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseSTADThreshold %d", pRenderData->VeboxDNDIParams.dwDenoiseSTADThreshold);
1449 // DW1
1450 pRenderData->VeboxDNDIParams.dwDenoiseASDThreshold = (pHVSDenoiseParam[1] & 0x00000fff);
1451 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseASDThreshold %d", pRenderData->VeboxDNDIParams.dwDenoiseASDThreshold);
1452 pRenderData->VeboxDNDIParams.dwDenoiseMPThreshold = (pHVSDenoiseParam[1] & 0x0f800000) >> 23;
1453 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseMPThreshold %d", pRenderData->VeboxDNDIParams.dwDenoiseMPThreshold);
1454 pRenderData->VeboxDNDIParams.dwDenoiseHistoryDelta = (pHVSDenoiseParam[1] & 0xf0000000) >> 28;
1455 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseHistoryDelta %d", pRenderData->VeboxDNDIParams.dwDenoiseHistoryDelta);
1456 // DW2
1457 pRenderData->VeboxDNDIParams.dwTDThreshold = (pHVSDenoiseParam[2] & 0xfff00000) >> 20;
1458 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwTDThreshold %d", pRenderData->VeboxDNDIParams.dwTDThreshold);
1459 // DW3
1460 pRenderData->VeboxDNDIParams.dwLTDThreshold = (pHVSDenoiseParam[3] & 0xfff00000) >> 20;
1461 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwLTDThreshold %d", pRenderData->VeboxDNDIParams.dwLTDThreshold);
1462 // DW4
1463 pRenderData->VeboxDNDIParams.dwDenoiseSCMThreshold = (pHVSDenoiseParam[4] & 0xfff00000) >> 20;
1464 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwDenoiseSCMThreshold %d", pRenderData->VeboxDNDIParams.dwDenoiseSCMThreshold);
1465 // DW5
1466 pRenderData->VeboxDNDIParams.dwChromaSTADThreshold = (pHVSDenoiseParam[5] & 0xfffe0000) >> 17;
1467 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwChromaSTADThreshold %d", pRenderData->VeboxDNDIParams.dwChromaSTADThreshold);
1468 // DW6
1469 pRenderData->VeboxDNDIParams.dwChromaTDThreshold = (pHVSDenoiseParam[6] & 0xfff00000) >> 20;
1470 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwChromaTDThreshold %d", pRenderData->VeboxDNDIParams.dwChromaTDThreshold);
1471 // DW7
1472 pRenderData->VeboxDNDIParams.dwChromaLTDThreshold = (pHVSDenoiseParam[7] & 0xfff00000) >> 20;
1473 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwChromaLTDThreshold %d", pRenderData->VeboxDNDIParams.dwChromaLTDThreshold);
1474 // DW9
1475 pRenderData->VeboxDNDIParams.dwPixRangeWeight[0] = (pHVSDenoiseParam[9] & 0x0000001f);
1476 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[0] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[0]);
1477 pRenderData->VeboxDNDIParams.dwPixRangeWeight[1] = (pHVSDenoiseParam[9] & 0x000003e0) >> 5;
1478 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[1] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[1]);
1479 pRenderData->VeboxDNDIParams.dwPixRangeWeight[2] = (pHVSDenoiseParam[9] & 0x00007c00) >> 10;
1480 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[2] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[2]);
1481 pRenderData->VeboxDNDIParams.dwPixRangeWeight[3] = (pHVSDenoiseParam[9] & 0x000f8000) >> 15;
1482 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[3] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[3]);
1483 pRenderData->VeboxDNDIParams.dwPixRangeWeight[4] = (pHVSDenoiseParam[9] & 0x01f00000) >> 20;
1484 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[4] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[4]);
1485 pRenderData->VeboxDNDIParams.dwPixRangeWeight[5] = (pHVSDenoiseParam[9] & 0x3e000000) >> 25;
1486 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeWeight[5] %d", pRenderData->VeboxDNDIParams.dwPixRangeWeight[5]);
1487 // DW11
1488 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[5] = (pHVSDenoiseParam[11] & 0x1fff0000) >> 16;
1489 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[5] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[5]);
1490 // DW12
1491 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[4] = (pHVSDenoiseParam[12] & 0x1fff0000) >> 16;
1492 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[4] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[4]);
1493 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[3] = (pHVSDenoiseParam[12] & 0x00001fff);
1494 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[3] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[3]);
1495 // DW13
1496 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[2] = (pHVSDenoiseParam[13] & 0x1fff0000) >> 16;
1497 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[2] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[2]);
1498 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[1] = (pHVSDenoiseParam[13] & 0x00001fff);
1499 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[1] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[1]);
1500 // DW14
1501 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[0] = (pHVSDenoiseParam[14] & 0x1fff0000) >> 16;
1502 VPHAL_RENDER_NORMALMESSAGE("HVS: pRenderData->VeboxDNDIParams.dwPixRangeThreshold[0] %d", pRenderData->VeboxDNDIParams.dwPixRangeThreshold[0]);
1503 // DW16
1504 veboxChromaParams->dwPixRangeWeightChromaU[0] = (pHVSDenoiseParam[16] & 0x0000001f);
1505 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[0] %d", veboxChromaParams->dwPixRangeWeightChromaU[0]);
1506 veboxChromaParams->dwPixRangeWeightChromaU[1] = (pHVSDenoiseParam[16] & 0x000003e0) >> 5;
1507 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[1] %d", veboxChromaParams->dwPixRangeWeightChromaU[1]);
1508 veboxChromaParams->dwPixRangeWeightChromaU[2] = (pHVSDenoiseParam[16] & 0x00007c00) >> 10;
1509 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[2] %d", veboxChromaParams->dwPixRangeWeightChromaU[2]);
1510 veboxChromaParams->dwPixRangeWeightChromaU[3] = (pHVSDenoiseParam[16] & 0x000f8000) >> 15;
1511 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[3] %d", veboxChromaParams->dwPixRangeWeightChromaU[3]);
1512 veboxChromaParams->dwPixRangeWeightChromaU[4] = (pHVSDenoiseParam[16] & 0x01f00000) >> 20;
1513 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[4] %d", veboxChromaParams->dwPixRangeWeightChromaU[4]);
1514 veboxChromaParams->dwPixRangeWeightChromaU[5] = (pHVSDenoiseParam[16] & 0x3e000000) >> 25;
1515 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaU[5] %d", veboxChromaParams->dwPixRangeWeightChromaU[5]);
1516 //DW18
1517 veboxChromaParams->dwPixRangeThresholdChromaU[5] = (pHVSDenoiseParam[18] & 0x1fff0000) >> 16;
1518 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[5] %d", veboxChromaParams->dwPixRangeThresholdChromaU[5]);
1519 //DW19
1520 veboxChromaParams->dwPixRangeThresholdChromaU[4] = (pHVSDenoiseParam[19] & 0x1fff0000) >> 16;
1521 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[4] %d", veboxChromaParams->dwPixRangeThresholdChromaU[4]);
1522 veboxChromaParams->dwPixRangeThresholdChromaU[3] = (pHVSDenoiseParam[19] & 0x00001fff);
1523 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[3] %d", veboxChromaParams->dwPixRangeThresholdChromaU[3]);
1524 //DW20
1525 veboxChromaParams->dwPixRangeThresholdChromaU[2] = (pHVSDenoiseParam[20] & 0x1fff0000) >> 16;
1526 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[2] %d", veboxChromaParams->dwPixRangeThresholdChromaU[2]);
1527 veboxChromaParams->dwPixRangeThresholdChromaU[1] = (pHVSDenoiseParam[20] & 0x00001fff);
1528 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[1] %d", veboxChromaParams->dwPixRangeThresholdChromaU[1]);
1529 //DW21
1530 veboxChromaParams->dwPixRangeThresholdChromaU[0] = (pHVSDenoiseParam[21] & 0x1fff0000) >> 16;
1531 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaU[0] %d", veboxChromaParams->dwPixRangeThresholdChromaU[0]);
1532 //DW23
1533 veboxChromaParams->dwPixRangeWeightChromaV[0] = (pHVSDenoiseParam[23] & 0x0000001f);
1534 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[0] %d", veboxChromaParams->dwPixRangeWeightChromaV[0]);
1535 veboxChromaParams->dwPixRangeWeightChromaV[1] = (pHVSDenoiseParam[23] & 0x000003e0) >> 5;
1536 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[1] %d", veboxChromaParams->dwPixRangeWeightChromaV[1]);
1537 veboxChromaParams->dwPixRangeWeightChromaV[2] = (pHVSDenoiseParam[23] & 0x00007c00) >> 10;
1538 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[2] %d", veboxChromaParams->dwPixRangeWeightChromaV[2]);
1539 veboxChromaParams->dwPixRangeWeightChromaV[3] = (pHVSDenoiseParam[23] & 0x000f8000) >> 15;
1540 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[3] %d", veboxChromaParams->dwPixRangeWeightChromaV[3]);
1541 veboxChromaParams->dwPixRangeWeightChromaV[4] = (pHVSDenoiseParam[23] & 0x01f00000) >> 20;
1542 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[4] %d", veboxChromaParams->dwPixRangeWeightChromaV[4]);
1543 veboxChromaParams->dwPixRangeWeightChromaV[5] = (pHVSDenoiseParam[23] & 0x3e000000) >> 25;
1544 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeWeightChromaV[5] %d", veboxChromaParams->dwPixRangeWeightChromaV[5]);
1545 //DW25
1546 veboxChromaParams->dwPixRangeThresholdChromaV[5] = (pHVSDenoiseParam[25] & 0x1fff0000) >> 16;
1547 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[5] %d", veboxChromaParams->dwPixRangeThresholdChromaV[5]);
1548 //DW26
1549 veboxChromaParams->dwPixRangeThresholdChromaV[4] = (pHVSDenoiseParam[26] & 0x1fff0000) >> 16;
1550 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[4] %d", veboxChromaParams->dwPixRangeThresholdChromaV[4]);
1551 veboxChromaParams->dwPixRangeThresholdChromaV[3] = (pHVSDenoiseParam[26] & 0x00001fff);
1552 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[3] %d", veboxChromaParams->dwPixRangeThresholdChromaV[3]);
1553 //DW27
1554 veboxChromaParams->dwPixRangeThresholdChromaV[2] = (pHVSDenoiseParam[27] & 0x1fff0000) >> 16;
1555 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[2] %d", veboxChromaParams->dwPixRangeThresholdChromaV[2]);
1556 veboxChromaParams->dwPixRangeThresholdChromaV[1] = (pHVSDenoiseParam[27] & 0x00001fff);
1557 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[1] %d", veboxChromaParams->dwPixRangeThresholdChromaV[1]);
1558 //DW28
1559 veboxChromaParams->dwPixRangeThresholdChromaV[0] = (pHVSDenoiseParam[28] & 0x1fff0000) >> 16;
1560 VPHAL_RENDER_NORMALMESSAGE("veboxChromaParams->dwPixRangeThresholdChromaV[0] %d", veboxChromaParams->dwPixRangeThresholdChromaV[0]);
1561 eStatus = MOS_STATUS_SUCCESS;
1562 }
1563 }
1564
1565 return eStatus;
1566 }
1567