1 /*
2 * Copyright (c) 2018-2023, 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 //!
24 //! \file media_libva_caps_g12.cpp
25 //! \brief This file implements the C++ class/interface for gen12 media capbilities.
26 //!
27
28 #include "codec_def_encode_hevc_g12.h"
29 #include "media_libva_util.h"
30 #include "media_libva.h"
31 #include "media_libva_vp.h"
32 #include "media_libva_caps_cp_interface.h"
33 #include "media_libva_caps_g12.h"
34 #include "media_libva_caps_factory.h"
35 #include "media_ddi_decode_const.h"
36 #include "media_ddi_encode_const.h"
37 #include "media_ddi_decode_const_g12.h"
38 #include "mos_bufmgr_priv.h"
39 #include "drm_fourcc.h"
40
41
42 #ifndef VA_CENC_TYPE_NONE
43 #define VA_CENC_TYPE_NONE 0x00000000
44 #endif
45
46 #ifndef VA_ENCRYPTION_TYPE_NONE
47 #define VA_ENCRYPTION_TYPE_NONE 0x00000000
48 #endif
49
50 const VAImageFormat m_supportedImageformatsG12[] =
51 { {VA_FOURCC_BGRA, VA_LSB_FIRST, 32, 32, 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff}, /* [31:0] B:G:R:A 8:8:8:8 little endian */
52 {VA_FOURCC_RGBA, VA_LSB_FIRST, 32, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff}, /* [31:0] R:G:B:A 8:8:8:8 little endian */
53 {VA_FOURCC_BGRX, VA_LSB_FIRST, 32, 24, 0x0000ff00, 0x00ff0000, 0xff000000, 0}, /* [31:0] B:G:R:x 8:8:8:8 little endian */
54 {VA_FOURCC_RGBX, VA_LSB_FIRST, 32, 24, 0xff000000, 0x00ff0000, 0x0000ff00, 0}, /* [31:0] R:G:B:x 8:8:8:8 little endian */
55 {VA_FOURCC_A2R10G10B10, VA_LSB_FIRST, 32, 30, 0x3ff00000, 0x000ffc00, 0x000003ff, 0x30000000}, /* [31:0] A:R:G:B 2:10:10:10 little endian */
56 {VA_FOURCC_A2B10G10R10, VA_LSB_FIRST, 32, 30, 0x000003ff, 0x000ffc00, 0x3ff00000, 0x30000000}, /* [31:0] A:B:G:R 2:10:10:10 little endian */
57 {VA_FOURCC_X2R10G10B10, VA_LSB_FIRST, 32, 30, 0x3ff00000, 0x000ffc00, 0x000003ff, 0}, /* [31:0] X:R:G:B 2:10:10:10 little endian */
58 {VA_FOURCC_X2B10G10R10, VA_LSB_FIRST, 32, 30, 0x000003ff, 0x000ffc00, 0x3ff00000, 0}, /* [31:0] X:B:G:R 2:10:10:10 little endian */
59 {VA_FOURCC_RGB565, VA_LSB_FIRST, 16, 16, 0xf800, 0x07e0, 0x001f, 0}, /* [15:0] R:G:B 5:6:5 little endian */
60 {VA_FOURCC_AYUV, VA_LSB_FIRST, 32, 0,0,0,0,0},
61 #if VA_CHECK_VERSION(1, 13, 0)
62 {VA_FOURCC_XYUV, VA_LSB_FIRST, 32, 0,0,0,0,0},
63 #endif
64 {VA_FOURCC_Y800, VA_LSB_FIRST, 8, 0,0,0,0,0},
65 {VA_FOURCC_NV12, VA_LSB_FIRST, 12, 0,0,0,0,0},
66 {VA_FOURCC_NV21, VA_LSB_FIRST, 12, 0,0,0,0,0},
67 {VA_FOURCC_YUY2, VA_LSB_FIRST, 16, 0,0,0,0,0},
68 {VA_FOURCC_UYVY, VA_LSB_FIRST, 16, 0,0,0,0,0},
69 {VA_FOURCC_YV12, VA_LSB_FIRST, 12, 0,0,0,0,0},
70 {VA_FOURCC_I420, VA_LSB_FIRST, 12, 0,0,0,0,0},
71 {VA_FOURCC_411P, VA_LSB_FIRST, 12, 0,0,0,0,0},
72 {VA_FOURCC_422H, VA_LSB_FIRST, 16, 0,0,0,0,0},
73 {VA_FOURCC_422V, VA_LSB_FIRST, 16, 0,0,0,0,0},
74 {VA_FOURCC_444P, VA_LSB_FIRST, 24, 0,0,0,0,0},
75 {VA_FOURCC_IMC3, VA_LSB_FIRST, 16, 0,0,0,0,0},
76 {VA_FOURCC_P010, VA_LSB_FIRST, 24, 0,0,0,0,0},
77 {VA_FOURCC_P012, VA_LSB_FIRST, 24, 0,0,0,0,0},
78 {VA_FOURCC_P016, VA_LSB_FIRST, 24, 0,0,0,0,0},
79 {VA_FOURCC_Y210, VA_LSB_FIRST, 32, 0,0,0,0,0},
80 #if VA_CHECK_VERSION(1, 9, 0)
81 {VA_FOURCC_Y212, VA_LSB_FIRST, 32, 0,0,0,0,0},
82 #endif
83 {VA_FOURCC_Y216, VA_LSB_FIRST, 32, 0,0,0,0,0},
84 {VA_FOURCC_Y410, VA_LSB_FIRST, 32, 0,0,0,0,0},
85 #if VA_CHECK_VERSION(1, 9, 0)
86 {VA_FOURCC_Y412, VA_LSB_FIRST, 64, 0,0,0,0,0},
87 #endif
88 {VA_FOURCC_Y416, VA_LSB_FIRST, 64, 0,0,0,0,0},
89 {VA_FOURCC_RGBP, VA_LSB_FIRST, 24, 24,0,0,0,0},
90 {VA_FOURCC_BGRP, VA_LSB_FIRST, 24, 24,0,0,0,0},
91 };
92
93 const VAConfigAttribValEncRateControlExt MediaLibvaCapsG12::m_encVp9RateControlExt =
94 {
95 {CODECHAL_ENCODE_VP9_MAX_NUM_TEMPORAL_LAYERS - 1, 1, 0}
96 };
97
QueryImageFormats(VAImageFormat * formatList,int32_t * numFormats)98 VAStatus MediaLibvaCapsG12::QueryImageFormats(VAImageFormat *formatList, int32_t *numFormats)
99 {
100 DDI_CHK_NULL(formatList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
101 DDI_CHK_NULL(numFormats, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
102 int32_t num = 0;
103 uint32_t maxNum = GetImageFormatsMaxNum();
104
105 memset(formatList, 0, sizeof(m_supportedImageformatsG12));
106 for (uint32_t idx = 0; idx < maxNum; idx++)
107 {
108 formatList[num].fourcc = m_supportedImageformatsG12[idx].fourcc;
109 formatList[num].byte_order = m_supportedImageformatsG12[idx].byte_order;
110 formatList[num].bits_per_pixel = m_supportedImageformatsG12[idx].bits_per_pixel;
111 formatList[num].depth = m_supportedImageformatsG12[idx].depth;
112 formatList[num].red_mask = m_supportedImageformatsG12[idx].red_mask;
113 formatList[num].green_mask = m_supportedImageformatsG12[idx].green_mask;
114 formatList[num].blue_mask = m_supportedImageformatsG12[idx].blue_mask;
115 formatList[num].alpha_mask = m_supportedImageformatsG12[idx].alpha_mask;
116 num++;
117 }
118 *numFormats = num;
119
120 return VA_STATUS_SUCCESS;
121 }
122
GetImageFormatsMaxNum()123 uint32_t MediaLibvaCapsG12::GetImageFormatsMaxNum()
124 {
125 return sizeof(m_supportedImageformatsG12)/sizeof(m_supportedImageformatsG12[0]);
126 }
127
IsImageSupported(uint32_t fourcc)128 bool MediaLibvaCapsG12::IsImageSupported(uint32_t fourcc)
129 {
130 uint32_t maxNum = GetImageFormatsMaxNum();
131 for (int32_t idx = 0; idx < maxNum; idx++)
132 {
133 if (m_supportedImageformatsG12[idx].fourcc == fourcc)
134 {
135 return true;
136 }
137 }
138
139 return false;
140 }
141
PopulateColorMaskInfo(VAImageFormat * vaImgFmt)142 VAStatus MediaLibvaCapsG12::PopulateColorMaskInfo(VAImageFormat *vaImgFmt)
143 {
144 uint32_t maxNum = GetImageFormatsMaxNum();
145
146 DDI_CHK_NULL(vaImgFmt, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
147
148 for (int32_t idx = 0; idx < maxNum; idx++)
149 {
150 if (m_supportedImageformatsG12[idx].fourcc == vaImgFmt->fourcc)
151 {
152 vaImgFmt->red_mask = m_supportedImageformatsG12[idx].red_mask;
153 vaImgFmt->green_mask = m_supportedImageformatsG12[idx].green_mask;
154 vaImgFmt->blue_mask = m_supportedImageformatsG12[idx].blue_mask;
155 vaImgFmt->alpha_mask = m_supportedImageformatsG12[idx].alpha_mask;
156
157 return VA_STATUS_SUCCESS;
158 }
159 }
160
161 return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
162 }
163
GetEncodeCodecMode(VAProfile profile,VAEntrypoint entrypoint)164 CODECHAL_MODE MediaLibvaCapsG12::GetEncodeCodecMode(VAProfile profile, VAEntrypoint entrypoint)
165 {
166 if (entrypoint == VAEntrypointStats)
167 {
168 return CODECHAL_ENCODE_MODE_AVC;
169 }
170
171 switch (profile)
172 {
173 case VAProfileH264High:
174 case VAProfileH264Main:
175 case VAProfileH264ConstrainedBaseline:
176 return CODECHAL_ENCODE_MODE_AVC;
177 case VAProfileMPEG2Main:
178 case VAProfileMPEG2Simple:
179 return CODECHAL_ENCODE_MODE_MPEG2;
180 case VAProfileJPEGBaseline:
181 return CODECHAL_ENCODE_MODE_JPEG;
182 case VAProfileVP8Version0_3:
183 return CODECHAL_ENCODE_MODE_VP8;
184 case VAProfileVP9Profile0:
185 case VAProfileVP9Profile1:
186 case VAProfileVP9Profile2:
187 case VAProfileVP9Profile3:
188 return CODECHAL_ENCODE_MODE_VP9;
189 case VAProfileHEVCMain:
190 case VAProfileHEVCMain10:
191 case VAProfileHEVCMain12:
192 case VAProfileHEVCMain422_10:
193 case VAProfileHEVCMain422_12:
194 case VAProfileHEVCMain444:
195 case VAProfileHEVCMain444_10:
196 case VAProfileHEVCSccMain:
197 case VAProfileHEVCSccMain10:
198 case VAProfileHEVCSccMain444:
199 case VAProfileHEVCSccMain444_10:
200 return CODECHAL_ENCODE_MODE_HEVC;
201 default:
202 DDI_ASSERTMESSAGE("Invalid Encode Mode");
203 return CODECHAL_UNSUPPORTED_MODE;
204 }
205 }
206
GetDecodeCodecMode(VAProfile profile)207 CODECHAL_MODE MediaLibvaCapsG12::GetDecodeCodecMode(VAProfile profile)
208 {
209 int8_t vaProfile = (int8_t)profile;
210 switch (vaProfile)
211 {
212 case VAProfileH264High:
213 case VAProfileH264Main:
214 case VAProfileH264ConstrainedBaseline:
215 return CODECHAL_DECODE_MODE_AVCVLD;
216 case VAProfileMPEG2Main:
217 case VAProfileMPEG2Simple:
218 return CODECHAL_DECODE_MODE_MPEG2VLD;
219 case VAProfileJPEGBaseline:
220 return CODECHAL_DECODE_MODE_JPEG;
221 case VAProfileVP8Version0_3:
222 return CODECHAL_DECODE_MODE_VP8VLD;
223 case VAProfileVP9Profile0:
224 case VAProfileVP9Profile1:
225 case VAProfileVP9Profile2:
226 case VAProfileVP9Profile3:
227 return CODECHAL_DECODE_MODE_VP9VLD;
228 case VAProfileHEVCMain:
229 case VAProfileHEVCMain10:
230 case VAProfileHEVCMain12:
231 case VAProfileHEVCMain422_10:
232 case VAProfileHEVCMain422_12:
233 case VAProfileHEVCMain444:
234 case VAProfileHEVCMain444_10:
235 case VAProfileHEVCMain444_12:
236 case VAProfileHEVCSccMain:
237 case VAProfileHEVCSccMain10:
238 case VAProfileHEVCSccMain444:
239 case VAProfileHEVCSccMain444_10:
240 return CODECHAL_DECODE_MODE_HEVCVLD;
241 case VAProfileVC1Simple:
242 case VAProfileVC1Main:
243 case VAProfileVC1Advanced:
244 return CODECHAL_DECODE_MODE_VC1VLD;
245 case VAProfileAV1Profile0:
246 case VAProfileAV1Profile1:
247 return CODECHAL_DECODE_MODE_AV1VLD;
248 default:
249 DDI_ASSERTMESSAGE("Invalid Decode Mode");
250 return CODECHAL_UNSUPPORTED_MODE;
251 }
252 }
253
GetDecodeCodecKey(VAProfile profile)254 std::string MediaLibvaCapsG12::GetDecodeCodecKey(VAProfile profile)
255 {
256 int8_t vaProfile = (int8_t)profile;
257 switch (vaProfile)
258 {
259 case VAProfileH264High:
260 case VAProfileH264Main:
261 case VAProfileH264ConstrainedBaseline:
262 return DECODE_ID_AVC;
263 case VAProfileMPEG2Main:
264 case VAProfileMPEG2Simple:
265 return DECODE_ID_MPEG2;
266 case VAProfileJPEGBaseline:
267 return DECODE_ID_JPEG;
268 case VAProfileVP8Version0_3:
269 return DECODE_ID_VP8;
270 case VAProfileVP9Profile0:
271 case VAProfileVP9Profile1:
272 case VAProfileVP9Profile2:
273 case VAProfileVP9Profile3:
274 return DECODE_ID_VP9;
275 case VAProfileHEVCMain:
276 case VAProfileHEVCMain10:
277 case VAProfileHEVCMain12:
278 case VAProfileHEVCMain422_10:
279 case VAProfileHEVCMain422_12:
280 case VAProfileHEVCMain444:
281 case VAProfileHEVCMain444_10:
282 case VAProfileHEVCMain444_12:
283 case VAProfileHEVCSccMain:
284 case VAProfileHEVCSccMain10:
285 case VAProfileHEVCSccMain444:
286 case VAProfileHEVCSccMain444_10:
287 return DECODE_ID_HEVC_REXT;
288 case VAProfileVC1Simple:
289 case VAProfileVC1Main:
290 case VAProfileVC1Advanced:
291 return DECODE_ID_VC1;
292 case VAProfileAV1Profile0:
293 case VAProfileAV1Profile1:
294 return DECODE_ID_AV1;
295 default:
296 DDI_ASSERTMESSAGE("Invalid Decode Mode");
297 return DECODE_ID_NONE;
298 }
299 }
300
GetEncodeCodecKey(VAProfile profile,VAEntrypoint entrypoint,uint32_t feiFunction)301 std::string MediaLibvaCapsG12::GetEncodeCodecKey(VAProfile profile, VAEntrypoint entrypoint, uint32_t feiFunction)
302 {
303 switch (profile)
304 {
305 case VAProfileH264High:
306 case VAProfileH264Main:
307 case VAProfileH264ConstrainedBaseline:
308 if (IsEncFei(entrypoint, feiFunction))
309 return ENCODE_ID_AVCFEI;
310 else
311 return ENCODE_ID_AVC;
312 case VAProfileMPEG2Main:
313 case VAProfileMPEG2Simple:
314 return ENCODE_ID_MPEG2;
315 case VAProfileJPEGBaseline:
316 return ENCODE_ID_JPEG;
317 case VAProfileVP8Version0_3:
318 return ENCODE_ID_VP8;
319 case VAProfileVP9Profile0:
320 case VAProfileVP9Profile1:
321 case VAProfileVP9Profile2:
322 case VAProfileVP9Profile3:
323 return ENCODE_ID_VP9;
324 case VAProfileHEVCMain:
325 case VAProfileHEVCMain10:
326 case VAProfileHEVCMain12:
327 case VAProfileHEVCMain422_10:
328 case VAProfileHEVCMain422_12:
329 case VAProfileHEVCMain444:
330 case VAProfileHEVCMain444_10:
331 case VAProfileHEVCSccMain:
332 case VAProfileHEVCSccMain10:
333 case VAProfileHEVCSccMain444:
334 case VAProfileHEVCSccMain444_10:
335 if (IsEncFei(entrypoint, feiFunction))
336 return ENCODE_ID_HEVCFEI;
337 else
338 return ENCODE_ID_HEVC;
339 case VAProfileNone:
340 if (IsEncFei(entrypoint, feiFunction))
341 return ENCODE_ID_AVCFEI;
342 else
343 return ENCODE_ID_NONE;
344 default:
345 return ENCODE_ID_NONE;
346 }
347 }
348
IsAV1Profile(VAProfile profile)349 bool MediaLibvaCapsG12::IsAV1Profile(VAProfile profile)
350 {
351 return (profile == (VAProfile)VAProfileAV1Profile0 ||
352 profile == (VAProfile)VAProfileAV1Profile1);
353 }
354
GetPlatformSpecificAttrib(VAProfile profile,VAEntrypoint entrypoint,VAConfigAttribType type,uint32_t * value)355 VAStatus MediaLibvaCapsG12::GetPlatformSpecificAttrib(VAProfile profile,
356 VAEntrypoint entrypoint,
357 VAConfigAttribType type,
358 uint32_t *value)
359 {
360 DDI_CHK_NULL(value, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
361 VAStatus status = VA_STATUS_SUCCESS;
362 *value = VA_ATTRIB_NOT_SUPPORTED;
363 switch ((int)type)
364 {
365 case VAConfigAttribEncMaxRefFrames:
366 {
367 // just VAConfigAttribEncMaxRefFrames of HEVC VME is different with platforms
368 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
369 {
370 *value = ENCODE_DP_HEVC_NUM_MAX_VME_L0_REF_G12 | (ENCODE_DP_HEVC_NUM_MAX_VME_L1_REF_G12 << 16);
371 }
372 else
373 {
374 status = VA_STATUS_ERROR_INVALID_PARAMETER;
375 }
376 break;
377 }
378 case VAConfigAttribDecProcessing:
379 {
380 #ifdef _DECODE_PROCESSING_SUPPORTED
381 if ((IsAvcProfile(profile) || IsHevcProfile(profile) || IsJpegProfile(profile) || IsVp9Profile(profile))
382 && !(MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrDisableVDBox2SFC)))
383 {
384 *value = VA_DEC_PROCESSING;
385 }
386 else
387 #endif
388 {
389 *value = VA_DEC_PROCESSING_NONE;
390 }
391 break;
392 }
393 case VAConfigAttribEncIntraRefresh:
394 {
395 if(IsAvcProfile(profile) || (entrypoint == VAEntrypointEncSliceLP && IsHevcProfile(profile)))
396 {
397 *value = VA_ENC_INTRA_REFRESH_ROLLING_COLUMN | VA_ENC_INTRA_REFRESH_ROLLING_ROW;
398 }
399 else
400 {
401 *value = VA_ENC_INTRA_REFRESH_NONE;
402 }
403 break;
404 }
405 case VAConfigAttribEncROI:
406 {
407 if (entrypoint == VAEntrypointEncSliceLP)
408 {
409 status = VA_STATUS_ERROR_INVALID_PARAMETER;
410 }
411 else if (IsAvcProfile(profile))
412 {
413 VAConfigAttribValEncROI roi_attrib = {0};
414 roi_attrib.bits.num_roi_regions = ENCODE_DP_AVC_MAX_ROI_NUM_BRC;
415 roi_attrib.bits.roi_rc_priority_support = 1;
416 roi_attrib.bits.roi_rc_qp_delta_support = 1;
417 *value = roi_attrib.value;
418 }
419 else if (IsHevcProfile(profile))
420 {
421 VAConfigAttribValEncROI roi_attrib = {0};
422 roi_attrib.bits.num_roi_regions = CODECHAL_ENCODE_HEVC_MAX_NUM_ROI;
423 roi_attrib.bits.roi_rc_priority_support = 0;
424 roi_attrib.bits.roi_rc_qp_delta_support = 1;
425 *value = roi_attrib.value;
426 }
427 break;
428 }
429 case VAConfigAttribCustomRoundingControl:
430 {
431 *value = 1;
432 break;
433 }
434 case VAConfigAttribEncMaxSlices:
435 {
436 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
437 {
438 *value = CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6;
439 }
440 else
441 {
442 *value =0;
443 status = VA_STATUS_ERROR_INVALID_PARAMETER;
444 }
445 break;
446 }
447 case VAConfigAttribMaxPictureWidth:
448 {
449 if(profile == VAProfileJPEGBaseline)
450 {
451 *value = ENCODE_JPEG_MAX_PIC_WIDTH;
452 }
453 else if(IsHevcProfile(profile))
454 {
455 *value = CODEC_16K_MAX_PIC_WIDTH;
456 }
457 else if(IsVp9Profile(profile))
458 {
459 *value = CODEC_8K_MAX_PIC_WIDTH;
460 }
461 else if(IsAvcProfile(profile))
462 {
463 *value = CODEC_4K_MAX_PIC_WIDTH;
464 }
465 else if(IsMpeg2Profile(profile))
466 {
467 *value = CODEC_2K_MAX_PIC_WIDTH;
468 }
469 else
470 {
471 *value = CODEC_MAX_PIC_WIDTH;
472 }
473 break;
474 }
475 case VAConfigAttribMaxPictureHeight:
476 {
477 if(profile == VAProfileJPEGBaseline)
478 {
479 *value = ENCODE_JPEG_MAX_PIC_HEIGHT;
480 }
481 else if(IsHevcProfile(profile))
482 {
483 *value = CODEC_12K_MAX_PIC_HEIGHT;
484 }
485 else if(IsVp9Profile(profile))
486 {
487 *value = CODEC_8K_MAX_PIC_HEIGHT;
488 }
489 else if(IsAvcProfile(profile))
490 {
491 *value = CODEC_4K_MAX_PIC_HEIGHT;
492 }
493 else if(IsMpeg2Profile(profile))
494 {
495 *value = CODEC_2K_MAX_PIC_HEIGHT;
496 }
497 else
498 {
499 *value = CODEC_MAX_PIC_HEIGHT;
500 }
501 break;
502 }
503 case VAConfigAttribQPBlockSize:
504 {
505 if(IsAvcProfile(profile))
506 {
507 *value = CODECHAL_MACROBLOCK_WIDTH;
508 }
509 else
510 {
511 status = VA_STATUS_ERROR_INVALID_PARAMETER;
512 }
513 break;
514 }
515 case VAConfigAttribPredictionDirection:
516 {
517 if (!IsHevcSccProfile(profile))
518 {
519 *value = VA_PREDICTION_DIRECTION_PREVIOUS | VA_PREDICTION_DIRECTION_FUTURE | VA_PREDICTION_DIRECTION_BI_NOT_EMPTY;
520 }
521 else
522 {
523 // Here we set
524 // VAConfigAttribPredictionDirection: VA_PREDICTION_DIRECTION_PREVIOUS | VA_PREDICTION_DIRECTION_BI_NOT_EMPTY together with
525 // VAConfigAttribEncMaxRefFrames: L0 != 0, L1 !=0
526 // to indicate SCC only supports I/low delay B
527 *value = VA_PREDICTION_DIRECTION_PREVIOUS | VA_PREDICTION_DIRECTION_BI_NOT_EMPTY;
528 }
529 break;
530 }
531 #if VA_CHECK_VERSION(1, 12, 0)
532 case VAConfigAttribEncHEVCFeatures:
533 {
534 if ((entrypoint == VAEntrypointEncSlice || entrypoint == VAEntrypointEncSliceLP) && IsHevcProfile(profile))
535 {
536 VAConfigAttribValEncHEVCFeatures hevcFeatures = {0};
537 hevcFeatures.bits.separate_colour_planes = VA_FEATURE_NOT_SUPPORTED;
538 hevcFeatures.bits.scaling_lists = VA_FEATURE_SUPPORTED;
539 hevcFeatures.bits.amp = VA_FEATURE_REQUIRED;
540 hevcFeatures.bits.sao = VA_FEATURE_SUPPORTED;
541 hevcFeatures.bits.pcm = VA_FEATURE_NOT_SUPPORTED;
542 hevcFeatures.bits.temporal_mvp = VA_FEATURE_SUPPORTED;
543 hevcFeatures.bits.strong_intra_smoothing = VA_FEATURE_NOT_SUPPORTED;
544 hevcFeatures.bits.dependent_slices = VA_FEATURE_NOT_SUPPORTED;
545 hevcFeatures.bits.sign_data_hiding = VA_FEATURE_NOT_SUPPORTED;
546 hevcFeatures.bits.constrained_intra_pred = VA_FEATURE_NOT_SUPPORTED;
547 hevcFeatures.bits.transform_skip = VA_FEATURE_SUPPORTED;
548 hevcFeatures.bits.cu_qp_delta = VA_FEATURE_REQUIRED;
549 hevcFeatures.bits.weighted_prediction = VA_FEATURE_SUPPORTED;
550 hevcFeatures.bits.transquant_bypass = VA_FEATURE_NOT_SUPPORTED;
551 hevcFeatures.bits.deblocking_filter_disable = VA_FEATURE_NOT_SUPPORTED;
552 *value = hevcFeatures.value;
553 }
554 break;
555 }
556 case VAConfigAttribEncHEVCBlockSizes:
557 {
558 if (entrypoint == VAEntrypointEncSlice && IsHevcProfile(profile))
559 {
560 VAConfigAttribValEncHEVCBlockSizes hevcBlockSize = {0};
561 hevcBlockSize.bits.log2_max_coding_tree_block_size_minus3 = 3;
562 hevcBlockSize.bits.log2_min_coding_tree_block_size_minus3 = 1;
563 hevcBlockSize.bits.log2_min_luma_coding_block_size_minus3 = 0;
564 hevcBlockSize.bits.log2_max_luma_transform_block_size_minus2 = 3;
565 hevcBlockSize.bits.log2_min_luma_transform_block_size_minus2 = 0;
566 hevcBlockSize.bits.max_max_transform_hierarchy_depth_inter = 2;
567 hevcBlockSize.bits.min_max_transform_hierarchy_depth_inter = 0;
568 hevcBlockSize.bits.max_max_transform_hierarchy_depth_intra = 2;
569 hevcBlockSize.bits.min_max_transform_hierarchy_depth_intra = 0;
570 hevcBlockSize.bits.log2_max_pcm_coding_block_size_minus3 = 0;
571 hevcBlockSize.bits.log2_min_pcm_coding_block_size_minus3 = 0;
572 *value = hevcBlockSize.value;
573 }
574 if (entrypoint == VAEntrypointEncSliceLP && IsHevcProfile(profile))
575 {
576 VAConfigAttribValEncHEVCBlockSizes hevcBlockSize = {0};
577 hevcBlockSize.bits.log2_max_coding_tree_block_size_minus3 = 3;
578 hevcBlockSize.bits.log2_min_coding_tree_block_size_minus3 = 3;
579 hevcBlockSize.bits.log2_min_luma_coding_block_size_minus3 = 0;
580 hevcBlockSize.bits.log2_max_luma_transform_block_size_minus2 = 3;
581 hevcBlockSize.bits.log2_min_luma_transform_block_size_minus2 = 0;
582 hevcBlockSize.bits.max_max_transform_hierarchy_depth_inter = 2;
583 hevcBlockSize.bits.min_max_transform_hierarchy_depth_inter = 0;
584 hevcBlockSize.bits.max_max_transform_hierarchy_depth_intra = 2;
585 hevcBlockSize.bits.min_max_transform_hierarchy_depth_intra = 0;
586 hevcBlockSize.bits.log2_max_pcm_coding_block_size_minus3 = 0;
587 hevcBlockSize.bits.log2_min_pcm_coding_block_size_minus3 = 0;
588 *value = hevcBlockSize.value;
589 }
590 break;
591 }
592 #endif
593 default:
594 status = VA_STATUS_ERROR_INVALID_PARAMETER;
595 break;
596 }
597 return status;
598 }
599
LoadHevcEncProfileEntrypoints()600 VAStatus MediaLibvaCapsG12::LoadHevcEncProfileEntrypoints()
601 {
602 VAStatus status = VA_STATUS_SUCCESS;
603
604 #ifdef _HEVC_ENCODE_VME_SUPPORTED
605
606 status = MediaLibvaCaps::LoadHevcEncProfileEntrypoints();
607 DDI_CHK_RET(status, "Failed to initialize Caps!");
608
609 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC))
610 {
611 SetAttribute(VAProfileHEVCMain, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
612 }
613
614 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC10bit))
615 {
616 SetAttribute(VAProfileHEVCMain10, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
617 }
618
619 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC12bit))
620 {
621 SetAttribute(VAProfileHEVCMain12, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
622 }
623
624 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC10bit422))
625 {
626 SetAttribute(VAProfileHEVCMain422_10, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
627 }
628
629 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVC12bit422))
630 {
631 SetAttribute(VAProfileHEVCMain422_12, VAEntrypointEncSlice, VAConfigAttribEncTileSupport, 1);
632 }
633 #endif
634 return status;
635 }
636
LoadHevcEncLpProfileEntrypoints()637 VAStatus MediaLibvaCapsG12::LoadHevcEncLpProfileEntrypoints()
638 {
639 VAStatus status = VA_STATUS_SUCCESS;
640 const uint8_t rcModeSize = (sizeof(m_encRcMode))/(sizeof(m_encRcMode[0]));
641
642 #ifdef _HEVC_ENCODE_VDENC_SUPPORTED
643 AttribMap *attributeList = nullptr;
644
645 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain)
646 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10)
647 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444)
648 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444))
649 {
650 status = CreateEncAttributes(VAProfileHEVCMain, VAEntrypointEncSliceLP, &attributeList);
651 DDI_CHK_RET(status, "Failed to initialize Caps!");
652 (*attributeList)[VAConfigAttribMaxPictureWidth] = CODEC_16K_MAX_PIC_WIDTH;
653 (*attributeList)[VAConfigAttribMaxPictureHeight] = CODEC_12K_MAX_PIC_HEIGHT;
654 (*attributeList)[VAConfigAttribEncTileSupport] = 1;
655 }
656
657 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain))
658 {
659 uint32_t configStartIdx = m_encConfigs.size();
660 AddEncConfig(VA_RC_CQP);
661 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
662 {
663 for (int32_t j = 3; j < rcModeSize; j++)
664 {
665 AddEncConfig(m_encRcMode[j]);
666 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
667 }
668 }
669 AddProfileEntry(VAProfileHEVCMain, VAEntrypointEncSliceLP, attributeList,
670 configStartIdx, m_encConfigs.size() - configStartIdx);
671 }
672 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit422))
673 {
674 uint32_t configStartIdx = m_encConfigs.size();
675 AddEncConfig(VA_RC_CQP);
676 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
677 {
678 for (int32_t j = 3; j < rcModeSize; j++)
679 {
680 AddEncConfig(m_encRcMode[j]);
681 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
682 }
683 }
684 AddProfileEntry(VAProfileHEVCMain422_10, VAEntrypointEncSliceLP, attributeList,
685 configStartIdx, m_encConfigs.size() - configStartIdx);
686 }
687 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10))
688 {
689 uint32_t configStartIdx = m_encConfigs.size();
690 AddEncConfig(VA_RC_CQP);
691 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
692 {
693 for (int32_t j = 3; j < rcModeSize; j++)
694 {
695 AddEncConfig(m_encRcMode[j]);
696 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
697 }
698 }
699 AddProfileEntry(VAProfileHEVCMain10, VAEntrypointEncSliceLP, attributeList,
700 configStartIdx, m_encConfigs.size() - configStartIdx);
701 }
702
703 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444))
704 {
705 uint32_t configStartIdx = m_encConfigs.size();
706 AddEncConfig(VA_RC_CQP);
707 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
708 {
709 for (int32_t j = 3; j < rcModeSize; j++)
710 {
711 AddEncConfig(m_encRcMode[j]);
712 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
713 }
714 }
715 AddProfileEntry(VAProfileHEVCMain444, VAEntrypointEncSliceLP, attributeList,
716 configStartIdx, m_encConfigs.size() - configStartIdx);
717 }
718
719 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444))
720 {
721 uint32_t configStartIdx = m_encConfigs.size();
722 AddEncConfig(VA_RC_CQP);
723 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
724 {
725 for (int32_t j = 3; j < rcModeSize; j++)
726 {
727 AddEncConfig(m_encRcMode[j]);
728 AddEncConfig(m_encRcMode[j] | VA_RC_PARALLEL);
729 }
730 }
731 AddProfileEntry(VAProfileHEVCMain444_10, VAEntrypointEncSliceLP, attributeList,
732 configStartIdx, m_encConfigs.size() - configStartIdx);
733 }
734
735 // SCC needs a separate attribute list from other profiles
736 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMainSCC)
737 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bitSCC)
738 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444SCC)
739 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444SCC))
740 {
741 status = CreateEncAttributes(VAProfileHEVCSccMain, VAEntrypointEncSliceLP, &attributeList);
742 DDI_CHK_RET(status, "Failed to initialize Caps!");
743 (*attributeList)[VAConfigAttribMaxPictureWidth] = CODEC_16K_MAX_PIC_WIDTH;
744 (*attributeList)[VAConfigAttribMaxPictureHeight] = CODEC_12K_MAX_PIC_HEIGHT;
745 (*attributeList)[VAConfigAttribEncTileSupport] = 1;
746 }
747
748 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMainSCC))
749 {
750 uint32_t configStartIdx = m_encConfigs.size();
751 AddEncConfig(VA_RC_CQP);
752 AddProfileEntry(VAProfileHEVCSccMain, VAEntrypointEncSliceLP, attributeList,
753 configStartIdx, m_encConfigs.size() - configStartIdx);
754 }
755
756 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bitSCC))
757 {
758 uint32_t configStartIdx = m_encConfigs.size();
759 AddEncConfig(VA_RC_CQP);
760 AddProfileEntry(VAProfileHEVCSccMain10, VAEntrypointEncSliceLP, attributeList,
761 configStartIdx, m_encConfigs.size() - configStartIdx);
762 }
763
764 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain444SCC))
765 {
766 uint32_t configStartIdx = m_encConfigs.size();
767 AddEncConfig(VA_RC_CQP);
768 AddProfileEntry(VAProfileHEVCSccMain444, VAEntrypointEncSliceLP, attributeList,
769 configStartIdx, m_encConfigs.size() - configStartIdx);
770 }
771
772 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeHEVCVdencMain10bit444SCC))
773 {
774 uint32_t configStartIdx = m_encConfigs.size();
775 AddEncConfig(VA_RC_CQP);
776 AddProfileEntry(VAProfileHEVCSccMain444_10, VAEntrypointEncSliceLP, attributeList,
777 configStartIdx, m_encConfigs.size() - configStartIdx);
778 }
779 #endif
780 return status;
781 }
782
LoadVp9EncProfileEntrypoints()783 VAStatus MediaLibvaCapsG12::LoadVp9EncProfileEntrypoints()
784 {
785 VAStatus status = VA_STATUS_SUCCESS;
786
787 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
788 AttribMap *attributeList = nullptr;
789 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels) &&
790 (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc) ||
791 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc8bit444) ||
792 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit420) ||
793 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit444)))
794 {
795 status = CreateEncAttributes(VAProfileVP9Profile0, VAEntrypointEncSliceLP, &attributeList);
796 DDI_CHK_RET(status, "Failed to initialize Caps!");
797 (*attributeList)[VAConfigAttribMaxPictureWidth] = m_maxVp9EncWidth;
798 (*attributeList)[VAConfigAttribMaxPictureHeight] = m_maxVp9EncHeight;
799 (*attributeList)[VAConfigAttribEncDynamicScaling] = 1;
800 (*attributeList)[VAConfigAttribEncTileSupport] = 1;
801 (*attributeList)[VAConfigAttribEncRateControlExt] = m_encVp9RateControlExt.value;
802 }
803
804 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc) &&
805 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
806 {
807 uint32_t configStartIdx = m_encConfigs.size();
808 AddEncConfig(VA_RC_CQP);
809 AddEncConfig(VA_RC_CBR);
810 AddEncConfig(VA_RC_VBR);
811 AddEncConfig(VA_RC_ICQ); // for VP9 CQL only
812 AddProfileEntry(VAProfileVP9Profile0, VAEntrypointEncSliceLP, attributeList,
813 configStartIdx, m_encConfigs.size() - configStartIdx);
814 }
815
816 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc8bit444) &&
817 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
818 {
819 uint32_t configStartIdx = m_encConfigs.size();
820 AddEncConfig(VA_RC_CQP);
821 AddEncConfig(VA_RC_CBR);
822 AddEncConfig(VA_RC_VBR);
823 AddEncConfig(VA_RC_ICQ); // for VP9 CQL only
824 AddProfileEntry(VAProfileVP9Profile1, VAEntrypointEncSliceLP, attributeList,
825 configStartIdx, m_encConfigs.size() - configStartIdx);
826 }
827
828 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit420) &&
829 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
830 {
831 uint32_t configStartIdx = m_encConfigs.size();
832 AddEncConfig(VA_RC_CQP);
833 AddEncConfig(VA_RC_CBR);
834 AddEncConfig(VA_RC_VBR);
835 AddEncConfig(VA_RC_ICQ); // for VP9 CQL only
836 AddProfileEntry(VAProfileVP9Profile2, VAEntrypointEncSliceLP, attributeList,
837 configStartIdx, m_encConfigs.size() - configStartIdx);
838 }
839
840 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEncodeVP9Vdenc10bit444) &&
841 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
842 {
843 uint32_t configStartIdx = m_encConfigs.size();
844 AddEncConfig(VA_RC_CQP);
845 AddEncConfig(VA_RC_CBR);
846 AddEncConfig(VA_RC_VBR);
847 AddEncConfig(VA_RC_ICQ); // for VP9 CQL only
848 AddProfileEntry(VAProfileVP9Profile3, VAEntrypointEncSliceLP, attributeList,
849 configStartIdx, m_encConfigs.size() - configStartIdx);
850 }
851 #endif
852 return status;
853 }
854
LoadProfileEntrypoints()855 VAStatus MediaLibvaCapsG12::LoadProfileEntrypoints()
856 {
857 VAStatus status = VA_STATUS_SUCCESS;
858 status = LoadAvcDecProfileEntrypoints();
859 DDI_CHK_RET(status, "Failed to initialize Caps!");
860 status = LoadAvcEncProfileEntrypoints();
861 DDI_CHK_RET(status, "Failed to initialize Caps!");
862 status = LoadAvcEncLpProfileEntrypoints();
863 DDI_CHK_RET(status, "Failed to initialize Caps!");
864 status = LoadMpeg2DecProfileEntrypoints();
865 DDI_CHK_RET(status, "Failed to initialize Caps!");
866 status = LoadMpeg2EncProfileEntrypoints();
867 DDI_CHK_RET(status, "Failed to initialize Caps!");
868 status = LoadVc1DecProfileEntrypoints();
869 DDI_CHK_RET(status, "Failed to initialize Caps!");
870 status = LoadJpegDecProfileEntrypoints();
871 DDI_CHK_RET(status, "Failed to initialize Caps!");
872 status = LoadJpegEncProfileEntrypoints();
873 DDI_CHK_RET(status, "Failed to initialize Caps!");
874 status = LoadHevcDecProfileEntrypoints();
875 DDI_CHK_RET(status, "Failed to initialize Caps!");
876 status = LoadHevcEncProfileEntrypoints();
877 DDI_CHK_RET(status, "Failed to initialize Caps!");
878 status = LoadHevcEncLpProfileEntrypoints();
879 DDI_CHK_RET(status, "Failed to initialize Caps!");
880 status = LoadVp8DecProfileEntrypoints();
881 DDI_CHK_RET(status, "Failed to initialize Caps!");
882 status = LoadVp8EncProfileEntrypoints();
883 DDI_CHK_RET(status, "Failed to initialize Caps!");
884 status = LoadVp9DecProfileEntrypoints();
885 DDI_CHK_RET(status, "Failed to initialize Caps!");
886 status = LoadVp9EncProfileEntrypoints();
887 DDI_CHK_RET(status, "Failed to initialize Caps!");
888 status = LoadAv1DecProfileEntrypoints();
889 DDI_CHK_RET(status, "Failed to initialize Caps!");
890 status = LoadNoneProfileEntrypoints();
891 DDI_CHK_RET(status, "Failed to initialize Caps!");
892 status = m_CapsCp->LoadCpProfileEntrypoints();
893 DDI_CHK_RET(status, "Failed to initialize CP Caps!");
894
895 return status;
896 }
897
CheckEncodeResolution(VAProfile profile,uint32_t width,uint32_t height)898 VAStatus MediaLibvaCapsG12::CheckEncodeResolution(
899 VAProfile profile,
900 uint32_t width,
901 uint32_t height)
902 {
903 switch (profile)
904 {
905 case VAProfileJPEGBaseline:
906 if (width > m_encJpegMaxWidth
907 || width < m_encJpegMinWidth
908 || height > m_encJpegMaxHeight
909 || height < m_encJpegMinHeight)
910 {
911 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
912 }
913 break;
914 case VAProfileMPEG2Simple:
915 case VAProfileMPEG2Main:
916 if( width > CODEC_MAX_PIC_WIDTH
917 || width < m_encMinWidth
918 || height > CODEC_MAX_PIC_HEIGHT
919 || height < m_encMinHeight)
920 {
921 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
922 }
923 break;
924 case VAProfileHEVCMain:
925 case VAProfileHEVCMain10:
926 case VAProfileHEVCMain12:
927 case VAProfileHEVCMain444:
928 case VAProfileHEVCMain444_10:
929 case VAProfileHEVCMain422_10:
930 case VAProfileHEVCMain422_12:
931 case VAProfileHEVCSccMain:
932 case VAProfileHEVCSccMain10:
933 case VAProfileHEVCSccMain444:
934 case VAProfileHEVCSccMain444_10:
935 if (width > m_maxHevcEncWidth
936 || width < (m_vdencActive ? m_hevcVDEncMinWidth : m_encMinWidth)
937 || height > m_maxHevcEncHeight
938 || height < (m_vdencActive ? m_hevcVDEncMinHeight : m_encMinHeight))
939 {
940 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
941 }
942 break;
943 case VAProfileVP9Profile0:
944 case VAProfileVP9Profile1:
945 case VAProfileVP9Profile2:
946 case VAProfileVP9Profile3:
947 if ((width > m_maxVp9EncWidth) ||
948 (width < m_minVp9EncWidth) ||
949 (height > m_maxVp9EncHeight) ||
950 (height < m_minVp9EncHeight) )
951 {
952 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
953 }
954 break;
955 default:
956 if (width > m_encMax4kWidth
957 || width < m_encMinWidth
958 || height > m_encMax4kHeight
959 || height < m_encMinHeight)
960 {
961 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
962 }
963 break;
964 }
965 return VA_STATUS_SUCCESS;
966 }
CheckDecodeResolution(int32_t codecMode,VAProfile profile,uint32_t width,uint32_t height)967 VAStatus MediaLibvaCapsG12::CheckDecodeResolution(
968 int32_t codecMode,
969 VAProfile profile,
970 uint32_t width,
971 uint32_t height)
972 {
973
974 uint32_t maxWidth, maxHeight;
975 switch (codecMode)
976 {
977 case CODECHAL_DECODE_MODE_MPEG2VLD:
978 maxWidth = m_decMpeg2MaxWidth;
979 maxHeight = m_decMpeg2MaxHeight;
980 break;
981 case CODECHAL_DECODE_MODE_VC1VLD:
982 maxWidth = m_decVc1MaxWidth;
983 maxHeight = m_decVc1MaxHeight;
984 break;
985 case CODECHAL_DECODE_MODE_JPEG:
986 maxWidth = m_decJpegMaxWidth;
987 maxHeight = m_decJpegMaxHeight;
988 break;
989 case CODECHAL_DECODE_MODE_AVCVLD:
990 maxWidth = m_decAvcMaxWidth;
991 maxHeight = m_decAvcMaxHeight;
992 break;
993 case CODECHAL_DECODE_MODE_HEVCVLD:
994 maxWidth = m_decHevcMax16kWidth;
995 maxHeight = m_decHevcMax16kHeight;
996 break;
997 case CODECHAL_DECODE_MODE_VP9VLD:
998 case CODECHAL_DECODE_MODE_AV1VLD:
999 maxWidth = m_decVp9Max16kWidth;
1000 maxHeight = m_decVp9Max16kHeight;
1001 break;
1002 default:
1003 maxWidth = m_decDefaultMaxWidth;
1004 maxHeight = m_decDefaultMaxHeight;
1005 break;
1006 }
1007
1008 uint32_t alignedHeight;
1009 if (profile == VAProfileVC1Advanced)
1010 {
1011 alignedHeight = MOS_ALIGN_CEIL(height,32);
1012 }
1013 else
1014 {
1015 alignedHeight = height;
1016 }
1017
1018 if (width > maxWidth || alignedHeight > maxHeight)
1019 {
1020 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
1021 }
1022 else
1023 {
1024 return VA_STATUS_SUCCESS;
1025 }
1026 }
1027
AddEncSurfaceAttributes(VAProfile profile,VAEntrypoint entrypoint,VASurfaceAttrib * attribList,uint32_t & numAttribs)1028 VAStatus MediaLibvaCapsG12::AddEncSurfaceAttributes(
1029 VAProfile profile,
1030 VAEntrypoint entrypoint,
1031 VASurfaceAttrib *attribList,
1032 uint32_t &numAttribs)
1033 {
1034 DDI_CHK_NULL(attribList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
1035
1036 if(entrypoint == VAEntrypointEncSlice || entrypoint == VAEntrypointEncSliceLP || entrypoint == VAEntrypointEncPicture || entrypoint == VAEntrypointFEI)
1037 {
1038 if (profile == VAProfileHEVCMain10 || profile == VAProfileHEVCSccMain10 || profile == VAProfileVP9Profile2)
1039 {
1040 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1041 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1042 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1043 attribList[numAttribs].value.value.i = VA_FOURCC('P', '0', '1', '0');
1044 numAttribs++;
1045
1046 if (profile == VAProfileVP9Profile2)
1047 {
1048 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1049 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1050 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1051 attribList[numAttribs].value.value.i = VA_FOURCC_P012;
1052 numAttribs++;
1053
1054 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1055 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1056 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1057 attribList[numAttribs].value.value.i = VA_FOURCC_P016;
1058 numAttribs++;
1059 }
1060 }
1061 else if(profile == VAProfileHEVCMain12)
1062 {
1063 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1064 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1065 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1066 attribList[numAttribs].value.value.i = VA_FOURCC_P012;
1067 numAttribs++;
1068
1069 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1070 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1071 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1072 attribList[numAttribs].value.value.i = VA_FOURCC_P016;
1073 numAttribs++;
1074 }
1075 else if (profile == VAProfileHEVCMain444 || profile == VAProfileHEVCSccMain444)
1076 {
1077 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1078 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1079 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1080 attribList[numAttribs].value.value.i = VA_FOURCC_AYUV;
1081 numAttribs++;
1082
1083 #if VA_CHECK_VERSION(1, 13, 0)
1084 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1085 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1086 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1087 attribList[numAttribs].value.value.i = VA_FOURCC_XYUV;
1088 numAttribs++;
1089 #endif
1090 }
1091 else if (profile == VAProfileHEVCMain444_10 || profile == VAProfileHEVCSccMain444_10)
1092 {
1093 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1094 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1095 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1096 attribList[numAttribs].value.value.i = VA_FOURCC_Y410;
1097 numAttribs++;
1098 }
1099 else if(profile == VAProfileHEVCMain422_10)
1100 {
1101 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1102 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1103 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1104 attribList[numAttribs].value.value.i = VA_FOURCC_YUY2;
1105 numAttribs++;
1106
1107 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1108 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1109 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1110 attribList[numAttribs].value.value.i = VA_FOURCC_Y210;
1111 numAttribs++;
1112 }
1113 else if(profile == VAProfileHEVCMain422_12)
1114 {
1115 //hevc rext: Y216 12/16bit 422
1116 #if VA_CHECK_VERSION(1, 9, 0)
1117 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1118 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1119 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1120 attribList[numAttribs].value.value.i = VA_FOURCC_Y212;
1121 numAttribs++;
1122 #endif
1123
1124 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1125 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1126 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1127 attribList[numAttribs].value.value.i = VA_FOURCC_Y216;
1128 numAttribs++;
1129 }
1130 else if (profile == VAProfileJPEGBaseline)
1131 {
1132 for (int32_t j = 0; j < m_numJpegEncSurfaceAttr; j++)
1133 {
1134 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1135 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1136 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1137 attribList[numAttribs].value.value.i = m_jpegEncSurfaceAttr[j];
1138 numAttribs++;
1139 }
1140 }
1141 else if (profile == VAProfileVP9Profile1)
1142 {
1143 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1144 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1145 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1146 attribList[numAttribs].value.value.i = VA_FOURCC_AYUV;
1147 numAttribs++;
1148
1149 #if VA_CHECK_VERSION(1, 13, 0)
1150 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1151 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1152 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1153 attribList[numAttribs].value.value.i = VA_FOURCC_XYUV;
1154 numAttribs++;
1155 #endif
1156 }
1157 else if (profile == VAProfileVP9Profile3)
1158 {
1159 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1160 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1161 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1162 attribList[numAttribs].value.value.i = VA_FOURCC_Y410;
1163 numAttribs++;
1164
1165 #if VA_CHECK_VERSION(1, 9, 0)
1166 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1167 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1168 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1169 attribList[numAttribs].value.value.i = VA_FOURCC_Y412;
1170 numAttribs++;
1171 #endif
1172
1173 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1174 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1175 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1176 attribList[numAttribs].value.value.i = VA_FOURCC_Y416;
1177 numAttribs++;
1178
1179 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1180 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1181 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1182 attribList[numAttribs].value.value.i = VA_FOURCC('A', 'R', 'G', 'B');
1183 numAttribs++;
1184
1185 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1186 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1187 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1188 attribList[numAttribs].value.value.i = VA_FOURCC('A', 'B', 'G', 'R');
1189 numAttribs++;
1190 }
1191 else
1192 {
1193 attribList[numAttribs].type = VASurfaceAttribPixelFormat;
1194 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1195 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1196 attribList[numAttribs].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1197 numAttribs++;
1198 }
1199 attribList[numAttribs].type = VASurfaceAttribMaxWidth;
1200 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1201 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE;
1202 attribList[numAttribs].value.value.i = CODEC_MAX_PIC_WIDTH;
1203
1204 if(profile == VAProfileJPEGBaseline)
1205 {
1206 attribList[numAttribs].value.value.i = ENCODE_JPEG_MAX_PIC_WIDTH;
1207 }
1208 else if(IsHevcProfile(profile))
1209 {
1210 attribList[numAttribs].value.value.i = CODEC_16K_MAX_PIC_WIDTH;
1211 }
1212 else if(IsVp9Profile(profile))
1213 {
1214 attribList[numAttribs].value.value.i = CODEC_8K_MAX_PIC_WIDTH;
1215 }
1216 if(IsAvcProfile(profile))
1217 {
1218 attribList[numAttribs].value.value.i = CODEC_4K_MAX_PIC_WIDTH;
1219 }
1220 numAttribs++;
1221
1222 attribList[numAttribs].type = VASurfaceAttribMaxHeight;
1223 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1224 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE;
1225 attribList[numAttribs].value.value.i = CODEC_MAX_PIC_HEIGHT;
1226 if(profile == VAProfileJPEGBaseline)
1227 {
1228 attribList[numAttribs].value.value.i = ENCODE_JPEG_MAX_PIC_HEIGHT;
1229 }
1230 else if(IsHevcProfile(profile))
1231 {
1232 uint32_t heightValue = CODEC_12K_MAX_PIC_HEIGHT;
1233 GetPlatformSpecificAttrib(profile, entrypoint, VAConfigAttribMaxPictureHeight, &heightValue);
1234 attribList[numAttribs].value.value.i = (int32_t) heightValue;
1235 }
1236 else if(IsVp9Profile(profile))
1237 {
1238 attribList[numAttribs].value.value.i = CODEC_8K_MAX_PIC_HEIGHT;
1239 }
1240 if(IsAvcProfile(profile))
1241 {
1242 attribList[numAttribs].value.value.i = CODEC_4K_MAX_PIC_HEIGHT;
1243 }
1244 numAttribs++;
1245
1246 attribList[numAttribs].type = VASurfaceAttribMinWidth;
1247 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1248 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE;
1249 attribList[numAttribs].value.value.i = m_encMinWidth;
1250 if(IsHevcProfile(profile))
1251 {
1252 attribList[numAttribs].value.value.i = m_vdencActive ? m_hevcVDEncMinWidth : m_encMinWidth;
1253 }
1254 else if (IsVp9Profile(profile))
1255 {
1256 attribList[numAttribs].value.value.i = m_vdencActive ? m_minVp9EncWidth : m_encMinWidth;
1257 }
1258 else if (profile == VAProfileJPEGBaseline)
1259 {
1260 attribList[numAttribs].value.value.i = m_encJpegMinWidth;
1261 }
1262 numAttribs++;
1263
1264 attribList[numAttribs].type = VASurfaceAttribMinHeight;
1265 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1266 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE;
1267 attribList[numAttribs].value.value.i = m_encMinHeight;
1268 if(IsHevcProfile(profile))
1269 {
1270 attribList[numAttribs].value.value.i = m_vdencActive ? m_hevcVDEncMinHeight : m_encMinHeight;
1271 }
1272 else if (IsVp9Profile(profile))
1273 {
1274 attribList[numAttribs].value.value.i = m_vdencActive ? m_minVp9EncHeight : m_encMinHeight;
1275 }
1276 else if (profile == VAProfileJPEGBaseline)
1277 {
1278 attribList[numAttribs].value.value.i = m_encJpegMinHeight;
1279 }
1280 numAttribs++;
1281
1282 attribList[numAttribs].type = VASurfaceAttribMemoryType;
1283 attribList[numAttribs].value.type = VAGenericValueTypeInteger;
1284 attribList[numAttribs].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1285 attribList[numAttribs].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1286 #if VA_CHECK_VERSION(1, 21, 0)
1287 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1288 #endif
1289 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
1290 numAttribs++;
1291 }
1292
1293 return VA_STATUS_SUCCESS;
1294 }
QuerySurfaceAttributes(VAConfigID configId,VASurfaceAttrib * attribList,uint32_t * numAttribs)1295 VAStatus MediaLibvaCapsG12::QuerySurfaceAttributes(
1296 VAConfigID configId,
1297 VASurfaceAttrib *attribList,
1298 uint32_t *numAttribs)
1299 {
1300 DDI_CHK_NULL(numAttribs, "Null num_attribs", VA_STATUS_ERROR_INVALID_PARAMETER);
1301
1302 if (attribList == nullptr)
1303 {
1304 *numAttribs = DDI_CODEC_GEN_MAX_SURFACE_ATTRIBUTES;
1305 return VA_STATUS_SUCCESS;
1306 }
1307
1308 int32_t profileTableIdx = -1;
1309 VAEntrypoint entrypoint;
1310 VAProfile profile;
1311 VAStatus status = GetProfileEntrypointFromConfigId(configId, &profile, &entrypoint, &profileTableIdx);
1312 DDI_CHK_RET(status, "Invalid config_id!");
1313 if (profileTableIdx < 0 || profileTableIdx >= m_profileEntryCount)
1314 {
1315 return VA_STATUS_ERROR_INVALID_CONFIG;
1316 }
1317
1318 VASurfaceAttrib *attribs = (VASurfaceAttrib *)MOS_AllocAndZeroMemory(DDI_CODEC_GEN_MAX_SURFACE_ATTRIBUTES * sizeof(*attribs));
1319 if (attribs == nullptr)
1320 {
1321 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1322 }
1323
1324 uint32_t i = 0;
1325
1326 if (entrypoint == VAEntrypointVideoProc) /* vpp */
1327 {
1328 attribs[i].type = VASurfaceAttribPixelFormat;
1329 attribs[i].value.type = VAGenericValueTypeInteger;
1330 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1331 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1332 i++;
1333
1334 attribs[i].type = VASurfaceAttribMaxWidth;
1335 attribs[i].value.type = VAGenericValueTypeInteger;
1336 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1337 attribs[i].value.value.i = VP_MAX_PIC_WIDTH;
1338 i++;
1339
1340 attribs[i].type = VASurfaceAttribMaxHeight;
1341 attribs[i].value.type = VAGenericValueTypeInteger;
1342 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1343 attribs[i].value.value.i = VP_MAX_PIC_HEIGHT;
1344 i++;
1345
1346 attribs[i].type = VASurfaceAttribMinWidth;
1347 attribs[i].value.type = VAGenericValueTypeInteger;
1348 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1349 attribs[i].value.value.i = VP_MIN_PIC_WIDTH;
1350 i++;
1351
1352 attribs[i].type = VASurfaceAttribMinHeight;
1353 attribs[i].value.type = VAGenericValueTypeInteger;
1354 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1355 attribs[i].value.value.i = VP_MIN_PIC_HEIGHT;
1356 i++;
1357
1358 for (int32_t j = 0; j < m_numVpSurfaceAttr && m_vpSurfaceAttr[j]; j++)
1359 {
1360 attribs[i].type = VASurfaceAttribPixelFormat;
1361 attribs[i].value.type = VAGenericValueTypeInteger;
1362 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1363 attribs[i].value.value.i = m_vpSurfaceAttr[j];
1364 i++;
1365 }
1366
1367 attribs[i].type = VASurfaceAttribMemoryType;
1368 attribs[i].value.type = VAGenericValueTypeInteger;
1369 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1370 #ifdef ANDROID
1371 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1372 VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR |
1373 VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM |
1374 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME |
1375 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 |
1376 #if VA_CHECK_VERSION(1, 21, 0)
1377 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1378 #endif
1379 VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC;
1380 #else
1381 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1382 VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR |
1383 VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM |
1384 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME |
1385 #if VA_CHECK_VERSION(1, 21, 0)
1386 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1387 #endif
1388 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
1389 #endif
1390 i++;
1391
1392 attribs[i].type = VASurfaceAttribExternalBufferDescriptor;
1393 attribs[i].value.type = VAGenericValueTypePointer;
1394 attribs[i].flags = VA_SURFACE_ATTRIB_SETTABLE;
1395 attribs[i].value.value.p = nullptr; /* ignore */
1396 i++;
1397 }
1398 else if (entrypoint == VAEntrypointVLD) /* vld */
1399 {
1400 if (profile == VAProfileHEVCMain10 || profile == VAProfileVP9Profile2)
1401 {
1402 attribs[i].type = VASurfaceAttribPixelFormat;
1403 attribs[i].value.type = VAGenericValueTypeInteger;
1404 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1405 attribs[i].value.value.i = VA_FOURCC_P010;
1406 i++;
1407
1408 if(profile == VAProfileVP9Profile2)
1409 {
1410 attribs[i].type = VASurfaceAttribPixelFormat;
1411 attribs[i].value.type = VAGenericValueTypeInteger;
1412 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1413 attribs[i].value.value.i = VA_FOURCC_P012;
1414 i++;
1415
1416 attribs[i].type = VASurfaceAttribPixelFormat;
1417 attribs[i].value.type = VAGenericValueTypeInteger;
1418 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1419 attribs[i].value.value.i = VA_FOURCC_P016;
1420 i++;
1421 }
1422 }
1423 else if (profile == VAProfileAV1Profile0)
1424 {
1425 attribs[i].type = VASurfaceAttribPixelFormat;
1426 attribs[i].value.type = VAGenericValueTypeInteger;
1427 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1428 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1429 i++;
1430
1431 attribs[i].type = VASurfaceAttribPixelFormat;
1432 attribs[i].value.type = VAGenericValueTypeInteger;
1433 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1434 attribs[i].value.value.i = VA_FOURCC_P010;
1435 i++;
1436 }
1437 else if(profile == VAProfileHEVCMain12)
1438 {
1439 attribs[i].type = VASurfaceAttribPixelFormat;
1440 attribs[i].value.type = VAGenericValueTypeInteger;
1441 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1442 attribs[i].value.value.i = VA_FOURCC_P012;
1443 i++;
1444
1445 attribs[i].type = VASurfaceAttribPixelFormat;
1446 attribs[i].value.type = VAGenericValueTypeInteger;
1447 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1448 attribs[i].value.value.i = VA_FOURCC_P016;
1449 i++;
1450 }
1451 else if(profile == VAProfileHEVCMain422_10)
1452 {
1453 attribs[i].type = VASurfaceAttribPixelFormat;
1454 attribs[i].value.type = VAGenericValueTypeInteger;
1455 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1456 attribs[i].value.value.i = VA_FOURCC_YUY2;
1457 i++;
1458
1459 attribs[i].type = VASurfaceAttribPixelFormat;
1460 attribs[i].value.type = VAGenericValueTypeInteger;
1461 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1462 attribs[i].value.value.i = VA_FOURCC_Y210;
1463 i++;
1464 }
1465 else if(profile == VAProfileHEVCMain422_12)
1466 {
1467 //hevc rext: Y216 12/16bit 422
1468 #if VA_CHECK_VERSION(1, 9, 0)
1469 attribs[i].type = VASurfaceAttribPixelFormat;
1470 attribs[i].value.type = VAGenericValueTypeInteger;
1471 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1472 attribs[i].value.value.i = VA_FOURCC_Y212;
1473 i++;
1474 #endif
1475
1476 attribs[i].type = VASurfaceAttribPixelFormat;
1477 attribs[i].value.type = VAGenericValueTypeInteger;
1478 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1479 attribs[i].value.value.i = VA_FOURCC_Y216;
1480 i++;
1481
1482 attribs[i].type = VASurfaceAttribPixelFormat;
1483 attribs[i].value.type = VAGenericValueTypeInteger;
1484 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1485 attribs[i].value.value.i = VA_FOURCC_P012;
1486 i++;
1487 }
1488 else if(profile == VAProfileHEVCMain444 || profile == VAProfileVP9Profile1)
1489 {
1490 attribs[i].type = VASurfaceAttribPixelFormat;
1491 attribs[i].value.type = VAGenericValueTypeInteger;
1492 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1493 attribs[i].value.value.i = VA_FOURCC_AYUV;
1494 i++;
1495
1496 #if VA_CHECK_VERSION(1, 13, 0)
1497 attribs[i].type = VASurfaceAttribPixelFormat;
1498 attribs[i].value.type = VAGenericValueTypeInteger;
1499 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1500 attribs[i].value.value.i = VA_FOURCC_XYUV;
1501 i++;
1502 #endif
1503 }
1504 else if(profile == VAProfileHEVCMain444_10 || profile == VAProfileVP9Profile3)
1505 {
1506 attribs[i].type = VASurfaceAttribPixelFormat;
1507 attribs[i].value.type = VAGenericValueTypeInteger;
1508 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1509 attribs[i].value.value.i = VA_FOURCC_Y410;
1510 i++;
1511
1512 if(profile == VAProfileVP9Profile3)
1513 {
1514 #if VA_CHECK_VERSION(1, 9, 0)
1515 attribs[i].type = VASurfaceAttribPixelFormat;
1516 attribs[i].value.type = VAGenericValueTypeInteger;
1517 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1518 attribs[i].value.value.i = VA_FOURCC_Y412;
1519 i++;
1520 #endif
1521
1522 attribs[i].type = VASurfaceAttribPixelFormat;
1523 attribs[i].value.type = VAGenericValueTypeInteger;
1524 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1525 attribs[i].value.value.i = VA_FOURCC_Y416;
1526 i++;
1527 }
1528 }
1529 else if(profile == VAProfileHEVCMain444_12)
1530 {
1531 #if VA_CHECK_VERSION(1, 9, 0)
1532 attribs[i].type = VASurfaceAttribPixelFormat;
1533 attribs[i].value.type = VAGenericValueTypeInteger;
1534 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1535 attribs[i].value.value.i = VA_FOURCC_Y412;
1536 i++;
1537
1538 attribs[i].type = VASurfaceAttribPixelFormat;
1539 attribs[i].value.type = VAGenericValueTypeInteger;
1540 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1541 attribs[i].value.value.i = VA_FOURCC_Y212;
1542 i++;
1543 #endif
1544
1545 attribs[i].type = VASurfaceAttribPixelFormat;
1546 attribs[i].value.type = VAGenericValueTypeInteger;
1547 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1548 attribs[i].value.value.i = VA_FOURCC_Y416;
1549 i++;
1550
1551 attribs[i].type = VASurfaceAttribPixelFormat;
1552 attribs[i].value.type = VAGenericValueTypeInteger;
1553 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1554 attribs[i].value.value.i = VA_FOURCC_P012;
1555 i++;
1556 }
1557 else if(profile == VAProfileHEVCSccMain10)
1558 {
1559 attribs[i].type = VASurfaceAttribPixelFormat;
1560 attribs[i].value.type = VAGenericValueTypeInteger;
1561 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1562 attribs[i].value.value.i = VA_FOURCC_P010;
1563 i++;
1564 }
1565 else if(profile == VAProfileHEVCSccMain444)
1566 {
1567 //422/444 8/10bit included
1568 attribs[i].type = VASurfaceAttribPixelFormat;
1569 attribs[i].value.type = VAGenericValueTypeInteger;
1570 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1571 attribs[i].value.value.i = VA_FOURCC_YUY2;
1572 i++;
1573
1574 attribs[i].type = VASurfaceAttribPixelFormat;
1575 attribs[i].value.type = VAGenericValueTypeInteger;
1576 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1577 attribs[i].value.value.i = VA_FOURCC_Y210;
1578 i++;
1579
1580 attribs[i].type = VASurfaceAttribPixelFormat;
1581 attribs[i].value.type = VAGenericValueTypeInteger;
1582 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1583 attribs[i].value.value.i = VA_FOURCC_AYUV;
1584 i++;
1585
1586 #if VA_CHECK_VERSION(1, 13, 0)
1587 attribs[i].type = VASurfaceAttribPixelFormat;
1588 attribs[i].value.type = VAGenericValueTypeInteger;
1589 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1590 attribs[i].value.value.i = VA_FOURCC_XYUV;
1591 i++;
1592 #endif
1593
1594 attribs[i].type = VASurfaceAttribPixelFormat;
1595 attribs[i].value.type = VAGenericValueTypeInteger;
1596 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1597 attribs[i].value.value.i = VA_FOURCC_Y410;
1598 i++;
1599
1600 attribs[i].type = VASurfaceAttribPixelFormat;
1601 attribs[i].value.type = VAGenericValueTypeInteger;
1602 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1603 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1604 i++;
1605 } else if (profile == VAProfileHEVCSccMain444_10)
1606 {
1607 attribs[i].type = VASurfaceAttribPixelFormat;
1608 attribs[i].value.type = VAGenericValueTypeInteger;
1609 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1610 attribs[i].value.value.i = VA_FOURCC_AYUV;
1611 i++;
1612
1613 #if VA_CHECK_VERSION(1, 13, 0)
1614 attribs[i].type = VASurfaceAttribPixelFormat;
1615 attribs[i].value.type = VAGenericValueTypeInteger;
1616 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1617 attribs[i].value.value.i = VA_FOURCC_XYUV;
1618 i++;
1619 #endif
1620
1621 attribs[i].type = VASurfaceAttribPixelFormat;
1622 attribs[i].value.type = VAGenericValueTypeInteger;
1623 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1624 attribs[i].value.value.i = VA_FOURCC_Y410;
1625 i++;
1626 }
1627 else if (profile == VAProfileJPEGBaseline)
1628 {
1629 for (int32_t j = 0; j < m_numJpegSurfaceAttr; j++)
1630 {
1631 attribs[i].type = VASurfaceAttribPixelFormat;
1632 attribs[i].value.type = VAGenericValueTypeInteger;
1633 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1634 attribs[i].value.value.i = m_jpegSurfaceAttr[j];
1635 i++;
1636 }
1637 }
1638 else
1639 {
1640 attribs[i].type = VASurfaceAttribPixelFormat;
1641 attribs[i].value.type = VAGenericValueTypeInteger;
1642 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1643 attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
1644 i++;
1645 }
1646
1647 auto maxWidth = m_decDefaultMaxWidth;
1648 auto maxHeight = m_decDefaultMaxHeight;
1649 if(IsMpeg2Profile(profile))
1650 {
1651 maxWidth = m_decMpeg2MaxWidth;
1652 maxHeight = m_decMpeg2MaxHeight;
1653 }
1654 else if(IsAvcProfile(profile))
1655 {
1656 maxWidth = m_decAvcMaxWidth;
1657 maxHeight = m_decAvcMaxWidth;
1658 }
1659 else if(IsHevcProfile(profile))
1660 {
1661 maxWidth = m_decHevcMax16kWidth;
1662 maxHeight = m_decHevcMax16kWidth;
1663 }
1664 else if(IsVc1Profile(profile))
1665 {
1666 maxWidth = m_decVc1MaxWidth;
1667 maxHeight = m_decVc1MaxHeight;
1668 }
1669 else if(IsJpegProfile(profile))
1670 {
1671 maxWidth = m_decJpegMaxWidth;
1672 maxHeight = m_decJpegMaxHeight;
1673 }
1674 else if(IsVp9Profile(profile))
1675 {
1676 maxWidth = m_decVp9Max16kWidth;
1677 maxHeight = m_decVp9Max16kHeight;
1678 }
1679 else if(IsAV1Profile(profile))
1680 {
1681 maxWidth = m_decAv1Max16kWidth;
1682 maxHeight = m_decAv1Max16kHeight;
1683 }
1684
1685 attribs[i].type = VASurfaceAttribMaxWidth;
1686 attribs[i].value.type = VAGenericValueTypeInteger;
1687 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1688 attribs[i].value.value.i = maxWidth;
1689 i++;
1690
1691 attribs[i].type = VASurfaceAttribMaxHeight;
1692 attribs[i].value.type = VAGenericValueTypeInteger;
1693 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
1694 attribs[i].value.value.i = maxHeight;
1695 i++;
1696
1697 attribs[i].type = VASurfaceAttribMemoryType;
1698 attribs[i].value.type = VAGenericValueTypeInteger;
1699 attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
1700 attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
1701 #if VA_CHECK_VERSION(1, 21, 0)
1702 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 |
1703 #endif
1704 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
1705 i++;
1706 }
1707 else if(entrypoint == VAEntrypointEncSlice || entrypoint == VAEntrypointEncSliceLP || entrypoint == VAEntrypointEncPicture || entrypoint == VAEntrypointFEI)
1708 {
1709 AddEncSurfaceAttributes(profile, entrypoint, attribs, i);
1710 }
1711 else
1712 {
1713 MOS_FreeMemory(attribs);
1714 return VA_STATUS_ERROR_UNIMPLEMENTED;
1715 }
1716
1717 if (i > *numAttribs)
1718 {
1719 *numAttribs = i;
1720 MOS_FreeMemory(attribs);
1721 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
1722 }
1723
1724 *numAttribs = i;
1725 MOS_SecureMemcpy(attribList, i * sizeof(*attribs), attribs, i * sizeof(*attribs));
1726
1727 MOS_FreeMemory(attribs);
1728 return status;
1729 }
1730
CreateEncAttributes(VAProfile profile,VAEntrypoint entrypoint,AttribMap ** attributeList)1731 VAStatus MediaLibvaCapsG12::CreateEncAttributes(
1732 VAProfile profile,
1733 VAEntrypoint entrypoint,
1734 AttribMap **attributeList)
1735 {
1736 if(IsVp8Profile(profile))
1737 {
1738 return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
1739 }
1740
1741 DDI_CHK_NULL(attributeList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
1742
1743 VAStatus status = CreateAttributeList(attributeList);
1744 DDI_CHK_RET(status, "Failed to initialize Caps!");
1745
1746 auto attribList = *attributeList;
1747 DDI_CHK_NULL(attribList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
1748
1749 VAConfigAttrib attrib;
1750 attrib.type = VAConfigAttribRTFormat;
1751 status = CheckEncRTFormat(profile, entrypoint, &attrib);
1752 DDI_CHK_RET(status, "Failed to Check Encode RT Format!");
1753 (*attribList)[attrib.type] = attrib.value;
1754
1755 attrib.type = VAConfigAttribMaxPictureWidth;
1756 GetPlatformSpecificAttrib(profile, entrypoint,
1757 VAConfigAttribMaxPictureWidth, &attrib.value);
1758 (*attribList)[attrib.type] = attrib.value;
1759
1760 attrib.type = VAConfigAttribMaxPictureHeight;
1761 GetPlatformSpecificAttrib(profile, entrypoint,
1762 VAConfigAttribMaxPictureHeight, &attrib.value);
1763 (*attribList)[attrib.type] = attrib.value;
1764
1765 if (profile == VAProfileJPEGBaseline)
1766 {
1767 attrib.type = VAConfigAttribEncJPEG;
1768 attrib.value =
1769 ((JPEG_MAX_QUANT_TABLE << 14) | // max_num_quantization_tables : 3
1770 (JPEG_MAX_NUM_HUFF_TABLE_INDEX << 11) | // max_num_huffman_tables : 3
1771 (1 << 7) | // max_num_scans : 4
1772 (jpegNumComponent << 4)); // max_num_components : 3
1773 // arithmatic_coding_mode = 0
1774 // progressive_dct_mode = 0
1775 // non_interleaved_mode = 0
1776 // differential_mode = 0
1777 (*attribList)[attrib.type] = attrib.value;
1778 }
1779
1780 attrib.type = VAConfigAttribEncQualityRange;
1781 if (profile == VAProfileJPEGBaseline)
1782 {
1783 // JPEG has no target usage.
1784 attrib.value = 1;
1785 }
1786 else
1787 {
1788 attrib.value = NUM_TARGET_USAGE_MODES - 1;// Indicates TUs from 1 upto the value reported are supported
1789 }
1790 (*attribList)[attrib.type] = attrib.value;
1791
1792 attrib.type = VAConfigAttribEncPackedHeaders;
1793 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
1794 if ((IsAvcProfile(profile))||(IsHevcProfile(profile)))
1795 {
1796 attrib.value = VA_ENC_PACKED_HEADER_PICTURE |
1797 VA_ENC_PACKED_HEADER_SEQUENCE |
1798 VA_ENC_PACKED_HEADER_SLICE |
1799 VA_ENC_PACKED_HEADER_RAW_DATA |
1800 VA_ENC_PACKED_HEADER_MISC;
1801 }
1802 else if (IsMpeg2Profile(profile))
1803 {
1804 attrib.value = VA_ENC_PACKED_HEADER_RAW_DATA;
1805 }
1806 else if(IsJpegProfile(profile))
1807 {
1808 attrib.value = VA_ENC_PACKED_HEADER_RAW_DATA;
1809 }
1810 else if(IsVp9Profile(profile))
1811 {
1812 attrib.value = VA_ENC_PACKED_HEADER_RAW_DATA;
1813 }
1814
1815 (*attribList)[attrib.type] = attrib.value;
1816 if(IsJpegProfile(profile))
1817 {
1818 return status;
1819 }
1820
1821 attrib.type = VAConfigAttribRateControl;
1822 attrib.value = VA_RC_CQP;
1823 if (entrypoint != VAEntrypointEncSliceLP ||
1824 (entrypoint == VAEntrypointEncSliceLP &&
1825 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels) &&
1826 !IsHevcSccProfile(profile))) // Currently, SCC doesn't support BRC
1827 {
1828 attrib.value |= VA_RC_CBR | VA_RC_VBR | VA_RC_MB;
1829 if (IsHevcProfile(profile))
1830 {
1831 if (entrypoint != VAEntrypointEncSliceLP)
1832 {
1833 attrib.value |= VA_RC_ICQ;
1834 }
1835 #if VA_CHECK_VERSION(1, 10, 0)
1836 else
1837 {
1838 attrib.value |= VA_RC_TCBRC;
1839 }
1840 #endif
1841 attrib.value |= VA_RC_VCM | VA_RC_QVBR;
1842 }
1843 if (IsVp9Profile(profile))
1844 {
1845 attrib.value |= VA_RC_ICQ;
1846 }
1847 }
1848 if (IsAvcProfile(profile) && (entrypoint != VAEntrypointEncSliceLP))
1849 {
1850 attrib.value |= VA_RC_ICQ | VA_RC_VCM | VA_RC_QVBR | VA_RC_AVBR;
1851 }
1852 if (IsAvcProfile(profile) &&
1853 ((entrypoint == VAEntrypointEncSliceLP) && MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels)))
1854 {
1855 attrib.value |= VA_RC_QVBR;
1856 #if VA_CHECK_VERSION(1, 10, 0)
1857 attrib.value |= VA_RC_TCBRC;
1858 #endif
1859 }
1860 if(entrypoint == VAEntrypointFEI)
1861 {
1862 attrib.value = VA_RC_CQP;
1863 }
1864 else if(entrypoint == VAEntrypointStats)
1865 {
1866 attrib.value = VA_RC_NONE;
1867 }
1868 (*attribList)[attrib.type] = attrib.value;
1869
1870 attrib.type = VAConfigAttribEncInterlaced;
1871 attrib.value = VA_ENC_INTERLACED_NONE;
1872 #ifndef ANDROID
1873 if(IsAvcProfile(profile) && (entrypoint != VAEntrypointEncSliceLP))
1874 {
1875 attrib.value = VA_ENC_INTERLACED_FIELD;
1876 }
1877 if(IsMpeg2Profile(profile))
1878 {
1879 attrib.value = VA_ENC_INTERLACED_FRAME;
1880 }
1881 #endif
1882 (*attribList)[attrib.type] = attrib.value;
1883
1884 attrib.type = VAConfigAttribEncMaxRefFrames;
1885 if (entrypoint == VAEntrypointEncSliceLP)
1886 {
1887 attrib.value = DDI_CODEC_VDENC_MAX_L0_REF_FRAMES | (DDI_CODEC_VDENC_MAX_L1_REF_FRAMES << DDI_CODEC_LEFT_SHIFT_FOR_REFLIST1);
1888 if (IsHevcProfile(profile))
1889 {
1890 attrib.value = DDI_CODEC_VDENC_MAX_L0_REF_FRAMES_LDB | (DDI_CODEC_VDENC_MAX_L1_REF_FRAMES_LDB << DDI_CODEC_LEFT_SHIFT_FOR_REFLIST1);
1891 }
1892 }
1893 else
1894 {
1895 // default value: 1 frame for each reference list
1896 attrib.value = 1 | (1 << 16);
1897 if(IsAvcProfile(profile))
1898 {
1899 attrib.value = CODECHAL_ENCODE_NUM_MAX_VME_L0_REF | (CODECHAL_ENCODE_NUM_MAX_VME_L1_REF << 16);
1900 }
1901 if(IsVp8Profile(profile))
1902 {
1903 attrib.value = ENCODE_VP8_NUM_MAX_L0_REF ;
1904 }
1905 if(IsVp9Profile(profile))
1906 {
1907 attrib.value = ENCODE_VP9_NUM_MAX_L0_REF;
1908 }
1909 if (IsHevcProfile(profile))
1910 {
1911 GetPlatformSpecificAttrib(profile, entrypoint,
1912 VAConfigAttribEncMaxRefFrames, &attrib.value);
1913 }
1914 }
1915 (*attribList)[attrib.type] = attrib.value;
1916
1917 attrib.type = VAConfigAttribEncMaxSlices;
1918 if (entrypoint == VAEntrypointEncSliceLP)
1919 {
1920 if (IsAvcProfile(profile))
1921 {
1922 attrib.value = ENCODE_AVC_MAX_SLICES_SUPPORTED;
1923 }
1924 else if (IsHevcProfile(profile))
1925 {
1926 attrib.value = ENCODE_HEVC_VDENC_NUM_MAX_SLICES;
1927 }
1928 }
1929 else
1930 {
1931 attrib.value = 0;
1932 if (IsAvcProfile(profile))
1933 {
1934 attrib.value = ENCODE_AVC_MAX_SLICES_SUPPORTED;
1935 }
1936 else if (IsHevcProfile(profile))
1937 {
1938 GetPlatformSpecificAttrib(profile, entrypoint,
1939 VAConfigAttribEncMaxSlices, &attrib.value);
1940 }
1941 }
1942 (*attribList)[attrib.type] = attrib.value;
1943
1944 attrib.type = VAConfigAttribEncSliceStructure;
1945 if (entrypoint == VAEntrypointEncSliceLP)
1946 {
1947 if (IsHevcProfile(profile))
1948 {
1949 attrib.value = VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS | VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS |
1950 VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE | VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS | VA_ENC_SLICE_STRUCTURE_EQUAL_MULTI_ROWS;
1951 }
1952 else
1953 {
1954 attrib.value = VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS | VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE |
1955 VA_ENC_SLICE_STRUCTURE_EQUAL_MULTI_ROWS | VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS;
1956 }
1957 }
1958 else
1959 {
1960 attrib.value = VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS;
1961 }
1962 (*attribList)[attrib.type] = attrib.value;
1963
1964 attrib.type = VAConfigAttribEncQuantization;
1965 if(IsAvcProfile(profile))
1966 {
1967 attrib.value = VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED;
1968 }
1969 else
1970 {
1971 attrib.value = VA_ENC_QUANTIZATION_NONE;
1972 }
1973 (*attribList)[attrib.type] = attrib.value;
1974
1975 attrib.type = VAConfigAttribEncIntraRefresh;
1976 attrib.value = VA_ENC_INTRA_REFRESH_NONE;
1977 GetPlatformSpecificAttrib(profile, entrypoint,
1978 VAConfigAttribEncIntraRefresh, &attrib.value);
1979 (*attribList)[attrib.type] = attrib.value;
1980
1981 attrib.type = VAConfigAttribEncSkipFrame;
1982 if (entrypoint == VAEntrypointEncSliceLP)
1983 {
1984 if (IsAvcProfile(profile))
1985 {
1986 attrib.value = 1;
1987 }
1988 else
1989 {
1990 attrib.value = 0;
1991 }
1992 }
1993 else
1994 {
1995 attrib.value = 1;
1996 }
1997 (*attribList)[attrib.type] = attrib.value;
1998
1999 attrib.type = VAConfigAttribEncryption;
2000 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
2001 if (m_isEntryptSupported)
2002 {
2003 attrib.value = 0;
2004 uint32_t encryptTypes[DDI_CP_ENCRYPT_TYPES_NUM] = {0};
2005 int32_t numTypes = m_CapsCp->GetEncryptionTypes(profile,
2006 encryptTypes, DDI_CP_ENCRYPT_TYPES_NUM);
2007 if (numTypes > 0)
2008 {
2009 for (int32_t j = 0; j < numTypes; j++)
2010 {
2011 attrib.value |= encryptTypes[j];
2012 }
2013 }
2014 }
2015 (*attribList)[attrib.type] = attrib.value;
2016
2017 attrib.type = VAConfigAttribEncROI;
2018 if (entrypoint == VAEntrypointEncSliceLP)
2019 {
2020 VAConfigAttribValEncROI roi_attrib = {0};
2021 if (IsAvcProfile(profile))
2022 {
2023 roi_attrib.bits.num_roi_regions = ENCODE_VDENC_AVC_MAX_ROI_NUMBER_ADV;
2024 }
2025 else if (IsHevcProfile(profile))
2026 {
2027 roi_attrib.bits.num_roi_regions = CODECHAL_ENCODE_HEVC_MAX_NUM_ROI;
2028 }
2029
2030 roi_attrib.bits.roi_rc_priority_support = 0;
2031 roi_attrib.bits.roi_rc_qp_delta_support = 1;
2032
2033 attrib.value = roi_attrib.value;
2034 }
2035 else
2036 {
2037 GetPlatformSpecificAttrib(profile, entrypoint,
2038 VAConfigAttribEncROI, &attrib.value);
2039 }
2040 (*attribList)[attrib.type] = attrib.value;
2041
2042 attrib.type = VAConfigAttribProcessingRate;
2043 attrib.value = VA_PROCESSING_RATE_ENCODE;
2044 (*attribList)[attrib.type] = attrib.value;
2045
2046 attrib.type = (VAConfigAttribType)VAConfigAttribEncDirtyRect;
2047 if((entrypoint == VAEntrypointEncSliceLP) && IsHevcProfile(profile))
2048 {
2049 attrib.value = CODECHAL_ENCODE_HEVC_MAX_NUM_DIRTYRECT;
2050 }
2051 else
2052 {
2053 attrib.value = 4;
2054 }
2055
2056 (*attribList)[attrib.type] = attrib.value;
2057
2058 attrib.type = VAConfigAttribEncParallelRateControl;
2059 if(entrypoint == VAEntrypointEncSliceLP)
2060 {
2061 attrib.value = 0;
2062 }
2063 else
2064 {
2065 attrib.value = 1;
2066 }
2067 (*attribList)[attrib.type] = attrib.value;
2068
2069 if ((entrypoint == VAEntrypointFEI) && (IsAvcProfile(profile) || IsHevcProfile(profile)))
2070 {
2071 attrib.type = (VAConfigAttribType)VAConfigAttribFEIFunctionType;
2072 attrib.value = IsAvcProfile(profile) ?
2073 (VA_FEI_FUNCTION_ENC | VA_FEI_FUNCTION_PAK | VA_FEI_FUNCTION_ENC_PAK) :
2074 VA_FEI_FUNCTION_ENC_PAK;
2075 (*attribList)[attrib.type] = attrib.value;
2076 }
2077
2078 attrib.type = (VAConfigAttribType)VAConfigAttribFEIMVPredictors;
2079 attrib.value = 0;
2080 if(IsAvcProfile(profile) || IsHevcProfile(profile))
2081 {
2082 attrib.value = DDI_CODEC_FEI_MAX_NUM_MVPREDICTOR;
2083 }
2084 (*attribList)[attrib.type] = attrib.value;
2085
2086 if(profile == VAProfileNone)
2087 {
2088 attrib.type = (VAConfigAttribType)VAConfigAttribStats;
2089 VAConfigAttribValStats attribValStats;
2090 memset(&attribValStats, 0, sizeof(attribValStats));
2091 attribValStats.bits.max_num_past_references = DDI_CODEC_STATS_MAX_NUM_PAST_REFS;
2092 attribValStats.bits.max_num_future_references = DDI_CODEC_STATS_MAX_NUM_FUTURE_REFS;
2093 attribValStats.bits.num_outputs = DDI_CODEC_STATS_MAX_NUM_OUTPUTS;
2094 attribValStats.bits.interlaced = DDI_CODEC_STATS_INTERLACED_SUPPORT;
2095 attrib.value = attribValStats.value;
2096 (*attribList)[attrib.type] = attrib.value;
2097 }
2098
2099 attrib.type = (VAConfigAttribType)VAConfigAttribCustomRoundingControl;
2100 GetPlatformSpecificAttrib(profile, entrypoint,
2101 (VAConfigAttribType)VAConfigAttribCustomRoundingControl, &attrib.value);
2102 (*attribList)[attrib.type] = attrib.value;
2103
2104 if (IsAvcProfile(profile) || IsHevcProfile(profile) )
2105 {
2106 attrib.type = (VAConfigAttribType)VAConfigAttribMaxFrameSize;
2107 VAConfigAttribValMaxFrameSize attribValMaxFrameSize;
2108 memset(&attribValMaxFrameSize, 0, sizeof(attribValMaxFrameSize));
2109 attribValMaxFrameSize.bits.max_frame_size = 1;
2110 attribValMaxFrameSize.bits.multiple_pass = 1;
2111 attribValMaxFrameSize.bits.reserved = 0;
2112 attrib.value = attribValMaxFrameSize.value;
2113 (*attribList)[attrib.type] = attrib.value;
2114 }
2115
2116 if (IsHevcProfile(profile))
2117 {
2118 attrib.type = (VAConfigAttribType) VAConfigAttribPredictionDirection;
2119 GetPlatformSpecificAttrib(profile, entrypoint,
2120 (VAConfigAttribType)VAConfigAttribPredictionDirection, &attrib.value);
2121 (*attribList)[attrib.type] = attrib.value;
2122 #if VA_CHECK_VERSION(1, 12, 0)
2123 attrib.type = (VAConfigAttribType)VAConfigAttribEncHEVCFeatures;
2124 GetPlatformSpecificAttrib(profile, entrypoint,
2125 (VAConfigAttribType)VAConfigAttribEncHEVCFeatures, &attrib.value);
2126 (*attribList)[attrib.type] = attrib.value;
2127 attrib.type = (VAConfigAttribType)VAConfigAttribEncHEVCBlockSizes;
2128 GetPlatformSpecificAttrib(profile, entrypoint,
2129 (VAConfigAttribType)VAConfigAttribEncHEVCBlockSizes, &attrib.value);
2130 (*attribList)[attrib.type] = attrib.value;
2131 #endif
2132 }
2133
2134 return status;
2135 }
2136
CreateDecAttributes(VAProfile profile,VAEntrypoint entrypoint,AttribMap ** attributeList)2137 VAStatus MediaLibvaCapsG12::CreateDecAttributes(
2138 VAProfile profile,
2139 VAEntrypoint entrypoint,
2140 AttribMap **attributeList)
2141 {
2142 DDI_CHK_NULL(attributeList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
2143
2144 VAStatus status = CreateAttributeList(attributeList);
2145 DDI_CHK_RET(status, "Failed to initialize Caps!");
2146
2147 auto attribList = *attributeList;
2148 DDI_CHK_NULL(attribList, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
2149
2150 VAConfigAttrib attrib;
2151 attrib.type = VAConfigAttribRTFormat;
2152 if ( profile == VAProfileJPEGBaseline )
2153 {
2154 // at present, latest libva have not support RGB24.
2155 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422 | VA_RT_FORMAT_YUV444 | VA_RT_FORMAT_YUV400 | VA_RT_FORMAT_YUV411 | VA_RT_FORMAT_RGB16 | VA_RT_FORMAT_RGB32;
2156 }
2157 else if(profile == VAProfileHEVCMain)
2158 {
2159 attrib.value = VA_RT_FORMAT_YUV420;
2160 }
2161 else if(profile == VAProfileHEVCMain10)
2162 {
2163 attrib.value = VA_RT_FORMAT_YUV420
2164 | VA_RT_FORMAT_YUV420_10BPP;
2165 }
2166 else if(profile == VAProfileHEVCMain12)
2167 {
2168 attrib.value = VA_RT_FORMAT_YUV420
2169 | VA_RT_FORMAT_YUV420_10BPP
2170 | VA_RT_FORMAT_YUV420_12
2171 | VA_RT_FORMAT_YUV400;
2172 }
2173 else if(profile == VAProfileHEVCMain422_10)
2174 {
2175 attrib.value = VA_RT_FORMAT_YUV420
2176 | VA_RT_FORMAT_YUV420_10BPP
2177 | VA_RT_FORMAT_YUV422
2178 | VA_RT_FORMAT_YUV422_10
2179 | VA_RT_FORMAT_YUV400;
2180 }
2181 else if(profile == VAProfileHEVCMain422_12)
2182 {
2183 attrib.value = VA_RT_FORMAT_YUV420
2184 | VA_RT_FORMAT_YUV420_10BPP
2185 | VA_RT_FORMAT_YUV420_12
2186 | VA_RT_FORMAT_YUV422
2187 | VA_RT_FORMAT_YUV422_10
2188 | VA_RT_FORMAT_YUV422_12
2189 | VA_RT_FORMAT_YUV400;
2190 }
2191 else if(profile == VAProfileHEVCMain444 || profile == VAProfileHEVCSccMain444)
2192 {
2193 attrib.value = VA_RT_FORMAT_YUV420
2194 | VA_RT_FORMAT_YUV422
2195 | VA_RT_FORMAT_YUV444
2196 | VA_RT_FORMAT_YUV400;
2197 }
2198 else if(profile == VAProfileHEVCMain444_10 || profile == VAProfileHEVCSccMain444_10)
2199 {
2200 attrib.value = VA_RT_FORMAT_YUV420
2201 | VA_RT_FORMAT_YUV420_10BPP
2202 | VA_RT_FORMAT_YUV422
2203 | VA_RT_FORMAT_YUV422_10
2204 | VA_RT_FORMAT_YUV444
2205 | VA_RT_FORMAT_YUV444_10
2206 | VA_RT_FORMAT_YUV400;
2207 }
2208 else if(profile == VAProfileHEVCMain444_12)
2209 {
2210 attrib.value = VA_RT_FORMAT_YUV420
2211 | VA_RT_FORMAT_YUV420_10BPP
2212 | VA_RT_FORMAT_YUV420_12
2213 | VA_RT_FORMAT_YUV422
2214 | VA_RT_FORMAT_YUV422_10
2215 | VA_RT_FORMAT_YUV422_12
2216 | VA_RT_FORMAT_YUV444
2217 | VA_RT_FORMAT_YUV444_10
2218 | VA_RT_FORMAT_YUV444_12
2219 | VA_RT_FORMAT_YUV400;
2220 }
2221 else if(profile == VAProfileHEVCSccMain)
2222 {
2223 attrib.value = VA_RT_FORMAT_YUV420
2224 | VA_RT_FORMAT_YUV400;
2225 }
2226 else if(profile == VAProfileHEVCSccMain10)
2227 {
2228 attrib.value = VA_RT_FORMAT_YUV420
2229 | VA_RT_FORMAT_YUV420_10BPP
2230 | VA_RT_FORMAT_YUV400;
2231 }
2232 else if (profile == VAProfileVP9Profile0)
2233 {
2234 attrib.value = VA_RT_FORMAT_YUV420;
2235 }
2236 else if (profile == VAProfileVP9Profile1)
2237 {
2238 attrib.value = VA_RT_FORMAT_YUV422
2239 | VA_RT_FORMAT_YUV444;
2240 }
2241 else if (profile == VAProfileVP9Profile2)
2242 {
2243 attrib.value = VA_RT_FORMAT_YUV420_10BPP
2244 | VA_RT_FORMAT_YUV420_12;
2245 }
2246 else if (profile == VAProfileVP9Profile3)
2247 {
2248 attrib.value = VA_RT_FORMAT_YUV422_10
2249 | VA_RT_FORMAT_YUV444_10
2250 | VA_RT_FORMAT_YUV422_12
2251 | VA_RT_FORMAT_YUV444_12;
2252 }
2253 else if (profile == VAProfileAV1Profile0)
2254 {
2255 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV420_10BPP;
2256 }
2257 else
2258 {
2259 attrib.value = VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422 | VA_RT_FORMAT_RGB32;
2260 }
2261
2262 (*attribList)[attrib.type] = attrib.value;
2263
2264 attrib.type = VAConfigAttribDecSliceMode;
2265 if (IsAvcProfile(profile))
2266 {
2267 attrib.value = VA_DEC_SLICE_MODE_NORMAL | VA_DEC_SLICE_MODE_BASE;
2268 }
2269 else if (IsHevcProfile(profile))
2270 {
2271 bool hevcmainProfileSupported = false;
2272 attrib.value = 0;
2273 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMainDecoding)
2274 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10Decoding)
2275 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit420Decoding)
2276 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD42210bitDecoding)
2277 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit422Decoding)
2278 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD4448bitDecoding)
2279 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD44410bitDecoding)
2280 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit444Decoding)
2281 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain8bit420SCC)
2282 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10bit420SCC)
2283 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain8bit444SCC)
2284 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10bit444SCC))
2285 {
2286 attrib.value |= VA_DEC_SLICE_MODE_NORMAL;
2287 hevcmainProfileSupported = true;
2288 }
2289 if ((MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrHEVCVLDMainShortDecoding) ||
2290 MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrHEVCVLDMain10ShortDecoding))
2291 && MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrEnableMediaKernels))
2292 {
2293 attrib.value |= VA_DEC_SLICE_MODE_BASE;
2294 hevcmainProfileSupported = true;
2295 }
2296 if (!hevcmainProfileSupported)
2297 {
2298 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
2299 }
2300 }
2301 else if (profile == VAProfileVP9Profile0
2302 || profile == VAProfileVP9Profile2
2303 || profile == VAProfileVP9Profile1
2304 || profile == VAProfileVP9Profile3)
2305 {
2306 bool vp9ProfileSupported = false;
2307 attrib.value = 0;
2308 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelVP9VLDProfile0Decoding8bit420)
2309 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelVP9VLDProfile1Decoding8bit444))
2310 {
2311 attrib.value |= VA_DEC_SLICE_MODE_NORMAL | VA_DEC_SLICE_MODE_BASE;
2312 vp9ProfileSupported = true;
2313 }
2314 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrVP9VLD10bProfile2Decoding)
2315 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelVP9VLDProfile3Decoding10bit444))
2316 {
2317 attrib.value |= VA_DEC_SLICE_MODE_NORMAL;
2318 vp9ProfileSupported = true;
2319 }
2320 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelVP9VLDProfile2Decoding12bit420)
2321 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelVP9VLDProfile3Decoding12bit444))
2322 {
2323 attrib.value |= VA_DEC_SLICE_MODE_NORMAL;
2324 vp9ProfileSupported = true;
2325 }
2326
2327 if (!vp9ProfileSupported)
2328 {
2329 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
2330 }
2331 }
2332 else if (profile == VAProfileAV1Profile0)
2333 {
2334 attrib.value = 0;
2335 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelAV1VLDDecoding8bit420)
2336 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelAV1VLDDecoding10bit420))
2337 {
2338 attrib.value |= VA_DEC_SLICE_MODE_NORMAL | VA_DEC_SLICE_MODE_BASE;
2339 }
2340 else
2341 {
2342 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
2343 }
2344 }
2345 else
2346 {
2347 attrib.value = VA_DEC_SLICE_MODE_NORMAL;
2348 }
2349 (*attribList)[attrib.type] = attrib.value;
2350
2351 attrib.type = VAConfigAttribDecProcessing;
2352 attrib.value = VA_DEC_PROCESSING_NONE;
2353 GetPlatformSpecificAttrib(profile, entrypoint,
2354 VAConfigAttribDecProcessing, &attrib.value);
2355 (*attribList)[attrib.type] = attrib.value;
2356
2357 attrib.type = VAConfigAttribMaxPictureWidth;
2358 attrib.value = CODEC_MAX_PIC_WIDTH;
2359 if(profile == VAProfileJPEGBaseline)
2360 {
2361 attrib.value = ENCODE_JPEG_MAX_PIC_WIDTH;
2362 }
2363 if(IsVc1Profile(profile) || IsMpeg2Profile(profile))
2364 {
2365 attrib.value = CODEC_2K_MAX_PIC_WIDTH;
2366 }
2367 if(IsVp8Profile(profile))
2368 {
2369 attrib.value = CODEC_4K_MAX_PIC_WIDTH;
2370 }
2371 if(IsAvcProfile(profile))
2372 {
2373 attrib.value = CODEC_8K_MAX_PIC_WIDTH;
2374 }
2375 if(IsHevcProfile(profile) || IsVp9Profile(profile) || IsAV1Profile(profile))
2376 {
2377 attrib.value = CODEC_16K_MAX_PIC_WIDTH;
2378 }
2379 (*attribList)[attrib.type] = attrib.value;
2380
2381 attrib.type = VAConfigAttribMaxPictureHeight;
2382 attrib.value = CODEC_MAX_PIC_HEIGHT;
2383 if(profile == VAProfileJPEGBaseline)
2384 {
2385 attrib.value = ENCODE_JPEG_MAX_PIC_HEIGHT;
2386 }
2387 if(IsVc1Profile(profile) || IsMpeg2Profile(profile))
2388 {
2389 attrib.value = CODEC_2K_MAX_PIC_HEIGHT;
2390 }
2391 if(IsVp8Profile(profile))
2392 {
2393 attrib.value = CODEC_4K_MAX_PIC_HEIGHT;
2394 }
2395 if(IsAvcProfile(profile))
2396 {
2397 attrib.value = CODEC_8K_MAX_PIC_HEIGHT;
2398 }
2399 if(IsHevcProfile(profile) || IsVp9Profile(profile) || IsAV1Profile(profile))
2400 {
2401 attrib.value = CODEC_16K_MAX_PIC_HEIGHT;
2402 }
2403 (*attribList)[attrib.type] = attrib.value;
2404
2405 attrib.type = VAConfigAttribEncryption;
2406
2407 attrib.value = VA_ATTRIB_NOT_SUPPORTED;
2408 if (m_isEntryptSupported)
2409 {
2410 uint32_t encryptTypes[DDI_CP_ENCRYPT_TYPES_NUM] = {0};
2411 int32_t numTypes = m_CapsCp->GetEncryptionTypes(profile,
2412 encryptTypes, DDI_CP_ENCRYPT_TYPES_NUM);
2413 if (numTypes > 0)
2414 {
2415 attrib.value = 0;
2416 for (int32_t j = 0; j < numTypes; j++)
2417 {
2418 attrib.value |= encryptTypes[j];
2419 }
2420 }
2421 }
2422 (*attribList)[attrib.type] = attrib.value;
2423
2424 if(profile == VAProfileJPEGBaseline)
2425 {
2426 attrib.type = VAConfigAttribDecJPEG;
2427 attrib.value = ((1 << VA_ROTATION_NONE) | (1 << VA_ROTATION_90) | (1 << VA_ROTATION_180) | (1 << VA_ROTATION_270));
2428 (*attribList)[attrib.type] = attrib.value;
2429 }
2430
2431 if(profile == VAProfileNone)
2432 {
2433 attrib.type = (VAConfigAttribType)VAConfigAttribStats;
2434 VAConfigAttribValStats attribValStats;
2435 memset(&attribValStats, 0, sizeof(attribValStats));
2436 attribValStats.bits.max_num_past_references = DDI_CODEC_STATS_MAX_NUM_PAST_REFS;
2437 attribValStats.bits.max_num_future_references = DDI_CODEC_STATS_MAX_NUM_FUTURE_REFS;
2438 attribValStats.bits.num_outputs = DDI_CODEC_STATS_MAX_NUM_OUTPUTS;
2439 attribValStats.bits.interlaced = DDI_CODEC_STATS_INTERLACED_SUPPORT;
2440 attrib.value = attribValStats.value;
2441 (*attribList)[attrib.type] = attrib.value;
2442 }
2443
2444 attrib.type = VAConfigAttribProcessingRate;
2445 attrib.value = VA_PROCESSING_RATE_DECODE;
2446 (*attribList)[attrib.type] = attrib.value;
2447
2448 attrib.type = (VAConfigAttribType)VAConfigAttribCustomRoundingControl;
2449 GetPlatformSpecificAttrib(profile, entrypoint,
2450 (VAConfigAttribType)VAConfigAttribCustomRoundingControl, &attrib.value);
2451 (*attribList)[attrib.type] = attrib.value;
2452
2453 #if VA_CHECK_VERSION(1, 11, 0)
2454 if(IsAV1Profile(profile) && MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrAV1VLDLSTDecoding))
2455 {
2456 attrib.type = VAConfigAttribDecAV1Features;
2457 VAConfigAttribValDecAV1Features feature = {0};
2458 feature.bits.lst_support = true;
2459 attrib.value = feature.value;
2460 (*attribList)[attrib.type] = attrib.value;
2461 }
2462 #endif
2463 return status;
2464 }
2465
LoadJpegDecProfileEntrypoints()2466 VAStatus MediaLibvaCapsG12::LoadJpegDecProfileEntrypoints()
2467 {
2468 VAStatus status = VA_STATUS_SUCCESS;
2469
2470 #ifdef _JPEG_DECODE_SUPPORTED
2471 AttribMap *attributeList = nullptr;
2472 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelJPEGDecoding))
2473 {
2474 status = CreateDecAttributes(VAProfileJPEGBaseline, VAEntrypointVLD, &attributeList);
2475 DDI_CHK_RET(status, "Failed to initialize Caps!");
2476
2477 uint32_t configStartIdx = m_decConfigs.size();
2478 for(int32_t i = 0; i < 2; i++)
2479 {
2480 AddDecConfig(VA_DEC_SLICE_MODE_NORMAL, VA_ENCRYPTION_TYPE_NONE, m_decProcessMode[i]);
2481 }
2482 AddProfileEntry(VAProfileJPEGBaseline, VAEntrypointVLD, attributeList, configStartIdx, 2);
2483 }
2484 #endif
2485
2486 return status;
2487 }
2488
LoadAv1DecProfileEntrypoints()2489 VAStatus MediaLibvaCapsG12::LoadAv1DecProfileEntrypoints()
2490 {
2491 VAStatus status = VA_STATUS_SUCCESS;
2492
2493 #if _AV1_DECODE_SUPPORTED
2494 AttribMap *attributeList = nullptr;
2495 if ((MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelAV1VLDDecoding8bit420)
2496 ||MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelAV1VLDDecoding10bit420)))
2497 {
2498 status = CreateDecAttributes((VAProfile) VAProfileAV1Profile0, VAEntrypointVLD, &attributeList);
2499 DDI_CHK_RET(status, "Failed to initialize Caps!");
2500
2501 uint32_t configStartIdx = m_decConfigs.size();
2502 for (int32_t i = 0; i < 2; i++)
2503 {
2504 AddDecConfig(m_decSliceMode[i], VA_CENC_TYPE_NONE, VA_DEC_PROCESSING_NONE);
2505 if (m_isEntryptSupported)
2506 {
2507 uint32_t encrytTypes[DDI_CP_ENCRYPT_TYPES_NUM];
2508
2509 int32_t numTypes = m_CapsCp->GetEncryptionTypes((VAProfile) VAProfileAV1Profile0,
2510 encrytTypes, DDI_CP_ENCRYPT_TYPES_NUM);
2511
2512 if (numTypes > 0)
2513 {
2514 for (int32_t l = 0; l < numTypes; l++)
2515 {
2516 AddDecConfig(m_decSliceMode[i], encrytTypes[l],
2517 VA_DEC_PROCESSING_NONE);
2518 }
2519 }
2520 }
2521 }
2522
2523 AddProfileEntry((VAProfile) VAProfileAV1Profile0, VAEntrypointVLD, attributeList,
2524 configStartIdx, m_decConfigs.size() - configStartIdx);
2525 }
2526
2527 #endif
2528 return status;
2529 }
2530
LoadHevcDecProfileEntrypoints()2531 VAStatus MediaLibvaCapsG12::LoadHevcDecProfileEntrypoints()
2532 {
2533 VAStatus status = VA_STATUS_SUCCESS;
2534
2535 #ifdef _HEVC_DECODE_SUPPORTED
2536 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMainDecoding)
2537 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrHEVCVLDMainShortDecoding))
2538 {
2539 LoadDecProfileEntrypoints(VAProfileHEVCMain);
2540 }
2541
2542 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10Decoding)
2543 || MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrHEVCVLDMain10ShortDecoding))
2544 {
2545 LoadDecProfileEntrypoints(VAProfileHEVCMain10);
2546 }
2547
2548 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit420Decoding))
2549 {
2550 LoadDecProfileEntrypoints(VAProfileHEVCMain12);
2551 }
2552
2553 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD42210bitDecoding))
2554 {
2555 LoadDecProfileEntrypoints(VAProfileHEVCMain422_10);
2556 }
2557
2558 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit422Decoding))
2559 {
2560 LoadDecProfileEntrypoints(VAProfileHEVCMain422_12);
2561 }
2562
2563 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD4448bitDecoding))
2564 {
2565 LoadDecProfileEntrypoints(VAProfileHEVCMain444);
2566 }
2567
2568 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLD44410bitDecoding))
2569 {
2570 LoadDecProfileEntrypoints(VAProfileHEVCMain444_10);
2571 }
2572
2573 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain12bit444Decoding))
2574 {
2575 LoadDecProfileEntrypoints(VAProfileHEVCMain444_12);
2576 }
2577
2578 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain8bit420SCC))
2579 {
2580 LoadDecProfileEntrypoints(VAProfileHEVCSccMain);
2581 }
2582
2583 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10bit420SCC))
2584 {
2585 LoadDecProfileEntrypoints(VAProfileHEVCSccMain10);
2586 }
2587
2588 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain8bit444SCC))
2589 {
2590 LoadDecProfileEntrypoints(VAProfileHEVCSccMain444);
2591 }
2592
2593 if (MEDIA_IS_SKU(&(m_mediaCtx->SkuTable), FtrIntelHEVCVLDMain10bit444SCC))
2594 {
2595 LoadDecProfileEntrypoints(VAProfileHEVCSccMain444_10);
2596 }
2597
2598 #endif
2599 return status;
2600 }
2601
IsHevcProfile(VAProfile profile)2602 bool MediaLibvaCapsG12::IsHevcProfile(VAProfile profile)
2603 {
2604 return (
2605 (profile == VAProfileHEVCMain) ||
2606 (profile == VAProfileHEVCMain10) ||
2607 (profile == VAProfileHEVCMain12) ||
2608 (profile == VAProfileHEVCMain422_10) ||
2609 (profile == VAProfileHEVCMain422_12) ||
2610 (profile == VAProfileHEVCMain444) ||
2611 (profile == VAProfileHEVCMain444_10) ||
2612 (profile == VAProfileHEVCMain444_12) ||
2613 (profile == VAProfileHEVCSccMain) ||
2614 (profile == VAProfileHEVCSccMain10) ||
2615 (profile == VAProfileHEVCSccMain444) ||
2616 (profile == VAProfileHEVCSccMain444_10)
2617 );
2618 }
2619
QueryAVCROIMaxNum(uint32_t rcMode,bool isVdenc,uint32_t * maxNum,bool * isRoiInDeltaQP)2620 VAStatus MediaLibvaCapsG12::QueryAVCROIMaxNum(uint32_t rcMode, bool isVdenc, uint32_t *maxNum, bool *isRoiInDeltaQP)
2621 {
2622 DDI_CHK_NULL(maxNum, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
2623 DDI_CHK_NULL(isRoiInDeltaQP, "Null pointer", VA_STATUS_ERROR_INVALID_PARAMETER);
2624
2625 if(isVdenc)
2626 {
2627 *maxNum = ENCODE_VDENC_AVC_MAX_ROI_NUMBER_ADV;
2628 }
2629 else
2630 {
2631 switch (rcMode)
2632 {
2633 case VA_RC_CQP:
2634 *maxNum = ENCODE_DP_AVC_MAX_ROI_NUMBER;
2635 break;
2636 default:
2637 *maxNum = ENCODE_DP_AVC_MAX_ROI_NUM_BRC;
2638 break;
2639 }
2640 }
2641
2642 *isRoiInDeltaQP = true;
2643
2644 return VA_STATUS_SUCCESS;
2645 }
2646
ConvertMediaFmtToGmmFmt(DDI_MEDIA_FORMAT format)2647 GMM_RESOURCE_FORMAT MediaLibvaCapsG12::ConvertMediaFmtToGmmFmt(
2648 DDI_MEDIA_FORMAT format)
2649 {
2650 switch (format)
2651 {
2652 case Media_Format_X8R8G8B8 : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
2653 case Media_Format_A8R8G8B8 : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
2654 case Media_Format_X8B8G8R8 : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
2655 case Media_Format_A8B8G8R8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
2656 case Media_Format_R8G8B8A8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
2657 case Media_Format_R5G6B5 : return GMM_FORMAT_B5G6R5_UNORM_TYPE;
2658 case Media_Format_R8G8B8 : return GMM_FORMAT_R8G8B8_UNORM;
2659 case Media_Format_RGBP : return GMM_FORMAT_RGBP;
2660 case Media_Format_BGRP : return GMM_FORMAT_BGRP;
2661 case Media_Format_NV12 : return GMM_FORMAT_NV12_TYPE;
2662 case Media_Format_NV21 : return GMM_FORMAT_NV21_TYPE;
2663 case Media_Format_YUY2 : return GMM_FORMAT_YUY2;
2664 case Media_Format_YVYU : return GMM_FORMAT_YVYU;
2665 case Media_Format_UYVY : return GMM_FORMAT_UYVY;
2666 case Media_Format_VYUY : return GMM_FORMAT_VYUY;
2667 case Media_Format_YV12 : return GMM_FORMAT_YV12_TYPE;
2668 case Media_Format_IYUV : return GMM_FORMAT_IYUV_TYPE;
2669 case Media_Format_I420 : return GMM_FORMAT_I420_TYPE;
2670 case Media_Format_444P : return GMM_FORMAT_MFX_JPEG_YUV444_TYPE;
2671 case Media_Format_422H : return GMM_FORMAT_MFX_JPEG_YUV422H_TYPE;
2672 case Media_Format_411P : return GMM_FORMAT_MFX_JPEG_YUV411_TYPE;
2673 case Media_Format_422V : return GMM_FORMAT_MFX_JPEG_YUV422V_TYPE;
2674 case Media_Format_IMC3 : return GMM_FORMAT_IMC3_TYPE;
2675 case Media_Format_400P : return GMM_FORMAT_GENERIC_8BIT;
2676 case Media_Format_Buffer : return GMM_FORMAT_RENDER_8BIT;
2677 case Media_Format_P010 : return GMM_FORMAT_P010_TYPE;
2678 case Media_Format_R10G10B10A2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
2679 case Media_Format_B10G10R10A2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
2680 case Media_Format_R10G10B10X2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
2681 case Media_Format_B10G10R10X2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
2682 case Media_Format_P012 : return GMM_FORMAT_P016_TYPE;
2683 case Media_Format_P016 : return GMM_FORMAT_P016_TYPE;
2684 case Media_Format_Y210 : return GMM_FORMAT_Y210_TYPE;
2685 #if VA_CHECK_VERSION(1, 9, 0)
2686 case Media_Format_Y212 : return GMM_FORMAT_Y212_TYPE;
2687 #endif
2688 case Media_Format_Y216 : return GMM_FORMAT_Y216_TYPE;
2689 case Media_Format_AYUV : return GMM_FORMAT_AYUV_TYPE;
2690 #if VA_CHECK_VERSION(1, 13, 0)
2691 case Media_Format_XYUV : return GMM_FORMAT_AYUV_TYPE;
2692 #endif
2693 case Media_Format_Y410 : return GMM_FORMAT_Y410_TYPE;
2694 #if VA_CHECK_VERSION(1, 9, 0)
2695 case Media_Format_Y412 : return GMM_FORMAT_Y412_TYPE;
2696 #endif
2697 case Media_Format_Y416 : return GMM_FORMAT_Y416_TYPE;
2698 case Media_Format_Y8 : return GMM_FORMAT_MEDIA_Y8_UNORM;
2699 case Media_Format_Y16S : return GMM_FORMAT_MEDIA_Y16_SNORM;
2700 case Media_Format_Y16U : return GMM_FORMAT_MEDIA_Y16_UNORM;
2701 case Media_Format_A16R16G16B16: return GMM_FORMAT_B16G16R16A16_UNORM;
2702 case Media_Format_A16B16G16R16: return GMM_FORMAT_R16G16B16A16_UNORM;
2703 default : return GMM_FORMAT_INVALID;
2704 }
2705 }
2706
GetDisplayAttributes(VADisplayAttribute * attribList,int32_t numAttribs)2707 VAStatus MediaLibvaCapsG12::GetDisplayAttributes(
2708 VADisplayAttribute *attribList,
2709 int32_t numAttribs)
2710 {
2711 DDI_CHK_NULL(attribList, "Null attribList", VA_STATUS_ERROR_INVALID_PARAMETER);
2712 for(auto i = 0; i < numAttribs; i ++)
2713 {
2714 switch(attribList->type)
2715 {
2716 #if VA_CHECK_VERSION(1, 15, 0)
2717 case VADisplayPCIID:
2718 attribList->min_value = attribList->value = attribList->max_value = (m_mediaCtx->iDeviceId & 0xffff) | 0x80860000;
2719 attribList->flags = VA_DISPLAY_ATTRIB_GETTABLE;
2720 break;
2721 #endif
2722 case VADisplayAttribCopy:
2723 attribList->min_value = attribList->value = attribList->max_value = 1 << VA_EXEC_MODE_POWER_SAVING ;
2724 attribList->flags = VA_DISPLAY_ATTRIB_GETTABLE;
2725 break;
2726 default:
2727 attribList->min_value = VA_ATTRIB_NOT_SUPPORTED;
2728 attribList->max_value = VA_ATTRIB_NOT_SUPPORTED;
2729 attribList->value = VA_ATTRIB_NOT_SUPPORTED;
2730 attribList->flags = VA_DISPLAY_ATTRIB_NOT_SUPPORTED;
2731 break;
2732 }
2733 attribList ++;
2734 }
2735 return VA_STATUS_SUCCESS;
2736 }
2737
GetSurfaceModifier(DDI_MEDIA_SURFACE * mediaSurface,uint64_t & modifier)2738 VAStatus MediaLibvaCapsG12::GetSurfaceModifier(DDI_MEDIA_SURFACE* mediaSurface, uint64_t &modifier)
2739 {
2740 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
2741 DDI_CHK_NULL(mediaSurface->bo, "nullptr mediaSurface->bo", VA_STATUS_ERROR_INVALID_SURFACE);
2742 DDI_CHK_NULL(mediaSurface->pGmmResourceInfo, "nullptr mediaSurface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_SURFACE);
2743 GMM_TILE_TYPE gmmTileType = mediaSurface->pGmmResourceInfo->GetTileType();
2744 GMM_RESOURCE_FLAG GmmFlags = {0};
2745 GmmFlags = mediaSurface->pGmmResourceInfo->GetResFlags();
2746
2747 bool bMmcEnabled = false;
2748 if ((GmmFlags.Gpu.MMC ||
2749 GmmFlags.Gpu.CCS) &&
2750 (GmmFlags.Info.MediaCompressed ||
2751 GmmFlags.Info.RenderCompressed))
2752 {
2753 bMmcEnabled = true;
2754 }
2755 else
2756 {
2757 bMmcEnabled = false;
2758 }
2759
2760 if(GMM_TILED_4 == gmmTileType && MEDIA_IS_SKU(&m_mediaCtx->SkuTable, FtrLocalMemory))
2761 {
2762 if(m_mediaCtx->m_auxTableMgr && bMmcEnabled)
2763 {
2764 modifier = GmmFlags.Info.MediaCompressed ? I915_FORMAT_MOD_4_TILED_DG2_MC_CCS :
2765 - (GmmFlags.Info.RenderCompressed ? I915_FORMAT_MOD_4_TILED_DG2_RC_CCS_CC : I915_FORMAT_MOD_4_TILED);
2766 }
2767 else
2768 {
2769 modifier = I915_FORMAT_MOD_4_TILED;
2770 }
2771 return VA_STATUS_SUCCESS;
2772 }
2773 else
2774 {
2775 return MediaLibvaCaps::GetSurfaceModifier(mediaSurface, modifier);
2776 }
2777 }
2778
SetExternalSurfaceTileFormat(DDI_MEDIA_SURFACE * mediaSurface,uint32_t & tileformat,bool & bMemCompEnable,bool & bMemCompRC)2779 VAStatus MediaLibvaCapsG12::SetExternalSurfaceTileFormat(DDI_MEDIA_SURFACE* mediaSurface, uint32_t &tileformat, bool &bMemCompEnable, bool &bMemCompRC)
2780 {
2781 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
2782 DDI_CHK_NULL(mediaSurface->pSurfDesc, "nullptr mediaSurface->pSurfDesc", VA_STATUS_ERROR_INVALID_SURFACE);
2783
2784 switch (mediaSurface->pSurfDesc->modifier)
2785 {
2786 case DRM_FORMAT_MOD_LINEAR:
2787 tileformat = TILING_NONE;
2788 bMemCompEnable = false;
2789 break;
2790 case I915_FORMAT_MOD_X_TILED:
2791 tileformat = TILING_X;
2792 bMemCompEnable = false;
2793 break;
2794 case I915_FORMAT_MOD_4_TILED:
2795 case I915_FORMAT_MOD_Yf_TILED:
2796 case I915_FORMAT_MOD_Y_TILED:
2797 tileformat = TILING_Y;
2798 bMemCompEnable = false;
2799 break;
2800 case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS:
2801 tileformat = TILING_Y;
2802 bMemCompEnable = true;
2803 bMemCompRC = true;
2804 break;
2805 case I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS:
2806 tileformat = TILING_Y;
2807 bMemCompEnable = true;
2808 bMemCompRC = false;
2809 break;
2810 default:
2811 return VA_STATUS_ERROR_INVALID_SURFACE;
2812 }
2813
2814 return VA_STATUS_SUCCESS;
2815 }
2816
2817 extern template class MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>;
2818
2819 static bool tglLPRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2820 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_TIGERLAKE_LP);
2821
2822 #ifdef IGFX_GEN12_RKL_SUPPORTED
2823 static bool rklRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2824 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_ROCKETLAKE);
2825 #endif
2826
2827
2828 #ifdef IGFX_GEN12_ADLS_SUPPORTED
2829 static bool adlsRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2830 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_ALDERLAKE_S);
2831 #endif
2832
2833 #ifdef IGFX_GEN12_DG1_SUPPORTED
2834 static bool dg1Registered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2835 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_DG1);
2836 #endif
2837
2838 #ifdef IGFX_GEN12_ADLP_SUPPORTED
2839 static bool adlpRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2840 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_ALDERLAKE_P);
2841 #endif
2842
2843 #ifdef IGFX_GEN12_ADLN_SUPPORTED
2844 static bool adlnRegistered = MediaLibvaCapsFactory<MediaLibvaCaps, DDI_MEDIA_CONTEXT>::
2845 RegisterCaps<MediaLibvaCapsG12>((uint32_t)IGFX_ALDERLAKE_N);
2846 #endif
2847
2848
2849