1 /*
2 * Copyright (c) 2017-2021, 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_libva_caps_g11.cpp
24 //! \brief This file implements the C++ class/interface for gen11 media capbilities.
25 //!
26
27 #include "codec_def_encode_hevc_g11.h"
28 #include "media_libva_util.h"
29 #include "media_libva.h"
30 #include "media_libva_caps_cp_interface.h"
31 #include "media_libva_caps_g11.h"
32 #include "media_libva_caps_factory.h"
33 #include "media_ddi_decode_const.h"
34 #include "media_ddi_encode_const.h"
35 #include "media_ddi_decode_const_g11.h"
36 #include "media_libva_vp.h"
37
38 const VAImageFormat m_supportedImageformatsG11[] =
39 { {VA_FOURCC_BGRA, VA_LSB_FIRST, 32, 32, 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff}, /* [31:0] B:G:R:A 8:8:8:8 little endian */
40 {VA_FOURCC_RGBA, VA_LSB_FIRST, 32, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff}, /* [31:0] R:G:B:A 8:8:8:8 little endian */
41 {VA_FOURCC_BGRX, VA_LSB_FIRST, 32, 24, 0x0000ff00, 0x00ff0000, 0xff000000, 0}, /* [31:0] B:G:R:x 8:8:8:8 little endian */
42 {VA_FOURCC_RGBX, VA_LSB_FIRST, 32, 24, 0xff000000, 0x00ff0000, 0x0000ff00, 0}, /* [31:0] R:G:B:x 8:8:8:8 little endian */
43 {VA_FOURCC_A2R10G10B10, VA_LSB_FIRST, 32, 30, 0x3ff00000, 0x000ffc00, 0x000003ff, 0x30000000}, /* [31:0] A:R:G:B 2:10:10:10 little endian */
44 {VA_FOURCC_A2B10G10R10, VA_LSB_FIRST, 32, 30, 0x000003ff, 0x000ffc00, 0x3ff00000, 0x30000000}, /* [31:0] A:B:G:R 2:10:10:10 little endian */
45 {VA_FOURCC_X2R10G10B10, VA_LSB_FIRST, 32, 30, 0x3ff00000, 0x000ffc00, 0x000003ff, 0}, /* [31:0] X:R:G:B 2:10:10:10 little endian */
46 {VA_FOURCC_X2B10G10R10, VA_LSB_FIRST, 32, 30, 0x000003ff, 0x000ffc00, 0x3ff00000, 0}, /* [31:0] X:B:G:R 2:10:10:10 little endian */
47 {VA_FOURCC_RGB565, VA_LSB_FIRST, 16, 16, 0xf800, 0x07e0, 0x001f, 0}, /* [15:0] R:G:B 5:6:5 little endian */
48 {VA_FOURCC_AYUV, VA_LSB_FIRST, 32, 0,0,0,0,0},
49 #if VA_CHECK_VERSION(1, 13, 0)
50 {VA_FOURCC_XYUV, VA_LSB_FIRST, 32, 0,0,0,0,0},
51 #endif
52 {VA_FOURCC_Y800, VA_LSB_FIRST, 8, 0,0,0,0,0},
53 {VA_FOURCC_NV12, VA_LSB_FIRST, 12, 0,0,0,0,0},
54 {VA_FOURCC_NV21, VA_LSB_FIRST, 12, 0,0,0,0,0},
55 {VA_FOURCC_YUY2, VA_LSB_FIRST, 16, 0,0,0,0,0},
56 {VA_FOURCC_UYVY, VA_LSB_FIRST, 16, 0,0,0,0,0},
57 {VA_FOURCC_YV12, VA_LSB_FIRST, 12, 0,0,0,0,0},
58 {VA_FOURCC_I420, VA_LSB_FIRST, 12, 0,0,0,0,0},
59 {VA_FOURCC_411P, VA_LSB_FIRST, 12, 0,0,0,0,0},
60 {VA_FOURCC_422H, VA_LSB_FIRST, 16, 0,0,0,0,0},
61 {VA_FOURCC_422V, VA_LSB_FIRST, 16, 0,0,0,0,0},
62 {VA_FOURCC_444P, VA_LSB_FIRST, 24, 0,0,0,0,0},
63 {VA_FOURCC_IMC3, VA_LSB_FIRST, 16, 0,0,0,0,0},
64 {VA_FOURCC_P010, VA_LSB_FIRST, 24, 0,0,0,0,0},
65 {VA_FOURCC_Y210, VA_LSB_FIRST, 32, 0,0,0,0,0},
66 {VA_FOURCC_Y410, VA_LSB_FIRST, 32, 0,0,0,0,0}
67 };
68
69 const VAConfigAttribValEncRateControlExt MediaLibvaCapsG11::m_encVp9RateControlExt =
70 {
71 {CODECHAL_ENCODE_VP9_MAX_NUM_TEMPORAL_LAYERS - 1, 1, 0}
72 };
73
QueryImageFormats(VAImageFormat * formatList,int32_t * numFormats)74 VAStatus MediaLibvaCapsG11::QueryImageFormats(VAImageFormat *formatList, int32_t *numFormats)
75 {
76 DDI_CHK_NULL(formatList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
77 DDI_CHK_NULL(numFormats, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
78 int32_t num = 0;
79 uint32_t maxNum = GetImageFormatsMaxNum();
80
81 memset(formatList, 0, sizeof(m_supportedImageformatsG11));
82 for (uint32_t idx = 0; idx < maxNum; idx++)
83 {
84 formatList[num].fourcc = m_supportedImageformatsG11[idx].fourcc;
85 formatList[num].byte_order = m_supportedImageformatsG11[idx].byte_order;
86 formatList[num].bits_per_pixel = m_supportedImageformatsG11[idx].bits_per_pixel;
87 formatList[num].depth = m_supportedImageformatsG11[idx].depth;
88 formatList[num].red_mask = m_supportedImageformatsG11[idx].red_mask;
89 formatList[num].green_mask = m_supportedImageformatsG11[idx].green_mask;
90 formatList[num].blue_mask = m_supportedImageformatsG11[idx].blue_mask;
91 formatList[num].alpha_mask = m_supportedImageformatsG11[idx].alpha_mask;
92 num++;
93 }
94 *numFormats = num;
95
96 return VA_STATUS_SUCCESS;
97 }
98
GetImageFormatsMaxNum()99 uint32_t MediaLibvaCapsG11::GetImageFormatsMaxNum()
100 {
101 return sizeof(m_supportedImageformatsG11)/sizeof(m_supportedImageformatsG11[0]);
102 }
103
IsImageSupported(uint32_t fourcc)104 bool MediaLibvaCapsG11::IsImageSupported(uint32_t fourcc)
105 {
106 uint32_t maxNum = GetImageFormatsMaxNum();
107 for (int32_t idx = 0; idx < maxNum; idx++)
108 {
109 if (m_supportedImageformatsG11[idx].fourcc == fourcc)
110 {
111 return true;
112 }
113 }
114
115 return false;
116 }
117
PopulateColorMaskInfo(VAImageFormat * vaImgFmt)118 VAStatus MediaLibvaCapsG11::PopulateColorMaskInfo(VAImageFormat *vaImgFmt)
119 {
120 uint32_t maxNum = GetImageFormatsMaxNum();
121
122 DDI_CHK_NULL(vaImgFmt, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
123
124 for (int32_t idx = 0; idx < maxNum; idx++)
125 {
126 if (m_supportedImageformatsG11[idx].fourcc == vaImgFmt->fourcc)
127 {
128 vaImgFmt->red_mask = m_supportedImageformatsG11[idx].red_mask;
129 vaImgFmt->green_mask = m_supportedImageformatsG11[idx].green_mask;
130 vaImgFmt->blue_mask = m_supportedImageformatsG11[idx].blue_mask;
131 vaImgFmt->alpha_mask = m_supportedImageformatsG11[idx].alpha_mask;
132
133 return VA_STATUS_SUCCESS;
134 }
135 }
136
137 return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
138 }
139
GetEncodeCodecMode(VAProfile profile,VAEntrypoint entrypoint)140 CODECHAL_MODE MediaLibvaCapsG11::GetEncodeCodecMode(VAProfile profile, VAEntrypoint entrypoint)
141 {
142 if (entrypoint == VAEntrypointStats)
143 {
144 return CODECHAL_ENCODE_MODE_AVC;
145 }
146
147 switch (profile)
148 {
149 case VAProfileH264High:
150 case VAProfileH264Main:
151 case VAProfileH264ConstrainedBaseline:
152 return CODECHAL_ENCODE_MODE_AVC;
153 case VAProfileMPEG2Main:
154 case VAProfileMPEG2Simple:
155 return CODECHAL_ENCODE_MODE_MPEG2;
156 case VAProfileJPEGBaseline:
157 return CODECHAL_ENCODE_MODE_JPEG;
158 case VAProfileVP8Version0_3:
159 return CODECHAL_ENCODE_MODE_VP8;
160 case VAProfileVP9Profile0:
161 case VAProfileVP9Profile1:
162 case VAProfileVP9Profile2:
163 case VAProfileVP9Profile3:
164 return CODECHAL_ENCODE_MODE_VP9;
165 case VAProfileHEVCMain:
166 case VAProfileHEVCMain10:
167 case VAProfileHEVCMain422_10:
168 case VAProfileHEVCMain444:
169 case VAProfileHEVCMain444_10:
170 return CODECHAL_ENCODE_MODE_HEVC;
171 default:
172 DDI_ASSERTMESSAGE("Invalid Encode Mode");
173 return CODECHAL_UNSUPPORTED_MODE;
174 }
175 }
176
GetDecodeCodecKey(VAProfile profile)177 std::string MediaLibvaCapsG11::GetDecodeCodecKey(VAProfile profile)
178 {
179 switch (profile)
180 {
181 case VAProfileH264High:
182 case VAProfileH264Main:
183 case VAProfileH264ConstrainedBaseline:
184 return DECODE_ID_AVC;
185 case VAProfileMPEG2Main:
186 case VAProfileMPEG2Simple:
187 return DECODE_ID_MPEG2;
188 case VAProfileJPEGBaseline:
189 return DECODE_ID_JPEG;
190 case VAProfileVP8Version0_3:
191 return DECODE_ID_VP8;
192 case VAProfileVP9Profile0:
193 case VAProfileVP9Profile1:
194 case VAProfileVP9Profile2:
195 case VAProfileVP9Profile3:
196 return DECODE_ID_VP9;
197 case VAProfileHEVCMain:
198 case VAProfileHEVCMain10:
199 case VAProfileHEVCMain12:
200 case VAProfileHEVCMain422_10:
201 case VAProfileHEVCMain422_12:
202 case VAProfileHEVCMain444:
203 case VAProfileHEVCMain444_10:
204 case VAProfileHEVCMain444_12:
205 return DECODE_ID_HEVC_G11;
206 case VAProfileVC1Simple:
207 case VAProfileVC1Main:
208 case VAProfileVC1Advanced:
209 return DECODE_ID_VC1;
210 default:
211 DDI_ASSERTMESSAGE("Invalid Encode Mode");
212 return DECODE_ID_NONE;
213 }
214 }
215
GetEncodeCodecKey(VAProfile profile,VAEntrypoint entrypoint,uint32_t feiFunction)216 std::string MediaLibvaCapsG11::GetEncodeCodecKey(VAProfile profile, VAEntrypoint entrypoint, uint32_t feiFunction)
217 {
218 switch (profile)
219 {
220 case VAProfileH264High:
221 case VAProfileH264Main:
222 case VAProfileH264ConstrainedBaseline:
223 if (IsEncFei(entrypoint, feiFunction))
224 {
225 return ENCODE_ID_AVCFEI;
226 }
227 else
228 {
229 return ENCODE_ID_AVC;
230 }
231 case VAProfileMPEG2Main:
232 case VAProfileMPEG2Simple:
233 return ENCODE_ID_MPEG2;
234 case VAProfileJPEGBaseline:
235 return ENCODE_ID_JPEG;
236 case VAProfileVP8Version0_3:
237 return ENCODE_ID_VP8;
238 case VAProfileVP9Profile0:
239 case VAProfileVP9Profile1:
240 case VAProfileVP9Profile2:
241 case VAProfileVP9Profile3:
242 return ENCODE_ID_VP9;
243 case VAProfileHEVCMain:
244 case VAProfileHEVCMain10:
245 case VAProfileHEVCMain422_10:
246 case VAProfileHEVCMain444:
247 case VAProfileHEVCMain444_10:
248 if (IsEncFei(entrypoint, feiFunction))
249 {
250 return ENCODE_ID_HEVCFEI;
251 }
252 else
253 {
254 return ENCODE_ID_HEVC;
255 }
256 case VAProfileNone:
257 if (IsEncFei(entrypoint, feiFunction))
258 {
259 return ENCODE_ID_AVCFEI;
260 }
261 else
262 {
263 return ENCODE_ID_NONE;
264 }
265 default:
266 return ENCODE_ID_NONE;
267 }
268 }
269
GetPlatformSpecificAttrib(VAProfile profile,VAEntrypoint entrypoint,VAConfigAttribType type,uint32_t * value)270 VAStatus MediaLibvaCapsG11::GetPlatformSpecificAttrib(VAProfile profile,
271 VAEntrypoint entrypoint,
272 VAConfigAttribType type,
273 uint32_t *value)
274 {
275 DDI_CHK_NULL(value, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
276 VAStatus status = VA_STATUS_SUCCESS;
277 *value = VA_ATTRIB_NOT_SUPPORTED;
278 switch ((int)type)
279 {
280 case VAConfigAttribEncMaxRefFrames:
281 {
282 // just VAConfigAttribEncMaxRefFrames of HEVC VME is different with platforms
283 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
284 {
285 *value = ENCODE_DP_HEVC_NUM_MAX_VME_L0_REF_G11 | (ENCODE_DP_HEVC_NUM_MAX_VME_L1_REF_G11 << 16);;
286 }
287 else
288 {
289 status = VA_STATUS_ERROR_INVALID_PARAMETER;
290 }
291 break;
292 }
293 case VAConfigAttribDecProcessing:
294 {
295 #ifdef _DECODE_PROCESSING_SUPPORTED
296 if ((IsAvcProfile(profile) || IsHevcProfile(profile)) && !(MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrDisableVDBox2SFC)))
297 {
298 *value = VA_DEC_PROCESSING;
299 }
300 else
301 #endif
302 {
303 *value = VA_DEC_PROCESSING_NONE;
304 }
305 break;
306 }
307 case VAConfigAttribEncIntraRefresh:
308 {
309 if(IsAvcProfile(profile) || (entrypoint == VAEntrypointEncSliceLP && IsHevcProfile(profile)))
310 {
311 *value = VA_ENC_INTRA_REFRESH_ROLLING_COLUMN | VA_ENC_INTRA_REFRESH_ROLLING_ROW;
312 }
313 else
314 {
315 *value = VA_ENC_INTRA_REFRESH_NONE;
316 }
317 break;
318 }
319 case VAConfigAttribEncROI:
320 {
321 if (entrypoint == VAEntrypointEncSliceLP)
322 {
323 status = VA_STATUS_ERROR_INVALID_PARAMETER;
324 }
325 else if (IsAvcProfile(profile))
326 {
327 VAConfigAttribValEncROI roi_attrib = {0};
328 roi_attrib.bits.num_roi_regions = ENCODE_DP_AVC_MAX_ROI_NUM_BRC;
329 roi_attrib.bits.roi_rc_priority_support = 1;
330 roi_attrib.bits.roi_rc_qp_delta_support = 1;
331 *value = roi_attrib.value;
332 }
333 else if (IsHevcProfile(profile))
334 {
335 VAConfigAttribValEncROI roi_attrib = {0};
336 roi_attrib.bits.num_roi_regions = CODECHAL_ENCODE_HEVC_MAX_NUM_ROI;
337 roi_attrib.bits.roi_rc_priority_support = 0;
338 roi_attrib.bits.roi_rc_qp_delta_support = 1;
339 *value = roi_attrib.value;
340 }
341 break;
342 }
343 case VAConfigAttribCustomRoundingControl:
344 {
345 *value = 1;
346 break;
347 }
348 case VAConfigAttribEncMaxSlices:
349 {
350 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
351 {
352 *value = CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6;
353 }
354 else
355 {
356 *value =0;
357 status = VA_STATUS_ERROR_INVALID_PARAMETER;
358 }
359 break;
360 }
361 case VAConfigAttribMaxPictureWidth:
362 {
363 if(profile == VAProfileJPEGBaseline)
364 {
365 *value = ENCODE_JPEG_MAX_PIC_WIDTH;
366 }
367 else if(IsHevcProfile(profile))
368 {
369 *value = CODEC_8K_MAX_PIC_WIDTH;
370 }
371 else if(IsAvcProfile(profile) || IsVp8Profile(profile))
372 {
373 *value = CODEC_4K_MAX_PIC_WIDTH;
374 }
375 else
376 {
377 *value = CODEC_MAX_PIC_WIDTH;
378 }
379 break;
380 }
381 case VAConfigAttribMaxPictureHeight:
382 {
383 if(profile == VAProfileJPEGBaseline)
384 {
385 *value = ENCODE_JPEG_MAX_PIC_HEIGHT;
386 }
387 else if(IsHevcProfile(profile))
388 {
389 *value = CODEC_8K_MAX_PIC_HEIGHT;
390 }
391 else if(IsAvcProfile(profile) || IsVp8Profile(profile))
392 {
393 *value = CODEC_4K_MAX_PIC_HEIGHT;
394 }
395 else
396 {
397 *value = CODEC_MAX_PIC_HEIGHT;
398 }
399 break;
400 }
401 case VAConfigAttribPredictionDirection:
402 {
403 if(IsHevcProfile(profile) && (entrypoint == VAEntrypointEncSliceLP))
404 {
405 *value = VA_PREDICTION_DIRECTION_PREVIOUS | VA_PREDICTION_DIRECTION_BI_NOT_EMPTY;
406 }
407 break;
408 }
409 #if VA_CHECK_VERSION(1, 12, 0)
410 case VAConfigAttribEncHEVCFeatures:
411 {
412 if ((entrypoint == VAEntrypointEncSlice || entrypoint == VAEntrypointEncSliceLP) && IsHevcProfile(profile))
413 {
414 VAConfigAttribValEncHEVCFeatures hevcFeatures = {0};
415 hevcFeatures.bits.separate_colour_planes = VA_FEATURE_NOT_SUPPORTED;
416 hevcFeatures.bits.scaling_lists = VA_FEATURE_SUPPORTED;
417 hevcFeatures.bits.amp = VA_FEATURE_REQUIRED;
418 hevcFeatures.bits.sao = VA_FEATURE_SUPPORTED;
419 hevcFeatures.bits.pcm = VA_FEATURE_NOT_SUPPORTED;
420 hevcFeatures.bits.temporal_mvp = VA_FEATURE_SUPPORTED;
421 hevcFeatures.bits.strong_intra_smoothing = VA_FEATURE_NOT_SUPPORTED;
422 hevcFeatures.bits.dependent_slices = VA_FEATURE_NOT_SUPPORTED;
423 hevcFeatures.bits.sign_data_hiding = VA_FEATURE_NOT_SUPPORTED;
424 hevcFeatures.bits.constrained_intra_pred = VA_FEATURE_NOT_SUPPORTED;
425 hevcFeatures.bits.transform_skip = VA_FEATURE_SUPPORTED;
426 hevcFeatures.bits.cu_qp_delta = VA_FEATURE_REQUIRED;
427 hevcFeatures.bits.weighted_prediction = VA_FEATURE_SUPPORTED;
428 hevcFeatures.bits.transquant_bypass = VA_FEATURE_NOT_SUPPORTED;
429 hevcFeatures.bits.deblocking_filter_disable = VA_FEATURE_NOT_SUPPORTED;
430 *value = hevcFeatures.value;
431 }
432 break;
433 }
434 case VAConfigAttribEncHEVCBlockSizes:
435 {
436 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
437 {
438 VAConfigAttribValEncHEVCBlockSizes hevcBlockSize = {0};
439 hevcBlockSize.bits.log2_max_coding_tree_block_size_minus3 = 2;
440 hevcBlockSize.bits.log2_min_coding_tree_block_size_minus3 = 1;
441 hevcBlockSize.bits.log2_min_luma_coding_block_size_minus3 = 0;
442 hevcBlockSize.bits.log2_max_luma_transform_block_size_minus2 = 3;
443 hevcBlockSize.bits.log2_min_luma_transform_block_size_minus2 = 0;
444 hevcBlockSize.bits.max_max_transform_hierarchy_depth_inter = 2;
445 hevcBlockSize.bits.min_max_transform_hierarchy_depth_inter = 0;
446 hevcBlockSize.bits.max_max_transform_hierarchy_depth_intra = 2;
447 hevcBlockSize.bits.min_max_transform_hierarchy_depth_intra = 0;
448 hevcBlockSize.bits.log2_max_pcm_coding_block_size_minus3 = 0;
449 hevcBlockSize.bits.log2_min_pcm_coding_block_size_minus3 = 0;
450 *value = hevcBlockSize.value;
451 }
452 if (entrypoint == VAEntrypointEncSliceLP && IsHevcProfile(profile))
453 {
454 VAConfigAttribValEncHEVCBlockSizes hevcBlockSize = {0};
455 hevcBlockSize.bits.log2_max_coding_tree_block_size_minus3 = 3;
456 hevcBlockSize.bits.log2_min_coding_tree_block_size_minus3 = 3;
457 hevcBlockSize.bits.log2_min_luma_coding_block_size_minus3 = 0;
458 hevcBlockSize.bits.log2_max_luma_transform_block_size_minus2 = 3;
459 hevcBlockSize.bits.log2_min_luma_transform_block_size_minus2 = 0;
460 hevcBlockSize.bits.max_max_transform_hierarchy_depth_inter = 2;
461 hevcBlockSize.bits.min_max_transform_hierarchy_depth_inter = 0;
462 hevcBlockSize.bits.max_max_transform_hierarchy_depth_intra = 2;
463 hevcBlockSize.bits.min_max_transform_hierarchy_depth_intra = 0;
464 hevcBlockSize.bits.log2_max_pcm_coding_block_size_minus3 = 0;
465 hevcBlockSize.bits.log2_min_pcm_coding_block_size_minus3 = 0;
466 *value = hevcBlockSize.value;
467 }
468 break;
469 }
470 #endif
471 default:
472 status = VA_STATUS_ERROR_INVALID_PARAMETER;
473 break;
474 }
475 return status;
476 }
477
LoadHevcEncProfileEntrypoints()478 VAStatus MediaLibvaCapsG11::LoadHevcEncProfileEntrypoints()
479 {
480 VAStatus status = VA_STATUS_SUCCESS;
481
482 #ifdef _HEVC_ENCODE_VME_SUPPORTED
483
484 status = MediaLibvaCaps::LoadHevcEncProfileEntrypoints();
485 DDI_CHK_RET(status, "Failed to initialize Caps!");
486
487 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC))
488 {
489 SetAttribute(VAProfileHEVCMain, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
490 }
491
492 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC10bit))
493 {
494 SetAttribute(VAProfileHEVCMain10, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
495 }
496
497 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC12bit))
498 {
499 SetAttribute(VAProfileHEVCMain12, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
500 }
501
502 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC10bit422))
503 {
504 SetAttribute(VAProfileHEVCMain422_10, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
505 }
506
507 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC12bit422))
508 {
509 SetAttribute(VAProfileHEVCMain422_12, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
510 }
511 #endif
512 return status;
513 }
514
LoadHevcEncLpProfileEntrypoints()515 VAStatus MediaLibvaCapsG11::LoadHevcEncLpProfileEntrypoints()
516 {
517 VAStatus status = VA_STATUS_SUCCESS;
518
519 #ifdef _HEVC_ENCODE_VDENC_SUPPORTED
520 AttribMap *attributeList = nullptr;
521
522 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain)
523 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10)
524 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444)
525 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444))
526 {
527 status = CreateEncAttributes(VAProfileHEVCMain, VAEntrypointEncSliceLP, &attributeList);
528 DDI_CHK_RET(status, "Failed to initialize Caps!");
529 (*attributeList)[VAConfigAttribEncTileSupport] = 1;
530 (*attributeList)[VAConfigAttribEncMaxRefFrames] = DDI_CODEC_VDENC_MAX_L0_REF_FRAMES_LDB | (DDI_CODEC_VDENC_MAX_L1_REF_FRAMES_LDB << DDI_CODEC_LEFT_SHIFT_FOR_REFLIST1);
531 (*attributeList)[VAConfigAttribEncDirtyRect] = CODECHAL_ENCODE_HEVC_MAX_NUM_DIRTYRECT;
532 (*attributeList)[VAConfigAttribEncParallelRateControl] = 0;
533 }
534
535 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain))
536 {
537 uint32_t configStartIdx = m_encConfigs.size();
538 AddEncConfig(VA_RC_CQP);
539 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
540 {
541 for (int32_t j = 3; j < 7; j++)
542 {
543 AddEncConfig(m_encRcMode[j]);
544 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
545 }
546 }
547 AddProfileEntry(VAProfileHEVCMain, VAEntrypointEncSliceLP, attributeList,
548 configStartIdx, m_encConfigs.size() - configStartIdx);
549 }
550
551 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10))
552 {
553 uint32_t configStartIdx = m_encConfigs.size();
554 AddEncConfig(VA_RC_CQP);
555 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
556 {
557 for (int32_t j = 3; j < 7; j++)
558 {
559 AddEncConfig(m_encRcMode[j]);
560 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
561 }
562 }
563 AddProfileEntry(VAProfileHEVCMain10, VAEntrypointEncSliceLP, attributeList,
564 configStartIdx, m_encConfigs.size() - configStartIdx);
565 }
566
567 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444))
568 {
569 uint32_t configStartIdx = m_encConfigs.size();
570 AddEncConfig(VA_RC_CQP);
571 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
572 {
573 for (int32_t j = 3; j < 7; j++)
574 {
575 AddEncConfig(m_encRcMode[j]);
576 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
577 }
578 }
579 AddProfileEntry(VAProfileHEVCMain444, VAEntrypointEncSliceLP, attributeList,
580 configStartIdx, m_encConfigs.size() - configStartIdx);
581 }
582
583 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444))
584 {
585 uint32_t configStartIdx = m_encConfigs.size();
586 AddEncConfig(VA_RC_CQP);
587 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
588 {
589 for (int32_t j = 3; j < 7; j++)
590 {
591 AddEncConfig(m_encRcMode[j]);
592 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
593 }
594 }
595 AddProfileEntry(VAProfileHEVCMain444_10, VAEntrypointEncSliceLP, attributeList,
596 configStartIdx, m_encConfigs.size() - configStartIdx);
597 }
598 #endif
599 return status;
600 }
601
LoadVp9EncProfileEntrypoints()602 VAStatus MediaLibvaCapsG11::LoadVp9EncProfileEntrypoints()
603 {
604 VAStatus status = VA_STATUS_SUCCESS;
605
606 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
607 AttribMap *attributeList = nullptr;
608
609 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels) &&
610 (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc) ||
611 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc8bit444) ||
612 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit420) ||
613 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit444)))
614 {
615 status = CreateEncAttributes(VAProfileVP9Profile0, VAEntrypointEncSliceLP, &attributeList);
616 DDI_CHK_RET(status, "Failed to initialize Caps!");
617 (*attributeList)[VAConfigAttribMaxPictureWidth] = m_maxVp9EncWidth;
618 (*attributeList)[VAConfigAttribMaxPictureHeight] = m_maxVp9EncHeight;
619 (*attributeList)[VAConfigAttribEncDynamicScaling] = 1;
620 (*attributeList)[VAConfigAttribEncTileSupport] = 1;
621 (*attributeList)[VAConfigAttribEncRateControlExt] = m_encVp9RateControlExt.value;
622 }
623
624 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc) &&
625 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
626 {
627 uint32_t configStartIdx = m_encConfigs.size();
628 AddEncConfig(VA_RC_CQP);
629 AddEncConfig(VA_RC_CBR);
630 AddEncConfig(VA_RC_VBR);
631 AddProfileEntry(VAProfileVP9Profile0, VAEntrypointEncSliceLP, attributeList,
632 configStartIdx, m_encConfigs.size() - configStartIdx);
633 }
634
635 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc8bit444) &&
636 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
637 {
638 uint32_t configStartIdx = m_encConfigs.size();
639 AddEncConfig(VA_RC_CQP);
640 AddEncConfig(VA_RC_CBR);
641 AddEncConfig(VA_RC_VBR);
642 AddProfileEntry(VAProfileVP9Profile1, VAEntrypointEncSliceLP, attributeList,
643 configStartIdx, m_encConfigs.size() - configStartIdx);
644 }
645
646 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit420) &&
647 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
648 {
649 uint32_t configStartIdx = m_encConfigs.size();
650 AddEncConfig(VA_RC_CQP);
651 AddEncConfig(VA_RC_CBR);
652 AddEncConfig(VA_RC_VBR);
653 AddProfileEntry(VAProfileVP9Profile2, VAEntrypointEncSliceLP, attributeList,
654 configStartIdx, m_encConfigs.size() - configStartIdx);
655 }
656
657 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit444) &&
658 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
659 {
660 uint32_t configStartIdx = m_encConfigs.size();
661 AddEncConfig(VA_RC_CQP);
662 AddEncConfig(VA_RC_CBR);
663 AddEncConfig(VA_RC_VBR);
664 AddProfileEntry(VAProfileVP9Profile3, VAEntrypointEncSliceLP, attributeList,
665 configStartIdx, m_encConfigs.size() - configStartIdx);
666 }
667 #endif
668 return status;
669 }
670
LoadProfileEntrypoints()671 VAStatus MediaLibvaCapsG11::LoadProfileEntrypoints()
672 {
673 VAStatus status = VA_STATUS_SUCCESS;
674 status = LoadAvcDecProfileEntrypoints();
675 DDI_CHK_RET(status, "Failed to initialize Caps!");
676 status = LoadAvcEncProfileEntrypoints();
677 DDI_CHK_RET(status, "Failed to initialize Caps!");
678 status = LoadAvcEncLpProfileEntrypoints();
679 DDI_CHK_RET(status, "Failed to initialize Caps!");
680 status = LoadMpeg2DecProfileEntrypoints();
681 DDI_CHK_RET(status, "Failed to initialize Caps!");
682 status = LoadMpeg2EncProfileEntrypoints();
683 DDI_CHK_RET(status, "Failed to initialize Caps!");
684 status = LoadVc1DecProfileEntrypoints();
685 DDI_CHK_RET(status, "Failed to initialize Caps!");
686 status = LoadJpegDecProfileEntrypoints();
687 DDI_CHK_RET(status, "Failed to initialize Caps!");
688 status = LoadJpegEncProfileEntrypoints();
689 DDI_CHK_RET(status, "Failed to initialize Caps!");
690 status = LoadHevcDecProfileEntrypoints();
691 DDI_CHK_RET(status, "Failed to initialize Caps!");
692 status = LoadHevcEncProfileEntrypoints();
693 DDI_CHK_RET(status, "Failed to initialize Caps!");
694 status = LoadHevcEncLpProfileEntrypoints();
695 DDI_CHK_RET(status, "Failed to initialize Caps!");
696 status = LoadVp8DecProfileEntrypoints();
697 DDI_CHK_RET(status, "Failed to initialize Caps!");
698 status = LoadVp8EncProfileEntrypoints();
699 DDI_CHK_RET(status, "Failed to initialize Caps!");
700 status = LoadVp9DecProfileEntrypoints();
701 DDI_CHK_RET(status, "Failed to initialize Caps!");
702 status = LoadVp9EncProfileEntrypoints();
703 DDI_CHK_RET(status, "Failed to initialize Caps!");
704 #ifdef ENABLE_KERNELS
705 status = LoadNoneProfileEntrypoints();
706 DDI_CHK_RET(status, "Failed to initialize Caps!");
707 #endif
708 status = m_CapsCp->LoadCpProfileEntrypoints();
709 DDI_CHK_RET(status, "Failed to initialize CP Caps!");
710 return status;
711 }
712
CheckEncodeResolution(VAProfile profile,uint32_t width,uint32_t height)713 VAStatus MediaLibvaCapsG11::CheckEncodeResolution(
714 VAProfile profile,
715 uint32_t width,
716 uint32_t height)
717 {
718 switch (profile)
719 {
720 case VAProfileJPEGBaseline:
721 if (width > m_encJpegMaxWidth
722 || width < m_encJpegMinWidth
723 || height > m_encJpegMaxHeight
724 || height < m_encJpegMinHeight)
725 {
726 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
727 }
728 break;
729 case VAProfileMPEG2Simple:
730 case VAProfileMPEG2Main:
731 if( width > CODEC_MAX_PIC_WIDTH
732 || width < m_encMinWidth
733 || height > CODEC_MAX_PIC_HEIGHT
734 || height < m_encMinHeight)
735 {
736 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
737 }
738 break;
739 case VAProfileHEVCMain:
740 case VAProfileHEVCMain10:
741 case VAProfileHEVCMain422_10:
742 case VAProfileHEVCMain444:
743 case VAProfileHEVCMain444_10:
744 if (width > m_maxHevcEncWidth
745 || width < (m_vdencActive ? m_hevcVDEncMinWidth : m_encMinWidth)
746 || height > m_maxHevcEncHeight
747 || height < (m_vdencActive ? m_hevcVDEncMinHeight : m_encMinHeight))
748 {
749 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
750 }
751 break;
752 case VAProfileVP9Profile0:
753 case VAProfileVP9Profile1:
754 case VAProfileVP9Profile2:
755 case VAProfileVP9Profile3:
756 if ((width > m_maxVp9EncWidth) ||
757 (width < m_minVp9EncWidth) ||
758 (height > m_maxVp9EncHeight) ||
759 (height < m_minVp9EncHeight) )
760 {
761 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
762 }
763 break;
764 default:
765 if (width > m_encMax4kWidth
766 || width < m_encMinWidth
767 || height > m_encMax4kHeight
768 || height < m_encMinHeight)
769 {
770 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
771 }
772 break;
773 }
774 return VA_STATUS_SUCCESS;
775 }
CheckDecodeResolution(int32_t codecMode,VAProfile profile,uint32_t width,uint32_t height)776 VAStatus MediaLibvaCapsG11::CheckDecodeResolution(
777 int32_t codecMode,
778 VAProfile profile,
779 uint32_t width,
780 uint32_t height)
781 {
782
783 uint32_t maxWidth, maxHeight;
784 switch (codecMode)
785 {
786 case CODECHAL_DECODE_MODE_MPEG2VLD:
787 maxWidth = m_decMpeg2MaxWidth;
788 maxHeight = m_decMpeg2MaxHeight;
789 break;
790 case CODECHAL_DECODE_MODE_VC1VLD:
791 maxWidth = m_decVc1MaxWidth;
792 maxHeight = m_decVc1MaxHeight;
793 break;
794 case CODECHAL_DECODE_MODE_JPEG:
795 maxWidth = m_decJpegMaxWidth;
796 maxHeight = m_decJpegMaxHeight;
797 break;
798 case CODECHAL_DECODE_MODE_HEVCVLD:
799 maxWidth = m_decHevcMaxWidth;
800 maxHeight = m_decHevcMaxHeight;
801 break;
802 case CODECHAL_DECODE_MODE_VP9VLD:
803 maxWidth = m_decVp9MaxWidth;
804 maxHeight = m_decVp9MaxHeight;
805 break;
806 default:
807 maxWidth = m_decDefaultMaxWidth;
808 maxHeight = m_decDefaultMaxHeight;
809 break;
810 }
811
812 uint32_t alignedHeight;
813 if (profile == VAProfileVC1Advanced)
814 {
815 alignedHeight = MOS_ALIGN_CEIL(height,32);
816 }
817 else
818 {
819 alignedHeight = height;
820 }
821
822 if (width > maxWidth || alignedHeight > maxHeight)
823 {
824 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
825 }
826 else
827 {
828 return VA_STATUS_SUCCESS;
829 }
830 }
831
QueryAVCROIMaxNum(uint32_t rcMode,bool isVdenc,uint32_t * maxNum,bool * isRoiInDeltaQP)832 VAStatus MediaLibvaCapsG11::QueryAVCROIMaxNum(uint32_t rcMode, bool isVdenc, uint32_t *maxNum, bool *isRoiInDeltaQP)
833 {
834 DDI_CHK_NULL(maxNum, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
835 DDI_CHK_NULL(isRoiInDeltaQP, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
836
837 if(isVdenc)
838 {
839 *maxNum = ENCODE_VDENC_AVC_MAX_ROI_NUMBER;
840 }
841 else
842 {
843 switch (rcMode)
844 {
845 case VA_RC_CQP:
846 *maxNum = ENCODE_DP_AVC_MAX_ROI_NUMBER;
847 break;
848 default:
849 *maxNum = ENCODE_DP_AVC_MAX_ROI_NUM_BRC;
850 break;
851 }
852 }
853
854 *isRoiInDeltaQP = true;
855
856 return VA_STATUS_SUCCESS;
857 }
858
ConvertMediaFmtToGmmFmt(DDI_MEDIA_FORMAT format)859 GMM_RESOURCE_FORMAT MediaLibvaCapsG11::ConvertMediaFmtToGmmFmt(
860 DDI_MEDIA_FORMAT format)
861 {
862 switch (format)
863 {
864 case Media_Format_X8R8G8B8 : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
865 case Media_Format_A8R8G8B8 : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
866 case Media_Format_X8B8G8R8 : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
867 case Media_Format_A8B8G8R8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
868 case Media_Format_R8G8B8A8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
869 case Media_Format_R5G6B5 : return GMM_FORMAT_B5G6R5_UNORM_TYPE;
870 case Media_Format_R8G8B8 : return GMM_FORMAT_R8G8B8_UNORM;
871 case Media_Format_RGBP : return GMM_FORMAT_RGBP;
872 case Media_Format_BGRP : return GMM_FORMAT_BGRP;
873 case Media_Format_NV12 : return GMM_FORMAT_NV12_TYPE;
874 case Media_Format_NV21 : return GMM_FORMAT_NV21_TYPE;
875 case Media_Format_YUY2 : return GMM_FORMAT_YUY2;
876 case Media_Format_UYVY : return GMM_FORMAT_UYVY;
877 case Media_Format_YV12 : return GMM_FORMAT_YV12_TYPE;
878 case Media_Format_IYUV : return GMM_FORMAT_IYUV_TYPE;
879 case Media_Format_I420 : return GMM_FORMAT_I420_TYPE;
880 case Media_Format_444P : return GMM_FORMAT_MFX_JPEG_YUV444_TYPE;
881 case Media_Format_422H : return GMM_FORMAT_MFX_JPEG_YUV422H_TYPE;
882 case Media_Format_411P : return GMM_FORMAT_MFX_JPEG_YUV411_TYPE;
883 case Media_Format_422V : return GMM_FORMAT_MFX_JPEG_YUV422V_TYPE;
884 case Media_Format_IMC3 : return GMM_FORMAT_IMC3_TYPE;
885 case Media_Format_400P : return GMM_FORMAT_GENERIC_8BIT;
886 case Media_Format_Buffer : return GMM_FORMAT_RENDER_8BIT;
887 case Media_Format_P010 : return GMM_FORMAT_P010_TYPE;
888 case Media_Format_P012 : return GMM_FORMAT_P016_TYPE;
889 case Media_Format_P016 : return GMM_FORMAT_P016_TYPE;
890 case Media_Format_R10G10B10A2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
891 case Media_Format_B10G10R10A2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
892 case Media_Format_R10G10B10X2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
893 case Media_Format_B10G10R10X2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
894 case Media_Format_Y210 : return GMM_FORMAT_Y210_TYPE;
895 #if VA_CHECK_VERSION(1, 9, 0)
896 case Media_Format_Y212 : return GMM_FORMAT_Y216_TYPE;
897 #endif
898 case Media_Format_Y216 : return GMM_FORMAT_Y216_TYPE;
899 case Media_Format_AYUV : return GMM_FORMAT_AYUV_TYPE;
900 #if VA_CHECK_VERSION(1, 13, 0)
901 case Media_Format_XYUV : return GMM_FORMAT_AYUV_TYPE;
902 #endif
903 case Media_Format_Y410 : return GMM_FORMAT_Y410_TYPE;
904 #if VA_CHECK_VERSION(1, 9, 0)
905 case Media_Format_Y412 : return GMM_FORMAT_Y416_TYPE;
906 #endif
907 case Media_Format_Y416 : return GMM_FORMAT_Y416_TYPE;
908 default : return GMM_FORMAT_INVALID;
909 }
910 }
911
QuerySurfaceAttributes(VAConfigID configId,VASurfaceAttrib * attribList,uint32_t * numAttribs)912 VAStatus MediaLibvaCapsG11::QuerySurfaceAttributes(
913 VAConfigID configId,
914 VASurfaceAttrib *attribList,
915 uint32_t *numAttribs)
916 {
917 DDI_CHK_NULL(numAttribs, "Null num_attribs", VA_STATUS_ERROR_INVALID_PARAMETER);
918
919 if (attribList == nullptr)
920 {
921 *numAttribs = DDI_CODEC_GEN_MAX_SURFACE_ATTRIBUTES;
922 return VA_STATUS_SUCCESS;
923 }
924
925 int32_t profileTableIdx = -1;
926 VAEntrypoint entrypoint;
927 VAProfile profile;
928 VAStatus status = GetProfileEntrypointFromConfigId(configId, &profile, &entrypoint, &profileTableIdx);
929 DDI_CHK_RET(status, "Invalid config_id!");
930 if (profileTableIdx < 0 || profileTableIdx >= m_profileEntryCount)
931 {
932 return VA_STATUS_ERROR_INVALID_CONFIG;
933 }
934
935 VASurfaceAttrib *attribs = (VASurfaceAttrib *)MOS_AllocAndZeroMemory(DDI_CODEC_GEN_MAX_SURFACE_ATTRIBUTES * sizeof(*attribs));
936 if (attribs == nullptr)
937 {
938 return VA_STATUS_ERROR_ALLOCATION_FAILED;
939 }
940
941 int32_t i = 0;
942
943 if (entrypoint == VAEntrypointVideoProc) /* vpp */
944 {
945 attribs[i].type = VASurfaceAttribPixelFormat;
946 attribs[i].value.type = VAGenericValueTypeInteger;
947 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
948 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
949 i++;
950
951 attribs[i].type = VASurfaceAttribMaxWidth;
952 attribs[i].value.type = VAGenericValueTypeInteger;
953 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
954 attribs[i].value.value.i = VP_MAX_PIC_WIDTH;
955 i++;
956
957 attribs[i].type = VASurfaceAttribMaxHeight;
958 attribs[i].value.type = VAGenericValueTypeInteger;
959 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
960 attribs[i].value.value.i = VP_MAX_PIC_HEIGHT;
961 i++;
962
963 attribs[i].type = VASurfaceAttribMinWidth;
964 attribs[i].value.type = VAGenericValueTypeInteger;
965 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
966 attribs[i].value.value.i = VP_MIN_PIC_WIDTH;
967 i++;
968
969 attribs[i].type = VASurfaceAttribMinHeight;
970 attribs[i].value.type = VAGenericValueTypeInteger;
971 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
972 attribs[i].value.value.i = VP_MIN_PIC_HEIGHT;
973 i++;
974
975 for (int32_t j = 0; j < m_numVpSurfaceAttr && m_vpSurfaceAttr[j]; j++)
976 {
977 attribs[i].type = VASurfaceAttribPixelFormat;
978 attribs[i].value.type = VAGenericValueTypeInteger;
979 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
980 attribs[i].value.value.i = m_vpSurfaceAttr[j];
981 i++;
982 }
983
984 attribs[i].type = VASurfaceAttribMemoryType;
985 attribs[i].value.type = VAGenericValueTypeInteger;
986 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
987 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
988 VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR |
989 VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM |
990 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME |
991 #if VA_CHECK_VERSION(1, 21, 0)
992 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
993 #endif
994 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
995 i++;
996
997 attribs[i].type = VASurfaceAttribExternalBufferDescriptor;
998 attribs[i].value.type = VAGenericValueTypePointer;
999 attribs[i].flags = VA_SURFACE_ATTRIB_SETTABLE;
1000 attribs[i].value.value.p = nullptr; /* ignore */
1001 i++;
1002 }
1003 else if (entrypoint == VAEntrypointVLD) /* vld */
1004 {
1005 if (profile == VAProfileHEVCMain10 || profile == VAProfileVP9Profile2)
1006 {
1007 attribs[i].type = VASurfaceAttribPixelFormat;
1008 attribs[i].value.type = VAGenericValueTypeInteger;
1009 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1010 attribs[i].value.value.i = VA_FOURCC_P010;
1011 i++;
1012
1013 if(profile == VAProfileVP9Profile2)
1014 {
1015 attribs[i].type = VASurfaceAttribPixelFormat;
1016 attribs[i].value.type = VAGenericValueTypeInteger;
1017 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1018 attribs[i].value.value.i = VA_FOURCC_P012;
1019 i++;
1020
1021 attribs[i].type = VASurfaceAttribPixelFormat;
1022 attribs[i].value.type = VAGenericValueTypeInteger;
1023 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1024 attribs[i].value.value.i = VA_FOURCC_P016;
1025 i++;
1026 }
1027 }
1028 else if(profile == VAProfileHEVCMain12)
1029 {
1030 attribs[i].type = VASurfaceAttribPixelFormat;
1031 attribs[i].value.type = VAGenericValueTypeInteger;
1032 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1033 attribs[i].value.value.i = VA_FOURCC_P012;
1034 i++;
1035
1036 attribs[i].type = VASurfaceAttribPixelFormat;
1037 attribs[i].value.type = VAGenericValueTypeInteger;
1038 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1039 attribs[i].value.value.i = VA_FOURCC_P016;
1040 i++;
1041 }
1042 else if(profile == VAProfileHEVCMain422_10)
1043 {
1044 attribs[i].type = VASurfaceAttribPixelFormat;
1045 attribs[i].value.type = VAGenericValueTypeInteger;
1046 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1047 attribs[i].value.value.i = VA_FOURCC_YUY2;
1048 i++;
1049
1050 attribs[i].type = VASurfaceAttribPixelFormat;
1051 attribs[i].value.type = VAGenericValueTypeInteger;
1052 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1053 attribs[i].value.value.i = VA_FOURCC_Y210;
1054 i++;
1055 }
1056 else if(profile == VAProfileHEVCMain422_12)
1057 {
1058 //hevc rext: Y216 12/16bit 422
1059 #if VA_CHECK_VERSION(1, 9, 0)
1060 attribs[i].type = VASurfaceAttribPixelFormat;
1061 attribs[i].value.type = VAGenericValueTypeInteger;
1062 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1063 attribs[i].value.value.i = VA_FOURCC_Y212;
1064 i++;
1065 #endif
1066
1067 attribs[i].type = VASurfaceAttribPixelFormat;
1068 attribs[i].value.type = VAGenericValueTypeInteger;
1069 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1070 attribs[i].value.value.i = VA_FOURCC_Y216;
1071 i++;
1072
1073 attribs[i].type = VASurfaceAttribPixelFormat;
1074 attribs[i].value.type = VAGenericValueTypeInteger;
1075 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1076 attribs[i].value.value.i = VA_FOURCC_P012;
1077 i++;
1078 }
1079 else if(profile == VAProfileHEVCMain444 || profile == VAProfileVP9Profile1)
1080 {
1081 attribs[i].type = VASurfaceAttribPixelFormat;
1082 attribs[i].value.type = VAGenericValueTypeInteger;
1083 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1084 attribs[i].value.value.i = VA_FOURCC_AYUV;
1085 i++;
1086
1087 #if VA_CHECK_VERSION(1, 13, 0)
1088 attribs[i].type = VASurfaceAttribPixelFormat;
1089 attribs[i].value.type = VAGenericValueTypeInteger;
1090 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1091 attribs[i].value.value.i = VA_FOURCC_XYUV;
1092 i++;
1093 #endif
1094 }
1095 else if(profile == VAProfileHEVCMain444_10 || profile == VAProfileVP9Profile3)
1096 {
1097 attribs[i].type = VASurfaceAttribPixelFormat;
1098 attribs[i].value.type = VAGenericValueTypeInteger;
1099 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1100 attribs[i].value.value.i = VA_FOURCC_Y410;
1101 i++;
1102
1103 if(profile == VAProfileVP9Profile3)
1104 {
1105 #if VA_CHECK_VERSION(1, 9, 0)
1106 attribs[i].type = VASurfaceAttribPixelFormat;
1107 attribs[i].value.type = VAGenericValueTypeInteger;
1108 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1109 attribs[i].value.value.i = VA_FOURCC_Y412;
1110 i++;
1111 #endif
1112
1113 attribs[i].type = VASurfaceAttribPixelFormat;
1114 attribs[i].value.type = VAGenericValueTypeInteger;
1115 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1116 attribs[i].value.value.i = VA_FOURCC_Y416;
1117 i++;
1118 }
1119 }
1120 else if(profile == VAProfileHEVCMain444_12)
1121 {
1122 #if VA_CHECK_VERSION(1, 9, 0)
1123 attribs[i].type = VASurfaceAttribPixelFormat;
1124 attribs[i].value.type = VAGenericValueTypeInteger;
1125 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1126 attribs[i].value.value.i = VA_FOURCC_Y412;
1127 i++;
1128
1129 attribs[i].type = VASurfaceAttribPixelFormat;
1130 attribs[i].value.type = VAGenericValueTypeInteger;
1131 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1132 attribs[i].value.value.i = VA_FOURCC_Y212;
1133 i++;
1134 #endif
1135
1136 attribs[i].type = VASurfaceAttribPixelFormat;
1137 attribs[i].value.type = VAGenericValueTypeInteger;
1138 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1139 attribs[i].value.value.i = VA_FOURCC_Y416;
1140 i++;
1141
1142 attribs[i].type = VASurfaceAttribPixelFormat;
1143 attribs[i].value.type = VAGenericValueTypeInteger;
1144 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1145 attribs[i].value.value.i = VA_FOURCC_P012;
1146 i++;
1147 }
1148 else if (profile == VAProfileJPEGBaseline)
1149 {
1150 for (int32_t j = 0; j < m_numJpegSurfaceAttr; j++)
1151 {
1152 attribs[i].type = VASurfaceAttribPixelFormat;
1153 attribs[i].value.type = VAGenericValueTypeInteger;
1154 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1155 attribs[i].value.value.i = m_jpegSurfaceAttr[j];
1156 i++;
1157 }
1158 }
1159 else
1160 {
1161 attribs[i].type = VASurfaceAttribPixelFormat;
1162 attribs[i].value.type = VAGenericValueTypeInteger;
1163 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1164 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1165 i++;
1166 }
1167
1168 auto maxWidth = m_decDefaultMaxWidth;
1169 auto maxHeight = m_decDefaultMaxHeight;
1170 if(IsMpeg2Profile(profile))
1171 {
1172 maxWidth = m_decMpeg2MaxWidth;
1173 maxHeight = m_decMpeg2MaxHeight;
1174 }
1175 else if(IsHevcProfile(profile))
1176 {
1177 maxWidth = m_decHevcMaxWidth;
1178 maxHeight = m_decHevcMaxHeight;
1179 }
1180 else if(IsVc1Profile(profile))
1181 {
1182 maxWidth = m_decVc1MaxWidth;
1183 maxHeight = m_decVc1MaxHeight;
1184 }
1185 else if(IsJpegProfile(profile))
1186 {
1187 maxWidth = m_decJpegMaxWidth;
1188 maxHeight = m_decJpegMaxHeight;
1189 }
1190 else if(IsVp9Profile(profile))
1191 {
1192 maxWidth = m_decVp9MaxWidth;
1193 maxHeight = m_decVp9MaxHeight;
1194 }
1195
1196 attribs[i].type = VASurfaceAttribMaxWidth;
1197 attribs[i].value.type = VAGenericValueTypeInteger;
1198 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1199 attribs[i].value.value.i = maxWidth;
1200 i++;
1201
1202 attribs[i].type = VASurfaceAttribMaxHeight;
1203 attribs[i].value.type = VAGenericValueTypeInteger;
1204 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1205 attribs[i].value.value.i = maxHeight;
1206 i++;
1207
1208 attribs[i].type = VASurfaceAttribMemoryType;
1209 attribs[i].value.type = VAGenericValueTypeInteger;
1210 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1211 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1212 VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR |
1213 VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM |
1214 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME |
1215 #if VA_CHECK_VERSION(1, 21, 0)
1216 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1217 #endif
1218 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
1219 i++;
1220 }
1221 else if(entrypoint == VAEntrypointEncSlice || entrypoint == VAEntrypointEncSliceLP || entrypoint == VAEntrypointEncPicture || entrypoint == VAEntrypointFEI)
1222 {
1223 if (profile == VAProfileHEVCMain10 || profile == VAProfileVP9Profile2)
1224 {
1225 attribs[i].type = VASurfaceAttribPixelFormat;
1226 attribs[i].value.type = VAGenericValueTypeInteger;
1227 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1228 attribs[i].value.value.i = VA_FOURCC('P', '0', '1', '0');
1229 i++;
1230 }
1231 else if(profile == VAProfileHEVCMain444)
1232 {
1233 attribs[i].type = VASurfaceAttribPixelFormat;
1234 attribs[i].value.type = VAGenericValueTypeInteger;
1235 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1236 attribs[i].value.value.i = VA_FOURCC_AYUV;
1237 i++;
1238
1239 #if VA_CHECK_VERSION(1, 13, 0)
1240 attribs[i].type = VASurfaceAttribPixelFormat;
1241 attribs[i].value.type = VAGenericValueTypeInteger;
1242 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1243 attribs[i].value.value.i = VA_FOURCC_XYUV;
1244 i++;
1245 #endif
1246 }
1247 else if(profile == VAProfileHEVCMain444_10)
1248 {
1249 attribs[i].type = VASurfaceAttribPixelFormat;
1250 attribs[i].value.type = VAGenericValueTypeInteger;
1251 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1252 attribs[i].value.value.i = VA_FOURCC_Y410;
1253 i++;
1254 }
1255 else if(profile == VAProfileHEVCMain422_10)
1256 {
1257 attribs[i].type = VASurfaceAttribPixelFormat;
1258 attribs[i].value.type = VAGenericValueTypeInteger;
1259 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1260 attribs[i].value.value.i = VA_FOURCC_YUY2;
1261 i++;
1262
1263 attribs[i].type = VASurfaceAttribPixelFormat;
1264 attribs[i].value.type = VAGenericValueTypeInteger;
1265 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1266 attribs[i].value.value.i = VA_FOURCC_Y210;
1267 i++;
1268 }
1269 else if (profile == VAProfileVP9Profile1)
1270 {
1271 attribs[i].type = VASurfaceAttribPixelFormat;
1272 attribs[i].value.type = VAGenericValueTypeInteger;
1273 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1274 attribs[i].value.value.i = VA_FOURCC('A', 'Y', 'U', 'V');
1275 i++;
1276 }
1277 else if (profile == VAProfileVP9Profile3)
1278 {
1279 attribs[i].type = VASurfaceAttribPixelFormat;
1280 attribs[i].value.type = VAGenericValueTypeInteger;
1281 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1282 attribs[i].value.value.i = VA_FOURCC('Y', '4', '1', '6');
1283 i++;
1284
1285 attribs[i].type = VASurfaceAttribPixelFormat;
1286 attribs[i].value.type = VAGenericValueTypeInteger;
1287 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1288 attribs[i].value.value.i = VA_FOURCC('A', 'R', 'G', 'B');
1289 i++;
1290
1291 attribs[i].type = VASurfaceAttribPixelFormat;
1292 attribs[i].value.type = VAGenericValueTypeInteger;
1293 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1294 attribs[i].value.value.i = VA_FOURCC('A', 'B', 'G', 'R');
1295 i++;
1296 }
1297 else if (profile == VAProfileJPEGBaseline)
1298 {
1299 for (int32_t j = 0; j < m_numJpegEncSurfaceAttr; j++)
1300 {
1301 attribs[i].type = VASurfaceAttribPixelFormat;
1302 attribs[i].value.type = VAGenericValueTypeInteger;
1303 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1304 attribs[i].value.value.i = m_jpegEncSurfaceAttr[j];
1305 i++;
1306 }
1307 }
1308 else
1309 {
1310 attribs[i].type = VASurfaceAttribPixelFormat;
1311 attribs[i].value.type = VAGenericValueTypeInteger;
1312 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1313 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1314 i++;
1315 }
1316 attribs[i].type = VASurfaceAttribMaxWidth;
1317 attribs[i].value.type = VAGenericValueTypeInteger;
1318 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1319 attribs[i].value.value.i = CODEC_MAX_PIC_WIDTH;
1320
1321 if(profile == VAProfileJPEGBaseline)
1322 {
1323 attribs[i].value.value.i = ENCODE_JPEG_MAX_PIC_WIDTH;
1324 }
1325 else if(IsHevcProfile(profile))
1326 {
1327 attribs[i].value.value.i = CODEC_8K_MAX_PIC_WIDTH;
1328 }
1329 else if(IsAvcProfile(profile) || IsVp8Profile(profile))
1330 {
1331 attribs[i].value.value.i = CODEC_4K_MAX_PIC_WIDTH;
1332 }
1333 else if (IsVp9Profile(profile))
1334 {
1335 attribs[i].value.value.i = m_maxVp9EncWidth;
1336 }
1337 i++;
1338
1339 attribs[i].type = VASurfaceAttribMaxHeight;
1340 attribs[i].value.type = VAGenericValueTypeInteger;
1341 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1342 attribs[i].value.value.i = CODEC_MAX_PIC_HEIGHT;
1343 if(profile == VAProfileJPEGBaseline)
1344 {
1345 attribs[i].value.value.i = ENCODE_JPEG_MAX_PIC_HEIGHT;
1346 }
1347 else if(IsHevcProfile(profile))
1348 {
1349 attribs[i].value.value.i = CODEC_8K_MAX_PIC_HEIGHT;
1350 }
1351 else if(IsAvcProfile(profile) || IsVp8Profile(profile))
1352 {
1353 attribs[i].value.value.i = CODEC_4K_MAX_PIC_HEIGHT;
1354 }
1355 else if (IsVp9Profile(profile))
1356 {
1357 attribs[i].value.value.i = m_maxVp9EncHeight;
1358 }
1359 i++;
1360
1361 attribs[i].type = VASurfaceAttribMinWidth;
1362 attribs[i].value.type = VAGenericValueTypeInteger;
1363 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1364 attribs[i].value.value.i = m_encMinWidth;
1365 if(IsHevcProfile(profile))
1366 {
1367 attribs[i].value.value.i = m_vdencActive ? m_hevcVDEncMinWidth : m_encMinWidth;
1368 }
1369 else if (IsVp9Profile(profile))
1370 {
1371 attribs[i].value.value.i = m_vdencActive ? m_minVp9EncWidth : m_encMinWidth;
1372 }
1373 else if (profile == VAProfileJPEGBaseline)
1374 {
1375 attribs[i].value.value.i = m_encJpegMinWidth;
1376 }
1377 i++;
1378
1379 attribs[i].type = VASurfaceAttribMinHeight;
1380 attribs[i].value.type = VAGenericValueTypeInteger;
1381 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1382 attribs[i].value.value.i = m_encMinHeight;
1383 if(IsHevcProfile(profile))
1384 {
1385 attribs[i].value.value.i = m_vdencActive ? m_hevcVDEncMinHeight : m_encMinHeight;
1386 }
1387 else if (IsVp9Profile(profile))
1388 {
1389 attribs[i].value.value.i = m_vdencActive ? m_minVp9EncHeight : m_encMinHeight;
1390 }
1391 else if (profile == VAProfileJPEGBaseline)
1392 {
1393 attribs[i].value.value.i = m_encJpegMinHeight;
1394 }
1395 i++;
1396
1397 attribs[i].type = VASurfaceAttribMemoryType;
1398 attribs[i].value.type = VAGenericValueTypeInteger;
1399 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1400 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1401 VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR |
1402 VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM |
1403 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME |
1404 #if VA_CHECK_VERSION(1, 21, 0)
1405 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1406 #endif
1407 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
1408 i++;
1409 }
1410 else
1411 {
1412 MOS_FreeMemory(attribs);
1413 return VA_STATUS_ERROR_UNIMPLEMENTED;
1414 }
1415
1416 if (i > *numAttribs)
1417 {
1418 *numAttribs = i;
1419 MOS_FreeMemory(attribs);
1420 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
1421 }
1422
1423 *numAttribs = i;
1424 MOS_SecureMemcpy(attribList, i * sizeof(*attribs), attribs, i * sizeof(*attribs));
1425
1426 MOS_FreeMemory(attribs);
1427 return status;
1428 }
1429
CreateEncAttributes(VAProfile profile,VAEntrypoint entrypoint,AttribMap ** attributeList)1430 VAStatus MediaLibvaCapsG11::CreateEncAttributes(
1431 VAProfile profile,
1432 VAEntrypoint entrypoint,
1433 AttribMap **attributeList)
1434 {
1435 VAStatus status = MediaLibvaCaps::CreateEncAttributes(profile, entrypoint, attributeList);
1436 DDI_CHK_RET(status, "Failed to create base encode attributes");
1437
1438 auto attribList = *attributeList;
1439 DDI_CHK_NULL(attribList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
1440
1441 #if VA_CHECK_VERSION(1, 12, 0)
1442 if (IsHevcProfile(profile)) {
1443 VAConfigAttrib attrib;
1444
1445 attrib.type = VAConfigAttribEncHEVCFeatures;
1446 GetPlatformSpecificAttrib(profile, entrypoint,
1447 attrib.type, &attrib.value);
1448 (*attribList)[attrib.type] = attrib.value;
1449
1450 attrib.type = VAConfigAttribEncHEVCBlockSizes;
1451 GetPlatformSpecificAttrib(profile, entrypoint,
1452 attrib.type, &attrib.value);
1453 (*attribList)[attrib.type] = attrib.value;
1454 }
1455 #endif
1456
1457 return status;
1458 }
1459
CreateDecAttributes(VAProfile profile,VAEntrypoint entrypoint,AttribMap ** attributeList)1460 VAStatus MediaLibvaCapsG11::CreateDecAttributes(
1461 VAProfile profile,
1462 VAEntrypoint entrypoint,
1463 AttribMap **attributeList)
1464 {
1465 VAStatus status = MediaLibvaCaps::CreateDecAttributes(profile, entrypoint, attributeList);
1466 DDI_CHK_RET(status, "Failed to initialize Caps!");
1467
1468 auto attribList = *attributeList;
1469 DDI_CHK_NULL(attribList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
1470
1471 VAConfigAttrib attrib;
1472 attrib.type = VAConfigAttribRTFormat;
1473 if(profile == VAProfileHEVCMain444)
1474 {
1475 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422 | VA_RT_FORMAT_YUV400 | VA_RT_FORMAT_YUV444;
1476 (*attribList)[attrib.type] = attrib.value;
1477 }
1478 else if(profile == VAProfileHEVCMain444_10)
1479 {
1480 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422 | VA_RT_FORMAT_YUV400 | VA_RT_FORMAT_YUV444;
1481 attrib.value |= VA_RT_FORMAT_YUV420_10 | VA_RT_FORMAT_YUV422_10 | VA_RT_FORMAT_YUV444_10;
1482 (*attribList)[attrib.type] = attrib.value;
1483 } else if(profile == VAProfileNone)
1484 {
1485 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422 | VA_RT_FORMAT_RGB32 | VA_RT_FORMAT_YUV444;
1486 (*attribList)[attrib.type] = attrib.value;
1487 }
1488
1489 return status;
1490 }
1491
1492 extern template class MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>;
1493
1494 static bool iclRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
1495 RegisterCaps<MediaLibvaCapsG11>((uint32_t)IGFX_ICELAKE);
1496 static bool icllpRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
1497 RegisterCaps<MediaLibvaCapsG11>((uint32_t)IGFX_ICELAKE_LP);
1498 static bool ehlRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
1499 RegisterCaps<MediaLibvaCapsG11>((uint32_t)IGFX_ELKHARTLAKE);
1500