1 /*
2 * Copyright (c) 2018-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 vp_vebox_cmd_packet.cpp
24 //! \brief vebox packet which used in by mediapipline.
25 //! \details vebox packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27
28 #include "vp_vebox_cmd_packet_legacy.h"
29 #include "vp_utils.h"
30 #include "mos_resource_defs.h"
31 #include "hal_oca_interface.h"
32 #include "vp_render_sfc_m12.h"
33 #include "vp_render_ief.h"
34 #include "vp_feature_caps.h"
35 #include "vp_platform_interface.h"
36 #include "mhw_vebox_itf.h"
37 #include "mhw_mi_itf.h"
38 #include "media_scalability_defs.h"
39 #include "renderhal_g12_base.h"
40
41 namespace vp {
42
43 #define INTERP(x0, x1, x, y0, y1) ((uint32_t) floor(y0+(x-x0)*(y1-y0)/(double)(x1-x0)))
44
45 const uint32_t VpVeboxCmdPacketLegacy::m_satP1Table[MHW_STE_FACTOR_MAX + 1] = {
46 0x00000000, 0xfffffffe, 0xfffffffc, 0xfffffffa, 0xfffffff6, 0xfffffff4, 0xfffffff2, 0xfffffff0, 0xffffffee, 0xffffffec };
47
48 const uint32_t VpVeboxCmdPacketLegacy::m_satS0Table[MHW_STE_FACTOR_MAX + 1] = {
49 0x000000ef, 0x00000100, 0x00000113, 0x00000129, 0x0000017a, 0x000001a2, 0x000001d3, 0x00000211, 0x00000262, 0x000002d1 };
50
51 const uint32_t VpVeboxCmdPacketLegacy::m_satS1Table[MHW_STE_FACTOR_MAX + 1] = {
52 0x000000ab, 0x00000080, 0x00000066, 0x00000055, 0x000000c2, 0x000000b9, 0x000000b0, 0x000000a9, 0x000000a2, 0x0000009c };
53
SetupSurfaceStates(PVP_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams)54 void VpVeboxCmdPacketLegacy::SetupSurfaceStates(
55 PVP_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams)
56 {
57 VP_FUNC_CALL();
58 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(pVeboxSurfaceStateCmdParams);
59 MOS_ZeroMemory(pVeboxSurfaceStateCmdParams, sizeof(VP_VEBOX_SURFACE_STATE_CMD_PARAMS));
60 pVeboxSurfaceStateCmdParams->pSurfInput = m_veboxPacketSurface.pCurrInput;
61 pVeboxSurfaceStateCmdParams->pSurfOutput = m_veboxPacketSurface.pCurrOutput;
62 pVeboxSurfaceStateCmdParams->pSurfSTMM = m_veboxPacketSurface.pSTMMInput;
63 pVeboxSurfaceStateCmdParams->pSurfDNOutput = m_veboxPacketSurface.pDenoisedCurrOutput;
64 pVeboxSurfaceStateCmdParams->bDIEnable = m_PacketCaps.bDI;
65 pVeboxSurfaceStateCmdParams->b3DlutEnable = m_PacketCaps.bHDR3DLUT; // Need to consider cappipe
66
67 if (pVeboxSurfaceStateCmdParams->pSurfOutput &&
68 pVeboxSurfaceStateCmdParams->pSurfOutput->osSurface &&
69 pVeboxSurfaceStateCmdParams->pSurfOutput->osSurface->OsResource.bUncompressedWriteNeeded)
70 {
71 VP_RENDER_NORMALMESSAGE("Force compression as RC for bUncompressedWriteNeeded being true");
72 pVeboxSurfaceStateCmdParams->pSurfOutput->osSurface->CompressionMode = MOS_MMC_RC;
73 }
74
75 UpdateCpPrepareResources();
76 }
77
UpdateCpPrepareResources()78 void VpVeboxCmdPacketLegacy::UpdateCpPrepareResources()
79 {
80 VP_FUNC_CALL();
81
82 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
83 VP_RENDER_ASSERT(pRenderData);
84 // For 3DLut usage, it update in CpPrepareResources() for kernel usage, should
85 // reupdate here. For other feature usage, it already update in vp_pipeline
86 if (pRenderData->HDR3DLUT.is3DLutTableUpdatedByKernel == true)
87 {
88 VP_RENDER_NORMALMESSAGE("Update CP Prepare Resource for 3DLut kernel.");
89 PMOS_RESOURCE source[VPHAL_MAX_SOURCES] = {nullptr};
90 PMOS_RESOURCE target[VPHAL_MAX_TARGETS] = {nullptr};
91
92 if ((nullptr != m_hwInterface->m_osInterface) &&
93 (nullptr != m_hwInterface->m_osInterface->osCpInterface))
94 {
95 VP_SURFACE *surf = GetSurface(SurfaceTypeVeboxInput);
96 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(surf);
97 source[0] = &(surf->osSurface->OsResource);
98
99 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(m_renderTarget);
100 target[0] = &(m_renderTarget->osSurface->OsResource);
101
102 m_hwInterface->m_osInterface->osCpInterface->PrepareResources((void **)source, 1, (void **)target, 1);
103 }
104 }
105 }
106
Init3DLutTable(PVP_SURFACE surf3DLut)107 MOS_STATUS VpVeboxCmdPacketLegacy::Init3DLutTable(PVP_SURFACE surf3DLut)
108 {
109 VP_FUNC_CALL();
110 VpVeboxRenderData *renderData = GetLastExecRenderData();
111
112 VP_RENDER_CHK_NULL_RETURN(renderData);
113
114 if (!renderData->HDR3DLUT.is3DLutTableFilled)
115 {
116 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
117 }
118
119 VP_RENDER_NORMALMESSAGE("3DLut table is calculated by kernel.");
120
121 return MOS_STATUS_SUCCESS;
122 }
123
SetupVeboxExternal3DLutforHDR(PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)124 MOS_STATUS VpVeboxCmdPacketLegacy::SetupVeboxExternal3DLutforHDR(
125 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)
126 {
127 PMHW_VEBOX_MODE pVeboxMode = nullptr;
128 PMHW_VEBOX_3D_LUT pLUT3D = nullptr;
129 PMHW_3DLUT_PARAMS external3DLutParams = nullptr;
130 PMOS_INTERFACE osInterface = nullptr;
131 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
132 external3DLutParams = &(pRenderData->GetIECPParams().s3DLutParams);
133
134 VP_RENDER_CHK_NULL_RETURN(m_surfMemCacheCtl);
135 VP_RENDER_CHK_NULL_RETURN(pVeboxStateCmdParams);
136 VP_RENDER_CHK_NULL_RETURN(pRenderData);
137 VP_PUBLIC_CHK_NULL_RETURN(external3DLutParams);
138 VP_PUBLIC_CHK_NULL_RETURN(m_hwInterface->m_osInterface);
139
140 osInterface = m_hwInterface->m_osInterface;
141 pVeboxMode = &pVeboxStateCmdParams->VeboxMode;
142 pLUT3D = &pVeboxStateCmdParams->LUT3D;
143 VP_PUBLIC_CHK_NULL_RETURN(pLUT3D);
144 pLUT3D->ArbitrationPriorityControl = 0;
145 pLUT3D->Lut3dEnable = true;
146 pLUT3D->Lut3dSize = 0;
147
148 switch (external3DLutParams->LUTSize)
149 {
150 case 17:
151 pLUT3D->Lut3dSize = 1;
152 break;
153 case 65:
154 pLUT3D->Lut3dSize = 2;
155 break;
156 case 45:
157 pLUT3D->Lut3dSize = 3;
158 break;
159 case 33:
160 default:
161 pLUT3D->Lut3dSize = 0;
162 break;
163 }
164
165 VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnRegisterResource(
166 osInterface,
167 &(pRenderData->HDR3DLUT.external3DLutSurfResource),
168 false,
169 true));
170
171 pVeboxStateCmdParams->Vebox3DLookUpTablesSurfCtrl.Value =
172 m_surfMemCacheCtl->DnDi.Vebox3DLookUpTablesSurfMemObjCtl;
173 pVeboxMode->ColorGamutExpansionEnable = true;
174 pVeboxStateCmdParams->pVebox3DLookUpTables = &(pRenderData->HDR3DLUT.external3DLutSurfResource);
175
176 return MOS_STATUS_SUCCESS;
177 }
178
SetupVebox3DLutForHDR(PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)179 MOS_STATUS VpVeboxCmdPacketLegacy::SetupVebox3DLutForHDR(
180 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)
181 {
182 PMHW_VEBOX_MODE pVeboxMode = nullptr;
183 PMHW_VEBOX_3D_LUT pLUT3D = nullptr;
184 PVP_SURFACE surf3DLut = GetSurface(SurfaceType3DLut);
185 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
186
187 VP_RENDER_CHK_NULL_RETURN(m_surfMemCacheCtl);
188 VP_RENDER_CHK_NULL_RETURN(pVeboxStateCmdParams);
189 VP_RENDER_CHK_NULL_RETURN(surf3DLut);
190 VP_RENDER_CHK_NULL_RETURN(surf3DLut->osSurface);
191 VP_RENDER_CHK_NULL_RETURN(pRenderData);
192
193 VP_RENDER_CHK_STATUS_RETURN(Init3DLutTable(surf3DLut));
194
195 pVeboxMode = &pVeboxStateCmdParams->VeboxMode;
196 pLUT3D = &pVeboxStateCmdParams->LUT3D;
197
198 pLUT3D->ArbitrationPriorityControl = 0;
199 pLUT3D->Lut3dEnable = true;
200 // Config 3DLut size to 65 for HDR10 usage.
201 pLUT3D->Lut3dSize = 2;
202 if (pRenderData->HDR3DLUT.uiLutSize == 33)
203 {
204 pLUT3D->Lut3dSize = 0; // 33x33x33
205 }
206
207 pVeboxStateCmdParams->Vebox3DLookUpTablesSurfCtrl.Value =
208 m_surfMemCacheCtl->DnDi.Vebox3DLookUpTablesSurfMemObjCtl;
209
210 pVeboxMode->ColorGamutExpansionEnable = true;
211
212 pVeboxStateCmdParams->pVebox3DLookUpTables = &surf3DLut->osSurface->OsResource;
213
214 return MOS_STATUS_SUCCESS;
215 }
216
UpdateDnHVSParameters(uint32_t * pStatSlice0GNEPtr,uint32_t * pStatSlice1GNEPtr)217 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateDnHVSParameters(
218 uint32_t *pStatSlice0GNEPtr,
219 uint32_t *pStatSlice1GNEPtr)
220 {
221 VP_FUNC_CALL();
222 return MOS_STATUS_SUCCESS;
223 }
224
SetupDNTableForHVS(PMHW_VEBOX_STATE_CMD_PARAMS veboxStateCmdParams)225 MOS_STATUS VpVeboxCmdPacketLegacy::SetupDNTableForHVS(
226 PMHW_VEBOX_STATE_CMD_PARAMS veboxStateCmdParams)
227 {
228 VP_FUNC_CALL();
229 return MOS_STATUS_SUCCESS;
230 }
231
SetupHDRLuts(PMHW_VEBOX_STATE_CMD_PARAMS veboxStateCmdParams)232 MOS_STATUS VpVeboxCmdPacketLegacy::SetupHDRLuts(
233 PMHW_VEBOX_STATE_CMD_PARAMS veboxStateCmdParams)
234 {
235 VP_FUNC_CALL();
236 VpVeboxRenderData *renderData = GetLastExecRenderData();
237 VP_RENDER_CHK_NULL_RETURN(renderData);
238 VP_RENDER_CHK_NULL_RETURN(veboxStateCmdParams);
239
240 if (renderData->HDR3DLUT.isExternal3DLutTable)
241 {
242 VP_RENDER_CHK_STATUS_RETURN(SetupVebox3DLutForHDR(veboxStateCmdParams));
243 VP_RENDER_NORMALMESSAGE("3DLUT table setup by API.");
244 return MOS_STATUS_SUCCESS;
245 }
246
247 if (renderData->HDR3DLUT.bHdr3DLut)
248 {
249 VP_RENDER_CHK_STATUS_RETURN(SetupVebox3DLutForHDR(veboxStateCmdParams));
250 }
251 else
252 {
253 veboxStateCmdParams->pVebox3DLookUpTables = nullptr;
254 }
255
256 return MOS_STATUS_SUCCESS;
257 }
258
SetupVeboxState(PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)259 MOS_STATUS VpVeboxCmdPacketLegacy::SetupVeboxState(
260 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)
261 {
262 VP_FUNC_CALL();
263
264 PMHW_VEBOX_MODE pVeboxMode = nullptr;
265
266 VP_RENDER_CHK_NULL_RETURN(pVeboxStateCmdParams);
267 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
268
269 pVeboxMode = &pVeboxStateCmdParams->VeboxMode;
270 VP_RENDER_CHK_NULL_RETURN(pVeboxMode);
271
272 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
273 VP_RENDER_CHK_NULL_RETURN(pRenderData);
274
275 MOS_ZeroMemory(pVeboxStateCmdParams, sizeof(*pVeboxStateCmdParams));
276
277 // Always enable the global iecp to align with the legacy path.
278 // For next step, need to enable it only when necessary.
279 pVeboxMode->GlobalIECPEnable = true;
280
281 pVeboxMode->DIEnable = m_PacketCaps.bDI;
282
283 pVeboxMode->SFCParallelWriteEnable = m_IsSfcUsed &&
284 (m_PacketCaps.bDN || m_PacketCaps.bDI);
285 pVeboxMode->DNEnable = m_PacketCaps.bDN;
286 pVeboxMode->DNDIFirstFrame = m_DNDIFirstFrame;
287 pVeboxMode->DIOutputFrames = m_DIOutputFrames;
288 pVeboxMode->DisableEncoderStatistics = true;
289 pVeboxMode->DisableTemporalDenoiseFilter = false;
290
291 if (!m_PacketCaps.bDI &&
292 m_PacketCaps.bDN &&
293 (IS_RGB_CSPACE(m_currentSurface->ColorSpace)))
294 {
295 // RGB DN must disable Temporal filter in Vebox
296 pVeboxMode->DisableTemporalDenoiseFilter = true;
297 pVeboxMode->GlobalIECPEnable = true;
298 }
299
300 pVeboxMode->ColorGamutCompressionEnable = m_PacketCaps.bCGC && !m_PacketCaps.bBt2020ToRGB;
301 pVeboxMode->ColorGamutExpansionEnable = m_PacketCaps.bBt2020ToRGB;
302
303 pVeboxStateCmdParams->bUseVeboxHeapKernelResource = UseKernelResource();
304
305 //Set up Chroma Sampling
306 pVeboxStateCmdParams->ChromaSampling = pRenderData->GetChromaSubSamplingParams();
307
308 // Permanent program limitation that should go in all the configurations of SKLGT which have 2 VEBOXes (i.e. GT3 & GT4)
309 // VEBOX1 should be disabled whenever there is an VE-SFC workload.
310 // This is because we have only one SFC all the GT configurations and that SFC is tied to VEBOX0.Hence the programming restriction.
311 if (m_IsSfcUsed)
312 {
313 pVeboxMode->SingleSliceVeboxEnable = 1;
314 }
315 else
316 {
317 pVeboxMode->SingleSliceVeboxEnable = 0;
318 }
319
320 VP_RENDER_CHK_STATUS_RETURN(SetupHDRLuts(pVeboxStateCmdParams));
321 VP_RENDER_CHK_STATUS_RETURN(SetupDNTableForHVS(pVeboxStateCmdParams));
322
323 return MOS_STATUS_SUCCESS;
324 }
325
InitCmdBufferWithVeParams(PRENDERHAL_INTERFACE pRenderHal,MOS_COMMAND_BUFFER & CmdBuffer,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)326 MOS_STATUS VpVeboxCmdPacketLegacy::InitCmdBufferWithVeParams(
327 PRENDERHAL_INTERFACE pRenderHal,
328 MOS_COMMAND_BUFFER & CmdBuffer,
329 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
330 {
331 VP_FUNC_CALL();
332
333 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
334 RENDERHAL_GENERIC_PROLOG_PARAMS_G12 genericPrologParamsG12 = {};
335
336 genericPrologParamsG12.bEnableMediaFrameTracking = pGenericPrologParams->bEnableMediaFrameTracking;
337 genericPrologParamsG12.bMmcEnabled = pGenericPrologParams->bMmcEnabled;
338 genericPrologParamsG12.dwMediaFrameTrackingAddrOffset = pGenericPrologParams->dwMediaFrameTrackingAddrOffset;
339 genericPrologParamsG12.dwMediaFrameTrackingTag = pGenericPrologParams->dwMediaFrameTrackingTag;
340 genericPrologParamsG12.presMediaFrameTrackingSurface = pGenericPrologParams->presMediaFrameTrackingSurface;
341
342 genericPrologParamsG12.VEngineHintParams.BatchBufferCount = 2;
343 //genericPrologParamsG12.VEngineHintParams.resScalableBatchBufs[0] = CmdBuffer[0].OsResource;
344 //genericPrologParamsG12.VEngineHintParams.resScalableBatchBufs[1] = CmdBuffer[1].OsResource;
345 genericPrologParamsG12.VEngineHintParams.UsingFrameSplit = true;
346 genericPrologParamsG12.VEngineHintParams.UsingSFC = false;
347 genericPrologParamsG12.VEngineHintParams.EngineInstance[0] = 0;
348 genericPrologParamsG12.VEngineHintParams.EngineInstance[1] = 1;
349 genericPrologParamsG12.VEngineHintParams.NeedSyncWithPrevious = true;
350 genericPrologParamsG12.VEngineHintParams.SameEngineAsLastSubmission = true;
351
352 pRenderHal->pOsInterface->VEEnable = false;
353
354 // Initialize command buffer and insert prolog
355 VP_RENDER_CHK_STATUS_RETURN(pRenderHal->pfnInitCommandBuffer(
356 pRenderHal,
357 &CmdBuffer,
358 (PRENDERHAL_GENERIC_PROLOG_PARAMS)&genericPrologParamsG12));
359
360 return eStatus;
361 }
362
363 //!
364 //! \brief Vebox initialize STMM History
365 //! \details Initialize STMM History surface
366 //! Description:
367 //! This function is used by VEBox for initializing
368 //! the STMM surface. The STMM / Denoise history is a custom surface used
369 //! for both input and output. Each cache line contains data for 4 4x4s.
370 //! The STMM for each 4x4 is 8 bytes, while the denoise history is 1 byte
371 //! and the chroma denoise history is 1 byte for each U and V.
372 //! Byte Data\n
373 //! 0 STMM for 2 luma values at luma Y=0, X=0 to 1\n
374 //! 1 STMM for 2 luma values at luma Y=0, X=2 to 3\n
375 //! 2 Luma Denoise History for 4x4 at 0,0\n
376 //! 3 Not Used\n
377 //! 4-5 STMM for luma from X=4 to 7\n
378 //! 6 Luma Denoise History for 4x4 at 0,4\n
379 //! 7 Not Used\n
380 //! 8-15 Repeat for 4x4s at 0,8 and 0,12\n
381 //! 16 STMM for 2 luma values at luma Y=1,X=0 to 1\n
382 //! 17 STMM for 2 luma values at luma Y=1, X=2 to 3\n
383 //! 18 U Chroma Denoise History\n
384 //! 19 Not Used\n
385 //! 20-31 Repeat for 3 4x4s at 1,4, 1,8 and 1,12\n
386 //! 32 STMM for 2 luma values at luma Y=2,X=0 to 1\n
387 //! 33 STMM for 2 luma values at luma Y=2, X=2 to 3\n
388 //! 34 V Chroma Denoise History\n
389 //! 35 Not Used\n
390 //! 36-47 Repeat for 3 4x4s at 2,4, 2,8 and 2,12\n
391 //! 48 STMM for 2 luma values at luma Y=3,X=0 to 1\n
392 //! 49 STMM for 2 luma values at luma Y=3, X=2 to 3\n
393 //! 50-51 Not Used\n
394 //! 36-47 Repeat for 3 4x4s at 3,4, 3,8 and 3,12\n
395 //! \return MOS_STATUS
396 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
397 //!
InitSTMMHistory()398 MOS_STATUS VpVeboxCmdPacketLegacy::InitSTMMHistory()
399 {
400 VP_FUNC_CALL();
401
402 MOS_STATUS eStatus;
403 uint32_t dwSize;
404 int32_t x, y;
405 uint8_t* pByte;
406 MOS_LOCK_PARAMS LockFlags;
407 PVP_SURFACE stmmSurface = GetSurface(SurfaceTypeSTMMIn);
408 eStatus = MOS_STATUS_SUCCESS;
409
410 VP_PUBLIC_CHK_NULL_RETURN(stmmSurface);
411 VP_PUBLIC_CHK_NULL_RETURN(stmmSurface->osSurface);
412
413 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
414
415 LockFlags.WriteOnly = 1;
416 LockFlags.TiledAsTiled = 1; // Set TiledAsTiled flag for STMM surface initialization.
417
418 // Lock the surface for writing
419 pByte = (uint8_t*)m_allocator->Lock(
420 &stmmSurface->osSurface->OsResource,
421 &LockFlags);
422
423 VP_RENDER_CHK_NULL(pByte);
424
425 dwSize = stmmSurface->osSurface->dwWidth >> 2;
426
427 // Fill STMM surface with DN history init values.
428 for (y = 0; y < (int32_t)stmmSurface->osSurface->dwHeight; y++)
429 {
430 for (x = 0; x < (int32_t)dwSize; x++)
431 {
432 MOS_FillMemory(pByte, 2, DNDI_HISTORY_INITVALUE);
433 // skip denosie history init.
434 pByte += 4;
435 }
436
437 pByte += stmmSurface->osSurface->dwPitch - stmmSurface->osSurface->dwWidth;
438 }
439
440 // Unlock the surface
441 VP_RENDER_CHK_STATUS(m_allocator->UnLock(&stmmSurface->osSurface->OsResource));
442
443 finish:
444 return eStatus;
445 }
446
IsFormatMMCSupported(MOS_FORMAT Format)447 bool VpVeboxCmdPacketLegacy::IsFormatMMCSupported(MOS_FORMAT Format)
448 {
449 VP_FUNC_CALL();
450
451 // Check if Sample Format is supported
452 if ((Format != Format_YUY2) &&
453 (Format != Format_Y210) &&
454 (Format != Format_Y410) &&
455 (Format != Format_Y216) &&
456 (Format != Format_Y416) &&
457 (Format != Format_P010) &&
458 (Format != Format_P016) &&
459 (Format != Format_AYUV) &&
460 (Format != Format_NV21) &&
461 (Format != Format_NV12) &&
462 (Format != Format_UYVY) &&
463 (Format != Format_YUYV) &&
464 (Format != Format_R10G10B10A2) &&
465 (Format != Format_B10G10R10A2) &&
466 (Format != Format_A8B8G8R8) &&
467 (Format != Format_X8B8G8R8) &&
468 (Format != Format_A8R8G8B8) &&
469 (Format != Format_X8R8G8B8) &&
470 (Format != Format_A16B16G16R16F) &&
471 (Format != Format_A16R16G16B16F))
472 {
473 VP_RENDER_NORMALMESSAGE("Unsupported Format '0x%08x' for VEBOX MMC ouput.", Format);
474 return false;
475 }
476
477 return true;
478 }
479
SetSfcMmcParams()480 MOS_STATUS VpVeboxCmdPacketLegacy::SetSfcMmcParams()
481 {
482 VP_FUNC_CALL();
483 VP_PUBLIC_CHK_NULL_RETURN(m_sfcRender);
484 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget);
485 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget->osSurface);
486 VP_PUBLIC_CHK_NULL_RETURN(m_mmc);
487
488 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->SetMmcParams(m_renderTarget->osSurface,
489 IsFormatMMCSupported(m_renderTarget->osSurface->Format),
490 m_mmc->IsMmcEnabled()));
491
492 return MOS_STATUS_SUCCESS;
493 }
494
GetSurface(SurfaceType type)495 VP_SURFACE *VpVeboxCmdPacketLegacy::GetSurface(SurfaceType type)
496 {
497 VP_FUNC_CALL();
498
499 auto it = m_surfSetting.surfGroup.find(type);
500 VP_SURFACE *surf = (m_surfSetting.surfGroup.end() != it) ? it->second : nullptr;
501 if (SurfaceTypeVeboxCurrentOutput == type && nullptr == surf && !m_IsSfcUsed)
502 {
503 // Vebox output case.
504 surf = m_renderTarget;
505 }
506 else if (SurfaceTypeVeboxInput == type && surf)
507 {
508 // The vp surface object for external surface will be destroyed by hw filter before packet submit.
509 // Store the vp surface object inside packet.
510 if (MOS_FAILED(m_allocator->CopyVpSurface(*m_currentSurface ,*surf)))
511 {
512 return nullptr;
513 }
514 m_currentSurface->rcMaxSrc = m_currentSurface->rcSrc;
515 surf = m_currentSurface;
516 }
517 else if (SurfaceTypeVeboxPreviousInput == type && surf)
518 {
519 // The vp surface object for external surface will be destroyed by hw filter before packet submit.
520 // Store the vp surface object inside packet.
521 if (MOS_FAILED(m_allocator->CopyVpSurface(*m_previousSurface ,*surf)))
522 {
523 return nullptr;
524 }
525 surf = m_previousSurface;
526 }
527 return surf;
528 }
529
UpdateCscParams(FeatureParamCsc & params)530 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateCscParams(FeatureParamCsc ¶ms)
531 {
532 VP_FUNC_CALL();
533 // Scaing only can be apply to SFC path
534 if (m_PacketCaps.bSfcCsc)
535 {
536 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->UpdateCscParams(params));
537 }
538
539 return MOS_STATUS_SUCCESS;
540 }
541
UpdateDenoiseParams(FeatureParamDenoise & params)542 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateDenoiseParams(FeatureParamDenoise ¶ms)
543 {
544 VP_FUNC_CALL();
545
546 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
547 VP_RENDER_CHK_NULL_RETURN(pRenderData);
548
549 // ConfigureDenoiseParams() just includes logic that both used in SetDenoiseParams and UpdateDenoiseParams.
550 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureDenoiseParams(pRenderData, params.denoiseParams.fDenoiseFactor));
551
552 // bDNDITopFirst in DNDI parameters need be configured during UpdateDIParams after DI parameter packet reusing being enabled.
553 return MOS_STATUS_SUCCESS;
554 }
555
UpdateTccParams(FeatureParamTcc & params)556 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateTccParams(FeatureParamTcc ¶ms)
557 {
558 VP_FUNC_CALL();
559 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
560 VP_RENDER_CHK_NULL_RETURN(pRenderData);
561
562 // ConfigureTccParams() just includes logic that both used in SetTccParams and UpdateTccParams.
563 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureTccParams(pRenderData, params.bEnableTCC, params.Magenta, params.Red,
564 params.Yellow, params.Green, params.Cyan, params.Blue));
565
566 return MOS_STATUS_SUCCESS;
567 }
568
UpdateSteParams(FeatureParamSte & params)569 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateSteParams(FeatureParamSte ¶ms)
570 {
571 VP_FUNC_CALL();
572 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
573 VP_RENDER_CHK_NULL_RETURN(pRenderData);
574
575 // ConfigureSteParams() just includes logic that both used in SetSteParams and UpdateSteParams.
576 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureSteParams(pRenderData, params.bEnableSTE, params.dwSTEFactor, params.bEnableSTD, params.STDParam.paraSizeInBytes, params.STDParam.param));
577
578 return MOS_STATUS_SUCCESS;
579 }
580
UpdateProcampParams(FeatureParamProcamp & params)581 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateProcampParams(FeatureParamProcamp ¶ms)
582 {
583 VP_FUNC_CALL();
584
585 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
586 VP_RENDER_CHK_NULL_RETURN(pRenderData);
587 PVPHAL_PROCAMP_PARAMS pProcampParams = params.procampParams;
588 VP_RENDER_CHK_NULL_RETURN(pProcampParams);
589
590 // ConfigureProcampParams() just includes logic that both used in SetProcampParams and UpdateProcampParams.
591 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureProcampParams(pRenderData, pProcampParams->bEnabled, pProcampParams->fBrightness,
592 pProcampParams->fContrast, pProcampParams->fHue, pProcampParams->fSaturation));
593
594 return MOS_STATUS_SUCCESS;
595 }
596
SetScalingParams(PSFC_SCALING_PARAMS scalingParams)597 MOS_STATUS VpVeboxCmdPacketLegacy::SetScalingParams(PSFC_SCALING_PARAMS scalingParams)
598 {
599 VP_FUNC_CALL();
600
601 VP_PUBLIC_CHK_NULL_RETURN(scalingParams);
602 // Scaing only can be apply to SFC path
603 if (m_PacketCaps.bSFC)
604 {
605 VP_PUBLIC_CHK_NULL_RETURN(m_sfcRender);
606 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->SetScalingParams(scalingParams));
607
608 //---------------------------------
609 // Set SFC State: mmc
610 //---------------------------------
611 SetSfcMmcParams();
612
613 return MOS_STATUS_SUCCESS;
614 }
615 else
616 {
617 VP_RENDER_NORMALMESSAGE("Scaling is enabled in SFC, pls recheck the features enabling in SFC");
618 return MOS_STATUS_INVALID_PARAMETER;
619 }
620 }
621
SetSfcCSCParams(PSFC_CSC_PARAMS cscParams)622 MOS_STATUS VpVeboxCmdPacketLegacy::SetSfcCSCParams(PSFC_CSC_PARAMS cscParams)
623 {
624 VP_FUNC_CALL();
625
626 VP_PUBLIC_CHK_NULL_RETURN(cscParams);
627
628 if (m_PacketCaps.bSFC)
629 {
630 VP_PUBLIC_CHK_NULL_RETURN(m_sfcRender);
631 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->SetCSCParams(cscParams));
632 return MOS_STATUS_SUCCESS;
633 }
634 else
635 {
636 VP_RENDER_NORMALMESSAGE("CSC/IEF for Output is enabled in SFC, pls recheck the features enabling in SFC");
637 return MOS_STATUS_INVALID_PARAMETER;
638 }
639 }
640
SetVeboxBeCSCParams(PVEBOX_CSC_PARAMS cscParams)641 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxBeCSCParams(PVEBOX_CSC_PARAMS cscParams)
642 {
643 VP_FUNC_CALL();
644
645 VP_RENDER_CHK_NULL_RETURN(cscParams);
646
647 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
648 VP_RENDER_ASSERT(pRenderData);
649
650 pRenderData->IECP.BeCSC.bBeCSCEnabled = cscParams->bCSCEnabled;
651
652 MHW_VEBOX_IECP_PARAMS& veboxIecpParams = pRenderData->GetIECPParams();
653
654 if (m_CscInputCspace != cscParams->inputColorSpace ||
655 m_CscOutputCspace != cscParams->outputColorSpace)
656 {
657 // For VE 3DLUT HDR cases, CSC params will be overriden in VeboxInterface_BT2020YUVToRGB
658 VeboxGetBeCSCMatrix(
659 cscParams->inputColorSpace,
660 cscParams->outputColorSpace,
661 cscParams->inputFormat);
662
663 veboxIecpParams.srcFormat = cscParams->inputFormat;
664 veboxIecpParams.dstFormat = cscParams->outputFormat;
665 veboxIecpParams.ColorSpace = (MHW_CSPACE)cscParams->inputColorSpace;
666 }
667
668 if (m_PacketCaps.bVebox &&
669 m_PacketCaps.bBeCSC &&
670 cscParams->bCSCEnabled)
671 {
672 veboxIecpParams.bCSCEnable = true;
673 veboxIecpParams.pfCscCoeff = m_fCscCoeff;
674 veboxIecpParams.pfCscInOffset = m_fCscInOffset;
675 veboxIecpParams.pfCscOutOffset = m_fCscOutOffset;
676 }
677
678 VP_RENDER_CHK_STATUS_RETURN(SetVeboxOutputAlphaParams(cscParams));
679 VP_RENDER_CHK_STATUS_RETURN(SetVeboxChromasitingParams(cscParams));
680
681 return MOS_STATUS_SUCCESS;
682 }
683
SetVeboxOutputAlphaParams(PVEBOX_CSC_PARAMS cscParams)684 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxOutputAlphaParams(PVEBOX_CSC_PARAMS cscParams)
685 {
686 VP_FUNC_CALL();
687
688 VP_RENDER_CHK_NULL_RETURN(cscParams);
689
690 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
691 VP_RENDER_ASSERT(pRenderData);
692
693 MHW_VEBOX_IECP_PARAMS& veboxIecpParams = pRenderData->GetIECPParams();
694
695 bool isAlphaFromStateSelect = IS_ALPHA_FORMAT(cscParams->outputFormat) &&
696 cscParams->alphaParams &&
697 (!IS_ALPHA_FORMAT(cscParams->inputFormat) ||
698 VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM != cscParams->alphaParams->AlphaMode);
699
700 VP_RENDER_NORMALMESSAGE("AlphaFromStateSelect = %d", isAlphaFromStateSelect);
701
702 if (isAlphaFromStateSelect)
703 {
704 veboxIecpParams.bAlphaEnable = true;
705 }
706 else
707 {
708 veboxIecpParams.bAlphaEnable = false;
709 return MOS_STATUS_SUCCESS;
710 }
711
712 MOS_FORMAT outFormat = cscParams->outputFormat;
713
714 auto SetOpaqueAlphaValue = [&](uint16_t &alphaValue)
715 {
716 if (Format_Y416 == cscParams->outputFormat)
717 {
718 alphaValue = 0xffff;
719 }
720 else
721 {
722 alphaValue = 0xff;
723 }
724 };
725
726 if (cscParams->alphaParams != nullptr)
727 {
728 switch (cscParams->alphaParams->AlphaMode)
729 {
730 case VPHAL_ALPHA_FILL_MODE_NONE:
731 if (outFormat == Format_A8R8G8B8)
732 {
733 veboxIecpParams.wAlphaValue =
734 (uint8_t)(0xff * cscParams->alphaParams->fAlpha);
735 }
736 else
737 {
738 SetOpaqueAlphaValue(veboxIecpParams.wAlphaValue);
739 }
740 break;
741
742 // VEBOX does not support Background Color
743 case VPHAL_ALPHA_FILL_MODE_BACKGROUND:
744
745 // VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM case is hit when the
746 // input does not have alpha
747 // So we set Opaque alpha channel.
748 case VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM:
749 case VPHAL_ALPHA_FILL_MODE_OPAQUE:
750 default:
751 SetOpaqueAlphaValue(veboxIecpParams.wAlphaValue);
752 break;
753 }
754 }
755 else
756 {
757 SetOpaqueAlphaValue(veboxIecpParams.wAlphaValue);
758 }
759
760 VP_RENDER_NORMALMESSAGE("wAlphaValue = %d", veboxIecpParams.wAlphaValue);
761
762 return MOS_STATUS_SUCCESS;
763 }
764
SetVeboxChromasitingParams(PVEBOX_CSC_PARAMS cscParams)765 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxChromasitingParams(PVEBOX_CSC_PARAMS cscParams)
766 {
767 VP_FUNC_CALL();
768
769 VP_RENDER_CHK_NULL_RETURN(cscParams);
770
771 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
772 VP_RENDER_ASSERT(pRenderData);
773
774 MHW_VEBOX_CHROMA_SAMPLING& veboxChromaSamplingParams = pRenderData->GetChromaSubSamplingParams();
775
776 veboxChromaSamplingParams.BypassChromaDownsampling = cscParams->bypassCDS;
777 veboxChromaSamplingParams.BypassChromaUpsampling = cscParams->bypassCUS;
778 veboxChromaSamplingParams.ChromaDownsamplingCoSitedHorizontalOffset = cscParams->chromaDownSamplingHorizontalCoef;
779 veboxChromaSamplingParams.ChromaDownsamplingCoSitedVerticalOffset = cscParams->chromaDownSamplingVerticalCoef;
780 veboxChromaSamplingParams.ChromaUpsamplingCoSitedHorizontalOffset = cscParams->chromaUpSamplingHorizontalCoef;
781 veboxChromaSamplingParams.ChromaUpsamplingCoSitedVerticalOffset = cscParams->chromaUpSamplingVerticalCoef;
782
783 return MOS_STATUS_SUCCESS;
784 }
785
SetSfcRotMirParams(PSFC_ROT_MIR_PARAMS rotMirParams)786 MOS_STATUS VpVeboxCmdPacketLegacy::SetSfcRotMirParams(PSFC_ROT_MIR_PARAMS rotMirParams)
787 {
788 VP_FUNC_CALL();
789
790 VP_PUBLIC_CHK_NULL_RETURN(rotMirParams);
791
792 if (m_PacketCaps.bSFC)
793 {
794 VP_PUBLIC_CHK_NULL_RETURN(m_sfcRender);
795 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->SetRotMirParams(rotMirParams));
796 return MOS_STATUS_SUCCESS;
797 }
798 else
799 {
800 VP_RENDER_NORMALMESSAGE("CSC/IEF for Output is enabled in SFC, pls recheck the features enabling in SFC");
801 return MOS_STATUS_INVALID_PARAMETER;
802 }
803
804 }
805
ConfigureTccParams(VpVeboxRenderData * renderData,bool bEnableTcc,uint8_t magenta,uint8_t red,uint8_t yellow,uint8_t green,uint8_t cyan,uint8_t blue)806 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigureTccParams(VpVeboxRenderData *renderData, bool bEnableTcc, uint8_t magenta, uint8_t red, uint8_t yellow, uint8_t green, uint8_t cyan, uint8_t blue)
807 {
808 // ConfigureTccParams() just includes logic that both used in SetTccParams and UpdateTccParams.
809 // If the logic won't be used in UpdateTccParams, please just add the logic into SetTccParams.
810 VP_FUNC_CALL();
811 MHW_VEBOX_IECP_PARAMS &mhwVeboxIecpParams = renderData->GetIECPParams();
812 if (bEnableTcc)
813 {
814 renderData->IECP.TCC.bTccEnabled = true;
815 mhwVeboxIecpParams.ColorPipeParams.bActive = true;
816 mhwVeboxIecpParams.ColorPipeParams.bEnableTCC = true;
817 mhwVeboxIecpParams.ColorPipeParams.TccParams.Magenta = magenta;
818 mhwVeboxIecpParams.ColorPipeParams.TccParams.Red = red;
819 mhwVeboxIecpParams.ColorPipeParams.TccParams.Yellow = yellow;
820 mhwVeboxIecpParams.ColorPipeParams.TccParams.Green = green;
821 mhwVeboxIecpParams.ColorPipeParams.TccParams.Cyan = cyan;
822 mhwVeboxIecpParams.ColorPipeParams.TccParams.Blue = blue;
823 }
824 else
825 {
826 renderData->IECP.TCC.bTccEnabled = false;
827 mhwVeboxIecpParams.ColorPipeParams.bEnableTCC = false;
828 }
829 return MOS_STATUS_SUCCESS;
830 }
831
ConfigureSteParams(VpVeboxRenderData * renderData,bool bEnableSte,uint32_t dwSTEFactor,bool bEnableStd,uint32_t stdParaSizeInBytes,void * stdParam)832 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigureSteParams(VpVeboxRenderData *renderData, bool bEnableSte, uint32_t dwSTEFactor, bool bEnableStd, uint32_t stdParaSizeInBytes, void* stdParam)
833 {
834 VP_FUNC_CALL();
835 // ConfigureSteParams() just includes logic that both used in SetSteParams and UpdateSteParams.
836 // If the logic won't be used in UpdateSteParams, please just add the logic into SetSteParams.
837
838 MHW_VEBOX_IECP_PARAMS &mhwVeboxIecpParams = renderData->GetIECPParams();
839 if (bEnableSte)
840 {
841 renderData->IECP.STE.bSteEnabled = true;
842 mhwVeboxIecpParams.ColorPipeParams.bActive = true;
843 mhwVeboxIecpParams.ColorPipeParams.bEnableSTE = true;
844 if (dwSTEFactor > MHW_STE_FACTOR_MAX)
845 {
846 mhwVeboxIecpParams.ColorPipeParams.SteParams.dwSTEFactor = MHW_STE_FACTOR_MAX;
847 mhwVeboxIecpParams.ColorPipeParams.SteParams.satP1 = m_satP1Table[MHW_STE_FACTOR_MAX];
848 mhwVeboxIecpParams.ColorPipeParams.SteParams.satS0 = m_satS0Table[MHW_STE_FACTOR_MAX];
849 mhwVeboxIecpParams.ColorPipeParams.SteParams.satS1 = m_satS1Table[MHW_STE_FACTOR_MAX];
850 }
851 else
852 {
853 mhwVeboxIecpParams.ColorPipeParams.SteParams.dwSTEFactor = dwSTEFactor;
854 mhwVeboxIecpParams.ColorPipeParams.SteParams.satP1 = m_satP1Table[dwSTEFactor];
855 mhwVeboxIecpParams.ColorPipeParams.SteParams.satS0 = m_satS0Table[dwSTEFactor];
856 mhwVeboxIecpParams.ColorPipeParams.SteParams.satS1 = m_satS1Table[dwSTEFactor];
857 }
858 }
859 else if (bEnableStd)
860 {
861 renderData->IECP.STE.bStdEnabled = true;
862 mhwVeboxIecpParams.ColorPipeParams.bActive = true;
863 mhwVeboxIecpParams.ColorPipeParams.bEnableSTD = true;
864 mhwVeboxIecpParams.ColorPipeParams.StdParams.paraSizeInBytes = stdParaSizeInBytes;
865 mhwVeboxIecpParams.ColorPipeParams.StdParams.param = stdParam;
866 }
867 else
868 {
869 renderData->IECP.STE.bSteEnabled = false;
870 mhwVeboxIecpParams.ColorPipeParams.bEnableSTE = false;
871 }
872 return MOS_STATUS_SUCCESS;
873 }
874
ConfigureProcampParams(VpVeboxRenderData * renderData,bool bEnableProcamp,float fBrightness,float fContrast,float fHue,float fSaturation)875 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigureProcampParams(VpVeboxRenderData *renderData, bool bEnableProcamp,
876 float fBrightness, float fContrast, float fHue, float fSaturation)
877 {
878 // ConfigureProcampParams() just includes logic that both used in SetProcampParams and UpdateProcampParams.
879 // If the logic won't be used in UpdateProcampParams, please just add the logic into SetProcampParams.
880 VP_FUNC_CALL();
881 VP_RENDER_CHK_NULL_RETURN(renderData);
882 MHW_VEBOX_IECP_PARAMS &mhwVeboxIecpParams = renderData->GetIECPParams();
883 if (bEnableProcamp)
884 {
885 renderData->IECP.PROCAMP.bProcampEnabled = true;
886 mhwVeboxIecpParams.ProcAmpParams.bActive = true;
887 mhwVeboxIecpParams.ProcAmpParams.bEnabled = true;
888 mhwVeboxIecpParams.ProcAmpParams.brightness = (uint32_t)MOS_F_ROUND(fBrightness * 16.0F); // S7.4
889 mhwVeboxIecpParams.ProcAmpParams.contrast = (uint32_t)MOS_UF_ROUND(fContrast * 128.0F); // U4.7
890 mhwVeboxIecpParams.ProcAmpParams.sinCS = (uint32_t)MOS_F_ROUND(sin(MHW_DEGREE_TO_RADIAN(fHue)) *
891 fContrast *fSaturation * 256.0F); // S7.8
892 mhwVeboxIecpParams.ProcAmpParams.cosCS = (uint32_t)MOS_F_ROUND(cos(MHW_DEGREE_TO_RADIAN(fHue)) *fContrast *fSaturation * 256.0F); // S7.8
893 }
894 else
895 {
896 renderData->IECP.PROCAMP.bProcampEnabled = false;
897 mhwVeboxIecpParams.ProcAmpParams.bActive = false;
898 mhwVeboxIecpParams.ProcAmpParams.bEnabled = false;
899 }
900
901 return MOS_STATUS_SUCCESS;
902 }
903
ConfigureDenoiseParams(VpVeboxRenderData * renderData,float fDenoiseFactor)904 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigureDenoiseParams(VpVeboxRenderData *renderData, float fDenoiseFactor)
905 {
906 // ConfigureDenoiseParams() just includes logic that both used in SetDenoiseParams and UpdateDenoiseParams.
907 // If the logic won't be used in UpdateDenoiseParams, please just add the logic into SetDenoiseParams.
908 VP_FUNC_CALL();
909 VP_RENDER_CHK_NULL_RETURN(renderData);
910 VP_SAMPLER_STATE_DN_PARAM lumaParams = {};
911 VPHAL_DNUV_PARAMS chromaParams = {};
912
913 GetDnLumaParams(renderData->DN.bDnEnabled, renderData->DN.bAutoDetect, fDenoiseFactor, m_PacketCaps.bRefValid, &lumaParams);
914 GetDnChromaParams(renderData->DN.bChromaDnEnabled, renderData->DN.bAutoDetect, fDenoiseFactor, &chromaParams);
915
916 // Setup Denoise Params
917 ConfigLumaPixRange(renderData->DN.bDnEnabled, renderData->DN.bAutoDetect, fDenoiseFactor);
918 ConfigChromaPixRange(renderData->DN.bChromaDnEnabled, renderData->DN.bAutoDetect, fDenoiseFactor);
919 ConfigDnLumaChromaParams(renderData->DN.bDnEnabled, renderData->DN.bChromaDnEnabled, &lumaParams, &chromaParams);
920 return MOS_STATUS_SUCCESS;
921 }
922
923 //!
924 //! \brief Vebox Populate VEBOX parameters
925 //! \details Populate the Vebox VEBOX state parameters to VEBOX RenderData
926 //! \param [in] bDnEnabled
927 //! true if DN being enabled
928 //! \param [in] pChromaParams
929 //! true to Chroma DN being enabled
930 //! \param [in] pLumaParams
931 //! Pointer to Luma DN and DI parameter
932 //! \param [in] pChromaParams
933 //! Pointer to Chroma DN parameter
934 //! \return MOS_STATUS
935 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
936 //!
ConfigDnLumaChromaParams(bool bDnEnabled,bool bChromaDenoise,PVP_SAMPLER_STATE_DN_PARAM pLumaParams,PVPHAL_DNUV_PARAMS pChromaParams)937 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigDnLumaChromaParams(
938 bool bDnEnabled,
939 bool bChromaDenoise,
940 PVP_SAMPLER_STATE_DN_PARAM pLumaParams,
941 PVPHAL_DNUV_PARAMS pChromaParams
942 )
943 {
944 VP_FUNC_CALL();
945
946 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
947
948 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
949
950 MHW_VEBOX_DNDI_PARAMS &veboxDNDIParams = pRenderData->GetDNDIParams();
951
952 // Luma Denoise Params
953 if (bDnEnabled && pLumaParams)
954 {
955 veboxDNDIParams.dwDenoiseASDThreshold = pLumaParams->dwDenoiseASDThreshold;
956 veboxDNDIParams.dwDenoiseHistoryDelta = pLumaParams->dwDenoiseHistoryDelta;
957 veboxDNDIParams.dwDenoiseMaximumHistory = pLumaParams->dwDenoiseMaximumHistory;
958 veboxDNDIParams.dwDenoiseSTADThreshold = pLumaParams->dwDenoiseSTADThreshold;
959 veboxDNDIParams.dwDenoiseSCMThreshold = pLumaParams->dwDenoiseSCMThreshold;
960 veboxDNDIParams.dwDenoiseMPThreshold = pLumaParams->dwDenoiseMPThreshold;
961 veboxDNDIParams.dwLTDThreshold = pLumaParams->dwLTDThreshold;
962 veboxDNDIParams.dwTDThreshold = pLumaParams->dwTDThreshold;
963 veboxDNDIParams.dwGoodNeighborThreshold = pLumaParams->dwGoodNeighborThreshold;
964 }
965
966 // Chroma Denoise Params
967 if (bChromaDenoise && pChromaParams)
968 {
969 veboxDNDIParams.dwChromaSTADThreshold = pChromaParams->dwSTADThresholdU; // Use U threshold for now
970 veboxDNDIParams.dwChromaLTDThreshold = pChromaParams->dwLTDThresholdU; // Use U threshold for now
971 veboxDNDIParams.dwChromaTDThreshold = pChromaParams->dwTDThresholdU; // Use U threshold for now
972 }
973
974 return MOS_STATUS_SUCCESS;
975 }
976
977 //!
978 //! \brief Configure FMD parameter
979 //! \details Configure FMD parameters for DNDI State
980 //! \param [in] bProgressive
981 //! true if sample being progressive
982 //! \param [in] bAutoDenoise
983 //! true if auto denoise being enabled
984 //! \param [out] pLumaParams
985 //! Pointer to DNDI Param for set FMD parameters
986 //! \return MOS_STATUS
987 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
988 //!
ConfigFMDParams(bool bProgressive,bool bAutoDenoise,bool bFmdEnabled)989 MOS_STATUS VpVeboxCmdPacketLegacy::ConfigFMDParams(bool bProgressive, bool bAutoDenoise, bool bFmdEnabled)
990 {
991 VP_FUNC_CALL();
992
993 return MOS_STATUS_SUCCESS;
994 }
995
SetDnParams(PVEBOX_DN_PARAMS pDnParams)996 MOS_STATUS VpVeboxCmdPacketLegacy::SetDnParams(
997 PVEBOX_DN_PARAMS pDnParams)
998 {
999 VP_FUNC_CALL();
1000
1001 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1002 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1003
1004 VP_PUBLIC_CHK_NULL_RETURN(pDnParams);
1005 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
1006 VP_PUBLIC_CHK_NULL_RETURN(m_report);
1007
1008 pRenderData->DN.bDnEnabled = pDnParams->bDnEnabled;
1009 pRenderData->DN.bAutoDetect = pDnParams->bAutoDetect;
1010 pRenderData->DN.bChromaDnEnabled = pDnParams->bChromaDenoise;
1011 pRenderData->DN.bHvsDnEnabled = pDnParams->bEnableHVSDenoise;
1012
1013 pRenderData->GetDNDIParams().bChromaDNEnable = pDnParams->bChromaDenoise;
1014 pRenderData->GetDNDIParams().bProgressiveDN = pDnParams->bDnEnabled && pDnParams->bProgressive;
1015 pRenderData->GetHVSParams().QP = pDnParams->HVSDenoise.QP;
1016 pRenderData->GetHVSParams().Mode = pDnParams->HVSDenoise.Mode;
1017 pRenderData->GetHVSParams().Strength = pDnParams->HVSDenoise.Strength;
1018
1019 // ConfigureDenoiseParams() just includes logic that both used in SetDenoiseParams and UpdateDenoiseParams.
1020 // If the logic won't be used in UpdateDenoiseParams, please just add the logic into SetDenoiseParams.
1021 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureDenoiseParams(pRenderData, pDnParams->fDenoiseFactor));
1022 // bDNDITopFirst in DNDI parameters need be configured during SetDIParams.
1023
1024 m_report->GetFeatures().denoise = pRenderData->DN.bDnEnabled;
1025 return eStatus;
1026 }
1027
SetSteParams(PVEBOX_STE_PARAMS pSteParams)1028 MOS_STATUS VpVeboxCmdPacketLegacy::SetSteParams(
1029 PVEBOX_STE_PARAMS pSteParams)
1030 {
1031 VP_FUNC_CALL();
1032
1033 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1034 VP_PUBLIC_CHK_NULL_RETURN(pSteParams);
1035 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
1036
1037 // ConfigureSteParams() just includes logic that both used in SetSteParams and UpdateSteParams.
1038 // If the logic won't be used in UpdateSteParams, please just add the logic into SetSteParams.
1039
1040 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureSteParams(pRenderData, pSteParams->bEnableSTE, pSteParams->dwSTEFactor, pSteParams->bEnableSTD, pSteParams->STDParam.paraSizeInBytes, pSteParams->STDParam.param));
1041
1042 return MOS_STATUS_SUCCESS;
1043 }
1044
SetTccParams(PVEBOX_TCC_PARAMS pTccParams)1045 MOS_STATUS VpVeboxCmdPacketLegacy::SetTccParams(
1046 PVEBOX_TCC_PARAMS pTccParams)
1047 {
1048 VP_FUNC_CALL();
1049
1050 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1051 VP_PUBLIC_CHK_NULL_RETURN(pTccParams);
1052 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
1053
1054 // ConfigureTccParams() just includes logic that both used in SetTccParams and UpdateTccParams.
1055 // If the logic won't be used in UpdateTccParams, please just add the logic into SetTccParams.
1056 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureTccParams(pRenderData, pTccParams->bEnableTCC, pTccParams->Magenta,
1057 pTccParams->Red, pTccParams->Yellow, pTccParams->Green, pTccParams->Cyan, pTccParams->Blue));
1058 return MOS_STATUS_SUCCESS;
1059 }
1060
SetProcampParams(PVEBOX_PROCAMP_PARAMS pProcampParams)1061 MOS_STATUS VpVeboxCmdPacketLegacy::SetProcampParams(
1062 PVEBOX_PROCAMP_PARAMS pProcampParams)
1063 {
1064 VP_FUNC_CALL();
1065
1066 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1067 VP_PUBLIC_CHK_NULL_RETURN(pProcampParams);
1068 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
1069
1070 // ConfigureProcampParams() just includes logic that both used in SetProcampParams and UpdateProcampParams.
1071 // If the logic won't be used in UpdateProcampParams, please just add the logic into SetProcampParams.
1072 VP_PUBLIC_CHK_STATUS_RETURN(ConfigureProcampParams(pRenderData, pProcampParams->bEnableProcamp, pProcampParams->fBrightness,
1073 pProcampParams->fContrast, pProcampParams->fHue, pProcampParams->fSaturation));
1074
1075 return MOS_STATUS_SUCCESS;
1076 }
1077
SetCgcParams(PVEBOX_CGC_PARAMS cgcParams)1078 MOS_STATUS VpVeboxCmdPacketLegacy::SetCgcParams(
1079 PVEBOX_CGC_PARAMS cgcParams)
1080 {
1081 VP_FUNC_CALL();
1082
1083 VP_PUBLIC_CHK_NULL_RETURN(cgcParams);
1084
1085 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
1086 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
1087
1088 MHW_VEBOX_GAMUT_PARAMS& mhwVeboxGamutParams = pRenderData->GetGamutParams();
1089
1090 bool bAdvancedMode = (cgcParams->GCompMode == GAMUT_MODE_ADVANCED) ? true : false;
1091 bool bypassGComp = false;
1092
1093 if (cgcParams->bBt2020ToRGB)
1094 {
1095 // Init GC params
1096 pRenderData->IECP.CGC.bCGCEnabled = true;
1097 mhwVeboxGamutParams.ColorSpace = VpHalCspace2MhwCspace(cgcParams->inputColorSpace);
1098 mhwVeboxGamutParams.dstColorSpace = MHW_CSpace_sRGB; // GC output color space is sRGB for format ARGB8
1099 mhwVeboxGamutParams.srcFormat = cgcParams->inputFormat;
1100 mhwVeboxGamutParams.dstFormat = cgcParams->outputFormat;
1101 mhwVeboxGamutParams.GCompMode = MHW_GAMUT_MODE_NONE;
1102 mhwVeboxGamutParams.GExpMode = MHW_GAMUT_MODE_NONE;
1103 mhwVeboxGamutParams.bGammaCorr = false;
1104 }
1105 else
1106 {
1107 if (cgcParams->bEnableCGC && cgcParams->GCompMode != GAMUT_MODE_NONE)
1108 {
1109 VP_RENDER_ASSERTMESSAGE("Bypass GamutComp.");
1110 }
1111 pRenderData->IECP.CGC.bCGCEnabled = false;
1112 mhwVeboxGamutParams.GCompMode = MHW_GAMUT_MODE_NONE;
1113 }
1114
1115 return MOS_STATUS_SUCCESS;
1116 }
1117
ValidateHDR3DLutParameters(bool is3DLutTableFilled)1118 MOS_STATUS VpVeboxCmdPacketLegacy::ValidateHDR3DLutParameters(bool is3DLutTableFilled)
1119 {
1120 VP_FUNC_CALL();
1121 if (!is3DLutTableFilled)
1122 {
1123 // 3DLut need be calculated and filled by 3DLut kernel.
1124 VP_RENDER_ASSERTMESSAGE("3DLut is not filled!");
1125 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1126 }
1127 return MOS_STATUS_SUCCESS;
1128 }
1129
SetHdrParams(PVEBOX_HDR_PARAMS hdrParams)1130 MOS_STATUS VpVeboxCmdPacketLegacy::SetHdrParams(PVEBOX_HDR_PARAMS hdrParams)
1131 {
1132 VP_FUNC_CALL();
1133 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1134 PMOS_INTERFACE pOsInterface = nullptr;
1135 PMHW_3DLUT_PARAMS pLutParams = nullptr;
1136
1137 VP_PUBLIC_CHK_NULL_RETURN(m_hwInterface);
1138 VP_PUBLIC_CHK_NULL_RETURN(m_hwInterface->m_osInterface);
1139 VP_PUBLIC_CHK_NULL_RETURN(hdrParams);
1140 VP_RENDER_ASSERT(pRenderData);
1141 MHW_VEBOX_IECP_PARAMS &mhwVeboxIecpParams = pRenderData->GetIECPParams();
1142 MHW_VEBOX_GAMUT_PARAMS &mhwVeboxGamutParams = pRenderData->GetGamutParams();
1143 pOsInterface = m_hwInterface->m_osInterface;
1144 pRenderData->HDR3DLUT.bHdr3DLut = true;
1145
1146 pRenderData->HDR3DLUT.is3DLutTableFilled = HDR_STAGE::HDR_STAGE_VEBOX_3DLUT_UPDATE == hdrParams->stage ||
1147 HDR_STAGE::HDR_STAGE_VEBOX_3DLUT_NO_UPDATE == hdrParams->stage;
1148 pRenderData->HDR3DLUT.is3DLutTableUpdatedByKernel = HDR_STAGE::HDR_STAGE_VEBOX_3DLUT_UPDATE == hdrParams->stage;
1149 pRenderData->HDR3DLUT.isExternal3DLutTable = HDR_STAGE::HDR_STAGE_VEBOX_EXTERNAL_3DLUT == hdrParams->stage;
1150 pRenderData->HDR3DLUT.uiMaxDisplayLum = hdrParams->uiMaxDisplayLum;
1151 pRenderData->HDR3DLUT.uiMaxContentLevelLum = hdrParams->uiMaxContentLevelLum;
1152 pRenderData->HDR3DLUT.hdrMode = hdrParams->hdrMode;
1153
1154 if (!(hdrParams->stage == HDR_STAGE_VEBOX_EXTERNAL_3DLUT))
1155 {
1156 VP_RENDER_CHK_STATUS_RETURN(ValidateHDR3DLutParameters(pRenderData->HDR3DLUT.is3DLutTableFilled));
1157 }
1158
1159 // Use Gamut
1160 mhwVeboxGamutParams.ColorSpace = VpHalCspace2MhwCspace(hdrParams->srcColorSpace);
1161 mhwVeboxGamutParams.dstColorSpace = VpHalCspace2MhwCspace(hdrParams->dstColorSpace);
1162 mhwVeboxGamutParams.dstFormat = hdrParams->dstFormat;
1163 mhwVeboxGamutParams.bGammaCorr = true;
1164 mhwVeboxGamutParams.InputGammaValue = (MHW_GAMMA_VALUE)GAMMA_1P0;
1165 mhwVeboxGamutParams.OutputGammaValue = (MHW_GAMMA_VALUE)GAMMA_1P0;
1166 if (pRenderData->HDR3DLUT.hdrMode == VPHAL_HDR_MODE_TONE_MAPPING)
1167 {
1168 mhwVeboxGamutParams.bH2S = true;
1169 mhwVeboxGamutParams.uiMaxCLL = (uint16_t)pRenderData->HDR3DLUT.uiMaxContentLevelLum;
1170 }
1171 else if (pRenderData->HDR3DLUT.hdrMode == VPHAL_HDR_MODE_H2H)
1172 {
1173 mhwVeboxGamutParams.bH2S = false;
1174 mhwVeboxGamutParams.uiMaxCLL = 0;
1175 }
1176
1177 if (hdrParams->stage == HDR_STAGE_VEBOX_EXTERNAL_3DLUT)
1178 {
1179 if (hdrParams->external3DLutParams)
1180 {
1181 mhwVeboxIecpParams.s3DLutParams.LUTSize = hdrParams->external3DLutParams->LutSize;
1182 pRenderData->HDR3DLUT.external3DLutSurfResource = hdrParams->external3DLutParams->pExt3DLutSurface->OsResource;
1183 }
1184 else
1185 {
1186 VP_RENDER_ASSERTMESSAGE("hdrParams external3DLutParams is null.");
1187 }
1188 }
1189 //Report
1190 if (m_hwInterface->m_reporting)
1191 {
1192 m_hwInterface->m_reporting->GetFeatures().hdrMode = (pRenderData->HDR3DLUT.hdrMode == VPHAL_HDR_MODE_H2H) ? VPHAL_HDR_MODE_H2H_VEBOX_3DLUT : VPHAL_HDR_MODE_TONE_MAPPING_VEBOX_3DLUT;
1193 }
1194
1195 return MOS_STATUS_SUCCESS;
1196 }
1197
IsTopField(VPHAL_SAMPLE_TYPE sampleType)1198 bool VpVeboxCmdPacketLegacy::IsTopField(VPHAL_SAMPLE_TYPE sampleType)
1199 {
1200 return sampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD ||
1201 sampleType == SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD;
1202 }
1203
IsTopFieldFirst(VPHAL_SAMPLE_TYPE sampleType)1204 bool VpVeboxCmdPacketLegacy::IsTopFieldFirst(VPHAL_SAMPLE_TYPE sampleType)
1205 {
1206 return m_DNDIFirstFrame ?
1207 IsTopField(sampleType) : // For no reference case, just do DI for current field.
1208 (sampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD ||
1209 sampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD);
1210 }
1211
SetDiParams(PVEBOX_DI_PARAMS diParams)1212 MOS_STATUS VpVeboxCmdPacketLegacy::SetDiParams(PVEBOX_DI_PARAMS diParams)
1213 {
1214 VP_FUNC_CALL();
1215
1216 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1217 VpVeboxRenderData *renderData = GetLastExecRenderData();
1218 VP_SAMPLER_STATE_DN_PARAM lumaParams = {};
1219 VPHAL_DNUV_PARAMS chromaParams = {};
1220
1221 VP_PUBLIC_CHK_NULL_RETURN(diParams);
1222 VP_PUBLIC_CHK_NULL_RETURN(renderData);
1223
1224 renderData->DI.value = 0;
1225 renderData->DI.bDeinterlace = diParams->bDiEnabled;
1226 renderData->DI.bQueryVariance = diParams->bEnableQueryVariance;
1227 renderData->DI.bTFF = IsTopFieldFirst(diParams->sampleTypeInput);
1228 renderData->DI.bFmdEnabled = diParams->enableFMD;
1229
1230 // for 30i->30fps + SFC
1231 if (m_PacketCaps.bSFC && !diParams->b60fpsDi)
1232 {
1233 // Set BLT1's Current DI Output as BLT2's input, it is always under Mode0
1234 // BLT1 output 1st field of current frame for the following cases:
1235 if (m_DNDIFirstFrame ||
1236 (diParams->sampleTypeInput == SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD) ||
1237 (diParams->sampleTypeInput == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
1238 (diParams->sampleTypeInput == SAMPLE_SINGLE_TOP_FIELD) ||
1239 (diParams->sampleTypeInput == SAMPLE_PROGRESSIVE))
1240 {
1241 m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_CURRENT;
1242 }
1243 else
1244 {
1245 // First sample output - 2nd field of the previous frame
1246 m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_PREVIOUS;
1247 }
1248 }
1249 // for 30i->60fps or other 30i->30fps cases
1250 else
1251 {
1252 m_DIOutputFrames = m_DNDIFirstFrame ?
1253 MEDIA_VEBOX_DI_OUTPUT_CURRENT :
1254 MEDIA_VEBOX_DI_OUTPUT_BOTH;
1255 }
1256
1257 VP_PUBLIC_CHK_STATUS_RETURN(SetDiParams(diParams->bDiEnabled, diParams->bSCDEnabled, diParams->bHDContent, diParams->sampleTypeInput, renderData->GetDNDIParams()));
1258
1259 return eStatus;
1260 }
1261
SetDiParams(bool bDiEnabled,bool bSCDEnabled,bool bHDContent,VPHAL_SAMPLE_TYPE sampleTypeInput,MHW_VEBOX_DNDI_PARAMS & param)1262 MOS_STATUS VpVeboxCmdPacketLegacy::SetDiParams(bool bDiEnabled, bool bSCDEnabled, bool bHDContent, VPHAL_SAMPLE_TYPE sampleTypeInput, MHW_VEBOX_DNDI_PARAMS ¶m)
1263 {
1264 VP_FUNC_CALL();
1265
1266 if (!bDiEnabled)
1267 {
1268 return MOS_STATUS_SUCCESS;
1269 }
1270
1271 param.bDNDITopFirst = IsTopFieldFirst(sampleTypeInput);
1272 param.dwLumaTDMWeight = VPHAL_VEBOX_DI_LUMA_TDM_WEIGHT_NATUAL;
1273 param.dwChromaTDMWeight = VPHAL_VEBOX_DI_CHROMA_TDM_WEIGHT_NATUAL;
1274 param.dwSHCMDelta = VPHAL_VEBOX_DI_SHCM_DELTA_NATUAL;
1275 param.dwSHCMThreshold = VPHAL_VEBOX_DI_SHCM_THRESHOLD_NATUAL;
1276 param.dwSVCMDelta = VPHAL_VEBOX_DI_SVCM_DELTA_NATUAL;
1277 param.dwSVCMThreshold = VPHAL_VEBOX_DI_SVCM_THRESHOLD_NATUAL;
1278 param.bFasterConvergence = false;
1279 param.bTDMLumaSmallerWindow = false;
1280 param.bTDMChromaSmallerWindow = false;
1281 param.dwLumaTDMCoringThreshold = VPHAL_VEBOX_DI_LUMA_TDM_CORING_THRESHOLD_NATUAL;
1282 param.dwChromaTDMCoringThreshold = VPHAL_VEBOX_DI_CHROMA_TDM_CORING_THRESHOLD_NATUAL;
1283 param.bBypassDeflickerFilter = true;
1284 param.bUseSyntheticContentMedian = false;
1285 param.bLocalCheck = true;
1286 param.bSyntheticContentCheck = false;
1287 param.dwDirectionCheckThreshold = VPHAL_VEBOX_DI_DIRECTION_CHECK_THRESHOLD_NATUAL;
1288 param.dwTearingLowThreshold = VPHAL_VEBOX_DI_TEARING_LOW_THRESHOLD_NATUAL;
1289 param.dwTearingHighThreshold = VPHAL_VEBOX_DI_TEARING_HIGH_THRESHOLD_NATUAL;
1290 param.dwDiffCheckSlackThreshold = VPHAL_VEBOX_DI_DIFF_CHECK_SLACK_THRESHOLD_NATUAL;
1291 param.dwSADWT0 = VPHAL_VEBOX_DI_SAD_WT0_NATUAL;
1292 param.dwSADWT1 = VPHAL_VEBOX_DI_SAD_WT1_NATUAL;
1293 param.dwSADWT2 = VPHAL_VEBOX_DI_SAD_WT2_NATUAL;
1294 param.dwSADWT3 = VPHAL_VEBOX_DI_SAD_WT3_NATUAL;
1295 param.dwSADWT4 = VPHAL_VEBOX_DI_SAD_WT4_NATUAL;
1296 param.dwSADWT6 = VPHAL_VEBOX_DI_SAD_WT6_NATUAL;
1297 param.bSCDEnable = bSCDEnabled;
1298
1299 if (bHDContent)
1300 {
1301 param.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_HD_NATUAL;
1302 param.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_HD_NATUAL;
1303 param.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_HD_NATUAL;
1304 param.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_HD_NATUAL;
1305 param.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_HD_NATUAL;
1306 param.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_HD_NATUAL;
1307 param.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_HD_NATUAL;
1308 param.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_HD_NATUAL;
1309 }
1310 else
1311 {
1312 param.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_SD_NATUAL;
1313 param.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_SD_NATUAL;
1314 param.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_SD_NATUAL;
1315 param.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_SD_NATUAL;
1316 param.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_SD_NATUAL;
1317 param.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_SD_NATUAL;
1318 param.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_SD_NATUAL;
1319 param.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_SD_NATUAL;
1320 }
1321
1322 return MOS_STATUS_SUCCESS;
1323 }
1324
SetVeboxSurfaceControlBits(PMHW_VEBOX_INTERFACE pVeboxInterface,MHW_VEBOX_SURFACE_CNTL_PARAMS * pVeboxSurfCntlParams,uint32_t * pSurfCtrlBits)1325 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxSurfaceControlBits(
1326 PMHW_VEBOX_INTERFACE pVeboxInterface,
1327 MHW_VEBOX_SURFACE_CNTL_PARAMS *pVeboxSurfCntlParams,
1328 uint32_t *pSurfCtrlBits)
1329 {
1330 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1331
1332 if (m_veboxItf)
1333 {
1334 VP_RENDER_CHK_STATUS_RETURN(m_veboxItf->SetVeboxSurfaceControlBits(
1335 pVeboxSurfCntlParams,
1336 pSurfCtrlBits));
1337 }
1338 else
1339 {
1340 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxSurfaceControlBits(
1341 pVeboxSurfCntlParams,
1342 pSurfCtrlBits));
1343 }
1344
1345 return MOS_STATUS_SUCCESS;
1346 }
1347
SetupDiIecpState(bool bDiScdEnable,PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)1348 MOS_STATUS VpVeboxCmdPacketLegacy::SetupDiIecpState(
1349 bool bDiScdEnable,
1350 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
1351 {
1352 VP_FUNC_CALL();
1353
1354 uint32_t dwWidth = 0;
1355 uint32_t dwHeight = 0;
1356 MHW_VEBOX_SURFACE_PARAMS MhwVeboxSurfaceParam = {};
1357 PMHW_VEBOX_INTERFACE pVeboxInterface = nullptr;
1358 MHW_VEBOX_SURFACE_CNTL_PARAMS VeboxSurfCntlParams = {};
1359 PVP_SURFACE pSurface = nullptr;
1360 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1361
1362 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
1363 pVeboxInterface = m_hwInterface->m_veboxInterface;
1364
1365 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1366 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrInput);
1367 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrInput->osSurface);
1368 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput);
1369 VP_RENDER_CHK_NULL_RETURN(m_surfMemCacheCtl);
1370
1371 MOS_ZeroMemory(pVeboxDiIecpCmdParams, sizeof(*pVeboxDiIecpCmdParams));
1372
1373 // Align dwEndingX with surface state
1374 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
1375 m_veboxPacketSurface.pCurrInput, &MhwVeboxSurfaceParam));
1376 if(m_veboxItf)
1377 {
1378 VP_RENDER_CHK_STATUS_RETURN(m_veboxItf->VeboxAdjustBoundary(
1379 &MhwVeboxSurfaceParam,
1380 &dwWidth,
1381 &dwHeight,
1382 m_PacketCaps.bDI));
1383 }
1384 else
1385 {
1386 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->VeboxAdjustBoundary(
1387 &MhwVeboxSurfaceParam,
1388 &dwWidth,
1389 &dwHeight,
1390 m_PacketCaps.bDI));
1391 }
1392
1393 pVeboxDiIecpCmdParams->dwStartingX = 0;
1394 pVeboxDiIecpCmdParams->dwEndingX = dwWidth-1;
1395
1396 pVeboxDiIecpCmdParams->pOsResCurrInput = &m_veboxPacketSurface.pCurrInput->osSurface->OsResource;
1397 pVeboxDiIecpCmdParams->dwCurrInputSurfOffset = m_veboxPacketSurface.pCurrInput->osSurface->dwOffset;
1398 pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.CurrentInputSurfMemObjCtl;
1399
1400 // Update control bits for current surface
1401 if (m_mmc->IsMmcEnabled())
1402 {
1403 pSurface = m_veboxPacketSurface.pCurrInput;
1404 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1405 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1406 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1407 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1408 pVeboxInterface,
1409 &VeboxSurfCntlParams,
1410 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value)));
1411 }
1412
1413 // Reference surface
1414 if (m_veboxPacketSurface.pPrevInput)
1415 {
1416 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pPrevInput->osSurface);
1417 pVeboxDiIecpCmdParams->pOsResPrevInput = &m_veboxPacketSurface.pPrevInput->osSurface->OsResource;
1418 pVeboxDiIecpCmdParams->dwPrevInputSurfOffset = m_veboxPacketSurface.pPrevInput->osSurface->dwOffset;
1419 pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.PreviousInputSurfMemObjCtl;
1420
1421 // Update control bits for PastSurface surface
1422 if (m_mmc->IsMmcEnabled())
1423 {
1424 pSurface = m_veboxPacketSurface.pPrevInput;
1425 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1426 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1427 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1428 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1429 pVeboxInterface,
1430 &VeboxSurfCntlParams,
1431 (uint32_t *)&(pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value)));
1432 }
1433 }
1434
1435 // VEBOX final output surface
1436 if (m_veboxPacketSurface.pCurrOutput)
1437 {
1438 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrOutput->osSurface);
1439 pVeboxDiIecpCmdParams->pOsResCurrOutput = &m_veboxPacketSurface.pCurrOutput->osSurface->OsResource;
1440 pVeboxDiIecpCmdParams->dwCurrOutputSurfOffset = m_veboxPacketSurface.pCurrOutput->osSurface->dwOffset;
1441 pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.CurrentOutputSurfMemObjCtl;
1442
1443 // Update control bits for Current Output Surf
1444 if (m_mmc->IsMmcEnabled())
1445 {
1446 pSurface = m_veboxPacketSurface.pCurrOutput;
1447 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1448 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1449 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1450 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1451 pVeboxInterface,
1452 &VeboxSurfCntlParams,
1453 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value)));
1454 }
1455 }
1456
1457 if (m_veboxPacketSurface.pPrevOutput)
1458 {
1459 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pPrevOutput->osSurface);
1460 pVeboxDiIecpCmdParams->pOsResPrevOutput = &m_veboxPacketSurface.pPrevOutput->osSurface->OsResource;
1461 pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.CurrentOutputSurfMemObjCtl;
1462
1463 // Update control bits for PrevOutput surface
1464 if (m_mmc->IsMmcEnabled())
1465 {
1466 pSurface = m_veboxPacketSurface.pPrevOutput;
1467 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1468 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1469 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1470 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1471 pVeboxInterface,
1472 &VeboxSurfCntlParams,
1473 (uint32_t *)&(pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value)));
1474 }
1475 }
1476
1477 // DN intermediate output surface
1478 if (m_veboxPacketSurface.pDenoisedCurrOutput)
1479 {
1480 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pDenoisedCurrOutput->osSurface);
1481 pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput = &m_veboxPacketSurface.pDenoisedCurrOutput->osSurface->OsResource;
1482 pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.DnOutSurfMemObjCtl;
1483
1484 // Update control bits for DenoisedCurrOutputSurf surface
1485 if (m_mmc->IsMmcEnabled())
1486 {
1487 pSurface = m_veboxPacketSurface.pDenoisedCurrOutput;
1488 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1489 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1490 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1491 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1492 pVeboxInterface,
1493 &VeboxSurfCntlParams,
1494 (uint32_t *)&(pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value)));
1495 }
1496 }
1497
1498 // STMM surface
1499 if (m_veboxPacketSurface.pSTMMInput && m_veboxPacketSurface.pSTMMOutput)
1500 {
1501 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pSTMMInput->osSurface);
1502 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pSTMMOutput->osSurface);
1503
1504 // STMM in
1505 pVeboxDiIecpCmdParams->pOsResStmmInput = &m_veboxPacketSurface.pSTMMInput->osSurface->OsResource;
1506 pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.STMMInputSurfMemObjCtl;
1507
1508 // Update control bits for stmm input surface
1509 if (m_mmc->IsMmcEnabled())
1510 {
1511 pSurface = m_veboxPacketSurface.pSTMMInput;
1512 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1513 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1514 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1515 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1516 pVeboxInterface,
1517 &VeboxSurfCntlParams,
1518 (uint32_t *)&(pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value)));
1519 }
1520
1521 // STMM out
1522 pVeboxDiIecpCmdParams->pOsResStmmOutput = &m_veboxPacketSurface.pSTMMOutput->osSurface->OsResource;
1523 pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.STMMOutputSurfMemObjCtl;
1524
1525 // Update control bits for stmm output surface
1526 if (m_mmc->IsMmcEnabled())
1527 {
1528 pSurface = m_veboxPacketSurface.pSTMMOutput;
1529 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1530 VeboxSurfCntlParams.bIsCompressed = pSurface->osSurface->bIsCompressed;
1531 VeboxSurfCntlParams.CompressionMode = pSurface->osSurface->CompressionMode;
1532 VP_RENDER_CHK_STATUS(SetVeboxSurfaceControlBits(
1533 pVeboxInterface,
1534 &VeboxSurfCntlParams,
1535 (uint32_t *)&(pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value)));
1536 }
1537 }
1538
1539 pVeboxDiIecpCmdParams->pOsResStatisticsOutput = &m_veboxPacketSurface.pStatisticsOutput->osSurface->OsResource;
1540 pVeboxDiIecpCmdParams->StatisticsOutputSurfCtrl.Value = m_surfMemCacheCtl->DnDi.StatisticsOutputSurfMemObjCtl;
1541
1542 if (m_veboxPacketSurface.pLaceOrAceOrRgbHistogram->osSurface)
1543 {
1544 pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram =
1545 &m_veboxPacketSurface.pLaceOrAceOrRgbHistogram->osSurface->OsResource;
1546 pVeboxDiIecpCmdParams->LaceOrAceOrRgbHistogramSurfCtrl.Value =
1547 m_surfMemCacheCtl->DnDi.LaceOrAceOrRgbHistogramSurfCtrl;
1548 }
1549 #if (_DEBUG || _RELEASE_INTERNAL)
1550 if (m_hwInterface->m_renderHal)
1551 {
1552 m_hwInterface->m_renderHal->oldCacheSettingForTargetSurface = (uint8_t)((m_surfMemCacheCtl->DnDi.CurrentOutputSurfMemObjCtl >> 1) & 0x0000003f);
1553 }
1554 #endif
1555 finish:
1556 return eStatus;
1557 }
1558
UseKernelResource()1559 bool VpVeboxCmdPacketLegacy::UseKernelResource()
1560 {
1561 VP_FUNC_CALL();
1562
1563 return false;
1564 }
1565
InitVeboxSurfaceParams(PVP_SURFACE pVpHalVeboxSurface,PMHW_VEBOX_SURFACE_PARAMS pMhwVeboxSurface)1566 MOS_STATUS VpVeboxCmdPacketLegacy::InitVeboxSurfaceParams(
1567 PVP_SURFACE pVpHalVeboxSurface,
1568 PMHW_VEBOX_SURFACE_PARAMS pMhwVeboxSurface)
1569 {
1570 VP_FUNC_CALL();
1571
1572 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1573
1574 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurface);
1575 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurface->osSurface);
1576 VP_RENDER_CHK_NULL_RETURN(pMhwVeboxSurface);
1577
1578 MOS_ZeroMemory(pMhwVeboxSurface, sizeof(*pMhwVeboxSurface));
1579 pMhwVeboxSurface->bActive = true;
1580 pMhwVeboxSurface->Format = pVpHalVeboxSurface->osSurface->Format;
1581 pMhwVeboxSurface->dwWidth = pVpHalVeboxSurface->osSurface->dwWidth;
1582 pMhwVeboxSurface->dwHeight = pVpHalVeboxSurface->osSurface->dwHeight;
1583 pMhwVeboxSurface->dwPitch = pVpHalVeboxSurface->osSurface->dwPitch;
1584 pMhwVeboxSurface->dwBitDepth = pVpHalVeboxSurface->osSurface->dwDepth;
1585 pMhwVeboxSurface->TileType = pVpHalVeboxSurface->osSurface->TileType;
1586 pMhwVeboxSurface->TileModeGMM = pVpHalVeboxSurface->osSurface->TileModeGMM;
1587 pMhwVeboxSurface->bGMMTileEnabled = pVpHalVeboxSurface->osSurface->bGMMTileEnabled;
1588 if (pVpHalVeboxSurface->rcMaxSrc.top == pVpHalVeboxSurface->rcMaxSrc.bottom ||
1589 pVpHalVeboxSurface->rcMaxSrc.left == pVpHalVeboxSurface->rcMaxSrc.right)
1590 {
1591 // If rcMaxSrc is invalid, just use rcSrc.
1592 pMhwVeboxSurface->rcMaxSrc = pVpHalVeboxSurface->rcSrc;
1593 }
1594 else
1595 {
1596 pMhwVeboxSurface->rcMaxSrc = pVpHalVeboxSurface->rcMaxSrc;
1597 }
1598 pMhwVeboxSurface->rcSrc = pVpHalVeboxSurface->rcSrc;
1599 pMhwVeboxSurface->bVEBOXCroppingUsed = pVpHalVeboxSurface->bVEBOXCroppingUsed;
1600 pMhwVeboxSurface->pOsResource = &pVpHalVeboxSurface->osSurface->OsResource;
1601 pMhwVeboxSurface->bIsCompressed = pVpHalVeboxSurface->osSurface->bIsCompressed;
1602
1603 if (pVpHalVeboxSurface->osSurface->dwPitch > 0)
1604 {
1605 pMhwVeboxSurface->dwUYoffset = ((pVpHalVeboxSurface->osSurface->UPlaneOffset.iSurfaceOffset - pVpHalVeboxSurface->osSurface->YPlaneOffset.iSurfaceOffset) / pVpHalVeboxSurface->osSurface->dwPitch)
1606 + pVpHalVeboxSurface->osSurface->UPlaneOffset.iYOffset;
1607 }
1608 return eStatus;
1609 }
1610
SendVeboxCmd(MOS_COMMAND_BUFFER * commandBuffer)1611 MOS_STATUS VpVeboxCmdPacketLegacy::SendVeboxCmd(MOS_COMMAND_BUFFER* commandBuffer)
1612 {
1613 VP_FUNC_CALL();
1614
1615 MOS_STATUS eStatus;
1616 int32_t iRemaining;
1617 MHW_VEBOX_DI_IECP_CMD_PARAMS VeboxDiIecpCmdParams;
1618 VP_VEBOX_SURFACE_STATE_CMD_PARAMS VeboxSurfaceStateCmdParams;
1619 MHW_VEBOX_SURFACE_STATE_CMD_PARAMS MhwVeboxSurfaceStateCmdParams;
1620 MHW_VEBOX_STATE_CMD_PARAMS VeboxStateCmdParams;
1621 MHW_MI_FLUSH_DW_PARAMS FlushDwParams;
1622 PMHW_VEBOX_INTERFACE pVeboxInterface;
1623 RENDERHAL_GENERIC_PROLOG_PARAMS GenericPrologParams;
1624
1625 eStatus = MOS_STATUS_SUCCESS;
1626 pVeboxInterface = m_hwInterface->m_veboxInterface;
1627 iRemaining = 0;
1628
1629 VP_RENDER_CHK_NULL_RETURN(commandBuffer);
1630
1631 eStatus = PrepareVeboxCmd(
1632 commandBuffer,
1633 GenericPrologParams,
1634 iRemaining);
1635
1636 if (eStatus != MOS_STATUS_SUCCESS)
1637 {
1638 CmdErrorHanlde(commandBuffer, iRemaining);
1639 }
1640 else
1641 {
1642 eStatus = RenderVeboxCmd(
1643 commandBuffer,
1644 VeboxDiIecpCmdParams,
1645 VeboxSurfaceStateCmdParams,
1646 MhwVeboxSurfaceStateCmdParams,
1647 VeboxStateCmdParams,
1648 FlushDwParams,
1649 &GenericPrologParams);
1650 if (eStatus != MOS_STATUS_SUCCESS)
1651 {
1652 // Failed -> discard all changes in Command Buffer
1653 CmdErrorHanlde(commandBuffer, iRemaining);
1654 }
1655 }
1656
1657 return eStatus;
1658 }
1659
CmdErrorHanlde(MOS_COMMAND_BUFFER * CmdBuffer,int32_t & iRemaining)1660 void VpVeboxCmdPacketLegacy::CmdErrorHanlde(
1661 MOS_COMMAND_BUFFER *CmdBuffer,
1662 int32_t &iRemaining)
1663 {
1664 VP_FUNC_CALL();
1665
1666 int32_t i= 0;
1667
1668 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(CmdBuffer);
1669 // Buffer overflow - display overflow size
1670 if (CmdBuffer->iRemaining < 0)
1671 {
1672 VP_RENDER_ASSERTMESSAGE("Command Buffer overflow by %d bytes", CmdBuffer->iRemaining);
1673 }
1674
1675 // Move command buffer back to beginning
1676 i = iRemaining - CmdBuffer->iRemaining;
1677 CmdBuffer->iRemaining = iRemaining;
1678 CmdBuffer->iOffset -= i;
1679 CmdBuffer->pCmdPtr = CmdBuffer->pCmdBase + CmdBuffer->iOffset / sizeof(uint32_t);
1680 }
1681
PrepareVeboxCmd(MOS_COMMAND_BUFFER * CmdBuffer,RENDERHAL_GENERIC_PROLOG_PARAMS & GenericPrologParams,int32_t & iRemaining)1682 MOS_STATUS VpVeboxCmdPacketLegacy::PrepareVeboxCmd(
1683 MOS_COMMAND_BUFFER* CmdBuffer,
1684 RENDERHAL_GENERIC_PROLOG_PARAMS& GenericPrologParams,
1685 int32_t& iRemaining)
1686 {
1687 VP_FUNC_CALL();
1688
1689 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1690 PMOS_INTERFACE pOsInterface = m_hwInterface->m_osInterface;
1691 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
1692 PMOS_RESOURCE gpuStatusBuffer = nullptr;
1693
1694 VP_RENDER_CHK_NULL_RETURN(CmdBuffer);
1695 VP_RENDER_CHK_NULL_RETURN(pOsInterface);
1696 VP_RENDER_CHK_NULL_RETURN(m_currentSurface);
1697 VP_RENDER_CHK_NULL_RETURN(m_currentSurface->osSurface);
1698
1699 // Set initial state
1700 iRemaining = CmdBuffer->iRemaining;
1701
1702 //---------------------------
1703 // Set Performance Tags
1704 //---------------------------
1705 VP_RENDER_CHK_STATUS_RETURN(VeboxSetPerfTag());
1706 pOsInterface->pfnResetPerfBufferID(pOsInterface);
1707 pOsInterface->pfnSetPerfTag(pOsInterface, pRenderData->PerfTag);
1708
1709 MOS_ZeroMemory(&GenericPrologParams, sizeof(GenericPrologParams));
1710
1711 VP_RENDER_CHK_STATUS_RETURN(SetMediaFrameTracking(GenericPrologParams));
1712
1713 return eStatus;
1714 }
1715
setVeboxProCmd(PMHW_MI_INTERFACE pMhwMiInterface,PMHW_VEBOX_INTERFACE pVeboxInterface,MOS_COMMAND_BUFFER * CmdBuffer)1716 MOS_STATUS VpVeboxCmdPacketLegacy::setVeboxProCmd(
1717 PMHW_MI_INTERFACE pMhwMiInterface,
1718 PMHW_VEBOX_INTERFACE pVeboxInterface,
1719 MOS_COMMAND_BUFFER* CmdBuffer)
1720 {
1721 std::shared_ptr<mhw::mi::Itf> miItf = nullptr;
1722 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1723
1724 miItf = std::static_pointer_cast<mhw::mi::Itf>(pMhwMiInterface->GetNewMiInterface());
1725 if (miItf)
1726 {
1727 VP_RENDER_CHK_STATUS_RETURN(miItf->AddVeboxMMIOPrologCmd(CmdBuffer));
1728 }
1729 else
1730 {
1731 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->setVeboxPrologCmd(pMhwMiInterface, CmdBuffer));
1732 }
1733
1734 return MOS_STATUS_SUCCESS;
1735 }
1736
SetVeboxIndex(PMHW_VEBOX_INTERFACE pVeboxInterface,uint32_t dwVeboxIndex,uint32_t dwVeboxCount,uint32_t dwUsingSFC)1737 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxIndex(
1738 PMHW_VEBOX_INTERFACE pVeboxInterface,
1739 uint32_t dwVeboxIndex,
1740 uint32_t dwVeboxCount,
1741 uint32_t dwUsingSFC)
1742 {
1743 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1744
1745 if(m_veboxItf)
1746 {
1747 m_veboxItf->SetVeboxIndex(dwVeboxIndex, dwVeboxCount, dwUsingSFC);
1748 }
1749 else
1750 {
1751 pVeboxInterface->SetVeboxIndex(dwVeboxIndex, dwVeboxCount, dwUsingSFC);
1752 }
1753
1754 return MOS_STATUS_SUCCESS;
1755 }
1756
SetVeboxState(PMHW_VEBOX_INTERFACE pVeboxInterface,PMOS_COMMAND_BUFFER pCmdBufferInUse,PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams,bool bCmBuffer)1757 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxState(
1758 PMHW_VEBOX_INTERFACE pVeboxInterface,
1759 PMOS_COMMAND_BUFFER pCmdBufferInUse,
1760 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams,
1761 bool bCmBuffer)
1762
1763 {
1764 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1765 VP_RENDER_CHK_NULL_RETURN(pCmdBufferInUse);
1766
1767 if(m_veboxItf)
1768 {
1769 auto& par = m_veboxItf->MHW_GETPAR_F(VEBOX_STATE)();
1770
1771 par.VeboxMode.ColorGamutExpansionEnable = pVeboxStateCmdParams->VeboxMode.ColorGamutExpansionEnable;
1772 par.VeboxMode.ColorGamutCompressionEnable = pVeboxStateCmdParams->VeboxMode.ColorGamutCompressionEnable;
1773 par.VeboxMode.GlobalIECPEnable = pVeboxStateCmdParams->VeboxMode.GlobalIECPEnable;
1774 par.VeboxMode.DNEnable = pVeboxStateCmdParams->VeboxMode.DNEnable;
1775 par.VeboxMode.DIEnable = pVeboxStateCmdParams->VeboxMode.DIEnable;
1776 par.VeboxMode.DNDIFirstFrame = pVeboxStateCmdParams->VeboxMode.DNDIFirstFrame;
1777 par.VeboxMode.DIOutputFrames = pVeboxStateCmdParams->VeboxMode.DIOutputFrames;
1778 par.VeboxMode.PipeSynchronizeDisable = pVeboxStateCmdParams->VeboxMode.PipeSynchronizeDisable;
1779 par.VeboxMode.DemosaicEnable = pVeboxStateCmdParams->VeboxMode.DemosaicEnable;
1780 par.VeboxMode.VignetteEnable = pVeboxStateCmdParams->VeboxMode.VignetteEnable;
1781 par.VeboxMode.AlphaPlaneEnable = pVeboxStateCmdParams->VeboxMode.AlphaPlaneEnable;
1782 par.VeboxMode.HotPixelFilteringEnable = pVeboxStateCmdParams->VeboxMode.HotPixelFilteringEnable;
1783 par.VeboxMode.SingleSliceVeboxEnable = pVeboxStateCmdParams->VeboxMode.SingleSliceVeboxEnable;
1784 par.VeboxMode.LACECorrectionEnable = pVeboxStateCmdParams->VeboxMode.LACECorrectionEnable;
1785 par.VeboxMode.DisableEncoderStatistics = pVeboxStateCmdParams->VeboxMode.DisableEncoderStatistics;
1786 par.VeboxMode.DisableTemporalDenoiseFilter = pVeboxStateCmdParams->VeboxMode.DisableTemporalDenoiseFilter;
1787 par.VeboxMode.SinglePipeIECPEnable = pVeboxStateCmdParams->VeboxMode.SinglePipeIECPEnable;
1788 par.VeboxMode.SFCParallelWriteEnable = pVeboxStateCmdParams->VeboxMode.SFCParallelWriteEnable;
1789 par.VeboxMode.ScalarMode = pVeboxStateCmdParams->VeboxMode.ScalarMode;
1790 par.VeboxMode.ForwardGammaCorrectionEnable = pVeboxStateCmdParams->VeboxMode.ForwardGammaCorrectionEnable;
1791 par.VeboxMode.Hdr1DLutEnable = pVeboxStateCmdParams->VeboxMode.Hdr1DLutEnable;
1792 par.VeboxMode.Fp16ModeEnable = pVeboxStateCmdParams->VeboxMode.Fp16ModeEnable;
1793 par.VeboxMode.Hdr1K1DLut = pVeboxStateCmdParams->VeboxMode.Hdr1K1DLut;
1794
1795 par.ChromaSampling.ChromaUpsamplingCoSitedHorizontalOffset = pVeboxStateCmdParams->ChromaSampling.ChromaUpsamplingCoSitedHorizontalOffset;
1796 par.ChromaSampling.ChromaUpsamplingCoSitedVerticalOffset = pVeboxStateCmdParams->ChromaSampling.ChromaUpsamplingCoSitedVerticalOffset;
1797 par.ChromaSampling.ChromaDownsamplingCoSitedHorizontalOffset = pVeboxStateCmdParams->ChromaSampling.ChromaDownsamplingCoSitedHorizontalOffset;
1798 par.ChromaSampling.ChromaDownsamplingCoSitedVerticalOffset = pVeboxStateCmdParams->ChromaSampling.ChromaDownsamplingCoSitedVerticalOffset;
1799 par.ChromaSampling.BypassChromaUpsampling = pVeboxStateCmdParams->ChromaSampling.BypassChromaUpsampling;
1800 par.ChromaSampling.BypassChromaDownsampling = pVeboxStateCmdParams->ChromaSampling.BypassChromaDownsampling;
1801
1802 par.LUT3D.ArbitrationPriorityControl = pVeboxStateCmdParams->LUT3D.ArbitrationPriorityControl;
1803 par.LUT3D.Lut3dEnable = pVeboxStateCmdParams->LUT3D.Lut3dEnable;
1804 par.LUT3D.Lut3dSize = pVeboxStateCmdParams->LUT3D.Lut3dSize;
1805
1806 par.bUseVeboxHeapKernelResource = pVeboxStateCmdParams->bUseVeboxHeapKernelResource;
1807 par.pLaceLookUpTables = pVeboxStateCmdParams->pLaceLookUpTables;
1808 par.pVeboxParamSurf = pVeboxStateCmdParams->pVeboxParamSurf;
1809 par.pVebox3DLookUpTables = pVeboxStateCmdParams->pVebox3DLookUpTables;
1810 par.pVebox1DLookUpTables = pVeboxStateCmdParams->pVebox1DLookUpTables;
1811 par.DummyIecpResource = &pVeboxStateCmdParams->DummyIecpResource;
1812 par.LaceLookUpTablesSurfCtrl.Value = pVeboxStateCmdParams->LaceLookUpTablesSurfCtrl.Value;
1813 par.Vebox3DLookUpTablesSurfCtrl.Value = pVeboxStateCmdParams->Vebox3DLookUpTablesSurfCtrl.Value;
1814 par.bNoUseVeboxHeap = pVeboxStateCmdParams->bNoUseVeboxHeap;
1815 par.bCmBuffer = bCmBuffer;
1816
1817 m_veboxItf->MHW_ADDCMD_F(VEBOX_STATE)(pCmdBufferInUse, nullptr);
1818 }
1819 else
1820 {
1821 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxState(
1822 pCmdBufferInUse,
1823 pVeboxStateCmdParams,
1824 0));
1825 }
1826
1827 return MOS_STATUS_SUCCESS;
1828 }
1829
SetVeboxSurfaces(PMHW_VEBOX_INTERFACE pVeboxInterface,PMOS_COMMAND_BUFFER pCmdBufferInUse,PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pMhwVeboxSurfaceStateCmdParams)1830 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxSurfaces(
1831 PMHW_VEBOX_INTERFACE pVeboxInterface,
1832 PMOS_COMMAND_BUFFER pCmdBufferInUse,
1833 PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pMhwVeboxSurfaceStateCmdParams)
1834
1835 {
1836 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1837 VP_RENDER_CHK_NULL_RETURN(pCmdBufferInUse);
1838
1839 if(m_veboxItf)
1840 {
1841 VP_RENDER_CHK_STATUS_RETURN(m_veboxItf->AddVeboxSurfaces(pCmdBufferInUse, pMhwVeboxSurfaceStateCmdParams));
1842 }
1843 else
1844 {
1845 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxSurfaces(
1846 pCmdBufferInUse,
1847 pMhwVeboxSurfaceStateCmdParams));
1848 }
1849
1850 return MOS_STATUS_SUCCESS;
1851 }
1852
SetVeboxDiIecp(PMHW_VEBOX_INTERFACE pVeboxInterface,PMOS_COMMAND_BUFFER pCmdBufferInUse,PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)1853 MOS_STATUS VpVeboxCmdPacketLegacy::SetVeboxDiIecp(
1854 PMHW_VEBOX_INTERFACE pVeboxInterface,
1855 PMOS_COMMAND_BUFFER pCmdBufferInUse,
1856 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
1857
1858 {
1859 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
1860 VP_RENDER_CHK_NULL_RETURN(pCmdBufferInUse);
1861
1862 if(m_veboxItf)
1863 {
1864 auto& par = m_veboxItf->MHW_GETPAR_F(VEB_DI_IECP)();
1865 par = {};
1866 par.dwEndingX = pVeboxDiIecpCmdParams->dwEndingX;
1867 par.dwStartingX = pVeboxDiIecpCmdParams->dwStartingX;
1868 par.dwEndingY = pVeboxDiIecpCmdParams->dwEndingY;
1869 par.dwStartingY = pVeboxDiIecpCmdParams->dwStartingY;
1870 par.dwCurrInputSurfOffset = pVeboxDiIecpCmdParams->dwCurrInputSurfOffset;
1871 par.dwPrevInputSurfOffset = pVeboxDiIecpCmdParams->dwPrevInputSurfOffset;
1872 par.dwCurrOutputSurfOffset = pVeboxDiIecpCmdParams->dwCurrOutputSurfOffset;
1873 par.dwStreamID = pVeboxDiIecpCmdParams->dwStreamID;
1874 par.dwStreamIDOutput = pVeboxDiIecpCmdParams->dwStreamIDOutput;
1875 par.pOsResCurrInput = pVeboxDiIecpCmdParams->pOsResCurrInput;
1876 par.pOsResPrevInput = pVeboxDiIecpCmdParams->pOsResPrevInput;
1877 par.pOsResStmmInput = pVeboxDiIecpCmdParams->pOsResStmmInput;
1878 par.pOsResStmmOutput = pVeboxDiIecpCmdParams->pOsResStmmOutput;
1879 par.pOsResDenoisedCurrOutput = pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput;
1880 par.pOsResCurrOutput = pVeboxDiIecpCmdParams->pOsResCurrOutput;
1881 par.pOsResPrevOutput = pVeboxDiIecpCmdParams->pOsResPrevOutput;
1882 par.pOsResStatisticsOutput = pVeboxDiIecpCmdParams->pOsResStatisticsOutput;
1883 par.pOsResAlphaOrVignette = pVeboxDiIecpCmdParams->pOsResAlphaOrVignette;
1884 par.pOsResLaceOrAceOrRgbHistogram = pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram;
1885 par.pOsResSkinScoreSurface = pVeboxDiIecpCmdParams->pOsResSkinScoreSurface;
1886 par.CurrInputSurfCtrl.Value = pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value;
1887 par.PrevInputSurfCtrl.Value = pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value;
1888 par.StmmInputSurfCtrl.Value = pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value;
1889 par.StmmOutputSurfCtrl.Value = pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value;
1890 par.DenoisedCurrOutputSurfCtrl.Value = pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value;
1891 par.CurrOutputSurfCtrl.Value = pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value;
1892 par.PrevOutputSurfCtrl.Value = pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value;
1893 par.StatisticsOutputSurfCtrl.Value = pVeboxDiIecpCmdParams->StatisticsOutputSurfCtrl.Value;
1894 par.AlphaOrVignetteSurfCtrl.Value = pVeboxDiIecpCmdParams->AlphaOrVignetteSurfCtrl.Value;
1895 par.LaceOrAceOrRgbHistogramSurfCtrl.Value = pVeboxDiIecpCmdParams->LaceOrAceOrRgbHistogramSurfCtrl.Value;
1896 par.SkinScoreSurfaceSurfCtrl.Value = pVeboxDiIecpCmdParams->SkinScoreSurfaceSurfCtrl.Value;
1897 par.CurInputSurfMMCState = pVeboxDiIecpCmdParams->CurInputSurfMMCState;
1898
1899 m_veboxItf->MHW_ADDCMD_F(VEB_DI_IECP)(pCmdBufferInUse, nullptr);
1900 }
1901 else
1902 {
1903 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxDiIecp(
1904 pCmdBufferInUse,
1905 pVeboxDiIecpCmdParams));
1906 }
1907
1908 return MOS_STATUS_SUCCESS;
1909 }
1910
RenderVeboxCmd(MOS_COMMAND_BUFFER * CmdBuffer,MHW_VEBOX_DI_IECP_CMD_PARAMS & VeboxDiIecpCmdParams,VP_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)1911 MOS_STATUS VpVeboxCmdPacketLegacy::RenderVeboxCmd(
1912 MOS_COMMAND_BUFFER *CmdBuffer,
1913 MHW_VEBOX_DI_IECP_CMD_PARAMS &VeboxDiIecpCmdParams,
1914 VP_VEBOX_SURFACE_STATE_CMD_PARAMS &VeboxSurfaceStateCmdParams,
1915 MHW_VEBOX_SURFACE_STATE_CMD_PARAMS &MhwVeboxSurfaceStateCmdParams,
1916 MHW_VEBOX_STATE_CMD_PARAMS &VeboxStateCmdParams,
1917 MHW_MI_FLUSH_DW_PARAMS &FlushDwParams,
1918 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
1919 {
1920 VP_FUNC_CALL();
1921
1922 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1923 PRENDERHAL_INTERFACE pRenderHal;
1924 PMOS_INTERFACE pOsInterface;
1925 PMHW_MI_INTERFACE pMhwMiInterface;
1926 PMHW_VEBOX_INTERFACE pVeboxInterface;
1927 bool bDiVarianceEnable;
1928 const MHW_VEBOX_HEAP *pVeboxHeap = nullptr;
1929 VpVeboxRenderData * pRenderData = GetLastExecRenderData();
1930 MOS_CONTEXT * pOsContext = nullptr;
1931 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
1932 MOS_COMMAND_BUFFER CmdBufferInUse;
1933 PMOS_COMMAND_BUFFER pCmdBufferInUse = nullptr;
1934 uint32_t curPipe = 0;
1935 uint8_t inputPipe = 0;
1936 uint32_t numPipe = 1;
1937 bool bMultipipe = false;
1938
1939 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
1940 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_renderHal);
1941 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_renderHal->pRenderHalPltInterface);
1942 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_mhwMiInterface);
1943 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_osInterface);
1944 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_veboxInterface);
1945 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_osInterface->pOsContext);
1946 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_mhwMiInterface->GetMmioRegisters());
1947 VP_RENDER_CHK_NULL_RETURN(pRenderData);
1948 VP_RENDER_CHK_NULL_RETURN(CmdBuffer);
1949
1950 pRenderHal = m_hwInterface->m_renderHal;
1951 pMhwMiInterface = m_hwInterface->m_mhwMiInterface;
1952 pOsInterface = m_hwInterface->m_osInterface;
1953 pVeboxInterface = m_hwInterface->m_veboxInterface;
1954 pOsContext = m_hwInterface->m_osInterface->pOsContext;
1955 pMmioRegisters = pMhwMiInterface->GetMmioRegisters();
1956 pCmdBufferInUse = CmdBuffer;
1957
1958 auto scalability = GetMediaScalability();
1959 m_veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
1960
1961 if(m_veboxItf)
1962 {
1963 VP_RENDER_CHK_STATUS_RETURN(m_veboxItf->GetVeboxHeapInfo(&pVeboxHeap));
1964 }
1965 else
1966 {
1967 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->GetVeboxHeapInfo(&pVeboxHeap));
1968 }
1969 VP_RENDER_CHK_NULL_RETURN(pVeboxHeap);
1970
1971 #ifdef _MMC_SUPPORTED
1972
1973 VP_RENDER_CHK_STATUS_RETURN(setVeboxProCmd(pMhwMiInterface, pVeboxInterface, CmdBuffer));
1974
1975 #endif
1976
1977 // Initialize the scalability
1978 curPipe = scalability->GetCurrentPipe();
1979 inputPipe = (uint8_t)curPipe;
1980 numPipe = scalability->GetPipeNumber();
1981 bMultipipe = (numPipe > 1) ? true : false;
1982
1983 VP_RENDER_CHK_STATUS_RETURN(SetVeboxIndex(pVeboxInterface, 0, numPipe, m_IsSfcUsed));
1984
1985 bDiVarianceEnable = m_PacketCaps.bDI;
1986
1987 SetupSurfaceStates(
1988 &VeboxSurfaceStateCmdParams);
1989
1990 SetupVeboxState(
1991 &VeboxStateCmdParams);
1992
1993 VP_RENDER_CHK_STATUS_RETURN(SetupDiIecpState(
1994 bDiVarianceEnable,
1995 &VeboxDiIecpCmdParams));
1996
1997 VP_RENDER_CHK_STATUS_RETURN(IsCmdParamsValid(
1998 VeboxStateCmdParams,
1999 VeboxDiIecpCmdParams,
2000 VeboxSurfaceStateCmdParams));
2001
2002 // Initialize command buffer and insert prolog
2003 VP_RENDER_CHK_STATUS_RETURN(InitCmdBufferWithVeParams(pRenderHal, *CmdBuffer, pGenericPrologParams));
2004
2005 //---------------------------------
2006 // Initialize Vebox Surface State Params
2007 //---------------------------------
2008 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceStateCmdParams(
2009 &VeboxSurfaceStateCmdParams, &MhwVeboxSurfaceStateCmdParams));
2010
2011 for (curPipe = 0; curPipe < numPipe; curPipe++)
2012 {
2013 if (bMultipipe)
2014 {
2015 // initialize the command buffer struct
2016 MOS_ZeroMemory(&CmdBufferInUse, sizeof(MOS_COMMAND_BUFFER));
2017 bool frameTrackingRequested = m_PacketCaps.lastSubmission && (numPipe - 1 == curPipe);
2018 scalability->SetCurrentPipeIndex((uint8_t)curPipe);
2019 scalability->GetCmdBuffer(&CmdBufferInUse, frameTrackingRequested);
2020 pCmdBufferInUse = &CmdBufferInUse;
2021 }
2022 else
2023 {
2024 pCmdBufferInUse = CmdBuffer;
2025 }
2026
2027 VP_RENDER_CHK_STATUS_RETURN(SetVeboxIndex(pVeboxInterface, curPipe, numPipe, m_IsSfcUsed));
2028
2029 AddCommonOcaMessage(pCmdBufferInUse, pOsContext, pOsInterface, pRenderHal, pMmioRegisters, pMhwMiInterface);
2030
2031 VP_RENDER_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddPerfCollectStartCmd(pRenderHal, pOsInterface, pCmdBufferInUse));
2032
2033 VP_RENDER_CHK_STATUS_RETURN(NullHW::StartPredicate(pOsInterface, pRenderHal->pMhwMiInterface, pCmdBufferInUse));
2034
2035 // Add compressible info of input/output surface to log
2036 if (this->m_currentSurface && VeboxSurfaceStateCmdParams.pSurfOutput)
2037 {
2038 std::string info = "in_comps = " + std::to_string(int(this->m_currentSurface->osSurface->bCompressible)) + ", out_comps = " + std::to_string(int(VeboxSurfaceStateCmdParams.pSurfOutput->osSurface->bCompressible));
2039 const char *ocaLog = info.c_str();
2040 HalOcaInterface::TraceMessage(*pCmdBufferInUse, (MOS_CONTEXT_HANDLE)pOsContext, ocaLog, info.size());
2041 }
2042
2043 if (bMultipipe)
2044 {
2045 // Insert prolog with VE params
2046 #ifdef _MMC_SUPPORTED
2047
2048 VP_RENDER_CHK_STATUS_RETURN(setVeboxProCmd(pMhwMiInterface, pVeboxInterface, pCmdBufferInUse));
2049
2050 #endif
2051
2052 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
2053 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
2054 genericPrologParams.pOsInterface = pRenderHal->pOsInterface;
2055 genericPrologParams.pvMiInterface = pRenderHal->pMhwMiInterface;
2056 genericPrologParams.bMmcEnabled = pGenericPrologParams ? pGenericPrologParams->bMmcEnabled : false;
2057 VP_RENDER_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmd(pCmdBufferInUse, &genericPrologParams));
2058
2059 VP_RENDER_CHK_STATUS_RETURN(scalability->SyncPipe(syncAllPipes, 0, pCmdBufferInUse));
2060
2061 // Enable Watchdog Timer
2062 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddWatchdogTimerStartCmd(pCmdBufferInUse));
2063
2064 #if (_DEBUG || _RELEASE_INTERNAL)
2065 // Add noop for simu no output issue
2066 if (curPipe > 0)
2067 {
2068 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2069 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2070 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2071 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2072 if (m_IsSfcUsed)
2073 {
2074 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2075 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2076 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2077 pMhwMiInterface->AddMiNoop(pCmdBufferInUse, nullptr);
2078 }
2079 }
2080 #endif
2081 }
2082
2083 //---------------------------------
2084 // Send CMD: Vebox_State
2085 //---------------------------------
2086 VP_RENDER_CHK_STATUS_RETURN(SetVeboxState(
2087 pVeboxInterface,
2088 pCmdBufferInUse,
2089 &VeboxStateCmdParams,
2090 0));
2091
2092 //---------------------------------
2093 // Send CMD: Vebox_Surface_State
2094 //---------------------------------
2095 VP_RENDER_CHK_STATUS_RETURN(SetVeboxSurfaces(
2096 pVeboxInterface,
2097 pCmdBufferInUse,
2098 &MhwVeboxSurfaceStateCmdParams));
2099
2100 //---------------------------------
2101 // Send CMD: SFC pipe commands
2102 //---------------------------------
2103 if (m_IsSfcUsed)
2104 {
2105 VP_RENDER_CHK_NULL_RETURN(m_sfcRender);
2106
2107 VP_RENDER_CHK_STATUS_RETURN(m_sfcRender->SetSfcPipe(curPipe, numPipe));
2108
2109 VP_RENDER_CHK_STATUS_RETURN(m_sfcRender->SetupSfcState(m_renderTarget));
2110
2111 VP_RENDER_CHK_STATUS_RETURN(m_sfcRender->SendSfcCmd(
2112 (pRenderData->DI.bDeinterlace || pRenderData->DN.bDnEnabled),
2113 pCmdBufferInUse));
2114 }
2115
2116 HalOcaInterface::OnDispatch(*pCmdBufferInUse, *pOsInterface, *pMhwMiInterface, *pMmioRegisters);
2117
2118 //---------------------------------
2119 // Send CMD: Vebox_DI_IECP
2120 //---------------------------------
2121 VP_RENDER_CHK_STATUS_RETURN(SetVeboxDiIecp(
2122 pVeboxInterface,
2123 pCmdBufferInUse,
2124 &VeboxDiIecpCmdParams));
2125
2126 VP_RENDER_CHK_NULL_RETURN(pOsInterface);
2127 VP_RENDER_CHK_NULL_RETURN(pOsInterface->pfnGetSkuTable);
2128 auto *skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
2129 if (skuTable && MEDIA_IS_SKU(skuTable, FtrEnablePPCFlush))
2130 {
2131 // Add PPC fulsh
2132 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
2133 FlushDwParams.bEnablePPCFlush = true;
2134 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiFlushDwCmd(pCmdBufferInUse, &FlushDwParams));
2135 }
2136
2137 if (bMultipipe)
2138 {
2139 // MI FlushDw, for vebox output green block issue
2140 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
2141 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiFlushDwCmd(pCmdBufferInUse, &FlushDwParams));
2142
2143 VP_RENDER_CHK_STATUS_RETURN(scalability->SyncPipe(syncAllPipes, 0, pCmdBufferInUse));
2144 }
2145
2146 //---------------------------------
2147 // Write GPU Status Tag for Tag based synchronization
2148 //---------------------------------
2149 if (!pOsInterface->bEnableKmdMediaFrameTracking)
2150 {
2151 VP_RENDER_CHK_STATUS_RETURN(SendVecsStatusTag(
2152 pMhwMiInterface,
2153 pOsInterface,
2154 pCmdBufferInUse));
2155 }
2156
2157 //---------------------------------
2158 // Write Sync tag for Vebox Heap Synchronization
2159 // If KMD frame tracking is on, the synchronization of Vebox Heap will use Status tag which
2160 // is updated using KMD frame tracking.
2161 //---------------------------------
2162 if (!pOsInterface->bEnableKmdMediaFrameTracking)
2163 {
2164 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
2165 FlushDwParams.pOsResource = (PMOS_RESOURCE)&pVeboxHeap->DriverResource;
2166 FlushDwParams.dwResourceOffset = pVeboxHeap->uiOffsetSync;
2167 FlushDwParams.dwDataDW1 = pVeboxHeap->dwNextTag;
2168
2169 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiFlushDwCmd(
2170 pCmdBufferInUse,
2171 &FlushDwParams));
2172 }
2173
2174 if (bMultipipe)
2175 {
2176 // Disable Watchdog Timer
2177 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddWatchdogTimerStopCmd(pCmdBufferInUse));
2178 }
2179
2180 VP_RENDER_CHK_STATUS_RETURN(NullHW::StopPredicate(pOsInterface, pRenderHal->pMhwMiInterface, pCmdBufferInUse));
2181
2182 VP_RENDER_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddPerfCollectEndCmd(pRenderHal, pOsInterface, pCmdBufferInUse));
2183
2184 #if (_DEBUG || _RELEASE_INTERNAL)
2185 VP_RENDER_CHK_STATUS_RETURN(StallBatchBuffer(pCmdBufferInUse));
2186 #endif
2187
2188 HalOcaInterface::On1stLevelBBEnd(*pCmdBufferInUse, *pOsInterface);
2189
2190 if (pOsInterface->bNoParsingAssistanceInKmd)
2191 {
2192 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiBatchBufferEnd(
2193 pCmdBufferInUse,
2194 nullptr));
2195 }
2196 else if (RndrCommonIsMiBBEndNeeded(pOsInterface))
2197 {
2198 // Add Batch Buffer end command (HW/OS dependent)
2199 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiBatchBufferEnd(
2200 pCmdBufferInUse,
2201 nullptr));
2202 }
2203
2204 if (bMultipipe)
2205 {
2206 scalability->ReturnCmdBuffer(pCmdBufferInUse);
2207 }
2208 }
2209
2210 if (bMultipipe)
2211 {
2212 scalability->SetCurrentPipeIndex(inputPipe);
2213 }
2214
2215 auto report = (VpFeatureReport *)(m_hwInterface->m_reporting);
2216 report->GetFeatures().VeboxScalability = bMultipipe;
2217
2218 MT_LOG2(MT_VP_HAL_RENDER_VE, MT_NORMAL, MT_VP_MHW_VE_SCALABILITY_EN, bMultipipe, MT_VP_MHW_VE_SCALABILITY_USE_SFC, m_IsSfcUsed);
2219
2220 return eStatus;
2221 }
2222
2223
AddCommonOcaMessage(PMOS_COMMAND_BUFFER pCmdBufferInUse,MOS_CONTEXT * pOsContext,PMOS_INTERFACE pOsInterface,PRENDERHAL_INTERFACE pRenderHal,PMHW_MI_MMIOREGISTERS pMmioRegisters,PMHW_MI_INTERFACE pMhwMiInterface)2224 void VpVeboxCmdPacketLegacy::AddCommonOcaMessage(PMOS_COMMAND_BUFFER pCmdBufferInUse, MOS_CONTEXT *pOsContext, PMOS_INTERFACE pOsInterface, PRENDERHAL_INTERFACE pRenderHal, PMHW_MI_MMIOREGISTERS pMmioRegisters, PMHW_MI_INTERFACE pMhwMiInterface)
2225 {
2226 VP_FUNC_CALL();
2227
2228 HalOcaInterface::On1stLevelBBStart(*pCmdBufferInUse, *pOsContext, pOsInterface->CurrentGpuContextHandle, *pMhwMiInterface, *pMmioRegisters);
2229
2230 char ocaMsg[] = "VP APG Vebox Packet";
2231 HalOcaInterface::TraceMessage(*pCmdBufferInUse, (MOS_CONTEXT_HANDLE)pOsContext, ocaMsg, sizeof(ocaMsg));
2232
2233 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
2234 if (pRenderData)
2235 {
2236 MHW_VEBOX_IECP_PARAMS IecpParams = pRenderData->GetIECPParams();
2237 if (pRenderData->IECP.STE.bStdEnabled && IecpParams.ColorPipeParams.StdParams.param)
2238 {
2239 char ocaMsg_std[] = "Customized STD state is used";
2240 HalOcaInterfaceNext::TraceMessage(*pCmdBufferInUse, (MOS_CONTEXT_HANDLE)pOsContext, ocaMsg_std, sizeof(ocaMsg_std));
2241 }
2242 }
2243
2244 HalOcaInterface::TraceOcaSkuValue(*pCmdBufferInUse, *pOsInterface);
2245
2246 // Add vphal param to log.
2247 HalOcaInterface::DumpVphalParam(*pCmdBufferInUse, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->pVphalOcaDumper);
2248
2249 if (m_vpUserFeatureControl)
2250 {
2251 HalOcaInterfaceNext::DumpVpUserFeautreControlInfo(*pCmdBufferInUse, pOsContext, m_vpUserFeatureControl->GetOcaFeautreControlInfo());
2252 }
2253 }
2254
2255
InitVeboxSurfaceStateCmdParams(PVP_VEBOX_SURFACE_STATE_CMD_PARAMS pVpHalVeboxSurfaceStateCmdParams,PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pMhwVeboxSurfaceStateCmdParams)2256 MOS_STATUS VpVeboxCmdPacketLegacy::InitVeboxSurfaceStateCmdParams(
2257 PVP_VEBOX_SURFACE_STATE_CMD_PARAMS pVpHalVeboxSurfaceStateCmdParams,
2258 PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pMhwVeboxSurfaceStateCmdParams)
2259 {
2260 VP_FUNC_CALL();
2261
2262 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2263
2264 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams);
2265 VP_RENDER_CHK_NULL_RETURN(pMhwVeboxSurfaceStateCmdParams);
2266
2267 MOS_ZeroMemory(pMhwVeboxSurfaceStateCmdParams, sizeof(*pMhwVeboxSurfaceStateCmdParams));
2268
2269 pMhwVeboxSurfaceStateCmdParams->bDIEnable = pVpHalVeboxSurfaceStateCmdParams->bDIEnable;
2270 pMhwVeboxSurfaceStateCmdParams->b3DlutEnable = pVpHalVeboxSurfaceStateCmdParams->b3DlutEnable;
2271
2272 if (pVpHalVeboxSurfaceStateCmdParams->pSurfInput)
2273 {
2274 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams->pSurfInput->osSurface);
2275 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2276 pVpHalVeboxSurfaceStateCmdParams->pSurfInput,
2277 &pMhwVeboxSurfaceStateCmdParams->SurfInput));
2278 pMhwVeboxSurfaceStateCmdParams->SurfInput.dwYoffset = pVpHalVeboxSurfaceStateCmdParams->pSurfInput->osSurface->YPlaneOffset.iYOffset;
2279 MT_LOG2(MT_VP_MHW_VE_SURFSTATE_INPUT, MT_NORMAL, MT_SURF_TILE_MODE, pVpHalVeboxSurfaceStateCmdParams->pSurfInput->osSurface->TileModeGMM,
2280 MT_SURF_MOS_FORMAT, pVpHalVeboxSurfaceStateCmdParams->pSurfInput->osSurface->Format);
2281 }
2282 if (pVpHalVeboxSurfaceStateCmdParams->pSurfOutput)
2283 {
2284 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams->pSurfOutput->osSurface);
2285 pMhwVeboxSurfaceStateCmdParams->bOutputValid = true;
2286 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2287 pVpHalVeboxSurfaceStateCmdParams->pSurfOutput,
2288 &pMhwVeboxSurfaceStateCmdParams->SurfOutput));
2289 pMhwVeboxSurfaceStateCmdParams->SurfOutput.dwYoffset = pVpHalVeboxSurfaceStateCmdParams->pSurfOutput->osSurface->YPlaneOffset.iYOffset;
2290 MT_LOG2(MT_VP_MHW_VE_SURFSTATE_OUT, MT_NORMAL, MT_SURF_TILE_MODE, pVpHalVeboxSurfaceStateCmdParams->pSurfOutput->osSurface->TileModeGMM,
2291 MT_SURF_MOS_FORMAT, pVpHalVeboxSurfaceStateCmdParams->pSurfOutput->osSurface->Format);
2292 }
2293 if (pVpHalVeboxSurfaceStateCmdParams->pSurfSTMM)
2294 {
2295 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams->pSurfSTMM->osSurface);
2296 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2297 pVpHalVeboxSurfaceStateCmdParams->pSurfSTMM,
2298 &pMhwVeboxSurfaceStateCmdParams->SurfSTMM));
2299 MT_LOG2(MT_VP_MHW_VE_SURFSTATE_STMM, MT_NORMAL, MT_SURF_TILE_MODE, pVpHalVeboxSurfaceStateCmdParams->pSurfSTMM->osSurface->TileModeGMM,
2300 MT_SURF_MOS_FORMAT, pVpHalVeboxSurfaceStateCmdParams->pSurfSTMM->osSurface->Format);
2301 }
2302 if (pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput)
2303 {
2304 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput->osSurface);
2305 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2306 pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput,
2307 &pMhwVeboxSurfaceStateCmdParams->SurfDNOutput));
2308 pMhwVeboxSurfaceStateCmdParams->SurfDNOutput.dwYoffset = pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput->osSurface->YPlaneOffset.iYOffset;
2309 MT_LOG2(MT_VP_MHW_VE_SURFSTATE_DNOUT, MT_NORMAL, MT_SURF_TILE_MODE, pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput->osSurface->TileModeGMM,
2310 MT_SURF_MOS_FORMAT, pVpHalVeboxSurfaceStateCmdParams->pSurfDNOutput->osSurface->Format);
2311 }
2312 if (pVpHalVeboxSurfaceStateCmdParams->pSurfSkinScoreOutput)
2313 {
2314 VP_RENDER_CHK_NULL_RETURN(pVpHalVeboxSurfaceStateCmdParams->pSurfSkinScoreOutput->osSurface);
2315 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2316 pVpHalVeboxSurfaceStateCmdParams->pSurfSkinScoreOutput,
2317 &pMhwVeboxSurfaceStateCmdParams->SurfSkinScoreOutput));
2318 MT_LOG2(MT_VP_MHW_VE_SURFSTATE_SKINSCORE, MT_NORMAL, MT_SURF_TILE_MODE, pVpHalVeboxSurfaceStateCmdParams->pSurfSkinScoreOutput->osSurface->TileModeGMM,
2319 MT_SURF_MOS_FORMAT, pVpHalVeboxSurfaceStateCmdParams->pSurfSkinScoreOutput->osSurface->Format);
2320 }
2321
2322 if (m_inputDepth)
2323 {
2324 pMhwVeboxSurfaceStateCmdParams->SurfInput.dwBitDepth = m_inputDepth;
2325 }
2326
2327 return eStatus;
2328 }
2329
SendVecsStatusTag(PMHW_MI_INTERFACE pMhwMiInterface,PMOS_INTERFACE pOsInterface,PMOS_COMMAND_BUFFER pCmdBuffer)2330 MOS_STATUS VpVeboxCmdPacketLegacy::SendVecsStatusTag(
2331 PMHW_MI_INTERFACE pMhwMiInterface,
2332 PMOS_INTERFACE pOsInterface,
2333 PMOS_COMMAND_BUFFER pCmdBuffer)
2334 {
2335 VP_FUNC_CALL();
2336
2337 PMOS_RESOURCE gpuStatusBuffer = nullptr;
2338 MHW_MI_FLUSH_DW_PARAMS FlushDwParams;
2339 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2340
2341 //------------------------------------
2342 VP_RENDER_CHK_NULL_RETURN(pMhwMiInterface);
2343 VP_RENDER_CHK_NULL_RETURN(pOsInterface);
2344 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
2345
2346 // Get GPU Status buffer
2347 pOsInterface->pfnGetGpuStatusBufferResource(pOsInterface, gpuStatusBuffer);
2348 VP_RENDER_CHK_NULL_RETURN(gpuStatusBuffer);
2349
2350 // Register the buffer
2351 VP_RENDER_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
2352 pOsInterface,
2353 gpuStatusBuffer,
2354 true,
2355 true));
2356
2357 MOS_ZeroMemory(&FlushDwParams, sizeof(FlushDwParams));
2358 FlushDwParams.pOsResource = gpuStatusBuffer;
2359 FlushDwParams.dwResourceOffset = pOsInterface->pfnGetGpuStatusTagOffset(pOsInterface, MOS_GPU_CONTEXT_VEBOX);
2360 FlushDwParams.dwDataDW1 = pOsInterface->pfnGetGpuStatusTag(pOsInterface, MOS_GPU_CONTEXT_VEBOX);
2361 VP_RENDER_CHK_STATUS_RETURN(pMhwMiInterface->AddMiFlushDwCmd(
2362 pCmdBuffer,
2363 &FlushDwParams));
2364
2365 // Increase buffer tag for next usage
2366 pOsInterface->pfnIncrementGpuStatusTag(pOsInterface, MOS_GPU_CONTEXT_VEBOX);
2367
2368 return eStatus;
2369 }
2370
RndrCommonIsMiBBEndNeeded(PMOS_INTERFACE pOsInterface)2371 bool VpVeboxCmdPacketLegacy::RndrCommonIsMiBBEndNeeded(
2372 PMOS_INTERFACE pOsInterface)
2373 {
2374 VP_FUNC_CALL();
2375
2376 bool needed = false;
2377
2378 if (nullptr == pOsInterface)
2379 return false;
2380
2381 return needed;
2382 }
2383
InitSfcRender()2384 MOS_STATUS VpVeboxCmdPacketLegacy::InitSfcRender()
2385 {
2386 VP_FUNC_CALL();
2387
2388 if (nullptr == m_sfcRender)
2389 {
2390 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
2391 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_vpPlatformInterface);
2392 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_vpPlatformInterface->CreateSfcRender(
2393 m_sfcRender,
2394 *m_hwInterface,
2395 m_allocator));
2396 VP_RENDER_CHK_NULL_RETURN(m_sfcRender);
2397 }
2398 VP_PUBLIC_CHK_STATUS_RETURN(m_sfcRender->Init());
2399 return MOS_STATUS_SUCCESS;
2400 }
2401
DumpVeboxStateHeap()2402 MOS_STATUS VpVeboxCmdPacketLegacy::DumpVeboxStateHeap()
2403 {
2404 VP_FUNC_CALL();
2405
2406 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2407 #if (_DEBUG || _RELEASE_INTERNAL)
2408 static uint32_t counter = 0;
2409 VP_SURFACE driverResource = {};
2410 VP_SURFACE kernelResource = {};
2411 MOS_SURFACE driverSurface = {};
2412 MOS_SURFACE kernelSurface = {};
2413
2414 const MHW_VEBOX_HEAP* pVeboxHeap = nullptr;
2415 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
2416 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
2417 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
2418
2419 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
2420 VpDebugInterface* debuginterface = (VpDebugInterface*)m_hwInterface->m_debugInterface;
2421
2422 if(veboxItf)
2423 {
2424 VP_RENDER_CHK_STATUS_RETURN(veboxItf->GetVeboxHeapInfo(&pVeboxHeap));
2425 }
2426 else
2427 {
2428 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->GetVeboxHeapInfo(&pVeboxHeap));
2429 }
2430 VP_RENDER_CHK_NULL_RETURN(pVeboxHeap);
2431
2432
2433 driverResource.osSurface = &driverSurface;
2434 kernelResource.osSurface = &kernelSurface;
2435
2436 driverResource.osSurface->OsResource = pVeboxHeap->DriverResource;
2437 kernelResource.osSurface->OsResource = pVeboxHeap->KernelResource;
2438
2439 VPHAL_GET_SURFACE_INFO info = {};
2440 m_allocator->GetSurfaceInfo(&driverResource, info);
2441 m_allocator->GetSurfaceInfo(&kernelResource, info);
2442
2443
2444 VP_SURFACE_DUMP(debuginterface,
2445 &kernelResource,
2446 counter,
2447 0,
2448 VPHAL_DUMP_TYPE_VEBOX_DRIVERHEAP,
2449 VPHAL_SURF_DUMP_DDI_VP_BLT);
2450
2451 VP_SURFACE_DUMP(debuginterface,
2452 &kernelResource,
2453 counter,
2454 0,
2455 VPHAL_DUMP_TYPE_VEBOX_KERNELHEAP,
2456 VPHAL_SURF_DUMP_DDI_VP_BLT);
2457
2458 counter++;
2459 #endif
2460 return eStatus;
2461 }
2462
Init()2463 MOS_STATUS VpVeboxCmdPacketLegacy::Init()
2464 {
2465 VP_FUNC_CALL();
2466
2467 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2468 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
2469 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_skuTable);
2470
2471 VP_RENDER_CHK_STATUS_RETURN(InitSfcRender());
2472
2473 if (nullptr == m_currentSurface)
2474 {
2475 m_currentSurface = m_allocator->AllocateVpSurface();
2476 VP_CHK_SPACE_NULL_RETURN(m_currentSurface);
2477 }
2478 else
2479 {
2480 m_currentSurface->Clean();
2481 }
2482
2483 if (nullptr == m_previousSurface)
2484 {
2485 m_previousSurface = m_allocator->AllocateVpSurface();
2486 VP_CHK_SPACE_NULL_RETURN(m_previousSurface);
2487 }
2488 else
2489 {
2490 m_previousSurface->Clean();
2491 }
2492
2493 if (nullptr == m_renderTarget)
2494 {
2495 m_renderTarget = m_allocator->AllocateVpSurface();
2496 VP_CHK_SPACE_NULL_RETURN(m_renderTarget);
2497 }
2498 else
2499 {
2500 m_renderTarget->Clean();
2501 }
2502
2503 MOS_ZeroMemory(&m_veboxPacketSurface, sizeof(VEBOX_PACKET_SURFACE_PARAMS));
2504 m_surfSetting.Clean();
2505
2506 return eStatus;
2507 }
2508
Prepare()2509 MOS_STATUS VpVeboxCmdPacketLegacy::Prepare()
2510 {
2511 VP_FUNC_CALL();
2512
2513 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2514
2515 return eStatus;
2516 }
2517
PrepareState()2518 MOS_STATUS VpVeboxCmdPacketLegacy::PrepareState()
2519 {
2520 VP_FUNC_CALL();
2521
2522 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2523
2524 if (m_packetResourcesPrepared)
2525 {
2526 VP_RENDER_NORMALMESSAGE("Resource Prepared, skip this time");
2527 return MOS_STATUS_SUCCESS;
2528 }
2529
2530 VP_RENDER_CHK_STATUS_RETURN(SetupIndirectStates());
2531
2532 VP_RENDER_CHK_STATUS_RETURN(UpdateVeboxStates());
2533
2534 m_packetResourcesPrepared = true;
2535
2536 return eStatus;
2537 }
2538
AdjustBlockStatistics()2539 MOS_STATUS VpVeboxCmdPacketLegacy::AdjustBlockStatistics()
2540 {
2541 VP_FUNC_CALL();
2542
2543 if (m_surfSetting.dwVeboxPerBlockStatisticsWidth == 0 || m_surfSetting.dwVeboxPerBlockStatisticsHeight == 0)
2544 {
2545 VP_RENDER_NORMALMESSAGE("Not need update statistic block height and width");
2546 return MOS_STATUS_SUCCESS;
2547 }
2548
2549 uint32_t dwWidth = 0;
2550 uint32_t dwHeight = 0;
2551 MHW_VEBOX_SURFACE_PARAMS mhwVeboxSurfaceParam = {};
2552 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
2553
2554 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
2555 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrInput);
2556
2557 // Align dwEndingX with surface state
2558 VP_RENDER_CHK_STATUS_RETURN(InitVeboxSurfaceParams(
2559 m_veboxPacketSurface.pCurrInput, &mhwVeboxSurfaceParam));
2560
2561 // Update Statistics Block Height and Weight in surfsetting
2562
2563 if (m_veboxItf)
2564 {
2565 VP_RENDER_CHK_STATUS_RETURN(m_veboxItf->VeboxAdjustBoundary(
2566 &mhwVeboxSurfaceParam,
2567 &dwWidth,
2568 &dwHeight,
2569 m_PacketCaps.bDI));
2570 }
2571 else
2572 {
2573 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->VeboxAdjustBoundary(
2574 &mhwVeboxSurfaceParam,
2575 &dwWidth,
2576 &dwHeight,
2577 m_PacketCaps.bDI));
2578 }
2579
2580 dwWidth = MOS_ALIGN_CEIL(dwWidth, 64);
2581 dwHeight = MOS_ROUNDUP_DIVIDE(dwHeight, 4);
2582
2583 if (dwWidth > m_surfSetting.dwVeboxPerBlockStatisticsWidth || dwHeight > m_surfSetting.dwVeboxPerBlockStatisticsHeight)
2584 {
2585 VP_RENDER_ASSERTMESSAGE("Adjust boundary width %d, height %d is larger than origin boundary width %d, height %d, not need update params",
2586 dwWidth,
2587 dwHeight,
2588 m_surfSetting.dwVeboxPerBlockStatisticsWidth,
2589 m_surfSetting.dwVeboxPerBlockStatisticsHeight);
2590 return MOS_STATUS_INVALID_PARAMETER;
2591 }
2592 else
2593 {
2594 VP_RENDER_NORMALMESSAGE("Adjust boundary width %d, height %d. Origin boundary width %d, height %d",
2595 dwWidth,
2596 dwHeight,
2597 m_surfSetting.dwVeboxPerBlockStatisticsWidth,
2598 m_surfSetting.dwVeboxPerBlockStatisticsHeight);
2599
2600 m_surfSetting.dwVeboxPerBlockStatisticsHeight = dwHeight;
2601 m_surfSetting.dwVeboxPerBlockStatisticsWidth = dwWidth;
2602 }
2603
2604 return MOS_STATUS_SUCCESS;
2605 }
2606
PacketInit(VP_SURFACE * inputSurface,VP_SURFACE * outputSurface,VP_SURFACE * previousSurface,VP_SURFACE_SETTING & surfSetting,VP_EXECUTE_CAPS packetCaps)2607 MOS_STATUS VpVeboxCmdPacketLegacy::PacketInit(
2608 VP_SURFACE *inputSurface,
2609 VP_SURFACE *outputSurface,
2610 VP_SURFACE *previousSurface,
2611 VP_SURFACE_SETTING &surfSetting,
2612 VP_EXECUTE_CAPS packetCaps)
2613 {
2614 VP_FUNC_CALL();
2615
2616 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
2617 m_packetResourcesPrepared = false;
2618
2619 VP_RENDER_CHK_NULL_RETURN(pRenderData);
2620 VP_RENDER_CHK_NULL_RETURN(inputSurface);
2621 VP_RENDER_CHK_NULL_RETURN(outputSurface);
2622 VP_RENDER_CHK_STATUS_RETURN(pRenderData->Init());
2623
2624 m_PacketCaps = packetCaps;
2625 VP_RENDER_NORMALMESSAGE("m_PacketCaps %x", m_PacketCaps.value);
2626
2627 VP_RENDER_CHK_STATUS_RETURN(Init());
2628 VP_RENDER_CHK_NULL_RETURN(m_allocator);
2629 VP_RENDER_CHK_NULL_RETURN(m_currentSurface);
2630 VP_RENDER_CHK_NULL_RETURN(m_renderTarget);
2631 VP_RENDER_CHK_NULL_RETURN(m_previousSurface);
2632
2633 VP_RENDER_CHK_STATUS_RETURN(InitSurfMemCacheControl(packetCaps));
2634
2635 m_IsSfcUsed = packetCaps.bSFC;
2636
2637 //update VEBOX resource GMM resource usage type
2638 m_allocator->UpdateResourceUsageType(&inputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_INPUT_PICTURE_FF);
2639 m_allocator->UpdateResourceUsageType(&outputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF);
2640
2641 // Set current src = current primary input
2642 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->CopyVpSurface(*m_renderTarget ,*outputSurface));
2643
2644 // Init packet surface params.
2645 m_surfSetting = surfSetting;
2646 m_veboxPacketSurface.pCurrInput = GetSurface(SurfaceTypeVeboxInput);
2647 m_veboxPacketSurface.pStatisticsOutput = GetSurface(SurfaceTypeStatistics);
2648 m_veboxPacketSurface.pCurrOutput = GetSurface(SurfaceTypeVeboxCurrentOutput);
2649 m_veboxPacketSurface.pPrevInput = GetSurface(SurfaceTypeVeboxPreviousInput);
2650 m_veboxPacketSurface.pSTMMInput = GetSurface(SurfaceTypeSTMMIn);
2651 m_veboxPacketSurface.pSTMMOutput = GetSurface(SurfaceTypeSTMMOut);
2652 m_veboxPacketSurface.pDenoisedCurrOutput = GetSurface(SurfaceTypeDNOutput);
2653 m_veboxPacketSurface.pPrevOutput = GetSurface(SurfaceTypeVeboxPreviousOutput);
2654 m_veboxPacketSurface.pAlphaOrVignette = GetSurface(SurfaceTypeAlphaOrVignette);
2655 m_veboxPacketSurface.pLaceOrAceOrRgbHistogram = GetSurface(SurfaceTypeLaceAceRGBHistogram);
2656 m_veboxPacketSurface.pSurfSkinScoreOutput = GetSurface(SurfaceTypeSkinScore);
2657
2658 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrInput);
2659 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput);
2660 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pLaceOrAceOrRgbHistogram);
2661
2662 m_DNDIFirstFrame = (!m_PacketCaps.bRefValid && (m_PacketCaps.bDN || m_PacketCaps.bDI));
2663 m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_CURRENT;
2664
2665 auto curInput = m_veboxPacketSurface.pCurrInput;
2666 auto curOutput = m_veboxPacketSurface.pCurrOutput;
2667 if (!m_IsSfcUsed &&
2668 ((uint32_t)curInput->rcSrc.bottom < curInput->osSurface->dwHeight ||
2669 (uint32_t)curInput->rcSrc.right < curInput->osSurface->dwWidth))
2670 {
2671 curInput->bVEBOXCroppingUsed = true;
2672 VP_RENDER_NORMALMESSAGE("bVEBOXCroppingUsed = true, input: rcSrc.bottom: %d, rcSrc.right: %d; dwHeight: %d, dwHeight: %d;",
2673 (uint32_t)curInput->rcSrc.bottom,
2674 (uint32_t)curInput->rcSrc.right,
2675 curInput->osSurface->dwHeight,
2676 curInput->osSurface->dwWidth);
2677
2678 if (curOutput)
2679 {
2680 curOutput->bVEBOXCroppingUsed = true;
2681 VP_RENDER_NORMALMESSAGE(" output: rcSrc.bottom: %d, rcSrc.right: %d; dwHeight: %d, dwHeight: %d;",
2682 (uint32_t)curOutput->rcSrc.bottom,
2683 (uint32_t)curOutput->rcSrc.right,
2684 curOutput->osSurface->dwHeight,
2685 curOutput->osSurface->dwWidth);
2686 }
2687 }
2688 else
2689 {
2690 curInput->bVEBOXCroppingUsed = false;
2691 if (curOutput)
2692 {
2693 curOutput->bVEBOXCroppingUsed = false;
2694 }
2695 }
2696
2697 // Adjust boundary for statistics surface block
2698 VP_RENDER_CHK_STATUS_RETURN(AdjustBlockStatistics());
2699
2700 // Get Vebox Secure mode form policy
2701 m_useKernelResource = packetCaps.bSecureVebox;
2702
2703 return MOS_STATUS_SUCCESS;
2704 }
2705
SetUpdatedExecuteResource(VP_SURFACE * inputSurface,VP_SURFACE * outputSurface,VP_SURFACE * previousSurface,VP_SURFACE_SETTING & surfSetting)2706 MOS_STATUS VpVeboxCmdPacketLegacy::SetUpdatedExecuteResource(
2707 VP_SURFACE *inputSurface,
2708 VP_SURFACE *outputSurface,
2709 VP_SURFACE *previousSurface,
2710 VP_SURFACE_SETTING &surfSetting)
2711 {
2712 VP_FUNC_CALL();
2713
2714 VP_RENDER_CHK_NULL_RETURN(inputSurface);
2715 VP_RENDER_CHK_NULL_RETURN(outputSurface);
2716 VP_RENDER_CHK_NULL_RETURN(inputSurface->osSurface);
2717 VP_RENDER_CHK_NULL_RETURN(outputSurface->osSurface);
2718 m_allocator->UpdateResourceUsageType(&inputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_INPUT_PICTURE_FF);
2719 m_allocator->UpdateResourceUsageType(&outputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF);
2720
2721 // Set current src = current primary input
2722 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->CopyVpSurface(*m_renderTarget ,*outputSurface));
2723
2724 // Init packet surface params.
2725 m_surfSetting = surfSetting;
2726 m_veboxPacketSurface.pCurrInput = GetSurface(SurfaceTypeVeboxInput);
2727 m_veboxPacketSurface.pStatisticsOutput = GetSurface(SurfaceTypeStatistics);
2728 m_veboxPacketSurface.pCurrOutput = GetSurface(SurfaceTypeVeboxCurrentOutput);
2729 m_veboxPacketSurface.pPrevInput = GetSurface(SurfaceTypeVeboxPreviousInput);
2730 m_veboxPacketSurface.pSTMMInput = GetSurface(SurfaceTypeSTMMIn);
2731 m_veboxPacketSurface.pSTMMOutput = GetSurface(SurfaceTypeSTMMOut);
2732 m_veboxPacketSurface.pDenoisedCurrOutput = GetSurface(SurfaceTypeDNOutput);
2733 m_veboxPacketSurface.pPrevOutput = GetSurface(SurfaceTypeVeboxPreviousOutput);
2734 m_veboxPacketSurface.pAlphaOrVignette = GetSurface(SurfaceTypeAlphaOrVignette);
2735 m_veboxPacketSurface.pLaceOrAceOrRgbHistogram = GetSurface(SurfaceTypeLaceAceRGBHistogram);
2736 m_veboxPacketSurface.pSurfSkinScoreOutput = GetSurface(SurfaceTypeSkinScore);
2737
2738 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pCurrInput);
2739 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput);
2740 VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pLaceOrAceOrRgbHistogram);
2741
2742 // Adjust boundary for statistics surface block
2743 VP_RENDER_CHK_STATUS_RETURN(AdjustBlockStatistics());
2744
2745 if (m_PacketCaps.bSFC)
2746 {
2747 VP_RENDER_CHK_STATUS_RETURN(SetSfcMmcParams());
2748 }
2749 return MOS_STATUS_SUCCESS;
2750 }
2751
Submit(MOS_COMMAND_BUFFER * commandBuffer,uint8_t packetPhase)2752 MOS_STATUS VpVeboxCmdPacketLegacy::Submit(MOS_COMMAND_BUFFER* commandBuffer, uint8_t packetPhase)
2753 {
2754 VP_FUNC_CALL();
2755
2756 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2757 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
2758
2759 if (m_currentSurface && m_currentSurface->osSurface)
2760 {
2761 // Ensure the input is ready to be read
2762 // Currently, mos RegisterResourcere cannot sync the 3d resource.
2763 // Temporaly, call sync resource to do the sync explicitly.
2764 // Sync need be done after switching context.
2765 #if MOS_MEDIASOLO_SUPPORTED
2766 if (!m_hwInterface->m_osInterface->bSoloInUse)
2767 #endif
2768 {
2769 m_allocator->SyncOnResource(
2770 &m_currentSurface->osSurface->OsResource,
2771 false);
2772 }
2773 }
2774
2775 // Send vebox command
2776 VP_RENDER_CHK_STATUS_RETURN(SendVeboxCmd(commandBuffer));
2777
2778 #if (_DEBUG || _RELEASE_INTERNAL)
2779 // Debug interface with state heap check
2780 VP_RENDER_CHK_STATUS_RETURN(DumpVeboxStateHeap())
2781 #endif
2782
2783 return eStatus;
2784 }
2785
CopySurfaceValue(VP_SURFACE * pTargetSurface,VP_SURFACE * pSourceSurface)2786 void VpVeboxCmdPacketLegacy::CopySurfaceValue(
2787 VP_SURFACE *pTargetSurface,
2788 VP_SURFACE *pSourceSurface)
2789 {
2790 VP_FUNC_CALL();
2791
2792 if (pTargetSurface == nullptr)
2793 {
2794 VP_RENDER_ASSERTMESSAGE("Input pTargetSurface is null");
2795 return;
2796 }
2797 *pTargetSurface = *pSourceSurface;
2798 }
2799
VpVeboxCmdPacketLegacy(MediaTask * task,PVP_MHWINTERFACE hwInterface,PVpAllocator & allocator,VPMediaMemComp * mmc)2800 VpVeboxCmdPacketLegacy::VpVeboxCmdPacketLegacy(
2801 MediaTask * task,
2802 PVP_MHWINTERFACE hwInterface,
2803 PVpAllocator &allocator,
2804 VPMediaMemComp *mmc):
2805 CmdPacket(task),
2806 VpCmdPacket(task, hwInterface, allocator, mmc, VP_PIPELINE_PACKET_VEBOX),
2807 VpVeboxCmdPacketBase(task, hwInterface, allocator, mmc)
2808 {
2809 if (hwInterface)
2810 {
2811 m_vpUserFeatureControl = hwInterface->m_userFeatureControl;
2812 }
2813 }
2814
~VpVeboxCmdPacketLegacy()2815 VpVeboxCmdPacketLegacy:: ~VpVeboxCmdPacketLegacy()
2816 {
2817 VP_FUNC_CALL();
2818
2819 MOS_Delete(m_sfcRender);
2820 MOS_Delete(m_lastExecRenderData);
2821 MOS_Delete(m_surfMemCacheCtl);
2822
2823 m_allocator->DestroyVpSurface(m_currentSurface);
2824 m_allocator->DestroyVpSurface(m_previousSurface);
2825 m_allocator->DestroyVpSurface(m_renderTarget);
2826 }
2827
2828 //!
2829 //! \brief Calculate offsets of statistics surface address based on the
2830 //! functions which were enabled in the previous call,
2831 //! and store the width and height of the per-block statistics into DNDI_STATE
2832 //! \details
2833 //! Layout of Statistics surface when Temporal DI enabled
2834 //! --------------------------------------------------------------\n
2835 //! | 16 bytes for x=0, Y=0 | 16 bytes for x=16, Y=0 | ...\n
2836 //! |-------------------------------------------------------------\n
2837 //! | 16 bytes for x=0, Y=4 | ...\n
2838 //! |------------------------------\n
2839 //! | ...\n
2840 //! |------------------------------\n
2841 //! | 16 bytes for x=0, Y=height-4| ...\n
2842 //! |-----------------------------------------------Pitch----------------------------------------------------------\n
2843 //! | 256 DW of ACE histogram Slice 0 (Previous)| 17 DW Reserved | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
2844 //! |--------------------------------------------------------------------------------------------------------------\n
2845 //! | 256 DW of ACE histogram Slice 0 (Current) | 11 DW FMD0 | 6 DW GNE0 | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
2846 //! |--------------------------------------------------------------------------------------------------------------\n
2847 //! | 256 DW of ACE histogram Slice 1 (Previous)| 17 DW Reserved | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
2848 //! |--------------------------------------------------------------------------------------------------------------\n
2849 //! | 256 DW of ACE histogram Slice 1 (Current) | 11 DW FMD1 | 6 DW GNE1 | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
2850 //! ---------------------------------------------------------------------------------------------------------------\n
2851 //!
2852 //! Layout of Statistics surface when DN or Spatial DI enabled (and Temporal DI disabled)
2853 //! --------------------------------------------------------------\n
2854 //! | 16 bytes for x=0, Y=0 | 16 bytes for x=16, Y=0 | ...\n
2855 //! |-------------------------------------------------------------\n
2856 //! | 16 bytes for x=0, Y=4 | ...\n
2857 //! |------------------------------\n
2858 //! | ...\n
2859 //! |------------------------------\n
2860 //! | 16 bytes for x=0, Y=height-4| ...\n
2861 //! |-----------------------------------------------Pitch----------------------------------------------------------\n
2862 //! | 256 DW of ACE histogram Slice 0 (Input) | 11 DW FMD0 | 6 DW GNE0 | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
2863 //! |--------------------------------------------------------------------------------------------------------------\n
2864 //! | 256 DW of ACE histogram Slice 1 (Input) | 11 DW FMD1 | 6 DW GNE1 | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
2865 //! ---------------------------------------------------------------------------------------------------------------\n
2866 //!
2867 //! Layout of Statistics surface when both DN and DI are disabled
2868 //! ------------------------------------------------Pitch----------------------------------------------------------\n
2869 //! | 256 DW of ACE histogram Slice 0 (Input) | 17 DW Reserved | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
2870 //! |--------------------------------------------------------------------------------------------------------------\n
2871 //! | 256 DW of ACE histogram Slice 1 (Input) | 17 DW Reserved | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
2872 //! ---------------------------------------------------------------------------------------------------------------\n
2873 //! \param [out] pStatSlice0Offset
2874 //! Statistics surface Slice 0 base pointer
2875 //! \param [out] pStatSlice1Offset
2876 //! Statistics surface Slice 1 base pointer
2877 //! \return MOS_STATUS
2878 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
2879 //!
GetStatisticsSurfaceOffsets(int32_t * pStatSlice0Offset,int32_t * pStatSlice1Offset)2880 MOS_STATUS VpVeboxCmdPacketLegacy::GetStatisticsSurfaceOffsets(
2881 int32_t* pStatSlice0Offset,
2882 int32_t* pStatSlice1Offset)
2883 {
2884 VP_FUNC_CALL();
2885
2886 uint32_t uiPitch;
2887 int32_t iOffset;
2888 MOS_STATUS eStatus;
2889
2890 eStatus = MOS_STATUS_UNKNOWN;
2891 uiPitch = 0;
2892
2893 // Query platform dependent size of per frame information
2894 VP_RENDER_CHK_STATUS(QueryStatLayout(
2895 VEBOX_STAT_QUERY_PER_FRAME_SIZE, &uiPitch));
2896
2897 // Get the base address of Frame based statistics for each slice
2898 if (m_PacketCaps.bDI) // VEBOX, VEBOX+IECP
2899 {
2900 // Frame based statistics begins after Encoder statistics
2901 iOffset = m_surfSetting.dwVeboxPerBlockStatisticsWidth *
2902 m_surfSetting.dwVeboxPerBlockStatisticsHeight;
2903
2904 *pStatSlice0Offset = iOffset + uiPitch; // Slice 0 current frame
2905 *pStatSlice1Offset = iOffset + uiPitch * 3; // Slice 1 current frame
2906 }
2907 else if (m_PacketCaps.bDN) // DN, DN_IECP, SpatialDI
2908 {
2909 // Frame based statistics begins after Encoder statistics
2910 iOffset = m_surfSetting.dwVeboxPerBlockStatisticsWidth *
2911 m_surfSetting.dwVeboxPerBlockStatisticsHeight;
2912
2913 *pStatSlice0Offset = iOffset; // Slice 0 input frame
2914 *pStatSlice1Offset = iOffset + uiPitch; // Slice 1 input frame
2915 }
2916 else // IECP only
2917 {
2918 *pStatSlice0Offset = 0; // Slice 0 input frame
2919 *pStatSlice1Offset = uiPitch; // Slice 1 input frame
2920 }
2921
2922 finish:
2923 return eStatus;
2924 }
2925
AddVeboxDndiState()2926 MOS_STATUS VpVeboxCmdPacketLegacy::AddVeboxDndiState()
2927 {
2928 VP_FUNC_CALL();
2929
2930 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
2931 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
2932 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
2933 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
2934 VP_RENDER_CHK_NULL_RETURN(pRenderData);
2935
2936 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
2937
2938 if (pRenderData->DN.bDnEnabled || pRenderData->DI.bDeinterlace || pRenderData->DI.bQueryVariance)
2939 {
2940 if(veboxItf)
2941 {
2942 return veboxItf->SetVeboxDndiState(&pRenderData->GetDNDIParams());
2943 }
2944 else
2945 {
2946 return pVeboxInterface->AddVeboxDndiState(&pRenderData->GetDNDIParams());
2947 }
2948
2949 }
2950 return MOS_STATUS_SUCCESS;
2951 }
2952
AddVeboxIECPState()2953 MOS_STATUS VpVeboxCmdPacketLegacy::AddVeboxIECPState()
2954 {
2955 VP_FUNC_CALL();
2956
2957 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
2958 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
2959 VpVeboxRenderData* pRenderData = GetLastExecRenderData();
2960
2961 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
2962 VP_RENDER_CHK_NULL_RETURN(pRenderData);
2963
2964 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
2965
2966 if (pRenderData->IECP.IsIecpEnabled())
2967 {
2968 VP_PUBLIC_NORMALMESSAGE("IecpState is added. ace %d, lace %d, becsc %d, tcc %d, ste %d, procamp %d, std %d",
2969 pRenderData->IECP.ACE.bAceEnabled,
2970 pRenderData->IECP.LACE.bLaceEnabled,
2971 pRenderData->IECP.BeCSC.bBeCSCEnabled,
2972 pRenderData->IECP.TCC.bTccEnabled,
2973 pRenderData->IECP.STE.bSteEnabled,
2974 pRenderData->IECP.PROCAMP.bProcampEnabled,
2975 pRenderData->IECP.STE.bStdEnabled);
2976
2977 if(veboxItf)
2978 {
2979 return veboxItf->SetVeboxIecpState(&pRenderData->GetIECPParams());
2980 }
2981 else
2982 {
2983 return pVeboxInterface->AddVeboxIecpState(&pRenderData->GetIECPParams());
2984 }
2985 }
2986 else
2987 {
2988 // BeCsc may not needed for AlphaFromStateSelect == 1 case.
2989 // Refer to IsBeCscNeededForAlphaFill for detail.
2990 VP_PUBLIC_NORMALMESSAGE("IecpState is not added with AlphaFromStateSelect %d",
2991 pRenderData->GetIECPParams().bAlphaEnable);
2992 }
2993 return MOS_STATUS_SUCCESS;
2994 }
2995
IsVeboxGamutStateNeeded()2996 bool VpVeboxCmdPacketLegacy::IsVeboxGamutStateNeeded()
2997 {
2998 VpVeboxRenderData *renderData = GetLastExecRenderData();
2999 return renderData ? renderData->HDR3DLUT.bHdr3DLut : false;
3000 }
3001
3002 //!
3003 //! \brief Add vebox Gamut state
3004 //! \details Add vebox Gamut state
3005 //! \return MOS_STATUS
3006 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
3007 //!
AddVeboxGamutState()3008 MOS_STATUS VpVeboxCmdPacketLegacy::AddVeboxGamutState()
3009 {
3010 VP_FUNC_CALL();
3011
3012 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
3013 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
3014 VpVeboxRenderData *renderData = GetLastExecRenderData();
3015 VP_PUBLIC_CHK_NULL_RETURN(pVeboxInterface);
3016 VP_PUBLIC_CHK_NULL_RETURN(renderData);
3017 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
3018
3019 if (pVeboxInterface &&
3020 IsVeboxGamutStateNeeded())
3021 {
3022 if(veboxItf)
3023 {
3024 VP_PUBLIC_CHK_STATUS_RETURN(veboxItf->SetVeboxGamutState(
3025 &renderData->GetIECPParams(),
3026 &renderData->GetGamutParams()));
3027 }
3028 else
3029 {
3030 VP_PUBLIC_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxGamutState(
3031 &renderData->GetIECPParams(),
3032 &renderData->GetGamutParams()));
3033 }
3034 }
3035
3036 return MOS_STATUS_SUCCESS;
3037 }
3038
3039 //!
3040 //! \brief Add vebox Hdr state
3041 //! \details Add vebox Hdr state
3042 //! \return MOS_STATUS
3043 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
3044 //!
AddVeboxHdrState()3045 MOS_STATUS VpVeboxCmdPacketLegacy::AddVeboxHdrState()
3046 {
3047 VP_FUNC_CALL();
3048
3049 PMHW_VEBOX_INTERFACE pVeboxInterface = m_hwInterface->m_veboxInterface;
3050 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
3051 VpVeboxRenderData *renderData = GetLastExecRenderData();
3052 VP_PUBLIC_CHK_NULL_RETURN(pVeboxInterface);
3053 VP_PUBLIC_CHK_NULL_RETURN(renderData);
3054 MHW_VEBOX_IECP_PARAMS &mhwVeboxIecpParams = renderData->GetIECPParams();
3055 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
3056
3057 if(veboxItf)
3058 {
3059 VP_PUBLIC_CHK_STATUS_RETURN(veboxItf->AddVeboxHdrState(&mhwVeboxIecpParams));
3060 }
3061 else
3062 {
3063 VP_PUBLIC_CHK_STATUS_RETURN(pVeboxInterface->AddVeboxHdrState(&mhwVeboxIecpParams));
3064 }
3065
3066 return MOS_STATUS_SUCCESS;
3067 }
3068
SetupIndirectStates()3069 MOS_STATUS VpVeboxCmdPacketLegacy::SetupIndirectStates()
3070 {
3071 VP_FUNC_CALL();
3072
3073 PMHW_VEBOX_INTERFACE pVeboxInterface = nullptr;
3074 std::shared_ptr<mhw::vebox::Itf> veboxItf = nullptr;
3075 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
3076
3077 VP_RENDER_CHK_NULL_RETURN(pRenderData);
3078 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
3079
3080 pVeboxInterface = m_hwInterface->m_veboxInterface;
3081 VP_RENDER_CHK_NULL_RETURN(pVeboxInterface);
3082 veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(pVeboxInterface->GetNewVeboxInterface());
3083
3084 // Set FMD Params
3085 VP_RENDER_CHK_STATUS_RETURN(ConfigFMDParams(pRenderData->GetDNDIParams().bProgressiveDN, pRenderData->DN.bAutoDetect, pRenderData->DI.bFmdEnabled));
3086
3087 //----------------------------------
3088 // Allocate and reset VEBOX state
3089 //----------------------------------
3090 if(veboxItf)
3091 {
3092 VP_RENDER_CHK_STATUS_RETURN(veboxItf->AssignVeboxState());
3093 }
3094 else
3095 {
3096 VP_RENDER_CHK_STATUS_RETURN(pVeboxInterface->AssignVeboxState());
3097 }
3098
3099 // Set IECP State
3100 VP_RENDER_CHK_STATUS_RETURN(AddVeboxIECPState());
3101
3102 // Set DNDI State
3103 VP_RENDER_CHK_STATUS_RETURN(AddVeboxDndiState());
3104
3105 // Set GAMUT State
3106 VP_RENDER_CHK_STATUS_RETURN(AddVeboxGamutState());
3107
3108 // Set HDR State
3109 VP_RENDER_CHK_STATUS_RETURN(AddVeboxHdrState());
3110
3111 return MOS_STATUS_SUCCESS;
3112 }
3113
VeboxGetBeCSCMatrix(VPHAL_CSPACE inputColorSpace,VPHAL_CSPACE outputColorSpace,MOS_FORMAT inputFormat)3114 void VpVeboxCmdPacketLegacy::VeboxGetBeCSCMatrix(
3115 VPHAL_CSPACE inputColorSpace,
3116 VPHAL_CSPACE outputColorSpace,
3117 MOS_FORMAT inputFormat)
3118 {
3119 VP_FUNC_CALL();
3120
3121 // Get the matrix to use for conversion
3122 VpHal_GetCscMatrix(
3123 inputColorSpace,
3124 outputColorSpace,
3125 m_fCscCoeff,
3126 m_fCscInOffset,
3127 m_fCscOutOffset);
3128
3129 // Vebox CSC converts RGB input to YUV for SFC
3130 // Vebox only supports A8B8G8R8 input, swap the 1st and 3rd
3131 // columns of the transfer matrix for A8R8G8B8 and X8R8G8B8
3132 // This only happens when SFC output is used
3133 if (inputFormat == Format_A8R8G8B8 ||
3134 inputFormat == Format_X8R8G8B8)
3135 {
3136 if (m_PacketCaps.bSFC || inputColorSpace != outputColorSpace)
3137 {
3138 VP_RENDER_NORMALMESSAGE("Swap R and B for format %d, sfc %d, inputColorSpace %d, outputColorSpace %d",
3139 inputFormat, m_PacketCaps.bSFC, inputColorSpace, outputColorSpace);
3140 float fTemp[3] = {};
3141 fTemp[0] = m_fCscCoeff[0];
3142 fTemp[1] = m_fCscCoeff[3];
3143 fTemp[2] = m_fCscCoeff[6];
3144
3145 m_fCscCoeff[0] = m_fCscCoeff[2];
3146 m_fCscCoeff[3] = m_fCscCoeff[5];
3147 m_fCscCoeff[6] = m_fCscCoeff[8];
3148
3149 m_fCscCoeff[2] = fTemp[0];
3150 m_fCscCoeff[5] = fTemp[1];
3151 m_fCscCoeff[8] = fTemp[2];
3152 }
3153 else
3154 {
3155 // Do not swap since no more process needed.
3156 VP_RENDER_NORMALMESSAGE("Not swap R and B for format %d, sfc %d, inputColorSpace %d, outputColorSpace %d",
3157 inputFormat, m_PacketCaps.bSFC, inputColorSpace, outputColorSpace);
3158 }
3159 }
3160 }
3161
IsCmdParamsValid(const MHW_VEBOX_STATE_CMD_PARAMS & VeboxStateCmdParams,const MHW_VEBOX_DI_IECP_CMD_PARAMS & VeboxDiIecpCmdParams,const VP_VEBOX_SURFACE_STATE_CMD_PARAMS & VeboxSurfaceStateCmdParams)3162 MOS_STATUS VpVeboxCmdPacketLegacy::IsCmdParamsValid(
3163 const MHW_VEBOX_STATE_CMD_PARAMS &VeboxStateCmdParams,
3164 const MHW_VEBOX_DI_IECP_CMD_PARAMS &VeboxDiIecpCmdParams,
3165 const VP_VEBOX_SURFACE_STATE_CMD_PARAMS &VeboxSurfaceStateCmdParams)
3166 {
3167 VP_FUNC_CALL();
3168
3169 const MHW_VEBOX_MODE &veboxMode = VeboxStateCmdParams.VeboxMode;
3170
3171 if (veboxMode.DIEnable)
3172 {
3173 if (nullptr == VeboxDiIecpCmdParams.pOsResPrevOutput &&
3174 (MEDIA_VEBOX_DI_OUTPUT_PREVIOUS == veboxMode.DIOutputFrames || MEDIA_VEBOX_DI_OUTPUT_BOTH == veboxMode.DIOutputFrames))
3175 {
3176 MT_ERR1(MT_VP_HAL_RENDER_VE, MT_SURF_ALLOC_HANDLE, 0);
3177 return MOS_STATUS_INVALID_PARAMETER;
3178 }
3179 if (nullptr == VeboxDiIecpCmdParams.pOsResCurrOutput &&
3180 (MEDIA_VEBOX_DI_OUTPUT_CURRENT == veboxMode.DIOutputFrames || MEDIA_VEBOX_DI_OUTPUT_BOTH == veboxMode.DIOutputFrames))
3181 {
3182 MT_ERR1(MT_VP_HAL_RENDER_VE, MT_SURF_ALLOC_HANDLE, 0);
3183 return MOS_STATUS_INVALID_PARAMETER;
3184 }
3185 }
3186
3187 if (m_PacketCaps.bDN && !m_PacketCaps.bDI && !m_PacketCaps.bQueryVariance && !m_PacketCaps.bIECP)
3188 {
3189 if ((VeboxSurfaceStateCmdParams.pSurfInput->osSurface->TileModeGMM == VeboxSurfaceStateCmdParams.pSurfDNOutput->osSurface->TileModeGMM) &&
3190 (VeboxSurfaceStateCmdParams.pSurfInput->osSurface->dwPitch != VeboxSurfaceStateCmdParams.pSurfDNOutput->osSurface->dwPitch))
3191 {
3192 MT_ERR3(MT_VP_MHW_VE_SURFSTATE_INPUT, MT_SURF_TILE_MODE, VeboxSurfaceStateCmdParams.pSurfInput->osSurface->TileModeGMM,
3193 MT_SURF_PITCH, VeboxSurfaceStateCmdParams.pSurfInput->osSurface->dwPitch, MT_SURF_PITCH, VeboxSurfaceStateCmdParams.pSurfDNOutput->osSurface->dwPitch);
3194 return MOS_STATUS_INVALID_PARAMETER;
3195 }
3196 }
3197 return MOS_STATUS_SUCCESS;
3198 }
3199
VeboxSetPerfTag()3200 MOS_STATUS VpVeboxCmdPacketLegacy::VeboxSetPerfTag()
3201 {
3202 VP_FUNC_CALL();
3203
3204 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3205 PVPHAL_PERFTAG pPerfTag = nullptr;
3206 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
3207
3208 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
3209 VP_PUBLIC_CHK_NULL_RETURN(m_currentSurface);
3210 VP_PUBLIC_CHK_NULL_RETURN(m_currentSurface->osSurface);
3211
3212 MOS_FORMAT srcFmt = m_currentSurface->osSurface->Format;
3213
3214 pPerfTag = &pRenderData->PerfTag;
3215
3216 switch (srcFmt)
3217 {
3218 case Format_NV12:
3219 return VeboxSetPerfTagNv12();
3220
3221 CASE_PA_FORMAT:
3222 return VeboxSetPerfTagPaFormat();
3223
3224 case Format_P010:
3225 // P010 Input Support for VEBOX, SFC
3226 *pPerfTag = VPHAL_VEBOX_P010;
3227 break;
3228
3229 case Format_P016:
3230 // P016 Input Support for VEBOX, SFC
3231 *pPerfTag = VPHAL_VEBOX_P016;
3232 break;
3233
3234 case Format_P210:
3235 // P210 Input Support for VEBOX, SFC
3236 *pPerfTag = VPHAL_VEBOX_P210;
3237 break;
3238
3239 case Format_P216:
3240 // P216 Input Support for VEBOX, SFC
3241 *pPerfTag = VPHAL_VEBOX_P216;
3242 break;
3243
3244 case Format_Y210:
3245 // Y210 Input Support for VEBOX, SFC
3246 *pPerfTag = VPHAL_VEBOX_Y210;
3247 break;
3248
3249 case Format_Y216:
3250 // Y216 Input Support for VEBOX, SFC
3251 *pPerfTag = VPHAL_VEBOX_Y216;
3252 break;
3253
3254 case Format_Y410:
3255 // Y410 Input Support for VEBOX, SFC
3256 *pPerfTag = VPHAL_VEBOX_Y410;
3257 break;
3258
3259 case Format_Y416:
3260 // Y416 Input Support for VEBOX, SFC
3261 *pPerfTag = VPHAL_VEBOX_Y416;
3262 break;
3263
3264 CASE_RGB32_FORMAT:
3265 case Format_AYUV:
3266 case Format_A16B16G16R16:
3267 case Format_A16R16G16B16:
3268 case Format_A16B16G16R16F:
3269 case Format_A16R16G16B16F:
3270 *pPerfTag = VPHAL_NONE;
3271 break;
3272
3273 default:
3274 VP_RENDER_ASSERTMESSAGE("Format Not found.");
3275 *pPerfTag = VPHAL_NONE;
3276 eStatus = MOS_STATUS_INVALID_PARAMETER;
3277 } // switch (srcFmt)
3278
3279 return eStatus;
3280 }
3281
VeboxSetPerfTagNv12()3282 MOS_STATUS VpVeboxCmdPacketLegacy::VeboxSetPerfTagNv12()
3283 {
3284 VP_FUNC_CALL();
3285
3286 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3287 PVPHAL_PERFTAG pPerfTag = nullptr;
3288 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
3289
3290 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
3291 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget);
3292 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget->osSurface);
3293
3294 MOS_FORMAT dstFormat = m_renderTarget->osSurface->Format;
3295
3296 pPerfTag = &pRenderData->PerfTag;
3297
3298 if (pRenderData->IsDiEnabled())
3299 {
3300 if (pRenderData->DN.bDnEnabled ||
3301 pRenderData->DN.bChromaDnEnabled)
3302 {
3303 if (IsIECPEnabled())
3304 {
3305 *pPerfTag = VPHAL_NV12_DNDI_422CP;
3306 }
3307 else
3308 {
3309 *pPerfTag = VPHAL_NV12_DNDI_PA;
3310 }
3311 }
3312 else
3313 {
3314 if (IsIECPEnabled())
3315 {
3316 *pPerfTag = VPHAL_PL_DI_422CP;
3317 }
3318 else
3319 {
3320 *pPerfTag = VPHAL_PL_DI_PA;
3321 }
3322 }
3323 }
3324 else
3325 {
3326 if (pRenderData->DN.bDnEnabled ||
3327 pRenderData->DN.bChromaDnEnabled)
3328 {
3329 if (IsOutputPipeVebox())
3330 {
3331 switch (dstFormat)
3332 {
3333 case Format_NV12:
3334 *pPerfTag = VPHAL_NV12_DN_420CP;
3335 break;
3336 CASE_PA_FORMAT:
3337 *pPerfTag = VPHAL_NV12_DN_422CP;
3338 break;
3339 case Format_RGB32:
3340 case Format_A8R8G8B8:
3341 case Format_A8B8G8R8:
3342 *pPerfTag = VPHAL_NV12_DN_RGB32CP;
3343 break;
3344 case Format_P010:
3345 case Format_P016:
3346 case Format_Y410:
3347 case Format_Y416:
3348 case Format_Y210:
3349 case Format_Y216:
3350 case Format_AYUV:
3351 case Format_Y8:
3352 case Format_Y16S:
3353 case Format_Y16U:
3354 *pPerfTag = VPHAL_NONE;
3355 break;
3356 default:
3357 VP_PUBLIC_ASSERTMESSAGE("Output Format Not found.");
3358 return MOS_STATUS_INVALID_PARAMETER;
3359 }
3360 }
3361 else if (IsIECPEnabled())
3362 {
3363 *pPerfTag = VPHAL_NV12_DN_420CP;
3364 }
3365 else
3366 {
3367 *pPerfTag = VPHAL_NV12_DN_NV12;
3368 }
3369 }
3370 else
3371 {
3372 if (IsOutputPipeVebox())
3373 {
3374 switch (dstFormat)
3375 {
3376 case Format_NV12:
3377 *pPerfTag = VPHAL_NV12_420CP;
3378 break;
3379 CASE_PA_FORMAT:
3380 *pPerfTag = VPHAL_NV12_422CP;
3381 break;
3382 case Format_RGB32:
3383 *pPerfTag = VPHAL_NV12_RGB32CP;
3384 break;
3385 case Format_A8R8G8B8:
3386 case Format_A8B8G8R8:
3387 case Format_R10G10B10A2:
3388 case Format_B10G10R10A2:
3389 *pPerfTag = VPHAL_NV12_RGB32CP;
3390 break;
3391 case Format_P010:
3392 case Format_P016:
3393 case Format_Y410:
3394 case Format_Y416:
3395 case Format_Y210:
3396 case Format_Y216:
3397 case Format_AYUV:
3398 case Format_Y8:
3399 case Format_Y16S:
3400 case Format_Y16U:
3401 *pPerfTag = VPHAL_NONE;
3402 break;
3403 default:
3404 VP_RENDER_ASSERTMESSAGE("Output Format Not found.");
3405 return MOS_STATUS_INVALID_PARAMETER;
3406 }
3407 }
3408 else
3409 {
3410 *pPerfTag = VPHAL_NV12_420CP;
3411 }
3412 }
3413 }
3414 return MOS_STATUS_SUCCESS;
3415 }
3416
VeboxSetPerfTagPaFormat()3417 MOS_STATUS VpVeboxCmdPacketLegacy::VeboxSetPerfTagPaFormat()
3418 {
3419 VP_FUNC_CALL();
3420
3421 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3422 PVPHAL_PERFTAG pPerfTag = nullptr;
3423 VpVeboxRenderData *pRenderData = GetLastExecRenderData();
3424
3425 VP_PUBLIC_CHK_NULL_RETURN(pRenderData);
3426 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget);
3427 VP_PUBLIC_CHK_NULL_RETURN(m_renderTarget->osSurface);
3428
3429 MOS_FORMAT dstFormat = m_renderTarget->osSurface->Format;
3430
3431 pPerfTag = &pRenderData->PerfTag;
3432
3433 if (pRenderData->IsDiEnabled())
3434 {
3435 if (pRenderData->DN.bDnEnabled ||
3436 pRenderData->DN.bChromaDnEnabled)
3437 {
3438 if (IsIECPEnabled())
3439 {
3440 *pPerfTag = VPHAL_PA_DNDI_422CP;
3441 }
3442 else
3443 {
3444 *pPerfTag = VPHAL_PA_DNDI_PA;
3445 }
3446 }
3447 else
3448 {
3449 if (IsIECPEnabled())
3450 {
3451 *pPerfTag = VPHAL_PA_DI_422CP;
3452 }
3453 else
3454 {
3455 *pPerfTag = VPHAL_PA_DI_PA;
3456 }
3457 }
3458 }
3459 else
3460 {
3461 if (pRenderData->DN.bDnEnabled ||
3462 pRenderData->DN.bChromaDnEnabled)
3463 {
3464 if (IsOutputPipeVebox())
3465 {
3466 switch (dstFormat)
3467 {
3468 case Format_NV12:
3469 *pPerfTag = VPHAL_PA_DN_420CP;
3470 break;
3471 CASE_PA_FORMAT:
3472 *pPerfTag = VPHAL_PA_DN_422CP;
3473 break;
3474 case Format_RGB32:
3475 *pPerfTag = VPHAL_PA_DN_RGB32CP;
3476 break;
3477 case Format_A8R8G8B8:
3478 case Format_A8B8G8R8:
3479 case Format_R10G10B10A2:
3480 case Format_B10G10R10A2:
3481 *pPerfTag = VPHAL_PA_RGB32CP;
3482 break;
3483 case Format_P010:
3484 case Format_P016:
3485 case Format_Y410:
3486 case Format_Y416:
3487 case Format_Y210:
3488 case Format_Y216:
3489 case Format_AYUV:
3490 case Format_Y8:
3491 case Format_Y16S:
3492 case Format_Y16U:
3493 *pPerfTag = VPHAL_NONE;
3494 break;
3495 default:
3496 VP_RENDER_ASSERTMESSAGE("Output Format Not found.");
3497 return MOS_STATUS_INVALID_PARAMETER;
3498 }
3499 }
3500 else if (IsIECPEnabled())
3501 {
3502 *pPerfTag = VPHAL_PA_DN_422CP;
3503 }
3504 else
3505 {
3506 *pPerfTag = VPHAL_PA_DN_PA;
3507 }
3508 }
3509 else
3510 {
3511 if (IsOutputPipeVebox())
3512 {
3513 switch (dstFormat)
3514 {
3515 case Format_NV12:
3516 *pPerfTag = VPHAL_PA_420CP;
3517 break;
3518 CASE_PA_FORMAT:
3519 *pPerfTag = VPHAL_PA_422CP;
3520 break;
3521 case Format_RGB32:
3522 *pPerfTag = VPHAL_PA_RGB32CP;
3523 break;
3524 case Format_A8R8G8B8:
3525 case Format_A8B8G8R8:
3526 case Format_R10G10B10A2:
3527 case Format_B10G10R10A2:
3528 *pPerfTag = VPHAL_PA_RGB32CP;
3529 break;
3530 case Format_P010:
3531 case Format_P016:
3532 case Format_Y410:
3533 case Format_Y416:
3534 case Format_Y210:
3535 case Format_Y216:
3536 case Format_AYUV:
3537 case Format_Y8:
3538 case Format_Y16S:
3539 case Format_Y16U:
3540 *pPerfTag = VPHAL_NONE;
3541 break;
3542 default:
3543 VP_RENDER_ASSERTMESSAGE("Output Format Not found.");
3544 return MOS_STATUS_INVALID_PARAMETER;
3545 }
3546 }
3547 else
3548 {
3549 *pPerfTag = VPHAL_PA_422CP;
3550 }
3551 }
3552 }
3553
3554 return MOS_STATUS_SUCCESS;
3555 }
3556
3557 //!
3558 //! \brief Vebox get statistics surface base
3559 //! \details Calculate address of statistics surface address based on the
3560 //! functions which were enabled in the previous call.
3561 //! \param uint8_t* pStat
3562 //! [in] Pointer to Statistics surface
3563 //! \param uint8_t* * pStatSlice0Base
3564 //! [out] Statistics surface Slice 0 base pointer
3565 //! \param uint8_t* * pStatSlice1Base
3566 //! [out] Statistics surface Slice 1 base pointer
3567 //! \return MOS_STATUS
3568 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
3569 //!
GetStatisticsSurfaceBase(uint8_t * pStat,uint8_t ** pStatSlice0Base,uint8_t ** pStatSlice1Base)3570 MOS_STATUS VpVeboxCmdPacketLegacy::GetStatisticsSurfaceBase(
3571 uint8_t *pStat,
3572 uint8_t **pStatSlice0Base,
3573 uint8_t **pStatSlice1Base)
3574 {
3575 VP_FUNC_CALL();
3576
3577 int32_t iOffsetSlice0, iOffsetSlice1;
3578 MOS_STATUS eStatus;
3579
3580 eStatus = MOS_STATUS_UNKNOWN;
3581
3582 // Calculate the offsets of Slice0 and Slice1
3583 VP_RENDER_CHK_STATUS(VpVeboxCmdPacketLegacy::GetStatisticsSurfaceOffsets(
3584 &iOffsetSlice0,
3585 &iOffsetSlice1));
3586
3587 *pStatSlice0Base = pStat + iOffsetSlice0; // Slice 0 current frame
3588 *pStatSlice1Base = pStat + iOffsetSlice1; // Slice 1 current frame
3589
3590 finish:
3591 return eStatus;
3592 }
3593
UpdateVeboxStates()3594 MOS_STATUS VpVeboxCmdPacketLegacy::UpdateVeboxStates()
3595 {
3596 VP_FUNC_CALL();
3597 MOS_STATUS eStatus;
3598 uint8_t *pStat = nullptr;
3599 uint8_t *pStatSlice0Base, *pStatSlice1Base;
3600 uint32_t dwQuery = 0;
3601 MOS_LOCK_PARAMS LockFlags;
3602 VpVeboxRenderData *renderData = GetLastExecRenderData();
3603
3604 VP_PUBLIC_CHK_NULL_RETURN(renderData);
3605 VP_PUBLIC_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput);
3606 VP_PUBLIC_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput->osSurface);
3607 VP_PUBLIC_CHK_NULL_RETURN(m_sfcRender);
3608
3609 eStatus = MOS_STATUS_SUCCESS;
3610
3611 if (!renderData->DN.bHvsDnEnabled)
3612 {
3613 // no need to update, direct return.
3614 return MOS_STATUS_SUCCESS;
3615 }
3616
3617 // Update DN State in CPU
3618 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
3619 LockFlags.ReadOnly = 1;
3620
3621 // Get Statistic surface
3622 pStat = (uint8_t *)m_allocator->Lock(
3623 &m_veboxPacketSurface.pStatisticsOutput->osSurface->OsResource,
3624 &LockFlags);
3625
3626 VP_PUBLIC_CHK_NULL_RETURN(pStat);
3627
3628 VP_RENDER_CHK_STATUS_RETURN(GetStatisticsSurfaceBase(
3629 pStat,
3630 &pStatSlice0Base,
3631 &pStatSlice1Base));
3632
3633 // Query platform dependent GNE offset
3634 VP_RENDER_CHK_STATUS_RETURN(QueryStatLayoutGNE(
3635 VEBOX_STAT_QUERY_GNE_OFFEST,
3636 &dwQuery,
3637 pStatSlice0Base,
3638 pStatSlice1Base));
3639
3640 #if VEBOX_AUTO_DENOISE_SUPPORTED
3641 VP_RENDER_CHK_STATUS_RETURN(UpdateDnHVSParameters(
3642 (uint32_t *)(pStatSlice0Base + dwQuery),
3643 (uint32_t *)(pStatSlice1Base + dwQuery)));
3644 #endif
3645
3646 // unlock the statistic surface
3647 VP_RENDER_CHK_STATUS_RETURN(m_allocator->UnLock(
3648 &m_veboxPacketSurface.pStatisticsOutput->osSurface->OsResource));
3649
3650 return MOS_STATUS_SUCCESS;
3651 }
3652
InitSurfMemCacheControl(VP_EXECUTE_CAPS packetCaps)3653 MOS_STATUS VpVeboxCmdPacketLegacy::InitSurfMemCacheControl(VP_EXECUTE_CAPS packetCaps)
3654 {
3655 VP_FUNC_CALL();
3656
3657 MOS_HW_RESOURCE_DEF Usage = MOS_HW_RESOURCE_DEF_MAX;
3658 MEMORY_OBJECT_CONTROL_STATE MemObjCtrl = {};
3659 PMOS_INTERFACE pOsInterface = nullptr;
3660 PVP_VEBOX_CACHE_CNTL pSettings = nullptr;
3661
3662 if (nullptr == m_surfMemCacheCtl)
3663 {
3664 m_surfMemCacheCtl = MOS_New(VP_VEBOX_CACHE_CNTL);
3665 }
3666
3667 VP_PUBLIC_CHK_NULL_RETURN(m_surfMemCacheCtl);
3668 VP_PUBLIC_CHK_NULL_RETURN(m_hwInterface);
3669 VP_PUBLIC_CHK_NULL_RETURN(m_hwInterface->m_osInterface);
3670
3671 MOS_ZeroMemory(m_surfMemCacheCtl, sizeof(VP_VEBOX_CACHE_CNTL));
3672
3673 pOsInterface = m_hwInterface->m_osInterface;
3674 pSettings = m_surfMemCacheCtl;
3675
3676 pSettings->bDnDi = true;
3677
3678 if (pSettings->bDnDi)
3679 {
3680 pSettings->DnDi.bL3CachingEnabled = true;
3681
3682 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.CurrentInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3683 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.PreviousInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3684 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.STMMInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3685 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.STMMOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3686 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.DnOutSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3687
3688 if (packetCaps.bVebox && !packetCaps.bSFC && !packetCaps.bRender)
3689 {
3690 // Disable cache for output surface in vebox only condition
3691 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.CurrentOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3692 }
3693 else
3694 {
3695 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.CurrentOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3696 }
3697
3698 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.StatisticsOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3699 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.AlphaOrVignetteSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3700 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.LaceOrAceOrRgbHistogramSurfCtrl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3701 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.SkinScoreSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3702 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.LaceLookUpTablesSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3703 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.Vebox3DLookUpTablesSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3704 }
3705 else
3706 {
3707 pSettings->DnDi.bL3CachingEnabled = false;
3708
3709 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.CurrentInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3710 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.PreviousInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3711 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.STMMInputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3712 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.STMMOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3713 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.DnOutSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3714 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.CurrentOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3715 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.StatisticsOutputSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3716 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.AlphaOrVignetteSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3717 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.LaceOrAceOrRgbHistogramSurfCtrl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3718 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.SkinScoreSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3719 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.LaceLookUpTablesSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3720 VPHAL_SET_SURF_MEMOBJCTL(pSettings->DnDi.Vebox3DLookUpTablesSurfMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3721 }
3722
3723 if (pSettings->bLace)
3724 {
3725 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.FrameHistogramSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3726 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.AggregatedHistogramSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3727 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.StdStatisticsSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3728 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.PwlfInSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3729 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.PwlfOutSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3730 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.WeitCoefSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_SurfaceState);
3731 }
3732 else
3733 {
3734 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.FrameHistogramSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3735 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.AggregatedHistogramSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3736 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.StdStatisticsSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3737 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.PwlfInSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3738 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.PwlfOutSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3739 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.WeitCoefSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3740 VPHAL_SET_SURF_MEMOBJCTL(pSettings->Lace.GlobalToneMappingCurveLUTSurfaceMemObjCtl, MOS_MP_RESOURCE_USAGE_DEFAULT);
3741 }
3742
3743 return MOS_STATUS_SUCCESS;
3744 }
3745
VpHalCspace2MhwCspace(VPHAL_CSPACE cspace)3746 MHW_CSPACE VpVeboxCmdPacketLegacy::VpHalCspace2MhwCspace(VPHAL_CSPACE cspace)
3747 {
3748 VP_FUNC_CALL();
3749
3750 switch (cspace)
3751 {
3752 case CSpace_Source:
3753 return MHW_CSpace_Source;
3754
3755 case CSpace_RGB:
3756 return MHW_CSpace_RGB;
3757
3758 case CSpace_YUV:
3759 return MHW_CSpace_YUV;
3760
3761 case CSpace_Gray:
3762 return MHW_CSpace_Gray;
3763
3764 case CSpace_Any:
3765 return MHW_CSpace_Any;
3766
3767 case CSpace_sRGB:
3768 return MHW_CSpace_sRGB;
3769
3770 case CSpace_stRGB:
3771 return MHW_CSpace_stRGB;
3772
3773 case CSpace_BT601:
3774 return MHW_CSpace_BT601;
3775
3776 case CSpace_BT601_FullRange:
3777 return MHW_CSpace_BT601_FullRange;
3778
3779 case CSpace_BT709:
3780 return MHW_CSpace_BT709;
3781
3782 case CSpace_BT709_FullRange:
3783 return MHW_CSpace_BT709_FullRange;
3784
3785 case CSpace_xvYCC601:
3786 return MHW_CSpace_xvYCC601;
3787
3788 case CSpace_xvYCC709:
3789 return MHW_CSpace_xvYCC709;
3790
3791 case CSpace_BT601Gray:
3792 return MHW_CSpace_BT601Gray;
3793
3794 case CSpace_BT601Gray_FullRange:
3795 return MHW_CSpace_BT601Gray_FullRange;
3796
3797 case CSpace_BT2020:
3798 return MHW_CSpace_BT2020;
3799
3800 case CSpace_BT2020_RGB:
3801 return MHW_CSpace_BT2020_RGB;
3802
3803 case CSpace_BT2020_FullRange:
3804 return MHW_CSpace_BT2020_FullRange;
3805
3806 case CSpace_BT2020_stRGB:
3807 return MHW_CSpace_BT2020_stRGB;
3808
3809 case CSpace_None:
3810 default:
3811 return MHW_CSpace_None;
3812 }
3813 }
3814
3815 }
3816
3817