1 /* 2 * Copyright (c) 2019-2021, 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_av1_picture_packet_g12_base.cpp 24 //! \brief Defines the interface for g12 av1 decode picture packet 25 //! 26 #include "codechal_utilities.h" 27 #include "decode_av1_picture_packet_g12_base.h" 28 #include "codechal_debug.h" 29 #include "decode_resource_auto_lock.h" 30 31 namespace decode{ ~Av1DecodePicPkt_G12_Base()32 Av1DecodePicPkt_G12_Base::~Av1DecodePicPkt_G12_Base() 33 { 34 FreeResources(); 35 } 36 FreeResources()37 MOS_STATUS Av1DecodePicPkt_G12_Base::FreeResources() 38 { 39 DECODE_FUNC_CALL(); 40 41 if (m_allocator != nullptr) 42 { 43 m_allocator->Destroy(m_intrabcDecodedOutputFrameBuffer); 44 if (!m_avpInterface->IsBtdlRowstoreCacheEnabled()) 45 { 46 m_allocator->Destroy(m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer); 47 } 48 m_allocator->Destroy(m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer); 49 if (!m_avpInterface->IsIpdlRowstoreCacheEnabled()) 50 { 51 m_allocator->Destroy(m_intraPredictionLineRowstoreReadWriteBuffer); 52 } 53 m_allocator->Destroy(m_intraPredictionTileLineRowstoreReadWriteBuffer); 54 if (!m_avpInterface->IsSmvlRowstoreCacheEnabled()) 55 { 56 m_allocator->Destroy(m_spatialMotionVectorLineReadWriteBuffer); 57 } 58 m_allocator->Destroy(m_spatialMotionVectorCodingTileLineReadWriteBuffer); 59 m_allocator->Destroy(m_loopRestorationMetaTileColumnReadWriteBuffer); 60 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineYBuffer); 61 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineUBuffer); 62 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineVBuffer); 63 if (!m_avpInterface->IsDflyRowstoreCacheEnabled()) 64 { 65 m_allocator->Destroy(m_deblockerFilterLineReadWriteYBuffer); 66 } 67 if (!m_avpInterface->IsDfluRowstoreCacheEnabled()) 68 { 69 m_allocator->Destroy(m_deblockerFilterLineReadWriteUBuffer); 70 } 71 if (!m_avpInterface->IsDflvRowstoreCacheEnabled()) 72 { 73 m_allocator->Destroy(m_deblockerFilterLineReadWriteVBuffer); 74 } 75 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteYBuffer); 76 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteVBuffer); 77 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteUBuffer); 78 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteYBuffer); 79 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteUBuffer); 80 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteVBuffer); 81 if (!m_avpInterface->IsCdefRowstoreCacheEnabled()) 82 { 83 m_allocator->Destroy(m_cdefFilterLineReadWriteBuffer); 84 } 85 m_allocator->Destroy(m_cdefFilterTileLineReadWriteBuffer); 86 m_allocator->Destroy(m_cdefFilterTileColumnReadWriteBuffer); 87 m_allocator->Destroy(m_cdefFilterMetaTileLineReadWriteBuffer); 88 m_allocator->Destroy(m_cdefFilterMetaTileColumnReadWriteBuffer); 89 m_allocator->Destroy(m_cdefFilterTopLeftCornerReadWriteBuffer); 90 m_allocator->Destroy(m_superResTileColumnReadWriteYBuffer); 91 m_allocator->Destroy(m_superResTileColumnReadWriteUBuffer); 92 m_allocator->Destroy(m_superResTileColumnReadWriteVBuffer); 93 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteYBuffer); 94 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteUBuffer); 95 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteVBuffer); 96 m_allocator->Destroy(m_decodedFrameStatusErrorBuffer); 97 m_allocator->Destroy(m_decodedBlockDataStreamoutBuffer); 98 m_allocator->Destroy(m_curMvBufferForDummyWL); 99 m_allocator->Destroy(m_bwdAdaptCdfBufForDummyWL); 100 m_allocator->Destroy(m_resDataBufferForDummyWL); 101 } 102 103 return MOS_STATUS_SUCCESS; 104 } 105 Init()106 MOS_STATUS Av1DecodePicPkt_G12_Base::Init() 107 { 108 DECODE_FUNC_CALL(); 109 110 DECODE_CHK_NULL(m_featureManager); 111 DECODE_CHK_NULL(m_hwInterface); 112 DECODE_CHK_NULL(m_osInterface); 113 DECODE_CHK_NULL(m_miInterface); 114 DECODE_CHK_NULL(m_av1Pipeline); 115 DECODE_CHK_NULL(m_avpInterface); 116 117 m_av1BasicFeature = dynamic_cast<Av1BasicFeatureG12*>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 118 DECODE_CHK_NULL(m_av1BasicFeature); 119 120 m_allocator = m_pipeline ->GetDecodeAllocator(); 121 DECODE_CHK_NULL(m_allocator); 122 123 DECODE_CHK_STATUS(AllocateFixedResources()); 124 125 return MOS_STATUS_SUCCESS; 126 } 127 Prepare()128 MOS_STATUS Av1DecodePicPkt_G12_Base::Prepare() 129 { 130 DECODE_FUNC_CALL(); 131 132 m_av1PicParams = m_av1BasicFeature->m_av1PicParams; 133 134 if (m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingX == 1 && m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingY == 1) 135 { 136 chromaSamplingFormat = HCP_CHROMA_FORMAT_YUV420;//Use HCP definitions here, since AVP and HCP will merge together in the future 137 } 138 else if (m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingX == 0 && m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingY == 0) 139 { 140 chromaSamplingFormat = HCP_CHROMA_FORMAT_YUV444; 141 } 142 else 143 { 144 DECODE_ASSERTMESSAGE("Invalid Chroma sampling format!"); 145 return MOS_STATUS_INVALID_PARAMETER; 146 } 147 148 #ifdef _MMC_SUPPORTED 149 m_mmcState = m_av1Pipeline->GetMmcState(); 150 DECODE_CHK_NULL(m_mmcState); 151 #endif 152 153 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 154 155 DECODE_CHK_STATUS(AllocateVariableResources()); 156 157 return MOS_STATUS_SUCCESS; 158 } 159 SetRowstoreCachingOffsets()160 MOS_STATUS Av1DecodePicPkt_G12_Base::SetRowstoreCachingOffsets() 161 { 162 if (m_avpInterface->IsRowStoreCachingSupported() && 163 (m_av1BasicFeature->m_frameWidthAlignedMinBlk != MOS_ALIGN_CEIL(m_prevFrmWidth, av1MinBlockWidth))) 164 { 165 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams; 166 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams)); 167 rowstoreParams.dwPicWidth = m_av1BasicFeature->m_frameWidthAlignedMinBlk; 168 rowstoreParams.bMbaff = false; 169 rowstoreParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 170 rowstoreParams.ucBitDepthMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 171 rowstoreParams.ucChromaFormat = m_av1BasicFeature->m_chromaFormat; 172 DECODE_CHK_STATUS(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams)); 173 } 174 175 return MOS_STATUS_SUCCESS; 176 } 177 AllocateFixedResources()178 MOS_STATUS Av1DecodePicPkt_G12_Base::AllocateFixedResources() 179 { 180 DECODE_FUNC_CALL(); 181 182 if (m_av1BasicFeature->m_usingDummyWl == true) 183 { 184 MhwVdboxAvpBufferSizeParams avpBufSizeParam; 185 MOS_ZeroMemory(&avpBufSizeParam, sizeof(avpBufSizeParam)); 186 187 avpBufSizeParam.m_bitDepthIdc = 0; 188 avpBufSizeParam.m_picWidth = 1; 189 avpBufSizeParam.m_picHeight = 1; 190 avpBufSizeParam.m_tileWidth = 16; 191 avpBufSizeParam.m_isSb128x128 = false; 192 avpBufSizeParam.m_curFrameTileNum = 1; 193 avpBufSizeParam.m_numTileCol = 1; 194 195 if (m_avpInterface->GetAv1BufferSize(mvTemporalBuf, 196 &avpBufSizeParam) != MOS_STATUS_SUCCESS) 197 { 198 DECODE_ASSERTMESSAGE( "Failed to get MvTemporalBuffer size."); 199 } 200 m_curMvBufferForDummyWL = m_allocator->AllocateBuffer(avpBufSizeParam.m_bufferSize, "MvBuffer", 201 resourceInternalReadWriteCache, notLockableVideoMem); 202 DECODE_CHK_NULL(m_curMvBufferForDummyWL); 203 204 m_bwdAdaptCdfBufForDummyWL = m_allocator->AllocateBuffer( 205 MOS_ALIGN_CEIL(m_av1BasicFeature->m_cdfMaxNumBytes, CODECHAL_PAGE_SIZE), "CdfTableBuffer", 206 resourceInternalReadWriteCache, notLockableVideoMem); 207 DECODE_CHK_NULL(m_bwdAdaptCdfBufForDummyWL); 208 } 209 210 return MOS_STATUS_SUCCESS; 211 } 212 AllocateVariableResources()213 MOS_STATUS Av1DecodePicPkt_G12_Base::AllocateVariableResources() 214 { 215 DECODE_FUNC_CALL(); 216 217 int32_t mibSizeLog2 = m_av1PicParams->m_seqInfoFlags.m_fields.m_use128x128Superblock ? av1MaxMibSizeLog2 : av1MinMibSizeLog2; 218 int32_t miCols = MOS_ALIGN_CEIL(m_av1PicParams->m_superResUpscaledWidthMinus1 + 1, 8) >> av1MiSizeLog2; 219 int32_t miRows = MOS_ALIGN_CEIL(m_av1PicParams->m_superResUpscaledHeightMinus1 + 1, 8) >> av1MiSizeLog2; 220 miCols = MOS_ALIGN_CEIL(miCols, 1 << mibSizeLog2); 221 miRows = MOS_ALIGN_CEIL(miRows, 1 << mibSizeLog2); 222 223 m_widthInSb = miCols >> mibSizeLog2; 224 m_heightInSb = miRows >> mibSizeLog2; 225 uint32_t maxTileWidthInSb = MOS_ROUNDUP_DIVIDE(4096, 1 << (mibSizeLog2 + av1MiSizeLog2)); 226 MhwVdboxAvpBufferSizeParams avpBufSizeParam; 227 MOS_ZeroMemory(&avpBufSizeParam, sizeof(avpBufSizeParam)); 228 229 avpBufSizeParam.m_bitDepthIdc = m_av1BasicFeature->m_av1DepthIndicator; 230 avpBufSizeParam.m_picWidth = m_widthInSb; 231 avpBufSizeParam.m_picHeight = m_heightInSb; 232 avpBufSizeParam.m_tileWidth = maxTileWidthInSb; 233 avpBufSizeParam.m_isSb128x128 = m_av1PicParams->m_seqInfoFlags.m_fields.m_use128x128Superblock ? true : false; 234 avpBufSizeParam.m_curFrameTileNum = m_av1PicParams->m_tileCols * m_av1PicParams->m_tileRows; 235 avpBufSizeParam.m_numTileCol = m_av1PicParams->m_tileCols; 236 237 // Intrabc Decoded Output Frame Buffer 238 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 239 { 240 MOS_SURFACE m_destSurface = m_av1BasicFeature->m_destSurface; 241 if (m_intrabcDecodedOutputFrameBuffer == nullptr) 242 { 243 PMOS_SURFACE surface = nullptr; 244 surface = m_allocator->AllocateSurface( 245 m_destSurface.dwWidth, 246 MOS_ALIGN_CEIL(m_destSurface.dwHeight, 8), 247 "Intrabc Decoded Output Frame Buffer", 248 m_destSurface.Format, 249 m_destSurface.bCompressible, 250 resourceInternalReadWriteNoCache, 251 notLockableVideoMem); 252 253 m_intrabcDecodedOutputFrameBuffer = surface; 254 DECODE_CHK_NULL(m_intrabcDecodedOutputFrameBuffer); 255 } 256 else 257 { 258 DECODE_CHK_STATUS(m_allocator->Resize( 259 m_intrabcDecodedOutputFrameBuffer, 260 m_destSurface.dwWidth, 261 MOS_ALIGN_CEIL(m_destSurface.dwHeight, 8), 262 notLockableVideoMem)); 263 } 264 } 265 266 // Bitstream decode line rowstore buffer 267 if (!m_avpInterface->IsBtdlRowstoreCacheEnabled()) 268 { 269 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 270 bsdLineBuf, 271 &avpBufSizeParam)); 272 if (m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer == nullptr) 273 { 274 m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer = m_allocator->AllocateBuffer( 275 avpBufSizeParam.m_bufferSize, 276 "BitstreamDecodeLineBuffer", 277 resourceInternalReadWriteCache, 278 notLockableVideoMem); 279 DECODE_CHK_NULL(m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer); 280 } 281 else 282 { 283 DECODE_CHK_STATUS(m_allocator->Resize( 284 m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer, 285 avpBufSizeParam.m_bufferSize, 286 notLockableVideoMem)); 287 } 288 } 289 290 // Bitstream decode tile line buffer 291 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 292 bsdTileLineBuf, 293 &avpBufSizeParam)); 294 if (m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer == nullptr) 295 { 296 m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer = m_allocator->AllocateBuffer( 297 avpBufSizeParam.m_bufferSize, 298 "BitstreamDecodeTileLineBuffer", 299 resourceInternalReadWriteCache, 300 notLockableVideoMem); 301 DECODE_CHK_NULL(m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer); 302 } 303 else 304 { 305 DECODE_CHK_STATUS(m_allocator->Resize( 306 m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer, 307 avpBufSizeParam.m_bufferSize, 308 notLockableVideoMem)); 309 } 310 311 // Intra Prediction Line Rowstore Read/Write Buffer 312 if (!m_avpInterface->IsIpdlRowstoreCacheEnabled()) 313 { 314 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 315 intraPredLine, 316 &avpBufSizeParam)); 317 if (m_intraPredictionLineRowstoreReadWriteBuffer == nullptr) 318 { 319 m_intraPredictionLineRowstoreReadWriteBuffer = m_allocator->AllocateBuffer( 320 avpBufSizeParam.m_bufferSize, 321 "intraPredictionLineRowstoreBuffer", 322 resourceInternalReadWriteCache, 323 notLockableVideoMem); 324 DECODE_CHK_NULL(m_intraPredictionLineRowstoreReadWriteBuffer); 325 } 326 else 327 { 328 DECODE_CHK_STATUS(m_allocator->Resize( 329 m_intraPredictionLineRowstoreReadWriteBuffer, 330 avpBufSizeParam.m_bufferSize, 331 notLockableVideoMem)); 332 } 333 } 334 335 // Intra Prediction Tile Line Rowstore Read/Write Buffer 336 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 337 intraPredTileLine, 338 &avpBufSizeParam)); 339 if (m_intraPredictionTileLineRowstoreReadWriteBuffer == nullptr) 340 { 341 m_intraPredictionTileLineRowstoreReadWriteBuffer = m_allocator->AllocateBuffer( 342 avpBufSizeParam.m_bufferSize, 343 "intraPredictionTileLineRowstoreBuffer", 344 resourceInternalReadWriteCache, 345 notLockableVideoMem); 346 DECODE_CHK_NULL(m_intraPredictionTileLineRowstoreReadWriteBuffer); 347 } 348 else 349 { 350 DECODE_CHK_STATUS(m_allocator->Resize( 351 m_intraPredictionTileLineRowstoreReadWriteBuffer, 352 avpBufSizeParam.m_bufferSize, 353 notLockableVideoMem)); 354 } 355 356 // Spatial motion vector Line rowstore buffer 357 if (!m_avpInterface->IsSmvlRowstoreCacheEnabled()) 358 { 359 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 360 spatialMvLineBuf, 361 &avpBufSizeParam)); 362 if (m_spatialMotionVectorLineReadWriteBuffer == nullptr) 363 { 364 m_spatialMotionVectorLineReadWriteBuffer = m_allocator->AllocateBuffer( 365 avpBufSizeParam.m_bufferSize, 366 "SpatialMotionVectorLineRowstoreBuffer", 367 resourceInternalReadWriteCache, 368 notLockableVideoMem); 369 DECODE_CHK_NULL(m_spatialMotionVectorLineReadWriteBuffer); 370 } 371 else 372 { 373 DECODE_CHK_STATUS(m_allocator->Resize( 374 m_spatialMotionVectorLineReadWriteBuffer, 375 avpBufSizeParam.m_bufferSize, 376 notLockableVideoMem)); 377 } 378 } 379 380 // Spatial motion vector Tile Line Buffer 381 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 382 spatialMvTileLineBuf, 383 &avpBufSizeParam)); 384 385 if (m_spatialMotionVectorCodingTileLineReadWriteBuffer == nullptr) 386 { 387 m_spatialMotionVectorCodingTileLineReadWriteBuffer = m_allocator->AllocateBuffer( 388 avpBufSizeParam.m_bufferSize, 389 "SpatialMotionVectorTileLineBuffer", 390 resourceInternalReadWriteCache, 391 notLockableVideoMem); 392 DECODE_CHK_NULL(m_spatialMotionVectorCodingTileLineReadWriteBuffer); 393 } 394 else 395 { 396 DECODE_CHK_STATUS(m_allocator->Resize( 397 m_spatialMotionVectorCodingTileLineReadWriteBuffer, 398 avpBufSizeParam.m_bufferSize, 399 notLockableVideoMem)); 400 } 401 402 // Loop Restoration Meta Tile Column Read/Write Buffer 403 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 404 lrMetaTileCol, 405 &avpBufSizeParam)); 406 if (m_loopRestorationMetaTileColumnReadWriteBuffer == nullptr) 407 { 408 m_loopRestorationMetaTileColumnReadWriteBuffer = m_allocator->AllocateBuffer( 409 avpBufSizeParam.m_bufferSize, 410 "LoopRestorationMetaTileColumnReadWriteBuffer", 411 resourceInternalReadWriteCache, 412 notLockableVideoMem); 413 DECODE_CHK_NULL(m_loopRestorationMetaTileColumnReadWriteBuffer); 414 } 415 else 416 { 417 DECODE_CHK_STATUS(m_allocator->Resize( 418 m_loopRestorationMetaTileColumnReadWriteBuffer, 419 avpBufSizeParam.m_bufferSize, 420 notLockableVideoMem)); 421 } 422 423 // Loop Restoration Filter Tile Read/Write Line Y Buffer 424 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 425 lrTileLineY, 426 &avpBufSizeParam)); 427 if (m_loopRestorationFilterTileReadWriteLineYBuffer == nullptr) 428 { 429 m_loopRestorationFilterTileReadWriteLineYBuffer = m_allocator->AllocateBuffer( 430 avpBufSizeParam.m_bufferSize, 431 "LoopRestorationFilterTileReadWriteLineYBuffer", 432 resourceInternalReadWriteCache, 433 notLockableVideoMem); 434 DECODE_CHK_NULL(m_loopRestorationFilterTileReadWriteLineYBuffer); 435 } 436 else 437 { 438 DECODE_CHK_STATUS(m_allocator->Resize( 439 m_loopRestorationFilterTileReadWriteLineYBuffer, 440 avpBufSizeParam.m_bufferSize, 441 notLockableVideoMem)); 442 } 443 444 //Loop Restoration Filter Tile Read/Write Line U Buffer 445 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 446 lrTileLineU, 447 &avpBufSizeParam)); 448 if (m_loopRestorationFilterTileReadWriteLineUBuffer == nullptr) 449 { 450 m_loopRestorationFilterTileReadWriteLineUBuffer = m_allocator->AllocateBuffer( 451 avpBufSizeParam.m_bufferSize, 452 "LoopRestorationFilterTileReadWriteLineUBuffer", 453 resourceInternalReadWriteCache, 454 notLockableVideoMem); 455 DECODE_CHK_NULL(m_loopRestorationFilterTileReadWriteLineUBuffer); 456 } 457 else 458 { 459 DECODE_CHK_STATUS(m_allocator->Resize( 460 m_loopRestorationFilterTileReadWriteLineUBuffer, 461 avpBufSizeParam.m_bufferSize, 462 notLockableVideoMem)); 463 } 464 465 // Loop Restoration Filter Tile Read/Write Line V Buffer 466 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 467 lrTileLineV, 468 &avpBufSizeParam)); 469 if (m_loopRestorationFilterTileReadWriteLineVBuffer == nullptr) 470 { 471 m_loopRestorationFilterTileReadWriteLineVBuffer = m_allocator->AllocateBuffer( 472 avpBufSizeParam.m_bufferSize, 473 "LoopRestorationFilterTileReadWriteLineVBuffer", 474 resourceInternalReadWriteCache, 475 notLockableVideoMem); 476 DECODE_CHK_NULL(m_loopRestorationFilterTileReadWriteLineVBuffer); 477 } 478 else 479 { 480 DECODE_CHK_STATUS(m_allocator->Resize( 481 m_loopRestorationFilterTileReadWriteLineVBuffer, 482 avpBufSizeParam.m_bufferSize, 483 notLockableVideoMem)); 484 } 485 486 if (!m_avpInterface->IsDflyRowstoreCacheEnabled()) 487 { 488 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 489 deblockLineYBuf, 490 &avpBufSizeParam)); 491 492 if (m_deblockerFilterLineReadWriteYBuffer == nullptr) 493 { 494 m_deblockerFilterLineReadWriteYBuffer = m_allocator->AllocateBuffer( 495 avpBufSizeParam.m_bufferSize, 496 "DeblockerFilterLineReadWriteYBuffer", 497 resourceInternalReadWriteCache, 498 notLockableVideoMem); 499 DECODE_CHK_NULL(m_deblockerFilterLineReadWriteYBuffer); 500 } 501 else 502 { 503 DECODE_CHK_STATUS(m_allocator->Resize( 504 m_deblockerFilterLineReadWriteYBuffer, 505 avpBufSizeParam.m_bufferSize, 506 notLockableVideoMem)); 507 } 508 } 509 510 if (!m_avpInterface->IsDfluRowstoreCacheEnabled()) 511 { 512 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 513 deblockLineUBuf, 514 &avpBufSizeParam)); 515 if (m_deblockerFilterLineReadWriteUBuffer == nullptr) 516 { 517 m_deblockerFilterLineReadWriteUBuffer = m_allocator->AllocateBuffer( 518 avpBufSizeParam.m_bufferSize, 519 "DeblockerFilterLineReadWriteUBuffer", 520 resourceInternalReadWriteCache, 521 notLockableVideoMem); 522 DECODE_CHK_NULL(m_deblockerFilterLineReadWriteUBuffer); 523 } 524 else 525 { 526 DECODE_CHK_STATUS(m_allocator->Resize( 527 m_deblockerFilterLineReadWriteUBuffer, 528 avpBufSizeParam.m_bufferSize, 529 notLockableVideoMem)); 530 } 531 } 532 533 if (!m_avpInterface->IsDflvRowstoreCacheEnabled()) 534 { 535 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 536 deblockLineVBuf, 537 &avpBufSizeParam)); 538 if (m_deblockerFilterLineReadWriteVBuffer == nullptr) 539 { 540 m_deblockerFilterLineReadWriteVBuffer = m_allocator->AllocateBuffer( 541 avpBufSizeParam.m_bufferSize, 542 "DeblockerFilterLineReadWriteVBuffer", 543 resourceInternalReadWriteCache, 544 notLockableVideoMem); 545 DECODE_CHK_NULL(m_deblockerFilterLineReadWriteVBuffer); 546 } 547 else 548 { 549 DECODE_CHK_STATUS(m_allocator->Resize( 550 m_deblockerFilterLineReadWriteVBuffer, 551 avpBufSizeParam.m_bufferSize, 552 notLockableVideoMem)); 553 } 554 } 555 556 // Deblocking Filter Tile Line Y Buffer 557 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 558 deblockTileLineYBuf, 559 &avpBufSizeParam)); 560 561 if (m_deblockerFilterTileLineReadWriteYBuffer == nullptr) 562 { 563 m_deblockerFilterTileLineReadWriteYBuffer = m_allocator->AllocateBuffer( 564 avpBufSizeParam.m_bufferSize, 565 "DeblockerFilterTileLineReadWriteYBuffer", 566 resourceInternalReadWriteCache, 567 notLockableVideoMem); 568 DECODE_CHK_NULL(m_deblockerFilterTileLineReadWriteYBuffer); 569 } 570 else 571 { 572 DECODE_CHK_STATUS(m_allocator->Resize( 573 m_deblockerFilterTileLineReadWriteYBuffer, 574 avpBufSizeParam.m_bufferSize, 575 notLockableVideoMem)); 576 } 577 578 // Deblocking Filter Tile Line V Buffer 579 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 580 deblockTileLineVBuf, 581 &avpBufSizeParam)); 582 583 if (m_deblockerFilterTileLineReadWriteVBuffer == nullptr) 584 { 585 m_deblockerFilterTileLineReadWriteVBuffer = m_allocator->AllocateBuffer( 586 avpBufSizeParam.m_bufferSize, 587 "DeblockerFilterTileLineReadWriteVBuffer", 588 resourceInternalReadWriteCache, 589 notLockableVideoMem); 590 DECODE_CHK_NULL(m_deblockerFilterTileLineReadWriteVBuffer); 591 } 592 else 593 { 594 DECODE_CHK_STATUS(m_allocator->Resize( 595 m_deblockerFilterTileLineReadWriteVBuffer, 596 avpBufSizeParam.m_bufferSize, 597 notLockableVideoMem)); 598 } 599 600 // Deblocking Filter Tile Line U Buffer 601 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 602 deblockTileLineUBuf, 603 &avpBufSizeParam)); 604 605 if (m_deblockerFilterTileLineReadWriteUBuffer == nullptr) 606 { 607 m_deblockerFilterTileLineReadWriteUBuffer = m_allocator->AllocateBuffer( 608 avpBufSizeParam.m_bufferSize, 609 "DeblockerFilterTileLineReadWriteUBuffer", 610 resourceInternalReadWriteCache, 611 notLockableVideoMem); 612 DECODE_CHK_NULL(m_deblockerFilterTileLineReadWriteUBuffer); 613 } 614 else 615 { 616 DECODE_CHK_STATUS(m_allocator->Resize( 617 m_deblockerFilterTileLineReadWriteUBuffer, 618 avpBufSizeParam.m_bufferSize, 619 notLockableVideoMem)); 620 } 621 622 // Deblocking Filter Tile Column Y Buffer 623 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 624 deblockTileColYBuf, 625 &avpBufSizeParam)); 626 627 if (m_deblockerFilterTileColumnReadWriteYBuffer == nullptr) 628 { 629 m_deblockerFilterTileColumnReadWriteYBuffer = m_allocator->AllocateBuffer( 630 avpBufSizeParam.m_bufferSize, 631 "DeblockerFilterTileColumnReadWriteYBuffer", 632 resourceInternalReadWriteCache, 633 notLockableVideoMem); 634 DECODE_CHK_NULL(m_deblockerFilterTileColumnReadWriteYBuffer); 635 } 636 else 637 { 638 DECODE_CHK_STATUS(m_allocator->Resize( 639 m_deblockerFilterTileColumnReadWriteYBuffer, 640 avpBufSizeParam.m_bufferSize, 641 notLockableVideoMem)); 642 } 643 644 // Deblocking Filter Tile Column U Buffer 645 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 646 deblockTileColUBuf, 647 &avpBufSizeParam)); 648 649 if (m_deblockerFilterTileColumnReadWriteUBuffer == nullptr) 650 { 651 m_deblockerFilterTileColumnReadWriteUBuffer = m_allocator->AllocateBuffer( 652 avpBufSizeParam.m_bufferSize, 653 "DeblockerFilterTileColumnReadWriteUBuffer", 654 resourceInternalReadWriteCache, 655 notLockableVideoMem); 656 DECODE_CHK_NULL(m_deblockerFilterTileColumnReadWriteUBuffer); 657 } 658 else 659 { 660 DECODE_CHK_STATUS(m_allocator->Resize( 661 m_deblockerFilterTileColumnReadWriteUBuffer, 662 avpBufSizeParam.m_bufferSize, 663 notLockableVideoMem)); 664 } 665 666 // Deblocking Filter Tile Column V Buffer 667 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 668 deblockTileColVBuf, 669 &avpBufSizeParam)); 670 671 if (m_deblockerFilterTileColumnReadWriteVBuffer == nullptr) 672 { 673 m_deblockerFilterTileColumnReadWriteVBuffer = m_allocator->AllocateBuffer( 674 avpBufSizeParam.m_bufferSize, 675 "DeblockerFilterTileColumnReadWriteVBuffer", 676 resourceInternalReadWriteCache, 677 notLockableVideoMem); 678 DECODE_CHK_NULL(m_deblockerFilterTileColumnReadWriteVBuffer); 679 } 680 else 681 { 682 DECODE_CHK_STATUS(m_allocator->Resize( 683 m_deblockerFilterTileColumnReadWriteVBuffer, 684 avpBufSizeParam.m_bufferSize, 685 notLockableVideoMem)); 686 } 687 688 // CDEF Filter Line Read/Write Buffer 689 if (!m_avpInterface->IsCdefRowstoreCacheEnabled()) 690 { 691 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 692 cdefLineBuf, 693 &avpBufSizeParam)); 694 if (m_cdefFilterLineReadWriteBuffer == nullptr) 695 { 696 m_cdefFilterLineReadWriteBuffer = m_allocator->AllocateBuffer( 697 avpBufSizeParam.m_bufferSize, 698 "CdefFilterLineReadWriteBuffer", 699 resourceInternalReadWriteCache, 700 notLockableVideoMem); 701 DECODE_CHK_NULL(m_cdefFilterLineReadWriteBuffer); 702 } 703 else 704 { 705 DECODE_CHK_STATUS(m_allocator->Resize( 706 m_cdefFilterLineReadWriteBuffer, 707 avpBufSizeParam.m_bufferSize, 708 notLockableVideoMem)); 709 } 710 } 711 712 // CDEF Filter Tile Line Read/Write Buffer 713 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 714 cdefTileLineBuf, 715 &avpBufSizeParam)); 716 if (m_cdefFilterTileLineReadWriteBuffer == nullptr) 717 { 718 m_cdefFilterTileLineReadWriteBuffer = m_allocator->AllocateBuffer( 719 avpBufSizeParam.m_bufferSize, 720 "CdefFilterTileLineReadWriteBuffer", 721 resourceInternalReadWriteCache, 722 notLockableVideoMem); 723 DECODE_CHK_NULL(m_cdefFilterTileLineReadWriteBuffer); 724 } 725 else 726 { 727 DECODE_CHK_STATUS(m_allocator->Resize( 728 m_cdefFilterTileLineReadWriteBuffer, 729 avpBufSizeParam.m_bufferSize, 730 notLockableVideoMem)); 731 } 732 733 // CDEF Filter Tile Column Read/Write Buffer 734 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 735 cdefTileColBuf, 736 &avpBufSizeParam)); 737 if (m_cdefFilterTileColumnReadWriteBuffer == nullptr) 738 { 739 m_cdefFilterTileColumnReadWriteBuffer = m_allocator->AllocateBuffer( 740 avpBufSizeParam.m_bufferSize, 741 "CdefFilterTileColumnReadWriteBuffer", 742 resourceInternalReadWriteCache, 743 notLockableVideoMem); 744 DECODE_CHK_NULL(m_cdefFilterTileColumnReadWriteBuffer); 745 } 746 else 747 { 748 DECODE_CHK_STATUS(m_allocator->Resize( 749 m_cdefFilterTileColumnReadWriteBuffer, 750 avpBufSizeParam.m_bufferSize, 751 notLockableVideoMem)); 752 } 753 754 // CDEF Filter Meta Tile Line Read Write Buffer 755 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 756 cdefMetaTileLine, 757 &avpBufSizeParam)); 758 if (m_cdefFilterMetaTileLineReadWriteBuffer == nullptr) 759 { 760 m_cdefFilterMetaTileLineReadWriteBuffer = m_allocator->AllocateBuffer( 761 avpBufSizeParam.m_bufferSize, 762 "CdefFilterMetaTileLineReadWriteBuffer", 763 resourceInternalReadWriteCache, 764 notLockableVideoMem); 765 DECODE_CHK_NULL(m_cdefFilterMetaTileLineReadWriteBuffer); 766 } 767 else 768 { 769 DECODE_CHK_STATUS(m_allocator->Resize( 770 m_cdefFilterMetaTileLineReadWriteBuffer, 771 avpBufSizeParam.m_bufferSize, 772 notLockableVideoMem)); 773 } 774 775 // CDEF Filter Meta Tile Column Read Write Buffer 776 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 777 cdefMetaTileCol, 778 &avpBufSizeParam)); 779 if (m_cdefFilterMetaTileColumnReadWriteBuffer == nullptr) 780 { 781 m_cdefFilterMetaTileColumnReadWriteBuffer = m_allocator->AllocateBuffer( 782 avpBufSizeParam.m_bufferSize, 783 "CdefFilterMetaTileColumnReadWriteBuffer", 784 resourceInternalReadWriteCache, 785 notLockableVideoMem); 786 DECODE_CHK_NULL(m_cdefFilterMetaTileColumnReadWriteBuffer); 787 } 788 else 789 { 790 DECODE_CHK_STATUS(m_allocator->Resize( 791 m_cdefFilterMetaTileColumnReadWriteBuffer, 792 avpBufSizeParam.m_bufferSize, 793 notLockableVideoMem)); 794 } 795 796 // Cdef Filter Top Left Corner Buffer 797 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 798 cdefTopLeftCornerBuf, 799 &avpBufSizeParam)); 800 801 if (m_cdefFilterTopLeftCornerReadWriteBuffer == nullptr) 802 { 803 m_cdefFilterTopLeftCornerReadWriteBuffer = m_allocator->AllocateBuffer( 804 avpBufSizeParam.m_bufferSize, 805 "CdefFilterTopLeftCornerReadWriteBuffer", 806 resourceInternalReadWriteCache, 807 notLockableVideoMem); 808 DECODE_CHK_NULL(m_cdefFilterTopLeftCornerReadWriteBuffer); 809 } 810 else 811 { 812 DECODE_CHK_STATUS(m_allocator->Resize( 813 m_cdefFilterTopLeftCornerReadWriteBuffer, 814 avpBufSizeParam.m_bufferSize, 815 notLockableVideoMem)); 816 } 817 818 // Super-Res Tile Column Y Buffer 819 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 820 superResTileColYBuf, 821 &avpBufSizeParam)); 822 if (m_superResTileColumnReadWriteYBuffer == nullptr) 823 { 824 m_superResTileColumnReadWriteYBuffer = m_allocator->AllocateBuffer( 825 avpBufSizeParam.m_bufferSize, 826 "SuperResTileColumnReadWriteYBuffer", 827 resourceInternalReadWriteCache, 828 notLockableVideoMem); 829 DECODE_CHK_NULL(m_superResTileColumnReadWriteYBuffer); 830 } 831 else 832 { 833 DECODE_CHK_STATUS(m_allocator->Resize( 834 m_superResTileColumnReadWriteYBuffer, 835 avpBufSizeParam.m_bufferSize, 836 notLockableVideoMem)); 837 } 838 839 // Super-Res Tile Column U Buffer 840 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 841 superResTileColUBuf, 842 &avpBufSizeParam)); 843 844 if (m_superResTileColumnReadWriteUBuffer == nullptr) 845 { 846 m_superResTileColumnReadWriteUBuffer = m_allocator->AllocateBuffer( 847 avpBufSizeParam.m_bufferSize, 848 "SuperResTileColumnReadWriteUBuffer", 849 resourceInternalReadWriteCache, 850 notLockableVideoMem); 851 DECODE_CHK_NULL(m_superResTileColumnReadWriteUBuffer); 852 } 853 else 854 { 855 DECODE_CHK_STATUS(m_allocator->Resize( 856 m_superResTileColumnReadWriteUBuffer, 857 avpBufSizeParam.m_bufferSize, 858 notLockableVideoMem)); 859 } 860 861 // Super-Res Tile Column V Buffer 862 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 863 superResTileColVBuf, 864 &avpBufSizeParam)); 865 866 if (m_superResTileColumnReadWriteVBuffer == nullptr) 867 { 868 m_superResTileColumnReadWriteVBuffer = m_allocator->AllocateBuffer( 869 avpBufSizeParam.m_bufferSize, 870 "SuperResTileColumnReadWriteVBuffer", 871 resourceInternalReadWriteCache, 872 notLockableVideoMem); 873 DECODE_CHK_NULL(m_superResTileColumnReadWriteVBuffer); 874 } 875 else 876 { 877 DECODE_CHK_STATUS(m_allocator->Resize( 878 m_superResTileColumnReadWriteVBuffer, 879 avpBufSizeParam.m_bufferSize, 880 notLockableVideoMem)); 881 } 882 883 // Loop Restoration Filter Tile Column Y Buffer 884 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 885 lrTileColYBuf, 886 &avpBufSizeParam)); 887 888 if (m_loopRestorationFilterTileColumnReadWriteYBuffer == nullptr) 889 { 890 m_loopRestorationFilterTileColumnReadWriteYBuffer = m_allocator->AllocateBuffer( 891 avpBufSizeParam.m_bufferSize, 892 "LoopRestorationFilterTileColumnReadWriteYBuffer", 893 resourceInternalReadWriteCache, 894 notLockableVideoMem); 895 DECODE_CHK_NULL(m_loopRestorationFilterTileColumnReadWriteYBuffer); 896 } 897 else 898 { 899 DECODE_CHK_STATUS(m_allocator->Resize( 900 m_loopRestorationFilterTileColumnReadWriteYBuffer, 901 avpBufSizeParam.m_bufferSize, 902 notLockableVideoMem)); 903 } 904 905 // Loop Restoration Filter Tile Column U Buffer 906 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 907 lrTileColUBuf, 908 &avpBufSizeParam)); 909 910 if (m_loopRestorationFilterTileColumnReadWriteUBuffer == nullptr) 911 { 912 m_loopRestorationFilterTileColumnReadWriteUBuffer = m_allocator->AllocateBuffer( 913 avpBufSizeParam.m_bufferSize, 914 "LoopRestorationFilterTileColumnReadWriteUBuffer", 915 resourceInternalReadWriteCache, 916 notLockableVideoMem); 917 DECODE_CHK_NULL(m_loopRestorationFilterTileColumnReadWriteUBuffer); 918 } 919 else 920 { 921 DECODE_CHK_STATUS(m_allocator->Resize( 922 m_loopRestorationFilterTileColumnReadWriteUBuffer, 923 avpBufSizeParam.m_bufferSize, 924 notLockableVideoMem)); 925 } 926 927 // Loop Restoration Filter Tile Column V Buffer 928 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 929 lrTileColVBuf, 930 &avpBufSizeParam)); 931 932 if (m_loopRestorationFilterTileColumnReadWriteVBuffer == nullptr) 933 { 934 m_loopRestorationFilterTileColumnReadWriteVBuffer = m_allocator->AllocateBuffer( 935 avpBufSizeParam.m_bufferSize, 936 "LoopRestorationFilterTileColumnReadWriteVBuffer", 937 resourceInternalReadWriteCache, 938 notLockableVideoMem); 939 DECODE_CHK_NULL(m_loopRestorationFilterTileColumnReadWriteVBuffer); 940 } 941 else 942 { 943 DECODE_CHK_STATUS(m_allocator->Resize( 944 m_loopRestorationFilterTileColumnReadWriteVBuffer, 945 avpBufSizeParam.m_bufferSize, 946 notLockableVideoMem)); 947 } 948 949 // Decoded Frame Status Error Buffer 950 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 951 frameStatusErrBuf, 952 &avpBufSizeParam)); 953 954 if (m_decodedFrameStatusErrorBuffer == nullptr) 955 { 956 m_decodedFrameStatusErrorBuffer = m_allocator->AllocateBuffer( 957 avpBufSizeParam.m_bufferSize, 958 "DecodedFrameStatusErrorBuffer", 959 resourceInternalWrite, 960 notLockableVideoMem); 961 DECODE_CHK_NULL(m_decodedFrameStatusErrorBuffer); 962 } 963 else 964 { 965 DECODE_CHK_STATUS(m_allocator->Resize( 966 m_decodedFrameStatusErrorBuffer, 967 avpBufSizeParam.m_bufferSize, 968 notLockableVideoMem)); 969 } 970 971 // Decoded Block Data Streamout Buffer 972 DECODE_CHK_STATUS(m_avpInterface->GetAv1BufferSize( 973 dbdStreamoutBuf, 974 &avpBufSizeParam)); 975 976 if (m_decodedBlockDataStreamoutBuffer == nullptr) 977 { 978 m_decodedBlockDataStreamoutBuffer = m_allocator->AllocateBuffer( 979 avpBufSizeParam.m_bufferSize, 980 "DecodedBlockDataStreamoutBuffer", 981 resourceInternalReadWriteNoCache, 982 notLockableVideoMem); 983 DECODE_CHK_NULL(m_decodedBlockDataStreamoutBuffer); 984 } 985 else 986 { 987 DECODE_CHK_STATUS(m_allocator->Resize( 988 m_decodedBlockDataStreamoutBuffer, 989 avpBufSizeParam.m_bufferSize, 990 notLockableVideoMem)); 991 } 992 993 return MOS_STATUS_SUCCESS; 994 } 995 SetAvpDstSurfaceParams(MHW_VDBOX_SURFACE_PARAMS & dstSurfaceParams)996 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpDstSurfaceParams(MHW_VDBOX_SURFACE_PARAMS& dstSurfaceParams) 997 { 998 DECODE_FUNC_CALL(); 999 1000 MOS_ZeroMemory(&dstSurfaceParams, sizeof(dstSurfaceParams)); 1001 dstSurfaceParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 1002 dstSurfaceParams.psSurface = &m_av1BasicFeature->m_destSurface; 1003 dstSurfaceParams.ucSurfaceStateId = reconPic; 1004 dstSurfaceParams.ChromaType = (uint8_t)chromaSamplingFormat; 1005 dstSurfaceParams.ucBitDepthLumaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1006 dstSurfaceParams.ucBitDepthChromaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1007 dstSurfaceParams.dwUVPlaneAlignment = 8; 1008 1009 #ifdef _MMC_SUPPORTED 1010 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_av1BasicFeature->m_destSurface))); 1011 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(dstSurfaceParams.psSurface, &dstSurfaceParams.mmcState)); 1012 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(dstSurfaceParams.psSurface, &dstSurfaceParams.dwCompressionFormat)); 1013 #endif 1014 return MOS_STATUS_SUCCESS; 1015 } 1016 SetAvpRefSurfaceParams(MHW_VDBOX_SURFACE_PARAMS * refSurfaceParams)1017 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpRefSurfaceParams(MHW_VDBOX_SURFACE_PARAMS *refSurfaceParams) 1018 { 1019 DECODE_FUNC_CALL(); 1020 1021 #ifdef _MMC_SUPPORTED 1022 //Record each reference surface mmc state 1023 uint8_t skipMask = 0; 1024 uint32_t compressionFormat = 0; 1025 #endif 1026 1027 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != keyFrame && m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != intraOnlyFrame) 1028 { 1029 Av1SurfaceId surfaceId[av1TotalRefsPerFrame] = { 1030 av1IntraFrame, 1031 av1LastRef, 1032 av1Last2Ref, 1033 av1Last3Ref, 1034 av1GoldRef, 1035 av1BwdRef, 1036 av1AltRef2, 1037 av1AltRef }; 1038 1039 //set for intra frame 1040 refSurface[0] = m_av1BasicFeature->m_destSurface; 1041 1042 Av1ReferenceFramesG12 &refFrames = m_av1BasicFeature->m_refFrames; 1043 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_av1PicParams, m_av1BasicFeature->m_av1TileParams[m_av1BasicFeature->m_tileCoding.m_curTile]); 1044 for (uint8_t i = 0; i < activeRefList.size(); i++) 1045 { 1046 PMOS_RESOURCE refResource[av1NumInterRefFrames]; 1047 uint8_t frameIdx = activeRefList[i]; 1048 auto refSuf = refFrames.GetReferenceByFrameIndex(frameIdx); 1049 if (refSuf != nullptr) 1050 { 1051 refSurface[i + 1].OsResource = *refSuf; 1052 } 1053 } 1054 1055 for (auto i = 0; i < av1TotalRefsPerFrame; i++) 1056 { 1057 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface[i])); 1058 refSurfaceParams[i].Mode = CODECHAL_DECODE_MODE_AV1VLD; 1059 refSurfaceParams[i].ChromaType = (uint8_t)chromaSamplingFormat; 1060 refSurfaceParams[i].ucBitDepthLumaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1061 refSurfaceParams[i].ucBitDepthChromaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1062 refSurfaceParams[i].dwUVPlaneAlignment = 8; 1063 refSurfaceParams[i].psSurface = &refSurface[i]; 1064 refSurfaceParams[i].ucSurfaceStateId = surfaceId[i]; 1065 #ifdef _MMC_SUPPORTED 1066 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(refSurfaceParams[i].psSurface, &refSurfaceParams[i].mmcState)); 1067 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(refSurfaceParams[i].psSurface, &refSurfaceParams[i].dwCompressionFormat)); 1068 if (refSurfaceParams[i].mmcState == MOS_MEMCOMP_DISABLED) 1069 { 1070 skipMask |= (1 << i); 1071 } 1072 else 1073 { 1074 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(refSurfaceParams[i].psSurface, &compressionFormat)); 1075 } 1076 DECODE_NORMALMESSAGE("AV1 MMC skip mask is %d compression format %d\n", skipMask, compressionFormat); 1077 #endif 1078 } 1079 1080 #ifdef _MMC_SUPPORTED 1081 if (m_mmcState->IsMmcEnabled()) 1082 { 1083 for (auto i = 0; i < av1TotalRefsPerFrame; i++) 1084 { 1085 // Set each refSurfaceParams mmcState as MOS_MEMCOMP_MC to satisfy MmcEnable in AddAvpSurfaceCmd 1086 // Compression type/enable should be the same for all reference surface state 1087 // The actual refSurfac mmcstate is recorded by skipMask 1088 refSurfaceParams[i].mmcState = MOS_MEMCOMP_MC; 1089 refSurfaceParams[i].mmcSkipMask = skipMask; 1090 refSurfaceParams[i].dwCompressionFormat = compressionFormat; 1091 } 1092 } 1093 #endif 1094 } 1095 1096 return MOS_STATUS_SUCCESS; 1097 } 1098 SetAvpIntraBCSurfaceParams(MHW_VDBOX_SURFACE_PARAMS & intraBCSurfaceParams)1099 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpIntraBCSurfaceParams(MHW_VDBOX_SURFACE_PARAMS &intraBCSurfaceParams) 1100 { 1101 DECODE_FUNC_CALL(); 1102 1103 MOS_ZeroMemory(&intraBCSurfaceParams, sizeof(intraBCSurfaceParams)); 1104 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(m_intrabcDecodedOutputFrameBuffer)); 1105 intraBCSurfaceParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 1106 intraBCSurfaceParams.psSurface = m_intrabcDecodedOutputFrameBuffer; 1107 intraBCSurfaceParams.ucSurfaceStateId = intrabcDecodedFrame; 1108 intraBCSurfaceParams.ChromaType = (uint8_t)chromaSamplingFormat; 1109 intraBCSurfaceParams.ucBitDepthLumaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1110 intraBCSurfaceParams.ucBitDepthChromaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 1111 intraBCSurfaceParams.dwUVPlaneAlignment = 8; 1112 1113 return MOS_STATUS_SUCCESS; 1114 } 1115 AddAvpSurfacesCmd(MOS_COMMAND_BUFFER & cmdBuffer)1116 MOS_STATUS Av1DecodePicPkt_G12_Base::AddAvpSurfacesCmd(MOS_COMMAND_BUFFER &cmdBuffer) 1117 { 1118 DECODE_FUNC_CALL(); 1119 1120 MHW_VDBOX_SURFACE_PARAMS dstSurfaceParams; 1121 DECODE_CHK_STATUS(SetAvpDstSurfaceParams(dstSurfaceParams)); 1122 DECODE_CHK_STATUS(m_avpInterface->AddAvpSurfaceCmd(&cmdBuffer, &dstSurfaceParams)); 1123 1124 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1125 { 1126 MHW_VDBOX_SURFACE_PARAMS refSurfaceParams[av1TotalRefsPerFrame]; 1127 for (uint16_t i = 0; i < av1TotalRefsPerFrame; i++) 1128 { 1129 MOS_ZeroMemory(&refSurfaceParams[i], sizeof(MHW_VDBOX_SURFACE_PARAMS)); 1130 } 1131 DECODE_CHK_STATUS(SetAvpRefSurfaceParams(refSurfaceParams)); 1132 for (uint8_t i = 0; i < av1TotalRefsPerFrame; i++) 1133 { 1134 DECODE_CHK_STATUS(m_avpInterface->AddAvpSurfaceCmd(&cmdBuffer, &refSurfaceParams[i])); 1135 } 1136 } 1137 1138 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 1139 { 1140 MHW_VDBOX_SURFACE_PARAMS intraBCSurfaceParams; 1141 DECODE_CHK_STATUS(SetAvpIntraBCSurfaceParams(intraBCSurfaceParams)); 1142 DECODE_CHK_STATUS(m_avpInterface->AddAvpSurfaceCmd(&cmdBuffer, &intraBCSurfaceParams)); 1143 } 1144 1145 return MOS_STATUS_SUCCESS; 1146 } 1147 AddAvpSegmentStateCmd(MOS_COMMAND_BUFFER & cmdBuffer)1148 MOS_STATUS Av1DecodePicPkt_G12_Base::AddAvpSegmentStateCmd(MOS_COMMAND_BUFFER &cmdBuffer) 1149 { 1150 DECODE_FUNC_CALL(); 1151 1152 MhwVdboxAvpSegmentStateParams segStateParams; 1153 MOS_ZeroMemory(&segStateParams, sizeof(segStateParams)); 1154 DECODE_CHK_STATUS(SetAvpSegmentStateParams(segStateParams)); 1155 1156 for (uint8_t i = 0; i < av1MaxSegments; i++) 1157 { 1158 segStateParams.m_currentSegmentId = i; 1159 DECODE_CHK_STATUS(m_avpInterface->AddAvpSegmentStateCmd( 1160 &cmdBuffer, 1161 &segStateParams)); 1162 1163 if (m_av1PicParams->m_av1SegData.m_enabled == 0) 1164 { 1165 break; 1166 } 1167 } 1168 1169 return MOS_STATUS_SUCCESS; 1170 } 1171 SetAvpSegmentStateParams(MhwVdboxAvpSegmentStateParams & segStateParams)1172 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpSegmentStateParams(MhwVdboxAvpSegmentStateParams& segStateParams) 1173 { 1174 DECODE_FUNC_CALL(); 1175 1176 segStateParams.m_av1SegmentParams = m_av1BasicFeature->m_segmentParams; 1177 1178 return MOS_STATUS_SUCCESS; 1179 } 1180 SetAvpPipeBufAddrParams(MhwVdboxAvpPipeBufAddrParams & pipeBufAddrParams)1181 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpPipeBufAddrParams(MhwVdboxAvpPipeBufAddrParams& pipeBufAddrParams) 1182 { 1183 DECODE_FUNC_CALL(); 1184 1185 pipeBufAddrParams.m_mode = CODECHAL_DECODE_MODE_AV1VLD; 1186 1187 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 1188 { 1189 pipeBufAddrParams.m_intrabcDecodedOutputFrameBuffer = &m_intrabcDecodedOutputFrameBuffer->OsResource; 1190 } 1191 1192 pipeBufAddrParams.m_decodedPic = &(m_av1BasicFeature->m_destSurface); 1193 pipeBufAddrParams.m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer = &m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer->OsResource; 1194 pipeBufAddrParams.m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer = &m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer->OsResource; 1195 pipeBufAddrParams.m_intraPredictionLineRowstoreReadWriteBuffer = &m_intraPredictionLineRowstoreReadWriteBuffer->OsResource; 1196 pipeBufAddrParams.m_intraPredictionTileLineRowstoreReadWriteBuffer = &m_intraPredictionTileLineRowstoreReadWriteBuffer->OsResource; 1197 pipeBufAddrParams.m_spatialMotionVectorLineReadWriteBuffer = &m_spatialMotionVectorLineReadWriteBuffer->OsResource; 1198 pipeBufAddrParams.m_spatialMotionVectorCodingTileLineReadWriteBuffer = &m_spatialMotionVectorCodingTileLineReadWriteBuffer->OsResource; 1199 pipeBufAddrParams.m_loopRestorationMetaTileColumnReadWriteBuffer = &m_loopRestorationMetaTileColumnReadWriteBuffer->OsResource; 1200 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineYBuffer = &m_loopRestorationFilterTileReadWriteLineYBuffer->OsResource; 1201 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineUBuffer = &m_loopRestorationFilterTileReadWriteLineUBuffer->OsResource; 1202 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineVBuffer = &m_loopRestorationFilterTileReadWriteLineVBuffer->OsResource; 1203 pipeBufAddrParams.m_deblockerFilterLineReadWriteYBuffer = &m_deblockerFilterLineReadWriteYBuffer->OsResource; 1204 pipeBufAddrParams.m_deblockerFilterLineReadWriteUBuffer = &m_deblockerFilterLineReadWriteUBuffer->OsResource; 1205 pipeBufAddrParams.m_deblockerFilterLineReadWriteVBuffer = &m_deblockerFilterLineReadWriteVBuffer->OsResource; 1206 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteYBuffer = &m_deblockerFilterTileLineReadWriteYBuffer->OsResource; 1207 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteVBuffer = &m_deblockerFilterTileLineReadWriteVBuffer->OsResource; 1208 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteUBuffer = &m_deblockerFilterTileLineReadWriteUBuffer->OsResource; 1209 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteYBuffer = &m_deblockerFilterTileColumnReadWriteYBuffer->OsResource; 1210 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteUBuffer = &m_deblockerFilterTileColumnReadWriteUBuffer->OsResource; 1211 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteVBuffer = &m_deblockerFilterTileColumnReadWriteVBuffer->OsResource; 1212 pipeBufAddrParams.m_cdefFilterLineReadWriteBuffer = &m_cdefFilterLineReadWriteBuffer->OsResource; 1213 pipeBufAddrParams.m_cdefFilterTileLineReadWriteBuffer = &m_cdefFilterTileLineReadWriteBuffer->OsResource; 1214 pipeBufAddrParams.m_cdefFilterTileColumnReadWriteBuffer = &m_cdefFilterTileColumnReadWriteBuffer->OsResource; 1215 pipeBufAddrParams.m_cdefFilterMetaTileLineReadWriteBuffer = &m_cdefFilterMetaTileLineReadWriteBuffer->OsResource; 1216 pipeBufAddrParams.m_cdefFilterMetaTileColumnReadWriteBuffer = &m_cdefFilterMetaTileColumnReadWriteBuffer->OsResource; 1217 pipeBufAddrParams.m_cdefFilterTopLeftCornerReadWriteBuffer = &m_cdefFilterTopLeftCornerReadWriteBuffer->OsResource; 1218 pipeBufAddrParams.m_superResTileColumnReadWriteYBuffer = &m_superResTileColumnReadWriteYBuffer->OsResource; 1219 pipeBufAddrParams.m_superResTileColumnReadWriteUBuffer = &m_superResTileColumnReadWriteUBuffer->OsResource; 1220 pipeBufAddrParams.m_superResTileColumnReadWriteVBuffer = &m_superResTileColumnReadWriteVBuffer->OsResource; 1221 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteYBuffer = &m_loopRestorationFilterTileColumnReadWriteYBuffer->OsResource; 1222 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteUBuffer = &m_loopRestorationFilterTileColumnReadWriteUBuffer->OsResource; 1223 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteVBuffer = &m_loopRestorationFilterTileColumnReadWriteVBuffer->OsResource; 1224 pipeBufAddrParams.m_decodedFrameStatusErrorBuffer = &m_decodedFrameStatusErrorBuffer->OsResource; 1225 pipeBufAddrParams.m_decodedBlockDataStreamoutBuffer = &m_decodedBlockDataStreamoutBuffer->OsResource; 1226 1227 auto tempBuffers = &(m_av1BasicFeature->m_tempBuffers); 1228 PMOS_BUFFER curMvBuffer = tempBuffers->GetCurBuffer()->mvBuf; 1229 DECODE_CHK_NULL(curMvBuffer); 1230 pipeBufAddrParams.m_curMvTemporalBuffer = &(curMvBuffer->OsResource); 1231 1232 Av1ReferenceFramesG12 &refFrames = m_av1BasicFeature->m_refFrames; 1233 uint8_t prevFrameIdx = refFrames.GetPrimaryRefIdx(); 1234 1235 uint32_t refSize = 0; 1236 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != keyFrame) 1237 { 1238 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_av1PicParams, m_av1BasicFeature->m_av1TileParams[m_av1BasicFeature->m_tileCoding.m_curTile]); 1239 refSize = activeRefList.size(); 1240 1241 //set for INTRA_FRAME 1242 pipeBufAddrParams.m_references[0] = &m_av1BasicFeature->m_destSurface.OsResource; 1243 pipeBufAddrParams.m_colMvTemporalBuffer[0] = &(curMvBuffer->OsResource); 1244 1245 for (uint8_t i = 0; i < activeRefList.size(); i++) 1246 { 1247 uint8_t frameIdx = activeRefList[i]; 1248 pipeBufAddrParams.m_references[i + lastFrame] = refFrames.GetReferenceByFrameIndex(frameIdx); 1249 auto tempBuf = tempBuffers->GetBufferByFrameIndex(frameIdx); 1250 pipeBufAddrParams.m_colMvTemporalBuffer[i + lastFrame] = tempBuf ? &(tempBuf->mvBuf->OsResource) : nullptr; 1251 } 1252 } 1253 1254 DECODE_CHK_STATUS(FixAvpPipeBufAddrParams(pipeBufAddrParams)); 1255 1256 DECODE_CHK_NULL(tempBuffers->GetCurBuffer()->initCdfBuf); 1257 PMOS_BUFFER curInitCdfBuffer = tempBuffers->GetCurBuffer()->initCdfBuf->buffer; 1258 DECODE_CHK_NULL(curInitCdfBuffer); 1259 pipeBufAddrParams.m_cdfTableInitializationBuffer = &(curInitCdfBuffer->OsResource); 1260 1261 if (!m_av1PicParams->m_picInfoFlags.m_fields.m_disableFrameEndUpdateCdf) 1262 { 1263 PMOS_BUFFER curBwdCdfBuffer = tempBuffers->GetCurBuffer()->bwdAdaptCdfBuf.buffer; 1264 DECODE_CHK_NULL(curBwdCdfBuffer); 1265 pipeBufAddrParams.m_cdfTableBwdAdaptationBuffer = &(curBwdCdfBuffer->OsResource); 1266 } 1267 1268 if (m_av1PicParams->m_av1SegData.m_enabled && m_av1PicParams->m_av1SegData.m_updateMap) 1269 { 1270 PMOS_BUFFER curSegIDWriteBuffer = tempBuffers->GetCurBuffer()->segIdWriteBuf.buffer; 1271 DECODE_CHK_NULL(curSegIDWriteBuffer); 1272 pipeBufAddrParams.m_segmentIdWriteBuffer = &(curSegIDWriteBuffer->OsResource); 1273 } 1274 1275 if (m_av1PicParams->m_av1SegData.m_enabled) 1276 { 1277 bool useSegMapFromPrevFrame = m_av1PicParams->m_av1SegData.m_temporalUpdate || 1278 !m_av1PicParams->m_av1SegData.m_updateMap; 1279 if (useSegMapFromPrevFrame && refFrames.CheckSegForPrimFrame(*m_av1PicParams)) 1280 { 1281 auto tempBuf = tempBuffers->GetBufferByFrameIndex(prevFrameIdx); 1282 auto segIdBuf = tempBuf ? tempBuf->segIdBuf : nullptr; 1283 auto buf = segIdBuf ? segIdBuf->buffer : nullptr; 1284 pipeBufAddrParams.m_segmentIdReadBuffer = buf ? &(buf->OsResource) : nullptr; 1285 } 1286 } 1287 1288 CODECHAL_DEBUG_TOOL(DumpResources(pipeBufAddrParams, refSize)); 1289 1290 return MOS_STATUS_SUCCESS; 1291 } 1292 FixAvpPipeBufAddrParams(MhwVdboxAvpPipeBufAddrParams & pipeBufAddrParams)1293 MOS_STATUS Av1DecodePicPkt_G12_Base::FixAvpPipeBufAddrParams(MhwVdboxAvpPipeBufAddrParams& pipeBufAddrParams) 1294 { 1295 DECODE_FUNC_CALL(); 1296 1297 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType == keyFrame) 1298 { 1299 for (auto i = 0; i < av1TotalRefsPerFrame; i++) 1300 { 1301 pipeBufAddrParams.m_references[i] = nullptr; 1302 } 1303 } 1304 else 1305 { 1306 PMOS_RESOURCE validRefPic = m_av1BasicFeature->m_refFrames.GetValidReference(); 1307 if (validRefPic == nullptr) 1308 { 1309 validRefPic = &m_av1BasicFeature->m_destSurface.OsResource; 1310 } 1311 for (uint8_t i = 0; i < av1TotalRefsPerFrame; i++) 1312 { 1313 // error concealment for the unset reference addresses and unset mv buffers 1314 if (pipeBufAddrParams.m_references[i] == nullptr) 1315 { 1316 pipeBufAddrParams.m_references[i] = validRefPic; 1317 } 1318 } 1319 1320 PMOS_BUFFER validMvBuf = m_av1BasicFeature->m_tempBuffers.GetValidBufferForReference( 1321 m_av1BasicFeature->m_refFrameIndexList)->mvBuf; 1322 for (uint32_t i = 0; i < CODEC_NUM_AV1_TEMP_BUFFERS; i++) 1323 { 1324 if (pipeBufAddrParams.m_colMvTemporalBuffer[i] == nullptr) 1325 { 1326 pipeBufAddrParams.m_colMvTemporalBuffer[i] = &validMvBuf->OsResource; 1327 } 1328 } 1329 } 1330 1331 PMOS_RESOURCE dummyRef = &(m_av1BasicFeature->m_dummyReference.OsResource); 1332 if (m_av1BasicFeature->m_useDummyReference && 1333 !m_allocator->ResourceIsNull(dummyRef)) 1334 { 1335 // set all ref pic addresses to valid addresses for error concealment purpose 1336 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++) 1337 { 1338 if (pipeBufAddrParams.m_references[i] == nullptr) 1339 { 1340 pipeBufAddrParams.m_references[i] = dummyRef; 1341 } 1342 } 1343 } 1344 1345 return MOS_STATUS_SUCCESS; 1346 } 1347 SetAvpIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS & indObjBaseAddrParams)1348 void Av1DecodePicPkt_G12_Base::SetAvpIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS& indObjBaseAddrParams) 1349 { 1350 DECODE_FUNC_CALL(); 1351 1352 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams)); 1353 indObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 1354 indObjBaseAddrParams.dwDataSize = m_av1BasicFeature->m_dataSize; 1355 indObjBaseAddrParams.dwDataOffset = m_av1BasicFeature->m_dataOffset; 1356 indObjBaseAddrParams.presDataBuffer = &(m_av1BasicFeature->m_resDataBuffer.OsResource); 1357 } 1358 AddAvpIndObjBaseAddrCmd(MOS_COMMAND_BUFFER & cmdBuffer)1359 MOS_STATUS Av1DecodePicPkt_G12_Base::AddAvpIndObjBaseAddrCmd(MOS_COMMAND_BUFFER &cmdBuffer) 1360 { 1361 DECODE_FUNC_CALL(); 1362 1363 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams; 1364 SetAvpIndObjBaseAddrParams(indObjBaseAddrParams); 1365 DECODE_CHK_STATUS(m_avpInterface->AddAvpIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams)); 1366 1367 return MOS_STATUS_SUCCESS; 1368 } 1369 SetAvpPipeBufAddrParamsForDummyWL(MhwVdboxAvpPipeBufAddrParams & pipeBufAddrParams)1370 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpPipeBufAddrParamsForDummyWL(MhwVdboxAvpPipeBufAddrParams& pipeBufAddrParams) 1371 { 1372 DECODE_FUNC_CALL(); 1373 1374 pipeBufAddrParams.m_mode = CODECHAL_DECODE_MODE_AV1VLD; 1375 1376 pipeBufAddrParams.m_decodedPic = m_av1BasicFeature->m_destSurfaceForDummyWL; 1377 1378 pipeBufAddrParams.m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer = &m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer->OsResource; 1379 pipeBufAddrParams.m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer = &m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer->OsResource; 1380 pipeBufAddrParams.m_intraPredictionLineRowstoreReadWriteBuffer = &m_intraPredictionLineRowstoreReadWriteBuffer->OsResource; 1381 pipeBufAddrParams.m_intraPredictionTileLineRowstoreReadWriteBuffer = &m_intraPredictionTileLineRowstoreReadWriteBuffer->OsResource; 1382 pipeBufAddrParams.m_spatialMotionVectorLineReadWriteBuffer = &m_spatialMotionVectorLineReadWriteBuffer->OsResource; 1383 pipeBufAddrParams.m_spatialMotionVectorCodingTileLineReadWriteBuffer = &m_spatialMotionVectorCodingTileLineReadWriteBuffer->OsResource; 1384 pipeBufAddrParams.m_loopRestorationMetaTileColumnReadWriteBuffer = &m_loopRestorationMetaTileColumnReadWriteBuffer->OsResource; 1385 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineYBuffer = &m_loopRestorationFilterTileReadWriteLineYBuffer->OsResource; 1386 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineUBuffer = &m_loopRestorationFilterTileReadWriteLineUBuffer->OsResource; 1387 pipeBufAddrParams.m_loopRestorationFilterTileReadWriteLineVBuffer = &m_loopRestorationFilterTileReadWriteLineVBuffer->OsResource; 1388 pipeBufAddrParams.m_deblockerFilterLineReadWriteYBuffer = &m_deblockerFilterLineReadWriteYBuffer->OsResource; 1389 pipeBufAddrParams.m_deblockerFilterLineReadWriteUBuffer = &m_deblockerFilterLineReadWriteUBuffer->OsResource; 1390 pipeBufAddrParams.m_deblockerFilterLineReadWriteVBuffer = &m_deblockerFilterLineReadWriteVBuffer->OsResource; 1391 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteYBuffer = &m_deblockerFilterTileLineReadWriteYBuffer->OsResource; 1392 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteVBuffer = &m_deblockerFilterTileLineReadWriteVBuffer->OsResource; 1393 pipeBufAddrParams.m_deblockerFilterTileLineReadWriteUBuffer = &m_deblockerFilterTileLineReadWriteUBuffer->OsResource; 1394 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteYBuffer = &m_deblockerFilterTileColumnReadWriteYBuffer->OsResource; 1395 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteUBuffer = &m_deblockerFilterTileColumnReadWriteUBuffer->OsResource; 1396 pipeBufAddrParams.m_deblockerFilterTileColumnReadWriteVBuffer = &m_deblockerFilterTileColumnReadWriteVBuffer->OsResource; 1397 pipeBufAddrParams.m_cdefFilterLineReadWriteBuffer = &m_cdefFilterLineReadWriteBuffer->OsResource; 1398 pipeBufAddrParams.m_cdefFilterTileLineReadWriteBuffer = &m_cdefFilterTileLineReadWriteBuffer->OsResource; 1399 pipeBufAddrParams.m_cdefFilterTileColumnReadWriteBuffer = &m_cdefFilterTileColumnReadWriteBuffer->OsResource; 1400 pipeBufAddrParams.m_cdefFilterMetaTileLineReadWriteBuffer = &m_cdefFilterMetaTileLineReadWriteBuffer->OsResource; 1401 pipeBufAddrParams.m_cdefFilterMetaTileColumnReadWriteBuffer = &m_cdefFilterMetaTileColumnReadWriteBuffer->OsResource; 1402 pipeBufAddrParams.m_cdefFilterTopLeftCornerReadWriteBuffer = &m_cdefFilterTopLeftCornerReadWriteBuffer->OsResource; 1403 pipeBufAddrParams.m_superResTileColumnReadWriteYBuffer = &m_superResTileColumnReadWriteYBuffer->OsResource; 1404 pipeBufAddrParams.m_superResTileColumnReadWriteUBuffer = &m_superResTileColumnReadWriteUBuffer->OsResource; 1405 pipeBufAddrParams.m_superResTileColumnReadWriteVBuffer = &m_superResTileColumnReadWriteVBuffer->OsResource; 1406 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteYBuffer = &m_loopRestorationFilterTileColumnReadWriteYBuffer->OsResource; 1407 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteUBuffer = &m_loopRestorationFilterTileColumnReadWriteUBuffer->OsResource; 1408 pipeBufAddrParams.m_loopRestorationFilterTileColumnReadWriteVBuffer = &m_loopRestorationFilterTileColumnReadWriteVBuffer->OsResource; 1409 pipeBufAddrParams.m_decodedFrameStatusErrorBuffer = &m_decodedFrameStatusErrorBuffer->OsResource; 1410 pipeBufAddrParams.m_decodedBlockDataStreamoutBuffer = &m_decodedBlockDataStreamoutBuffer->OsResource; 1411 1412 pipeBufAddrParams.m_curMvTemporalBuffer = &m_curMvBufferForDummyWL->OsResource; 1413 pipeBufAddrParams.m_cdfTableInitializationBuffer = &m_av1BasicFeature->m_defaultCdfBuffers[3]->OsResource; 1414 pipeBufAddrParams.m_cdfTableBwdAdaptationBuffer = &m_bwdAdaptCdfBufForDummyWL->OsResource; 1415 1416 return MOS_STATUS_SUCCESS; 1417 } 1418 UpdatePipeBufAddrForDummyWL(MOS_COMMAND_BUFFER & cmdBuffer)1419 MOS_STATUS Av1DecodePicPkt_G12_Base::UpdatePipeBufAddrForDummyWL(MOS_COMMAND_BUFFER &cmdBuffer) 1420 { 1421 DECODE_FUNC_CALL(); 1422 1423 MhwVdboxAvpPipeBufAddrParams pipeBufAddrParams = {}; 1424 DECODE_CHK_STATUS(SetAvpPipeBufAddrParamsForDummyWL(pipeBufAddrParams)); 1425 #ifdef _MMC_SUPPORTED 1426 pipeBufAddrParams.m_preDeblockSurfMmcState = MOS_MEMCOMP_DISABLED; 1427 #endif 1428 DECODE_CHK_STATUS(m_avpInterface->AddAvpPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams)); 1429 1430 return MOS_STATUS_SUCCESS; 1431 } 1432 UpdateIndObjAddrForDummyWL(MOS_COMMAND_BUFFER & cmdBuffer)1433 MOS_STATUS Av1DecodePicPkt_G12_Base::UpdateIndObjAddrForDummyWL(MOS_COMMAND_BUFFER &cmdBuffer) 1434 { 1435 DECODE_FUNC_CALL(); 1436 1437 if (!m_dummyBsBufInited) 1438 { 1439 m_resDataBufferForDummyWL= m_allocator->AllocateBuffer( 1440 140, "BsBuffer for inserted Dummy WL", resourceInputBitstream, lockableVideoMem); //140 Bytes 1441 DECODE_CHK_NULL(m_resDataBufferForDummyWL); 1442 auto data = (uint8_t *)m_allocator->LockResourceForWrite(&m_resDataBufferForDummyWL->OsResource); 1443 DECODE_CHK_NULL(data); 1444 1445 uint32_t bsBuffer[] = 1446 { 1447 0x3004260a, 0x1d95985a, 0x8311a32e, 0x4957f9a8, 1448 0x16000832, 0x00000100, 0x00900000, 0x88040000, 1449 0x797797f7, 0x346907ae, 0x00106332, 0x00010000, 1450 0x01c02a07, 0x9a165a76, 0x13041816, 0x92fd0c00, 1451 0x02fc1aad, 0xf94923f3, 0x88ce7a1b, 0xc440d4fb, 1452 0xcf5940bb, 0xe3a4fcff, 0x6c13cd19, 0x8e7b22b1, 1453 0x83f20193, 0x41c12b17, 0x7a266ac8, 0x9b0b871e, 1454 0x956345f8, 0x538c1c25, 0x2302b41f, 0x1e0587a8, 1455 0x182a0ec1, 0x3672822a, 0x5003db7b 1456 }; 1457 1458 MOS_SecureMemcpy(data, sizeof(bsBuffer), bsBuffer, sizeof(bsBuffer)); 1459 m_dummyBsBufInited = true; 1460 } 1461 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams; 1462 1463 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams)); 1464 indObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 1465 indObjBaseAddrParams.dwDataSize = 140; 1466 indObjBaseAddrParams.dwDataOffset = 0; 1467 indObjBaseAddrParams.presDataBuffer = &(m_resDataBufferForDummyWL->OsResource); 1468 1469 DECODE_CHK_STATUS(m_avpInterface->AddAvpIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams)); 1470 1471 return MOS_STATUS_SUCCESS; 1472 } 1473 SetAvpPicStateParams(MhwVdboxAvpPicStateParams & picStateParams)1474 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpPicStateParams(MhwVdboxAvpPicStateParams& picStateParams) 1475 { 1476 DECODE_FUNC_CALL(); 1477 1478 MOS_ZeroMemory(&picStateParams, sizeof(picStateParams)); 1479 picStateParams.m_picParams = m_av1PicParams; 1480 picStateParams.m_refList = &(m_av1BasicFeature->m_refFrames.m_refList[0]); 1481 1482 DECODE_CHK_STATUS(SetupSkipModeFrames(picStateParams)); 1483 DECODE_CHK_STATUS(SetupFrameSignBias(picStateParams)); 1484 1485 memset(&m_av1PicParams->m_refFrameSide, 0, sizeof(m_av1PicParams->m_refFrameSide)); 1486 if(m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint && 1487 !AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1488 { 1489 for (auto ref = 0; ref < av1NumInterRefFrames; ref++) 1490 { 1491 picStateParams.m_refOrderHints[ref] = m_av1BasicFeature->m_refFrames.m_currRefList->m_refOrderHint[ref]; 1492 1493 if (m_av1BasicFeature->m_refFrames.GetRelativeDist(*m_av1PicParams, picStateParams.m_refOrderHints[ref], m_av1PicParams->m_orderHint) > 0 || 1494 picStateParams.m_refOrderHints[ref] == m_av1PicParams->m_orderHint) 1495 { 1496 m_av1PicParams->m_refFrameSide[ref + lastFrame] = 1; 1497 } 1498 } 1499 } 1500 1501 return MOS_STATUS_SUCCESS; 1502 } 1503 SetAvpInterPredStateParams(MhwVdboxAvpPicStateParams & picStateParams)1504 MOS_STATUS Av1DecodePicPkt_G12_Base::SetAvpInterPredStateParams(MhwVdboxAvpPicStateParams& picStateParams) 1505 { 1506 DECODE_FUNC_CALL(); 1507 1508 MOS_ZeroMemory(&picStateParams, sizeof(picStateParams)); 1509 picStateParams.m_picParams = m_av1PicParams; 1510 1511 if(!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType) && 1512 m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint) 1513 { 1514 for (auto ref = 0; ref < av1NumInterRefFrames; ref++) 1515 { 1516 uint8_t refPicIndex = m_av1PicParams->m_refFrameIdx[ref]; 1517 if (!CodecHal_PictureIsInvalid(m_av1PicParams->m_refFrameMap[refPicIndex])) 1518 { 1519 uint8_t refFrameIdx = m_av1PicParams->m_refFrameMap[refPicIndex].FrameIdx; 1520 for (auto i = 0; i < 7; i++) 1521 { 1522 picStateParams.m_savedRefOrderHints[ref][i] = m_av1BasicFeature->m_refFrames.m_refList[refFrameIdx]->m_refOrderHint[i]; 1523 } 1524 } 1525 } 1526 1527 DECODE_CHK_STATUS(m_av1BasicFeature->m_refFrames.SetupMotionFieldProjection(*m_av1PicParams)); 1528 1529 picStateParams.m_refMaskMfProj = m_av1PicParams->m_activeRefBitMaskMfmv[0] | 1530 (m_av1PicParams->m_activeRefBitMaskMfmv[1] << 1) | 1531 (m_av1PicParams->m_activeRefBitMaskMfmv[2] << 2) | 1532 (m_av1PicParams->m_activeRefBitMaskMfmv[3] << 3) | 1533 (m_av1PicParams->m_activeRefBitMaskMfmv[4] << 4) | 1534 (m_av1PicParams->m_activeRefBitMaskMfmv[5] << 5) | 1535 (m_av1PicParams->m_activeRefBitMaskMfmv[6] << 6); 1536 } 1537 1538 return MOS_STATUS_SUCCESS; 1539 } 1540 CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)1541 MOS_STATUS Av1DecodePicPkt_G12_Base::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize) 1542 { 1543 DECODE_FUNC_CALL(); 1544 1545 commandBufferSize = m_pictureStatesSize; 1546 requestedPatchListSize = m_picturePatchListSize; 1547 1548 return MOS_STATUS_SUCCESS; 1549 } 1550 SetupSkipModeFrames(MhwVdboxAvpPicStateParams & picStateParams)1551 MOS_STATUS Av1DecodePicPkt_G12_Base::SetupSkipModeFrames(MhwVdboxAvpPicStateParams& picStateParams) 1552 { 1553 DECODE_FUNC_CALL(); 1554 1555 if (!m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint || 1556 AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType) || 1557 m_av1PicParams->m_modeControlFlags.m_fields.m_referenceMode == singleReference) 1558 { 1559 picStateParams.m_skipModeFrame[0] = -1; 1560 picStateParams.m_skipModeFrame[1] = -1; 1561 return MOS_STATUS_SUCCESS; 1562 } 1563 1564 int32_t curFrameOffset = m_av1PicParams->m_orderHint; 1565 int32_t refFrameOffset[2] = { -1, 0x7fffffff }; 1566 int32_t refIdx[2] = { -1, -1 }; 1567 Av1ReferenceFramesG12 &refFrames = m_av1BasicFeature->m_refFrames; 1568 DECODE_CHK_STATUS(refFrames.Identify1stNearRef(*m_av1PicParams, curFrameOffset, refFrameOffset, refIdx)); 1569 1570 if (refIdx[0] != -1 && refIdx[1] != -1) 1571 { 1572 // == Bi-directional prediction == 1573 //cm->is_skip_mode_allowed = 1; 1574 picStateParams.m_skipModeFrame[0] = AOMMIN(refIdx[0], refIdx[1]); 1575 picStateParams.m_skipModeFrame[1] = AOMMAX(refIdx[0], refIdx[1]); 1576 } 1577 else if (refIdx[0] != -1 && refIdx[1] == -1) 1578 { 1579 DECODE_CHK_STATUS(refFrames.Identify2ndNearRef(*m_av1PicParams, curFrameOffset, refFrameOffset, refIdx)); 1580 if (refFrameOffset[1] != -1) 1581 { 1582 picStateParams.m_skipModeFrame[0] = AOMMIN(refIdx[0], refIdx[1]); 1583 picStateParams.m_skipModeFrame[1] = AOMMAX(refIdx[0], refIdx[1]); 1584 } 1585 } 1586 return MOS_STATUS_SUCCESS; 1587 } 1588 SetupFrameSignBias(MhwVdboxAvpPicStateParams & picStateParams)1589 MOS_STATUS Av1DecodePicPkt_G12_Base::SetupFrameSignBias(MhwVdboxAvpPicStateParams& picStateParams) 1590 { 1591 DECODE_FUNC_CALL(); 1592 1593 for (auto refFrame = (uint32_t)lastFrame; refFrame <= (uint32_t)altRefFrame; refFrame++)//no bias for intra frame 1594 { 1595 if (m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint && 1596 !AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1597 { 1598 int32_t refFrameOffset = -1; 1599 1600 uint8_t refPicIndex = m_av1PicParams->m_refFrameIdx[refFrame - lastFrame];//0 corresponds to LAST_FRAME 1601 PCODEC_PICTURE refFrameList = &(m_av1PicParams->m_refFrameMap[0]); 1602 1603 if (!CodecHal_PictureIsInvalid(refFrameList[refPicIndex])) 1604 { 1605 uint8_t refFrameIdx = refFrameList[refPicIndex].FrameIdx; 1606 refFrameOffset = m_av1BasicFeature->m_refFrames.m_refList[refFrameIdx]->m_orderHint; 1607 } 1608 1609 int32_t frameOffset = (int32_t)m_av1PicParams->m_orderHint; 1610 picStateParams.m_referenceFrameSignBias[refFrame] = 1611 (m_av1BasicFeature->m_refFrames.GetRelativeDist(*m_av1PicParams, refFrameOffset, frameOffset) <= 0) ? 0 : 1; 1612 } 1613 else 1614 { 1615 picStateParams.m_referenceFrameSignBias[refFrame] = 0; 1616 } 1617 } 1618 1619 return MOS_STATUS_SUCCESS; 1620 } 1621 1622 #if USE_CODECHAL_DEBUG_TOOL DumpResources(MhwVdboxAvpPipeBufAddrParams & pipeBufAddrParams,uint32_t refSize)1623 MOS_STATUS Av1DecodePicPkt_G12_Base::DumpResources(MhwVdboxAvpPipeBufAddrParams &pipeBufAddrParams, uint32_t refSize) 1624 { 1625 DECODE_FUNC_CALL(); 1626 1627 CodechalDebugInterface *debugInterface = m_av1Pipeline->GetDebugInterface(); 1628 debugInterface->m_frameType = m_av1PicParams->m_picInfoFlags.m_fields.m_frameType ? P_TYPE : I_TYPE; 1629 m_av1PicParams->m_currPic.PicFlags = PICTURE_FRAME; 1630 debugInterface->m_currPic = m_av1PicParams->m_currPic; 1631 debugInterface->m_bufferDumpFrameNum = m_av1BasicFeature->m_frameNum; 1632 1633 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != keyFrame) 1634 { 1635 for (uint32_t n = 0; n < refSize; n++) 1636 { 1637 MOS_SURFACE refSurface; 1638 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 1639 refSurface.OsResource = *(pipeBufAddrParams.m_references[n + lastFrame]); 1640 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 1641 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(n)) + "]"; 1642 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 1643 &refSurface, 1644 CodechalDbgAttr::attrDecodeReferenceSurfaces, 1645 refSurfName.c_str())); 1646 } 1647 } 1648 1649 //For multi-tiles per frame case, only need dump these resources once. 1650 if (m_av1BasicFeature->m_tileCoding.m_curTile == 0) 1651 { 1652 if (pipeBufAddrParams.m_segmentIdReadBuffer != nullptr && 1653 !m_allocator->ResourceIsNull(pipeBufAddrParams.m_segmentIdReadBuffer)) 1654 { 1655 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 1656 pipeBufAddrParams.m_segmentIdReadBuffer, 1657 CodechalDbgAttr::attrSegId, 1658 "SegIdReadBuffer", 1659 (m_widthInSb * m_heightInSb * CODECHAL_CACHELINE_SIZE), 1660 CODECHAL_NUM_MEDIA_STATES)); 1661 } 1662 1663 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 1664 pipeBufAddrParams.m_cdfTableInitializationBuffer, 1665 CodechalDbgAttr::attrCoefProb, 1666 "CdfTableInitialization", 1667 m_av1BasicFeature->m_cdfMaxNumBytes, 1668 CODECHAL_NUM_MEDIA_STATES)); 1669 } 1670 1671 return MOS_STATUS_SUCCESS; 1672 } 1673 #endif 1674 1675 } 1676