Debian Codegraph @

media_driver/agnostic/Xe_M/Xe_XPM/hw/mhw_vebox_xe_xpm.cpp

raw
1 /*===================== begin_copyright_notice ==================================
2
3 # Copyright (c) 2020-2021, Intel Corporation
4
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
11
12 # The above copyright notice and this permission notice shall be included
13 # in all copies or substantial portions of the Software.
14
15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 # OTHER DEALINGS IN THE SOFTWARE.
22
23 ======================= end_copyright_notice ==================================*/
24 //!
25 //! \file mhw_vebox_xe_xpm.cpp
26 //! \brief Constructs vebox commands on Xe_XPM platforms
27 //! \details Each client facing function both creates a HW command and adds
28 //! that command to a command or batch buffer.
29 //!
30
31 #include "mhw_vebox_xe_xpm.h"
32 #include "mhw_vebox_hwcmd_xe_xpm.h"
33 #include "mhw_utilities_xe_xpm.h"
34 #include "mos_solo_generic.h"
35
36 MhwVeboxInterfaceXe_Xpm::MhwVeboxInterfaceXe_Xpm(PMOS_INTERFACE pOsInterface)
37 : MhwVeboxInterfaceG12(pOsInterface)
38 {
39 MHW_FUNCTION_ENTER;
40 MEDIA_SYSTEM_INFO *pGtSystemInfo;
41
42 m_veboxScalabilitySupported = false;
43
44 MHW_CHK_NULL_NO_STATUS_RETURN(pOsInterface);
45 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
46 MHW_CHK_NULL_NO_STATUS_RETURN(pGtSystemInfo);
47 MHW_NORMALMESSAGE("Vebox Number Enabled %d", pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled);
48
49 if (pGtSystemInfo->VEBoxInfo.IsValid &&
50 pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled > 1)
51 {
52 m_veboxScalabilitySupported = true;
53 }
54 }
55
56 MhwVeboxInterfaceXe_Xpm::~MhwVeboxInterfaceXe_Xpm()
57 {
58 MHW_FUNCTION_ENTER;
59 }
60
61 MOS_STATUS MhwVeboxInterfaceXe_Xpm::AddVeboxDiIecp(
62 PMOS_COMMAND_BUFFER pCmdBuffer,
63 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
64 {
65 MOS_STATUS eStatus;
66 PMOS_INTERFACE pOsInterface;
67 MHW_RESOURCE_PARAMS ResourceParams;
68
69 mhw_vebox_xe_xpm::VEB_DI_IECP_CMD cmd;
70 MHW_CHK_NULL(m_osInterface);
71 MHW_CHK_NULL(pCmdBuffer);
72 MHW_CHK_NULL(pVeboxDiIecpCmdParams);
73 MHW_ASSERT(MOS_IS_ALIGNED(pVeboxDiIecpCmdParams->dwCurrInputSurfOffset, MHW_PAGE_SIZE)); // offset should be aligned with 4KB
74 MHW_ASSERT(MOS_IS_ALIGNED(pVeboxDiIecpCmdParams->dwPrevInputSurfOffset, MHW_PAGE_SIZE)); // offset should be aligned with 4KB
75
76 // Initialize
77 eStatus = MOS_STATUS_SUCCESS;
78 pOsInterface = m_osInterface;
79
80 if (pVeboxDiIecpCmdParams->pOsResCurrInput)
81 {
82 if (pVeboxDiIecpCmdParams->CurInputSurfMMCState != MOS_MEMCOMP_DISABLED)
83 {
84 mhw_vebox_xe_xpm::VEB_DI_IECP_COMMAND_SURFACE_CONTROL_BITS_CMD *pSurfCtrlBits;
85 pSurfCtrlBits = (mhw_vebox_xe_xpm::VEB_DI_IECP_COMMAND_SURFACE_CONTROL_BITS_CMD*)&pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value;
86 pSurfCtrlBits->DW0.MemoryCompressionEnable = 1;
87 pSurfCtrlBits->DW0.CompressionType = pSurfCtrlBits->COMPRESSION_TYPE_MEDIACOMPRESSIONENABLED;
88 if (pVeboxDiIecpCmdParams->CurInputSurfMMCState == MOS_MEMCOMP_RC)
89 {
90 pSurfCtrlBits->DW0.CompressionType = pSurfCtrlBits->COMPRESSION_TYPE_RENDERCOMPRESSIONENABLED;
91 }
92 }
93
94 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
95 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResCurrInput;
96 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->dwCurrInputSurfOffset + pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value;
97 ResourceParams.pdwCmd = & (cmd.DW2.Value);
98 ResourceParams.dwLocationInCmd = 2;
99 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
100
101 MHW_CHK_STATUS(pfnAddResourceToCmd(
102 pOsInterface,
103 pCmdBuffer,
104 &ResourceParams));
105 }
106
107 if (pVeboxDiIecpCmdParams->pOsResPrevInput)
108 {
109 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
110 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevInput;
111 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value + pVeboxDiIecpCmdParams->dwPrevInputSurfOffset;
112 ResourceParams.pdwCmd = & (cmd.DW4.Value);
113 ResourceParams.dwLocationInCmd = 4;
114 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
115
116 MHW_CHK_STATUS(pfnAddResourceToCmd(
117 pOsInterface,
118 pCmdBuffer,
119 &ResourceParams));
120 }
121
122 if (pVeboxDiIecpCmdParams->pOsResStmmInput)
123 {
124 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
125 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStmmInput;
126 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value;
127 ResourceParams.pdwCmd = & (cmd.DW6.Value);
128 ResourceParams.dwLocationInCmd = 6;
129 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
130
131 MHW_CHK_STATUS(pfnAddResourceToCmd(
132 pOsInterface,
133 pCmdBuffer,
134 &ResourceParams));
135 }
136
137 if (pVeboxDiIecpCmdParams->pOsResStmmOutput)
138 {
139 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
140 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStmmOutput;
141 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value;
142 ResourceParams.pdwCmd = & (cmd.DW8.Value);
143 ResourceParams.dwLocationInCmd = 8;
144 ResourceParams.bIsWritable = true;
145 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
146
147 MHW_CHK_STATUS(pfnAddResourceToCmd(
148 pOsInterface,
149 pCmdBuffer,
150 &ResourceParams));
151 }
152
153 if (pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput)
154 {
155 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
156 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput;
157 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value;
158 ResourceParams.pdwCmd = & (cmd.DW10.Value);
159 ResourceParams.dwLocationInCmd = 10;
160 ResourceParams.bIsWritable = true;
161 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
162
163 MHW_CHK_STATUS(pfnAddResourceToCmd(
164 pOsInterface,
165 pCmdBuffer,
166 &ResourceParams));
167 }
168
169 if (pVeboxDiIecpCmdParams->pOsResCurrOutput)
170 {
171 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
172 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResCurrOutput;
173 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value + pVeboxDiIecpCmdParams->dwCurrOutputSurfOffset;
174 ResourceParams.pdwCmd = & (cmd.DW12.Value);
175 ResourceParams.dwLocationInCmd = 12;
176 ResourceParams.bIsWritable = true;
177 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
178
179 MHW_CHK_STATUS(pfnAddResourceToCmd(
180 pOsInterface,
181 pCmdBuffer,
182 &ResourceParams));
183 }
184
185 if (pVeboxDiIecpCmdParams->pOsResPrevOutput)
186 {
187 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
188 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResPrevOutput;
189 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value;
190 ResourceParams.pdwCmd = & (cmd.DW14.Value);
191 ResourceParams.dwLocationInCmd = 14;
192 ResourceParams.bIsWritable = true;
193 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
194
195 MHW_CHK_STATUS(pfnAddResourceToCmd(
196 pOsInterface,
197 pCmdBuffer,
198 &ResourceParams));
199 }
200
201 if (pVeboxDiIecpCmdParams->pOsResStatisticsOutput)
202 {
203 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
204 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResStatisticsOutput;
205 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->StatisticsOutputSurfCtrl.Value;
206 ResourceParams.pdwCmd = & (cmd.DW16.Value);
207 ResourceParams.dwLocationInCmd = 16;
208 ResourceParams.bIsWritable = true;
209 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
210
211 MHW_CHK_STATUS(pfnAddResourceToCmd(
212 pOsInterface,
213 pCmdBuffer,
214 &ResourceParams));
215 }
216
217 if (pVeboxDiIecpCmdParams->pOsResAlphaOrVignette)
218 {
219 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
220 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResAlphaOrVignette;
221 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->AlphaOrVignetteSurfCtrl.Value;
222 ResourceParams.pdwCmd = & (cmd.DW18.Value);
223 ResourceParams.dwLocationInCmd = 18;
224 ResourceParams.bIsWritable = true;
225 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
226
227 MHW_CHK_STATUS(pfnAddResourceToCmd(
228 pOsInterface,
229 pCmdBuffer,
230 &ResourceParams));
231 }
232
233 if (pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram)
234 {
235 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
236 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram;
237 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->LaceOrAceOrRgbHistogramSurfCtrl.Value;
238 ResourceParams.pdwCmd = & (cmd.DW20.Value);
239 ResourceParams.dwLocationInCmd = 20;
240 ResourceParams.bIsWritable = true;
241 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
242
243 MHW_CHK_STATUS(pfnAddResourceToCmd(
244 pOsInterface,
245 pCmdBuffer,
246 &ResourceParams));
247 }
248
249 if (pVeboxDiIecpCmdParams->pOsResSkinScoreSurface)
250 {
251 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
252 ResourceParams.presResource = pVeboxDiIecpCmdParams->pOsResSkinScoreSurface;
253 ResourceParams.dwOffset = pVeboxDiIecpCmdParams->SkinScoreSurfaceSurfCtrl.Value;
254 ResourceParams.pdwCmd = & (cmd.DW22.Value);
255 ResourceParams.dwLocationInCmd = 22;
256 ResourceParams.bIsWritable = true;
257 ResourceParams.HwCommandType = MOS_VEBOX_DI_IECP;
258
259 MHW_CHK_STATUS(pfnAddResourceToCmd(
260 pOsInterface,
261 pCmdBuffer,
262 &ResourceParams));
263 }
264
265 if (m_veboxScalabilityEnabled == false)
266 {
267 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
268 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
269 }
270 else
271 {
272 uint32_t iMediumX;
273 MHW_ASSERT(pVeboxDiIecpCmdParams->dwEndingX >= m_numofVebox * 64 - 1);
274
275 iMediumX = MOS_ALIGN_FLOOR(((pVeboxDiIecpCmdParams->dwEndingX + 1) / m_numofVebox), 64);
276 iMediumX = MOS_CLAMP_MIN_MAX(iMediumX, 64, (pVeboxDiIecpCmdParams->dwEndingX - 63));
277
278 if (m_numofVebox == 2)
279 {
280 if (m_indexofVebox == MHW_VEBOX_INDEX_0)
281 {
282 cmd.DW1.EndingX = iMediumX - 1;
283 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
284 }
285 else if (m_indexofVebox == MHW_VEBOX_INDEX_1)
286 {
287 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
288 cmd.DW1.StartingX = iMediumX;
289 }
290 else
291 {
292 MHW_ASSERTMESSAGE("Unsupported Vebox Scalability Settings");
293 }
294 }
295 else if (m_numofVebox == 3)
296 {
297 if (m_indexofVebox == MHW_VEBOX_INDEX_0)
298 {
299 cmd.DW1.EndingX = iMediumX - 1;
300 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
301 }
302 else if (m_indexofVebox == MHW_VEBOX_INDEX_1)
303 {
304 cmd.DW1.EndingX = 2 * iMediumX - 1;
305 cmd.DW1.StartingX = iMediumX;
306 }
307 else if (m_indexofVebox == MHW_VEBOX_INDEX_2)
308 {
309 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
310 cmd.DW1.StartingX = 2 * iMediumX;
311 }
312 else
313 {
314 MHW_ASSERTMESSAGE("Unsupported Vebox Scalability Settings");
315 }
316 }
317 else if (m_numofVebox == 4)
318 {
319 if (m_indexofVebox == MHW_VEBOX_INDEX_0)
320 {
321 cmd.DW1.EndingX = iMediumX - 1;
322 cmd.DW1.StartingX = pVeboxDiIecpCmdParams->dwStartingX;
323 }
324 else if (m_indexofVebox == MHW_VEBOX_INDEX_1)
325 {
326 cmd.DW1.EndingX = 2 * iMediumX - 1;
327 cmd.DW1.StartingX = iMediumX;
328 }
329 else if (m_indexofVebox == MHW_VEBOX_INDEX_2)
330 {
331 cmd.DW1.EndingX = 3 * iMediumX - 1;
332 cmd.DW1.StartingX = 2 * iMediumX;
333 }
334 else if (m_indexofVebox == MHW_VEBOX_INDEX_3)
335 {
336 cmd.DW1.EndingX = pVeboxDiIecpCmdParams->dwEndingX;
337 cmd.DW1.StartingX = 3 * iMediumX;
338 }
339 else
340 {
341 MHW_ASSERTMESSAGE("Unsupported Vebox Scalability Settings");
342 }
343 }
344
345 if (m_usingSfc)
346 {
347 cmd.DW1.SplitWorkloadEnable = true;
348
349 if ((pVeboxDiIecpCmdParams->dwEndingX + 1) != m_numofVebox * iMediumX)
350 {
351 if (m_indexofVebox < m_numofVebox - 1)
352 {
353 cmd.DW1.EndingX += 64;
354 }
355
356 if (m_indexofVebox >= MHW_VEBOX_INDEX_1)
357 {
358 cmd.DW1.StartingX += 64;
359 }
360 }
361 }
362 else
363 {
364 cmd.DW1.SplitWorkloadEnable = false;
365 }
366
367 cmd.DW24.OutputEndingX = cmd.DW1.EndingX;
368 cmd.DW24.OutputStartingX = cmd.DW1.StartingX;
369
370 if (m_usingSfc)
371 {
372 // Use left overfetch for sfc split
373 if (cmd.DW1.StartingX >= 64)
374 {
375 cmd.DW1.StartingX -= 64;
376 }
377 }
378
379 MT_LOG3(MT_VP_MHW_VE_SCALABILITY, MT_NORMAL, MT_VP_MHW_VE_SCALABILITY_EN, m_veboxScalabilityEnabled,
380 MT_VP_MHW_VE_SCALABILITY_USE_SFC, m_usingSfc, MT_VP_MHW_VE_SCALABILITY_IDX, m_indexofVebox);
381
382 MHW_NORMALMESSAGE("VEBOX%d STATE: startx %d endx %d", m_indexofVebox, cmd.DW1.StartingX, cmd.DW1.EndingX);
383 MHW_NORMALMESSAGE("VEBOX%d STATE: output startx %d endx %d", m_indexofVebox, cmd.DW24.OutputStartingX, cmd.DW24.OutputEndingX);
384 }
385
386 pOsInterface->pfnAddCommand(pCmdBuffer, &cmd, cmd.byteSize);
387
388 finish:
389 return eStatus;
390 }
391
392 MOS_STATUS MhwVeboxInterfaceXe_Xpm::VeboxAdjustBoundary(
393 PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,
394 uint32_t *pdwSurfaceWidth,
395 uint32_t *pdwSurfaceHeight,
396 bool bDIEnable,
397 bool b3DlutEnable)
398 {
399 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
400 MEDIA_FEATURE_TABLE *pSkuTable = nullptr;
401
402 MHW_CHK_NULL(pSurfaceParam);
403 MHW_CHK_NULL(pdwSurfaceWidth);
404 MHW_CHK_NULL(pdwSurfaceHeight);
405 MHW_CHK_NULL(m_osInterface);
406
407 pSkuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
408 MHW_CHK_NULL(pSkuTable);
409
410 MHW_CHK_STATUS(MhwVeboxInterfaceG12::VeboxAdjustBoundary(pSurfaceParam, pdwSurfaceWidth, pdwSurfaceHeight, bDIEnable));
411
412 // match the vebox width with sfc input width to fix corruption issue when sfc scalability enabled in emu
413 if (m_veboxScalabilityEnabled && m_usingSfc && m_osInterface->bSimIsActive)
414 {
415 *pdwSurfaceWidth = MOS_ALIGN_CEIL(*pdwSurfaceWidth, 16);
416 *pdwSurfaceHeight = MOS_ALIGN_CEIL(*pdwSurfaceHeight, 4);
417 }
418
419 if (b3DlutEnable && MEDIA_IS_SKU(pSkuTable, FtrHeight8AlignVE3DLUTDualPipe))
420 {
421 *pdwSurfaceHeight = MOS_ALIGN_CEIL(*pdwSurfaceHeight, 8);
422 MHW_NORMALMESSAGE("Align Frame Height as 8x due to 3DlutEnable");
423 }
424
425 finish:
426 return eStatus;
427 }
428
429 MOS_STATUS MhwVeboxInterfaceXe_Xpm::AddVeboxDndiState(
430 PMHW_VEBOX_DNDI_PARAMS pVeboxDndiParams)
431 {
432 PMHW_VEBOX_HEAP pVeboxHeap;
433 uint32_t uiOffset;
434 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
435
436 mhw_vebox_xe_xpm::VEBOX_DNDI_STATE_CMD *pVeboxDndiState, mVeboxDndiState;
437
438 MHW_CHK_NULL(pVeboxDndiParams);
439 MHW_CHK_NULL(m_veboxHeap);
440 pVeboxHeap = m_veboxHeap;
441
442 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
443 pVeboxDndiState =
444 (mhw_vebox_xe_xpm::VEBOX_DNDI_STATE_CMD *)(pVeboxHeap->pLockedDriverResourceMem +
445 pVeboxHeap->uiDndiStateOffset +
446 uiOffset);
447 MHW_CHK_NULL(pVeboxDndiState);
448 *pVeboxDndiState = mVeboxDndiState;
449
450 eStatus = MhwVeboxInterfaceG12::AddVeboxDndiState(pVeboxDndiParams);
451
452 if (pVeboxDndiParams->bSCDEnable)
453 {
454 pVeboxDndiState->DW34.SignBitForMinimumStmm = 1;
455 pVeboxDndiState->DW34.SignBitForMaximumStmm = 1;
456 pVeboxDndiState->DW34.SignBitForSmoothMvThreshold = 1;
457 }
458 else
459 {
460 pVeboxDndiState->DW34.SignBitForMinimumStmm = 0;
461 pVeboxDndiState->DW34.SignBitForMaximumStmm = 0;
462 pVeboxDndiState->DW34.SignBitForSmoothMvThreshold = 0;
463 }
464
465 finish:
466 return eStatus;
467 }
468
469 //!
470 //! \brief Set which vebox can be used by HW
471 //! \details VPHAL set which VEBOX can be use by HW
472 //! \param [in] dwVeboxIndex;
473 //! set which Vebox can be used by HW
474 //! \param [in] dwVeboxCount;
475 //! set Vebox Count
476 //! \param [in] dwUsingSFC;
477 //! set whether using SFC
478 //! \return MOS_STATUS
479 //! MOS_STATUS_SUCCESS if success, else fail reason
480 MOS_STATUS MhwVeboxInterfaceXe_Xpm::SetVeboxIndex(
481 uint32_t dwVeboxIndex,
482 uint32_t dwVeboxCount,
483 uint32_t dwUsingSFC)
484 {
485 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
486
487 MHW_ASSERT(dwVeboxIndex < dwVeboxCount);
488
489 m_indexofVebox = dwVeboxIndex;
490 m_numofVebox = dwVeboxCount;
491 m_veboxScalabilityEnabled = (dwVeboxCount > 1) ? m_veboxScalabilitySupported : false;
492 m_usingSfc = dwUsingSFC;
493
494 return eStatus;
495 }
496
497 //!
498 //! \brief Create Gpu Context for Vebox
499 //! \details Create Gpu Context for Vebox
500 //! \param [in] pOsInterface
501 //! OS interface
502 //! \param [in] VeboxGpuContext
503 //! Vebox Gpu Context
504 //! \param [in] VeboxGpuNode
505 //! Vebox Gpu Node
506 //! \return MOS_STATUS
507 //! MOS_STATUS_SUCCESS if success, else fail reason
508 //!
509 MOS_STATUS MhwVeboxInterfaceXe_Xpm::CreateGpuContext(
510 PMOS_INTERFACE pOsInterface,
511 MOS_GPU_CONTEXT VeboxGpuContext,
512 MOS_GPU_NODE VeboxGpuNode)
513 {
514 MEDIA_FEATURE_TABLE *skuTable;
515 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
516 MOS_GPUCTX_CREATOPTIONS_ENHANCED createOptionenhanced;
517 MEDIA_SYSTEM_INFO* pGtSystemInfo = nullptr;
518
519 MHW_CHK_NULL(pOsInterface);
520
521 skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
522 MHW_CHK_NULL(skuTable);
523
524 #if (_DEBUG || _RELEASE_INTERNAL)
525 if (MEDIA_IS_SKU(skuTable, FtrContextBasedScheduling) && pOsInterface->bVeboxScalabilityMode)
526 {
527 pOsInterface->ctxBasedScheduling = true;
528 }
529 #endif
530 Mos_SetVirtualEngineSupported(pOsInterface, true);
531 pOsInterface->pfnVirtualEngineSupported(pOsInterface, true, true);
532
533 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
534 MHW_CHK_NULL(pGtSystemInfo);
535
536 createOptionenhanced.LRCACount = pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled;
537
538 // Create VEBOX/VEBOX2 Context
539 MHW_CHK_STATUS(pOsInterface->pfnCreateGpuContext(
540 pOsInterface,
541 VeboxGpuContext,
542 VeboxGpuNode,
543 &createOptionenhanced));
544
545 finish:
546 return eStatus;
547 }
548
549 MOS_STATUS MhwVeboxInterfaceXe_Xpm::AddVeboxSurfaces(
550 PMOS_COMMAND_BUFFER pCmdBuffer,
551 PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams)
552 {
553 MOS_STATUS eStatus;
554 bool bOutputValid;
555
556 mhw_vebox_xe_xpm::VEBOX_SURFACE_STATE_CMD cmd1, cmd2;
557
558 MHW_CHK_NULL(pCmdBuffer);
559 MHW_CHK_NULL(m_osInterface);
560 MHW_CHK_NULL(pVeboxSurfaceStateCmdParams);
561 MHW_CHK_NULL(m_osInterface->pfnGetMemoryCompressionFormat);
562
563 eStatus = MOS_STATUS_SUCCESS;
564 bOutputValid = pVeboxSurfaceStateCmdParams->bOutputValid;
565
566 if (!pVeboxSurfaceStateCmdParams->SurfInput.dwCompressionFormat)
567 m_osInterface->pfnGetMemoryCompressionFormat(m_osInterface, pVeboxSurfaceStateCmdParams->SurfInput.pOsResource, &pVeboxSurfaceStateCmdParams->SurfInput.dwCompressionFormat);
568
569 // Setup Surface State for Input surface
570 SetVeboxSurfaces(
571 &pVeboxSurfaceStateCmdParams->SurfInput,
572 &pVeboxSurfaceStateCmdParams->SurfSTMM,
573 nullptr,
574 &cmd1,
575 false,
576 pVeboxSurfaceStateCmdParams->bDIEnable,
577 pVeboxSurfaceStateCmdParams->b3DlutEnable);
578 m_osInterface->pfnAddCommand(pCmdBuffer, &cmd1, cmd1.byteSize);
579
580 // Setup Surface State for Output surface
581 if (bOutputValid)
582 {
583 if (!pVeboxSurfaceStateCmdParams->SurfOutput.dwCompressionFormat)
584 m_osInterface->pfnGetMemoryCompressionFormat(m_osInterface, pVeboxSurfaceStateCmdParams->SurfOutput.pOsResource, &pVeboxSurfaceStateCmdParams->SurfOutput.dwCompressionFormat);
585
586 SetVeboxSurfaces(
587 &pVeboxSurfaceStateCmdParams->SurfOutput,
588 &pVeboxSurfaceStateCmdParams->SurfDNOutput,
589 &pVeboxSurfaceStateCmdParams->SurfSkinScoreOutput,
590 &cmd2,
591 true,
592 pVeboxSurfaceStateCmdParams->bDIEnable,
593 pVeboxSurfaceStateCmdParams->b3DlutEnable);
594
595 // Reset Output Format When Input/Output Format are the same
596 if (pVeboxSurfaceStateCmdParams->SurfInput.Format == pVeboxSurfaceStateCmdParams->SurfOutput.Format)
597 {
598 cmd2.DW3.SurfaceFormat = cmd1.DW3.SurfaceFormat;
599 }
600
601 m_osInterface->pfnAddCommand(pCmdBuffer, &cmd2, cmd2.byteSize);
602 }
603
604 finish:
605 return eStatus;
606 }
607
608 void MhwVeboxInterfaceXe_Xpm::SetVeboxSurfaces(
609 PMHW_VEBOX_SURFACE_PARAMS pSurfaceParam,
610 PMHW_VEBOX_SURFACE_PARAMS pDerivedSurfaceParam,
611 PMHW_VEBOX_SURFACE_PARAMS pSkinScoreSurfaceParam,
612 mhw_vebox_xe_xpm::VEBOX_SURFACE_STATE_CMD * pVeboxSurfaceState,
613 bool bIsOutputSurface,
614 bool bDIEnable,
615 bool b3DlutEnable)
616 {
617 uint32_t dwFormat;
618 uint32_t dwSurfaceWidth;
619 uint32_t dwSurfaceHeight;
620 uint32_t dwSurfacePitch;
621 bool bHalfPitchForChroma;
622 bool bInterleaveChroma;
623 uint16_t wUXOffset;
624 uint16_t wUYOffset;
625 uint16_t wVXOffset;
626 uint16_t wVYOffset;
627 uint8_t bBayerOffset;
628 uint8_t bBayerStride;
629 uint8_t bBayerInputAlignment;
630
631 mhw_vebox_xe_xpm::VEBOX_SURFACE_STATE_CMD VeboxSurfaceState;
632
633 MHW_CHK_NULL_NO_STATUS_RETURN(pSurfaceParam);
634 MHW_CHK_NULL_NO_STATUS_RETURN(pVeboxSurfaceState);
635
636 // Initialize
637 dwSurfaceWidth = 0;
638 dwSurfaceHeight = 0;
639 dwSurfacePitch = 0;
640 bHalfPitchForChroma = false;
641 bInterleaveChroma = false;
642 wUXOffset = 0;
643 wUYOffset = 0;
644 wVXOffset = 0;
645 wVYOffset = 0;
646 bBayerOffset = 0;
647 bBayerStride = 0;
648 bBayerInputAlignment = 0;
649 *pVeboxSurfaceState = VeboxSurfaceState;
650
651 switch (pSurfaceParam->Format)
652 {
653 case Format_NV12:
654 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR4208;
655 bInterleaveChroma = true;
656 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
657 break;
658
659 case Format_YUYV:
660 case Format_YUY2:
661 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBNORMAL;
662 break;
663
664 case Format_UYVY:
665 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPY;
666 break;
667
668 case Format_AYUV:
669 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED444A8;
670 break;
671
672 case Format_Y416:
673 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED44416;
674 break;
675
676 case Format_Y410:
677 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED44410;
678 break;
679
680 case Format_YVYU:
681 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPUV;
682 break;
683
684 case Format_VYUY:
685 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_YCRCBSWAPUVY;
686 break;
687
688 case Format_A8B8G8R8:
689 case Format_X8B8G8R8:
690 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R8G8B8A8UNORMR8G8B8A8UNORMSRGB;
691 break;
692
693 case Format_A16B16G16R16:
694 case Format_A16R16G16B16:
695 case Format_A16B16G16R16F:
696 case Format_A16R16G16B16F:
697 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R16G16B16A16;
698 break;
699
700 case Format_L8:
701 case Format_P8:
702 case Format_Y8:
703 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_Y8UNORM;
704 break;
705
706 case Format_IRW0:
707 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
708 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISBLUE;
709 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
710 break;
711
712 case Format_IRW1:
713 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
714 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISRED;
715 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
716 break;
717
718 case Format_IRW2:
719 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
720 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISRED;
721 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
722 break;
723
724 case Format_IRW3:
725 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
726 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISBLUE;
727 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_16_BITINPUTATA16_BITSTRIDE;
728 break;
729
730 case Format_IRW4:
731 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
732 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISBLUE;
733 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
734 break;
735
736 case Format_IRW5:
737 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
738 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISRED;
739 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
740 break;
741
742 case Format_IRW6:
743 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
744 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISRED;
745 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
746 break;
747
748 case Format_IRW7:
749 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_BAYERPATTERN;
750 bBayerOffset = VeboxSurfaceState.BAYER_PATTERN_OFFSET_PIXELATX0_Y0ISGREEN_PIXELATX1_Y0ISBLUE;
751 bBayerStride = VeboxSurfaceState.BAYER_PATTERN_FORMAT_8_BITINPUTATA8_BITSTRIDE;
752 break;
753
754 case Format_P010:
755 case Format_P016:
756 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR42016;
757 bInterleaveChroma = true;
758 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
759 break;
760
761 case Format_A8R8G8B8:
762 case Format_X8R8G8B8:
763 if (bIsOutputSurface)
764 {
765 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_B8G8R8A8UNORM;
766 }
767 else
768 {
769 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R8G8B8A8UNORMR8G8B8A8UNORMSRGB;
770 }
771 break;
772
773 case Format_R10G10B10A2:
774 case Format_B10G10R10A2:
775 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_R10G10B10A2UNORMR10G10B10A2UNORMSRGB;
776 break;
777
778 case Format_Y216:
779 case Format_Y210:
780 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PACKED42216;
781 break;
782
783 case Format_P216:
784 case Format_P210:
785 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_PLANAR42216;
786 wUYOffset = (uint16_t)pSurfaceParam->dwUYoffset;
787 break;
788
789 case Format_Y16S:
790 case Format_Y16U:
791 dwFormat = VeboxSurfaceState.SURFACE_FORMAT_Y16UNORM;
792 break;
793
794 default:
795 MHW_ASSERTMESSAGE("Unsupported format.");
796 goto finish;
797 break;
798 }
799
800 if (!bIsOutputSurface)
801 {
802 // camera pipe will use 10/12/14 for LSB, 0 for MSB. For other pipeline,
803 // dwBitDepth is inherited from pSrc->dwDepth which may not among (0,10,12,14)
804 // For such cases should use MSB as default value.
805 switch (pSurfaceParam->dwBitDepth)
806 {
807 case 10:
808 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_10BITLSBALIGNEDDATA;
809 break;
810
811 case 12:
812 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_12BITLSBALIGNEDDATA;
813 break;
814
815 case 14:
816 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_14BITLSBALIGNEDDATA;
817 break;
818
819 case 0:
820 default:
821 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_MSBALIGNEDDATA;
822 break;
823 }
824 }
825 else
826 {
827 bBayerInputAlignment = VeboxSurfaceState.BAYER_INPUT_ALIGNMENT_MSBALIGNEDDATA;
828 }
829
830 // adjust boundary for vebox
831 VeboxAdjustBoundary(
832 pSurfaceParam,
833 &dwSurfaceWidth,
834 &dwSurfaceHeight,
835 bDIEnable,
836 b3DlutEnable);
837
838 dwSurfacePitch = (pSurfaceParam->TileType == MOS_TILE_LINEAR) ? MOS_ALIGN_CEIL(pSurfaceParam->dwPitch, MHW_VEBOX_LINEAR_PITCH) : pSurfaceParam->dwPitch;
839
840 pVeboxSurfaceState->DW1.SurfaceIdentification = bIsOutputSurface;
841 pVeboxSurfaceState->DW2.Width = dwSurfaceWidth - 1;
842 pVeboxSurfaceState->DW2.Height = dwSurfaceHeight - 1;
843
844 pVeboxSurfaceState->DW3.HalfPitchForChroma = bHalfPitchForChroma;
845 pVeboxSurfaceState->DW3.InterleaveChroma = bInterleaveChroma;
846 pVeboxSurfaceState->DW3.SurfaceFormat = dwFormat;
847 pVeboxSurfaceState->DW3.BayerInputAlignment = bBayerInputAlignment;
848 pVeboxSurfaceState->DW3.BayerPatternOffset = bBayerOffset;
849 pVeboxSurfaceState->DW3.BayerPatternFormat = bBayerStride;
850 pVeboxSurfaceState->DW3.SurfacePitch = dwSurfacePitch - 1;
851 pVeboxSurfaceState->DW3.TileMode = MosGetHWTileType(pSurfaceParam->TileType, pSurfaceParam->TileModeGMM, pSurfaceParam->bGMMTileEnabled);
852
853 pVeboxSurfaceState->DW4.XOffsetForU = wUXOffset;
854 pVeboxSurfaceState->DW4.YOffsetForU = wUYOffset;
855 pVeboxSurfaceState->DW5.XOffsetForV = wVXOffset;
856 pVeboxSurfaceState->DW5.YOffsetForV = wVYOffset;
857
858 // May fix this for stereo surfaces
859 pVeboxSurfaceState->DW6.YOffsetForFrame = pSurfaceParam->dwYoffset;
860 pVeboxSurfaceState->DW6.XOffsetForFrame = 0;
861
862 pVeboxSurfaceState->DW7.DerivedSurfacePitch = pDerivedSurfaceParam->dwPitch - 1;
863 pVeboxSurfaceState->DW8.SurfacePitchForSkinScoreOutputSurfaces = (bIsOutputSurface && pSkinScoreSurfaceParam->bActive) ? (pSkinScoreSurfaceParam->dwPitch - 1) : 0;
864
865 pVeboxSurfaceState->DW7.CompressionFormat = pSurfaceParam->dwCompressionFormat;
866
867 finish:
868 return;
869 }
870
871 bool MhwVeboxInterfaceXe_Xpm::IsScalabilitySupported()
872 {
873 return m_veboxScalabilitySupported;
874 }
875
876 MOS_STATUS MhwVeboxInterfaceXe_Xpm::FindVeboxGpuNodeToUse(
877 PMHW_VEBOX_GPUNODE_LIMIT pGpuNodeLimit)
878 {
879 MOS_GPU_NODE VeboxGpuNode = MOS_GPU_NODE_VE;
880 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
881
882 MHW_CHK_NULL(pGpuNodeLimit);
883
884 // KMD Virtual Engine, use virtual GPU NODE-- MOS_GPU_NODE_VE
885 pGpuNodeLimit->dwGpuNodeToUse = VeboxGpuNode;
886
887 #if !EMUL
888 #if (_DEBUG || _RELEASE_INTERNAL)
889 if (Mos_Solo_IsInUse(m_osInterface))
890 {
891 MHW_CHK_STATUS(ValidateVeboxScalabilityConfig());
892 }
893 #endif
894
895 Mos_Solo_CheckNodeLimitation(m_osInterface, &pGpuNodeLimit->dwGpuNodeToUse);
896 #endif
897
898 finish:
899 return eStatus;
900 }
901
902 #if (_DEBUG || _RELEASE_INTERNAL)
903 MOS_STATUS MhwVeboxInterfaceXe_Xpm::ValidateVeboxScalabilityConfig()
904 {
905 MEDIA_SYSTEM_INFO *pGtSystemInfo;
906 MOS_FORCE_VEBOX eForceVebox;
907 bool bScalableVEMode;
908 bool bUseVE1, bUseVE2, bUseVE3, bUseVE4;
909 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
910
911 MHW_CHK_NULL(m_osInterface);
912
913 eForceVebox = m_osInterface->eForceVebox;
914 bScalableVEMode = ((m_osInterface->bVeboxScalabilityMode) ? true : false);
915 pGtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
916 MHW_CHK_NULL(pGtSystemInfo);
917
918 if (eForceVebox != MOS_FORCE_VEBOX_NONE &&
919 eForceVebox != MOS_FORCE_VEBOX_1 &&
920 eForceVebox != MOS_FORCE_VEBOX_2 &&
921 eForceVebox != MOS_FORCE_VEBOX_1_2 &&
922 eForceVebox != MOS_FORCE_VEBOX_1_2_3&&
923 eForceVebox != MOS_FORCE_VEBOX_1_2_3_4)
924 {
925 eStatus = MOS_STATUS_INVALID_PARAMETER;
926 MHW_ASSERTMESSAGE("eForceVebox value is invalid.");
927 goto finish;
928 }
929
930 if (!bScalableVEMode &&
931 (eForceVebox == MOS_FORCE_VEBOX_1_2 ||
932 eForceVebox == MOS_FORCE_VEBOX_1_2_3 ||
933 eForceVebox == MOS_FORCE_VEBOX_1_2_3_4))
934 {
935 eStatus = MOS_STATUS_INVALID_PARAMETER;
936 MHW_ASSERTMESSAGE("eForceVebox value is not consistent with scalability mode.");
937 goto finish;
938 }
939
940 if (bScalableVEMode && !m_veboxScalabilitySupported)
941 {
942 eStatus = MOS_STATUS_INVALID_PARAMETER;
943 MHW_ASSERTMESSAGE("scalability mode is not allowed on current platform!");
944 goto finish;
945 }
946
947 bUseVE1 = bUseVE2 = bUseVE3 = bUseVE4 = false;
948 if (eForceVebox == MOS_FORCE_VEBOX_NONE)
949 {
950 bUseVE1 = true;
951 }
952 else
953 {
954 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_1, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE1);
955 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_2, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE2);
956 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_3, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE3);
957 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_4, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE4);
958 }
959
960 if (!pGtSystemInfo->VEBoxInfo.IsValid ||
961 (uint32_t)(bUseVE1 + bUseVE2 + bUseVE3 + bUseVE4) > pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled)
962 {
963 eStatus = MOS_STATUS_INVALID_PARAMETER;
964 MHW_ASSERTMESSAGE("the forced VEBOX is not enabled in current platform.");
965 goto finish;
966 }
967
968 finish:
969 return eStatus;
970 }
971 #endif