m3x1m0m
/
edid
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Cromaticity bytes are implemented

master
Maximilian Stiefel 4 years ago
parent
2df23f1f41
commit
ba6d391d8d
5 changed files with 214 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      display_stockach_i2c
  2. 69
      display_stockach_parsed
  3. 32
      edid_stockach.json
  4. BIN
      main
  5. 145
      main.c

10
display_stockach_i2c
View File

@ -0,0 +1,10 @@
maximilian@ironhero:~/ad9984a_bo$ sudo i2cdump -y -r 0-127 2 0x50 b
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 00 ff ff ff ff ff ff 00 1e 6d d5 59 04 45 09 00 ........?m?Y?E?.
10: 03 17 01 03 68 35 1e 78 ea 33 31 a4 57 51 a0 26 ????h5?x?31?WQ?&
20: 10 50 54 a7 6b 80 b3 00 81 80 95 00 71 4f a9 c0 ?PT?k??.???.qO??
30: 81 00 81 c0 90 40 02 3a 80 18 71 38 2d 40 58 2c ?.???@?:??q8-@X,
40: 45 00 09 25 21 00 00 1e 00 00 00 fd 00 38 4b 1e E.?%!..?...?.8K?
50: 53 0f 00 0a 20 20 20 20 20 20 00 00 00 fc 00 32 S?.? ...?.2
60: 34 45 4e 33 33 0a 20 20 20 20 20 20 00 00 00 ff 4EN33? ....
70: 00 33 30 33 4e 44 51 41 48 56 34 39 32 0a 00 f1 .303NDQAHV492?.?

69
display_stockach_parsed
View File

@ -0,0 +1,69 @@
maximilian@ironhero:~/ad9984a_bo$ sudo python2.7 parse_display_ddc.py
[sudo] password for maximilian:
Header:
7789
Manufacturer: GSM
Product code: 22997
Serial number: 607492
Week: 3
Year: 2013
Edid version 1, revision 3
Analog input
Levels: +.7/0]
Separate sync supported
Horizontal screen size: 53cm
Vertical screen size: 30cm
Display gamma: 2.200
DPMS standby supported
DPMS suspend supported
DPMS active-off supported
Display type (analog): RGB color
Preferred timing mode in descriptor block 1
Chromaticity coordinates: r: (0.641, 0.343), g: (0.316, 0.628), b: (0.148, 0.065), w: (0.312, 0.329)
Established timings:
720x400 @ 70 Hz (VGA)
640x480 @ 60 Hz (VGA)
640x480 @ 75 Hz
800x600 @ 56 Hz
800x600 @ 60 Hz
800x600 @ 75 Hz
832x624 @ 75 Hz (Apple Macintosh II)
1024x768 @ 60 Hz
1024x768 @ 75 Hz
1280x1024 @ 75 Hz
1152x870 @ 75 Hz (Apple Macintosh II)
Standard timing information:
X res: 1680, aspect 16:10, Y res (derived): 1050), vertical frequency: 60
X res: 1280, aspect 5:4, Y res (derived): 1024), vertical frequency: 60
X res: 1440, aspect 16:10, Y res (derived): 900), vertical frequency: 60
X res: 1152, aspect 4:3, Y res (derived): 864), vertical frequency: 75
X res: 1600, aspect 16:9, Y res (derived): 900), vertical frequency: 60
X res: 1280, aspect 16:10, Y res (derived): 800), vertical frequency: 60
X res: 1280, aspect 16:9, Y res (derived): 720), vertical frequency: 60
X res: 1400, aspect 4:3, Y res (derived): 1050), vertical frequency: 60
Descriptor 1: Detailed timing descriptor:
Pixel clock: 148500kHz
Horizontal active pixels: 1920
Horizontal blanking pixels: 280
Vertical active lines: 1080
Vertical blanking lines: 45
Horizontal front porch pixels: 88
Horizontal sync pulse pixels: 44
Vertical front porch lines: 4
Vertical sync pulse lines: 5
Horizontal image size: 521mm
Vertical image size: 293mm
Horizontal border pixels: 0
Vertical border lines: 0
Digital separate sync
VSync serration
Positive horizontal sync polarity
Descriptor 2: Display range limits
Minimum vertical field rate 56Hz
Maximum vertical field rate 75Hz
Minimum horizontal field rate 30Hz
Maximum horizontal field rate 83Hz
Maximum pixel clock rate: 150Mhz
Default GTF
Descriptor 3: Display name 24EN33
Descriptor 4: Display serial number 303NDQAHV492

32
edid_stockach.json
View File

@ -8,17 +8,19 @@
"edid_version": 1,
"edid_revision": 3
},
"video_input_parameters": {
"input_type": "analog",
"levels": {
"upper": 0.7,
"lower": 0.0
"basic_display_parameters": {
"video_input_parameters": {
"input_type": "analog",
"levels": {
"upper": 0.7,
"lower": 0.0
},
"blank_to_black": false,
"seperate_sync": true,
"composite_sync": false,
"sync_on_green": false,
"vsync_serrated": false
},
"blank_to_black": false,
"seperate_sync": true,
"composite_sync": false,
"sync_on_green": false,
"vsync_serrated": false,
"horizontal_screen_size": 53,
"vertical_screen_size": 30,
"gamma": 2.2,
@ -33,5 +35,15 @@
"preferred_timing_mode": true,
"continuous_timings": false
}
},
"chromaticity_coordinates": {
"red_x": 0.641,
"red_y": 0.343,
"green_x": 0.316,
"green_y": 0.628,
"blue_x": 0.148,
"blue_y": 0.065,
"white_x": 0.3125,
"white_y": 0.329
}
}

BIN
main
View File

Binary file not shown.

145
main.c
View File

@ -69,16 +69,16 @@ typedef struct __attribute__ (( packed )) {
* 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;
uint8_t green_x : 2;
uint8_t red_y : 2;
uint8_t red_x : 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;
uint8_t white_x : 2;
uint8_t blue_y : 2;
uint8_t blue_x : 2;
} blue_white_lsbs;
uint8_t red_x_msbs;
uint8_t red_y_msbs;
@ -88,7 +88,7 @@ typedef struct __attribute__ (( packed )) {
uint8_t blue_y_msbs;
uint8_t white_x_msbs;
uint8_t white_y_msbs;
} chromacity_cordinates;
} chromaticity_coordinates;
/*! Established timing bitmap. Supported bitmap for (formerly) very common
timing modes. 3 bytes */
struct __attribute__ (( packed )) {
@ -122,6 +122,11 @@ typedef struct __attribute__ (( packed )) {
uint8_t checksum;
} edid_t;
static int stp_round(const float in)
{
return (int)(in < 0 ? (in - 0.5) : (in + 0.5));
}
/**
* @brief test function to show buffer
*/
@ -162,13 +167,6 @@ 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)
@ -234,17 +232,21 @@ static int generate_basic_display_parameters( edid_t* edid,
if (edid && json_str) {
// Input type analog or digital
json_scanf( json_str, json_len, "{video_input_parameters: {input_type: %Q}",
json_scanf( json_str, json_len,
"{basic_display_parameters: {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: {upper: %f}}}",
"{basic_display_parameters: {video_input_parameters: \
{levels: {upper: %f}}}",
&multi_use_flt0);
json_scanf( json_str, json_len,
"{video_input_parameters: {levels: {lower: %f}}}",
"{basic_display_parameters: {video_input_parameters: \
{levels: {lower: %f}}}",
&multi_use_flt1);
if (multi_use_flt0 == 0.7f && multi_use_flt1 == -0.3f) {
multi_use_int = 0;
@ -262,31 +264,35 @@ static int generate_basic_display_parameters( edid_t* edid,
.analog.levels = 0x3 & multi_use_int;
// Blank to black
json_scanf( json_str, json_len,
"{video_input_parameters: {blank_to_black: %B}}",
"{basic_display_parameters: {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}}",
"{basic_display_parameters: {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}}",
"{basic_display_parameters: {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}}",
"{basic_display_parameters: {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}}",
"{video_input_parameters: {sync_on_green: %B}}",
&multi_use_bool);
edid->basic_display_parameters.video_input_parameters
.analog.blank_to_black = 0x1 & multi_use_bool;
@ -302,40 +308,40 @@ static int generate_basic_display_parameters( edid_t* edid,
free(multi_use_str);
// Horizontal screen size
json_scanf( json_str, json_len,
"{video_input_parameters: {horizontal_screen_size: %d}}",
"{basic_display_parameters: {horizontal_screen_size: %d}}",
&multi_use_int);
edid->basic_display_parameters
.horizontal_screen_size = multi_use_int;
// Vertical screen size
json_scanf( json_str, json_len,
"{video_input_parameters: {vertical_screen_size: %d}}",
"{basic_display_parameters: {vertical_screen_size: %d}}",
&multi_use_int);
edid->basic_display_parameters
.vertical_screen_size = multi_use_int;
// Horizontal screen size
json_scanf( json_str, json_len,
"{video_input_parameters: {gamma: %f}}",
"{basic_display_parameters: {gamma: %f}}",
&multi_use_flt0);
edid->basic_display_parameters
.gamma = (multi_use_flt0-1)*100;
// Display Power Management Signaling (DPMS)
// Standby
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {dpms: \
"{basic_display_parameters: {features: {dpms: \
{standby_supported: %B}}}}",
&multi_use_bool);
edid->basic_display_parameters
.features.dpms_standby_supported = 0x1 & multi_use_bool;
// Suspend
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {dpms: \
"{basic_display_parameters: {features: {dpms: \
{suspend_supported: %B}}}}",
&multi_use_bool);
edid->basic_display_parameters
.features.dpms_suspend_supported = 0x1 & multi_use_bool;
// Active-off
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {dpms: \
"{basic_display_parameters: {features: {dpms: \
{active_off_supported: %B}}}}",
&multi_use_bool);
edid->basic_display_parameters
@ -344,7 +350,7 @@ static int generate_basic_display_parameters( edid_t* edid,
char a_str[] = "analog";
char d_str[] = "digital";
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {display_type: %Q}}}",
"{basic_display_parameters: {features: {display_type: %Q}}}",
&multi_use_str);
// Create substrings for comparison
memcpy(a_str, multi_use_str, strlen(a_str));
@ -380,19 +386,20 @@ static int generate_basic_display_parameters( edid_t* edid,
free(multi_use_str);
// Standard sRGB
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {standard_srgb: %B}}}",
"{basic_display_parameters: {features: {standard_srgb: %B}}}",
&multi_use_bool);
edid->basic_display_parameters
.features.standard_srgb = 0x1 & multi_use_bool;
// Prefered timing mode
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {preferred_timing_mode: %B}}}",
"{basic_display_parameters: {features: \
{preferred_timing_mode: %B}}}",
&multi_use_bool);
edid->basic_display_parameters
.features.preferred_timing_mode = 0x1 & multi_use_bool;
// Continuous timings
json_scanf( json_str, json_len,
"{video_input_parameters: {features: {continuous_timings: %B}}}",
"{basic_display_parameters: {features: {continuous_timings: %B}}}",
&multi_use_bool);
edid->basic_display_parameters
.features.continuous_timings = 0x1 & multi_use_bool;
@ -403,6 +410,79 @@ static int generate_basic_display_parameters( edid_t* edid,
return 0;
}
static int generate_chromaticity_coordinates( edid_t* edid,
unsigned char* json_str,
size_t json_len)
{
float multi_use_flt;
unsigned int multi_use_int;
if (edid && json_str) {
// Red x
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {red_x: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.red_green_lsbs.red_x = 0x3 & multi_use_int;
edid->chromaticity_coordinates.red_x_msbs = 0xFF & multi_use_int >> 2;
// Red y
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {red_y: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.red_green_lsbs.red_y = 0x3 & multi_use_int;
edid->chromaticity_coordinates.red_y_msbs = 0xFF & multi_use_int >> 2;
// Green x
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {green_x: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.red_green_lsbs.green_x = 0x3 & multi_use_int;
edid->chromaticity_coordinates.green_x_msbs = 0xFF & multi_use_int >> 2;
// Green y
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {green_y: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.red_green_lsbs.green_y = 0x3 & multi_use_int;
edid->chromaticity_coordinates.green_y_msbs = 0xFF & multi_use_int >> 2;
// Blue x
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {blue_x: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.blue_white_lsbs.blue_x = 0x3 & multi_use_int;
edid->chromaticity_coordinates.blue_x_msbs = 0xFF & multi_use_int >> 2;
// Blue y
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {blue_y: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
edid->chromaticity_coordinates.blue_white_lsbs.blue_y = 0x3 & multi_use_int;
edid->chromaticity_coordinates.blue_y_msbs = 0xFF & multi_use_int >> 2;
// White x
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {white_x: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
printf("white_y>%f, %d\n", multi_use_flt, multi_use_int);
edid->chromaticity_coordinates.blue_white_lsbs.white_x = 0x3 & multi_use_int;
edid->chromaticity_coordinates.white_x_msbs = 0xFF & multi_use_int >> 2;
// White y
json_scanf( json_str, json_len,
"{chromaticity_coordinates: {white_y: %f}}",
&multi_use_flt);
multi_use_int = stp_round(1024.0f * multi_use_flt);
printf("white_y>%f, %d\n", multi_use_flt, multi_use_int);
edid->chromaticity_coordinates.blue_white_lsbs.white_y = 0x3 & multi_use_int;
edid->chromaticity_coordinates.white_y_msbs = 0xFF & multi_use_int >> 2;
} else {
printf("Error: One of either edid or json_str is NULL.\n");
return 1;
}
return 0;
}
int main(void)
{
//uint8_t edith[EDID_LENGTH];
@ -419,6 +499,7 @@ int main(void)
}
generate_header(&edith, mystr, len);
generate_basic_display_parameters(&edith, mystr, len);
generate_chromaticity_coordinates(&edith, mystr, len);
disp_buf((uint8_t*)&edith, EDID_LENGTH);
return 0;
}

Write Preview
Loading…
Cancel
Save