/*
 * 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;
}