Google Git
Sign in
fuchsia / third_party / github.com / intel / libva-utils / refs/tags/2.7.1 / . / vainfo / vainfo.c
blob: 00c6e7ef1c62068b905b4ad999f6026bfc70e4e8 [file] [log] [blame]
/*
* Copyright (c) 2007 Intel Corporation. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>
#include <va/va_str.h>
#include "va_display.h"
#ifdef ANDROID
/* Macros generated from configure */
#define LIBVA_VERSION_S "2.0.0"
#endif
#define CHECK_VASTATUS(va_status,func, ret) \
if (va_status != VA_STATUS_SUCCESS) { \
fprintf(stderr,"%s failed with error code %d (%s),exit\n",func, va_status, vaErrorStr(va_status)); \
ret_val = ret; \
goto error; \
}
static int show_all_opt = 0;
static void
usage_exit(const char *program)
{
fprintf(stdout, "Show information from VA-API driver\n");
fprintf(stdout, "Usage: %s --help\n", program);
fprintf(stdout, "\t--help print this message\n\n");
fprintf(stdout, "Usage: %s [options]\n", program);
fprintf(stdout, " -a, --all Show all supported attributes\n");
va_print_display_options(stdout);
exit(0);
}
static void
parse_args(const char *name, int argc, char **argv)
{
int c;
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"all", no_argument, 0, 'a'},
{ NULL, 0, NULL, 0 }
};
va_init_display_args(&argc, argv);
while ((c = getopt_long(argc, argv,
"a",
long_options,
&option_index)) != -1) {
switch(c) {
case 'a':
show_all_opt = 1;
break;
case 'h':
default:
usage_exit(name);
break;
}
}
}
static int show_config_attributes(VADisplay va_dpy, VAProfile profile, VAEntrypoint entrypoint)
{
struct str_format
{
int format;
char *name;
};
VAStatus va_status;
int i, n;
VAConfigAttrib attrib_list[VAConfigAttribTypeMax];
int max_num_attributes = VAConfigAttribTypeMax;
for (i = 0; i < max_num_attributes; i++) {
attrib_list[i].type = i;
}
va_status = vaGetConfigAttributes(va_dpy,
profile, entrypoint,
attrib_list, max_num_attributes);
if (VA_STATUS_ERROR_UNSUPPORTED_PROFILE == va_status ||
VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT == va_status )
return 0;
printf("%s/%s\n", vaProfileStr(profile), vaEntrypointStr(entrypoint));
if (attrib_list[VAConfigAttribRTFormat].value != VA_ATTRIB_NOT_SUPPORTED) {
static struct str_format list[] = {
{VA_RT_FORMAT_YUV420, "VA_RT_FORMAT_YUV420"},
{VA_RT_FORMAT_YUV422, "VA_RT_FORMAT_YUV422"},
{VA_RT_FORMAT_YUV444, "VA_RT_FORMAT_YUV444"},
{VA_RT_FORMAT_YUV411, "VA_RT_FORMAT_YUV411"},
{VA_RT_FORMAT_YUV400, "VA_RT_FORMAT_YUV400"},
{VA_RT_FORMAT_YUV420_10, "VA_RT_FORMAT_YUV420_10"},
{VA_RT_FORMAT_YUV422_10, "VA_RT_FORMAT_YUV422_10"},
{VA_RT_FORMAT_YUV444_10, "VA_RT_FORMAT_YUV444_10"},
{VA_RT_FORMAT_YUV420_12, "VA_RT_FORMAT_YUV420_12"},
{VA_RT_FORMAT_YUV422_12, "VA_RT_FORMAT_YUV422_12"},
{VA_RT_FORMAT_YUV444_12, "VA_RT_FORMAT_YUV444_12"},
{VA_RT_FORMAT_RGB16, "VA_RT_FORMAT_RGB16"},
{VA_RT_FORMAT_RGB32, "VA_RT_FORMAT_RGB32"},
{VA_RT_FORMAT_RGBP, "VA_RT_FORMAT_RGBP"},
{VA_RT_FORMAT_RGB32_10, "VA_RT_FORMAT_RGB32_10"},
{VA_RT_FORMAT_RGB32_10BPP, "VA_RT_FORMAT_RGB32_10BPP"},
{VA_RT_FORMAT_YUV420_10BPP, "VA_RT_FORMAT_YUV420_10BPP"},
{VA_RT_FORMAT_PROTECTED, "VA_RT_FORMAT_PROTECTED"},
};
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribRTFormat].type));
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribRTFormat].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribSpatialResidual].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribSpatialResidual].type),
attrib_list[VAConfigAttribSpatialResidual].value);
}
if (attrib_list[VAConfigAttribSpatialClipping].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribSpatialClipping].type),
attrib_list[VAConfigAttribSpatialClipping].value);
}
if (attrib_list[VAConfigAttribIntraResidual].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribIntraResidual].type),
attrib_list[VAConfigAttribIntraResidual].value);
}
if (attrib_list[VAConfigAttribEncryption].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %x\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncryption].type),
attrib_list[VAConfigAttribEncryption].value);
}
if (attrib_list[VAConfigAttribRateControl].value != VA_ATTRIB_NOT_SUPPORTED) {
static struct str_format list[] = {
{VA_RC_NONE, "VA_RC_NONE"},
{VA_RC_CBR, "VA_RC_CBR"},
{VA_RC_VBR, "VA_RC_VBR"},
{VA_RC_VCM, "VA_RC_VCM"},
{VA_RC_CQP, "VA_RC_CQP"},
{VA_RC_VBR_CONSTRAINED, "VA_RC_VBR_CONSTRAINED"},
{VA_RC_ICQ, "VA_RC_ICQ"},
{VA_RC_MB, "VA_RC_MB"},
{VA_RC_CFS, "VA_RC_CFS"},
{VA_RC_PARALLEL, "VA_RC_PARALLEL"},
{VA_RC_QVBR, "VA_RC_QVBR"},
{VA_RC_AVBR, "VA_RC_AVBR"},
};
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribRateControl].type));
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribRateControl].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribDecSliceMode].value != VA_ATTRIB_NOT_SUPPORTED) {
static struct str_format list[] = {
{VA_DEC_SLICE_MODE_NORMAL, "VA_DEC_SLICE_MODE_NORMAL"},
{VA_DEC_SLICE_MODE_BASE, "VA_DEC_SLICE_MODE_BASE"},
};
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecSliceMode].type));
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribDecSliceMode].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribDecJPEG].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
static struct str_format list[] = {
{1 << VA_ROTATION_NONE, "VA_ROTATION_NONE"},
{1 << VA_ROTATION_90, "VA_ROTATION_90"},
{1 << VA_ROTATION_180, "VA_ROTATION_180"},
{1 << VA_ROTATION_270, "VA_ROTATION_270"},
};
VAConfigAttribValDecJPEG *config = (VAConfigAttribValDecJPEG*)&attrib_list[VAConfigAttribDecJPEG].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecJPEG].type));
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (config->bits.rotation & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribDecProcessing].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s:", vaConfigAttribTypeStr(attrib_list[VAConfigAttribDecProcessing].type));
if (VA_DEC_PROCESSING_NONE == attrib_list[VAConfigAttribDecProcessing].value)
printf(" VA_DEC_PROCESSING_NONE\n");
else if (VA_DEC_PROCESSING == attrib_list[VAConfigAttribDecProcessing].value)
printf(" VA_DEC_PROCESSING\n");
}
if (attrib_list[VAConfigAttribEncPackedHeaders].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncPackedHeaders].type));
if (VA_ENC_PACKED_HEADER_NONE == attrib_list[VAConfigAttribEncPackedHeaders].value)
printf("VA_ENC_PACKED_HEADER_NONE\n");
else {
static struct str_format list[] = {
{VA_ENC_PACKED_HEADER_SEQUENCE, "VA_ENC_PACKED_HEADER_SEQUENCE"},
{VA_ENC_PACKED_HEADER_PICTURE, "VA_ENC_PACKED_HEADER_PICTURE"},
{VA_ENC_PACKED_HEADER_SLICE, "VA_ENC_PACKED_HEADER_SLICE"},
{VA_ENC_PACKED_HEADER_MISC, "VA_ENC_PACKED_HEADER_MISC"},
{VA_ENC_PACKED_HEADER_RAW_DATA, "VA_ENC_PACKED_HEADER_RAW_DATA"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribEncPackedHeaders].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
}
if (attrib_list[VAConfigAttribEncInterlaced].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncInterlaced].type));
if (VA_ENC_INTERLACED_NONE == attrib_list[VAConfigAttribEncInterlaced].value)
printf("VA_ENC_INTERLACED_NONE\n");
else {
static struct str_format list[] = {
{VA_ENC_INTERLACED_FRAME, "VA_ENC_INTERLACED_FRAME"},
{VA_ENC_INTERLACED_FIELD, "VA_ENC_INTERLACED_FIELD"},
{VA_ENC_INTERLACED_MBAFF, "VA_ENC_INTERLACED_MBAFF"},
{VA_ENC_INTERLACED_PAFF, "VA_ENC_INTERLACED_PAFF"},
{VA_ENC_PACKED_HEADER_RAW_DATA, "VA_ENC_PACKED_HEADER_RAW_DATA"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribEncInterlaced].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
}
if (attrib_list[VAConfigAttribEncMaxRefFrames].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxRefFrames].type));
printf("l0=%d\n", attrib_list[VAConfigAttribEncMaxRefFrames].value & 0xffff);
printf("%-*sl1=%d\n", 45, "", (attrib_list[VAConfigAttribEncMaxRefFrames].value >> 16) & 0xffff);
}
if (attrib_list[VAConfigAttribEncMaxSlices].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMaxSlices].type),
attrib_list[VAConfigAttribEncMaxRefFrames].value);
}
if (attrib_list[VAConfigAttribEncSliceStructure].value != VA_ATTRIB_NOT_SUPPORTED) {
static struct str_format list[] = {
{VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS, "VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS"},
{VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS, "VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS"},
{VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS, "VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS"},
{VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE, "VA_ENC_SLICE_STRUCTURE_MAX_SLICE_SIZE"},
{VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS, "VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS"},
};
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncSliceStructure].type));
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribEncSliceStructure].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribEncMacroblockInfo].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncMacroblockInfo].type));
}
if (attrib_list[VAConfigAttribMaxPictureWidth].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxPictureWidth].type),
attrib_list[VAConfigAttribMaxPictureWidth].value);
}
if (attrib_list[VAConfigAttribMaxPictureHeight].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxPictureHeight].type),
attrib_list[VAConfigAttribMaxPictureHeight].value);
}
if (attrib_list[VAConfigAttribEncJPEG].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValEncJPEG *config = (VAConfigAttribValEncJPEG*)&attrib_list[VAConfigAttribEncJPEG].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncJPEG].type));
printf("rithmatic_coding_mode=%d\n", config->bits.arithmatic_coding_mode);
printf("%-*sprogressive_dct_mode=%d\n", 45, "", config->bits.progressive_dct_mode);
printf("%-*snon_interleaved_mode=%d\n", 45, "", config->bits.non_interleaved_mode);
printf("%-*sdifferential_mode=%d\n", 45, "", config->bits.differential_mode);
printf("%-*sdifferential_mode=%d\n", 45, "", config->bits.differential_mode);
printf("%-*smax_num_components=%d\n", 45, "", config->bits.max_num_components);
printf("%-*smax_num_scans=%d\n", 45, "", config->bits.max_num_scans);
printf("%-*smax_num_huffman_tables=%d\n", 45, "", config->bits.max_num_huffman_tables);
printf("%-*smax_num_quantization_tables=%d\n", 45, "", config->bits.max_num_quantization_tables);
}
if (attrib_list[VAConfigAttribEncQualityRange].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: number of supported quality levels is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncQualityRange].type),
attrib_list[VAConfigAttribEncQualityRange].value <= 1 ? 1 :attrib_list[VAConfigAttribEncQualityRange].value);
}
if (attrib_list[VAConfigAttribEncQuantization].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s:", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncQuantization].type));
if (VA_ENC_QUANTIZATION_NONE == attrib_list[VAConfigAttribEncQuantization].value)
printf(" VA_ENC_QUANTIZATION_NONE\n");
else if (VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED == attrib_list[VAConfigAttribEncQuantization].value)
printf(" VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED\n");
}
if (attrib_list[VAConfigAttribEncIntraRefresh].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncIntraRefresh].type));
if (VA_ENC_INTRA_REFRESH_NONE == attrib_list[VAConfigAttribEncIntraRefresh].value)
printf("VA_ENC_INTRA_REFRESH_NONE\n");
else {
static struct str_format list[] = {
{VA_ENC_INTRA_REFRESH_ROLLING_COLUMN, "VA_ENC_INTRA_REFRESH_ROLLING_COLUMN"},
{VA_ENC_INTRA_REFRESH_ROLLING_ROW, "VA_ENC_INTRA_REFRESH_ROLLING_ROW"},
{VA_ENC_INTRA_REFRESH_ADAPTIVE, "VA_ENC_INTRA_REFRESH_ADAPTIVE"},
{VA_ENC_INTRA_REFRESH_CYCLIC, "VA_ENC_INTRA_REFRESH_CYCLIC"},
{VA_ENC_INTRA_REFRESH_P_FRAME, "VA_ENC_INTRA_REFRESH_P_FRAME"},
{VA_ENC_INTRA_REFRESH_B_FRAME, "VA_ENC_INTRA_REFRESH_B_FRAME"},
{VA_ENC_INTRA_REFRESH_MULTI_REF, "VA_ENC_INTRA_REFRESH_MULTI_REF"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribEncIntraRefresh].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
}
if (attrib_list[VAConfigAttribEncSkipFrame].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncSkipFrame].type));
}
if (attrib_list[VAConfigAttribEncROI].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValEncROI *config = (VAConfigAttribValEncROI*)&attrib_list[VAConfigAttribEncROI].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncROI].type));
printf("num_roi_regions=%d\n", config->bits.num_roi_regions);
printf("%-*sroi_rc_priority_support=%d\n", 45, "", config->bits.roi_rc_priority_support);
printf("%-*sroi_rc_qp_delta_support=%d\n", 45, "", config->bits.roi_rc_qp_delta_support);
}
if (attrib_list[VAConfigAttribEncRateControlExt].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValEncRateControlExt *config = (VAConfigAttribValEncRateControlExt*)&attrib_list[VAConfigAttribEncRateControlExt].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncRateControlExt].type));
printf("max_num_temporal_layers_minus1=%d ", config->bits.max_num_temporal_layers_minus1);
printf("temporal_layer_bitrate_control_flag=%d\n", config->bits.temporal_layer_bitrate_control_flag);
}
if (attrib_list[VAConfigAttribProcessingRate].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribProcessingRate].type));
static struct str_format list[] = {
{VA_PROCESSING_RATE_ENCODE, "VA_PROCESSING_RATE_ENCODE"},
{VA_PROCESSING_RATE_DECODE, "VA_PROCESSING_RATE_DECODE"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribProcessingRate].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribEncDirtyRect].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: number of supported regions is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncDirtyRect].type),
attrib_list[VAConfigAttribEncDirtyRect].value);
}
if (attrib_list[VAConfigAttribEncParallelRateControl].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: number of supported layers is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncParallelRateControl].type),
attrib_list[VAConfigAttribEncParallelRateControl].value);
}
if (attrib_list[VAConfigAttribEncDynamicScaling].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncDynamicScaling].type));
}
if (attrib_list[VAConfigAttribFrameSizeToleranceSupport].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFrameSizeToleranceSupport].type),
attrib_list[VAConfigAttribFrameSizeToleranceSupport].value);
}
if (attrib_list[VAConfigAttribFEIFunctionType].value != VA_ATTRIB_NOT_SUPPORTED) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFEIFunctionType].type));
static struct str_format list[] = {
{VA_FEI_FUNCTION_ENC, "VA_FEI_FUNCTION_ENC"},
{VA_FEI_FUNCTION_PAK, "VA_FEI_FUNCTION_PAK"},
{VA_FEI_FUNCTION_ENC_PAK, "VA_FEI_FUNCTION_ENC_PAK"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribFEIFunctionType].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribFEIMVPredictors].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: number of supported MV predictors is %d\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribFEIMVPredictors].type),
attrib_list[VAConfigAttribFEIMVPredictors].value);
}
if (attrib_list[VAConfigAttribStats].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValStats *config = (VAConfigAttribValStats*)&attrib_list[VAConfigAttribStats].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribStats].type));
printf("max_num_past_references=%d\n", config->bits.max_num_past_references);
printf("%-*smax_num_future_references=%d\n", 45, "", config->bits.max_num_future_references);
printf("%-*snum_outputs=%d\n", 45, "", config->bits.num_outputs);
printf("%-*sinterlaced=%d\n", 45, "", config->bits.interlaced);
}
if (attrib_list[VAConfigAttribEncTileSupport].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribEncTileSupport].type));
}
if (attrib_list[VAConfigAttribQPBlockSize].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: supported\n", vaConfigAttribTypeStr(attrib_list[VAConfigAttribQPBlockSize].type));
}
if (attrib_list[VAConfigAttribMaxFrameSize].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValMaxFrameSize *config = (VAConfigAttribValMaxFrameSize*)&attrib_list[VAConfigAttribMaxFrameSize].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMaxFrameSize].type));
printf("max_frame_size=%d\n", config->bits.max_frame_size);
printf("%-*smultiple_pass=%d\n", 45, "", config->bits.multiple_pass);
}
if (attrib_list[VAConfigAttribPredictionDirection].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribPredictionDirection].type));
static struct str_format list[] = {
{VA_PREDICTION_DIRECTION_PREVIOUS,"VA_PREDICTION_DIRECTION_PREVIOUS"},
{VA_PREDICTION_DIRECTION_FUTURE, "VA_PREDICTION_DIRECTION_FUTURE"},
};
for (i = 0, n = 0; i < sizeof(list)/sizeof(list[0]); i++) {
if (attrib_list[VAConfigAttribPredictionDirection].value & list[i].format) {
printf("%-*s%s\n", 0 == n ? 0 : 45, "", list[i].name);
n++;
}
}
}
if (attrib_list[VAConfigAttribMultipleFrame].value & (~VA_ATTRIB_NOT_SUPPORTED)) {
VAConfigAttribValMultipleFrame *config = (VAConfigAttribValMultipleFrame*)&attrib_list[VAConfigAttribMultipleFrame].value;
printf(" %-39s: ", vaConfigAttribTypeStr(attrib_list[VAConfigAttribMultipleFrame].type));
printf("max_num_concurrent_frames=%d\n", config->bits.max_num_concurrent_frames);
printf("%-*smixed_quality_level=%d\n", 45, "", config->bits.mixed_quality_level);
}
printf("\n");
return 0;
}
int main(int argc, const char* argv[])
{
VADisplay va_dpy;
VAStatus va_status;
int major_version, minor_version;
const char *driver;
const char *name = strrchr(argv[0], '/');
VAProfile profile, *profile_list = NULL;
int num_profiles, max_num_profiles, i;
VAEntrypoint entrypoint, *entrypoints = NULL;
int num_entrypoint = 0;
int ret_val = 0;
if (name)
name++;
else
name = argv[0];
parse_args(name, argc, (char **)argv);
va_dpy = va_open_display();
if (NULL == va_dpy)
{
fprintf(stderr, "%s: vaGetDisplay() failed\n", name);
return 2;
}
va_status = vaInitialize(va_dpy, &major_version, &minor_version);
CHECK_VASTATUS(va_status, "vaInitialize", 3);
printf("%s: VA-API version: %d.%d (libva %s)\n",
name, major_version, minor_version, LIBVA_VERSION_S);
driver = vaQueryVendorString(va_dpy);
printf("%s: Driver version: %s\n", name, driver ? driver : "<unknown>");
num_entrypoint = vaMaxNumEntrypoints (va_dpy);
entrypoints = malloc (num_entrypoint * sizeof (VAEntrypoint));
if (!entrypoints) {
printf ("Failed to allocate memory for entrypoint list\n");
ret_val = -1;
goto error;
}
max_num_profiles = vaMaxNumProfiles(va_dpy);
profile_list = malloc(max_num_profiles * sizeof(VAProfile));
if (!profile_list) {
printf("Failed to allocate memory for profile list\n");
ret_val = 5;
goto error;
}
va_status = vaQueryConfigProfiles(va_dpy, profile_list, &num_profiles);
CHECK_VASTATUS(va_status, "vaQueryConfigProfiles", 6);
if (show_all_opt) {
printf("%s: Supported config attributes per profile/entrypoint pair\n", name);
for (i = 0; i < num_profiles; i++) {
profile = profile_list[i];
va_status = vaQueryConfigEntrypoints(va_dpy, profile, entrypoints,
&num_entrypoint);
if (va_status == VA_STATUS_ERROR_UNSUPPORTED_PROFILE)
continue;
CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints", 4);
for (entrypoint = 0; entrypoint < num_entrypoint; entrypoint++) {
ret_val = show_config_attributes(va_dpy, profile_list[i], entrypoints[entrypoint]);
if (ret_val) {
printf("Failed to get config attributes\n");
goto error;
}
}
}
} else {
printf("%s: Supported profile and entrypoints\n", name);
for (i = 0; i < num_profiles; i++) {
profile = profile_list[i];
va_status = vaQueryConfigEntrypoints(va_dpy, profile, entrypoints,
&num_entrypoint);
if (va_status == VA_STATUS_ERROR_UNSUPPORTED_PROFILE)
continue;
CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints", 4);
for (entrypoint = 0; entrypoint < num_entrypoint; entrypoint++) {
printf(" %-32s: %s\n",
vaProfileStr(profile),
vaEntrypointStr(entrypoints[entrypoint]));
}
}
}
error:
free(entrypoints);
free(profile_list);
vaTerminate(va_dpy);
va_close_display(va_dpy);
return ret_val;
}