1 /* 2 # Copyright (c) 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_lpm.h 24 //! \brief MHW VDBOX MFX interface common base for Xe2_LPM 25 //! \details 26 //! 27 28 #ifndef __MHW_VDBOX_MFX_IMPL_XE2_LPM_H__ 29 #define __MHW_VDBOX_MFX_IMPL_XE2_LPM_H__ 30 31 #include "mhw_vdbox_mfx_impl_xe2_lpm_base.h" 32 #include "mhw_vdbox_mfx_hwcmd_xe2_lpm.h" 33 34 namespace mhw 35 { 36 namespace vdbox 37 { 38 namespace mfx 39 { 40 namespace xe2_lpm_base 41 { 42 namespace xe2_lpm 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, Reserved117, params.vdaqmEnable) 60 61 #include "mhw_hwcmd_process_cmdfields.h" 62 } 63 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT)64 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_MODE_SELECT) 65 { 66 _MHW_SETCMD_CALLBASE(MFX_PIPE_MODE_SELECT); 67 68 #define DO_FIELDS() \ 69 DO_FIELD(DW4, SliceSizeStreamout32bit, params.sliceSizeStreamout32bit); 70 71 #include "mhw_hwcmd_process_cmdfields.h" 72 } 73 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_BUF_ADDR_STATE)74 _MHW_SETCMD_OVERRIDE_DECL(MFX_PIPE_BUF_ADDR_STATE) 75 { 76 _MHW_SETCMD_CALLBASE(MFX_PIPE_BUF_ADDR_STATE); 77 78 MHW_RESOURCE_PARAMS resourceParams; 79 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 80 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 81 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR; 82 83 if (params.psPreDeblockSurface != nullptr) 84 { 85 InitMocsParams(resourceParams, &cmd.DW3.Value, 1, 6); 86 cmd.DW3.PreDeblockingMemoryObjectControlState = m_preDeblockingMemoryCtrl.Gen12_7.Index; 87 88 resourceParams.presResource = &(params.psPreDeblockSurface->OsResource); 89 resourceParams.dwOffset = params.psPreDeblockSurface->dwOffset; 90 resourceParams.pdwCmd = &(cmd.DW1.Value); 91 resourceParams.dwLocationInCmd = 1; 92 resourceParams.bIsWritable = true; 93 94 MHW_MI_CHK_STATUS(AddResourceToCmd( 95 this->m_osItf, 96 this->m_currentCmdBuf, 97 &resourceParams)); 98 } 99 100 if (params.psPostDeblockSurface != nullptr) 101 { 102 InitMocsParams(resourceParams, &cmd.DW6.Value, 1, 6); 103 cmd.DW6.PostDeblockingMemoryObjectControlState = m_postDeblockingMemoryCtrl.Gen12_7.Index; 104 105 resourceParams.presResource = &(params.psPostDeblockSurface->OsResource); 106 resourceParams.dwOffset = params.psPostDeblockSurface->dwOffset; 107 resourceParams.pdwCmd = &(cmd.DW4.Value); 108 resourceParams.dwLocationInCmd = 4; 109 resourceParams.bIsWritable = true; 110 111 MHW_MI_CHK_STATUS(AddResourceToCmd( 112 this->m_osItf, 113 this->m_currentCmdBuf, 114 &resourceParams)); 115 } 116 117 if (params.psRawSurface != nullptr) 118 { 119 if (!params.decodeInUse) 120 { 121 cmd.DW9.OriginalUncompressedPictureSourceMemoryObjectControlState = 122 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value; 123 } 124 else 125 { 126 InitMocsParams(resourceParams, &cmd.DW9.Value, 1, 6); 127 cmd.DW9.OriginalUncompressedPictureSourceMemoryObjectControlState = m_OriginalUncompressedPictureSourceMemoryCtrl.Gen12_7.Index; 128 } 129 130 resourceParams.presResource = ¶ms.psRawSurface->OsResource; 131 resourceParams.dwOffset = params.psRawSurface->dwOffset; 132 resourceParams.pdwCmd = &(cmd.DW7.Value); 133 resourceParams.dwLocationInCmd = 7; 134 resourceParams.bIsWritable = false; 135 136 MHW_MI_CHK_STATUS(AddResourceToCmd( 137 this->m_osItf, 138 this->m_currentCmdBuf, 139 &resourceParams)); 140 } 141 142 if (params.presStreamOutBuffer != nullptr) 143 { 144 InitMocsParams(resourceParams, &cmd.DW12.Value, 1, 6); 145 cmd.DW12.StreamoutDataDestinationMemoryObjectControlState = m_streamoutDataDestinationMemoryCtrl.Gen12_7.Index; 146 147 resourceParams.presResource = params.presStreamOutBuffer; 148 resourceParams.dwOffset = 0; 149 resourceParams.pdwCmd = &(cmd.DW10.Value); 150 resourceParams.dwLocationInCmd = 10; 151 resourceParams.bIsWritable = true; 152 153 MHW_MI_CHK_STATUS(AddResourceToCmd( 154 this->m_osItf, 155 this->m_currentCmdBuf, 156 &resourceParams)); 157 158 if (!params.decodeInUse) 159 { 160 cmd.DW54.MacroblockStatusBufferMemoryObjectControlState = 161 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value; 162 163 resourceParams.presResource = params.presStreamOutBuffer; 164 resourceParams.dwOffset = 0; 165 resourceParams.pdwCmd = &(cmd.DW52.Value); 166 resourceParams.dwLocationInCmd = 52; 167 resourceParams.bIsWritable = true; 168 169 MHW_MI_CHK_STATUS(AddResourceToCmd( 170 this->m_osItf, 171 this->m_currentCmdBuf, 172 &resourceParams)); 173 } 174 } 175 176 if (m_intraRowstoreCache.enabled) 177 { 178 cmd.DW15.IntraRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 179 cmd.DW13.IntraRowStoreScratchBufferBaseAddress = m_intraRowstoreCache.dwAddress; 180 } 181 else if (params.presMfdIntraRowStoreScratchBuffer != nullptr) 182 { 183 InitMocsParams(resourceParams, &cmd.DW15.Value, 1, 6); 184 cmd.DW15.IntraRowStoreScratchBufferMemoryObjectControlState = m_intraRowStoreScratchBufferMemoryCtrl.Gen12_7.Index; 185 186 resourceParams.presResource = params.presMfdIntraRowStoreScratchBuffer; 187 resourceParams.dwOffset = 0; 188 resourceParams.pdwCmd = &(cmd.DW13.Value); 189 resourceParams.dwLocationInCmd = 13; 190 resourceParams.bIsWritable = true; 191 192 MHW_MI_CHK_STATUS(AddResourceToCmd( 193 this->m_osItf, 194 this->m_currentCmdBuf, 195 &resourceParams)); 196 } 197 198 if (m_deblockingFilterRowstoreCache.enabled) 199 { 200 cmd.DW18.DeblockingFilterRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE; 201 cmd.DW16.DeblockingFilterRowStoreScratchBaseAddress = m_deblockingFilterRowstoreCache.dwAddress; 202 } 203 else if (params.presMfdDeblockingFilterRowStoreScratchBuffer != nullptr) 204 { 205 InitMocsParams(resourceParams, &cmd.DW18.Value, 1, 6); 206 cmd.DW18.DeblockingFilterRowStoreScratchMemoryObjectControlState = m_deblockingFilterRowStoreScratchMemoryCtrl.Gen12_7.Index; 207 208 resourceParams.presResource = params.presMfdDeblockingFilterRowStoreScratchBuffer; 209 resourceParams.dwOffset = 0; 210 resourceParams.pdwCmd = &(cmd.DW16.Value); 211 resourceParams.dwLocationInCmd = 16; 212 resourceParams.bIsWritable = true; 213 214 MHW_MI_CHK_STATUS(AddResourceToCmd( 215 this->m_osItf, 216 this->m_currentCmdBuf, 217 &resourceParams)); 218 } 219 220 PMOS_RESOURCE *references = const_cast<PMOS_RESOURCE*>(params.presReferences); 221 uint32_t numRefIdx = CODEC_MAX_NUM_REF_FRAME; 222 uint32_t step = 1; 223 224 // When one on one ref idx mapping is enabled, add active vdenc references into cmd 225 // instead of full ref list in picture paramters 226 if (params.oneOnOneMapping) 227 { 228 references = const_cast<PMOS_RESOURCE*>(params.presVdencReferences); 229 step = 2; 230 } 231 232 resourceParams.mocsParams.mocsTableIndex = nullptr; 233 for (uint32_t i = 0; i < numRefIdx; i++) 234 { 235 if (references[i] != nullptr) 236 { 237 MOS_SURFACE details; 238 MOS_ZeroMemory(&details, sizeof(details)); 239 details.Format = Format_Invalid; 240 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, references[i], &details)); 241 242 MOS_MEMCOMP_STATE mmcMode = (params.PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ? 243 params.PostDeblockSurfMmcState : params.PreDeblockSurfMmcState; 244 if (mmcMode == MOS_MEMCOMP_RC || mmcMode == MOS_MEMCOMP_MC) 245 { 246 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2 * step)) | ((mmcMode == MOS_MEMCOMP_RC) << (i * 2 * step + 1)); 247 } 248 249 resourceParams.presResource = references[i]; 250 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset; 251 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i * step].DW0_1.Value[0]); 252 resourceParams.dwLocationInCmd = (i * 2 * step) + 19; // * 2 to account for QW rather than DW 253 resourceParams.bIsWritable = false; 254 255 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd; 256 257 MHW_MI_CHK_STATUS(AddResourceToCmd( 258 this->m_osItf, 259 this->m_currentCmdBuf, 260 &resourceParams)); 261 } 262 } 263 InitMocsParams(resourceParams, &cmd.DW51.Value, 1, 6); 264 // There is only one control DW51 for all references 265 if (params.decodeInUse) 266 { 267 cmd.DW51.ReferncePictureMemoryObjectControlState = m_referncePictureMemoryObjectControlStateCtrlDecode.Gen12_7.Index << 1; 268 } 269 else 270 { 271 cmd.DW51.ReferncePictureMemoryObjectControlState = m_referncePictureMemoryObjectControlStateCtrlEncode.Gen12_7.Index << 1; 272 } 273 274 // Reset dwSharedMocsOffset 275 resourceParams.dwSharedMocsOffset = 0; 276 if (params.presMacroblockIldbStreamOutBuffer1 != nullptr) 277 { 278 InitMocsParams(resourceParams, &cmd.DW57.Value, 1, 6); 279 cmd.DW57.MacroblockIldbStreamoutBufferMemoryObjectControlState = m_macroblockIldbStreamoutBufferCtrl.Gen12_7.Index; 280 281 resourceParams.presResource = params.presMacroblockIldbStreamOutBuffer1; 282 resourceParams.dwOffset = 0; 283 resourceParams.pdwCmd = &(cmd.DW55.Value); 284 resourceParams.dwLocationInCmd = 55; 285 resourceParams.bIsWritable = true; 286 287 MHW_MI_CHK_STATUS(AddResourceToCmd( 288 this->m_osItf, 289 this->m_currentCmdBuf, 290 &resourceParams)); 291 } 292 293 if (params.presMacroblockIldbStreamOutBuffer2 != nullptr) 294 { 295 InitMocsParams(resourceParams, &cmd.DW60.Value, 1, 6); 296 cmd.DW60.SecondMacroblockIldbStreamoutBufferMemoryObjectControlState = m_secondMacroblockIldbStreamoutBufferCtrl.Gen12_7.Index; 297 298 resourceParams.presResource = params.presMacroblockIldbStreamOutBuffer2; 299 resourceParams.dwOffset = 0; 300 resourceParams.pdwCmd = &(cmd.DW58.Value); 301 resourceParams.dwLocationInCmd = 58; 302 resourceParams.bIsWritable = true; 303 304 MHW_MI_CHK_STATUS(AddResourceToCmd( 305 this->m_osItf, 306 this->m_currentCmdBuf, 307 &resourceParams)); 308 } 309 310 if (params.presSliceSizeStreamOutBuffer != nullptr) 311 { 312 InitMocsParams(resourceParams, &cmd.DW67.Value, 1, 6); 313 cmd.DW67.SlicesizeStreamoutDataDestinationMemoryObjectControlState = m_slicesizeStreamoutDataDestinationCtrl.Gen12_7.Index; 314 315 cmd.DW67.SlicesizeStreamoutDataDestinationMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED; 316 317 resourceParams.presResource = params.presSliceSizeStreamOutBuffer; 318 resourceParams.dwOffset = 0; 319 resourceParams.pdwCmd = &(cmd.DW65.Value); 320 resourceParams.dwLocationInCmd = 65; 321 resourceParams.bIsWritable = true; 322 323 MHW_MI_CHK_STATUS(AddResourceToCmd( 324 this->m_osItf, 325 this->m_currentCmdBuf, 326 &resourceParams)); 327 } 328 329 return MOS_STATUS_SUCCESS; 330 } 331 MEDIA_CLASS_DEFINE_END(mhw__vdbox__mfx__xe2_lpm_base__xe2_lpm__Impl) 332 }; 333 } // namespace xe2_lpm 334 } // namespace xe2_lpm_base 335 } // namespace mfx 336 } // namespace vdbox 337 } // namespace mhw 338 339 #endif // __MHW_VDBOX_MFX_IMPL_XE2_LPM_H__ 340