1 /* 2 * Copyright (c) 2020-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_avc_picture_xe_m_base_packet.cpp 24 //! \brief Defines the interface for avc decode picture packet 25 //! 26 #include "codechal_utilities.h" 27 #include "decode_avc_picture_xe_m_base_packet.h" 28 #include "codechal_debug.h" 29 #include "decode_common_feature_defs.h" 30 #include "decode_resource_auto_lock.h" 31 32 namespace decode{ ~AvcDecodePicPktXe_M_Base()33 AvcDecodePicPktXe_M_Base::~AvcDecodePicPktXe_M_Base() 34 { 35 FreeResources(); 36 } 37 FreeResources()38 MOS_STATUS AvcDecodePicPktXe_M_Base::FreeResources() 39 { 40 DECODE_FUNC_CALL(); 41 42 if (m_allocator != nullptr) 43 { 44 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer); 45 if (!m_mfxInterface->IsBsdMpcRowstoreCacheEnabled()) 46 { 47 m_allocator->Destroy(m_resBsdMpcRowStoreScratchBuffer); 48 } 49 if (!m_mfxInterface->IsIntraRowstoreCacheEnabled()) 50 { 51 m_allocator->Destroy(m_resMfdIntraRowStoreScratchBuffer); 52 } 53 if (!m_mfxInterface->IsMprRowstoreCacheEnabled()) 54 { 55 m_allocator->Destroy(m_resMprRowStoreScratchBuffer); 56 } 57 } 58 59 return MOS_STATUS_SUCCESS; 60 } 61 Init()62 MOS_STATUS AvcDecodePicPktXe_M_Base::Init() 63 { 64 DECODE_FUNC_CALL(); 65 66 DECODE_CHK_NULL(m_featureManager); 67 DECODE_CHK_NULL(m_hwInterface); 68 DECODE_CHK_NULL(m_osInterface); 69 DECODE_CHK_NULL(m_miInterface); 70 DECODE_CHK_NULL(m_avcPipeline); 71 DECODE_CHK_NULL(m_mfxInterface); 72 73 m_avcBasicFeature = dynamic_cast<AvcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 74 DECODE_CHK_NULL(m_avcBasicFeature); 75 76 #ifdef _DECODE_PROCESSING_SUPPORTED 77 m_downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature*>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling)); 78 DecodeSubPacket* subPacket = m_avcPipeline->GetSubPacket(DecodePacketId(m_avcPipeline, downSamplingSubPacketId)); 79 m_downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(subPacket); 80 #endif 81 m_allocator = m_pipeline ->GetDecodeAllocator(); 82 DECODE_CHK_NULL(m_allocator); 83 84 DECODE_CHK_STATUS(AllocateFixedResources()); 85 86 return MOS_STATUS_SUCCESS; 87 } 88 Prepare()89 MOS_STATUS AvcDecodePicPktXe_M_Base::Prepare() 90 { 91 DECODE_FUNC_CALL(); 92 93 m_avcPicParams = m_avcBasicFeature->m_avcPicParams; 94 95 #ifdef _MMC_SUPPORTED 96 m_mmcState = m_avcPipeline->GetMmcState(); 97 DECODE_CHK_NULL(m_mmcState); 98 #endif 99 100 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 101 102 DECODE_CHK_STATUS(AllocateVariableResources()); 103 104 return MOS_STATUS_SUCCESS; 105 } 106 SetRowstoreCachingOffsets()107 MOS_STATUS AvcDecodePicPktXe_M_Base::SetRowstoreCachingOffsets() 108 { 109 if (m_mfxInterface->IsRowStoreCachingSupported()) 110 { 111 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams; 112 MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams)); 113 rowstoreParams.dwPicWidth = m_avcBasicFeature->m_width; 114 rowstoreParams.bMbaff = m_avcPicParams->seq_fields.mb_adaptive_frame_field_flag; 115 rowstoreParams.Mode = CODECHAL_DECODE_MODE_AVCVLD; 116 rowstoreParams.bIsFrame = m_avcPicParams->seq_fields.frame_mbs_only_flag; 117 DECODE_CHK_STATUS(static_cast<CodechalHwInterfaceG12*>(m_hwInterface)->SetRowstoreCachingOffsets(&rowstoreParams)); 118 } 119 120 return MOS_STATUS_SUCCESS; 121 } 122 AllocateFixedResources()123 MOS_STATUS AvcDecodePicPktXe_M_Base::AllocateFixedResources() 124 { 125 DECODE_FUNC_CALL(); 126 127 return MOS_STATUS_SUCCESS; 128 } 129 AllocateVariableResources()130 MOS_STATUS AvcDecodePicPktXe_M_Base::AllocateVariableResources() 131 { 132 DECODE_FUNC_CALL(); 133 134 uint16_t picWidthInMB = MOS_MAX(m_picWidthInMbLastMaxAlloced, (m_avcPicParams->pic_width_in_mbs_minus1 + 1)); 135 uint16_t picHeightInMB = MOS_MAX(m_picHeightInMbLastMaxAlloced, (m_avcPicParams->pic_height_in_mbs_minus1 + 1)); 136 uint32_t numMacroblocks = picWidthInMB * picHeightInMB; 137 138 if (m_resMfdDeblockingFilterRowStoreScratchBuffer == nullptr) 139 { 140 m_resMfdDeblockingFilterRowStoreScratchBuffer = m_allocator->AllocateBuffer( 141 picWidthInMB * 4 * CODECHAL_CACHELINE_SIZE, 142 "DeblockingScratchBuffer", 143 resourceInternalReadWriteCache, 144 notLockableVideoMem); 145 DECODE_CHK_NULL(m_resMfdDeblockingFilterRowStoreScratchBuffer); 146 } 147 else 148 { 149 DECODE_CHK_STATUS(m_allocator->Resize( 150 m_resMfdDeblockingFilterRowStoreScratchBuffer, 151 picWidthInMB * 4 * CODECHAL_CACHELINE_SIZE, 152 notLockableVideoMem)); 153 } 154 155 if (m_mfxInterface->IsBsdMpcRowstoreCacheEnabled() == false) 156 { 157 if (m_resBsdMpcRowStoreScratchBuffer == nullptr) 158 { 159 m_resBsdMpcRowStoreScratchBuffer = m_allocator->AllocateBuffer( 160 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE, 161 "MpcScratchBuffer", 162 resourceInternalReadWriteCache, 163 notLockableVideoMem); 164 } 165 else 166 { 167 DECODE_CHK_STATUS(m_allocator->Resize( 168 m_resBsdMpcRowStoreScratchBuffer, 169 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE, 170 notLockableVideoMem)); 171 } 172 } 173 174 if (m_mfxInterface->IsIntraRowstoreCacheEnabled() == false) 175 { 176 if (m_resMfdIntraRowStoreScratchBuffer == nullptr) 177 { 178 m_resMfdIntraRowStoreScratchBuffer = m_allocator->AllocateBuffer( 179 picWidthInMB * CODECHAL_CACHELINE_SIZE, 180 "IntraScratchBuffer", 181 resourceInternalReadWriteCache, 182 notLockableVideoMem); 183 } 184 else 185 { 186 DECODE_CHK_STATUS(m_allocator->Resize( 187 m_resMfdIntraRowStoreScratchBuffer, 188 picWidthInMB * CODECHAL_CACHELINE_SIZE, 189 notLockableVideoMem)); 190 } 191 } 192 193 if (m_mfxInterface->IsMprRowstoreCacheEnabled() == false) 194 { 195 if (m_resMprRowStoreScratchBuffer == nullptr) 196 { 197 m_resMprRowStoreScratchBuffer = m_allocator->AllocateBuffer( 198 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE, 199 "MprScratchBuffer", 200 resourceInternalReadWriteCache, 201 notLockableVideoMem); 202 } 203 else 204 { 205 DECODE_CHK_STATUS(m_allocator->Resize( 206 m_resMprRowStoreScratchBuffer, 207 picWidthInMB * 2 * CODECHAL_CACHELINE_SIZE, 208 notLockableVideoMem)); 209 } 210 } 211 212 //record the width and height used for allocation internal resources. 213 m_picWidthInMbLastMaxAlloced = picWidthInMB; 214 m_picHeightInMbLastMaxAlloced = picHeightInMB; 215 216 return MOS_STATUS_SUCCESS; 217 } 218 SetMfxPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 & pipeModeSelectParams)219 void AvcDecodePicPktXe_M_Base::SetMfxPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 &pipeModeSelectParams) 220 { 221 DECODE_FUNC_CALL(); 222 223 pipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_AVCVLD; 224 pipeModeSelectParams.bDeblockerStreamOutEnable = false; 225 pipeModeSelectParams.bStreamOutEnabled = m_avcBasicFeature->m_streamOutEnabled; 226 pipeModeSelectParams.bPostDeblockOutEnable = m_avcBasicFeature->m_deblockingEnabled; 227 pipeModeSelectParams.bPreDeblockOutEnable = !m_avcBasicFeature->m_deblockingEnabled; 228 pipeModeSelectParams.bShortFormatInUse = m_avcBasicFeature->m_shortFormatInUse; 229 } 230 SetMfxSurfaceParams(MHW_VDBOX_SURFACE_PARAMS & dstSurfaceParams)231 MOS_STATUS AvcDecodePicPktXe_M_Base::SetMfxSurfaceParams(MHW_VDBOX_SURFACE_PARAMS &dstSurfaceParams) 232 { 233 DECODE_FUNC_CALL(); 234 235 MOS_ZeroMemory(&dstSurfaceParams, sizeof(dstSurfaceParams)); 236 dstSurfaceParams.Mode = CODECHAL_DECODE_MODE_AVCVLD; 237 dstSurfaceParams.psSurface = &m_avcBasicFeature->m_destSurface; 238 239 #ifdef _MMC_SUPPORTED 240 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_avcBasicFeature->m_destSurface))); 241 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(dstSurfaceParams.psSurface, &dstSurfaceParams.mmcState)); 242 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(dstSurfaceParams.psSurface, &dstSurfaceParams.dwCompressionFormat)); 243 #endif 244 return MOS_STATUS_SUCCESS; 245 } 246 SetMfxPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & pipeBufAddrParams)247 MOS_STATUS AvcDecodePicPktXe_M_Base::SetMfxPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS &pipeBufAddrParams) 248 { 249 DECODE_FUNC_CALL(); 250 251 pipeBufAddrParams.Mode = CODECHAL_DECODE_MODE_AVCVLD; 252 253 if (m_avcBasicFeature->m_deblockingEnabled) 254 { 255 pipeBufAddrParams.psPostDeblockSurface = &(m_avcBasicFeature->m_destSurface); 256 } 257 else 258 { 259 pipeBufAddrParams.psPreDeblockSurface = &(m_avcBasicFeature->m_destSurface); 260 } 261 pipeBufAddrParams.presMfdIntraRowStoreScratchBuffer = &m_resMfdIntraRowStoreScratchBuffer->OsResource; 262 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resMfdDeblockingFilterRowStoreScratchBuffer->OsResource; 263 264 if (m_avcBasicFeature->m_streamOutEnabled) 265 { 266 pipeBufAddrParams.presStreamOutBuffer = m_avcBasicFeature->m_externalStreamOutBuffer; 267 } 268 269 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames; 270 const std::vector<uint8_t> & activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams); 271 272 for (uint8_t i = 0; i < activeRefList.size(); i++) 273 { 274 uint8_t frameIdx = activeRefList[i]; 275 uint8_t frameId = (m_avcBasicFeature->m_picIdRemappingInUse) ? i : refFrames.m_refList[frameIdx]->ucFrameId; 276 pipeBufAddrParams.presReferences[frameId] = refFrames.GetReferenceByFrameIndex(frameIdx); 277 278 // Return error if reference surface's width or height is less than dest surface. 279 if (pipeBufAddrParams.presReferences[frameId] != nullptr) 280 { 281 MOS_SURFACE refSurface; 282 refSurface.OsResource = *(pipeBufAddrParams.presReferences[frameId]); 283 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 284 DECODE_CHK_COND(((refSurface.dwWidth < m_avcBasicFeature->m_destSurface.dwWidth) 285 || (refSurface.dwHeight < m_avcBasicFeature->m_destSurface.dwHeight)), 286 "Reference surface's width or height is less than Dest surface."); 287 } 288 } 289 290 DECODE_CHK_STATUS(FixMfxPipeBufAddrParams(pipeBufAddrParams)); 291 292 CODECHAL_DEBUG_TOOL(DECODE_CHK_STATUS(DumpResources(pipeBufAddrParams))); 293 294 return MOS_STATUS_SUCCESS; 295 } 296 FixMfxPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & pipeBufAddrParams)297 MOS_STATUS AvcDecodePicPktXe_M_Base::FixMfxPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS &pipeBufAddrParams) 298 { 299 DECODE_FUNC_CALL(); 300 301 PMOS_RESOURCE validRefPic = nullptr; 302 PMOS_RESOURCE dummyRef = &(m_avcBasicFeature->m_dummyReference.OsResource); 303 if (m_avcBasicFeature->m_useDummyReference && !m_allocator->ResourceIsNull(dummyRef)) 304 { 305 validRefPic = dummyRef; 306 } 307 else 308 { 309 validRefPic = m_avcBasicFeature->m_refFrames.GetValidReference(); 310 if (validRefPic == nullptr) 311 { 312 validRefPic = &m_avcBasicFeature->m_destSurface.OsResource; 313 } 314 } 315 316 for (uint8_t i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++) 317 { 318 // error concealment for the unset reference addresses and unset mv buffers 319 if (pipeBufAddrParams.presReferences[i] == nullptr) 320 { 321 pipeBufAddrParams.presReferences[i] = validRefPic; 322 } 323 } 324 325 return MOS_STATUS_SUCCESS; 326 } 327 SetMfxIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS & indObjBaseAddrParams)328 void AvcDecodePicPktXe_M_Base::SetMfxIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS &indObjBaseAddrParams) 329 { 330 DECODE_FUNC_CALL(); 331 332 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams)); 333 indObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_AVCVLD; 334 indObjBaseAddrParams.dwDataSize = m_avcBasicFeature->m_dataSize; 335 indObjBaseAddrParams.dwDataOffset = m_avcBasicFeature->m_dataOffset; 336 indObjBaseAddrParams.presDataBuffer = &(m_avcBasicFeature->m_resDataBuffer.OsResource); 337 } 338 SetMfxBspBufBaseAddrParams(MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS & bspBufBaseAddrParams)339 void AvcDecodePicPktXe_M_Base::SetMfxBspBufBaseAddrParams(MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS &bspBufBaseAddrParams) 340 { 341 DECODE_FUNC_CALL(); 342 343 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams)); 344 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer->OsResource; 345 bspBufBaseAddrParams.presMprRowStoreScratchBuffer = &m_resMprRowStoreScratchBuffer->OsResource; 346 } 347 SetMfdAvcDpbParams(MHW_VDBOX_AVC_DPB_PARAMS & dpbParams)348 void AvcDecodePicPktXe_M_Base::SetMfdAvcDpbParams(MHW_VDBOX_AVC_DPB_PARAMS &dpbParams) 349 { 350 DECODE_FUNC_CALL(); 351 352 MOS_ZeroMemory(&dpbParams, sizeof(dpbParams)); 353 dpbParams.pAvcPicParams = m_avcPicParams; 354 dpbParams.pMvcExtPicParams = m_avcBasicFeature->m_mvcExtPicParams; 355 dpbParams.ppAvcRefList = &(m_avcBasicFeature->m_refFrames.m_refList[0]); 356 dpbParams.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse; 357 } 358 SetMfdAvcPicidParams(MHW_VDBOX_PIC_ID_PARAMS & picIdParams)359 void AvcDecodePicPktXe_M_Base::SetMfdAvcPicidParams(MHW_VDBOX_PIC_ID_PARAMS &picIdParams) 360 { 361 DECODE_FUNC_CALL(); 362 363 MOS_ZeroMemory(&picIdParams, sizeof(picIdParams)); 364 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames; 365 picIdParams.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse; 366 picIdParams.pAvcPicIdx = &(refFrames.m_avcPicIdx[0]); 367 } 368 SetMfxAvcImgParams(MHW_VDBOX_AVC_IMG_PARAMS & imgParams)369 void AvcDecodePicPktXe_M_Base::SetMfxAvcImgParams(MHW_VDBOX_AVC_IMG_PARAMS &imgParams) 370 { 371 DECODE_FUNC_CALL(); 372 373 MOS_ZeroMemory(&imgParams, sizeof(imgParams)); 374 imgParams.pAvcPicParams = m_avcPicParams; 375 imgParams.pMvcExtPicParams = m_avcBasicFeature->m_mvcExtPicParams; 376 377 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames; 378 const std::vector<uint8_t> & activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams); 379 uint8_t activeFrameCnt = activeRefList.size(); 380 imgParams.ucActiveFrameCnt = activeFrameCnt; 381 } 382 SetMfxAvcDirectmodeParams(MHW_VDBOX_AVC_DIRECTMODE_PARAMS & avcDirectmodeParams)383 MOS_STATUS AvcDecodePicPktXe_M_Base::SetMfxAvcDirectmodeParams(MHW_VDBOX_AVC_DIRECTMODE_PARAMS &avcDirectmodeParams) 384 { 385 DECODE_FUNC_CALL(); 386 387 MOS_ZeroMemory(&avcDirectmodeParams, sizeof(avcDirectmodeParams)); 388 MOS_ZeroMemory(&m_resAvcDmvBuffers, (sizeof(MOS_RESOURCE) * CODEC_AVC_NUM_DMV_BUFFERS)); 389 390 AvcReferenceFrames &refFrames = m_avcBasicFeature->m_refFrames; 391 auto mvBuffers = &(m_avcBasicFeature->m_mvBuffers); 392 PMOS_BUFFER curMvBuffer = mvBuffers->GetCurBuffer(); 393 DECODE_CHK_NULL(curMvBuffer); 394 395 m_resAvcDmvBuffers[0] = curMvBuffer->OsResource; 396 PMOS_BUFFER curAvailableBuffers = mvBuffers->GetAvailableBuffer(); 397 DECODE_CHK_NULL(curAvailableBuffers); 398 m_resAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS] = curAvailableBuffers->OsResource; 399 400 const std::vector<uint8_t> & activeRefList = refFrames.GetActiveReferenceList(*m_avcPicParams); 401 402 for (uint8_t i = 0; i < activeRefList.size(); i++) 403 { 404 uint8_t frameIdx = activeRefList[i]; 405 if (m_avcBasicFeature->m_secondField && activeRefList.size() > m_avcBasicFeature->m_avcPicParams->frame_num && 406 (frameIdx == m_avcBasicFeature->m_curRenderPic.FrameIdx)) 407 { 408 m_resAvcDmvBuffers[i + 1] = curMvBuffer->OsResource; 409 } 410 else 411 { 412 PMOS_BUFFER mvBuf = mvBuffers->GetBufferByFrameIndex(frameIdx); 413 414 // m_resAvcDmvBuffers[0] is used as current mv buffer itself. 415 if (mvBuf != nullptr) 416 { 417 m_resAvcDmvBuffers[i + 1] = mvBuf->OsResource; 418 } 419 else 420 { 421 PMOS_BUFFER curAvailableBuf = mvBuffers->GetAvailableBuffer(); 422 DECODE_CHK_NULL(curAvailableBuf); 423 m_resAvcDmvBuffers[i + 1] = curAvailableBuf->OsResource; 424 } 425 } 426 refFrames.m_refList[frameIdx]->ucDMVIdx[0] = i + 1; 427 } 428 429 avcDirectmodeParams.CurrPic = m_avcPicParams->CurrPic; 430 avcDirectmodeParams.uiUsedForReferenceFlags = m_avcPicParams->UsedForReferenceFlags; 431 avcDirectmodeParams.presAvcDmvBuffers = &m_resAvcDmvBuffers[0]; 432 avcDirectmodeParams.ucAvcDmvIdx = 0; 433 avcDirectmodeParams.pAvcPicIdx = &(refFrames.m_avcPicIdx[0]); 434 avcDirectmodeParams.avcRefList = (void**)refFrames.m_refList; 435 avcDirectmodeParams.bPicIdRemappingInUse = m_avcBasicFeature->m_picIdRemappingInUse; 436 437 CODECHAL_DEBUG_TOOL(DECODE_CHK_STATUS(DumpResources(avcDirectmodeParams, curMvBuffer->size))); 438 439 return MOS_STATUS_SUCCESS; 440 } 441 SetMfxQmParams(MHW_VDBOX_QM_PARAMS & qmParams)442 void AvcDecodePicPktXe_M_Base::SetMfxQmParams(MHW_VDBOX_QM_PARAMS &qmParams) 443 { 444 DECODE_FUNC_CALL(); 445 446 MOS_ZeroMemory(&qmParams, sizeof(qmParams)); 447 qmParams.Standard = CODECHAL_AVC; 448 qmParams.pAvcIqMatrix = (PMHW_VDBOX_AVC_QM_PARAMS)m_avcBasicFeature->m_avcIqMatrixParams; 449 } 450 AddMfxBspBufBaseAddrCmd(MOS_COMMAND_BUFFER & cmdBuffer)451 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxBspBufBaseAddrCmd(MOS_COMMAND_BUFFER &cmdBuffer) 452 { 453 DECODE_FUNC_CALL(); 454 455 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS BspBufBaseAddrParams; 456 SetMfxBspBufBaseAddrParams(BspBufBaseAddrParams); 457 DECODE_CHK_STATUS(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &BspBufBaseAddrParams)); 458 459 return MOS_STATUS_SUCCESS; 460 } 461 AddMfxSurfacesCmd(MOS_COMMAND_BUFFER & cmdBuffer)462 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxSurfacesCmd(MOS_COMMAND_BUFFER &cmdBuffer) 463 { 464 DECODE_FUNC_CALL(); 465 466 MHW_VDBOX_SURFACE_PARAMS dstSurfaceParams; 467 DECODE_CHK_STATUS(SetMfxSurfaceParams(dstSurfaceParams)); 468 DECODE_CHK_STATUS(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &dstSurfaceParams)); 469 470 return MOS_STATUS_SUCCESS; 471 } 472 AddMfxIndObjBaseAddrCmd(MOS_COMMAND_BUFFER & cmdBuffer)473 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxIndObjBaseAddrCmd(MOS_COMMAND_BUFFER &cmdBuffer) 474 { 475 DECODE_FUNC_CALL(); 476 477 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams; 478 SetMfxIndObjBaseAddrParams(indObjBaseAddrParams); 479 DECODE_CHK_STATUS(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams)); 480 481 return MOS_STATUS_SUCCESS; 482 } 483 AddMfdAvcDpbCmd(MOS_COMMAND_BUFFER & cmdBuffer)484 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfdAvcDpbCmd(MOS_COMMAND_BUFFER &cmdBuffer) 485 { 486 DECODE_FUNC_CALL(); 487 488 MHW_VDBOX_AVC_DPB_PARAMS dpbParams; 489 SetMfdAvcDpbParams(dpbParams); 490 DECODE_CHK_STATUS(m_mfxInterface->AddMfdAvcDpbCmd(&cmdBuffer, &dpbParams)); 491 492 return MOS_STATUS_SUCCESS; 493 } 494 AddMfxQmCmd(MOS_COMMAND_BUFFER & cmdBuffer)495 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxQmCmd(MOS_COMMAND_BUFFER &cmdBuffer) 496 { 497 DECODE_FUNC_CALL(); 498 499 MHW_VDBOX_QM_PARAMS qmParams; 500 SetMfxQmParams(qmParams); 501 DECODE_CHK_STATUS(m_mfxInterface->AddMfxQmCmd(&cmdBuffer, &qmParams)); 502 503 return MOS_STATUS_SUCCESS; 504 } 505 AddMfxAvcDirectmodeCmd(MOS_COMMAND_BUFFER & cmdBuffer)506 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxAvcDirectmodeCmd(MOS_COMMAND_BUFFER &cmdBuffer) 507 { 508 DECODE_FUNC_CALL(); 509 510 MHW_VDBOX_AVC_DIRECTMODE_PARAMS avcDirectmodeParams; 511 SetMfxAvcDirectmodeParams(avcDirectmodeParams); 512 DECODE_CHK_STATUS(m_mfxInterface->AddMfxAvcDirectmodeCmd(&cmdBuffer, &avcDirectmodeParams)); 513 514 return MOS_STATUS_SUCCESS; 515 } 516 AddMfdAvcPicidCmd(MOS_COMMAND_BUFFER & cmdBuffer)517 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfdAvcPicidCmd(MOS_COMMAND_BUFFER &cmdBuffer) 518 { 519 DECODE_FUNC_CALL(); 520 521 MHW_VDBOX_PIC_ID_PARAMS picIdParams; 522 SetMfdAvcPicidParams(picIdParams); 523 DECODE_CHK_STATUS(m_mfxInterface->AddMfdAvcPicidCmd(&cmdBuffer, &picIdParams)); 524 525 return MOS_STATUS_SUCCESS; 526 } 527 AddMfxAvcImgCmd(MOS_COMMAND_BUFFER & cmdBuffer)528 MOS_STATUS AvcDecodePicPktXe_M_Base::AddMfxAvcImgCmd(MOS_COMMAND_BUFFER &cmdBuffer) 529 { 530 DECODE_FUNC_CALL(); 531 532 MHW_VDBOX_AVC_IMG_PARAMS imgParams; 533 SetMfxAvcImgParams(imgParams); 534 DECODE_CHK_STATUS(m_mfxInterface->AddMfxAvcImgCmd(&cmdBuffer, nullptr, &imgParams)); 535 536 return MOS_STATUS_SUCCESS; 537 } 538 CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)539 MOS_STATUS AvcDecodePicPktXe_M_Base::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize) 540 { 541 DECODE_FUNC_CALL(); 542 543 commandBufferSize = m_pictureStatesSize; 544 requestedPatchListSize = m_picturePatchListSize; 545 546 return MOS_STATUS_SUCCESS; 547 } 548 549 #if USE_CODECHAL_DEBUG_TOOL DumpResources(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & pipeBufAddrParams)550 MOS_STATUS AvcDecodePicPktXe_M_Base::DumpResources(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS &pipeBufAddrParams) 551 { 552 DECODE_FUNC_CALL(); 553 554 CodechalDebugInterface *debugInterface = m_avcPipeline->GetDebugInterface(); 555 556 for (auto n = 0; n < CODEC_AVC_MAX_NUM_REF_FRAME; n++) 557 { 558 if (m_avcBasicFeature->m_refFrames.m_avcPicIdx[n].bValid) 559 { 560 MOS_SURFACE refSurface; 561 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 562 refSurface.OsResource = *(pipeBufAddrParams.presReferences[n]); 563 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 564 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(n)) + "]"; 565 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 566 &refSurface, 567 CodechalDbgAttr::attrDecodeReferenceSurfaces, 568 refSurfName.c_str())); 569 } 570 } 571 572 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 573 &m_avcBasicFeature->m_resDataBuffer.OsResource, 574 CodechalDbgAttr::attrDecodeBitstream, 575 "DEC", 576 m_avcBasicFeature->m_dataSize, 577 m_avcBasicFeature->m_dataOffset, 578 CODECHAL_NUM_MEDIA_STATES)); 579 580 return MOS_STATUS_SUCCESS; 581 } 582 DumpResources(MHW_VDBOX_AVC_DIRECTMODE_PARAMS & avcDirectmodeParams,uint32_t mvBufferSize)583 MOS_STATUS AvcDecodePicPktXe_M_Base::DumpResources(MHW_VDBOX_AVC_DIRECTMODE_PARAMS &avcDirectmodeParams, uint32_t mvBufferSize) 584 { 585 DECODE_FUNC_CALL(); 586 587 CodechalDebugInterface *debugInterface = m_avcPipeline->GetDebugInterface(); 588 for (auto n = 0; n < CODEC_AVC_MAX_NUM_REF_FRAME; n++) 589 { 590 if (m_avcBasicFeature->m_refFrames.m_avcPicIdx[n].bValid) 591 { 592 std::string mvBufDumpName = "_DEC_Ref_MV_" + std::to_string(n); 593 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 594 &avcDirectmodeParams.presAvcDmvBuffers[n+1], 595 CodechalDbgAttr::attrMvData, 596 mvBufDumpName.c_str(), 597 mvBufferSize)); 598 } 599 } 600 601 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 602 &avcDirectmodeParams.presAvcDmvBuffers[0], 603 CodechalDbgAttr::attrMvData, 604 "DEC_Cur_MV_", 605 mvBufferSize)); 606 return MOS_STATUS_SUCCESS; 607 } 608 609 #endif 610 611 } 612