Debian Codegraph @

media_softlet/media_interface/media_interfaces_ptl/media_interfaces_ptl.cpp

raw
1 /*===================== begin_copyright_notice ==================================
2 Copyright (c) 2024, Intel Corporation
3
4 # Permission is hereby granted, free of charge, to any person obtaining a
5 # copy of this software and associated documentation files (the "Software"),
6 # to deal in the Software without restriction, including without limitation
7 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 # and/or sell copies of the Software, and to permit persons to whom the
9 # Software is furnished to do so, subject to the following conditions:
10
11 # The above copyright notice and this permission notice shall be included
12 # in all copies or substantial portions of the Software.
13
14 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 # OTHER DEALINGS IN THE SOFTWARE.
21 ======================= end_copyright_notice ==================================*/
22 //!
23 //! \file media_interfaces_ptl.cpp
24
25 //! \brief Helps with PTL factory creation.
26 //!
27
28 #include "media_interfaces_ptl.h"
29
30 #include "codechal_common.h"
31 #include "codechal_debug.h"
32
33 #include "vp_pipeline_adapter_xe3_lpm.h"
34 #include "vp_platform_interface_xe3_lpm.h"
35 #include "vp_kernel_config_xe2_hpg.h"
36 #include "mhw_mi_xe3_lpm_base_impl.h"
37 #include "mhw_sfc_xe3_lpm_base_impl.h"
38 #include "mhw_vebox_xe3_lpm_base_impl.h"
39 #include "mhw_render_xe2_hpg_next_impl.h"
40 #include "mhw_blt_xe3_lpm_impl.h"
41
42 #include "media_interfaces_mcpy_next.h"
43
44 #include "mhw_vdbox_vdenc_impl_xe_lpm_plus.h"
45
46 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
47 #include "igvpkrn_xe2_hpg.h"
48 #include "igvpkrn_xe2_hpg_cmfcpatch.h"
49 #include "igvpkrn_l0_xe2_hpg.h"
50 #include "igvpfc_common_xe2.h"
51 #include "igvpfc_fp_xe2.h"
52 #include "igvpfc_444PL3_input_xe2.h"
53 #include "igvpfc_444PL3_output_xe2.h"
54 #include "igvpfc_420PL3_input_xe2.h"
55 #include "igvpfc_420PL3_output_xe2.h"
56 #include "igvp3dlut_xe2.h"
57 #include "igvpfc_422HV_input_xe2.h"
58 #endif
59
60 using namespace mhw::vdbox::avp::xe3_lpm_base;
61 using namespace mhw::vdbox::vdenc::xe3_lpm_base;
62 using namespace mhw::vdbox::huc::xe3_lpm_base;
63
64 extern template class MediaFactory<uint32_t, CodechalDeviceNext>;
65 extern template class MediaFactory<uint32_t, VphalDevice>;
66 extern template class MediaFactory<uint32_t, RenderHalDevice>;
67 extern template class MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>;
68
69
70 extern template class MediaFactory<uint32_t, MhwInterfacesNext>;
71
72 static bool ptlRegisteredVphal =
73 MediaFactory<uint32_t, VphalDevice>::
74 Register<VphalInterfacesXe3_Lpm>((uint32_t)IGFX_PTL);
75
76 MOS_STATUS VphalInterfacesXe3_Lpm::Initialize(
77 PMOS_INTERFACE osInterface,
78 bool bInitVphalState,
79 MOS_STATUS * eStatus,
80 bool clearViewMode)
81 {
82 vp::VpPlatformInterface* vpPlatformInterface = MOS_New(vp::VpPlatformInterfacsXe3_Lpm, osInterface);
83 if (nullptr == vpPlatformInterface)
84 {
85 *eStatus = MOS_STATUS_NULL_POINTER;
86 return *eStatus;
87 }
88
89 InitPlatformKernelBinary(vpPlatformInterface);
90
91 if (!bInitVphalState)
92 {
93 m_vpPipeline = MOS_New(vp::VpPipeline, osInterface);
94 if (nullptr == m_vpPipeline)
95 {
96 MOS_Delete(vpPlatformInterface);
97 MOS_OS_CHK_NULL_RETURN(m_vpPipeline);
98 }
99 m_vpPlatformInterface = vpPlatformInterface;
100 *eStatus = MOS_STATUS_SUCCESS;
101 return *eStatus;
102 }
103
104 m_vpBase = MOS_New(
105 VpPipelineAdapterXe3_Lpm,
106 osInterface,
107 *vpPlatformInterface,
108 *eStatus);
109 if (nullptr == m_vpBase)
110 {
111 MOS_Delete(vpPlatformInterface);
112 *eStatus = MOS_STATUS_NULL_POINTER;
113 return *eStatus;
114 }
115 m_isNextEnabled = true;
116
117 return *eStatus;
118 }
119
120 MOS_STATUS VphalInterfacesXe3_Lpm::CreateVpPlatformInterface(
121 PMOS_INTERFACE osInterface,
122 MOS_STATUS * eStatus)
123 {
124 vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfacsXe3_Lpm, osInterface);
125 if (nullptr == vpPlatformInterface)
126 {
127 *eStatus = MOS_STATUS_NULL_POINTER;
128 }
129 else
130 {
131 InitPlatformKernelBinary(vpPlatformInterface);
132
133 m_vpPlatformInterface = vpPlatformInterface;
134 *eStatus = MOS_STATUS_SUCCESS;
135 }
136 return *eStatus;
137 }
138
139 void VphalInterfacesXe3_Lpm::InitPlatformKernelBinary(
140 vp::VpPlatformInterface *&vpPlatformInterface)
141 {
142 static vp::VpKernelConfigXe2_Hpg kernelConfig;
143 vpPlatformInterface->SetKernelConfig(&kernelConfig);
144 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
145 vpPlatformInterface->SetVpFCKernelBinary(
146 IGVPKRN_XE2_HPG,
147 IGVPKRN_XE2_HPG_SIZE,
148 IGVPKRN_XE2_HPG_CMFCPATCH,
149 IGVPKRN_XE2_HPG_CMFCPATCH_SIZE);
150 vpPlatformInterface->AddVpNativeAdvKernelEntryToList(IGVP3DLUT_GENERATION_XE2_HPG, IGVP3DLUT_GENERATION_XE2_HPG_SIZE, "hdr_3dlut_l0");
151 // Need to SetOclKernelEnable in platform interface for ocl kernels
152 vpPlatformInterface->SetOclKernelEnable();
153 AddVpNativeKernelEntryToListFc_commonXe2(*vpPlatformInterface);
154 AddVpNativeKernelEntryToListFc_fpXe2(*vpPlatformInterface);
155 AddVpNativeKernelEntryToListFc_444pl3_inputXe2(*vpPlatformInterface);
156 AddVpNativeKernelEntryToListFc_444pl3_outputXe2(*vpPlatformInterface);
157 AddVpNativeKernelEntryToListFc_420pl3_inputXe2(*vpPlatformInterface);
158 AddVpNativeKernelEntryToListFc_420pl3_outputXe2(*vpPlatformInterface);
159 AddVpNativeKernelEntryToList3dlutXe2(*vpPlatformInterface);
160 AddVpNativeKernelEntryToListFc_422hv_inputXe2(*vpPlatformInterface);
161 #endif
162 }
163
164 static bool ptlRegisteredMhwNext =
165 MediaFactory<uint32_t, MhwInterfacesNext>::
166 Register<MhwInterfacesPtl_Next>((uint32_t)IGFX_PTL);
167
168 MOS_STATUS MhwInterfacesPtl_Next::Initialize(
169 CreateParams params,
170 PMOS_INTERFACE osInterface)
171 {
172 if (osInterface == nullptr)
173 {
174 MHW_ASSERTMESSAGE("The OS interface is not valid!");
175 return MOS_STATUS_INVALID_PARAMETER;
176 }
177 m_osInterface = osInterface;
178
179 auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
180 if (gtSystemInfo == nullptr)
181 {
182 MHW_ASSERTMESSAGE("The OS interface is not valid!");
183 return MOS_STATUS_INVALID_PARAMETER;
184 }
185
186 if ((params.m_isCp == false) && (params.Flags.m_value == 0) && (params.m_isMos) == 0)
187 {
188 MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
189 return MOS_STATUS_INVALID_PARAMETER;
190 }
191
192 //MHW_MI must always be created
193 auto ptr = std::make_shared<mhw::mi::xe3_lpm_base::Impl>(osInterface);
194 m_miItf = std::static_pointer_cast<mhw::mi::Itf>(ptr);
195 //For mos, need miInterface only
196 if(params.m_isMos)
197 {
198 return MOS_STATUS_SUCCESS;
199 }
200
201 // MHW_CP must always be created
202 MOS_STATUS status;
203 m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
204 MHW_MI_CHK_NULL(m_cpInterface);
205
206 ptr->SetCpInterface(m_cpInterface, m_miItf);
207
208 if (params.Flags.m_render)
209 {
210 auto renderPtr = std::make_shared<mhw::render::xe2_hpg_next::Impl>(osInterface);
211 m_renderItf = std::static_pointer_cast<mhw::render::Itf>(renderPtr);
212 }
213 if (params.Flags.m_stateHeap)
214 {
215 m_stateHeapInterface =
216 MOS_New(StateHeap, osInterface, params.m_heapMode);
217 }
218 if (params.Flags.m_sfc)
219 {
220 auto sfcPtr = std::make_shared<mhw::sfc::xe3_lpm_base::Impl>(osInterface);
221 m_sfcItf = std::static_pointer_cast<mhw::sfc::Itf>(sfcPtr);
222 }
223 if (params.Flags.m_vebox)
224 {
225 auto veboxPtr = std::make_shared<mhw::vebox::xe3_lpm_base::Impl>(osInterface);
226 m_veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(veboxPtr);
227 }
228
229 if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
230 {
231 auto ptr = std::make_shared<mhw::vdbox::mfx::xe3_lpm_base::xe3_lpm::Impl>(osInterface, m_cpInterface);
232 m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(ptr);
233 }
234 if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
235 {
236 m_hcpItf = std::make_shared<mhw::vdbox::hcp::xe3_lpm_base::xe3_lpm::Impl>(osInterface);
237 }
238 if (params.Flags.m_vdboxAll)
239 {
240 auto ptr = std::make_shared<mhw::vdbox::avp::xe3_lpm_base::xe3_lpm::Impl>(osInterface);
241 m_avpItf = std::static_pointer_cast<mhw::vdbox::avp::Itf>(ptr);
242 }
243 if (params.Flags.m_vdboxAll)
244 {
245 auto ptr = std::make_shared<mhw::vdbox::vvcp::xe3_lpm_base::xe3_lpm::Impl>(osInterface, m_cpInterface);
246 m_vvcpItf = std::static_pointer_cast<mhw::vdbox::vvcp::Itf>(ptr);
247 }
248 if (params.Flags.m_vdboxAll || params.Flags.m_huc)
249 {
250 auto ptr = std::make_shared<mhw::vdbox::huc::xe3_lpm_base::xe3_lpm::Impl>(osInterface, m_cpInterface);
251 m_hucItf = std::static_pointer_cast<mhw::vdbox::huc::Itf>(ptr);
252 }
253 if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
254 {
255 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe3_lpm_base::xe3_lpm::Impl>(osInterface);
256 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
257 }
258 if (params.Flags.m_blt)
259 {
260 auto bltptr = std::make_shared<mhw::blt::xe3_lpm::Impl>(osInterface);
261 m_bltItf = std::static_pointer_cast<mhw::blt::Itf>(bltptr);
262 }
263
264 return MOS_STATUS_SUCCESS;
265 }
266
267 //!
268 //! \brief Destroys all created MHW interfaces
269 //! \details If the HAL creation fails, this is used for cleanup
270 //!
271 void MhwInterfacesPtl_Next::Destroy()
272 {
273 MhwInterfacesNext::Destroy();
274 }
275
276 static bool ptlRegisteredCodecHal =
277 MediaFactory<uint32_t, CodechalDeviceNext>::
278 Register<CodechalInterfacesXe3_Lpm>((uint32_t)IGFX_PTL);
279
280 MOS_STATUS CodechalInterfacesXe3_Lpm::Initialize(
281 void * standardInfo,
282 void * settings,
283 MhwInterfacesNext *mhwInterfaces,
284 PMOS_INTERFACE osInterface)
285 {
286 if (standardInfo == nullptr ||
287 mhwInterfaces == nullptr ||
288 osInterface == nullptr)
289 {
290 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
291 return MOS_STATUS_INVALID_PARAMETER;
292 }
293
294 // This part should be moved back to media_intefaces.cpp for softlet build
295 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
296 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
297
298 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
299 if (mhwInterfaces != nullptr && info->Mode == CODECHAL_ENCODE_MODE_VP9)
300 {
301 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe3_lpm_base::xe3_lpm::Impl>(osInterface);
302 mhwInterfaces->m_vdencItf = std::dynamic_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
303 CODECHAL_PUBLIC_CHK_NULL_RETURN(mhwInterfaces->m_vdencItf);
304 }
305 #endif
306
307 bool disableScalability = true;
308
309 CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
310
311 if (hwInterface == nullptr)
312 {
313 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
314 return MOS_STATUS_NO_SPACE;
315 }
316 hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
317 hwInterface->pfnCreateDecodeMultiPipe = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
318
319 #if USE_CODECHAL_DEBUG_TOOL
320 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
321 if (debugInterface == nullptr)
322 {
323 MOS_Delete(hwInterface);
324 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
325 return MOS_STATUS_NO_SPACE;
326 }
327 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
328 {
329 MOS_Delete(hwInterface);
330 MOS_Delete(debugInterface);
331 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
332 return MOS_STATUS_INVALID_PARAMETER;
333 }
334 #else
335 CodechalDebugInterface *debugInterface = nullptr;
336 #endif // USE_CODECHAL_DEBUG_TOOL
337
338 auto release_func = [&]()
339 {
340 MOS_Delete(hwInterface);
341 #if USE_CODECHAL_DEBUG_TOOL
342 MOS_Delete(debugInterface);
343 #endif // USE_CODECHAL_DEBUG_TOOL
344 };
345
346 if (CodecHalIsDecode(CodecFunction))
347 {
348 #ifdef _MPEG2_DECODE_SUPPORTED
349 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
350 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
351 {
352 m_codechalDevice = MOS_New(Decode::Mpeg2, hwInterface, debugInterface);
353 }
354 else
355 #endif
356 #ifdef _VC1_DECODE_SUPPORTED
357 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
358 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
359 {
360 CODECHAL_PUBLIC_ASSERTMESSAGE("PTL doesn't support VC1!");
361 }
362 else
363 #endif
364 #ifdef _AVC_DECODE_SUPPORTED
365 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
366 {
367 m_codechalDevice = MOS_New(Decode::Avc, hwInterface, debugInterface);
368 }
369 else
370 #endif
371 #ifdef _JPEG_DECODE_SUPPORTED
372 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
373 {
374 m_codechalDevice = MOS_New(Decode::Jpeg, hwInterface, debugInterface);
375 }
376 else
377 #endif
378 #ifdef _VP8_DECODE_SUPPORTED
379 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
380 {
381 m_codechalDevice = MOS_New(Decode::Vp8, hwInterface, debugInterface);
382 }
383 else
384 #endif
385 #ifdef _HEVC_DECODE_SUPPORTED
386 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
387 {
388 m_codechalDevice = MOS_New(Decode::Hevc, hwInterface, debugInterface);
389 }
390 else
391 #endif
392 #ifdef _VP9_DECODE_SUPPORTED
393 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
394 {
395 m_codechalDevice = MOS_New(Decode::Vp9, hwInterface, debugInterface);
396 }
397 else
398 #endif
399 #ifdef _AV1_DECODE_SUPPORTED
400 if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
401 {
402 m_codechalDevice = MOS_New(Decode::Av1, hwInterface, debugInterface);
403 }
404 else
405 #endif
406 #ifdef _VVC_DECODE_SUPPORTED
407 if (info->Mode == CODECHAL_DECODE_MODE_VVCVLD) //VVC
408 {
409 m_codechalDevice = MOS_New(Decode::Vvc, hwInterface, debugInterface);
410 }
411 else
412 #endif
413 {
414 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
415 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
416 }
417
418 if (m_codechalDevice == nullptr)
419 {
420 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
421 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
422 }
423 }
424 else if (CodecHalIsEncode(CodecFunction))
425 {
426 #if defined(_AVC_ENCODE_VDENC_SUPPORTED)
427 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
428 {
429 if (CodecHalUsesVdencEngine(info->CodecFunction))
430 {
431 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe3_Lpm, hwInterface, debugInterface);
432 if (m_codechalDevice == nullptr)
433 {
434 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
435 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
436 }
437 return MOS_STATUS_SUCCESS;
438 }
439 }
440 else
441 #endif
442 #if defined(_VP9_ENCODE_VDENC_SUPPORTED)
443 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
444 {
445 m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe3_Lpm, hwInterface, debugInterface);
446 if (m_codechalDevice == nullptr)
447 {
448 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
449 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
450 }
451 return MOS_STATUS_SUCCESS;
452 }
453 else
454 #endif
455 #if defined(_JPEG_ENCODE_SUPPORTED)
456 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
457 {
458 m_codechalDevice = MOS_New(EncodeJpegPipelineAdapter, 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 #endif
468 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
469 if (info->Mode == codechalEncodeModeAv1)
470 {
471 if (CodecHalUsesVdencEngine(info->CodecFunction))
472 {
473 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe3_Lpm, hwInterface, debugInterface);
474 if (m_codechalDevice == nullptr)
475 {
476 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
477 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
478 }
479 return MOS_STATUS_SUCCESS;
480 }
481 else
482 {
483 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
484 }
485 }
486 else
487 #endif
488 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
489 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
490 {
491 if (CodecHalUsesVdencEngine(info->CodecFunction))
492 {
493 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe3_Lpm_Base, hwInterface, debugInterface);
494 if (m_codechalDevice == nullptr)
495 {
496 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
497 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
498 }
499 return MOS_STATUS_SUCCESS;
500 }
501 }
502 else
503 #endif
504 {
505 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
506 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
507 }
508 }
509 else
510 {
511 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
512 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
513 }
514
515 return MOS_STATUS_SUCCESS;
516 }
517
518 static bool ptlRegisteredRenderHal =
519 MediaFactory<uint32_t, RenderHalDevice>::
520 Register<RenderHalInterfacesXe3_Lpg>((uint32_t)IGFX_PTL);
521
522 MOS_STATUS RenderHalInterfacesXe3_Lpg::Initialize()
523 {
524 m_renderhalDevice = MOS_New(XRenderHal);
525 if (m_renderhalDevice == nullptr)
526 {
527 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
528 return MOS_STATUS_NO_SPACE;
529 }
530 return MOS_STATUS_SUCCESS;
531 }
532
533 #define IP_VERSION_XE3_LPM 0x1600
534 #define IP_VERSION_XE3_LPM_EXT 0x1601
535
536 static bool ptlRegisteredHwInfo =
537 MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::Register<MediaInterfacesHwInfoDeviceXe3_Lpm>((uint32_t)IGFX_PTL);
538
539 MOS_STATUS MediaInterfacesHwInfoDeviceXe3_Lpm::Initialize(PLATFORM platform)
540 {
541 #if defined(LINUX)
542 if (platform.usDeviceID == 0xFD80 || platform.usDeviceID == 0xFD81)
543 m_hwInfo.SetDeviceInfo(IP_VERSION_XE3_LPM_EXT, platform.usRevId);//WCL
544 else
545 m_hwInfo.SetDeviceInfo(IP_VERSION_XE3_LPM, platform.usRevId); //PTL
546 #else
547 m_hwInfo.SetDeviceInfo(IP_VERSION_XE3_LPM, platform.usRevId);
548 #endif
549 return MOS_STATUS_SUCCESS;
550 }
551
552 static bool ptlRegisteredMcpy =
553 MediaFactory<uint32_t, McpyDeviceNext>::
554 Register<McpyDeviceXe3_Lpm_Base>((uint32_t)IGFX_PTL);