Debian Codegraph @

media_driver/media_interface/media_interfaces_m8_bdw/media_interfaces_g8_bdw.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_g8_bdw.cpp
24 //! \brief Helps with BDW factory creation.
25 //!
26
27 #include "media_interfaces_g8_bdw.h"
28 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
29 #include "igcodeckrn_g8.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
47 static bool bdwRegisteredVphal =
48 MediaFactory<uint32_t, VphalDevice>::
49 Register<VphalInterfacesG8Bdw>((uint32_t)IGFX_BROADWELL);
50
51 MOS_STATUS VphalInterfacesG8Bdw::Initialize(
52 PMOS_INTERFACE osInterface,
53 bool bInitVphalState,
54 MOS_STATUS *eStatus,
55 bool clearViewMode)
56 {
57 m_vpBase = MOS_New(
58 VphalState,
59 osInterface,
60 eStatus);
61
62 return *eStatus;
63 }
64
65 static bool bdwRegisteredMhw =
66 MediaFactory<uint32_t, MhwInterfaces>::
67 Register<MhwInterfacesG8Bdw>((uint32_t)IGFX_BROADWELL);
68
69 #define PLATFORM_INTEL_BDW 4
70 #define GENX_BDW 3
71
72 MOS_STATUS MhwInterfacesG8Bdw::Initialize(
73 CreateParams params,
74 PMOS_INTERFACE osInterface)
75 {
76 if (osInterface == nullptr)
77 {
78 MHW_ASSERTMESSAGE("The OS interface is not valid!");
79 return MOS_STATUS_INVALID_PARAMETER;
80 }
81
82 auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
83 if (gtSystemInfo == nullptr)
84 {
85 MHW_ASSERTMESSAGE("The OS interface is not valid!");
86 return MOS_STATUS_INVALID_PARAMETER;
87 }
88
89 if ((params.m_isCp == false) && (params.Flags.m_value == 0))
90 {
91 MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
92 return MOS_STATUS_INVALID_PARAMETER;
93 }
94
95 // MHW_CP and MHW_MI must always be created
96 MOS_STATUS status;
97 m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
98 m_miInterface = MOS_New(Mi, m_cpInterface, osInterface);
99
100 if (params.Flags.m_render)
101 {
102 m_renderInterface =
103 MOS_New(Render, m_miInterface, osInterface, gtSystemInfo, params.m_heapMode);
104 }
105 if (params.Flags.m_stateHeap)
106 {
107 m_stateHeapInterface =
108 MOS_New(StateHeap, osInterface, params.m_heapMode);
109 }
110 if (params.Flags.m_vebox)
111 {
112 m_veboxInterface = MOS_New(Vebox, osInterface);
113 }
114
115 if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
116 {
117 m_mfxInterface =
118 MOS_New(Mfx, osInterface, m_miInterface, m_cpInterface, params.m_isDecode);
119 }
120
121 return MOS_STATUS_SUCCESS;
122 }
123
124 static bool bdwRegisteredCodecHal =
125 MediaFactory<uint32_t, CodechalDevice>::
126 Register<CodechalInterfacesG8Bdw>((uint32_t)IGFX_BROADWELL);
127
128 MOS_STATUS CodechalInterfacesG8Bdw::Initialize(
129 void *standardInfo,
130 void *settings,
131 MhwInterfaces *mhwInterfaces,
132 PMOS_INTERFACE osInterface)
133 {
134 if (standardInfo == nullptr ||
135 mhwInterfaces == nullptr ||
136 osInterface == nullptr)
137 {
138 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
139 return MOS_STATUS_INVALID_PARAMETER;
140 }
141 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
142 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
143
144 CodechalHwInterface *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces);
145
146 if (hwInterface == nullptr)
147 {
148 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
149 return MOS_STATUS_NO_SPACE;
150 }
151 #if USE_CODECHAL_DEBUG_TOOL
152 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
153 if (debugInterface == nullptr)
154 {
155 MOS_Delete(hwInterface);
156 mhwInterfaces->SetDestroyState(true);
157 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
158 return MOS_STATUS_NO_SPACE;
159 }
160 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
161 {
162 MOS_Delete(hwInterface);
163 mhwInterfaces->SetDestroyState(true);
164 MOS_Delete(debugInterface);
165 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
166 return MOS_STATUS_INVALID_PARAMETER;
167 }
168 #else
169 CodechalDebugInterface *debugInterface = nullptr;
170 #endif // USE_CODECHAL_DEBUG_TOOL
171
172 if (CodecHalIsDecode(CodecFunction))
173 {
174 #ifdef _MPEG2_DECODE_SUPPORTED
175 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
176 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
177 {
178 m_codechalDevice = MOS_New(Decode::Mpeg2, hwInterface, debugInterface, info);
179 }
180 else
181 #endif
182 #ifdef _VC1_DECODE_SUPPORTED
183 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
184 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
185 {
186 m_codechalDevice = MOS_New(Decode::Vc1, hwInterface, debugInterface, info);
187 }
188 else
189 #endif
190 #ifdef _AVC_DECODE_SUPPORTED
191 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
192 {
193 m_codechalDevice = MOS_New(Decode::Avc, hwInterface, debugInterface, info);
194 }
195 else
196 #endif
197 #ifdef _JPEG_DECODE_SUPPORTED
198 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
199 {
200 m_codechalDevice = MOS_New(Decode::Jpeg, hwInterface, debugInterface, info);
201 }
202 else
203 #endif
204 #ifdef _VP8_DECODE_SUPPORTED
205 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
206 {
207 m_codechalDevice = MOS_New(Decode::Vp8, hwInterface, debugInterface, info);
208 }
209 else
210 #endif
211 #ifdef _HEVC_DECODE_SUPPORTED
212 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
213 {
214 #ifdef _HYBRID_HEVC_DECODE_SUPPORTED
215 if (info->bIsHybridCodec)
216 {
217 m_codechalDevice = MOS_New(CodechalDecodeHybridHevcState, hwInterface, debugInterface, info);
218 }
219 else
220 #endif
221 {
222 m_codechalDevice = MOS_New(Decode::Hevc, hwInterface, debugInterface, info);
223 }
224 }
225 else
226 #endif
227 #ifdef _VP9_DECODE_SUPPORTED
228 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
229 {
230 #ifdef _HYBRID_VP9_DECODE_SUPPORTED
231 if (info->bIsHybridCodec)
232 {
233 m_codechalDevice = MOS_New(CodechalDecodeHybridVp9State, hwInterface, debugInterface, info);
234 }
235 else
236 #endif
237 {
238 m_codechalDevice = MOS_New(Decode::Vp9, hwInterface, debugInterface, info);
239 }
240 }
241 else
242 #endif
243 {
244 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
245 return MOS_STATUS_INVALID_PARAMETER;
246 }
247
248 CodechalDecode *decoder = dynamic_cast<CodechalDecode *>(m_codechalDevice);
249 if (decoder == nullptr)
250 {
251 MOS_Delete(hwInterface);
252 mhwInterfaces->SetDestroyState(true);
253 #if USE_CODECHAL_DEBUG_TOOL
254 MOS_Delete(debugInterface);
255 #endif
256 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
257 return MOS_STATUS_NO_SPACE;
258 }
259 }
260 else if (CodecHalIsEncode(CodecFunction))
261 {
262 CodechalEncoderState *encoder = nullptr;
263 #ifdef _MPEG2_ENCODE_VME_SUPPORTED
264 if (info->Mode == CODECHAL_ENCODE_MODE_MPEG2)
265 {
266 // Setup encode interface functions
267 encoder = MOS_New(Encode::Mpeg2, hwInterface, debugInterface, info);
268 if (encoder == nullptr)
269 {
270 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode allocation failed!");
271 return MOS_STATUS_INVALID_PARAMETER;
272 }
273 else
274 {
275 m_codechalDevice = encoder;
276 }
277
278 encoder->m_kernelBase = (uint8_t*)IGCODECKRN_G8;
279 }
280 else
281 #endif
282 #ifdef _JPEG_ENCODE_SUPPORTED
283 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
284 {
285 encoder = MOS_New(Encode::Jpeg, hwInterface, debugInterface, info);
286 if (encoder == nullptr)
287 {
288 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
289 return MOS_STATUS_INVALID_PARAMETER;
290 }
291 else
292 {
293 m_codechalDevice = encoder;
294 }
295 encoder->m_needCheckCpEnabled = true;
296 }
297 else
298 #endif
299 #ifdef _AVC_ENCODE_VME_SUPPORTED
300 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
301 {
302 if (CodecHalIsFeiEncode(info->CodecFunction))
303 {
304 encoder = MOS_New(Encode::AvcFei, hwInterface, debugInterface, info);
305 }
306 else
307 {
308 encoder = MOS_New(Encode::AvcEnc, hwInterface, debugInterface, info);
309 }
310 if (encoder == nullptr)
311 {
312 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
313 return MOS_STATUS_INVALID_PARAMETER;
314 }
315 else
316 {
317 m_codechalDevice = encoder;
318 }
319 }
320 else
321 #endif
322 {
323 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
324 return MOS_STATUS_INVALID_PARAMETER;
325 }
326 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
327 if (info->Mode != CODECHAL_ENCODE_MODE_JPEG)
328 {
329 // Create CSC and Downscaling interface
330 if ((encoder->m_cscDsState = MOS_New(Encode::CscDs, encoder)) == nullptr)
331 {
332 return MOS_STATUS_INVALID_PARAMETER;
333 }
334 }
335 #endif
336 }
337 else
338 {
339 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
340 return MOS_STATUS_INVALID_PARAMETER;
341 }
342
343 return MOS_STATUS_SUCCESS;
344 }
345
346 static bool bdwRegisteredCMHal =
347 MediaFactory<uint32_t, CMHalDevice>::
348 Register<CMHalInterfacesG8Bdw>((uint32_t)IGFX_BROADWELL);
349
350 MOS_STATUS CMHalInterfacesG8Bdw::Initialize(CM_HAL_STATE *pCmState)
351 {
352 if (pCmState == nullptr)
353 {
354 MHW_ASSERTMESSAGE("pCmState is nullptr.")
355 return MOS_STATUS_INVALID_PARAMETER;
356 }
357
358 m_cmhalDevice = MOS_New(CMHal, pCmState);
359 if (m_cmhalDevice == nullptr)
360 {
361 MHW_ASSERTMESSAGE("Create CM Hal interfaces failed.")
362 return MOS_STATUS_NO_SPACE;
363 }
364 uint32_t gengt = PLATFORM_INTEL_GT2;
365
366 if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT1 ))
367 {
368 gengt = PLATFORM_INTEL_GT1;
369 }
370 else if (MEDIA_IS_SKU(pCmState->skuTable, FtrGT1_5))
371 {
372 gengt = PLATFORM_INTEL_GT1_5;
373 }
374 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT2 ))
375 {
376 gengt = PLATFORM_INTEL_GT2;
377 }
378 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT3 ))
379 {
380 gengt = PLATFORM_INTEL_GT3;
381 }
382 else if( MEDIA_IS_SKU(pCmState->skuTable, FtrGT4 ))
383 {
384 gengt = PLATFORM_INTEL_GT4;
385 }
386 m_cmhalDevice->SetGenPlatformInfo(PLATFORM_INTEL_BDW, gengt, "BDW");
387 uint32_t cisaID = GENX_BDW;
388 m_cmhalDevice->AddSupportedCisaIDs(&cisaID);
389 return MOS_STATUS_SUCCESS;
390 }
391
392 static bool bdwRegisteredRenderHal =
393 MediaFactory<uint32_t, RenderHalDevice>::
394 Register<RenderHalInterfacesG8Bdw>((uint32_t)IGFX_BROADWELL);
395
396 MOS_STATUS RenderHalInterfacesG8Bdw::Initialize()
397 {
398 m_renderhalDevice = MOS_New(XRenderHal);
399 if (m_renderhalDevice == nullptr)
400 {
401 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
402 return MOS_STATUS_NO_SPACE;
403 }
404 return MOS_STATUS_SUCCESS;
405 }