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