1 /* 2 * Copyright (c) 2021-2023, 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 mhw_vdbox_mfx_impl.h 24 //! \brief MHW VDBOX MFX interface common base 25 //! \details 26 //! 27 #ifndef __MHW_VDBOX_MFX_IMPL_H__ 28 #define __MHW_VDBOX_MFX_IMPL_H__ 29 30 #include "mhw_vdbox_mfx_itf.h" 31 #include "mhw_impl.h" 32 #include "mhw_mi_impl.h" 33 34 #ifdef IGFX_MFX_INTERFACE_EXT_SUPPORT 35 #include "mhw_vdbox_mfx_hwcmd_ext.h" 36 #endif 37 38 #define AVC_MPR_ROWSTORE_BASEADDRESS 256 39 #define AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF 512 40 #define AVC_IP_ROWSTORE_BASEADDRESS 512 41 #define AVC_IP_ROWSTORE_BASEADDRESS_MBAFF 1024 42 #define AVC_VLF_ROWSTORE_BASEADDRESS 768 43 #define VP8_IP_ROWSTORE_BASEADDRESS 256 44 #define VP8_VLF_ROWSTORE_BASEADDRESS 512 45 46 namespace mhw 47 { 48 namespace vdbox 49 { 50 namespace mfx 51 { 52 53 template<typename cmd_t> 54 class Impl : public Itf, public mhw::Impl 55 { 56 _MFX_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL); 57 58 public: SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC])59 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override 60 { 61 MHW_FUNCTION_ENTER; 62 63 MHW_CHK_NULL_RETURN(settings); 64 65 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS); 66 67 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size); 68 } 69 GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)70 MOS_STATUS GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) override 71 { 72 MHW_FUNCTION_ENTER; 73 74 MHW_MI_CHK_NULL(rowstoreParams); 75 76 bool avc = rowstoreParams->Mode == CODECHAL_DECODE_MODE_AVCVLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC; 77 bool vp8 = rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP8VLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP8; 78 bool widthLE4K = rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K; 79 bool mbaffOrField = rowstoreParams->bMbaff || !rowstoreParams->bIsFrame; 80 81 //BSD row store cache 82 m_bsdMpcRowstoreCache.enabled = m_bsdMpcRowstoreCache.supported && widthLE4K && (avc || vp8); 83 m_bsdMpcRowstoreCache.dwAddress = m_bsdMpcRowstoreCache.enabled ? BSDMPCROWSTORE_BASEADDRESS : 0; 84 85 //MPR row store cache 86 m_mprRowstoreCache.enabled = m_mprRowstoreCache.supported && widthLE4K && avc; 87 m_mprRowstoreCache.dwAddress = m_mprRowstoreCache.enabled ? (mbaffOrField ? AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF : AVC_MPR_ROWSTORE_BASEADDRESS) : 0; 88 89 //Intra Prediction row store cache 90 m_intraRowstoreCache.enabled = m_intraRowstoreCache.supported && widthLE4K && (avc || vp8); 91 if (m_intraRowstoreCache.enabled) 92 { 93 m_intraRowstoreCache.dwAddress = avc ? (mbaffOrField ? AVC_IP_ROWSTORE_BASEADDRESS_MBAFF 94 : AVC_IP_ROWSTORE_BASEADDRESS) 95 : VP8_IP_ROWSTORE_BASEADDRESS; 96 } 97 else 98 { 99 m_intraRowstoreCache.dwAddress = 0; 100 } 101 102 //VLF row store cache 103 m_deblockingFilterRowstoreCache.enabled = m_deblockingFilterRowstoreCache.supported && widthLE4K && ((avc && !mbaffOrField) || vp8); 104 m_deblockingFilterRowstoreCache.dwAddress = m_deblockingFilterRowstoreCache.enabled ? (avc ? AVC_VLF_ROWSTORE_BASEADDRESS : VP8_VLF_ROWSTORE_BASEADDRESS) : 0; 105 106 return MOS_STATUS_SUCCESS; 107 } 108 SetCacheabilitySettings()109 virtual void SetCacheabilitySettings() 110 { 111 MHW_FUNCTION_ENTER; 112 m_preDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( 113 MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC, 114 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 115 m_postDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( 116 MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC, 117 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 118 m_OriginalUncompressedPictureSourceMemoryCtrl.Value = 119 m_osItf->pfnCachePolicyGetMemoryObject( 120 MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE, 121 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 122 m_streamoutDataDestinationMemoryCtrl.Value = 123 m_osItf->pfnCachePolicyGetMemoryObject( 124 MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC, 125 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 126 m_intraRowStoreScratchBufferMemoryCtrl.Value = 127 m_osItf->pfnCachePolicyGetMemoryObject( 128 MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC, 129 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 130 m_deblockingFilterRowStoreScratchMemoryCtrl.Value = 131 m_osItf->pfnCachePolicyGetMemoryObject( 132 MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC, 133 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 134 m_referncePictureMemoryObjectControlStateCtrl.Value = 135 m_osItf->pfnCachePolicyGetMemoryObject( 136 MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC, 137 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 138 m_referncePictureMemoryObjectControlStateCtrlDecode.Value = 139 m_osItf->pfnCachePolicyGetMemoryObject( 140 MOS_HW_RESOURCE_USAGE_DECODE_INPUT_REFERENCE, 141 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 142 m_referncePictureMemoryObjectControlStateCtrlEncode.Value = 143 m_osItf->pfnCachePolicyGetMemoryObject( 144 MOS_HW_RESOURCE_USAGE_ENCODE_INPUT_RECON, 145 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 146 m_macroblockIldbStreamoutBufferCtrl.Value = 147 m_osItf->pfnCachePolicyGetMemoryObject( 148 MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC, 149 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 150 m_secondMacroblockIldbStreamoutBufferCtrl.Value = 151 m_osItf->pfnCachePolicyGetMemoryObject( 152 MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC, 153 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 154 m_slicesizeStreamoutDataDestinationCtrl.Value = 155 m_osItf->pfnCachePolicyGetMemoryObject( 156 MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC, 157 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 158 m_mfxIndirectBitstreamCtrl.Value = 159 m_osItf->pfnCachePolicyGetMemoryObject( 160 MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE, 161 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 162 m_mfdIndirectItCoeffCtrl.Value = 163 m_osItf->pfnCachePolicyGetMemoryObject( 164 MOS_CODEC_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE, 165 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 166 m_mfxIndirectMvCtrl.Value = 167 m_osItf->pfnCachePolicyGetMemoryObject( 168 MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC, 169 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 170 m_mfcIndirectPakBseCtrl.Value = 171 m_osItf->pfnCachePolicyGetMemoryObject( 172 MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC, 173 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 174 m_bsdMpcRowStoreScratchBufferCtrl.Value = 175 m_osItf->pfnCachePolicyGetMemoryObject( 176 MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC, 177 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 178 m_mprRowStoreScratchBufferCtrl.Value = 179 m_osItf->pfnCachePolicyGetMemoryObject( 180 MOS_CODEC_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC, 181 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 182 m_bitplaneReadBufferIndexToMemoryCtrl.Value = 183 m_osItf->pfnCachePolicyGetMemoryObject( 184 MOS_CODEC_RESOURCE_USAGE_BITPLANE_READ_CODEC, 185 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 186 187 m_directMvBufferForWriteCtrl.Value = 188 m_osItf->pfnCachePolicyGetMemoryObject( 189 MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC, 190 m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; 191 192 } 193 IsRowStoreCachingSupported()194 bool IsRowStoreCachingSupported() override 195 { 196 return m_rowstoreCachingSupported; 197 } 198 IsMprRowstoreCacheEnabled()199 bool IsMprRowstoreCacheEnabled() override 200 { 201 return m_mprRowstoreCache.enabled; 202 } 203 GetViewOrder(MFD_AVC_DPB_STATE_PAR params,uint32_t currIdx,uint32_t list)204 uint32_t GetViewOrder( 205 MFD_AVC_DPB_STATE_PAR params, 206 uint32_t currIdx, 207 uint32_t list) 208 { 209 auto avcPicParams = params.pAvcPicParams; 210 auto mvcExtPicParams = params.pMvcExtPicParams; 211 auto avcRefList = params.ppAvcRefList; 212 213 // No need to check if bottom field since only progressive is supported for mvc clips. 214 int32_t currPOC = avcPicParams->CurrFieldOrderCnt[0]; 215 uint32_t numRefs = (list == LIST_0) ? mvcExtPicParams->NumInterViewRefsL0 : mvcExtPicParams->NumInterViewRefsL1; 216 uint32_t viewOrder = 0xF; 217 uint32_t currRef = params.pAvcPicIdx[currIdx].ucPicIdx; 218 219 if (params.pAvcPicIdx[currIdx].bValid && 220 avcRefList[currRef]->bUsedAsInterViewRef && 221 (currPOC == avcRefList[currRef]->iFieldOrderCnt[0])) 222 { 223 for (uint32_t i = 0; i < numRefs; i++) 224 { 225 if (mvcExtPicParams->ViewIDList[currIdx] == mvcExtPicParams->InterViewRefList[list][i]) 226 { 227 viewOrder = mvcExtPicParams->ViewIDList[currIdx]; 228 break; 229 } 230 } 231 } 232 233 return viewOrder; 234 } 235 IsDeblockingFilterRowstoreCacheEnabled()236 bool IsDeblockingFilterRowstoreCacheEnabled() override 237 { 238 return m_deblockingFilterRowstoreCache.enabled; 239 } 240 IsIntraRowstoreCacheEnabled()241 bool IsIntraRowstoreCacheEnabled() override 242 { 243 return m_intraRowstoreCache.enabled; 244 } 245 IsBsdMpcRowstoreCacheEnabled()246 bool IsBsdMpcRowstoreCacheEnabled() override 247 { 248 return m_bsdMpcRowstoreCache.enabled; 249 } 250 GetMaxVdboxIndex()251 MHW_VDBOX_NODE_IND GetMaxVdboxIndex() override 252 { 253 return MEDIA_IS_SKU(m_osItf->pfnGetSkuTable(m_osItf), FtrVcs2) ? MHW_VDBOX_NODE_2 : MHW_VDBOX_NODE_1; 254 } 255 256 //! 257 //! \brief Get the vdbox num 258 //! 259 //! \return bool 260 //! vdbox num got 261 //! GetNumVdbox()262 uint8_t GetNumVdbox() override 263 { 264 MEDIA_ENGINE_INFO mediaEngineInfo = {}; 265 m_osItf->pfnGetMediaEngineInfo(m_osItf, mediaEngineInfo); 266 267 m_numVdbox = (uint8_t)(mediaEngineInfo.VDBoxInfo.NumberOfVDBoxEnabled); 268 269 return m_numVdbox; 270 } 271 272 #if (_DEBUG || _RELEASE_INTERNAL) CheckScalabilityOverrideValidity()273 MOS_STATUS CheckScalabilityOverrideValidity() 274 { 275 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 276 277 MEDIA_SYSTEM_INFO *gtSystemInfo; 278 uint32_t forceVdbox; 279 bool scalableDecMode; 280 bool useVD1, useVD2, useVD3, useVD4; 281 282 MHW_MI_CHK_NULL(m_osItf); 283 scalableDecMode = m_osItf->bHcpDecScalabilityMode ? true : false; 284 forceVdbox = m_osItf->eForceVdbox; 285 gtSystemInfo = m_osItf->pfnGetGtSystemInfo(m_osItf); 286 MHW_MI_CHK_NULL(gtSystemInfo); 287 288 if (forceVdbox != MOS_FORCE_VDBOX_NONE && 289 forceVdbox != MOS_FORCE_VDBOX_1 && 290 forceVdbox != MOS_FORCE_VDBOX_2 && 291 // 2 pipes, VDBOX1-BE1, VDBOX2-BE2 292 forceVdbox != MOS_FORCE_VDBOX_1_1_2 && 293 forceVdbox != MOS_FORCE_VDBOX_2_1_2) 294 { 295 eStatus = MOS_STATUS_INVALID_PARAMETER; 296 MHW_ASSERTMESSAGE("user feature forceVdbox value is invalid."); 297 return eStatus; 298 } 299 300 if (!scalableDecMode && 301 (forceVdbox == MOS_FORCE_VDBOX_1_1_2 || 302 forceVdbox == MOS_FORCE_VDBOX_2_1_2)) 303 { 304 eStatus = MOS_STATUS_INVALID_PARAMETER; 305 MHW_ASSERTMESSAGE("user feature forceVdbox valude does not consistent with regkey scalability mode."); 306 return eStatus; 307 } 308 309 if (scalableDecMode && !m_scalabilitySupported) 310 { 311 eStatus = MOS_STATUS_INVALID_PARAMETER; 312 MHW_ASSERTMESSAGE("user feature scalability mode is not allowed on current platform!"); 313 return eStatus; 314 } 315 316 useVD1 = useVD2 = false; 317 if (forceVdbox == 0) 318 { 319 useVD1 = true; 320 } 321 else 322 { 323 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_1, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD1); 324 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_2, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD2); 325 } 326 327 if (!gtSystemInfo->VDBoxInfo.IsValid || 328 (useVD1 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox0Enabled) || 329 (useVD2 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox1Enabled)) 330 { 331 eStatus = MOS_STATUS_INVALID_PARAMETER; 332 MHW_ASSERTMESSAGE("the forced VDBOX is not enabled in current platform."); 333 return eStatus; 334 } 335 336 return eStatus; 337 } 338 #endif 339 FindGpuNodeToUse(PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit)340 MOS_STATUS FindGpuNodeToUse(PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit) override 341 { 342 bool setVideoNode = false; 343 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 344 345 MOS_GPU_NODE videoGpuNode = MOS_GPU_NODE_VIDEO; 346 347 if (MOS_VE_MULTINODESCALING_SUPPORTED(m_osItf)) 348 { 349 if (GetNumVdbox() == 1) 350 { 351 videoGpuNode = MOS_GPU_NODE_VIDEO; 352 } 353 else 354 { 355 MHW_MI_CHK_STATUS(m_osItf->pfnCreateVideoNodeAssociation( 356 m_osItf, 357 setVideoNode, 358 &videoGpuNode)); 359 } 360 } 361 362 #if (_DEBUG || _RELEASE_INTERNAL) 363 if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE && 364 (!m_osItf->bSupportVirtualEngine || !m_scalabilitySupported)) 365 { 366 eStatus = MOS_STATUS_INVALID_PARAMETER; 367 MHW_ASSERTMESSAGE("not support DebugOverrid on current OS or Platform."); 368 return eStatus; 369 } 370 371 if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE) 372 { 373 MHW_MI_CHK_STATUS(CheckScalabilityOverrideValidity()); 374 } 375 #endif 376 377 gpuNodeLimit->dwGpuNodeToUse = videoGpuNode; 378 379 return eStatus; 380 } 381 382 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_preDeblockingMemoryCtrl; 383 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_postDeblockingMemoryCtrl; 384 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_OriginalUncompressedPictureSourceMemoryCtrl; 385 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_streamoutDataDestinationMemoryCtrl; 386 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_intraRowStoreScratchBufferMemoryCtrl; 387 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_deblockingFilterRowStoreScratchMemoryCtrl; 388 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrl; 389 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlDecode; 390 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlEncode; 391 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_macroblockIldbStreamoutBufferCtrl; 392 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_secondMacroblockIldbStreamoutBufferCtrl; 393 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_slicesizeStreamoutDataDestinationCtrl; 394 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectBitstreamCtrl; 395 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfdIndirectItCoeffCtrl; 396 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectMvCtrl; 397 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfcIndirectPakBseCtrl; 398 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bsdMpcRowStoreScratchBufferCtrl; 399 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mprRowStoreScratchBufferCtrl; 400 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bitplaneReadBufferIndexToMemoryCtrl; 401 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_directMvBufferForWriteCtrl; 402 403 protected: 404 using base_t = Itf; 405 MhwCpInterface *m_cpItf = nullptr; 406 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {}; 407 Impl(PMOS_INTERFACE osItf,MhwCpInterface * cpItf)408 Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : mhw::Impl(osItf) 409 { 410 MHW_FUNCTION_ENTER; 411 m_cpItf = cpItf; 412 413 InitRowstoreUserFeatureSettings(); 414 SetCacheabilitySettings(); 415 } 416 ~Impl()417 virtual ~Impl() 418 { 419 MHW_FUNCTION_ENTER; 420 421 #if (_DEBUG || _RELEASE_INTERNAL) 422 if (m_intraRowstoreCache.enabled || 423 m_deblockingFilterRowstoreCache.enabled || 424 m_bsdMpcRowstoreCache.enabled || 425 m_mprRowstoreCache.enabled) 426 { 427 // Report rowstore cache usage status to regkey 428 ReportUserSettingForDebug( 429 m_userSettingPtr, 430 __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED, 431 1, 432 MediaUserSetting::Group::Device); 433 } 434 #endif 435 436 } 437 InitRowstoreUserFeatureSettings()438 MOS_STATUS InitRowstoreUserFeatureSettings() 439 { 440 MHW_FUNCTION_ENTER; 441 442 bool rowstoreCachingDisableDefaultValue = false; 443 if (m_osItf->bSimIsActive) 444 { 445 // Disable RowStore Cache on simulation by default 446 rowstoreCachingDisableDefaultValue = true; 447 } 448 else 449 { 450 rowstoreCachingDisableDefaultValue = false; 451 } 452 m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue; 453 #if (_DEBUG || _RELEASE_INTERNAL) 454 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf); 455 { 456 MediaUserSetting::Value outValue; 457 ReadUserSettingForDebug(userSettingPtr, 458 outValue, 459 "Disable RowStore Cache", 460 MediaUserSetting::Group::Device, 461 rowstoreCachingDisableDefaultValue, 462 true); 463 m_rowstoreCachingSupported = !(outValue.Get<bool>()); 464 } 465 #endif // _DEBUG || _RELEASE_INTERNAL 466 467 if (m_rowstoreCachingSupported) 468 { 469 m_intraRowstoreCache.supported = true; 470 #if (_DEBUG || _RELEASE_INTERNAL) 471 { 472 MediaUserSetting::Value outValue; 473 ReadUserSettingForDebug(userSettingPtr, 474 outValue, 475 "DisableIntraRowStoreCache", 476 MediaUserSetting::Group::Device); 477 m_intraRowstoreCache.supported = !(outValue.Get<bool>()); 478 } 479 #endif // _DEBUG || _RELEASE_INTERNAL 480 481 m_deblockingFilterRowstoreCache.supported = true; 482 #if (_DEBUG || _RELEASE_INTERNAL) 483 { 484 MediaUserSetting::Value outValue; 485 ReadUserSettingForDebug(userSettingPtr, 486 outValue, 487 "DisableDeblockingFilterRowStoreCache", 488 MediaUserSetting::Group::Device); 489 m_deblockingFilterRowstoreCache.supported = !(outValue.Get<bool>()); 490 } 491 #endif // _DEBUG || _RELEASE_INTERNAL 492 493 m_bsdMpcRowstoreCache.supported = true; 494 #if (_DEBUG || _RELEASE_INTERNAL) 495 { 496 MediaUserSetting::Value outValue; 497 ReadUserSettingForDebug(userSettingPtr, 498 outValue, 499 "DisableBsdMpcRowStoreCache", 500 MediaUserSetting::Group::Device); 501 m_bsdMpcRowstoreCache.supported = !(outValue.Get<bool>()); 502 } 503 #endif // _DEBUG || _RELEASE_INTERNAL 504 505 m_mprRowstoreCache.supported = true; 506 #if (_DEBUG || _RELEASE_INTERNAL) 507 { 508 MediaUserSetting::Value outValue; 509 ReadUserSettingForDebug(userSettingPtr, 510 outValue, 511 "DisableMprRowStoreCache", 512 MediaUserSetting::Group::Device); 513 m_mprRowstoreCache.supported = !(outValue.Get<bool>()); 514 } 515 #endif // _DEBUG || _RELEASE_INTERNAL 516 } 517 518 return MOS_STATUS_SUCCESS; 519 } 520 _MHW_SETCMD_OVERRIDE_DECL(MFX_QM_STATE)521 _MHW_SETCMD_OVERRIDE_DECL(MFX_QM_STATE) 522 { 523 _MHW_SETCMD_CALLBASE(MFX_QM_STATE); 524 525 for (uint8_t i = 0; i < 16; i++) 526 { 527 cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i]; 528 } 529 530 cmd.DW1.Obj2.Avc = params.qmType; 531 532 return MOS_STATUS_SUCCESS; 533 } 534 _MHW_SETCMD_OVERRIDE_DECL(MFX_FQM_STATE)535 _MHW_SETCMD_OVERRIDE_DECL(MFX_FQM_STATE) 536 { 537 _MHW_SETCMD_CALLBASE(MFX_FQM_STATE); 538 539 for (uint8_t i = 0; i < 32; i++) 540 { 541 cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i]; 542 } 543 544 cmd.DW1.Obj2.Avc = params.qmType; 545 546 return MOS_STATUS_SUCCESS; 547 } 548 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT)549 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT) 550 { 551 _MHW_SETCMD_CALLBASE(MFX_PIPE_MODE_SELECT); 552 553 MHW_MI_CHK_STATUS(m_cpItf->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)&cmd)); 554 555 #define DO_FIELDS() \ 556 DO_FIELD(DW1, StandardSelect, params.standardSelect); \ 557 DO_FIELD(DW1, CodecSelect, params.codecSelect); \ 558 DO_FIELD(DW1, FrameStatisticsStreamoutEnable, params.frameStatisticsStreamoutEnable); \ 559 DO_FIELD(DW1, ScaledSurfaceEnable, params.scaledSurfaceEnable); \ 560 DO_FIELD(DW1, PreDeblockingOutputEnablePredeblockoutenable, params.preDeblockingOutputEnablePredeblockoutenable); \ 561 DO_FIELD(DW1, PostDeblockingOutputEnablePostdeblockoutenable, params.postDeblockingOutputEnablePostdeblockoutenable); \ 562 DO_FIELD(DW1, StreamOutEnable, params.streamOutEnable); \ 563 DO_FIELD(DW1, DeblockerStreamOutEnable, params.deblockerStreamOutEnable); \ 564 DO_FIELD(DW1, VdencMode, params.vdencMode); \ 565 DO_FIELD(DW1, DecoderModeSelect, params.decoderModeSelect); \ 566 DO_FIELD(DW1, DecoderShortFormatMode, params.decoderShortFormatMode); \ 567 DO_FIELD(DW1, ExtendedStreamOutEnable, params.extendedStreamOutEnable); \ 568 DO_FIELD(DW2, Vlf720IOddHeightInVc1Mode, params.vlf720IOddHeightInVc1Mode); 569 570 #include "mhw_hwcmd_process_cmdfields.h" 571 } 572 _MHW_SETCMD_OVERRIDE_DECL(MFX_SURFACE_STATE)573 _MHW_SETCMD_OVERRIDE_DECL(MFX_SURFACE_STATE) 574 { 575 _MHW_SETCMD_CALLBASE(MFX_SURFACE_STATE); 576 577 #define DO_FIELDS() \ 578 DO_FIELD(DW1, SurfaceId, params.surfaceId); \ 579 DO_FIELD(DW2, Height, params.height); \ 580 DO_FIELD(DW2, Width, params.width); \ 581 DO_FIELD(DW3, Tilemode, params.tilemode); \ 582 DO_FIELD(DW3, SurfacePitch, params.surfacePitch); \ 583 DO_FIELD(DW3, CompressionFormat, params.compressionFormat); \ 584 DO_FIELD(DW3, InterleaveChroma, params.interleaveChroma); \ 585 DO_FIELD(DW3, SurfaceFormat, params.surfaceFormat); \ 586 DO_FIELD(DW4, YOffsetForUCb, params.yOffsetForUCb); \ 587 DO_FIELD(DW5, YOffsetForVCr, params.yOffsetForVCr); 588 589 #include "mhw_hwcmd_process_cmdfields.h" 590 } 591 _MHW_SETCMD_OVERRIDE_DECL(MFX_IND_OBJ_BASE_ADDR_STATE)592 _MHW_SETCMD_OVERRIDE_DECL(MFX_IND_OBJ_BASE_ADDR_STATE) 593 { 594 _MHW_SETCMD_CALLBASE(MFX_IND_OBJ_BASE_ADDR_STATE); 595 596 MHW_RESOURCE_PARAMS resourceParams; 597 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 598 resourceParams.dwLsbNum = MHW_VDBOX_MFX_UPPER_BOUND_STATE_SHIFT; 599 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR; 600 601 // mode specific settings 602 if (CodecHalIsDecodeModeVLD(params.Mode) || (params.Mode == CODECHAL_ENCODE_MODE_VP8)) 603 { 604 MHW_MI_CHK_NULL(params.presDataBuffer); 605 606 InitMocsParams(resourceParams, &cmd.MfxIndirectBitstreamObjectAttributes.DW0.Value, 1, 6); 607 608 resourceParams.presResource = params.presDataBuffer; 609 resourceParams.dwOffset = params.dwDataOffset; 610 resourceParams.pdwCmd = cmd.MfxIndirectBitstreamObjectBaseAddress.DW0_1.Value; 611 resourceParams.dwLocationInCmd = 1; 612 resourceParams.dwSize = params.dwDataSize; 613 resourceParams.bIsWritable = false; 614 615 // upper bound of the allocated resource will be set at 3 DW apart from address location 616 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; 617 618 MHW_MI_CHK_STATUS(AddResourceToCmd( 619 this->m_osItf, 620 this->m_currentCmdBuf, 621 &resourceParams)); 622 } 623 else if (CodecHalIsDecodeModeIT(params.Mode)) 624 { 625 MHW_MI_CHK_NULL(params.presDataBuffer); 626 InitMocsParams(resourceParams, &cmd.MfdIndirectItCoeffObjectAttributes.DW0.Value, 1, 6); 627 628 resourceParams.presResource = params.presDataBuffer; 629 resourceParams.dwOffset = params.dwDataOffset; 630 resourceParams.pdwCmd = cmd.MfdIndirectItCoeffObjectBaseAddress.DW0_1.Value; 631 resourceParams.dwLocationInCmd = 11; 632 resourceParams.dwSize = params.dwDataSize; 633 resourceParams.bIsWritable = false; 634 635 // upper bound of the allocated resource will be set at 3 DW apart from address location 636 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; 637 638 MHW_MI_CHK_STATUS(AddResourceToCmd( 639 this->m_osItf, 640 this->m_currentCmdBuf, 641 &resourceParams)); 642 } 643 644 if (params.presMvObjectBuffer) 645 { 646 InitMocsParams(resourceParams, &cmd.MfxIndirectMvObjectAttributes.DW0.Value, 1, 6); 647 cmd.MfxIndirectMvObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfxIndirectMvCtrl.Gen12_7.Index; 648 649 resourceParams.presResource = params.presMvObjectBuffer; 650 resourceParams.dwOffset = params.dwMvObjectOffset; 651 resourceParams.pdwCmd = cmd.MfxIndirectMvObjectBaseAddress.DW0_1.Value; 652 resourceParams.dwLocationInCmd = 6; 653 resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwMvObjectSize, 0x1000); 654 resourceParams.bIsWritable = false; 655 656 // upper bound of the allocated resource will be set at 3 DW apart from address location 657 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; 658 659 MHW_MI_CHK_STATUS(AddResourceToCmd( 660 this->m_osItf, 661 this->m_currentCmdBuf, 662 &resourceParams)); 663 } 664 665 if (params.presPakBaseObjectBuffer) 666 { 667 InitMocsParams(resourceParams, &cmd.MfcIndirectPakBseObjectAttributes.DW0.Value, 1, 6); 668 cmd.MfcIndirectPakBseObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfcIndirectPakBseCtrl.Gen12_7.Index; 669 670 resourceParams.presResource = params.presPakBaseObjectBuffer; 671 resourceParams.dwOffset = 0; 672 resourceParams.pdwCmd = cmd.MfcIndirectPakBseObjectBaseAddress.DW0_1.Value; 673 resourceParams.dwLocationInCmd = 21; 674 resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwPakBaseObjectSize, 0x1000); 675 resourceParams.bIsWritable = true; 676 677 // upper bound of the allocated resource will be set at 3 DW apart from address location 678 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; 679 680 MHW_MI_CHK_STATUS(AddResourceToCmd( 681 this->m_osItf, 682 this->m_currentCmdBuf, 683 &resourceParams)); 684 } 685 686 return MOS_STATUS_SUCCESS; 687 } 688 _MHW_SETCMD_OVERRIDE_DECL(MFX_BSP_BUF_BASE_ADDR_STATE)689 _MHW_SETCMD_OVERRIDE_DECL(MFX_BSP_BUF_BASE_ADDR_STATE) 690 { 691 _MHW_SETCMD_CALLBASE(MFX_BSP_BUF_BASE_ADDR_STATE); 692 693 MHW_RESOURCE_PARAMS resourceParams; 694 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 695 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 696 resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR; 697 698 if (m_bsdMpcRowstoreCache.enabled) // mbaff and non mbaff mode for all resolutions 699 { 700 cmd.DW3.BsdMpcRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 701 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = m_bsdMpcRowstoreCache.dwAddress; 702 } 703 else if (params.presBsdMpcRowStoreScratchBuffer) 704 { 705 InitMocsParams(resourceParams, &cmd.DW3.Value, 1, 6); 706 cmd.DW3.BsdMpcRowStoreScratchBufferIndexToMemoryObjectControlStateMocsTables = m_bsdMpcRowStoreScratchBufferCtrl.Gen12_7.Index; 707 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = 0; 708 709 resourceParams.presResource = params.presBsdMpcRowStoreScratchBuffer; 710 resourceParams.dwOffset = 0; 711 resourceParams.pdwCmd = &(cmd.DW1.Value); 712 resourceParams.dwLocationInCmd = 1; 713 resourceParams.bIsWritable = true; 714 715 MHW_MI_CHK_STATUS(AddResourceToCmd( 716 this->m_osItf, 717 this->m_currentCmdBuf, 718 &resourceParams)); 719 } 720 721 if (m_mprRowstoreCache.enabled) 722 { 723 cmd.DW6.MprRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 724 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = m_mprRowstoreCache.dwAddress; 725 } 726 else if (params.presMprRowStoreScratchBuffer) 727 { 728 InitMocsParams(resourceParams, &cmd.DW6.Value, 1, 6); 729 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = 0; 730 731 resourceParams.presResource = params.presMprRowStoreScratchBuffer; 732 resourceParams.dwOffset = 0; 733 resourceParams.pdwCmd = &(cmd.DW4.Value); 734 resourceParams.dwLocationInCmd = 4; 735 resourceParams.bIsWritable = true; 736 737 MHW_MI_CHK_STATUS(AddResourceToCmd( 738 this->m_osItf, 739 this->m_currentCmdBuf, 740 &resourceParams)); 741 } 742 743 return MOS_STATUS_SUCCESS; 744 } 745 _MHW_SETCMD_OVERRIDE_DECL(MFX_PAK_INSERT_OBJECT)746 _MHW_SETCMD_OVERRIDE_DECL(MFX_PAK_INSERT_OBJECT) 747 { 748 _MHW_SETCMD_CALLBASE(MFX_PAK_INSERT_OBJECT); 749 750 uint32_t dwordsUsed = cmd.dwSize; 751 752 dwordsUsed += params.dwPadding; 753 754 #define DO_FIELDS() \ 755 DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \ 756 DO_FIELD(DW1, BitstreamstartresetResetbitstreamstartingpos, params.bitstreamstartresetResetbitstreamstartingpos); \ 757 DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.endofsliceflagLastdstdatainsertcommandflag); \ 758 DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.lastheaderflagLastsrcheaderdatainsertcommandflag); \ 759 DO_FIELD(DW1, EmulationflagEmulationbytebitsinsertenable, params.emulationflagEmulationbytebitsinsertenable); \ 760 DO_FIELD(DW1, SkipemulbytecntSkipEmulationByteCount, params.skipemulbytecntSkipEmulationByteCount); \ 761 DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, params.databitsinlastdwSrcdataendingbitinclusion50); \ 762 DO_FIELD(DW1, SliceHeaderIndicator, params.sliceHeaderIndicator); \ 763 DO_FIELD(DW1, Headerlengthexcludefrmsize, params.headerlengthexcludefrmsize); \ 764 DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, 0); 765 766 #include "mhw_hwcmd_process_cmdfields.h" 767 } 768 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE)769 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE) 770 { 771 _MHW_SETCMD_CALLBASE(MFX_AVC_IMG_STATE); 772 773 #define DO_FIELDS() \ 774 DO_FIELD(DW1, FrameSize, params.frameSize); \ 775 DO_FIELD(DW2, FrameWidth, params.frameWidth); \ 776 DO_FIELD(DW2, FrameHeight, params.frameHeight); \ 777 DO_FIELD(DW3, ImgstructImageStructureImgStructure10, params.imgstructImageStructureImgStructure10); \ 778 DO_FIELD(DW3, WeightedBipredIdc, params.weightedBipredIdc); \ 779 DO_FIELD(DW3, WeightedPredFlag, params.weightedPredFlag); \ 780 DO_FIELD(DW3, RhodomainRateControlEnable, params.vdencEnabled); \ 781 DO_FIELD(DW3, FirstChromaQpOffset, params.firstChromaQpOffset); \ 782 DO_FIELD(DW3, SecondChromaQpOffset, params.secondChromaQpOffset); \ 783 DO_FIELD(DW4, Fieldpicflag, params.fieldpicflag); \ 784 DO_FIELD(DW4, Mbaffflameflag, params.mbaffflameflag); \ 785 DO_FIELD(DW4, Framembonlyflag, params.framembonlyflag); \ 786 DO_FIELD(DW4, Transform8X8Flag, params.transform8X8Flag); \ 787 DO_FIELD(DW4, Direct8X8Infflag, params.direct8X8Infflag); \ 788 DO_FIELD(DW4, Constrainedipredflag, params.constrainedipredflag); \ 789 DO_FIELD(DW4, Imgdisposableflag, params.imgdisposableflag); \ 790 DO_FIELD(DW4, Entropycodingflag, params.entropycodingflag); \ 791 DO_FIELD(DW4, Mbmvformatflag, params.mbmvformatflag); \ 792 DO_FIELD(DW4, Chromaformatidc, params.chromaformatidc); \ 793 DO_FIELD(DW4, Mvunpackedflag, params.mvunpackedflag); \ 794 DO_FIELD(DW4, Inserttestflag, 0); \ 795 DO_FIELD(DW4, Loadslicepointerflag, 0); \ 796 DO_FIELD(DW4, Mbstatenabled, params.mbstatenabled); \ 797 DO_FIELD(DW4, Minframewsize, 0); \ 798 DO_FIELD(DW5, IntrambmaxbitflagIntrambmaxsizereportmask, params.intrambmaxbitflagIntrambmaxsizereportmask); \ 799 DO_FIELD(DW5, IntermbmaxbitflagIntermbmaxsizereportmask, params.intermbmaxbitflagIntermbmaxsizereportmask); \ 800 DO_FIELD(DW5, FrameszoverflagFramebitratemaxreportmask, params.frameszoverflagFramebitratemaxreportmask); \ 801 DO_FIELD(DW5, FrameszunderflagFramebitrateminreportmask, params.frameszunderflagFramebitrateminreportmask); \ 802 DO_FIELD(DW5, IntraIntermbipcmflagForceipcmcontrolmask, params.intraIntermbipcmflagForceipcmcontrolmask); \ 803 DO_FIELD(DW5, MbratectrlflagMbLevelRateControlEnablingFlag, params.mbratectrlflagMbLevelRateControlEnablingFlag); \ 804 DO_FIELD(DW5, Nonfirstpassflag, false); \ 805 DO_FIELD(DW5, TrellisQuantizationChromaDisableTqchromadisable, true); \ 806 DO_FIELD(DW5, TrellisQuantizationRoundingTqr, params.trellisQuantizationRoundingTqr); \ 807 DO_FIELD(DW5, TrellisQuantizationEnabledTqenb, params.trellisQuantizationEnabledTqenb); \ 808 DO_FIELD(DW6, Intrambmaxsz, params.intrambmaxsz); \ 809 DO_FIELD(DW6, Intermbmaxsz, params.intermbmaxsz); \ 810 DO_FIELD(DW8, Slicedeltaqppmax0, 0); \ 811 DO_FIELD(DW8, Slicedeltaqpmax1, 0); \ 812 DO_FIELD(DW8, Slicedeltaqpmax2, 0); \ 813 DO_FIELD(DW8, Slicedeltaqpmax3, 0); \ 814 DO_FIELD(DW9, Slicedeltaqpmin0, 0); \ 815 DO_FIELD(DW9, Slicedeltaqpmin1, 0); \ 816 DO_FIELD(DW9, Slicedeltaqpmin2, 0); \ 817 DO_FIELD(DW9, Slicedeltaqpmin3, 0); \ 818 DO_FIELD(DW10, Framebitratemin, params.framebitratemin); \ 819 DO_FIELD(DW10, Framebitrateminunitmode, params.framebitrateminunitmode); \ 820 DO_FIELD(DW10, Framebitrateminunit, params.framebitrateminunit); \ 821 DO_FIELD(DW10, Framebitratemax, params.framebitratemax); \ 822 DO_FIELD(DW10, Framebitratemaxunitmode, params.framebitratemaxunitmode); \ 823 DO_FIELD(DW10, Framebitratemaxunit, params.framebitratemaxunit); \ 824 DO_FIELD(DW11, Framebitratemindelta, params.framebitratemindelta); \ 825 DO_FIELD(DW11, Framebitratemaxdelta, params.framebitratemaxdelta); \ 826 DO_FIELD(DW11, SliceStatsStreamoutEnable, params.sliceStatsStreamoutEnable); \ 827 DO_FIELD(DW13, InitialQpValue, params.initialQpValue); \ 828 DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL0, params.numberOfActiveReferencePicturesFromL0); \ 829 DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL1, params.numberOfActiveReferencePicturesFromL1); \ 830 DO_FIELD(DW13, NumberOfReferenceFrames, params.numberOfReferenceFrames); \ 831 DO_FIELD(DW13, CurrentPictureHasPerformedMmco5, 0); \ 832 DO_FIELD(DW14, PicOrderPresentFlag, params.picOrderPresentFlag); \ 833 DO_FIELD(DW14, DeltaPicOrderAlwaysZeroFlag, params.deltaPicOrderAlwaysZeroFlag); \ 834 DO_FIELD(DW14, PicOrderCntType, params.picOrderCntType); \ 835 DO_FIELD(DW14, SliceGroupMapType, params.sliceGroupMapType); \ 836 DO_FIELD(DW14, RedundantPicCntPresentFlag, params.redundantPicCntPresentFlag); \ 837 DO_FIELD(DW14, NumSliceGroupsMinus1, params.numSliceGroupsMinus1); \ 838 DO_FIELD(DW14, DeblockingFilterControlPresentFlag, params.deblockingFilterControlPresentFlag); \ 839 DO_FIELD(DW14, Log2MaxFrameNumMinus4, params.log2MaxFrameNumMinus4); \ 840 DO_FIELD(DW14, Log2MaxPicOrderCntLsbMinus4, params.log2MaxPicOrderCntLsbMinus4); \ 841 DO_FIELD(DW15, SliceGroupChangeRate, params.sliceGroupChangeRate); \ 842 DO_FIELD(DW15, CurrPicFrameNum, params.currPicFrameNum); \ 843 DO_FIELD(DW16, CurrentFrameViewId, params.currentFrameViewId); \ 844 DO_FIELD(DW16, MaxViewIdxl0, params.maxViewIdxl0); \ 845 DO_FIELD(DW16, MaxViewIdxl1, params.maxViewIdxl1); \ 846 DO_FIELD(DW16, InterViewOrderDisable, 0); \ 847 DO_FIELD(DW17, ExtendedRhodomainStatisticsEnable, params.extendedRhodomainStatisticsEnable); \ 848 DO_FIELD(DW19, ThresholdSizeInBytes, params.thresholdSizeInBytes); \ 849 DO_FIELD(DW20, TargetSliceSizeInBytes, params.targetSliceSizeInBytes); 850 851 #include "mhw_hwcmd_process_cmdfields.h" 852 } 853 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_REF_IDX_STATE)854 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_REF_IDX_STATE) 855 { 856 _MHW_SETCMD_CALLBASE(MFX_AVC_REF_IDX_STATE); 857 858 cmd.DW1.RefpiclistSelect = params.uiList; 859 860 for (uint8_t i = 0; i < 8; i++) 861 { 862 cmd.ReferenceListEntry[i] = params.referenceListEntry[i]; 863 } 864 865 return MOS_STATUS_SUCCESS; 866 } 867 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_WEIGHTOFFSET_STATE)868 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_WEIGHTOFFSET_STATE) 869 { 870 _MHW_SETCMD_CALLBASE(MFX_AVC_WEIGHTOFFSET_STATE); 871 872 cmd.DW1.WeightAndOffsetSelect = params.uiList; 873 874 for (uint8_t i = 0; i < 96; i++) 875 { 876 cmd.Weightoffset[i] = params.weightoffset[i]; 877 } 878 879 return MOS_STATUS_SUCCESS; 880 } 881 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_SLICE_STATE)882 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_SLICE_STATE) 883 { 884 _MHW_SETCMD_CALLBASE(MFX_AVC_SLICE_STATE); 885 886 #define DO_FIELDS() \ 887 DO_FIELD(DW1, SliceType, params.sliceType); \ 888 DO_FIELD(DW2, Log2WeightDenomLuma, params.log2WeightDenomLuma); \ 889 DO_FIELD(DW2, Log2WeightDenomChroma, params.log2WeightDenomChroma); \ 890 DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList0, params.numberOfReferencePicturesInInterPredictionList0); \ 891 DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList1, params.numberOfReferencePicturesInInterPredictionList1); \ 892 DO_FIELD(DW3, SliceAlphaC0OffsetDiv2, params.sliceAlphaC0OffsetDiv2); \ 893 DO_FIELD(DW3, SliceBetaOffsetDiv2, params.sliceBetaOffsetDiv2); \ 894 DO_FIELD(DW3, SliceQuantizationParameter, params.sliceQuantizationParameter); \ 895 DO_FIELD(DW3, CabacInitIdc10, params.cabacInitIdc10); \ 896 DO_FIELD(DW3, DisableDeblockingFilterIndicator, params.disableDeblockingFilterIndicator); \ 897 DO_FIELD(DW3, DirectPredictionType, params.directPredictionType); \ 898 DO_FIELD(DW3, WeightedPredictionIndicator, params.weightedPredictionIndicator); \ 899 DO_FIELD(DW4, SliceStartMbNum, params.sliceStartMbNum); \ 900 DO_FIELD(DW4, SliceHorizontalPosition, params.sliceHorizontalPosition); \ 901 DO_FIELD(DW4, SliceVerticalPosition, params.sliceVerticalPosition); \ 902 DO_FIELD(DW5, NextSliceHorizontalPosition, params.nextSliceHorizontalPosition); \ 903 DO_FIELD(DW5, NextSliceVerticalPosition, params.nextSliceVerticalPosition); \ 904 DO_FIELD(DW6, StreamId10, 0); \ 905 DO_FIELD(DW6, SliceId30, params.sliceId30); \ 906 DO_FIELD(DW6, Cabaczerowordinsertionenable, params.cabaczerowordinsertionenable); \ 907 DO_FIELD(DW6, Emulationbytesliceinsertenable, params.emulationbytesliceinsertenable); \ 908 DO_FIELD(DW6, TailInsertionPresentInBitstream, params.tailInsertionPresentInBitstream); \ 909 DO_FIELD(DW6, SlicedataInsertionPresentInBitstream, params.slicedataInsertionPresentInBitstream); \ 910 DO_FIELD(DW6, HeaderInsertionPresentInBitstream, params.headerInsertionPresentInBitstream); \ 911 DO_FIELD(DW6, IsLastSlice, params.isLastSlice); \ 912 DO_FIELD(DW6, MbTypeSkipConversionDisable, false); \ 913 DO_FIELD(DW6, MbTypeDirectConversionDisable, false); \ 914 DO_FIELD(DW6, RateControlCounterEnable, false); \ 915 DO_FIELD(DW9, Roundintra, params.roundintra); \ 916 DO_FIELD(DW9, Roundintraenable, true); \ 917 DO_FIELD(DW9, Roundinter, params.roundinter); \ 918 DO_FIELD(DW9, Roundinterenable, params.roundinterenable); 919 920 #include "mhw_hwcmd_process_cmdfields.h" 921 } 922 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_DIRECTMODE_STATE)923 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_DIRECTMODE_STATE) 924 { 925 _MHW_SETCMD_CALLBASE(MFX_AVC_DIRECTMODE_STATE); 926 927 MHW_RESOURCE_PARAMS resourceParams; 928 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 929 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 930 resourceParams.HwCommandType = MOS_MFX_AVC_DIRECT_MODE; 931 932 if (!params.bDisableDmvBuffers) 933 { 934 MHW_MI_CHK_NULL(params.presAvcDmvBuffers); 935 InitMocsParams(resourceParams, &cmd.DirectMvBufferForWriteAttributes.DW0.Value, 1, 6); 936 937 // current picture 938 resourceParams.presResource = ¶ms.presAvcDmvBuffers[params.ucAvcDmvIdx]; 939 resourceParams.dwOffset = 0; 940 resourceParams.pdwCmd = &(cmd.DirectMvBufferForWriteBaseAddress.DW0_1.Value[0]); 941 resourceParams.dwLocationInCmd = 34; 942 resourceParams.bIsWritable = true; 943 944 MHW_MI_CHK_STATUS(AddResourceToCmd( 945 this->m_osItf, 946 this->m_currentCmdBuf, 947 &resourceParams)); 948 } 949 950 CODEC_REF_LIST** refList; 951 MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST**)params.avcRefList); 952 953 if (CodecHal_PictureIsBottomField(params.CurrPic)) 954 { 955 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = 0; 956 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1]; 957 } 958 else 959 { 960 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = 961 refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[0]; 962 if (CodecHal_PictureIsFrame(params.CurrPic)) 963 { 964 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1]; 965 } 966 } 967 968 if (!params.bDisableDmvBuffers) 969 { 970 InitMocsParams(resourceParams, &cmd.DirectMvBufferAttributes.DW0.Value, 1, 6); 971 } 972 973 bool dmvPresent[CODEC_MAX_NUM_REF_FRAME] = { false }; 974 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++) 975 { 976 if (params.pAvcPicIdx[i].bValid) 977 { 978 uint8_t idx = params.pAvcPicIdx[i].ucPicIdx; 979 uint8_t picID = params.bPicIdRemappingInUse ? i : refList[idx]->ucFrameId; 980 uint8_t mvIdx = refList[idx]->ucDMVIdx[0]; 981 982 uint8_t validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 0) & 1; 983 uint8_t frameID = picID << 1; 984 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2) 985 { 986 if (!params.bDisableDmvBuffers) 987 { 988 dmvPresent[picID] = true; 989 990 resourceParams.presResource = ¶ms.presAvcDmvBuffers[mvIdx]; 991 resourceParams.dwOffset = 0; 992 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[picID].DW0_1.Value[0]); 993 resourceParams.dwLocationInCmd = picID * 2 + 1; 994 resourceParams.bIsWritable = false; 995 996 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; 997 998 MHW_MI_CHK_STATUS(AddResourceToCmd( 999 this->m_osItf, 1000 this->m_currentCmdBuf, 1001 &resourceParams)); 1002 } 1003 1004 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[0] * validRef; 1005 } 1006 else 1007 { 1008 return MOS_STATUS_UNKNOWN; 1009 } 1010 1011 validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 1) & 1; 1012 frameID = (picID << 1) + 1; 1013 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2) 1014 { 1015 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[1] * validRef; 1016 } 1017 else 1018 { 1019 return MOS_STATUS_UNKNOWN; 1020 } 1021 } 1022 } 1023 1024 if (!params.bDisableDmvBuffers) 1025 { 1026 // Use a valid address for remaining DMV buffers 1027 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++) 1028 { 1029 if (dmvPresent[i] == false) 1030 { 1031 //Give default buffer to the MV 1032 resourceParams.presResource = ¶ms.presAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS]; 1033 resourceParams.dwOffset = 0; 1034 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[i].DW0_1.Value[0]); 1035 resourceParams.dwLocationInCmd = i * 2 + 1; 1036 resourceParams.bIsWritable = false; 1037 1038 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; 1039 1040 MHW_MI_CHK_STATUS(AddResourceToCmd( 1041 this->m_osItf, 1042 this->m_currentCmdBuf, 1043 &resourceParams)); 1044 } 1045 } 1046 } 1047 1048 return MOS_STATUS_SUCCESS; 1049 } 1050 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_SLICEADDR)1051 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_SLICEADDR) 1052 { 1053 _MHW_SETCMD_CALLBASE(MFD_AVC_SLICEADDR); 1054 1055 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; 1056 sliceInfoParam.presDataBuffer = params.presDataBuffer; 1057 sliceInfoParam.dwSliceIndex = params.dwSliceIndex; 1058 sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed; 1059 sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress; 1060 sliceInfoParam.dwDataStartOffset[1] = params.avcSliceParams->slice_data_offset; 1061 1062 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( 1063 params.decodeInUse, 1064 this->m_currentCmdBuf, 1065 nullptr, 1066 &sliceInfoParam)); 1067 #define DO_FIELDS() \ 1068 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ 1069 DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress); 1070 1071 #include "mhw_hwcmd_process_cmdfields.h" 1072 } 1073 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_BSD_OBJECT)1074 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_BSD_OBJECT) 1075 { 1076 _MHW_SETCMD_CALLBASE(MFD_AVC_BSD_OBJECT); 1077 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; 1078 sliceInfoParam.presDataBuffer = params.presDataBuffer; 1079 sliceInfoParam.dwSliceIndex = params.dwSliceIndex; 1080 sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed; 1081 sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress; 1082 sliceInfoParam.dwDataStartOffset[1] = params.pAvcSliceParams->slice_data_offset; 1083 sliceInfoParam.dwDataLength[1] = params.pAvcSliceParams->slice_data_size; 1084 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( 1085 params.decodeInUse, 1086 this->m_currentCmdBuf, 1087 nullptr, 1088 &sliceInfoParam)); 1089 #define DO_FIELDS() \ 1090 DO_FIELD(DW4, LastsliceFlag, params.LastsliceFlag); \ 1091 DO_FIELD(DW3, IntraPredmode4X48X8LumaErrorControlBit, 1); \ 1092 DO_FIELD(DW5, IntraPredictionErrorControlBitAppliedToIntra16X16Intra8X8Intra4X4LumaAndChroma, 1); \ 1093 DO_FIELD(DW5, Intra8X84X4PredictionErrorConcealmentControlBit, 1); \ 1094 DO_FIELD(DW5, ISliceConcealmentMode, 1); \ 1095 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ 1096 DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress); \ 1097 DO_FIELD(DW4, FirstMbByteOffsetOfSliceDataOrSliceHeader, params.FirstMbByteOffsetOfSliceDataOrSliceHeader); \ 1098 DO_FIELD(DW4, FirstMacroblockMbBitOffset, params.FirstMacroblockMbBitOffset); \ 1099 DO_FIELD(DW4, FixPrevMbSkipped, 1); 1100 #include "mhw_hwcmd_process_cmdfields.h" 1101 } 1102 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_PICID_STATE)1103 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_PICID_STATE) 1104 { 1105 _MHW_SETCMD_CALLBASE(MFD_AVC_PICID_STATE); 1106 MOS_SecureMemcpy(cmd.Pictureidlist1616Bits, 1107 sizeof(params.Pictureidlist1616Bits), 1108 params.Pictureidlist1616Bits, 1109 sizeof(params.Pictureidlist1616Bits)); 1110 #define DO_FIELDS() \ 1111 DO_FIELD(DW1, PictureidRemappingDisable, params.PictureidRemappingDisable); 1112 1113 #include "mhw_hwcmd_process_cmdfields.h" 1114 } 1115 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_PIC_STATE)1116 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_PIC_STATE) 1117 { 1118 _MHW_SETCMD_CALLBASE(MFX_JPEG_PIC_STATE); 1119 1120 #define DO_FIELDS() \ 1121 if (params.decodeInUse) \ 1122 { \ 1123 DO_FIELD(DW1, Obj1.InputFormatYuv, params.inputFormatYuv); \ 1124 DO_FIELD(DW1, Obj1.Rotation, params.rotation); \ 1125 DO_FIELD(DW1, Obj1.OutputFormatYuv, params.outputFormatYuv); \ 1126 DO_FIELD(DW1, Obj1.VerticalDownSamplingEnable, params.verticalDownSamplingEnable); \ 1127 DO_FIELD(DW1, Obj1.HorizontalDownSamplingEnable, params.horizontalDownSamplingEnable); \ 1128 DO_FIELD(DW1, Obj1.VerticalUpSamplingEnable, params.verticalUpSamplingEnable); \ 1129 } \ 1130 else \ 1131 { \ 1132 DO_FIELD(DW1, Obj0.OutputMcuStructure, params.outputMcuStructure); \ 1133 DO_FIELD(DW1, Obj0.InputSurfaceFormatYuv, params.inputSurfaceFormatYuv); \ 1134 DO_FIELD(DW1, Obj0.PixelsInVerticalLastMcu, params.pixelsInVerticalLastMcu); \ 1135 DO_FIELD(DW1, Obj0.PixelsInHorizontalLastMcu, params.pixelsInHorizontalLastMcu); \ 1136 } \ 1137 DO_FIELD(DW2, Obj0.FrameWidthInBlocksMinus1, params.frameWidthInBlocksMinus1); \ 1138 DO_FIELD(DW2, Obj0.FrameHeightInBlocksMinus1, params.frameHeightInBlocksMinus1); 1139 #include "mhw_hwcmd_process_cmdfields.h" 1140 } 1141 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_HUFF_TABLE_STATE)1142 _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_HUFF_TABLE_STATE) 1143 { 1144 _MHW_SETCMD_CALLBASE(MFX_JPEG_HUFF_TABLE_STATE); 1145 1146 MHW_MI_CHK_STATUS(MOS_SecureMemcpy( 1147 cmd.DcBits128BitArray, 1148 sizeof(cmd.DcBits128BitArray), 1149 params.pDCBits, 1150 sizeof(cmd.DcBits128BitArray))); 1151 MHW_MI_CHK_STATUS(MOS_SecureMemcpy( 1152 cmd.DcHuffval128BitArray, 1153 sizeof(cmd.DcHuffval128BitArray), 1154 params.pDCValues, 1155 sizeof(cmd.DcHuffval128BitArray))); 1156 MHW_MI_CHK_STATUS(MOS_SecureMemcpy( 1157 cmd.AcBits168BitArray, 1158 sizeof(cmd.AcBits168BitArray), 1159 params.pACBits, 1160 sizeof(cmd.AcBits168BitArray))); 1161 MHW_MI_CHK_STATUS(MOS_SecureMemcpy( 1162 cmd.AcHuffval1608BitArray, 1163 sizeof(cmd.AcHuffval1608BitArray), 1164 params.pACValues, 1165 sizeof(cmd.AcHuffval1608BitArray))); 1166 1167 MHW_MI_CHK_STATUS(MOS_SecureMemcpy( 1168 &cmd.DW52.Value, 1169 sizeof(uint16_t), 1170 (uint8_t *)params.pACValues + sizeof(cmd.AcHuffval1608BitArray), 1171 sizeof(uint16_t))); 1172 1173 #define DO_FIELDS() \ 1174 DO_FIELD(DW1, Hufftableid1Bit, params.huffTableID); 1175 1176 #include "mhw_hwcmd_process_cmdfields.h" 1177 } 1178 _MHW_SETCMD_OVERRIDE_DECL(MFD_JPEG_BSD_OBJECT)1179 _MHW_SETCMD_OVERRIDE_DECL(MFD_JPEG_BSD_OBJECT) 1180 { 1181 _MHW_SETCMD_CALLBASE(MFD_JPEG_BSD_OBJECT); 1182 1183 #define DO_FIELDS() \ 1184 DO_FIELD(DW1, IndirectDataLength, params.indirectDataLength); \ 1185 DO_FIELD(DW2, IndirectDataStartAddress, params.dataStartAddress); \ 1186 DO_FIELD(DW3, ScanVerticalPosition, params.scanVerticalPosition); \ 1187 DO_FIELD(DW3, ScanHorizontalPosition, params.scanHorizontalPosition); \ 1188 DO_FIELD(DW4, McuCount, params.mcuCount); \ 1189 DO_FIELD(DW4, ScanComponents, params.scanComponent); \ 1190 DO_FIELD(DW4, Interleaved, params.interleaved); \ 1191 DO_FIELD(DW5, Restartinterval16Bit, params.restartInterval); 1192 1193 #include "mhw_hwcmd_process_cmdfields.h" 1194 } 1195 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_HUFF_TABLE_STATE)1196 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_HUFF_TABLE_STATE) 1197 { 1198 _MHW_SETCMD_CALLBASE(MFC_JPEG_HUFF_TABLE_STATE); 1199 1200 for (uint8_t i = 0; i < 12; i++) 1201 { 1202 cmd.DcTable[i] = params.dcTable[i]; 1203 } 1204 1205 for (uint8_t i = 0; i < 162; i++) 1206 { 1207 cmd.AcTable[i] = params.acTable[i]; 1208 } 1209 1210 cmd.DW1.HuffTableId = params.huffTableId; 1211 1212 return MOS_STATUS_SUCCESS; 1213 } 1214 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_SCAN_OBJECT)1215 _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_SCAN_OBJECT) 1216 { 1217 _MHW_SETCMD_CALLBASE(MFC_JPEG_SCAN_OBJECT); 1218 1219 #define DO_FIELDS() \ 1220 DO_FIELD(DW1, McuCount, params.mcuCount); \ 1221 DO_FIELD(DW2, RestartInterval, params.restartInterval); \ 1222 DO_FIELD(DW2, IsLastScan, 1); \ 1223 DO_FIELD(DW2, HeadPresentFlag, 1); \ 1224 DO_FIELD(DW2, HuffmanDcTable, params.huffmanDcTable); \ 1225 DO_FIELD(DW2, HuffmanAcTable, params.huffmanAcTable); 1226 1227 #include "mhw_hwcmd_process_cmdfields.h" 1228 } 1229 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_DPB_STATE)1230 _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_DPB_STATE) 1231 { 1232 _MHW_SETCMD_CALLBASE(MFD_AVC_DPB_STATE); 1233 for (auto i = 0, j = 0; i < 8; i++, j++) 1234 { 1235 cmd.Ltstframenumlist1616Bits[i] = (params.refFrameOrder[j++] & 0xFFFF); 1236 cmd.Ltstframenumlist1616Bits[i] = cmd.Ltstframenumlist1616Bits[i] | ((params.refFrameOrder[j] & 0xFFFF) << 16); //SecondEntry 1237 } 1238 if (params.pMvcExtPicParams) 1239 { 1240 for (auto i = 0, j = 0; j < (CODEC_MAX_NUM_REF_FRAME / 2); i++, j++) 1241 { 1242 cmd.Viewidlist1616Bits[i] = params.pMvcExtPicParams->ViewIDList[j++]; 1243 cmd.Viewidlist1616Bits[i] = cmd.Viewidlist1616Bits[i] | (params.pMvcExtPicParams->ViewIDList[j] << 16); 1244 } 1245 for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++) 1246 { 1247 cmd.Vieworderlistl0168Bits[i] = GetViewOrder(params, j++, LIST_0); //FirstEntry 1248 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 8); //SecondEntry 1249 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 16); //ThirdEntry 1250 cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j, LIST_0) << 24); //FourthEntry 1251 } 1252 for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++) 1253 { 1254 cmd.Vieworderlistl1168Bits[i] = GetViewOrder(params, j++, LIST_1); //FirstEntry 1255 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 8); //SecondEntry 1256 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 16); //ThirdEntry 1257 cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j, LIST_1) << 24); //FourthEntry 1258 } 1259 } 1260 else 1261 { 1262 // non-MVC usage 1263 MOS_ZeroMemory(cmd.Viewidlist1616Bits, sizeof(cmd.Viewidlist1616Bits)); 1264 MOS_FillMemory(cmd.Vieworderlistl0168Bits, sizeof(cmd.Vieworderlistl0168Bits), 0xF); 1265 MOS_FillMemory(cmd.Vieworderlistl1168Bits, sizeof(cmd.Vieworderlistl1168Bits), 0xF); 1266 } 1267 1268 #define DO_FIELDS() \ 1269 DO_FIELD(DW1, NonExistingframeFlag161Bit, params.NonExistingframeFlag161Bit); \ 1270 DO_FIELD(DW1, LongtermframeFlag161Bit, params.LongtermframeFlag161Bit); \ 1271 DO_FIELD(DW2, Value, params.usedForRef); 1272 1273 #include "mhw_hwcmd_process_cmdfields.h" 1274 } 1275 _MHW_SETCMD_OVERRIDE_DECL(MFX_MPEG2_PIC_STATE)1276 _MHW_SETCMD_OVERRIDE_DECL(MFX_MPEG2_PIC_STATE) 1277 { 1278 _MHW_SETCMD_CALLBASE(MFX_MPEG2_PIC_STATE); 1279 1280 #define DO_FIELDS() \ 1281 DO_FIELD(DW1, ScanOrder, params.ScanOrder); \ 1282 DO_FIELD(DW1, IntraVlcFormat, params.IntraVlcFormat); \ 1283 DO_FIELD(DW1, QuantizerScaleType, params.QuantizerScaleType); \ 1284 DO_FIELD(DW1, ConcealmentMotionVectorFlag, params.ConcealmentMotionVectorFlag); \ 1285 DO_FIELD(DW1, FramePredictionFrameDct, params.FramePredictionFrameDct); \ 1286 DO_FIELD(DW1, TffTopFieldFirst, params.TffTopFieldFirst); \ 1287 DO_FIELD(DW1, PictureStructure, params.PictureStructure); \ 1288 DO_FIELD(DW1, IntraDcPrecision, params.IntraDcPrecision); \ 1289 DO_FIELD(DW1, FCode00, params.FCode00); \ 1290 DO_FIELD(DW1, FCode01, params.FCode01); \ 1291 DO_FIELD(DW1, FCode10, params.FCode10); \ 1292 DO_FIELD(DW1, FCode11, params.FCode11); \ 1293 DO_FIELD(DW2, PictureCodingType, params.PictureCodingType); \ 1294 DO_FIELD(DW2, ISliceConcealmentMode, params.ISliceConcealmentMode); \ 1295 DO_FIELD(DW2, PBSliceConcealmentMode, params.PBSliceConcealmentMode); \ 1296 DO_FIELD(DW2, PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride, params.PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride); \ 1297 DO_FIELD(DW2, PBSlicePredictedMotionVectorOverrideFinalMvValueOverride, params.PBSlicePredictedMotionVectorOverrideFinalMvValueOverride); \ 1298 DO_FIELD(DW3, SliceConcealmentDisableBit, params.SliceConcealmentDisableBit); \ 1299 DO_FIELD(DW3, Framewidthinmbsminus170PictureWidthInMacroblocks, params.Framewidthinmbsminus170PictureWidthInMacroblocks); \ 1300 DO_FIELD(DW3, Frameheightinmbsminus170PictureHeightInMacroblocks, params.Frameheightinmbsminus170PictureHeightInMacroblocks); \ 1301 DO_FIELD(DW4, Roundintradc, 3); \ 1302 DO_FIELD(DW4, Roundinterdc, 1); \ 1303 DO_FIELD(DW4, Roundintraac, 5); \ 1304 DO_FIELD(DW4, Roundinterac, 1); \ 1305 DO_FIELD(DW3, MFX_MPEG2_PIC_STATE_CMD_DW3_BIT24_28, params.mfxMpeg2PicStatePar0); \ 1306 1307 #include "mhw_hwcmd_process_cmdfields.h" 1308 } 1309 _MHW_SETCMD_OVERRIDE_DECL(MFD_MPEG2_BSD_OBJECT)1310 _MHW_SETCMD_OVERRIDE_DECL(MFD_MPEG2_BSD_OBJECT) 1311 { 1312 _MHW_SETCMD_CALLBASE(MFD_MPEG2_BSD_OBJECT); 1313 1314 #define DO_FIELDS() \ 1315 DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ 1316 DO_FIELD(DW2, IndirectDataStartAddress, params.IndirectDataStartAddress); \ 1317 DO_FIELD(DW3, FirstMacroblockBitOffset, params.FirstMacroblockBitOffset); \ 1318 DO_FIELD(DW3, IsLastMb, params.IsLastMb); \ 1319 DO_FIELD(DW3, LastPicSlice, params.LastPicSlice); \ 1320 DO_FIELD(DW3, MbRowLastSlice, params.MbRowLastSlice); \ 1321 DO_FIELD(DW3, MacroblockCount, params.MacroblockCount); \ 1322 DO_FIELD(DW3, SliceHorizontalPosition, params.SliceHorizontalPosition); \ 1323 DO_FIELD(DW3, SliceVerticalPosition, params.SliceVerticalPosition); \ 1324 DO_FIELD(DW4, QuantizerScaleCode, params.QuantizerScaleCode); \ 1325 DO_FIELD(DW4, NextSliceHorizontalPosition, params.NextSliceHorizontalPosition); \ 1326 DO_FIELD(DW4, NextSliceVerticalPosition, params.NextSliceVerticalPosition); 1327 1328 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; 1329 sliceInfoParam.presDataBuffer = params.presDataBuffer; 1330 sliceInfoParam.dwDataStartOffset[0] = params.dwDataStartOffset; 1331 1332 MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( 1333 params.decodeInUse, 1334 nullptr, 1335 this->m_currentBatchBuf, 1336 &sliceInfoParam)); 1337 1338 #include "mhw_hwcmd_process_cmdfields.h" 1339 } 1340 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT)1341 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT) 1342 { 1343 _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT); 1344 1345 #define DO_FIELDS() \ 1346 DO_FIELD(DW0, DwordLength, params.DwordLength); \ 1347 DO_FIELD(DW3, IndirectItCoeffDataLength, (params.dwDCTLength) << 2); \ 1348 DO_FIELD(DW4, IndirectItCoeffDataStartAddressOffset, params.IndirectItCoeffDataStartAddressOffset); 1349 1350 #include "mhw_hwcmd_process_cmdfields.h" 1351 } 1352 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT_MPEG2_INLINE_DATA)1353 _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT_MPEG2_INLINE_DATA) 1354 { 1355 _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT_MPEG2_INLINE_DATA); 1356 1357 auto MBType = params.pMBParams->MBType; 1358 1359 cmd.DW0.MacroblockIntraType = 1; 1360 cmd.DW0.DctType = MBType.m_fieldResidual; 1361 cmd.DW0.CodedBlockPattern = params.CodedBlockPattern; 1362 cmd.DW0.Lastmbinrow = params.Lastmbinrow; 1363 cmd.DW1.Horzorigin = params.Horzorigin; 1364 cmd.DW1.Vertorigin = params.Vertorigin; 1365 1366 if (params.CodingType != I_TYPE) 1367 { 1368 cmd.DW0.MacroblockIntraType = MBType.m_intraMb; 1369 cmd.DW0.MacroblockMotionForward = MBType.m_motionFwd; 1370 cmd.DW0.MacroblockMotionBackward = MBType.m_motionBwd; 1371 cmd.DW0.MotionType = MBType.m_motionType; 1372 cmd.DW0.MotionVerticalFieldSelect = MBType.m_mvertFieldSel; 1373 1374 // Next, copy in the motion vectors 1375 if (MBType.m_intraMb == 0) 1376 { 1377 uint32_t *point = (uint32_t *)(params.sPackedMVs0); 1378 cmd.DW2.Value = *point++; 1379 cmd.DW3.Value = *point++; 1380 1381 point = (uint32_t *)(params.sPackedMVs1); 1382 cmd.DW4.Value = *point++; 1383 cmd.DW5.Value = *point++; 1384 } 1385 } 1386 1387 #include "mhw_hwcmd_process_cmdfields.h" 1388 } 1389 _MHW_SETCMD_OVERRIDE_DECL(MFX_VP8_PIC_STATE)1390 _MHW_SETCMD_OVERRIDE_DECL(MFX_VP8_PIC_STATE) 1391 { 1392 _MHW_SETCMD_CALLBASE(MFX_VP8_PIC_STATE); 1393 1394 #define DO_FIELDS() \ 1395 DO_FIELD(DW1, FrameWidthMinus1 , params.FrameWidthMinus1); \ 1396 DO_FIELD(DW1, FrameHeightMinus1 , params.FrameHeightMinus1); \ 1397 DO_FIELD(DW2, McFilterSelect , params.McFilterSelect); \ 1398 DO_FIELD(DW2, ChromaFullPixelMcFilterMode , params.ChromaFullPixelMcFilterMode); \ 1399 DO_FIELD(DW2, Dblkfiltertype , params.Dblkfiltertype); \ 1400 DO_FIELD(DW2, Skeyframeflag , params.Skeyframeflag); \ 1401 DO_FIELD(DW2, SegmentationIdStreamoutEnable , params.SegmentationIdStreamoutEnable); \ 1402 DO_FIELD(DW2, SegmentationIdStreaminEnable , params.SegmentationIdStreaminEnable); \ 1403 DO_FIELD(DW2, SegmentEnableFlag , params.SegmentEnableFlag); \ 1404 DO_FIELD(DW2, UpdateMbsegmentMapFlag , params.UpdateMbsegmentMapFlag); \ 1405 DO_FIELD(DW2, MbNocoeffSkipflag , params.MbNocoeffSkipflag); \ 1406 DO_FIELD(DW2, ModeReferenceLoopFilterDeltaEnabled , params.ModeReferenceLoopFilterDeltaEnabled); \ 1407 DO_FIELD(DW2, GoldenRefPictureMvSignbiasFlag , params.GoldenRefPictureMvSignbiasFlag); \ 1408 DO_FIELD(DW2, AlternateRefPicMvSignbiasFlag , params.AlternateRefPicMvSignbiasFlag); \ 1409 DO_FIELD(DW2, DeblockSharpnessLevel , params.DeblockSharpnessLevel); \ 1410 DO_FIELD(DW3, DblkfilterlevelForSegment3 , params.DblkfilterlevelForSegment3); \ 1411 DO_FIELD(DW3, DblkfilterlevelForSegment2 , params.DblkfilterlevelForSegment2); \ 1412 DO_FIELD(DW3, DblkfilterlevelForSegment1 , params.DblkfilterlevelForSegment1); \ 1413 DO_FIELD(DW3, DblkfilterlevelForSegment0 , params.DblkfilterlevelForSegment0); \ 1414 DO_FIELD(DW8, QuantizerValue1Blocktype2Uvdc , params.QuantizerValue1Blocktype2Uvdc); \ 1415 DO_FIELD(DW8, QuantizerValue1Blocktype3Uvac , params.QuantizerValue1Blocktype3Uvac); \ 1416 DO_FIELD(DW9, QuantizerValue1Blocktype4Y2Dc , params.QuantizerValue1Blocktype4Y2Dc); \ 1417 DO_FIELD(DW9, QuantizerValue1Blocktype5Y2Ac , params.QuantizerValue1Blocktype5Y2Ac); \ 1418 DO_FIELD(DW10, QuantizerValue2Blocktype0Y1Dc , params.QuantizerValue2Blocktype0Y1Dc); \ 1419 DO_FIELD(DW10, QuantizerValue2Blocktype1Y1Ac , params.QuantizerValue2Blocktype1Y1Ac); \ 1420 DO_FIELD(DW11, QuantizerValue2Blocktype2Uvdc , params.QuantizerValue2Blocktype2Uvdc); \ 1421 DO_FIELD(DW11, QuantizerValue2Blocktype3Uvac , params.QuantizerValue2Blocktype3Uvac); \ 1422 DO_FIELD(DW12, QuantizerValue2Blocktype4Y2Dc , params.QuantizerValue2Blocktype4Y2Dc); \ 1423 DO_FIELD(DW12, QuantizerValue2Blocktype5Y2Ac , params.QuantizerValue2Blocktype5Y2Ac); \ 1424 DO_FIELD(DW13, QuantizerValue3Blocktype0Y1Dc , params.QuantizerValue3Blocktype0Y1Dc); \ 1425 DO_FIELD(DW13, QuantizerValue3Blocktype1Y1Ac , params.QuantizerValue3Blocktype1Y1Ac); \ 1426 DO_FIELD(DW14, QuantizerValue3Blocktype2Uvdc , params.QuantizerValue3Blocktype2Uvdc); \ 1427 DO_FIELD(DW14, QuantizerValue3Blocktype3Uvac , params.QuantizerValue3Blocktype3Uvac); \ 1428 DO_FIELD(DW15, QuantizerValue3Blocktype4Y2Dc , params.QuantizerValue3Blocktype4Y2Dc); \ 1429 DO_FIELD(DW15, QuantizerValue3Blocktype5Y2Ac , params.QuantizerValue3Blocktype5Y2Ac); \ 1430 DO_FIELD(DW19, Mbsegmentidtreeprobs2 , params.Mbsegmentidtreeprobs2); \ 1431 DO_FIELD(DW19, Mbsegmentidtreeprobs1 , params.Mbsegmentidtreeprobs1); \ 1432 DO_FIELD(DW19, Mbsegmentidtreeprobs0 , params.Mbsegmentidtreeprobs0); \ 1433 DO_FIELD(DW20, Mbnocoeffskipfalseprob , params.Mbnocoeffskipfalseprob); \ 1434 DO_FIELD(DW20, Intrambprob , params.Intrambprob); \ 1435 DO_FIELD(DW20, Interpredfromlastrefprob , params.Interpredfromlastrefprob); \ 1436 DO_FIELD(DW20, Interpredfromgrefrefprob , params.Interpredfromgrefrefprob); \ 1437 DO_FIELD(DW21, Ymodeprob3 , params.Ymodeprob3); \ 1438 DO_FIELD(DW21, Ymodeprob2 , params.Ymodeprob2); \ 1439 DO_FIELD(DW21, Ymodeprob1 , params.Ymodeprob1); \ 1440 DO_FIELD(DW21, Ymodeprob0 , params.Ymodeprob0); \ 1441 DO_FIELD(DW22, Uvmodeprob2 , params.Uvmodeprob2); \ 1442 DO_FIELD(DW22, Uvmodeprob1 , params.Uvmodeprob1); \ 1443 DO_FIELD(DW22, Uvmodeprob0 , params.Uvmodeprob0); \ 1444 DO_FIELD(DW23, Mvupdateprobs00 , params.Mvupdateprobs00); \ 1445 DO_FIELD(DW23, Mvupdateprobs01 , params.Mvupdateprobs01); \ 1446 DO_FIELD(DW23, Mvupdateprobs02 , params.Mvupdateprobs02); \ 1447 DO_FIELD(DW23, Mvupdateprobs03 , params.Mvupdateprobs03); \ 1448 DO_FIELD(DW24, Mvupdateprobs04 , params.Mvupdateprobs04); \ 1449 DO_FIELD(DW24, Mvupdateprobs05 , params.Mvupdateprobs05); \ 1450 DO_FIELD(DW24, Mvupdateprobs06 , params.Mvupdateprobs06); \ 1451 DO_FIELD(DW24, Mvupdateprobs07 , params.Mvupdateprobs07); \ 1452 DO_FIELD(DW25, Mvupdateprobs08 , params.Mvupdateprobs08); \ 1453 DO_FIELD(DW25, Mvupdateprobs09 , params.Mvupdateprobs09); \ 1454 DO_FIELD(DW25, Mvupdateprobs010 , params.Mvupdateprobs010); \ 1455 DO_FIELD(DW25, Mvupdateprobs011 , params.Mvupdateprobs011); \ 1456 DO_FIELD(DW26, Mvupdateprobs012 , params.Mvupdateprobs012); \ 1457 DO_FIELD(DW26, Mvupdateprobs013 , params.Mvupdateprobs013); \ 1458 DO_FIELD(DW26, Mvupdateprobs014 , params.Mvupdateprobs014); \ 1459 DO_FIELD(DW26, Mvupdateprobs015 , params.Mvupdateprobs015); \ 1460 DO_FIELD(DW27, Mvupdateprobs016 , params.Mvupdateprobs016); \ 1461 DO_FIELD(DW27, Mvupdateprobs017 , params.Mvupdateprobs017); \ 1462 DO_FIELD(DW27, Mvupdateprobs018 , params.Mvupdateprobs018); \ 1463 DO_FIELD(DW28, Mvupdateprobs10 , params.Mvupdateprobs10); \ 1464 DO_FIELD(DW28, Mvupdateprobs11 , params.Mvupdateprobs11); \ 1465 DO_FIELD(DW28, Mvupdateprobs12 , params.Mvupdateprobs12); \ 1466 DO_FIELD(DW28, Mvupdateprobs13 , params.Mvupdateprobs13); \ 1467 DO_FIELD(DW29, Mvupdateprobs14 , params.Mvupdateprobs14); \ 1468 DO_FIELD(DW29, Mvupdateprobs15 , params.Mvupdateprobs15); \ 1469 DO_FIELD(DW29, Mvupdateprobs16 , params.Mvupdateprobs16); \ 1470 DO_FIELD(DW29, Mvupdateprobs17 , params.Mvupdateprobs17); \ 1471 DO_FIELD(DW30, Mvupdateprobs18 , params.Mvupdateprobs18); \ 1472 DO_FIELD(DW30, Mvupdateprobs19 , params.Mvupdateprobs19); \ 1473 DO_FIELD(DW30, Mvupdateprobs110 , params.Mvupdateprobs110); \ 1474 DO_FIELD(DW30, Mvupdateprobs111 , params.Mvupdateprobs111); \ 1475 DO_FIELD(DW31, Mvupdateprobs112 , params.Mvupdateprobs112); \ 1476 DO_FIELD(DW31, Mvupdateprobs113 , params.Mvupdateprobs113); \ 1477 DO_FIELD(DW31, Mvupdateprobs114 , params.Mvupdateprobs114); \ 1478 DO_FIELD(DW31, Mvupdateprobs115 , params.Mvupdateprobs115); \ 1479 DO_FIELD(DW32, Mvupdateprobs116 , params.Mvupdateprobs116); \ 1480 DO_FIELD(DW32, Mvupdateprobs117 , params.Mvupdateprobs117); \ 1481 DO_FIELD(DW32, Mvupdateprobs118 , params.Mvupdateprobs118); \ 1482 DO_FIELD(DW33, Reflfdelta0ForIntraFrame , params.Reflfdelta0ForIntraFrame); \ 1483 DO_FIELD(DW33, Reflfdelta1ForLastFrame , params.Reflfdelta1ForLastFrame); \ 1484 DO_FIELD(DW33, Reflfdelta2ForGoldenFrame , params.Reflfdelta2ForGoldenFrame); \ 1485 DO_FIELD(DW33, Reflfdelta3ForAltrefFrame , params.Reflfdelta3ForAltrefFrame); \ 1486 DO_FIELD(DW34, Modelfdelta0ForBPredMode , params.Modelfdelta0ForBPredMode); \ 1487 DO_FIELD(DW34, Modelfdelta1ForZeromvMode , params.Modelfdelta1ForZeromvMode); \ 1488 DO_FIELD(DW34, Modelfdelta2ForNearestNearAndNewMode , params.Modelfdelta2ForNearestNearAndNewMode); \ 1489 DO_FIELD(DW34, Modelfdelta3ForSplitmvMode , params.Modelfdelta3ForSplitmvMode); 1490 1491 1492 cmd.DW4.dec.QuantizerValue0Blocktype0Y1Dc = params.QuantizerValue0Blocktype0Y1Dc; 1493 cmd.DW4.dec.QuantizerValue0Blocktype1Y1Ac = params.QuantizerValue0Blocktype1Y1Ac; 1494 1495 cmd.DW5.dec.QuantizerValue0Blocktype2Uvdc = params.QuantizerValue0Blocktype2Uvdc; 1496 cmd.DW5.dec.QuantizerValue0Blocktype3Uvac = params.QuantizerValue0Blocktype3Uvac; 1497 1498 cmd.DW6.dec.QuantizerValue0Blocktype4Y2Dc = params.QuantizerValue0Blocktype4Y2Dc; 1499 cmd.DW6.dec.QuantizerValue0Blocktype5Y2Ac = params.QuantizerValue0Blocktype5Y2Ac; 1500 1501 cmd.DW7.dec.QuantizerValue1Blocktype0Y1Dc = params.QuantizerValue1Blocktype0Y1Dc; 1502 cmd.DW7.dec.QuantizerValue1Blocktype1Y1Ac = params.QuantizerValue1Blocktype1Y1Ac; 1503 1504 1505 MHW_RESOURCE_PARAMS resourceParams; 1506 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 1507 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 1508 resourceParams.HwCommandType = MOS_MFX_VP8_PIC; 1509 1510 resourceParams.presResource = params.presCoefProbBuffer; 1511 resourceParams.dwOffset = params.dwCoefProbTableOffset; 1512 resourceParams.pdwCmd = cmd.CoeffprobabilityStreaminBaseAddress.DW0_1.Value; 1513 resourceParams.dwLocationInCmd = 16; 1514 resourceParams.bIsWritable = false; 1515 1516 MHW_MI_CHK_STATUS(AddResourceToCmd( 1517 this->m_osItf, 1518 this->m_currentCmdBuf, 1519 &resourceParams)); 1520 1521 if (params.SegmentEnableFlag) 1522 { 1523 resourceParams.presResource = params.presSegmentationIdStreamBuffer; 1524 resourceParams.dwOffset = 0; 1525 resourceParams.pdwCmd = cmd.SegmentationIdStreamBaseAddress.DW0_1.Value; 1526 resourceParams.dwLocationInCmd = 35; 1527 resourceParams.bIsWritable = true; 1528 1529 1530 MHW_MI_CHK_STATUS(AddResourceToCmd( 1531 this->m_osItf, 1532 this->m_currentCmdBuf, 1533 &resourceParams)); 1534 } 1535 1536 1537 #include "mhw_hwcmd_process_cmdfields.h" 1538 } 1539 _MHW_SETCMD_OVERRIDE_DECL(MFD_VP8_BSD_OBJECT)1540 _MHW_SETCMD_OVERRIDE_DECL(MFD_VP8_BSD_OBJECT) 1541 { 1542 _MHW_SETCMD_CALLBASE(MFD_VP8_BSD_OBJECT); 1543 1544 #define DO_FIELDS() \ 1545 DO_FIELD(DW1, CodedNumOfCoeffTokenPartitions, params.CodedNumOfCoeffTokenPartitions); \ 1546 DO_FIELD(DW1, Partition0CpbacEntropyRange, params.Partition0CpbacEntropyRange); \ 1547 DO_FIELD(DW1, Partition0CpbacEntropyCount, params.Partition0CpbacEntropyCount); \ 1548 DO_FIELD(DW2, Partition0CpbacEntropyValue, params.Partition0CpbacEntropyValue); \ 1549 DO_FIELD(DW3, IndirectPartition0DataLength, params.IndirectPartition0DataLength); \ 1550 DO_FIELD(DW4, IndirectPartition0DataStartOffset, params.IndirectPartition0DataStartOffset); \ 1551 DO_FIELD(DW5, IndirectPartition1DataLength, params.IndirectPartition1DataLength); \ 1552 DO_FIELD(DW6, IndirectPartition1DataStartOffset, params.IndirectPartition1DataStartOffset); \ 1553 DO_FIELD(DW7, IndirectPartition2DataLength, params.IndirectPartition2DataLength); \ 1554 DO_FIELD(DW8, IndirectPartition2DataStartOffset, params.IndirectPartition2DataStartOffset); \ 1555 DO_FIELD(DW9, IndirectPartition3DataLength, params.IndirectPartition3DataLength); \ 1556 DO_FIELD(DW10, IndirectPartition3DataStartOffset, params.IndirectPartition3DataStartOffset); \ 1557 DO_FIELD(DW11, IndirectPartition4DataLength, params.IndirectPartition4DataLength); \ 1558 DO_FIELD(DW12, IndirectPartition4DataStartOffset, params.IndirectPartition4DataStartOffset); \ 1559 DO_FIELD(DW13, IndirectPartition5DataLength, params.IndirectPartition5DataLength); \ 1560 DO_FIELD(DW14, IndirectPartition5DataStartOffset, params.IndirectPartition5DataStartOffset); \ 1561 DO_FIELD(DW15, IndirectPartition6DataLength, params.IndirectPartition6DataLength); \ 1562 DO_FIELD(DW16, IndirectPartition6DataStartOffset, params.IndirectPartition6DataStartOffset); \ 1563 DO_FIELD(DW17, IndirectPartition7DataLength, params.IndirectPartition7DataLength); \ 1564 DO_FIELD(DW18, IndirectPartition7DataStartOffset, params.IndirectPartition7DataStartOffset); \ 1565 DO_FIELD(DW19, IndirectPartition8DataLength, params.IndirectPartition8DataLength); \ 1566 DO_FIELD(DW20, IndirectPartition8DataStartOffset, params.IndirectPartition8DataStartOffset); \ 1567 1568 #include "mhw_hwcmd_process_cmdfields.h" 1569 } 1570 MEDIA_CLASS_DEFINE_END(mhw__vdbox__mfx__Impl) 1571 }; 1572 }//namespace mfx 1573 }//namespace vdbox 1574 }//namespace mhw 1575 1576 #endif // __MHW_VDBOX_MFX_IMPL_H__ 1577