Debian Codegraph @

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_vvcp_impl.h

raw
1 /*
2 * Copyright (c) 2022-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 mhw_vdbox_vvcp_impl.h
24 //! \brief MHW VDBOX VVCP interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_VVCP_IMPL_H__
29 #define __MHW_VDBOX_VVCP_IMPL_H__
30
31 #include "mhw_vdbox_vvcp_itf.h"
32 #include "mhw_impl.h"
33
34 namespace mhw
35 {
36 namespace vdbox
37 {
38 namespace vvcp
39 {
40
41 template <typename cmd_t>
42 class Impl : public Itf, public mhw::Impl
43 {
44 _VVCP_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
45
46 public:
47 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
48 {
49 MHW_FUNCTION_ENTER;
50
51 MHW_CHK_NULL_RETURN(settings);
52 uint32_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
53
54 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
55 }
56
57 MOS_STATUS GetVvcpBufSize(VvcpBufferType bufferType, VvcpBufferSizePar* vvcpBufSizeParam) override
58 {
59 MHW_FUNCTION_ENTER;
60
61 MHW_MI_CHK_NULL(vvcpBufSizeParam);
62
63 uint32_t bufferSize = 0;
64 uint32_t picWidthInCtus = 0;
65 uint32_t picHeightInCtus = 0;
66 uint8_t bitDepthIdx = (vvcpBufSizeParam->m_bitDepthIdc == 2) ? 1 : 0;
67
68 switch (bufferType)
69 {
70 case vcMvTemporalBuffer:
71 bufferSize = 8 * (((vvcpBufSizeParam->m_picWidth - 1) >> 6) + 1) * (((vvcpBufSizeParam->m_picHeight - 1) >> 6) + 1);
72 break;
73 case vcedLineBuffer:
74 case vcmvLineBuffer:
75 case vcprLineBuffer:
76 case vclfYLineBuffer:
77 case vclfULineBuffer:
78 case vclfVLineBuffer:
79 case vcSaoYLineBuffer:
80 case vcSaoULineBuffer:
81 case vcSaoVLineBuffer:
82 case vcAlfLineBuffer:
83 bufferSize = CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_clPerCtu[vvcpBufSizeParam->m_spsLog2CtuSizeMinus5][bitDepthIdx] * vvcpBufSizeParam->m_maxTileWidthInCtus + CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_extraCl;
84 break;
85 case vclfYTileRowBuffer:
86 case vclfUTileRowBuffer:
87 case vclfVTileRowBuffer:
88 case vcSaoYTileRowBuffer:
89 case vcSaoUTileRowBuffer:
90 case vcSaoVTileRowBuffer:
91 case vcAlfTileRowBuffer:
92 picWidthInCtus = MOS_ROUNDUP_SHIFT(vvcpBufSizeParam->m_picWidth, vvcpBufSizeParam->m_spsLog2CtuSizeMinus5 + 5);
93 bufferSize = CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_clPerCtu[vvcpBufSizeParam->m_spsLog2CtuSizeMinus5][bitDepthIdx] * picWidthInCtus + CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_extraCl;
94 break;
95 case vclfYTileColumnBuffer:
96 case vclfUTileColumnBuffer:
97 case vclfVTileColumnBuffer:
98 case vcSaoYTileColumnBuffer:
99 case vcSaoUTileColumnBuffer:
100 case vcSaoVTileColumnBuffer:
101 case vcAlfYTileColumnBuffer:
102 case vcAlfUTileColumnBuffer:
103 case vcAlfVTileColumnBuffer:
104 picHeightInCtus = MOS_ROUNDUP_SHIFT(vvcpBufSizeParam->m_picHeight, vvcpBufSizeParam->m_spsLog2CtuSizeMinus5 + 5);
105 bufferSize = CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_clPerCtu[vvcpBufSizeParam->m_spsLog2CtuSizeMinus5][bitDepthIdx] * picHeightInCtus + CodecVvcBufferSize[vvcpBufSizeParam->m_spsChromaFormatIdc][bufferType].m_extraCl;
106 break;
107 default:
108 return MOS_STATUS_INVALID_PARAMETER;
109 }
110
111 vvcpBufSizeParam->m_bufferSize = bufferSize * MHW_CACHELINE_SIZE;
112
113 return MOS_STATUS_SUCCESS;
114 }
115
116 bool IsRowStoreCachingSupported() override
117 {
118 return m_rowstoreCachingSupported;
119 }
120
121 bool IsBufferRowstoreCacheEnabled(VvcpBufferType bufferType) override
122 {
123 MHW_FUNCTION_ENTER;
124
125 bool rowstoreCacheEnabled = false;
126 switch (bufferType)
127 {
128 case vcedLineBuffer:
129 rowstoreCacheEnabled = m_edlbRowstoreCache.enabled ? true : false;
130 break;
131 case vcmvLineBuffer:
132 rowstoreCacheEnabled = m_mvlbRowstoreCache.enabled ? true : false;
133 break;
134 case vcprLineBuffer:
135 rowstoreCacheEnabled = m_prlbRowstoreCache.enabled ? true : false;
136 break;
137 case vclfYLineBuffer:
138 rowstoreCacheEnabled = m_lfylbRowstoreCache.enabled ? true : false;
139 break;
140 case vclfULineBuffer:
141 rowstoreCacheEnabled = m_lfulbRowstoreCache.enabled ? true : false;
142 break;
143 case vclfVLineBuffer:
144 rowstoreCacheEnabled = m_lfvlbRowstoreCache.enabled ? true : false;
145 break;
146 case vcSaoYLineBuffer:
147 rowstoreCacheEnabled = m_saylbRowstoreCache.enabled ? true : false;
148 break;
149 case vcSaoULineBuffer:
150 rowstoreCacheEnabled = m_saulbRowstoreCache.enabled ? true : false;
151 break;
152 case vcSaoVLineBuffer:
153 rowstoreCacheEnabled = m_savlbRowstoreCache.enabled ? true : false;
154 break;
155 case vcAlfLineBuffer:
156 rowstoreCacheEnabled = m_alflbRowstoreCache.enabled ? true : false;
157 break;
158 default:
159 return false;
160 }
161
162 return rowstoreCacheEnabled;
163 }
164
165 MOS_STATUS GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
166 {
167 MHW_FUNCTION_ENTER;
168
169 MHW_MI_CHK_NULL(rowstoreParams);
170
171 uint32_t picWidth = rowstoreParams->dwPicWidth;
172 uint8_t ctuSize = rowstoreParams->ucLCUSize;
173
174 //EDLB
175 if (m_edlbRowstoreCache.supported)
176 {
177 m_edlbRowstoreCache.enabled = true;
178 m_edlbRowstoreCache.dwAddress = 0;
179 }
180
181 //MVLB
182 if (m_mvlbRowstoreCache.supported)
183 {
184 m_mvlbRowstoreCache.enabled = true;
185 if (ctuSize > 32)
186 {
187 m_mvlbRowstoreCache.dwAddress = (picWidth <= 4096) ? 64 : 132;
188 }
189 else
190 {
191 m_mvlbRowstoreCache.dwAddress = (picWidth <= 4064) ? 127 : 264;
192 }
193 }
194
195 //PRLB
196 if (m_prlbRowstoreCache.supported)
197 {
198 if (ctuSize > 32)
199 {
200 m_prlbRowstoreCache.enabled = true;
201 m_prlbRowstoreCache.dwAddress = (picWidth <= 4096) ? 320 : 660;
202 }
203 else
204 {
205 m_prlbRowstoreCache.enabled = (picWidth <= 4064) ? true : false;
206 m_prlbRowstoreCache.dwAddress = (picWidth <= 4064) ? 381 : 0;
207 }
208 }
209
210 //LFYLB
211 if (m_lfylbRowstoreCache.supported)
212 {
213 if (ctuSize > 32)
214 {
215 m_lfylbRowstoreCache.enabled = (picWidth <= 4096) ? true : false;
216 m_lfylbRowstoreCache.dwAddress = (picWidth <= 4096) ? 576 : 0;
217 }
218 else
219 {
220 m_lfylbRowstoreCache.enabled = (picWidth <= 4064) ? true : false;
221 m_lfylbRowstoreCache.dwAddress = (picWidth <= 4064) ? 635 : 0;
222 }
223 }
224
225 //LFULB
226 if (m_lfulbRowstoreCache.supported)
227 {
228 m_lfulbRowstoreCache.enabled = true;
229 if (ctuSize > 32)
230 {
231 m_lfulbRowstoreCache.dwAddress = (picWidth <= 4096) ? 1280 : 1188;
232 }
233 else
234 {
235 m_lfulbRowstoreCache.dwAddress = (picWidth <= 4064) ? 1397 : 792;
236 }
237 }
238
239 //LFVLB
240 if (m_lfvlbRowstoreCache.supported)
241 {
242 m_lfvlbRowstoreCache.enabled = true;
243 if (ctuSize > 32)
244 {
245 m_lfvlbRowstoreCache.dwAddress = (picWidth <= 4096) ? 1472 : 1584;
246 }
247 else
248 {
249 m_lfvlbRowstoreCache.dwAddress = (picWidth <= 4064) ? 1651 : 1320;
250 }
251 }
252
253 //SAYLB
254 if (m_saylbRowstoreCache.supported)
255 {
256 if (ctuSize > 32)
257 {
258 m_saylbRowstoreCache.enabled = (picWidth <= 4096) ? true : false;
259 m_saylbRowstoreCache.dwAddress = (picWidth <= 4096) ? 1664 : 0;
260 }
261 else
262 {
263 m_saylbRowstoreCache.enabled = (picWidth <= 4064) ? true : false;
264 m_saylbRowstoreCache.dwAddress = (picWidth <= 4064) ? 1905 : 0;
265 }
266 }
267
268 //SAULB
269 if (m_saulbRowstoreCache.supported)
270 {
271 m_saulbRowstoreCache.enabled = true;
272 if (ctuSize > 32)
273 {
274 m_saulbRowstoreCache.dwAddress = (picWidth <= 4096) ? 1857 : 1980;
275 }
276 else
277 {
278 m_saulbRowstoreCache.dwAddress = (picWidth <= 4064) ? 2160 : 1848;
279 }
280 }
281
282 //SAVLB
283 if (m_savlbRowstoreCache.supported)
284 {
285 m_savlbRowstoreCache.enabled = true;
286 if (ctuSize > 32)
287 {
288 m_savlbRowstoreCache.dwAddress = (picWidth <= 4096) ? 1986 : 2245;
289 }
290 else
291 {
292 m_savlbRowstoreCache.dwAddress = (picWidth <= 4064) ? 2288 : 2113;
293 }
294 }
295
296 //ALFLB
297 if (m_alflbRowstoreCache.supported)
298 {
299 if (ctuSize > 32)
300 {
301 m_alflbRowstoreCache.enabled = (picWidth <= 4096) ? true : false;
302 m_alflbRowstoreCache.dwAddress = (picWidth <= 4096) ? 2115 : 0;
303 }
304 else
305 {
306 m_alflbRowstoreCache.enabled = (picWidth <= 4064) ? true : false;
307 m_alflbRowstoreCache.dwAddress = (picWidth <= 4064) ? 2416 : 0;
308 }
309 }
310
311 return MOS_STATUS_SUCCESS;
312 }
313
314 MOS_STATUS GetVvcpStateCmdSize(uint32_t *commandsSize, uint32_t *patchListSize, PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) override
315 {
316 // Just return success here, please implement logic in platform sepecific impl class.
317 return MOS_STATUS_SUCCESS;
318 }
319
320 MOS_STATUS GetVvcpSliceLvlCmdSize(
321 uint32_t *sliceLvlCmdSize) override
322 {
323 // Just return success here, please implement logic in platform sepecific impl class.
324 return MOS_STATUS_SUCCESS;
325 }
326
327 MOS_STATUS GetVvcpPrimitiveCmdSize(
328 uint32_t *sliceCommandsSize,
329 uint32_t *slicePatchListSize,
330 uint32_t *tileCommandsSize,
331 uint32_t *tilePatchListSize) override
332 {
333 // Just return success here, please implement logic in platform sepecific impl class.
334 return MOS_STATUS_SUCCESS;
335 }
336
337 protected:
338 using base_t = Itf;
339 MhwCpInterface *m_cpItf = nullptr;
340
341 bool m_decodeInUse = true; //!< Flag to indicate if the interface is for decoder or encoder use
342
343 Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : mhw::Impl(osItf)
344 {
345 MHW_FUNCTION_ENTER;
346 m_cpItf = cpItf;
347
348 InitRowstoreUserFeatureSettings();
349 }
350
351 virtual ~Impl()
352 {
353 MHW_FUNCTION_ENTER;
354
355 #if (_DEBUG || _RELEASE_INTERNAL)
356 if (m_edlbRowstoreCache.enabled ||
357 m_mvlbRowstoreCache.enabled ||
358 m_prlbRowstoreCache.enabled ||
359 m_lfylbRowstoreCache.enabled ||
360 m_lfulbRowstoreCache.enabled ||
361 m_lfvlbRowstoreCache.enabled ||
362 m_saylbRowstoreCache.enabled ||
363 m_saulbRowstoreCache.enabled ||
364 m_savlbRowstoreCache.enabled ||
365 m_alflbRowstoreCache.enabled)
366 {
367 // Report rowstore cache usage status to regkey
368 ReportUserSettingForDebug(
369 m_userSettingPtr,
370 __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED,
371 1,
372 MediaUserSetting::Group::Device);
373 }
374 #endif // _DEBUG || _RELEASE_INTERNAL
375
376 }
377
378 virtual uint32_t GetMocsValue(MOS_HW_RESOURCE_DEF hwResType) = 0;
379
380 RowStoreCache m_edlbRowstoreCache = {}; //!< VCED Line Buffer(EDLB)
381 RowStoreCache m_mvlbRowstoreCache = {}; //!< VCMV Line Buffer (MVLB)
382 RowStoreCache m_prlbRowstoreCache = {}; //!< VCPR Line Buffer (PRLB)
383 RowStoreCache m_lfylbRowstoreCache = {}; //!< VCLF Y Line Buffer (LFYLB)
384 RowStoreCache m_lfulbRowstoreCache = {}; //!< VCLF U Line Buffer (LFULB)
385 RowStoreCache m_lfvlbRowstoreCache = {}; //!< VCLF V Line Buffer (LFVLB)
386 RowStoreCache m_saylbRowstoreCache = {}; //!< VCSAO Y Line Buffer (SAYLB)
387 RowStoreCache m_saulbRowstoreCache = {}; //!< VCSAO U Line Buffer (SAULB)
388 RowStoreCache m_savlbRowstoreCache = {}; //!< VCSAO V Line Buffer (SAVLB)
389 RowStoreCache m_alflbRowstoreCache = {}; //!< VCALF Line Buffer (ALFLB)
390
391 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {}; //!< Cacheability settings
392 private:
393
394 bool m_rowstoreCachingSupported = false; //!< Flag to indicate if row store cache is supported
395
396 void InitRowstoreUserFeatureSettings()
397 {
398 m_rowstoreCachingSupported = true;
399 #if (_DEBUG || _RELEASE_INTERNAL)
400 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf);
401
402 DeclareUserSettingKeyForDebug(
403 userSettingPtr,
404 "DisableVvcEdlbRowstoreCache",
405 MediaUserSetting::Group::Device,
406 0,
407 true);
408 DeclareUserSettingKeyForDebug(
409 userSettingPtr,
410 "DisableVvcMvlbRowstoreCache",
411 MediaUserSetting::Group::Device,
412 0,
413 true);
414 DeclareUserSettingKeyForDebug(
415 userSettingPtr,
416 "DisableVvcPrlbRowstoreCache",
417 MediaUserSetting::Group::Device,
418 0,
419 true);
420 DeclareUserSettingKeyForDebug(
421 userSettingPtr,
422 "DisableVvcLfylbRowstoreCache",
423 MediaUserSetting::Group::Device,
424 0,
425 true);
426 DeclareUserSettingKeyForDebug(
427 userSettingPtr,
428 "DisableVvcLfulbRowstoreCache",
429 MediaUserSetting::Group::Device,
430 0,
431 true);
432 DeclareUserSettingKeyForDebug(
433 userSettingPtr,
434 "DisableVvcLfvlbRowstoreCache",
435 MediaUserSetting::Group::Device,
436 0,
437 true);
438 DeclareUserSettingKeyForDebug(
439 userSettingPtr,
440 "DisableVvcSaylbRowstoreCache",
441 MediaUserSetting::Group::Device,
442 0,
443 true);
444 DeclareUserSettingKeyForDebug(
445 userSettingPtr,
446 "DisableVvcSaulbRowstoreCache",
447 MediaUserSetting::Group::Device,
448 0,
449 true);
450 DeclareUserSettingKeyForDebug(
451 userSettingPtr,
452 "DisableVvcSavlbRowstoreCache",
453 MediaUserSetting::Group::Device,
454 0,
455 true);
456 DeclareUserSettingKeyForDebug(
457 userSettingPtr,
458 "DisableVvcAlflbRowstoreCache",
459 MediaUserSetting::Group::Device,
460 0,
461 true);
462
463 {
464 MediaUserSetting::Value outValue;
465 ReadUserSettingForDebug(userSettingPtr,
466 outValue,
467 "Disable RowStore Cache",
468 MediaUserSetting::Group::Device);
469 m_rowstoreCachingSupported = !(outValue.Get<bool>());
470 }
471 #endif // _DEBUG || _RELEASE_INTERNAL
472
473 if (m_rowstoreCachingSupported) // updated
474 {
475 m_edlbRowstoreCache.supported = true;
476 #if (_DEBUG || _RELEASE_INTERNAL)
477 {
478 MediaUserSetting::Value outValue;
479 ReadUserSettingForDebug(userSettingPtr,
480 outValue,
481 "DisableVvcEdlbRowstoreCache",
482 MediaUserSetting::Group::Device);
483 m_edlbRowstoreCache.supported = !(outValue.Get<bool>());
484 }
485 #endif // _DEBUG || _RELEASE_INTERNAL
486
487 m_mvlbRowstoreCache.supported = true;
488 #if (_DEBUG || _RELEASE_INTERNAL)
489 {
490 MediaUserSetting::Value outValue;
491 ReadUserSettingForDebug(userSettingPtr,
492 outValue,
493 "DisableVvcMvlbRowstoreCache",
494 MediaUserSetting::Group::Device);
495 m_mvlbRowstoreCache.supported = !(outValue.Get<bool>());
496 }
497 #endif // _DEBUG || _RELEASE_INTERNAL
498
499 m_prlbRowstoreCache.supported = true;
500 #if (_DEBUG || _RELEASE_INTERNAL)
501 {
502 MediaUserSetting::Value outValue;
503 ReadUserSettingForDebug(userSettingPtr,
504 outValue,
505 "DisableVvcPrlbRowstoreCache",
506 MediaUserSetting::Group::Device);
507 m_prlbRowstoreCache.supported = !(outValue.Get<bool>());
508 }
509 #endif // _DEBUG || _RELEASE_INTERNAL
510
511 m_lfylbRowstoreCache.supported = true;
512 #if (_DEBUG || _RELEASE_INTERNAL)
513 {
514 MediaUserSetting::Value outValue;
515 ReadUserSettingForDebug(userSettingPtr,
516 outValue,
517 "DisableVvcLfylbRowstoreCache",
518 MediaUserSetting::Group::Device);
519 m_lfylbRowstoreCache.supported = !(outValue.Get<bool>());
520 }
521 #endif // _DEBUG || _RELEASE_INTERNAL
522
523 m_lfulbRowstoreCache.supported = true;
524 #if (_DEBUG || _RELEASE_INTERNAL)
525 {
526 MediaUserSetting::Value outValue;
527 ReadUserSettingForDebug(userSettingPtr,
528 outValue,
529 "DisableVvcLfulbRowstoreCache",
530 MediaUserSetting::Group::Device);
531 m_lfulbRowstoreCache.supported = !(outValue.Get<bool>());
532 }
533 #endif // _DEBUG || _RELEASE_INTERNAL
534
535 m_lfvlbRowstoreCache.supported = true;
536 #if (_DEBUG || _RELEASE_INTERNAL)
537 {
538 MediaUserSetting::Value outValue;
539 ReadUserSettingForDebug(userSettingPtr,
540 outValue,
541 "DisableVvcLfvlbRowstoreCache",
542 MediaUserSetting::Group::Device);
543 m_lfvlbRowstoreCache.supported = !(outValue.Get<bool>());
544 }
545 #endif // _DEBUG || _RELEASE_INTERNAL
546
547 m_saylbRowstoreCache.supported = true;
548 #if (_DEBUG || _RELEASE_INTERNAL)
549 {
550 MediaUserSetting::Value outValue;
551 ReadUserSettingForDebug(userSettingPtr,
552 outValue,
553 "DisableVvcSaylbRowstoreCache",
554 MediaUserSetting::Group::Device);
555 m_saylbRowstoreCache.supported = !(outValue.Get<bool>());
556 }
557 #endif // _DEBUG || _RELEASE_INTERNAL
558
559 m_saulbRowstoreCache.supported = true;
560 #if (_DEBUG || _RELEASE_INTERNAL)
561 {
562 MediaUserSetting::Value outValue;
563 ReadUserSettingForDebug(userSettingPtr,
564 outValue,
565 "DisableVvcSaulbRowstoreCache",
566 MediaUserSetting::Group::Device);
567 m_saulbRowstoreCache.supported = !(outValue.Get<bool>());
568 }
569 #endif // _DEBUG || _RELEASE_INTERNAL
570
571 m_savlbRowstoreCache.supported = true;
572 #if (_DEBUG || _RELEASE_INTERNAL)
573 {
574 MediaUserSetting::Value outValue;
575 ReadUserSettingForDebug(userSettingPtr,
576 outValue,
577 "DisableVvcSavlbRowstoreCache",
578 MediaUserSetting::Group::Device);
579 m_savlbRowstoreCache.supported = !(outValue.Get<bool>());
580 }
581 #endif // _DEBUG || _RELEASE_INTERNAL
582
583 m_alflbRowstoreCache.supported = true;
584 #if (_DEBUG || _RELEASE_INTERNAL)
585 {
586 MediaUserSetting::Value outValue;
587 ReadUserSettingForDebug(userSettingPtr,
588 outValue,
589 "DisableVvcAlflbRowstoreCache",
590 MediaUserSetting::Group::Device);
591 m_alflbRowstoreCache.supported = !(outValue.Get<bool>());
592 }
593 #endif // _DEBUG || _RELEASE_INTERNAL
594 }
595 }
596
597 protected:
598
599 _MHW_SETCMD_OVERRIDE_DECL(VVCP_VD_CONTROL_STATE)
600 {
601 _MHW_SETCMD_CALLBASE(VVCP_VD_CONTROL_STATE);
602
603 #define DO_FIELDS() \
604 DO_FIELD(VdControlStateBody.DW0, PipelineInitialization, params.pipelineInitialization); \
605 DO_FIELD(VdControlStateBody.DW1, MemoryImplicitFlush, params.memoryImplicitFlush); \
606 DO_FIELD(VdControlStateBody.DW1, PipeScalableModePipeLock, params.pipeScalableModePipeLock); \
607 DO_FIELD(VdControlStateBody.DW1, PipeScalableModePipeUnlock, params.pipeScalableModePipeUnlock);
608
609 #include "mhw_hwcmd_process_cmdfields.h"
610 }
611
612 _MHW_SETCMD_OVERRIDE_DECL(VVCP_PIPE_MODE_SELECT)
613 {
614 _MHW_SETCMD_CALLBASE(VVCP_PIPE_MODE_SELECT);
615
616 MHW_MI_CHK_STATUS(m_cpItf->SetProtectionSettingsForReservedPipeModeSelect((uint32_t *)&cmd));
617
618 #define DO_FIELDS() \
619 DO_FIELD(DW1, CodecSelect, params.codecSelect); \
620 DO_FIELD(DW1, PicStatusErrorReportEnable, params.picStatusErrorReportEnable ? 1 : 0); \
621 DO_FIELD(DW1, CodecStandardSelect, params.codecStandardSelect); \
622 DO_FIELD(DW2, PicStatusErrorReportId, params.picStatusErrorReportId);
623
624 #include "mhw_hwcmd_process_cmdfields.h"
625 }
626
627 _MHW_SETCMD_OVERRIDE_DECL(VVCP_SURFACE_STATE)
628 {
629 _MHW_SETCMD_CALLBASE(VVCP_SURFACE_STATE);
630
631 #define DO_FIELDS() \
632 DO_FIELD(DW1, SurfaceId, params.surfaceId); \
633 DO_FIELD(DW1, SurfacePitchMinus1, params.surfacePitchMinus1); \
634 DO_FIELD(DW2, SurfaceFormat, params.surfaceFormat); \
635 DO_FIELD(DW2, YOffsetForUCbInPixel, params.yOffsetForUCbInPixel); \
636 DO_FIELD(DW4, CompressionFormat, params.compressionFormat)
637
638 #include "mhw_hwcmd_process_cmdfields.h"
639 }
640
641 _MHW_SETCMD_OVERRIDE_DECL(VVCP_PIPE_BUF_ADDR_STATE)
642 {
643 _MHW_SETCMD_CALLBASE(VVCP_PIPE_BUF_ADDR_STATE);
644
645 MHW_RESOURCE_PARAMS resourceParams = {};
646
647 // 1. MHW_VDBOX_HCP_GENERAL_STATE_SHIFT(6) may not work with DecodedPicture
648 // since it needs to be 4k aligned
649 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
650 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
651
652 // Decoded Output Frame Buffer
653 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
654 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC);
655 cmd.DecodedPictureMemoryAddressAttributes.DW0.Tilemode = GetHwTileType(params.decodedPic->TileType, params.decodedPic->TileModeGMM, params.decodedPic->bGMMTileEnabled);
656
657 resourceParams.presResource = &(params.decodedPic->OsResource);
658 resourceParams.dwOffset = params.decodedPic->dwOffset;
659 resourceParams.pdwCmd = (cmd.DecodedPictureBaseAddress.DW0_1.Value);
660 resourceParams.dwLocationInCmd = 1;
661 resourceParams.bIsWritable = true;
662
663 MHW_MI_CHK_STATUS(AddResourceToCmd(
664 m_osItf,
665 m_currentCmdBuf,
666 &resourceParams));
667
668 // Reference frames
669 for (uint32_t i = 0; i < vvcMaxNumRefFrame; i++)
670 {
671 // Reference Picture Buffer
672 if (params.references[i] != nullptr)
673 {
674 MOS_SURFACE details = {};
675 details.Format = Format_Invalid;
676 MHW_MI_CHK_STATUS(m_osItf->pfnGetResourceInfo(m_osItf, params.references[i], &details));
677 cmd.ReferencePicture[i].ReferencePictureMemoryAddressAttributes.DW0.Tilemode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
678 cmd.ReferencePicture[i].ReferencePictureMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
679 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC);
680
681 resourceParams.presResource = params.references[i];
682 resourceParams.pdwCmd = (cmd.ReferencePicture[i].ReferencePictureBaseAddress0Refaddr.DW0_1.Value);
683 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
684 resourceParams.dwLocationInCmd = (i * 3) + 4;
685 resourceParams.bIsWritable = false;
686 resourceParams.dwSharedMocsOffset = 2;
687
688 MHW_MI_CHK_STATUS(AddResourceToCmd(
689 m_osItf,
690 m_currentCmdBuf,
691 &resourceParams));
692 }
693 }
694
695 // Collocated MV Temporal buffers
696 for (uint32_t i = 0; i < vvcMaxNumRefFrame; i++)
697 {
698 if (params.colMvTemporalBuffer[i] != nullptr)
699 {
700 cmd.CollocatedMotionVectorTemporalBuffer[i].ReferencePictureMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
701 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
702
703 resourceParams.presResource = params.colMvTemporalBuffer[i];
704 resourceParams.dwOffset = 0;
705 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBuffer[i].ReferencePictureBaseAddress0Refaddr.DW0_1.Value);
706 resourceParams.dwLocationInCmd = (i * 3) + 49;
707 resourceParams.bIsWritable = true;
708 resourceParams.dwSharedMocsOffset = 2;
709
710 InitMocsParams(resourceParams, &cmd.CollocatedMotionVectorTemporalBuffer[i].ReferencePictureMemoryAddressAttributes.DW0.Value, 1, 6);
711
712 MHW_MI_CHK_STATUS(AddResourceToCmd(
713 m_osItf,
714 m_currentCmdBuf,
715 &resourceParams));
716 }
717 }
718
719 // Current Motion Vector Temporal Buffer
720 if (params.curMvTemporalBuffer != nullptr)
721 {
722 cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
723 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
724
725 resourceParams.presResource = params.curMvTemporalBuffer;
726 resourceParams.dwOffset = 0;
727 resourceParams.pdwCmd = (cmd.CurrentMotionVectorTemporalBufferBaseAddress.DW0_1.Value);
728 resourceParams.dwLocationInCmd = 94;
729 resourceParams.bIsWritable = true;
730
731 InitMocsParams(resourceParams, &cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.Value, 1, 6);
732
733 MHW_MI_CHK_STATUS(AddResourceToCmd(
734 m_osItf,
735 m_currentCmdBuf,
736 &resourceParams));
737 }
738
739 // APS Scaling List Buffer
740 if (params.apsScalingListDataBuffer != nullptr)
741 {
742 cmd.ApsScalinglistDataBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
743 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
744
745 resourceParams.presResource = params.apsScalingListDataBuffer;
746 resourceParams.dwOffset = 0;
747 resourceParams.pdwCmd = (cmd.ApsScalinglistDataBufferBaseAddress.DW0_1.Value);
748 resourceParams.dwLocationInCmd = 97;
749 resourceParams.bIsWritable = false;
750
751 InitMocsParams(resourceParams, &cmd.ApsScalinglistDataBufferMemoryAddressAttributes.DW0.Value, 1, 6);
752
753 MHW_MI_CHK_STATUS(AddResourceToCmd(
754 m_osItf,
755 m_currentCmdBuf,
756 &resourceParams));
757 }
758
759 // APS ALF buffer
760 if (params.apsAlfBuffer != nullptr)
761 {
762 cmd.ApsAlfDataBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
763 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
764
765 resourceParams.presResource = params.apsAlfBuffer;
766 resourceParams.dwOffset = 0;
767 resourceParams.pdwCmd = (cmd.ApsAlfDataBufferBaseAddress.DW0_1.Value);
768 resourceParams.dwLocationInCmd = 100;
769 resourceParams.bIsWritable = false;
770
771 InitMocsParams(resourceParams, &cmd.ApsAlfDataBufferMemoryAddressAttributes.DW0.Value, 1, 6);
772
773 MHW_MI_CHK_STATUS(AddResourceToCmd(
774 m_osItf,
775 m_currentCmdBuf,
776 &resourceParams));
777 }
778
779 // SPS Chroma QP buffer
780 if (params.spsChromaQpTableBuffer != nullptr)
781 {
782 cmd.SpsChromaqpTableBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
783 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
784 resourceParams.presResource = params.spsChromaQpTableBuffer;
785 resourceParams.dwOffset = 0;
786 resourceParams.pdwCmd = (cmd.SpsChromaqpTableBufferBaseAddress.DW0_1.Value);
787 resourceParams.dwLocationInCmd = 103;
788 resourceParams.bIsWritable = false;
789
790 InitMocsParams(resourceParams, &cmd.SpsChromaqpTableBufferMemoryAddressAttributes.DW0.Value, 1, 6);
791
792 MHW_MI_CHK_STATUS(AddResourceToCmd(
793 m_osItf,
794 m_currentCmdBuf,
795 &resourceParams));
796 }
797
798 // Reset dwSharedMocsOffset
799 resourceParams.dwSharedMocsOffset = 0;
800
801 // Rowstore cache
802 // VCED Line Buffer (EDLB)
803 if (m_edlbRowstoreCache.enabled)
804 {
805 cmd.VcedLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcedLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
806 cmd.VcedLineBufferBaseAddress.DW0_1.BaseAddress = m_edlbRowstoreCache.dwAddress;
807 }
808 else if (params.vcedLineBuffer != nullptr)
809 {
810 cmd.VcedLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
811 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
812
813 resourceParams.presResource = params.vcedLineBuffer;
814 resourceParams.dwOffset = 0;
815 resourceParams.pdwCmd = (cmd.VcedLineBufferBaseAddress.DW0_1.Value);
816 resourceParams.dwLocationInCmd = 106;
817 resourceParams.bIsWritable = true;
818
819 InitMocsParams(resourceParams, &cmd.VcedLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
820
821 MHW_MI_CHK_STATUS(AddResourceToCmd(
822 m_osItf,
823 m_currentCmdBuf,
824 &resourceParams));
825 }
826
827 // VCMV Line Buffer (MVLB)
828 if (m_mvlbRowstoreCache.enabled)
829 {
830 cmd.VcmvLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcmvLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
831 cmd.VcmvLineBufferBaseAddress.DW0_1.BaseAddress = m_mvlbRowstoreCache.dwAddress;
832 }
833 else if (params.vcmvLineBuffer != nullptr)
834 {
835 cmd.VcmvLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
836 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
837
838 resourceParams.presResource = params.vcmvLineBuffer;
839 resourceParams.dwOffset = 0;
840 resourceParams.pdwCmd = (cmd.VcmvLineBufferBaseAddress.DW0_1.Value);
841 resourceParams.dwLocationInCmd = 109;
842 resourceParams.bIsWritable = true;
843
844 InitMocsParams(resourceParams, &cmd.VcmvLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
845
846 MHW_MI_CHK_STATUS(AddResourceToCmd(
847 m_osItf,
848 m_currentCmdBuf,
849 &resourceParams));
850 }
851
852 // VCPR Line Buffer (PRLB)
853 if (m_prlbRowstoreCache.enabled)
854 {
855 cmd.VcprLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcprLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
856 cmd.VcprLineBufferBaseAddress.DW0_1.BaseAddress = m_prlbRowstoreCache.dwAddress;
857 }
858 else if (params.vcprLineBuffer != nullptr)
859 {
860 cmd.VcprLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
861 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
862
863 resourceParams.presResource = params.vcprLineBuffer;
864 resourceParams.dwOffset = 0;
865 resourceParams.pdwCmd = (cmd.VcprLineBufferBaseAddress.DW0_1.Value);
866 resourceParams.dwLocationInCmd = 112;
867 resourceParams.bIsWritable = true;
868
869 InitMocsParams(resourceParams, &cmd.VcprLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
870
871 MHW_MI_CHK_STATUS(AddResourceToCmd(
872 m_osItf,
873 m_currentCmdBuf,
874 &resourceParams));
875 }
876
877 // VCLF Y Line Buffer (LFYLB)
878 if (m_lfylbRowstoreCache.enabled)
879 {
880 cmd.VclfYLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VclfYLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
881 cmd.VclfYLineBufferBaseAddress.DW0_1.BaseAddress = m_lfylbRowstoreCache.dwAddress;
882 }
883 else if (params.vclfYLineBuffer != nullptr)
884 {
885 cmd.VclfYLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
886 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
887
888 resourceParams.presResource = params.vclfYLineBuffer;
889 resourceParams.dwOffset = 0;
890 resourceParams.pdwCmd = (cmd.VclfYLineBufferBaseAddress.DW0_1.Value);
891 resourceParams.dwLocationInCmd = 115;
892 resourceParams.bIsWritable = true;
893
894 InitMocsParams(resourceParams, &cmd.VclfYLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
895
896 MHW_MI_CHK_STATUS(AddResourceToCmd(
897 m_osItf,
898 m_currentCmdBuf,
899 &resourceParams));
900 }
901
902 // VCLF Y Tile Row Buffer (LFYTR)
903 if (params.vclfYTileRowBuffer != nullptr)
904 {
905 cmd.VclfYTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
906 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
907
908 resourceParams.presResource = params.vclfYTileRowBuffer;
909 resourceParams.dwOffset = 0;
910 resourceParams.pdwCmd = (cmd.VclfYTileRowBufferBaseAddress.DW0_1.Value);
911 resourceParams.dwLocationInCmd = 118;
912 resourceParams.bIsWritable = true;
913
914 InitMocsParams(resourceParams, &cmd.VclfYTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
915
916 MHW_MI_CHK_STATUS(AddResourceToCmd(
917 m_osItf,
918 m_currentCmdBuf,
919 &resourceParams));
920 }
921
922 // VCLF Y Tile Column Buffer (LFYTC)
923 if (params.vclfYTileColumnBuffer != nullptr)
924 {
925 cmd.VclfYTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
926 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
927
928 resourceParams.presResource = params.vclfYTileColumnBuffer;
929 resourceParams.dwOffset = 0;
930 resourceParams.pdwCmd = (cmd.VclfYTileColumnBufferBaseAddress.DW0_1.Value);
931 resourceParams.dwLocationInCmd = 121;
932 resourceParams.bIsWritable = true;
933
934 InitMocsParams(resourceParams, &cmd.VclfYTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
935
936 MHW_MI_CHK_STATUS(AddResourceToCmd(
937 m_osItf,
938 m_currentCmdBuf,
939 &resourceParams));
940 }
941
942 // VCLF U Line Buffer (LFULB)
943 if (m_lfulbRowstoreCache.enabled)
944 {
945 cmd.VclfULineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VclfULineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
946 cmd.VclfULineBufferBaseAddress.DW0_1.BaseAddress = m_lfulbRowstoreCache.dwAddress;
947 }
948 else if (params.vclfULineBuffer != nullptr)
949 {
950 cmd.VclfULineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
951 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
952
953 resourceParams.presResource = params.vclfULineBuffer;
954 resourceParams.dwOffset = 0;
955 resourceParams.pdwCmd = (cmd.VclfULineBufferBaseAddress.DW0_1.Value);
956 resourceParams.dwLocationInCmd = 124;
957 resourceParams.bIsWritable = true;
958
959 InitMocsParams(resourceParams, &cmd.VclfULineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
960
961 MHW_MI_CHK_STATUS(AddResourceToCmd(
962 m_osItf,
963 m_currentCmdBuf,
964 &resourceParams));
965 }
966
967 // VCLF U Tile Row Buffer (LFUTR)
968 if (params.vclfUTileRowBuffer != nullptr)
969 {
970 cmd.VclfUTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
971 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
972
973 resourceParams.presResource = params.vclfUTileRowBuffer;
974 resourceParams.dwOffset = 0;
975 resourceParams.pdwCmd = (cmd.VclfUTileRowBufferBaseAddress.DW0_1.Value);
976 resourceParams.dwLocationInCmd = 127;
977 resourceParams.bIsWritable = true;
978
979 InitMocsParams(resourceParams, &cmd.VclfUTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
980
981 MHW_MI_CHK_STATUS(AddResourceToCmd(
982 m_osItf,
983 m_currentCmdBuf,
984 &resourceParams));
985 }
986
987 // VCLF U Tile Column Buffer (LFUTC)
988 if (params.vclfUTileColumnBuffer != nullptr)
989 {
990 cmd.VclfUTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
991 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
992
993 resourceParams.presResource = params.vclfUTileColumnBuffer;
994 resourceParams.dwOffset = 0;
995 resourceParams.pdwCmd = (cmd.VclfUTileColumnBufferBaseAddress.DW0_1.Value);
996 resourceParams.dwLocationInCmd = 130;
997 resourceParams.bIsWritable = true;
998
999 InitMocsParams(resourceParams, &cmd.VclfUTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1000
1001 MHW_MI_CHK_STATUS(AddResourceToCmd(
1002 m_osItf,
1003 m_currentCmdBuf,
1004 &resourceParams));
1005 }
1006
1007 // VCLF V Line Buffer (LFVLB)
1008 if (m_lfvlbRowstoreCache.enabled)
1009 {
1010 cmd.VclfVLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VclfVLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1011 cmd.VclfVLineBufferBaseAddress.DW0_1.BaseAddress = m_lfvlbRowstoreCache.dwAddress;
1012 }
1013 else if (params.vclfVLineBuffer != nullptr)
1014 {
1015 cmd.VclfVLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1016 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1017
1018 resourceParams.presResource = params.vclfVLineBuffer;
1019 resourceParams.dwOffset = 0;
1020 resourceParams.pdwCmd = (cmd.VclfVLineBufferBaseAddress.DW0_1.Value);
1021 resourceParams.dwLocationInCmd = 133;
1022 resourceParams.bIsWritable = true;
1023
1024 InitMocsParams(resourceParams, &cmd.VclfVLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1025
1026 MHW_MI_CHK_STATUS(AddResourceToCmd(
1027 m_osItf,
1028 m_currentCmdBuf,
1029 &resourceParams));
1030 }
1031
1032 // VCLF V Tile Row Buffer (LFVTR)
1033 if (params.vclfVTileRowBuffer != nullptr)
1034 {
1035 cmd.VclfVTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1036 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1037
1038 resourceParams.presResource = params.vclfVTileRowBuffer;
1039 resourceParams.dwOffset = 0;
1040 resourceParams.pdwCmd = (cmd.VclfVTileRowBufferBaseAddress.DW0_1.Value);
1041 resourceParams.dwLocationInCmd = 136;
1042 resourceParams.bIsWritable = true;
1043
1044 InitMocsParams(resourceParams, &cmd.VclfVTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1045
1046 MHW_MI_CHK_STATUS(AddResourceToCmd(
1047 m_osItf,
1048 m_currentCmdBuf,
1049 &resourceParams));
1050 }
1051
1052 // VCLF V Tile Column Buffer (LFVTC)
1053 if (params.vclfVTileColumnBuffer != nullptr)
1054 {
1055 cmd.VclfVTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1056 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1057
1058 resourceParams.presResource = params.vclfVTileColumnBuffer;
1059 resourceParams.dwOffset = 0;
1060 resourceParams.pdwCmd = (cmd.VclfVTileColumnBufferBaseAddress.DW0_1.Value);
1061 resourceParams.dwLocationInCmd = 139;
1062 resourceParams.bIsWritable = true;
1063
1064 InitMocsParams(resourceParams, &cmd.VclfVTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1065
1066 MHW_MI_CHK_STATUS(AddResourceToCmd(
1067 m_osItf,
1068 m_currentCmdBuf,
1069 &resourceParams));
1070 }
1071
1072 // VCSAO Y Line Buffer (SAYLB)
1073 if (m_saylbRowstoreCache.enabled)
1074 {
1075 cmd.VcsaoYLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcsaoYLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1076 cmd.VcsaoYLineBufferBaseAddress.DW0_1.BaseAddress = m_saylbRowstoreCache.dwAddress;
1077 }
1078 else if (params.vcSaoYLineBuffer != nullptr)
1079 {
1080 cmd.VcsaoYLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1081 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1082
1083 resourceParams.presResource = params.vcSaoYLineBuffer;
1084 resourceParams.dwOffset = 0;
1085 resourceParams.pdwCmd = (cmd.VcsaoYLineBufferBaseAddress.DW0_1.Value);
1086 resourceParams.dwLocationInCmd = 142;
1087 resourceParams.bIsWritable = true;
1088
1089 InitMocsParams(resourceParams, &cmd.VcsaoYLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1090
1091 MHW_MI_CHK_STATUS(AddResourceToCmd(
1092 m_osItf,
1093 m_currentCmdBuf,
1094 &resourceParams));
1095 }
1096
1097 // VCSAO Y Tile Row Buffer (SAYTR)
1098 if (params.vcSaoYTileRowBuffer != nullptr)
1099 {
1100 cmd.VcsaoYTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1101 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1102
1103 resourceParams.presResource = params.vcSaoYTileRowBuffer;
1104 resourceParams.dwOffset = 0;
1105 resourceParams.pdwCmd = (cmd.VcsaoYTileRowBufferBaseAddress.DW0_1.Value);
1106 resourceParams.dwLocationInCmd = 145;
1107 resourceParams.bIsWritable = true;
1108
1109 InitMocsParams(resourceParams, &cmd.VcsaoYTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1110
1111 MHW_MI_CHK_STATUS(AddResourceToCmd(
1112 m_osItf,
1113 m_currentCmdBuf,
1114 &resourceParams));
1115 }
1116
1117 // VCSAO Y Tile Column Buffer (SAYTC)
1118 if (params.vcSaoYTileColumnBuffer != nullptr)
1119 {
1120 cmd.VcsaoYTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1121 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1122
1123 resourceParams.presResource = params.vcSaoYTileColumnBuffer;
1124 resourceParams.dwOffset = 0;
1125 resourceParams.pdwCmd = (cmd.VcsaoYTileColumnBufferBaseAddress.DW0_1.Value);
1126 resourceParams.dwLocationInCmd = 148;
1127 resourceParams.bIsWritable = true;
1128
1129 InitMocsParams(resourceParams, &cmd.VcsaoYTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1130
1131 MHW_MI_CHK_STATUS(AddResourceToCmd(
1132 m_osItf,
1133 m_currentCmdBuf,
1134 &resourceParams));
1135 }
1136
1137 // VCSAO U Line Buffer (SAULB)
1138 if (m_saulbRowstoreCache.enabled)
1139 {
1140 cmd.VcsaoULineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcsaoULineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1141 cmd.VcsaoULineBufferBaseAddress.DW0_1.BaseAddress = m_saulbRowstoreCache.dwAddress;
1142 }
1143 else if (params.vcSaoULineBuffer != nullptr)
1144 {
1145 cmd.VcsaoULineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1146 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1147
1148 resourceParams.presResource = params.vcSaoULineBuffer;
1149 resourceParams.dwOffset = 0;
1150 resourceParams.pdwCmd = (cmd.VcsaoULineBufferBaseAddress.DW0_1.Value);
1151 resourceParams.dwLocationInCmd = 151;
1152 resourceParams.bIsWritable = true;
1153
1154 InitMocsParams(resourceParams, &cmd.VcsaoULineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1155
1156 MHW_MI_CHK_STATUS(AddResourceToCmd(
1157 m_osItf,
1158 m_currentCmdBuf,
1159 &resourceParams));
1160 }
1161
1162 // VCSAO U Tile Row Buffer (SAUTR)
1163 if (params.vcSaoUTileRowBuffer != nullptr)
1164 {
1165 cmd.VcsaoUTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1166 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1167
1168 resourceParams.presResource = params.vcSaoUTileRowBuffer;
1169 resourceParams.dwOffset = 0;
1170 resourceParams.pdwCmd = (cmd.VcsaoUTileRowBufferBaseAddress.DW0_1.Value);
1171 resourceParams.dwLocationInCmd = 154;
1172 resourceParams.bIsWritable = true;
1173
1174 InitMocsParams(resourceParams, &cmd.VcsaoUTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1175
1176 MHW_MI_CHK_STATUS(AddResourceToCmd(
1177 m_osItf,
1178 m_currentCmdBuf,
1179 &resourceParams));
1180 }
1181
1182 // VCSAO U Tile Column Buffer (SAUTC)
1183 if (params.vcSaoUTileColumnBuffer != nullptr)
1184 {
1185 cmd.VcsaoUTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1186 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1187
1188 resourceParams.presResource = params.vcSaoUTileColumnBuffer;
1189 resourceParams.dwOffset = 0;
1190 resourceParams.pdwCmd = (cmd.VcsaoUTileColumnBufferBaseAddress.DW0_1.Value);
1191 resourceParams.dwLocationInCmd = 157;
1192 resourceParams.bIsWritable = true;
1193
1194 InitMocsParams(resourceParams, &cmd.VcsaoUTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1195
1196 MHW_MI_CHK_STATUS(AddResourceToCmd(
1197 m_osItf,
1198 m_currentCmdBuf,
1199 &resourceParams));
1200 }
1201
1202 // VCSAO V Line Buffer (SAVLB)
1203 if (m_savlbRowstoreCache.enabled)
1204 {
1205 cmd.VcsaoVLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcsaoVLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1206 cmd.VcsaoVLineBufferBaseAddress.DW0_1.BaseAddress = m_savlbRowstoreCache.dwAddress;
1207 }
1208 else if (params.vcSaoVLineBuffer != nullptr)
1209 {
1210 cmd.VcsaoVLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1211 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1212
1213 resourceParams.presResource = params.vcSaoVLineBuffer;
1214 resourceParams.dwOffset = 0;
1215 resourceParams.pdwCmd = (cmd.VcsaoVLineBufferBaseAddress.DW0_1.Value);
1216 resourceParams.dwLocationInCmd = 160;
1217 resourceParams.bIsWritable = true;
1218
1219 InitMocsParams(resourceParams, &cmd.VcsaoVLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1220
1221 MHW_MI_CHK_STATUS(AddResourceToCmd(
1222 m_osItf,
1223 m_currentCmdBuf,
1224 &resourceParams));
1225 }
1226
1227 // VCSAO V Tile Row Buffer (SAVTR)
1228 if (params.vcSaoVTileRowBuffer != nullptr)
1229 {
1230 cmd.VcsaoVTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1231 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1232
1233 resourceParams.presResource = params.vcSaoVTileRowBuffer;
1234 resourceParams.dwOffset = 0;
1235 resourceParams.pdwCmd = (cmd.VcsaoVTileRowBufferBaseAddress.DW0_1.Value);
1236 resourceParams.dwLocationInCmd = 163;
1237 resourceParams.bIsWritable = true;
1238
1239 InitMocsParams(resourceParams, &cmd.VcsaoVTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1240
1241 MHW_MI_CHK_STATUS(AddResourceToCmd(
1242 m_osItf,
1243 m_currentCmdBuf,
1244 &resourceParams));
1245 }
1246
1247 // VCSAO V Tile Column Buffer (SAVTC)
1248 if (params.vcSaoVTileColumnBuffer != nullptr)
1249 {
1250 cmd.VcsaoVTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1251 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1252
1253 resourceParams.presResource = params.vcSaoVTileColumnBuffer;
1254 resourceParams.dwOffset = 0;
1255 resourceParams.pdwCmd = (cmd.VcsaoVTileColumnBufferBaseAddress.DW0_1.Value);
1256 resourceParams.dwLocationInCmd = 166;
1257 resourceParams.bIsWritable = true;
1258
1259 InitMocsParams(resourceParams, &cmd.VcsaoVTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1260
1261 MHW_MI_CHK_STATUS(AddResourceToCmd(
1262 m_osItf,
1263 m_currentCmdBuf,
1264 &resourceParams));
1265 }
1266
1267 // VCALF Line Buffer (ALFLB)
1268 if (m_alflbRowstoreCache.enabled)
1269 {
1270 cmd.VcalfLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.VcalfLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1271 cmd.VcalfLineBufferBaseAddress.DW0_1.BaseAddress = m_alflbRowstoreCache.dwAddress;
1272 }
1273 else if (params.vcAlfLineBuffer != nullptr)
1274 {
1275 cmd.VcalfLineBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1276 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1277
1278 resourceParams.presResource = params.vcAlfLineBuffer;
1279 resourceParams.dwOffset = 0;
1280 resourceParams.pdwCmd = (cmd.VcalfLineBufferBaseAddress.DW0_1.Value);
1281 resourceParams.dwLocationInCmd = 169;
1282 resourceParams.bIsWritable = true;
1283
1284 InitMocsParams(resourceParams, &cmd.VcalfLineBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1285
1286 MHW_MI_CHK_STATUS(AddResourceToCmd(
1287 m_osItf,
1288 m_currentCmdBuf,
1289 &resourceParams));
1290 }
1291
1292 // VCALF Tile Row Buffer (ALFTR)
1293 if (params.vcAlfTileRowBuffer != nullptr)
1294 {
1295 cmd.VcalfTileRowBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1296 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1297
1298 resourceParams.presResource = params.vcAlfTileRowBuffer;
1299 resourceParams.dwOffset = 0;
1300 resourceParams.pdwCmd = (cmd.VcalfTileRowBufferBaseAddress.DW0_1.Value);
1301 resourceParams.dwLocationInCmd = 172;
1302 resourceParams.bIsWritable = true;
1303
1304 InitMocsParams(resourceParams, &cmd.VcalfTileRowBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1305
1306 MHW_MI_CHK_STATUS(AddResourceToCmd(
1307 m_osItf,
1308 m_currentCmdBuf,
1309 &resourceParams));
1310 }
1311
1312 // VCALF Y Tile Column Buffer (ALYTC)
1313 if (params.vcAlfYTileColumnBuffer != nullptr)
1314 {
1315 cmd.VcalfYTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1316 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1317
1318 resourceParams.presResource = params.vcAlfYTileColumnBuffer;
1319 resourceParams.dwOffset = 0;
1320 resourceParams.pdwCmd = (cmd.VcalfYTileColumnBufferBaseAddress.DW0_1.Value);
1321 resourceParams.dwLocationInCmd = 175;
1322 resourceParams.bIsWritable = true;
1323
1324 InitMocsParams(resourceParams, &cmd.VcalfYTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1325
1326 MHW_MI_CHK_STATUS(AddResourceToCmd(
1327 m_osItf,
1328 m_currentCmdBuf,
1329 &resourceParams));
1330 }
1331
1332 // VCALF U Tile Column Buffer (ALUTC)
1333 if (params.vcAlfUTileColumnBuffer != nullptr)
1334 {
1335 cmd.VcalfUTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1336 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1337
1338 resourceParams.presResource = params.vcAlfUTileColumnBuffer;
1339 resourceParams.dwOffset = 0;
1340 resourceParams.pdwCmd = (cmd.VcalfUTileColumnBufferBaseAddress.DW0_1.Value);
1341 resourceParams.dwLocationInCmd = 178;
1342 resourceParams.bIsWritable = true;
1343
1344 InitMocsParams(resourceParams, &cmd.VcalfUTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1345
1346 MHW_MI_CHK_STATUS(AddResourceToCmd(
1347 m_osItf,
1348 m_currentCmdBuf,
1349 &resourceParams));
1350 }
1351
1352 // VCALF V Tile Column Buffer (ALVTC)
1353 if (params.vcAlfVTileColumnBuffer != nullptr)
1354 {
1355 cmd.VcalfVTileColumnBufferMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1356 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED);
1357
1358 resourceParams.presResource = params.vcAlfVTileColumnBuffer;
1359 resourceParams.dwOffset = 0;
1360 resourceParams.pdwCmd = (cmd.VcalfVTileColumnBufferBaseAddress.DW0_1.Value);
1361 resourceParams.dwLocationInCmd = 181;
1362 resourceParams.bIsWritable = true;
1363
1364 InitMocsParams(resourceParams, &cmd.VcalfVTileColumnBufferMemoryAddressAttributes.DW0.Value, 1, 6);
1365
1366 MHW_MI_CHK_STATUS(AddResourceToCmd(
1367 m_osItf,
1368 m_currentCmdBuf,
1369 &resourceParams));
1370 }
1371
1372 return MOS_STATUS_SUCCESS;
1373 }
1374
1375 _MHW_SETCMD_OVERRIDE_DECL(VVCP_IND_OBJ_BASE_ADDR_STATE)
1376 {
1377 _MHW_SETCMD_CALLBASE(VVCP_IND_OBJ_BASE_ADDR_STATE);
1378
1379 MHW_RESOURCE_PARAMS resourceParams = {};
1380 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
1381 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
1382
1383 // mode specific settings
1384 MHW_MI_CHK_NULL(params.presDataBuffer);
1385
1386 resourceParams.presResource = params.presDataBuffer;
1387 resourceParams.dwOffset = params.dwDataOffset;
1388 resourceParams.pdwCmd = &(cmd.VvcpIndirectBitstreamObjectBaseAddress.DW0_1.Value[0]);
1389 resourceParams.dwLocationInCmd = 1;
1390 resourceParams.dwSize = params.dwDataSize;
1391 resourceParams.bIsWritable = false;
1392
1393 // No Indirect Bitstream Object Access Upper Bound defined for VVC
1394 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1395
1396 InitMocsParams(resourceParams, &cmd.VvcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value, 1, 6);
1397
1398 MHW_MI_CHK_STATUS(AddResourceToCmd(
1399 m_osItf,
1400 m_currentCmdBuf,
1401 &resourceParams));
1402
1403 cmd.VvcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
1404 GetMocsValue(MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE);
1405
1406 return MOS_STATUS_SUCCESS;
1407 }
1408
1409 _MHW_SETCMD_OVERRIDE_DECL(VVCP_PIC_STATE)
1410 {
1411 _MHW_SETCMD_CALLBASE(VVCP_PIC_STATE);
1412
1413 // ALF
1414 for (auto i = 0; i < 8; i++)
1415 {
1416 if (params.dActiveapsid & (1 << i))
1417 {
1418 cmd.DPicApsalfparamsets[i].DW0.AlfLumaFilterSignalFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfLumaFilterSignalFlag;
1419 cmd.DPicApsalfparamsets[i].DW0.AlfChromaFilterSignalFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfChromaFilterSignalFlag;
1420 cmd.DPicApsalfparamsets[i].DW0.AlfCcCbFilterSignalFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfCcCbFilterSignalFlag;
1421 cmd.DPicApsalfparamsets[i].DW0.AlfCcCrFilterSignalFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfCcCrFilterSignalFlag; //!< alf_cc_cr_filter_signal_flag
1422 cmd.DPicApsalfparamsets[i].DW0.AlfLumaClipFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfLumaClipFlag; //!< alf_luma_clip_flag
1423 cmd.DPicApsalfparamsets[i].DW0.AlfChromaClipFlag = params.alfApsArray[i].m_alfFlags.m_fields.m_alfChromaClipFlag; //!< alf_chroma_clip_flag
1424 cmd.DPicApsalfparamsets[i].DW0.Reserved6 = 0; //!< Reserved
1425 cmd.DPicApsalfparamsets[i].DW0.AlfLumaNumFiltersSignalledMinus1 = params.alfApsArray[i].m_alfLumaNumFiltersSignalledMinus1; //!< alf_luma_num_filters_signalled_minus1
1426 cmd.DPicApsalfparamsets[i].DW0.AlfChromaNumAltFiltersMinus1 = params.alfApsArray[i].m_alfChromaNumAltFiltersMinus1;
1427 }
1428 }
1429
1430 #define DO_FIELDS() \
1431 DO_FIELD(DW1, SpsSubpicInfoPresentFlag, params.spsSubpicInfoPresentFlag); \
1432 DO_FIELD(DW1, SpsIndependentSubpicsFlag, params.spsIndependentSubpicsFlag);\
1433 DO_FIELD(DW1, SpsSubpicSameSizeFlag, params.spsSubpicSameSizeFlag);\
1434 DO_FIELD(DW1, SpsEntropyCodingSyncEnabledFlag, params.spsEntropyCodingSyncEnabledFlag);\
1435 DO_FIELD(DW1, SpsQtbttDualTreeIntraFlag, params.spsQtbttDualTreeIntraFlag);\
1436 DO_FIELD(DW1, SpsMaxLumaTransformSize64Flag, params.spsMaxLumaTransformSize64Flag);\
1437 DO_FIELD(DW1, SpsTransformSkipEnabledFlag, params.spsTransformSkipEnabledFlag);\
1438 DO_FIELD(DW1, SpsBdpcmEnabledFlag, params.spsBdpcmEnabledFlag);\
1439 DO_FIELD(DW1, SpsMtsEnabledFlag, params.spsMtsEnabledFlag);\
1440 DO_FIELD(DW1, SpsExplicitMtsIntraEnabledFlag, params.spsExplicitMtsIntraEnabledFlag);\
1441 DO_FIELD(DW1, SpsExplicitMtsInterEnabledFlag, params.spsExplicitMtsInterEnabledFlag);\
1442 DO_FIELD(DW1, SpsLfnstEnabledFlag, params.spsLfnstEnabledFlag);\
1443 DO_FIELD(DW1, SpsJointCbcrEnabledFlag, params.spsJointCbcrEnabledFlag);\
1444 DO_FIELD(DW1, SpsSameQpTableForChromaFlag, params.spsSameQpTableForChromaFlag);\
1445 DO_FIELD(DW1, DLmcsDisabledFlag, params.dLmcsDisabledFlag);\
1446 DO_FIELD(DW1, DDblkDisabledFlag, params.dDblkDisabledFlag);\
1447 DO_FIELD(DW1, DSaoLumaDisabledFlag, params.dSaoLumaDisabledFlag);\
1448 DO_FIELD(DW1, DSaoChromaDisabledFlag, params.dSaoChromaDisabledFlag);\
1449 DO_FIELD(DW1, DAlfDisabledFlag, params.dAlfDisabledFlag);\
1450 DO_FIELD(DW1, DAlfCbDisabledFlag, params.dAlfCbDisabledFlag);\
1451 DO_FIELD(DW1, DAlfCrDisabledFlag, params.dAlfCrDisabledFlag);\
1452 DO_FIELD(DW1, DAlfCcCbDisabledFlag, params.dAlfCcCbDisabledFlag);\
1453 DO_FIELD(DW1, DAlfCcCrDisabledFlag, params.dAlfCcCrDisabledFlag);\
1454 DO_FIELD(DW1, DSingleSliceFrameFlag, params.dSingleSliceFrameFlag);\
1455 DO_FIELD(DW2, SpsSbtmvpEnabledFlag, params.spsSbtmvpEnabledFlag);\
1456 DO_FIELD(DW2, SpsAmvrEnabledFlag, params.spsAmvrEnabledFlag);\
1457 DO_FIELD(DW2, SpsSmvdEnabledFlag, params.spsSmvdEnabledFlag);\
1458 DO_FIELD(DW2, SpsMmvdEnabledFlag, params.spsMmvdEnabledFlag);\
1459 DO_FIELD(DW2, SpsSbtEnabledFlag, params.spsSbtEnabledFlag);\
1460 DO_FIELD(DW2, SpsAffineEnabledFlag, params.spsAffineEnabledFlag);\
1461 DO_FIELD(DW2, Sps6ParamAffineEnabledFlag, params.sps6ParamAffineEnabledFlag);\
1462 DO_FIELD(DW2, SpsAffineAmvrEnabledFlag, params.spsAffineAmvrEnabledFlag);\
1463 DO_FIELD(DW2, SpsBcwEnabledFlag, params.spsBcwEnabledFlag);\
1464 DO_FIELD(DW2, SpsCiipEnabledFlag, params.spsCiipEnabledFlag);\
1465 DO_FIELD(DW2, SpsGpmEnabledFlag, params.spsGpmEnabledFlag);\
1466 DO_FIELD(DW2, SpsIspEnabledFlag, params.spsIspEnabledFlag);\
1467 DO_FIELD(DW2, SpsMrlEnabledFlag, params.spsMrlEnabledFlag);\
1468 DO_FIELD(DW2, SpsMipEnabledFlag, params.spsMipEnabledFlag);\
1469 DO_FIELD(DW2, SpsCclmEnabledFlag, params.spsCclmEnabledFlag);\
1470 DO_FIELD(DW2, SpsChromaHorizontalCollocatedFlag, params.spsChromaHorizontalCollocatedFlag);\
1471 DO_FIELD(DW2, SpsChromaVerticalCollocatedFlag, params.spsChromaVerticalCollocatedFlag);\
1472 DO_FIELD(DW2, SpsTemporalMvpEnabledFlag, params.spsTemporalMvpEnabledFlag);\
1473 DO_FIELD(DW2, SpsPaletteEnabledFlag, params.spsPaletteEnabledFlag);\
1474 DO_FIELD(DW2, SpsActEnabledFlag, params.spsActEnabledFlag);\
1475 DO_FIELD(DW2, SpsIbcEnabledFlag, params.spsIbcEnabledFlag);\
1476 DO_FIELD(DW2, SpsLadfEnabledFlag, params.spsLadfEnabledFlag);\
1477 DO_FIELD(DW2, SpsScalingMatrixForLfnstDisabledFlag, params.spsScalingMatrixForLfnstDisabledFlag);\
1478 DO_FIELD(DW2, SpsScalingMatrixForAlternativeColorSpaceDisabledFlag, params.spsScalingMatrixForAlternativeColorSpaceDisabledFlag);\
1479 DO_FIELD(DW2, SpsScalingMatrixDesignatedColorSpaceFlag, params.spsScalingMatrixDesignatedColorSpaceFlag);\
1480 DO_FIELD(DW3, PpsLoopFilterAcrossTilesEnabledFlag, params.ppsLoopFilterAcrossTilesEnabledFlag);\
1481 DO_FIELD(DW3, PpsRectSliceFlag, params.ppsRectSliceFlag);\
1482 DO_FIELD(DW3, PpsSingleSlicePerSubpicFlag, params.ppsSingleSlicePerSubpicFlag);\
1483 DO_FIELD(DW3, PpsLoopFilterAcrossSlicesEnabledFlag, params.ppsLoopFilterAcrossSlicesEnabledFlag);\
1484 DO_FIELD(DW3, PpsWeightedPredFlag, params.ppsWeightedPredFlag);\
1485 DO_FIELD(DW3, PpsWeightedBipredFlag, params.ppsWeightedBipredFlag);\
1486 DO_FIELD(DW3, PpsRefWraparoundEnabledFlag, params.ppsRefWraparoundEnabledFlag);\
1487 DO_FIELD(DW3, PpsCuQpDeltaEnabledFlag, params.ppsCuQpDeltaEnabledFlag);\
1488 DO_FIELD(DW3, Virtualboundariespresentflag, params.virtualboundariespresentflag);\
1489 DO_FIELD(DW3, PhNonRefPicFlag, params.phNonRefPicFlag);\
1490 DO_FIELD(DW3, PhChromaResidualScaleFlag, params.phChromaResidualScaleFlag);\
1491 DO_FIELD(DW3, PhTemporalMvpEnabledFlag, params.phTemporalMvpEnabledFlag);\
1492 DO_FIELD(DW3, PhMmvdFullpelOnlyFlag, params.phMmvdFullpelOnlyFlag);\
1493 DO_FIELD(DW3, PhMvdL1ZeroFlag, params.phMvdL1ZeroFlag);\
1494 DO_FIELD(DW3, PhBdofDisabledFlag, params.phBdofDisabledFlag);\
1495 DO_FIELD(DW3, PhDmvrDisabledFlag, params.phDmvrDisabledFlag);\
1496 DO_FIELD(DW3, PhProfDisabledFlag, params.phProfDisabledFlag);\
1497 DO_FIELD(DW3, PhJointCbcrSignFlag, params.phJointCbcrSignFlag);\
1498 DO_FIELD(DW4, SpsChromaFormatIdc, params.spsChromaFormatIdc);\
1499 DO_FIELD(DW4, SpsLog2CtuSizeMinus5, params.spsLog2CtuSizeMinus5);\
1500 DO_FIELD(DW4, SpsBitdepthMinus8, params.spsBitdepthMinus8);\
1501 DO_FIELD(DW4, SpsLog2MinLumaCodingBlockSizeMinus2, params.spsLog2MinLumaCodingBlockSizeMinus2);\
1502 DO_FIELD(DW4, SpsNumSubpicsMinus1, params.spsNumSubpicsMinus1);\
1503 DO_FIELD(DW5, SpsLog2TransformSkipMaxSizeMinus2, params.spsLog2TransformSkipMaxSizeMinus2);\
1504 DO_FIELD(DW5, SpsSixMinusMaxNumMergeCand, params.spsSixMinusMaxNumMergeCand);\
1505 DO_FIELD(DW5, SpsFiveMinusMaxNumSubblockMergeCand, params.spsFiveMinusMaxNumSubblockMergeCand);\
1506 DO_FIELD(DW5, DMaxNumGpmMergeCand, params.dMaxNumGpmMergeCand);\
1507 DO_FIELD(DW5, SpsLog2ParallelMergeLevelMinus2, params.spsLog2ParallelMergeLevelMinus2);\
1508 DO_FIELD(DW5, SpsMinQpPrimeTs, params.spsMinQpPrimeTs);\
1509 DO_FIELD(DW5, SpsSixMinusMaxNumIbcMergeCand, params.spsSixMinusMaxNumIbcMergeCand);\
1510 DO_FIELD(DW6, SpsLadfQpOffset0, params.spsLadfQpOffset0);\
1511 DO_FIELD(DW6, SpsLadfQpOffset1, params.spsLadfQpOffset1);\
1512 DO_FIELD(DW6, SpsLadfQpOffset2, params.spsLadfQpOffset2);\
1513 DO_FIELD(DW6, SpsLadfQpOffset3, params.spsLadfQpOffset3);\
1514 DO_FIELD(DW7, SpsLadfDeltaThresholdMinus10, params.spsLadfDeltaThresholdMinus10);\
1515 DO_FIELD(DW7, SpsLadfDeltaThresholdMinus11, params.spsLadfDeltaThresholdMinus11);\
1516 DO_FIELD(DW7, SpsLadfLowestIntervalQpOffset, params.spsLadfLowestIntervalQpOffset);\
1517 DO_FIELD(DW8, SpsLadfDeltaThresholdMinus12, params.spsLadfDeltaThresholdMinus12);\
1518 DO_FIELD(DW8, SpsLadfDeltaThresholdMinus13, params.spsLadfDeltaThresholdMinus13);\
1519 DO_FIELD(DW8, SpsNumLadfIntervalsMinus2, params.spsNumLadfIntervalsMinus2);\
1520 DO_FIELD(DW9, PpsPicWidthInLumaSamples, params.ppsPicWidthInLumaSamples);\
1521 DO_FIELD(DW9, PpsPicHeightInLumaSamples, params.ppsPicHeightInLumaSamples);\
1522 DO_FIELD(DW10, PpsScalingWinLeftOffset, params.ppsScalingWinLeftOffset);\
1523 DO_FIELD(DW11, PpsScalingWinRightOffset, params.ppsScalingWinRightOffset);\
1524 DO_FIELD(DW12, PpsScalingWinTopOffset, params.ppsScalingWinTopOffset);\
1525 DO_FIELD(DW13, PpsScalingWinBottomOffset, params.ppsScalingWinBottomOffset);\
1526 DO_FIELD(DW14, DNumtilerowsminus1, params.dNumtilerowsminus1);\
1527 DO_FIELD(DW14, DNumtilecolumnsminus1, params.dNumtilecolumnsminus1);\
1528 DO_FIELD(DW15, PpsCbQpOffset, params.ppsCbQpOffset);\
1529 DO_FIELD(DW15, PpsCrQpOffset, params.ppsCrQpOffset);\
1530 DO_FIELD(DW15, PpsJointCbcrQpOffsetValue, params.ppsJointCbcrQpOffsetValue);\
1531 DO_FIELD(DW15, PpsChromaQpOffsetListLenMinus1, params.ppsChromaQpOffsetListLenMinus1);\
1532 DO_FIELD(DW16, PpsCbQpOffsetList0, params.ppsCbQpOffsetList0);\
1533 DO_FIELD(DW16, PpsCbQpOffsetList1, params.ppsCbQpOffsetList1);\
1534 DO_FIELD(DW16, PpsCbQpOffsetList2, params.ppsCbQpOffsetList2);\
1535 DO_FIELD(DW16, PpsCbQpOffsetList3, params.ppsCbQpOffsetList3);\
1536 DO_FIELD(DW17, PpsCbQpOffsetList4, params.ppsCbQpOffsetList4);\
1537 DO_FIELD(DW17, PpsCbQpOffsetList5, params.ppsCbQpOffsetList5);\
1538 DO_FIELD(DW17, PpsPicWidthMinusWraparoundOffset, params.ppsPicWidthMinusWraparoundOffset);\
1539 DO_FIELD(DW18, PpsCrQpOffsetList0, params.ppsCrQpOffsetList0);\
1540 DO_FIELD(DW18, PpsCrQpOffsetList1, params.ppsCrQpOffsetList1);\
1541 DO_FIELD(DW18, PpsCrQpOffsetList2, params.ppsCrQpOffsetList2);\
1542 DO_FIELD(DW18, PpsCrQpOffsetList3, params.ppsCrQpOffsetList3);\
1543 DO_FIELD(DW19, PpsCrQpOffsetList4, params.ppsCrQpOffsetList4);\
1544 DO_FIELD(DW19, PpsCrQpOffsetList5, params.ppsCrQpOffsetList5);\
1545 DO_FIELD(DW20, PpsJointCbcrQpOffsetList0, params.ppsJointCbcrQpOffsetList0);\
1546 DO_FIELD(DW20, PpsJointCbcrQpOffsetList1, params.ppsJointCbcrQpOffsetList1);\
1547 DO_FIELD(DW20, PpsJointCbcrQpOffsetList2, params.ppsJointCbcrQpOffsetList2);\
1548 DO_FIELD(DW20, PpsJointCbcrQpOffsetList3, params.ppsJointCbcrQpOffsetList3);\
1549 DO_FIELD(DW21, PpsJointCbcrQpOffsetList4, params.ppsJointCbcrQpOffsetList4);\
1550 DO_FIELD(DW21, PpsJointCbcrQpOffsetList5, params.ppsJointCbcrQpOffsetList5);\
1551 DO_FIELD(DW22, Numvervirtualboundaries, params.numvervirtualboundaries);\
1552 DO_FIELD(DW22, Numhorvirtualboundaries, params.numhorvirtualboundaries);\
1553 DO_FIELD(DW22, PhLog2DiffMinQtMinCbIntraSliceLuma, params.phLog2DiffMinQtMinCbIntraSliceLuma);\
1554 DO_FIELD(DW22, PhMaxMttHierarchyDepthIntraSliceLuma, params.phMaxMttHierarchyDepthIntraSliceLuma);\
1555 DO_FIELD(DW22, PhLog2DiffMaxBtMinQtIntraSliceLuma, params.phLog2DiffMaxBtMinQtIntraSliceLuma);\
1556 DO_FIELD(DW22, PhLog2DiffMaxTtMinQtIntraSliceLuma, params.phLog2DiffMaxTtMinQtIntraSliceLuma);\
1557 DO_FIELD(DW22, PhLog2DiffMinQtMinCbIntraSliceChroma, params.phLog2DiffMinQtMinCbIntraSliceChroma);\
1558 DO_FIELD(DW22, PhMaxMttHierarchyDepthIntraSliceChroma, params.phMaxMttHierarchyDepthIntraSliceChroma);\
1559 DO_FIELD(DW23, DVirtualboundaryposxminus10, params.dVirtualboundaryposxminus10);\
1560 DO_FIELD(DW23, DVirtualboundaryposyminus10, params.dVirtualboundaryposyminus10);\
1561 DO_FIELD(DW24, DVirtualboundaryposxminus11, params.dVirtualboundaryposxminus11);\
1562 DO_FIELD(DW24, DVirtualboundaryposyminus11, params.dVirtualboundaryposyminus11);\
1563 DO_FIELD(DW25, DVirtualboundaryposxminus12, params.dVirtualboundaryposxminus12);\
1564 DO_FIELD(DW25, DVirtualboundaryposyminus12, params.dVirtualboundaryposyminus12);\
1565 DO_FIELD(DW26, PhLog2DiffMaxBtMinQtIntraSliceChroma, params.phLog2DiffMaxBtMinQtIntraSliceChroma);\
1566 DO_FIELD(DW26, PhLog2DiffMaxTtMinQtIntraSliceChroma, params.phLog2DiffMaxTtMinQtIntraSliceChroma);\
1567 DO_FIELD(DW26, PhCuQpDeltaSubdivIntraSlice, params.phCuQpDeltaSubdivIntraSlice);\
1568 DO_FIELD(DW26, PhCuChromaQpOffsetSubdivIntraSlice, params.phCuChromaQpOffsetSubdivIntraSlice);\
1569 DO_FIELD(DW26, PhLog2DiffMinQtMinCbInterSlice, params.phLog2DiffMinQtMinCbInterSlice);\
1570 DO_FIELD(DW26, PhMaxMttHierarchyDepthInterSlice, params.phMaxMttHierarchyDepthInterSlice);\
1571 DO_FIELD(DW27, PhLog2DiffMaxBtMinQtInterSlice, params.phLog2DiffMaxBtMinQtInterSlice);\
1572 DO_FIELD(DW27, PhLog2DiffMaxTtMinQtInterSlice, params.phLog2DiffMaxTtMinQtInterSlice);\
1573 DO_FIELD(DW27, PhCuQpDeltaSubdivInterSlice, params.phCuQpDeltaSubdivInterSlice);\
1574 DO_FIELD(DW27, PhCuChromaQpOffsetSubdivInterSlice, params.phCuChromaQpOffsetSubdivInterSlice);\
1575 DO_FIELD(DW28, DActiveapsid, params.dActiveapsid);
1576
1577 #include "mhw_hwcmd_process_cmdfields.h"
1578 }
1579
1580 _MHW_SETCMD_OVERRIDE_DECL(VVCP_DPB_STATE)
1581 {
1582 _MHW_SETCMD_CALLBASE(VVCP_DPB_STATE);
1583
1584 for (auto i = 0; i < vvcMaxNumRefFrame; i++)
1585 {
1586 cmd.Entries[i].DW0.DRefscalingwinleftoffsetI = (uint32_t)params.refFrameAttr[i].m_refscalingwinleftoffset;
1587 cmd.Entries[i].DW1.DRefscalingwinrightoffsetI = (uint32_t)params.refFrameAttr[i].m_refscalingwinrightoffset;
1588 cmd.Entries[i].DW2.DRefscalingwintopoffsetI = (uint32_t)params.refFrameAttr[i].m_refscalingwintopoffset;
1589 cmd.Entries[i].DW3.DRefscalingwinbottomoffsetI = (uint32_t)params.refFrameAttr[i].m_refscalingwinbottomoffset;
1590 cmd.Entries[i].DW4.DRefpicscalex0J = (uint32_t)params.refPicScaleWidth[i];
1591 cmd.Entries[i].DW4.DRefpicscalex1J = (uint32_t)params.refPicScaleHeight[i];
1592 cmd.Entries[i].DW5.DRefpicwidthI = (uint32_t)params.refFrameAttr[i].m_refpicwidth;
1593 cmd.Entries[i].DW5.DRefpicheightI = (uint32_t)params.refFrameAttr[i].m_refpicheight;
1594 }
1595
1596 return MOS_STATUS_SUCCESS;
1597 }
1598
1599 _MHW_SETCMD_OVERRIDE_DECL(VVCP_SLICE_STATE)
1600 {
1601 _MHW_SETCMD_CALLBASE(VVCP_SLICE_STATE);
1602
1603 // LMCS
1604 if (params.spsLmcsEnabledFlag && params.shLmcsUsedFlag)
1605 {
1606 uint8_t sliceLmcsApsId = params.phLmcsApsId;
1607 CodecVvcLmcsData *lmcsData = &params.vvcLmcsData[sliceLmcsApsId];
1608 ApsLmcsReshapeInfo *lmcsShapeInfo = &params.vvcLmcsShapeInfo[sliceLmcsApsId];
1609
1610 cmd.DW9.LmcsMinBinIdx = lmcsData->m_lmcsMinBinIdx;
1611 cmd.DW9.LmcsDeltaMaxBinIdx = lmcsData->m_lmcsDeltaMaxBinIdx;
1612
1613 for (int i = 0; i < 16; i++)
1614 {
1615 cmd.DW10_17.Scalecoeff[i] = static_cast<uint16_t>(lmcsShapeInfo->m_scaleCoeff[i]);
1616 cmd.DW18_25.Invscalecoeff[i] = static_cast<uint16_t>(lmcsShapeInfo->m_invScaleCoeff[i]);
1617 cmd.DW26_33.Chromascalecoeff[i] = static_cast<uint16_t>(lmcsShapeInfo->m_chromaScaleCoeff[i]);
1618 }
1619 MOS_SecureMemcpy(cmd.Lmcspivot161, sizeof(cmd.Lmcspivot161), &lmcsShapeInfo->m_lmcsPivot[1], sizeof(cmd.Lmcspivot161));
1620 }
1621
1622 #define DO_FIELDS() \
1623 DO_FIELD(DW1, ShAlfEnabledFlag, params.shAlfEnabledFlag); \
1624 DO_FIELD(DW1, ShAlfCbEnabledFlag, params.shAlfCbEnabledFlag); \
1625 DO_FIELD(DW1, ShAlfCrEnabledFlag, params.shAlfCrEnabledFlag); \
1626 DO_FIELD(DW1, ShAlfCcCbEnabledFlag, params.shAlfCcCbEnabledFlag); \
1627 DO_FIELD(DW1, ShAlfCcCrEnabledFlag, params.shAlfCcCrEnabledFlag); \
1628 DO_FIELD(DW1, ShLmcsUsedFlag, params.shLmcsUsedFlag); \
1629 DO_FIELD(DW1, ShExplicitScalingListUsedFlag, params.shExplicitScalingListUsedFlag); \
1630 DO_FIELD(DW1, ShCabacInitFlag, params.shCabacInitFlag); \
1631 DO_FIELD(DW1, ShCollocatedFromL0Flag, params.shCollocatedFromL0Flag); \
1632 DO_FIELD(DW1, ShCuChromaQpOffsetEnabledFlag, params.shCuChromaQpOffsetEnabledFlag); \
1633 DO_FIELD(DW1, ShSaoLumaUsedFlag, params.shSaoLumaUsedFlag); \
1634 DO_FIELD(DW1, ShSaoChromaUsedFlag, params.shSaoChromaUsedFlag); \
1635 DO_FIELD(DW1, ShDeblockingFilterDisabledFlag, params.shDeblockingFilterDisabledFlag); \
1636 DO_FIELD(DW1, ShDepQuantUsedFlag, params.shDepQuantUsedFlag); \
1637 DO_FIELD(DW1, ShSignDataHidingUsedFlag, params.shSignDataHidingUsedFlag); \
1638 DO_FIELD(DW1, ShTsResidualCodingDisabledFlag, params.shTsResidualCodingDisabledFlag); \
1639 DO_FIELD(DW1, Nobackwardpredflag, params.nobackwardpredflag); \
1640 DO_FIELD(DW1, PVvcpDebugEnable, params.pVvcpDebugEnable); \
1641 DO_FIELD(DW1, DMultipleSlicesInTileFlag, params.dMultipleSlicesInTileFlag); \
1642 DO_FIELD(DW1, DIsbottommostsliceoftileFlag, params.dIsbottommostsliceoftileFlag); \
1643 DO_FIELD(DW1, DIstopmostsliceoftileFlag, params.dIstopmostsliceoftileFlag); \
1644 DO_FIELD(DW1, DSubpicTreatedAsPicFlag, params.dSubpicTreatedAsPicFlag); \
1645 DO_FIELD(DW1, DLoopFilterAcrossSubpicEnabledFlag, params.dLoopFilterAcrossSubpicEnabledFlag); \
1646 DO_FIELD(DW1, DIsRightMostSliceOfSubpicFlag, params.dIsRightMostSliceOfSubpicFlag); \
1647 DO_FIELD(DW1, DIsLeftMostSliceOfSubpicFlag, params.dIsLeftMostSliceOfSubpicFlag); \
1648 DO_FIELD(DW1, DIsBottomMostSliceOfSubpicFlag, params.dIsBottomMostSliceOfSubpicFlag); \
1649 DO_FIELD(DW1, DIsTopMostSliceOfSubpicFlag, params.dIsTopMostSliceOfSubpicFlag); \
1650 DO_FIELD(DW1, DLastsliceofpicFlag, params.dLastsliceofpicFlag); \
1651 DO_FIELD(DW2, Numctusincurrslice, params.numctusincurrslice); \
1652 DO_FIELD(DW3, ShNumTilesInSliceMinus1, params.shNumTilesInSliceMinus1); \
1653 DO_FIELD(DW3, ShSliceType, params.shSliceType); \
1654 DO_FIELD(DW3, ShNumAlfApsIdsLuma, params.shNumAlfApsIdsLuma); \
1655 DO_FIELD(DW3, AlfChromaNumAltFiltersMinus1, params.alfChromaNumAltFiltersMinus1); \
1656 DO_FIELD(DW3, AlfCcCbFiltersSignalledMinus1, params.alfCcCbFiltersSignalledMinus1); \
1657 DO_FIELD(DW3, AlfCcCrFiltersSignalledMinus1, params.alfCcCrFiltersSignalledMinus1); \
1658 DO_FIELD(DW4, ShAlfApsIdLuma0, params.shAlfApsIdLuma0); \
1659 DO_FIELD(DW4, ShAlfApsIdLuma1, params.shAlfApsIdLuma1); \
1660 DO_FIELD(DW4, ShAlfApsIdLuma2, params.shAlfApsIdLuma2); \
1661 DO_FIELD(DW4, ShAlfApsIdLuma3, params.shAlfApsIdLuma3); \
1662 DO_FIELD(DW4, ShAlfApsIdLuma4, params.shAlfApsIdLuma4); \
1663 DO_FIELD(DW4, ShAlfApsIdLuma5, params.shAlfApsIdLuma5); \
1664 DO_FIELD(DW4, ShAlfApsIdLuma6, params.shAlfApsIdLuma6); \
1665 DO_FIELD(DW5, ShAlfApsIdChroma, params.shAlfApsIdChroma); \
1666 DO_FIELD(DW5, ShAlfCcCbApsId, params.shAlfCcCbApsId); \
1667 DO_FIELD(DW5, ShAlfCcCrApsId, params.shAlfCcCrApsId); \
1668 DO_FIELD(DW5, Numrefidxactive0, params.numrefidxactive0); \
1669 DO_FIELD(DW5, Numrefidxactive1, params.numrefidxactive1); \
1670 DO_FIELD(DW5, ShCollocatedRefIdx, params.shCollocatedRefIdx); \
1671 DO_FIELD(DW6, Sliceqpy, params.sliceqpy); \
1672 DO_FIELD(DW6, ShCbQpOffset, params.shCbQpOffset); \
1673 DO_FIELD(DW6, ShCrQpOffset, params.shCrQpOffset); \
1674 DO_FIELD(DW6, ShJointCbcrQpOffset, params.shJointCbcrQpOffset); \
1675 DO_FIELD(DW7, ShLumaBetaOffsetDiv2, params.shLumaBetaOffsetDiv2); \
1676 DO_FIELD(DW7, ShLumaTcOffsetDiv2, params.shLumaTcOffsetDiv2); \
1677 DO_FIELD(DW7, ShCbBetaOffsetDiv2, params.shCbBetaOffsetDiv2); \
1678 DO_FIELD(DW7, ShCbTcOffsetDiv2, params.shCbTcOffsetDiv2); \
1679 DO_FIELD(DW8, ShCrBetaOffsetDiv2, params.shCrBetaOffsetDiv2); \
1680 DO_FIELD(DW8, ShCrTcOffsetDiv2, params.shCrTcOffsetDiv2); \
1681 DO_FIELD(DW42, DSubpicCtuTopLeftX, params.dSubpicCtuTopLeftX); \
1682 DO_FIELD(DW42, DSubpicCtuTopLeftY, params.dSubpicCtuTopLeftY); \
1683 DO_FIELD(DW43, DSubpicWidthMinus1, params.dSubpicWidthMinus1); \
1684 DO_FIELD(DW43, DSubpicHeightMinus1, params.dSubpicHeightMinus1); \
1685 DO_FIELD(DW45, DToplefttilex, params.dToplefttilex); \
1686 DO_FIELD(DW45, DToplefttiley, params.dToplefttiley); \
1687 DO_FIELD(DW46, DSliceheightinctus, params.dSliceheightinctus); \
1688 DO_FIELD(DW47, DSlicestartctbx, params.dSlicestartctbx); \
1689 DO_FIELD(DW47, DSlicestartctby, params.dSlicestartctby);
1690
1691 #include "mhw_hwcmd_process_cmdfields.h"
1692 }
1693
1694 _MHW_SETCMD_OVERRIDE_DECL(VVCP_BSD_OBJECT)
1695 {
1696 _MHW_SETCMD_CALLBASE(VVCP_BSD_OBJECT);
1697
1698 #define DO_FIELDS() \
1699 DO_FIELD(DW1, IndirectBsdDataLength, params.bsdDataLength); \
1700 DO_FIELD(DW2, IndirectDataStartAddress, params.bsdDataStartOffset);
1701
1702 #include "mhw_hwcmd_process_cmdfields.h"
1703 }
1704
1705 _MHW_SETCMD_OVERRIDE_DECL(VVCP_REF_IDX_STATE)
1706 {
1707 _MHW_SETCMD_CALLBASE(VVCP_REF_IDX_STATE);
1708
1709 for (uint8_t i = 0; i < static_cast<uint8_t>(params.numRefForList); i++)
1710 {
1711 uint8_t refFrameIDx = params.refPicList[params.listIdx][i].FrameIdx;
1712
1713 if (refFrameIDx < vvcMaxNumRefFrame)
1714 {
1715 cmd.Entries[i].DW0.RefpiclistListidxI = params.refPicList[params.listIdx][i].FrameIdx;
1716 cmd.Entries[i].DW0.StRefPicFlagListidxRplsidxI = params.stRefPicFlag[params.listIdx][i];
1717 cmd.Entries[i].DW0.RprconstraintsactiveflagListidxI = params.rprConstraintsActiveFlag[params.listIdx][i];
1718 cmd.Entries[i].DW0.DUnavailablerefpicListidxI = params.unavailableRefPic[params.listIdx][i];
1719 cmd.Entries[i].DW0.DDiffpicordercntListidxI = params.diffPicOrderCnt[params.listIdx][i];
1720 }
1721 else
1722 {
1723 cmd.Entries[i].DW0.Value = 0x00;
1724 }
1725 }
1726
1727 for (uint8_t i = (uint8_t)params.numRefForList; i < vvcMaxNumRefFrame; i++)
1728 {
1729 cmd.Entries[i].DW0.Value = 0x00;
1730 }
1731
1732 #define DO_FIELDS() \
1733 DO_FIELD(DW1, Listidx, params.listIdx); \
1734 DO_FIELD(DW1, Refidxsymlx, params.refIdxSymLx[params.listIdx]);
1735
1736 #include "mhw_hwcmd_process_cmdfields.h"
1737 }
1738
1739 _MHW_SETCMD_OVERRIDE_DECL(VVCP_WEIGHTOFFSET_STATE)
1740 {
1741 _MHW_SETCMD_CALLBASE(VVCP_WEIGHTOFFSET_STATE);
1742
1743 auto wpInfo = params.wpInfo;
1744 MHW_ASSERT(wpInfo->m_lumaLog2WeightDenom + wpInfo->m_deltaChromaLog2WeightDenom >= 0 &&
1745 wpInfo->m_lumaLog2WeightDenom + wpInfo->m_deltaChromaLog2WeightDenom < 8);
1746 int8_t chromalog2Weightdenom = wpInfo->m_lumaLog2WeightDenom + wpInfo->m_deltaChromaLog2WeightDenom;
1747
1748 uint16_t lumaFlag = 0, chromaFlag = 0;
1749 if (params.listIdx == 0)
1750 {
1751 for (auto i = 0; i < 15; i++)
1752 {
1753 lumaFlag |= wpInfo->m_lumaWeightL0Flag[i] << i;
1754 chromaFlag |= wpInfo->m_chromaWeightL0Flag[i] << i;
1755 }
1756 cmd.DW2.LumaWeightLxFlagI = lumaFlag;
1757 cmd.DW2.ChromaWeightLxFlagI = chromaFlag;
1758
1759 for (auto i = 0; i < 15; i++)
1760 {
1761 cmd.DLumaweightsoffsets[i].DW0.DeltaLumaWeightLxI = wpInfo->m_deltaLumaWeightL0[i];
1762 cmd.DLumaweightsoffsets[i].DW0.LumaOffsetLxI = wpInfo->m_lumaOffsetL0[i];
1763 cmd.DChromacbweightsoffsets[i].DW0.DeltaChromaWeightLxIJ = wpInfo->m_deltaChromaWeightL0[i][0];
1764 cmd.DChromacbweightsoffsets[i].DW0.DeltaChromaOffsetLxIJ = wpInfo->m_deltaChromaOffsetL0[i][0];
1765 cmd.DChromacrweightsoffsets[i].DW0.DeltaChromaWeightLxIJ = wpInfo->m_deltaChromaWeightL0[i][1];
1766 cmd.DChromacrweightsoffsets[i].DW0.DeltaChromaOffsetLxIJ = wpInfo->m_deltaChromaOffsetL0[i][1];
1767 }
1768 }
1769 else if (params.listIdx == 1)
1770 {
1771 for (auto i = 0; i < 15; i++)
1772 {
1773 lumaFlag |= wpInfo->m_lumaWeightL1Flag[i] << i;
1774 chromaFlag |= wpInfo->m_chromaWeightL1Flag[i] << i;
1775 }
1776 cmd.DW2.LumaWeightLxFlagI = lumaFlag;
1777 cmd.DW2.ChromaWeightLxFlagI = chromaFlag;
1778
1779 for (auto i = 0; i < 15; i++)
1780 {
1781 cmd.DLumaweightsoffsets[i].DW0.DeltaLumaWeightLxI = wpInfo->m_deltaLumaWeightL1[i];
1782 cmd.DLumaweightsoffsets[i].DW0.LumaOffsetLxI = wpInfo->m_lumaOffsetL1[i];
1783 cmd.DChromacbweightsoffsets[i].DW0.DeltaChromaWeightLxIJ = wpInfo->m_deltaChromaWeightL1[i][0];
1784 cmd.DChromacbweightsoffsets[i].DW0.DeltaChromaOffsetLxIJ = wpInfo->m_deltaChromaOffsetL1[i][0];
1785 cmd.DChromacrweightsoffsets[i].DW0.DeltaChromaWeightLxIJ = wpInfo->m_deltaChromaWeightL1[i][1];
1786 cmd.DChromacrweightsoffsets[i].DW0.DeltaChromaOffsetLxIJ = wpInfo->m_deltaChromaOffsetL1[i][1];
1787 }
1788 }
1789
1790 #define DO_FIELDS() \
1791 DO_FIELD(DW1, Listidx, params.listIdx); \
1792 DO_FIELD(DW1, LumaLog2WeightDenom, wpInfo->m_lumaLog2WeightDenom); \
1793 DO_FIELD(DW1, Chromalog2Weightdenom, chromalog2Weightdenom);
1794
1795 #include "mhw_hwcmd_process_cmdfields.h"
1796 }
1797
1798 _MHW_SETCMD_OVERRIDE_DECL(VVCP_TILE_CODING)
1799 {
1800 _MHW_SETCMD_CALLBASE(VVCP_TILE_CODING);
1801
1802 #define DO_FIELDS() \
1803 DO_FIELD(DW1, Tilecolbdval, params.tilecolbdval); \
1804 DO_FIELD(DW1, Tilerowbdval, params.tilerowbdval); \
1805 DO_FIELD(DW2, Colwidthval, params.colwidthval); \
1806 DO_FIELD(DW2, Rowheightval, params.rowheightval); \
1807 DO_FIELD(DW3, DCurrenttilecolumnposition, params.currenttilecolumnposition); \
1808 DO_FIELD(DW3, DCurrenttilerowposition, params.currenttilerowposition); \
1809 DO_FIELD(DW4, DIsrightmosttileofsliceFlag, params.flags.m_isrightmosttileofsliceFlag); \
1810 DO_FIELD(DW4, DIsleftmosttileofsliceFlag, params.flags.m_isleftmosttileofsliceFlag); \
1811 DO_FIELD(DW4, DIsbottommosttileofsliceFlag, params.flags.m_isbottommosttileofsliceFlag); \
1812 DO_FIELD(DW4, DIstopmosttileofsliceFlag, params.flags.m_istopmosttileofsliceFlag); \
1813 DO_FIELD(DW4, DIsrightmosttileofframeFlag, params.flags.m_isrightmosttileofframeFlag); \
1814 DO_FIELD(DW4, DIsleftmosttileofframeFlag, params.flags.m_isleftmosttileofframeFlag); \
1815 DO_FIELD(DW4, DIsbottommosttileofframeFlag, params.flags.m_isbottommosttileofframeFlag); \
1816 DO_FIELD(DW4, DIstopmosttileofframeFlag, params.flags.m_istopmosttileofframeFlag);
1817
1818 #include "mhw_hwcmd_process_cmdfields.h"
1819 }
1820 MEDIA_CLASS_DEFINE_END(mhw__vdbox__vvcp__Impl)
1821 };
1822
1823
1824 } // namespace vvcp
1825 } // namespace vdbox
1826 } // namespace mhw
1827
1828 #endif // __MHW_VDBOX_VVCP_IMPL_H__