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