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 Base class for rendering tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglRenderCase.hpp" 25 26 #include "teglSimpleConfigCase.hpp" 27 28 #include "egluNativeDisplay.hpp" 29 #include "egluNativeWindow.hpp" 30 #include "egluNativePixmap.hpp" 31 #include "egluUtil.hpp" 32 #include "egluUnique.hpp" 33 34 #include "eglwLibrary.hpp" 35 #include "eglwEnums.hpp" 36 37 #include "tcuRenderTarget.hpp" 38 #include "tcuTestLog.hpp" 39 #include "tcuCommandLine.hpp" 40 41 #include "deStringUtil.hpp" 42 #include "deUniquePtr.hpp" 43 44 #include <algorithm> 45 #include <iterator> 46 #include <memory> 47 #include <set> 48 49 namespace deqp 50 { 51 namespace egl 52 { 53 54 using std::string; 55 using std::vector; 56 using std::set; 57 using tcu::TestLog; 58 using namespace eglw; 59 60 static void postSurface (const Library& egl, EGLDisplay display, EGLSurface surface, EGLint typeBit) 61 { 62 if (typeBit == EGL_WINDOW_BIT) 63 EGLU_CHECK_CALL(egl, swapBuffers(display, surface)); 64 else if (typeBit == EGL_PIXMAP_BIT) 65 EGLU_CHECK_CALL(egl, waitClient()); 66 else if (typeBit == EGL_PBUFFER_BIT) 67 EGLU_CHECK_CALL(egl, waitClient()); 68 else 69 DE_ASSERT(false); 70 } 71 72 // RenderCase 73 74 RenderCase::RenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint surfaceTypeMask, const eglu::FilterList& filters) 75 : SimpleConfigCase (eglTestCtx, name, description, filters) 76 , m_surfaceTypeMask (surfaceTypeMask) 77 { 78 } 79 80 RenderCase::~RenderCase (void) 81 { 82 } 83 84 EGLint getBuildClientAPIMask (void) 85 { 86 EGLint apiMask = 0; 87 88 // Always supported regardless of flags - dynamically loaded 89 apiMask |= EGL_OPENGL_ES2_BIT; 90 apiMask |= EGL_OPENGL_ES3_BIT; 91 apiMask |= EGL_OPENGL_BIT; 92 93 #if defined(DEQP_SUPPORT_GLES1) 94 apiMask |= EGL_OPENGL_ES_BIT; 95 #endif 96 97 #if defined(DEQP_SUPPORT_VG) 98 apiMask |= EGL_OPENVG_BIT; 99 #endif 100 101 return apiMask; 102 } 103 104 static void checkBuildClientAPISupport (EGLint requiredAPIs) 105 { 106 const EGLint builtClientAPIs = getBuildClientAPIMask(); 107 108 #if !defined(DEQP_SUPPORT_GLES1) 109 if (requiredAPIs & EGL_OPENGL_ES_BIT) 110 TCU_THROW(NotSupportedError, "Test case requires ES1.1 API not supported in current build"); 111 else 112 #endif 113 if ((requiredAPIs & builtClientAPIs) != requiredAPIs) 114 TCU_THROW(InternalError, "Test case requires client API not supported in current build"); 115 } 116 117 void RenderCase::executeForConfig (EGLDisplay display, EGLConfig config) 118 { 119 const Library& egl = m_eglTestCtx.getLibrary(); 120 tcu::TestLog& log = m_testCtx.getLog(); 121 const int width = 128; 122 const int height = 128; 123 const EGLint configId = eglu::getConfigID(egl, display, config); 124 125 const eglu::NativeDisplayFactory& displayFactory = m_eglTestCtx.getNativeDisplayFactory(); 126 eglu::NativeDisplay& nativeDisplay = m_eglTestCtx.getNativeDisplay(); 127 128 bool isOk = true; 129 string failReason = ""; 130 131 if (m_surfaceTypeMask & EGL_WINDOW_BIT) 132 { 133 tcu::ScopedLogSection(log, 134 string("Config") + de::toString(configId) + "-Window", 135 string("Config ID ") + de::toString(configId) + ", window surface"); 136 137 const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(displayFactory, m_testCtx.getCommandLine()); 138 139 try 140 { 141 const eglu::WindowParams params (width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())); 142 de::UniquePtr<eglu::NativeWindow> window (windowFactory.createWindow(&nativeDisplay, display, config, DE_NULL, params)); 143 EGLSurface eglSurface = createWindowSurface(nativeDisplay, *window, display, config, DE_NULL); 144 eglu::UniqueSurface surface (egl, display, eglSurface); 145 146 executeForSurface(display, *surface, Config(config, EGL_WINDOW_BIT, 0)); 147 } 148 catch (const tcu::TestError& e) 149 { 150 log << e; 151 isOk = false; 152 failReason = e.what(); 153 } 154 } 155 156 if (m_surfaceTypeMask & EGL_PIXMAP_BIT) 157 { 158 tcu::ScopedLogSection(log, 159 string("Config") + de::toString(configId) + "-Pixmap", 160 string("Config ID ") + de::toString(configId) + ", pixmap surface"); 161 162 const eglu::NativePixmapFactory& pixmapFactory = eglu::selectNativePixmapFactory(displayFactory, m_testCtx.getCommandLine()); 163 164 try 165 { 166 de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory.createPixmap(&nativeDisplay, display, config, DE_NULL, width, height)); 167 EGLSurface eglSurface = createPixmapSurface(nativeDisplay, *pixmap, display, config, DE_NULL); 168 eglu::UniqueSurface surface (egl, display, eglSurface); 169 170 executeForSurface(display, *surface, Config(config, EGL_PIXMAP_BIT, 0)); 171 } 172 catch (const tcu::TestError& e) 173 { 174 log << e; 175 isOk = false; 176 failReason = e.what(); 177 } 178 } 179 180 if (m_surfaceTypeMask & EGL_PBUFFER_BIT) 181 { 182 tcu::ScopedLogSection(log, 183 string("Config") + de::toString(configId) + "-Pbuffer", 184 string("Config ID ") + de::toString(configId) + ", pbuffer surface"); 185 try 186 { 187 const EGLint surfaceAttribs[] = 188 { 189 EGL_WIDTH, width, 190 EGL_HEIGHT, height, 191 EGL_NONE 192 }; 193 194 eglu::UniqueSurface surface(egl, display, egl.createPbufferSurface(display, config, surfaceAttribs)); 195 EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()"); 196 197 executeForSurface(display, *surface, Config(config, EGL_PBUFFER_BIT, 0)); 198 } 199 catch (const tcu::TestError& e) 200 { 201 log << e; 202 isOk = false; 203 failReason = e.what(); 204 } 205 } 206 207 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 208 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, failReason.c_str()); 209 } 210 211 // SingleContextRenderCase 212 213 SingleContextRenderCase::SingleContextRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint apiMask, EGLint surfaceTypeMask, const eglu::FilterList& filters) 214 : RenderCase (eglTestCtx, name, description, surfaceTypeMask, filters) 215 , m_apiMask (apiMask) 216 { 217 } 218 219 SingleContextRenderCase::~SingleContextRenderCase (void) 220 { 221 } 222 223 void SingleContextRenderCase::executeForSurface (EGLDisplay display, EGLSurface surface, const Config& config) 224 { 225 const Library& egl = m_eglTestCtx.getLibrary(); 226 const EGLint apis[] = { EGL_OPENGL_ES2_BIT, EGL_OPENGL_ES3_BIT_KHR, EGL_OPENGL_ES_BIT, EGL_OPENVG_BIT }; 227 tcu::TestLog& log = m_testCtx.getLog(); 228 const EGLint configApiMask = eglu::getConfigAttribInt(egl, display, config.config, EGL_RENDERABLE_TYPE); 229 230 checkBuildClientAPISupport(m_apiMask); 231 232 for (int apiNdx = 0; apiNdx < DE_LENGTH_OF_ARRAY(apis); apiNdx++) 233 { 234 EGLint apiBit = apis[apiNdx]; 235 236 // Skip API if build or current config doesn't support it. 237 if ((apiBit & m_apiMask) == 0 || (apiBit & configApiMask) == 0) 238 continue; 239 240 EGLint api = EGL_NONE; 241 const char* apiName = DE_NULL; 242 vector<EGLint> contextAttribs; 243 244 // Select api enum and build context attributes. 245 switch (apiBit) 246 { 247 case EGL_OPENGL_ES2_BIT: 248 api = EGL_OPENGL_ES_API; 249 apiName = "OpenGL ES 2.x"; 250 contextAttribs.push_back(EGL_CONTEXT_CLIENT_VERSION); 251 contextAttribs.push_back(2); 252 break; 253 254 case EGL_OPENGL_ES3_BIT_KHR: 255 api = EGL_OPENGL_ES_API; 256 apiName = "OpenGL ES 3.x"; 257 contextAttribs.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR); 258 contextAttribs.push_back(3); 259 break; 260 261 case EGL_OPENGL_ES_BIT: 262 api = EGL_OPENGL_ES_API; 263 apiName = "OpenGL ES 1.x"; 264 contextAttribs.push_back(EGL_CONTEXT_CLIENT_VERSION); 265 contextAttribs.push_back(1); 266 break; 267 268 case EGL_OPENVG_BIT: 269 api = EGL_OPENVG_API; 270 apiName = "OpenVG"; 271 break; 272 273 default: 274 DE_ASSERT(DE_FALSE); 275 } 276 277 contextAttribs.push_back(EGL_NONE); 278 279 log << TestLog::Message << apiName << TestLog::EndMessage; 280 281 EGLU_CHECK_CALL(egl, bindAPI(api)); 282 283 eglu::UniqueContext context (egl, display, egl.createContext(display, config.config, EGL_NO_CONTEXT, &contextAttribs[0])); 284 285 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, *context)); 286 executeForContext(display, *context, surface, Config(config.config, config.surfaceTypeBit, apiBit)); 287 288 // Call SwapBuffers() / WaitClient() to finish rendering 289 postSurface(egl, display, surface, config.surfaceTypeBit); 290 } 291 292 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 293 } 294 295 // MultiContextRenderCase 296 297 MultiContextRenderCase::MultiContextRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi) 298 : RenderCase (eglTestCtx, name, description, surfaceType, filters) 299 , m_numContextsPerApi (numContextsPerApi) 300 , m_apiMask (api) 301 { 302 } 303 304 MultiContextRenderCase::~MultiContextRenderCase (void) 305 { 306 } 307 308 void MultiContextRenderCase::executeForSurface (EGLDisplay display, EGLSurface surface, const Config& config) 309 { 310 const Library& egl = m_eglTestCtx.getLibrary(); 311 const EGLint configApiMask = eglu::getConfigAttribInt(egl, display, config.config, EGL_RENDERABLE_TYPE); 312 vector<std::pair<EGLint, EGLContext> > contexts; 313 contexts.reserve(3*m_numContextsPerApi); // 3 types of contexts at maximum. 314 315 checkBuildClientAPISupport(m_apiMask); 316 317 // ConfigFilter should make sure that config always supports all of the APIs. 318 TCU_CHECK_INTERNAL((configApiMask & m_apiMask) == m_apiMask); 319 320 try 321 { 322 // Create contexts that will participate in rendering. 323 for (int ndx = 0; ndx < m_numContextsPerApi; ndx++) 324 { 325 if (m_apiMask & EGL_OPENGL_ES2_BIT) 326 { 327 static const EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 328 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API)); 329 contexts.push_back(std::make_pair(EGL_OPENGL_ES2_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0]))); 330 } 331 332 if (m_apiMask & EGL_OPENGL_ES3_BIT_KHR) 333 { 334 static const EGLint attribs[] = { EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_NONE }; 335 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API)); 336 contexts.push_back(std::make_pair(EGL_OPENGL_ES3_BIT_KHR, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0]))); 337 } 338 339 if (m_apiMask & EGL_OPENGL_ES_BIT) 340 { 341 static const EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE }; 342 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API)); 343 contexts.push_back(std::make_pair(EGL_OPENGL_ES_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0]))); 344 } 345 346 if (m_apiMask & EGL_OPENVG_BIT) 347 { 348 static const EGLint attribs[] = { EGL_NONE }; 349 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENVG_API)); 350 contexts.push_back(std::make_pair(EGL_OPENVG_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0]))); 351 } 352 } 353 354 EGLU_CHECK_MSG(egl, "eglCreateContext()"); 355 356 // Execute for contexts. 357 executeForContexts(display, surface, Config(config.config, config.surfaceTypeBit, m_apiMask), contexts); 358 359 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 360 } 361 catch (...) 362 { 363 // Make sure all contexts have been destroyed. 364 for (vector<std::pair<EGLint, EGLContext> >::iterator i = contexts.begin(); i != contexts.end(); i++) 365 egl.destroyContext(display, i->second); 366 throw; 367 } 368 369 // Destroy contexts. 370 for (vector<std::pair<EGLint, EGLContext> >::iterator i = contexts.begin(); i != contexts.end(); i++) 371 egl.destroyContext(display, i->second); 372 } 373 374 // Utilities 375 376 template <int Red, int Green, int Blue, int Alpha> 377 static bool colorBits (const eglu::CandidateConfig& c) 378 { 379 return c.redSize() == Red && 380 c.greenSize() == Green && 381 c.blueSize() == Blue && 382 c.alphaSize() == Alpha; 383 } 384 385 template <int Red, int Green, int Blue, int Alpha> 386 static bool notColorBits (const eglu::CandidateConfig& c) 387 { 388 return c.redSize() != Red || 389 c.greenSize() != Green || 390 c.blueSize() != Blue || 391 c.alphaSize() != Alpha; 392 } 393 394 template <deUint32 Type> 395 static bool surfaceType (const eglu::CandidateConfig& c) 396 { 397 return (c.surfaceType() & Type) == Type; 398 } 399 400 static bool isConformant (const eglu::CandidateConfig& c) 401 { 402 return c.get(EGL_CONFIG_CAVEAT) != EGL_NON_CONFORMANT_CONFIG; 403 } 404 405 static bool notFloat (const eglu::CandidateConfig& c) 406 { 407 return c.colorComponentType() != EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT; 408 } 409 410 static bool notYUV (const eglu::CandidateConfig& c) 411 { 412 return c.colorBufferType() != EGL_YUV_BUFFER_EXT; 413 } 414 415 void getDefaultRenderFilterLists (vector<RenderFilterList>& filterLists, const eglu::FilterList& baseFilters) 416 { 417 static const struct 418 { 419 const char* name; 420 eglu::ConfigFilter filter; 421 } s_colorRules[] = 422 { 423 { "rgb565", colorBits<5, 6, 5, 0> }, 424 { "rgb888", colorBits<8, 8, 8, 0> }, 425 { "rgba4444", colorBits<4, 4, 4, 4> }, 426 { "rgba5551", colorBits<5, 5, 5, 1> }, 427 { "rgba8888", colorBits<8, 8, 8, 8> }, 428 }; 429 430 static const struct 431 { 432 const char* name; 433 EGLint bits; 434 eglu::ConfigFilter filter; 435 } s_surfaceRules[] = 436 { 437 { "window", EGL_WINDOW_BIT, surfaceType<EGL_WINDOW_BIT> }, 438 { "pixmap", EGL_PIXMAP_BIT, surfaceType<EGL_PIXMAP_BIT>, }, 439 { "pbuffer", EGL_PBUFFER_BIT, surfaceType<EGL_PBUFFER_BIT> } 440 }; 441 442 for (int colorNdx = 0; colorNdx < DE_LENGTH_OF_ARRAY(s_colorRules); colorNdx++) 443 { 444 for (int surfaceNdx = 0; surfaceNdx < DE_LENGTH_OF_ARRAY(s_surfaceRules); surfaceNdx++) 445 { 446 const string name = string(s_colorRules[colorNdx].name) + "_" + s_surfaceRules[surfaceNdx].name; 447 RenderFilterList filters (name.c_str(), "", s_surfaceRules[surfaceNdx].bits); 448 449 filters << baseFilters 450 << s_colorRules[colorNdx].filter 451 << s_surfaceRules[surfaceNdx].filter 452 << isConformant; 453 454 filterLists.push_back(filters); 455 } 456 } 457 458 // Add other config ids to "other" set 459 { 460 RenderFilterList filters ("other", "", EGL_WINDOW_BIT|EGL_PIXMAP_BIT|EGL_PBUFFER_BIT); 461 462 filters << baseFilters 463 << notColorBits<5, 6, 5, 0> 464 << notColorBits<8, 8, 8, 0> 465 << notColorBits<4, 4, 4, 4> 466 << notColorBits<5, 5, 5, 1> 467 << notColorBits<8, 8, 8, 8> 468 << isConformant 469 << notFloat 470 << notYUV; 471 472 filterLists.push_back(filters); 473 } 474 } 475 476 } // egl 477 } // deqp 478
