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