1 /* 2 * Copyright (c) 2021-2022, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file decode_vvc_picture_packet.cpp 24 //! \brief Defines the interface for vvc decode picture packet 25 //! 26 #include "decode_vvc_picture_packet.h" 27 #include "codechal_debug.h" 28 #include "decode_resource_auto_lock.h" 29 30 namespace decode{ ~VvcDecodePicPkt()31 VvcDecodePicPkt::~VvcDecodePicPkt() 32 { 33 FreeResources(); 34 } 35 FreeResources()36 MOS_STATUS VvcDecodePicPkt::FreeResources() 37 { 38 DECODE_FUNC_CALL(); 39 40 if (m_allocator != nullptr) 41 { 42 //sw written buffer 43 m_allocator->Destroy(m_alfBufferArray); 44 m_allocator->Destroy(m_scalingListBufferArray); 45 m_allocator->Destroy(m_chromaQpBufferArray); 46 47 //Tile (boundary) Storage 48 m_allocator->Destroy(m_vclfYTileRowBuffer); 49 m_allocator->Destroy(m_vclfYTileColumnBuffer); 50 m_allocator->Destroy(m_vclfUTileRowBuffer); 51 m_allocator->Destroy(m_vclfUTileColumnBuffer); 52 m_allocator->Destroy(m_vclfVTileRowBuffer); 53 m_allocator->Destroy(m_vclfVTileColumnBuffer); 54 m_allocator->Destroy(m_vcSaoYTileRowBuffer); 55 m_allocator->Destroy(m_vcSaoYTileColumnBuffer); 56 m_allocator->Destroy(m_vcSaoUTileRowBuffer); 57 m_allocator->Destroy(m_vcSaoUTileColumnBuffer); 58 m_allocator->Destroy(m_vcSaoVTileRowBuffer); 59 m_allocator->Destroy(m_vcSaoVTileColumnBuffer); 60 m_allocator->Destroy(m_vcAlfTileRowBuffer); 61 m_allocator->Destroy(m_vcAlfYTileColumnBuffer); 62 m_allocator->Destroy(m_vcAlfUTileColumnBuffer); 63 m_allocator->Destroy(m_vcAlfVTileColumnBuffer); 64 65 //rowstore 66 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcedLineBuffer)) 67 { 68 m_allocator->Destroy(m_vcedLineBuffer); 69 } 70 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcmvLineBuffer)) 71 { 72 m_allocator->Destroy(m_vcmvLineBuffer); 73 } 74 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcprLineBuffer)) 75 { 76 m_allocator->Destroy(m_vcprLineBuffer); 77 } 78 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfYLineBuffer)) 79 { 80 m_allocator->Destroy(m_vclfYLineBuffer); 81 } 82 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfULineBuffer)) 83 { 84 m_allocator->Destroy(m_vclfULineBuffer); 85 } 86 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfVLineBuffer)) 87 { 88 m_allocator->Destroy(m_vclfVLineBuffer); 89 } 90 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoYLineBuffer)) 91 { 92 m_allocator->Destroy(m_vcSaoYLineBuffer); 93 } 94 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoULineBuffer)) 95 { 96 m_allocator->Destroy(m_vcSaoULineBuffer); 97 } 98 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoVLineBuffer)) 99 { 100 m_allocator->Destroy(m_vcSaoVLineBuffer); 101 } 102 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcAlfLineBuffer)) 103 { 104 m_allocator->Destroy(m_vcAlfLineBuffer); 105 } 106 107 // Pic Lvl BB Array 108 if (m_picLevelBBArray) 109 { 110 DECODE_CHK_STATUS(m_allocator->Destroy(m_picLevelBBArray)); 111 } 112 } 113 114 return MOS_STATUS_SUCCESS; 115 } 116 Init()117 MOS_STATUS VvcDecodePicPkt::Init() 118 { 119 DECODE_FUNC_CALL(); 120 121 DECODE_CHK_NULL(m_featureManager); 122 DECODE_CHK_NULL(m_hwInterface); 123 DECODE_CHK_NULL(m_osInterface); 124 DECODE_CHK_NULL(m_vvcPipeline); 125 126 m_vvcBasicFeature = dynamic_cast<VvcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 127 DECODE_CHK_NULL(m_vvcBasicFeature); 128 129 m_allocator = m_pipeline ->GetDecodeAllocator(); 130 DECODE_CHK_NULL(m_allocator); 131 132 DECODE_CHK_STATUS(AllocateFixedResources()); 133 DECODE_CHK_STATUS(CalculatePictureStateCommandSize()); 134 135 return MOS_STATUS_SUCCESS; 136 } 137 AllocatePicLvlBB()138 MOS_STATUS VvcDecodePicPkt::AllocatePicLvlBB() 139 { 140 DECODE_FUNC_CALL(); 141 // Pic Lvl Batch Buffer needed to be lockable and program by driver 142 if (m_picLevelBBArray == nullptr) 143 { 144 m_picLevelBBArray = m_allocator->AllocateBatchBufferArray( 145 m_pictureStatesSize, 1, CODEC_VVC_BUFFER_ARRAY_SIZE, true, lockableVideoMem); 146 DECODE_CHK_NULL(m_picLevelBBArray); 147 m_curPicLvlBatchBuffer = m_picLevelBBArray->Fetch(); 148 DECODE_CHK_NULL(m_curPicLvlBatchBuffer); 149 } 150 else 151 { 152 m_curPicLvlBatchBuffer = m_picLevelBBArray->Fetch(); 153 DECODE_CHK_NULL(m_curPicLvlBatchBuffer); 154 DECODE_CHK_STATUS(m_allocator->Resize( 155 m_curPicLvlBatchBuffer, m_pictureStatesSize, lockableVideoMem)); 156 } 157 return MOS_STATUS_SUCCESS; 158 } 159 Prepare()160 MOS_STATUS VvcDecodePicPkt::Prepare() 161 { 162 DECODE_FUNC_CALL(); 163 164 DECODE_CHK_NULL(m_vvcBasicFeature); 165 m_vvcPicParams = m_vvcBasicFeature->m_vvcPicParams; 166 DECODE_CHK_NULL(m_vvcPicParams); 167 168 #ifdef _MMC_SUPPORTED 169 m_mmcState = m_vvcPipeline->GetMmcState(); 170 DECODE_CHK_NULL(m_mmcState); 171 #endif 172 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 173 DECODE_CHK_STATUS(AllocateVariableResources()); 174 175 DECODE_CHK_STATUS(AllocatePicLvlBB()); 176 177 return MOS_STATUS_SUCCESS; 178 } 179 SetRowstoreCachingOffsets()180 MOS_STATUS VvcDecodePicPkt::SetRowstoreCachingOffsets() 181 { 182 if (m_vvcpItf->IsRowStoreCachingSupported() && 183 (m_vvcBasicFeature->m_frameWidthAlignedMinBlk != MOS_ALIGN_CEIL(m_prevFrmWidth, vvcMinBlockWidth))) 184 { 185 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams; 186 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams)); 187 rowstoreParams.dwPicWidth = m_vvcBasicFeature->m_frameWidthAlignedMinBlk; 188 rowstoreParams.bMbaff = false; 189 rowstoreParams.Mode = CODECHAL_DECODE_MODE_VVCVLD; 190 rowstoreParams.ucBitDepthMinus8 = m_vvcPicParams->m_spsBitdepthMinus8; 191 rowstoreParams.ucChromaFormat = m_vvcBasicFeature->m_chromaFormat; 192 rowstoreParams.ucLCUSize = 1 << (m_vvcPicParams->m_spsLog2CtuSizeMinus5 + 5); 193 DECODE_CHK_STATUS(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams)); 194 } 195 196 return MOS_STATUS_SUCCESS; 197 } 198 Execute(MOS_COMMAND_BUFFER & cmdBuffer)199 MOS_STATUS VvcDecodePicPkt::Execute(MOS_COMMAND_BUFFER& cmdBuffer) 200 { 201 DECODE_FUNC_CALL() 202 203 PMOS_RESOURCE validRefPic = m_vvcBasicFeature->m_refFrames.GetValidReference(); 204 if (nullptr == validRefPic) 205 { 206 return MOS_STATUS_INVALID_PARAMETER; 207 } 208 209 DECODE_CHK_STATUS(AddAllCmds_VVCP_SURFACE_STATE(cmdBuffer)); 210 211 // temp solution: add here to avoid compile error 212 // APS scaling List Data Buffer 213 // Scaling List data buffer 214 DECODE_CHK_NULL(m_scalingListBufferArray); 215 m_apsScalingListBuffer = m_scalingListBufferArray->Fetch(); 216 DECODE_CHK_NULL(m_apsScalingListBuffer); 217 // ALF APS data buffer 218 DECODE_CHK_NULL(m_alfBufferArray); 219 m_apsAlfBuffer = m_alfBufferArray->Fetch(); 220 DECODE_CHK_NULL(m_apsAlfBuffer); 221 // Chroma QP 222 DECODE_CHK_NULL(m_chromaQpBufferArray); 223 m_chromaQpBuffer = m_chromaQpBufferArray->Fetch(); 224 DECODE_CHK_NULL(m_chromaQpBuffer); 225 226 SETPAR_AND_ADDCMD(VVCP_PIPE_BUF_ADDR_STATE, m_vvcpItf, &cmdBuffer); 227 SETPAR_AND_ADDCMD(VVCP_IND_OBJ_BASE_ADDR_STATE, m_vvcpItf, &cmdBuffer); 228 SETPAR_AND_ADDCMD(VVCP_DPB_STATE, m_vvcpItf, &cmdBuffer); 229 SETPAR_AND_ADDCMD(VVCP_PIC_STATE, m_vvcpItf, &cmdBuffer); 230 231 return MOS_STATUS_SUCCESS; 232 } 233 InitVvcState(MOS_COMMAND_BUFFER & cmdBuffer)234 MOS_STATUS VvcDecodePicPkt::InitVvcState(MOS_COMMAND_BUFFER& cmdBuffer) 235 { 236 DECODE_FUNC_CALL() 237 238 // Send VD_CONTROL_STATE Pipe Initialization 239 SETPAR_AND_ADDCMD(VVCP_VD_CONTROL_STATE, m_vvcpItf, &cmdBuffer); 240 DECODE_CHK_STATUS(AddAllCmds_VVCP_PIPE_MODE_SELECT(cmdBuffer)); 241 242 return MOS_STATUS_SUCCESS; 243 } 244 AllocateFixedResources()245 MOS_STATUS VvcDecodePicPkt::AllocateFixedResources() 246 { 247 DECODE_FUNC_CALL(); 248 249 // ALF APS buffers 250 uint32_t allocSize = MOS_ALIGN_CEIL(m_alfBufferSize, CODECHAL_PAGE_SIZE); 251 if (m_alfBufferArray == nullptr) 252 { 253 m_alfBufferArray= m_allocator->AllocateBufferArray( 254 allocSize, 255 "ALF APS Data Buffer", 256 CODEC_VVC_BUFFER_ARRAY_SIZE, 257 resourceInternalReadWriteCache, 258 lockableVideoMem); 259 DECODE_CHK_NULL(m_alfBufferArray); 260 } 261 262 // Scaling List APS buffers 263 allocSize = MOS_ALIGN_CEIL(m_scalingListBufferSize, CODECHAL_PAGE_SIZE); 264 if (m_scalingListBufferArray == nullptr) 265 { 266 m_scalingListBufferArray= m_allocator->AllocateBufferArray( 267 allocSize, 268 "ScalingList APS Data Buffer", 269 CODEC_VVC_BUFFER_ARRAY_SIZE, 270 resourceInternalReadWriteCache, 271 lockableVideoMem); 272 DECODE_CHK_NULL(m_scalingListBufferArray); 273 } 274 275 //ChromaQp table 276 allocSize = MOS_ALIGN_CEIL(m_chromaQpBufferSize, CODECHAL_PAGE_SIZE); 277 if (m_chromaQpBufferArray == nullptr) 278 { 279 m_chromaQpBufferArray= m_allocator->AllocateBufferArray( 280 allocSize, 281 "ChromaQP Table Buffer", 282 CODEC_VVC_BUFFER_ARRAY_SIZE, 283 resourceInternalReadWriteCache, 284 lockableVideoMem); 285 DECODE_CHK_NULL(m_chromaQpBufferArray); 286 } 287 288 return MOS_STATUS_SUCCESS; 289 } 290 AllocateVariableResources()291 MOS_STATUS VvcDecodePicPkt::AllocateVariableResources() 292 { 293 DECODE_FUNC_CALL(); 294 295 VvcpBufferSizePar vvcpBufSizeParam; 296 MOS_ZeroMemory(&vvcpBufSizeParam, sizeof(vvcpBufSizeParam)); 297 298 vvcpBufSizeParam.m_picWidth = m_vvcPicParams->m_ppsPicWidthInLumaSamples; 299 vvcpBufSizeParam.m_picHeight = m_vvcPicParams->m_ppsPicHeightInLumaSamples; 300 vvcpBufSizeParam.m_maxTileWidthInCtus = m_vvcBasicFeature->m_maxTileWidth; 301 vvcpBufSizeParam.m_bitDepthIdc = m_vvcPicParams->m_spsBitdepthMinus8; 302 vvcpBufSizeParam.m_spsChromaFormatIdc = m_vvcPicParams->m_spsChromaFormatIdc; 303 vvcpBufSizeParam.m_spsLog2CtuSizeMinus5 = m_vvcPicParams->m_spsLog2CtuSizeMinus5; 304 305 // Tile (boundary) Storage 306 // VCLF Y Tile Row Buffer (LFYTR) 307 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 308 vclfYTileRowBuffer, 309 &vvcpBufSizeParam)); 310 if (m_vclfYTileRowBuffer == nullptr) 311 { 312 m_vclfYTileRowBuffer = m_allocator->AllocateBuffer( 313 vvcpBufSizeParam.m_bufferSize, 314 "VCLF Y Tile Row Buffer", 315 resourceInternalReadWriteCache, 316 notLockableVideoMem); 317 DECODE_CHK_NULL(m_vclfYTileRowBuffer); 318 } 319 else 320 { 321 DECODE_CHK_STATUS(m_allocator->Resize( 322 m_vclfYTileRowBuffer, 323 vvcpBufSizeParam.m_bufferSize, 324 notLockableVideoMem)); 325 } 326 // VCLF Y Tile Column Buffer (LFYTC) 327 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 328 vclfYTileColumnBuffer, 329 &vvcpBufSizeParam)); 330 if (m_vclfYTileColumnBuffer == nullptr) 331 { 332 m_vclfYTileColumnBuffer = m_allocator->AllocateBuffer( 333 vvcpBufSizeParam.m_bufferSize, 334 "VCLF Y Tile Column Buffer", 335 resourceInternalReadWriteCache, 336 notLockableVideoMem); 337 DECODE_CHK_NULL(m_vclfYTileColumnBuffer); 338 } 339 else 340 { 341 DECODE_CHK_STATUS(m_allocator->Resize( 342 m_vclfYTileColumnBuffer, 343 vvcpBufSizeParam.m_bufferSize, 344 notLockableVideoMem)); 345 } 346 // VCLF U Tile Row Buffer (LFUTR) 347 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 348 vclfUTileRowBuffer, 349 &vvcpBufSizeParam)); 350 if (m_vclfUTileRowBuffer == nullptr) 351 { 352 m_vclfUTileRowBuffer = m_allocator->AllocateBuffer( 353 vvcpBufSizeParam.m_bufferSize, 354 "VCLF U Tile Row Buffer", 355 resourceInternalReadWriteCache, 356 notLockableVideoMem); 357 DECODE_CHK_NULL(m_vclfUTileRowBuffer); 358 } 359 else 360 { 361 DECODE_CHK_STATUS(m_allocator->Resize( 362 m_vclfUTileRowBuffer, 363 vvcpBufSizeParam.m_bufferSize, 364 notLockableVideoMem)); 365 } 366 // VCLF U Tile Column Buffer (LFUTC) 367 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 368 vclfUTileColumnBuffer, 369 &vvcpBufSizeParam)); 370 if (m_vclfUTileColumnBuffer == nullptr) 371 { 372 m_vclfUTileColumnBuffer = m_allocator->AllocateBuffer( 373 vvcpBufSizeParam.m_bufferSize, 374 "VCLF U Tile Column Buffer", 375 resourceInternalReadWriteCache, 376 notLockableVideoMem); 377 DECODE_CHK_NULL(m_vclfUTileColumnBuffer); 378 } 379 else 380 { 381 DECODE_CHK_STATUS(m_allocator->Resize( 382 m_vclfUTileColumnBuffer, 383 vvcpBufSizeParam.m_bufferSize, 384 notLockableVideoMem)); 385 } 386 // VCLF V Tile Row Buffer (LFVTR) 387 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 388 vclfVTileRowBuffer, 389 &vvcpBufSizeParam)); 390 if (m_vclfVTileRowBuffer == nullptr) 391 { 392 m_vclfVTileRowBuffer = m_allocator->AllocateBuffer( 393 vvcpBufSizeParam.m_bufferSize, 394 "VCLF V Tile Row Buffer", 395 resourceInternalReadWriteCache, 396 notLockableVideoMem); 397 DECODE_CHK_NULL(m_vclfVTileRowBuffer); 398 } 399 else 400 { 401 DECODE_CHK_STATUS(m_allocator->Resize( 402 m_vclfVTileRowBuffer, 403 vvcpBufSizeParam.m_bufferSize, 404 notLockableVideoMem)); 405 } 406 // VCLF V Tile Column Buffer (LFVTC) 407 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 408 vclfVTileColumnBuffer, 409 &vvcpBufSizeParam)); 410 if (m_vclfVTileColumnBuffer == nullptr) 411 { 412 m_vclfVTileColumnBuffer = m_allocator->AllocateBuffer( 413 vvcpBufSizeParam.m_bufferSize, 414 "VCLF V Tile Column Buffer", 415 resourceInternalReadWriteCache, 416 notLockableVideoMem); 417 DECODE_CHK_NULL(m_vclfVTileColumnBuffer); 418 } 419 else 420 { 421 DECODE_CHK_STATUS(m_allocator->Resize( 422 m_vclfVTileColumnBuffer, 423 vvcpBufSizeParam.m_bufferSize, 424 notLockableVideoMem)); 425 } 426 // VCSAO Y Tile Row Buffer (SAYTR) 427 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 428 vcSaoYTileRowBuffer, 429 &vvcpBufSizeParam)); 430 if (m_vcSaoYTileRowBuffer == nullptr) 431 { 432 m_vcSaoYTileRowBuffer = m_allocator->AllocateBuffer( 433 vvcpBufSizeParam.m_bufferSize, 434 "VCSAO Y Tile Row Buffer", 435 resourceInternalReadWriteCache, 436 notLockableVideoMem); 437 DECODE_CHK_NULL(m_vcSaoYTileRowBuffer); 438 } 439 else 440 { 441 DECODE_CHK_STATUS(m_allocator->Resize( 442 m_vcSaoYTileRowBuffer, 443 vvcpBufSizeParam.m_bufferSize, 444 notLockableVideoMem)); 445 } 446 // VCSAO Y Tile Column Buffer (SAYTC) 447 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 448 vcSaoYTileColumnBuffer, 449 &vvcpBufSizeParam)); 450 if (m_vcSaoYTileColumnBuffer == nullptr) 451 { 452 m_vcSaoYTileColumnBuffer = m_allocator->AllocateBuffer( 453 vvcpBufSizeParam.m_bufferSize, 454 "VCSAO Y Tile Column Buffer", 455 resourceInternalReadWriteCache, 456 notLockableVideoMem); 457 DECODE_CHK_NULL(m_vcSaoYTileColumnBuffer); 458 } 459 else 460 { 461 DECODE_CHK_STATUS(m_allocator->Resize( 462 m_vcSaoYTileColumnBuffer, 463 vvcpBufSizeParam.m_bufferSize, 464 notLockableVideoMem)); 465 } 466 // VCSAO U Tile Row Buffer (SAUTR) 467 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 468 vcSaoUTileRowBuffer, 469 &vvcpBufSizeParam)); 470 if (m_vcSaoUTileRowBuffer == nullptr) 471 { 472 m_vcSaoUTileRowBuffer = m_allocator->AllocateBuffer( 473 vvcpBufSizeParam.m_bufferSize, 474 "VCSAO U Tile Row Buffer", 475 resourceInternalReadWriteCache, 476 notLockableVideoMem); 477 DECODE_CHK_NULL(m_vcSaoUTileRowBuffer); 478 } 479 else 480 { 481 DECODE_CHK_STATUS(m_allocator->Resize( 482 m_vcSaoUTileRowBuffer, 483 vvcpBufSizeParam.m_bufferSize, 484 notLockableVideoMem)); 485 } 486 // VCSAO U Tile Column Buffer (SAUTC) 487 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 488 vcSaoUTileColumnBuffer, 489 &vvcpBufSizeParam)); 490 if (m_vcSaoUTileColumnBuffer == nullptr) 491 { 492 m_vcSaoUTileColumnBuffer = m_allocator->AllocateBuffer( 493 vvcpBufSizeParam.m_bufferSize, 494 "VCSAO U Tile Column Buffer", 495 resourceInternalReadWriteCache, 496 notLockableVideoMem); 497 DECODE_CHK_NULL(m_vcSaoUTileColumnBuffer); 498 } 499 else 500 { 501 DECODE_CHK_STATUS(m_allocator->Resize( 502 m_vcSaoUTileColumnBuffer, 503 vvcpBufSizeParam.m_bufferSize, 504 notLockableVideoMem)); 505 } 506 // VCSAO V Tile Row Buffer (SAVTR) 507 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 508 vcSaoVTileRowBuffer, 509 &vvcpBufSizeParam)); 510 if (m_vcSaoVTileRowBuffer == nullptr) 511 { 512 m_vcSaoVTileRowBuffer = m_allocator->AllocateBuffer( 513 vvcpBufSizeParam.m_bufferSize, 514 "VCSAO V Tile Row Buffer", 515 resourceInternalReadWriteCache, 516 notLockableVideoMem); 517 DECODE_CHK_NULL(m_vcSaoVTileRowBuffer); 518 } 519 else 520 { 521 DECODE_CHK_STATUS(m_allocator->Resize( 522 m_vcSaoVTileRowBuffer, 523 vvcpBufSizeParam.m_bufferSize, 524 notLockableVideoMem)); 525 } 526 // VCSAO V Tile Column Buffer (SAVTC) 527 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 528 vcSaoVTileColumnBuffer, 529 &vvcpBufSizeParam)); 530 if (m_vcSaoVTileColumnBuffer == nullptr) 531 { 532 m_vcSaoVTileColumnBuffer = m_allocator->AllocateBuffer( 533 vvcpBufSizeParam.m_bufferSize, 534 "VCSAO V Tile Column Buffer", 535 resourceInternalReadWriteCache, 536 notLockableVideoMem); 537 DECODE_CHK_NULL(m_vcSaoVTileColumnBuffer); 538 } 539 else 540 { 541 DECODE_CHK_STATUS(m_allocator->Resize( 542 m_vcSaoVTileColumnBuffer, 543 vvcpBufSizeParam.m_bufferSize, 544 notLockableVideoMem)); 545 } 546 // VCALF Tile Row Buffer (ALFTR) 547 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 548 vcAlfTileRowBuffer, 549 &vvcpBufSizeParam)); 550 if (m_vcAlfTileRowBuffer == nullptr) 551 { 552 m_vcAlfTileRowBuffer = m_allocator->AllocateBuffer( 553 vvcpBufSizeParam.m_bufferSize, 554 "VCALF Tile Row Buffer", 555 resourceInternalReadWriteCache, 556 notLockableVideoMem); 557 DECODE_CHK_NULL(m_vcAlfTileRowBuffer); 558 } 559 else 560 { 561 DECODE_CHK_STATUS(m_allocator->Resize( 562 m_vcAlfTileRowBuffer, 563 vvcpBufSizeParam.m_bufferSize, 564 notLockableVideoMem)); 565 } 566 // VCALF Tile Row Buffer (ALFTR) 567 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 568 vcAlfYTileColumnBuffer, 569 &vvcpBufSizeParam)); 570 if (m_vcAlfYTileColumnBuffer == nullptr) 571 { 572 m_vcAlfYTileColumnBuffer = m_allocator->AllocateBuffer( 573 vvcpBufSizeParam.m_bufferSize, 574 "VCALF Y Tile Column Buffer", 575 resourceInternalReadWriteCache, 576 notLockableVideoMem); 577 DECODE_CHK_NULL(m_vcAlfYTileColumnBuffer); 578 } 579 else 580 { 581 DECODE_CHK_STATUS(m_allocator->Resize( 582 m_vcAlfYTileColumnBuffer, 583 vvcpBufSizeParam.m_bufferSize, 584 notLockableVideoMem)); 585 } 586 // VCALF U Tile Column Buffer (ALUTC) 587 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 588 vcAlfUTileColumnBuffer, 589 &vvcpBufSizeParam)); 590 if (m_vcAlfUTileColumnBuffer == nullptr) 591 { 592 m_vcAlfUTileColumnBuffer = m_allocator->AllocateBuffer( 593 vvcpBufSizeParam.m_bufferSize, 594 "VCALF U Tile Column Buffer", 595 resourceInternalReadWriteCache, 596 notLockableVideoMem); 597 DECODE_CHK_NULL(m_vcAlfUTileColumnBuffer); 598 } 599 else 600 { 601 DECODE_CHK_STATUS(m_allocator->Resize( 602 m_vcAlfUTileColumnBuffer, 603 vvcpBufSizeParam.m_bufferSize, 604 notLockableVideoMem)); 605 } 606 // VCALF V Tile Column Buffer (ALVTC) 607 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 608 vcAlfVTileColumnBuffer, 609 &vvcpBufSizeParam)); 610 if (m_vcAlfVTileColumnBuffer == nullptr) 611 { 612 m_vcAlfVTileColumnBuffer = m_allocator->AllocateBuffer( 613 vvcpBufSizeParam.m_bufferSize, 614 "VCALF V Tile Column Buffer", 615 resourceInternalReadWriteCache, 616 notLockableVideoMem); 617 DECODE_CHK_NULL(m_vcAlfVTileColumnBuffer); 618 } 619 else 620 { 621 DECODE_CHK_STATUS(m_allocator->Resize( 622 m_vcAlfVTileColumnBuffer, 623 vvcpBufSizeParam.m_bufferSize, 624 notLockableVideoMem)); 625 } 626 627 // Rowstore buffers 628 // VCED Line Buffer (EDLB) 629 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcedLineBuffer)) 630 { 631 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 632 vcedLineBuffer, 633 &vvcpBufSizeParam)); 634 635 if (m_vcedLineBuffer == nullptr) 636 { 637 m_vcedLineBuffer = m_allocator->AllocateBuffer( 638 vvcpBufSizeParam.m_bufferSize, 639 "VCED Line Buffer (EDLB)", 640 resourceInternalReadWriteCache, 641 notLockableVideoMem); 642 DECODE_CHK_NULL(m_vcedLineBuffer); 643 } 644 else 645 { 646 DECODE_CHK_STATUS(m_allocator->Resize( 647 m_vcedLineBuffer, 648 vvcpBufSizeParam.m_bufferSize, 649 notLockableVideoMem)); 650 } 651 } 652 // VCMV Line Buffer (MVLB) 653 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcmvLineBuffer)) 654 { 655 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 656 vcmvLineBuffer, 657 &vvcpBufSizeParam)); 658 659 if (m_vcmvLineBuffer == nullptr) 660 { 661 m_vcmvLineBuffer = m_allocator->AllocateBuffer( 662 vvcpBufSizeParam.m_bufferSize, 663 "VCMV Line Buffer (MVLB)", 664 resourceInternalReadWriteCache, 665 notLockableVideoMem); 666 DECODE_CHK_NULL(m_vcmvLineBuffer); 667 } 668 else 669 { 670 DECODE_CHK_STATUS(m_allocator->Resize( 671 m_vcmvLineBuffer, 672 vvcpBufSizeParam.m_bufferSize, 673 notLockableVideoMem)); 674 } 675 } 676 // VCPR Line Buffer (PRLB) 677 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcprLineBuffer)) 678 { 679 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 680 vcprLineBuffer, 681 &vvcpBufSizeParam)); 682 683 if (m_vcprLineBuffer == nullptr) 684 { 685 m_vcprLineBuffer = m_allocator->AllocateBuffer( 686 vvcpBufSizeParam.m_bufferSize, 687 "VCPR Line Buffer (PRLB)", 688 resourceInternalReadWriteCache, 689 notLockableVideoMem); 690 DECODE_CHK_NULL(m_vcprLineBuffer); 691 } 692 else 693 { 694 DECODE_CHK_STATUS(m_allocator->Resize( 695 m_vcprLineBuffer, 696 vvcpBufSizeParam.m_bufferSize, 697 notLockableVideoMem)); 698 } 699 } 700 // VCLF Y Line Buffer (LFYLB) 701 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfYLineBuffer)) 702 { 703 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 704 vclfYLineBuffer, 705 &vvcpBufSizeParam)); 706 707 if (m_vclfYLineBuffer == nullptr) 708 { 709 m_vclfYLineBuffer = m_allocator->AllocateBuffer( 710 vvcpBufSizeParam.m_bufferSize, 711 "VCPR Line Buffer (PRLB)", 712 resourceInternalReadWriteCache, 713 notLockableVideoMem); 714 DECODE_CHK_NULL(m_vclfYLineBuffer); 715 } 716 else 717 { 718 DECODE_CHK_STATUS(m_allocator->Resize( 719 m_vclfYLineBuffer, 720 vvcpBufSizeParam.m_bufferSize, 721 notLockableVideoMem)); 722 } 723 } 724 // VCLF U Line Buffer (LFULB) 725 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfULineBuffer)) 726 { 727 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 728 vclfULineBuffer, 729 &vvcpBufSizeParam)); 730 731 if (m_vclfULineBuffer == nullptr) 732 { 733 m_vclfULineBuffer = m_allocator->AllocateBuffer( 734 vvcpBufSizeParam.m_bufferSize, 735 "VCPR Line Buffer (PRLB)", 736 resourceInternalReadWriteCache, 737 notLockableVideoMem); 738 DECODE_CHK_NULL(m_vclfULineBuffer); 739 } 740 else 741 { 742 DECODE_CHK_STATUS(m_allocator->Resize( 743 m_vclfULineBuffer, 744 vvcpBufSizeParam.m_bufferSize, 745 notLockableVideoMem)); 746 } 747 } 748 // VCLF V Line Buffer (LFVLB) 749 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vclfVLineBuffer)) 750 { 751 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 752 vclfVLineBuffer, 753 &vvcpBufSizeParam)); 754 755 if (m_vclfVLineBuffer == nullptr) 756 { 757 m_vclfVLineBuffer = m_allocator->AllocateBuffer( 758 vvcpBufSizeParam.m_bufferSize, 759 "VCLF V Line Buffer (LFVLB)", 760 resourceInternalReadWriteCache, 761 notLockableVideoMem); 762 DECODE_CHK_NULL(m_vclfVLineBuffer); 763 } 764 else 765 { 766 DECODE_CHK_STATUS(m_allocator->Resize( 767 m_vclfVLineBuffer, 768 vvcpBufSizeParam.m_bufferSize, 769 notLockableVideoMem)); 770 } 771 } 772 // VCSAO Y Line Buffer (SAYLB) 773 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoYLineBuffer)) 774 { 775 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 776 vcSaoYLineBuffer, 777 &vvcpBufSizeParam)); 778 779 if (m_vcSaoYLineBuffer == nullptr) 780 { 781 m_vcSaoYLineBuffer = m_allocator->AllocateBuffer( 782 vvcpBufSizeParam.m_bufferSize, 783 "VCSAO Y Line Buffer (SAYLB)", 784 resourceInternalReadWriteCache, 785 notLockableVideoMem); 786 DECODE_CHK_NULL(m_vcSaoYLineBuffer); 787 } 788 else 789 { 790 DECODE_CHK_STATUS(m_allocator->Resize( 791 m_vcSaoYLineBuffer, 792 vvcpBufSizeParam.m_bufferSize, 793 notLockableVideoMem)); 794 } 795 } 796 // VCSAO U Line Buffer (SAULB) 797 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoULineBuffer)) 798 { 799 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 800 vcSaoULineBuffer, 801 &vvcpBufSizeParam)); 802 803 if (m_vcSaoULineBuffer == nullptr) 804 { 805 m_vcSaoULineBuffer = m_allocator->AllocateBuffer( 806 vvcpBufSizeParam.m_bufferSize, 807 "VCSAO U Line Buffer (SAULB)", 808 resourceInternalReadWriteCache, 809 notLockableVideoMem); 810 DECODE_CHK_NULL(m_vcSaoULineBuffer); 811 } 812 else 813 { 814 DECODE_CHK_STATUS(m_allocator->Resize( 815 m_vcSaoULineBuffer, 816 vvcpBufSizeParam.m_bufferSize, 817 notLockableVideoMem)); 818 } 819 } 820 // VCSAO V Line Buffer (SAVLB) 821 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcSaoVLineBuffer)) 822 { 823 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 824 vcSaoVLineBuffer, 825 &vvcpBufSizeParam)); 826 827 if (m_vcSaoVLineBuffer == nullptr) 828 { 829 m_vcSaoVLineBuffer = m_allocator->AllocateBuffer( 830 vvcpBufSizeParam.m_bufferSize, 831 "VCSAO V Line Buffer (SAVLB)", 832 resourceInternalReadWriteCache, 833 notLockableVideoMem); 834 DECODE_CHK_NULL(m_vcSaoVLineBuffer); 835 } 836 else 837 { 838 DECODE_CHK_STATUS(m_allocator->Resize( 839 m_vcSaoVLineBuffer, 840 vvcpBufSizeParam.m_bufferSize, 841 notLockableVideoMem)); 842 } 843 } 844 // VCALF Line Buffer (ALFLB) 845 if (!m_vvcpItf->IsBufferRowstoreCacheEnabled(vcAlfLineBuffer)) 846 { 847 DECODE_CHK_STATUS(m_vvcpItf->GetVvcpBufSize( 848 vcAlfLineBuffer, 849 &vvcpBufSizeParam)); 850 851 if (m_vcAlfLineBuffer == nullptr) 852 { 853 m_vcAlfLineBuffer = m_allocator->AllocateBuffer( 854 vvcpBufSizeParam.m_bufferSize, 855 "VCALF Line Buffer (ALFLB)", 856 resourceInternalReadWriteCache, 857 notLockableVideoMem); 858 DECODE_CHK_NULL(m_vcAlfLineBuffer); 859 } 860 else 861 { 862 DECODE_CHK_STATUS(m_allocator->Resize( 863 m_vcAlfLineBuffer, 864 vvcpBufSizeParam.m_bufferSize, 865 notLockableVideoMem)); 866 } 867 } 868 869 870 return MOS_STATUS_SUCCESS; 871 } 872 FixVvcpPipeBufAddrParams() const873 MOS_STATUS VvcDecodePicPkt::FixVvcpPipeBufAddrParams() const 874 { 875 DECODE_FUNC_CALL(); 876 877 uint8_t validRefFrameIdx = m_vvcBasicFeature->m_refFrames.GetValidReferenceFrameIdx(); 878 DECODE_ASSERT(validRefFrameIdx < CODEC_MAX_DPB_NUM_VVC); 879 880 auto ¶ms = m_vvcpItf->MHW_GETPAR_F(VVCP_PIPE_BUF_ADDR_STATE)(); 881 PMOS_RESOURCE validRefPic = m_vvcBasicFeature->m_refFrames.GetReferenceByFrameIndex(validRefFrameIdx); 882 for (uint8_t i = 0; i < vvcMaxNumRefFrame; i++) 883 { 884 // error concealment for the unset reference addresses and unset mv buffers 885 if (params.references[i] == nullptr) 886 { 887 params.references[i] = validRefPic; 888 } 889 } 890 891 PMOS_BUFFER validMvBuf = m_vvcBasicFeature->m_mvBuffers.GetValidBufferForReference( 892 m_vvcBasicFeature->m_refFrameIndexList); 893 for (uint32_t i = 0; i < vvcMaxNumRefFrame; i++) 894 { 895 if (params.colMvTemporalBuffer[i] == nullptr) 896 { 897 params.colMvTemporalBuffer[i] = &validMvBuf->OsResource; 898 } 899 } 900 901 return MOS_STATUS_SUCCESS; 902 } 903 SetScalingListDataBuffer(uint8_t * buffer,uint32_t size) const904 MOS_STATUS VvcDecodePicPkt::SetScalingListDataBuffer(uint8_t *buffer, uint32_t size) const 905 { 906 DECODE_FUNC_CALL(); 907 DECODE_CHK_NULL(buffer); 908 909 uint8_t apsId = m_vvcPicParams->m_phScalingListApsId; 910 DECODE_CHK_COND((m_vvcBasicFeature->m_activeScalingListMask & (1 << apsId)) == 0, "Invalid scaling list id."); 911 912 const CodecVvcQmData &scalingList = m_vvcBasicFeature->m_scalingListArray[apsId]; 913 MOS_SecureMemcpy(buffer, size, &scalingList, sizeof(scalingList)); 914 return MOS_STATUS_SUCCESS; 915 } 916 SetDataBuffers() const917 MOS_STATUS VvcDecodePicPkt::SetDataBuffers() const 918 { 919 DECODE_FUNC_CALL(); 920 921 if (m_vvcBasicFeature->m_activeAlfMask != 0) 922 { 923 uint32_t alfTempBuffer[m_alfBufferSize]; 924 // Set ALF Data buffers with accumulated ALF tables 925 DECODE_CHK_STATUS(m_vvcpItf->SetAlfApsDataBuffer(alfTempBuffer, m_vvcBasicFeature->m_alfApsArray, m_vvcBasicFeature->m_activeAlfMask)); 926 ResourceAutoLock resLock(m_allocator, &m_apsAlfBuffer->OsResource); 927 uint32_t* data = static_cast<uint32_t*>(resLock.LockResourceForWrite()); 928 DECODE_CHK_NULL(data); 929 MOS_SecureMemcpy(data, m_alfBufferSize, alfTempBuffer, m_alfBufferSize); 930 } 931 932 if (m_vvcPicParams->m_spsFlags2.m_fields.m_spsExplicitScalingListEnabledFlag && 933 m_vvcPicParams->m_phFlags.m_fields.m_phExplicitScalingListEnabledFlag) 934 { 935 DECODE_CHK_COND(m_vvcBasicFeature->m_activeScalingListMask == 0, "Invalid scaling list enable flag."); 936 ResourceAutoLock resLock(m_allocator, &m_apsScalingListBuffer->OsResource); 937 uint8_t* data = static_cast<uint8_t*>(resLock.LockResourceForWrite()); 938 // Set Scaling List APS Data buffers with accumulated Scaling List tables 939 DECODE_CHK_STATUS(SetScalingListDataBuffer(data, m_apsScalingListBuffer->size)); 940 } 941 942 ResourceAutoLock resLock(m_allocator, &m_chromaQpBuffer->OsResource); 943 uint8_t* data = static_cast<uint8_t*>(resLock.LockResourceForWrite()); 944 DECODE_CHK_NULL(data); 945 //change to copy for 3 times because ddi parse m_chromaQpTable[3][112] while hw support m_chromaQpTable[3][76] 946 MOS_SecureMemcpy(data, 76 * sizeof(int8_t), m_vvcPicParams->m_chromaQpTable[0], 76 * sizeof(int8_t)); 947 MOS_SecureMemcpy(data + 76, 76 * sizeof(int8_t), m_vvcPicParams->m_chromaQpTable[1], 76 * sizeof(int8_t)); 948 MOS_SecureMemcpy(data + 76 * 2, 76 * sizeof(int8_t), m_vvcPicParams->m_chromaQpTable[2], 76 * sizeof(int8_t)); 949 950 return MOS_STATUS_SUCCESS; 951 } 952 CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)953 MOS_STATUS VvcDecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize) 954 { 955 DECODE_FUNC_CALL(); 956 957 commandBufferSize = m_pictureStatesSize; 958 requestedPatchListSize = m_picturePatchListSize; 959 960 return MOS_STATUS_SUCCESS; 961 } 962 963 #if USE_CODECHAL_DEBUG_TOOL DumpResources() const964 MOS_STATUS VvcDecodePicPkt::DumpResources() const 965 { 966 DECODE_FUNC_CALL(); 967 968 CodechalDebugInterface *debugInterface = m_vvcPipeline->GetDebugInterface(); 969 debugInterface->m_frameType = m_vvcBasicFeature->m_pictureCodingType; 970 debugInterface->m_currPic = m_vvcPicParams->m_currPic; 971 debugInterface->m_bufferDumpFrameNum = m_vvcBasicFeature->m_frameNum; 972 973 auto &par = m_vvcpItf->MHW_GETPAR_F(VVCP_PIPE_BUF_ADDR_STATE)(); 974 975 // For multi-slices per frame case, only need dump these resources once. 976 if (m_vvcBasicFeature->m_curSlice == 0) 977 { 978 if (!m_vvcPicParams->m_picMiscFlags.m_fields.m_intraPicFlag) 979 { 980 for (auto n = 0; n < vvcMaxNumRefFrame; n++) 981 { 982 if (par.references[n] != nullptr) 983 { 984 MOS_SURFACE refSurface; 985 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 986 refSurface.OsResource = *(par.references[n]); 987 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 988 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(n)) + "]"; 989 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 990 &refSurface, 991 CodechalDbgAttr::attrDecodeReferenceSurfaces, 992 refSurfName.c_str())); 993 } 994 } 995 } 996 997 if (par.apsAlfBuffer != nullptr && 998 !m_allocator->ResourceIsNull(par.apsAlfBuffer)) 999 { 1000 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 1001 par.apsAlfBuffer, 1002 CodechalDbgAttr::attrAlfData, 1003 "AlfPipeBuf", 1004 MOS_ALIGN_CEIL(m_alfBufferSize, CODECHAL_PAGE_SIZE), 1005 CODECHAL_NUM_MEDIA_STATES)); 1006 } 1007 } 1008 1009 return MOS_STATUS_SUCCESS; 1010 } 1011 #endif 1012 CalculatePictureStateCommandSize()1013 MOS_STATUS VvcDecodePicPkt::CalculatePictureStateCommandSize() 1014 { 1015 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams; 1016 1017 stateCmdSizeParams.bShortFormat = true; 1018 stateCmdSizeParams.bHucDummyStream = false; 1019 stateCmdSizeParams.bSfcInUse = false; 1020 // Picture Level Commands 1021 DECODE_CHK_STATUS(m_hwInterface->GetVvcpStateCommandSize( 1022 m_vvcBasicFeature->m_mode, 1023 &m_pictureStatesSize, 1024 &m_picturePatchListSize, 1025 &stateCmdSizeParams)); 1026 1027 return MOS_STATUS_SUCCESS; 1028 } 1029 MHW_SETPAR_DECL_SRC(VVCP_VD_CONTROL_STATE,VvcDecodePicPkt)1030 MHW_SETPAR_DECL_SRC(VVCP_VD_CONTROL_STATE, VvcDecodePicPkt) 1031 { 1032 params = {}; 1033 1034 params.pipelineInitialization = true; 1035 1036 return MOS_STATUS_SUCCESS; 1037 } 1038 AddAllCmds_VVCP_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER & cmdBuffer)1039 MOS_STATUS VvcDecodePicPkt::AddAllCmds_VVCP_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER &cmdBuffer) 1040 { 1041 DECODE_FUNC_CALL(); 1042 1043 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after VVCP Pipemode select... 1044 auto &mfxWaitParams = m_miItf->MHW_GETPAR_F(MFX_WAIT)(); 1045 mfxWaitParams = {}; 1046 mfxWaitParams.iStallVdboxPipeline = true; 1047 DECODE_CHK_STATUS((m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer))); 1048 1049 DECODE_CHK_NULL(m_vvcpItf); 1050 SETPAR_AND_ADDCMD(VVCP_PIPE_MODE_SELECT, m_vvcpItf, &cmdBuffer); 1051 1052 mfxWaitParams = {}; 1053 mfxWaitParams.iStallVdboxPipeline = true; 1054 DECODE_CHK_STATUS((m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer))); 1055 1056 return MOS_STATUS_SUCCESS; 1057 } 1058 MHW_SETPAR_DECL_SRC(VVCP_PIPE_MODE_SELECT,VvcDecodePicPkt)1059 MHW_SETPAR_DECL_SRC(VVCP_PIPE_MODE_SELECT, VvcDecodePicPkt) 1060 { 1061 params = {}; 1062 1063 params.codecSelect = 0; // default value for decode 1064 params.picStatusErrorReportEnable = false; 1065 params.codecStandardSelect = CODEC_STANDARD_SELECT_VVC; 1066 params.picStatusErrorReportId = false; 1067 1068 return MOS_STATUS_SUCCESS; 1069 } 1070 AddAllCmds_VVCP_SURFACE_STATE(MOS_COMMAND_BUFFER & cmdBuffer)1071 MOS_STATUS VvcDecodePicPkt::AddAllCmds_VVCP_SURFACE_STATE(MOS_COMMAND_BUFFER &cmdBuffer) 1072 { 1073 DECODE_FUNC_CALL(); 1074 1075 // Dest surface 1076 m_curVvcpSurfStateId = reconPic; 1077 SETPAR_AND_ADDCMD(VVCP_SURFACE_STATE, m_vvcpItf, &cmdBuffer); 1078 1079 // Ref surface 1080 if (!m_vvcPicParams->m_picMiscFlags.m_fields.m_intraPicFlag) 1081 { 1082 VvcReferenceFrames &refFrames = m_vvcBasicFeature->m_refFrames; 1083 uint8_t frameIdx = CODEC_MAX_DPB_NUM_VVC; 1084 for (uint8_t i = 0; i < vvcMaxNumRefFrame; i++) 1085 { 1086 m_curVvcpSurfStateId = i + vvcRefPic0; 1087 bool valRes = false; 1088 if (m_vvcPicParams->m_refFrameList[i].PicFlags != PICTURE_INVALID) 1089 { 1090 frameIdx = m_vvcPicParams->m_refFrameList[i].FrameIdx; 1091 PMOS_RESOURCE refSurf = refFrames.GetReferenceByFrameIndex(frameIdx); 1092 if (refSurf != nullptr) 1093 { 1094 m_refSurface[i].OsResource = *refSurf; 1095 valRes = true; 1096 } 1097 } 1098 1099 if (valRes == false) 1100 { 1101 frameIdx = refFrames.GetValidReferenceFrameIdx(); 1102 PMOS_RESOURCE refSurf = refFrames.GetReferenceByFrameIndex(frameIdx); 1103 if (refSurf == nullptr) 1104 { 1105 return MOS_STATUS_INVALID_PARAMETER; 1106 } 1107 m_refSurface[i].OsResource = *refSurf; 1108 } 1109 1110 SETPAR_AND_ADDCMD(VVCP_SURFACE_STATE, m_vvcpItf, &cmdBuffer); 1111 } 1112 } 1113 1114 return MOS_STATUS_SUCCESS; 1115 } 1116 MHW_SETPAR_DECL_SRC(VVCP_SURFACE_STATE,VvcDecodePicPkt)1117 MHW_SETPAR_DECL_SRC(VVCP_SURFACE_STATE, VvcDecodePicPkt) 1118 { 1119 params = {}; 1120 1121 uint32_t uvPlaneAlignment = 8; 1122 PMOS_SURFACE psSurface = nullptr; 1123 1124 params.surfaceId = m_curVvcpSurfStateId; 1125 if (params.surfaceId == vvcReconPic) 1126 { 1127 // Decode dest surface 1128 psSurface = &m_vvcBasicFeature->m_destSurface; 1129 1130 } 1131 else if (params.surfaceId >= vvcRefPic0 && params.surfaceId <= vvcRefPic14) 1132 { 1133 // Decode ref surface 1134 psSurface = const_cast<PMOS_SURFACE>(&m_refSurface[params.surfaceId - vvcRefPic0]); 1135 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(psSurface)); 1136 } 1137 else 1138 { 1139 return MOS_STATUS_INVALID_PARAMETER; 1140 } 1141 1142 params.surfacePitchMinus1 = psSurface->dwPitch - 1; 1143 params.yOffsetForUCbInPixel = MOS_ALIGN_CEIL((psSurface->UPlaneOffset.iSurfaceOffset - psSurface->dwOffset) / 1144 psSurface->dwPitch + psSurface->RenderOffset.YUV.U.YOffset, 1145 uvPlaneAlignment); 1146 1147 #ifdef _MMC_SUPPORTED 1148 if (params.surfaceId == vvcReconPic) 1149 { 1150 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_vvcBasicFeature->m_destSurface))); 1151 } 1152 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(psSurface, ¶ms.compressionFormat)); 1153 #endif 1154 1155 if (m_vvcPicParams->m_spsBitdepthMinus8 == 0) 1156 { 1157 if (m_vvcPicParams->m_spsChromaFormatIdc == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_NV12) // 4:2:0 8bit surface 1158 { 1159 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_PLANAR4208; 1160 } 1161 else if (m_vvcPicParams->m_spsChromaFormatIdc == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0 10bit surface 1162 { 1163 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010; 1164 } 1165 else 1166 { 1167 return MOS_STATUS_INVALID_PARAMETER; 1168 } 1169 } 1170 else if (m_vvcPicParams->m_spsBitdepthMinus8 == 2) 1171 { 1172 if (m_vvcPicParams->m_spsChromaFormatIdc == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0 10bit surface 1173 { 1174 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010; 1175 } 1176 else 1177 { 1178 return MOS_STATUS_INVALID_PARAMETER; 1179 } 1180 } 1181 else 1182 { 1183 return MOS_STATUS_INVALID_PARAMETER; 1184 } 1185 1186 return MOS_STATUS_SUCCESS; 1187 } 1188 MHW_SETPAR_DECL_SRC(VVCP_PIPE_BUF_ADDR_STATE,VvcDecodePicPkt)1189 MHW_SETPAR_DECL_SRC(VVCP_PIPE_BUF_ADDR_STATE, VvcDecodePicPkt) 1190 { 1191 params = {}; 1192 1193 // Decoded Picture 1194 params.decodedPic = &(m_vvcBasicFeature->m_destSurface); 1195 1196 // Current MV buffer 1197 auto mvBuffers = &(m_vvcBasicFeature->m_mvBuffers); 1198 MOS_BUFFER *curMvBuffer = mvBuffers->GetCurBuffer(); 1199 DECODE_CHK_NULL(curMvBuffer); 1200 params.curMvTemporalBuffer = &(curMvBuffer->OsResource); 1201 1202 // Collocated MV buffer & reference frames 1203 VvcReferenceFrames &refFrames = m_vvcBasicFeature->m_refFrames; 1204 if (!refFrames.m_curIsIntra) 1205 { 1206 for (uint8_t i = 0; i < vvcMaxNumRefFrame; i++) 1207 { 1208 if (m_vvcPicParams->m_refFrameList[i].PicFlags != PICTURE_INVALID) 1209 { 1210 uint8_t frameIdx = m_vvcPicParams->m_refFrameList[i].FrameIdx; 1211 if (m_vvcPicParams->m_refFrameList[i].PicFlags == PICTURE_UNAVAILABLE_FRAME) 1212 { 1213 params.colMvTemporalBuffer[i] = &curMvBuffer->OsResource; 1214 } 1215 else 1216 { 1217 MOS_BUFFER *mvBuf = mvBuffers->GetBufferByFrameIndex(frameIdx); 1218 DECODE_CHK_NULL(mvBuf); 1219 params.colMvTemporalBuffer[i] = &mvBuf->OsResource; 1220 } 1221 params.references[i] = refFrames.GetReferenceByFrameIndex(frameIdx); 1222 } 1223 else 1224 { 1225 params.colMvTemporalBuffer[i] = nullptr; 1226 params.references[i] = nullptr; 1227 } 1228 } 1229 } 1230 1231 DECODE_CHK_STATUS(FixVvcpPipeBufAddrParams()); 1232 1233 params.apsScalingListDataBuffer = &m_apsScalingListBuffer->OsResource; 1234 params.apsAlfBuffer = &m_apsAlfBuffer->OsResource; 1235 params.spsChromaQpTableBuffer = &m_chromaQpBuffer->OsResource; 1236 1237 params.vcedLineBuffer = &m_vcedLineBuffer->OsResource; 1238 params.vcmvLineBuffer = &m_vcmvLineBuffer->OsResource; 1239 params.vcprLineBuffer = &m_vcprLineBuffer->OsResource; 1240 1241 params.vclfYLineBuffer = &m_vclfYLineBuffer->OsResource; 1242 params.vclfYTileRowBuffer = &m_vclfYTileRowBuffer->OsResource; 1243 params.vclfYTileColumnBuffer = &m_vclfYTileColumnBuffer->OsResource; 1244 params.vclfULineBuffer = &m_vclfULineBuffer->OsResource; 1245 params.vclfUTileRowBuffer = &m_vclfUTileRowBuffer->OsResource; 1246 params.vclfUTileColumnBuffer = &m_vclfUTileColumnBuffer->OsResource; 1247 params.vclfVLineBuffer = &m_vclfVLineBuffer->OsResource; 1248 params.vclfVTileRowBuffer = &m_vclfVTileRowBuffer->OsResource; 1249 params.vclfVTileColumnBuffer = &m_vclfVTileColumnBuffer->OsResource; 1250 1251 params.vcSaoYLineBuffer = &m_vcSaoYLineBuffer->OsResource; 1252 params.vcSaoYTileRowBuffer = &m_vcSaoYTileRowBuffer->OsResource; 1253 params.vcSaoYTileColumnBuffer = &m_vcSaoYTileColumnBuffer->OsResource; 1254 params.vcSaoULineBuffer = &m_vcSaoULineBuffer->OsResource; 1255 params.vcSaoUTileRowBuffer = &m_vcSaoUTileRowBuffer->OsResource; 1256 params.vcSaoUTileColumnBuffer = &m_vcSaoUTileColumnBuffer->OsResource; 1257 params.vcSaoVLineBuffer = &m_vcSaoVLineBuffer->OsResource; 1258 params.vcSaoVTileRowBuffer = &m_vcSaoVTileRowBuffer->OsResource; 1259 params.vcSaoVTileColumnBuffer = &m_vcSaoVTileColumnBuffer->OsResource; 1260 1261 params.vcAlfLineBuffer = &m_vcAlfLineBuffer->OsResource; 1262 params.vcAlfTileRowBuffer = &m_vcAlfTileRowBuffer->OsResource; 1263 params.vcAlfYTileColumnBuffer = &m_vcAlfYTileColumnBuffer->OsResource; 1264 params.vcAlfUTileColumnBuffer = &m_vcAlfUTileColumnBuffer->OsResource; 1265 params.vcAlfVTileColumnBuffer = &m_vcAlfVTileColumnBuffer->OsResource; 1266 1267 DECODE_CHK_STATUS(SetDataBuffers()); 1268 1269 #if USE_CODECHAL_DEBUG_TOOL 1270 DECODE_CHK_STATUS(DumpResources()); 1271 #endif 1272 1273 return MOS_STATUS_SUCCESS; 1274 } 1275 MHW_SETPAR_DECL_SRC(VVCP_IND_OBJ_BASE_ADDR_STATE,VvcDecodePicPkt)1276 MHW_SETPAR_DECL_SRC(VVCP_IND_OBJ_BASE_ADDR_STATE, VvcDecodePicPkt) 1277 { 1278 params = {}; 1279 1280 params.dwDataSize = m_vvcBasicFeature->m_dataSize; 1281 params.dwDataOffset = m_vvcBasicFeature->m_dataOffset; 1282 params.presDataBuffer = &(m_vvcBasicFeature->m_resDataBuffer.OsResource); 1283 1284 return MOS_STATUS_SUCCESS; 1285 } 1286 MHW_SETPAR_DECL_SRC(VVCP_PIC_STATE,VvcDecodePicPkt)1287 MHW_SETPAR_DECL_SRC(VVCP_PIC_STATE, VvcDecodePicPkt) 1288 { 1289 params = {}; 1290 1291 CodecVvcPicParams *picParams = m_vvcBasicFeature->m_vvcPicParams; 1292 1293 params.spsSubpicInfoPresentFlag = picParams->m_spsFlags0.m_fields.m_spsSubpicInfoPresentFlag; 1294 params.spsIndependentSubpicsFlag = picParams->m_spsFlags0.m_fields.m_spsIndependentSubpicsFlag; 1295 params.spsSubpicSameSizeFlag = picParams->m_spsFlags0.m_fields.m_spsSubpicSameSizeFlag; 1296 params.spsEntropyCodingSyncEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsEntropyCodingSyncEnabledFlag; 1297 params.spsQtbttDualTreeIntraFlag = picParams->m_spsFlags0.m_fields.m_spsQtbttDualTreeIntraFlag; 1298 params.spsMaxLumaTransformSize64Flag = picParams->m_spsFlags0.m_fields.m_spsMaxLumaTransformSize64Flag; 1299 params.spsTransformSkipEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsTransformSkipEnabledFlag; 1300 params.spsBdpcmEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsBdpcmEnabledFlag; 1301 params.spsMtsEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsMtsEnabledFlag; 1302 params.spsExplicitMtsIntraEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsExplicitMtsIntraEnabledFlag; 1303 params.spsExplicitMtsInterEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsExplicitMtsInterEnabledFlag; 1304 params.spsLfnstEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsLfnstEnabledFlag; 1305 params.spsJointCbcrEnabledFlag = picParams->m_spsFlags0.m_fields.m_spsJointCbcrEnabledFlag; 1306 params.spsSameQpTableForChromaFlag = picParams->m_spsFlags0.m_fields.m_spsSameQpTableForChromaFlag; 1307 1308 // derived flags 1309 params.dLmcsDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsLmcsEnabledFlag == 0) || 1310 (picParams->m_spsFlags0.m_fields.m_spsLmcsEnabledFlag == 1 && 1311 picParams->m_phFlags.m_fields.m_phLmcsEnabledFlag == 0)) 1312 ? 1 1313 : 0; 1314 params.dDblkDisabledFlag = ((picParams->m_ppsFlags.m_fields.m_ppsDeblockingFilterDisabledFlag == 1 && 1315 picParams->m_ppsFlags.m_fields.m_ppsDeblockingFilterOverrideEnabledFlag == 0) || 1316 (picParams->m_ppsFlags.m_fields.m_ppsDeblockingFilterOverrideEnabledFlag == 1 && 1317 picParams->m_phFlags.m_fields.m_phDeblockingFilterDisabledFlag == 1 && 1318 picParams->m_ppsFlags.m_fields.m_ppsDbfInfoInPhFlag == 1)) 1319 ? 1 1320 : 0; 1321 params.dSaoLumaDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsSaoEnabledFlag == 0) || 1322 (picParams->m_ppsFlags.m_fields.m_ppsSaoInfoInPhFlag == 1 && 1323 picParams->m_phFlags.m_fields.m_phSaoLumaEnabledFlag == 0)) 1324 ? 1 1325 : 0; 1326 params.dSaoChromaDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsSaoEnabledFlag == 0) || 1327 (picParams->m_ppsFlags.m_fields.m_ppsSaoInfoInPhFlag == 1 && 1328 picParams->m_phFlags.m_fields.m_phSaoChromaEnabledFlag == 0)) 1329 ? 1 1330 : 0; 1331 params.dAlfDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsAlfEnabledFlag == 0) || 1332 (picParams->m_ppsFlags.m_fields.m_ppsAlfInfoInPhFlag == 1 && 1333 picParams->m_phFlags.m_fields.m_phAlfEnabledFlag == 0)) 1334 ? 1 1335 : 0; 1336 params.dAlfCbDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsAlfEnabledFlag == 0) || 1337 (picParams->m_ppsFlags.m_fields.m_ppsAlfInfoInPhFlag == 1 && 1338 picParams->m_phFlags.m_fields.m_phAlfCbEnabledFlag == 0)) 1339 ? 1 1340 : 0; 1341 params.dAlfCrDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsAlfEnabledFlag == 0) || 1342 (picParams->m_ppsFlags.m_fields.m_ppsAlfInfoInPhFlag == 1 && 1343 picParams->m_phFlags.m_fields.m_phAlfCrEnabledFlag == 0)) 1344 ? 1 1345 : 0; 1346 params.dAlfCcCbDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsCcalfEnabledFlag == 0) || 1347 (picParams->m_ppsFlags.m_fields.m_ppsAlfInfoInPhFlag == 1 && 1348 picParams->m_phFlags.m_fields.m_phAlfCcCbEnabledFlag == 0)) 1349 ? 1 1350 : 0; 1351 params.dAlfCcCrDisabledFlag = ((picParams->m_spsFlags0.m_fields.m_spsCcalfEnabledFlag == 0) || 1352 (picParams->m_ppsFlags.m_fields.m_ppsAlfInfoInPhFlag == 1 && 1353 picParams->m_phFlags.m_fields.m_phAlfCcCrEnabledFlag == 0)) 1354 ? 1 1355 : 0; 1356 params.dSingleSliceFrameFlag = (m_vvcBasicFeature->m_numSlices == 1) ? 1 : 0; 1357 1358 params.spsSbtmvpEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsSbtmvpEnabledFlag; 1359 params.spsAmvrEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsAmvrEnabledFlag; 1360 params.spsSmvdEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsSmvdEnabledFlag; 1361 params.spsMmvdEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsMmvdEnabledFlag; 1362 params.spsSbtEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsSbtEnabledFlag; 1363 params.spsAffineEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsAffineEnabledFlag; 1364 params.sps6ParamAffineEnabledFlag = picParams->m_spsFlags1.m_fields.m_sps6paramAffineEnabledFlag; 1365 params.spsAffineAmvrEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsAffineAmvrEnabledFlag; 1366 params.spsBcwEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsBcwEnabledFlag; 1367 params.spsCiipEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsCiipEnabledFlag; 1368 params.spsGpmEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsGpmEnabledFlag; 1369 params.spsIspEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsIspEnabledFlag; 1370 params.spsMrlEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsMrlEnabledFlag; 1371 params.spsMipEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsMipEnabledFlag; 1372 params.spsCclmEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsCclmEnabledFlag; 1373 params.spsChromaHorizontalCollocatedFlag = picParams->m_spsFlags1.m_fields.m_spsChromaHorizontalCollocatedFlag; 1374 params.spsChromaVerticalCollocatedFlag = picParams->m_spsFlags1.m_fields.m_spsChromaVerticalCollocatedFlag; 1375 params.spsTemporalMvpEnabledFlag = picParams->m_spsFlags1.m_fields.m_spsTemporalMvpEnabledFlag; 1376 params.spsPaletteEnabledFlag = picParams->m_spsFlags2.m_fields.m_spsPaletteEnabledFlag; 1377 params.spsActEnabledFlag = picParams->m_spsFlags2.m_fields.m_spsActEnabledFlag; 1378 params.spsIbcEnabledFlag = picParams->m_spsFlags2.m_fields.m_spsIbcEnabledFlag; 1379 params.spsLadfEnabledFlag = picParams->m_spsFlags2.m_fields.m_spsLadfEnabledFlag; 1380 params.spsScalingMatrixForLfnstDisabledFlag = picParams->m_spsFlags2.m_fields.m_spsScalingMatrixForLfnstDisabledFlag; 1381 params.spsScalingMatrixForAlternativeColorSpaceDisabledFlag = picParams->m_spsFlags2.m_fields.m_spsScalingMatrixForAlternativeColourSpaceDisabledFlag; 1382 params.spsScalingMatrixDesignatedColorSpaceFlag = picParams->m_spsFlags2.m_fields.m_spsScalingMatrixDesignatedColourSpaceFlag; 1383 1384 params.ppsLoopFilterAcrossTilesEnabledFlag = picParams->m_ppsFlags.m_fields.m_ppsLoopFilterAcrossTilesEnabledFlag; 1385 params.ppsRectSliceFlag = picParams->m_ppsFlags.m_fields.m_ppsRectSliceFlag; 1386 params.ppsSingleSlicePerSubpicFlag = picParams->m_ppsFlags.m_fields.m_ppsSingleSlicePerSubpicFlag; 1387 params.ppsLoopFilterAcrossSlicesEnabledFlag = picParams->m_ppsFlags.m_fields.m_ppsLoopFilterAcrossSlicesEnabledFlag; 1388 params.ppsWeightedPredFlag = picParams->m_ppsFlags.m_fields.m_ppsWeightedPredFlag; 1389 params.ppsWeightedBipredFlag = picParams->m_ppsFlags.m_fields.m_ppsWeightedBipredFlag; 1390 params.ppsRefWraparoundEnabledFlag = picParams->m_ppsFlags.m_fields.m_ppsRefWraparoundEnabledFlag; 1391 params.ppsCuQpDeltaEnabledFlag = picParams->m_ppsFlags.m_fields.m_ppsCuQpDeltaEnabledFlag; 1392 params.virtualboundariespresentflag = (picParams->m_spsFlags2.m_fields.m_spsVirtualBoundariesEnabledFlag && 1393 (picParams->m_spsFlags2.m_fields.m_spsVirtualBoundariesPresentFlag || picParams->m_phFlags.m_fields.m_phVirtualBoundariesPresentFlag)) 1394 ? 1 1395 : 0; 1396 params.phNonRefPicFlag = picParams->m_phFlags.m_fields.m_phNonRefPicFlag; 1397 params.phChromaResidualScaleFlag = picParams->m_phFlags.m_fields.m_phChromaResidualScaleFlag; 1398 params.phTemporalMvpEnabledFlag = picParams->m_phFlags.m_fields.m_phTemporalMvpEnabledFlag; 1399 params.phMmvdFullpelOnlyFlag = picParams->m_phFlags.m_fields.m_phMmvdFullpelOnlyFlag; 1400 params.phMvdL1ZeroFlag = picParams->m_phFlags.m_fields.m_phMvdL1ZeroFlag; 1401 params.phBdofDisabledFlag = picParams->m_phFlags.m_fields.m_phBdofDisabledFlag; 1402 params.phDmvrDisabledFlag = picParams->m_phFlags.m_fields.m_phDmvrDisabledFlag; 1403 params.phProfDisabledFlag = picParams->m_phFlags.m_fields.m_phProfDisabledFlag; 1404 params.phJointCbcrSignFlag = picParams->m_phFlags.m_fields.m_phJointCbcrSignFlag; 1405 1406 params.spsChromaFormatIdc = picParams->m_spsChromaFormatIdc; 1407 params.spsLog2CtuSizeMinus5 = picParams->m_spsLog2CtuSizeMinus5; 1408 params.spsBitdepthMinus8 = picParams->m_spsBitdepthMinus8; 1409 params.spsLog2MinLumaCodingBlockSizeMinus2 = picParams->m_spsLog2MinLumaCodingBlockSizeMinus2; 1410 params.spsNumSubpicsMinus1 = picParams->m_spsNumSubpicsMinus1; 1411 1412 params.spsLog2TransformSkipMaxSizeMinus2 = picParams->m_spsLog2TransformSkipMaxSizeMinus2; 1413 params.spsSixMinusMaxNumMergeCand = picParams->m_spsSixMinusMaxNumMergeCand; 1414 params.spsFiveMinusMaxNumSubblockMergeCand = picParams->m_spsFiveMinusMaxNumSubblockMergeCand; 1415 1416 uint8_t maxNumMergeCand = 6 - picParams->m_spsSixMinusMaxNumMergeCand; 1417 if (picParams->m_spsFlags1.m_fields.m_spsGpmEnabledFlag && (maxNumMergeCand >= 3)) 1418 { 1419 params.dMaxNumGpmMergeCand = maxNumMergeCand - picParams->m_spsMaxNumMergeCandMinusMaxNumGpmCand; 1420 } 1421 else if (picParams->m_spsFlags1.m_fields.m_spsGpmEnabledFlag && (maxNumMergeCand == 2)) 1422 { 1423 params.dMaxNumGpmMergeCand = 2; 1424 } 1425 else 1426 { 1427 params.dMaxNumGpmMergeCand = 0; 1428 } 1429 1430 params.spsLog2ParallelMergeLevelMinus2 = picParams->m_spsLog2ParallelMergeLevelMinus2; 1431 params.spsMinQpPrimeTs = picParams->m_spsMinQpPrimeTs; 1432 params.spsSixMinusMaxNumIbcMergeCand = picParams->m_spsSixMinusMaxNumIbcMergeCand; 1433 1434 params.spsLadfQpOffset0 = picParams->m_spsLadfQpOffset[0]; 1435 params.spsLadfQpOffset1 = picParams->m_spsLadfQpOffset[1]; 1436 params.spsLadfQpOffset2 = picParams->m_spsLadfQpOffset[2]; 1437 params.spsLadfQpOffset3 = picParams->m_spsLadfQpOffset[3]; 1438 1439 params.spsLadfDeltaThresholdMinus10 = picParams->m_spsLadfDeltaThresholdMinus1[0]; 1440 params.spsLadfDeltaThresholdMinus11 = picParams->m_spsLadfDeltaThresholdMinus1[1]; 1441 params.spsLadfLowestIntervalQpOffset = picParams->m_spsLadfLowestIntervalQpOffset; 1442 1443 params.spsLadfDeltaThresholdMinus12 = picParams->m_spsLadfDeltaThresholdMinus1[2]; 1444 params.spsLadfDeltaThresholdMinus13 = picParams->m_spsLadfDeltaThresholdMinus1[3]; 1445 params.spsNumLadfIntervalsMinus2 = picParams->m_spsNumLadfIntervalsMinus2; 1446 1447 params.ppsPicWidthInLumaSamples = picParams->m_ppsPicWidthInLumaSamples; 1448 params.ppsPicHeightInLumaSamples = picParams->m_ppsPicHeightInLumaSamples; 1449 1450 params.ppsScalingWinLeftOffset = picParams->m_ppsScalingWinLeftOffset; 1451 params.ppsScalingWinRightOffset = picParams->m_ppsScalingWinRightOffset; 1452 params.ppsScalingWinTopOffset = picParams->m_ppsScalingWinTopOffset; 1453 params.ppsScalingWinBottomOffset = picParams->m_ppsScalingWinBottomOffset; 1454 1455 params.dNumtilerowsminus1 = m_vvcBasicFeature->m_tileRows - 1; 1456 params.dNumtilecolumnsminus1 = m_vvcBasicFeature->m_tileCols - 1; 1457 1458 params.ppsCbQpOffset = picParams->m_ppsCbQpOffset; 1459 params.ppsCrQpOffset = picParams->m_ppsCrQpOffset; 1460 params.ppsJointCbcrQpOffsetValue = picParams->m_ppsJointCbcrQpOffsetValue; 1461 params.ppsChromaQpOffsetListLenMinus1 = picParams->m_ppsFlags.m_fields.m_ppsCuChromaQpOffsetListEnabledFlag ? picParams->m_ppsChromaQpOffsetListLenMinus1 : 0; 1462 1463 params.ppsCbQpOffsetList0 = picParams->m_ppsCbQpOffsetList[0]; 1464 params.ppsCbQpOffsetList1 = picParams->m_ppsCbQpOffsetList[1]; 1465 params.ppsCbQpOffsetList2 = picParams->m_ppsCbQpOffsetList[2]; 1466 params.ppsCbQpOffsetList3 = picParams->m_ppsCbQpOffsetList[3]; 1467 1468 params.ppsCbQpOffsetList4 = picParams->m_ppsCbQpOffsetList[4]; 1469 params.ppsCbQpOffsetList5 = picParams->m_ppsCbQpOffsetList[5]; 1470 params.ppsPicWidthMinusWraparoundOffset = picParams->m_ppsPicWidthMinusWraparoundOffset; 1471 1472 params.ppsCrQpOffsetList0 = picParams->m_ppsCrQpOffsetList[0]; 1473 params.ppsCrQpOffsetList1 = picParams->m_ppsCrQpOffsetList[1]; 1474 params.ppsCrQpOffsetList2 = picParams->m_ppsCrQpOffsetList[2]; 1475 params.ppsCrQpOffsetList3 = picParams->m_ppsCrQpOffsetList[3]; 1476 1477 params.ppsCrQpOffsetList4 = picParams->m_ppsCrQpOffsetList[4]; 1478 params.ppsCrQpOffsetList5 = picParams->m_ppsCrQpOffsetList[5]; 1479 1480 params.ppsJointCbcrQpOffsetList0 = picParams->m_ppsJointCbcrQpOffsetList[0]; 1481 params.ppsJointCbcrQpOffsetList1 = picParams->m_ppsJointCbcrQpOffsetList[1]; 1482 params.ppsJointCbcrQpOffsetList2 = picParams->m_ppsJointCbcrQpOffsetList[2]; 1483 params.ppsJointCbcrQpOffsetList3 = picParams->m_ppsJointCbcrQpOffsetList[3]; 1484 1485 params.ppsJointCbcrQpOffsetList4 = picParams->m_ppsJointCbcrQpOffsetList[4]; 1486 params.ppsJointCbcrQpOffsetList5 = picParams->m_ppsJointCbcrQpOffsetList[5]; 1487 1488 params.numvervirtualboundaries = picParams->m_numVerVirtualBoundaries; 1489 params.numhorvirtualboundaries = picParams->m_numHorVirtualBoundaries; 1490 params.phLog2DiffMinQtMinCbIntraSliceLuma = picParams->m_phLog2DiffMinQtMinCbIntraSliceLuma; 1491 params.phMaxMttHierarchyDepthIntraSliceLuma = picParams->m_phMaxMtt_hierarchyDepthIntraSliceLuma; 1492 params.phLog2DiffMaxBtMinQtIntraSliceLuma = picParams->m_phLog2DiffMaxBtMinQtIntraSliceLuma; 1493 params.phLog2DiffMaxTtMinQtIntraSliceLuma = picParams->m_phLog2DiffMax_ttMinQtIntraSliceLuma; 1494 params.phLog2DiffMinQtMinCbIntraSliceChroma = picParams->m_phLog2DiffMinQtMinCbIntraSliceChroma; 1495 params.phMaxMttHierarchyDepthIntraSliceChroma = picParams->m_phMaxMtt_hierarchyDepthIntraSliceChroma; 1496 1497 params.dVirtualboundaryposxminus10 = (picParams->m_virtualBoundaryPosX[0] >> 3) - 1; 1498 params.dVirtualboundaryposyminus10 = (picParams->m_virtualBoundaryPosY[0] >> 3) - 1; 1499 params.dVirtualboundaryposxminus11 = (picParams->m_virtualBoundaryPosX[1] >> 3) - 1; 1500 params.dVirtualboundaryposyminus11 = (picParams->m_virtualBoundaryPosY[1] >> 3) - 1; 1501 params.dVirtualboundaryposxminus12 = (picParams->m_virtualBoundaryPosX[2] >> 3) - 1; 1502 params.dVirtualboundaryposyminus12 = (picParams->m_virtualBoundaryPosY[2] >> 3) - 1; 1503 1504 params.phLog2DiffMaxBtMinQtIntraSliceChroma = picParams->m_phLog2DiffMaxBtMinQtIntraSliceChroma; 1505 params.phLog2DiffMaxTtMinQtIntraSliceChroma = picParams->m_phLog2DiffMax_ttMinQtIntraSliceChroma; 1506 params.phCuQpDeltaSubdivIntraSlice = picParams->m_phCuQpDeltaSubdivIntraSlice; 1507 params.phCuChromaQpOffsetSubdivIntraSlice = picParams->m_phCuChromaQpOffsetSubdivIntraSlice; 1508 params.phLog2DiffMinQtMinCbInterSlice = picParams->m_phLog2DiffMinQtMinCbInterSlice; 1509 params.phMaxMttHierarchyDepthInterSlice = picParams->m_phMaxMtt_hierarchyDepthInterSlice; 1510 1511 params.phLog2DiffMaxBtMinQtInterSlice = picParams->m_phLog2DiffMaxBtMinQtInterSlice; 1512 params.phLog2DiffMaxTtMinQtInterSlice = picParams->m_phLog2DiffMax_ttMinQtInterSlice; 1513 params.phCuQpDeltaSubdivInterSlice = picParams->m_phCuQpDeltaSubdivInterSlice; 1514 params.phCuChromaQpOffsetSubdivInterSlice = picParams->m_phCuChromaQpOffsetSubdivInterSlice; 1515 1516 // ALF 1517 params.dActiveapsid = m_vvcBasicFeature->m_activeAlfMask; 1518 MOS_ZeroMemory(params.alfApsArray, 8 * sizeof(CodecVvcAlfData)); 1519 MOS_SecureMemcpy(params.alfApsArray, 8 * sizeof(CodecVvcAlfData), m_vvcBasicFeature->m_alfApsArray, 8 * sizeof(CodecVvcAlfData)); 1520 1521 return MOS_STATUS_SUCCESS; 1522 } 1523 MHW_SETPAR_DECL_SRC(VVCP_DPB_STATE,VvcDecodePicPkt)1524 MHW_SETPAR_DECL_SRC(VVCP_DPB_STATE, VvcDecodePicPkt) 1525 { 1526 params = {}; 1527 1528 VvcRefFrameAttributes curFrameAttr; 1529 DECODE_CHK_STATUS(m_vvcBasicFeature->m_refFrames.GetRefAttrByFrameIndex( 1530 m_vvcPicParams->m_currPic.FrameIdx, 1531 &curFrameAttr)); 1532 1533 uint8_t frameIdx = 0; 1534 for (uint8_t i = 0; i < vvcMaxNumRefFrame; i++) 1535 { 1536 if (!m_vvcBasicFeature->m_refFrames.m_curIsIntra) 1537 { 1538 if (m_vvcPicParams->m_refFrameList[i].PicFlags != PICTURE_INVALID) 1539 { 1540 frameIdx = m_vvcPicParams->m_refFrameList[i].FrameIdx; 1541 } 1542 else 1543 { 1544 frameIdx = m_vvcBasicFeature->m_refFrames.GetValidReferenceFrameIdx(); 1545 } 1546 1547 if (frameIdx >= CODEC_MAX_DPB_NUM_VVC) 1548 { 1549 return MOS_STATUS_INVALID_PARAMETER; 1550 } 1551 } 1552 else 1553 { 1554 frameIdx = m_vvcPicParams->m_currPic.FrameIdx; 1555 } 1556 DECODE_CHK_STATUS(m_vvcBasicFeature->m_refFrames.GetRefAttrByFrameIndex( 1557 frameIdx, 1558 ¶ms.refFrameAttr[i])); 1559 1560 params.refPicScaleWidth[i] = ((params.refFrameAttr[i].m_currPicScalWinWidthL << 14) + (curFrameAttr.m_currPicScalWinWidthL >> 1)) / curFrameAttr.m_currPicScalWinWidthL; 1561 params.refPicScaleHeight[i] = ((params.refFrameAttr[i].m_currPicScalWinHeightL << 14) + (curFrameAttr.m_currPicScalWinHeightL >> 1)) / curFrameAttr.m_currPicScalWinHeightL; 1562 } 1563 1564 return MOS_STATUS_SUCCESS; 1565 } 1566 } 1567