Debian Codegraph @

media_softlet/media_interface/media_interfaces_bmg/media_interfaces_bmg.cpp

raw
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
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
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
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
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) && (params.m_isMos == 0))
172 {
173 MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
174 return MOS_STATUS_INVALID_PARAMETER;
175 }
176 //MHW_MI must always be created
177 auto ptr = std::make_shared<mhw::mi::xe_lpm_plus_base_next::Impl>(osInterface);
178 m_miItf = std::static_pointer_cast<mhw::mi::Itf>(ptr);
179 //For mos, need miInterface only
180 if (params.m_isMos)
181 {
182 return MOS_STATUS_SUCCESS;
183 }
184
185 // MHW_CP must always be created
186 MOS_STATUS status;
187 m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
188 MHW_MI_CHK_NULL(m_cpInterface);
189 ptr->SetCpInterface(m_cpInterface, m_miItf);
190
191 if (params.Flags.m_render)
192 {
193 auto renderPtr = std::make_shared<mhw::render::xe2_hpg_next::Impl>(osInterface);
194 m_renderItf = std::static_pointer_cast<mhw::render::Itf>(renderPtr);
195 }
196 if (params.Flags.m_stateHeap)
197 {
198 m_stateHeapInterface =
199 MOS_New(StateHeap, osInterface, params.m_heapMode);
200 }
201 if (params.Flags.m_sfc)
202 {
203 auto sfcPtr = std::make_shared<mhw::sfc::xe2_hpm_next::Impl>(osInterface);
204 m_sfcItf = std::static_pointer_cast<mhw::sfc::Itf>(sfcPtr);
205 }
206 if (params.Flags.m_vebox)
207 {
208 auto veboxPtr = std::make_shared<mhw::vebox::xe2_hpm_next::Impl>(osInterface);
209 m_veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(veboxPtr);
210 }
211
212 if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
213 {
214 auto ptr = std::make_shared<mhw::vdbox::mfx::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
215 m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(ptr);
216 }
217 if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
218 {
219 m_hcpItf = std::make_shared<mhw::vdbox::hcp::xe_lpm_plus_base::v1::Impl>(osInterface);
220 }
221 if (params.Flags.m_vdboxAll)
222 {
223 auto ptr = std::make_shared<mhw::vdbox::avp::xe_lpm_plus_base::v1::Impl>(osInterface);
224 m_avpItf = std::static_pointer_cast<mhw::vdbox::avp::Itf>(ptr);
225 }
226 if (params.Flags.m_vdboxAll || params.Flags.m_huc)
227 {
228 auto ptr = std::make_shared<mhw::vdbox::huc::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
229 m_hucItf = std::static_pointer_cast<mhw::vdbox::huc::Itf>(ptr);
230 }
231 if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
232 {
233 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v1::Impl>(osInterface);
234 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
235 }
236 if (params.Flags.m_blt)
237 {
238 auto bltptr = std::make_shared<mhw::blt::xe2_hpm::Impl>(osInterface);
239 m_bltItf = std::static_pointer_cast<mhw::blt::Itf>(bltptr);
240 }
241
242 return MOS_STATUS_SUCCESS;
243 }
244
245 //!
246 //! \brief Destroys all created MHW interfaces
247 //! \details If the HAL creation fails, this is used for cleanup
248 //!
249 void MhwInterfacesBmg_Next::Destroy()
250 {
251 MhwInterfacesNext::Destroy();
252 }
253
254 static bool bmgRegisteredCodecHal =
255 MediaFactory<uint32_t, CodechalDeviceNext>::
256 Register<CodechalInterfacesXe2_Hpm>((uint32_t)IGFX_BMG);
257
258 MOS_STATUS CodechalInterfacesXe2_Hpm::Initialize(
259 void * standardInfo,
260 void * settings,
261 MhwInterfacesNext *mhwInterfaces,
262 PMOS_INTERFACE osInterface)
263 {
264 if (standardInfo == nullptr ||
265 mhwInterfaces == nullptr ||
266 osInterface == nullptr)
267 {
268 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
269 return MOS_STATUS_INVALID_PARAMETER;
270 }
271
272 // This part should be moved back to media_intefaces.cpp for softlet build
273 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
274 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
275
276 #ifdef _MEDIA_RESERVED
277 #ifdef _VP9_ENCODE_VDENC_SUPPORTED //use vdenc from Xe_LPM_plus instead of Xe2_HPM
278 if (mhwInterfaces != nullptr && info->Mode == CODECHAL_ENCODE_MODE_VP9)
279 {
280 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v0::Impl>(osInterface);
281 mhwInterfaces->m_vdencItf = std::dynamic_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
282 CODECHAL_PUBLIC_CHK_NULL_RETURN(mhwInterfaces->m_vdencItf);
283 }
284 #endif
285 #endif
286
287 bool disableScalability = false;
288 #ifdef _MEDIA_RESERVED
289 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
290 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
291 disableScalability = true;
292 #endif
293 #endif
294 auto skuTable = osInterface->pfnGetSkuTable(osInterface);
295 if (!skuTable)
296 {
297 CODECHAL_PUBLIC_ASSERTMESSAGE("SkuTable is not valid!");
298 return MOS_STATUS_INVALID_PARAMETER;
299 }
300
301 if (MEDIA_IS_SKU(skuTable,FtrEngineGroupScheduling))
302 {
303 CODECHAL_PUBLIC_NORMALMESSAGE("FtrEngineGroupScheduling is set. Disable Scalability!");
304 disableScalability = true;
305 }
306
307 CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
308
309 if (hwInterface == nullptr)
310 {
311 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
312 return MOS_STATUS_NO_SPACE;
313 }
314 hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
315 hwInterface->pfnCreateDecodeMultiPipe = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
316
317 #if USE_CODECHAL_DEBUG_TOOL
318 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
319 if (debugInterface == nullptr)
320 {
321 MOS_Delete(hwInterface);
322 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
323 return MOS_STATUS_NO_SPACE;
324 }
325 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
326 {
327 MOS_Delete(hwInterface);
328 MOS_Delete(debugInterface);
329 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
330 return MOS_STATUS_INVALID_PARAMETER;
331 }
332 #else
333 CodechalDebugInterface *debugInterface = nullptr;
334 #endif // USE_CODECHAL_DEBUG_TOOL
335
336 auto release_func = [&]()
337 {
338 MOS_Delete(hwInterface);
339 #if USE_CODECHAL_DEBUG_TOOL
340 MOS_Delete(debugInterface);
341 #endif // USE_CODECHAL_DEBUG_TOOL
342 };
343
344 if (CodecHalIsDecode(CodecFunction))
345 {
346 #ifdef _MPEG2_DECODE_SUPPORTED
347 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
348 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
349 {
350 m_codechalDevice = MOS_New(DecodeMpeg2PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
351 if (m_codechalDevice == nullptr)
352 {
353 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
354 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
355 }
356 }
357 else
358 #endif
359 #ifdef _VC1_DECODE_SUPPORTED
360 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
361 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
362 {
363 CODECHAL_PUBLIC_ASSERTMESSAGE("BMG doesn't support VC1!");
364 }
365 else
366 #endif
367 #ifdef _AVC_DECODE_SUPPORTED
368 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
369 {
370 m_codechalDevice = MOS_New(DecodeAvcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
371
372 if (m_codechalDevice == nullptr)
373 {
374 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
375 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
376 }
377 }
378 else
379 #endif
380 #ifdef _JPEG_DECODE_SUPPORTED
381 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
382 {
383 m_codechalDevice = MOS_New(DecodeJpegPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
384 }
385 else
386 #endif
387 #ifdef _VP8_DECODE_SUPPORTED
388 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
389 {
390 m_codechalDevice = MOS_New(DecodeVp8PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
391 }
392 else
393 #endif
394 #ifdef _HEVC_DECODE_SUPPORTED
395 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
396 {
397 m_codechalDevice = MOS_New(DecodeHevcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
398 }
399 else
400 #endif
401 #ifdef _VP9_DECODE_SUPPORTED
402 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
403 {
404 m_codechalDevice = MOS_New(DecodeVp9PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
405 }
406 else
407 #endif
408 #ifdef _AV1_DECODE_SUPPORTED
409 if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
410 {
411 m_codechalDevice = MOS_New(DecodeAv1PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
412 }
413 else
414 #endif
415 {
416 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
417 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
418 }
419
420 if (m_codechalDevice == nullptr)
421 {
422 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
423 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
424 }
425 }
426 else if (CodecHalIsEncode(CodecFunction))
427 {
428
429 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
430 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
431 {
432 if (CodecHalUsesVdencEngine(info->CodecFunction))
433 {
434 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
435 if (m_codechalDevice == nullptr)
436 {
437 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
438 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
439 }
440 return MOS_STATUS_SUCCESS;
441 }
442 }
443 else
444 #endif
445 #if defined (_AVC_ENCODE_VDENC_SUPPORTED)
446 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
447 {
448 if (CodecHalUsesVdencEngine(info->CodecFunction))
449 {
450 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
451 if (m_codechalDevice == nullptr)
452 {
453 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
454 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
455 }
456 return MOS_STATUS_SUCCESS;
457 }
458 }
459 else
460 #endif
461 #ifdef _JPEG_ENCODE_SUPPORTED
462 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
463 {
464 m_codechalDevice = MOS_New(EncodeJpegPipelineAdapter, hwInterface, debugInterface);
465 if (m_codechalDevice == nullptr)
466 {
467 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
468 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
469 }
470 return MOS_STATUS_SUCCESS;
471 }
472 else
473 #endif
474 #ifdef _MEDIA_RESERVED
475 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
476 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
477 {
478 m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe2_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 else
487 #endif
488 #endif
489 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
490 if (info->Mode == codechalEncodeModeAv1)
491 {
492 if (CodecHalUsesVdencEngine(info->CodecFunction))
493 {
494 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
495 if (m_codechalDevice == nullptr)
496 {
497 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
498 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
499 }
500 return MOS_STATUS_SUCCESS;
501 }
502 else
503 {
504 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
505 }
506 }
507 else
508 #endif
509 {
510 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
511 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
512 }
513 }
514 else
515 {
516 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
517 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
518 }
519
520 return MOS_STATUS_SUCCESS;
521 }
522
523 static bool bmgRegisteredRenderHal =
524 MediaFactory<uint32_t, RenderHalDevice>::
525 Register<RenderHalInterfacesXe2_Hpg>((uint32_t)IGFX_BMG);
526
527 MOS_STATUS RenderHalInterfacesXe2_Hpg::Initialize()
528 {
529 m_renderhalDevice = MOS_New(XRenderHal);
530 if (m_renderhalDevice == nullptr)
531 {
532 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
533 return MOS_STATUS_NO_SPACE;
534 }
535 return MOS_STATUS_SUCCESS;
536 }
537
538 #define IP_VERSION_XE2_HPM 0x1301
539 static bool bmgRegisteredHwInfo =
540 MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::
541 Register<MediaInterfacesHwInfoDeviceXe2_Hpm>((uint32_t)IGFX_BMG);
542
543 MOS_STATUS MediaInterfacesHwInfoDeviceXe2_Hpm::Initialize(PLATFORM platform)
544 {
545 m_hwInfo.SetDeviceInfo(IP_VERSION_XE2_HPM, platform.usRevId);
546 return MOS_STATUS_SUCCESS;
547 }
548
549 static bool bmgRegisteredMcpy =
550 MediaFactory<uint32_t, McpyDeviceNext>::
551 Register<McpyDeviceXe2_Hpm>((uint32_t)IGFX_BMG);