1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL Module
3 * ---------------------------------------
5 * Copyright 2015 The Android Open Source Project
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Test EXT_buffer_age
22 *//*--------------------------------------------------------------------*/
24 #include "teglBufferAgeTests.hpp"
26 #include "tcuImageCompare.hpp"
27 #include "tcuTestLog.hpp"
28 #include "tcuSurface.hpp"
29 #include "tcuTextureUtil.hpp"
31 #include "egluNativeWindow.hpp"
32 #include "egluUtil.hpp"
33 #include "egluConfigFilter.hpp"
35 #include "eglwLibrary.hpp"
36 #include "eglwEnums.hpp"
38 #include "gluDefs.hpp"
39 #include "gluRenderContext.hpp"
40 #include "gluShaderProgram.hpp"
42 #include "glwDefs.hpp"
43 #include "glwEnums.hpp"
44 #include "glwFunctions.hpp"
46 #include "deRandom.hpp"
67 typedef tcu::Vector<GLubyte, 3> Color;
71 class ReferenceRenderer;
73 class BufferAgeTest : public TestCase
85 RESIZETYPE_BEFORE_SWAP,
86 RESIZETYPE_AFTER_SWAP,
91 BufferAgeTest (EglTestContext& eglTestCtx,
92 bool preserveColorBuffer,
93 const vector<DrawType>& oddFrameDrawType,
94 const vector<DrawType>& evenFrameDrawType,
95 ResizeType resizeType,
97 const char* description);
99 ~BufferAgeTest (void);
103 IterateResult iterate (void);
106 void initEGLSurface (EGLConfig config);
107 void initEGLContext (EGLConfig config);
110 const bool m_preserveColorBuffer;
111 const vector<DrawType> m_oddFrameDrawType;
112 const vector<DrawType> m_evenFrameDrawType;
113 const ResizeType m_resizeType;
115 EGLDisplay m_eglDisplay;
116 eglu::NativeWindow* m_window;
117 EGLSurface m_eglSurface;
118 EGLConfig m_eglConfig;
119 EGLContext m_eglContext;
122 GLES2Renderer* m_gles2Renderer;
123 ReferenceRenderer* m_refRenderer;
130 ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
136 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
137 : bottomLeft(bottomLeft_)
138 , topRight (topRight_)
145 DrawCommand (const BufferAgeTest::DrawType drawType_, const ColoredRect& rect_);
146 BufferAgeTest::DrawType drawType;
150 DrawCommand::DrawCommand (const BufferAgeTest::DrawType drawType_, const ColoredRect& rect_)
151 : drawType(drawType_)
158 Frame (int width_, int height_);
161 vector<DrawCommand> draws;
164 Frame::Frame (int width_, int height_)
171 // (x1,y1) lie in the lower-left quadrant while (x2,y2) lie in the upper-right.
172 // the coords are multiplied by 4 to amplify the minimial difference between coords to 4 (if not zero)
173 // to avoid the situation where two edges are too close to each other which makes the rounding error
174 // intoleratable by compareToReference()
175 void generateRandomFrame (Frame* dst, const vector<BufferAgeTest::DrawType>& drawTypes, de::Random& rnd)
177 for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
179 const int x1 = rnd.getInt(0, (dst->width-1)/8) * 4;
180 const int y1 = rnd.getInt(0, (dst->height-1)/8) * 4;
181 const int x2 = rnd.getInt((dst->width-1)/8, (dst->width-1)/4) * 4;
182 const int y2 = rnd.getInt((dst->height-1)/8, (dst->height-1)/4) * 4;
183 const GLubyte r = rnd.getUint8();
184 const GLubyte g = rnd.getUint8();
185 const GLubyte b = rnd.getUint8();
186 const ColoredRect coloredRect (IVec2(x1, y1), IVec2(x2, y2), Color(r, g, b));
187 const DrawCommand drawCommand (drawTypes[ndx], coloredRect);
188 (*dst).draws.push_back(drawCommand);
192 typedef vector<Frame> FrameSequence;
194 //helper function declaration
195 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, bool preserveColorBuffer);
196 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor);
197 void clearColorReference (tcu::Surface* ref, const tcu::Vec4& clearColor);
198 void readPixels (const glw::Functions& gl, tcu::Surface* screen);
199 float windowToDeviceCoordinates (int x, int length);
200 bool compareToReference (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& buffer, int frameNdx, int bufferNum);
201 vector<int> getFramesOnBuffer (const vector<int>& bufferAges, int frameNdx);
206 GLES2Renderer (const glw::Functions& gl);
207 ~GLES2Renderer (void);
208 void render (int width, int height, const Frame& frame) const;
211 GLES2Renderer (const GLES2Renderer&);
212 GLES2Renderer& operator= (const GLES2Renderer&);
214 const glw::Functions& m_gl;
215 glu::ShaderProgram m_glProgram;
216 glw::GLuint m_coordLoc;
217 glw::GLuint m_colorLoc;
220 // generate sources for vertex and fragment buffer
221 glu::ProgramSources getSources (void)
223 const char* const vertexShaderSource =
224 "attribute mediump vec4 a_pos;\n"
225 "attribute mediump vec4 a_color;\n"
226 "varying mediump vec4 v_color;\n"
229 "\tv_color = a_color;\n"
230 "\tgl_Position = a_pos;\n"
233 const char* const fragmentShaderSource =
234 "varying mediump vec4 v_color;\n"
237 "\tgl_FragColor = v_color;\n"
240 return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
243 GLES2Renderer::GLES2Renderer (const glw::Functions& gl)
245 , m_glProgram (gl, getSources())
246 , m_coordLoc ((glw::GLuint)-1)
247 , m_colorLoc ((glw::GLuint)-1)
249 m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
250 m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
251 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
254 GLES2Renderer::~GLES2Renderer (void)
258 void GLES2Renderer::render (int width, int height, const Frame& frame) const
260 for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
262 const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
263 if (frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_RENDER)
265 float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), width);
266 float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), height);
267 float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), width);
268 float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), height);
270 const glw::GLfloat coords[] =
281 const glw::GLubyte colors[] =
283 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
284 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
285 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
287 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
288 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
289 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
292 m_gl.useProgram(m_glProgram.getProgram());
293 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
295 m_gl.enableVertexAttribArray(m_coordLoc);
296 m_gl.enableVertexAttribArray(m_colorLoc);
297 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
299 m_gl.vertexAttribPointer(m_coordLoc, 4, GL_FLOAT, GL_FALSE, 0, coords);
300 m_gl.vertexAttribPointer(m_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);
301 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
303 m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/4);
304 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
306 m_gl.disableVertexAttribArray(m_coordLoc);
307 m_gl.disableVertexAttribArray(m_colorLoc);
308 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
311 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
313 else if (frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_CLEAR)
315 m_gl.enable(GL_SCISSOR_TEST);
316 m_gl.scissor(coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
317 coloredRect.topRight.x()-coloredRect.bottomLeft.x(), coloredRect.topRight.y()-coloredRect.bottomLeft.y());
318 m_gl.clearColor(coloredRect.color.x()/255.0f, coloredRect.color.y()/255.0f, coloredRect.color.z()/255.0f, 1.0f);
319 m_gl.clear(GL_COLOR_BUFFER_BIT);
320 m_gl.disable(GL_SCISSOR_TEST);
327 class ReferenceRenderer
330 ReferenceRenderer (void);
331 void render (tcu::Surface* target, const Frame& frame) const;
333 ReferenceRenderer (const ReferenceRenderer&);
334 ReferenceRenderer& operator= (const ReferenceRenderer&);
337 ReferenceRenderer::ReferenceRenderer(void)
341 void ReferenceRenderer::render (tcu::Surface* target, const Frame& frame) const
343 for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
345 const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
346 if (frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_RENDER || frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_CLEAR)
348 // tcu does not support degenerate subregions. Since they correspond to no-op rendering, just skip them.
349 if (coloredRect.bottomLeft.x() == coloredRect.topRight.x() || coloredRect.bottomLeft.y() == coloredRect.topRight.y())
352 const tcu::UVec4 color(coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255);
353 tcu::clear(tcu::getSubregion(target->getAccess(), coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
354 coloredRect.topRight.x()-coloredRect.bottomLeft.x(), coloredRect.topRight.y()-coloredRect.bottomLeft.y()), color);
361 BufferAgeTest::BufferAgeTest (EglTestContext& eglTestCtx,
362 bool preserveColorBuffer,
363 const vector<DrawType>& oddFrameDrawType,
364 const vector<DrawType>& evenFrameDrawType,
365 ResizeType resizeType,
367 const char* description)
368 : TestCase (eglTestCtx, name, description)
369 , m_seed (deStringHash(name))
370 , m_preserveColorBuffer (preserveColorBuffer)
371 , m_oddFrameDrawType (oddFrameDrawType)
372 , m_evenFrameDrawType (evenFrameDrawType)
373 , m_resizeType (resizeType)
374 , m_eglDisplay (EGL_NO_DISPLAY)
376 , m_eglSurface (EGL_NO_SURFACE)
377 , m_eglContext (EGL_NO_CONTEXT)
378 , m_gles2Renderer (DE_NULL)
379 , m_refRenderer (DE_NULL)
383 BufferAgeTest::~BufferAgeTest (void)
388 void BufferAgeTest::init (void)
390 const Library& egl = m_eglTestCtx.getLibrary();
392 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
393 m_eglConfig = getEGLConfig(m_eglTestCtx.getLibrary(), m_eglDisplay, m_preserveColorBuffer);
395 if (m_eglConfig == DE_NULL)
396 TCU_THROW(NotSupportedError, "No supported config found");
398 //create surface and context and make them current
399 initEGLSurface(m_eglConfig);
400 initEGLContext(m_eglConfig);
402 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
404 if (eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_buffer_age") == false)
405 TCU_THROW(NotSupportedError, "EGL_EXT_buffer_age is not supported");
407 m_gles2Renderer = new GLES2Renderer(m_gl);
408 m_refRenderer = new ReferenceRenderer();
411 void BufferAgeTest::deinit (void)
413 const Library& egl = m_eglTestCtx.getLibrary();
415 delete m_refRenderer;
416 m_refRenderer = DE_NULL;
418 delete m_gles2Renderer;
419 m_gles2Renderer = DE_NULL;
421 if (m_eglContext != EGL_NO_CONTEXT)
423 egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
424 egl.destroyContext(m_eglDisplay, m_eglContext);
425 m_eglContext = EGL_NO_CONTEXT;
428 if (m_eglSurface != EGL_NO_SURFACE)
430 egl.destroySurface(m_eglDisplay, m_eglSurface);
431 m_eglSurface = EGL_NO_SURFACE;
434 if (m_eglDisplay != EGL_NO_DISPLAY)
436 egl.terminate(m_eglDisplay);
437 m_eglDisplay = EGL_NO_DISPLAY;
444 void BufferAgeTest::initEGLSurface (EGLConfig config)
446 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
447 m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, config, DE_NULL,
448 eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
449 m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, config, DE_NULL);
452 void BufferAgeTest::initEGLContext (EGLConfig config)
454 const Library& egl = m_eglTestCtx.getLibrary();
455 const EGLint attribList[] =
457 EGL_CONTEXT_CLIENT_VERSION, 2,
461 egl.bindAPI(EGL_OPENGL_ES_API);
462 m_eglContext = egl.createContext(m_eglDisplay, config, EGL_NO_CONTEXT, attribList);
463 EGLU_CHECK_MSG(egl, "eglCreateContext");
464 DE_ASSERT(m_eglSurface != EGL_NO_SURFACE);
465 egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
466 EGLU_CHECK_MSG(egl, "eglMakeCurrent");
469 // return indices of frames that have been written to the given buffer
470 vector<int> getFramesOnBuffer (const vector<int>& bufferAges, int frameNdx)
472 DE_ASSERT(frameNdx < (int)bufferAges.size());
473 vector<int> frameOnBuffer;
474 int age = bufferAges[frameNdx];
477 frameNdx = frameNdx - age;
478 DE_ASSERT(frameNdx >= 0);
479 frameOnBuffer.push_back(frameNdx);
480 age = bufferAges[frameNdx];
483 reverse(frameOnBuffer.begin(), frameOnBuffer.end());
484 return frameOnBuffer;
487 TestCase::IterateResult BufferAgeTest::iterate (void)
489 de::Random rnd (m_seed);
490 const Library& egl = m_eglTestCtx.getLibrary();
491 tcu::TestLog& log = m_testCtx.getLog();
492 const int width = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
493 const int height = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
494 const float clearRed = rnd.getFloat();
495 const float clearGreen = rnd.getFloat();
496 const float clearBlue = rnd.getFloat();
497 const tcu::Vec4 clearColor (clearRed, clearGreen, clearBlue, 1.0f);
498 const int numFrames = 20;
499 FrameSequence frameSequence;
500 vector<int> bufferAges;
502 if (m_preserveColorBuffer)
503 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
505 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
507 for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
509 tcu::Surface currentBuffer (width, height);
510 tcu::Surface refBuffer (width, height);
511 Frame newFrame (width, height);
512 EGLint currentBufferAge = -1;
514 if (frameNdx % 2 == 0)
515 generateRandomFrame(&newFrame, m_evenFrameDrawType, rnd);
517 generateRandomFrame(&newFrame, m_oddFrameDrawType, rnd);
519 frameSequence.push_back(newFrame);
521 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_EXT, ¤tBufferAge));
523 if (currentBufferAge > frameNdx || currentBufferAge < 0) // invalid buffer age
525 std::ostringstream stream;
526 stream << "Fail, the age is invalid. Age: " << currentBufferAge << ", frameNdx: " << frameNdx;
527 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, stream.str().c_str());
531 if (frameNdx > 0 && m_preserveColorBuffer && currentBufferAge != 1)
533 std::ostringstream stream;
534 stream << "Fail, EGL_BUFFER_PRESERVED is set to true, but buffer age is: " << currentBufferAge << " (should be 1)";
535 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, stream.str().c_str());
539 bufferAges.push_back(currentBufferAge);
540 DE_ASSERT((int)bufferAges.size() == frameNdx+1);
542 // during first half, just keep rendering without reading pixel back to mimic ordinary use case
543 if (frameNdx < numFrames/2)
545 if (currentBufferAge == 0)
546 clearColorScreen(m_gl, clearColor);
548 m_gles2Renderer->render(width, height, newFrame);
550 if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
552 if (frameNdx % 2 == 0)
553 m_window->setSurfaceSize(IVec2(width*2, height/2));
555 m_window->setSurfaceSize(IVec2(height/2, width*2));
558 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
560 if (m_resizeType == RESIZETYPE_AFTER_SWAP)
562 if (frameNdx % 2 == 0)
563 m_window->setSurfaceSize(IVec2(width*2, height/2));
565 m_window->setSurfaceSize(IVec2(height/2, width*2));
571 // do verification in the second half
572 if (currentBufferAge > 0) //buffer contain previous content, need to verify
574 const vector<int> framesOnBuffer = getFramesOnBuffer(bufferAges, frameNdx);
575 readPixels(m_gl, ¤tBuffer);
576 clearColorReference(&refBuffer, clearColor);
578 for (vector<int>::const_iterator it = framesOnBuffer.begin(); it != framesOnBuffer.end(); it++)
579 m_refRenderer->render(&refBuffer, frameSequence[*it]);
581 if (compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx-currentBufferAge) == false)
583 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, buffer content is not well preserved when age > 0");
587 else // currentBufferAge == 0, content is undefined, clear the buffer, currentBufferAge < 0 is ruled out at the beginning
589 clearColorScreen(m_gl, clearColor);
590 clearColorReference(&refBuffer, clearColor);
593 m_gles2Renderer->render(width, height, newFrame);
594 m_refRenderer->render(&refBuffer, newFrame);
596 readPixels(m_gl, ¤tBuffer);
598 if (compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx) == false)
600 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, render result is wrong");
604 if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
606 if (frameNdx % 2 == 0)
607 m_window->setSurfaceSize(IVec2(width*2, height/2));
609 m_window->setSurfaceSize(IVec2(height/2, width*2));
612 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
614 if (m_resizeType == RESIZETYPE_AFTER_SWAP)
616 if (frameNdx % 2 == 0)
617 m_window->setSurfaceSize(IVec2(width*2, height/2));
619 m_window->setSurfaceSize(IVec2(height/2, width*2));
623 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
627 string generateDrawTypeName (const vector<BufferAgeTest::DrawType>& drawTypes)
629 std::ostringstream stream;
630 if (drawTypes.size() == 0)
631 return string("_none");
633 for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
635 if (drawTypes[ndx] == BufferAgeTest::DRAWTYPE_GLES2_RENDER)
637 else if (drawTypes[ndx] == BufferAgeTest::DRAWTYPE_GLES2_CLEAR)
645 string generateTestName (const vector<BufferAgeTest::DrawType>& oddFrameDrawType, const vector<BufferAgeTest::DrawType>& evenFrameDrawType)
647 return "odd" + generateDrawTypeName(oddFrameDrawType) + "_even" + generateDrawTypeName(evenFrameDrawType);
650 string generateResizeGroupName (BufferAgeTest::ResizeType resizeType)
654 case BufferAgeTest::RESIZETYPE_NONE:
657 case BufferAgeTest::RESIZETYPE_AFTER_SWAP:
658 return "resize_after_swap";
660 case BufferAgeTest::RESIZETYPE_BEFORE_SWAP:
661 return "resize_before_swap";
664 DE_FATAL("Unknown resize type");
669 bool isWindow (const eglu::CandidateConfig& c)
671 return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
674 bool isES2Renderable (const eglu::CandidateConfig& c)
676 return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
679 bool hasPreserveSwap (const eglu::CandidateConfig& c)
681 return (c.surfaceType() & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
684 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, bool preserveColorBuffer)
686 eglu::FilterList filters;
687 filters << isWindow << isES2Renderable;
688 if (preserveColorBuffer)
689 filters << hasPreserveSwap;
690 return eglu::chooseSingleConfig(egl, eglDisplay, filters);
693 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor)
695 gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
696 gl.clear(GL_COLOR_BUFFER_BIT);
699 void clearColorReference (tcu::Surface* ref, const tcu::Vec4& clearColor)
701 tcu::clear(ref->getAccess(), clearColor);
704 void readPixels (const glw::Functions& gl, tcu::Surface* screen)
706 gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
709 float windowToDeviceCoordinates (int x, int length)
711 return (2.0f * float(x) / float(length)) - 1.0f;
714 bool compareToReference (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& buffer, int frameNdx, int bufferNum)
716 std::ostringstream stream;
717 stream << "FrameNdx = " << frameNdx << ", compare current buffer (numbered: " << bufferNum << ") to reference";
718 return tcu::intThresholdPositionDeviationCompare(log, "buffer age test", stream.str().c_str(), reference.getAccess(), buffer.getAccess(),
719 tcu::UVec4(8, 8, 8, 0), tcu::IVec3(2,2,0), true, tcu::COMPARE_LOG_RESULT);
724 BufferAgeTests::BufferAgeTests (EglTestContext& eglTestCtx)
725 : TestCaseGroup(eglTestCtx, "buffer_age", "Color buffer age tests")
729 void BufferAgeTests::init (void)
731 const BufferAgeTest::DrawType clearRender[] =
733 BufferAgeTest::DRAWTYPE_GLES2_CLEAR,
734 BufferAgeTest::DRAWTYPE_GLES2_RENDER
737 const BufferAgeTest::DrawType renderClear[] =
739 BufferAgeTest::DRAWTYPE_GLES2_RENDER,
740 BufferAgeTest::DRAWTYPE_GLES2_CLEAR
743 const BufferAgeTest::ResizeType resizeTypes[] =
745 BufferAgeTest::RESIZETYPE_NONE,
746 BufferAgeTest::RESIZETYPE_BEFORE_SWAP,
747 BufferAgeTest::RESIZETYPE_AFTER_SWAP
750 vector< vector<BufferAgeTest::DrawType> > frameDrawTypes;
751 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> ());
752 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (1, BufferAgeTest::DRAWTYPE_GLES2_CLEAR));
753 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (1, BufferAgeTest::DRAWTYPE_GLES2_RENDER));
754 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (2, BufferAgeTest::DRAWTYPE_GLES2_CLEAR));
755 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (2, BufferAgeTest::DRAWTYPE_GLES2_RENDER));
756 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (DE_ARRAY_BEGIN(clearRender), DE_ARRAY_END(clearRender)));
757 frameDrawTypes.push_back(vector<BufferAgeTest::DrawType> (DE_ARRAY_BEGIN(renderClear), DE_ARRAY_END(renderClear)));
759 for (int preserveNdx = 0; preserveNdx < 2; preserveNdx++)
761 const bool preserve = (preserveNdx == 0);
762 TestCaseGroup* const preserveGroup = new TestCaseGroup(m_eglTestCtx, (preserve ? "preserve" : "no_preserve"), "");
764 for (size_t resizeTypeNdx = 0; resizeTypeNdx < DE_LENGTH_OF_ARRAY(resizeTypes); resizeTypeNdx++)
766 const BufferAgeTest::ResizeType resizeType = resizeTypes[resizeTypeNdx];
767 TestCaseGroup* const resizeGroup = new TestCaseGroup(m_eglTestCtx, generateResizeGroupName(resizeType).c_str(), "");
769 for (size_t evenNdx = 0; evenNdx < frameDrawTypes.size(); evenNdx++)
771 const vector<BufferAgeTest::DrawType>& evenFrameDrawType = frameDrawTypes[evenNdx];
773 for (size_t oddNdx = evenNdx; oddNdx < frameDrawTypes.size(); oddNdx++)
775 const vector<BufferAgeTest::DrawType>& oddFrameDrawType = frameDrawTypes[oddNdx];
776 const std::string name = generateTestName(oddFrameDrawType, evenFrameDrawType);
777 resizeGroup->addChild(new BufferAgeTest(m_eglTestCtx, preserve, oddFrameDrawType, evenFrameDrawType, BufferAgeTest::RESIZETYPE_NONE, name.c_str(), ""));
781 preserveGroup->addChild(resizeGroup);
783 addChild(preserveGroup);