| // 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[128] = { |
| 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[128] = { |
| 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 |
| }; |
| |
| |
| /* Print an edid descriptor block (standard case is at 54 + 18*i) */ |
| void show_edid_dtd(FILE* outfile, unsigned char* base) |
| { |
| int pelclk = base[0] + (base[1]<<8); |
| |
| if (pelclk != 0) { |
| int hres = base[2] + ((base[4] & 0xf0)<<4); |
| int hbl = base[3] + ((base[4] & 0x0f)<<8); |
| int vres = base[5] + ((base[7] & 0xf0)<<4); |
| int vbl = base[6] + ((base[7] & 0x0f)<<8); |
| int hso = base[8] + ((base[11] & 0xc0)<<2); |
| int hsw = base[9] + ((base[11] & 0x30)<<4); |
| int vso = (base[10] >> 4) + |
| ((base[11] & 0x0c)<<2); |
| int vsw = (base[10] & 0xf) + |
| ((base[11] & 0x03)<<4); |
| int hsiz = base[12] + ((base[14] & 0xf0)<<4); |
| int vsiz = base[13] + ((base[14] & 0x0f)<<8); |
| int hbdr = base[15]; |
| int vbdr = base[16]; |
| int mdflg = base[17]; |
| |
| 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[18]; |
| int stp; |
| switch (base[3]) { |
| |
| case 0xff: |
| case 0xfe: |
| case 0xfc: |
| strncpy(monstr, (char *)base+5, 13); |
| for(stp = 0; stp < 13; stp++) if (monstr[stp] == 0x0a) monstr[stp] = 0; |
| monstr[stp] = 0; |
| if (base[3] != 0xfe) |
| fprintf(outfile, "%s: %s\n", |
| (base[3] == 0xfc) ? "Name" : "Serial", monstr); |
| else |
| fprintf(outfile, "%s\n", monstr); |
| break; |
| |
| case 0xfd: |
| fprintf(outfile, "Range V %d - %d Hz, H %d - %d kHz, Pel <= %d MHz\n", |
| base[5], base[6], base[7], base[8], base[9]*10); |
| break; |
| |
| default: |
| fprintf(outfile, "Undecoded descriptor block type 0x%x\n", base[3]); |
| 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"}; |
| |
| void show_cea_timing(FILE* outfile, unsigned char* edid_ext) |
| { |
| int i, dbc; |
| int off_dtd = edid_ext[2]; |
| int n_dtd = edid_ext[3] & 0xf; |
| fprintf(outfile, "Found CEA EDID Timing Extension rev 3\n"); |
| |
| if (off_dtd < 4) { |
| fprintf(outfile, "Block is empty (off_dtd = %d, n_dtd = %d\n", |
| off_dtd, n_dtd); |
| return; |
| } |
| fprintf(outfile, |
| "Block has %d DTDs starting at offset %d (thus %d bytes of DBCs)\n", |
| n_dtd, off_dtd, off_dtd - 4); |
| fprintf(outfile, |
| "Support: %sunderscan, %sbasic audio, %sYCrCb 4:4:4, %sYCrCb 4:2:2\n", |
| (edid_ext[3] & 0x80) ? "" : "no ", |
| (edid_ext[3] & 0x40) ? "" : "no ", |
| (edid_ext[3] & 0x20) ? "" : "no ", |
| (edid_ext[3] & 0x10) ? "" : "no "); |
| |
| /* Between offset 4 and off_dtd is the Data Block Collection */ |
| /* There may be none, in which case off_dtd == 4 */ |
| dbc = 4; |
| while (dbc < off_dtd) { |
| int db_len = edid_ext[dbc] & 0x1f; |
| int dbp = dbc + 1; |
| |
| switch (edid_ext[dbc] >> 5) { |
| |
| case 1: |
| /* Audio Data Block */ |
| while (dbp < (dbc + db_len + 1)) { |
| int atype =(edid_ext[dbp]>>3) & 0xf; |
| fprintf(outfile, "Audio: %d channel %s: ", edid_ext[dbp] & 0x7, |
| sad_audio_type[atype]); |
| dbp++; |
| if (edid_ext[dbp] & 0x40) fprintf(outfile, "192k "); |
| if (edid_ext[dbp] & 0x20) fprintf(outfile, "176k "); |
| if (edid_ext[dbp] & 0x10) fprintf(outfile, "96k "); |
| if (edid_ext[dbp] & 0x08) fprintf(outfile, "88k "); |
| if (edid_ext[dbp] & 0x04) fprintf(outfile, "48k "); |
| if (edid_ext[dbp] & 0x02) fprintf(outfile, "44k "); |
| if (edid_ext[dbp] & 0x01) fprintf(outfile, "32k "); |
| dbp++; |
| if (atype == 1) |
| fprintf(outfile, "%s%s%s\n", |
| (edid_ext[dbp] & 0x4) ? "24-bit ":"", |
| (edid_ext[dbp] & 0x2) ? "20-bit ":"", |
| (edid_ext[dbp] & 0x1) ? "16-bit":""); |
| else |
| fprintf(outfile, "Max %dkHz\n", edid_ext[dbp] * 8); |
| dbp++; |
| } |
| break; |
| |
| case 2: |
| /* Vidio Data Block */ |
| while (dbp < (dbc + db_len + 1)) { |
| int vtype = edid_ext[dbp] & 0x7f; |
| fprintf(outfile, "Video: Code %d %s\n", vtype, |
| (edid_ext[dbp] & 0x80) ? "(native)":""); |
| dbp++; |
| } |
| break; |
| |
| case 3: |
| /* Vendor Data Block */ |
| if ((edid_ext[dbp+0] == 0x03) && |
| (edid_ext[dbp+1] == 0x0C) && |
| (edid_ext[dbp+2] == 0x00)) { |
| fprintf(outfile, |
| "HDMI Vendor block (CEC @0x%04x):\nSupport: %s%s%s%s%s%s\n", |
| edid_ext[dbp+3] + (edid_ext[dbp+4]<<8), |
| (edid_ext[dbp+5] & 0x80) ? "AI ":"", |
| (edid_ext[dbp+5] & 0x40) ? "DC_48bit ":"", |
| (edid_ext[dbp+5] & 0x20) ? "DC_36bit ":"", |
| (edid_ext[dbp+5] & 0x10) ? "DC_30bit ":"", |
| (edid_ext[dbp+5] & 0x08) ? "DC_Y444 ":"", |
| (edid_ext[dbp+5] & 0x01) ? "DVI_Dual":""); |
| if (edid_ext[dbp+6] > 0) |
| fprintf(outfile, "Max TMDS Frequency %dMHz\n", edid_ext[dbp+6]*5); |
| if (edid_ext[dbp+7] & 0x80) |
| fprintf(outfile, "Video latency %dms, audio latency %dms\n", |
| 2 * (edid_ext[dbp+8] - 1), 2 * (edid_ext[dbp+9] - 1)); |
| if (edid_ext[dbp+7] & 0x40) |
| fprintf(outfile, |
| "Interlaced Video latency %dms, audio latency %dms\n", |
| 2 * (edid_ext[dbp+10] - 1), 2 * (edid_ext[dbp+11] - 1)); |
| } |
| else |
| fprintf(outfile, "Vendor block for %02x-%02x-%02x", |
| edid_ext[dbp+0], edid_ext[dbp+1], edid_ext[dbp+2]); |
| break; |
| |
| case 4: |
| /* Speaker allocation Block */ |
| fprintf(outfile, "Speakers: %s%s%s%s%s%s%s\n", |
| (edid_ext[dbp+0] & 0x40) ? "RearCenter L/R ":"", |
| (edid_ext[dbp+0] & 0x20) ? "FrontCenter L/R ":"", |
| (edid_ext[dbp+0] & 0x10) ? "Rear Center":"", |
| (edid_ext[dbp+0] & 0x08) ? "Rear L/R ":"", |
| (edid_ext[dbp+0] & 0x04) ? "Front Center ":"", |
| (edid_ext[dbp+0] & 0x02) ? "LFE ":"", |
| (edid_ext[dbp+0] & 0x01) ? "Front L/R ":""); |
| break; |
| |
| default: |
| fprintf(outfile, "Unknown Data Block with type tag 0x%x, length 0x%x\n", |
| edid_ext[dbc] >> 5, db_len); |
| break; |
| } |
| dbc += db_len + 1; |
| } |
| for(i=0; i < n_dtd; i++) |
| show_edid_dtd(outfile, edid_ext + (off_dtd + 18*i)); |
| } |
| |
| |
| int edid_valid(unsigned char *edid_data) |
| { |
| return ((edid_data[0]==0x00) && (edid_data[1]==0xff) && |
| (edid_data[2]==0xff) && (edid_data[3]==0xff) && |
| (edid_data[4]==0xff) && (edid_data[5]==0xff) && |
| (edid_data[6]==0xff) && (edid_data[7]==0x00)); |
| } |
| |
| int edid_lpcm_support(unsigned char *edid_data, int ext) |
| { |
| unsigned char* edid_ext = edid_data + 128; |
| int dbc; |
| int off_dtd = edid_ext[2]; |
| |
| /* 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[126] < 1)) |
| return 0; |
| |
| /* No if extension is not CEA rev 3 */ |
| if (!((edid_ext[0] == 0x02) && (edid_ext[1] == 0x03))) |
| return 0; |
| |
| /* No if block is empty */ |
| if (off_dtd < 4) |
| return 0; |
| |
| /* Between offset 4 and off_dtd is the Data Block Collection */ |
| /* There may be none, in which case off_dtd == 4 */ |
| dbc = 4; |
| while (dbc < off_dtd) { |
| int db_len = edid_ext[dbc] & 0x1f; |
| int dbp = dbc + 1; |
| |
| if (((edid_ext[dbc] >> 5) == 1) && |
| (((edid_ext[dbp]>>3) & 0xF) == 1)) { |
| /* Audio Data Block, type LPCM, return bitmap of frequencies */ |
| return edid_ext[dbp+1]; |
| } |
| dbc += db_len + 1; |
| } |
| return 0; |
| } |
| |
| |
| int edid_has_hdmi_info(unsigned char *edid_data, int ext) |
| { |
| unsigned char* edid_ext = edid_data + 128; |
| int dbc; |
| int off_dtd = edid_ext[2]; |
| |
| /* 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[126] < 1)) |
| return 0; |
| |
| /* No if extension is not CEA rev 3 */ |
| if (!((edid_ext[0] == 0x02) && (edid_ext[1] == 0x03))) |
| return 0; |
| |
| /* No if block is empty */ |
| if (off_dtd < 4) |
| return 0; |
| |
| /* Between offset 4 and off_dtd is the Data Block Collection */ |
| /* There may be none, in which case off_dtd == 4 */ |
| dbc = 4; |
| while (dbc < off_dtd) { |
| int db_len = edid_ext[dbc] & 0x1f; |
| int dbp = dbc + 1; |
| |
| if ((edid_ext[dbc] >> 5) == 3) { |
| /* Vendor Data Block */ |
| if ((edid_ext[dbp+0] == 0x03) && |
| (edid_ext[dbp+1] == 0x0C) && |
| (edid_ext[dbp+2] == 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[18]; |
| int edidrev = edid_data[19]; |
| 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[8]>>2), |
| '@' + ((edid_data[8] & 3)<<3) + (edid_data[9]>>5), |
| '@' + (edid_data[9] & 0x1f), |
| edid_data[10] + (edid_data[11]<<8)); |
| fprintf(outfile, "Manufactured wk %d of %d. Edid version %d.%d\n", |
| edid_data[16], 1990+edid_data[17], edidver, edidrev); |
| fprintf(outfile, |
| "Input: %s, vid level %d, %s, %s %s %s %s sync, %dx%dcm, Gamma %f\n", |
| (edid_data[20] & 0x80) ? "digital" : "analog", |
| (edid_data[20]>>5) & 3, |
| (edid_data[20] * 0x10) ? "Blank to black" : "", |
| (edid_data[20] * 0x08) ? "Separate" : "", |
| (edid_data[20] * 0x04) ? "Composite" : "", |
| (edid_data[20] * 0x02) ? "On-green" : "", |
| (edid_data[20] * 0x01) ? "Serration V" : "", |
| edid_data[21], edid_data[22], 1.0+((float)edid_data[23]/100.0)); |
| fprintf(outfile, "Features: %s %s %s %s %s %s %s\n", |
| (edid_data[24] & 0x80) ? "standby" : "", |
| (edid_data[24] & 0x40) ? "suspend" : "", |
| (edid_data[24] & 0x20) ? "active-off" : "", |
| (edid_data[24] & 0x18) ? "colour" : "monochrome", |
| (edid_data[24] & 0x04) ? "std-cspace" : "non-std-cspace", |
| (edid_data[24] & 0x02) ? "preferred-timing" : "", |
| (edid_data[24] & 0x02) ? "default-GTF" : ""); |
| |
| fprintf(outfile, "Established Timing:\n"); |
| if (edid_data[35] & 0x80) fprintf(outfile, "720x400@70\n"); |
| if (edid_data[35] & 0x40) fprintf(outfile, "720x400@88\n"); |
| if (edid_data[35] & 0x20) fprintf(outfile, "640x480@60\n"); |
| if (edid_data[35] & 0x10) fprintf(outfile, "640x480@67\n"); |
| if (edid_data[35] & 0x08) fprintf(outfile, "640x480@72\n"); |
| if (edid_data[35] & 0x04) fprintf(outfile, "640x480@75\n"); |
| if (edid_data[35] & 0x02) fprintf(outfile, "800x600@56\n"); |
| if (edid_data[35] & 0x01) fprintf(outfile, "800x600@60\n"); |
| if (edid_data[36] & 0x80) fprintf(outfile, "800x600@72\n"); |
| if (edid_data[36] & 0x40) fprintf(outfile, "800x600@75\n"); |
| if (edid_data[36] & 0x20) fprintf(outfile, "832x624@75\n"); |
| if (edid_data[36] & 0x10) fprintf(outfile, "1024x768i@87\n"); |
| if (edid_data[36] & 0x08) fprintf(outfile, "1024x768@60\n"); |
| if (edid_data[36] & 0x04) fprintf(outfile, "1024x768@70\n"); |
| if (edid_data[36] & 0x02) fprintf(outfile, "1024x768@75\n"); |
| if (edid_data[36] & 0x01) fprintf(outfile, "1280x1024@75\n"); |
| if (edid_data[36] & 0x80) fprintf(outfile, "1152x870@75\n"); |
| |
| fprintf(outfile, "Standard timing:\n"); |
| for(i=0; i < 8; i++) { |
| int hinfo = edid_data[38+2*i]; |
| int vinfo = edid_data[39+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 < 4; i++) { |
| show_edid_dtd(outfile, edid_data + (54 + i * 18)); |
| } |
| fprintf(outfile, "EDID contains %d extensions\n", edid_data[126]); |
| |
| edid_ext = edid_data + 128; |
| |
| if ((ext >= 1) && (edid_data[126] >= 1)) { |
| if ((edid_ext[0] == 0x02) && (edid_ext[1] == 0x03)) { |
| show_cea_timing(outfile, edid_ext); |
| |
| } else |
| fprintf(outfile, "EDID extension tag 0x%02x rev 0x%02x not known\n", |
| edid_data[128], edid_data[129]); |
| |
| } |
| } |
| |
| |
| /* Pixel counts normally round to 8 */ |
| #define CLOSE_ENOUGH(a, b) (abs((a)-(b)) < 16) |
| |
| 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[21]; |
| int vsiz = edid_data[22]; |
| 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; |
| } |
| |
