Debian Codegraph @

media_driver/media_interface/media_interfaces_m9_glk/media_interfaces_g9_glk.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_glk.cpp
24 //! \brief Helps with gen-specific factory creation.
25 //!
26
27 #include "media_interfaces_g9_kbl.h"
28 #include "media_interfaces_g9_glk.h"
29 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
30 #include "igcodeckrn_g9.h"
31 #endif
32
33 extern template class MediaFactory<uint32_t, MhwInterfaces>;
34 extern template class MediaFactory<uint32_t, MmdDevice>;
35 extern template class MediaFactory<uint32_t, CodechalDevice>;
36 extern template class MediaFactory<uint32_t, CMHalDevice>;
37 extern template class MediaFactory<uint32_t, VphalDevice>;
38 extern template class MediaFactory<uint32_t, RenderHalDevice>;
39 extern template class MediaFactory<uint32_t, Nv12ToP010Device>;
40 extern template class MediaFactory<uint32_t, DecodeHistogramDevice>;
41
42 #define PLATFORM_INTEL_GLK 16
43 #define GENX_SKL 5
44 #define GENX_BXT 6
45
46 static bool glkRegisteredVphal =
47 MediaFactory<uint32_t, VphalDevice>::
48 Register<VphalInterfacesG9Glk>((uint32_t)IGFX_GEMINILAKE);
49
50 MOS_STATUS VphalInterfacesG9Glk::Initialize(
51 PMOS_INTERFACE osInterface,
52 bool bInitVphalState,
53 MOS_STATUS *eStatus,
54 bool clearViewMode)
55 {
56 m_vpBase = MOS_New(
57 VphalState,
58 osInterface,
59 eStatus);
60
61 return *eStatus;
62 }
63
64 static bool glkRegisteredMhw =
65 MediaFactory<uint32_t, MhwInterfaces>::
66 Register<MhwInterfacesG9Kbl>((uint32_t)IGFX_GEMINILAKE);
67
68 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
69 static bool glkRegisteredMmd =
70 MediaFactory<uint32_t, MmdDevice>::
71 Register<MmdDeviceG9Kbl>((uint32_t)IGFX_GEMINILAKE);
72 #endif
73
74 static bool glkRegisteredNv12ToP010 =
75 MediaFactory<uint32_t, Nv12ToP010Device>::
76 Register<Nv12ToP010DeviceG9Glk>((uint32_t)IGFX_GEMINILAKE);
77
78 MOS_STATUS Nv12ToP010DeviceG9Glk::Initialize(
79 PMOS_INTERFACE osInterface)
80 {
81 m_nv12ToP010device = MOS_New(Nv12ToP010, osInterface);
82
83 if (m_nv12ToP010device == nullptr)
84 {
85 MHW_ASSERTMESSAGE("Create Nv12 to P010 interfaces failed.")
86 return MOS_STATUS_NO_SPACE;
87 }
88
89 return MOS_STATUS_SUCCESS;
90 }
91
92 static bool glkRegisteredCodecHal =
93 MediaFactory<uint32_t, CodechalDevice>::
94 Register<CodechalInterfacesG9Glk>((uint32_t)IGFX_GEMINILAKE);
95
96 MOS_STATUS CodechalInterfacesG9Glk::Initialize(
97 void *standardInfo,
98 void *settings,
99 MhwInterfaces *mhwInterfaces,
100 PMOS_INTERFACE osInterface)
101 {
102 if (standardInfo == nullptr ||
103 mhwInterfaces == nullptr ||
104 osInterface == nullptr)
105 {
106 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
107 return MOS_STATUS_INVALID_PARAMETER;
108 }
109 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
110 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
111
112 CodechalHwInterface *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces);
113
114 if (hwInterface == nullptr)
115 {
116 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
117 return MOS_STATUS_NO_SPACE;
118 }
119 #if USE_CODECHAL_DEBUG_TOOL
120 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
121 if (debugInterface == nullptr)
122 {
123 MOS_Delete(hwInterface);
124 mhwInterfaces->SetDestroyState(true);
125 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
126 return MOS_STATUS_NO_SPACE;
127 }
128 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
129 {
130 MOS_Delete(hwInterface);
131 mhwInterfaces->SetDestroyState(true);
132 MOS_Delete(debugInterface);
133 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
134 return MOS_STATUS_INVALID_PARAMETER;
135 }
136 #else
137 CodechalDebugInterface *debugInterface = nullptr;
138 #endif // USE_CODECHAL_DEBUG_TOOL
139
140 if (CodecHalIsDecode(CodecFunction))
141 {
142 #ifdef _MPEG2_DECODE_SUPPORTED
143 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
144 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
145 {
146 m_codechalDevice = MOS_New(Decode::Mpeg2, hwInterface, debugInterface, info);
147 }
148 else
149 #endif
150 #ifdef _VC1_DECODE_SUPPORTED
151 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
152 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
153 {
154 m_codechalDevice = MOS_New(Decode::Vc1, hwInterface, debugInterface, info);
155 }
156 else
157 #endif
158 #ifdef _AVC_DECODE_SUPPORTED
159 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
160 {
161 m_codechalDevice = MOS_New(Decode::Avc, hwInterface, debugInterface, info);
162
163 if (m_codechalDevice == nullptr)
164 {
165 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
166 return MOS_STATUS_NO_SPACE;
167 }
168 #ifdef _DECODE_PROCESSING_SUPPORTED
169 if (settings != nullptr && ((CodechalSetting *)settings)->downsamplingHinted)
170 {
171 CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(m_codechalDevice);
172 if (decoder == nullptr)
173 {
174 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
175 return MOS_STATUS_NO_SPACE;
176 }
177 FieldScalingInterface *fieldScalingInterface =
178 MOS_New(Decode::FieldScaling, hwInterface);
179 if (fieldScalingInterface == nullptr)
180 {
181 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create field scaling interface!");
182 return MOS_STATUS_NO_SPACE;
183 }
184 decoder->m_fieldScalingInterface = fieldScalingInterface;
185 }
186 #endif
187 }
188 else
189 #endif
190 #ifdef _JPEG_DECODE_SUPPORTED
191 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
192 {
193 m_codechalDevice = MOS_New(Decode::Jpeg, hwInterface, debugInterface, info);
194 }
195 else
196 #endif
197 #ifdef _VP8_DECODE_SUPPORTED
198 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
199 {
200 m_codechalDevice = MOS_New(Decode::Vp8, hwInterface, debugInterface, info);
201 }
202 else
203 #endif
204 #ifdef _HEVC_DECODE_SUPPORTED
205 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
206 {
207 m_codechalDevice = MOS_New(Decode::Hevc, hwInterface, debugInterface, info);
208 }
209 else
210 #endif
211 #ifdef _VP9_DECODE_SUPPORTED
212 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
213 {
214 m_codechalDevice = MOS_New(Decode::Vp9, hwInterface, debugInterface, info);
215 }
216 else
217 #endif
218 {
219 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
220 return MOS_STATUS_INVALID_PARAMETER;
221 }
222
223 if (m_codechalDevice == nullptr)
224 {
225 MOS_Delete(hwInterface);
226 mhwInterfaces->SetDestroyState(true);
227 #if USE_CODECHAL_DEBUG_TOOL
228 MOS_Delete(debugInterface);
229 #endif
230 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
231 return MOS_STATUS_NO_SPACE;
232 }
233 }
234 else if (CodecHalIsEncode(CodecFunction))
235 {
236 CodechalEncoderState *encoder = nullptr;
237 #ifdef _MPEG2_ENCODE_VME_SUPPORTED
238 if (info->Mode == CODECHAL_ENCODE_MODE_MPEG2)
239 {
240 // Setup encode interface functions
241 encoder = MOS_New(Encode::Mpeg2, hwInterface, debugInterface, info);
242 if (encoder == nullptr)
243 {
244 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode allocation failed!");
245 return MOS_STATUS_INVALID_PARAMETER;
246 }
247 else
248 {
249 m_codechalDevice = encoder;
250 }
251
252 encoder->m_kernelBase = (uint8_t*)IGCODECKRN_G9;
253 }
254 else
255 #endif
256 #ifdef _JPEG_ENCODE_SUPPORTED
257 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
258 {
259 encoder = MOS_New(Encode::Jpeg, hwInterface, debugInterface, info);
260 if (encoder == nullptr)
261 {
262 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
263 return MOS_STATUS_INVALID_PARAMETER;
264 }
265 else
266 {
267 m_codechalDevice = encoder;
268 }
269 encoder->m_needCheckCpEnabled = true;
270 }
271 else
272 #endif
273 #ifdef _HEVC_ENCODE_VME_SUPPORTED
274 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
275 {
276 encoder = MOS_New(Encode::HevcEnc, hwInterface, debugInterface, info);
277 if (encoder == nullptr)
278 {
279 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
280 return MOS_STATUS_INVALID_PARAMETER;
281 }
282 else
283 {
284 m_codechalDevice = encoder;
285 }
286
287 encoder->m_kernelBase = (uint8_t*)IGCODECKRN_G9;
288 }
289 else
290 #endif
291 #if defined (_AVC_ENCODE_VME_SUPPORTED) || defined (_AVC_ENCODE_VDENC_SUPPORTED)
292 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
293 {
294 if (CodecHalUsesVdencEngine(info->CodecFunction))
295 {
296 #ifdef _AVC_ENCODE_VDENC_SUPPORTED
297 encoder = MOS_New(Encode::AvcVdenc, hwInterface, debugInterface, info);
298 #endif
299 }
300 else
301 {
302 #ifdef _AVC_ENCODE_VME_SUPPORTED
303 encoder = MOS_New(Encode::AvcEnc, hwInterface, debugInterface, info);
304 #endif
305 }
306
307 if (encoder == nullptr)
308 {
309 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
310 return MOS_STATUS_INVALID_PARAMETER;
311 }
312 else
313 {
314 m_codechalDevice = encoder;
315 }
316 }
317 else
318 #endif
319 #ifdef _VP8_ENCODE_SUPPORTED
320 if (info->Mode == CODECHAL_ENCODE_MODE_VP8)
321 {
322 // Setup encode interface functions
323 encoder = MOS_New(Encode::Vp8, hwInterface, debugInterface, info);
324 if (encoder == nullptr)
325 {
326 CODECHAL_PUBLIC_ASSERTMESSAGE("VP8 Encode allocation failed!");
327 return MOS_STATUS_INVALID_PARAMETER;
328 }
329 else
330 {
331 m_codechalDevice = encoder;
332 }
333 }
334 else
335 #endif
336 {
337 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
338 return MOS_STATUS_INVALID_PARAMETER;
339 }
340 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
341 if (info->Mode != CODECHAL_ENCODE_MODE_JPEG)
342 {
343 // Create CSC and Downscaling interface
344 if ((encoder->m_cscDsState = MOS_New(Encode::CscDs, encoder)) == nullptr)
345 {
346 return MOS_STATUS_INVALID_PARAMETER;
347 }
348 }
349 #endif
350 }
351 else
352 {
353 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
354 return MOS_STATUS_INVALID_PARAMETER;
355 }
356
357 return MOS_STATUS_SUCCESS;
358 }
359
360 static bool glkRegisteredCMHal =
361 MediaFactory<uint32_t, CMHalDevice>::
362 Register<CMHalInterfacesG9Glk>((uint32_t)IGFX_GEMINILAKE);
363
364 MOS_STATUS CMHalInterfacesG9Glk::Initialize(CM_HAL_STATE *pCmState)
365 {
366 if (pCmState == nullptr)
367 {
368 MHW_ASSERTMESSAGE("pCmState is nullptr.")
369 return MOS_STATUS_INVALID_PARAMETER;
370 }
371
372 m_cmhalDevice = MOS_New(CMHal, pCmState);
373 if (m_cmhalDevice == nullptr)
374 {
375 MHW_ASSERTMESSAGE("Create CM Hal interfaces failed.")
376 return MOS_STATUS_NO_SPACE;
377 }
378 int gengt = PLATFORM_INTEL_GT2;
379 if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT1 ))
380 {
381 gengt = PLATFORM_INTEL_GT1;
382 }
383 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT1_5))
384 {
385 gengt = PLATFORM_INTEL_GT1_5;
386 }
387 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT2 ))
388 {
389 gengt = PLATFORM_INTEL_GT2;
390 }
391 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT3 ))
392 {
393 gengt = PLATFORM_INTEL_GT3;
394 }
395 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT4 ))
396 {
397 gengt = PLATFORM_INTEL_GT4;
398 }
399
400 m_cmhalDevice->SetGenPlatformInfo(PLATFORM_INTEL_GLK, gengt, "BXT");
401 uint32_t cisaIDs[] = {GENX_BXT, GENX_SKL};
402 m_cmhalDevice->AddSupportedCisaIDs(cisaIDs, 2);
403
404 CM_HAL_G9_X *pGen9Device = static_cast<CM_HAL_G9_X *>(m_cmhalDevice);
405 const char *CmSteppingInfo_GLK[] = { "A0", "A1", "n/a", "B0" };
406 pGen9Device->OverwriteSteppingTable(CmSteppingInfo_GLK, sizeof(CmSteppingInfo_GLK)/sizeof(const char *));
407 return MOS_STATUS_SUCCESS;
408 }
409
410 static bool glkRegisteredRenderHal =
411 MediaFactory<uint32_t, RenderHalDevice>::
412 Register<RenderHalInterfacesG9Kbl>((uint32_t)IGFX_GEMINILAKE);
413
414
415 static bool glkRegisteredDecodeHistogram =
416 MediaFactory<uint32_t, DecodeHistogramDevice>::
417 Register<DecodeHistogramDeviceG9Glk>((uint32_t)IGFX_GEMINILAKE);
418
419 MOS_STATUS DecodeHistogramDeviceG9Glk::Initialize(
420 CodechalHwInterface *hwInterface,
421 PMOS_INTERFACE osInterface)
422 {
423 m_decodeHistogramDevice = MOS_New(DecodeHistogramVebox, hwInterface, osInterface);
424
425 if (m_decodeHistogramDevice == nullptr)
426 {
427 MHW_ASSERTMESSAGE("Create vebox decode histogram interfaces failed.")
428 return MOS_STATUS_NO_SPACE;
429 }
430
431 return MOS_STATUS_SUCCESS;
432 }