1 /* 2 * Copyright (c) 2021-2024, 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.cpp 24 //! \brief Defines the interface for av1 decode picture packet 25 //! 26 #include "decode_av1_picture_packet.h" 27 #include "codechal_debug.h" 28 29 namespace decode{ ~Av1DecodePicPkt()30 Av1DecodePicPkt::~Av1DecodePicPkt() 31 { 32 FreeResources(); 33 } 34 FreeResources()35 MOS_STATUS Av1DecodePicPkt::FreeResources() 36 { 37 DECODE_FUNC_CALL(); 38 39 if (m_allocator != nullptr) 40 { 41 m_allocator->Destroy(m_intrabcDecodedOutputFrameBuffer); 42 if (!m_avpItf->IsBufferRowstoreCacheEnabled(bsdLineBuffer)) 43 { 44 m_allocator->Destroy(m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer); 45 } 46 m_allocator->Destroy(m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer); 47 if (!m_avpItf->IsBufferRowstoreCacheEnabled(intraPredLineBuffer)) 48 { 49 m_allocator->Destroy(m_intraPredictionLineRowstoreReadWriteBuffer); 50 } 51 m_allocator->Destroy(m_intraPredictionTileLineRowstoreReadWriteBuffer); 52 if (!m_avpItf->IsBufferRowstoreCacheEnabled(spatialMvLineBuffer)) 53 { 54 m_allocator->Destroy(m_spatialMotionVectorLineReadWriteBuffer); 55 } 56 m_allocator->Destroy(m_spatialMotionVectorCodingTileLineReadWriteBuffer); 57 m_allocator->Destroy(m_loopRestorationMetaTileColumnReadWriteBuffer); 58 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineYBuffer); 59 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineUBuffer); 60 m_allocator->Destroy(m_loopRestorationFilterTileReadWriteLineVBuffer); 61 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineYBuffer)) 62 { 63 m_allocator->Destroy(m_deblockerFilterLineReadWriteYBuffer); 64 } 65 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineUBuffer)) 66 { 67 m_allocator->Destroy(m_deblockerFilterLineReadWriteUBuffer); 68 } 69 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineVBuffer)) 70 { 71 m_allocator->Destroy(m_deblockerFilterLineReadWriteVBuffer); 72 } 73 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteYBuffer); 74 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteVBuffer); 75 m_allocator->Destroy(m_deblockerFilterTileLineReadWriteUBuffer); 76 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteYBuffer); 77 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteUBuffer); 78 m_allocator->Destroy(m_deblockerFilterTileColumnReadWriteVBuffer); 79 if (!m_avpItf->IsBufferRowstoreCacheEnabled(cdefLineBuffer)) 80 { 81 m_allocator->Destroy(m_cdefFilterLineReadWriteBuffer); 82 } 83 m_allocator->Destroy(m_cdefFilterTileLineReadWriteBuffer); 84 m_allocator->Destroy(m_cdefFilterTileColumnReadWriteBuffer); 85 m_allocator->Destroy(m_cdefFilterMetaTileLineReadWriteBuffer); 86 m_allocator->Destroy(m_cdefFilterMetaTileColumnReadWriteBuffer); 87 m_allocator->Destroy(m_cdefFilterTopLeftCornerReadWriteBuffer); 88 m_allocator->Destroy(m_superResTileColumnReadWriteYBuffer); 89 m_allocator->Destroy(m_superResTileColumnReadWriteUBuffer); 90 m_allocator->Destroy(m_superResTileColumnReadWriteVBuffer); 91 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteYBuffer); 92 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteUBuffer); 93 m_allocator->Destroy(m_loopRestorationFilterTileColumnReadWriteVBuffer); 94 m_allocator->Destroy(m_decodedFrameStatusErrorBuffer); 95 m_allocator->Destroy(m_decodedBlockDataStreamoutBuffer); 96 m_allocator->Destroy(m_filmGrainSampleTemplateBuf); 97 m_allocator->Destroy(m_filmGrainTileColumnDataBuf); 98 m_allocator->Destroy(m_loopRestorationFilterTileColumnAlignmentBuf); 99 } 100 101 return MOS_STATUS_SUCCESS; 102 } 103 Init()104 MOS_STATUS Av1DecodePicPkt::Init() 105 { 106 DECODE_FUNC_CALL(); 107 108 DECODE_CHK_NULL(m_featureManager); 109 DECODE_CHK_NULL(m_hwInterface); 110 DECODE_CHK_NULL(m_osInterface); 111 DECODE_CHK_NULL(m_av1Pipeline); 112 113 m_av1BasicFeature = dynamic_cast<Av1BasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 114 DECODE_CHK_NULL(m_av1BasicFeature); 115 116 m_allocator = m_pipeline ->GetDecodeAllocator(); 117 DECODE_CHK_NULL(m_allocator); 118 119 return MOS_STATUS_SUCCESS; 120 } 121 Prepare()122 MOS_STATUS Av1DecodePicPkt::Prepare() 123 { 124 DECODE_FUNC_CALL(); 125 126 DECODE_CHK_STATUS(GetChromaFormat()); 127 128 #ifdef _MMC_SUPPORTED 129 m_mmcState = m_av1Pipeline->GetMmcState(); 130 DECODE_CHK_NULL(m_mmcState); 131 #endif 132 133 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 134 135 DECODE_CHK_STATUS(AllocateVariableResources()); 136 137 return MOS_STATUS_SUCCESS; 138 } 139 GetChromaFormat()140 MOS_STATUS Av1DecodePicPkt::GetChromaFormat() 141 { 142 DECODE_FUNC_CALL(); 143 144 m_av1PicParams = m_av1BasicFeature->m_av1PicParams; 145 146 if (m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingX == 1 && m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingY == 1) 147 { 148 chromaSamplingFormat = av1ChromaFormatYuv420; 149 } 150 else 151 { 152 DECODE_ASSERTMESSAGE("Invalid Chroma sampling format!"); 153 return MOS_STATUS_INVALID_PARAMETER; 154 } 155 156 return MOS_STATUS_SUCCESS; 157 } 158 SetRowstoreCachingOffsets()159 MOS_STATUS Av1DecodePicPkt::SetRowstoreCachingOffsets() 160 { 161 if (m_avpItf->IsRowStoreCachingSupported() && 162 (m_av1BasicFeature->m_frameWidthAlignedMinBlk != MOS_ALIGN_CEIL(m_prevFrmWidth, av1MinBlockWidth))) 163 { 164 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams; 165 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams)); 166 rowstoreParams.dwPicWidth = m_av1BasicFeature->m_frameWidthAlignedMinBlk; 167 rowstoreParams.bMbaff = false; 168 rowstoreParams.Mode = CODECHAL_DECODE_MODE_AV1VLD; 169 rowstoreParams.ucBitDepthMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 170 rowstoreParams.ucChromaFormat = static_cast<uint8_t>(chromaSamplingFormat); 171 DECODE_CHK_STATUS(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams)); 172 } 173 174 return MOS_STATUS_SUCCESS; 175 } 176 AllocateVariableResources()177 MOS_STATUS Av1DecodePicPkt::AllocateVariableResources() 178 { 179 DECODE_FUNC_CALL(); 180 181 int32_t mibSizeLog2 = m_av1PicParams->m_seqInfoFlags.m_fields.m_use128x128Superblock ? av1MaxMibSizeLog2 : av1MinMibSizeLog2; 182 int32_t miCols = MOS_ALIGN_CEIL(m_av1PicParams->m_superResUpscaledWidthMinus1 + 1, 8) >> av1MiSizeLog2; 183 int32_t miRows = MOS_ALIGN_CEIL(m_av1PicParams->m_superResUpscaledHeightMinus1 + 1, 8) >> av1MiSizeLog2; 184 miCols = MOS_ALIGN_CEIL(miCols, 1 << mibSizeLog2); 185 miRows = MOS_ALIGN_CEIL(miRows, 1 << mibSizeLog2); 186 187 m_widthInSb = miCols >> mibSizeLog2; 188 m_heightInSb = miRows >> mibSizeLog2; 189 uint32_t maxTileWidthInSb = MOS_ROUNDUP_DIVIDE(4096, 1 << (mibSizeLog2 + av1MiSizeLog2)); 190 AvpBufferSizePar avpBufSizeParam; 191 MOS_ZeroMemory(&avpBufSizeParam, sizeof(avpBufSizeParam)); 192 193 avpBufSizeParam.bitDepthIdc = m_av1BasicFeature->m_av1DepthIndicator; 194 avpBufSizeParam.width = m_widthInSb; 195 avpBufSizeParam.height = m_heightInSb; 196 avpBufSizeParam.tileWidth = maxTileWidthInSb; 197 avpBufSizeParam.isSb128x128 = m_av1PicParams->m_seqInfoFlags.m_fields.m_use128x128Superblock ? true : false; 198 avpBufSizeParam.curFrameTileNum = m_av1PicParams->m_tileCols * m_av1PicParams->m_tileRows; 199 avpBufSizeParam.numTileCol = m_av1PicParams->m_tileCols; 200 avpBufSizeParam.chromaFormat = chromaSamplingFormat; 201 202 // Lamda expression 203 auto AllocateBuffer = [&] (PMOS_BUFFER &buffer, AvpBufferType bufferType, const char *bufferName) 204 { 205 DECODE_CHK_STATUS(m_avpItf->GetAvpBufSize(bufferType, &avpBufSizeParam)); 206 if (buffer == nullptr) 207 { 208 buffer = m_allocator->AllocateBuffer( 209 avpBufSizeParam.bufferSize, bufferName, resourceInternalReadWriteCache, notLockableVideoMem); 210 DECODE_CHK_NULL(buffer); 211 } 212 else 213 { 214 DECODE_CHK_STATUS(m_allocator->Resize(buffer, avpBufSizeParam.bufferSize, notLockableVideoMem)); 215 } 216 return MOS_STATUS_SUCCESS; 217 }; 218 219 // Intrabc Decoded Output Frame Buffer 220 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 221 { 222 MOS_SURFACE m_destSurface = m_av1BasicFeature->m_destSurface; 223 if (m_intrabcDecodedOutputFrameBuffer == nullptr) 224 { 225 PMOS_SURFACE surface = nullptr; 226 surface = m_allocator->AllocateSurface( 227 m_destSurface.dwWidth, 228 MOS_ALIGN_CEIL(m_destSurface.dwHeight, 8), 229 "Intrabc Decoded Output Frame Buffer", 230 m_destSurface.Format, 231 m_destSurface.bCompressible, 232 resourceInternalReadWriteNoCache, 233 notLockableVideoMem); 234 235 m_intrabcDecodedOutputFrameBuffer = surface; 236 DECODE_CHK_NULL(m_intrabcDecodedOutputFrameBuffer); 237 } 238 else 239 { 240 DECODE_CHK_STATUS(m_allocator->Resize( 241 m_intrabcDecodedOutputFrameBuffer, 242 m_destSurface.dwWidth, 243 MOS_ALIGN_CEIL(m_destSurface.dwHeight, 8), 244 notLockableVideoMem)); 245 } 246 } 247 248 // Bitstream decode line rowstore buffer 249 if (!m_avpItf->IsBufferRowstoreCacheEnabled(bsdLineBuffer)) 250 { 251 DECODE_CHK_STATUS(AllocateBuffer( 252 m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer, 253 bsdLineBuffer, 254 "BitstreamDecodeLineBuffer")); 255 } 256 257 // Bitstream decode tile line buffer 258 DECODE_CHK_STATUS(AllocateBuffer( 259 m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer, 260 bsdTileLineBuffer, 261 "BitstreamDecodeTileLineBuffer")); 262 263 // Intra Prediction Line Rowstore Read/Write Buffer 264 if (!m_avpItf->IsBufferRowstoreCacheEnabled(intraPredLineBuffer)) 265 { 266 DECODE_CHK_STATUS(AllocateBuffer( 267 m_intraPredictionLineRowstoreReadWriteBuffer, 268 intraPredLineBuffer, 269 "intraPredictionLineRowstoreBuffer")); 270 } 271 272 // Intra Prediction Tile Line Rowstore Read/Write Buffer 273 DECODE_CHK_STATUS(AllocateBuffer( 274 m_intraPredictionTileLineRowstoreReadWriteBuffer, 275 intraPredTileLineBuffer, 276 "intraPredictionTileLineRowstoreBuffer")); 277 278 // Spatial motion vector Line rowstore buffer 279 if (!m_avpItf->IsBufferRowstoreCacheEnabled(spatialMvLineBuffer)) 280 { 281 DECODE_CHK_STATUS(AllocateBuffer( 282 m_spatialMotionVectorLineReadWriteBuffer, 283 spatialMvLineBuffer, 284 "SpatialMotionVectorLineRowstoreBuffer")); 285 } 286 287 // Spatial motion vector Tile Line Buffer 288 DECODE_CHK_STATUS(AllocateBuffer( 289 m_spatialMotionVectorCodingTileLineReadWriteBuffer, 290 spatialMvTileLineBuffer, 291 "SpatialMotionVectorTileLineBuffer")); 292 293 // Loop Restoration Meta Tile Column Read/Write Buffer 294 DECODE_CHK_STATUS(AllocateBuffer( 295 m_loopRestorationMetaTileColumnReadWriteBuffer, 296 lrMetaTileColBuffer, 297 "LoopRestorationMetaTileColumnReadWriteBuffer")); 298 299 // Loop Restoration Filter Tile Read/Write Line Y Buffer 300 DECODE_CHK_STATUS(AllocateBuffer( 301 m_loopRestorationFilterTileReadWriteLineYBuffer, 302 lrTileLineYBuffer, 303 "LoopRestorationFilterTileReadWriteLineYBuffer")); 304 305 //Loop Restoration Filter Tile Read/Write Line U Buffer 306 DECODE_CHK_STATUS(AllocateBuffer( 307 m_loopRestorationFilterTileReadWriteLineUBuffer, 308 lrTileLineUBuffer, 309 "LoopRestorationFilterTileReadWriteLineUBuffer")); 310 311 // Loop Restoration Filter Tile Read/Write Line V Buffer 312 DECODE_CHK_STATUS(AllocateBuffer( 313 m_loopRestorationFilterTileReadWriteLineVBuffer, 314 lrTileLineVBuffer, 315 "LoopRestorationFilterTileReadWriteLineVBuffer")); 316 317 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineYBuffer)) 318 { 319 DECODE_CHK_STATUS(AllocateBuffer( 320 m_deblockerFilterLineReadWriteYBuffer, 321 deblockLineYBuffer, 322 "DeblockerFilterLineReadWriteYBuffer")); 323 } 324 325 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineUBuffer)) 326 { 327 DECODE_CHK_STATUS(AllocateBuffer( 328 m_deblockerFilterLineReadWriteUBuffer, 329 deblockLineUBuffer, 330 "DeblockerFilterLineReadWriteUBuffer")); 331 } 332 333 if (!m_avpItf->IsBufferRowstoreCacheEnabled(deblockLineVBuffer)) 334 { 335 DECODE_CHK_STATUS(AllocateBuffer( 336 m_deblockerFilterLineReadWriteVBuffer, 337 deblockLineVBuffer, 338 "DeblockerFilterLineReadWriteVBuffer")); 339 } 340 341 // Deblocking Filter Tile Line Y Buffer 342 DECODE_CHK_STATUS(AllocateBuffer( 343 m_deblockerFilterTileLineReadWriteYBuffer, 344 deblockTileLineYBuffer, 345 "DeblockerFilterTileLineReadWriteYBuffer")); 346 347 // Deblocking Filter Tile Line V Buffer 348 DECODE_CHK_STATUS(AllocateBuffer( 349 m_deblockerFilterTileLineReadWriteVBuffer, 350 deblockTileLineVBuffer, 351 "DeblockerFilterTileLineReadWriteVBuffer")); 352 353 // Deblocking Filter Tile Line U Buffer 354 DECODE_CHK_STATUS(AllocateBuffer( 355 m_deblockerFilterTileLineReadWriteUBuffer, 356 deblockTileLineUBuffer, 357 "DeblockerFilterTileLineReadWriteUBuffer")); 358 359 // Deblocking Filter Tile Column Y Buffer 360 DECODE_CHK_STATUS(AllocateBuffer( 361 m_deblockerFilterTileColumnReadWriteYBuffer, 362 deblockTileColYBuffer, 363 "DeblockerFilterTileColumnReadWriteYBuffer")); 364 365 // Deblocking Filter Tile Column U Buffer 366 DECODE_CHK_STATUS(AllocateBuffer( 367 m_deblockerFilterTileColumnReadWriteUBuffer, 368 deblockTileColUBuffer, 369 "DeblockerFilterTileColumnReadWriteUBuffer")); 370 371 // Deblocking Filter Tile Column V Buffer 372 DECODE_CHK_STATUS(AllocateBuffer( 373 m_deblockerFilterTileColumnReadWriteVBuffer, 374 deblockTileColVBuffer, 375 "DeblockerFilterTileColumnReadWriteVBuffer")); 376 377 // CDEF Filter Line Read/Write Buffer 378 if (!m_avpItf->IsBufferRowstoreCacheEnabled(cdefLineBuffer)) 379 { 380 DECODE_CHK_STATUS(AllocateBuffer( 381 m_cdefFilterLineReadWriteBuffer, 382 cdefLineBuffer, 383 "CdefFilterLineReadWriteBuffer")); 384 } 385 386 // CDEF Filter Tile Line Read/Write Buffer 387 DECODE_CHK_STATUS(AllocateBuffer( 388 m_cdefFilterTileLineReadWriteBuffer, 389 cdefTileLineBuffer, 390 "CdefFilterTileLineReadWriteBuffer")); 391 392 // CDEF Filter Tile Column Read/Write Buffer 393 DECODE_CHK_STATUS(AllocateBuffer( 394 m_cdefFilterTileColumnReadWriteBuffer, 395 cdefTileColBuffer, 396 "CdefFilterTileColumnReadWriteBuffer")); 397 398 // CDEF Filter Meta Tile Line Read Write Buffer 399 DECODE_CHK_STATUS(AllocateBuffer( 400 m_cdefFilterMetaTileLineReadWriteBuffer, 401 cdefMetaTileLineBuffer, 402 "CdefFilterMetaTileLineReadWriteBuffer")); 403 404 // CDEF Filter Meta Tile Column Read Write Buffer 405 DECODE_CHK_STATUS(AllocateBuffer( 406 m_cdefFilterMetaTileColumnReadWriteBuffer, 407 cdefMetaTileColBuffer, 408 "CdefFilterMetaTileColumnReadWriteBuffer")); 409 410 // Cdef Filter Top Left Corner Buffer 411 DECODE_CHK_STATUS(AllocateBuffer( 412 m_cdefFilterTopLeftCornerReadWriteBuffer, 413 cdefTopLeftCornerBuffer, 414 "CdefFilterTopLeftCornerReadWriteBuffer")); 415 416 // Super-Res Tile Column Y Buffer 417 DECODE_CHK_STATUS(AllocateBuffer( 418 m_superResTileColumnReadWriteYBuffer, 419 superResTileColYBuffer, 420 "SuperResTileColumnReadWriteYBuffer")); 421 422 // Super-Res Tile Column U Buffer 423 DECODE_CHK_STATUS(AllocateBuffer( 424 m_superResTileColumnReadWriteUBuffer, 425 superResTileColUBuffer, 426 "SuperResTileColumnReadWriteUBuffer")); 427 428 // Super-Res Tile Column V Buffer 429 DECODE_CHK_STATUS(AllocateBuffer( 430 m_superResTileColumnReadWriteVBuffer, 431 superResTileColVBuffer, 432 "SuperResTileColumnReadWriteVBuffer")); 433 434 // Loop Restoration Filter Tile Column Y Buffer 435 DECODE_CHK_STATUS(AllocateBuffer( 436 m_loopRestorationFilterTileColumnReadWriteYBuffer, 437 lrTileColYBuffer, 438 "LoopRestorationFilterTileColumnReadWriteYBuffer")); 439 440 // Loop Restoration Filter Tile Column U Buffer 441 DECODE_CHK_STATUS(AllocateBuffer( 442 m_loopRestorationFilterTileColumnReadWriteUBuffer, 443 lrTileColUBuffer, 444 "LoopRestorationFilterTileColumnReadWriteUBuffer")); 445 446 // Loop Restoration Filter Tile Column V Buffer 447 DECODE_CHK_STATUS(AllocateBuffer( 448 m_loopRestorationFilterTileColumnReadWriteVBuffer, 449 lrTileColVBuffer, 450 "LoopRestorationFilterTileColumnReadWriteVBuffer")); 451 452 // Decoded Frame Status Error Buffer 453 DECODE_CHK_STATUS(AllocateBuffer( 454 m_decodedFrameStatusErrorBuffer, 455 frameStatusErrBuffer, 456 "DecodedFrameStatusErrorBuffer")); 457 458 // Decoded Block Data Streamout Buffer 459 DECODE_CHK_STATUS(AllocateBuffer( 460 m_decodedBlockDataStreamoutBuffer, 461 dbdStreamoutBuffer, 462 "DecodedBlockDataStreamoutBuffer")); 463 464 // Film Grain sample template buffer 465 DECODE_CHK_STATUS(AllocateBuffer( 466 m_filmGrainSampleTemplateBuf, 467 fgSampleTmpBuffer, 468 "FilmGrainSampleTemplateBuf")); 469 470 // Film Grain tile column data read/write buffer 471 DECODE_CHK_STATUS(AllocateBuffer( 472 m_filmGrainTileColumnDataBuf, 473 fgTileColBuffer, 474 "FilmGrainTileColumnBuf")); 475 476 // Loop restoration filter tile column alignment read/write buffer 477 DECODE_CHK_STATUS(AllocateBuffer( 478 m_loopRestorationFilterTileColumnAlignmentBuf, 479 lrTileColAlignBuffer, 480 "LoopRestorationFilterTileColumnAlignmentBuf")); 481 482 return MOS_STATUS_SUCCESS; 483 } 484 CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)485 MOS_STATUS Av1DecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize) 486 { 487 DECODE_FUNC_CALL(); 488 489 commandBufferSize = m_pictureStatesSize; 490 requestedPatchListSize = m_picturePatchListSize; 491 492 return MOS_STATUS_SUCCESS; 493 } 494 AddAllCmds_AVP_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER & cmdBuffer)495 MOS_STATUS Av1DecodePicPkt::AddAllCmds_AVP_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER& cmdBuffer) 496 { 497 DECODE_FUNC_CALL(); 498 499 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after AVP Pipemode select. 500 auto &mfxWaitParams = m_miItf->MHW_GETPAR_F(MFX_WAIT)(); 501 mfxWaitParams = {}; 502 mfxWaitParams.iStallVdboxPipeline = true; 503 DECODE_CHK_STATUS((m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer))); 504 DECODE_CHK_NULL(m_avpItf); 505 506 SETPAR_AND_ADDCMD(AVP_PIPE_MODE_SELECT, m_avpItf, &cmdBuffer); 507 508 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after AVP Pipemode select. 509 mfxWaitParams = {}; 510 mfxWaitParams.iStallVdboxPipeline = true; 511 DECODE_CHK_STATUS((m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer))); 512 513 return MOS_STATUS_SUCCESS; 514 } 515 MHW_SETPAR_DECL_SRC(AVP_PIPE_MODE_SELECT,Av1DecodePicPkt)516 MHW_SETPAR_DECL_SRC(AVP_PIPE_MODE_SELECT, Av1DecodePicPkt) 517 { 518 params.codecStandardSelect = 2; 519 params.codecSelect = 0; 520 521 return MOS_STATUS_SUCCESS; 522 } 523 MHW_SETPAR_DECL_SRC(AVP_IND_OBJ_BASE_ADDR_STATE,Av1DecodePicPkt)524 MHW_SETPAR_DECL_SRC(AVP_IND_OBJ_BASE_ADDR_STATE, Av1DecodePicPkt) 525 { 526 params.Mode = CODECHAL_DECODE_MODE_AV1VLD; 527 params.dataSize = m_av1BasicFeature->m_dataSize; 528 params.dataOffset = m_av1BasicFeature->m_dataOffset; 529 params.dataBuffer = &(m_av1BasicFeature->m_resDataBuffer.OsResource); 530 531 return MOS_STATUS_SUCCESS; 532 } 533 MHW_SETPAR_DECL_SRC(AVP_PIC_STATE,Av1DecodePicPkt)534 MHW_SETPAR_DECL_SRC(AVP_PIC_STATE, Av1DecodePicPkt) 535 { 536 params.frameWidthMinus1 = m_av1PicParams->m_frameWidthMinus1; 537 params.frameHeightMinus1 = m_av1PicParams->m_frameHeightMinus1; 538 539 if (m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingX == 1 && m_av1PicParams->m_seqInfoFlags.m_fields.m_subsamplingY == 1) 540 { 541 if (!m_av1PicParams->m_seqInfoFlags.m_fields.m_monoChrome && 542 (m_av1PicParams->m_bitDepthIdx == 0 || m_av1PicParams->m_bitDepthIdx == 1)) 543 { 544 //4:2:0 545 params.chromaFormat = av1ChromaFormatYuv420; 546 } 547 else 548 { 549 return MOS_STATUS_PLATFORM_NOT_SUPPORTED; 550 } 551 } 552 553 params.bitDepthIdc = m_av1PicParams->m_bitDepthIdx; 554 params.superblockSizeUsed = m_av1PicParams->m_seqInfoFlags.m_fields.m_use128x128Superblock; 555 params.enableOrderHint = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint; 556 params.orderHintBitsMinus1 = (m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint)? m_av1PicParams->m_orderHintBitsMinus1 : 0; 557 params.enableFilterIntra = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableFilterIntra; 558 params.enableIntraEdgeFilter = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableIntraEdgeFilter; 559 params.enableDualFilter = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableDualFilter; 560 params.enableInterIntraCompound = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableInterintraCompound; 561 params.enableMaskedCompound = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableMaskedCompound; 562 params.enableJointCompound = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableJntComp; 563 564 params.allowScreenContentTools = m_av1PicParams->m_picInfoFlags.m_fields.m_allowScreenContentTools; 565 params.forceIntegerMv = m_av1PicParams->m_picInfoFlags.m_fields.m_forceIntegerMv; 566 params.allowWarpedMotion = m_av1PicParams->m_picInfoFlags.m_fields.m_allowWarpedMotion; 567 params.enableCDEF = !(m_av1PicParams->m_losslessMode || m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc 568 || !m_av1PicParams->m_seqInfoFlags.m_fields.m_enableCdef); // coded lossless is used here 569 params.enableSuperres = m_av1PicParams->m_picInfoFlags.m_fields.m_useSuperres; 570 params.enableRestoration = m_av1PicParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType != 0 || 571 m_av1PicParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType != 0 || 572 m_av1PicParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType != 0; 573 params.enableLargeScaleTile = m_av1PicParams->m_picInfoFlags.m_fields.m_largeScaleTile; 574 params.frameType = m_av1PicParams->m_picInfoFlags.m_fields.m_frameType; 575 params.errorResilientMode = m_av1PicParams->m_picInfoFlags.m_fields.m_errorResilientMode; 576 params.allowIntraBC = m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc; 577 params.primaryRefFrame = m_av1PicParams->m_primaryRefFrame; 578 params.segmentParams = m_av1PicParams->m_av1SegData; 579 params.deltaQPresentFlag = m_av1PicParams->m_modeControlFlags.m_fields.m_deltaQPresentFlag; 580 params.log2DeltaQRes = m_av1PicParams->m_modeControlFlags.m_fields.m_log2DeltaQRes; 581 params.codedLossless = m_av1PicParams->m_losslessMode; 582 params.baseQindex = m_av1PicParams->m_baseQindex; 583 params.yDcDeltaQ = m_av1PicParams->m_yDcDeltaQ; 584 585 params.uDcDeltaQ = m_av1PicParams->m_uDcDeltaQ; 586 params.uAcDeltaQ = m_av1PicParams->m_uAcDeltaQ; 587 params.vDcDeltaQ = m_av1PicParams->m_vDcDeltaQ; 588 params.vAcDeltaQ = m_av1PicParams->m_vAcDeltaQ; 589 590 params.allowHighPrecisionMV = m_av1PicParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv; 591 params.referenceSelect = !(m_av1PicParams->m_modeControlFlags.m_fields.m_referenceMode == singleReference); 592 params.interpFilter = m_av1PicParams->m_interpFilter; 593 params.motionModeSwitchable = m_av1PicParams->m_picInfoFlags.m_fields.m_isMotionModeSwitchable; 594 params.useReferenceFrameMvSet = m_av1PicParams->m_picInfoFlags.m_fields.m_useRefFrameMvs; 595 params.currentOrderHint = m_av1PicParams->m_orderHint; 596 params.reducedTxSetUsed = m_av1PicParams->m_modeControlFlags.m_fields.m_reducedTxSetUsed; 597 params.txMode = m_av1PicParams->m_modeControlFlags.m_fields.m_txMode; 598 params.skipModePresent = m_av1PicParams->m_modeControlFlags.m_fields.m_skipModePresent; 599 params.applyFilmGrainFlag = m_av1PicParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_applyGrain ? 1: 0; 600 601 DECODE_CHK_STATUS(SetRefPicStateParam()); 602 DECODE_CHK_STATUS(SetSkipModeFrameParam()); 603 604 uint8_t idx = 0; 605 for (uint32_t frame = (uint32_t)lastFrame; frame <= (uint32_t)altRefFrame; frame++) 606 { 607 params.warpParamsArrayProjection[idx++] = CAT2SHORTS(m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[0], m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[1]); 608 params.warpParamsArrayProjection[idx++] = CAT2SHORTS(m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[2], m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[3]); 609 params.warpParamsArrayProjection[idx++] = CAT2SHORTS(m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[4], m_av1PicParams->m_wm[frame - lastFrame].m_wmmat[5]); 610 } 611 612 return MOS_STATUS_SUCCESS; 613 } 614 MHW_SETPAR_DECL_SRC(AVP_INTER_PRED_STATE,Av1DecodePicPkt)615 MHW_SETPAR_DECL_SRC(AVP_INTER_PRED_STATE, Av1DecodePicPkt) 616 { 617 if(!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType) && 618 m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint) 619 { 620 for (auto ref = 0; ref < av1NumInterRefFrames; ref++) 621 { 622 uint8_t refPicIndex = m_av1PicParams->m_refFrameIdx[ref]; 623 if (!CodecHal_PictureIsInvalid(m_av1PicParams->m_refFrameMap[refPicIndex])) 624 { 625 uint8_t refFrameIdx = m_av1PicParams->m_refFrameMap[refPicIndex].FrameIdx; 626 for (auto i = 0; i < 7; i++) 627 { 628 params.savedRefOrderHints[ref][i] = m_av1BasicFeature->m_refFrames.m_refList[refFrameIdx]->m_refOrderHint[i]; 629 } 630 } 631 } 632 633 DECODE_CHK_STATUS(m_av1BasicFeature->m_refFrames.SetupMotionFieldProjection(*m_av1PicParams)); 634 635 params.refMaskMfProj = m_av1PicParams->m_activeRefBitMaskMfmv[0] | 636 (m_av1PicParams->m_activeRefBitMaskMfmv[1] << 1) | 637 (m_av1PicParams->m_activeRefBitMaskMfmv[2] << 2) | 638 (m_av1PicParams->m_activeRefBitMaskMfmv[3] << 3) | 639 (m_av1PicParams->m_activeRefBitMaskMfmv[4] << 4) | 640 (m_av1PicParams->m_activeRefBitMaskMfmv[5] << 5) | 641 (m_av1PicParams->m_activeRefBitMaskMfmv[6] << 6); 642 } 643 644 return MOS_STATUS_SUCCESS; 645 } 646 AddAllCmds_AVP_SEGMENT_STATE(MOS_COMMAND_BUFFER & cmdBuffer)647 MOS_STATUS Av1DecodePicPkt::AddAllCmds_AVP_SEGMENT_STATE(MOS_COMMAND_BUFFER& cmdBuffer) 648 { 649 DECODE_FUNC_CALL(); 650 651 auto &par = m_avpItf->MHW_GETPAR_F(AVP_SEGMENT_STATE)(); 652 par = {}; 653 654 MOS_SecureMemcpy( 655 &par.av1SegmentParams, 656 sizeof(par.av1SegmentParams), 657 m_av1BasicFeature->m_segmentParams, 658 sizeof(par.av1SegmentParams)); 659 660 for (uint8_t i = 0; i < av1MaxSegments; i++) 661 { 662 par.currentSegmentId = i; 663 DECODE_CHK_STATUS(m_avpItf->MHW_ADDCMD_F(AVP_SEGMENT_STATE)(&cmdBuffer)); 664 665 if (m_av1PicParams->m_av1SegData.m_enabled == 0) 666 { 667 break; 668 } 669 } 670 671 return MOS_STATUS_SUCCESS; 672 } 673 AddAllCmds_AVP_SURFACE_STATE(MOS_COMMAND_BUFFER & cmdBuffer)674 MOS_STATUS Av1DecodePicPkt::AddAllCmds_AVP_SURFACE_STATE(MOS_COMMAND_BUFFER& cmdBuffer) 675 { 676 DECODE_FUNC_CALL(); 677 678 m_curAvpSurfStateId = reconPic; 679 SETPAR_AND_ADDCMD(AVP_SURFACE_STATE, m_avpItf, &cmdBuffer); 680 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 681 { 682 for (uint8_t i = 0; i < av1TotalRefsPerFrame; i++) 683 { 684 m_curAvpSurfStateId = i + av1IntraFrame; 685 686 //set for intra frame 687 m_refSurface[0] = m_av1BasicFeature->m_destSurface; 688 GetSurfaceMmcInfo(const_cast<PMOS_SURFACE>(&m_refSurface[0]), m_refMmcState[0], m_refCompressionFormat); 689 Av1ReferenceFrames &refFrames = m_av1BasicFeature->m_refFrames; 690 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_av1PicParams, 691 m_av1BasicFeature->m_av1TileParams[m_av1BasicFeature->m_tileCoding.m_curTile]); 692 693 for (uint8_t i = 0; i < activeRefList.size(); i++) 694 { 695 PMOS_RESOURCE refResource[av1NumInterRefFrames]; 696 uint8_t frameIdx = activeRefList[i]; 697 auto refSuf = refFrames.GetReferenceByFrameIndex(frameIdx); 698 if (refSuf != nullptr) 699 { 700 m_refSurface[i + 1].OsResource = *refSuf; 701 GetSurfaceMmcInfo(const_cast<PMOS_SURFACE>(&m_refSurface[i + 1]), m_refMmcState[i + 1], m_refCompressionFormat); 702 } 703 } 704 705 SETPAR_AND_ADDCMD(AVP_SURFACE_STATE, m_avpItf, &cmdBuffer); 706 } 707 } 708 709 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 710 { 711 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(m_intrabcDecodedOutputFrameBuffer)); 712 m_curAvpSurfStateId = intrabcDecodedFrame; 713 SETPAR_AND_ADDCMD(AVP_SURFACE_STATE, m_avpItf, &cmdBuffer); 714 } 715 716 if (m_av1PicParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_applyGrain) 717 { 718 m_curAvpSurfStateId = filmGrainPic; 719 SETPAR_AND_ADDCMD(AVP_SURFACE_STATE, m_avpItf, &cmdBuffer); 720 } 721 722 return MOS_STATUS_SUCCESS; 723 } 724 MHW_SETPAR_DECL_SRC(AVP_SURFACE_STATE,Av1DecodePicPkt)725 MHW_SETPAR_DECL_SRC(AVP_SURFACE_STATE, Av1DecodePicPkt) 726 { 727 MOS_MEMCOMP_STATE mmcState = {}; 728 params.surfaceStateId = m_curAvpSurfStateId; 729 params.bitDepthLumaMinus8 = m_av1PicParams->m_bitDepthIdx << 1; 730 731 if (params.bitDepthLumaMinus8 == 0) 732 { 733 params.srcFormat = mhw::vdbox::avp::SURFACE_FORMAT::SURFACE_FORMAT_PLANAR4208; 734 } 735 else 736 { 737 params.srcFormat = mhw::vdbox::avp::SURFACE_FORMAT::SURFACE_FORMAT_P010; 738 } 739 740 switch (params.surfaceStateId) 741 { 742 case reconPic: 743 params.pitch = m_av1BasicFeature->m_destSurface.dwPitch; 744 params.uOffset = m_av1BasicFeature->m_destSurface.YoffsetForUplane; 745 params.vOffset = 0; 746 DECODE_CHK_STATUS(GetSurfaceMmcInfo(&m_av1BasicFeature->m_destSurface, 747 mmcState, params.compressionFormat)); 748 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState); 749 break; 750 case intrabcDecodedFrame: 751 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(m_intrabcDecodedOutputFrameBuffer)); 752 params.pitch = m_intrabcDecodedOutputFrameBuffer->dwPitch; 753 params.uOffset = m_intrabcDecodedOutputFrameBuffer->YoffsetForUplane; 754 params.vOffset = 0; 755 break; 756 case av1IntraFrame: 757 case av1LastRef: 758 case av1Last2Ref: 759 case av1Last3Ref: 760 case av1GoldRef: 761 case av1BwdRef: 762 case av1AltRef2: 763 case av1AltRef: 764 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(const_cast<PMOS_SURFACE>(&m_refSurface[params.surfaceStateId - av1IntraFrame]))); 765 params.pitch = m_refSurface[params.surfaceStateId - av1IntraFrame].dwPitch; 766 params.uOffset = m_refSurface[params.surfaceStateId - av1IntraFrame].YoffsetForUplane; 767 params.vOffset = 0; 768 std::copy(std::begin(m_refMmcState), std::end(m_refMmcState), params.mmcState); 769 params.compressionFormat = m_refCompressionFormat; 770 break; 771 case filmGrainPic: 772 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface)); 773 params.pitch = m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface->dwPitch; 774 params.uOffset = m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface->YoffsetForUplane; 775 params.vOffset = 0; 776 DECODE_CHK_STATUS(GetSurfaceMmcInfo(m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface, 777 mmcState, params.compressionFormat)); 778 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState); 779 break; 780 } 781 782 return MOS_STATUS_SUCCESS; 783 } 784 MHW_SETPAR_DECL_SRC(AVP_PIPE_BUF_ADDR_STATE,Av1DecodePicPkt)785 MHW_SETPAR_DECL_SRC(AVP_PIPE_BUF_ADDR_STATE, Av1DecodePicPkt) 786 { 787 if (m_av1PicParams->m_picInfoFlags.m_fields.m_allowIntrabc) 788 { 789 params.intrabcDecodedOutputFrameBuffer = &m_intrabcDecodedOutputFrameBuffer->OsResource; 790 } 791 792 params.decodedPic = &(m_av1BasicFeature->m_destSurface); 793 params.bsLineRowstoreBuffer = &m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer->OsResource; 794 params.bsTileLineRowstoreBuffer = &m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer->OsResource; 795 params.intraPredLineRowstoreBuffer = &m_intraPredictionLineRowstoreReadWriteBuffer->OsResource; 796 params.intraPredTileLineRowstoreBuffer = &m_intraPredictionTileLineRowstoreReadWriteBuffer->OsResource; 797 params.spatialMVLineBuffer = &m_spatialMotionVectorLineReadWriteBuffer->OsResource; 798 params.spatialMVCodingTileLineBuffer = &m_spatialMotionVectorCodingTileLineReadWriteBuffer->OsResource; 799 params.lrMetaTileColumnBuffer = &m_loopRestorationMetaTileColumnReadWriteBuffer->OsResource; 800 params.lrTileLineYBuffer = &m_loopRestorationFilterTileReadWriteLineYBuffer->OsResource; 801 params.lrTileLineUBuffer = &m_loopRestorationFilterTileReadWriteLineUBuffer->OsResource; 802 params.lrTileLineVBuffer = &m_loopRestorationFilterTileReadWriteLineVBuffer->OsResource; 803 params.deblockLineYBuffer = &m_deblockerFilterLineReadWriteYBuffer->OsResource; 804 params.deblockLineUBuffer = &m_deblockerFilterLineReadWriteUBuffer->OsResource; 805 params.deblockLineVBuffer = &m_deblockerFilterLineReadWriteVBuffer->OsResource; 806 params.deblockTileLineYBuffer = &m_deblockerFilterTileLineReadWriteYBuffer->OsResource; 807 params.deblockTileLineUBuffer = &m_deblockerFilterTileLineReadWriteUBuffer->OsResource; 808 params.deblockTileLineVBuffer = &m_deblockerFilterTileLineReadWriteVBuffer->OsResource; 809 params.deblockTileColumnYBuffer = &m_deblockerFilterTileColumnReadWriteYBuffer->OsResource; 810 params.deblockTileColumnUBuffer = &m_deblockerFilterTileColumnReadWriteUBuffer->OsResource; 811 params.deblockTileColumnVBuffer = &m_deblockerFilterTileColumnReadWriteVBuffer->OsResource; 812 params.cdefLineBuffer = &m_cdefFilterLineReadWriteBuffer->OsResource; 813 params.cdefTileLineBuffer = &m_cdefFilterTileLineReadWriteBuffer->OsResource; 814 params.cdefTileColumnBuffer = &m_cdefFilterTileColumnReadWriteBuffer->OsResource; 815 params.cdefMetaTileLineBuffer = &m_cdefFilterMetaTileLineReadWriteBuffer->OsResource; 816 params.cdefMetaTileColumnBuffer = &m_cdefFilterMetaTileColumnReadWriteBuffer->OsResource; 817 params.cdefTopLeftCornerBuffer = &m_cdefFilterTopLeftCornerReadWriteBuffer->OsResource; 818 params.superResTileColumnYBuffer = &m_superResTileColumnReadWriteYBuffer->OsResource; 819 params.superResTileColumnUBuffer = &m_superResTileColumnReadWriteUBuffer->OsResource; 820 params.superResTileColumnVBuffer = &m_superResTileColumnReadWriteVBuffer->OsResource; 821 params.lrTileColumnYBuffer = &m_loopRestorationFilterTileColumnReadWriteYBuffer->OsResource; 822 params.lrTileColumnUBuffer = &m_loopRestorationFilterTileColumnReadWriteUBuffer->OsResource; 823 params.lrTileColumnVBuffer = &m_loopRestorationFilterTileColumnReadWriteVBuffer->OsResource; 824 params.decodedFrameStatusErrorBuffer = &m_decodedFrameStatusErrorBuffer->OsResource; 825 params.decodedBlockDataStreamoutBuffer = &m_decodedBlockDataStreamoutBuffer->OsResource; 826 params.filmGrainTileColumnDataBuffer = &m_filmGrainTileColumnDataBuf->OsResource; 827 params.filmGrainSampleTemplateBuffer = &m_filmGrainSampleTemplateBuf->OsResource; 828 params.lrTileColumnAlignBuffer = &m_loopRestorationFilterTileColumnAlignmentBuf->OsResource; 829 830 if (m_av1PicParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_applyGrain) 831 { 832 params.filmGrainOutputSurface = &(m_av1BasicFeature->m_filmGrainProcParams->m_outputSurface->OsResource); 833 } 834 835 auto tempBuffers = &(m_av1BasicFeature->m_tempBuffers); 836 PMOS_BUFFER curMvBuffer = tempBuffers->GetCurBuffer()->mvBuf; 837 DECODE_CHK_NULL(curMvBuffer); 838 params.curMvTempBuffer = &(curMvBuffer->OsResource); 839 840 Av1ReferenceFrames &refFrames = m_av1BasicFeature->m_refFrames; 841 uint8_t prevFrameIdx = refFrames.GetPrimaryRefIdx(); 842 843 uint32_t refSize = 0; 844 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != keyFrame) 845 { 846 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList( 847 *m_av1PicParams, m_av1BasicFeature->m_av1TileParams[m_av1BasicFeature->m_tileCoding.m_curTile]); 848 refSize = activeRefList.size(); 849 850 //set for INTRA_FRAME 851 params.refs[0] = &m_av1BasicFeature->m_destSurface.OsResource; 852 params.colMvTempBuffer[0] = &(curMvBuffer->OsResource); 853 854 for (uint8_t i = 0; i < activeRefList.size(); i++) 855 { 856 uint8_t frameIdx = activeRefList[i]; 857 params.refs[i + lastFrame] = refFrames.GetReferenceByFrameIndex(frameIdx); 858 auto tempBuf = tempBuffers->GetBufferByFrameIndex(frameIdx); 859 params.colMvTempBuffer[i + lastFrame] = tempBuf ? &(tempBuf->mvBuf->OsResource) : nullptr; 860 } 861 } 862 863 DECODE_CHK_STATUS(RefAddrErrorConcel()); 864 865 DECODE_CHK_NULL(tempBuffers->GetCurBuffer()->initCdfBuf); 866 PMOS_BUFFER curInitCdfBuffer = tempBuffers->GetCurBuffer()->initCdfBuf->buffer; 867 DECODE_CHK_NULL(curInitCdfBuffer); 868 params.cdfTableInitBuffer = &(curInitCdfBuffer->OsResource); 869 870 if (!m_av1PicParams->m_picInfoFlags.m_fields.m_disableFrameEndUpdateCdf) 871 { 872 PMOS_BUFFER curBwdCdfBuffer = tempBuffers->GetCurBuffer()->bwdAdaptCdfBuf.buffer; 873 DECODE_CHK_NULL(curBwdCdfBuffer); 874 params.cdfTableBwdAdaptBuffer = &(curBwdCdfBuffer->OsResource); 875 } 876 877 if (m_av1PicParams->m_av1SegData.m_enabled && m_av1PicParams->m_av1SegData.m_updateMap) 878 { 879 PMOS_BUFFER curSegIDWriteBuffer = tempBuffers->GetCurBuffer()->segIdWriteBuf.buffer; 880 DECODE_CHK_NULL(curSegIDWriteBuffer); 881 params.segmentIdWriteBuffer = &(curSegIDWriteBuffer->OsResource); 882 } 883 884 if (m_av1PicParams->m_av1SegData.m_enabled) 885 { 886 bool useSegMapFromPrevFrame = m_av1PicParams->m_av1SegData.m_temporalUpdate || 887 !m_av1PicParams->m_av1SegData.m_updateMap; 888 if (useSegMapFromPrevFrame && refFrames.CheckSegForPrimFrame(*m_av1PicParams)) 889 { 890 auto tempBuf = tempBuffers->GetBufferByFrameIndex(prevFrameIdx); 891 auto segIdBuf = tempBuf ? tempBuf->segIdBuf : nullptr; 892 auto buf = segIdBuf ? segIdBuf->buffer : nullptr; 893 params.segmentIdReadBuffer = buf ? &(buf->OsResource) : nullptr; 894 } 895 } 896 897 #ifdef _MMC_SUPPORTED 898 if (m_mmcState && m_mmcState->IsMmcEnabled()) 899 { 900 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_av1BasicFeature->m_destSurface), ¶ms.mmcStatePreDeblock)); 901 }; 902 #endif 903 904 #if USE_CODECHAL_DEBUG_TOOL 905 DECODE_CHK_STATUS(DumpResources(refSize)); 906 #endif 907 908 return MOS_STATUS_SUCCESS; 909 } 910 RefAddrErrorConcel() const911 MOS_STATUS Av1DecodePicPkt::RefAddrErrorConcel() const 912 { 913 DECODE_FUNC_CALL(); 914 915 auto &par = m_avpItf->MHW_GETPAR_F(AVP_PIPE_BUF_ADDR_STATE)(); 916 917 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType == keyFrame) 918 { 919 for (auto i = 0; i < av1TotalRefsPerFrame; i++) 920 { 921 par.refs[i] = nullptr; 922 } 923 } 924 else 925 { 926 PMOS_RESOURCE validRefPic = m_av1BasicFeature->m_refFrames.GetValidReference(); 927 if (validRefPic == nullptr) 928 { 929 validRefPic = &m_av1BasicFeature->m_destSurface.OsResource; 930 } 931 for (uint8_t i = 0; i < av1TotalRefsPerFrame; i++) 932 { 933 // error concealment for the unset reference addresses and unset mv buffers 934 if (par.refs[i] == nullptr) 935 { 936 par.refs[i] = validRefPic; 937 } 938 } 939 940 PMOS_BUFFER validMvBuf = m_av1BasicFeature->m_tempBuffers.GetValidBufferForReference( 941 m_av1BasicFeature->m_refFrameIndexList)->mvBuf; 942 for (uint32_t i = 0; i < CODEC_NUM_AV1_TEMP_BUFFERS; i++) 943 { 944 if (par.colMvTempBuffer[i] == nullptr) 945 { 946 par.colMvTempBuffer[i] = &validMvBuf->OsResource; 947 } 948 } 949 } 950 951 PMOS_RESOURCE dummyRef = &(m_av1BasicFeature->m_dummyReference.OsResource); 952 if (m_av1BasicFeature->m_useDummyReference && !m_allocator->ResourceIsNull(dummyRef)) 953 { 954 // set all ref pic addresses to valid addresses for error concealment purpose 955 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++) 956 { 957 if (par.refs[i] == nullptr) 958 { 959 par.refs[i] = dummyRef; 960 } 961 } 962 } 963 964 return MOS_STATUS_SUCCESS; 965 } 966 SetSkipModeFrameParam() const967 MOS_STATUS Av1DecodePicPkt::SetSkipModeFrameParam() const 968 { 969 DECODE_FUNC_CALL(); 970 971 auto &par = m_avpItf->MHW_GETPAR_F(AVP_PIC_STATE)(); 972 973 if (!m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint || 974 AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType) || 975 m_av1PicParams->m_modeControlFlags.m_fields.m_referenceMode == singleReference) 976 { 977 par.skipModeFrame[0] = intraFrame; 978 par.skipModeFrame[1] = intraFrame; 979 } 980 else 981 { 982 int32_t curFrameOffset = m_av1PicParams->m_orderHint; 983 int32_t refFrameOffset[2] = { -1, 0x7fffffff }; 984 int32_t refIdx[2] = { -1, -1 }; 985 Av1ReferenceFrames &refFrames = m_av1BasicFeature->m_refFrames; 986 DECODE_CHK_STATUS(refFrames.Identify1stNearRef(*m_av1PicParams, curFrameOffset, refFrameOffset, refIdx)); 987 988 if (refIdx[0] != -1 && refIdx[1] != -1) 989 { 990 // == Bi-directional prediction == 991 // cm->is_skip_mode_allowed = 1; 992 par.skipModeFrame[0] = AOMMIN(refIdx[0], refIdx[1]); 993 par.skipModeFrame[1] = AOMMAX(refIdx[0], refIdx[1]); 994 } 995 else if (refIdx[0] != -1 && refIdx[1] == -1) 996 { 997 DECODE_CHK_STATUS(refFrames.Identify2ndNearRef(*m_av1PicParams, curFrameOffset, refFrameOffset, refIdx)); 998 if (refFrameOffset[1] != -1) 999 { 1000 par.skipModeFrame[0] = AOMMIN(refIdx[0], refIdx[1]); 1001 par.skipModeFrame[1] = AOMMAX(refIdx[0], refIdx[1]); 1002 } 1003 } 1004 1005 par.skipModeFrame[0] += lastFrame; 1006 par.skipModeFrame[1] += lastFrame; 1007 } 1008 1009 return MOS_STATUS_SUCCESS; 1010 } 1011 SetRefPicStateParam() const1012 MOS_STATUS Av1DecodePicPkt::SetRefPicStateParam() const 1013 { 1014 DECODE_FUNC_CALL(); 1015 1016 auto &par = m_avpItf->MHW_GETPAR_F(AVP_PIC_STATE)(); 1017 1018 uint8_t refFrameSignBias[8] = {}; 1019 auto curRefList = m_av1BasicFeature->m_refFrames.m_currRefList; 1020 PCODEC_PICTURE refFrameList = &(m_av1PicParams->m_refFrameMap[0]); 1021 PCODEC_REF_LIST_AV1 *m_refList = &(m_av1BasicFeature->m_refFrames.m_refList[0]); 1022 1023 for (auto refFrame = (uint32_t)lastFrame; refFrame <= (uint32_t)altRefFrame; refFrame++) //no bias for intra frame 1024 { 1025 if (m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint && 1026 !AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1027 { 1028 int32_t refFrameOffset = -1; 1029 1030 uint8_t refPicIndex = m_av1PicParams->m_refFrameIdx[refFrame - lastFrame]; //0 corresponds to LAST_FRAME 1031 PCODEC_PICTURE refFrameList = &(m_av1PicParams->m_refFrameMap[0]); 1032 1033 if (!CodecHal_PictureIsInvalid(refFrameList[refPicIndex])) 1034 { 1035 uint8_t refFrameIdx = refFrameList[refPicIndex].FrameIdx; 1036 refFrameOffset = m_av1BasicFeature->m_refFrames.m_refList[refFrameIdx]->m_orderHint; 1037 } 1038 1039 int32_t frameOffset = (int32_t)m_av1PicParams->m_orderHint; 1040 refFrameSignBias[refFrame] = (m_av1BasicFeature->m_refFrames.GetRelativeDist(*m_av1PicParams, refFrameOffset, frameOffset) <= 0) ? 0 : 1; 1041 } 1042 else 1043 { 1044 refFrameSignBias[refFrame] = 0; 1045 } 1046 } 1047 1048 par.refFrameRes[intraFrame] = CAT2SHORTS(m_av1PicParams->m_frameWidthMinus1, m_av1PicParams->m_frameHeightMinus1); 1049 par.refScaleFactor[intraFrame] = CAT2SHORTS(m_av1ScalingFactor, m_av1ScalingFactor); 1050 par.refOrderHints[intraFrame] = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint ? curRefList->m_orderHint : 0; 1051 par.refFrameIdx[0] = intraFrame; 1052 par.refFrameSide = 0; 1053 uint32_t horizontalScaleFactor, verticalScaleFactor; 1054 1055 for (auto i = 0; i < av1NumInterRefFrames; i++) 1056 { 1057 uint32_t curFrameWidth = m_av1PicParams->m_frameWidthMinus1 + 1; 1058 uint32_t curFrameHeight = m_av1PicParams->m_frameHeightMinus1 + 1; 1059 1060 par.refFrameBiasFlag |= (refFrameSignBias[i + lastFrame] << (i + lastFrame)); 1061 par.frameLevelGlobalMotionInvalidFlags |= (m_av1PicParams->m_wm[i].m_invalid << (i + lastFrame)); 1062 par.globalMotionType[i] = m_av1PicParams->m_wm[i].m_wmtype; 1063 par.refFrameIdx[i + lastFrame] = i + lastFrame; 1064 1065 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1066 { 1067 uint8_t refPicIndex = refFrameList[m_av1PicParams->m_refFrameIdx[i]].FrameIdx; 1068 horizontalScaleFactor = (m_refList[refPicIndex]->m_frameWidth * m_av1ScalingFactor + (curFrameWidth >> 1)) / curFrameWidth; 1069 verticalScaleFactor = (m_refList[refPicIndex]->m_frameHeight * m_av1ScalingFactor + (curFrameHeight >> 1)) / curFrameHeight; 1070 1071 par.refFrameRes[i + lastFrame] = CAT2SHORTS(m_refList[refPicIndex]->m_frameWidth - 1, m_refList[refPicIndex]->m_frameHeight - 1); 1072 par.refScaleFactor[i + lastFrame] = CAT2SHORTS(verticalScaleFactor, horizontalScaleFactor); 1073 par.refOrderHints[i + lastFrame] = m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint ? curRefList->m_refOrderHint[i] : 0; 1074 } 1075 else 1076 { 1077 par.refFrameRes[i + lastFrame] = par.refFrameRes[intraFrame]; 1078 par.refScaleFactor[i + lastFrame] = par.refScaleFactor[intraFrame]; 1079 par.refOrderHints[i + lastFrame] = par.refOrderHints[intraFrame]; 1080 } 1081 1082 if ((m_av1BasicFeature->m_refFrames.GetRelativeDist(*m_av1PicParams, par.refOrderHints[i + lastFrame], curRefList->m_orderHint) > 0 || 1083 par.refOrderHints[i + lastFrame] == curRefList->m_orderHint) && m_av1PicParams->m_seqInfoFlags.m_fields.m_enableOrderHint) 1084 { 1085 par.refFrameSide |= 1 << (i + lastFrame); 1086 } 1087 } 1088 1089 if (AV1_KEY_OR_INRA_FRAME(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType)) 1090 { 1091 MOS_ZeroMemory(par.refFrameRes, sizeof(par.refFrameRes)); 1092 MOS_ZeroMemory(par.refScaleFactor, sizeof(par.refScaleFactor)); 1093 par.refFrameSide = 0; 1094 } 1095 1096 return MOS_STATUS_SUCCESS; 1097 } 1098 GetSurfaceMmcInfo(PMOS_SURFACE surface,MOS_MEMCOMP_STATE & mmcState,uint32_t & compressionFormat) const1099 MOS_STATUS Av1DecodePicPkt::GetSurfaceMmcInfo(PMOS_SURFACE surface, MOS_MEMCOMP_STATE& mmcState, uint32_t& compressionFormat) const 1100 { 1101 DECODE_FUNC_CALL(); 1102 1103 DECODE_CHK_NULL(surface); 1104 #ifdef _MMC_SUPPORTED 1105 DECODE_CHK_NULL(m_mmcState); 1106 1107 if (m_mmcState->IsMmcEnabled()) 1108 { 1109 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(surface)); 1110 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(surface, &mmcState)); 1111 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(surface, &compressionFormat)); 1112 } 1113 else 1114 #endif 1115 { 1116 mmcState = MOS_MEMCOMP_DISABLED; 1117 } 1118 1119 return MOS_STATUS_SUCCESS; 1120 } 1121 1122 #if USE_CODECHAL_DEBUG_TOOL DumpResources(uint32_t refSize) const1123 MOS_STATUS Av1DecodePicPkt::DumpResources(uint32_t refSize) const 1124 { 1125 DECODE_FUNC_CALL(); 1126 1127 CodechalDebugInterface *debugInterface = m_av1Pipeline->GetDebugInterface(); 1128 debugInterface->m_frameType = m_av1PicParams->m_picInfoFlags.m_fields.m_frameType ? P_TYPE : I_TYPE; 1129 m_av1PicParams->m_currPic.PicFlags = PICTURE_FRAME; 1130 debugInterface->m_currPic = m_av1PicParams->m_currPic; 1131 debugInterface->m_bufferDumpFrameNum = m_av1BasicFeature->m_frameNum; 1132 1133 auto &par = m_avpItf->MHW_GETPAR_F(AVP_PIPE_BUF_ADDR_STATE)(); 1134 1135 if (m_av1PicParams->m_picInfoFlags.m_fields.m_frameType != keyFrame) 1136 { 1137 for (uint32_t n = 0; n < refSize; n++) 1138 { 1139 MOS_SURFACE refSurface; 1140 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 1141 refSurface.OsResource = *(par.refs[n + lastFrame]); 1142 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 1143 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(n)) + "]"; 1144 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 1145 &refSurface, 1146 CodechalDbgAttr::attrDecodeReferenceSurfaces, 1147 refSurfName.c_str())); 1148 } 1149 } 1150 1151 //For multi-tiles per frame case, only need dump these resources once. 1152 if (m_av1BasicFeature->m_tileCoding.m_curTile == 0) 1153 { 1154 if (par.segmentIdReadBuffer != nullptr && 1155 !m_allocator->ResourceIsNull(par.segmentIdReadBuffer)) 1156 { 1157 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 1158 par.segmentIdReadBuffer, 1159 CodechalDbgAttr::attrSegId, 1160 "SegIdReadBuffer", 1161 (m_widthInSb * m_heightInSb * CODECHAL_CACHELINE_SIZE), 1162 CODECHAL_NUM_MEDIA_STATES)); 1163 } 1164 1165 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 1166 par.cdfTableInitBuffer, 1167 CodechalDbgAttr::attrCoefProb, 1168 "CdfTableInitialization", 1169 m_av1BasicFeature->m_cdfMaxNumBytes, 1170 CODECHAL_NUM_MEDIA_STATES)); 1171 } 1172 1173 return MOS_STATUS_SUCCESS; 1174 } 1175 #endif 1176 1177 } 1178