1 /*
2 * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #if !defined(_WIN32)
30 #include <unistd.h>
31 #endif
32 #include <getopt.h>
33 #include <va/va_str.h>
34
35 #include "va_display.h"
36
37 #define CHECK_VASTATUS(va_status,func, ret) \
38 if (va_status != VA_STATUS_SUCCESS) { \
39 fprintf(stderr,"%s failed with error code %d (%s),exit\n",func, va_status, vaErrorStr(va_status)); \
40 ret_val = ret; \
41 goto error; \
42 }
43 static int show_all_opt = 0;
44
45 static void
usage_exit(const char * program)46 usage_exit(const char *program)
47 {
48 fprintf(stdout, "Show information from VA-API driver\n");
49 fprintf(stdout, "Usage: %s --help\n", program);
50 fprintf(stdout, "\t--help print this message\n\n");
51 fprintf(stdout, "Usage: %s [options]\n", program);
52 fprintf(stdout, " -a, --all Show all supported attributes\n");
53 va_print_display_options(stdout);
54
55 exit(0);
56 }
57
58 static void
parse_args(const char * name,int argc,char ** argv)59 parse_args(const char *name, int argc, char **argv)
60 {
61 int c;
62 int option_index = 0;
63
64 static struct option long_options[] = {
65 {"help", no_argument, 0, 'h'},
66 {"all", no_argument, 0, 'a'},
67 { NULL, 0, NULL, 0 }
68 };
69
70 va_init_display_args(&argc, argv);
71
72 while ((c = getopt_long(argc, argv,
73 "a",
74 long_options,
75 &option_index)) != -1) {
76
77 switch (c) {
78 case 'a':
79 show_all_opt = 1;
80 break;
81 case 'h':
82 default:
83 usage_exit(name);
84 break;
85 }
86 }
87 }
88
show_config_attributes(VADisplay va_dpy,VAProfile profile,VAEntrypoint entrypoint)89 static int show_config_attributes(VADisplay va_dpy, VAProfile profile, VAEntrypoint entrypoint)
90 {
91 struct str_format {
92 int format;
93 char *name;
94 };
95
96 VAStatus va_status;
97 int i, n;
98
99 VAConfigAttrib attrib_list[VAConfigAttribTypeMax];
100 int max_num_attributes = VAConfigAttribTypeMax;
101
102 for (i = 0; i < max_num_attributes; i++) {
103 attrib_list[i].type = i;
104 }
105
106 va_status = vaGetConfigAttributes(va_dpy,
107 profile, entrypoint,
108 attrib_list, max_num_attributes);
109 if (VA_STATUS_ERROR_UNSUPPORTED_PROFILE == va_status ||
110 VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT == va_status)
111 return 0;
112
113 printf("%s/%s\n", vaProfileStr(profile), vaEntrypointStr(entrypoint));
114
115 if (attrib_list[VAConfigAttribRTFormat].value != VA_ATTRIB_NOT_SUPPORTED) {
116 static struct str_format list[] = {
117 {VA_RT_FORMAT_YUV420, "VA_RT_FORMAT_YUV420"},
118 {VA_RT_FORMAT_YUV422, "VA_RT_FORMAT_YUV422"},
119 {VA_RT_FORMAT_YUV444, "VA_RT_FORMAT_YUV444"},
120 {VA_RT_FORMAT_YUV411, "VA_RT_FORMAT_YUV411"},
121 {VA_RT_FORMAT_YUV400, "VA_RT_FORMAT_YUV400"},
122 {VA_RT_FORMAT_YUV420_10, "VA_RT_FORMAT_YUV420_10"},
123 {VA_RT_FORMAT_YUV422_10, "VA_RT_FORMAT_YUV422_10"},
124 {VA_RT_FORMAT_YUV444_10, "VA_RT_FORMAT_YUV444_10"},
125 {VA_RT_FORMAT_YUV420_12, "VA_RT_FORMAT_YUV420_12"},
126 {VA_RT_FORMAT_YUV422_12, "VA_RT_FORMAT_YUV422_12"},
127 {VA_RT_FORMAT_YUV444_12, "VA_RT_FORMAT_YUV444_12"},
128 {VA_RT_FORMAT_RGB16, "VA_RT_FORMAT_RGB16"},
129 {VA_RT_FORMAT_RGB32, "VA_RT_FORMAT_RGB32"},
130 {VA_RT_FORMAT_RGBP, "VA_RT_FORMAT_RGBP"},
131 {VA_RT_FORMAT_RGB32_10, "VA_RT_FORMAT_RGB32_10"},
132 {VA_RT_FORMAT_RGB32_10BPP, "VA_RT_FORMAT_RGB32_10BPP"},
133 {VA_RT_FORMAT_YUV420_10BPP, "VA_RT_FORMAT_YUV420_10BPP"},
134 {VA_RT_FORMAT_PROTECTED, "VA_RT_FORMAT_PROTECTED"},
135 };
136
137 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribRTFormat].type));
138 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
139 if (attrib_list[VAConfigAttribRTFormat].value & list[i].format) {
140 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
141 n++;
142 }
143 }
144 }
145
146 if (attrib_list[VAConfigAttribSpatialResidual].value != VA_ATTRIB_NOT_SUPPORTED) {
147 printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribSpatialResidual].type),
148 attrib_list[VAConfigAttribSpatialResidual].value);
149 }
150
151 if (attrib_list[VAConfigAttribSpatialClipping].value != VA_ATTRIB_NOT_SUPPORTED) {
152 printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribSpatialClipping].type),
153 attrib_list[VAConfigAttribSpatialClipping].value);
154 }
155
156 if (attrib_list[VAConfigAttribIntraResidual].value != VA_ATTRIB_NOT_SUPPORTED) {
157 printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribIntraResidual].type),
158 attrib_list[VAConfigAttribIntraResidual].value);
159 }
160
161 if (attrib_list[VAConfigAttribEncryption].value != VA_ATTRIB_NOT_SUPPORTED) {
162 printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncryption].type),
163 attrib_list[VAConfigAttribEncryption].value);
164 }
165
166 if (attrib_list[VAConfigAttribRateControl].value != VA_ATTRIB_NOT_SUPPORTED) {
167 static struct str_format list[] = {
168 {VA_RC_NONE, "VA_RC_NONE"},
169 {VA_RC_CBR, "VA_RC_CBR"},
170 {VA_RC_VBR, "VA_RC_VBR"},
171 {VA_RC_VCM, "VA_RC_VCM"},
172 {VA_RC_CQP, "VA_RC_CQP"},
173 {VA_RC_VBR_CONSTRAINED, "VA_RC_VBR_CONSTRAINED"},
174 {VA_RC_ICQ, "VA_RC_ICQ"},
175 {VA_RC_MB, "VA_RC_MB"},
176 {VA_RC_CFS, "VA_RC_CFS"},
177 {VA_RC_PARALLEL, "VA_RC_PARALLEL"},
178 {VA_RC_QVBR, "VA_RC_QVBR"},
179 {VA_RC_AVBR, "VA_RC_AVBR"},
180 {VA_RC_TCBRC, "VA_RC_TCBRC"},
181 };
182 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribRateControl].type));
183 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
184 if (attrib_list[VAConfigAttribRateControl].value & list[i].format) {
185 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
186 n++;
187 }
188 }
189 }
190
191 if (attrib_list[VAConfigAttribDecSliceMode].value != VA_ATTRIB_NOT_SUPPORTED) {
192 static struct str_format list[] = {
193 {VA_DEC_SLICE_MODE_NORMAL, "VA_DEC_SLICE_MODE_NORMAL"},
194 {VA_DEC_SLICE_MODE_BASE, "VA_DEC_SLICE_MODE_BASE"},
195 };
196 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecSliceMode].type));
197 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
198 if (attrib_list[VAConfigAttribDecSliceMode].value & list[i].format) {
199 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
200 n++;
201 }
202 }
203 }
204
205 if (attrib_list[VAConfigAttribDecJPEG].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
206 static struct str_format list[] = {
207 {1 << VA_ROTATION_NONE, "VA_ROTATION_NONE"},
208 {1 << VA_ROTATION_90, "VA_ROTATION_90"},
209 {1 << VA_ROTATION_180, "VA_ROTATION_180"},
210 {1 << VA_ROTATION_270, "VA_ROTATION_270"},
211 };
212
213 VAConfigAttribValDecJPEG *config = (VAConfigAttribValDecJPEG*)&attrib_list[VAConfigAttribDecJPEG].value;
214 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecJPEG].type));
215 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
216 if (config->bits.rotation & list[i].format) {
217 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
218 n++;
219 }
220 }
221 }
222
223 if (attrib_list[VAConfigAttribDecProcessing].value != VA_ATTRIB_NOT_SUPPORTED) {
224 printf(" %-39s:", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecProcessing].type));
225 if (VA_DEC_PROCESSING_NONE == attrib_list[VAConfigAttribDecProcessing].value)
226 printf(" VA_DEC_PROCESSING_NONE\n");
227 else if (VA_DEC_PROCESSING == attrib_list[VAConfigAttribDecProcessing].value)
228 printf(" VA_DEC_PROCESSING\n");
229 }
230
231 if (attrib_list[VAConfigAttribEncPackedHeaders].value != VA_ATTRIB_NOT_SUPPORTED) {
232 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncPackedHeaders].type));
233 if (VA_ENC_PACKED_HEADER_NONE == attrib_list[VAConfigAttribEncPackedHeaders].value)
234 printf("VA_ENC_PACKED_HEADER_NONE\n");
235 else {
236 static struct str_format list[] = {
237 {VA_ENC_PACKED_HEADER_SEQUENCE, "VA_ENC_PACKED_HEADER_SEQUENCE"},
238 {VA_ENC_PACKED_HEADER_PICTURE, "VA_ENC_PACKED_HEADER_PICTURE"},
239 {VA_ENC_PACKED_HEADER_SLICE, "VA_ENC_PACKED_HEADER_SLICE"},
240 {VA_ENC_PACKED_HEADER_MISC, "VA_ENC_PACKED_HEADER_MISC"},
241 {VA_ENC_PACKED_HEADER_RAW_DATA, "VA_ENC_PACKED_HEADER_RAW_DATA"},
242 };
243 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
244 if (attrib_list[VAConfigAttribEncPackedHeaders].value & list[i].format) {
245 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
246 n++;
247 }
248 }
249 }
250 }
251
252 if (attrib_list[VAConfigAttribEncInterlaced].value != VA_ATTRIB_NOT_SUPPORTED) {
253 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncInterlaced].type));
254 if (VA_ENC_INTERLACED_NONE == attrib_list[VAConfigAttribEncInterlaced].value)
255 printf("VA_ENC_INTERLACED_NONE\n");
256 else {
257 static struct str_format list[] = {
258 {VA_ENC_INTERLACED_FRAME, "VA_ENC_INTERLACED_FRAME"},
259 {VA_ENC_INTERLACED_FIELD, "VA_ENC_INTERLACED_FIELD"},
260 {VA_ENC_INTERLACED_MBAFF, "VA_ENC_INTERLACED_MBAFF"},
261 {VA_ENC_INTERLACED_PAFF, "VA_ENC_INTERLACED_PAFF"},
262 {VA_ENC_PACKED_HEADER_RAW_DATA, "VA_ENC_PACKED_HEADER_RAW_DATA"},
263 };
264 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
265 if (attrib_list[VAConfigAttribEncInterlaced].value & list[i].format) {
266 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
267 n++;
268 }
269 }
270 }
271 }
272
273 if (attrib_list[VAConfigAttribEncMaxRefFrames].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
274 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxRefFrames].type));
275 printf("l0=%d\n", attrib_list[VAConfigAttribEncMaxRefFrames].value & 0xffff);
276 printf("%-*sl1=%d\n", 45, "", (attrib_list[VAConfigAttribEncMaxRefFrames].value >> 16) & 0xffff);
277 }
278
279 #if VA_CHECK_VERSION(1, 21, 0)
280 if (attrib_list[VAConfigAttribEncMaxTileRows].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
281 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxTileRows].type),
282 attrib_list[VAConfigAttribEncMaxTileRows].value);
283 }
284
285 if (attrib_list[VAConfigAttribEncMaxTileCols].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
286 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxTileCols].type),
287 attrib_list[VAConfigAttribEncMaxTileCols].value);
288 }
289 #endif
290
291 if (attrib_list[VAConfigAttribEncMaxSlices].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
292 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxSlices].type),
293 attrib_list[VAConfigAttribEncMaxSlices].value);
294 }
295
296 if (attrib_list[VAConfigAttribEncSliceStructure].value != VA_ATTRIB_NOT_SUPPORTED) {
297 static struct str_format list[] = {
298 {VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS, "VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS"},
299 {VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS, "VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS"},
300 {VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS, "VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS"},
301 {VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE, "VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE"},
302 {VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS, "VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS"},
303 };
304 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncSliceStructure].type));
305 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
306 if (attrib_list[VAConfigAttribEncSliceStructure].value & list[i].format) {
307 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
308 n++;
309 }
310 }
311 }
312
313 if (attrib_list[VAConfigAttribEncMacroblockInfo].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
314 printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMacroblockInfo].type));
315 }
316
317 if (attrib_list[VAConfigAttribMaxPictureWidth].value != VA_ATTRIB_NOT_SUPPORTED) {
318 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxPictureWidth].type),
319 attrib_list[VAConfigAttribMaxPictureWidth].value);
320 }
321
322 if (attrib_list[VAConfigAttribMaxPictureHeight].value != VA_ATTRIB_NOT_SUPPORTED) {
323 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxPictureHeight].type),
324 attrib_list[VAConfigAttribMaxPictureHeight].value);
325 }
326
327 if (attrib_list[VAConfigAttribEncJPEG].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
328 VAConfigAttribValEncJPEG *config = (VAConfigAttribValEncJPEG*)&attrib_list[VAConfigAttribEncJPEG].value;
329 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncJPEG].type));
330 printf("arithmatic_coding_mode=%d\n", config->bits.arithmatic_coding_mode);
331 printf("%-*sprogressive_dct_mode=%d\n", 45, "", config->bits.progressive_dct_mode);
332 printf("%-*snon_interleaved_mode=%d\n", 45, "", config->bits.non_interleaved_mode);
333 printf("%-*sdifferential_mode=%d\n", 45, "", config->bits.differential_mode);
334 printf("%-*sdifferential_mode=%d\n", 45, "", config->bits.differential_mode);
335 printf("%-*smax_num_components=%d\n", 45, "", config->bits.max_num_components);
336 printf("%-*smax_num_scans=%d\n", 45, "", config->bits.max_num_scans);
337 printf("%-*smax_num_huffman_tables=%d\n", 45, "", config->bits.max_num_huffman_tables);
338 printf("%-*smax_num_quantization_tables=%d\n", 45, "", config->bits.max_num_quantization_tables);
339 }
340
341 if (attrib_list[VAConfigAttribEncQualityRange].value != VA_ATTRIB_NOT_SUPPORTED) {
342 printf(" %-39s: number of supported quality levels is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncQualityRange].type),
343 attrib_list[VAConfigAttribEncQualityRange].value <= 1 ? 1 : attrib_list[VAConfigAttribEncQualityRange].value);
344 }
345
346 if (attrib_list[VAConfigAttribEncQuantization].value != VA_ATTRIB_NOT_SUPPORTED) {
347 printf(" %-39s:", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncQuantization].type));
348 if (VA_ENC_QUANTIZATION_NONE == attrib_list[VAConfigAttribEncQuantization].value)
349 printf(" VA_ENC_QUANTIZATION_NONE\n");
350 else if (VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED == attrib_list[VAConfigAttribEncQuantization].value)
351 printf(" VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED\n");
352 }
353
354 if (attrib_list[VAConfigAttribEncIntraRefresh].value != VA_ATTRIB_NOT_SUPPORTED) {
355 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncIntraRefresh].type));
356 if (VA_ENC_INTRA_REFRESH_NONE == attrib_list[VAConfigAttribEncIntraRefresh].value)
357 printf("VA_ENC_INTRA_REFRESH_NONE\n");
358 else {
359 static struct str_format list[] = {
360 {VA_ENC_INTRA_REFRESH_ROLLING_COLUMN, "VA_ENC_INTRA_REFRESH_ROLLING_COLUMN"},
361 {VA_ENC_INTRA_REFRESH_ROLLING_ROW, "VA_ENC_INTRA_REFRESH_ROLLING_ROW"},
362 {VA_ENC_INTRA_REFRESH_ADAPTIVE, "VA_ENC_INTRA_REFRESH_ADAPTIVE"},
363 {VA_ENC_INTRA_REFRESH_CYCLIC, "VA_ENC_INTRA_REFRESH_CYCLIC"},
364 {VA_ENC_INTRA_REFRESH_P_FRAME, "VA_ENC_INTRA_REFRESH_P_FRAME"},
365 {VA_ENC_INTRA_REFRESH_B_FRAME, "VA_ENC_INTRA_REFRESH_B_FRAME"},
366 {VA_ENC_INTRA_REFRESH_MULTI_REF, "VA_ENC_INTRA_REFRESH_MULTI_REF"},
367 };
368 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
369 if (attrib_list[VAConfigAttribEncIntraRefresh].value & list[i].format) {
370 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
371 n++;
372 }
373 }
374 }
375 }
376
377 if (attrib_list[VAConfigAttribEncSkipFrame].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
378 printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncSkipFrame].type));
379 }
380
381 if (attrib_list[VAConfigAttribEncROI].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
382 VAConfigAttribValEncROI *config = (VAConfigAttribValEncROI*)&attrib_list[VAConfigAttribEncROI].value;
383 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncROI].type));
384 printf("num_roi_regions=%d\n", config->bits.num_roi_regions);
385 printf("%-*sroi_rc_priority_support=%d\n", 45, "", config->bits.roi_rc_priority_support);
386 printf("%-*sroi_rc_qp_delta_support=%d\n", 45, "", config->bits.roi_rc_qp_delta_support);
387 }
388
389 if (attrib_list[VAConfigAttribEncRateControlExt].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
390 VAConfigAttribValEncRateControlExt *config = (VAConfigAttribValEncRateControlExt*)&attrib_list[VAConfigAttribEncRateControlExt].value;
391 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncRateControlExt].type));
392 printf("max_num_temporal_layers_minus1=%d ", config->bits.max_num_temporal_layers_minus1);
393 printf("temporal_layer_bitrate_control_flag=%d\n", config->bits.temporal_layer_bitrate_control_flag);
394 }
395
396 if (attrib_list[VAConfigAttribProcessingRate].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
397 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribProcessingRate].type));
398 static struct str_format list[] = {
399 {VA_PROCESSING_RATE_ENCODE, "VA_PROCESSING_RATE_ENCODE"},
400 {VA_PROCESSING_RATE_DECODE, "VA_PROCESSING_RATE_DECODE"},
401 };
402 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
403 if (attrib_list[VAConfigAttribProcessingRate].value & list[i].format) {
404 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
405 n++;
406 }
407 }
408 }
409
410 if (attrib_list[VAConfigAttribEncDirtyRect].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
411 printf(" %-39s: number of supported regions is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncDirtyRect].type),
412 attrib_list[VAConfigAttribEncDirtyRect].value);
413 }
414
415 if (attrib_list[VAConfigAttribEncParallelRateControl].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
416 printf(" %-39s: number of supported layers is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncParallelRateControl].type),
417 attrib_list[VAConfigAttribEncParallelRateControl].value);
418 }
419
420 if (attrib_list[VAConfigAttribEncDynamicScaling].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
421 printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncDynamicScaling].type));
422 }
423
424 if (attrib_list[VAConfigAttribFrameSizeToleranceSupport].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
425 printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFrameSizeToleranceSupport].type),
426 attrib_list[VAConfigAttribFrameSizeToleranceSupport].value);
427 }
428
429 if (attrib_list[VAConfigAttribFEIFunctionType].value != VA_ATTRIB_NOT_SUPPORTED) {
430 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFEIFunctionType].type));
431 static struct str_format list[] = {
432 {VA_FEI_FUNCTION_ENC, "VA_FEI_FUNCTION_ENC"},
433 {VA_FEI_FUNCTION_PAK, "VA_FEI_FUNCTION_PAK"},
434 {VA_FEI_FUNCTION_ENC_PAK, "VA_FEI_FUNCTION_ENC_PAK"},
435 };
436 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
437 if (attrib_list[VAConfigAttribFEIFunctionType].value & list[i].format) {
438 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
439 n++;
440 }
441 }
442 }
443
444 if (attrib_list[VAConfigAttribFEIMVPredictors].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
445 printf(" %-39s: number of supported MV predictors is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFEIMVPredictors].type),
446 attrib_list[VAConfigAttribFEIMVPredictors].value);
447 }
448
449 if (attrib_list[VAConfigAttribStats].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
450 VAConfigAttribValStats *config = (VAConfigAttribValStats*)&attrib_list[VAConfigAttribStats].value;
451 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribStats].type));
452 printf("max_num_past_references=%d\n", config->bits.max_num_past_references);
453 printf("%-*smax_num_future_references=%d\n", 45, "", config->bits.max_num_future_references);
454 printf("%-*snum_outputs=%d\n", 45, "", config->bits.num_outputs);
455 printf("%-*sinterlaced=%d\n", 45, "", config->bits.interlaced);
456 }
457
458 if (attrib_list[VAConfigAttribEncTileSupport].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
459 printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncTileSupport].type));
460 }
461
462 if (attrib_list[VAConfigAttribQPBlockSize].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
463 printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribQPBlockSize].type));
464 }
465
466 if (attrib_list[VAConfigAttribMaxFrameSize].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
467 VAConfigAttribValMaxFrameSize *config = (VAConfigAttribValMaxFrameSize*)&attrib_list[VAConfigAttribMaxFrameSize].value;
468 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxFrameSize].type));
469 printf("max_frame_size=%d\n", config->bits.max_frame_size);
470 printf("%-*smultiple_pass=%d\n", 45, "", config->bits.multiple_pass);
471 }
472
473 if (attrib_list[VAConfigAttribPredictionDirection].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
474 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribPredictionDirection].type));
475 static struct str_format list[] = {
476 {VA_PREDICTION_DIRECTION_PREVIOUS, "VA_PREDICTION_DIRECTION_PREVIOUS"},
477 {VA_PREDICTION_DIRECTION_FUTURE, "VA_PREDICTION_DIRECTION_FUTURE"},
478 };
479 for (i = 0, n = 0; i < sizeof(list) / sizeof(list[0]); i++) {
480 if (attrib_list[VAConfigAttribPredictionDirection].value & list[i].format) {
481 printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
482 n++;
483 }
484 }
485 }
486
487 if (attrib_list[VAConfigAttribMultipleFrame].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
488 VAConfigAttribValMultipleFrame *config = (VAConfigAttribValMultipleFrame*)&attrib_list[VAConfigAttribMultipleFrame].value;
489 printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMultipleFrame].type));
490 printf("max_num_concurrent_frames=%d\n", config->bits.max_num_concurrent_frames);
491 printf("%-*smixed_quality_level=%d\n", 45, "", config->bits.mixed_quality_level);
492 }
493
494 printf("\n");
495
496 return 0;
497 }
498
main(int argc,const char * argv[])499 int main(int argc, const char* argv[])
500 {
501 VADisplay va_dpy;
502 VAStatus va_status;
503 int major_version, minor_version;
504 const char *driver;
505 const char *name = strrchr(argv[0], '/');
506 VAProfile profile, *profile_list = NULL;
507 int num_profiles, max_num_profiles, i;
508 VAEntrypoint entrypoint, *entrypoints = NULL;
509 int num_entrypoint = 0;
510 int ret_val = 0;
511
512 if (name)
513 name++;
514 else
515 name = argv[0];
516
517 parse_args(name, argc, (char **)argv);
518
519 va_dpy = va_open_display();
520 if (NULL == va_dpy) {
521 fprintf(stderr, "%s: vaGetDisplay() failed\n", name);
522 return 2;
523 }
524
525 va_status = vaInitialize(va_dpy, &major_version, &minor_version);
526 CHECK_VASTATUS(va_status, "vaInitialize", 3);
527
528 printf("%s: VA-API version: %d.%d",
529 name, major_version, minor_version);
530 #ifdef ANDROID
531 printf("\n");
532 #else
533 printf(" (libva %s)\n", LIBVA_VERSION_S);
534 #endif // ANDROID
535
536 driver = vaQueryVendorString(va_dpy);
537 printf("%s: Driver version: %s\n", name, driver ? driver : "<unknown>");
538
539 num_entrypoint = vaMaxNumEntrypoints(va_dpy);
540 entrypoints = malloc(num_entrypoint * sizeof(VAEntrypoint));
541 if (!entrypoints) {
542 printf("Failed to allocate memory for entrypoint list\n");
543 ret_val = -1;
544 goto error;
545 }
546
547 max_num_profiles = vaMaxNumProfiles(va_dpy);
548 profile_list = malloc(max_num_profiles * sizeof(VAProfile));
549
550 if (!profile_list) {
551 printf("Failed to allocate memory for profile list\n");
552 ret_val = 5;
553 goto error;
554 }
555
556 va_status = vaQueryConfigProfiles(va_dpy, profile_list, &num_profiles);
557 CHECK_VASTATUS(va_status, "vaQueryConfigProfiles", 6);
558
559 if (show_all_opt) {
560 printf("%s: Supported config attributes per profile/entrypoint pair\n", name);
561 for (i = 0; i < num_profiles; i++) {
562 profile = profile_list[i];
563 va_status = vaQueryConfigEntrypoints(va_dpy, profile, entrypoints,
564 &num_entrypoint);
565 if (va_status == VA_STATUS_ERROR_UNSUPPORTED_PROFILE)
566 continue;
567
568 CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints", 4);
569
570 for (entrypoint = 0; entrypoint < num_entrypoint; entrypoint++) {
571 ret_val = show_config_attributes(va_dpy, profile_list[i], entrypoints[entrypoint]);
572 if (ret_val) {
573 printf("Failed to get config attributes\n");
574 goto error;
575 }
576 }
577 }
578 } else {
579 printf("%s: Supported profile and entrypoints\n", name);
580 for (i = 0; i < num_profiles; i++) {
581 profile = profile_list[i];
582 va_status = vaQueryConfigEntrypoints(va_dpy, profile, entrypoints,
583 &num_entrypoint);
584 if (va_status == VA_STATUS_ERROR_UNSUPPORTED_PROFILE)
585 continue;
586
587 CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints", 4);
588
589 for (entrypoint = 0; entrypoint < num_entrypoint; entrypoint++) {
590 printf(" %-32s: %s\n",
591 vaProfileStr(profile),
592 vaEntrypointStr(entrypoints[entrypoint]));
593 }
594 }
595 }
596
597 error:
598 free(entrypoints);
599 free(profile_list);
600 vaTerminate(va_dpy);
601 va_close_display(va_dpy);
602
603 return ret_val;
604 }
605