1 /* 2 * Copyright (c) 2021-2024, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file mhw_vdbox_mfx_impl_xe2_hpm.h 24 //! \brief MHW VDBOX MFX interface common base for Xe2_HPM 25 //! \details 26 //! 27 28 #ifndef __MHW_VDBOX_MFX_IMPL_XE2_HPM_H__ 29 #define __MHW_VDBOX_MFX_IMPL_XE2_HPM_H__ 30 31 #include "mhw_vdbox_mfx_impl_xe_lpm_plus_base.h" 32 #include "mhw_vdbox_mfx_hwcmd_xe2_hpm.h" 33 34 namespace mhw 35 { 36 namespace vdbox 37 { 38 namespace mfx 39 { 40 namespace xe_lpm_plus_base 41 { 42 namespace v1 43 { 44 class Impl : public BaseImpl<Cmd> 45 { 46 protected: 47 using cmd_t = Cmd; 48 using base_t = BaseImpl<cmd_t>; 49 50 public: Impl(PMOS_INTERFACE osItf,MhwCpInterface * cpItf)51 Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : base_t(osItf, cpItf){}; 52 53 protected: _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE)54 _MHW_SETCMD_OVERRIDE_DECL(MFX_AVC_IMG_STATE) 55 { 56 _MHW_SETCMD_CALLBASE(MFX_AVC_IMG_STATE); 57 58 #define DO_FIELDS() \ 59 DO_FIELD(DW3, VdaqmEnable, params.vdaqmEnable) 60 61 #include "mhw_hwcmd_process_cmdfields.h" 62 } 63 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_BUF_ADDR_STATE)64 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_BUF_ADDR_STATE) 65 { 66 _MHW_SETCMD_CALLBASE(MFX_PIPE_BUF_ADDR_STATE); 67 68 MHW_RESOURCE_PARAMS resourceParams; 69 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 70 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 71 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR; 72 73 if (params.psPreDeblockSurface != nullptr) 74 { 75 InitMocsParams(resourceParams, &cmd.DW3.Value, 1, 6); 76 cmd.DW3.PreDeblockingMemoryObjectControlState = m_preDeblockingMemoryCtrl.Gen12_7.Index; 77 cmd.DW3.PreDeblockingCompressionAccumulationBufferEnable = 78 (params.PreDeblockSurfMmcState == MOS_MEMCOMP_RC || params.PreDeblockSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0; 79 80 resourceParams.presResource = &(params.psPreDeblockSurface->OsResource); 81 resourceParams.dwOffset = params.psPreDeblockSurface->dwOffset; 82 resourceParams.pdwCmd = &(cmd.DW1.Value); 83 resourceParams.dwLocationInCmd = 1; 84 resourceParams.bIsWritable = true; 85 86 MHW_MI_CHK_STATUS(AddResourceToCmd( 87 this->m_osItf, 88 this->m_currentCmdBuf, 89 &resourceParams)); 90 } 91 92 if (params.psPostDeblockSurface != nullptr) 93 { 94 InitMocsParams(resourceParams, &cmd.DW6.Value, 1, 6); 95 cmd.DW6.PostDeblockingMemoryObjectControlState = m_postDeblockingMemoryCtrl.Gen12_7.Index; 96 cmd.DW6.PostDeblockingCompressionAccumulationBufferEnable = 97 (params.PostDeblockSurfMmcState == MOS_MEMCOMP_RC || params.PostDeblockSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0; 98 99 resourceParams.presResource = &(params.psPostDeblockSurface->OsResource); 100 resourceParams.dwOffset = params.psPostDeblockSurface->dwOffset; 101 resourceParams.pdwCmd = &(cmd.DW4.Value); 102 resourceParams.dwLocationInCmd = 4; 103 resourceParams.bIsWritable = true; 104 105 MHW_MI_CHK_STATUS(AddResourceToCmd( 106 this->m_osItf, 107 this->m_currentCmdBuf, 108 &resourceParams)); 109 } 110 111 if (params.psRawSurface != nullptr) 112 { 113 if (!params.decodeInUse) 114 { 115 cmd.DW9.OriginalUncompressedPictureSourceMemoryObjectControlState = 116 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value; 117 cmd.DW9.OriginalUncompressedPictureCompressionAccumulationBufferEnable = 118 (params.RawSurfMmcState == MOS_MEMCOMP_RC || params.RawSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0; 119 } 120 else 121 { 122 InitMocsParams(resourceParams, &cmd.DW9.Value, 1, 6); 123 } 124 125 resourceParams.presResource = ¶ms.psRawSurface->OsResource; 126 resourceParams.dwOffset = params.psRawSurface->dwOffset; 127 resourceParams.pdwCmd = &(cmd.DW7.Value); 128 resourceParams.dwLocationInCmd = 7; 129 resourceParams.bIsWritable = false; 130 131 MHW_MI_CHK_STATUS(AddResourceToCmd( 132 this->m_osItf, 133 this->m_currentCmdBuf, 134 &resourceParams)); 135 } 136 137 if (params.presStreamOutBuffer != nullptr) 138 { 139 InitMocsParams(resourceParams, &cmd.DW12.Value, 1, 6); 140 cmd.DW12.StreamoutDataDestinationMemoryObjectControlState = m_streamoutDataDestinationMemoryCtrl.Gen12_7.Index; 141 142 resourceParams.presResource = params.presStreamOutBuffer; 143 resourceParams.dwOffset = 0; 144 resourceParams.pdwCmd = &(cmd.DW10.Value); 145 resourceParams.dwLocationInCmd = 10; 146 resourceParams.bIsWritable = true; 147 148 MHW_MI_CHK_STATUS(AddResourceToCmd( 149 this->m_osItf, 150 this->m_currentCmdBuf, 151 &resourceParams)); 152 153 if (!params.decodeInUse) 154 { 155 cmd.DW54.MacroblockStatusBufferMemoryObjectControlState = 156 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value; 157 158 resourceParams.presResource = params.presStreamOutBuffer; 159 resourceParams.dwOffset = 0; 160 resourceParams.pdwCmd = &(cmd.DW52.Value); 161 resourceParams.dwLocationInCmd = 52; 162 resourceParams.bIsWritable = true; 163 164 MHW_MI_CHK_STATUS(AddResourceToCmd( 165 this->m_osItf, 166 this->m_currentCmdBuf, 167 &resourceParams)); 168 } 169 } 170 171 if (m_intraRowstoreCache.enabled) 172 { 173 cmd.DW15.IntraRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 174 cmd.DW13.IntraRowStoreScratchBufferBaseAddress = m_intraRowstoreCache.dwAddress; 175 } 176 else if (params.presMfdIntraRowStoreScratchBuffer != nullptr) 177 { 178 InitMocsParams(resourceParams, &cmd.DW15.Value, 1, 6); 179 cmd.DW15.IntraRowStoreScratchBufferCompressionAccumulationBufferEnable = 0; 180 181 resourceParams.presResource = params.presMfdIntraRowStoreScratchBuffer; 182 resourceParams.dwOffset = 0; 183 resourceParams.pdwCmd = &(cmd.DW13.Value); 184 resourceParams.dwLocationInCmd = 13; 185 resourceParams.bIsWritable = true; 186 187 MHW_MI_CHK_STATUS(AddResourceToCmd( 188 this->m_osItf, 189 this->m_currentCmdBuf, 190 &resourceParams)); 191 } 192 193 if (m_deblockingFilterRowstoreCache.enabled) 194 { 195 cmd.DW18.DeblockingFilterRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 196 cmd.DW16.DeblockingFilterRowStoreScratchBaseAddress = m_deblockingFilterRowstoreCache.dwAddress; 197 } 198 else if (params.presMfdDeblockingFilterRowStoreScratchBuffer != nullptr) 199 { 200 InitMocsParams(resourceParams, &cmd.DW18.Value, 1, 6); 201 cmd.DW18.DeblockingFilterRowStoreScratchCompressionAccumulationBufferEnable = 0; 202 203 resourceParams.presResource = params.presMfdDeblockingFilterRowStoreScratchBuffer; 204 resourceParams.dwOffset = 0; 205 resourceParams.pdwCmd = &(cmd.DW16.Value); 206 resourceParams.dwLocationInCmd = 16; 207 resourceParams.bIsWritable = true; 208 209 MHW_MI_CHK_STATUS(AddResourceToCmd( 210 this->m_osItf, 211 this->m_currentCmdBuf, 212 &resourceParams)); 213 } 214 215 PMOS_RESOURCE *references = const_cast<PMOS_RESOURCE*>(params.presReferences); 216 uint32_t numRefIdx = CODEC_MAX_NUM_REF_FRAME; 217 uint32_t step = 1; 218 219 // When one on one ref idx mapping is enabled, add active vdenc references into cmd 220 // instead of full ref list in picture paramters 221 if (params.oneOnOneMapping) 222 { 223 references = const_cast<PMOS_RESOURCE*>(params.presVdencReferences); 224 step = 2; 225 } 226 227 for (uint32_t i = 0; i < numRefIdx; i++) 228 { 229 if (references[i] != nullptr) 230 { 231 MOS_SURFACE details; 232 MOS_ZeroMemory(&details, sizeof(details)); 233 details.Format = Format_Invalid; 234 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, references[i], &details)); 235 236 MOS_MEMCOMP_STATE mmcMode = (params.PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ? 237 params.PostDeblockSurfMmcState : params.PreDeblockSurfMmcState; 238 if (mmcMode == MOS_MEMCOMP_RC || mmcMode == MOS_MEMCOMP_MC) 239 { 240 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2 * step)) | ((mmcMode == MOS_MEMCOMP_RC) << (i * 2 * step + 1)); 241 } 242 243 resourceParams.presResource = references[i]; 244 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset; 245 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i * step].DW0_1.Value[0]); 246 resourceParams.dwLocationInCmd = (i * 2 * step) + 19; // * 2 to account for QW rather than DW 247 resourceParams.bIsWritable = false; 248 249 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd; 250 251 MHW_MI_CHK_STATUS(AddResourceToCmd( 252 this->m_osItf, 253 this->m_currentCmdBuf, 254 &resourceParams)); 255 } 256 } 257 InitMocsParams(resourceParams, &cmd.DW51.Value, 1, 6); 258 // There is only one control DW51 for all references 259 cmd.DW51.ReferncePictureMemoryObjectControlState = m_referncePictureMemoryObjectControlStateCtrl.Gen12_7.Index; 260 261 // Reset dwSharedMocsOffset 262 resourceParams.dwSharedMocsOffset = 0; 263 if (params.presMacroblockIldbStreamOutBuffer1 != nullptr) 264 { 265 InitMocsParams(resourceParams, &cmd.DW57.Value, 1, 6); 266 cmd.DW57.MacroblockIldbStreamoutBufferCompressionAccumulationBufferEnable = 0; 267 268 resourceParams.presResource = params.presMacroblockIldbStreamOutBuffer1; 269 resourceParams.dwOffset = 0; 270 resourceParams.pdwCmd = &(cmd.DW55.Value); 271 resourceParams.dwLocationInCmd = 55; 272 resourceParams.bIsWritable = true; 273 274 MHW_MI_CHK_STATUS(AddResourceToCmd( 275 this->m_osItf, 276 this->m_currentCmdBuf, 277 &resourceParams)); 278 } 279 280 if (params.presMacroblockIldbStreamOutBuffer2 != nullptr) 281 { 282 InitMocsParams(resourceParams, &cmd.DW60.Value, 1, 6); 283 cmd.DW60.SecondMacroblockIldbStreamoutBufferCompressionAccumulationBufferEnable = 0; 284 285 resourceParams.presResource = params.presMacroblockIldbStreamOutBuffer2; 286 resourceParams.dwOffset = 0; 287 resourceParams.pdwCmd = &(cmd.DW58.Value); 288 resourceParams.dwLocationInCmd = 58; 289 resourceParams.bIsWritable = true; 290 291 MHW_MI_CHK_STATUS(AddResourceToCmd( 292 this->m_osItf, 293 this->m_currentCmdBuf, 294 &resourceParams)); 295 } 296 297 if (params.presSliceSizeStreamOutBuffer != nullptr) 298 { 299 InitMocsParams(resourceParams, &cmd.DW67.Value, 1, 6); 300 cmd.DW67.SlicesizeStreamoutDataDestinationMemoryObjectControlState = m_slicesizeStreamoutDataDestinationCtrl.Gen12_7.Index; 301 302 cmd.DW67.SlicesizeStreamoutDataDestinationMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED; 303 304 resourceParams.presResource = params.presSliceSizeStreamOutBuffer; 305 resourceParams.dwOffset = 0; 306 resourceParams.pdwCmd = &(cmd.DW65.Value); 307 resourceParams.dwLocationInCmd = 65; 308 resourceParams.bIsWritable = true; 309 310 MHW_MI_CHK_STATUS(AddResourceToCmd( 311 this->m_osItf, 312 this->m_currentCmdBuf, 313 &resourceParams)); 314 } 315 316 return MOS_STATUS_SUCCESS; 317 } 318 MEDIA_CLASS_DEFINE_END(mhw__vdbox__mfx__xe_lpm_plus_base__v1__Impl) 319 }; 320 } // namespace v1 321 } // namespace xe_lpm_plus_base 322 } // namespace mfx 323 } // namespace vdbox 324 } // namespace mhw 325 326 #endif // __MHW_VDBOX_MFX_IMPL_XE2_HPM_H__ 327