1 /* 2 * Copyright (c) 2022-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_hevc_picture_packet.cpp 24 //! \brief Defines the interface for hevc decode picture packet 25 //! 26 #include "codec_utilities_next.h" 27 #include "decode_hevc_picture_packet.h" 28 #include "decode_hevc_phase_real_tile.h" 29 #include "decode_hevc_phase_front_end.h" 30 #include "decode_hevc_phase_back_end.h" 31 #include "decode_common_feature_defs.h" 32 #include "decode_hevc_mem_compression.h" 33 #include "mhw_vdbox_hcp_itf.h" 34 #include "mhw_impl.h" 35 #include "decode_utils.h" 36 37 using namespace mhw::vdbox::hcp; 38 39 const mhw::vdbox::hcp::Itf::HevcSliceType mhw::vdbox::hcp::Itf::m_hevcBsdSliceType[3] = 40 { 41 mhw::vdbox::hcp::Itf::hevcSliceB, 42 mhw::vdbox::hcp::Itf::hevcSliceP, 43 mhw::vdbox::hcp::Itf::hevcSliceI 44 }; 45 46 namespace decode 47 { ~HevcDecodePicPkt()48 HevcDecodePicPkt::~HevcDecodePicPkt() 49 { 50 FreeResources(); 51 } 52 FreeResources()53 MOS_STATUS HevcDecodePicPkt::FreeResources() 54 { 55 DECODE_FUNC_CALL(); 56 57 if (m_allocator != nullptr) 58 { 59 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer); 60 m_allocator->Destroy(m_resMfdDeblockingFilterRowStoreScratchBuffer); 61 m_allocator->Destroy(m_resDeblockingFilterTileRowStoreScratchBuffer); 62 m_allocator->Destroy(m_resDeblockingFilterColumnRowStoreScratchBuffer); 63 m_allocator->Destroy(m_resMetadataLineBuffer); 64 m_allocator->Destroy(m_resMetadataTileLineBuffer); 65 m_allocator->Destroy(m_resMetadataTileColumnBuffer); 66 m_allocator->Destroy(m_resSaoLineBuffer); 67 m_allocator->Destroy(m_resSaoTileLineBuffer); 68 m_allocator->Destroy(m_resSaoTileColumnBuffer); 69 m_allocator->Destroy(m_resSliceStateStreamOutBuffer); 70 m_allocator->Destroy(m_resMvUpRightColStoreBuffer); 71 m_allocator->Destroy(m_resIntraPredUpRightColStoreBuffer); 72 m_allocator->Destroy(m_resIntraPredLeftReconColStoreBuffer); 73 m_allocator->Destroy(m_resCABACSyntaxStreamOutBuffer); 74 m_allocator->Destroy(m_resCABACStreamOutSizeBuffer); 75 } 76 77 return MOS_STATUS_SUCCESS; 78 } 79 Init()80 MOS_STATUS HevcDecodePicPkt::Init() 81 { 82 DECODE_FUNC_CALL(); 83 DECODE_CHK_NULL(m_featureManager); 84 DECODE_CHK_NULL(m_hwInterface); 85 DECODE_CHK_NULL(m_osInterface); 86 DECODE_CHK_NULL(m_miItf); 87 DECODE_CHK_NULL(m_hevcPipeline); 88 DECODE_CHK_NULL(m_hcpItf); 89 90 m_hevcBasicFeature = dynamic_cast<HevcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature)); 91 DECODE_CHK_NULL(m_hevcBasicFeature); 92 93 #ifdef _DECODE_PROCESSING_SUPPORTED 94 m_downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature *>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling)); 95 DecodeSubPacket *subPacket = m_hevcPipeline->GetSubPacket(DecodePacketId(m_hevcPipeline, downSamplingSubPacketId)); 96 m_downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(subPacket); 97 #endif 98 99 m_allocator = m_pipeline ->GetDecodeAllocator(); 100 DECODE_CHK_NULL(m_allocator); 101 102 DECODE_CHK_STATUS(AllocateFixedResources()); 103 104 return MOS_STATUS_SUCCESS; 105 } 106 Prepare()107 MOS_STATUS HevcDecodePicPkt::Prepare() 108 { 109 DECODE_FUNC_CALL(); 110 111 m_hevcPicParams = m_hevcBasicFeature->m_hevcPicParams; 112 m_hevcIqMatrixParams = m_hevcBasicFeature->m_hevcIqMatrixParams; 113 m_hevcRextPicParams = m_hevcBasicFeature->m_hevcRextPicParams; 114 m_hevcSccPicParams = m_hevcBasicFeature->m_hevcSccPicParams; 115 116 #ifdef _MMC_SUPPORTED 117 m_mmcState = m_hevcPipeline->GetMmcState(); 118 DECODE_CHK_NULL(m_mmcState); 119 #endif 120 121 DECODE_CHK_STATUS(SetRowstoreCachingOffsets()); 122 DECODE_CHK_STATUS(AllocateVariableResources()); 123 124 return MOS_STATUS_SUCCESS; 125 } 126 SetPhase(DecodePhase * phase)127 MOS_STATUS HevcDecodePicPkt::SetPhase(DecodePhase *phase) 128 { 129 DECODE_FUNC_CALL(); 130 m_phase = phase; 131 return MOS_STATUS_SUCCESS; 132 } 133 ReportCabacStreamOutSize(MOS_COMMAND_BUFFER & cmdBuffer)134 MOS_STATUS HevcDecodePicPkt::ReportCabacStreamOutSize(MOS_COMMAND_BUFFER &cmdBuffer) 135 { 136 DECODE_FUNC_CALL(); 137 DECODE_CHK_NULL(m_resCABACStreamOutSizeBuffer); 138 139 auto mmioRegistersHcp = m_hwInterface->GetHcpInterfaceNext()->GetMmioRegisters(MHW_VDBOX_NODE_1); 140 141 auto &par = m_miItf->GETPAR_MI_STORE_REGISTER_MEM(); 142 par = {}; 143 par.presStoreBuffer = &m_resCABACStreamOutSizeBuffer->OsResource; 144 par.dwOffset = 0; 145 par.dwRegister = mmioRegistersHcp->hcpDebugFEStreamOutSizeRegOffset; 146 147 DECODE_CHK_STATUS(m_miItf->ADDCMD_MI_STORE_REGISTER_MEM(&cmdBuffer)); 148 149 return MOS_STATUS_SUCCESS; 150 } 151 IsRealTilePhase()152 bool HevcDecodePicPkt::IsRealTilePhase() 153 { 154 if (m_phase == nullptr) 155 { 156 return false; 157 } 158 HevcPhaseRealTile *realtilePhase = dynamic_cast<HevcPhaseRealTile *>(m_phase); 159 return (realtilePhase != nullptr); 160 } 161 IsFrontEndPhase()162 bool HevcDecodePicPkt::IsFrontEndPhase() 163 { 164 if (m_phase == nullptr) 165 { 166 return false; 167 } 168 HevcPhaseFrontEnd *frontEndPhase = dynamic_cast<HevcPhaseFrontEnd *>(m_phase); 169 return (frontEndPhase != nullptr); 170 } 171 IsBackEndPhase()172 bool HevcDecodePicPkt::IsBackEndPhase() 173 { 174 if (m_phase == nullptr) 175 { 176 return false; 177 } 178 HevcPhaseBackEnd *backEndPhase = dynamic_cast<HevcPhaseBackEnd *>(m_phase); 179 return (backEndPhase != nullptr); 180 } 181 SetRowstoreCachingOffsets()182 MOS_STATUS HevcDecodePicPkt::SetRowstoreCachingOffsets() 183 { 184 if (m_hcpItf->IsRowStoreCachingSupported()) 185 { 186 HcpVdboxRowStorePar rowstoreParams; 187 rowstoreParams.Mode = CODECHAL_DECODE_MODE_HEVCVLD; 188 rowstoreParams.dwPicWidth = m_hevcBasicFeature->m_width; 189 rowstoreParams.bMbaff = false; 190 rowstoreParams.ucBitDepthMinus8 = (uint8_t)MOS_MAX(m_hevcPicParams->bit_depth_luma_minus8, 191 m_hevcPicParams->bit_depth_chroma_minus8); 192 rowstoreParams.ucChromaFormat = m_hevcPicParams->chroma_format_idc; 193 rowstoreParams.ucLCUSize = (uint8_t)m_hevcBasicFeature->m_ctbSize; 194 DECODE_CHK_STATUS(m_hcpItf->SetRowstoreCachingOffsets(rowstoreParams)); 195 } 196 197 return MOS_STATUS_SUCCESS; 198 } 199 AllocateFixedResources()200 MOS_STATUS HevcDecodePicPkt::AllocateFixedResources() 201 { 202 DECODE_FUNC_CALL(); 203 204 if (m_resSliceStateStreamOutBuffer == nullptr) 205 { 206 uint32_t sizeOfBuffer = CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6 * sliceStateCachelinesPerSlice * CODECHAL_CACHELINE_SIZE; 207 m_resSliceStateStreamOutBuffer = m_allocator->AllocateBuffer( 208 sizeOfBuffer, 209 "SliceStateStreamOut", 210 resourceInternalReadWriteCache, 211 notLockableVideoMem); 212 DECODE_CHK_NULL(m_resSliceStateStreamOutBuffer); 213 } 214 215 if (m_resCABACStreamOutSizeBuffer == nullptr) 216 { 217 m_resCABACStreamOutSizeBuffer = m_allocator->AllocateBuffer( 218 sizeof(uint64_t), 219 "CABACStreamOutSizeBuffer", 220 resourceInternalReadWriteCache, 221 notLockableVideoMem); 222 DECODE_CHK_NULL(m_resCABACStreamOutSizeBuffer); 223 } 224 225 return MOS_STATUS_SUCCESS; 226 } 227 AllocateVariableResources()228 MOS_STATUS HevcDecodePicPkt::AllocateVariableResources() 229 { 230 DECODE_FUNC_CALL(); 231 232 HcpBufferSizePar hcpBufSizePar; 233 MOS_ZeroMemory(&hcpBufSizePar, sizeof(hcpBufSizePar)); 234 235 hcpBufSizePar.ucMaxBitDepth = m_hevcBasicFeature->m_bitDepth; 236 hcpBufSizePar.ucChromaFormat = m_hevcBasicFeature->m_chromaFormat; 237 hcpBufSizePar.dwCtbLog2SizeY = m_hevcPicParams->log2_diff_max_min_luma_coding_block_size + 238 m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3; 239 hcpBufSizePar.dwPicWidth = m_hevcBasicFeature->m_width; 240 hcpBufSizePar.dwPicHeight = m_hevcBasicFeature->m_height; 241 hcpBufSizePar.dwMaxFrameSize = m_hevcBasicFeature->m_dataSize; 242 243 auto AllocateBuffer = [&](PMOS_BUFFER &buffer, const HCP_INTERNAL_BUFFER_TYPE bufferType, const char *bufferName) { 244 uint32_t bufSize = 0; 245 hcpBufSizePar.bufferType = bufferType; 246 DECODE_CHK_STATUS(m_hcpItf->GetHcpBufSize(hcpBufSizePar, bufSize)); 247 248 if (buffer == nullptr) 249 { 250 buffer = m_allocator->AllocateBuffer(bufSize, bufferName, resourceInternalReadWriteCache, notLockableVideoMem); 251 DECODE_CHK_NULL(buffer); 252 } 253 else 254 { 255 DECODE_CHK_STATUS(m_allocator->Resize(buffer, bufSize, notLockableVideoMem)); 256 } 257 return MOS_STATUS_SUCCESS; 258 }; 259 260 if (!m_hcpItf->IsHevcDfRowstoreCacheEnabled()) 261 { 262 // Deblocking Filter Row Store Scratch buffer 263 DECODE_CHK_STATUS(AllocateBuffer(m_resMfdDeblockingFilterRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_LINE, "DeblockingScratchBuffer")); 264 } 265 266 // Deblocking Filter Tile Row Store Scratch data surface 267 DECODE_CHK_STATUS(AllocateBuffer(m_resDeblockingFilterTileRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_LINE, "DeblockingTileScratchBuffer")); 268 269 // Deblocking Filter Column Row Store Scratch data surface 270 DECODE_CHK_STATUS(AllocateBuffer(m_resDeblockingFilterColumnRowStoreScratchBuffer, HCP_INTERNAL_BUFFER_TYPE::DBLK_TILE_COL, "DeblockingColumnScratchBuffer")); 271 272 if (!m_hcpItf->IsHevcDatRowstoreCacheEnabled()) 273 { 274 // Metadata Line buffer 275 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataLineBuffer, HCP_INTERNAL_BUFFER_TYPE::META_LINE, "MetadataLineBuffer")); 276 } 277 278 // Metadata Tile Line buffer 279 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataTileLineBuffer, HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE, "MetadataTileLineBuffer")); 280 281 // Metadata Tile Column buffer 282 DECODE_CHK_STATUS(AllocateBuffer(m_resMetadataTileColumnBuffer, HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL, "MetadataTileColumnBuffer")); 283 284 if (!m_hcpItf->IsHevcSaoRowstoreCacheEnabled()) 285 { 286 // SAO Line buffer 287 DECODE_CHK_STATUS(AllocateBuffer(m_resSaoLineBuffer, HCP_INTERNAL_BUFFER_TYPE::SAO_LINE, "SaoLineBuffer")); 288 } 289 290 // SAO Tile Line buffer 291 DECODE_CHK_STATUS(AllocateBuffer(m_resSaoTileLineBuffer, HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_LINE, "SaoTileLineBuffer")); 292 293 // SAO Tile Column buffer 294 DECODE_CHK_STATUS(AllocateBuffer(m_resSaoTileColumnBuffer, HCP_INTERNAL_BUFFER_TYPE::SAO_TILE_COL, "SaoTileColumnBuffer")); 295 296 // MV up right column store buffer 297 DECODE_CHK_STATUS(AllocateBuffer(m_resMvUpRightColStoreBuffer, HCP_INTERNAL_BUFFER_TYPE::MV_UP_RT_COL, "MVUpperRightColumnStore")); 298 299 // Intra prediction up right column store buffer 300 DECODE_CHK_STATUS(AllocateBuffer(m_resIntraPredUpRightColStoreBuffer, HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_UP_RIGHT_COL, "MVUpperRightColumnStore")); 301 302 // Intra prediction left recon column store buffer 303 DECODE_CHK_STATUS(AllocateBuffer(m_resIntraPredLeftReconColStoreBuffer, HCP_INTERNAL_BUFFER_TYPE::INTRA_PRED_LFT_RECON_COL, "IntraPredLeftReconColumnStore")); 304 305 // Cabac stream out buffer 306 DECODE_CHK_STATUS(AllocateBuffer(m_resCABACSyntaxStreamOutBuffer, HCP_INTERNAL_BUFFER_TYPE::CABAC_STREAMOUT, "CABACStreamOutBuffer")); 307 308 return MOS_STATUS_SUCCESS; 309 } 310 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT,HevcDecodePicPkt)311 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT, HevcDecodePicPkt) 312 { 313 DECODE_FUNC_CALL(); 314 315 params.codecSelect = 0; // CODEC_SELECT_DECODE 316 params.codecStandardSelect = CodecHal_GetStandardFromMode(m_hevcBasicFeature->m_mode) - CODECHAL_HCP_BASE; 317 params.bStreamOutEnabled = false; 318 319 auto cpInterface = m_hwInterface->GetCpInterface(); 320 DECODE_CHK_NULL(cpInterface); 321 322 bool twoPassScalable = false; // !decodeInUse 323 params.setProtectionSettings = [=](uint32_t *data) { return cpInterface->SetProtectionSettingsForHcpPipeModeSelect(data, twoPassScalable); }; 324 325 params.mediaSoftResetCounterPer1000Clocks = 0; 326 #if (_DEBUG || _RELEASE_INTERNAL) 327 if (m_osInterface->bSoftReset) 328 { 329 params.mediaSoftResetCounterPer1000Clocks = 500; 330 } 331 #endif 332 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface); 333 DECODE_CHK_NULL(waTable); 334 335 if (MEDIA_IS_WA(waTable, Wa_14012254246)) 336 { 337 auto userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface); 338 params.prefetchDisable = ReadUserFeature(userSettingPtr, "DisableTlbPrefetch", MediaUserSetting::Group::Sequence).Get<bool>(); 339 } 340 341 return MOS_STATUS_SUCCESS; 342 } 343 MHW_SETPAR_DECL_SRC(HCP_SURFACE_STATE,HevcDecodePicPkt)344 MHW_SETPAR_DECL_SRC(HCP_SURFACE_STATE, HevcDecodePicPkt) 345 { 346 DECODE_FUNC_CALL(); 347 348 uint8_t chromaType = m_hevcPicParams->chroma_format_idc; 349 uint8_t ucBitDepthLumaMinus8 = m_hevcPicParams->bit_depth_luma_minus8; 350 uint8_t ucBitDepthChromaMinus8 = m_hevcPicParams->bit_depth_luma_minus8; 351 uint32_t dwUVPlaneAlignment = 1 << (m_hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3); 352 PMOS_SURFACE psSurface = &m_hevcBasicFeature->m_destSurface; // For HEVC decode, reference should be same format as dest surface 353 MHW_MI_CHK_NULL(psSurface); 354 355 uint32_t uvPlaneAlignment = m_uvPlaneAlignmentLegacy; 356 357 params.surfaceStateId = m_curHcpSurfStateId; 358 params.surfacePitchMinus1 = psSurface->dwPitch - 1; 359 360 if (ucBitDepthLumaMinus8 == 0 && ucBitDepthChromaMinus8 == 0) 361 { 362 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_NV12) // 4:2:0 8bit surface 363 { 364 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_PLANAR4208; 365 } 366 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0 10bit surface 367 { 368 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010; 369 } 370 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_YUY2) // 4:2:2 8bit surface 371 { 372 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_YUY2FORMAT; 373 } 374 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y210) // 4:2:2 10bit surface 375 { 376 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT; 377 } 378 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_AYUV) // 4:4:4 8bit surface 379 { 380 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_AYUV4444FORMAT; 381 } 382 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y410) // 4:4:4 10bit surface 383 { 384 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y410FORMAT; 385 } 386 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0 16bit surface 387 { 388 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016; 389 } 390 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2 16bit surface 391 { 392 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT; 393 } 394 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4 395 { 396 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT; 397 } 398 else 399 { 400 return MOS_STATUS_INVALID_PARAMETER; 401 } 402 } 403 else if ((ucBitDepthLumaMinus8 <= 2) && (ucBitDepthChromaMinus8 <= 2)) // only support bitdepth <= 10bit 404 { 405 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P010) // 4:2:0 406 { 407 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P010; 408 } 409 else if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0 410 { 411 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016; 412 } 413 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y210) // 4:2:2 414 { 415 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT; 416 } 417 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2 418 { 419 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT; 420 } 421 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y410) // 4:4:4 422 { 423 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y410FORMAT; 424 } 425 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4 426 { 427 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT; 428 } 429 else 430 { 431 return MOS_STATUS_INVALID_PARAMETER; 432 } 433 } 434 else // 12bit 435 { 436 if (chromaType == HCP_CHROMA_FORMAT_YUV420 && psSurface->Format == Format_P016) // 4:2:0 437 { 438 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_P016; 439 } 440 else if (chromaType == HCP_CHROMA_FORMAT_YUV422 && psSurface->Format == Format_Y216) // 4:2:2 441 { 442 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y216Y210FORMAT; 443 } 444 else if (chromaType == HCP_CHROMA_FORMAT_YUV444 && psSurface->Format == Format_Y416) // 4:4:4 445 { 446 params.surfaceFormat = SURFACE_FORMAT::SURFACE_FORMAT_Y416FORMAT; 447 } 448 else 449 { 450 return MOS_STATUS_INVALID_PARAMETER; 451 } 452 } 453 454 if (m_curHcpSurfStateId == CODECHAL_HCP_SRC_SURFACE_ID) 455 { 456 uvPlaneAlignment = dwUVPlaneAlignment ? dwUVPlaneAlignment : m_rawUVPlaneAlignment; 457 } 458 else 459 { 460 uvPlaneAlignment = dwUVPlaneAlignment ? dwUVPlaneAlignment : m_reconUVPlaneAlignment; 461 } 462 463 params.yOffsetForUCbInPixel = 464 MOS_ALIGN_CEIL((psSurface->UPlaneOffset.iSurfaceOffset - psSurface->dwOffset) / psSurface->dwPitch + psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment); 465 466 if ((ucBitDepthLumaMinus8 == 4) || (ucBitDepthChromaMinus8 == 4)) // 12 bit 467 { 468 params.defaultAlphaValue = 0xfff0; 469 } 470 else 471 { 472 params.defaultAlphaValue = 0xffff; 473 } 474 475 #ifdef _MMC_SUPPORTED 476 if (m_curHcpSurfStateId == CODECHAL_HCP_DECODED_SURFACE_ID) 477 { 478 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(psSurface)); 479 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(psSurface, ¶ms.mmcState)); 480 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(psSurface, ¶ms.dwCompressionFormat)); 481 } 482 else if (m_curHcpSurfStateId == CODECHAL_HCP_REF_SURFACE_ID) 483 { 484 auto &pipeBufAddrPar = m_hcpItf->MHW_GETPAR_F(HCP_PIPE_BUF_ADDR_STATE)(); 485 486 HevcDecodeMemComp *hevcDecodeMemComp = dynamic_cast<HevcDecodeMemComp *>(m_mmcState); 487 DECODE_CHK_NULL(hevcDecodeMemComp); 488 if (m_hevcBasicFeature->m_isSCCIBCMode) 489 { 490 HevcReferenceFrames &refFrames = m_hevcBasicFeature->m_refFrames; 491 DECODE_CHK_NULL(m_hevcBasicFeature->m_hevcPicParams); 492 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_hevcBasicFeature->m_hevcPicParams); 493 uint8_t IBCRefIdx = refFrames.m_IBCRefIdx; 494 if (activeRefList.size() <= IBCRefIdx) 495 { 496 DECODE_ASSERTMESSAGE("Invalid IBC reference index."); 497 } 498 uint8_t IBCFrameIdx = activeRefList[IBCRefIdx]; 499 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) 500 { 501 MOS_MEMCOMP_STATE mmcState = MOS_MEMCOMP_DISABLED; 502 503 if (pipeBufAddrPar.presReferences[i] == nullptr || 504 pipeBufAddrPar.presReferences[i] == refFrames.GetReferenceByFrameIndex(IBCFrameIdx)) // Skip MMC Setting use default MOS_MEMCOMP_DISABLED value to control IBC ref suraface 505 { 506 continue; 507 } 508 DECODE_CHK_STATUS(m_mmcState->GetResourceMmcState(pipeBufAddrPar.presReferences[i], mmcState)); 509 params.refsMmcEnable |= (mmcState == MOS_MEMCOMP_RC || mmcState == MOS_MEMCOMP_MC) ? (1 << i) : 0; 510 params.refsMmcType |= (mmcState == MOS_MEMCOMP_RC) ? (1 << i) : 0; 511 if (m_mmcState->IsMmcEnabled()) 512 { 513 DECODE_CHK_STATUS(m_mmcState->GetResourceMmcFormat(pipeBufAddrPar.presReferences[i], params.dwCompressionFormat)); 514 } 515 } 516 } 517 else 518 { 519 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) 520 { 521 MOS_MEMCOMP_STATE mmcState = MOS_MEMCOMP_DISABLED; 522 523 if (pipeBufAddrPar.presReferences[i] == nullptr) 524 { 525 continue; 526 } 527 528 DECODE_CHK_STATUS(m_mmcState->GetResourceMmcState(pipeBufAddrPar.presReferences[i], mmcState)); 529 params.refsMmcEnable |= (mmcState == MOS_MEMCOMP_RC || mmcState == MOS_MEMCOMP_MC) ? (1 << i) : 0; 530 params.refsMmcType |= (mmcState == MOS_MEMCOMP_RC) ? (1 << i) : 0; 531 if (m_mmcState->IsMmcEnabled()) 532 { 533 DECODE_CHK_STATUS(m_mmcState->GetResourceMmcFormat(pipeBufAddrPar.presReferences[i], params.dwCompressionFormat)); 534 } 535 } 536 } 537 } 538 #endif 539 540 return MOS_STATUS_SUCCESS; 541 } 542 AddAllCmds_HCP_SURFACE_STATE(MOS_COMMAND_BUFFER & cmdBuffer)543 MOS_STATUS HevcDecodePicPkt::AddAllCmds_HCP_SURFACE_STATE(MOS_COMMAND_BUFFER &cmdBuffer) 544 { 545 DECODE_FUNC_CALL(); 546 547 auto ¶ms = m_hcpItf->MHW_GETPAR_F(HCP_SURFACE_STATE)(); 548 params = {}; 549 550 m_curHcpSurfStateId = CODECHAL_HCP_DECODED_SURFACE_ID; 551 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, &cmdBuffer); 552 553 params = {}; 554 m_curHcpSurfStateId = CODECHAL_HCP_REF_SURFACE_ID; 555 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, &cmdBuffer); 556 557 return MOS_STATUS_SUCCESS; 558 } 559 FixHcpPipeBufAddrParams(HCP_PIPE_BUF_ADDR_STATE_PAR & params) const560 MOS_STATUS HevcDecodePicPkt::FixHcpPipeBufAddrParams(HCP_PIPE_BUF_ADDR_STATE_PAR ¶ms) const 561 { 562 DECODE_FUNC_CALL(); 563 564 if (m_hevcBasicFeature->m_refFrames.m_curIsIntra) 565 { 566 PMOS_RESOURCE dummyRef = &(m_hevcBasicFeature->m_dummyReference.OsResource); 567 if (m_hevcBasicFeature->m_useDummyReference && 568 !m_allocator->ResourceIsNull(dummyRef)) 569 { 570 // set all ref pic addresses to valid addresses for error concealment purpose 571 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) 572 { 573 if (params.presReferences[i] == nullptr) 574 { 575 params.presReferences[i] = dummyRef; 576 m_hevcBasicFeature->m_dummyReferenceSlot[i] = true; 577 } 578 } 579 } 580 } 581 else 582 { 583 PMOS_RESOURCE validRef = m_hevcBasicFeature->m_refFrames.GetValidReference(); 584 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) 585 { 586 // error concealment for the unset reference addresses and unset mv buffers 587 if (params.presReferences[i] == nullptr) 588 { 589 params.presReferences[i] = validRef; 590 } 591 } 592 593 PMOS_BUFFER validMvBuf = m_hevcBasicFeature->m_mvBuffers.GetValidBufferForReference(m_hevcBasicFeature->m_refFrameIndexList); 594 for (uint32_t i = 0; i < CODEC_NUM_HEVC_MV_BUFFERS; i++) 595 { 596 if (params.presColMvTempBuffer[i] == nullptr) 597 { 598 params.presColMvTempBuffer[i] = &validMvBuf->OsResource; 599 } 600 } 601 } 602 603 return MOS_STATUS_SUCCESS; 604 } 605 606 #if USE_CODECHAL_DEBUG_TOOL DumpResources(HCP_PIPE_BUF_ADDR_STATE_PAR & pipeBufAddrParams,uint8_t activeRefListSize,uint32_t mvBufferSize) const607 MOS_STATUS HevcDecodePicPkt::DumpResources( 608 HCP_PIPE_BUF_ADDR_STATE_PAR &pipeBufAddrParams, 609 uint8_t activeRefListSize, 610 uint32_t mvBufferSize) const 611 { 612 DECODE_FUNC_CALL(); 613 614 CodechalDebugInterface *debugInterface = m_pipeline->GetDebugInterface(); 615 DECODE_CHK_NULL(debugInterface); 616 617 for (uint32_t i = 0; i < activeRefListSize; i++) 618 { 619 if (pipeBufAddrParams.presReferences[i] != nullptr) 620 { 621 MOS_SURFACE refSurface; 622 MOS_ZeroMemory(&refSurface, sizeof(MOS_SURFACE)); 623 refSurface.OsResource = *(pipeBufAddrParams.presReferences[i]); 624 DECODE_CHK_STATUS(CodecUtilities::CodecHalGetResourceInfo(m_osInterface, &refSurface)); 625 626 std::string refSurfDumpName = "RefSurf[" + std::to_string(i) + "]"; 627 DECODE_CHK_STATUS(debugInterface->DumpYUVSurface( 628 &refSurface, 629 CodechalDbgAttr::attrDecodeReferenceSurfaces, 630 refSurfDumpName.c_str())); 631 } 632 633 if (pipeBufAddrParams.presColMvTempBuffer[i] != nullptr) 634 { 635 std::string mvBufDumpName = "_DEC_" + std::to_string(i); 636 DECODE_CHK_STATUS(debugInterface->DumpBuffer( 637 pipeBufAddrParams.presColMvTempBuffer[i], 638 CodechalDbgAttr::attrMvData, 639 mvBufDumpName.c_str(), 640 mvBufferSize)); 641 } 642 } 643 644 return MOS_STATUS_SUCCESS; 645 } 646 #endif 647 MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE,HevcDecodePicPkt)648 MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE, HevcDecodePicPkt) 649 { 650 DECODE_FUNC_CALL(); 651 652 params.Mode = m_hevcBasicFeature->m_mode; 653 654 PMOS_SURFACE destSurface = &(m_hevcBasicFeature->m_destSurface); 655 params.psPreDeblockSurface = destSurface; 656 657 #ifdef _MMC_SUPPORTED 658 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(destSurface, ¶ms.PreDeblockSurfMmcState)); 659 #endif 660 661 params.presMfdDeblockingFilterRowStoreScratchBuffer = &(m_resMfdDeblockingFilterRowStoreScratchBuffer->OsResource); 662 params.presDeblockingFilterTileRowStoreScratchBuffer = &(m_resDeblockingFilterTileRowStoreScratchBuffer->OsResource); 663 params.presDeblockingFilterColumnRowStoreScratchBuffer = &(m_resDeblockingFilterColumnRowStoreScratchBuffer->OsResource); 664 665 params.presMetadataLineBuffer = &(m_resMetadataLineBuffer->OsResource); 666 params.presMetadataTileLineBuffer = &(m_resMetadataTileLineBuffer->OsResource); 667 params.presMetadataTileColumnBuffer = &(m_resMetadataTileColumnBuffer->OsResource); 668 params.presSaoLineBuffer = &(m_resSaoLineBuffer->OsResource); 669 params.presSaoTileLineBuffer = &(m_resSaoTileLineBuffer->OsResource); 670 params.presSaoTileColumnBuffer = &(m_resSaoTileColumnBuffer->OsResource); 671 672 auto mvBuffers = &(m_hevcBasicFeature->m_mvBuffers); 673 PMOS_BUFFER curMvBuffer = mvBuffers->GetCurBuffer(); 674 DECODE_CHK_NULL(curMvBuffer); 675 params.presCurMvTempBuffer = &(curMvBuffer->OsResource); 676 677 HevcReferenceFrames &refFrames = m_hevcBasicFeature->m_refFrames; 678 const std::vector<uint8_t> &activeRefList = refFrames.GetActiveReferenceList(*m_hevcPicParams); 679 if (!refFrames.m_curIsIntra) 680 { 681 DECODE_ASSERT(activeRefList.size() <= 8); 682 for (uint8_t i = 0; i < activeRefList.size(); i++) 683 { 684 uint8_t frameIdx = activeRefList[i]; 685 if (frameIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC) 686 { 687 continue; 688 } 689 690 params.presReferences[i] = refFrames.GetReferenceByFrameIndex(frameIdx); 691 if (params.presReferences[i] == nullptr) 692 { 693 PCODEC_REF_LIST curFrameInRefList = refFrames.m_refList[m_hevcPicParams->CurrPic.FrameIdx]; 694 DECODE_CHK_NULL(curFrameInRefList); 695 MOS_ZeroMemory(&curFrameInRefList->resRefPic, sizeof(MOS_RESOURCE)); 696 DECODE_ASSERTMESSAGE("Reference frame for current Frame is not exist, current frame will be skipped. Thus, clear current frame resource in reference list."); 697 return MOS_STATUS_INVALID_PARAMETER; 698 } 699 PMOS_BUFFER mvBuf = mvBuffers->GetBufferByFrameIndex(frameIdx); 700 params.presColMvTempBuffer[i] = mvBuf ? (&mvBuf->OsResource) : nullptr; 701 702 // Return error if reference surface's pitch * height is less than dest surface. 703 MOS_SURFACE refSurface; 704 refSurface.OsResource = *(params.presReferences[i]); 705 DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&refSurface)); 706 DECODE_CHK_COND((refSurface.dwPitch * refSurface.dwHeight) < (destSurface->dwPitch * destSurface->dwHeight), 707 "Reference surface's pitch * height is less than Dest surface."); 708 } 709 } 710 711 FixHcpPipeBufAddrParams(params); 712 713 if (m_hevcBasicFeature->m_isSCCIBCMode) 714 { 715 uint8_t IBCRefIdx = refFrames.m_IBCRefIdx; 716 DECODE_CHK_COND(activeRefList.size() <= IBCRefIdx, "Invalid IBC reference index."); 717 718 uint8_t refIdxMask = 0; 719 for (uint8_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++) 720 { 721 uint8_t IBCFrameIdx = activeRefList[IBCRefIdx]; 722 if (params.presReferences[i] == refFrames.GetReferenceByFrameIndex(IBCFrameIdx)) 723 { 724 refIdxMask |= (1 << i); 725 } 726 } 727 params.IBCRefIdxMask = refIdxMask; 728 } 729 730 CODECHAL_DEBUG_TOOL(DECODE_CHK_STATUS(DumpResources(params, activeRefList.size(), curMvBuffer->size))); 731 732 return MOS_STATUS_SUCCESS; 733 } 734 MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE,HevcDecodePicPkt)735 MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE, HevcDecodePicPkt) 736 { 737 DECODE_FUNC_CALL(); 738 739 params.bDecodeInUse = true; 740 params.dwDataSize = m_hevcBasicFeature->m_dataSize; 741 params.dwDataOffset = m_hevcBasicFeature->m_dataOffset; 742 params.presDataBuffer = &(m_hevcBasicFeature->m_resDataBuffer.OsResource); 743 744 return MOS_STATUS_SUCCESS; 745 } 746 AddAllCmds_HCP_QM_STATE(MOS_COMMAND_BUFFER & cmdBuffer)747 MOS_STATUS HevcDecodePicPkt::AddAllCmds_HCP_QM_STATE(MOS_COMMAND_BUFFER &cmdBuffer) 748 { 749 DECODE_FUNC_CALL(); 750 751 auto ¶ms = m_hcpItf->MHW_GETPAR_F(HCP_QM_STATE)(); 752 params = {}; 753 auto pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams; 754 MHW_MI_CHK_NULL(pHevcIqMatrix); 755 uint8_t *qMatrix = nullptr; 756 qMatrix = (uint8_t *)params.quantizermatrix; 757 758 for (uint8_t sizeId = 0; sizeId < 4; sizeId++) // 4x4, 8x8, 16x16, 32x32 759 { 760 for (uint8_t predType = 0; predType < 2; predType++) // Intra, Inter 761 { 762 for (uint8_t color = 0; color < 3; color++) // Y, Cb, Cr 763 { 764 if ((sizeId == 3) && (color != 0)) 765 break; 766 767 params.sizeid = sizeId; 768 params.predictionType = predType; 769 params.colorComponent = color; 770 771 switch (sizeId) 772 { 773 case SIZEID_4X4: 774 case SIZEID_8X8: 775 default: 776 params.dcCoefficient = 0; 777 break; 778 case SIZEID_16X16: 779 params.dcCoefficient = pHevcIqMatrix->ListDC16x16[3 * predType + color]; 780 break; 781 case SIZEID_32X32: 782 params.dcCoefficient = pHevcIqMatrix->ListDC32x32[predType]; 783 break; 784 } 785 786 if (sizeId == SIZEID_4X4) 787 { 788 for (uint8_t i = 0; i < 4; i++) 789 { 790 for (uint8_t ii = 0; ii < 4; ii++) 791 { 792 qMatrix[4 * i + ii] = pHevcIqMatrix->List4x4[3 * predType + color][4 * i + ii]; 793 } 794 } 795 } 796 else if (sizeId == SIZEID_8X8) 797 { 798 for (uint8_t i = 0; i < 8; i++) 799 { 800 for (uint8_t ii = 0; ii < 8; ii++) 801 { 802 qMatrix[8 * i + ii] = pHevcIqMatrix->List8x8[3 * predType + color][8 * i + ii]; 803 } 804 } 805 } 806 else if (sizeId == SIZEID_16X16) 807 { 808 for (uint8_t i = 0; i < 8; i++) 809 { 810 for (uint8_t ii = 0; ii < 8; ii++) 811 { 812 qMatrix[8 * i + ii] = pHevcIqMatrix->List16x16[3 * predType + color][8 * i + ii]; 813 } 814 } 815 } 816 else // 32x32 817 { 818 for (uint8_t i = 0; i < 8; i++) 819 { 820 for (uint8_t ii = 0; ii < 8; ii++) 821 { 822 qMatrix[8 * i + ii] = pHevcIqMatrix->List32x32[predType][8 * i + ii]; 823 } 824 } 825 } 826 827 DECODE_CHK_STATUS(m_hcpItf->MHW_ADDCMD_F(HCP_QM_STATE)(&cmdBuffer)); 828 } 829 } 830 } 831 832 return MOS_STATUS_SUCCESS; 833 } 834 MHW_SETPAR_DECL_SRC(HCP_PIC_STATE,HevcDecodePicPkt)835 MHW_SETPAR_DECL_SRC(HCP_PIC_STATE, HevcDecodePicPkt) 836 { 837 DECODE_FUNC_CALL(); 838 839 DECODE_CHK_NULL(m_hevcPicParams); 840 841 if (m_hevcRextPicParams && m_hevcRextPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag == 1) 842 { 843 MHW_ASSERTMESSAGE("HW decoder doesn't support HEVC High Throughput profile so far."); 844 MHW_ASSERTMESSAGE("So cabac_bypass_alignment_enabled_flag cannot equal to 1."); 845 return MOS_STATUS_INVALID_PARAMETER; 846 } 847 848 params.bDecodeInUse = true; 849 params.framewidthinmincbminus1 = m_hevcPicParams->PicWidthInMinCbsY - 1; 850 params.frameheightinmincbminus1 = m_hevcPicParams->PicHeightInMinCbsY - 1; 851 params.mincusize = (m_hevcPicParams->log2_min_luma_coding_block_size_minus3) & 0x3; 852 params.ctbsizeLcusize = (m_hevcPicParams->log2_diff_max_min_luma_coding_block_size + m_hevcPicParams->log2_min_luma_coding_block_size_minus3) & 0x3; 853 params.maxtusize = (m_hevcPicParams->log2_diff_max_min_transform_block_size + m_hevcPicParams->log2_min_transform_block_size_minus2) & 0x3; 854 params.mintusize = (m_hevcPicParams->log2_min_transform_block_size_minus2) & 0x3; 855 params.maxpcmsize = (m_hevcPicParams->log2_diff_max_min_pcm_luma_coding_block_size + m_hevcPicParams->log2_min_pcm_luma_coding_block_size_minus3) & 0x3; 856 params.minpcmsize = (m_hevcPicParams->log2_min_pcm_luma_coding_block_size_minus3) & 0x3; 857 858 // As per HW requirement, CurPicIsI and ColPicIsI should be set to either both correct or both zero 859 // Since driver doesn't know Collocated_Ref_Idx for SF, and cannot get accurate CurPicIsI for both LF/SF 860 // Have to make ColPicIsI = CurPicIsI = 0 for both LF/SF 861 params.sampleAdaptiveOffsetEnabled = m_hevcPicParams->sample_adaptive_offset_enabled_flag; 862 params.pcmEnabledFlag = m_hevcPicParams->pcm_enabled_flag; 863 params.cuQpDeltaEnabledFlag = m_hevcPicParams->cu_qp_delta_enabled_flag; 864 params.diffCuQpDeltaDepth = m_hevcPicParams->diff_cu_qp_delta_depth; 865 params.pcmLoopFilterDisableFlag = m_hevcPicParams->pcm_loop_filter_disabled_flag; 866 params.constrainedIntraPredFlag = m_hevcPicParams->constrained_intra_pred_flag; 867 params.log2ParallelMergeLevelMinus2 = m_hevcPicParams->log2_parallel_merge_level_minus2; 868 params.signDataHidingFlag = m_hevcPicParams->sign_data_hiding_enabled_flag; 869 params.loopFilterAcrossTilesEnabled = m_hevcPicParams->loop_filter_across_tiles_enabled_flag; 870 params.entropyCodingSyncEnabled = m_hevcPicParams->entropy_coding_sync_enabled_flag; 871 params.tilesEnabledFlag = m_hevcPicParams->tiles_enabled_flag; 872 params.weightedPredFlag = m_hevcPicParams->weighted_pred_flag; 873 params.weightedBipredFlag = m_hevcPicParams->weighted_bipred_flag; 874 params.fieldpic = (m_hevcPicParams->RefFieldPicFlag >> 15) & 0x01; 875 params.bottomfield = ((m_hevcPicParams->RefBottomFieldFlag >> 15) & 0x01) ? 0 : 1; 876 params.transformSkipEnabled = m_hevcPicParams->transform_skip_enabled_flag; 877 params.ampEnabledFlag = m_hevcPicParams->amp_enabled_flag; 878 params.transquantBypassEnableFlag = m_hevcPicParams->transquant_bypass_enabled_flag; 879 params.strongIntraSmoothingEnableFlag = m_hevcPicParams->strong_intra_smoothing_enabled_flag; 880 881 params.picCbQpOffset = m_hevcPicParams->pps_cb_qp_offset & 0x1f; 882 params.picCrQpOffset = m_hevcPicParams->pps_cr_qp_offset & 0x1f; 883 params.maxTransformHierarchyDepthIntra = m_hevcPicParams->max_transform_hierarchy_depth_intra & 0x7; 884 params.maxTransformHierarchyDepthInter = m_hevcPicParams->max_transform_hierarchy_depth_inter & 0x7; 885 params.pcmSampleBitDepthChromaMinus1 = m_hevcPicParams->pcm_sample_bit_depth_chroma_minus1; 886 params.pcmSampleBitDepthLumaMinus1 = m_hevcPicParams->pcm_sample_bit_depth_luma_minus1; 887 888 // RExt fields 889 params.chromaSubsampling = m_hevcPicParams->chroma_format_idc; 890 params.log2Maxtransformskipsize = m_hevcRextPicParams ? (m_hevcRextPicParams->log2_max_transform_skip_block_size_minus2 + 2) : 0x2; 891 892 params.bitDepthChromaMinus8 = m_hevcPicParams->bit_depth_chroma_minus8; 893 params.bitDepthLumaMinus8 = m_hevcPicParams->bit_depth_luma_minus8; 894 895 params.requestCRC = m_hevcPicParams->RequestCRC; 896 897 // Force to false due to definition in xe_lpm_plus 898 params.sseEnable = false; 899 params.rhodomainRateControlEnable = false; 900 params.fractionalQpAdjustmentEnable = false; 901 902 if (m_hevcSccPicParams) 903 { 904 params.deblockingFilterOverrideEnabled = m_hevcPicParams->deblocking_filter_override_enabled_flag; 905 params.ppsDeblockingFilterDisabled = m_hevcPicParams->pps_deblocking_filter_disabled_flag; 906 params.chromaBitDepthEntryMinus8 = m_hevcPicParams->bit_depth_chroma_minus8; 907 params.lumaBitDepthEntryMinus8 = m_hevcPicParams->bit_depth_luma_minus8; 908 params.ppsCurrPicRefEnabledFlag = m_hevcSccPicParams->PicSCCExtensionFlags.fields.pps_curr_pic_ref_enabled_flag; 909 params.motionVectorResolutionControlIdc = m_hevcSccPicParams->PicSCCExtensionFlags.fields.motion_vector_resolution_control_idc; 910 params.intraBoundaryFilteringDisabledFlag = m_hevcSccPicParams->PicSCCExtensionFlags.fields.intra_boundary_filtering_disabled_flag; 911 params.paletteMaxSize = m_hevcSccPicParams->palette_max_size; 912 params.deltaPaletteMaxPredictorSize = m_hevcSccPicParams->delta_palette_max_predictor_size; 913 params.ibcConfiguration = m_hevcSccPicParams->PicSCCExtensionFlags.fields.pps_curr_pic_ref_enabled_flag ? 2 : 0; 914 params.paletteModeEnabledFlag = m_hevcSccPicParams->PicSCCExtensionFlags.fields.palette_mode_enabled_flag; 915 } 916 return MOS_STATUS_SUCCESS; 917 } 918 MHW_SETPAR_DECL_SRC(HCP_TILE_STATE,HevcDecodePicPkt)919 MHW_SETPAR_DECL_SRC(HCP_TILE_STATE, HevcDecodePicPkt) 920 { 921 DECODE_FUNC_CALL(); 922 923 params.pTileColWidth = (uint16_t *)m_hevcBasicFeature->m_tileCoding.GetTileColWidth(); 924 params.pTileRowHeight = (uint16_t *)m_hevcBasicFeature->m_tileCoding.GetTileRowHeight(); 925 DECODE_CHK_NULL(params.pTileColWidth); 926 DECODE_CHK_NULL(params.pTileRowHeight); 927 params.numTileColumnsMinus1 = m_hevcPicParams->num_tile_columns_minus1; 928 params.numTileRowsMinus1 = m_hevcPicParams->num_tile_rows_minus1; 929 MHW_CHK_COND(m_hevcPicParams->num_tile_rows_minus1 >= HEVC_NUM_MAX_TILE_ROW, "num_tile_rows_minus1 is out of range!"); 930 MHW_CHK_COND(m_hevcPicParams->num_tile_columns_minus1 >= HEVC_NUM_MAX_TILE_COLUMN, "num_tile_columns_minus1 is out of range!"); 931 932 return MOS_STATUS_SUCCESS; 933 } 934 } 935 936