// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "edid_utils.h"

/* Dump out an EDID block in a simple format */
void show_edid_data(FILE* outfile, unsigned char* edid_data,
                    int items, int base)
{
  int item = 0;

  while (item < items) {
    int i;
    fprintf(outfile, " 0x%04x:  ", item + base);
    for(i=0; i < 16; i++) {
      fprintf(outfile, "%02x ", edid_data[item++]);
      if (item >= items) break;
    }
    fprintf(outfile, "\n");
  }
}


unsigned char test_edid1[256] = {
  0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
  0x06,0xaf,0x5c,0x20,0x00,0x00,0x00,0x00,
  0x01,0x12,0x01,0x03,0x80,0x1a,0x0e,0x78,
  0x0a,0x99,0x85,0x95,0x55,0x56,0x92,0x28,
  0x22,0x50,0x54,0x00,0x00,0x00,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x96,0x19,
  0x56,0x28,0x50,0x00,0x08,0x30,0x18,0x10,
  0x24,0x00,0x00,0x90,0x10,0x00,0x00,0x18,
  0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x20,0x00,0x00,0x00,0xfe,0x00,0x41,
  0x55,0x4f,0x0a,0x20,0x20,0x20,0x20,0x20,
  0x20,0x20,0x20,0x20,0x00,0x00,0x00,0xfe,
  0x00,0x42,0x31,0x31,0x36,0x58,0x57,0x30,
  0x32,0x20,0x56,0x30,0x20,0x0a,0x00,0xf8
};

unsigned char test_edid2[256] = {
  0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
  0x30,0xe4,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x14,0x01,0x03,0x80,0x1a,0x0e,0x78,
  0x0a,0xbf,0x45,0x95,0x58,0x52,0x8a,0x28,
  0x25,0x50,0x54,0x00,0x00,0x00,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x84,0x1c,
  0x56,0xa8,0x50,0x00,0x19,0x30,0x30,0x20,
  0x35,0x00,0x00,0x90,0x10,0x00,0x00,0x1b,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0xfe,0x00,0x4c,
  0x47,0x20,0x44,0x69,0x73,0x70,0x6c,0x61,
  0x79,0x0a,0x20,0x20,0x00,0x00,0x00,0xfc,
  0x00,0x4c,0x50,0x31,0x31,0x36,0x57,0x48,
  0x31,0x2d,0x54,0x4c,0x4e,0x31,0x00,0x4e
};

unsigned char test_edid3[256] = {
  0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
  0x4d,0xd9,0x02,0x00,0x00,0x00,0x00,0x00,
  0x00,0x11,0x01,0x03,0x80,0x00,0x00,0x78,
  0x0a,0x0d,0xc9,0xa0,0x57,0x47,0x98,0x27,
  0x12,0x48,0x4c,0x00,0x00,0x00,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x1d,
  0x80,0xd0,0x72,0x1c,0x16,0x20,0x10,0x2c,
  0x25,0x80,0xc4,0x8e,0x21,0x00,0x00,0x9e,
  0x01,0x1d,0x80,0x18,0x71,0x1c,0x16,0x20,
  0x58,0x2c,0x25,0x00,0xc4,0x8e,0x21,0x00,
  0x00,0x9e,0x00,0x00,0x00,0xfc,0x00,0x48,
  0x44,0x4d,0x49,0x20,0x4c,0x4c,0x43,0x0a,
  0x20,0x20,0x20,0x20,0x00,0x00,0x00,0xfd,
  0x00,0x3b,0x3d,0x0f,0x2d,0x08,0x00,0x0a,
  0x20,0x20,0x20,0x20,0x20,0x20,0x01,0xc0,
  0x02,0x03,0x1e,0x47,0x4f,0x94,0x13,0x05,
  0x03,0x04,0x02,0x01,0x16,0x15,0x07,0x06,
  0x11,0x10,0x12,0x1f,0x23,0x09,0x07,0x01,
  0x65,0x03,0x0c,0x00,0x10,0x00,0x8c,0x0a,
  0xd0,0x90,0x20,0x40,0x31,0x20,0x0c,0x40,
  0x55,0x00,0x13,0x8e,0x21,0x00,0x00,0x18,
  0x01,0x1d,0x00,0xbc,0x52,0xd0,0x1e,0x20,
  0xb8,0x28,0x55,0x40,0xc4,0x8e,0x21,0x00,
  0x00,0x1e,0x8c,0x0a,0xd0,0x8a,0x20,0xe0,
  0x2d,0x10,0x10,0x3e,0x96,0x00,0xc4,0x8e,
  0x21,0x00,0x00,0x18,0x01,0x1d,0x00,0x72,
  0x51,0xd0,0x1e,0x20,0x6e,0x28,0x55,0x00,
  0xc4,0x8e,0x21,0x00,0x00,0x1e,0x8c,0x0a,
  0xd0,0x8a,0x20,0xe0,0x2d,0x10,0x10,0x3e,
  0x96,0x00,0x13,0x8e,0x21,0x00,0x00,0x18,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfb
};

unsigned char test_edid4[256] = {
  0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
  0x4c,0x2d,0x10,0x02,0x00,0x00,0x00,0x00,
  0x31,0x0f,0x01,0x03,0x80,0x10,0x09,0x8c,
  0x0a,0xe2,0xbd,0xa1,0x5b,0x4a,0x98,0x24,
  0x15,0x47,0x4a,0x20,0x00,0x00,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x1d,
  0x00,0x72,0x51,0xd0,0x1e,0x20,0x6e,0x28,
  0x55,0x00,0xa0,0x5a,0x00,0x00,0x00,0x1e,
  0x01,0x1d,0x80,0x18,0x71,0x1c,0x16,0x20,
  0x58,0x2c,0x25,0x00,0xa0,0x5a,0x00,0x00,
  0x00,0x9e,0x00,0x00,0x00,0xfd,0x00,0x3b,
  0x3d,0x1e,0x2e,0x08,0x00,0x0a,0x20,0x20,
  0x20,0x20,0x20,0x20,0x00,0x00,0x00,0xfc,
  0x00,0x53,0x41,0x4d,0x53,0x55,0x4e,0x47,
  0x0a,0x20,0x20,0x20,0x20,0x20,0x01,0x8d,
  0x02,0x03,0x16,0x71,0x43,0x84,0x05,0x03,
  0x23,0x09,0x07,0x07,0x83,0x01,0x00,0x00,
  0x65,0x03,0x0c,0x00,0x20,0x00,0x8c,0x0a,
  0xd0,0x8a,0x20,0xe0,0x2d,0x10,0x10,0x3e,
  0x96,0x00,0xa0,0x5a,0x00,0x00,0x00,0x18,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30
};

unsigned char test_edid5[256] = {
  0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
  0x3d,0xcb,0x61,0x07,0x00,0x00,0x00,0x00,
  0x00,0x11,0x01,0x03,0x80,0x00,0x00,0x78,
  0x0a,0x0d,0xc9,0xa0,0x57,0x47,0x98,0x27,
  0x12,0x48,0x4c,0x00,0x00,0x00,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x1d,
  0x80,0x18,0x71,0x1c,0x16,0x20,0x58,0x2c,
  0x25,0x00,0xc4,0x8e,0x21,0x00,0x00,0x9e,
  0x01,0x1d,0x80,0xd0,0x72,0x1c,0x16,0x20,
  0x10,0x2c,0x25,0x80,0xc4,0x8e,0x21,0x00,
  0x00,0x9e,0x00,0x00,0x00,0xfc,0x00,0x54,
  0x58,0x2d,0x53,0x52,0x36,0x30,0x35,0x0a,
  0x20,0x20,0x20,0x20,0x00,0x00,0x00,0xfd,
  0x00,0x17,0xf0,0x0f,0x7e,0x11,0x00,0x0a,
  0x20,0x20,0x20,0x20,0x20,0x20,0x01,0x93,
  0x02,0x03,0x3b,0x72,0x55,0x85,0x04,0x03,
  0x02,0x0e,0x0f,0x07,0x23,0x24,0x10,0x94,
  0x13,0x12,0x11,0x1d,0x1e,0x16,0x25,0x26,
  0x01,0x1f,0x35,0x09,0x7f,0x07,0x0f,0x7f,
  0x07,0x17,0x07,0x50,0x3f,0x06,0xc0,0x57,
  0x06,0x00,0x5f,0x7e,0x01,0x67,0x5e,0x00,
  0x83,0x4f,0x00,0x00,0x66,0x03,0x0c,0x00,
  0x20,0x00,0x80,0x8c,0x0a,0xd0,0x8a,0x20,
  0xe0,0x2d,0x10,0x10,0x3e,0x96,0x00,0xc4,
  0x8e,0x21,0x00,0x00,0x18,0x8c,0x0a,0xd0,
  0x90,0x20,0x40,0x31,0x20,0x0c,0x40,0x55,
  0x00,0xc4,0x8e,0x21,0x00,0x00,0x18,0x01,
  0x1d,0x00,0x72,0x51,0xd0,0x1e,0x20,0x6e,
  0x28,0x55,0x00,0xc4,0x8e,0x21,0x00,0x00,
  0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xdd
};

static unsigned char *test_edids[N_TEST_EDIDS] = {
  test_edid1, test_edid2, test_edid3, test_edid4, test_edid5
};

int get_test_edid(int n, unsigned char *dst)
{
  if ((n < 1) || (n > N_TEST_EDIDS)) return -1;
  memcpy(dst, test_edids[n-1], 256);
  return 0;
}

int show_test_edid(FILE *outfile, int n)
{
  if ((n < 1) || (n > N_TEST_EDIDS)) return -1;
  fprintf(outfile, "Test EDID %d\n", n);
  show_edid(outfile, test_edids[n-1], 1);
  return 0;
}

/* Print an edid descriptor block (standard case is at 54 + 18*i) */
void show_edid_dtd(FILE* outfile, unsigned char* base)
{
  int pelclk = base[DTD_PCLK_LO] + (base[DTD_PCLK_HI]<<8);

  if (pelclk != 0) {
    int hres = base[DTD_HA_LO] + ((base[DTD_HABL_HI] & 0xf0)<<4);
    int hbl = base[DTD_HBL_LO] + ((base[DTD_HABL_HI] & 0x0f)<<8);
    int vres = base[DTD_VA_LO] + ((base[DTD_VABL_HI] & 0xf0)<<4);
    int vbl = base[DTD_VBL_LO] + ((base[DTD_VABL_HI] & 0x0f)<<8);
    int hso = base[DTD_HSO_LO] + ((base[DTD_HVSX_HI] & 0xc0)<<2);
    int hsw = base[DTD_HSW_LO] + ((base[DTD_HVSX_HI] & 0x30)<<4);
    int vso = (base[DTD_VSX_LO] >> 4) + ((base[DTD_HVSX_HI] & 0x0c)<<2);
    int vsw = (base[DTD_VSX_LO] & 0xf) + ((base[DTD_HVSX_HI] & 0x03)<<4);
    int hsiz = base[DTD_HSIZE_LO] + ((base[DTD_HVSIZE_HI] & 0xf0)<<4);
    int vsiz = base[DTD_VSIZE_LO] + ((base[DTD_HVSIZE_HI] & 0x0f)<<8);
    int hbdr = base[DTD_HBORDER];
    int vbdr = base[DTD_VBORDER];
    int mdflg = base[DTD_FLAGS];

    int refr = (pelclk * 10000)/((hres+hbl)*(vres+vbl));
    int refm = (pelclk * 10000)%((hres+hbl)*(vres+vbl));
    int refd = (refm*100)/((hres+hbl)*(vres+vbl));

    fprintf(outfile, "%dx%d%c@%d.%02d, dot clock %d  %cHsync %cVsync\n",
            hres, vres, (mdflg & 0x80) ? 'i':'p',
            refr, refd,
            pelclk * 10000,
            (mdflg & 0x2) ? '+':'-',
            (mdflg & 0x4) ? '+':'-');
    fprintf(outfile, "H: start %d, end %d, total %d\n",
            hres+hso, hres+hso+hsw, hres+hbl);
    fprintf(outfile, "V: start %d, end %d, total %d\n",
            vres+vso, vres+vso+vsw, vres+vbl);
    fprintf(outfile, "Size %dx%dmm, Border %dx%d pixels\n",
            hsiz, vsiz, hbdr, vbdr);
  } else {
    char monstr[DTD_SIZE];
    int stp;
    switch (base[DTD_TYPETAG]) {
    case DTDTYPE_SERIAL:
    case DTDTYPE_STRING:
    case DTDTYPE_NAME:
      strncpy(monstr, (char *)base+DTD_STRING, 13);
      for(stp = 0; stp < 13; stp++) if (monstr[stp] == 0x0a) monstr[stp] = 0;
      monstr[stp] = 0;
      if (base[3] != DTDTYPE_STRING)
        fprintf(outfile, "%s: %s\n",
                (base[3] == DTDTYPE_NAME) ? "Name" : "Serial", monstr);
      else
        fprintf(outfile, "%s\n", monstr);
      break;

    case DTDTYPE_LIMITS:
      fprintf(outfile, "Range V %d - %d Hz, H %d - %d kHz, Pel <= %d MHz\n",
              base[DTD_MINV_HZ], base[DTD_MAXV_HZ],
              base[DTD_MINH_kHZ], base[DTD_MAXH_kHZ],
              base[DTD_MAXCLK_100kHZ]*10);
      break;

    default:
      fprintf(outfile, "Undecoded descriptor block type 0x%x\n",
              base[DTD_TYPETAG]);
      break;
    }
  }
}


char *sad_audio_type[16] = {
  "Reserved", "LPCM", "AC-3", "MPEG1 (Layer 1 and 2)",
  "MP3", "MPEG2", "AAC", "DTS",
  "ATRAC", "SACD", "DD+", "DTS-HD",
  "MLP/Dolby TrueHD", "DST Audio", "WMA Pro", "Reserved"};

char *uscanstr[4] = {
  "not supported",
  "always overscan",
  "always underscan",
  "supports both over- and underscan"};

void show_cea_timing(FILE* outfile, unsigned char* edid_ext)
{
  int i, dbc;
  int off_dtd = edid_ext[CEA_DTD_OFFSET];
  int n_dtd;
  fprintf(outfile, "Found CEA EDID Timing Extension rev 3\n");

  if (off_dtd < CEA_DBC_START) {
    fprintf(outfile, "Block is empty (off_dtd = %d)\n", off_dtd);
    return;
  }
  /* Ends with 0 and a checksum, have at least one pad byte */
  n_dtd = (CEA_LAST_PAD - off_dtd)/DTD_SIZE;
  fprintf(outfile,
          "Block has DTDs starting at offset %d (thus %d bytes of DBCs)\n",
          off_dtd, off_dtd - CEA_DBC_START);
  fprintf(outfile, "There is space for max %d DTDs in the extension\n", n_dtd);
  fprintf(outfile,
          "There are %d native DTDs (between regular and extensions)\n",
          edid_ext[CEA_NATIVE_DTDS] & 0xf);
  fprintf(outfile, "IT formats %sdefault to underscan\n",
          (edid_ext[CEA_SUPPORT] & 0x80) ? "" : "do not ");
  fprintf(outfile,
          "Support: %sbasic audio, %sYCrCb 4:4:4, %sYCrCb 4:2:2\n",
          (edid_ext[CEA_SUPPORT] & 0x40) ? "" : "no ",
          (edid_ext[CEA_SUPPORT] & 0x20) ? "" : "no ",
          (edid_ext[CEA_SUPPORT] & 0x10) ? "" : "no ");

  /* Between offset 4 and off_dtd is the Data Block Collection */
  /* There may be none, in which case off_dtd == 4             */
  dbc = CEA_DBC_START;
  while (dbc < off_dtd) {
    int db_len = edid_ext[dbc+DBC_TAG_LENGTH] & DBC_LEN_MASK;
    int dbp = dbc + 1;

    switch (edid_ext[dbc+DBC_TAG_LENGTH] >> DBC_TAG_SHIFT) {

    case DBC_TAG_AUDIO:
      /* Audio Data Block */
      while (dbp < (dbc + db_len + 1)) {
        int atype =(edid_ext[dbp + DBCA_FORMAT]>>3) & 0xf;
        fprintf(outfile, "Audio: %d channel %s: ",
                edid_ext[dbp + DBCA_FORMAT] & 0x7,
                sad_audio_type[atype]);
        if (edid_ext[dbp + DBCA_RATE] & 0x40) fprintf(outfile, "192k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x20) fprintf(outfile, "176k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x10) fprintf(outfile, "96k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x08) fprintf(outfile, "88k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x04) fprintf(outfile, "48k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x02) fprintf(outfile, "44k ");
        if (edid_ext[dbp + DBCA_RATE] & 0x01) fprintf(outfile, "32k ");

        if (atype == 1)
          fprintf(outfile, "%s%s%s\n",
                  (edid_ext[dbp + DBCA_INFO] & 0x4) ? "24-bit ":"",
                  (edid_ext[dbp + DBCA_INFO] & 0x2) ? "20-bit ":"",
                  (edid_ext[dbp + DBCA_INFO] & 0x1) ? "16-bit":"");
        else if ((atype >= 2) && (atype <= 8))
          fprintf(outfile, "Max %dkHz\n", edid_ext[dbp + DBCA_INFO] * 8);
        else
          fprintf(outfile, "Codec vendor flags 0x%02x\n",
                  edid_ext[dbp + DBCA_INFO]);
        dbp += DBCA_SIZE;
      }
      break;

    case DBC_TAG_VIDEO:
      /* Vidio Data Block */
      while (dbp < (dbc + db_len + 1)) {
        int vtype = edid_ext[dbp + DBCV_CODE] & 0x7f;
        fprintf(outfile, "Video: Code %d %s\n", vtype,
                (edid_ext[dbp + DBCV_CODE] & 0x80) ? "(native)":"");
        dbp += DBCV_SIZE;
      }
      break;

    case DBC_TAG_VENDOR:
      /* Vendor Data Block */
      if ((edid_ext[dbp+DBCVND_IEEE_LO] == 0x03) &&
          (edid_ext[dbp+DBCVND_IEEE_MID] == 0x0C) &&
          (edid_ext[dbp+DBCVND_IEEE_HI] == 0x00)) {
        fprintf(outfile,
                "HDMI Vendor block (CEC @0x%04x):\nSupport: %s%s%s%s%s%s\n",
                edid_ext[dbp+DBCVHDMI_CEC_LO] +
                (edid_ext[dbp+DBCVHDMI_CEC_HI]<<8),
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x80) ? "AI ":"",
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x40) ? "DC_48bit ":"",
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x20) ? "DC_36bit ":"",
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x10) ? "DC_30bit ":"",
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x08) ? "DC_Y444 ":"",
                (edid_ext[dbp+DBCVHDMI_SUPPORT] & 0x01) ? "DVI_Dual":"");
        if (edid_ext[dbp+DBCVHDMI_MAXTMDS_5MHz] > 0)
          fprintf(outfile, "Max TMDS Frequency %dMHz\n",
                  edid_ext[dbp+DBCVHDMI_MAXTMDS_5MHz]*5);
        if (edid_ext[dbp+DBCVHDMI_LATFLAGS] & 0x80)
          fprintf(outfile, "Video latency %dms, audio latency %dms\n",
                  2 * (edid_ext[dbp+DBCVHDMI_VLAT] - 1),
                  2 * (edid_ext[dbp+DBCVHDMI_ALAT] - 1));
        if (edid_ext[dbp+7] & 0x40)
          fprintf(outfile,
                  "Interlaced Video latency %dms, audio latency %dms\n",
                  2 * (edid_ext[dbp+DBCVHDMI_IVLAT] - 1),
                  2 * (edid_ext[dbp+DBCVHDMI_IALAT] - 1));
      }
      else
        fprintf(outfile, "Vendor block for %02x-%02x-%02x",
                edid_ext[dbp+DBCVND_IEEE_LO], edid_ext[dbp+DBCVND_IEEE_MID],
                edid_ext[dbp+DBCVND_IEEE_HI]);
      break;

    case DBC_TAG_SPEAKER:
      /* Speaker allocation Block */
      fprintf(outfile, "Speakers: %s%s%s%s%s%s%s\n",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x40) ? "RearCenter L/R ":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x20) ? "FrontCenter L/R ":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x10) ? "Rear Center":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x08) ? "Rear L/R ":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x04) ? "Front Center ":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x02) ? "LFE ":"",
              (edid_ext[dbp+DBCSP_ALLOC] & 0x01) ? "Front L/R ":"");
      break;

    case DBC_TAG_EXTENDED:
      switch (edid_ext[dbp + DBC_ETAG]) {
      case DBC_ETAG_VCDB:
        fprintf(outfile, "Video Capabilities:\n");
        fprintf(outfile, "  Quantization range selectable: %s\n",
                (edid_ext[dbp + VCDB_FLAGS] & 0x40) ? "unknown":"via AVI Q");
        /* PT field zero implies no data, just use IT and CE fields */
        if (VCDB_S_PT(edid_ext[dbp + VCDB_FLAGS]))
          fprintf(outfile, "  Preferred mode %s\n",
                  uscanstr[VCDB_S_PT(edid_ext[dbp + VCDB_FLAGS])]);
        fprintf(outfile, "  IT modes %s\n",
                uscanstr[VCDB_S_IT(edid_ext[dbp + VCDB_FLAGS])]);
        fprintf(outfile, "  CE modes %s\n",
                uscanstr[VCDB_S_CE(edid_ext[dbp + VCDB_FLAGS])]);
        break;

      case DBC_ETAG_COL:
        fprintf(outfile, "Colorimetry supports %s%s metadata 0x%x\n",
                (edid_ext[dbp+COL_FLAGS] & 0x02) ? "HD (YCC709) ":"",
                (edid_ext[dbp+COL_FLAGS] & 0x01) ? "SD (YCC601) ":"",
                (edid_ext[dbp+COL_META] & 0x07));
        break;

      default:
        fprintf(outfile,
                "Unknown Data block with extended tag 0x%x,  length 0x%x\n",
                edid_ext[dbc + DBC_ETAG], db_len);
      }

    default:
      fprintf(outfile, "Unknown Data Block with type tag 0x%x, length 0x%x\n",
              edid_ext[dbc+DBC_TAG_LENGTH] >> DBC_TAG_SHIFT, db_len);
      break;
    }
    dbc += db_len + 1;
  }
  for(i=0; i < n_dtd; i++) {
    /* Find 0,0 when we hit padding */
    if ((edid_ext[off_dtd + DTD_SIZE*i + DTD_PCLK_LO] == 0) &&
        (edid_ext[off_dtd + DTD_SIZE*i + DTD_PCLK_HI] == 0)) {
      fprintf(outfile, "End of DTD padding reached after %d DTDs\n", i);
      break;
    }
    show_edid_dtd(outfile, edid_ext + (off_dtd + DTD_SIZE*i));
  }
}


int edid_valid(unsigned char *edid_data)
{
  return ((edid_data[EDID_HDR+0]==0x00) && (edid_data[EDID_HDR+1]==0xff) &&
          (edid_data[EDID_HDR+2]==0xff) && (edid_data[EDID_HDR+3]==0xff) &&
          (edid_data[EDID_HDR+4]==0xff) && (edid_data[EDID_HDR+5]==0xff) &&
          (edid_data[EDID_HDR+6]==0xff) && (edid_data[EDID_HDR+7]==0x00));
}

int edid_lpcm_support(unsigned char *edid_data, int ext)
{
  unsigned char* edid_ext = edid_data + EDID_SIZE;
  int dbc;
  int off_dtd = edid_ext[CEA_DTD_OFFSET];

  /* No if no extension, which can happen for two reasons */
  /* a) ext < 1 indicates no data was read into the extension area */
  /* b) edid_data[126] < 1 indicates EDID does not use extension area */
  if ((ext < 1) || (edid_data[EDID_EXT_FLAG] < 1))
    return 0;

  /* No if extension is not CEA rev 3 */
  if (!((edid_ext[EEXT_TAG] == 0x02) && (edid_ext[EEXT_REV] == 0x03)))
    return 0;

  /* If DBC block is not empty look for audio info */
  if (off_dtd > CEA_DBC_START) {

    /* Between offset 4 and off_dtd is the Data Block Collection */
    /* There may be none, in which case off_dtd == 4             */
    dbc = CEA_DBC_START;
    while (dbc < off_dtd) {
      int db_len = edid_ext[dbc + DBC_TAG_LENGTH] & DBC_LEN_MASK;
      int dbp = dbc + 1;

      if (((edid_ext[dbc+DBC_TAG_LENGTH] >> DBC_TAG_SHIFT) == DBC_TAG_AUDIO) &&
          (((edid_ext[dbp + DBCA_FORMAT]>>3) & 0xF) == DBCA_FMT_LPCM)) {
        /* Audio Data Block, type LPCM, return bitmap of frequencies */
        return edid_ext[dbp+DBCA_RATE];
      }
      dbc += db_len + 1;
    }
    /* Get here if failed to find LPCM info in DBC block */
  }
  /* Last chance is to look for Basic Audio return bitmap for 32, 44.1, 48 */
  if (edid_ext[CEA_SUPPORT] & 0x40)
    return 0x7;

  return 0;
}


int edid_has_hdmi_info(unsigned char *edid_data, int ext)
{
  unsigned char* edid_ext = edid_data + EDID_SIZE;
  int dbc;
  int off_dtd = edid_ext[CEA_DTD_OFFSET];

  /* No if no extension, which can happen for two reasons */
  /* a) ext < 1 indicates no data was read into the extension area */
  /* b) edid_data[126] < 1 indicates EDID does not use extension area */
  if ((ext < 1) || (edid_data[EDID_EXT_FLAG] < 1))
    return 0;

  /* No if extension is not CEA rev 3 */
  if (!((edid_ext[EEXT_TAG] == 0x02) && (edid_ext[EEXT_REV] == 0x03)))
    return 0;

  /* No if block is empty */
  if (off_dtd < CEA_DBC_START)
    return 0;

  /* Between offset 4 and off_dtd is the Data Block Collection */
  /* There may be none, in which case off_dtd == 4             */
  dbc = CEA_DBC_START;
  while (dbc < off_dtd) {
    int db_len = edid_ext[dbc + DBC_TAG_LENGTH] & DBC_LEN_MASK;
    int dbp = dbc + 1;

    if ((edid_ext[dbc + DBC_TAG_LENGTH] >> DBC_TAG_SHIFT) == DBC_TAG_VENDOR) {
      /* Vendor Data Block */
      if ((edid_ext[dbp+DBCVND_IEEE_LO] == 0x03) &&
          (edid_ext[dbp+DBCVND_IEEE_MID] == 0x0C) &&
          (edid_ext[dbp+DBCVND_IEEE_HI] == 0x00))
        return 1;
      }
    dbc += db_len + 1;
  }
  return 0;
}

/* Print out an EDID */
void show_edid(FILE *outfile, unsigned char *edid_data, int ext)
{
  int i;
  int edidver = edid_data[EDID_VERSION];
  int edidrev = edid_data[EDID_REVISION];
  unsigned char* edid_ext;

  if (!edid_valid(edid_data)) {
    fprintf(outfile, "Block does not contain EDID header\n");
    return;
  }
  /* unsigned edid_data so the right shifts pull in zeros */
  fprintf(outfile, "Manufacturer ID %c%c%c, product ID 0x%x\n",
          '@' + (edid_data[EDID_MFG_EID]>>2),
          '@' + (((edid_data[EDID_MFG_EID] & 3)<<3) +
                 (edid_data[EDID_MFG_EID+1]>>5)),
          '@' + (edid_data[EDID_MFG_EID+1] & 0x1f),
          edid_data[EDID_MFG_PROD_LO] + (edid_data[EDID_MFG_PROD_HI]<<8));
  fprintf(outfile, "Manufactured wk %d of %d. Edid version %d.%d\n",
          edid_data[EDID_MFG_WEEK], 1990+edid_data[EDID_MFG_YEAR],
          edidver, edidrev);
  fprintf(outfile,
          "Input: %s, vid level %d, %s, %s %s %s %s sync, %dx%dcm, Gamma %f\n",
          (edid_data[EDID_VIDEO_IN] & 0x80) ? "digital" : "analog",
          (edid_data[EDID_VIDEO_IN]>>5) & 3,
          (edid_data[EDID_VIDEO_IN] * 0x10) ? "Blank to black" : "",
          (edid_data[EDID_VIDEO_IN] * 0x08) ? "Separate" : "",
          (edid_data[EDID_VIDEO_IN] * 0x04) ? "Composite" : "",
          (edid_data[EDID_VIDEO_IN] * 0x02) ? "On-green" : "",
          (edid_data[EDID_VIDEO_IN] * 0x01) ? "Serration V" : "",
          edid_data[EDID_MAX_HSIZE], edid_data[EDID_MAX_VSIZE],
          1.0+((float)edid_data[EDID_GAMMA]/100.0));
  fprintf(outfile, "Features: %s %s %s %s %s %s %s\n",
          (edid_data[EDID_FEATURES] & 0x80) ? "standby" : "",
          (edid_data[EDID_FEATURES] & 0x40) ? "suspend" : "",
          (edid_data[EDID_FEATURES] & 0x20) ? "active-off" : "",
          (edid_data[EDID_FEATURES] & 0x18) ? "colour" : "monochrome",
          (edid_data[EDID_FEATURES] & 0x04) ? "std-cspace" : "non-std-cspace",
          (edid_data[EDID_FEATURES] & 0x02) ? "preferred-timing" : "",
          (edid_data[EDID_FEATURES] & 0x01) ? "default-GTF" : "");

  fprintf(outfile, "Established Timing:\n");
  if (edid_data[EDID_ESTTIME1] & 0x80) fprintf(outfile, "720x400@70\n");
  if (edid_data[EDID_ESTTIME1] & 0x40) fprintf(outfile, "720x400@88\n");
  if (edid_data[EDID_ESTTIME1] & 0x20) fprintf(outfile, "640x480@60\n");
  if (edid_data[EDID_ESTTIME1] & 0x10) fprintf(outfile, "640x480@67\n");
  if (edid_data[EDID_ESTTIME1] & 0x08) fprintf(outfile, "640x480@72\n");
  if (edid_data[EDID_ESTTIME1] & 0x04) fprintf(outfile, "640x480@75\n");
  if (edid_data[EDID_ESTTIME1] & 0x02) fprintf(outfile, "800x600@56\n");
  if (edid_data[EDID_ESTTIME1] & 0x01) fprintf(outfile, "800x600@60\n");
  if (edid_data[EDID_ESTTIME2] & 0x80) fprintf(outfile, "800x600@72\n");
  if (edid_data[EDID_ESTTIME2] & 0x40) fprintf(outfile, "800x600@75\n");
  if (edid_data[EDID_ESTTIME2] & 0x20) fprintf(outfile, "832x624@75\n");
  if (edid_data[EDID_ESTTIME2] & 0x10) fprintf(outfile, "1024x768i@87\n");
  if (edid_data[EDID_ESTTIME2] & 0x08) fprintf(outfile, "1024x768@60\n");
  if (edid_data[EDID_ESTTIME2] & 0x04) fprintf(outfile, "1024x768@70\n");
  if (edid_data[EDID_ESTTIME2] & 0x02) fprintf(outfile, "1024x768@75\n");
  if (edid_data[EDID_ESTTIME2] & 0x01) fprintf(outfile, "1280x1024@75\n");
  if (edid_data[EDID_MFGTIME]  & 0x80) fprintf(outfile, "1152x870@75\n");

  fprintf(outfile, "Standard timing:\n");
  for(i=0; i < EDID_N_STDTIME; i++) {
    int hinfo = edid_data[EDID_STDTIMEH+2*i];
    int vinfo = edid_data[EDID_STDTIMEV+2*i];
    int hres, vres;

    /* 01 01 is pad by spec, but 00 00 and 20 20 are see in wild */
    if (((hinfo == 0x01) && (vinfo == 0x01)) ||
        ((hinfo == 0x00) && (vinfo == 0x00)) ||
        ((hinfo == 0x20) && (vinfo == 0x20)))
      continue;
    hres = (hinfo * 8) + 248;
    switch (vinfo >> 6) {
    case ASPECT_16_10:
      vres = (hres * 10)/16;
      break;
    case ASPECT_4_3:
      vres = (hres * 3)/4;
      break;
    case ASPECT_5_4:
      vres = (hres * 4)/5;
      break;
    case ASPECT_16_9:
      vres = (hres * 9)/16;
      break;
      /* Default will only be hit if compiler broken */
    default:
      vres = 0;
    }
    fprintf(outfile, "%d: %dx%d@%d\n", i, hres, vres, 60 + (vinfo & 0x3f));
  }

  fprintf(outfile, "Descriptor blocks:\n");
  for(i = 0; i < EDID_N_DTDS; i++) {
    show_edid_dtd(outfile, edid_data + (EDID_DTD_BASE + i * DTD_SIZE));
  }
  fprintf(outfile, "EDID contains %d extensions\n", edid_data[EDID_EXT_FLAG]);

  edid_ext = edid_data + EDID_SIZE;

  if ((ext >= 1) && (edid_data[EDID_EXT_FLAG] >= 1)) {
    if ((edid_ext[EEXT_TAG] == 0x02) && (edid_ext[EEXT_REV] == 0x03)) {
      show_cea_timing(outfile, edid_ext);
    } else {
      char *tagtype;
      switch(edid_ext[EEXT_TAG]) {
      case 0x01:
        tagtype = "LCD Timings";
        break;
      case 0x02:
        tagtype = "CEA";
        break;
      case 0x20:
        tagtype = "EDID 2.0";
        break;
      case 0x30:
        tagtype = "Color Information";
        break;
      case 0x40:
        tagtype = "DVI Feature";
        break;
      case 0x50:
        tagtype = "Touch Screen Map";
        break;
      case 0xF0:
        tagtype = "Block Map";
        break;
      case 0xFF:
        tagtype = "Manufacturer";
        break;
      default:
        tagtype = "Unknown";
      }
      fprintf(outfile, "EDID %s extension tag 0x%02x rev 0x%02x skipped\n",
              tagtype, edid_ext[EEXT_TAG], edid_ext[EEXT_REV]);
    }
  }
}


/* Pixel counts normally round to 8 */
#define CLOSE_ENOUGH(a, b) (abs((a)-(b)) < 16)

/* These match order of defines ASPECT_x_y in edid_utils.h */
char *aspect_to_str[]={"16:10","4:3","5:4","16:9"};

int find_aspect(int h, int v)
{
  if (CLOSE_ENOUGH((h * 3), (v * 4)))
    return ASPECT_4_3;
  if (CLOSE_ENOUGH((h * 4), (v * 5)))
    return ASPECT_5_4;
  if (CLOSE_ENOUGH((h * 9), (v * 16)))
    return ASPECT_16_9;
  if (CLOSE_ENOUGH((h * 10), (v * 16)))
    return ASPECT_16_10;

  return -1;
}

int find_aspect_fromisize(unsigned char *edid_data)
{
  int hsiz = edid_data[EDID_MAX_HSIZE];
  int vsiz = edid_data[EDID_MAX_VSIZE];
  int res;

  /* Zero size for projector */
  /* Only use this code if there was no preferred resolution */
  /* So assume it is an older 4:3 projector not a video one  */
  if ((hsiz == 0) && (vsiz == 0))
    return ASPECT_4_3;

  res = find_aspect(hsiz, vsiz);

  /* If things didn't work out, assume the old 4:3 case */
  if (res < 0)
    return ASPECT_4_3;
  else
    return res;
}