src/video/x11/edid-parse.c

   1 /*
   2  * Copyright 2007 Red Hat, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 /* Author: Soren Sandmann <sandmann@redhat.com> */
  24 #include "../../SDL_internal.h"
  25 #include "SDL_stdinc.h"
  26
  27 #include "edid.h"
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <math.h>
  31 #include <stdio.h>
  32
  33 #define TRUE 1
  34 #define FALSE 0
  35
  36 static int
  37 get_bit (int in, int bit)
  38 {
  39     return (in & (1 << bit)) >> bit;
  40 }
  41
  42 static int
  43 get_bits (int in, int begin, int end)
  44 {
  45     int mask = (1 << (end - begin + 1)) - 1;
  46
  47     return (in >> begin) & mask;
  48 }
  49
  50 static int
  51 decode_header (const uchar *edid)
  52 {
  53     if (memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
  54         return TRUE;
  55     return FALSE;
  56 }
  57
  58 static int
  59 decode_vendor_and_product_identification (const uchar *edid, MonitorInfo *info)
  60 {
  61     int is_model_year;
  62
  63     /* Manufacturer Code */
  64     info->manufacturer_code[0]  = get_bits (edid[0x08], 2, 6);
  65     info->manufacturer_code[1]  = get_bits (edid[0x08], 0, 1) << 3;
  66     info->manufacturer_code[1] |= get_bits (edid[0x09], 5, 7);
  67     info->manufacturer_code[2]  = get_bits (edid[0x09], 0, 4);
  68     info->manufacturer_code[3]  = '\0';
  69
  70     info->manufacturer_code[0] += 'A' - 1;
  71     info->manufacturer_code[1] += 'A' - 1;
  72     info->manufacturer_code[2] += 'A' - 1;
  73
  74     /* Product Code */
  75     info->product_code = edid[0x0b] << 8 | edid[0x0a];
  76
  77     /* Serial Number */
  78     info->serial_number =
  79         edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
  80
  81     /* Week and Year */
  82     is_model_year = FALSE;
  83     switch (edid[0x10])
  84     {
  85     case 0x00:
  86         info->production_week = -1;
  87         break;
  88
  89     case 0xff:
  90         info->production_week = -1;
  91         is_model_year = TRUE;
  92         break;
  93
  94     default:
  95         info->production_week = edid[0x10];
  96         break;
  97     }
  98
  99     if (is_model_year)
 100     {
 101         info->production_year = -1;
 102         info->model_year = 1990 + edid[0x11];
 103     }
 104     else
 105     {
 106         info->production_year = 1990 + edid[0x11];
 107         info->model_year = -1;
 108     }
 109
 110     return TRUE;
 111 }
 112
 113 static int
 114 decode_edid_version (const uchar *edid, MonitorInfo *info)
 115 {
 116     info->major_version = edid[0x12];
 117     info->minor_version = edid[0x13];
 118
 119     return TRUE;
 120 }
 121
 122 static int
 123 decode_display_parameters (const uchar *edid, MonitorInfo *info)
 124 {
 125     /* Digital vs Analog */
 126     info->is_digital = get_bit (edid[0x14], 7);
 127
 128     if (info->is_digital)
 129     {
 130         int bits;
 131
 132         static const int bit_depth[8] =
 133         {
 134             -1, 6, 8, 10, 12, 14, 16, -1
 135         };
 136
 137         static const Interface interfaces[6] =
 138         {
 139             UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT
 140         };
 141
 142         bits = get_bits (edid[0x14], 4, 6);
 143         info->ad.digital.bits_per_primary = bit_depth[bits];
 144
 145         bits = get_bits (edid[0x14], 0, 3);
 146
 147         if (bits <= 5)
 148             info->ad.digital.interface = interfaces[bits];
 149         else
 150             info->ad.digital.interface = UNDEFINED;
 151     }
 152     else
 153     {
 154         int bits = get_bits (edid[0x14], 5, 6);
 155
 156         static const double levels[][3] =
 157         {
 158             { 0.7,   0.3,    1.0 },
 159             { 0.714, 0.286,  1.0 },
 160             { 1.0,   0.4,    1.4 },
 161             { 0.7,   0.0,    0.7 },
 162         };
 163
 164         info->ad.analog.video_signal_level = levels[bits][0];
 165         info->ad.analog.sync_signal_level = levels[bits][1];
 166         info->ad.analog.total_signal_level = levels[bits][2];
 167
 168         info->ad.analog.blank_to_black = get_bit (edid[0x14], 4);
 169
 170         info->ad.analog.separate_hv_sync = get_bit (edid[0x14], 3);
 171         info->ad.analog.composite_sync_on_h = get_bit (edid[0x14], 2);
 172         info->ad.analog.composite_sync_on_green = get_bit (edid[0x14], 1);
 173
 174         info->ad.analog.serration_on_vsync = get_bit (edid[0x14], 0);
 175     }
 176
 177     /* Screen Size / Aspect Ratio */
 178     if (edid[0x15] == 0 && edid[0x16] == 0)
 179     {
 180         info->width_mm = -1;
 181         info->height_mm = -1;
 182         info->aspect_ratio = -1.0;
 183     }
 184     else if (edid[0x16] == 0)
 185     {
 186         info->width_mm = -1;
 187         info->height_mm = -1;
 188         info->aspect_ratio = 100.0 / (edid[0x15] + 99);
 189     }
 190     else if (edid[0x15] == 0)
 191     {
 192         info->width_mm = -1;
 193         info->height_mm = -1;
 194         info->aspect_ratio = 100.0 / (edid[0x16] + 99);
 195         info->aspect_ratio = 1/info->aspect_ratio; /* portrait */
 196     }
 197     else
 198     {
 199         info->width_mm = 10 * edid[0x15];
 200         info->height_mm = 10 * edid[0x16];
 201     }
 202
 203     /* Gamma */
 204     if (edid[0x17] == 0xFF)
 205         info->gamma = -1.0;
 206     else
 207         info->gamma = (edid[0x17] + 100.0) / 100.0;
 208
 209     /* Features */
 210     info->standby = get_bit (edid[0x18], 7);
 211     info->suspend = get_bit (edid[0x18], 6);
 212     info->active_off = get_bit (edid[0x18], 5);
 213
 214     if (info->is_digital)
 215     {
 216         info->ad.digital.rgb444 = TRUE;
 217         if (get_bit (edid[0x18], 3))
 218             info->ad.digital.ycrcb444 = 1;
 219         if (get_bit (edid[0x18], 4))
 220             info->ad.digital.ycrcb422 = 1;
 221     }
 222     else
 223     {
 224         int bits = get_bits (edid[0x18], 3, 4);
 225         ColorType color_type[4] =
 226         {
 227             MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR
 228         };
 229
 230         info->ad.analog.color_type = color_type[bits];
 231     }
 232
 233     info->srgb_is_standard = get_bit (edid[0x18], 2);
 234
 235     /* In 1.3 this is called "has preferred timing" */
 236     info->preferred_timing_includes_native = get_bit (edid[0x18], 1);
 237
 238     /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */
 239     info->continuous_frequency = get_bit (edid[0x18], 0);
 240     return TRUE;
 241 }
 242
 243 static double
 244 decode_fraction (int high, int low)
 245 {
 246     double result = 0.0;
 247     int i;
 248
 249     high = (high << 2) | low;
 250
 251     for (i = 0; i < 10; ++i)
 252         result += get_bit (high, i) * SDL_pow (2, i - 10);
 253
 254     return result;
 255 }
 256
 257 static int
 258 decode_color_characteristics (const uchar *edid, MonitorInfo *info)
 259 {
 260     info->red_x = decode_fraction (edid[0x1b], get_bits (edid[0x19], 6, 7));
 261     info->red_y = decode_fraction (edid[0x1c], get_bits (edid[0x19], 5, 4));
 262     info->green_x = decode_fraction (edid[0x1d], get_bits (edid[0x19], 2, 3));
 263     info->green_y = decode_fraction (edid[0x1e], get_bits (edid[0x19], 0, 1));
 264     info->blue_x = decode_fraction (edid[0x1f], get_bits (edid[0x1a], 6, 7));
 265     info->blue_y = decode_fraction (edid[0x20], get_bits (edid[0x1a], 4, 5));
 266     info->white_x = decode_fraction (edid[0x21], get_bits (edid[0x1a], 2, 3));
 267     info->white_y = decode_fraction (edid[0x22], get_bits (edid[0x1a], 0, 1));
 268
 269     return TRUE;
 270 }
 271
 272 static int
 273 decode_established_timings (const uchar *edid, MonitorInfo *info)
 274 {
 275     static const Timing established[][8] =
 276     {
 277         {
 278             { 800, 600, 60 },
 279             { 800, 600, 56 },
 280             { 640, 480, 75 },
 281             { 640, 480, 72 },
 282             { 640, 480, 67 },
 283             { 640, 480, 60 },
 284             { 720, 400, 88 },
 285             { 720, 400, 70 }
 286         },
 287         {
 288             { 1280, 1024, 75 },
 289             { 1024, 768, 75 },
 290             { 1024, 768, 70 },
 291             { 1024, 768, 60 },
 292             { 1024, 768, 87 },
 293             { 832, 624, 75 },
 294             { 800, 600, 75 },
 295             { 800, 600, 72 }
 296         },
 297         {
 298             { 0, 0, 0 },
 299             { 0, 0, 0 },
 300             { 0, 0, 0 },
 301             { 0, 0, 0 },
 302             { 0, 0, 0 },
 303             { 0, 0, 0 },
 304             { 0, 0, 0 },
 305             { 1152, 870, 75 }
 306         },
 307     };
 308
 309     int i, j, idx;
 310
 311     idx = 0;
 312     for (i = 0; i < 3; ++i)
 313     {
 314         for (j = 0; j < 8; ++j)
 315         {
 316             int byte = edid[0x23 + i];
 317
 318             if (get_bit (byte, j) && established[i][j].frequency != 0)
 319                 info->established[idx++] = established[i][j];
 320         }
 321     }
 322     return TRUE;
 323 }
 324
 325 static int
 326 decode_standard_timings (const uchar *edid, MonitorInfo *info)
 327 {
 328     int i;
 329
 330     for (i = 0; i < 8; i++)
 331     {
 332         int first = edid[0x26 + 2 * i];
 333         int second = edid[0x27 + 2 * i];
 334
 335         if (first != 0x01 && second != 0x01)
 336         {
 337             int w = 8 * (first + 31);
 338             int h = 0;
 339
 340             switch (get_bits (second, 6, 7))
 341             {
 342             case 0x00: h = (w / 16) * 10; break;
 343             case 0x01: h = (w / 4) * 3; break;
 344             case 0x02: h = (w / 5) * 4; break;
 345             case 0x03: h = (w / 16) * 9; break;
 346             }
 347
 348             info->standard[i].width = w;
 349             info->standard[i].height = h;
 350             info->standard[i].frequency = get_bits (second, 0, 5) + 60;
 351         }
 352     }
 353
 354     return TRUE;
 355 }
 356
 357 static void
 358 decode_lf_string (const uchar *s, int n_chars, char *result)
 359 {
 360     int i;
 361     for (i = 0; i < n_chars; ++i)
 362     {
 363         if (s[i] == 0x0a)
 364         {
 365             *result++ = '\0';
 366             break;
 367         }
 368         else if (s[i] == 0x00)
 369         {
 370             /* Convert embedded 0's to spaces */
 371             *result++ = ' ';
 372         }
 373         else
 374         {
 375             *result++ = s[i];
 376         }
 377     }
 378 }
 379
 380 static void
 381 decode_display_descriptor (const uchar *desc,
 382                            MonitorInfo *info)
 383 {
 384     switch (desc[0x03])
 385     {
 386     case 0xFC:
 387         decode_lf_string (desc + 5, 13, info->dsc_product_name);
 388         break;
 389     case 0xFF:
 390         decode_lf_string (desc + 5, 13, info->dsc_serial_number);
 391         break;
 392     case 0xFE:
 393         decode_lf_string (desc + 5, 13, info->dsc_string);
 394         break;
 395     case 0xFD:
 396         /* Range Limits */
 397         break;
 398     case 0xFB:
 399         /* Color Point */
 400         break;
 401     case 0xFA:
 402         /* Timing Identifications */
 403         break;
 404     case 0xF9:
 405         /* Color Management */
 406         break;
 407     case 0xF8:
 408         /* Timing Codes */
 409         break;
 410     case 0xF7:
 411         /* Established Timings */
 412         break;
 413     case 0x10:
 414         break;
 415     }
 416 }
 417
 418 static void
 419 decode_detailed_timing (const uchar *timing,
 420                         DetailedTiming *detailed)
 421 {
 422     int bits;
 423     StereoType stereo[] =
 424     {
 425         NO_STEREO, NO_STEREO, FIELD_RIGHT, FIELD_LEFT,
 426         TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN,
 427         FOUR_WAY_INTERLEAVED, SIDE_BY_SIDE
 428     };
 429
 430     detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;
 431     detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);
 432     detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);
 433     detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);
 434     detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);
 435     detailed->h_front_porch = timing[0x08] | get_bits (timing[0x0b], 6, 7) << 8;
 436     detailed->h_sync = timing[0x09] | get_bits (timing[0x0b], 4, 5) << 8;
 437     detailed->v_front_porch =
 438         get_bits (timing[0x0a], 4, 7) | get_bits (timing[0x0b], 2, 3) << 4;
 439     detailed->v_sync =
 440         get_bits (timing[0x0a], 0, 3) | get_bits (timing[0x0b], 0, 1) << 4;
 441     detailed->width_mm =  timing[0x0c] | get_bits (timing[0x0e], 4, 7) << 8;
 442     detailed->height_mm = timing[0x0d] | get_bits (timing[0x0e], 0, 3) << 8;
 443     detailed->right_border = timing[0x0f];
 444     detailed->top_border = timing[0x10];
 445
 446     detailed->interlaced = get_bit (timing[0x11], 7);
 447
 448     /* Stereo */
 449     bits = get_bits (timing[0x11], 5, 6) << 1 | get_bit (timing[0x11], 0);
 450     detailed->stereo = stereo[bits];
 451
 452     /* Sync */
 453     bits = timing[0x11];
 454
 455     detailed->digital_sync = get_bit (bits, 4);
 456     if (detailed->digital_sync)
 457     {
 458         detailed->ad.digital.composite = !get_bit (bits, 3);
 459
 460         if (detailed->ad.digital.composite)
 461         {
 462             detailed->ad.digital.serrations = get_bit (bits, 2);
 463             detailed->ad.digital.negative_vsync = FALSE;
 464         }
 465         else
 466         {
 467             detailed->ad.digital.serrations = FALSE;
 468             detailed->ad.digital.negative_vsync = !get_bit (bits, 2);
 469         }
 470
 471         detailed->ad.digital.negative_hsync = !get_bit (bits, 0);
 472     }
 473     else
 474     {
 475         detailed->ad.analog.bipolar = get_bit (bits, 3);
 476         detailed->ad.analog.serrations = get_bit (bits, 2);
 477         detailed->ad.analog.sync_on_green = !get_bit (bits, 1);
 478     }
 479 }
 480
 481 static int
 482 decode_descriptors (const uchar *edid, MonitorInfo *info)
 483 {
 484     int i;
 485     int timing_idx;
 486
 487     timing_idx = 0;
 488
 489     for (i = 0; i < 4; ++i)
 490     {
 491         int index = 0x36 + i * 18;
 492
 493         if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00)
 494         {
 495             decode_display_descriptor (edid + index, info);
 496         }
 497         else
 498         {
 499             decode_detailed_timing (
 500                 edid + index, &(info->detailed_timings[timing_idx++]));
 501         }
 502     }
 503
 504     info->n_detailed_timings = timing_idx;
 505
 506     return TRUE;
 507 }
 508
 509 static void
 510 decode_check_sum (const uchar *edid,
 511                   MonitorInfo *info)
 512 {
 513     int i;
 514     uchar check = 0;
 515
 516     for (i = 0; i < 128; ++i)
 517         check += edid[i];
 518
 519     info->checksum = check;
 520 }
 521
 522 MonitorInfo *
 523 decode_edid (const uchar *edid)
 524 {
 525     MonitorInfo *info = calloc (1, sizeof (MonitorInfo));
 526
 527     decode_check_sum (edid, info);
 528
 529     if (!decode_header (edid) ||
 530         !decode_vendor_and_product_identification (edid, info) ||
 531         !decode_edid_version (edid, info) ||
 532         !decode_display_parameters (edid, info) ||
 533         !decode_color_characteristics (edid, info) ||
 534         !decode_established_timings (edid, info) ||
 535         !decode_standard_timings (edid, info) ||
 536         !decode_descriptors (edid, info)) {
 537         free(info);
 538         return NULL;
 539     }
 540
 541     return info;
 542 }
 543
 544 static const char *
 545 yesno (int v)
 546 {
 547     return v? "yes" : "no";
 548 }
 549
 550 void
 551 dump_monitor_info (MonitorInfo *info)
 552 {
 553     int i;
 554
 555     printf ("Checksum: %d (%s)\n",
 556             info->checksum, info->checksum? "incorrect" : "correct");
 557     printf ("Manufacturer Code: %s\n", info->manufacturer_code);
 558     printf ("Product Code: 0x%x\n", info->product_code);
 559     printf ("Serial Number: %u\n", info->serial_number);
 560
 561     if (info->production_week != -1)
 562         printf ("Production Week: %d\n", info->production_week);
 563     else
 564         printf ("Production Week: unspecified\n");
 565
 566     if (info->production_year != -1)
 567         printf ("Production Year: %d\n", info->production_year);
 568     else
 569         printf ("Production Year: unspecified\n");
 570
 571     if (info->model_year != -1)
 572         printf ("Model Year: %d\n", info->model_year);
 573     else
 574         printf ("Model Year: unspecified\n");
 575
 576     printf ("EDID revision: %d.%d\n", info->major_version, info->minor_version);
 577
 578     printf ("Display is %s\n", info->is_digital? "digital" : "analog");
 579     if (info->is_digital)
 580     {
 581         const char *interface;
 582         if (info->ad.digital.bits_per_primary != -1)
 583             printf ("Bits Per Primary: %d\n", info->ad.digital.bits_per_primary);
 584         else
 585             printf ("Bits Per Primary: undefined\n");
 586
 587         switch (info->ad.digital.interface)
 588         {
 589         case DVI: interface = "DVI"; break;
 590         case HDMI_A: interface = "HDMI-a"; break;
 591         case HDMI_B: interface = "HDMI-b"; break;
 592         case MDDI: interface = "MDDI"; break;
 593         case DISPLAY_PORT: interface = "DisplayPort"; break;
 594         case UNDEFINED: interface = "undefined"; break;
 595         default: interface = "unknown"; break;
 596         }
 597         printf ("Interface: %s\n", interface);
 598
 599         printf ("RGB 4:4:4: %s\n", yesno (info->ad.digital.rgb444));
 600         printf ("YCrCb 4:4:4: %s\n", yesno (info->ad.digital.ycrcb444));
 601         printf ("YCrCb 4:2:2: %s\n", yesno (info->ad.digital.ycrcb422));
 602     }
 603     else
 604     {
 605        const char *s;
 606         printf ("Video Signal Level: %f\n", info->ad.analog.video_signal_level);
 607         printf ("Sync Signal Level: %f\n", info->ad.analog.sync_signal_level);
 608         printf ("Total Signal Level: %f\n", info->ad.analog.total_signal_level);
 609
 610         printf ("Blank to Black: %s\n",
 611                 yesno (info->ad.analog.blank_to_black));
 612         printf ("Separate HV Sync: %s\n",
 613                 yesno (info->ad.analog.separate_hv_sync));
 614         printf ("Composite Sync on H: %s\n",
 615                 yesno (info->ad.analog.composite_sync_on_h));
 616         printf ("Serration on VSync: %s\n",
 617                 yesno (info->ad.analog.serration_on_vsync));
 618
 619         switch (info->ad.analog.color_type)
 620         {
 621         case UNDEFINED_COLOR: s = "undefined"; break;
 622         case MONOCHROME: s = "monochrome"; break;
 623         case RGB: s = "rgb"; break;
 624         case OTHER_COLOR: s = "other color"; break;
 625         default: s = "unknown"; break;
 626         };
 627
 628         printf ("Color: %s\n", s);
 629     }
 630
 631     if (info->width_mm == -1)
 632         printf ("Width: undefined\n");
 633     else
 634         printf ("Width: %d mm\n", info->width_mm);
 635
 636     if (info->height_mm == -1)
 637         printf ("Height: undefined\n");
 638     else
 639         printf ("Height: %d mm\n", info->height_mm);
 640
 641     if (info->aspect_ratio > 0)
 642         printf ("Aspect Ratio: %f\n", info->aspect_ratio);
 643     else
 644         printf ("Aspect Ratio: undefined\n");
 645
 646     if (info->gamma >= 0)
 647         printf ("Gamma: %f\n", info->gamma);
 648     else
 649         printf ("Gamma: undefined\n");
 650
 651     printf ("Standby: %s\n", yesno (info->standby));
 652     printf ("Suspend: %s\n", yesno (info->suspend));
 653     printf ("Active Off: %s\n", yesno (info->active_off));
 654
 655     printf ("SRGB is Standard: %s\n", yesno (info->srgb_is_standard));
 656     printf ("Preferred Timing Includes Native: %s\n",
 657             yesno (info->preferred_timing_includes_native));
 658     printf ("Continuous Frequency: %s\n", yesno (info->continuous_frequency));
 659
 660     printf ("Red X: %f\n", info->red_x);
 661     printf ("Red Y: %f\n", info->red_y);
 662     printf ("Green X: %f\n", info->green_x);
 663     printf ("Green Y: %f\n", info->green_y);
 664     printf ("Blue X: %f\n", info->blue_x);
 665     printf ("Blue Y: %f\n", info->blue_y);
 666     printf ("White X: %f\n", info->white_x);
 667     printf ("White Y: %f\n", info->white_y);
 668
 669     printf ("Established Timings:\n");
 670
 671     for (i = 0; i < 24; ++i)
 672     {
 673         Timing *timing = &(info->established[i]);
 674
 675         if (timing->frequency == 0)
 676             break;
 677
 678         printf ("  %d x %d @ %d Hz\n",
 679                 timing->width, timing->height, timing->frequency);
 680
 681     }
 682
 683     printf ("Standard Timings:\n");
 684     for (i = 0; i < 8; ++i)
 685     {
 686         Timing *timing = &(info->standard[i]);
 687
 688         if (timing->frequency == 0)
 689             break;
 690
 691         printf ("  %d x %d @ %d Hz\n",
 692                 timing->width, timing->height, timing->frequency);
 693     }
 694
 695     for (i = 0; i < info->n_detailed_timings; ++i)
 696     {
 697         DetailedTiming *timing = &(info->detailed_timings[i]);
 698         const char *s;
 699
 700         printf ("Timing%s: \n",
 701                 (i == 0 && info->preferred_timing_includes_native)?
 702                 " (Preferred)" : "");
 703         printf ("  Pixel Clock: %d\n", timing->pixel_clock);
 704         printf ("  H Addressable: %d\n", timing->h_addr);
 705         printf ("  H Blank: %d\n", timing->h_blank);
 706         printf ("  H Front Porch: %d\n", timing->h_front_porch);
 707         printf ("  H Sync: %d\n", timing->h_sync);
 708         printf ("  V Addressable: %d\n", timing->v_addr);
 709         printf ("  V Blank: %d\n", timing->v_blank);
 710         printf ("  V Front Porch: %d\n", timing->v_front_porch);
 711         printf ("  V Sync: %d\n", timing->v_sync);
 712         printf ("  Width: %d mm\n", timing->width_mm);
 713         printf ("  Height: %d mm\n", timing->height_mm);
 714         printf ("  Right Border: %d\n", timing->right_border);
 715         printf ("  Top Border: %d\n", timing->top_border);
 716         switch (timing->stereo)
 717         {
 718         default:
 719         case NO_STEREO:   s = "No Stereo"; break;
 720         case FIELD_RIGHT: s = "Field Sequential, Right on Sync"; break;
 721         case FIELD_LEFT:  s = "Field Sequential, Left on Sync"; break;
 722         case TWO_WAY_RIGHT_ON_EVEN: s = "Two-way, Right on Even"; break;
 723         case TWO_WAY_LEFT_ON_EVEN:  s = "Two-way, Left on Even"; break;
 724         case FOUR_WAY_INTERLEAVED:  s = "Four-way Interleaved"; break;
 725         case SIDE_BY_SIDE:          s = "Side-by-Side"; break;
 726         }
 727         printf ("  Stereo: %s\n", s);
 728
 729         if (timing->digital_sync)
 730         {
 731             printf ("  Digital Sync:\n");
 732             printf ("    composite: %s\n", yesno (timing->ad.digital.composite));
 733             printf ("    serrations: %s\n", yesno (timing->ad.digital.serrations));
 734             printf ("    negative vsync: %s\n",
 735                     yesno (timing->ad.digital.negative_vsync));
 736             printf ("    negative hsync: %s\n",
 737                     yesno (timing->ad.digital.negative_hsync));
 738         }
 739         else
 740         {
 741             printf ("  Analog Sync:\n");
 742             printf ("    bipolar: %s\n", yesno (timing->ad.analog.bipolar));
 743             printf ("    serrations: %s\n", yesno (timing->ad.analog.serrations));
 744             printf ("    sync on green: %s\n", yesno (
 745                         timing->ad.analog.sync_on_green));
 746         }
 747     }
 748
 749     printf ("Detailed Product information:\n");
 750     printf ("  Product Name: %s\n", info->dsc_product_name);
 751     printf ("  Serial Number: %s\n", info->dsc_serial_number);
 752     printf ("  Unspecified String: %s\n", info->dsc_string);
 753 }
 754