Debian Codegraph @

media_driver/media_interface/media_interfaces_m9_skl/media_interfaces_g9_skl.cpp

raw
1 /*
2 * Copyright (c) 2017-2019, 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 */
22 //!
23 //! \file media_interfaces_g9_skl.cpp
24 //! \brief Helps with SKL factory creation.
25 //!
26
27 #include "media_interfaces_g9_skl.h"
28 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
29 #include "igcodeckrn_g9.h"
30 #endif
31
32 #ifdef _HYBRID_HEVC_DECODE_SUPPORTED
33 #include "codechal_decode_hybrid_hevc.h"
34 #endif
35
36 #ifdef _HYBRID_VP9_DECODE_SUPPORTED
37 #include "codechal_decode_hybrid_vp9.h"
38 #endif
39
40 extern template class MediaFactory<uint32_t, MhwInterfaces>;
41 extern template class MediaFactory<uint32_t, MmdDevice>;
42 extern template class MediaFactory<uint32_t, CodechalDevice>;
43 extern template class MediaFactory<uint32_t, CMHalDevice>;
44 extern template class MediaFactory<uint32_t, VphalDevice>;
45 extern template class MediaFactory<uint32_t, RenderHalDevice>;
46 extern template class MediaFactory<uint32_t, Nv12ToP010Device>;
47 extern template class MediaFactory<uint32_t, DecodeHistogramDevice>;
48
49 static bool sklRegisteredVphal =
50 MediaFactory<uint32_t, VphalDevice>::
51 Register<VphalInterfacesG9Skl>((uint32_t)IGFX_SKYLAKE);
52
53 MOS_STATUS VphalInterfacesG9Skl::Initialize(
54 PMOS_INTERFACE osInterface,
55 bool bInitVphalState,
56 MOS_STATUS *eStatus,
57 bool clearViewMode)
58 {
59 m_vpBase = MOS_New(
60 VphalState,
61 osInterface,
62 eStatus);
63
64 return *eStatus;
65 }
66
67 static bool sklRegisteredMhw =
68 MediaFactory<uint32_t, MhwInterfaces>::
69 Register<MhwInterfacesG9Skl>((uint32_t)IGFX_SKYLAKE);
70
71 #define PLATFORM_INTEL_SKL 7
72 #define GENX_SKL 5
73
74 MOS_STATUS MhwInterfacesG9Skl::Initialize(
75 CreateParams params,
76 PMOS_INTERFACE osInterface)
77 {
78 if (osInterface == nullptr)
79 {
80 MHW_ASSERTMESSAGE("The OS interface is not valid!");
81 return MOS_STATUS_INVALID_PARAMETER;
82 }
83
84 auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
85 if (gtSystemInfo == nullptr)
86 {
87 MHW_ASSERTMESSAGE("The OS interface is not valid!");
88 return MOS_STATUS_INVALID_PARAMETER;
89 }
90
91 if ((params.m_isCp == false) && (params.Flags.m_value == 0))
92 {
93 MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
94 return MOS_STATUS_INVALID_PARAMETER;
95 }
96
97 // MHW_CP and MHW_MI must always be created
98 MOS_STATUS status;
99 m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
100 m_miInterface = MOS_New(Mi, m_cpInterface, osInterface);
101
102 if (params.Flags.m_render)
103 {
104 m_renderInterface =
105 MOS_New(Render, m_miInterface, osInterface, gtSystemInfo, params.m_heapMode);
106 }
107 if (params.Flags.m_stateHeap)
108 {
109 m_stateHeapInterface =
110 MOS_New(StateHeap, osInterface, params.m_heapMode);
111 }
112 if (params.Flags.m_sfc)
113 {
114 m_sfcInterface = MOS_New(Sfc, osInterface);
115 }
116 if (params.Flags.m_vebox)
117 {
118 m_veboxInterface = MOS_New(Vebox, osInterface);
119 }
120
121 if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
122 {
123 m_mfxInterface =
124 MOS_New(Mfx, osInterface, m_miInterface, m_cpInterface, params.m_isDecode);
125 }
126 if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
127 {
128 m_hcpInterface =
129 MOS_New(Hcp, osInterface, m_miInterface, m_cpInterface, params.m_isDecode);
130 }
131 if (params.Flags.m_vdboxAll || params.Flags.m_huc)
132 {
133 m_hucInterface = MOS_New(Huc, osInterface, m_miInterface, m_cpInterface);
134 }
135 if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
136 {
137 m_vdencInterface = MOS_New(Vdenc, osInterface);
138 }
139
140 return MOS_STATUS_SUCCESS;
141 }
142 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
143 static bool sklRegisteredMmd =
144 MediaFactory<uint32_t, MmdDevice>::
145 Register<MmdDeviceG9Skl>((uint32_t)IGFX_SKYLAKE);
146
147 MOS_STATUS MmdDeviceG9Skl::Initialize(
148 PMOS_INTERFACE osInterface,
149 MhwInterfaces *mhwInterfaces)
150 {
151 #define MMD_FAILURE() \
152 { \
153 if (device != nullptr) \
154 { \
155 MOS_Delete(device); \
156 } \
157 return MOS_STATUS_NO_SPACE; \
158 }
159 MHW_FUNCTION_ENTER;
160
161 MhwMiInterface *miInterface = nullptr;
162 MhwRenderInterface *renderInterface = nullptr;
163 Mmd *device = nullptr;
164
165 if (mhwInterfaces->m_miInterface == nullptr)
166 {
167 MMD_FAILURE();
168 }
169 miInterface = mhwInterfaces->m_miInterface;
170
171 if (mhwInterfaces->m_renderInterface == nullptr)
172 {
173 MMD_FAILURE();
174 }
175 renderInterface = mhwInterfaces->m_renderInterface;
176
177 device = MOS_New(Mmd);
178
179 if (device == nullptr)
180 {
181 MMD_FAILURE();
182 }
183
184 if (device->Initialize(
185 osInterface,
186 mhwInterfaces->m_cpInterface,
187 miInterface,
188 renderInterface) != MOS_STATUS_SUCCESS)
189 {
190 MMD_FAILURE();
191 }
192
193 m_mmdDevice = device;
194
195 return MOS_STATUS_SUCCESS;
196 }
197 #endif
198 static bool sklRegisteredNv12ToP010 =
199 MediaFactory<uint32_t, Nv12ToP010Device>::
200 Register<Nv12ToP010DeviceG9Skl>((uint32_t)IGFX_SKYLAKE);
201
202 MOS_STATUS Nv12ToP010DeviceG9Skl::Initialize(
203 PMOS_INTERFACE osInterface)
204 {
205 m_nv12ToP010device = MOS_New(Nv12ToP010, osInterface);
206
207 if (m_nv12ToP010device == nullptr)
208 {
209 MHW_ASSERTMESSAGE("Create Nv12 to P010 interfaces failed.")
210 return MOS_STATUS_NO_SPACE;
211 }
212
213 return MOS_STATUS_SUCCESS;
214 }
215
216 static bool sklRegisteredCodecHal =
217 MediaFactory<uint32_t, CodechalDevice>::
218 Register<CodechalInterfacesG9Skl>((uint32_t)IGFX_SKYLAKE);
219
220 MOS_STATUS CodechalInterfacesG9Skl::Initialize(
221 void *standardInfo,
222 void *settings,
223 MhwInterfaces *mhwInterfaces,
224 PMOS_INTERFACE osInterface)
225 {
226 if (standardInfo == nullptr ||
227 mhwInterfaces == nullptr ||
228 osInterface == nullptr)
229 {
230 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
231 return MOS_STATUS_INVALID_PARAMETER;
232 }
233 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
234 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
235
236 CodechalHwInterface *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces);
237
238 if (hwInterface == nullptr)
239 {
240 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
241 return MOS_STATUS_NO_SPACE;
242 }
243 #if USE_CODECHAL_DEBUG_TOOL
244 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
245 if (debugInterface == nullptr)
246 {
247 MOS_Delete(hwInterface);
248 mhwInterfaces->SetDestroyState(true);
249 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
250 return MOS_STATUS_NO_SPACE;
251 }
252 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
253 {
254 MOS_Delete(hwInterface);
255 mhwInterfaces->SetDestroyState(true);
256 MOS_Delete(debugInterface);
257 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
258 return MOS_STATUS_INVALID_PARAMETER;
259 }
260 #else
261 CodechalDebugInterface *debugInterface = nullptr;
262 #endif // USE_CODECHAL_DEBUG_TOOL
263
264 if (CodecHalIsDecode(CodecFunction))
265 {
266 #ifdef _MPEG2_DECODE_SUPPORTED
267 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
268 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
269 {
270 m_codechalDevice = MOS_New(Decode::Mpeg2, hwInterface, debugInterface, info);
271 }
272 else
273 #endif
274 #ifdef _VC1_DECODE_SUPPORTED
275 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
276 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
277 {
278 m_codechalDevice = MOS_New(Decode::Vc1, hwInterface, debugInterface, info);
279 }
280 else
281 #endif
282 #ifdef _AVC_DECODE_SUPPORTED
283 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
284 {
285 m_codechalDevice = MOS_New(Decode::Avc, hwInterface, debugInterface, info);
286
287 #ifdef _DECODE_PROCESSING_SUPPORTED
288 if (settings != nullptr && ((CodechalSetting *)settings)->downsamplingHinted)
289 {
290 CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(m_codechalDevice);
291 if (decoder == nullptr)
292 {
293 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
294 return MOS_STATUS_NO_SPACE;
295 }
296 FieldScalingInterface *fieldScalingInterface =
297 MOS_New(Decode::FieldScaling, hwInterface);
298 if (fieldScalingInterface == nullptr)
299 {
300 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create field scaling interface!");
301 return MOS_STATUS_NO_SPACE;
302 }
303 decoder->m_fieldScalingInterface = fieldScalingInterface;
304 }
305 #endif
306 }
307 else
308 #endif
309 #ifdef _JPEG_DECODE_SUPPORTED
310 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
311 {
312 m_codechalDevice = MOS_New(Decode::Jpeg, hwInterface, debugInterface, info);
313 }
314 else
315 #endif
316 #ifdef _VP8_DECODE_SUPPORTED
317 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
318 {
319 m_codechalDevice = MOS_New(Decode::Vp8, hwInterface, debugInterface, info);
320 }
321 else
322 #endif
323 #ifdef _HEVC_DECODE_SUPPORTED
324 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
325 {
326 #ifdef _HYBRID_HEVC_DECODE_SUPPORTED
327 if (info->bIsHybridCodec)
328 {
329 m_codechalDevice = MOS_New(CodechalDecodeHybridHevcState, hwInterface, debugInterface, info);
330 }
331 else
332 #endif
333 {
334 m_codechalDevice = MOS_New(Decode::Hevc, hwInterface, debugInterface, info);
335 }
336 }
337 else
338 #endif
339 #ifdef _VP9_DECODE_SUPPORTED
340 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
341 {
342 #ifdef _HYBRID_VP9_DECODE_SUPPORTED
343 if (info->bIsHybridCodec)
344 {
345 m_codechalDevice = MOS_New(CodechalDecodeHybridVp9State, hwInterface, debugInterface, info);
346 }
347 else
348 #endif
349 {
350 m_codechalDevice = MOS_New(Decode::Vp9, hwInterface, debugInterface, info);
351 }
352 }
353 else
354 #endif
355 {
356 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
357 return MOS_STATUS_INVALID_PARAMETER;
358 }
359
360 if (m_codechalDevice == nullptr)
361 {
362 MOS_Delete(hwInterface);
363 mhwInterfaces->SetDestroyState(true);
364 #if USE_CODECHAL_DEBUG_TOOL
365 MOS_Delete(debugInterface);
366 #endif
367 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
368 return MOS_STATUS_NO_SPACE;
369 }
370 }
371 else if (CodecHalIsEncode(CodecFunction))
372 {
373 CodechalEncoderState *encoder = nullptr;
374 #ifdef _MPEG2_ENCODE_VME_SUPPORTED
375 if (info->Mode == CODECHAL_ENCODE_MODE_MPEG2)
376 {
377 // Setup encode interface functions
378 encoder = MOS_New(Encode::Mpeg2, hwInterface, debugInterface, info);
379 if (encoder == nullptr)
380 {
381 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode allocation failed!");
382 return MOS_STATUS_INVALID_PARAMETER;
383 }
384 else
385 {
386 m_codechalDevice = encoder;
387 }
388
389 encoder->m_kernelBase = (uint8_t*)IGCODECKRN_G9;
390 }
391 else
392 #endif
393 #ifdef _JPEG_ENCODE_SUPPORTED
394 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
395 {
396 encoder = MOS_New(Encode::Jpeg, hwInterface, debugInterface, info);
397 if (encoder == nullptr)
398 {
399 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
400 return MOS_STATUS_INVALID_PARAMETER;
401 }
402 else
403 {
404 m_codechalDevice = encoder;
405 }
406 encoder->m_needCheckCpEnabled = true;
407 }
408 else
409 #endif
410 #ifdef _HEVC_ENCODE_VME_SUPPORTED
411 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
412 {
413 if (CodecHalIsFeiEncode(info->CodecFunction))
414 {
415 encoder = MOS_New(Encode::HevcFei, hwInterface, debugInterface, info);
416 }
417 else
418 {
419 encoder = MOS_New(Encode::HevcEnc, hwInterface, debugInterface, info);
420 }
421
422 if (encoder == nullptr)
423 {
424 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
425 return MOS_STATUS_INVALID_PARAMETER;
426 }
427 else
428 {
429 m_codechalDevice = encoder;
430 }
431
432 encoder->m_kernelBase = (uint8_t*)IGCODECKRN_G9;
433 }
434 else
435 #endif
436 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
437 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
438 {
439 if (CodecHalIsFeiEncode(info->CodecFunction))
440 {
441 #ifdef _AVC_ENCODE_VME_SUPPORTED
442 encoder = MOS_New(Encode::AvcFei, hwInterface, debugInterface, info);
443 #endif
444 }
445 else if (CodecHalUsesVdencEngine(info->CodecFunction))
446 {
447 #ifdef _AVC_ENCODE_VDENC_SUPPORTED
448 encoder = MOS_New(Encode::AvcVdenc, hwInterface, debugInterface, info);
449 #endif
450 }
451 else
452 {
453 #ifdef _AVC_ENCODE_VME_SUPPORTED
454 encoder = MOS_New(Encode::AvcEnc, hwInterface, debugInterface, info);
455 #endif
456 }
457 if (encoder == nullptr)
458 {
459 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
460 return MOS_STATUS_INVALID_PARAMETER;
461 }
462 else
463 {
464 m_codechalDevice = encoder;
465 }
466 }
467 else
468 #endif
469 #ifdef _VP8_ENCODE_SUPPORTED
470 if (info->Mode == CODECHAL_ENCODE_MODE_VP8)
471 {
472 // Setup encode interface functions
473 encoder = MOS_New(Encode::Vp8, hwInterface, debugInterface, info);
474 if (encoder == nullptr)
475 {
476 CODECHAL_PUBLIC_ASSERTMESSAGE("VP8 Encode allocation failed!");
477 return MOS_STATUS_INVALID_PARAMETER;
478 }
479 else
480 {
481 m_codechalDevice = encoder;
482 }
483 }
484 else
485 #endif
486 {
487 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
488 return MOS_STATUS_INVALID_PARAMETER;
489 }
490 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
491 if (info->Mode != CODECHAL_ENCODE_MODE_JPEG)
492 {
493 // Create CSC and Downscaling interface
494 if ((encoder->m_cscDsState = MOS_New(Encode::CscDs, encoder)) == nullptr)
495 {
496 return MOS_STATUS_INVALID_PARAMETER;
497 }
498 }
499 #endif
500 }
501 else
502 {
503 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
504 return MOS_STATUS_INVALID_PARAMETER;
505 }
506
507 return MOS_STATUS_SUCCESS;
508 }
509
510 static bool sklRegisteredCMHal =
511 MediaFactory<uint32_t, CMHalDevice>::
512 Register<CMHalInterfacesG9Skl>((uint32_t)IGFX_SKYLAKE);
513
514 MOS_STATUS CMHalInterfacesG9Skl::Initialize(CM_HAL_STATE *pCmState)
515 {
516 if (pCmState == nullptr)
517 {
518 MHW_ASSERTMESSAGE("pCmState is nullptr.")
519 return MOS_STATUS_INVALID_PARAMETER;
520 }
521
522 m_cmhalDevice = MOS_New(CMHal, pCmState);
523 if (m_cmhalDevice == nullptr)
524 {
525 MHW_ASSERTMESSAGE("Create CM Hal interfaces failed.")
526 return MOS_STATUS_NO_SPACE;
527 }
528
529 int gengt = PLATFORM_INTEL_GT2;
530 if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT1))
531 {
532 gengt = PLATFORM_INTEL_GT1;
533 }
534 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT1_5))
535 {
536 gengt = PLATFORM_INTEL_GT1_5;
537 }
538 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT2))
539 {
540 gengt = PLATFORM_INTEL_GT2;
541 }
542 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT3))
543 {
544 gengt = PLATFORM_INTEL_GT3;
545 }
546 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT4))
547 {
548 gengt = PLATFORM_INTEL_GT4;
549 }
550
551 m_cmhalDevice->SetGenPlatformInfo(PLATFORM_INTEL_SKL, gengt, "SKL");
552 uint32_t cisaID = GENX_SKL;
553 m_cmhalDevice->AddSupportedCisaIDs(&cisaID);
554 return MOS_STATUS_SUCCESS;
555 }
556
557 static bool sklRegisteredRenderHal =
558 MediaFactory<uint32_t, RenderHalDevice>::
559 Register<RenderHalInterfacesG9Skl>((uint32_t)IGFX_SKYLAKE);
560
561 MOS_STATUS RenderHalInterfacesG9Skl::Initialize()
562 {
563 m_renderhalDevice = MOS_New(XRenderHal);
564 if (m_renderhalDevice == nullptr)
565 {
566 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
567 return MOS_STATUS_NO_SPACE;
568 }
569 return MOS_STATUS_SUCCESS;
570 }
571
572 static bool sklRegisteredDecodeHistogram =
573 MediaFactory<uint32_t, DecodeHistogramDevice>::
574 Register<DecodeHistogramDeviceG9Skl>((uint32_t)IGFX_SKYLAKE);
575
576 MOS_STATUS DecodeHistogramDeviceG9Skl::Initialize(
577 CodechalHwInterface *hwInterface,
578 PMOS_INTERFACE osInterface)
579 {
580 m_decodeHistogramDevice = MOS_New(DecodeHistogramVebox, hwInterface, osInterface);
581
582 if (m_decodeHistogramDevice == nullptr)
583 {
584 MHW_ASSERTMESSAGE("Create vebox decode histogram interfaces failed.")
585 return MOS_STATUS_NO_SPACE;
586 }
587
588 return MOS_STATUS_SUCCESS;
589 }
590