src/egl/main/eglconfig.c

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