diff options
Diffstat (limited to 'deps/sysobj_early/src/util_edid.c')
| -rw-r--r-- | deps/sysobj_early/src/util_edid.c | 319 |
1 files changed, 319 insertions, 0 deletions
diff --git a/deps/sysobj_early/src/util_edid.c b/deps/sysobj_early/src/util_edid.c new file mode 100644 index 00000000..3f953191 --- /dev/null +++ b/deps/sysobj_early/src/util_edid.c @@ -0,0 +1,319 @@ +/* + * sysobj - https://github.com/bp0/verbose-spork + * Copyright (C) 2018 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#define _GNU_SOURCE +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <math.h> +#include <endian.h> +#include <stdio.h> +#include "util_edid.h" +#include "util_sysobj.h" +#include "gettext.h" + +/* block must be 128 bytes */ +int block_check(const void *edid_block_bytes) { + if (!edid_block_bytes) return 0; + uint8_t sum = 0; + uint8_t *data = (uint8_t*)edid_block_bytes; + int i; + for(i=0; i<128; i++) + sum += data[i]; + return sum == 0 ? 1 : 0; +} + +int edid_fill(struct edid *id_out, const void *edid_bytes, int edid_len) { + int i; + + if (!id_out) return 0; + + memset(id_out, 0, sizeof(struct edid)); + id_out->size = edid_len; + + if (edid_len >= 128) { + uint8_t *u8 = (uint8_t*)edid_bytes; + uint16_t *u16 = (uint16_t*)edid_bytes; + uint32_t *u32 = (uint32_t*)edid_bytes; + + id_out->ver_major = u8[18]; /* byte 18 */ + id_out->ver_minor = u8[19]; /* byte 19 */ + + /* checksum first block */ + id_out->checksum_ok = block_check(edid_bytes); + if (edid_len > 128) { + int blocks = edid_len / 128; + if (blocks > EDID_MAX_EXT_BLOCKS) blocks = EDID_MAX_EXT_BLOCKS; + blocks--; + id_out->ext_blocks = blocks; + for(; blocks; blocks--) { + id_out->ext[blocks-1][0] = *(u8 + (blocks * 128)); + int r = block_check(u8 + (blocks * 128)); + id_out->ext[blocks-1][1] = (uint8_t)r; + if (r) id_out->ext_blocks_ok++; + else id_out->ext_blocks_fail++; + } + } + + /* expect 1.3 */ + + uint16_t vid = be16toh(u16[4]); /* bytes 8-9 */ + id_out->ven[2] = 64 + (vid & 0x1f); + id_out->ven[1] = 64 + ((vid >> 5) & 0x1f); + id_out->ven[0] = 64 + ((vid >> 10) & 0x1f); + + id_out->product = le16toh(u16[5]); /* bytes 10-11 */ + id_out->n_serial = le32toh(u32[3]);/* bytes 12-15 */ + id_out->week = u8[16]; /* byte 16 */ + id_out->year = u8[17] + 1990; /* byte 17 */ + + if (id_out->week >= 52) + id_out->week = 0; + + id_out->a_or_d = (u8[20] & 0x80) ? 1 : 0; + if (id_out->a_or_d == 1) { + /* digital */ + switch((u8[20] >> 4) & 0x7) { + case 0x1: id_out->bpc = 6; break; + case 0x2: id_out->bpc = 8; break; + case 0x3: id_out->bpc = 10; break; + case 0x4: id_out->bpc = 12; break; + case 0x5: id_out->bpc = 14; break; + case 0x6: id_out->bpc = 16; break; + } + } + + if (u8[21] && u8[22]) { + id_out->horiz_cm = u8[21]; + id_out->vert_cm = u8[22]; + id_out->diag_cm = + sqrt( (id_out->horiz_cm * id_out->horiz_cm) + + (id_out->vert_cm * id_out->vert_cm) ); + id_out->diag_in = id_out->diag_cm / 2.54; + } + + uint16_t dh, dl; + + /* descriptor at byte 54 */ + dh = be16toh(u16[54/2]); + dl = be16toh(u16[54/2+1]); + id_out->d_type[0] = (dh << 16) + dl; + switch(id_out->d_type[0]) { + case 0xfc: case 0xff: case 0xfe: + strncpy(id_out->d_text[0], (char*)u8+54+5, 13); + } + + /* descriptor at byte 72 */ + dh = be16toh(u16[72/2]); + dl = be16toh(u16[72/2+1]); + id_out->d_type[1] = (dh << 16) + dl; + switch(id_out->d_type[1]) { + case 0xfc: case 0xff: case 0xfe: + strncpy(id_out->d_text[1], (char*)u8+72+5, 13); + } + + /* descriptor at byte 90 */ + dh = be16toh(u16[90/2]); + dl = be16toh(u16[90/2+1]); + id_out->d_type[2] = (dh << 16) + dl; + switch(id_out->d_type[2]) { + case 0xfc: case 0xff: case 0xfe: + strncpy(id_out->d_text[2], (char*)u8+90+5, 13); + } + + /* descriptor at byte 108 */ + dh = be16toh(u16[108/2]); + dl = be16toh(u16[108/2+1]); + id_out->d_type[3] = (dh << 16) + dl; + switch(id_out->d_type[3]) { + case 0xfc: case 0xff: case 0xfe: + strncpy(id_out->d_text[3], (char*)u8+108+5, 13); + } + + for(i = 0; i < 4; i++) { + g_strstrip(id_out->d_text[i]); + switch(id_out->d_type[i]) { + case 0xfc: + id_out->name = id_out->d_text[i]; + break; + case 0xff: + id_out->serial = id_out->d_text[i]; + break; + case 0xfe: + if (id_out->ut1) + id_out->ut2 = id_out->d_text[i]; + else + id_out->ut1 = id_out->d_text[i]; + break; + } + } + + if (!id_out->name) { + if (SEQ(id_out->ut1, "LG Display") && id_out->ut2) + /* LG may use "uspecified text" for name and model */ + id_out->name = id_out->ut2; + else if (SEQ(id_out->ut1, "AUO") && id_out->ut2) + /* Same with AUO */ + id_out->name = id_out->ut2; + else { + if (id_out->ut1) id_out->name = id_out->ut1; + if (id_out->ut2 && !id_out->serial) id_out->serial = id_out->ut2; + } + } + } + return 1; +} + +int edid_hex_to_bin(void **edid_bytes, int *edid_len, const char *hex_string) { + int blen = strlen(hex_string) / 2; + uint8_t *buffer = malloc(blen), *n = buffer; + memset(buffer, 0, blen); + int len = 0; + + const char *p = hex_string; + char byte[3] = ".."; + + while(p && *p) { + if (isxdigit(p[0]) && isxdigit(p[1])) { + byte[0] = p[0]; + byte[1] = p[1]; + *n = strtol(byte, NULL, 16); + n++; + len++; + p += 2; + } else + p++; + } + + *edid_bytes = (void *)buffer; + *edid_len = len; + return 1; +} + +int edid_fill_xrandr(struct edid *id_out, const char *xrandr_edid_dump) { + void *buffer = NULL; + int len = 0; + edid_hex_to_bin(&buffer, &len, xrandr_edid_dump); + return edid_fill(id_out, buffer, len); +} + +const char *edid_ext_block_type(int type) { + switch(type) { + case 0xf0: + return N_("extension block map"); + case 0x02: + return N_("EIA/CEA-861 extension block"); + } + return N_("unknown block type"); +} + +const char *edid_descriptor_type(int type) { + switch(type) { + case 0xff: + return N_("display serial number"); + case 0xfe: + return N_("unspecified text"); + case 0xfd: + return N_("display range limits"); + case 0xfc: + return N_("display name"); + case 0xfb: + return N_("additional white point"); + case 0xfa: + return N_("additional standard timing identifiers"); + case 0xf9: + return N_("Display Color Management"); + case 0xf8: + return N_("CVT 3-byte timing codes"); + case 0xf7: + return N_("additional standard timing"); + case 0x10: + return N_("dummy"); + } + if (type < 0x0f) return N_("manufacturer reserved descriptor"); + return N_("detailed timing descriptor"); +} + +char *edid_dump(struct edid *id) { + char *ret = NULL; + int i; + + if (!id) return NULL; + ret = appfnl(ret, "edid_version: %d.%d (%d bytes)", id->ver_major, id->ver_minor, id->size); + + ret = appfnl(ret, "mfg: %s, model: %u, n_serial: %u", id->ven, id->product, id->n_serial); + if (id->week && id->year) + ret = appf(ret, "", ", dom: week %d of %d", id->week, id->year); + else if (id->year) + ret = appf(ret, "", ", dom: %d", id->year); + + ret = appfnl(ret, "type: %s", id->a_or_d ? "digital" : "analog"); + if (id->bpc) + ret = appfnl(ret, "bits per color channel: %d", id->bpc); + + if (id->horiz_cm && id->vert_cm) + ret = appfnl(ret, "size: %d cm × %d cm", id->horiz_cm, id->vert_cm); + if (id->diag_cm) + ret = appfnl(ret, "diagonal: %0.2f cm (%0.2f in)", id->diag_cm, id->diag_in); + + ret = appfnl(ret, "checksum %s", id->checksum_ok ? "ok" : "failed!"); + if (id->ext_blocks_ok || id->ext_blocks_fail) + ret = appf(ret, "", ", extension blocks: %d of %d ok", id->ext_blocks_ok, id->ext_blocks_ok + id->ext_blocks_fail); + + for(i = 0; i < 4; i++) + ret = appfnl(ret, "descriptor[%d] (%s): %s", i, _(edid_descriptor_type(id->d_type[i])), *id->d_text[i] ? id->d_text[i] : "{...}"); + + for(i = 0; i < EDID_MAX_EXT_BLOCKS; i++) { + if (id->ext[i][0]) { + ret = appfnl(ret, "ext_block[%d]: (%s): %s", i, _(edid_ext_block_type(id->ext[i][0])), id->ext[i][1] ? "ok" : "fail"); + } + } + + return ret; +} + +char *edid_bin_to_hex(const void *edid_bytes, int edid_len) { + int lines = edid_len / 16; + int blen = lines * 35 + 1; + int pc = 0; + char *ret = malloc(blen); + memset(ret, 0, blen); + uint8_t *u8 = (uint8_t*)edid_bytes; + char *p = ret; + for(; lines; lines--) { + sprintf(p, "\t\t"); + p+=2; + int i; + for(i = 0; i < 16; i++) { + sprintf(p, "%02x", (unsigned int)*u8); + p+=2; + u8++; + pc++; + if (pc == blen-1) { + sprintf(p, "\n"); + goto edid_print_done; + } + } + sprintf(p, "\n"); + p++; + } +edid_print_done: + return ret; +} |