/* * Copyright (c) 2021-2023, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file mhw_vdbox_mfx_impl.h //! \brief MHW VDBOX MFX interface common base //! \details //! #ifndef __MHW_VDBOX_MFX_IMPL_H__ #define __MHW_VDBOX_MFX_IMPL_H__ #include "mhw_vdbox_mfx_itf.h" #include "mhw_impl.h" #include "mhw_mi_impl.h" #ifdef IGFX_MFX_INTERFACE_EXT_SUPPORT #include "mhw_vdbox_mfx_hwcmd_ext.h" #endif #define AVC_MPR_ROWSTORE_BASEADDRESS 256 #define AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF 512 #define AVC_IP_ROWSTORE_BASEADDRESS 512 #define AVC_IP_ROWSTORE_BASEADDRESS_MBAFF 1024 #define AVC_VLF_ROWSTORE_BASEADDRESS 768 #define AVC_VLF_ROWSTORE_BASEADDRESS_MBAFF 1280 #define VP8_IP_ROWSTORE_BASEADDRESS 256 #define VP8_VLF_ROWSTORE_BASEADDRESS 512 namespace mhw { namespace vdbox { namespace mfx { template class Impl : public Itf, public mhw::Impl { _MFX_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL); public: MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override { MHW_FUNCTION_ENTER; MHW_CHK_NULL_RETURN(settings); size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS); return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size); } MOS_STATUS GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) override { MHW_FUNCTION_ENTER; MHW_MI_CHK_NULL(rowstoreParams); bool avc = IsAvcMode(rowstoreParams); bool vp8 = IsVp8Mode(rowstoreParams); bool widthLE4K = IsPictureWidthLE4K(rowstoreParams); bool mbaffOrField = IsMbaffOrField(rowstoreParams); //BSD row store cache m_bsdMpcRowstoreCache.enabled = m_bsdMpcRowstoreCache.supported && widthLE4K && (avc || vp8); m_bsdMpcRowstoreCache.dwAddress = m_bsdMpcRowstoreCache.enabled ? BSDMPCROWSTORE_BASEADDRESS : 0; //MPR row store cache m_mprRowstoreCache.enabled = m_mprRowstoreCache.supported && widthLE4K && avc; m_mprRowstoreCache.dwAddress = m_mprRowstoreCache.enabled ? (mbaffOrField ? AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF : AVC_MPR_ROWSTORE_BASEADDRESS) : 0; //Intra Prediction row store cache m_intraRowstoreCache.enabled = m_intraRowstoreCache.supported && widthLE4K && (avc || vp8); if (m_intraRowstoreCache.enabled) { m_intraRowstoreCache.dwAddress = avc ? (mbaffOrField ? AVC_IP_ROWSTORE_BASEADDRESS_MBAFF : AVC_IP_ROWSTORE_BASEADDRESS) : VP8_IP_ROWSTORE_BASEADDRESS; } else { m_intraRowstoreCache.dwAddress = 0; } //VLF row store cache - platform-aware configuration ConfigureVlfRowstoreCache(rowstoreParams); return MOS_STATUS_SUCCESS; } virtual void SetCacheabilitySettings() { MHW_FUNCTION_ENTER; m_preDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_postDeblockingMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_OriginalUncompressedPictureSourceMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_streamoutDataDestinationMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_intraRowStoreScratchBufferMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_deblockingFilterRowStoreScratchMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_referncePictureMemoryObjectControlStateCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_referncePictureMemoryObjectControlStateCtrlDecode.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_HW_RESOURCE_USAGE_DECODE_INPUT_REFERENCE, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_referncePictureMemoryObjectControlStateCtrlEncode.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_HW_RESOURCE_USAGE_ENCODE_INPUT_RECON, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_macroblockIldbStreamoutBufferCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_secondMacroblockIldbStreamoutBufferCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_slicesizeStreamoutDataDestinationCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_mfxIndirectBitstreamCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_mfdIndirectItCoeffCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_mfxIndirectMvCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_mfcIndirectPakBseCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_bsdMpcRowStoreScratchBufferCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_mprRowStoreScratchBufferCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_bitplaneReadBufferIndexToMemoryCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_BITPLANE_READ_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; m_directMvBufferForWriteCtrl.Value = m_osItf->pfnCachePolicyGetMemoryObject( MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC, m_osItf->pfnGetGmmClientContext(m_osItf)).DwordValue; } bool IsRowStoreCachingSupported() override { return m_rowstoreCachingSupported; } bool IsMprRowstoreCacheEnabled() override { return m_mprRowstoreCache.enabled; } uint32_t GetViewOrder( MFD_AVC_DPB_STATE_PAR params, uint32_t currIdx, uint32_t list) { MHW_FUNCTION_ENTER; auto avcPicParams = params.pAvcPicParams; auto mvcExtPicParams = params.pMvcExtPicParams; auto avcRefList = params.ppAvcRefList; // No need to check if bottom field since only progressive is supported for mvc clips. int32_t currPOC = avcPicParams->CurrFieldOrderCnt[0]; uint32_t numRefs = (list == LIST_0) ? mvcExtPicParams->NumInterViewRefsL0 : mvcExtPicParams->NumInterViewRefsL1; uint32_t viewOrder = 0xF; uint32_t currRef = params.pAvcPicIdx[currIdx].ucPicIdx; if (params.pAvcPicIdx[currIdx].bValid && avcRefList[currRef]->bUsedAsInterViewRef && (currPOC == avcRefList[currRef]->iFieldOrderCnt[0])) { for (uint32_t i = 0; i < numRefs; i++) { if (mvcExtPicParams->ViewIDList[currIdx] == mvcExtPicParams->InterViewRefList[list][i]) { viewOrder = mvcExtPicParams->ViewIDList[currIdx]; break; } } } return viewOrder; } bool IsDeblockingFilterRowstoreCacheEnabled() override { return m_deblockingFilterRowstoreCache.enabled; } bool IsIntraRowstoreCacheEnabled() override { return m_intraRowstoreCache.enabled; } bool IsBsdMpcRowstoreCacheEnabled() override { return m_bsdMpcRowstoreCache.enabled; } MHW_VDBOX_NODE_IND GetMaxVdboxIndex() override { return MEDIA_IS_SKU(m_osItf->pfnGetSkuTable(m_osItf), FtrVcs2) ? MHW_VDBOX_NODE_2 : MHW_VDBOX_NODE_1; } //! //! \brief Get the vdbox num //! //! \return bool //! vdbox num got //! uint8_t GetNumVdbox() override { MHW_FUNCTION_ENTER; MEDIA_ENGINE_INFO mediaEngineInfo = {}; m_osItf->pfnGetMediaEngineInfo(m_osItf, mediaEngineInfo); m_numVdbox = (uint8_t)(mediaEngineInfo.VDBoxInfo.NumberOfVDBoxEnabled); return m_numVdbox; } #if (_DEBUG || _RELEASE_INTERNAL) MOS_STATUS CheckScalabilityOverrideValidity() { MHW_FUNCTION_ENTER; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MEDIA_SYSTEM_INFO *gtSystemInfo; uint32_t forceVdbox; bool scalableDecMode; bool useVD1, useVD2, useVD3, useVD4; MHW_MI_CHK_NULL(m_osItf); scalableDecMode = m_osItf->bHcpDecScalabilityMode ? true : false; forceVdbox = m_osItf->eForceVdbox; gtSystemInfo = m_osItf->pfnGetGtSystemInfo(m_osItf); MHW_MI_CHK_NULL(gtSystemInfo); if (forceVdbox != MOS_FORCE_VDBOX_NONE && forceVdbox != MOS_FORCE_VDBOX_1 && forceVdbox != MOS_FORCE_VDBOX_2 && // 2 pipes, VDBOX1-BE1, VDBOX2-BE2 forceVdbox != MOS_FORCE_VDBOX_1_1_2 && forceVdbox != MOS_FORCE_VDBOX_2_1_2) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("user feature forceVdbox value is invalid."); return eStatus; } if (!scalableDecMode && (forceVdbox == MOS_FORCE_VDBOX_1_1_2 || forceVdbox == MOS_FORCE_VDBOX_2_1_2)) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("user feature forceVdbox valude does not consistent with regkey scalability mode."); return eStatus; } if (scalableDecMode && !m_scalabilitySupported) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("user feature scalability mode is not allowed on current platform!"); return eStatus; } useVD1 = useVD2 = false; if (forceVdbox == 0) { useVD1 = true; } else { MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_1, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD1); MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_2, MOS_FORCEVDBOX_VDBOXID_BITSNUM, MOS_FORCEVDBOX_MASK, useVD2); } if (!gtSystemInfo->VDBoxInfo.IsValid || (useVD1 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox0Enabled) || (useVD2 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox1Enabled)) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("the forced VDBOX is not enabled in current platform."); return eStatus; } return eStatus; } #endif MOS_STATUS FindGpuNodeToUse(PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit) override { MHW_FUNCTION_ENTER; bool setVideoNode = false; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MOS_GPU_NODE videoGpuNode = MOS_GPU_NODE_VIDEO; if (MOS_VE_MULTINODESCALING_SUPPORTED(m_osItf)) { if (GetNumVdbox() == 1) { videoGpuNode = MOS_GPU_NODE_VIDEO; } else { MHW_MI_CHK_STATUS(m_osItf->pfnCreateVideoNodeAssociation( m_osItf, setVideoNode, &videoGpuNode)); } } #if (_DEBUG || _RELEASE_INTERNAL) if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE && (!m_osItf->bSupportVirtualEngine || !m_scalabilitySupported)) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_ASSERTMESSAGE("not support DebugOverrid on current OS or Platform."); return eStatus; } if (m_osItf != nullptr && m_osItf->bEnableDbgOvrdInVE) { MHW_MI_CHK_STATUS(CheckScalabilityOverrideValidity()); } #endif gpuNodeLimit->dwGpuNodeToUse = videoGpuNode; return eStatus; } MHW_MEMORY_OBJECT_CONTROL_PARAMS m_preDeblockingMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_postDeblockingMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_OriginalUncompressedPictureSourceMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_streamoutDataDestinationMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_intraRowStoreScratchBufferMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_deblockingFilterRowStoreScratchMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlDecode; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_referncePictureMemoryObjectControlStateCtrlEncode; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_macroblockIldbStreamoutBufferCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_secondMacroblockIldbStreamoutBufferCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_slicesizeStreamoutDataDestinationCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectBitstreamCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfdIndirectItCoeffCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfxIndirectMvCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mfcIndirectPakBseCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bsdMpcRowStoreScratchBufferCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_mprRowStoreScratchBufferCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_bitplaneReadBufferIndexToMemoryCtrl; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_directMvBufferForWriteCtrl; protected: bool IsAvcMode(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const { return rowstoreParams->Mode == CODECHAL_DECODE_MODE_AVCVLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC; } bool IsVp8Mode(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const { return rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP8VLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP8; } bool IsPictureWidthLE4K(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const { return rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K; } bool IsMbaffOrField(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) const { return rowstoreParams->bMbaff || !rowstoreParams->bIsFrame; } virtual bool GetVlfRowstoreCacheMbaffSupport() const { return false; // Base implementation: no MBAFF support for VLF cache } void ConfigureVlfRowstoreCache(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams) { bool avc = IsAvcMode(rowstoreParams); bool vp8 = IsVp8Mode(rowstoreParams); bool widthLE4K = IsPictureWidthLE4K(rowstoreParams); bool mbaffOrField = IsMbaffOrField(rowstoreParams); bool supportMbaff = GetVlfRowstoreCacheMbaffSupport(); // Enable VLF cache based on platform support if (supportMbaff) { // xe3+ platforms: Enable VLF for AVC or VP8, including MBAFF m_deblockingFilterRowstoreCache.enabled = m_deblockingFilterRowstoreCache.supported && widthLE4K && (avc || vp8); } else { // Base/older platforms: Enable VLF for AVC (non-MBAFF) or VP8 m_deblockingFilterRowstoreCache.enabled = m_deblockingFilterRowstoreCache.supported && widthLE4K && ((avc && !mbaffOrField) || vp8); } // Configure VLF address based on enablement and codec/format if (m_deblockingFilterRowstoreCache.enabled) { if (avc) { m_deblockingFilterRowstoreCache.dwAddress = mbaffOrField ? AVC_VLF_ROWSTORE_BASEADDRESS_MBAFF : AVC_VLF_ROWSTORE_BASEADDRESS; } else // VP8 { m_deblockingFilterRowstoreCache.dwAddress = VP8_VLF_ROWSTORE_BASEADDRESS; } } else { m_deblockingFilterRowstoreCache.dwAddress = 0; } } using base_t = Itf; MhwCpInterface *m_cpItf = nullptr; MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {}; Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : mhw::Impl(osItf) { MHW_FUNCTION_ENTER; m_cpItf = cpItf; InitRowstoreUserFeatureSettings(); SetCacheabilitySettings(); } virtual ~Impl() { MHW_FUNCTION_ENTER; #if (_DEBUG || _RELEASE_INTERNAL) if (m_intraRowstoreCache.enabled || m_deblockingFilterRowstoreCache.enabled || m_bsdMpcRowstoreCache.enabled || m_mprRowstoreCache.enabled) { // Report rowstore cache usage status to regkey ReportUserSettingForDebug( m_userSettingPtr, __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED, 1, MediaUserSetting::Group::Device); } #endif } MOS_STATUS InitRowstoreUserFeatureSettings() { MHW_FUNCTION_ENTER; bool rowstoreCachingDisableDefaultValue = false; if (m_osItf->bSimIsActive) { // Disable RowStore Cache on simulation by default rowstoreCachingDisableDefaultValue = true; } else { rowstoreCachingDisableDefaultValue = false; } m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue; #if (_DEBUG || _RELEASE_INTERNAL) auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf); { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "Disable RowStore Cache", MediaUserSetting::Group::Device, rowstoreCachingDisableDefaultValue, true); m_rowstoreCachingSupported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL if (m_rowstoreCachingSupported) { m_intraRowstoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableIntraRowStoreCache", MediaUserSetting::Group::Device); m_intraRowstoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_deblockingFilterRowstoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableDeblockingFilterRowStoreCache", MediaUserSetting::Group::Device); m_deblockingFilterRowstoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_bsdMpcRowstoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableBsdMpcRowStoreCache", MediaUserSetting::Group::Device); m_bsdMpcRowstoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL m_mprRowstoreCache.supported = true; #if (_DEBUG || _RELEASE_INTERNAL) { MediaUserSetting::Value outValue; ReadUserSettingForDebug(userSettingPtr, outValue, "DisableMprRowStoreCache", MediaUserSetting::Group::Device); m_mprRowstoreCache.supported = !(outValue.Get()); } #endif // _DEBUG || _RELEASE_INTERNAL } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_QM_STATE) { _MHW_SETCMD_CALLBASE(MFX_QM_STATE); for (uint8_t i = 0; i < 16; i++) { cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i]; } cmd.DW1.Obj2.Avc = params.qmType; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_FQM_STATE) { _MHW_SETCMD_CALLBASE(MFX_FQM_STATE); for (uint8_t i = 0; i < 32; i++) { cmd.ForwardQuantizerMatrix[i] = params.quantizermatrix[i]; } cmd.DW1.Obj2.Avc = params.qmType; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT) { _MHW_SETCMD_CALLBASE(MFX_PIPE_MODE_SELECT); MHW_MI_CHK_STATUS(m_cpItf->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)&cmd)); #define DO_FIELDS() \ DO_FIELD(DW1, StandardSelect, params.standardSelect); \ DO_FIELD(DW1, CodecSelect, params.codecSelect); \ DO_FIELD(DW1, FrameStatisticsStreamoutEnable, params.frameStatisticsStreamoutEnable); \ DO_FIELD(DW1, ScaledSurfaceEnable, params.scaledSurfaceEnable); \ DO_FIELD(DW1, PreDeblockingOutputEnablePredeblockoutenable, params.preDeblockingOutputEnablePredeblockoutenable); \ DO_FIELD(DW1, PostDeblockingOutputEnablePostdeblockoutenable, params.postDeblockingOutputEnablePostdeblockoutenable); \ DO_FIELD(DW1, StreamOutEnable, params.streamOutEnable); \ DO_FIELD(DW1, DeblockerStreamOutEnable, params.deblockerStreamOutEnable); \ DO_FIELD(DW1, VdencMode, params.vdencMode); \ DO_FIELD(DW1, DecoderModeSelect, params.decoderModeSelect); \ DO_FIELD(DW1, DecoderShortFormatMode, params.decoderShortFormatMode); \ DO_FIELD(DW1, ExtendedStreamOutEnable, params.extendedStreamOutEnable); \ DO_FIELD(DW2, Vlf720IOddHeightInVc1Mode, params.vlf720IOddHeightInVc1Mode); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_SURFACE_STATE) { _MHW_SETCMD_CALLBASE(MFX_SURFACE_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, SurfaceId, params.surfaceId); \ DO_FIELD(DW2, Height, params.height); \ DO_FIELD(DW2, Width, params.width); \ DO_FIELD(DW3, Tilemode, params.tilemode); \ DO_FIELD(DW3, SurfacePitch, params.surfacePitch); \ DO_FIELD(DW3, CompressionFormat, params.compressionFormat); \ DO_FIELD(DW3, InterleaveChroma, params.interleaveChroma); \ DO_FIELD(DW3, SurfaceFormat, params.surfaceFormat); \ DO_FIELD(DW4, YOffsetForUCb, params.yOffsetForUCb); \ DO_FIELD(DW5, YOffsetForVCr, params.yOffsetForVCr); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_IND_OBJ_BASE_ADDR_STATE) { _MHW_SETCMD_CALLBASE(MFX_IND_OBJ_BASE_ADDR_STATE); MHW_RESOURCE_PARAMS resourceParams; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_MFX_UPPER_BOUND_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR; // mode specific settings if (CodecHalIsDecodeModeVLD(params.Mode) || (params.Mode == CODECHAL_ENCODE_MODE_VP8)) { MHW_MI_CHK_NULL(params.presDataBuffer); InitMocsParams(resourceParams, &cmd.MfxIndirectBitstreamObjectAttributes.DW0.Value, 1, 6); resourceParams.presResource = params.presDataBuffer; resourceParams.dwOffset = params.dwDataOffset; resourceParams.pdwCmd = cmd.MfxIndirectBitstreamObjectBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 1; resourceParams.dwSize = params.dwDataSize; resourceParams.bIsWritable = false; // upper bound of the allocated resource will be set at 3 DW apart from address location resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } else if (CodecHalIsDecodeModeIT(params.Mode)) { MHW_MI_CHK_NULL(params.presDataBuffer); InitMocsParams(resourceParams, &cmd.MfdIndirectItCoeffObjectAttributes.DW0.Value, 1, 6); resourceParams.presResource = params.presDataBuffer; resourceParams.dwOffset = params.dwDataOffset; resourceParams.pdwCmd = cmd.MfdIndirectItCoeffObjectBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 11; resourceParams.dwSize = params.dwDataSize; resourceParams.bIsWritable = false; // upper bound of the allocated resource will be set at 3 DW apart from address location resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presMvObjectBuffer) { InitMocsParams(resourceParams, &cmd.MfxIndirectMvObjectAttributes.DW0.Value, 1, 6); cmd.MfxIndirectMvObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfxIndirectMvCtrl.Gen12_7.Index; resourceParams.presResource = params.presMvObjectBuffer; resourceParams.dwOffset = params.dwMvObjectOffset; resourceParams.pdwCmd = cmd.MfxIndirectMvObjectBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 6; resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwMvObjectSize, 0x1000); resourceParams.bIsWritable = false; // upper bound of the allocated resource will be set at 3 DW apart from address location resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (params.presPakBaseObjectBuffer) { InitMocsParams(resourceParams, &cmd.MfcIndirectPakBseObjectAttributes.DW0.Value, 1, 6); cmd.MfcIndirectPakBseObjectAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_mfcIndirectPakBseCtrl.Gen12_7.Index; resourceParams.presResource = params.presPakBaseObjectBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = cmd.MfcIndirectPakBseObjectBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 21; resourceParams.dwSize = MOS_ALIGN_CEIL(params.dwPakBaseObjectSize, 0x1000); resourceParams.bIsWritable = true; // upper bound of the allocated resource will be set at 3 DW apart from address location resourceParams.dwUpperBoundLocationOffsetFromCmd = 3; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_BSP_BUF_BASE_ADDR_STATE) { _MHW_SETCMD_CALLBASE(MFX_BSP_BUF_BASE_ADDR_STATE); MHW_RESOURCE_PARAMS resourceParams; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR; if (m_bsdMpcRowstoreCache.enabled) // mbaff and non mbaff mode for all resolutions { cmd.DW3.BsdMpcRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = m_bsdMpcRowstoreCache.dwAddress; } else if (params.presBsdMpcRowStoreScratchBuffer) { InitMocsParams(resourceParams, &cmd.DW3.Value, 1, 6); cmd.DW3.BsdMpcRowStoreScratchBufferIndexToMemoryObjectControlStateMocsTables = m_bsdMpcRowStoreScratchBufferCtrl.Gen12_7.Index; cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = 0; resourceParams.presResource = params.presBsdMpcRowStoreScratchBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = &(cmd.DW1.Value); resourceParams.dwLocationInCmd = 1; resourceParams.bIsWritable = true; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } if (m_mprRowstoreCache.enabled) { cmd.DW6.MprRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = m_mprRowstoreCache.dwAddress; } else if (params.presMprRowStoreScratchBuffer) { InitMocsParams(resourceParams, &cmd.DW6.Value, 1, 6); cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = 0; resourceParams.presResource = params.presMprRowStoreScratchBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = &(cmd.DW4.Value); resourceParams.dwLocationInCmd = 4; resourceParams.bIsWritable = true; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_PAK_INSERT_OBJECT) { _MHW_SETCMD_CALLBASE(MFX_PAK_INSERT_OBJECT); uint32_t dwordsUsed = cmd.dwSize; dwordsUsed += params.dwPadding; #define DO_FIELDS() \ DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \ DO_FIELD(DW1, BitstreamstartresetResetbitstreamstartingpos, params.bitstreamstartresetResetbitstreamstartingpos); \ DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.endofsliceflagLastdstdatainsertcommandflag); \ DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.lastheaderflagLastsrcheaderdatainsertcommandflag); \ DO_FIELD(DW1, EmulationflagEmulationbytebitsinsertenable, params.emulationflagEmulationbytebitsinsertenable); \ DO_FIELD(DW1, SkipemulbytecntSkipEmulationByteCount, params.skipemulbytecntSkipEmulationByteCount); \ DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, params.databitsinlastdwSrcdataendingbitinclusion50); \ DO_FIELD(DW1, SliceHeaderIndicator, params.sliceHeaderIndicator); \ DO_FIELD(DW1, Headerlengthexcludefrmsize, params.headerlengthexcludefrmsize); \ DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, 0); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE) { _MHW_SETCMD_CALLBASE(MFX_AVC_IMG_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, FrameSize, params.frameSize); \ DO_FIELD(DW2, FrameWidth, params.frameWidth); \ DO_FIELD(DW2, FrameHeight, params.frameHeight); \ DO_FIELD(DW3, ImgstructImageStructureImgStructure10, params.imgstructImageStructureImgStructure10); \ DO_FIELD(DW3, WeightedBipredIdc, params.weightedBipredIdc); \ DO_FIELD(DW3, WeightedPredFlag, params.weightedPredFlag); \ DO_FIELD(DW3, RhodomainRateControlEnable, params.vdencEnabled); \ DO_FIELD(DW3, FirstChromaQpOffset, params.firstChromaQpOffset); \ DO_FIELD(DW3, SecondChromaQpOffset, params.secondChromaQpOffset); \ DO_FIELD(DW4, Fieldpicflag, params.fieldpicflag); \ DO_FIELD(DW4, Mbaffflameflag, params.mbaffflameflag); \ DO_FIELD(DW4, Framembonlyflag, params.framembonlyflag); \ DO_FIELD(DW4, Transform8X8Flag, params.transform8X8Flag); \ DO_FIELD(DW4, Direct8X8Infflag, params.direct8X8Infflag); \ DO_FIELD(DW4, Constrainedipredflag, params.constrainedipredflag); \ DO_FIELD(DW4, Imgdisposableflag, params.imgdisposableflag); \ DO_FIELD(DW4, Entropycodingflag, params.entropycodingflag); \ DO_FIELD(DW4, Mbmvformatflag, params.mbmvformatflag); \ DO_FIELD(DW4, Chromaformatidc, params.chromaformatidc); \ DO_FIELD(DW4, Mvunpackedflag, params.mvunpackedflag); \ DO_FIELD(DW4, Inserttestflag, 0); \ DO_FIELD(DW4, Loadslicepointerflag, 0); \ DO_FIELD(DW4, Mbstatenabled, params.mbstatenabled); \ DO_FIELD(DW4, Minframewsize, 0); \ DO_FIELD(DW5, IntrambmaxbitflagIntrambmaxsizereportmask, params.intrambmaxbitflagIntrambmaxsizereportmask); \ DO_FIELD(DW5, IntermbmaxbitflagIntermbmaxsizereportmask, params.intermbmaxbitflagIntermbmaxsizereportmask); \ DO_FIELD(DW5, FrameszoverflagFramebitratemaxreportmask, params.frameszoverflagFramebitratemaxreportmask); \ DO_FIELD(DW5, FrameszunderflagFramebitrateminreportmask, params.frameszunderflagFramebitrateminreportmask); \ DO_FIELD(DW5, IntraIntermbipcmflagForceipcmcontrolmask, params.intraIntermbipcmflagForceipcmcontrolmask); \ DO_FIELD(DW5, MbratectrlflagMbLevelRateControlEnablingFlag, params.mbratectrlflagMbLevelRateControlEnablingFlag); \ DO_FIELD(DW5, Nonfirstpassflag, false); \ DO_FIELD(DW5, TrellisQuantizationChromaDisableTqchromadisable, true); \ DO_FIELD(DW5, TrellisQuantizationRoundingTqr, params.trellisQuantizationRoundingTqr); \ DO_FIELD(DW5, TrellisQuantizationEnabledTqenb, params.trellisQuantizationEnabledTqenb); \ DO_FIELD(DW6, Intrambmaxsz, params.intrambmaxsz); \ DO_FIELD(DW6, Intermbmaxsz, params.intermbmaxsz); \ DO_FIELD(DW8, Slicedeltaqppmax0, 0); \ DO_FIELD(DW8, Slicedeltaqpmax1, 0); \ DO_FIELD(DW8, Slicedeltaqpmax2, 0); \ DO_FIELD(DW8, Slicedeltaqpmax3, 0); \ DO_FIELD(DW9, Slicedeltaqpmin0, 0); \ DO_FIELD(DW9, Slicedeltaqpmin1, 0); \ DO_FIELD(DW9, Slicedeltaqpmin2, 0); \ DO_FIELD(DW9, Slicedeltaqpmin3, 0); \ DO_FIELD(DW10, Framebitratemin, params.framebitratemin); \ DO_FIELD(DW10, Framebitrateminunitmode, params.framebitrateminunitmode); \ DO_FIELD(DW10, Framebitrateminunit, params.framebitrateminunit); \ DO_FIELD(DW10, Framebitratemax, params.framebitratemax); \ DO_FIELD(DW10, Framebitratemaxunitmode, params.framebitratemaxunitmode); \ DO_FIELD(DW10, Framebitratemaxunit, params.framebitratemaxunit); \ DO_FIELD(DW11, Framebitratemindelta, params.framebitratemindelta); \ DO_FIELD(DW11, Framebitratemaxdelta, params.framebitratemaxdelta); \ DO_FIELD(DW11, SliceStatsStreamoutEnable, params.sliceStatsStreamoutEnable); \ DO_FIELD(DW13, InitialQpValue, params.initialQpValue); \ DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL0, params.numberOfActiveReferencePicturesFromL0); \ DO_FIELD(DW13, NumberOfActiveReferencePicturesFromL1, params.numberOfActiveReferencePicturesFromL1); \ DO_FIELD(DW13, NumberOfReferenceFrames, params.numberOfReferenceFrames); \ DO_FIELD(DW13, CurrentPictureHasPerformedMmco5, 0); \ DO_FIELD(DW14, PicOrderPresentFlag, params.picOrderPresentFlag); \ DO_FIELD(DW14, DeltaPicOrderAlwaysZeroFlag, params.deltaPicOrderAlwaysZeroFlag); \ DO_FIELD(DW14, PicOrderCntType, params.picOrderCntType); \ DO_FIELD(DW14, SliceGroupMapType, params.sliceGroupMapType); \ DO_FIELD(DW14, RedundantPicCntPresentFlag, params.redundantPicCntPresentFlag); \ DO_FIELD(DW14, NumSliceGroupsMinus1, params.numSliceGroupsMinus1); \ DO_FIELD(DW14, DeblockingFilterControlPresentFlag, params.deblockingFilterControlPresentFlag); \ DO_FIELD(DW14, Log2MaxFrameNumMinus4, params.log2MaxFrameNumMinus4); \ DO_FIELD(DW14, Log2MaxPicOrderCntLsbMinus4, params.log2MaxPicOrderCntLsbMinus4); \ DO_FIELD(DW15, SliceGroupChangeRate, params.sliceGroupChangeRate); \ DO_FIELD(DW15, CurrPicFrameNum, params.currPicFrameNum); \ DO_FIELD(DW16, CurrentFrameViewId, params.currentFrameViewId); \ DO_FIELD(DW16, MaxViewIdxl0, params.maxViewIdxl0); \ DO_FIELD(DW16, MaxViewIdxl1, params.maxViewIdxl1); \ DO_FIELD(DW16, InterViewOrderDisable, 0); \ DO_FIELD(DW17, ExtendedRhodomainStatisticsEnable, params.extendedRhodomainStatisticsEnable); \ DO_FIELD(DW19, ThresholdSizeInBytes, params.thresholdSizeInBytes); \ DO_FIELD(DW20, TargetSliceSizeInBytes, params.targetSliceSizeInBytes); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_REF_IDX_STATE) { _MHW_SETCMD_CALLBASE(MFX_AVC_REF_IDX_STATE); cmd.DW1.RefpiclistSelect = params.uiList; for (uint8_t i = 0; i < 8; i++) { cmd.ReferenceListEntry[i] = params.referenceListEntry[i]; } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_WEIGHTOFFSET_STATE) { _MHW_SETCMD_CALLBASE(MFX_AVC_WEIGHTOFFSET_STATE); cmd.DW1.WeightAndOffsetSelect = params.uiList; for (uint8_t i = 0; i < 96; i++) { cmd.Weightoffset[i] = params.weightoffset[i]; } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_SLICE_STATE) { _MHW_SETCMD_CALLBASE(MFX_AVC_SLICE_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, SliceType, params.sliceType); \ DO_FIELD(DW2, Log2WeightDenomLuma, params.log2WeightDenomLuma); \ DO_FIELD(DW2, Log2WeightDenomChroma, params.log2WeightDenomChroma); \ DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList0, params.numberOfReferencePicturesInInterPredictionList0); \ DO_FIELD(DW2, NumberOfReferencePicturesInInterPredictionList1, params.numberOfReferencePicturesInInterPredictionList1); \ DO_FIELD(DW3, SliceAlphaC0OffsetDiv2, params.sliceAlphaC0OffsetDiv2); \ DO_FIELD(DW3, SliceBetaOffsetDiv2, params.sliceBetaOffsetDiv2); \ DO_FIELD(DW3, SliceQuantizationParameter, params.sliceQuantizationParameter); \ DO_FIELD(DW3, CabacInitIdc10, params.cabacInitIdc10); \ DO_FIELD(DW3, DisableDeblockingFilterIndicator, params.disableDeblockingFilterIndicator); \ DO_FIELD(DW3, DirectPredictionType, params.directPredictionType); \ DO_FIELD(DW3, WeightedPredictionIndicator, params.weightedPredictionIndicator); \ DO_FIELD(DW4, SliceStartMbNum, params.sliceStartMbNum); \ DO_FIELD(DW4, SliceHorizontalPosition, params.sliceHorizontalPosition); \ DO_FIELD(DW4, SliceVerticalPosition, params.sliceVerticalPosition); \ DO_FIELD(DW5, NextSliceHorizontalPosition, params.nextSliceHorizontalPosition); \ DO_FIELD(DW5, NextSliceVerticalPosition, params.nextSliceVerticalPosition); \ DO_FIELD(DW6, StreamId10, 0); \ DO_FIELD(DW6, SliceId30, params.sliceId30); \ DO_FIELD(DW6, Cabaczerowordinsertionenable, params.cabaczerowordinsertionenable); \ DO_FIELD(DW6, Emulationbytesliceinsertenable, params.emulationbytesliceinsertenable); \ DO_FIELD(DW6, TailInsertionPresentInBitstream, params.tailInsertionPresentInBitstream); \ DO_FIELD(DW6, SlicedataInsertionPresentInBitstream, params.slicedataInsertionPresentInBitstream); \ DO_FIELD(DW6, HeaderInsertionPresentInBitstream, params.headerInsertionPresentInBitstream); \ DO_FIELD(DW6, IsLastSlice, params.isLastSlice); \ DO_FIELD(DW6, MbTypeSkipConversionDisable, false); \ DO_FIELD(DW6, MbTypeDirectConversionDisable, false); \ DO_FIELD(DW6, RateControlCounterEnable, false); \ DO_FIELD(DW9, Roundintra, params.roundintra); \ DO_FIELD(DW9, Roundintraenable, true); \ DO_FIELD(DW9, Roundinter, params.roundinter); \ DO_FIELD(DW9, Roundinterenable, params.roundinterenable); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_DIRECTMODE_STATE) { _MHW_SETCMD_CALLBASE(MFX_AVC_DIRECTMODE_STATE); MHW_RESOURCE_PARAMS resourceParams; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_AVC_DIRECT_MODE; if (!params.bDisableDmvBuffers) { MHW_MI_CHK_NULL(params.presAvcDmvBuffers); InitMocsParams(resourceParams, &cmd.DirectMvBufferForWriteAttributes.DW0.Value, 1, 6); // current picture resourceParams.presResource = ¶ms.presAvcDmvBuffers[params.ucAvcDmvIdx]; resourceParams.dwOffset = 0; resourceParams.pdwCmd = &(cmd.DirectMvBufferForWriteBaseAddress.DW0_1.Value[0]); resourceParams.dwLocationInCmd = 34; resourceParams.bIsWritable = true; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } CODEC_REF_LIST** refList; MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST**)params.avcRefList); if (CodecHal_PictureIsBottomField(params.CurrPic)) { cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = 0; cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1]; } else { cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[0]; if (CodecHal_PictureIsFrame(params.CurrPic)) { cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] = refList[params.CurrPic.FrameIdx]->iFieldOrderCnt[1]; } } if (!params.bDisableDmvBuffers) { InitMocsParams(resourceParams, &cmd.DirectMvBufferAttributes.DW0.Value, 1, 6); } bool dmvPresent[CODEC_AVC_NUM_REF_DMV_BUFFERS] = { false }; for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++) { if (params.pAvcPicIdx[i].bValid) { uint8_t idx = params.pAvcPicIdx[i].ucPicIdx; uint8_t picID = params.bPicIdRemappingInUse ? i : refList[idx]->ucFrameId; uint8_t mvIdx = refList[idx]->ucDMVIdx[0]; uint8_t validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 0) & 1; uint8_t frameID = picID << 1; if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2) { if (!params.bDisableDmvBuffers) { dmvPresent[picID] = true; resourceParams.presResource = ¶ms.presAvcDmvBuffers[mvIdx]; resourceParams.dwOffset = 0; resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[picID].DW0_1.Value[0]); resourceParams.dwLocationInCmd = picID * 2 + 1; resourceParams.bIsWritable = false; resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[0] * validRef; } else { return MOS_STATUS_UNKNOWN; } validRef = ((params.uiUsedForReferenceFlags >> (i * 2)) >> 1) & 1; frameID = (picID << 1) + 1; if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2) { cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[1] * validRef; } else { return MOS_STATUS_UNKNOWN; } } } if (!params.bDisableDmvBuffers) { // Use a valid address for remaining DMV buffers for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++) { if (dmvPresent[i] == false) { //Give default buffer to the MV resourceParams.presResource = ¶ms.presAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS]; resourceParams.dwOffset = 0; resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[i].DW0_1.Value[0]); resourceParams.dwLocationInCmd = i * 2 + 1; resourceParams.bIsWritable = false; resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } } } return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_SLICEADDR) { _MHW_SETCMD_CALLBASE(MFD_AVC_SLICEADDR); MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; sliceInfoParam.presDataBuffer = params.presDataBuffer; sliceInfoParam.dwSliceIndex = params.dwSliceIndex; sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed; sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress; sliceInfoParam.dwDataStartOffset[1] = params.avcSliceParams->slice_data_offset; MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( params.decodeInUse, this->m_currentCmdBuf, nullptr, &sliceInfoParam)); #define DO_FIELDS() \ DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_BSD_OBJECT) { _MHW_SETCMD_CALLBASE(MFD_AVC_BSD_OBJECT); MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; sliceInfoParam.presDataBuffer = params.presDataBuffer; sliceInfoParam.dwSliceIndex = params.dwSliceIndex; sliceInfoParam.dwTotalBytesConsumed = params.dwTotalBytesConsumed; sliceInfoParam.dwDataStartOffset[0] = params.IndirectBsdDataStartAddress; sliceInfoParam.dwDataStartOffset[1] = params.pAvcSliceParams->slice_data_offset; sliceInfoParam.dwDataLength[1] = params.pAvcSliceParams->slice_data_size; MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( params.decodeInUse, this->m_currentCmdBuf, nullptr, &sliceInfoParam)); #define DO_FIELDS() \ DO_FIELD(DW4, LastsliceFlag, params.LastsliceFlag); \ DO_FIELD(DW3, IntraPredmode4X48X8LumaErrorControlBit, 1); \ DO_FIELD(DW5, IntraPredictionErrorControlBitAppliedToIntra16X16Intra8X8Intra4X4LumaAndChroma, 1); \ DO_FIELD(DW5, Intra8X84X4PredictionErrorConcealmentControlBit, 1); \ DO_FIELD(DW5, ISliceConcealmentMode, 1); \ DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ DO_FIELD(DW2, IndirectBsdDataStartAddress, params.IndirectBsdDataStartAddress); \ DO_FIELD(DW4, FirstMbByteOffsetOfSliceDataOrSliceHeader, params.FirstMbByteOffsetOfSliceDataOrSliceHeader); \ DO_FIELD(DW4, FirstMacroblockMbBitOffset, params.FirstMacroblockMbBitOffset); \ DO_FIELD(DW4, FixPrevMbSkipped, 1); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_PICID_STATE) { _MHW_SETCMD_CALLBASE(MFD_AVC_PICID_STATE); MOS_SecureMemcpy(cmd.Pictureidlist1616Bits, sizeof(params.Pictureidlist1616Bits), params.Pictureidlist1616Bits, sizeof(params.Pictureidlist1616Bits)); #define DO_FIELDS() \ DO_FIELD(DW1, PictureidRemappingDisable, params.PictureidRemappingDisable); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_PIC_STATE) { _MHW_SETCMD_CALLBASE(MFX_JPEG_PIC_STATE); #define DO_FIELDS() \ if (params.decodeInUse) \ { \ DO_FIELD(DW1, Obj1.InputFormatYuv, params.inputFormatYuv); \ DO_FIELD(DW1, Obj1.Rotation, params.rotation); \ DO_FIELD(DW1, Obj1.OutputFormatYuv, params.outputFormatYuv); \ DO_FIELD(DW1, Obj1.VerticalDownSamplingEnable, params.verticalDownSamplingEnable); \ DO_FIELD(DW1, Obj1.HorizontalDownSamplingEnable, params.horizontalDownSamplingEnable); \ DO_FIELD(DW1, Obj1.VerticalUpSamplingEnable, params.verticalUpSamplingEnable); \ } \ else \ { \ DO_FIELD(DW1, Obj0.OutputMcuStructure, params.outputMcuStructure); \ DO_FIELD(DW1, Obj0.InputSurfaceFormatYuv, params.inputSurfaceFormatYuv); \ DO_FIELD(DW1, Obj0.PixelsInVerticalLastMcu, params.pixelsInVerticalLastMcu); \ DO_FIELD(DW1, Obj0.PixelsInHorizontalLastMcu, params.pixelsInHorizontalLastMcu); \ } \ DO_FIELD(DW2, Obj0.FrameWidthInBlocksMinus1, params.frameWidthInBlocksMinus1); \ DO_FIELD(DW2, Obj0.FrameHeightInBlocksMinus1, params.frameHeightInBlocksMinus1); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_JPEG_HUFF_TABLE_STATE) { _MHW_SETCMD_CALLBASE(MFX_JPEG_HUFF_TABLE_STATE); MHW_MI_CHK_STATUS(MOS_SecureMemcpy( cmd.DcBits128BitArray, sizeof(cmd.DcBits128BitArray), params.pDCBits, sizeof(cmd.DcBits128BitArray))); MHW_MI_CHK_STATUS(MOS_SecureMemcpy( cmd.DcHuffval128BitArray, sizeof(cmd.DcHuffval128BitArray), params.pDCValues, sizeof(cmd.DcHuffval128BitArray))); MHW_MI_CHK_STATUS(MOS_SecureMemcpy( cmd.AcBits168BitArray, sizeof(cmd.AcBits168BitArray), params.pACBits, sizeof(cmd.AcBits168BitArray))); MHW_MI_CHK_STATUS(MOS_SecureMemcpy( cmd.AcHuffval1608BitArray, sizeof(cmd.AcHuffval1608BitArray), params.pACValues, sizeof(cmd.AcHuffval1608BitArray))); MHW_MI_CHK_STATUS(MOS_SecureMemcpy( &cmd.DW52.Value, sizeof(uint16_t), (uint8_t *)params.pACValues + sizeof(cmd.AcHuffval1608BitArray), sizeof(uint16_t))); #define DO_FIELDS() \ DO_FIELD(DW1, Hufftableid1Bit, params.huffTableID); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_JPEG_BSD_OBJECT) { _MHW_SETCMD_CALLBASE(MFD_JPEG_BSD_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW1, IndirectDataLength, params.indirectDataLength); \ DO_FIELD(DW2, IndirectDataStartAddress, params.dataStartAddress); \ DO_FIELD(DW3, ScanVerticalPosition, params.scanVerticalPosition); \ DO_FIELD(DW3, ScanHorizontalPosition, params.scanHorizontalPosition); \ DO_FIELD(DW4, McuCount, params.mcuCount); \ DO_FIELD(DW4, ScanComponents, params.scanComponent); \ DO_FIELD(DW4, Interleaved, params.interleaved); \ DO_FIELD(DW5, Restartinterval16Bit, params.restartInterval); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_HUFF_TABLE_STATE) { _MHW_SETCMD_CALLBASE(MFC_JPEG_HUFF_TABLE_STATE); for (uint8_t i = 0; i < 12; i++) { cmd.DcTable[i] = params.dcTable[i]; } for (uint8_t i = 0; i < 162; i++) { cmd.AcTable[i] = params.acTable[i]; } cmd.DW1.HuffTableId = params.huffTableId; return MOS_STATUS_SUCCESS; } _MHW_SETCMD_OVERRIDE_DECL(MFC_JPEG_SCAN_OBJECT) { _MHW_SETCMD_CALLBASE(MFC_JPEG_SCAN_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW1, McuCount, params.mcuCount); \ DO_FIELD(DW2, RestartInterval, params.restartInterval); \ DO_FIELD(DW2, IsLastScan, 1); \ DO_FIELD(DW2, HeadPresentFlag, 1); \ DO_FIELD(DW2, HuffmanDcTable, params.huffmanDcTable); \ DO_FIELD(DW2, HuffmanAcTable, params.huffmanAcTable); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_AVC_DPB_STATE) { _MHW_SETCMD_CALLBASE(MFD_AVC_DPB_STATE); for (auto i = 0, j = 0; i < 8; i++, j++) { cmd.Ltstframenumlist1616Bits[i] = (params.refFrameOrder[j++] & 0xFFFF); cmd.Ltstframenumlist1616Bits[i] = cmd.Ltstframenumlist1616Bits[i] | ((params.refFrameOrder[j] & 0xFFFF) << 16); //SecondEntry } if (params.pMvcExtPicParams) { for (auto i = 0, j = 0; j < (CODEC_MAX_NUM_REF_FRAME / 2); i++, j++) { cmd.Viewidlist1616Bits[i] = params.pMvcExtPicParams->ViewIDList[j++]; cmd.Viewidlist1616Bits[i] = cmd.Viewidlist1616Bits[i] | (params.pMvcExtPicParams->ViewIDList[j] << 16); } for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++) { cmd.Vieworderlistl0168Bits[i] = GetViewOrder(params, j++, LIST_0); //FirstEntry cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 8); //SecondEntry cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j++, LIST_0) << 16); //ThirdEntry cmd.Vieworderlistl0168Bits[i] = cmd.Vieworderlistl0168Bits[i] | (GetViewOrder(params, j, LIST_0) << 24); //FourthEntry } for (auto i = 0, j = 0; i < (CODEC_MAX_NUM_REF_FRAME / 4); i++, j++) { cmd.Vieworderlistl1168Bits[i] = GetViewOrder(params, j++, LIST_1); //FirstEntry cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 8); //SecondEntry cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j++, LIST_1) << 16); //ThirdEntry cmd.Vieworderlistl1168Bits[i] = cmd.Vieworderlistl1168Bits[i] | (GetViewOrder(params, j, LIST_1) << 24); //FourthEntry } } else { // non-MVC usage MOS_ZeroMemory(cmd.Viewidlist1616Bits, sizeof(cmd.Viewidlist1616Bits)); MOS_FillMemory(cmd.Vieworderlistl0168Bits, sizeof(cmd.Vieworderlistl0168Bits), 0xF); MOS_FillMemory(cmd.Vieworderlistl1168Bits, sizeof(cmd.Vieworderlistl1168Bits), 0xF); } #define DO_FIELDS() \ DO_FIELD(DW1, NonExistingframeFlag161Bit, params.NonExistingframeFlag161Bit); \ DO_FIELD(DW1, LongtermframeFlag161Bit, params.LongtermframeFlag161Bit); \ DO_FIELD(DW2, Value, params.usedForRef); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_MPEG2_PIC_STATE) { _MHW_SETCMD_CALLBASE(MFX_MPEG2_PIC_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, ScanOrder, params.ScanOrder); \ DO_FIELD(DW1, IntraVlcFormat, params.IntraVlcFormat); \ DO_FIELD(DW1, QuantizerScaleType, params.QuantizerScaleType); \ DO_FIELD(DW1, ConcealmentMotionVectorFlag, params.ConcealmentMotionVectorFlag); \ DO_FIELD(DW1, FramePredictionFrameDct, params.FramePredictionFrameDct); \ DO_FIELD(DW1, TffTopFieldFirst, params.TffTopFieldFirst); \ DO_FIELD(DW1, PictureStructure, params.PictureStructure); \ DO_FIELD(DW1, IntraDcPrecision, params.IntraDcPrecision); \ DO_FIELD(DW1, FCode00, params.FCode00); \ DO_FIELD(DW1, FCode01, params.FCode01); \ DO_FIELD(DW1, FCode10, params.FCode10); \ DO_FIELD(DW1, FCode11, params.FCode11); \ DO_FIELD(DW2, PictureCodingType, params.PictureCodingType); \ DO_FIELD(DW2, ISliceConcealmentMode, params.ISliceConcealmentMode); \ DO_FIELD(DW2, PBSliceConcealmentMode, params.PBSliceConcealmentMode); \ DO_FIELD(DW2, PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride, params.PBSlicePredictedBidirMotionTypeOverrideBiDirectionMvTypeOverride); \ DO_FIELD(DW2, PBSlicePredictedMotionVectorOverrideFinalMvValueOverride, params.PBSlicePredictedMotionVectorOverrideFinalMvValueOverride); \ DO_FIELD(DW3, SliceConcealmentDisableBit, params.SliceConcealmentDisableBit); \ DO_FIELD(DW3, Framewidthinmbsminus170PictureWidthInMacroblocks, params.Framewidthinmbsminus170PictureWidthInMacroblocks); \ DO_FIELD(DW3, Frameheightinmbsminus170PictureHeightInMacroblocks, params.Frameheightinmbsminus170PictureHeightInMacroblocks); \ DO_FIELD(DW4, Roundintradc, 3); \ DO_FIELD(DW4, Roundinterdc, 1); \ DO_FIELD(DW4, Roundintraac, 5); \ DO_FIELD(DW4, Roundinterac, 1); \ DO_FIELD(DW3, MFX_MPEG2_PIC_STATE_CMD_DW3_BIT24_28, params.mfxMpeg2PicStatePar0); \ #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_MPEG2_BSD_OBJECT) { _MHW_SETCMD_CALLBASE(MFD_MPEG2_BSD_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW1, IndirectBsdDataLength, params.IndirectBsdDataLength); \ DO_FIELD(DW2, IndirectDataStartAddress, params.IndirectDataStartAddress); \ DO_FIELD(DW3, FirstMacroblockBitOffset, params.FirstMacroblockBitOffset); \ DO_FIELD(DW3, IsLastMb, params.IsLastMb); \ DO_FIELD(DW3, LastPicSlice, params.LastPicSlice); \ DO_FIELD(DW3, MbRowLastSlice, params.MbRowLastSlice); \ DO_FIELD(DW3, MacroblockCount, params.MacroblockCount); \ DO_FIELD(DW3, SliceHorizontalPosition, params.SliceHorizontalPosition); \ DO_FIELD(DW3, SliceVerticalPosition, params.SliceVerticalPosition); \ DO_FIELD(DW4, QuantizerScaleCode, params.QuantizerScaleCode); \ DO_FIELD(DW4, NextSliceHorizontalPosition, params.NextSliceHorizontalPosition); \ DO_FIELD(DW4, NextSliceVerticalPosition, params.NextSliceVerticalPosition); MHW_CP_SLICE_INFO_PARAMS sliceInfoParam; sliceInfoParam.presDataBuffer = params.presDataBuffer; sliceInfoParam.dwDataStartOffset[0] = params.dwDataStartOffset; MHW_MI_CHK_STATUS(m_cpItf->SetMfxProtectionState( params.decodeInUse, nullptr, this->m_currentBatchBuf, &sliceInfoParam)); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT) { _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW0, DwordLength, params.DwordLength); \ DO_FIELD(DW3, IndirectItCoeffDataLength, (params.dwDCTLength) << 2); \ DO_FIELD(DW4, IndirectItCoeffDataStartAddressOffset, params.IndirectItCoeffDataStartAddressOffset); #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_IT_OBJECT_MPEG2_INLINE_DATA) { _MHW_SETCMD_CALLBASE(MFD_IT_OBJECT_MPEG2_INLINE_DATA); auto MBType = params.pMBParams->MBType; cmd.DW0.MacroblockIntraType = 1; cmd.DW0.DctType = MBType.m_fieldResidual; cmd.DW0.CodedBlockPattern = params.CodedBlockPattern; cmd.DW0.Lastmbinrow = params.Lastmbinrow; cmd.DW1.Horzorigin = params.Horzorigin; cmd.DW1.Vertorigin = params.Vertorigin; if (params.CodingType != I_TYPE) { cmd.DW0.MacroblockIntraType = MBType.m_intraMb; cmd.DW0.MacroblockMotionForward = MBType.m_motionFwd; cmd.DW0.MacroblockMotionBackward = MBType.m_motionBwd; cmd.DW0.MotionType = MBType.m_motionType; cmd.DW0.MotionVerticalFieldSelect = MBType.m_mvertFieldSel; // Next, copy in the motion vectors if (MBType.m_intraMb == 0) { uint32_t *point = (uint32_t *)(params.sPackedMVs0); cmd.DW2.Value = *point++; cmd.DW3.Value = *point++; point = (uint32_t *)(params.sPackedMVs1); cmd.DW4.Value = *point++; cmd.DW5.Value = *point++; } } #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFX_VP8_PIC_STATE) { _MHW_SETCMD_CALLBASE(MFX_VP8_PIC_STATE); #define DO_FIELDS() \ DO_FIELD(DW1, FrameWidthMinus1 , params.FrameWidthMinus1); \ DO_FIELD(DW1, FrameHeightMinus1 , params.FrameHeightMinus1); \ DO_FIELD(DW2, McFilterSelect , params.McFilterSelect); \ DO_FIELD(DW2, ChromaFullPixelMcFilterMode , params.ChromaFullPixelMcFilterMode); \ DO_FIELD(DW2, Dblkfiltertype , params.Dblkfiltertype); \ DO_FIELD(DW2, Skeyframeflag , params.Skeyframeflag); \ DO_FIELD(DW2, SegmentationIdStreamoutEnable , params.SegmentationIdStreamoutEnable); \ DO_FIELD(DW2, SegmentationIdStreaminEnable , params.SegmentationIdStreaminEnable); \ DO_FIELD(DW2, SegmentEnableFlag , params.SegmentEnableFlag); \ DO_FIELD(DW2, UpdateMbsegmentMapFlag , params.UpdateMbsegmentMapFlag); \ DO_FIELD(DW2, MbNocoeffSkipflag , params.MbNocoeffSkipflag); \ DO_FIELD(DW2, ModeReferenceLoopFilterDeltaEnabled , params.ModeReferenceLoopFilterDeltaEnabled); \ DO_FIELD(DW2, GoldenRefPictureMvSignbiasFlag , params.GoldenRefPictureMvSignbiasFlag); \ DO_FIELD(DW2, AlternateRefPicMvSignbiasFlag , params.AlternateRefPicMvSignbiasFlag); \ DO_FIELD(DW2, DeblockSharpnessLevel , params.DeblockSharpnessLevel); \ DO_FIELD(DW3, DblkfilterlevelForSegment3 , params.DblkfilterlevelForSegment3); \ DO_FIELD(DW3, DblkfilterlevelForSegment2 , params.DblkfilterlevelForSegment2); \ DO_FIELD(DW3, DblkfilterlevelForSegment1 , params.DblkfilterlevelForSegment1); \ DO_FIELD(DW3, DblkfilterlevelForSegment0 , params.DblkfilterlevelForSegment0); \ DO_FIELD(DW8, QuantizerValue1Blocktype2Uvdc , params.QuantizerValue1Blocktype2Uvdc); \ DO_FIELD(DW8, QuantizerValue1Blocktype3Uvac , params.QuantizerValue1Blocktype3Uvac); \ DO_FIELD(DW9, QuantizerValue1Blocktype4Y2Dc , params.QuantizerValue1Blocktype4Y2Dc); \ DO_FIELD(DW9, QuantizerValue1Blocktype5Y2Ac , params.QuantizerValue1Blocktype5Y2Ac); \ DO_FIELD(DW10, QuantizerValue2Blocktype0Y1Dc , params.QuantizerValue2Blocktype0Y1Dc); \ DO_FIELD(DW10, QuantizerValue2Blocktype1Y1Ac , params.QuantizerValue2Blocktype1Y1Ac); \ DO_FIELD(DW11, QuantizerValue2Blocktype2Uvdc , params.QuantizerValue2Blocktype2Uvdc); \ DO_FIELD(DW11, QuantizerValue2Blocktype3Uvac , params.QuantizerValue2Blocktype3Uvac); \ DO_FIELD(DW12, QuantizerValue2Blocktype4Y2Dc , params.QuantizerValue2Blocktype4Y2Dc); \ DO_FIELD(DW12, QuantizerValue2Blocktype5Y2Ac , params.QuantizerValue2Blocktype5Y2Ac); \ DO_FIELD(DW13, QuantizerValue3Blocktype0Y1Dc , params.QuantizerValue3Blocktype0Y1Dc); \ DO_FIELD(DW13, QuantizerValue3Blocktype1Y1Ac , params.QuantizerValue3Blocktype1Y1Ac); \ DO_FIELD(DW14, QuantizerValue3Blocktype2Uvdc , params.QuantizerValue3Blocktype2Uvdc); \ DO_FIELD(DW14, QuantizerValue3Blocktype3Uvac , params.QuantizerValue3Blocktype3Uvac); \ DO_FIELD(DW15, QuantizerValue3Blocktype4Y2Dc , params.QuantizerValue3Blocktype4Y2Dc); \ DO_FIELD(DW15, QuantizerValue3Blocktype5Y2Ac , params.QuantizerValue3Blocktype5Y2Ac); \ DO_FIELD(DW19, Mbsegmentidtreeprobs2 , params.Mbsegmentidtreeprobs2); \ DO_FIELD(DW19, Mbsegmentidtreeprobs1 , params.Mbsegmentidtreeprobs1); \ DO_FIELD(DW19, Mbsegmentidtreeprobs0 , params.Mbsegmentidtreeprobs0); \ DO_FIELD(DW20, Mbnocoeffskipfalseprob , params.Mbnocoeffskipfalseprob); \ DO_FIELD(DW20, Intrambprob , params.Intrambprob); \ DO_FIELD(DW20, Interpredfromlastrefprob , params.Interpredfromlastrefprob); \ DO_FIELD(DW20, Interpredfromgrefrefprob , params.Interpredfromgrefrefprob); \ DO_FIELD(DW21, Ymodeprob3 , params.Ymodeprob3); \ DO_FIELD(DW21, Ymodeprob2 , params.Ymodeprob2); \ DO_FIELD(DW21, Ymodeprob1 , params.Ymodeprob1); \ DO_FIELD(DW21, Ymodeprob0 , params.Ymodeprob0); \ DO_FIELD(DW22, Uvmodeprob2 , params.Uvmodeprob2); \ DO_FIELD(DW22, Uvmodeprob1 , params.Uvmodeprob1); \ DO_FIELD(DW22, Uvmodeprob0 , params.Uvmodeprob0); \ DO_FIELD(DW23, Mvupdateprobs00 , params.Mvupdateprobs00); \ DO_FIELD(DW23, Mvupdateprobs01 , params.Mvupdateprobs01); \ DO_FIELD(DW23, Mvupdateprobs02 , params.Mvupdateprobs02); \ DO_FIELD(DW23, Mvupdateprobs03 , params.Mvupdateprobs03); \ DO_FIELD(DW24, Mvupdateprobs04 , params.Mvupdateprobs04); \ DO_FIELD(DW24, Mvupdateprobs05 , params.Mvupdateprobs05); \ DO_FIELD(DW24, Mvupdateprobs06 , params.Mvupdateprobs06); \ DO_FIELD(DW24, Mvupdateprobs07 , params.Mvupdateprobs07); \ DO_FIELD(DW25, Mvupdateprobs08 , params.Mvupdateprobs08); \ DO_FIELD(DW25, Mvupdateprobs09 , params.Mvupdateprobs09); \ DO_FIELD(DW25, Mvupdateprobs010 , params.Mvupdateprobs010); \ DO_FIELD(DW25, Mvupdateprobs011 , params.Mvupdateprobs011); \ DO_FIELD(DW26, Mvupdateprobs012 , params.Mvupdateprobs012); \ DO_FIELD(DW26, Mvupdateprobs013 , params.Mvupdateprobs013); \ DO_FIELD(DW26, Mvupdateprobs014 , params.Mvupdateprobs014); \ DO_FIELD(DW26, Mvupdateprobs015 , params.Mvupdateprobs015); \ DO_FIELD(DW27, Mvupdateprobs016 , params.Mvupdateprobs016); \ DO_FIELD(DW27, Mvupdateprobs017 , params.Mvupdateprobs017); \ DO_FIELD(DW27, Mvupdateprobs018 , params.Mvupdateprobs018); \ DO_FIELD(DW28, Mvupdateprobs10 , params.Mvupdateprobs10); \ DO_FIELD(DW28, Mvupdateprobs11 , params.Mvupdateprobs11); \ DO_FIELD(DW28, Mvupdateprobs12 , params.Mvupdateprobs12); \ DO_FIELD(DW28, Mvupdateprobs13 , params.Mvupdateprobs13); \ DO_FIELD(DW29, Mvupdateprobs14 , params.Mvupdateprobs14); \ DO_FIELD(DW29, Mvupdateprobs15 , params.Mvupdateprobs15); \ DO_FIELD(DW29, Mvupdateprobs16 , params.Mvupdateprobs16); \ DO_FIELD(DW29, Mvupdateprobs17 , params.Mvupdateprobs17); \ DO_FIELD(DW30, Mvupdateprobs18 , params.Mvupdateprobs18); \ DO_FIELD(DW30, Mvupdateprobs19 , params.Mvupdateprobs19); \ DO_FIELD(DW30, Mvupdateprobs110 , params.Mvupdateprobs110); \ DO_FIELD(DW30, Mvupdateprobs111 , params.Mvupdateprobs111); \ DO_FIELD(DW31, Mvupdateprobs112 , params.Mvupdateprobs112); \ DO_FIELD(DW31, Mvupdateprobs113 , params.Mvupdateprobs113); \ DO_FIELD(DW31, Mvupdateprobs114 , params.Mvupdateprobs114); \ DO_FIELD(DW31, Mvupdateprobs115 , params.Mvupdateprobs115); \ DO_FIELD(DW32, Mvupdateprobs116 , params.Mvupdateprobs116); \ DO_FIELD(DW32, Mvupdateprobs117 , params.Mvupdateprobs117); \ DO_FIELD(DW32, Mvupdateprobs118 , params.Mvupdateprobs118); \ DO_FIELD(DW33, Reflfdelta0ForIntraFrame , params.Reflfdelta0ForIntraFrame); \ DO_FIELD(DW33, Reflfdelta1ForLastFrame , params.Reflfdelta1ForLastFrame); \ DO_FIELD(DW33, Reflfdelta2ForGoldenFrame , params.Reflfdelta2ForGoldenFrame); \ DO_FIELD(DW33, Reflfdelta3ForAltrefFrame , params.Reflfdelta3ForAltrefFrame); \ DO_FIELD(DW34, Modelfdelta0ForBPredMode , params.Modelfdelta0ForBPredMode); \ DO_FIELD(DW34, Modelfdelta1ForZeromvMode , params.Modelfdelta1ForZeromvMode); \ DO_FIELD(DW34, Modelfdelta2ForNearestNearAndNewMode , params.Modelfdelta2ForNearestNearAndNewMode); \ DO_FIELD(DW34, Modelfdelta3ForSplitmvMode , params.Modelfdelta3ForSplitmvMode); cmd.DW4.dec.QuantizerValue0Blocktype0Y1Dc = params.QuantizerValue0Blocktype0Y1Dc; cmd.DW4.dec.QuantizerValue0Blocktype1Y1Ac = params.QuantizerValue0Blocktype1Y1Ac; cmd.DW5.dec.QuantizerValue0Blocktype2Uvdc = params.QuantizerValue0Blocktype2Uvdc; cmd.DW5.dec.QuantizerValue0Blocktype3Uvac = params.QuantizerValue0Blocktype3Uvac; cmd.DW6.dec.QuantizerValue0Blocktype4Y2Dc = params.QuantizerValue0Blocktype4Y2Dc; cmd.DW6.dec.QuantizerValue0Blocktype5Y2Ac = params.QuantizerValue0Blocktype5Y2Ac; cmd.DW7.dec.QuantizerValue1Blocktype0Y1Dc = params.QuantizerValue1Blocktype0Y1Dc; cmd.DW7.dec.QuantizerValue1Blocktype1Y1Ac = params.QuantizerValue1Blocktype1Y1Ac; MHW_RESOURCE_PARAMS resourceParams; MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; resourceParams.HwCommandType = MOS_MFX_VP8_PIC; resourceParams.presResource = params.presCoefProbBuffer; resourceParams.dwOffset = params.dwCoefProbTableOffset; resourceParams.pdwCmd = cmd.CoeffprobabilityStreaminBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 16; resourceParams.bIsWritable = false; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); if (params.SegmentEnableFlag) { resourceParams.presResource = params.presSegmentationIdStreamBuffer; resourceParams.dwOffset = 0; resourceParams.pdwCmd = cmd.SegmentationIdStreamBaseAddress.DW0_1.Value; resourceParams.dwLocationInCmd = 35; resourceParams.bIsWritable = true; MHW_MI_CHK_STATUS(AddResourceToCmd( this->m_osItf, this->m_currentCmdBuf, &resourceParams)); } #include "mhw_hwcmd_process_cmdfields.h" } _MHW_SETCMD_OVERRIDE_DECL(MFD_VP8_BSD_OBJECT) { _MHW_SETCMD_CALLBASE(MFD_VP8_BSD_OBJECT); #define DO_FIELDS() \ DO_FIELD(DW1, CodedNumOfCoeffTokenPartitions, params.CodedNumOfCoeffTokenPartitions); \ DO_FIELD(DW1, Partition0CpbacEntropyRange, params.Partition0CpbacEntropyRange); \ DO_FIELD(DW1, Partition0CpbacEntropyCount, params.Partition0CpbacEntropyCount); \ DO_FIELD(DW2, Partition0CpbacEntropyValue, params.Partition0CpbacEntropyValue); \ DO_FIELD(DW3, IndirectPartition0DataLength, params.IndirectPartition0DataLength); \ DO_FIELD(DW4, IndirectPartition0DataStartOffset, params.IndirectPartition0DataStartOffset); \ DO_FIELD(DW5, IndirectPartition1DataLength, params.IndirectPartition1DataLength); \ DO_FIELD(DW6, IndirectPartition1DataStartOffset, params.IndirectPartition1DataStartOffset); \ DO_FIELD(DW7, IndirectPartition2DataLength, params.IndirectPartition2DataLength); \ DO_FIELD(DW8, IndirectPartition2DataStartOffset, params.IndirectPartition2DataStartOffset); \ DO_FIELD(DW9, IndirectPartition3DataLength, params.IndirectPartition3DataLength); \ DO_FIELD(DW10, IndirectPartition3DataStartOffset, params.IndirectPartition3DataStartOffset); \ DO_FIELD(DW11, IndirectPartition4DataLength, params.IndirectPartition4DataLength); \ DO_FIELD(DW12, IndirectPartition4DataStartOffset, params.IndirectPartition4DataStartOffset); \ DO_FIELD(DW13, IndirectPartition5DataLength, params.IndirectPartition5DataLength); \ DO_FIELD(DW14, IndirectPartition5DataStartOffset, params.IndirectPartition5DataStartOffset); \ DO_FIELD(DW15, IndirectPartition6DataLength, params.IndirectPartition6DataLength); \ DO_FIELD(DW16, IndirectPartition6DataStartOffset, params.IndirectPartition6DataStartOffset); \ DO_FIELD(DW17, IndirectPartition7DataLength, params.IndirectPartition7DataLength); \ DO_FIELD(DW18, IndirectPartition7DataStartOffset, params.IndirectPartition7DataStartOffset); \ DO_FIELD(DW19, IndirectPartition8DataLength, params.IndirectPartition8DataLength); \ DO_FIELD(DW20, IndirectPartition8DataStartOffset, params.IndirectPartition8DataStartOffset); \ #include "mhw_hwcmd_process_cmdfields.h" } MEDIA_CLASS_DEFINE_END(mhw__vdbox__mfx__Impl) }; }//namespace mfx }//namespace vdbox }//namespace mhw #endif // __MHW_VDBOX_MFX_IMPL_H__