forked from m3x1m0m/edid
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
9.7 KiB
301 lines
9.7 KiB
4 years ago
|
#include <stdio.h>
|
||
|
#include <stdint.h>
|
||
|
#include <string.h>
|
||
|
#include <stdlib.h>
|
||
|
#include "frozen/frozen.h"
|
||
|
|
||
|
#define EDID_LENGTH 128
|
||
|
#define EDID_BYTES_OFFSET_HEADER_PREAMBLE 0
|
||
|
#define EDID_BYTES_OFFSET_HEADER_MANUFACTURER_ID 8
|
||
|
#define EDID_BYTES_OFFSET_HEADER_PRODUCT_CODE 10
|
||
|
|
||
|
|
||
|
typedef struct __attribute__ (( packed )) {
|
||
|
uint8_t resolution;
|
||
|
uint8_t image_aspect_ratio : 2;
|
||
|
uint8_t vertical_frequency : 6;
|
||
|
} standard_timing_information_t;
|
||
|
|
||
|
typedef struct __attribute__ (( packed )) {
|
||
|
/*! Header information, 20 bytes */
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint64_t preamble;
|
||
|
uint8_t manufacturer_id[2];
|
||
|
uint16_t product_code;
|
||
|
uint32_t serial_number;
|
||
|
uint8_t week_of_manufacture;
|
||
|
uint8_t year_of_manufacture;
|
||
|
uint8_t edid_version;
|
||
|
uint8_t edid_revision;
|
||
|
} header;
|
||
|
/*! Basic display parameters, 5 bytes */
|
||
|
struct __attribute__ (( packed )) {
|
||
|
union __attribute__ (( packed )) {
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t video_interface : 4;
|
||
|
uint8_t bit_depth : 3;
|
||
|
uint8_t input_type : 1; // 1 for digital
|
||
|
} digital;
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t vsync_serrated: 1;
|
||
|
uint8_t sync_on_green : 1;
|
||
|
uint8_t composite_sync: 1;
|
||
|
uint8_t seperate_sync : 1;
|
||
|
uint8_t blank_to_black: 1;
|
||
|
uint8_t levels : 2;
|
||
|
uint8_t input_type : 1; // 0 for analog
|
||
|
} analog;
|
||
|
} video_input_parameters; // 1 byte
|
||
|
uint8_t h_screen_size;
|
||
|
uint8_t v_screen_size;
|
||
|
uint8_t gamma;
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t dpms_standby : 1;
|
||
|
uint8_t dpms_suspend : 1;
|
||
|
uint8_t dpms_active_off : 1;
|
||
|
uint8_t display_type : 2;
|
||
|
uint8_t standard_srgb : 1;
|
||
|
uint8_t preferred_timing_mode : 1;
|
||
|
uint8_t continuous_timings : 1;
|
||
|
} features;
|
||
|
} basic_display_parameters;
|
||
|
/*! Chromaticity coordinates. 10-bit CIE 1931 xy coordinates for red, green,
|
||
|
* blue, and white point, 10 bytes */
|
||
|
struct __attribute__ (( packed )) {
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t red_x : 2;
|
||
|
uint8_t red_y : 2;
|
||
|
uint8_t green_x : 2;
|
||
|
uint8_t green_y : 2;
|
||
|
} red_green_lsbs;
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t blue_x : 2;
|
||
|
uint8_t blue_y : 2;
|
||
|
uint8_t white_x : 2;
|
||
|
uint8_t white_y : 2;
|
||
|
} blue_white_lsbs;
|
||
|
uint8_t red_x_msbs;
|
||
|
uint8_t red_y_msbs;
|
||
|
uint8_t green_x_msbs;
|
||
|
uint8_t green_y_msbs;
|
||
|
uint8_t blue_x_msbs;
|
||
|
uint8_t blue_y_msbs;
|
||
|
uint8_t white_x_msbs;
|
||
|
uint8_t white_y_msbs;
|
||
|
} chromacity_cordinates;
|
||
|
/*! Established timing bitmap. Supported bitmap for (formerly) very common
|
||
|
timing modes. 3 bytes */
|
||
|
struct __attribute__ (( packed )) {
|
||
|
uint8_t m720_400_70 : 1;
|
||
|
uint8_t m720_400_80 : 1;
|
||
|
uint8_t m640_480_60 : 1;
|
||
|
uint8_t m640_480_67 : 1;
|
||
|
uint8_t m640_480_72 : 1;
|
||
|
uint8_t m640_480_75 : 1;
|
||
|
uint8_t m800_600_56 : 1;
|
||
|
uint8_t m800_600_60 : 1;
|
||
|
uint8_t m800_600_72 : 1;
|
||
|
uint8_t m800_600_75 : 1;
|
||
|
uint8_t m832_624_75 : 1;
|
||
|
uint8_t m1024_768_87 : 1;
|
||
|
uint8_t m1024_768_60 : 1;
|
||
|
uint8_t m1024_768_70 : 1;
|
||
|
uint8_t m1024_768_75 : 1;
|
||
|
uint8_t m1280_1024_75: 1;
|
||
|
uint8_t m1152_870_75 : 1;
|
||
|
uint8_t reserved : 7;
|
||
|
} common_timing_modes;
|
||
|
/*! Standard timing information. Up to 8 2-byte fields describing standard
|
||
|
display modes. Unused fields are filled with 01 01 hex. 16 bytes */
|
||
|
standard_timing_information_t timings[8];
|
||
|
uint8_t descriptor_1[18];
|
||
|
uint8_t descriptor_2[18];
|
||
|
uint8_t descriptor_3[18];
|
||
|
uint8_t descriptor_4[18];
|
||
|
uint8_t number_extensions;
|
||
|
uint8_t checksum;
|
||
|
} edid_t;
|
||
|
|
||
|
/**
|
||
|
* @brief test function to show buffer
|
||
|
*/
|
||
|
static void disp_buf(uint8_t *buf, int len)
|
||
|
{
|
||
|
int i;
|
||
|
for (i = 0; i < len; i++) {
|
||
|
printf("%02x ", buf[i]);
|
||
|
if ((i + 1) % 16 == 0) {
|
||
|
printf("\n");
|
||
|
}
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
static size_t file_to_str(unsigned char** str, const char const* filename)
|
||
|
{
|
||
|
size_t length;
|
||
|
FILE * f = fopen (filename, "rb");
|
||
|
|
||
|
if (f) {
|
||
|
fseek (f, 0, SEEK_END);
|
||
|
length = ftell (f);
|
||
|
fseek (f, 0, SEEK_SET);
|
||
|
*str = (unsigned char*)malloc(length);
|
||
|
if (*str) {
|
||
|
fread (*str, 1, length, f);
|
||
|
}
|
||
|
fclose (f);
|
||
|
} else {
|
||
|
printf("File pointer is NULL..\n");
|
||
|
}
|
||
|
return length;
|
||
|
}
|
||
|
|
||
|
static void generate_preamble(edid_t* edid)
|
||
|
{
|
||
|
memset((uint8_t*)&(edid->header.preamble)+0, 0x00, 1);
|
||
|
memset((uint8_t*)&(edid->header.preamble)+1, 0xFF, 6);
|
||
|
memset((uint8_t*)&(edid->header.preamble)+7, 0x00, 1);
|
||
|
/*memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE,
|
||
|
0x00, 1);
|
||
|
memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE + 1,
|
||
|
0xFF, 6);
|
||
|
memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE + 7,
|
||
|
0x00, 1);
|
||
|
*/
|
||
|
}
|
||
|
|
||
|
static int generate_header(edid_t* edid, unsigned char* json_str, size_t json_len)
|
||
|
{
|
||
|
char* multi_use_str;
|
||
|
unsigned int multi_use_int;
|
||
|
|
||
|
if (edid && json_str) {
|
||
|
// Manufacturer ID
|
||
|
json_scanf( json_str, json_len, "{header: {manufacturer_id: %Q}",
|
||
|
&multi_use_str);
|
||
|
if (strlen(multi_use_str) == 3) {
|
||
|
multi_use_int = 0;
|
||
|
multi_use_int |=
|
||
|
((0x1F & (multi_use_str[0]-64)) << 10)| // First letter
|
||
|
((0x1F & (multi_use_str[1]-64)) << 5) | // Second letter
|
||
|
((0x1F & (multi_use_str[2]-64)) << 0); // Third letter
|
||
|
edid->header.manufacturer_id[0] = multi_use_int >> 8;
|
||
|
edid->header.manufacturer_id[1] = multi_use_int;
|
||
|
} else {
|
||
|
printf("Error: JSON file format is wrong somewhere arround manufacturer\
|
||
|
ID.\n");
|
||
|
return 1;
|
||
|
}
|
||
|
// Product code
|
||
|
json_scanf(json_str, json_len, "{header: {product_code: %d}", &multi_use_int);
|
||
|
edid->header.product_code = 0xFFFF & multi_use_int;
|
||
|
// Serial number
|
||
|
json_scanf(json_str, json_len, "{header: {serial_number: %d}", &multi_use_int);
|
||
|
edid->header.serial_number = 0xFFFFFFFF & multi_use_int;
|
||
|
// Week of manufacture
|
||
|
json_scanf( json_str, json_len, "{header: {week_of_manufacture: %d}",
|
||
|
&multi_use_int);
|
||
|
edid->header.week_of_manufacture = 0xFF & multi_use_int;
|
||
|
// Year of manufacture
|
||
|
json_scanf( json_str, json_len, "{header: {year_of_manufacture: %d}",
|
||
|
&multi_use_int);
|
||
|
edid->header.year_of_manufacture = 0xFF & (multi_use_int - 1990);
|
||
|
// EDID version
|
||
|
json_scanf(json_str, json_len, "{header: {edid_version: %d}", &multi_use_int);
|
||
|
edid->header.edid_version = 0xFF & multi_use_int;
|
||
|
// EDID revision
|
||
|
json_scanf(json_str, json_len, "{header: {edid_revision: %d}", &multi_use_int);
|
||
|
edid->header.edid_revision = 0xFF & multi_use_int;
|
||
|
} else {
|
||
|
printf("One of either edid or json_str is NULL.\n");
|
||
|
return 2;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int generate_video_input_parameters( edid_t* edid,
|
||
|
unsigned char* json_str,
|
||
|
size_t json_len)
|
||
|
{
|
||
|
char* multi_use_str;
|
||
|
unsigned int multi_use_int;
|
||
|
bool multi_use_bool;
|
||
|
|
||
|
if (edid && json_str) {
|
||
|
// Input type analog or digital
|
||
|
json_scanf( json_str, json_len, "{video_input_parameters: {input_type: %Q}",
|
||
|
&multi_use_str);
|
||
|
if (strcmp(multi_use_str, "analog") == 0) {
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.input_type = 0;
|
||
|
// Levels
|
||
|
json_scanf( json_str, json_len, "{video_input_parameters: {levels: %d}",
|
||
|
&multi_use_int);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.levels = 0x3 & multi_use_int;
|
||
|
// Blank to black
|
||
|
json_scanf( json_str, json_len,
|
||
|
"{video_input_parameters: {blank_to_black: %B}",
|
||
|
&multi_use_bool);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.blank_to_black = 0x1 & multi_use_bool;
|
||
|
// Seperate sync
|
||
|
json_scanf( json_str, json_len,
|
||
|
"{video_input_parameters: {seperate_sync: %B}",
|
||
|
&multi_use_bool);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.seperate_sync = 0x1 & multi_use_bool;
|
||
|
// Composite sync
|
||
|
json_scanf( json_str, json_len,
|
||
|
"{video_input_parameters: {composite_sync: %B}",
|
||
|
&multi_use_bool);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.composite_sync = 0x1 & multi_use_bool;
|
||
|
// Sync on green
|
||
|
json_scanf( json_str, json_len,
|
||
|
"{video_input_parameters: {sync_on_green: %B}",
|
||
|
&multi_use_bool);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.sync_on_green = 0x1 & multi_use_bool;
|
||
|
// Vsync serrated
|
||
|
json_scanf( json_str, json_len,
|
||
|
"{video_input_parameters: {blank_to_black: %B}",
|
||
|
&multi_use_bool);
|
||
|
edid->basic_display_parameters.video_input_parameters
|
||
|
.analog.blank_to_black = 0x1 & multi_use_bool;
|
||
|
} else if (strcmp(multi_use_str, "digital") == 0) {
|
||
|
printf("Digital video configuration is not yet supported.\n");
|
||
|
return 1;
|
||
|
} else {
|
||
|
printf("Error: JSON file format is wrong somewhere around\
|
||
|
the video input params.\n");
|
||
|
return 2;
|
||
|
}
|
||
|
} else {
|
||
|
printf("One of either edid or json_str is NULL.\n");
|
||
|
return 3;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int main(void)
|
||
|
{
|
||
|
//uint8_t edith[EDID_LENGTH];
|
||
|
edid_t edith;
|
||
|
memset(&edith, 0x00, sizeof(edith));
|
||
|
printf("size> %d bytes\n", sizeof(edith));
|
||
|
generate_preamble(&edith);
|
||
|
unsigned char* mystr = NULL;
|
||
|
size_t len = file_to_str(&mystr, "edid.json");
|
||
|
if (mystr) {
|
||
|
printf("%s\n", mystr);
|
||
|
printf("len> %d\n", len);
|
||
|
//free(mystr);
|
||
|
}
|
||
|
generate_header(&edith, mystr, len);
|
||
|
generate_video_input_parameters(&edith, mystr, len);
|
||
|
disp_buf((uint8_t*)&edith, EDID_LENGTH);
|
||
|
return 0;
|
||
|
}
|