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
Initialize(PMOS_INTERFACE osInterface,bool bInitVphalState,MOS_STATUS * eStatus,bool clearViewMode)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
CreateVpPlatformInterface(PMOS_INTERFACE osInterface,MOS_STATUS * eStatus)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
InitPlatformKernelBinary(vp::VpPlatformInterface * & vpPlatformInterface)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
Initialize(CreateParams params,PMOS_INTERFACE osInterface)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 //!
Destroy()245 void MhwInterfacesXe_Lpm_Plus_Next::Destroy()
246 {
247 MhwInterfacesNext::Destroy();
248 }
249
250 #ifdef _MMC_SUPPORTED
251 static bool mtlRegisteredMmd =
252 MediaFactory<uint32_t, MmdDeviceNext>::
253 Register<MmdDeviceXe_Lpm_Plus_Next>((uint32_t)IGFX_METEORLAKE);
254
Initialize(PMOS_INTERFACE osInterface,MhwInterfacesNext * mhwInterfaces)255 MOS_STATUS MmdDeviceXe_Lpm_Plus_Next::Initialize(
256 PMOS_INTERFACE osInterface,
257 MhwInterfacesNext* mhwInterfaces)
258 {
259 #define MMD_FAILURE() \
260 { \
261 if (device != nullptr) \
262 { \
263 MOS_Delete(device); \
264 } \
265 return MOS_STATUS_NO_SPACE; \
266 }
267 MHW_FUNCTION_ENTER;
268
269 Mmd* device = nullptr;
270
271 if (mhwInterfaces->m_miItf == nullptr)
272 {
273 MMD_FAILURE();
274 }
275
276 if (mhwInterfaces->m_veboxItf == nullptr)
277 {
278 MMD_FAILURE();
279 }
280
281 device = MOS_New(Mmd);
282
283 if (device == nullptr)
284 {
285 MMD_FAILURE();
286 }
287
288 if (device->Initialize(
289 osInterface,
290 mhwInterfaces) != MOS_STATUS_SUCCESS)
291 {
292 MOS_Delete(device);
293 MOS_OS_CHK_STATUS_RETURN(MOS_STATUS_UNINITIALIZED);
294 }
295
296 m_mmdDevice = device;
297
298 return MOS_STATUS_SUCCESS;
299 }
300 #endif
301
302 static bool mtlRegisteredMcpy =
303 MediaFactory<uint32_t, McpyDeviceNext>::
304 Register<McpyDeviceXe_Lpm_Plus>((uint32_t)IGFX_METEORLAKE);
305
Initialize(PMOS_INTERFACE osInterface,MhwInterfacesNext * mhwInterfaces)306 MOS_STATUS McpyDeviceXe_Lpm_Plus::Initialize(
307 PMOS_INTERFACE osInterface,
308 MhwInterfacesNext *mhwInterfaces)
309 {
310 #define MCPY_FAILURE() \
311 { \
312 if (device != nullptr) \
313 { \
314 MOS_Delete(device); \
315 } \
316 return MOS_STATUS_NO_SPACE; \
317 }
318
319 MHW_FUNCTION_ENTER;
320
321 Mcpy *device = nullptr;
322
323 if (nullptr == mhwInterfaces->m_miItf)
324 {
325 MCPY_FAILURE();
326 }
327
328 if (nullptr == mhwInterfaces->m_veboxItf)
329 {
330 MCPY_FAILURE();
331 }
332
333 if (nullptr == mhwInterfaces->m_bltItf)
334 {
335 MCPY_FAILURE();
336 }
337
338 device = MOS_New(Mcpy);
339
340 if (device == nullptr)
341 {
342 MCPY_FAILURE();
343 }
344
345 if (device->Initialize(
346 osInterface, mhwInterfaces) != MOS_STATUS_SUCCESS)
347 {
348 MOS_Delete(device);
349 MOS_OS_CHK_STATUS_RETURN(MOS_STATUS_UNINITIALIZED);
350 }
351
352 m_mcpyDevice = device;
353
354 return MOS_STATUS_SUCCESS;
355 }
356
357 static bool mtlRegisteredCodecHal =
358 MediaFactory<uint32_t, CodechalDeviceNext>::
359 Register<CodechalInterfacesXe_Lpm_Plus>((uint32_t)IGFX_METEORLAKE);
360
Initialize(void * standardInfo,void * settings,MhwInterfacesNext * mhwInterfaces,PMOS_INTERFACE osInterface)361 MOS_STATUS CodechalInterfacesXe_Lpm_Plus::Initialize(
362 void * standardInfo,
363 void * settings,
364 MhwInterfacesNext *mhwInterfaces,
365 PMOS_INTERFACE osInterface)
366 {
367 if (standardInfo == nullptr ||
368 mhwInterfaces == nullptr ||
369 osInterface == nullptr)
370 {
371 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
372 return MOS_STATUS_INVALID_PARAMETER;
373 }
374 // Shared pointer to user setting instance
375 MediaUserSettingSharedPtr userSettingPtr = osInterface->pfnGetUserSettingInstance(osInterface);
376 // This part should be moved back to media_intefaces.cpp for softlet build
377 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
378 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
379
380 bool disableScalability = false;
381 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
382 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
383 disableScalability = true;
384 #endif
385
386 CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
387
388 if (hwInterface == nullptr)
389 {
390 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
391 return MOS_STATUS_NO_SPACE;
392 }
393 hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
394 hwInterface->pfnCreateDecodeMultiPipe = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
395
396 #if USE_CODECHAL_DEBUG_TOOL
397 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
398 if (debugInterface == nullptr)
399 {
400 MOS_Delete(hwInterface);
401 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
402 return MOS_STATUS_NO_SPACE;
403 }
404 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
405 {
406 MOS_Delete(hwInterface);
407 MOS_Delete(debugInterface);
408 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
409 return MOS_STATUS_INVALID_PARAMETER;
410 }
411 #else
412 CodechalDebugInterface *debugInterface = nullptr;
413 #endif // USE_CODECHAL_DEBUG_TOOL
414
415 auto release_func = [&]()
416 {
417 MOS_Delete(hwInterface);
418 #if USE_CODECHAL_DEBUG_TOOL
419 MOS_Delete(debugInterface);
420 #endif // USE_CODECHAL_DEBUG_TOOL
421 };
422
423 if (CodecHalIsDecode(CodecFunction))
424 {
425 #ifdef _MPEG2_DECODE_SUPPORTED
426 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
427 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
428 {
429 m_codechalDevice = MOS_New(DecodeMpeg2PipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
430 }
431 else
432 #endif
433 #ifdef _VC1_DECODE_SUPPORTED
434 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
435 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
436 {
437 CODECHAL_PUBLIC_ASSERTMESSAGE("MTL doesn't support VC1!");
438 }
439 else
440 #endif
441 #ifdef _AVC_DECODE_SUPPORTED
442 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
443 {
444 m_codechalDevice = MOS_New(DecodeAvcPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
445 }
446 else
447 #endif
448 #ifdef _JPEG_DECODE_SUPPORTED
449 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
450 {
451 m_codechalDevice = MOS_New(DecodeJpegPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
452 }
453 else
454 #endif
455 #ifdef _VP8_DECODE_SUPPORTED
456 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
457 {
458 m_codechalDevice = MOS_New(DecodeVp8PipelineAdapterXe_Lpm_Plus_Base, hwInterface, debugInterface);
459 }
460 else
461 #endif
462 #ifdef _HEVC_DECODE_SUPPORTED
463 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
464 {
465 m_codechalDevice = MOS_New(DecodeHevcPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
466 }
467 else
468 #endif
469 #ifdef _VP9_DECODE_SUPPORTED
470 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
471 {
472 m_codechalDevice = MOS_New(DecodeVp9PipelineAdapterXe_Lpm_Plus_Base, hwInterface, debugInterface);
473 }
474 else
475 #endif
476 #ifdef _AV1_DECODE_SUPPORTED
477 if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
478 {
479 m_codechalDevice = MOS_New(DecodeAv1PipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
480 }
481 else
482 #endif
483 {
484 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
485 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
486 }
487
488 if (m_codechalDevice == nullptr)
489 {
490 MOS_Delete(hwInterface);
491 mhwInterfaces->SetDestroyState(true);
492 #if USE_CODECHAL_DEBUG_TOOL
493 MOS_Delete(debugInterface);
494 #endif
495 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
496 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
497 }
498 }
499 else if (CodecHalIsEncode(CodecFunction))
500 {
501 #if defined(_AVC_ENCODE_VDENC_SUPPORTED)
502 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
503 {
504 if (CodecHalUsesVdencEngine(info->CodecFunction))
505 {
506 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe_Lpm_Plus_Base, 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_ASSERTMESSAGE("Encode allocation failed, AVC VME Encoder is not supported, please use AVC LowPower Encoder instead!");
517 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
518 }
519 }
520 else
521 #endif
522 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
523 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
524 {
525 m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
526 if (m_codechalDevice == nullptr)
527 {
528 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
529 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
530 }
531 return MOS_STATUS_SUCCESS;
532 }
533 else
534 #endif
535 if (info->Mode == CODECHAL_ENCODE_MODE_MPEG2)
536 {
537 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode allocation failed, MPEG2 Encoder is not supported!");
538 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
539 }
540 else
541 #ifdef _JPEG_ENCODE_SUPPORTED
542 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
543 {
544 m_codechalDevice = MOS_New(EncodeJpegPipelineAdapterXe_Lpm_Plus_Base, hwInterface, debugInterface);
545 if (m_codechalDevice == nullptr)
546 {
547 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
548 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
549 }
550 return MOS_STATUS_SUCCESS;
551 }
552 else
553 #endif
554 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
555 if (info->Mode == codechalEncodeModeAv1)
556 {
557 if (CodecHalUsesVdencEngine(info->CodecFunction))
558 {
559 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
560 if (m_codechalDevice == nullptr)
561 {
562 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
563 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
564 }
565 return MOS_STATUS_SUCCESS;
566 }
567 else
568 {
569 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
570 }
571 }
572 else
573 #endif
574 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
575 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
576 {
577 if (CodecHalUsesVdencEngine(info->CodecFunction))
578 {
579 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe_Lpm_Plus, hwInterface, debugInterface);
580 if (m_codechalDevice == nullptr)
581 {
582 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
583 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
584 }
585 return MOS_STATUS_SUCCESS;
586 }
587 else
588 {
589 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode allocation failed, HEVC VME Encoder is not supported.");
590 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
591 }
592 }
593 else
594 #endif
595 {
596 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
597 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
598 }
599 }
600 else
601 {
602 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
603 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
604 }
605
606 return MOS_STATUS_SUCCESS;
607 }
608
609 static bool mtlRegisteredRenderHal =
610 MediaFactory<uint32_t, RenderHalDevice>::
611 Register<RenderHalInterfacesXe_Lpg>((uint32_t)IGFX_METEORLAKE);
612
Initialize()613 MOS_STATUS RenderHalInterfacesXe_Lpg::Initialize()
614 {
615 m_renderhalDevice = MOS_New(XRenderHal);
616 if (m_renderhalDevice == nullptr)
617 {
618 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
619 return MOS_STATUS_NO_SPACE;
620 }
621 return MOS_STATUS_SUCCESS;
622 }
623
624 #define IP_VERSION_XE_LPM_PLUS 0x1300
625 static bool mtlRegisteredHwInfo =
626 MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::
627 Register<MediaInterfacesHwInfoDeviceXe_Lpm_Plus>((uint32_t)IGFX_METEORLAKE);
628
Initialize(PLATFORM platform)629 MOS_STATUS MediaInterfacesHwInfoDeviceXe_Lpm_Plus::Initialize(PLATFORM platform)
630 {
631 m_hwInfo.SetDeviceInfo(IP_VERSION_XE_LPM_PLUS, platform.usRevId);
632 return MOS_STATUS_SUCCESS;
633 }
634