1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: typedef uint16 EISAId < read = EISAIdToString , write = StringToEISAId > ; 
17: 
18: string EISAIdToString ( EISAId x ) 
19: { 
20: uint16 sw = SwapBytes ( x ) ; 
21: string s ; 
22: SPrintf ( s , "%c%c%c" , '@' + ( sw >> 10 & 0x1F ) , '@' + ( sw >> 5 & 0x1F ) , '@' + ( sw >> 0 & 0x1F ) ) ; 
23: return s ; 
24: } 
25: 
26: void StringToEISAId ( EISAId & x , string s ) 
27: { 
28: char c [ 3 ] ; 
29: SScan ( s , "%c%c%c" , c [ 0 ] , c [ 1 ] , c2 [ 2 ] ) ; 
30: x = ( c [ 0 ] - '@' ) << 10 | ( c [ 1 ] - '@' ) << 5 | ( c [ 2 ] - '@' ) << 0 ; 
31: x = SwapBytes ( x ) ; 
32: } 
33: 
34: 
35: 
36: typedef struct 
37: { 
38: ubyte x_resolution ; 
39: ubyte vFrequency : 6 ; 
40: ubyte pixelRatio : 2 ; 
41: } Timing < read = TimingToString > ; 
42: 
43: string TimingToString ( Timing & t ) 
44: { 
45: if ( t . x_resolution == 1 && t . vFrequency == 1 && t . pixelRatio == 0 ) return "-" ; 
46: int x = ( t . x_resolution + 31 ) * 8 ; 
47: int y ; 
48: switch ( t . pixelRatio ) 
49: { 
50: case 0 : y = x * 10 / 16 ; break ; 
51: case 1 : y = x * 3 / 4 ; break ; 
52: case 2 : y = x * 4 / 5 ; break ; 
53: case 3 : y = x * 9 / 16 ; break ; 
54: } 
55: string s ; 
56: SPrintf ( s , "%ux%u, %uHz" , x , y , t . vFrequency + 60 ) ; 
57: return s ; 
58: } 
59: 
60: 
61: 
62: enum < ubyte > DescriptorType 
63: { 
64: TIMINGS = 0xFA , 
65: WHITE_POINT = 0xFB , 
66: MONITOR_NAME = 0xFC , 
67: RANGE_LIMITS = 0xFD , 
68: UNSPECIFIED_TEXT = 0xFE , 
69: SERIAL_NUMBER = 0xFF , 
70: } ; 
71: 
72: 
73: 
74: enum < ubyte > FormatCode 
75: { 
76: RESERVED = 0 , 
77: LPCM = 1 , 
78: AC_3 = 2 , 
79: MPEG1 = 3 , 
80: MP3 = 4 , 
81: MPEG2 = 5 , 
82: AAC = 6 , 
83: DTS = 7 , 
84: ATRAC = 8 , 
85: SACD = 9 , 
86: DD_PLUS = 10 , 
87: DTS_HD = 11 , 
88: MLP_TRUEHD = 12 , 
89: DST = 13 , 
90: WMA_PRO = 14 , 
91: RESERVED2 = 15 , 
92: } ; 
93: 
94: 
95: 
96: enum < ubyte > BlockType 
97: { 
98: AUDIO = 1 , 
99: VIDEO = 2 , 
100: VENDOR_SPECIFIC = 3 , 
101: SPEAKER = 4 , 
102: } ; 
103: 
104: 
105: 
106: enum < ubyte > SVDIndex 
107: { 
108: _DMT0659 = 1 , 
109: _480p = 2 , 
110: _480pH = 3 , 
111: _720p = 4 , 
112: _1080i = 5 , 
113: _480i = 6 , 
114: _480iH = 7 , 
115: _240p = 8 , 
116: _240pH = 9 , 
117: _480i4x = 10 , 
118: _480i4xH = 11 , 
119: _240p4x = 12 , 
120: _240p4xH = 13 , 
121: _480p2x = 14 , 
122: _480p2xH = 15 , 
123: _1080p = 16 , 
124: _576p = 17 , 
125: _576pH = 18 , 
126: _720p50 = 19 , 
127: _1080i25 = 20 , 
128: _576i = 21 , 
129: _576iH = 22 , 
130: _288p = 23 , 
131: _288pH = 24 , 
132: _576i4x = 25 , 
133: _576i4xH = 26 , 
134: _288p4x = 27 , 
135: _288p4xH = 28 , 
136: _576p2x = 29 , 
137: _576p2xH = 30 , 
138: _1080p50 = 31 , 
139: _1080p24 = 32 , 
140: _1080p25 = 33 , 
141: _1080p30 = 34 , 
142: _480p4x = 35 , 
143: _480p4xH = 36 , 
144: _576p4x = 37 , 
145: _576p4xH = 38 , 
146: _1080i25b = 39 , 
147: _1080i50 = 40 , 
148: _720p100 = 41 , 
149: _576p100 = 42 , 
150: _576p100H = 43 , 
151: _576i50 = 44 , 
152: _576i50H = 45 , 
153: _1080i60 = 46 , 
154: _720p120 = 47 , 
155: _480p119 = 48 , 
156: _480p119H = 49 , 
157: _480i59 = 50 , 
158: _480i59H = 51 , 
159: _576p200 = 52 , 
160: _576p200H = 53 , 
161: _576i100 = 54 , 
162: _576i100H = 55 , 
163: _480p239 = 56 , 
164: _480p239H = 57 , 
165: _480i119 = 58 , 
166: _480i119H = 59 , 
167: _720p24 = 60 , 
168: _720p25 = 61 , 
169: _720p30 = 62 , 
170: _1080p120 = 63 , 
171: } ; 
172: 
173: typedef struct 
174: { 
175: SVDIndex index : 7 < comment = "index value to a table of standard resolutions/timings from CEA/EIA-861E" > ; 
176: ubyte native : 1 < comment = "1 to designate that this should be considered a \"native\" resolution, 0 for non-native" > ; 
177: } SVD < read = SVDToString , comment = "Short Video Descriptor" > ; 
178: 
179: string SVDToString ( SVD & svd ) 
180: { 
181: string s ; 
182: SPrintf ( s , "%s%s (%u)" , ( svd . native ? "*" : "" ) , EnumToString ( svd . index ) , svd . index ) ; 
183: return s ; 
184: } 
185: 
186: 
187: 
188: string SPAToString ( uint16 spa ) 
189: { 
190: string s ; 
191: SPrintf ( s , "%u.%u.%u.%u" , spa >> 4 & 15 , spa >> 0 & 15 , spa >> 12 & 15 , spa >> 8 & 15 ) ; 
192: return s ; 
193: } 
194: 
195: 
196: 
197: string TDMSFreqToString ( ubyte f ) 
198: { 
199: string s ; 
200: SPrintf ( s , "%u MHz" , ( uint ) f * 5 ) ; 
201: return s ; 
202: } 
203: 
204: 
205: 
206: string PixelClockToString ( uint16 f ) 
207: { 
208: string s ; 
209: SPrintf ( s , "%.2lf MHz" , ( double ) f / 100 ) ; 
210: return s ; 
211: } 
212: 
213: void StringToPixelClock ( uint16 & f , string s ) 
214: { 
215: f = Atof ( s ) * 100 ; 
216: } 
217: 
218: 
219: 
220: typedef ubyte PixelRate < read = PixelRateToString , write = StringToPixelRate > ; 
221: 
222: string PixelRateToString ( PixelRate f ) 
223: { 
224: string s ; 
225: SPrintf ( s , "%u MHz" , ( uint ) f * 10 ) ; 
226: return s ; 
227: } 
228: 
229: void StringToPixelRate ( PixelRate & f , string s ) 
230: { 
231: f = Atof ( s ) / 10 ; 
232: } 
233: 
234: 
235: 
236: typedef ubyte BitRate < read = BitRateToString , write = StringToBitRate , comment = "maximum supported bitrate divided by 8 kbit/s" > ; 
237: 
238: string BitRateToString ( BitRate b ) 
239: { 
240: string s ; 
241: SPrintf ( s , "%u kHz" , ( uint ) b * 8 ) ; 
242: return s ; 
243: } 
244: 
245: void StringToBitRate ( BitRate & b , string s ) 
246: { 
247: b = Atof ( s ) / 8 ; 
248: } 
249: 
250: 
251: 
252: typedef ubyte Latency < read = LatencyToString , write = StringToLatency , comment = "Latency (value=1+ms/2 with a max of 251 meaning 500ms)" > ; 
253: 
254: string LatencyToString ( Latency l ) 
255: { 
256: if ( l == 0 ) return "-" ; 
257: string s ; 
258: SPrintf ( s , "%u ms" , ( ( uint ) l - 1 ) * 2 ) ; 
259: return s ; 
260: } 
261: 
262: void StringToLatency ( Latency & l , string s ) 
263: { 
264: if ( s == "-" ) l = 0 ; else l = ( uint ) ( Atof ( s ) / 2 ) + 1 ; 
265: } 
266: 
267: 
268: 
269: typedef struct 
270: { 
271: ubyte size : 5 < comment = "Total number of bytes in this block following this byte" > ; 
272: BlockType typeTag : 3 < comment = "Block Type Tag (1 is audio, 2 is video, 3 is vendor specific, 4 is speaker allocation, all other values Reserved)" > ; 
273: 
274: 
275: switch ( typeTag ) 
276: { 
277: case AUDIO : 
278: { 
279: ubyte channelCount : 3 < comment = "number of channels minus 1" > ; 
280: FormatCode formatCode : 4 < comment = "Audio format code" > ; 
281: ubyte reserved1 : 1 ; 
282: struct SampleRates 
283: { 
284: ubyte _32kHz : 1 ; 
285: ubyte _44kHz : 1 ; 
286: ubyte _48kHz : 1 ; 
287: ubyte _88kHz : 1 ; 
288: ubyte _96kHz : 1 ; 
289: ubyte _176kHz : 1 ; 
290: ubyte _192kHz : 1 ; 
291: ubyte reserved : 1 ; 
292: } sampleRates < comment = "sampling frequencies supported" > ; 
293: if ( formatCode == 1 ) 
294: { 
295: ubyte _16bits : 1 ; 
296: ubyte _20bits : 1 ; 
297: ubyte _24bits : 1 ; 
298: ubyte reserved : 5 ; 
299: } 
300: else 
301: { 
302: BitRate bitrate ; 
303: } 
304: break ; 
305: } 
306: 
307: case VIDEO : 
308: { 
309: SVD svds [ size ] < bgcolor = cLtGreen , comment = "Short Video Descriptors" > ; 
310: break ; 
311: } 
312: 
313: case VENDOR_SPECIFIC : 
314: { 
315: ubyte oui [ 3 ] < format = hex , comment = "IEEE Registration Identifier" > ; 
316: uint16 spa < read = SPAToString , comment = "Source Physical Address" > ; 
317: if ( size >= 3 ) 
318: { 
319: ubyte DVI_Dual : 1 < comment = "sink supports DVI Dual Link Operation" > ; 
320: ubyte reserved : 1 ; 
321: ubyte reserved : 1 ; 
322: ubyte dc_Y444 : 1 < comment = "sink supports 4:4:4 in deep color modes" > ; 
323: ubyte dc_30bit : 1 < comment = "sink supports 10-bit-per-channel deep color" > ; 
324: ubyte dc_36bit : 1 < comment = "sink supports 12-bit-per-channel deep color" > ; 
325: ubyte dc_48bit : 1 < comment = "sink supports 16-bit-per-channel deep color" > ; 
326: ubyte supports_AI : 1 < comment = "sink supports a function that needs info from ACP or ISRC packets" > ; 
327: } 
328: if ( size >= 4 ) 
329: ubyte max_TMDS_Frequency < read = TDMSFreqToString , comment = "Maximum TMDS frequency" > ; 
330: if ( size >= 5 ) 
331: { 
332: ubyte reserved : 6 ; 
333: ubyte i_latency_fields : 1 < comment = "set if interlaced latency fields are present; if set four latency fields will be present" > ; 
334: ubyte latency_fields : 1 < comment = "set if latency fields are present" > ; 
335: if ( latency_fields ) 
336: { 
337: Latency videoLatency < comment = "Video Latency (value=1+ms/2 with a max of 251 meaning 500ms)" > ; 
338: Latency audioLatency < comment = "Audio Latency (value=1+ms/2 with a max of 251 meaning 500ms)" > ; 
339: } 
340: if ( i_latency_fields ) 
341: { 
342: Latency interlacedVideoLatency < comment = "Interlaced Video Latency (value=1+ms/2 with a max of 251 meaning 500ms)" > ; 
343: Latency interlacedAudioLatency < comment = "Interlaced Audio Latency (value=1+ms/2 with a max of 251 meaning 500ms)" > ; 
344: } 
345: } 
346: break ; 
347: } 
348: 
349: case SPEAKER : 
350: { 
351: ubyte frontLeftRight : 1 < comment = "Front Left / Front Right present for 1, absent for 0" > ; 
352: ubyte LFE : 1 < comment = "LFE present for 1, absent for 0" > ; 
353: ubyte frontCenter : 1 < comment = "Front Center present for 1, absent for 0" > ; 
354: ubyte rearLeftRight : 1 < comment = "Rear Left / Rear Right present for 1, absent for 0" > ; 
355: ubyte rearCenter : 1 < comment = "Rear Center present for 1, absent for 0" > ; 
356: ubyte frontLeftRightCenter : 1 < comment = "Front Left Center / Front Right Center present for 1, absent for 0" > ; 
357: ubyte rearLeftRightCenter : 1 < comment = "Rear Left Center / Rear Right Center present for 1, absent for 0" > ; 
358: ubyte reserved : 1 ; 
359: ubyte reserved [ 2 ] ; 
360: break ; 
361: } 
362: } 
363: 
364: 
365: 
366: 
367: 
368: 
369: 
370: 
371: 
372: } DataBlock < size = DataBlockSize , optimize = false , open = true , comment = "Data block" > ; 
373: 
374: int DataBlockSize ( DataBlock & b ) 
375: { 
376: return ( ReadUByte ( startof ( b ) ) & 0x1F ) ; 
377: } 
378: 
379: 
380: 
381: typedef struct 
382: { 
383: uint16 pixelClock < read = PixelClockToString , write = StringToPixelClock , comment = "Pixel clock in 10 kHz units. (0.01-655.35 MHz, little-endian)" > ; 
384: 
385: ubyte hActive_lsb < comment = "Horizontal active pixels 8 lsbits (0-4095)" > ; 
386: ubyte hBlanking_lsb < comment = "Horizontal blanking pixels 8 lsbits (0-4095) End of active to start of next active." > ; 
387: ubyte hBlanking_msb : 4 < comment = "Horizontal blanking pixels 4 msbits" > ; 
388: ubyte hActive_msb : 4 < comment = "Horizontal active pixels 4 msbits" > ; 
389: ubyte vActive_lsb < comment = "Vertical active lines 8 lsbits (0-4095)" > ; 
390: ubyte vBlanking_lsb < comment = "Vertical blanking lines 8 lsbits (0-4095)" > ; 
391: ubyte vBlanking_msb : 4 < comment = "Vertical blanking lines 4 msbits" > ; 
392: ubyte vActive_msb : 4 < comment = "Vertical active lines 4 msbits" > ; 
393: ubyte hSyncOffset_lsb < comment = "Horizontal sync offset pixels 8 lsbits (0-1023) From blanking start" > ; 
394: ubyte hSync_lsb < comment = "Horizontal sync pulse width pixels 8 lsbits (0-1023)" > ; 
395: ubyte vSync_lsb : 4 < comment = "Vertical sync pulse width lines 4 lsbits (0-63)" > ; 
396: ubyte vSyncOffset_lsb : 4 < comment = "Vertical sync offset lines 4 lsbits (0-63)" > ; 
397: ubyte vSync_msb : 2 < comment = "Vertical sync pulse width lines 2 msbits" > ; 
398: ubyte vSyncOffset_msb : 2 < comment = "Vertical sync offset lines 2 msbits" > ; 
399: ubyte hSync_msb : 2 < comment = "Horizontal sync pulse width pixels 2 msbits" > ; 
400: ubyte hSyncOffset_msb : 2 < comment = "Horizontal sync offset pixels 2 msbits" > ; 
401: ubyte hSize_lsb < comment = "Horizontal display size, mm, 8 lsbits (0-4095 mm, 161 in)" > ; 
402: ubyte vSize_lsb < comment = "Vertical display size, mm, 8 lsbits (0-4095 mm, 161 in)" > ; 
403: ubyte vSize_msb : 4 < comment = "Vertical display size, mm, 4 msbits" > ; 
404: ubyte hSize_msb : 4 < comment = "Horizontal display size, mm, 4 msbits" > ; 
405: ubyte hBorder < comment = "Horizontal border pixels (each side; total is twice this)" > ; 
406: ubyte vBorder < comment = "Vertical border lines (each side; total is twice this)" > ; 
407: 
408: ubyte _f0 : 1 < comment = "2-way line-interleaved stereo, if bits 4-3 are not 00." > ; 
409: ubyte _f1 : 1 < comment = "If analog sync: Sync on all 3 RGB lines (else green only). Digital: HSync polarity (1=positive)" > ; 
410: ubyte _f2 : 1 < comment = "If digital separate: Vertical sync polarity (1=positive). Other types: VSync serrated (HSync during VSync)" > ; 
411: ubyte _f34 : 2 < comment = "Sync type: 00=Analog composite; 01=Bipolar analog composite; 10=Digital composite (on HSync); 11=Digital separate" > ; 
412: ubyte _f56 : 2 < comment = "Stereo mode: 00=No stereo; other values depend on bit 0: Bit 0=0: 01=Field sequential, sync=1 during right; 10=similar, sync=1 during left; 11=4-way interleaved stereo. Bit 0=1 2-way interleaved stereo: 01=Right image on even lines; 10=Left image on even lines; 11=side-by-side" > ; 
413: ubyte interlaced : 1 < comment = "Interlaced" > ; 
414: 
415: 
416: 
417: } ModeLine < read = ModeLineToString , write = StringToModeLine , comment = "Xfree86 modeline" > ; 
418: 
419: string ModeLineToString ( ModeLine & n ) 
420: { 
421: uint hActive = ( uint ) n . hActive_msb << 8 | n . hActive_lsb ; 
422: uint hSyncOffset = ( uint ) n . hSyncOffset_msb << 8 | n . hSyncOffset_lsb ; 
423: uint hSync = ( uint ) n . hSync_msb << 8 | n . hSync_lsb ; 
424: uint hBlanking = ( uint ) n . hBlanking_msb << 8 | n . hBlanking_lsb ; 
425: 
426: uint vActive = ( uint ) n . vActive_msb << 8 | n . vActive_lsb ; 
427: uint vSyncOffset = ( uint ) n . vSyncOffset_msb << 8 | n . vSyncOffset_lsb ; 
428: uint vSync = ( uint ) n . vSync_msb << 8 | n . vSync_lsb ; 
429: uint vBlanking = ( uint ) n . vBlanking_msb << 8 | n . vBlanking_lsb ; 
430: 
431: uint im = n . interlaced ? 2 : 1 ; 
432: string s ; 
433: SPrintf ( s , "Modeline \"%ux%u\"   %.2lf   %4u %4u %4u %4u   %4u %4u %4u %4u  %chsync %cvsync %s  ; %u %u" , 
434: hActive , vActive * im , ( double ) n . pixelClock / 100 , 
435: hActive , hActive + hSyncOffset , hActive + hSyncOffset + hSync , hActive + hBlanking , 
436: vActive * im , ( vActive + vSyncOffset ) * im , ( vActive + vSyncOffset + vSync ) * im , ( vActive + vBlanking ) * im , 
437: n . _f1 ? '+' : '-' , n . _f2 ? '+' : '-' , 
438: n . interlaced ? "Interlace" : "" , 
439: n . hBorder , n . vBorder 
440: ) ; 
441: return s ; 
442: } 
443: 
444: void StringToModeLine ( ModeLine & n , string s ) 
445: { 
446: uint dummy ; 
447: uint hActive , hActive_hSyncOffset , hActive_hSyncOffset_hSync , hActive_hBlanking ; 
448: uint vActive , vActive_vSyncOffset , vActive_vSyncOffset_vSync , vActive_vBlanking ; 
449: char hsync , vsync ; 
450: string interlaced ; 
451: double f ; 
452: SScanf ( s , "Modeline \"%ux%u\"   %lf   %u %u %u %u   %u %u %u %u  %chsync %cvsync %[^0-9;]" , 
453: dummy , dummy , f , 
454: hActive , hActive_hSyncOffset , hActive_hSyncOffset_hSync , hActive_hBlanking , 
455: vActive , vActive_vSyncOffset , vActive_vSyncOffset_vSync , vActive_vBlanking , 
456: hsync , vsync , 
457: interlaced 
458: ) ; 
459: int p = Strchr ( s , ';' ) ; 
460: if ( p >= 0 ) SScanf ( SubStr ( s , p ) , "; %u %u" , n . hBorder , n . vBorder ) ; 
461: 
462: n . interlaced = ( interlaced [ 0 ] == 'I' ) ; 
463: uint im = n . interlaced ? 2 : 1 ; 
464: 
465: uint hBlanking = hActive_hBlanking - hActive ; 
466: uint hSync = hActive_hSyncOffset_hSync - hActive_hSyncOffset ; 
467: uint hSyncOffset = hActive_hSyncOffset - hActive ; 
468: n . hActive_msb = hActive >> 8 ; n . hActive_lsb = ( ubyte ) hActive ; 
469: n . hSyncOffset_msb = hSyncOffset >> 8 ; n . hSyncOffset_lsb = ( ubyte ) hSyncOffset ; 
470: n . hSync_msb = hSync >> 8 ; n . hSync_lsb = ( ubyte ) hSync ; 
471: n . hBlanking_msb = hBlanking >> 8 ; n . hBlanking_lsb = ( ubyte ) hBlanking ; 
472: 
473: uint vBlanking = ( vActive_vBlanking - vActive ) / im ; 
474: uint vSync = ( vActive_vSyncOffset_vSync - vActive_vSyncOffset ) / im ; 
475: uint vSyncOffset = ( vActive_vSyncOffset - vActive ) / im ; 
476: vActive /= im ; 
477: n . vActive_msb = vActive >> 8 ; n . vActive_lsb = ( ubyte ) vActive ; 
478: n . vSyncOffset_msb = vSyncOffset >> 8 ; n . vSyncOffset_lsb = ( ubyte ) vSyncOffset ; 
479: n . vSync_msb = vSync >> 8 ; n . vSync_lsb = ( ubyte ) vSync ; 
480: n . vBlanking_msb = vBlanking >> 8 ; n . vBlanking_lsb = ( ubyte ) vBlanking ; 
481: 
482: n . _f1 = hsync == '+' ? 1 : 0 ; 
483: n . _f2 = vsync == '+' ? 1 : 0 ; 
484: n . pixelClock = f * 100 ; 
485: } 
486: 
487: 
488: 
489: struct File 
490: { 
491: struct Header 
492: { 
493: ubyte pattern [ 8 ] < format = hex , comment = "Fixed header pattern: 00 FF FF FF FF FF FF 00" > ; 
494: EISAId eisaId < comment = "EISA ID. Encoded as 3 5-bit letters (1=A, 26=Z), big-endian, with msbit reserved." > ; 
495: uint16 mfgProductId < comment = "Manufacturer product code. 16-bit number, little-endian." > ; 
496: uint32 serial < comment = "Serial number. 32 bits, little endian." > ; 
497: ubyte mfgWeek < comment = "Week of manufacture. Week numbering is not consistent between manufacturers." > ; 
498: ubyte mfgYear < comment = "Year of manufacture, less 1990. (1990-2245). If week=255, it is the model year instead." > ; 
499: ubyte edidVersion < comment = "EDID version, usually 1 (for 1.3)" > ; 
500: ubyte edidRevision < comment = "EDID revision, usually 3 (for 1.3)" > ; 
501: } header < open = false , comment = "Header information" > ; 
502: 
503: struct Basic 
504: { 
505: union Bitmap 
506: { 
507: ubyte hmz ; 
508: if ( hmz & 0x80 ) 
509: { 
510: struct Digital 
511: { 
512: ubyte vesa : 1 < comment = "Signal is compatible with VESA DFP 1.x TMDS CRGB, 1 pixel per clock, up to 8 bits per color, MSB aligned," > ; 
513: ubyte reserved : 6 < comment = "Reserved, must be 0" > ; 
514: ubyte digital : 1 < comment = "1=Digital input" > ; 
515: } digital ; 
516: } 
517: else 
518: { 
519: struct Analog 
520: { 
521: ubyte vSeparate : 1 < comment = "VSync pulse must be separated when composite or sync-on-green is used" > ; 
522: ubyte syncOnGreen : 1 < comment = "Sync on green supported" > ; 
523: 
524: ubyte compositeSync : 1 < comment = "Composite sync (on HSync) supported" > ; 
525: ubyte separateSync : 1 < comment = "Separate sync supported" > ; 
526: ubyte blankToBlack : 1 < comment = "Blank-to-black setup (pedestal) expected" > ; 
527: ubyte level : 2 < comment = "Video white and sync levels, relative to blank: 00=+0.7/0.3 V; 01=+0.714/0.286 V; 10=+1.0/0.4 V; 11=+0.7/0 V" > ; 
528: ubyte analog : 1 < comment = "0=Analog input" > ; 
529: } analog ; 
530: } 
531: } bitmap < comment = "Video input parameters bitmap" > ; 
532: 
533: ubyte width < comment = "Maximum horizontal image size, in centimetres (max 292 cm/115 in at 16:9 aspect ratio)" > ; 
534: ubyte height < comment = "Maximum vertical image size, in centimetres. If either byte is 0, undefined (e.g. projector)" > ; 
535: ubyte gamma < comment = "Display gamma, minus 1, times 100 (range 1.00-3.54)" > ; 
536: 
537: struct Features 
538: { 
539: ubyte gtf : 1 < comment = "GTF supported with default parameter values." > ; 
540: ubyte prefTimingDesc1 : 1 < comment = "Preferred timing mode specified in descriptor block 1." > ; 
541: ubyte sRGB : 1 < comment = "Standard sRGB colour space. Bytes 25-34 must contain sRGB standard values." > ; 
542: if ( bitmap . hmz & 0x80 ) 
543: ubyte displayType : 2 < comment = "Display type (digital): 00 = RGB 4:4:4; 01 = RGB 4:4:4 + YCrCb 4:4:4; 10 = RGB 4:4:4 + YCrCb 4:2:2; 11 = RGB 4:4:4 + YCrCb 4:4:4 + YCrCb 4:2:2" > ; 
544: else 
545: ubyte displayType : 2 < comment = "Display type (analog): 00 = Monochrome or Grayscale; 01 = RGB color; 10 = Non-RGB color; 11 = Undefined" > ; 
546: ubyte dpmsActiveOff : 1 < comment = "DPMS active-off supported" > ; 
547: ubyte dpmsSusepend : 1 < comment = "DPMS suspend supported" > ; 
548: ubyte dpmsStandby : 1 < comment = "DPMS standby supported" > ; 
549: } features < comment = "Supported features bitmap" > ; 
550: } basic < open = false , comment = "Basic display parameters" > ; 
551: 
552: struct Chromaticity 
553: { 
554: ubyte green_y_lsb : 2 < comment = "Green y value least-significant 2 bits" > ; 
555: ubyte green_x_lsb : 2 < comment = "Green x value least-significant 2 bits" > ; 
556: ubyte red_y_lsb : 2 < comment = "Red y value least-significant 2 bits" > ; 
557: ubyte red_x_lsb : 2 < comment = "Red x value least-significant 2 bits" > ; 
558: ubyte bluewhite_lsb : 2 < comment = "Blue and white least-significant 2 bits" > ; 
559: ubyte zero : 6 ; 
560: ubyte red_x_msb < comment = "Red x value most significant 8 bits. 0-255 encodes 0-0.996 (255/256); 0-0.999 (1023/1024) with lsbits" > ; 
561: ubyte red_y_msb < comment = "Red y value most significant 8 bits" > ; 
562: ubyte green_x_msb < comment = "Green x value most significant 8 bits" > ; 
563: ubyte green_y_msb < comment = "Green y value most significant 8 bits" > ; 
564: ubyte blue_x_msb < comment = "Blue x value most significant 8 bits" > ; 
565: ubyte blue_y_msb < comment = "Blue y value most significant 8 bits" > ; 
566: ubyte white_x_msb < comment = "Default white point x value most significant 8 bits" > ; 
567: ubyte white_y_msb < comment = "Default white point y value most significant 8 bits" > ; 
568: } chromaticity < bgcolor = cLtAqua , comment = "Chromaticity coordinates. 10-bit CIE xy coordinates for red, green, blue, and white. [0-1023/1024]." > ; 
569: 
570: struct Timings 
571: { 
572: ubyte _800x600_60 : 1 ; 
573: ubyte _800x600_56 : 1 ; 
574: ubyte _640x480_75 : 1 ; 
575: ubyte _640x480_72 : 1 ; 
576: ubyte _640x480_67 : 1 ; 
577: ubyte _640x480_60 : 1 ; 
578: ubyte _720x400_88 : 1 ; 
579: ubyte _720x400_70 : 1 ; 
580: ubyte _1280x1024_75 : 1 ; 
581: ubyte _1024x768_75 : 1 ; 
582: ubyte _1024x768_72 : 1 ; 
583: ubyte _1024x768_60 : 1 ; 
584: ubyte _1024x768i_87 : 1 ; 
585: ubyte _832x624_75 : 1 ; 
586: ubyte _800x600_75 : 1 ; 
587: ubyte _800x600_72 : 1 ; 
588: ubyte mfgSpecific : 7 ; 
589: ubyte _1152x870_75 : 1 ; 
590: } timings < bgcolor = cLtGreen , comment = "Established timing bitmap. Supported bitmap for very common timing modes." > ; 
591: 
592: Timing timings2 [ 8 ] < bgcolor = cLtGreen , comment = "Standard timing information. Up to 8 2-byte fields describing standard display modes." > ; 
593: 
594: struct Descriptor 
595: { 
596: if ( ReadUShort ( FTell ( ) ) != 0 ) 
597: { 
598: ModeLine numbers ; 
599: } 
600: else 
601: { 
602: uint16 zero ; 
603: ubyte zero ; 
604: DescriptorType descriptorType ; 
605: ubyte zero ; 
606: switch ( descriptorType ) 
607: { 
608: case TIMINGS : 
609: Timing timings [ 6 ] < comment = "Additional standard timing identifiers. 6- 2-byte descriptors, padded with 0A." > ; 
610: break ; 
611: 
612: case MONITOR_NAME : 
613: char name [ 13 ] < comment = "Monitor name (text)" > ; 
614: break ; 
615: 
616: case SERIAL_NUMBER : 
617: char serial [ 13 ] < comment = "Monitor serial number (text)" > ; 
618: break ; 
619: 
620: case UNSPECIFIED_TEXT : 
621: char text [ 13 ] < comment = "Unspecified text (text)" > ; 
622: break ; 
623: 
624: case RANGE_LIMITS : 
625: { 
626: ubyte vMinRate < comment = "Minimum vertical field rate" > ; 
627: ubyte vMaxRate < comment = "Maximum vertical field rate" > ; 
628: ubyte hMinRate < comment = "Minimum horizontal line rate" > ; 
629: ubyte hMaxRate < comment = "Maximum horizontal line rate" > ; 
630: PixelRate maxPixelRate < comment = "Maximum pixel clock rate, rounded up to 10 MHz multiple (10-2550 MHz)" > ; 
631: ubyte extended < comment = "02: Secondary GTF supported, parameters as follows." > ; 
632: if ( extended == 0x2 ) 
633: { 
634: ubyte reserved ; 
635: ubyte startFreqSecondCurve < comment = "Start frequency for secondary curve, divided by 2 kHz (0-510 kHz)" > ; 
636: ubyte gtf_C < comment = "C value, multiplied by 2 (0-127.5)" > ; 
637: uint16 gtf_M < comment = "GTF M value (0-65535, little-endian)" > ; 
638: ubyte gtf_K < comment = "GTF K value (0-255)" > ; 
639: ubyte gtf_J < comment = "GTF J value, multiplied by 2 (0-127.5)" > ; 
640: } 
641: else 
642: { 
643: ubyte padding [ 7 ] < comment = "0A 20 20 20 20 20 20" > ; 
644: } 
645: break ; 
646: } 
647: 
648: case WHITE_POINT : 
649: { 
650: struct 
651: { 
652: ubyte indexNumber < comment = "Point index number (1-255) Usually 1; 0 indicates descriptor not used." > ; 
653: ubyte white_y_lsb : 2 < comment = "White point y value least-significant 2 bits" > ; 
654: ubyte white_x_lsb : 2 < comment = "White point x value least-significant 2 bits" > ; 
655: ubyte unused : 4 ; 
656: ubyte white_x_msb < comment = "White point x value most significant 8 bits (like EDID byte 27)" > ; 
657: ubyte white_y_msb < comment = "White point y value most significant 8 bits (like EDID byte 28)" > ; 
658: ubyte gamma < comment = "Gamma value, minus 1, time 100 (1.0-3.54, like EDID byte 23)" > ; 
659: } whitePoints [ 2 ] < bgcolor = cLtAqua , comment = "Additional white point descriptors" > ; 
660: ubyte padding [ 3 ] < comment = "0A 20 20" > ; 
661: break ; 
662: } 
663: 
664: default : 
665: { 
666: ubyte unknown [ 13 ] ; 
667: Warning ( "Unknown descriptor type" ) ; 
668: break ; 
669: } 
670: } 
671: } 
672: } descriptors [ 4 ] < optimize = false , bgcolor = cLtGray , comment = "Detailed Timing Descriptor blocks, in decreasing preference order. After all detailed timing descriptors, additional descriptors are permitted." > ; 
673: 
674: 
675: ubyte extensionCount < comment = "Number of extensions to follow. 0 if no extensions." > ; 
676: ubyte checksum < format = hex , comment = "Sum of all 128 bytes should equal 0 (mod 256)." > ; 
677: 
678: 
679: 
680: struct CEA_EDID 
681: { 
682: local int64 extensionBlockStart < hidden = true > = FTell ( ) ; 
683: 
684: ubyte extensionTag < comment = "Extension tag (which kind of extension block this is); 02h for CEA EDID" > ; 
685: switch ( extensionTag ) 
686: { 
687: case 0x2 : 
688: { 
689: ubyte revision < comment = "Revision number (Version number); 03h for Version 3" > ; 
690: ubyte dtdStart < comment = "Byte number \"d\" within this block where the 18-byte DTDs begin." > ; 
691: ubyte dtdCount : 4 < comment = "total number of native formats in the DTDs included in this block" > ; 
692: ubyte YCbCr422 : 1 < comment = "1 if display supports YCbCr 4:2:2, 0 if not" > ; 
693: ubyte YCbCr444 : 1 < comment = "1 if display supports YCbCr 4:4:4, 0 if not" > ; 
694: ubyte basic_audio : 1 < comment = "1 if display supports basic audio, 0 if not" > ; 
695: ubyte underscan : 1 < comment = "if display supports underscan, 0 if not" > ; 
696: 
697: while ( FTell ( ) < extensionBlockStart + dtdStart ) 
698: { 
699: DataBlock dataBlock ; 
700: } 
701: 
702: if ( FTell ( ) != extensionBlockStart + dtdStart ) 
703: { 
704: Warning ( "Unexpected DTD start" ) ; 
705: } 
706: 
707: FSeek ( extensionBlockStart + dtdStart ) ; 
708: 
709: while ( ReadUShort ( FTell ( ) ) != 0 ) 
710: { 
711: Descriptor descriptor < optimize = false , bgcolor = cLtGray , comment = "Detailed Timing Descriptor block" > ; 
712: } 
713: 
714: ubyte padding [ 127 - ( FTell ( ) - extensionBlockStart ) ] < format = hex , comment = "Post-DTD padding. Should be populated with 00h" > ; 
715: ubyte checksum < format = hex , comment = "This byte should be programmed such that the sum of all 128 bytes equals 00h." > ; 
716: if ( Checksum ( CHECKSUM_SUM8 , extensionBlockStart , 128 ) != 0 ) Warning ( "Invalid extension block checksum!" ) ; 
717: 
718: break ; 
719: } 
720: 
721: default : 
722: Warning ( "Unsupported extension block" ) ; 
723: break ; 
724: } 
725: } extensions [ extensionCount ] < optimize = false , open = true , comment = "EDID Extensions" > ; 
726: 
727: 
728: } file < open = true , fgcolor = cBlue > ; 
729: 
730: 
731: tok_eof 
warning: \0 character in file data
warning: \0 character in file data
warning: \0 character in file data