1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program EGL Module 3 * --------------------------------------- 4 * 5 * Copyright 2016 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 Test KHR_mutable_render_buffer 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglMutableRenderBufferTests.hpp" 25 26 #include "egluUtil.hpp" 27 28 #include "eglwLibrary.hpp" 29 #include "eglwEnums.hpp" 30 31 #include "gluDefs.hpp" 32 #include "gluRenderContext.hpp" 33 34 #include "glwFunctions.hpp" 35 #include "glwEnums.hpp" 36 37 using namespace eglw; 38 39 using std::vector; 40 41 namespace deqp 42 { 43 namespace egl 44 { 45 namespace 46 { 47 48 class MutableRenderBufferTest : public TestCase 49 { 50 public: 51 MutableRenderBufferTest (EglTestContext& eglTestCtx, 52 const char* name, 53 const char* description, 54 bool enableConfigBit); 55 ~MutableRenderBufferTest (void); 56 void init (void); 57 void deinit (void); 58 IterateResult iterate (void); 59 60 protected: 61 deUint32 drawAndSwap (const Library& egl, 62 deUint32 color, 63 bool flush); 64 bool m_enableConfigBit; 65 EGLDisplay m_eglDisplay; 66 EGLSurface m_eglSurface; 67 EGLConfig m_eglConfig; 68 eglu::NativeWindow* m_window; 69 EGLContext m_eglContext; 70 glw::Functions m_gl; 71 }; 72 73 MutableRenderBufferTest::MutableRenderBufferTest (EglTestContext& eglTestCtx, 74 const char* name, const char* description, 75 bool enableConfigBit) 76 : TestCase (eglTestCtx, name, description) 77 , m_enableConfigBit (enableConfigBit) 78 , m_eglDisplay (EGL_NO_DISPLAY) 79 , m_eglSurface (EGL_NO_SURFACE) 80 , m_eglConfig (DE_NULL) 81 , m_window (DE_NULL) 82 , m_eglContext (EGL_NO_CONTEXT) 83 { 84 } 85 86 MutableRenderBufferTest::~MutableRenderBufferTest (void) 87 { 88 deinit(); 89 } 90 91 void MutableRenderBufferTest::init (void) 92 { 93 const Library& egl = m_eglTestCtx.getLibrary(); 94 95 // create display 96 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 97 98 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_mutable_render_buffer")) 99 { 100 TCU_THROW(NotSupportedError, "EGL_KHR_mutable_render_buffer is not supported"); 101 } 102 103 // get mutable render buffer config 104 const EGLint attribs[] = 105 { 106 EGL_RED_SIZE, 8, 107 EGL_GREEN_SIZE, 8, 108 EGL_BLUE_SIZE, 8, 109 EGL_ALPHA_SIZE, 8, 110 EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_MUTABLE_RENDER_BUFFER_BIT_KHR, 111 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 112 EGL_NONE 113 }; 114 const EGLint attribsNoBit[] = 115 { 116 EGL_RED_SIZE, 8, 117 EGL_GREEN_SIZE, 8, 118 EGL_BLUE_SIZE, 8, 119 EGL_ALPHA_SIZE, 8, 120 EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 121 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 122 EGL_NONE 123 }; 124 125 if (m_enableConfigBit) 126 { 127 m_eglConfig = eglu::chooseSingleConfig(egl, m_eglDisplay, attribs); 128 } 129 else 130 { 131 const vector<EGLConfig> configs = eglu::chooseConfigs(egl, m_eglDisplay, attribsNoBit); 132 133 for (vector<EGLConfig>::const_iterator config = configs.begin(); config != configs.end(); ++config) 134 { 135 EGLint surfaceType = -1; 136 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, *config, EGL_SURFACE_TYPE, &surfaceType)); 137 138 if (!(surfaceType & EGL_MUTABLE_RENDER_BUFFER_BIT_KHR)) 139 { 140 m_eglConfig = *config; 141 break; 142 } 143 } 144 145 if (m_eglConfig == DE_NULL) 146 TCU_THROW(NotSupportedError, "No config without support for mutable_render_buffer found"); 147 } 148 149 // create surface 150 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 151 m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, 152 eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))); 153 m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, m_eglConfig, DE_NULL); 154 155 // create context and make current 156 const EGLint contextAttribList[] = 157 { 158 EGL_CONTEXT_CLIENT_VERSION, 2, 159 EGL_NONE 160 }; 161 162 egl.bindAPI(EGL_OPENGL_ES_API); 163 m_eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttribList); 164 EGLU_CHECK_MSG(egl, "eglCreateContext"); 165 TCU_CHECK(m_eglSurface != EGL_NO_SURFACE); 166 egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext); 167 EGLU_CHECK_MSG(egl, "eglMakeCurrent"); 168 169 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0)); 170 } 171 172 void MutableRenderBufferTest::deinit (void) 173 { 174 const Library& egl = m_eglTestCtx.getLibrary(); 175 176 if (m_eglContext != EGL_NO_CONTEXT) 177 { 178 egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 179 egl.destroyContext(m_eglDisplay, m_eglContext); 180 m_eglContext = EGL_NO_CONTEXT; 181 } 182 183 if (m_eglSurface != EGL_NO_SURFACE) 184 { 185 egl.destroySurface(m_eglDisplay, m_eglSurface); 186 m_eglSurface = EGL_NO_SURFACE; 187 } 188 189 if (m_eglDisplay != EGL_NO_DISPLAY) 190 { 191 egl.terminate(m_eglDisplay); 192 m_eglDisplay = EGL_NO_DISPLAY; 193 } 194 195 if (m_window != DE_NULL) 196 { 197 delete m_window; 198 m_window = DE_NULL; 199 } 200 } 201 202 deUint32 MutableRenderBufferTest::drawAndSwap (const Library& egl, deUint32 color, bool flush) 203 { 204 DE_ASSERT(color < 256); 205 m_gl.clearColor((float)color/255.f, (float)color/255.f, (float)color/255.f, (float)color/255.f); 206 m_gl.clear(GL_COLOR_BUFFER_BIT); 207 if (flush) 208 { 209 m_gl.flush(); 210 } 211 else 212 { 213 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface)); 214 } 215 return (color | color << 8 | color << 16 | color << 24); 216 } 217 218 TestCase::IterateResult MutableRenderBufferTest::iterate (void) 219 { 220 const Library& egl = m_eglTestCtx.getLibrary(); 221 222 int frameNumber = 1; 223 224 // run a few back-buffered frames even if we can't verify their contents 225 for (; frameNumber < 5; frameNumber++) 226 { 227 drawAndSwap(egl, frameNumber, false); 228 } 229 230 // switch to single-buffer rendering 231 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER)); 232 233 // Use eglSwapBuffers for the first frame 234 drawAndSwap(egl, frameNumber, false); 235 frameNumber++; 236 237 // test a few single-buffered frames 238 for (; frameNumber < 10; frameNumber++) 239 { 240 deUint32 backBufferPixel = 0xFFFFFFFF; 241 deUint32 frontBufferPixel = drawAndSwap(egl, frameNumber, true); 242 m_gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &backBufferPixel); 243 244 // when single buffered, front-buffer == back-buffer 245 if (backBufferPixel != frontBufferPixel) 246 { 247 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface isn't single-buffered"); 248 return STOP; 249 } 250 } 251 252 // switch back to back-buffer rendering 253 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, EGL_BACK_BUFFER)); 254 255 // run a few back-buffered frames even if we can't verify their contents 256 for (; frameNumber < 14; frameNumber++) 257 { 258 drawAndSwap(egl, frameNumber, false); 259 } 260 261 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 262 return STOP; 263 } 264 265 class MutableRenderBufferQueryTest : public MutableRenderBufferTest 266 { 267 public: 268 MutableRenderBufferQueryTest (EglTestContext& eglTestCtx, 269 const char* name, 270 const char* description); 271 ~MutableRenderBufferQueryTest (void); 272 IterateResult iterate (void); 273 }; 274 275 MutableRenderBufferQueryTest::MutableRenderBufferQueryTest (EglTestContext& eglTestCtx, 276 const char* name, const char* description) 277 : MutableRenderBufferTest (eglTestCtx, name, description, true) 278 { 279 } 280 281 MutableRenderBufferQueryTest::~MutableRenderBufferQueryTest (void) 282 { 283 deinit(); 284 } 285 286 TestCase::IterateResult MutableRenderBufferQueryTest::iterate (void) 287 { 288 const Library& egl = m_eglTestCtx.getLibrary(); 289 290 // check that by default the query returns back buffered 291 EGLint curRenderBuffer = -1; 292 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, &curRenderBuffer)); 293 if (curRenderBuffer != EGL_BACK_BUFFER) 294 { 295 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface didn't default to back-buffered rendering"); 296 return STOP; 297 } 298 299 // switch to single-buffer rendering and check that the query output changed 300 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER)); 301 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, &curRenderBuffer)); 302 if (curRenderBuffer != EGL_SINGLE_BUFFER) 303 { 304 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface didn't switch to single-buffer rendering"); 305 return STOP; 306 } 307 308 // switch back to back-buffer rendering and check the query again 309 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, EGL_BACK_BUFFER)); 310 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, &curRenderBuffer)); 311 if (curRenderBuffer != EGL_BACK_BUFFER) 312 { 313 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface didn't switch back to back-buffer rendering"); 314 return STOP; 315 } 316 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 317 return STOP; 318 } 319 320 class MutableRenderBufferQueryNegativeTest : public MutableRenderBufferTest 321 { 322 public: 323 MutableRenderBufferQueryNegativeTest (EglTestContext& eglTestCtx, 324 const char* name, 325 const char* description); 326 ~MutableRenderBufferQueryNegativeTest (void); 327 IterateResult iterate (void); 328 }; 329 330 MutableRenderBufferQueryNegativeTest::MutableRenderBufferQueryNegativeTest (EglTestContext& eglTestCtx, 331 const char* name, const char* description) 332 : MutableRenderBufferTest (eglTestCtx, name, description, false) 333 { 334 } 335 336 MutableRenderBufferQueryNegativeTest::~MutableRenderBufferQueryNegativeTest (void) 337 { 338 deinit(); 339 } 340 341 TestCase::IterateResult MutableRenderBufferQueryNegativeTest::iterate (void) 342 { 343 const Library& egl = m_eglTestCtx.getLibrary(); 344 345 // check that by default the query returns back buffered 346 EGLint curRenderBuffer = -1; 347 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, &curRenderBuffer)); 348 if (curRenderBuffer != EGL_BACK_BUFFER) 349 { 350 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface didn't default to back-buffered rendering"); 351 return STOP; 352 } 353 354 // check that trying to switch to single-buffer rendering fails when the config bit is not set 355 EGLBoolean ret = egl.surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER); 356 EGLint err = egl.getError(); 357 if (ret != EGL_FALSE) 358 { 359 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, 360 "eglSurfaceAttrib didn't return false when trying to enable single-buffering on a context without the mutable render buffer bit set"); 361 return STOP; 362 } 363 if (err != EGL_BAD_MATCH) 364 { 365 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, 366 "eglSurfaceAttrib didn't set the EGL_BAD_MATCH error when trying to enable single-buffering on a context without the mutable render buffer bit set"); 367 return STOP; 368 } 369 370 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_RENDER_BUFFER, &curRenderBuffer)); 371 if (curRenderBuffer != EGL_BACK_BUFFER) 372 { 373 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Surface didn't stay in back-buffered rendering after error"); 374 return STOP; 375 } 376 377 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 378 return STOP; 379 } 380 381 } // anonymous 382 383 MutableRenderBufferTests::MutableRenderBufferTests (EglTestContext& eglTestCtx) 384 : TestCaseGroup(eglTestCtx, "mutable_render_buffer", "Mutable render buffer tests") 385 { 386 } 387 388 void MutableRenderBufferTests::init (void) 389 { 390 addChild(new MutableRenderBufferQueryTest(m_eglTestCtx, "querySurface", 391 "Tests if querySurface returns the correct value after surfaceAttrib is called")); 392 addChild(new MutableRenderBufferQueryNegativeTest(m_eglTestCtx, "negativeConfigBit", 393 "Tests trying to enable single-buffering on a context without the mutable render buffer bit set")); 394 addChild(new MutableRenderBufferTest(m_eglTestCtx, "basic", 395 "Tests enabling/disabling single-buffer rendering and checks the buffering behavior", true)); 396 } 397 398 } // egl 399 } // deqp 400
