modules/egl/teglChooseConfigReference.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program EGL Module
   3  * ---------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Choose config reference implementation.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglChooseConfigReference.hpp"
  25
  26 #include "egluUtil.hpp"
  27 #include "egluConfigInfo.hpp"
  28 #include "egluStrUtil.hpp"
  29 #include "eglwLibrary.hpp"
  30 #include "eglwEnums.hpp"
  31
  32 #include "deSTLUtil.hpp"
  33
  34 #include <algorithm>
  35 #include <vector>
  36 #include <map>
  37
  38 namespace deqp
  39 {
  40 namespace egl
  41 {
  42
  43 using namespace eglw;
  44 using eglu::ConfigInfo;
  45
  46 enum Criteria
  47 {
  48         CRITERIA_AT_LEAST = 0,
  49         CRITERIA_EXACT,
  50         CRITERIA_MASK,
  51         CRITERIA_SPECIAL,
  52
  53         CRITERIA_LAST
  54 };
  55
  56 enum SortOrder
  57 {
  58         SORTORDER_NONE  = 0,
  59         SORTORDER_SMALLER,
  60         SORTORDER_SPECIAL,
  61
  62         SORTORDER_LAST
  63 };
  64
  65 struct AttribRule
  66 {
  67         EGLenum         name;
  68         EGLint          value;
  69         Criteria        criteria;
  70         SortOrder       sortOrder;
  71
  72         AttribRule (void)
  73                 : name                  (EGL_NONE)
  74                 , value                 (EGL_NONE)
  75                 , criteria              (CRITERIA_LAST)
  76                 , sortOrder             (SORTORDER_LAST)
  77         {
  78         }
  79
  80         AttribRule (EGLenum name_, EGLint value_, Criteria criteria_, SortOrder sortOrder_)
  81                 : name                  (name_)
  82                 , value                 (value_)
  83                 , criteria              (criteria_)
  84                 , sortOrder             (sortOrder_)
  85         {
  86         }
  87 };
  88
  89 class SurfaceConfig
  90 {
  91 private:
  92         static int getCaveatRank (EGLenum caveat)
  93         {
  94                 switch (caveat)
  95                 {
  96                         case EGL_NONE:                                  return 0;
  97                         case EGL_SLOW_CONFIG:                   return 1;
  98                         case EGL_NON_CONFORMANT_CONFIG: return 2;
  99                         default:
 100                                 TCU_THROW(TestError, (std::string("Unknown config caveat: ") + eglu::getConfigCaveatStr(caveat).toString()).c_str());
 101                 }
 102         }
 103
 104         static int getColorBufferTypeRank (EGLenum type)
 105         {
 106                 switch (type)
 107                 {
 108                         case EGL_RGB_BUFFER:                    return 0;
 109                         case EGL_LUMINANCE_BUFFER:              return 1;
 110                         case EGL_YUV_BUFFER_EXT:                return 2;
 111                         default:
 112                                 TCU_THROW(TestError, (std::string("Unknown color buffer type: ") + eglu::getColorBufferTypeStr(type).toString()).c_str());
 113                 }
 114         }
 115
 116         static int getYuvOrderRank (EGLenum order)
 117         {
 118                 switch (order)
 119                 {
 120                         case EGL_NONE:                                  return 0;
 121                         case EGL_YUV_ORDER_YUV_EXT:             return 1;
 122                         case EGL_YUV_ORDER_YVU_EXT:             return 2;
 123                         case EGL_YUV_ORDER_YUYV_EXT:    return 3;
 124                         case EGL_YUV_ORDER_YVYU_EXT:    return 4;
 125                         case EGL_YUV_ORDER_UYVY_EXT:    return 5;
 126                         case EGL_YUV_ORDER_VYUY_EXT:    return 6;
 127                         case EGL_YUV_ORDER_AYUV_EXT:    return 7;
 128                         default:
 129                                 TCU_THROW(TestError, (std::string("Unknown YUV order: ") + eglu::getYuvOrderStr(order).toString()).c_str());
 130                 }
 131         }
 132
 133         static int getYuvPlaneBppValue (EGLenum bpp)
 134         {
 135                 switch (bpp)
 136                 {
 137                         case EGL_YUV_PLANE_BPP_0_EXT:   return 0;
 138                         case EGL_YUV_PLANE_BPP_8_EXT:   return 8;
 139                         case EGL_YUV_PLANE_BPP_10_EXT:  return 10;
 140                         default:
 141                                 TCU_THROW(TestError, (std::string("Unknown YUV plane BPP: ") + eglu::getYuvPlaneBppStr(bpp).toString()).c_str());
 142                 }
 143         }
 144
 145         typedef bool (*CompareFunc) (const SurfaceConfig& a, const SurfaceConfig& b);
 146
 147         static bool compareCaveat (const SurfaceConfig& a, const SurfaceConfig& b)
 148         {
 149                 return getCaveatRank((EGLenum)a.m_info.configCaveat) < getCaveatRank((EGLenum)b.m_info.configCaveat);
 150         }
 151
 152         static bool compareColorBufferType (const SurfaceConfig& a, const SurfaceConfig& b)
 153         {
 154                 return getColorBufferTypeRank((EGLenum)a.m_info.colorBufferType) < getColorBufferTypeRank((EGLenum)b.m_info.colorBufferType);
 155         }
 156
 157         static bool compareYuvOrder (const SurfaceConfig& a, const SurfaceConfig& b)
 158         {
 159                 return getYuvOrderRank((EGLenum)a.m_info.yuvOrder) < getYuvOrderRank((EGLenum)b.m_info.yuvOrder);
 160         }
 161
 162         static bool compareColorBufferBits (const SurfaceConfig& a, const SurfaceConfig& b, const tcu::BVec4& specifiedRGBColors, const tcu::BVec2& specifiedLuminanceColors, bool yuvPlaneBppSpecified)
 163         {
 164                 DE_ASSERT(a.m_info.colorBufferType == b.m_info.colorBufferType);
 165                 switch (a.m_info.colorBufferType)
 166                 {
 167                         case EGL_RGB_BUFFER:
 168                         {
 169                                 const tcu::IVec4        mask    (specifiedRGBColors.cast<deInt32>());
 170
 171                                 return (a.m_info.redSize * mask[0] + a.m_info.greenSize * mask[1] + a.m_info.blueSize * mask[2] + a.m_info.alphaSize * mask[3])
 172                                                 > (b.m_info.redSize * mask[0] + b.m_info.greenSize * mask[1] + b.m_info.blueSize * mask[2] + b.m_info.alphaSize * mask[3]);
 173                         }
 174
 175                         case EGL_LUMINANCE_BUFFER:
 176                         {
 177                                 const tcu::IVec2        mask    (specifiedLuminanceColors.cast<deInt32>());
 178
 179                                 return (a.m_info.luminanceSize * mask[0] + a.m_info.alphaSize * mask[1]) > (b.m_info.luminanceSize * mask[0] + b.m_info.alphaSize * mask[1]);
 180                         }
 181
 182                         case EGL_YUV_BUFFER_EXT:
 183                                 return yuvPlaneBppSpecified ? (a.m_info.yuvPlaneBpp > b.m_info.yuvPlaneBpp) : false;
 184
 185                         default:
 186                                 DE_ASSERT(DE_FALSE);
 187                                 return true;
 188                 }
 189         }
 190
 191         template <EGLenum Attribute>
 192         static bool compareAttributeSmaller (const SurfaceConfig& a, const SurfaceConfig& b)
 193         {
 194                 return a.getAttribute(Attribute) < b.getAttribute(Attribute);
 195         }
 196 public:
 197         SurfaceConfig (EGLConfig config, ConfigInfo &info)
 198                 : m_config(config)
 199                 , m_info(info)
 200         {
 201         }
 202
 203         EGLConfig getEglConfig (void) const
 204         {
 205                 return m_config;
 206         }
 207
 208         EGLint getAttribute (const EGLenum attribute) const
 209         {
 210                 return m_info.getAttribute(attribute);
 211         }
 212
 213         friend bool operator== (const SurfaceConfig& a, const SurfaceConfig& b)
 214         {
 215                 const std::map<EGLenum, AttribRule> defaultRules = getDefaultRules();
 216
 217                 for (std::map<EGLenum, AttribRule>::const_iterator iter = defaultRules.begin(); iter != defaultRules.end(); iter++)
 218                 {
 219                         const EGLenum attribute = iter->first;
 220
 221                         if (a.getAttribute(attribute) != b.getAttribute(attribute)) return false;
 222                 }
 223                 return true;
 224         }
 225
 226         bool compareTo (const SurfaceConfig& b, const tcu::BVec4& specifiedRGBColors, const tcu::BVec2& specifiedLuminanceColors, bool yuvPlaneBppSpecified) const
 227         {
 228                 static const SurfaceConfig::CompareFunc compareFuncs[] =
 229                 {
 230                         SurfaceConfig::compareCaveat,
 231                         SurfaceConfig::compareColorBufferType,
 232                         DE_NULL, // SurfaceConfig::compareColorBufferBits,
 233                         SurfaceConfig::compareAttributeSmaller<EGL_BUFFER_SIZE>,
 234                         SurfaceConfig::compareAttributeSmaller<EGL_SAMPLE_BUFFERS>,
 235                         SurfaceConfig::compareAttributeSmaller<EGL_SAMPLES>,
 236                         SurfaceConfig::compareAttributeSmaller<EGL_DEPTH_SIZE>,
 237                         SurfaceConfig::compareAttributeSmaller<EGL_STENCIL_SIZE>,
 238                         SurfaceConfig::compareAttributeSmaller<EGL_ALPHA_MASK_SIZE>,
 239                         SurfaceConfig::compareYuvOrder,
 240                         SurfaceConfig::compareAttributeSmaller<EGL_CONFIG_ID>
 241                 };
 242
 243                 if (*this == b)
 244                         return false; // std::sort() can compare object to itself.
 245
 246                 for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(compareFuncs); ndx++)
 247                 {
 248                         if (!compareFuncs[ndx])
 249                         {
 250                                 if (compareColorBufferBits(*this, b, specifiedRGBColors, specifiedLuminanceColors, yuvPlaneBppSpecified))
 251                                         return true;
 252                                 else if (compareColorBufferBits(b, *this, specifiedRGBColors, specifiedLuminanceColors, yuvPlaneBppSpecified))
 253                                         return false;
 254
 255                                 continue;
 256                         }
 257
 258                         if (compareFuncs[ndx](*this, b))
 259                                 return true;
 260                         else if (compareFuncs[ndx](b, *this))
 261                                 return false;
 262                 }
 263
 264                 TCU_FAIL("Unable to compare configs - duplicate ID?");
 265         }
 266
 267         static std::map<EGLenum, AttribRule> getDefaultRules (void)
 268         {
 269                 // \todo [2011-03-24 pyry] From EGL 1.4 spec - check that this is valid for other versions as well
 270                 std::map<EGLenum, AttribRule> rules;
 271
 272                 //                                                                      Attribute                                                                       Default                         Selection Criteria      Sort Order                      Sort Priority
 273                 rules[EGL_BUFFER_SIZE]                          = AttribRule(EGL_BUFFER_SIZE,                           0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      4
 274                 rules[EGL_RED_SIZE]                                     = AttribRule(EGL_RED_SIZE,                                      0,                                      CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 275                 rules[EGL_GREEN_SIZE]                           = AttribRule(EGL_GREEN_SIZE,                            0,                                      CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 276                 rules[EGL_BLUE_SIZE]                            = AttribRule(EGL_BLUE_SIZE,                                     0,                                      CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 277                 rules[EGL_LUMINANCE_SIZE]                       = AttribRule(EGL_LUMINANCE_SIZE,                        0,                                      CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 278                 rules[EGL_ALPHA_SIZE]                           = AttribRule(EGL_ALPHA_SIZE,                            0,                                      CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 279                 rules[EGL_ALPHA_MASK_SIZE]                      = AttribRule(EGL_ALPHA_MASK_SIZE,                       0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      9
 280                 rules[EGL_BIND_TO_TEXTURE_RGB]          = AttribRule(EGL_BIND_TO_TEXTURE_RGB,           EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 281                 rules[EGL_BIND_TO_TEXTURE_RGBA]         = AttribRule(EGL_BIND_TO_TEXTURE_RGBA,          EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 282                 rules[EGL_COLOR_BUFFER_TYPE]            = AttribRule(EGL_COLOR_BUFFER_TYPE,                     EGL_RGB_BUFFER,         CRITERIA_EXACT,         SORTORDER_NONE);        //      2
 283                 rules[EGL_CONFIG_CAVEAT]                        = AttribRule(EGL_CONFIG_CAVEAT,                         EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_SPECIAL);     //      1
 284                 rules[EGL_CONFIG_ID]                            = AttribRule(EGL_CONFIG_ID,                                     EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_SMALLER);     //      11
 285                 rules[EGL_CONFORMANT]                           = AttribRule(EGL_CONFORMANT,                            0,                                      CRITERIA_MASK,          SORTORDER_NONE);
 286                 rules[EGL_DEPTH_SIZE]                           = AttribRule(EGL_DEPTH_SIZE,                            0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      7
 287                 rules[EGL_LEVEL]                                        = AttribRule(EGL_LEVEL,                                         0,                                      CRITERIA_EXACT,         SORTORDER_NONE);
 288                 rules[EGL_MAX_SWAP_INTERVAL]            = AttribRule(EGL_MAX_SWAP_INTERVAL,                     EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 289                 rules[EGL_MIN_SWAP_INTERVAL]            = AttribRule(EGL_MIN_SWAP_INTERVAL,                     EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 290                 rules[EGL_NATIVE_RENDERABLE]            = AttribRule(EGL_NATIVE_RENDERABLE,                     EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 291                 rules[EGL_NATIVE_VISUAL_TYPE]           = AttribRule(EGL_NATIVE_VISUAL_TYPE,            EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_SPECIAL);     //      10
 292                 rules[EGL_RENDERABLE_TYPE]                      = AttribRule(EGL_RENDERABLE_TYPE,                       EGL_OPENGL_ES_BIT,      CRITERIA_MASK,          SORTORDER_NONE);
 293                 rules[EGL_SAMPLE_BUFFERS]                       = AttribRule(EGL_SAMPLE_BUFFERS,                        0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      5
 294                 rules[EGL_SAMPLES]                                      = AttribRule(EGL_SAMPLES,                                       0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      6
 295                 rules[EGL_STENCIL_SIZE]                         = AttribRule(EGL_STENCIL_SIZE,                          0,                                      CRITERIA_AT_LEAST,      SORTORDER_SMALLER);     //      8
 296                 rules[EGL_SURFACE_TYPE]                         = AttribRule(EGL_SURFACE_TYPE,                          EGL_WINDOW_BIT,         CRITERIA_MASK,          SORTORDER_NONE);
 297                 rules[EGL_TRANSPARENT_TYPE]                     = AttribRule(EGL_TRANSPARENT_TYPE,                      EGL_NONE,                       CRITERIA_EXACT,         SORTORDER_NONE);
 298                 rules[EGL_TRANSPARENT_RED_VALUE]        = AttribRule(EGL_TRANSPARENT_RED_VALUE,         EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 299                 rules[EGL_TRANSPARENT_GREEN_VALUE]      = AttribRule(EGL_TRANSPARENT_GREEN_VALUE,       EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 300                 rules[EGL_TRANSPARENT_BLUE_VALUE]       = AttribRule(EGL_TRANSPARENT_BLUE_VALUE,        EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 301
 302                 // EGL_EXT_yuv_surface
 303                 rules[EGL_YUV_ORDER_EXT]                        = AttribRule(EGL_YUV_ORDER_EXT,                         EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_SPECIAL);
 304                 rules[EGL_YUV_NUMBER_OF_PLANES_EXT]     = AttribRule(EGL_YUV_NUMBER_OF_PLANES_EXT,      EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 305                 rules[EGL_YUV_SUBSAMPLE_EXT]            = AttribRule(EGL_YUV_SUBSAMPLE_EXT,                     EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 306                 rules[EGL_YUV_DEPTH_RANGE_EXT]          = AttribRule(EGL_YUV_DEPTH_RANGE_EXT,           EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 307                 rules[EGL_YUV_CSC_STANDARD_EXT]         = AttribRule(EGL_YUV_CSC_STANDARD_EXT,          EGL_DONT_CARE,          CRITERIA_EXACT,         SORTORDER_NONE);
 308                 rules[EGL_YUV_PLANE_BPP_EXT]            = AttribRule(EGL_YUV_PLANE_BPP_EXT,                     EGL_DONT_CARE,          CRITERIA_AT_LEAST,      SORTORDER_SPECIAL);     //      3
 309
 310                 return rules;
 311         }
 312 private:
 313         EGLConfig m_config;
 314         ConfigInfo m_info;
 315 };
 316
 317 class CompareConfigs
 318 {
 319 public:
 320         CompareConfigs (const tcu::BVec4& specifiedRGBColors, const tcu::BVec2& specifiedLuminanceColors, bool yuvPlaneBppSpecified)
 321                 : m_specifiedRGBColors                  (specifiedRGBColors)
 322                 , m_specifiedLuminanceColors    (specifiedLuminanceColors)
 323                 , m_yuvPlaneBppSpecified                (yuvPlaneBppSpecified)
 324         {
 325         }
 326
 327         bool operator() (const SurfaceConfig& a, const SurfaceConfig& b)
 328         {
 329                 return a.compareTo(b, m_specifiedRGBColors, m_specifiedLuminanceColors, m_yuvPlaneBppSpecified);
 330         }
 331
 332 private:
 333         const tcu::BVec4        m_specifiedRGBColors;
 334         const tcu::BVec2        m_specifiedLuminanceColors;
 335         const bool                      m_yuvPlaneBppSpecified;
 336 };
 337
 338 class ConfigFilter
 339 {
 340 private:
 341         std::map<EGLenum, AttribRule> m_rules;
 342 public:
 343         ConfigFilter ()
 344                 : m_rules(SurfaceConfig::getDefaultRules())
 345         {
 346         }
 347
 348         void setValue (EGLenum name, EGLint value)
 349         {
 350                 DE_ASSERT(de::contains(m_rules, name));
 351                 m_rules[name].value = value;
 352         }
 353
 354         void setValues (std::vector<std::pair<EGLenum, EGLint> > values)
 355         {
 356                 for (size_t ndx = 0; ndx < values.size(); ndx++)
 357                 {
 358                         const EGLenum   name    = values[ndx].first;
 359                         const EGLint    value   = values[ndx].second;
 360
 361                         setValue(name, value);
 362                 }
 363         }
 364
 365         AttribRule getAttribute (EGLenum name) const
 366         {
 367                 DE_ASSERT(de::contains(m_rules, name));
 368                 return m_rules.find(name)->second;
 369         }
 370
 371         bool isMatch (const SurfaceConfig& config) const
 372         {
 373                 for (std::map<EGLenum, AttribRule>::const_iterator iter = m_rules.begin(); iter != m_rules.end(); iter++)
 374                 {
 375                         const AttribRule rule = iter->second;
 376
 377                         if (rule.value == EGL_DONT_CARE)
 378                                 continue;
 379                         else if (rule.name == EGL_MATCH_NATIVE_PIXMAP)
 380                                 TCU_CHECK(rule.value == EGL_NONE); // Not supported
 381                         else if (rule.name == EGL_TRANSPARENT_RED_VALUE || rule.name == EGL_TRANSPARENT_GREEN_VALUE || rule.name == EGL_TRANSPARENT_BLUE_VALUE)
 382                                 continue;
 383                         else
 384                         {
 385                                 const EGLint cfgValue = config.getAttribute(rule.name);
 386
 387                                 switch (rule.criteria)
 388                                 {
 389                                         case CRITERIA_EXACT:
 390                                                 if (rule.value != cfgValue)
 391                                                         return false;
 392                                                 break;
 393
 394                                         case CRITERIA_AT_LEAST:
 395                                                 if (rule.value > cfgValue)
 396                                                         return false;
 397                                                 break;
 398
 399                                         case CRITERIA_MASK:
 400                                                 if ((rule.value & cfgValue) != rule.value)
 401                                                         return false;
 402                                                 break;
 403
 404                                         default:
 405                                                 TCU_FAIL("Unknown criteria");
 406                                 }
 407                         }
 408                 }
 409
 410                 return true;
 411         }
 412
 413         tcu::BVec4 getSpecifiedRGBColors (void) const
 414         {
 415                 const EGLenum bitAttribs[] =
 416                 {
 417                         EGL_RED_SIZE,
 418                         EGL_GREEN_SIZE,
 419                         EGL_BLUE_SIZE,
 420                         EGL_ALPHA_SIZE
 421                 };
 422
 423                 tcu::BVec4 result;
 424
 425                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(bitAttribs); ndx++)
 426                 {
 427                         const EGLenum   attrib  = bitAttribs[ndx];
 428                         const EGLint    value   = getAttribute(attrib).value;
 429
 430                         if (value != 0 && value != EGL_DONT_CARE)
 431                                 result[ndx] = true;
 432                         else
 433                                 result[ndx] = false;
 434                 }
 435
 436                 return result;
 437         }
 438
 439         tcu::BVec2 getSpecifiedLuminanceColors (void) const
 440         {
 441                 const EGLenum bitAttribs[] =
 442                 {
 443                         EGL_LUMINANCE_SIZE,
 444                         EGL_ALPHA_SIZE
 445                 };
 446
 447                 tcu::BVec2 result;
 448
 449                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(bitAttribs); ndx++)
 450                 {
 451                         const EGLenum   attrib  = bitAttribs[ndx];
 452                         const EGLint    value   = getAttribute(attrib).value;
 453
 454                         if (value != 0 && value != EGL_DONT_CARE)
 455                                 result[ndx] = true;
 456                         else
 457                                 result[ndx] = false;
 458                 }
 459
 460                 return result;
 461         }
 462
 463         bool isYuvPlaneBppSpecified (void) const
 464         {
 465                 const EGLenum   attrib  = EGL_YUV_PLANE_BPP_EXT;
 466                 const EGLint    value   = getAttribute(attrib).value;
 467
 468                 return (value != 0) && (value != EGL_DONT_CARE);
 469         }
 470
 471         std::vector<SurfaceConfig> filter (const std::vector<SurfaceConfig>& configs) const
 472         {
 473                 std::vector<SurfaceConfig> out;
 474
 475                 for (std::vector<SurfaceConfig>::const_iterator iter = configs.begin(); iter != configs.end(); iter++)
 476                 {
 477                         if (isMatch(*iter)) out.push_back(*iter);
 478                 }
 479
 480                 return out;
 481         }
 482 };
 483
 484 void chooseConfigReference (const Library& egl, EGLDisplay display, std::vector<EGLConfig>& dst, const std::vector<std::pair<EGLenum, EGLint> >& attributes)
 485 {
 486         // Get all configs
 487         std::vector<EGLConfig> eglConfigs = eglu::getConfigs(egl, display);
 488
 489         // Config infos - including extension attributes
 490         std::vector<ConfigInfo> configInfos;
 491         configInfos.resize(eglConfigs.size());
 492
 493         for (size_t ndx = 0; ndx < eglConfigs.size(); ndx++)
 494         {
 495                 eglu::queryCoreConfigInfo(egl, display, eglConfigs[ndx], &configInfos[ndx]);
 496                 eglu::queryExtConfigInfo(egl, display, eglConfigs[ndx], &configInfos[ndx]);
 497         }
 498
 499         // Pair configs with info
 500         std::vector<SurfaceConfig> configs;
 501         for (size_t ndx = 0; ndx < eglConfigs.size(); ndx++)
 502                 configs.push_back(SurfaceConfig(eglConfigs[ndx], configInfos[ndx]));
 503
 504         // Filter configs
 505         ConfigFilter configFilter;
 506         configFilter.setValues(attributes);
 507
 508         std::vector<SurfaceConfig> filteredConfigs = configFilter.filter(configs);
 509
 510         // Sort configs
 511         std::sort(filteredConfigs.begin(), filteredConfigs.end(), CompareConfigs(configFilter.getSpecifiedRGBColors(), configFilter.getSpecifiedLuminanceColors(), configFilter.isYuvPlaneBppSpecified()));
 512
 513         // Write to dst list
 514         dst.resize(filteredConfigs.size());
 515         for (size_t ndx = 0; ndx < filteredConfigs.size(); ndx++)
 516                 dst[ndx] = filteredConfigs[ndx].getEglConfig();
 517 }
 518
 519 } // egl
 520 } // deqp