1 /* 2 * Copyright (c) 2020-2022, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file decode_vp8_picture_packet.cpp 24 //! \brief Defines the interface for vp8 decode picture packet 25 //! 26 #include "decode_vp8_picture_packet.h" 27 #include "codechal_debug.h" 28 #include "decode_common_feature_defs.h" 29 #include "decode_vp8_mem_compression.h" 30 31 namespace decode 32 { ~Vp8DecodePicPkt()33 Vp8DecodePicPkt::~Vp8DecodePicPkt() 34 { 35 FreeResources(); 36 } 37 FreeResources()38 MOS_STATUS Vp8DecodePicPkt::FreeResources() 39 { 40 DECODE_FUNC_CALL(); 41 42 if (m_allocator != nullptr) 43 { 44 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer); 45 m_allocator->Destroy(m_resMfdIntraRowStoreScratchBuffer); 46 m_allocator->Destroy(m_resBsdMpcRowStoreScratchBuffer); 47 m_allocator->Destroy(m_resMprRowStoreScratchBuffer); 48 m_allocator->Destroy(m_resSegmentationIdStreamBuffer); 49 } 50 51 return MOS_STATUS_SUCCESS; 52 } 53 Init()54 MOS_STATUS Vp8DecodePicPkt::Init() 55 { 56 DECODE_FUNC_CALL(); 57 58 DECODE_CHK_NULL(m_featureManager); 59 DECODE_CHK_NULL(m_hwInterface); 60 DECODE_CHK_NULL(m_osInterface); 61 DECODE_CHK_NULL(m_miItf); 62 DECODE_CHK_NULL(m_vp8Pipeline); 63 64 m_vp8BasicFeature = dynamic_cast<Vp8BasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 65 DECODE_CHK_NULL(m_vp8BasicFeature); 66 67 m_allocator = m_pipeline->GetDecodeAllocator(); 68 DECODE_CHK_NULL(m_allocator); 69 70 return MOS_STATUS_SUCCESS; 71 } 72 Prepare()73 MOS_STATUS Vp8DecodePicPkt::Prepare() 74 { 75 DECODE_FUNC_CALL(); 76 77 m_vp8PicParams = m_vp8BasicFeature->m_vp8PicParams; 78 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 79 DECODE_CHK_STATUS(SetRowStoreScratchBuffer()); 80 DECODE_CHK_STATUS(SetSegmentationIdStreamBuffer()); 81 82 #ifdef _MMC_SUPPORTED 83 m_mmcState = m_vp8Pipeline->GetMmcState(); 84 DECODE_CHK_NULL(m_mmcState); 85 #endif 86 87 return MOS_STATUS_SUCCESS; 88 } 89 SetRowstoreCachingOffsets()90 MOS_STATUS Vp8DecodePicPkt::SetRowstoreCachingOffsets() 91 { 92 DECODE_FUNC_CALL(); 93 94 if (m_mfxItf->IsRowStoreCachingSupported()) 95 { 96 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams; 97 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams)); 98 rowstoreParams.dwPicWidth = m_vp8BasicFeature->m_width; 99 rowstoreParams.bMbaff = false; 100 rowstoreParams.Mode = CODECHAL_DECODE_MODE_VP8VLD; 101 //DECODE_CHK_STATUS(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams)); 102 DECODE_CHK_STATUS(m_mfxItf->GetRowstoreCachingAddrs(&rowstoreParams)); 103 104 } 105 106 return MOS_STATUS_SUCCESS; 107 } 108 SetRowStoreScratchBuffer()109 MOS_STATUS Vp8DecodePicPkt::SetRowStoreScratchBuffer() 110 { 111 DECODE_FUNC_CALL(); 112 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 113 114 // MfdDeblockingFilterRowStoreScratchBuffer 115 if (m_mfxItf->IsDeblockingFilterRowstoreCacheEnabled() == false) 116 { 117 // Deblocking Filter Row Store Scratch buffer 118 //(Num MacroBlock Width) * (Num Cachlines) * (Cachline size) 119 auto buffer_size = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * 2 * CODECHAL_CACHELINE_SIZE; 120 121 if (m_resMfdDeblockingFilterRowStoreScratchBuffer == nullptr) 122 { 123 m_resMfdDeblockingFilterRowStoreScratchBuffer = m_allocator->AllocateBuffer( 124 buffer_size, "DeblockingScratchBuffer", resourceInternalReadWriteCache, notLockableVideoMem); 125 DECODE_CHK_NULL(m_resMfdDeblockingFilterRowStoreScratchBuffer); 126 } 127 else 128 { 129 DECODE_CHK_STATUS(m_allocator->Resize( 130 m_resMfdDeblockingFilterRowStoreScratchBuffer, buffer_size, notLockableVideoMem)); 131 } 132 } 133 134 // m_resMfdIntraRowStoreScratchBuffer 135 if (m_mfxItf->IsIntraRowstoreCacheEnabled() == false) 136 { 137 // Intra Row Store Scratch buffer 138 // (FrameWidth in MB) * (CacheLine size per MB) 139 auto buffer_size = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * 2 * CODECHAL_CACHELINE_SIZE; 140 141 if (m_resMfdIntraRowStoreScratchBuffer == nullptr) 142 { 143 m_resMfdIntraRowStoreScratchBuffer = m_allocator->AllocateBuffer( 144 buffer_size, "IntraScratchBuffer", resourceInternalReadWriteCache, notLockableVideoMem); 145 DECODE_CHK_NULL(m_resMfdIntraRowStoreScratchBuffer); 146 } 147 else 148 { 149 DECODE_CHK_STATUS(m_allocator->Resize( 150 m_resMfdIntraRowStoreScratchBuffer, buffer_size, notLockableVideoMem)); 151 } 152 } 153 154 // m_resBsdMpcRowStoreScratchBuffer 155 if (m_mfxItf->IsBsdMpcRowstoreCacheEnabled() == false) 156 { 157 // BSD/MPC Row Store Scratch buffer 158 // (FrameWidth in MB) * (2) * (CacheLine size per MB) 159 auto buffer_size = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * CODECHAL_CACHELINE_SIZE; 160 161 if (m_resBsdMpcRowStoreScratchBuffer == nullptr) 162 { 163 m_resBsdMpcRowStoreScratchBuffer = m_allocator->AllocateBuffer( 164 buffer_size, "MpcScratchBuffer", resourceInternalReadWriteCache, notLockableVideoMem); 165 DECODE_CHK_NULL(m_resBsdMpcRowStoreScratchBuffer); 166 } 167 else 168 { 169 DECODE_CHK_STATUS(m_allocator->Resize( 170 m_resBsdMpcRowStoreScratchBuffer, buffer_size, notLockableVideoMem)); 171 } 172 } 173 174 // m_resMprRowStoreScratchBuffer 175 { 176 // MPR Row Store Scratch buffer 177 // (FrameWidth in MB) * (2) * (CacheLine size per MB) 178 auto buffer_size = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * CODECHAL_CACHELINE_SIZE * 22; 179 180 if (m_resMprRowStoreScratchBuffer == nullptr) 181 { 182 m_resMprRowStoreScratchBuffer = m_allocator->AllocateBuffer( 183 buffer_size, "MprScratchBuffer", resourceInternalReadWriteCache, notLockableVideoMem); 184 DECODE_CHK_NULL(m_resMprRowStoreScratchBuffer); 185 } 186 else 187 { 188 DECODE_CHK_STATUS(m_allocator->Resize( 189 m_resMprRowStoreScratchBuffer, buffer_size, notLockableVideoMem)); 190 } 191 } 192 193 return eStatus; 194 } 195 SetSegmentationIdStreamBuffer()196 MOS_STATUS Vp8DecodePicPkt::SetSegmentationIdStreamBuffer(){ 197 DECODE_FUNC_CALL(); 198 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 199 200 // m_resSegmentationIdStreamBuffer 201 //(Num MacroBlocks) * (Cachline size) * (2 bit) 202 uint32_t numMacroblocks = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * (m_vp8PicParams->wFrameHeightInMbsMinus1 + 1); 203 auto buffer_size = MOS_MAX(numMacroblocks * CODECHAL_CACHELINE_SIZE * 2 / 8, 64); 204 205 if (m_resSegmentationIdStreamBuffer == nullptr) 206 { 207 m_resSegmentationIdStreamBuffer = m_allocator->AllocateBuffer( 208 buffer_size, "SegmentationIdStreamBuffer", resourceInternalReadWriteCache, notLockableVideoMem); 209 DECODE_CHK_NULL(m_resSegmentationIdStreamBuffer); 210 } 211 else 212 { 213 DECODE_CHK_STATUS(m_allocator->Resize( 214 m_resSegmentationIdStreamBuffer, buffer_size, notLockableVideoMem)); 215 } 216 217 return eStatus; 218 } 219 MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT,Vp8DecodePicPkt)220 MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT, Vp8DecodePicPkt) 221 { 222 params.Mode = (CODECHAL_MODE)CODECHAL_DECODE_MODE_VP8VLD; 223 params.streamOutEnable = m_vp8BasicFeature->m_streamOutEnabled; 224 225 params.postDeblockingOutputEnablePostdeblockoutenable = m_vp8BasicFeature->m_deblockingEnabled; 226 params.preDeblockingOutputEnablePredeblockoutenable = !m_vp8BasicFeature->m_deblockingEnabled; 227 params.decoderShortFormatMode = !m_vp8BasicFeature->m_shortFormatInUse; 228 params.standardSelect = 5; // CODECHAL_VP8 229 params.decoderModeSelect = 0; // mfxDecoderModeVld 230 return MOS_STATUS_SUCCESS; 231 } 232 MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE,Vp8DecodePicPkt)233 MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE, Vp8DecodePicPkt) 234 { 235 // set cmd function 236 MOS_SURFACE *psSurface = &m_vp8BasicFeature->m_destSurface; 237 238 #ifdef _MMC_SUPPORTED 239 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_vp8BasicFeature->m_destSurface))); 240 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(psSurface, ¶ms.mmcState)); 241 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(psSurface, ¶ms.compressionFormat)); 242 #endif 243 244 params.height = psSurface->dwHeight - 1; 245 params.width = psSurface->dwWidth - 1; 246 params.surfacePitch = psSurface->dwPitch - 1; 247 params.interleaveChroma = 1; 248 params.surfaceFormat = SURFACE_FORMAT_PLANAR4208; 249 250 params.tilemode = m_mfxItf->MosGetHWTileType(psSurface->TileType, psSurface->TileModeGMM, psSurface->bGMMTileEnabled); 251 252 uint32_t uvPlaneAlignment = MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY; 253 if (params.surfaceId == CODECHAL_MFX_SRC_SURFACE_ID) 254 { 255 uvPlaneAlignment = MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9; 256 } 257 else 258 { 259 uvPlaneAlignment = MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY; 260 } 261 262 if (psSurface->Format == Format_P8) // monochrome format 263 { 264 params.interleaveChroma = 0; 265 } 266 267 params.yOffsetForUCb = MOS_ALIGN_CEIL((psSurface->UPlaneOffset.iSurfaceOffset - psSurface->dwOffset) / 268 psSurface->dwPitch + psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment); 269 params.yOffsetForVCr = MOS_ALIGN_CEIL((psSurface->VPlaneOffset.iSurfaceOffset - psSurface->dwOffset) / 270 psSurface->dwPitch + psSurface->RenderOffset.YUV.V.YOffset, uvPlaneAlignment); 271 272 return MOS_STATUS_SUCCESS; 273 } 274 MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE,Vp8DecodePicPkt)275 MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE, Vp8DecodePicPkt) 276 { 277 params.decodeInUse = true; 278 params.Mode = (CODECHAL_MODE)CODECHAL_DECODE_MODE_VP8VLD; 279 280 if (m_vp8BasicFeature->m_deblockingEnabled) 281 { 282 params.psPostDeblockSurface = &(m_vp8BasicFeature->m_destSurface); 283 } 284 else 285 { 286 params.psPreDeblockSurface = &(m_vp8BasicFeature->m_destSurface); 287 } 288 #ifdef _MMC_SUPPORTED 289 auto m_mmcEnabled = m_mmcState->IsMmcEnabled(); 290 Vp8DecodeMemComp *vp8DecodeMemComp = dynamic_cast<Vp8DecodeMemComp *>(m_mmcState); 291 DECODE_CHK_NULL(vp8DecodeMemComp); 292 vp8DecodeMemComp->m_mmcEnabled = m_mmcEnabled; 293 DECODE_CHK_STATUS(vp8DecodeMemComp->SetPipeBufAddr(*m_vp8BasicFeature, params.PostDeblockSurfMmcState, params.PreDeblockSurfMmcState)); 294 #endif 295 296 params.presReferences[CodechalDecodeLastRef] = m_vp8BasicFeature->m_LastRefSurface; 297 params.presReferences[CodechalDecodeGoldenRef] = m_vp8BasicFeature->m_GoldenRefSurface; 298 params.presReferences[CodechalDecodeAlternateRef] = m_vp8BasicFeature->m_AltRefSurface; 299 300 params.presMfdIntraRowStoreScratchBuffer = &(m_resMfdIntraRowStoreScratchBuffer->OsResource); 301 params.presMfdDeblockingFilterRowStoreScratchBuffer = &(m_resMfdDeblockingFilterRowStoreScratchBuffer->OsResource); 302 303 params.references = params.presReferences; 304 305 if (m_vp8BasicFeature->m_streamOutEnabled) 306 { 307 params.presStreamOutBuffer = m_vp8BasicFeature->m_streamOutBuffer; 308 } 309 310 #ifdef _MMC_SUPPORTED 311 DECODE_CHK_STATUS(vp8DecodeMemComp->CheckReferenceList(*m_vp8BasicFeature, params.PostDeblockSurfMmcState, params.PreDeblockSurfMmcState)); 312 #endif 313 314 CODECHAL_DEBUG_TOOL(DumpResources(params)); 315 316 return MOS_STATUS_SUCCESS; 317 } 318 MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE,Vp8DecodePicPkt)319 MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE, Vp8DecodePicPkt) 320 { 321 params.Mode = m_vp8BasicFeature->m_mode; 322 params.dwDataSize = m_vp8BasicFeature->m_dataSize; 323 params.dwDataOffset = m_vp8BasicFeature->m_dataOffset; 324 params.presDataBuffer = & (m_vp8BasicFeature->m_resDataBuffer.OsResource); 325 326 return MOS_STATUS_SUCCESS; 327 } 328 MHW_SETPAR_DECL_SRC(MFX_BSP_BUF_BASE_ADDR_STATE,Vp8DecodePicPkt)329 MHW_SETPAR_DECL_SRC(MFX_BSP_BUF_BASE_ADDR_STATE, Vp8DecodePicPkt) 330 { 331 params.presBsdMpcRowStoreScratchBuffer = &(m_resBsdMpcRowStoreScratchBuffer->OsResource); 332 params.presMprRowStoreScratchBuffer = &(m_resMprRowStoreScratchBuffer->OsResource); 333 334 return MOS_STATUS_SUCCESS; 335 } 336 MHW_SETPAR_DECL_SRC(MFX_VP8_PIC_STATE,Vp8DecodePicPkt)337 MHW_SETPAR_DECL_SRC(MFX_VP8_PIC_STATE, Vp8DecodePicPkt) 338 { 339 auto vp8PicParams = m_vp8BasicFeature->m_vp8PicParams; 340 auto vp8IqMatrixParams = m_vp8BasicFeature->m_vp8IqMatrixParams; 341 params.presSegmentationIdStreamBuffer = &(m_resSegmentationIdStreamBuffer->OsResource); 342 params.dwCoefProbTableOffset = 0; 343 if (m_vp8BasicFeature->m_bitstreamLockingInUse) 344 { 345 params.presCoefProbBuffer = &(m_vp8BasicFeature->m_resCoefProbBufferInternal->OsResource); 346 } 347 else 348 { 349 params.presCoefProbBuffer = &(m_vp8BasicFeature->m_resCoefProbBufferExternal); 350 } 351 352 params.FrameWidthMinus1 = vp8PicParams->wFrameWidthInMbsMinus1; 353 params.FrameHeightMinus1 = vp8PicParams->wFrameHeightInMbsMinus1; 354 params.McFilterSelect = (vp8PicParams->version != 0); 355 params.ChromaFullPixelMcFilterMode = (vp8PicParams->version == 3); 356 params.Dblkfiltertype = vp8PicParams->filter_type; 357 params.Skeyframeflag = vp8PicParams->key_frame; 358 params.SegmentationIdStreamoutEnable = 359 (vp8PicParams->segmentation_enabled) && (vp8PicParams->update_mb_segmentation_map); 360 params.SegmentationIdStreaminEnable = 361 (vp8PicParams->segmentation_enabled) && !(vp8PicParams->update_mb_segmentation_map); 362 params.SegmentEnableFlag = vp8PicParams->segmentation_enabled; 363 params.UpdateMbsegmentMapFlag = 364 (vp8PicParams->segmentation_enabled) ? vp8PicParams->update_mb_segmentation_map : 0; 365 params.MbNocoeffSkipflag = vp8PicParams->mb_no_coeff_skip; 366 params.ModeReferenceLoopFilterDeltaEnabled = vp8PicParams->loop_filter_adj_enable; 367 params.GoldenRefPictureMvSignbiasFlag = vp8PicParams->sign_bias_golden; 368 params.AlternateRefPicMvSignbiasFlag = vp8PicParams->sign_bias_alternate; 369 params.DeblockSharpnessLevel = vp8PicParams->ucSharpnessLevel; 370 params.DblkfilterlevelForSegment3 = vp8PicParams->ucLoopFilterLevel[3]; 371 params.DblkfilterlevelForSegment2 = vp8PicParams->ucLoopFilterLevel[2]; 372 params.DblkfilterlevelForSegment1 = vp8PicParams->ucLoopFilterLevel[1]; 373 params.DblkfilterlevelForSegment0 = vp8PicParams->ucLoopFilterLevel[0]; 374 375 uint32_t i = 0; 376 uint32_t j = 0; 377 params.QuantizerValue0Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j]; 378 params.QuantizerValue0Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 379 380 i = 0; 381 j = 2; 382 params.QuantizerValue0Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j]; 383 params.QuantizerValue0Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1]; 384 385 i = 0; 386 j = 4; 387 params.QuantizerValue0Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j]; 388 params.QuantizerValue0Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 389 390 i = 1; 391 j = 0; 392 params.QuantizerValue1Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j]; 393 params.QuantizerValue1Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 394 395 i = 1; 396 j = 2; 397 params.QuantizerValue1Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j]; 398 params.QuantizerValue1Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1]; 399 400 i = 1; 401 j = 4; 402 params.QuantizerValue1Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j]; 403 params.QuantizerValue1Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 404 405 i = 2; 406 j = 0; 407 params.QuantizerValue2Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j]; 408 params.QuantizerValue2Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 409 410 i = 2; 411 j = 2; 412 params.QuantizerValue2Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j]; 413 params.QuantizerValue2Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1]; 414 415 i = 2; 416 j = 4; 417 params.QuantizerValue2Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j]; 418 params.QuantizerValue2Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 419 420 i = 3; 421 j = 0; 422 params.QuantizerValue3Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j]; 423 params.QuantizerValue3Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 424 425 i = 3; 426 j = 2; 427 params.QuantizerValue3Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j]; 428 params.QuantizerValue3Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1]; 429 430 i = 3; 431 j = 4; 432 params.QuantizerValue3Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j]; 433 params.QuantizerValue3Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1]; 434 435 params.Mbsegmentidtreeprobs2 = vp8PicParams->cMbSegmentTreeProbs[2]; 436 params.Mbsegmentidtreeprobs1 = vp8PicParams->cMbSegmentTreeProbs[1]; 437 params.Mbsegmentidtreeprobs0 = vp8PicParams->cMbSegmentTreeProbs[0]; 438 params.Mbnocoeffskipfalseprob = vp8PicParams->ucProbSkipFalse; 439 params.Intrambprob = vp8PicParams->ucProbIntra; 440 params.Interpredfromlastrefprob = vp8PicParams->ucProbLast; 441 params.Interpredfromgrefrefprob = vp8PicParams->ucProbGolden; 442 params.Ymodeprob3 = vp8PicParams->ucYModeProbs[3]; 443 params.Ymodeprob2 = vp8PicParams->ucYModeProbs[2]; 444 params.Ymodeprob1 = vp8PicParams->ucYModeProbs[1]; 445 params.Ymodeprob0 = vp8PicParams->ucYModeProbs[0]; 446 params.Uvmodeprob2 = vp8PicParams->ucUvModeProbs[2]; 447 params.Uvmodeprob1 = vp8PicParams->ucUvModeProbs[1]; 448 params.Uvmodeprob0 = vp8PicParams->ucUvModeProbs[0]; 449 450 i = 0; 451 j = 0; 452 params.Mvupdateprobs00 = vp8PicParams->ucMvUpdateProb[i][j]; 453 params.Mvupdateprobs01 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 454 params.Mvupdateprobs02 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 455 params.Mvupdateprobs03 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 456 457 i = 0; 458 j = 4; 459 params.Mvupdateprobs04 = vp8PicParams->ucMvUpdateProb[i][j]; 460 params.Mvupdateprobs05 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 461 params.Mvupdateprobs06 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 462 params.Mvupdateprobs07 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 463 464 i = 0; 465 j = 8; 466 params.Mvupdateprobs08 = vp8PicParams->ucMvUpdateProb[i][j]; 467 params.Mvupdateprobs09 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 468 params.Mvupdateprobs010 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 469 params.Mvupdateprobs011 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 470 471 i = 0; 472 j = 12; 473 params.Mvupdateprobs012 = vp8PicParams->ucMvUpdateProb[i][j]; 474 params.Mvupdateprobs013 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 475 params.Mvupdateprobs014 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 476 params.Mvupdateprobs015 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 477 478 i = 0; 479 j = 16; 480 params.Mvupdateprobs016 = vp8PicParams->ucMvUpdateProb[i][j]; 481 params.Mvupdateprobs017 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 482 params.Mvupdateprobs018 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 483 484 i = 1; 485 j = 0; 486 params.Mvupdateprobs10 = vp8PicParams->ucMvUpdateProb[i][j]; 487 params.Mvupdateprobs11 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 488 params.Mvupdateprobs12 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 489 params.Mvupdateprobs13 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 490 491 i = 1; 492 j = 4; 493 params.Mvupdateprobs14 = vp8PicParams->ucMvUpdateProb[i][j]; 494 params.Mvupdateprobs15 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 495 params.Mvupdateprobs16 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 496 params.Mvupdateprobs17 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 497 498 i = 1; 499 j = 8; 500 params.Mvupdateprobs18 = vp8PicParams->ucMvUpdateProb[i][j]; 501 params.Mvupdateprobs19 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 502 params.Mvupdateprobs110 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 503 params.Mvupdateprobs111 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 504 505 i = 1; 506 j = 12; 507 params.Mvupdateprobs112 = vp8PicParams->ucMvUpdateProb[i][j]; 508 params.Mvupdateprobs113 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 509 params.Mvupdateprobs114 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 510 params.Mvupdateprobs115 = vp8PicParams->ucMvUpdateProb[i][j + 3]; 511 512 i = 1; 513 j = 16; 514 params.Mvupdateprobs116 = vp8PicParams->ucMvUpdateProb[i][j]; 515 params.Mvupdateprobs117 = vp8PicParams->ucMvUpdateProb[i][j + 1]; 516 params.Mvupdateprobs118 = vp8PicParams->ucMvUpdateProb[i][j + 2]; 517 518 params.Reflfdelta0ForIntraFrame = vp8PicParams->cRefLfDelta[0]; 519 params.Reflfdelta1ForLastFrame = vp8PicParams->cRefLfDelta[1]; 520 params.Reflfdelta2ForGoldenFrame = vp8PicParams->cRefLfDelta[2]; 521 params.Reflfdelta3ForAltrefFrame = vp8PicParams->cRefLfDelta[3]; 522 params.Modelfdelta0ForBPredMode = vp8PicParams->cModeLfDelta[0]; 523 params.Modelfdelta1ForZeromvMode = vp8PicParams->cModeLfDelta[1]; 524 params.Modelfdelta2ForNearestNearAndNewMode = vp8PicParams->cModeLfDelta[2]; 525 params.Modelfdelta3ForSplitmvMode = vp8PicParams->cModeLfDelta[3]; 526 527 return MOS_STATUS_SUCCESS; 528 } 529 AddAllCmds_MFX_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER & cmdBuffer)530 MOS_STATUS Vp8DecodePicPkt::AddAllCmds_MFX_PIPE_MODE_SELECT(MOS_COMMAND_BUFFER &cmdBuffer) 531 { 532 DECODE_FUNC_CALL(); 533 534 auto &par = m_miItf->GETPAR_MFX_WAIT(); 535 par.iStallVdboxPipeline = true; 536 //for gen 12, we need to add MFX wait for both KIN and VRT before and after MFX Pipemode select. 537 MHW_MI_CHK_STATUS(m_miItf->ADDCMD_MFX_WAIT(&cmdBuffer, nullptr)); 538 539 DECODE_CHK_NULL(m_mfxItf); 540 SETPAR_AND_ADDCMD(MFX_PIPE_MODE_SELECT, m_mfxItf, &cmdBuffer); 541 542 //for gen 12, we need to add MFX wait for both KIN and VRT before and after MFX Pipemode select. 543 MHW_MI_CHK_STATUS(m_miItf->ADDCMD_MFX_WAIT(&cmdBuffer, nullptr)); 544 545 return MOS_STATUS_SUCCESS; 546 } 547 CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)548 MOS_STATUS Vp8DecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize) 549 { 550 DECODE_FUNC_CALL(); 551 552 commandBufferSize = m_pictureStatesSize; 553 requestedPatchListSize = m_picturePatchListSize; 554 555 return MOS_STATUS_SUCCESS; 556 } 557 AddMiForceWakeupCmd(MOS_COMMAND_BUFFER & cmdBuffer)558 MOS_STATUS Vp8DecodePicPkt::AddMiForceWakeupCmd(MOS_COMMAND_BUFFER& cmdBuffer) 559 { 560 DECODE_FUNC_CALL(); 561 562 auto &par = m_miItf->GETPAR_MI_FORCE_WAKEUP(); 563 MOS_ZeroMemory(&par, sizeof(par)); 564 par.bMFXPowerWellControl = true; 565 par.bMFXPowerWellControlMask = true; 566 par.bHEVCPowerWellControl = false; 567 par.bHEVCPowerWellControlMask = true; 568 569 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_FORCE_WAKEUP(&cmdBuffer)); 570 571 return MOS_STATUS_SUCCESS; 572 } 573 574 #if USE_CODECHAL_DEBUG_TOOL DumpResources(MFX_PIPE_BUF_ADDR_STATE_PAR & pipeBufAddrParams) const575 MOS_STATUS Vp8DecodePicPkt::DumpResources(MFX_PIPE_BUF_ADDR_STATE_PAR &pipeBufAddrParams) const 576 { 577 DECODE_FUNC_CALL(); 578 579 CodechalDebugInterface *debugInterface = m_pipeline->GetDebugInterface(); 580 DECODE_CHK_NULL(debugInterface); 581 for (uint16_t n = 0; n <= CodechalDecodeAlternateRef; n++) 582 { 583 if (pipeBufAddrParams.presReferences[n]) 584 { 585 MOS_SURFACE refSurface; 586 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 587 refSurface.OsResource = *(pipeBufAddrParams.presReferences[n]); 588 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 589 590 debugInterface->m_refIndex = n; 591 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(debugInterface->m_refIndex)) + "]"; 592 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 593 &refSurface, 594 CodechalDbgAttr::attrDecodeReferenceSurfaces, 595 refSurfName.c_str())); 596 } 597 } 598 599 return MOS_STATUS_SUCCESS; 600 } 601 602 #endif 603 604 } // namespace decode 605 606