Debian Codegraph @

media_softlet/media_interface/media_interfaces_mtl/media_interfaces_mtl.cpp

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