src/egl/main/eglconfig.c

   1 /**
   2  * EGL Configuration (pixel format) functions.
   3  */
   4
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <assert.h>
   9 #include "eglconfig.h"
  10 #include "egldisplay.h"
  11 #include "eglcurrent.h"
  12 #include "egllog.h"
  13
  14
  15 #define MIN2(A, B)  (((A) < (B)) ? (A) : (B))
  16
  17
  18 /**
  19  * Init the given _EGLconfig to default values.
  20  * \param id  the configuration's ID.
  21  *
  22  * Note that id must be positive for the config to be valid.
  23  * It is also recommended that when there are N configs, their
  24  * IDs are from 1 to N respectively.
  25  */
  26 void
  27 _eglInitConfig(_EGLConfig *config, _EGLDisplay *dpy, EGLint id)
  28 {
  29    memset(config, 0, sizeof(*config));
  30
  31    config->Display = dpy;
  32
  33    /* some attributes take non-zero default values */
  34    SET_CONFIG_ATTRIB(config, EGL_CONFIG_ID,               id);
  35    SET_CONFIG_ATTRIB(config, EGL_CONFIG_CAVEAT,           EGL_NONE);
  36    SET_CONFIG_ATTRIB(config, EGL_TRANSPARENT_TYPE,        EGL_NONE);
  37    SET_CONFIG_ATTRIB(config, EGL_NATIVE_VISUAL_TYPE,      EGL_NONE);
  38 #ifdef EGL_VERSION_1_2
  39    SET_CONFIG_ATTRIB(config, EGL_COLOR_BUFFER_TYPE,       EGL_RGB_BUFFER);
  40 #endif /* EGL_VERSION_1_2 */
  41 }
  42
  43
  44 /**
  45  * Link a config to a display and return the handle of the link.
  46  * The handle can be passed to client directly.
  47  *
  48  * Note that we just save the ptr to the config (we don't copy the config).
  49  */
  50 EGLConfig
  51 _eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf)
  52 {
  53    /* sanity check */
  54    assert(GET_CONFIG_ATTRIB(conf, EGL_CONFIG_ID) > 0);
  55
  56    if (!dpy->Configs) {
  57       dpy->Configs = _eglCreateArray("Config", 16);
  58       if (!dpy->Configs)
  59          return (EGLConfig) NULL;
  60    }
  61
  62    conf->Display = dpy;
  63    _eglAppendArray(dpy->Configs, (void *) conf);
  64
  65    return (EGLConfig) conf;
  66 }
  67
  68
  69 EGLBoolean
  70 _eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy)
  71 {
  72    _EGLConfig *conf;
  73
  74    conf = (_EGLConfig *) _eglFindArray(dpy->Configs, (void *) config);
  75    if (conf)
  76       assert(conf->Display == dpy);
  77
  78    return (conf != NULL);
  79 }
  80
  81
  82 enum {
  83    /* types */
  84    ATTRIB_TYPE_INTEGER,
  85    ATTRIB_TYPE_BOOLEAN,
  86    ATTRIB_TYPE_BITMASK,
  87    ATTRIB_TYPE_ENUM,
  88    ATTRIB_TYPE_PSEUDO, /* non-queryable */
  89    ATTRIB_TYPE_PLATFORM, /* platform-dependent */
  90    /* criteria */
  91    ATTRIB_CRITERION_EXACT,
  92    ATTRIB_CRITERION_ATLEAST,
  93    ATTRIB_CRITERION_MASK,
  94    ATTRIB_CRITERION_SPECIAL,
  95    ATTRIB_CRITERION_IGNORE
  96 };
  97
  98
  99 /* EGL spec Table 3.1 and 3.4 */
 100 static const struct {
 101    EGLint attr;
 102    EGLint type;
 103    EGLint criterion;
 104    EGLint default_value;
 105 } _eglValidationTable[] =
 106 {
 107    { EGL_BUFFER_SIZE,               ATTRIB_TYPE_INTEGER,
 108                                     ATTRIB_CRITERION_ATLEAST,
 109                                     0 },
 110    { EGL_RED_SIZE,                  ATTRIB_TYPE_INTEGER,
 111                                     ATTRIB_CRITERION_ATLEAST,
 112                                     0 },
 113    { EGL_GREEN_SIZE,                ATTRIB_TYPE_INTEGER,
 114                                     ATTRIB_CRITERION_ATLEAST,
 115                                     0 },
 116    { EGL_BLUE_SIZE,                 ATTRIB_TYPE_INTEGER,
 117                                     ATTRIB_CRITERION_ATLEAST,
 118                                     0 },
 119    { EGL_LUMINANCE_SIZE,            ATTRIB_TYPE_INTEGER,
 120                                     ATTRIB_CRITERION_ATLEAST,
 121                                     0 },
 122    { EGL_ALPHA_SIZE,                ATTRIB_TYPE_INTEGER,
 123                                     ATTRIB_CRITERION_ATLEAST,
 124                                     0 },
 125    { EGL_ALPHA_MASK_SIZE,           ATTRIB_TYPE_INTEGER,
 126                                     ATTRIB_CRITERION_ATLEAST,
 127                                     0 },
 128    { EGL_BIND_TO_TEXTURE_RGB,       ATTRIB_TYPE_BOOLEAN,
 129                                     ATTRIB_CRITERION_EXACT,
 130                                     EGL_DONT_CARE },
 131    { EGL_BIND_TO_TEXTURE_RGBA,      ATTRIB_TYPE_BOOLEAN,
 132                                     ATTRIB_CRITERION_EXACT,
 133                                     EGL_DONT_CARE },
 134    { EGL_COLOR_BUFFER_TYPE,         ATTRIB_TYPE_ENUM,
 135                                     ATTRIB_CRITERION_EXACT,
 136                                     EGL_RGB_BUFFER },
 137    { EGL_CONFIG_CAVEAT,             ATTRIB_TYPE_ENUM,
 138                                     ATTRIB_CRITERION_EXACT,
 139                                     EGL_DONT_CARE },
 140    { EGL_CONFIG_ID,                 ATTRIB_TYPE_INTEGER,
 141                                     ATTRIB_CRITERION_EXACT,
 142                                     EGL_DONT_CARE },
 143    { EGL_CONFORMANT,                ATTRIB_TYPE_BITMASK,
 144                                     ATTRIB_CRITERION_MASK,
 145                                     0 },
 146    { EGL_DEPTH_SIZE,                ATTRIB_TYPE_INTEGER,
 147                                     ATTRIB_CRITERION_ATLEAST,
 148                                     0 },
 149    { EGL_LEVEL,                     ATTRIB_TYPE_PLATFORM,
 150                                     ATTRIB_CRITERION_EXACT,
 151                                     0 },
 152    { EGL_MAX_PBUFFER_WIDTH,         ATTRIB_TYPE_INTEGER,
 153                                     ATTRIB_CRITERION_IGNORE,
 154                                     0 },
 155    { EGL_MAX_PBUFFER_HEIGHT,        ATTRIB_TYPE_INTEGER,
 156                                     ATTRIB_CRITERION_IGNORE,
 157                                     0 },
 158    { EGL_MAX_PBUFFER_PIXELS,        ATTRIB_TYPE_INTEGER,
 159                                     ATTRIB_CRITERION_IGNORE,
 160                                     0 },
 161    { EGL_MAX_SWAP_INTERVAL,         ATTRIB_TYPE_INTEGER,
 162                                     ATTRIB_CRITERION_EXACT,
 163                                     EGL_DONT_CARE },
 164    { EGL_MIN_SWAP_INTERVAL,         ATTRIB_TYPE_INTEGER,
 165                                     ATTRIB_CRITERION_EXACT,
 166                                     EGL_DONT_CARE },
 167    { EGL_NATIVE_RENDERABLE,         ATTRIB_TYPE_BOOLEAN,
 168                                     ATTRIB_CRITERION_EXACT,
 169                                     EGL_DONT_CARE },
 170    { EGL_NATIVE_VISUAL_ID,          ATTRIB_TYPE_PLATFORM,
 171                                     ATTRIB_CRITERION_IGNORE,
 172                                     0 },
 173    { EGL_NATIVE_VISUAL_TYPE,        ATTRIB_TYPE_PLATFORM,
 174                                     ATTRIB_CRITERION_EXACT,
 175                                     EGL_DONT_CARE },
 176    { EGL_RENDERABLE_TYPE,           ATTRIB_TYPE_BITMASK,
 177                                     ATTRIB_CRITERION_MASK,
 178                                     EGL_OPENGL_ES_BIT },
 179    { EGL_SAMPLE_BUFFERS,            ATTRIB_TYPE_INTEGER,
 180                                     ATTRIB_CRITERION_ATLEAST,
 181                                     0 },
 182    { EGL_SAMPLES,                   ATTRIB_TYPE_INTEGER,
 183                                     ATTRIB_CRITERION_ATLEAST,
 184                                     0 },
 185    { EGL_STENCIL_SIZE,              ATTRIB_TYPE_INTEGER,
 186                                     ATTRIB_CRITERION_ATLEAST,
 187                                     0 },
 188    { EGL_SURFACE_TYPE,              ATTRIB_TYPE_BITMASK,
 189                                     ATTRIB_CRITERION_MASK,
 190                                     EGL_WINDOW_BIT },
 191    { EGL_TRANSPARENT_TYPE,          ATTRIB_TYPE_ENUM,
 192                                     ATTRIB_CRITERION_EXACT,
 193                                     EGL_NONE },
 194    { EGL_TRANSPARENT_RED_VALUE,     ATTRIB_TYPE_INTEGER,
 195                                     ATTRIB_CRITERION_EXACT,
 196                                     EGL_DONT_CARE },
 197    { EGL_TRANSPARENT_GREEN_VALUE,   ATTRIB_TYPE_INTEGER,
 198                                     ATTRIB_CRITERION_EXACT,
 199                                     EGL_DONT_CARE },
 200    { EGL_TRANSPARENT_BLUE_VALUE,    ATTRIB_TYPE_INTEGER,
 201                                     ATTRIB_CRITERION_EXACT,
 202                                     EGL_DONT_CARE },
 203    /* these are not real attributes */
 204    { EGL_MATCH_NATIVE_PIXMAP,       ATTRIB_TYPE_PSEUDO,
 205                                     ATTRIB_CRITERION_SPECIAL,
 206                                     EGL_NONE },
 207    /* there is a gap before EGL_SAMPLES */
 208    { 0x3030,                        ATTRIB_TYPE_PSEUDO,
 209                                     ATTRIB_CRITERION_IGNORE,
 210                                     0 },
 211    { EGL_NONE,                      ATTRIB_TYPE_PSEUDO,
 212                                     ATTRIB_CRITERION_IGNORE,
 213                                     0 },
 214
 215    { EGL_Y_INVERTED_NOK,            ATTRIB_TYPE_BOOLEAN,
 216                                     ATTRIB_CRITERION_EXACT,
 217                                     EGL_DONT_CARE },
 218
 219 };
 220
 221
 222 /**
 223  * Return true if a config is valid.  When for_matching is true,
 224  * EGL_DONT_CARE is accepted as a valid attribute value, and checks
 225  * for conflicting attribute values are skipped.
 226  *
 227  * Note that some attributes are platform-dependent and are not
 228  * checked.
 229  */
 230 EGLBoolean
 231 _eglValidateConfig(const _EGLConfig *conf, EGLBoolean for_matching)
 232 {
 233    EGLint i, attr, val;
 234    EGLBoolean valid = EGL_TRUE;
 235    EGLint red_size = 0, green_size = 0, blue_size = 0, luminance_size = 0;
 236    EGLint alpha_size = 0, buffer_size = 0;
 237
 238    /* all attributes should have been listed */
 239    assert(ARRAY_SIZE(_eglValidationTable) == _EGL_CONFIG_NUM_ATTRIBS);
 240
 241    /* check attributes by their types */
 242    for (i = 0; i < ARRAY_SIZE(_eglValidationTable); i++) {
 243       EGLint mask;
 244
 245       attr = _eglValidationTable[i].attr;
 246       val = GET_CONFIG_ATTRIB(conf, attr);
 247
 248       switch (_eglValidationTable[i].type) {
 249       case ATTRIB_TYPE_INTEGER:
 250          switch (attr) {
 251          case EGL_CONFIG_ID:
 252             /* config id must be positive */
 253             if (val <= 0)
 254                valid = EGL_FALSE;
 255             break;
 256          case EGL_SAMPLE_BUFFERS:
 257             /* there can be at most 1 sample buffer */
 258             if (val > 1)
 259                valid = EGL_FALSE;
 260             break;
 261          case EGL_RED_SIZE:
 262             red_size = val;
 263             break;
 264          case EGL_GREEN_SIZE:
 265             green_size = val;
 266             break;
 267          case EGL_BLUE_SIZE:
 268             blue_size = val;
 269             break;
 270          case EGL_LUMINANCE_SIZE:
 271             luminance_size = val;
 272             break;
 273          case EGL_ALPHA_SIZE:
 274             alpha_size = val;
 275             break;
 276          case EGL_BUFFER_SIZE:
 277             buffer_size = val;
 278             break;
 279          }
 280          if (val < 0)
 281             valid = EGL_FALSE;
 282          break;
 283       case ATTRIB_TYPE_BOOLEAN:
 284          if (val != EGL_TRUE && val != EGL_FALSE)
 285             valid = EGL_FALSE;
 286          break;
 287       case ATTRIB_TYPE_ENUM:
 288          switch (attr) {
 289          case EGL_CONFIG_CAVEAT:
 290             if (val != EGL_NONE && val != EGL_SLOW_CONFIG &&
 291                 val != EGL_NON_CONFORMANT_CONFIG)
 292                valid = EGL_FALSE;
 293             break;
 294          case EGL_TRANSPARENT_TYPE:
 295             if (val != EGL_NONE && val != EGL_TRANSPARENT_RGB)
 296                valid = EGL_FALSE;
 297             break;
 298          case EGL_COLOR_BUFFER_TYPE:
 299             if (val != EGL_RGB_BUFFER && val != EGL_LUMINANCE_BUFFER)
 300                valid = EGL_FALSE;
 301             break;
 302          default:
 303             assert(0);
 304             break;
 305          }
 306          break;
 307       case ATTRIB_TYPE_BITMASK:
 308          switch (attr) {
 309          case EGL_SURFACE_TYPE:
 310             mask = EGL_PBUFFER_BIT |
 311                    EGL_PIXMAP_BIT |
 312                    EGL_WINDOW_BIT |
 313                    EGL_VG_COLORSPACE_LINEAR_BIT |
 314                    EGL_VG_ALPHA_FORMAT_PRE_BIT |
 315                    EGL_MULTISAMPLE_RESOLVE_BOX_BIT |
 316                    EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
 317 #ifdef EGL_MESA_screen_surface
 318             if (conf->Display->Extensions.MESA_screen_surface)
 319                mask |= EGL_SCREEN_BIT_MESA;
 320 #endif
 321             break;
 322          case EGL_RENDERABLE_TYPE:
 323          case EGL_CONFORMANT:
 324             mask = EGL_OPENGL_ES_BIT |
 325                    EGL_OPENVG_BIT |
 326                    EGL_OPENGL_ES2_BIT |
 327                    EGL_OPENGL_BIT;
 328             break;
 329          default:
 330             assert(0);
 331             break;
 332          }
 333          if (val & ~mask)
 334             valid = EGL_FALSE;
 335          break;
 336       case ATTRIB_TYPE_PLATFORM:
 337          /* unable to check platform-dependent attributes here */
 338          break;
 339       case ATTRIB_TYPE_PSEUDO:
 340          /* pseudo attributes should not be set */
 341          if (val != 0)
 342             valid = EGL_FALSE;
 343          break;
 344       default:
 345          assert(0);
 346          break;
 347       }
 348
 349       if (!valid && for_matching) {
 350          /* accept EGL_DONT_CARE as a valid value */
 351          if (val == EGL_DONT_CARE)
 352             valid = EGL_TRUE;
 353          if (_eglValidationTable[i].criterion == ATTRIB_CRITERION_SPECIAL)
 354             valid = EGL_TRUE;
 355       }
 356       if (!valid) {
 357          _eglLog(_EGL_DEBUG,
 358                "attribute 0x%04x has an invalid value 0x%x", attr, val);
 359          break;
 360       }
 361    }
 362
 363    /* any invalid attribute value should have been catched */
 364    if (!valid || for_matching)
 365       return valid;
 366
 367    /* now check for conflicting attribute values */
 368
 369    switch (GET_CONFIG_ATTRIB(conf, EGL_COLOR_BUFFER_TYPE)) {
 370    case EGL_RGB_BUFFER:
 371       if (luminance_size)
 372          valid = EGL_FALSE;
 373       if (red_size + green_size + blue_size + alpha_size != buffer_size)
 374          valid = EGL_FALSE;
 375       break;
 376    case EGL_LUMINANCE_BUFFER:
 377       if (red_size || green_size || blue_size)
 378          valid = EGL_FALSE;
 379       if (luminance_size + alpha_size != buffer_size)
 380          valid = EGL_FALSE;
 381       break;
 382    }
 383    if (!valid) {
 384       _eglLog(_EGL_DEBUG, "conflicting color buffer type and channel sizes");
 385       return EGL_FALSE;
 386    }
 387
 388    val = GET_CONFIG_ATTRIB(conf, EGL_SAMPLE_BUFFERS);
 389    if (!val && GET_CONFIG_ATTRIB(conf, EGL_SAMPLES))
 390       valid = EGL_FALSE;
 391    if (!valid) {
 392       _eglLog(_EGL_DEBUG, "conflicting samples and sample buffers");
 393       return EGL_FALSE;
 394    }
 395
 396    val = GET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE);
 397    if (!(val & EGL_WINDOW_BIT)) {
 398       if (GET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_ID) != 0 ||
 399           GET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_TYPE) != EGL_NONE)
 400          valid = EGL_FALSE;
 401    }
 402    if (!(val & EGL_PBUFFER_BIT)) {
 403       if (GET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGB) ||
 404           GET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGBA))
 405          valid = EGL_FALSE;
 406    }
 407    if (!valid) {
 408       _eglLog(_EGL_DEBUG, "conflicting surface type and native visual/texture binding");
 409       return EGL_FALSE;
 410    }
 411
 412    return valid;
 413 }
 414
 415
 416 /**
 417  * Return true if a config matches the criteria.  This and
 418  * _eglParseConfigAttribList together implement the algorithm
 419  * described in "Selection of EGLConfigs".
 420  *
 421  * Note that attributes that are special (currently, only
 422  * EGL_MATCH_NATIVE_PIXMAP) are ignored.
 423  */
 424 EGLBoolean
 425 _eglMatchConfig(const _EGLConfig *conf, const _EGLConfig *criteria)
 426 {
 427    EGLint attr, val, i;
 428    EGLBoolean matched = EGL_TRUE;
 429
 430    for (i = 0; i < ARRAY_SIZE(_eglValidationTable); i++) {
 431       EGLint cmp;
 432       if (_eglValidationTable[i].criterion == ATTRIB_CRITERION_IGNORE)
 433          continue;
 434
 435       attr = _eglValidationTable[i].attr;
 436       cmp = GET_CONFIG_ATTRIB(criteria, attr);
 437       if (cmp == EGL_DONT_CARE)
 438          continue;
 439
 440       val = GET_CONFIG_ATTRIB(conf, attr);
 441       switch (_eglValidationTable[i].criterion) {
 442       case ATTRIB_CRITERION_EXACT:
 443          if (val != cmp)
 444             matched = EGL_FALSE;
 445          break;
 446       case ATTRIB_CRITERION_ATLEAST:
 447          if (val < cmp)
 448             matched = EGL_FALSE;
 449          break;
 450       case ATTRIB_CRITERION_MASK:
 451          if ((val & cmp) != cmp)
 452             matched = EGL_FALSE;
 453          break;
 454       case ATTRIB_CRITERION_SPECIAL:
 455          /* ignored here */
 456          break;
 457       default:
 458          assert(0);
 459          break;
 460       }
 461
 462       if (!matched) {
 463 #ifdef DEBUG
 464          _eglLog(_EGL_DEBUG,
 465                "the value (0x%x) of attribute 0x%04x did not meet the criteria (0x%x)",
 466                val, attr, cmp);
 467 #endif
 468          break;
 469       }
 470    }
 471
 472    return matched;
 473 }
 474
 475 static INLINE EGLBoolean
 476 _eglIsConfigAttribValid(_EGLConfig *conf, EGLint attr)
 477 {
 478    if (_eglIndexConfig(conf, attr) < 0)
 479       return EGL_FALSE;
 480
 481    /* there are some holes in the range */
 482    switch (attr) {
 483    case 0x3030 /* a gap before EGL_SAMPLES */:
 484    case EGL_NONE:
 485 #ifdef EGL_VERSION_1_4
 486    case EGL_MATCH_NATIVE_PIXMAP:
 487 #endif
 488       return EGL_FALSE;
 489    case EGL_Y_INVERTED_NOK:
 490       return conf->Display->Extensions.NOK_texture_from_pixmap;
 491    default:
 492       break;
 493    }
 494
 495    return EGL_TRUE;
 496 }
 497
 498 /**
 499  * Initialize a criteria config from the given attribute list.
 500  * Return EGL_FALSE if any of the attribute is invalid.
 501  */
 502 EGLBoolean
 503 _eglParseConfigAttribList(_EGLConfig *conf, const EGLint *attrib_list)
 504 {
 505    EGLint attr, val, i;
 506    EGLint config_id = 0, level = 0;
 507    EGLBoolean has_native_visual_type = EGL_FALSE;
 508    EGLBoolean has_transparent_color = EGL_FALSE;
 509
 510    /* reset to default values */
 511    for (i = 0; i < ARRAY_SIZE(_eglValidationTable); i++) {
 512       attr = _eglValidationTable[i].attr;
 513       val = _eglValidationTable[i].default_value;
 514       SET_CONFIG_ATTRIB(conf, attr, val);
 515    }
 516
 517    /* parse the list */
 518    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i += 2) {
 519       attr = attrib_list[i];
 520       val = attrib_list[i + 1];
 521
 522       if (!_eglIsConfigAttribValid(conf, attr))
 523          return EGL_FALSE;
 524
 525       SET_CONFIG_ATTRIB(conf, attr, val);
 526
 527       /* rememeber some attributes for post-processing */
 528       switch (attr) {
 529       case EGL_CONFIG_ID:
 530          config_id = val;
 531          break;
 532       case EGL_LEVEL:
 533          level = val;
 534          break;
 535       case EGL_NATIVE_VISUAL_TYPE:
 536          has_native_visual_type = EGL_TRUE;
 537          break;
 538       case EGL_TRANSPARENT_RED_VALUE:
 539       case EGL_TRANSPARENT_GREEN_VALUE:
 540       case EGL_TRANSPARENT_BLUE_VALUE:
 541          has_transparent_color = EGL_TRUE;
 542          break;
 543       default:
 544          break;
 545       }
 546    }
 547
 548    if (!_eglValidateConfig(conf, EGL_TRUE))
 549       return EGL_FALSE;
 550
 551    /* the spec says that EGL_LEVEL cannot be EGL_DONT_CARE */
 552    if (level == EGL_DONT_CARE)
 553       return EGL_FALSE;
 554
 555    /* ignore other attributes when EGL_CONFIG_ID is given */
 556    if (config_id > 0) {
 557       _eglResetConfigKeys(conf, EGL_DONT_CARE);
 558       SET_CONFIG_ATTRIB(conf, EGL_CONFIG_ID, config_id);
 559    }
 560    else {
 561       if (has_native_visual_type) {
 562          val = GET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE);
 563          if (!(val & EGL_WINDOW_BIT))
 564             SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_TYPE, EGL_DONT_CARE);
 565       }
 566
 567       if (has_transparent_color) {
 568          val = GET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_TYPE);
 569          if (val == EGL_NONE) {
 570             SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_RED_VALUE,
 571                               EGL_DONT_CARE);
 572             SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_GREEN_VALUE,
 573                               EGL_DONT_CARE);
 574             SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_BLUE_VALUE,
 575                               EGL_DONT_CARE);
 576          }
 577       }
 578    }
 579
 580    return EGL_TRUE;
 581 }
 582
 583
 584 /**
 585  * Decide the ordering of conf1 and conf2, under the given criteria.
 586  * When compare_id is true, this implements the algorithm described
 587  * in "Sorting of EGLConfigs".  When compare_id is false,
 588  * EGL_CONFIG_ID is not compared.
 589  *
 590  * It returns a negative integer if conf1 is considered to come
 591  * before conf2;  a positive integer if conf2 is considered to come
 592  * before conf1;  zero if the ordering cannot be decided.
 593  *
 594  * Note that EGL_NATIVE_VISUAL_TYPE is platform-dependent and is
 595  * ignored here.
 596  */
 597 EGLint
 598 _eglCompareConfigs(const _EGLConfig *conf1, const _EGLConfig *conf2,
 599                    const _EGLConfig *criteria, EGLBoolean compare_id)
 600 {
 601    const EGLint compare_attribs[] = {
 602       EGL_BUFFER_SIZE,
 603       EGL_SAMPLE_BUFFERS,
 604       EGL_SAMPLES,
 605       EGL_DEPTH_SIZE,
 606       EGL_STENCIL_SIZE,
 607       EGL_ALPHA_MASK_SIZE,
 608    };
 609    EGLint val1, val2;
 610    EGLBoolean rgb_buffer;
 611    EGLint i;
 612
 613    if (conf1 == conf2)
 614       return 0;
 615
 616    /* the enum values have the desired ordering */
 617    assert(EGL_NONE < EGL_SLOW_CONFIG);
 618    assert(EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG);
 619    val1 = GET_CONFIG_ATTRIB(conf1, EGL_CONFIG_CAVEAT);
 620    val2 = GET_CONFIG_ATTRIB(conf2, EGL_CONFIG_CAVEAT);
 621    if (val1 != val2)
 622       return (val1 - val2);
 623
 624    /* the enum values have the desired ordering */
 625    assert(EGL_RGB_BUFFER < EGL_LUMINANCE_BUFFER);
 626    val1 = GET_CONFIG_ATTRIB(conf1, EGL_COLOR_BUFFER_TYPE);
 627    val2 = GET_CONFIG_ATTRIB(conf2, EGL_COLOR_BUFFER_TYPE);
 628    if (val1 != val2)
 629       return (val1 - val2);
 630    rgb_buffer = (val1 == EGL_RGB_BUFFER);
 631
 632    if (criteria) {
 633       val1 = val2 = 0;
 634       if (rgb_buffer) {
 635          if (GET_CONFIG_ATTRIB(criteria, EGL_RED_SIZE) > 0) {
 636             val1 += GET_CONFIG_ATTRIB(conf1, EGL_RED_SIZE);
 637             val2 += GET_CONFIG_ATTRIB(conf2, EGL_RED_SIZE);
 638          }
 639          if (GET_CONFIG_ATTRIB(criteria, EGL_GREEN_SIZE) > 0) {
 640             val1 += GET_CONFIG_ATTRIB(conf1, EGL_GREEN_SIZE);
 641             val2 += GET_CONFIG_ATTRIB(conf2, EGL_GREEN_SIZE);
 642          }
 643          if (GET_CONFIG_ATTRIB(criteria, EGL_BLUE_SIZE) > 0) {
 644             val1 += GET_CONFIG_ATTRIB(conf1, EGL_BLUE_SIZE);
 645             val2 += GET_CONFIG_ATTRIB(conf2, EGL_BLUE_SIZE);
 646          }
 647       }
 648       else {
 649          if (GET_CONFIG_ATTRIB(criteria, EGL_LUMINANCE_SIZE) > 0) {
 650             val1 += GET_CONFIG_ATTRIB(conf1, EGL_LUMINANCE_SIZE);
 651             val2 += GET_CONFIG_ATTRIB(conf2, EGL_LUMINANCE_SIZE);
 652          }
 653       }
 654       if (GET_CONFIG_ATTRIB(criteria, EGL_ALPHA_SIZE) > 0) {
 655          val1 += GET_CONFIG_ATTRIB(conf1, EGL_ALPHA_SIZE);
 656          val2 += GET_CONFIG_ATTRIB(conf2, EGL_ALPHA_SIZE);
 657       }
 658    }
 659    else {
 660       /* assume the default criteria, which gives no specific ordering */
 661       val1 = val2 = 0;
 662    }
 663
 664    /* for color bits, larger one is preferred */
 665    if (val1 != val2)
 666       return (val2 - val1);
 667
 668    for (i = 0; i < ARRAY_SIZE(compare_attribs); i++) {
 669       val1 = GET_CONFIG_ATTRIB(conf1, compare_attribs[i]);
 670       val2 = GET_CONFIG_ATTRIB(conf2, compare_attribs[i]);
 671       if (val1 != val2)
 672          return (val1 - val2);
 673    }
 674
 675    /* EGL_NATIVE_VISUAL_TYPE cannot be compared here */
 676
 677    if (compare_id) {
 678       val1 = GET_CONFIG_ATTRIB(conf1, EGL_CONFIG_ID);
 679       val2 = GET_CONFIG_ATTRIB(conf2, EGL_CONFIG_ID);
 680       assert(val1 != val2);
 681    }
 682    else {
 683       val1 = val2 = 0;
 684    }
 685
 686    return (val1 - val2);
 687 }
 688
 689
 690 static INLINE
 691 void _eglSwapConfigs(const _EGLConfig **conf1, const _EGLConfig **conf2)
 692 {
 693    const _EGLConfig *tmp = *conf1;
 694    *conf1 = *conf2;
 695    *conf2 = tmp;
 696 }
 697
 698
 699 /**
 700  * Quick sort an array of configs.  This differs from the standard
 701  * qsort() in that the compare function accepts an additional
 702  * argument.
 703  */
 704 void
 705 _eglSortConfigs(const _EGLConfig **configs, EGLint count,
 706                 EGLint (*compare)(const _EGLConfig *, const _EGLConfig *,
 707                                   void *),
 708                 void *priv_data)
 709 {
 710    const EGLint pivot = 0;
 711    EGLint i, j;
 712
 713    if (count <= 1)
 714       return;
 715
 716    _eglSwapConfigs(&configs[pivot], &configs[count / 2]);
 717    i = 1;
 718    j = count - 1;
 719    do {
 720       while (i < count && compare(configs[i], configs[pivot], priv_data) < 0)
 721          i++;
 722       while (compare(configs[j], configs[pivot], priv_data) > 0)
 723          j--;
 724       if (i < j) {
 725          _eglSwapConfigs(&configs[i], &configs[j]);
 726          i++;
 727          j--;
 728       }
 729       else if (i == j) {
 730          i++;
 731          j--;
 732          break;
 733       }
 734    } while (i <= j);
 735    _eglSwapConfigs(&configs[pivot], &configs[j]);
 736
 737    _eglSortConfigs(configs, j, compare, priv_data);
 738    _eglSortConfigs(configs + i, count - i, compare, priv_data);
 739 }
 740
 741
 742 static int
 743 _eglFallbackCompare(const _EGLConfig *conf1, const _EGLConfig *conf2,
 744                    void *priv_data)
 745 {
 746    const _EGLConfig *criteria = (const _EGLConfig *) priv_data;
 747    return _eglCompareConfigs(conf1, conf2, criteria, EGL_TRUE);
 748 }
 749
 750
 751 /**
 752  * Typical fallback routine for eglChooseConfig
 753  */
 754 EGLBoolean
 755 _eglChooseConfig(_EGLDriver *drv, _EGLDisplay *disp, const EGLint *attrib_list,
 756                  EGLConfig *configs, EGLint config_size, EGLint *num_configs)
 757 {
 758    _EGLConfig **configList, criteria;
 759    EGLint i, count;
 760
 761    if (!num_configs)
 762       return _eglError(EGL_BAD_PARAMETER, "eglChooseConfigs");
 763
 764    _eglInitConfig(&criteria, disp, 0);
 765    if (!_eglParseConfigAttribList(&criteria, attrib_list))
 766       return _eglError(EGL_BAD_ATTRIBUTE, "eglChooseConfig");
 767
 768    configList = (_EGLConfig **) _eglFilterArray(disp->Configs, &count,
 769          (_EGLArrayForEach) _eglMatchConfig, (void *) &criteria);
 770    if (!configList)
 771       return _eglError(EGL_BAD_ALLOC, "eglChooseConfig(out of memory)");
 772
 773    /* perform sorting of configs */
 774    if (configs && count) {
 775       _eglSortConfigs((const _EGLConfig **) configList, count,
 776                       _eglFallbackCompare, (void *) &criteria);
 777       count = MIN2(count, config_size);
 778       for (i = 0; i < count; i++)
 779          configs[i] = _eglGetConfigHandle(configList[i]);
 780    }
 781
 782    free(configList);
 783
 784    *num_configs = count;
 785
 786    return EGL_TRUE;
 787 }
 788
 789
 790 /**
 791  * Fallback for eglGetConfigAttrib.
 792  */
 793 EGLBoolean
 794 _eglGetConfigAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
 795                     EGLint attribute, EGLint *value)
 796 {
 797    if (!_eglIsConfigAttribValid(conf, attribute))
 798       return _eglError(EGL_BAD_ATTRIBUTE, "eglGetConfigAttrib");
 799    if (!value)
 800       return _eglError(EGL_BAD_PARAMETER, "eglGetConfigAttrib");
 801
 802    *value = GET_CONFIG_ATTRIB(conf, attribute);
 803    return EGL_TRUE;
 804 }
 805
 806
 807 static EGLBoolean
 808 _eglFlattenConfig(void *elem, void *buffer)
 809 {
 810    _EGLConfig *conf = (_EGLConfig *) elem;
 811    EGLConfig *handle = (EGLConfig *) buffer;
 812    *handle = _eglGetConfigHandle(conf);
 813    return EGL_TRUE;
 814 }
 815
 816 /**
 817  * Fallback for eglGetConfigs.
 818  */
 819 EGLBoolean
 820 _eglGetConfigs(_EGLDriver *drv, _EGLDisplay *disp, EGLConfig *configs,
 821                EGLint config_size, EGLint *num_config)
 822 {
 823    if (!num_config)
 824       return _eglError(EGL_BAD_PARAMETER, "eglGetConfigs");
 825
 826    *num_config = _eglFlattenArray(disp->Configs, (void *) configs,
 827          sizeof(configs[0]), config_size, _eglFlattenConfig);
 828
 829    return EGL_TRUE;
 830 }