Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_vebox_impl.h

raw
1 /*
2 * Copyright (c) 2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vebox_impl.h
24 //! \brief MHW VEBOX interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VEBOX_IMPL_H__
29 #define __MHW_VEBOX_IMPL_H__
30
31 #include "mhw_vebox_itf.h"
32 #include "mhw_impl.h"
33 #include "hal_oca_interface_next.h"
34 #include "mos_solo_generic.h"
35
36 #ifdef IGFX_VEBOX_INTERFACE_EXT_SUPPORT
37 #include "mhw_vebox_impl_ext.h"
38 #endif
39
40 namespace mhw
41 {
42 namespace vebox
43 {
44
45 template <typename cmd_t>
46 class Impl : public Itf, public mhw::Impl
47 {
48 _VEBOX_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
49
50 public:
51 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
52 {
53 MHW_FUNCTION_ENTER;
54
55 MOS_ZeroMemory(&m_veboxSettings, sizeof(m_veboxSettings));
56
57 MEDIA_ENGINE_INFO mediaSysInfo = {};
58
59 m_veboxSettings = g_Vebox_Settings;
60 m_vebox0InUse = false;
61 m_vebox1InUse = false;
62 m_veboxScalabilitySupported = false;
63 m_veboxSplitRatio = 50;
64 memset(&m_chromaParams, 0, sizeof(m_chromaParams));
65
66 MOS_SecureMemcpy(m_BT2020InvPixelValue, sizeof(uint32_t) * 256, g_Vebox_BT2020_Inverse_Pixel_Value, sizeof(uint32_t) * 256);
67 MOS_SecureMemcpy(m_BT2020FwdPixelValue, sizeof(uint32_t) * 256, g_Vebox_BT2020_Forward_Pixel_Value, sizeof(uint32_t) * 256);
68 MOS_SecureMemcpy(m_BT2020InvGammaLUT, sizeof(uint32_t) * 256, g_Vebox_BT2020_Inverse_Gamma_LUT, sizeof(uint32_t) * 256);
69 MOS_SecureMemcpy(m_BT2020FwdGammaLUT, sizeof(uint32_t) * 256, g_Vebox_BT2020_Forward_Gamma_LUT, sizeof(uint32_t) * 256);
70
71 MOS_ZeroMemory(&m_laceColorCorrection, sizeof(m_laceColorCorrection));
72
73 MHW_CHK_NULL_NO_STATUS_RETURN(osItf);
74 MOS_STATUS eStatus = osItf->pfnGetMediaEngineInfo(osItf, mediaSysInfo);
75 if (eStatus == MOS_STATUS_SUCCESS)
76 {
77 if (mediaSysInfo.VEBoxInfo.IsValid &&
78 mediaSysInfo.VEBoxInfo.NumberOfVEBoxEnabled > 1)
79 {
80 m_veboxScalabilitySupported = true;
81 }
82 }
83
84 #if (_DEBUG || _RELEASE_INTERNAL)
85 if (m_userSettingPtr != nullptr)
86 {
87 ReadUserSettingForDebug(
88 m_userSettingPtr,
89 m_veboxSplitRatio,
90 __MEDIA_USER_FEATURE_VALUE_VEBOX_SPLIT_RATIO,
91 MediaUserSetting::Group::Device);
92 }
93 #endif
94 };
95
96 static __inline uint32_t MosGetHWTileType(MOS_TILE_TYPE tileType, MOS_TILE_MODE_GMM tileModeGMM, bool gmmTileEnabled)
97 {
98 uint32_t tileMode = 0;
99
100 if (gmmTileEnabled)
101 {
102 return tileModeGMM;
103 }
104
105 switch (tileType)
106 {
107 case MOS_TILE_LINEAR:
108 tileMode = 0;
109 break;
110 case MOS_TILE_YS:
111 tileMode = 1;
112 break;
113 case MOS_TILE_X:
114 tileMode = 2;
115 break;
116 default:
117 tileMode = 3;
118 break;
119 }
120 return tileMode;
121 }
122
123 MOS_STATUS UpdateVeboxSync() override
124 {
125 PMHW_VEBOX_HEAP pVeboxHeap;
126 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
127 PMOS_INTERFACE pOsInterface;
128
129 MHW_FUNCTION_ENTER;
130
131 MHW_CHK_NULL_RETURN(this->m_osItf);
132 MHW_CHK_NULL_RETURN(m_veboxHeap);
133
134 pVeboxHeap = m_veboxHeap;
135 pOsInterface = this->m_osItf;
136
137 // If KMD frame tracking is on, the dwSyncTag has been set to gpu status tag
138 // in Mhw_VeboxInterface_AssignVeboxState(). dwNextTag is not used anymore.
139 if (!pOsInterface->bEnableKmdMediaFrameTracking)
140 {
141 pVeboxHeap->pStates[pVeboxHeap->uiCurState].dwSyncTag =
142 pVeboxHeap->dwNextTag++;
143 }
144 pVeboxHeap->pStates[pVeboxHeap->uiCurState].bBusy = true;
145
146 return eStatus;
147 }
148
149 MOS_STATUS GetVeboxHeapInfo(
150 const MHW_VEBOX_HEAP** ppVeboxHeap) override
151 {
152 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
153
154 MHW_FUNCTION_ENTER;
155 MHW_CHK_NULL_RETURN(ppVeboxHeap);
156
157 *ppVeboxHeap = (const MHW_VEBOX_HEAP*)m_veboxHeap;
158
159 return eStatus;
160 }
161
162 MOS_STATUS SetVeboxHeapStateIndex(
163 uint32_t index) override
164 {
165 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
166
167 MHW_FUNCTION_ENTER;
168 MHW_CHK_NULL_RETURN(m_veboxHeap);
169
170 m_veboxHeap->uiCurState = index;
171
172 return eStatus;
173 }
174
175 uint32_t GetVeboxNumInstances() override
176 {
177 MHW_FUNCTION_ENTER;
178
179 return m_veboxSettings.uiNumInstances;
180 }
181
182 MOS_STATUS DestroyHeap() override
183 {
184 PMOS_INTERFACE pOsInterface;
185 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
186
187 MHW_FUNCTION_ENTER;
188 MHW_CHK_NULL_RETURN(this->m_osItf);
189
190 pOsInterface = this->m_osItf;
191
192 if (m_veboxHeap)
193 {
194 #if (_DEBUG || _RELEASE_INTERNAL)
195 ReportVeboxId();
196 #endif
197 if (!Mos_ResourceIsNull(&m_veboxHeap->DriverResource))
198 {
199 if (m_veboxHeap->pLockedDriverResourceMem)
200 {
201 pOsInterface->pfnUnlockResource(
202 pOsInterface,
203 &m_veboxHeap->DriverResource);
204 }
205
206 pOsInterface->pfnFreeResource(
207 pOsInterface,
208 &m_veboxHeap->DriverResource);
209 }
210
211 if (!Mos_ResourceIsNull(&m_veboxHeap->KernelResource))
212 {
213 pOsInterface->pfnFreeResource(
214 pOsInterface,
215 &m_veboxHeap->KernelResource);
216 }
217
218 MOS_FreeMemory(m_veboxHeap);
219 m_veboxHeap = nullptr;
220 }
221 return eStatus;
222 }
223
224 MOS_STATUS CreateHeap() override
225 {
226 MOS_STATUS eStatus;
227 uint8_t* pMem;
228 uint32_t uiSize;
229 uint32_t uiOffset;
230 MOS_ALLOC_GFXRES_PARAMS AllocParams;
231 MOS_LOCK_PARAMS LockFlags;
232 MEDIA_FEATURE_TABLE* skuTable = nullptr;
233
234 MHW_FUNCTION_ENTER;
235
236 MHW_CHK_NULL_RETURN(this->m_osItf);
237 MHW_CHK_NULL_RETURN(this->m_osItf->pfnGetSkuTable);
238
239 skuTable = this->m_osItf->pfnGetSkuTable(this->m_osItf);
240 MHW_CHK_NULL_RETURN(skuTable);
241
242 eStatus = MOS_STATUS_SUCCESS;
243
244 uiSize = sizeof(MHW_VEBOX_HEAP);
245 uiSize += m_veboxSettings.uiNumInstances *
246 sizeof(MHW_VEBOX_HEAP_STATE);
247
248 // Allocate memory for VEBOX
249 pMem = (uint8_t*)MOS_AllocAndZeroMemory(uiSize);
250 MHW_CHK_NULL_RETURN(pMem);
251
252 m_veboxHeap = (MHW_VEBOX_HEAP*)pMem;
253
254 m_veboxHeap->pStates =
255 (MHW_VEBOX_HEAP_STATE*)(pMem + sizeof(MHW_VEBOX_HEAP));
256
257 // Assign offsets and sizes
258 uiOffset = 0;
259 m_veboxHeap->uiDndiStateOffset = uiOffset;
260 uiOffset += m_veboxSettings.uiDndiStateSize;
261
262 m_veboxHeap->uiIecpStateOffset = uiOffset;
263 uiOffset += m_veboxSettings.uiIecpStateSize;
264
265 m_veboxHeap->uiGamutStateOffset = uiOffset;
266 uiOffset += m_veboxSettings.uiGamutStateSize;
267
268 m_veboxHeap->uiVertexTableOffset = uiOffset;
269 uiOffset += m_veboxSettings.uiVertexTableSize;
270
271 m_veboxHeap->uiCapturePipeStateOffset = uiOffset;
272 uiOffset += m_veboxSettings.uiCapturePipeStateSize;
273
274 m_veboxHeap->uiGammaCorrectionStateOffset = uiOffset;
275 uiOffset += m_veboxSettings.uiGammaCorrectionStateSize;
276
277 m_veboxHeap->uiHdrStateOffset = uiOffset;
278 uiOffset += m_veboxSettings.uiHdrStateSize;
279 #if (_DEBUG || _RELEASE_INTERNAL)
280 if (m_veboxIdReportEnabled)
281 {
282 m_veboxHeap->uiEngineDataOffset = uiOffset;
283 uiOffset += m_veboxSettings.uiEngineDataSize;
284 }
285 #endif
286 m_veboxHeap->uiInstanceSize = uiOffset;
287
288 // Appending VeboxHeap sync data after all vebox heap instances
289 m_veboxHeap->uiOffsetSync =
290 m_veboxHeap->uiInstanceSize *
291 m_veboxSettings.uiNumInstances;
292
293 // Allocate GPU memory
294 uiSize = m_veboxHeap->uiInstanceSize *
295 m_veboxSettings.uiNumInstances +
296 m_veboxSettings.uiSyncSize;
297
298 // for using vdbox copy, the size have to be cache line aligned
299 MOS_ALIGN_CEIL(uiSize, MHW_CACHELINE_SIZE);
300
301 m_veboxHeap->uiStateHeapSize = uiSize;
302
303 MOS_ZeroMemory(&AllocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
304
305 AllocParams.Type = MOS_GFXRES_BUFFER;
306 AllocParams.TileType = MOS_TILE_LINEAR;
307 AllocParams.Format = Format_Buffer;
308 AllocParams.dwBytes = uiSize;
309 AllocParams.pBufName = "VphalVeboxHeap";
310 AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF;
311
312 if (MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
313 {
314 AllocParams.dwMemType = MOS_MEMPOOL_SYSTEMMEMORY;
315 }
316
317 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnAllocateResource(
318 this->m_osItf,
319 &AllocParams,
320 &m_veboxHeap->DriverResource));
321
322 if (MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
323 {
324 // Use device memory for vebox heap kernel resource, as no cpu access on it.
325 AllocParams.dwMemType = MOS_MEMPOOL_DEVICEMEMORY;
326 }
327 AllocParams.Flags.bNotLockable = 1;
328 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnAllocateResource(
329 this->m_osItf,
330 &AllocParams,
331 &m_veboxHeap->KernelResource));
332
333 // Lock the driver resource
334 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
335
336 LockFlags.NoOverWrite = 1;
337
338 m_veboxHeap->pLockedDriverResourceMem =
339 (uint8_t*)this->m_osItf->pfnLockResource(
340 this->m_osItf,
341 &m_veboxHeap->DriverResource,
342 &LockFlags);
343 MHW_CHK_NULL_RETURN(m_veboxHeap->pLockedDriverResourceMem);
344
345 // Initialize VeboxHeap controls that depend on mapping
346 m_veboxHeap->pSync =
347 (uint32_t*)(m_veboxHeap->pLockedDriverResourceMem +
348 m_veboxHeap->uiOffsetSync);
349
350 if (eStatus != MOS_STATUS_SUCCESS)
351 {
352 DestroyHeap();
353 }
354 return eStatus;
355 }
356
357 MOS_STATUS SetgnLumaWgts(uint32_t lumaStadTh, uint32_t TGNEThCnt, bool tGNEEnable) override
358 {
359 dw4X4TGNEThCnt = TGNEThCnt;
360 bTGNEEnable = tGNEEnable;
361 dwLumaStadTh = lumaStadTh;
362
363 return MOS_STATUS_SUCCESS;
364 }
365
366 MOS_STATUS SetgnChromaWgts(uint32_t chromaStadTh) override
367 {
368 dwChromaStadTh = chromaStadTh;
369
370 return MOS_STATUS_SUCCESS;
371 }
372
373 MOS_STATUS SetgnHVSParams(
374 bool tGNEEnable, uint32_t lumaStadTh, uint32_t chromaStadTh,
375 uint32_t tGNEThCnt, uint32_t historyInit, bool fallBack) override
376 {
377 dw4X4TGNEThCnt = tGNEThCnt;
378 bTGNEEnable = tGNEEnable;
379 dwLumaStadTh = lumaStadTh;
380 dwChromaStadTh = chromaStadTh;
381 bHVSfallback = fallBack;
382 dwHistoryInit = historyInit;
383
384 return MOS_STATUS_SUCCESS;
385 }
386
387 MOS_STATUS SetgnHVSMode(bool hVSAutoBdrate, bool hVSAutoSubjective, uint32_t bSDThreshold) override
388 {
389 bHVSAutoBdrateEnable = hVSAutoBdrate;
390 bHVSAutoSubjectiveEnable = hVSAutoSubjective;
391 dwBSDThreshold = bSDThreshold;
392
393 return MOS_STATUS_SUCCESS;
394 }
395
396 const MHW_VEBOX_CHROMA_PARAMS &GetChromaParams() const
397 {
398 return m_chromaParams;
399 }
400
401 bool GetTGNEEnable() const
402 {
403 return bTGNEEnable;
404 }
405
406 uint32_t GetChromaStadThreshold() const
407 {
408 return dwChromaStadTh;
409 }
410
411 uint32_t GetLumaStadThreshold() const
412 {
413 return dwLumaStadTh;
414 }
415
416 uint32_t Get4X4TGNEThresholdCount() const
417 {
418 return dw4X4TGNEThCnt;
419 }
420
421
422 void RefreshVeboxSync()
423 {
424 MHW_VEBOX_HEAP *pVeboxHeap;
425 MHW_VEBOX_HEAP_STATE *pCurInstance;
426 uint32_t dwCurrentTag;
427 int32_t i;
428 int32_t iInstanceInUse;
429 MOS_NULL_RENDERING_FLAGS NullRenderingFlags;
430
431 MHW_FUNCTION_ENTER;
432 if (m_veboxHeap == nullptr ||
433 this->m_osItf == nullptr)
434 {
435 MHW_ASSERTMESSAGE("RefreshVeboxSync failed due to m_veboxHeap or m_osInterface is invalid ");
436 return;
437 }
438 iInstanceInUse = 0;
439
440 // Vebox Heap will always be locked by driver
441 pVeboxHeap = m_veboxHeap;
442
443 // Most recent tag
444 if (this->m_osItf->bEnableKmdMediaFrameTracking)
445 {
446 dwCurrentTag = this->m_osItf->pfnGetGpuStatusSyncTag(this->m_osItf, MOS_GPU_CONTEXT_VEBOX);
447 }
448 else
449 {
450 dwCurrentTag = pVeboxHeap->pSync[0];
451 }
452 pVeboxHeap->dwSyncTag = dwCurrentTag - 1;
453
454 NullRenderingFlags = this->m_osItf->pfnGetNullHWRenderFlags(
455 this->m_osItf);
456
457 // Refresh VeboxHeap states
458 pCurInstance = pVeboxHeap->pStates;
459 for (i = m_veboxSettings.uiNumInstances; i > 0; i--, pCurInstance++)
460 {
461 if (!pCurInstance->bBusy) continue;
462
463 // The condition below is valid when sync tag wraps from 2^32-1 to 0
464 if (((int32_t)(dwCurrentTag - pCurInstance->dwSyncTag) >= 0) ||
465 NullRenderingFlags.VPGobal ||
466 NullRenderingFlags.VPDnDi ||
467 this->m_osItf->bNullHwIsEnabled)
468 {
469 pCurInstance->bBusy = false;
470 }
471 else
472 {
473 iInstanceInUse++;
474 }
475 }
476
477 // Save number of instance in use
478 m_veboxHeapInUse = iInstanceInUse;
479 }
480
481 MOS_STATUS SetVeboxSurfaceControlBits(
482 PMHW_VEBOX_SURFACE_CNTL_PARAMS pVeboxSurfCntlParams,
483 uint32_t* pSurfCtrlBits) override
484 {
485 return MOS_STATUS_SUCCESS;
486 }
487
488 MOS_STATUS SetVeboxDndiState(
489 PMHW_VEBOX_DNDI_PARAMS pVeboxDndiParams) override
490 {
491 return MOS_STATUS_SUCCESS;
492 }
493
494 MOS_STATUS SetVeboxIecpState(
495 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams) override
496 {
497 return MOS_STATUS_SUCCESS;
498 }
499
500 MOS_STATUS SetDisableHistogram(
501 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams) override
502 {
503 return MOS_STATUS_SUCCESS;
504 }
505
506 MOS_STATUS SetAlphaFromStateSelect(
507 PMHW_VEBOX_IECP_PARAMS pVeboxIecpParams) override
508 {
509 return MOS_STATUS_SUCCESS;
510 }
511
512 MOS_STATUS SetVeboxLaceColorParams(
513 MHW_LACE_COLOR_CORRECTION *pLaceColorParams) override
514 {
515 MHW_CHK_NULL_RETURN(pLaceColorParams);
516 MOS_SecureMemcpy(&m_laceColorCorrection, sizeof(MHW_LACE_COLOR_CORRECTION), pLaceColorParams, sizeof(MHW_LACE_COLOR_CORRECTION));
517
518 return MOS_STATUS_SUCCESS;
519 }
520
521 MOS_STATUS SetVeboxChromaParams(
522 MHW_VEBOX_CHROMA_PARAMS* chromaParams) override
523 {
524 MHW_CHK_NULL_RETURN(chromaParams);
525 MOS_SecureMemcpy(&m_chromaParams, sizeof(MHW_VEBOX_CHROMA_PARAMS), chromaParams, sizeof(MHW_VEBOX_CHROMA_PARAMS));
526
527 return MOS_STATUS_SUCCESS;
528 }
529
530 MOS_STATUS AssignVeboxState() override
531 {
532 uint32_t dwWaitMs, dwWaitTag;
533 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
534 MHW_VEBOX_HEAP_STATE *pVeboxCurState;
535 MHW_VEBOX_HEAP *pVeboxHeap;
536 uint32_t uiOffset;
537
538 MHW_FUNCTION_ENTER;
539 MHW_CHK_NULL_RETURN(m_veboxHeap);
540 MHW_CHK_NULL_RETURN(this->m_osItf);
541
542 pVeboxHeap = m_veboxHeap;
543 pVeboxCurState = &m_veboxHeap->pStates[pVeboxHeap->uiNextState];
544
545 // Refresh sync tag for all vebox heap instance
546 RefreshVeboxSync();
547
548 // Check validity of current vebox heap instance
549 // The code below is unlikely to be executed - unless all Vebox states are in use
550 // If this ever happens, please consider increasing the number of media states
551 MHW_CHK_NULL_RETURN(pVeboxCurState);
552 if (pVeboxCurState->bBusy)
553 {
554 // Get current vebox instance sync tag
555 dwWaitTag = pVeboxCurState->dwSyncTag;
556
557 // Wait for Batch Buffer complete event OR timeout
558 for (dwWaitMs = MHW_TIMEOUT_MS_DEFAULT; dwWaitMs > 0; dwWaitMs--)
559 {
560 uint32_t dwCurrentTag;
561
562 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnWaitForBBCompleteNotifyEvent(
563 this->m_osItf,
564 MOS_GPU_CONTEXT_VEBOX,
565 MHW_EVENT_TIMEOUT_MS));
566
567 if (this->m_osItf->bEnableKmdMediaFrameTracking)
568 {
569 dwCurrentTag = this->m_osItf->pfnGetGpuStatusSyncTag(this->m_osItf, MOS_GPU_CONTEXT_VEBOX);
570 }
571 else
572 {
573 dwCurrentTag = pVeboxHeap->pSync[0];
574 }
575 // Mark current instance status as availabe. Wait if this sync tag came back from GPU
576 if ((int32_t)(dwCurrentTag - dwWaitTag) >= 0)
577 {
578 pVeboxCurState->bBusy = false;
579 break;
580 }
581 }
582
583 // Timeout
584 if (dwWaitMs == 0)
585 {
586 MHW_ASSERTMESSAGE("Timeout on waiting for free Vebox Heap.");
587 eStatus = MOS_STATUS_UNKNOWN;
588 return eStatus;
589 }
590 }
591
592 // Prepare syncTag for GPU write back
593 if (this->m_osItf->bEnableKmdMediaFrameTracking)
594 {
595 pVeboxCurState->dwSyncTag = this->m_osItf->pfnGetGpuStatusTag(this->m_osItf, MOS_GPU_CONTEXT_VEBOX);
596 }
597 else
598 {
599 pVeboxCurState->dwSyncTag = pVeboxHeap->dwNextTag;
600 }
601
602 // Assign current state and increase next state
603 pVeboxHeap->uiCurState = pVeboxHeap->uiNextState;
604 pVeboxHeap->uiNextState = (pVeboxHeap->uiNextState + 1) %
605 (m_veboxSettings.uiNumInstances);
606
607 uiOffset = pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize;
608 #if (_DEBUG || _RELEASE_INTERNAL)
609 if (m_veboxIdReportEnabled)
610 {
611 if (pVeboxCurState->engineData && MHW_VEBOX_ENGINE_CLASS_ID ==(*pVeboxCurState->engineData).classId)
612 {
613 // Record old engine instance id before memory clearance when reusing heap state
614 m_usedVeboxID |= 1 << (*pVeboxCurState->engineData).instanceId;
615 }
616 if (nullptr == pVeboxCurState->engineData)
617 {
618 pVeboxCurState->engineData =
619 (MHW_VEBOX_ENGINE_DATA*)(pVeboxHeap->pLockedDriverResourceMem + uiOffset +
620 pVeboxHeap->uiEngineDataOffset);
621 }
622 }
623 #endif
624 //Clean the memory of current veboxheap to avoid the history states
625 MOS_ZeroMemory(pVeboxHeap->pLockedDriverResourceMem + uiOffset, pVeboxHeap->uiInstanceSize);
626
627 return eStatus;
628 }
629
630 MOS_STATUS AdjustBoundary(
631 PMHW_VEBOX_SURFACE_PARAMS pCurrSurf,
632 uint32_t *pdwSurfaceWidth,
633 uint32_t *pdwSurfaceHeight,
634 bool bDIEnable)
635 {
636 uint16_t wWidthAlignUnit;
637 uint16_t wHeightAlignUnit;
638 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
639
640 MHW_CHK_NULL_RETURN(pCurrSurf);
641 MHW_CHK_NULL_RETURN(pdwSurfaceWidth);
642 MHW_CHK_NULL_RETURN(pdwSurfaceHeight);
643
644 // initialize
645 wHeightAlignUnit = 1;
646 wWidthAlignUnit = 1;
647
648 switch (pCurrSurf->Format)
649 {
650 case Format_NV12:
651 wHeightAlignUnit = bDIEnable ? 4 : 2;
652 wWidthAlignUnit = 2;
653 break;
654
655 case Format_YUYV:
656 case Format_YUY2:
657 case Format_UYVY:
658 case Format_YVYU:
659 case Format_VYUY:
660 case Format_Y210:
661 case Format_Y216:
662 wHeightAlignUnit = bDIEnable ? 2 : 1;
663 wWidthAlignUnit = 2;
664 break;
665
666 case Format_AYUV:
667 case Format_Y416:
668 wHeightAlignUnit = 1;
669 wWidthAlignUnit = 2;
670 break;
671
672 // For other formats, we will not do any special alignment
673 case Format_A8R8G8B8:
674 case Format_X8R8G8B8:
675 case Format_A8B8G8R8:
676 case Format_X8B8G8R8:
677 case Format_L8:
678 default:
679 break;
680 }
681
682 //When Crop being used in vebox, source surface height/width is updated in VeboxAdjustBoundary(), and the rcMaxSrc is used for crop rectangle.
683 //But in dynamic Crop case, if the rcMaxSrc is larger than the rcSrc, the input pdwSurfaceHeight/pdwSurfaceWidth will be the input surface size.
684 //And if the target surface size is smaller than input surface, it may lead to pagefault issue . So in Vebox Crop case, we set the pdwSurfaceHeight/pdwSurfaceWidth
685 //with rcSrc to ensure Vebox input size is same with target Dstrec.
686 if (pCurrSurf->bVEBOXCroppingUsed)
687 {
688 *pdwSurfaceHeight = MOS_ALIGN_CEIL(
689 MOS_MIN(pCurrSurf->dwHeight, MOS_MAX((uint32_t)pCurrSurf->rcSrc.bottom, MHW_VEBOX_MIN_HEIGHT)),
690 wHeightAlignUnit);
691 *pdwSurfaceWidth = MOS_ALIGN_CEIL(
692 MOS_MIN(pCurrSurf->dwWidth, MOS_MAX((uint32_t)pCurrSurf->rcSrc.right, MHW_VEBOX_MIN_WIDTH)),
693 wWidthAlignUnit);
694 MHW_NORMALMESSAGE("bVEBOXCroppingUsed = true, SurfInput.dwWidth: %d, SurfInput.dwHeight: %d, SurfInput.rcSrc.bottom: %d, par.SurfInput.rcSrc.right: %d; pdwSurfaceHeight: %d, pdwSurfaceWidth: %d;",
695 pCurrSurf->dwWidth,
696 pCurrSurf->dwHeight,
697 (uint32_t)pCurrSurf->rcSrc.bottom,
698 (uint32_t)pCurrSurf->rcSrc.right,
699 *pdwSurfaceHeight,
700 *pdwSurfaceWidth);
701 MT_LOG5(MT_VP_MHW_VE_ADJUST_SURFPARAM, MT_NORMAL, MT_VP_RENDER_VE_CROPPING, 1, MT_RECT_BOTTOM, pCurrSurf->rcSrc.bottom,
702 MT_RECT_RIGHT, pCurrSurf->rcSrc.right, MT_SURF_HEIGHT, *pdwSurfaceHeight, MT_SURF_WIDTH, *pdwSurfaceWidth);
703 }
704 else
705 {
706 // Align width and height with max src renctange with consideration of
707 // these conditions:
708 // The minimum of width/height should equal to or larger than
709 // MHW_VEBOX_MIN_WIDTH/HEIGHT. The maximum of width/heigh should equal
710 // to or smaller than surface width/height
711 *pdwSurfaceHeight = MOS_ALIGN_CEIL(
712 MOS_MIN(pCurrSurf->dwHeight, MOS_MAX((uint32_t)pCurrSurf->rcMaxSrc.bottom, MHW_VEBOX_MIN_HEIGHT)),
713 wHeightAlignUnit);
714 *pdwSurfaceWidth = MOS_ALIGN_CEIL(
715 MOS_MIN(pCurrSurf->dwWidth, MOS_MAX((uint32_t)pCurrSurf->rcMaxSrc.right, MHW_VEBOX_MIN_WIDTH)),
716 wWidthAlignUnit);
717 MHW_NORMALMESSAGE("bVEBOXCroppingUsed = false, SurfInput.dwWidth: %d, SurfInput.dwHeight: %d, SurfInput.rcMaxSrc.bottom: %d, SurfInput.rcMaxSrc.right: %d; pdwSurfaceHeight: %d, pdwSurfaceWidth: %d;",
718 pCurrSurf->dwWidth,
719 pCurrSurf->dwHeight,
720 (uint32_t)pCurrSurf->rcMaxSrc.bottom,
721 (uint32_t)pCurrSurf->rcMaxSrc.right,
722 *pdwSurfaceHeight,
723 *pdwSurfaceWidth);
724 }
725
726 if (m_forceInputHeight8Aligned)
727 {
728 if (wHeightAlignUnit <= 8 && MOS_ALIGN_CEIL(*pdwSurfaceHeight, 8) <= pCurrSurf->dwHeight)
729 {
730 MHW_NORMALMESSAGE("Vebox input height updated from %d to %d by force 8 aligned, pCurrSurf->dwHeight %d, wHeightAlignUnit %d",
731 *pdwSurfaceHeight, MOS_ALIGN_CEIL(*pdwSurfaceHeight, 8), pCurrSurf->dwHeight, wHeightAlignUnit);
732 *pdwSurfaceHeight = MOS_ALIGN_CEIL(*pdwSurfaceHeight, 8);
733 }
734 else
735 {
736 MHW_ASSERTMESSAGE("Invalid parameter for forceInputHeight8Aligned, pdwSurfaceHeight %d, pdwSurfaceHeight w/ 8 aligned %d, pCurrSurf->dwHeight %d, wHeightAlignUnit %d",
737 *pdwSurfaceHeight, MOS_ALIGN_CEIL(*pdwSurfaceHeight, 8), pCurrSurf->dwHeight, wHeightAlignUnit);
738 }
739 }
740 return eStatus;
741 }
742
743 //!
744 //! \brief Set which vebox can be used by HW
745 //! \details VPHAL set which VEBOX can be use by HW
746 //! \param [in] dwVeboxIndex;
747 //! set which Vebox can be used by HW
748 //! \param [in] dwVeboxCount;
749 //! set Vebox Count
750 //! \param [in] dwUsingSFC;
751 //! set whether using SFC
752 //! \return MOS_STATUS
753 //! MOS_STATUS_SUCCESS if success, else fail reason
754 MOS_STATUS SetVeboxIndex(
755 uint32_t dwVeboxIndex,
756 uint32_t dwVeboxCount,
757 uint32_t dwUsingSFC) override
758 {
759 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
760
761 MHW_ASSERT(dwVeboxIndex < dwVeboxCount);
762
763 m_indexofVebox = dwVeboxIndex;
764 m_numofVebox = dwVeboxCount;
765 m_veboxScalabilityEnabled = (dwVeboxCount > 1) ? m_veboxScalabilitySupported : false;
766 m_usingSfc = dwUsingSFC;
767
768 return eStatus;
769 }
770
771 MOS_STATUS TraceIndirectStateInfo(MOS_COMMAND_BUFFER& cmdBuffer, MOS_CONTEXT& mosContext, bool isCmBuffer, bool useVeboxHeapKernelResource)
772 {
773 if (isCmBuffer)
774 {
775 char ocaLog[] = "Vebox indirect state use CmBuffer";
776 HalOcaInterfaceNext::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)&mosContext, ocaLog, sizeof(ocaLog));
777 }
778 else
779 {
780 if (useVeboxHeapKernelResource)
781 {
782 char ocaLog[] = "Vebox indirect state use KernelResource";
783 HalOcaInterfaceNext::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)&mosContext, ocaLog, sizeof(ocaLog));
784 }
785 else
786 {
787 char ocaLog[] = "Vebox indirect state use DriverResource";
788 HalOcaInterfaceNext::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)&mosContext, ocaLog, sizeof(ocaLog));
789 }
790 }
791 return MOS_STATUS_SUCCESS;
792 }
793
794 //!
795 //! \brief Create Gpu Context for Vebox
796 //! \details Create Gpu Context for Vebox
797 //! \param [in] pOsInterface
798 //! OS interface
799 //! \param [in] VeboxGpuContext
800 //! Vebox Gpu Context
801 //! \param [in] VeboxGpuNode
802 //! Vebox Gpu Node
803 //! \return MOS_STATUS
804 //! MOS_STATUS_SUCCESS if success, else fail reason
805 //!
806 MOS_STATUS CreateGpuContext(
807 PMOS_INTERFACE pOsInterface,
808 MOS_GPU_CONTEXT VeboxGpuContext,
809 MOS_GPU_NODE VeboxGpuNode) override
810 {
811 MEDIA_FEATURE_TABLE *skuTable;
812 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
813
814 MHW_CHK_NULL_RETURN(pOsInterface);
815
816 skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
817 MHW_CHK_NULL_RETURN(skuTable);
818
819 #if (_DEBUG || _RELEASE_INTERNAL)
820 if (MEDIA_IS_SKU(skuTable, FtrContextBasedScheduling) && pOsInterface->bVeboxScalabilityMode)
821 {
822 pOsInterface->ctxBasedScheduling = true;
823 }
824 #endif
825
826 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
827 {
828 MOS_GPUCTX_CREATOPTIONS createOption;
829
830 // Create VEBOX/VEBOX2 Context
831 MHW_CHK_STATUS_RETURN(pOsInterface->pfnCreateGpuContext(
832 pOsInterface,
833 VeboxGpuContext,
834 VeboxGpuNode,
835 &createOption));
836 }
837 else
838 {
839 MOS_GPUCTX_CREATOPTIONS_ENHANCED createOptionenhanced;
840 MEDIA_SYSTEM_INFO* pGtSystemInfo;
841
842 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
843 MHW_CHK_NULL_RETURN(pGtSystemInfo);
844
845 if (pOsInterface->ctxBasedScheduling)
846 {
847 createOptionenhanced.LRCACount = pGtSystemInfo->VEBoxInfo.NumberOfVEBoxEnabled;
848 }
849 else
850 {
851 createOptionenhanced.LRCACount = 1;
852 createOptionenhanced.UsingSFC = true;
853 }
854
855 // Create VEBOX/VEBOX2 Context
856 MHW_CHK_STATUS_RETURN(pOsInterface->pfnCreateGpuContext(
857 pOsInterface,
858 VeboxGpuContext,
859 VeboxGpuNode,
860 &createOptionenhanced));
861 }
862
863 return eStatus;
864 }
865
866 #if (_DEBUG || _RELEASE_INTERNAL)
867 MOS_STATUS ValidateVeboxScalabilityConfig()
868 {
869 MHW_FUNCTION_ENTER;
870
871 MEDIA_ENGINE_INFO mediaSysInfo = {};
872 MOS_FORCE_VEBOX eForceVebox;
873 bool bScalableVEMode;
874 bool bUseVE1, bUseVE2, bUseVE3, bUseVE4;
875 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
876
877 MHW_CHK_NULL_RETURN(this->m_osItf);
878
879 eForceVebox = this->m_osItf->eForceVebox;
880 bScalableVEMode = ((this->m_osItf->bVeboxScalabilityMode) ? true : false);
881 eStatus = this->m_osItf->pfnGetMediaEngineInfo(this->m_osItf, mediaSysInfo);
882 MHW_CHK_STATUS_RETURN(eStatus);
883
884 if (eForceVebox != MOS_FORCE_VEBOX_NONE &&
885 eForceVebox != MOS_FORCE_VEBOX_1 &&
886 eForceVebox != MOS_FORCE_VEBOX_2 &&
887 eForceVebox != MOS_FORCE_VEBOX_1_2 &&
888 eForceVebox != MOS_FORCE_VEBOX_1_2_3 &&
889 eForceVebox != MOS_FORCE_VEBOX_1_2_3_4)
890 {
891 eStatus = MOS_STATUS_INVALID_PARAMETER;
892 MHW_ASSERTMESSAGE("eForceVebox value is invalid.");
893 return eStatus;
894 }
895
896 if (!bScalableVEMode &&
897 (eForceVebox == MOS_FORCE_VEBOX_1_2 ||
898 eForceVebox == MOS_FORCE_VEBOX_1_2_3 ||
899 eForceVebox == MOS_FORCE_VEBOX_1_2_3_4))
900 {
901 eStatus = MOS_STATUS_INVALID_PARAMETER;
902 MHW_ASSERTMESSAGE("eForceVebox value is not consistent with scalability mode.");
903 return eStatus;
904 }
905
906 if (bScalableVEMode && !this->m_veboxScalabilitySupported)
907 {
908 eStatus = MOS_STATUS_INVALID_PARAMETER;
909 MHW_ASSERTMESSAGE("scalability mode is not allowed on current platform!");
910 return eStatus;
911 }
912
913 bUseVE1 = bUseVE2 = bUseVE3 = bUseVE4 = false;
914 if (eForceVebox == MOS_FORCE_VEBOX_NONE)
915 {
916 bUseVE1 = true;
917 }
918 else
919 {
920 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_1, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE1);
921 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_2, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE2);
922 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_3, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE3);
923 MHW_VEBOX_IS_VEBOX_SPECIFIED_IN_CONFIG(eForceVebox, MOS_FORCE_VEBOX_4, MOS_FORCEVEBOX_VEBOXID_BITSNUM, MOS_FORCEVEBOX_MASK, bUseVE4);
924 }
925
926 if (!mediaSysInfo.VEBoxInfo.IsValid ||
927 (uint32_t)(bUseVE1 + bUseVE2 + bUseVE3 + bUseVE4) > mediaSysInfo.VEBoxInfo.NumberOfVEBoxEnabled)
928 {
929 eStatus = MOS_STATUS_INVALID_PARAMETER;
930 MHW_ASSERTMESSAGE("the forced VEBOX is not enabled in current platform.");
931 return eStatus;
932 }
933
934 return eStatus;
935 }
936
937 bool IsVeboxIdReportEnabled() override
938 {
939 return m_veboxIdReportEnabled;
940 }
941
942 MOS_STATUS ReportVeboxId() override
943 {
944 if (m_veboxIdReportEnabled)
945 {
946 MHW_CHK_NULL_RETURN(m_veboxHeap);
947 MHW_CHK_NULL_RETURN(m_veboxHeap->pStates);
948 uint32_t reportedUsedID = 0;
949 for (uint32_t index = 0; index < m_veboxSettings.uiNumInstances; index++)
950 {
951 const MHW_VEBOX_HEAP_STATE &curInstance = m_veboxHeap->pStates[index];
952 if (curInstance.engineData && MHW_VEBOX_ENGINE_CLASS_ID == (*curInstance.engineData).classId)
953 {
954 m_usedVeboxID |= 1 << (*curInstance.engineData).instanceId;
955 }
956 }
957 // It is only used in debugging scenarios for multi-Vebox platforms.
958 // No need to add any locks here.
959 // This approach can handle all current debugging scenarios with multiple threads/processes.
960 ReadUserSettingForDebug(
961 m_userSettingPtr,
962 reportedUsedID,
963 __MEDIA_USER_FEATURE_VALUE_USED_VEBOX_ID,
964 MediaUserSetting::Group::Sequence,
965 0,
966 false,
967 MEDIA_USER_SETTING_INTERNAL_REPORT);
968 ReportUserSettingForDebug(
969 m_userSettingPtr,
970 __MEDIA_USER_FEATURE_VALUE_USED_VEBOX_ID,
971 reportedUsedID | m_usedVeboxID,
972 MediaUserSetting::Group::Sequence);
973 }
974 return MOS_STATUS_SUCCESS;
975 }
976 #endif
977
978 MOS_STATUS VeboxAdjustBoundary(
979 PMHW_VEBOX_SURFACE_PARAMS pcurrSurf,
980 uint32_t * pdwSurfaceWidth,
981 uint32_t * pdwSurfaceHeight,
982 bool bDIEnable) override
983 {
984 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
985
986 MHW_CHK_NULL_RETURN(pdwSurfaceWidth);
987 MHW_CHK_NULL_RETURN(pdwSurfaceHeight);
988
989 MHW_CHK_STATUS_RETURN(AdjustBoundary(pcurrSurf, pdwSurfaceWidth, pdwSurfaceHeight, bDIEnable));
990 // match the vebox width with sfc input width to fix corruption issue when sfc scalability enabled
991 if (m_veboxScalabilityEnabled && m_usingSfc && this->m_osItf->bSimIsActive)
992 {
993 *pdwSurfaceWidth = MOS_ALIGN_CEIL(*pdwSurfaceWidth, 16);
994 *pdwSurfaceHeight = MOS_ALIGN_CEIL(*pdwSurfaceHeight, 4);
995 }
996
997 return eStatus;
998 }
999
1000 void SetForceInputHeight8AlignedFlag(bool forceInputHeight8Aligned) override
1001 {
1002 MHW_NORMALMESSAGE("SetForceInputHeight8AlignedFlag %d->%d", forceInputHeight8Aligned, m_forceInputHeight8Aligned);
1003 m_forceInputHeight8Aligned = forceInputHeight8Aligned;
1004 }
1005
1006 MOS_STATUS FindVeboxGpuNodeToUse(
1007 PMHW_VEBOX_GPUNODE_LIMIT pGpuNodeLimit) override
1008 {
1009 MOS_GPU_NODE VeboxGpuNode = MOS_GPU_NODE_VE;
1010 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1011
1012 MHW_CHK_NULL_RETURN(pGpuNodeLimit);
1013
1014 // KMD Virtual Engine, use virtual GPU NODE-- MOS_GPU_NODE_VE
1015 pGpuNodeLimit->dwGpuNodeToUse = VeboxGpuNode;
1016
1017 #if !EMUL
1018 #if (_DEBUG || _RELEASE_INTERNAL)
1019 if (Mos_Solo_IsInUse(this->m_osItf))
1020 {
1021 MHW_CHK_STATUS_RETURN(ValidateVeboxScalabilityConfig());
1022 }
1023 #endif
1024
1025 Mos_Solo_CheckNodeLimitation(this->m_osItf, &pGpuNodeLimit->dwGpuNodeToUse);
1026 #endif
1027
1028 return eStatus;
1029 }
1030
1031 MOS_STATUS SetVeboxInUse(
1032 bool inputVebox0,
1033 bool inputVebox1)
1034 {
1035 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1036
1037 m_vebox0InUse = inputVebox0;
1038 m_vebox1InUse = inputVebox1;
1039
1040 return eStatus;
1041 }
1042
1043 bool IsScalabilitySupported()
1044 {
1045 return m_veboxScalabilitySupported;
1046 }
1047
1048 MOS_STATUS AddVeboxSurfaces(
1049 PMOS_COMMAND_BUFFER pCmdBufferInUse,
1050 PMHW_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams) override
1051 {
1052 return MOS_STATUS_SUCCESS;
1053 }
1054
1055 bool IsVeboxScalabilitywith4K() override
1056 {
1057 return m_veboxScalabilitywith4K;
1058 }
1059
1060 MOS_STATUS Add1DLutState(void *surface, PMHW_1DLUT_PARAMS p1DLutParams) override
1061 {
1062 return MOS_STATUS_SUCCESS;
1063 }
1064
1065 MOS_STATUS AddFP16State(PMHW_FP16_PARAMS pFP16Params) override
1066 {
1067 return MOS_STATUS_SUCCESS;
1068 }
1069
1070 _MHW_SETCMD_OVERRIDE_DECL(VEBOX_SURFACE_STATE)
1071 {
1072 _MHW_SETCMD_CALLBASE(VEBOX_SURFACE_STATE);
1073 cmd.DW1.SurfaceIdentification = params.SurfaceIdentification;
1074 cmd.DW2.Width = params.Width;
1075 cmd.DW2.Height = params.Height;
1076
1077 cmd.DW3.HalfPitchForChroma = params.HalfPitchForChroma;
1078 cmd.DW3.InterleaveChroma = params.InterleaveChroma;
1079 cmd.DW3.SurfaceFormat = params.SurfaceFormat;
1080 cmd.DW3.BayerInputAlignment = params.BayerInputAlignment;
1081 cmd.DW3.BayerPatternOffset = params.BayerPatternOffset;
1082 cmd.DW3.BayerPatternFormat = params.BayerPatternFormat;
1083 cmd.DW3.SurfacePitch = params.SurfacePitch;
1084 cmd.DW3.TileMode = params.TileMode;
1085
1086 cmd.DW4.XOffsetForU = params.XOffsetForU;
1087 cmd.DW4.YOffsetForU = params.YOffsetForU;
1088 cmd.DW5.XOffsetForV = params.XOffsetForV;
1089 cmd.DW5.YOffsetForV = params.YOffsetForV;
1090
1091 // May fix this for stereo surfaces
1092 cmd.DW6.YOffsetForFrame = params.YOffsetForFrame;
1093 cmd.DW6.XOffsetForFrame = params.XOffsetForFrame;
1094
1095 cmd.DW7.DerivedSurfacePitch = params.DerivedSurfacePitch;
1096 cmd.DW8.SurfacePitchForSkinScoreOutputSurfaces = params.SurfacePitchForSkinScoreOutputSurfaces;
1097
1098 cmd.DW7.CompressionFormat = params.CompressionFormat;
1099
1100 return MOS_STATUS_SUCCESS;
1101 }
1102
1103 _MHW_SETCMD_OVERRIDE_DECL(VEBOX_STATE)
1104 {
1105 _MHW_SETCMD_CALLBASE(VEBOX_STATE);
1106
1107 return MOS_STATUS_SUCCESS;
1108 }
1109
1110 _MHW_SETCMD_OVERRIDE_DECL(VEBOX_TILING_CONVERT)
1111 {
1112 _MHW_SETCMD_CALLBASE(VEBOX_TILING_CONVERT);
1113
1114 return MOS_STATUS_SUCCESS;
1115 }
1116
1117 _MHW_SETCMD_OVERRIDE_DECL(VEB_DI_IECP)
1118 {
1119 _MHW_SETCMD_CALLBASE(VEB_DI_IECP);
1120
1121 return MOS_STATUS_SUCCESS;
1122 }
1123
1124 protected:
1125 using base_t = Itf;
1126
1127 bool m_veboxScalabilitySupported = false;
1128 bool m_veboxScalabilityEnabled = false;
1129 bool m_vebox0InUse = false;
1130 bool m_vebox1InUse = false;
1131 uint32_t m_indexofVebox = 0;
1132 uint32_t m_numofVebox = 1;
1133 uint32_t m_usingSfc = 0;
1134 uint32_t m_veboxSplitRatio = 0;
1135 MHW_LACE_COLOR_CORRECTION m_laceColorCorrection = {};
1136 uint32_t m_BT2020InvPixelValue[256] = {};
1137 uint32_t m_BT2020FwdPixelValue[256] = {};
1138 uint32_t m_BT2020InvGammaLUT[256] = {};
1139 uint32_t m_BT2020FwdGammaLUT[256] = {};
1140 uint32_t dwLumaStadTh = 3200;
1141 uint32_t dwChromaStadTh = 1600;
1142 uint32_t dw4X4TGNEThCnt = 576;
1143 uint32_t dwHistoryInit = 32;
1144 uint32_t dwBSDThreshold = 480;
1145 bool bTGNEEnable = false;
1146 bool bHVSAutoBdrateEnable = false;
1147 bool bHVSAutoSubjectiveEnable = false;
1148 bool bHVSfallback = false;
1149 bool m_forceInputHeight8Aligned = false;
1150
1151 MHW_VEBOX_HEAP *m_veboxHeap = nullptr;
1152 MHW_VEBOX_SETTINGS m_veboxSettings = {};
1153 bool m_veboxScalabilitywith4K = false;
1154 MHW_VEBOX_CHROMA_PARAMS m_chromaParams = {};
1155
1156 //VPHAL_HVSDENOISE_PARAMS m_HvsParams = {};
1157 MHW_VEBOX_DNDI_PARAMS m_veboxDNDIParams = {};
1158 MHW_VEBOX_IECP_PARAMS m_veboxIecpParams = {};
1159 MHW_VEBOX_CHROMA_SAMPLING m_chromaSampling = {};
1160 MHW_VEBOX_GAMUT_PARAMS m_veboxGamutParams = {};
1161
1162 int m_veboxHeapInUse = 0;
1163 #if (_DEBUG || _RELEASE_INTERNAL)
1164 bool m_veboxIdReportEnabled = false;
1165 uint32_t m_usedVeboxID = 0;
1166 #endif
1167 MEDIA_CLASS_DEFINE_END(mhw__vebox__Impl)
1168 };
1169 } // namespace render
1170 } // namespace mhw
1171
1172 #endif // __MHW_RENDER_IMPL_H__