1 /*===================== begin_copyright_notice ==================================
2 
3 * Copyright (c) 2024, 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     media_interfaces_bmg.cpp
26 
27 //! \brief    Helps with BMG factory creation.
28 //!
29 
30 #include "media_interfaces_bmg.h"
31 
32 #include "codechal_common.h"
33 #include "codechal_debug.h"
34 
35 #include "vp_pipeline_adapter_xe2_hpm.h"
36 #include "vp_platform_interface_xe2_hpm.h"
37 #include "vp_kernel_config_xe2_hpg.h"
38 #include "mhw_mi_xe_lpm_plus_base_next_impl.h"
39 #include "mhw_sfc_xe2_hpm_next_impl.h"
40 #include "mhw_vebox_xe2_hpm_next_impl.h"
41 #include "mhw_render_xe2_hpg_next_impl.h"
42 #include "mhw_blt_xe2_hpm_impl.h"
43 
44 //use vdenc from Xe_LPM_plus instead of Xe2_HPM
45 #ifdef _MEDIA_RESERVED
46 #include "mhw_vdbox_vdenc_impl_xe_lpm_plus.h"
47 #endif
48 
49 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
50 #include "igvpkrn_xe2_hpg.h"
51 #include "igvpkrn_xe2_hpg_cmfcpatch.h"
52 #include "igvpkrn_l0_xe2_hpg.h"
53 #endif
54 
55 using namespace mhw::vdbox::avp::xe_lpm_plus_base;
56 using namespace mhw::vdbox::huc::xe_lpm_plus_base;
57 using namespace mhw::vdbox::mfx::xe_lpm_plus_base;
58 
59 extern template class MediaFactory<uint32_t, CodechalDeviceNext>;
60 extern template class MediaFactory<uint32_t, VphalDevice>;
61 extern template class MediaFactory<uint32_t, RenderHalDevice>;
62 extern template class MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>;
63 
64 // Swith to use new media factory template
65 extern template class MediaFactory<uint32_t, MhwInterfacesNext>;
66 extern template class MediaFactory<uint32_t, McpyDeviceNext>;
67 
68 static bool bmgRegisteredVphal =
69     MediaFactory<uint32_t, VphalDevice>::
70         Register<VphalInterfacesXe2_Hpm>((uint32_t)IGFX_BMG);
71 
Initialize(PMOS_INTERFACE osInterface,bool bInitVphalState,MOS_STATUS * eStatus,bool clearViewMode)72 MOS_STATUS VphalInterfacesXe2_Hpm::Initialize(
73     PMOS_INTERFACE osInterface,
74     bool           bInitVphalState,
75     MOS_STATUS *   eStatus,
76     bool           clearViewMode)
77 {
78     vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfaceXe2_Hpm, osInterface);
79     if (nullptr == vpPlatformInterface)
80     {
81         *eStatus = MOS_STATUS_NULL_POINTER;
82         return *eStatus;
83     }
84 
85     InitPlatformKernelBinary(vpPlatformInterface);
86 
87     if (!bInitVphalState)
88     {
89         m_vpPipeline = MOS_New(vp::VpPipeline, osInterface);
90         if (nullptr == m_vpPipeline)
91         {
92             MOS_Delete(vpPlatformInterface);
93             MOS_OS_CHK_NULL_RETURN(m_vpPipeline);
94         }
95         m_vpPlatformInterface = vpPlatformInterface;
96         *eStatus = MOS_STATUS_SUCCESS;
97         return *eStatus;
98     }
99 
100     m_vpBase = MOS_New(
101         VpPipelineAdapterXe2_Hpm,
102         osInterface,
103         *vpPlatformInterface,
104         *eStatus);
105     if (nullptr == m_vpBase)
106     {
107         MOS_Delete(vpPlatformInterface);
108         *eStatus = MOS_STATUS_NULL_POINTER;
109         return *eStatus;
110     }
111     m_isNextEnabled = true;
112     return *eStatus;
113 }
114 
CreateVpPlatformInterface(PMOS_INTERFACE osInterface,MOS_STATUS * eStatus)115 MOS_STATUS VphalInterfacesXe2_Hpm::CreateVpPlatformInterface(
116     PMOS_INTERFACE osInterface,
117     MOS_STATUS *   eStatus)
118 {
119     vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfaceXe2_Hpm, osInterface);
120     if (nullptr == vpPlatformInterface)
121     {
122         *eStatus = MOS_STATUS_NULL_POINTER;
123     }
124     else
125     {
126         InitPlatformKernelBinary(vpPlatformInterface);
127 
128         m_vpPlatformInterface = vpPlatformInterface;
129         *eStatus              = MOS_STATUS_SUCCESS;
130     }
131     return *eStatus;
132 }
133 
InitPlatformKernelBinary(vp::VpPlatformInterface * & vpPlatformInterface)134 void VphalInterfacesXe2_Hpm::InitPlatformKernelBinary(
135     vp::VpPlatformInterface  *&vpPlatformInterface)
136 {
137     static vp::VpKernelConfigXe2_Hpg kernelConfig;
138     vpPlatformInterface->SetKernelConfig(&kernelConfig);
139 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
140     vpPlatformInterface->SetVpFCKernelBinary(
141                         IGVPKRN_XE2_HPG,
142                         IGVPKRN_XE2_HPG_SIZE,
143                         IGVPKRN_XE2_HPG_CMFCPATCH,
144                         IGVPKRN_XE2_HPG_CMFCPATCH_SIZE);
145     vpPlatformInterface->AddVpNativeAdvKernelEntryToList(IGVP3DLUT_GENERATION_XE2_HPG, IGVP3DLUT_GENERATION_XE2_HPG_SIZE, "hdr_3dlut_l0");
146 #endif
147 }
148 
149 static bool bmgRegisteredMhwNext =
150     MediaFactory<uint32_t, MhwInterfacesNext>::
151         Register<MhwInterfacesBmg_Next>((uint32_t)IGFX_BMG);
152 
Initialize(CreateParams params,PMOS_INTERFACE osInterface)153 MOS_STATUS MhwInterfacesBmg_Next::Initialize(
154     CreateParams   params,
155     PMOS_INTERFACE osInterface)
156 {
157     if (osInterface == nullptr)
158     {
159         MHW_ASSERTMESSAGE("The OS interface is not valid!");
160         return MOS_STATUS_INVALID_PARAMETER;
161     }
162     m_osInterface = osInterface;
163 
164     auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
165     if (gtSystemInfo == nullptr)
166     {
167         MHW_ASSERTMESSAGE("The OS interface is not valid!");
168         return MOS_STATUS_INVALID_PARAMETER;
169     }
170 
171     if ((params.m_isCp == false) && (params.Flags.m_value == 0))
172     {
173         MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
174         return MOS_STATUS_INVALID_PARAMETER;
175     }
176 
177     // MHW_CP and MHW_MI must always be created
178     MOS_STATUS status;
179     m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
180     MHW_MI_CHK_NULL(m_cpInterface);
181     auto ptr      = std::make_shared<mhw::mi::xe_lpm_plus_base_next::Impl>(osInterface);
182     m_miItf       = std::static_pointer_cast<mhw::mi::Itf>(ptr);
183     ptr->SetCpInterface(m_cpInterface, m_miItf);
184 
185     if (params.Flags.m_render)
186     {
187         auto renderPtr = std::make_shared<mhw::render::xe2_hpg_next::Impl>(osInterface);
188         m_renderItf    = std::static_pointer_cast<mhw::render::Itf>(renderPtr);
189     }
190     if (params.Flags.m_stateHeap)
191     {
192         m_stateHeapInterface =
193             MOS_New(StateHeap, osInterface, params.m_heapMode);
194     }
195     if (params.Flags.m_sfc)
196     {
197         auto sfcPtr    = std::make_shared<mhw::sfc::xe2_hpm_next::Impl>(osInterface);
198         m_sfcItf       = std::static_pointer_cast<mhw::sfc::Itf>(sfcPtr);
199     }
200     if (params.Flags.m_vebox)
201     {
202         auto veboxPtr    = std::make_shared<mhw::vebox::xe2_hpm_next::Impl>(osInterface);
203         m_veboxItf       = std::static_pointer_cast<mhw::vebox::Itf>(veboxPtr);
204     }
205 
206     if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
207     {
208         auto ptr = std::make_shared<mhw::vdbox::mfx::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
209         m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(ptr);
210     }
211     if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
212     {
213         m_hcpItf = std::make_shared<mhw::vdbox::hcp::xe_lpm_plus_base::v1::Impl>(osInterface);
214     }
215     if (params.Flags.m_vdboxAll)
216     {
217         auto ptr = std::make_shared<mhw::vdbox::avp::xe_lpm_plus_base::v1::Impl>(osInterface);
218         m_avpItf = std::static_pointer_cast<mhw::vdbox::avp::Itf>(ptr);
219     }
220     if (params.Flags.m_vdboxAll || params.Flags.m_huc)
221     {
222         auto ptr = std::make_shared<mhw::vdbox::huc::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
223         m_hucItf = std::static_pointer_cast<mhw::vdbox::huc::Itf>(ptr);
224     }
225     if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
226     {
227         auto ptr = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v1::Impl>(osInterface);
228         m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
229     }
230     if (params.Flags.m_blt)
231     {
232         auto bltptr = std::make_shared<mhw::blt::xe2_hpm::Impl>(osInterface);
233         m_bltItf = std::static_pointer_cast<mhw::blt::Itf>(bltptr);
234     }
235 
236     return MOS_STATUS_SUCCESS;
237 }
238 
239 //!
240 //! \brief    Destroys all created MHW interfaces
241 //! \details  If the HAL creation fails, this is used for cleanup
242 //!
Destroy()243 void MhwInterfacesBmg_Next::Destroy()
244 {
245     MhwInterfacesNext::Destroy();
246 }
247 
248 static bool bmgRegisteredCodecHal =
249     MediaFactory<uint32_t, CodechalDeviceNext>::
250         Register<CodechalInterfacesXe2_Hpm>((uint32_t)IGFX_BMG);
251 
Initialize(void * standardInfo,void * settings,MhwInterfacesNext * mhwInterfaces,PMOS_INTERFACE osInterface)252 MOS_STATUS CodechalInterfacesXe2_Hpm::Initialize(
253     void *         standardInfo,
254     void *         settings,
255     MhwInterfacesNext *mhwInterfaces,
256     PMOS_INTERFACE osInterface)
257 {
258     if (standardInfo == nullptr ||
259         mhwInterfaces == nullptr ||
260         osInterface == nullptr)
261     {
262         CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
263         return MOS_STATUS_INVALID_PARAMETER;
264     }
265 
266     // This part should be moved back to media_intefaces.cpp for softlet build
267     PCODECHAL_STANDARD_INFO info          = ((PCODECHAL_STANDARD_INFO)standardInfo);
268     CODECHAL_FUNCTION       CodecFunction = info->CodecFunction;
269 
270 #ifdef _MEDIA_RESERVED
271 #ifdef _VP9_ENCODE_VDENC_SUPPORTED  //use vdenc from Xe_LPM_plus instead of Xe2_HPM
272     if (mhwInterfaces != nullptr && info->Mode == CODECHAL_ENCODE_MODE_VP9)
273     {
274         auto ptr                      = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v0::Impl>(osInterface);
275         mhwInterfaces->m_vdencItf = std::dynamic_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
276         CODECHAL_PUBLIC_CHK_NULL_RETURN(mhwInterfaces->m_vdencItf);
277     }
278 #endif
279 #endif
280 
281     bool disableScalability = false;
282 #ifdef _MEDIA_RESERVED
283 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
284     if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
285         disableScalability = true;
286 #endif
287 #endif
288 
289     CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
290 
291     if (hwInterface == nullptr)
292     {
293         CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
294         return MOS_STATUS_NO_SPACE;
295     }
296     hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
297     hwInterface->pfnCreateDecodeMultiPipe  = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
298 
299 #if USE_CODECHAL_DEBUG_TOOL
300     CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
301     if (debugInterface == nullptr)
302     {
303         MOS_Delete(hwInterface);
304         CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
305         return MOS_STATUS_NO_SPACE;
306     }
307     if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
308     {
309         MOS_Delete(hwInterface);
310         MOS_Delete(debugInterface);
311         CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
312         return MOS_STATUS_INVALID_PARAMETER;
313     }
314 #else
315     CodechalDebugInterface *debugInterface = nullptr;
316 #endif  // USE_CODECHAL_DEBUG_TOOL
317 
318     auto release_func = [&]()
319     {
320         MOS_Delete(hwInterface);
321 #if USE_CODECHAL_DEBUG_TOOL
322         MOS_Delete(debugInterface);
323 #endif  // USE_CODECHAL_DEBUG_TOOL
324     };
325 
326     if (CodecHalIsDecode(CodecFunction))
327     {
328 #ifdef _MPEG2_DECODE_SUPPORTED
329         if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
330             info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
331         {
332             m_codechalDevice = MOS_New(DecodeMpeg2PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
333             if (m_codechalDevice == nullptr)
334             {
335                 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
336                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
337             }
338         }
339         else
340 #endif
341 #ifdef _VC1_DECODE_SUPPORTED
342         if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
343             info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
344         {
345             CODECHAL_PUBLIC_ASSERTMESSAGE("BMG doesn't support VC1!");
346         }
347         else
348 #endif
349 #ifdef _AVC_DECODE_SUPPORTED
350         if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
351         {
352             m_codechalDevice = MOS_New(DecodeAvcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
353 
354             if (m_codechalDevice == nullptr)
355             {
356                 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
357                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
358             }
359         }
360         else
361 #endif
362 #ifdef _JPEG_DECODE_SUPPORTED
363         if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
364         {
365             m_codechalDevice = MOS_New(DecodeJpegPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
366         }
367         else
368 #endif
369 #ifdef _VP8_DECODE_SUPPORTED
370         if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
371         {
372             m_codechalDevice = MOS_New(DecodeVp8PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
373         }
374         else
375 #endif
376 #ifdef _HEVC_DECODE_SUPPORTED
377         if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
378         {
379             m_codechalDevice = MOS_New(DecodeHevcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
380         }
381         else
382 #endif
383 #ifdef _VP9_DECODE_SUPPORTED
384             if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
385         {
386             m_codechalDevice = MOS_New(DecodeVp9PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
387         }
388         else
389 #endif
390 #ifdef _AV1_DECODE_SUPPORTED
391         if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
392         {
393             m_codechalDevice = MOS_New(DecodeAv1PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
394         }
395         else
396 #endif
397         {
398             CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
399             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
400         }
401 
402         if (m_codechalDevice == nullptr)
403         {
404             CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
405             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
406         }
407     }
408     else if (CodecHalIsEncode(CodecFunction))
409     {
410 #ifdef _MEDIA_RESERVED
411 #if defined (_AVC_ENCODE_VDENC_SUPPORTED)
412         if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
413         {
414             if (CodecHalUsesVdencEngine(info->CodecFunction))
415             {
416                 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
417                 if (m_codechalDevice == nullptr)
418                 {
419                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
420                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
421                 }
422                 return MOS_STATUS_SUCCESS;
423             }
424         }
425         else
426 #endif
427 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
428         if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
429         {
430             m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
431             if (m_codechalDevice == nullptr)
432             {
433                 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
434                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
435             }
436             return MOS_STATUS_SUCCESS;
437         }
438         else
439 #endif
440 #ifdef _JPEG_ENCODE_SUPPORTED
441         if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
442         {
443             m_codechalDevice = MOS_New(EncodeJpegPipelineAdapter, hwInterface, debugInterface);
444             if (m_codechalDevice == nullptr)
445             {
446                 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
447                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
448             }
449             return MOS_STATUS_SUCCESS;
450         }
451         else
452 #endif
453 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
454         if (info->Mode == codechalEncodeModeAv1)
455         {
456             if (CodecHalUsesVdencEngine(info->CodecFunction))
457             {
458                 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
459                 if (m_codechalDevice == nullptr)
460                 {
461                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
462                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
463                 }
464                 return MOS_STATUS_SUCCESS;
465             }
466             else
467             {
468                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
469             }
470         }
471         else
472 #endif
473 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
474         if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
475         {
476             if (CodecHalUsesVdencEngine(info->CodecFunction))
477             {
478                 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
479                 if (m_codechalDevice == nullptr)
480                 {
481                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
482                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
483                 }
484                 return MOS_STATUS_SUCCESS;
485             }
486         }
487         else
488 #endif
489 #endif
490         {
491             CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
492             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
493         }
494     }
495     else
496     {
497         CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
498         CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
499     }
500 
501     return MOS_STATUS_SUCCESS;
502 }
503 
504 static bool bmgRegisteredRenderHal =
505     MediaFactory<uint32_t, RenderHalDevice>::
506         Register<RenderHalInterfacesXe2_Hpg>((uint32_t)IGFX_BMG);
507 
Initialize()508 MOS_STATUS RenderHalInterfacesXe2_Hpg::Initialize()
509 {
510     m_renderhalDevice = MOS_New(XRenderHal);
511     if (m_renderhalDevice == nullptr)
512     {
513         MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
514         return MOS_STATUS_NO_SPACE;
515     }
516     return MOS_STATUS_SUCCESS;
517 }
518 
519 #define IP_VERSION_XE2_HPM 0x1301
520 static bool bmgRegisteredHwInfo =
521 MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::
522 Register<MediaInterfacesHwInfoDeviceXe2_Hpm>((uint32_t)IGFX_BMG);
523 
Initialize(PLATFORM platform)524 MOS_STATUS MediaInterfacesHwInfoDeviceXe2_Hpm::Initialize(PLATFORM platform)
525 {
526     m_hwInfo.SetDeviceInfo(IP_VERSION_XE2_HPM, platform.usRevId);
527     return MOS_STATUS_SUCCESS;
528 }
529 
530 static bool bmgRegisteredMcpy =
531 MediaFactory<uint32_t, McpyDeviceNext>::
532 Register<McpyDeviceXe2_Hpm>((uint32_t)IGFX_BMG);
533 
Initialize(PMOS_INTERFACE osInterface,MhwInterfacesNext * mhwInterfaces)534 MOS_STATUS McpyDeviceXe2_Hpm::Initialize(
535     PMOS_INTERFACE osInterface,
536     MhwInterfacesNext* mhwInterfaces)
537 {
538 #define MCPY_FAILURE()                                      \
539 {                                                           \
540     if (device != nullptr)                                  \
541     {                                                       \
542         MOS_Delete(device);                                 \
543     }                                                       \
544     return MOS_STATUS_NO_SPACE;                             \
545 }
546 
547     MHW_FUNCTION_ENTER;
548 
549     Mcpy* device = nullptr;
550 
551     if (nullptr == mhwInterfaces->m_miItf)
552     {
553         MCPY_FAILURE();
554     }
555 
556     if (nullptr == mhwInterfaces->m_veboxItf)
557     {
558         MCPY_FAILURE();
559     }
560 
561     if (nullptr == mhwInterfaces->m_bltItf)
562     {
563         MCPY_FAILURE();
564     }
565 
566     device = MOS_New(Mcpy);
567 
568     if (device == nullptr)
569     {
570         MCPY_FAILURE();
571     }
572 
573     if (device->Initialize(
574         osInterface, mhwInterfaces) != MOS_STATUS_SUCCESS)
575     {
576         MOS_Delete(device);
577         MOS_OS_CHK_STATUS_RETURN(MOS_STATUS_UNINITIALIZED);
578     }
579 
580     m_mcpyDevice = device;
581 
582     return MOS_STATUS_SUCCESS;
583 }