modules/egl/teglBufferAgeTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program EGL Module
   3  * ---------------------------------------
   4  *
   5  * Copyright 2015 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 EXT_buffer_age
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglBufferAgeTests.hpp"
  25
  26 #include "tcuImageCompare.hpp"
  27 #include "tcuTestLog.hpp"
  28 #include "tcuSurface.hpp"
  29 #include "tcuTextureUtil.hpp"
  30
  31 #include "egluNativeWindow.hpp"
  32 #include "egluUtil.hpp"
  33 #include "egluConfigFilter.hpp"
  34
  35 #include "eglwLibrary.hpp"
  36 #include "eglwEnums.hpp"
  37
  38 #include "gluDefs.hpp"
  39 #include "gluRenderContext.hpp"
  40 #include "gluShaderProgram.hpp"
  41
  42 #include "glwDefs.hpp"
  43 #include "glwEnums.hpp"
  44 #include "glwFunctions.hpp"
  45
  46 #include "deRandom.hpp"
  47 #include "deString.h"
  48
  49 #include <string>
  50 #include <vector>
  51 #include <sstream>
  52
  53 using std::string;
  54 using std::vector;
  55 using glw::GLubyte;
  56 using tcu::IVec2;
  57
  58 using namespace eglw;
  59
  60 namespace deqp
  61 {
  62 namespace egl
  63 {
  64 namespace
  65 {
  66
  67 typedef tcu::Vector<GLubyte, 3> Color;
  68
  69 class GLES2Renderer;
  70
  71 class ReferenceRenderer;
  72
  73 class BufferAgeTest : public TestCase
  74 {
  75 public:
  76         enum DrawType
  77         {
  78                 DRAWTYPE_GLES2_CLEAR,
  79                 DRAWTYPE_GLES2_RENDER
  80         };
  81
  82         enum ResizeType
  83         {
  84                 RESIZETYPE_NONE = 0,
  85                 RESIZETYPE_BEFORE_SWAP,
  86                 RESIZETYPE_AFTER_SWAP,
  87
  88                 RESIZETYPE_LAST
  89         };
  90
  91                                                                 BufferAgeTest   (EglTestContext&                        eglTestCtx,
  92                                                                                                  bool                                           preserveColorBuffer,
  93                                                                                                  const vector<DrawType>&        oddFrameDrawType,
  94                                                                                                  const vector<DrawType>&        evenFrameDrawType,
  95                                                                                                  ResizeType                                     resizeType,
  96                                                                                                  const char*                            name,
  97                                                                                                  const char*                            description);
  98
  99                                                                 ~BufferAgeTest  (void);
 100
 101         void                                            init                    (void);
 102         void                                            deinit                  (void);
 103         IterateResult                           iterate                 (void);
 104
 105 private:
 106         void                                            initEGLSurface (EGLConfig config);
 107         void                                            initEGLContext (EGLConfig config);
 108
 109         const int                                       m_seed;
 110         const bool                                      m_preserveColorBuffer;
 111         const vector<DrawType>          m_oddFrameDrawType;
 112         const vector<DrawType>          m_evenFrameDrawType;
 113         const ResizeType                        m_resizeType;
 114
 115         EGLDisplay                                      m_eglDisplay;
 116         eglu::NativeWindow*                     m_window;
 117         EGLSurface                                      m_eglSurface;
 118         EGLConfig                                       m_eglConfig;
 119         EGLContext                                      m_eglContext;
 120         glw::Functions                          m_gl;
 121
 122         GLES2Renderer*                          m_gles2Renderer;
 123         ReferenceRenderer*                      m_refRenderer;
 124
 125 };
 126
 127 struct ColoredRect
 128 {
 129 public:
 130                                                         ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
 131         IVec2                                   bottomLeft;
 132         IVec2                                   topRight;
 133         Color                                   color;
 134 };
 135
 136 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
 137         : bottomLeft(bottomLeft_)
 138         , topRight      (topRight_)
 139         , color         (color_)
 140 {
 141 }
 142
 143 struct DrawCommand
 144 {
 145                                                         DrawCommand (const BufferAgeTest::DrawType drawType_, const ColoredRect& rect_);
 146         BufferAgeTest::DrawType drawType;
 147         ColoredRect                             rect;
 148 };
 149
 150 DrawCommand::DrawCommand (const BufferAgeTest::DrawType drawType_, const ColoredRect& rect_)
 151         : drawType(drawType_)
 152         , rect    (rect_)
 153 {
 154 }
 155
 156 struct Frame
 157 {
 158                                                 Frame (int width_, int height_);
 159         int                                     width;
 160         int                                     height;
 161         vector<DrawCommand> draws;
 162 };
 163
 164 Frame::Frame (int width_, int height_)
 165         : width(width_)
 166         , height(height_)
 167 {
 168 }
 169
 170
 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)
 176 {
 177         for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
 178         {
 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);
 189         }
 190 }
 191
 192 typedef vector<Frame> FrameSequence;
 193
 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);
 202
 203 class GLES2Renderer
 204 {
 205 public:
 206                                                         GLES2Renderer           (const glw::Functions& gl);
 207                                                         ~GLES2Renderer          (void);
 208         void                                    render                          (int width, int height, const Frame& frame) const;
 209
 210 private:
 211                                                         GLES2Renderer           (const GLES2Renderer&);
 212         GLES2Renderer&                  operator=                       (const GLES2Renderer&);
 213
 214         const glw::Functions&   m_gl;
 215         glu::ShaderProgram              m_glProgram;
 216         glw::GLuint                             m_coordLoc;
 217         glw::GLuint                             m_colorLoc;
 218 };
 219
 220 // generate sources for vertex and fragment buffer
 221 glu::ProgramSources getSources (void)
 222 {
 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"
 227                 "void main(void)\n"
 228                 "{\n"
 229                 "\tv_color = a_color;\n"
 230                 "\tgl_Position = a_pos;\n"
 231                 "}";
 232
 233         const char* const fragmentShaderSource =
 234                 "varying mediump vec4 v_color;\n"
 235                 "void main(void)\n"
 236                 "{\n"
 237                 "\tgl_FragColor = v_color;\n"
 238                 "}";
 239
 240         return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
 241 }
 242
 243 GLES2Renderer::GLES2Renderer (const glw::Functions& gl)
 244         : m_gl            (gl)
 245         , m_glProgram (gl, getSources())
 246         , m_coordLoc  ((glw::GLuint)-1)
 247         , m_colorLoc  ((glw::GLuint)-1)
 248 {
 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");
 252 }
 253
 254 GLES2Renderer::~GLES2Renderer (void)
 255 {
 256 }
 257
 258 void GLES2Renderer::render (int width, int height, const Frame& frame) const
 259 {
 260         for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
 261         {
 262                 const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
 263                 if (frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_RENDER)
 264                 {
 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);
 269
 270                         const glw::GLfloat coords[] =
 271                         {
 272                                 x1, y1, 0.0f, 1.0f,
 273                                 x1, y2, 0.0f, 1.0f,
 274                                 x2, y2, 0.0f, 1.0f,
 275
 276                                 x2, y2, 0.0f, 1.0f,
 277                                 x2, y1, 0.0f, 1.0f,
 278                                 x1, y1, 0.0f, 1.0f
 279                         };
 280
 281                         const glw::GLubyte colors[] =
 282                         {
 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,
 286
 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,
 290                         };
 291
 292                         m_gl.useProgram(m_glProgram.getProgram());
 293                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
 294
 295                         m_gl.enableVertexAttribArray(m_coordLoc);
 296                         m_gl.enableVertexAttribArray(m_colorLoc);
 297                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
 298
 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");
 302
 303                         m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/4);
 304                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
 305
 306                         m_gl.disableVertexAttribArray(m_coordLoc);
 307                         m_gl.disableVertexAttribArray(m_colorLoc);
 308                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
 309
 310                         m_gl.useProgram(0);
 311                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
 312                 }
 313                 else if (frame.draws[drawNdx].drawType == BufferAgeTest::DRAWTYPE_GLES2_CLEAR)
 314                 {
 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);
 321                 }
 322                 else
 323                         DE_ASSERT(false);
 324         }
 325 }
 326
 327 class ReferenceRenderer
 328 {
 329 public:
 330                                                 ReferenceRenderer       (void);
 331         void                            render                          (tcu::Surface* target, const Frame& frame) const;
 332 private:
 333                                                 ReferenceRenderer       (const ReferenceRenderer&);
 334         ReferenceRenderer&      operator=                       (const ReferenceRenderer&);
 335 };
 336
 337 ReferenceRenderer::ReferenceRenderer(void)
 338 {
 339 }
 340
 341 void ReferenceRenderer::render (tcu::Surface* target, const Frame& frame) const
 342 {
 343         for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
 344         {
 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)
 347                 {
 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())
 350                                 continue;
 351
 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);
 355                 }
 356                 else
 357                         DE_ASSERT(false);
 358         }
 359 }
 360
 361 BufferAgeTest::BufferAgeTest (EglTestContext&                   eglTestCtx,
 362                                                           bool                                          preserveColorBuffer,
 363                                                           const vector<DrawType>&       oddFrameDrawType,
 364                                                           const vector<DrawType>&       evenFrameDrawType,
 365                                                           ResizeType                            resizeType,
 366                                                           const char*                           name,
 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)
 375         , m_window                              (DE_NULL)
 376         , m_eglSurface                  (EGL_NO_SURFACE)
 377         , m_eglContext                  (EGL_NO_CONTEXT)
 378         , m_gles2Renderer               (DE_NULL)
 379         , m_refRenderer                 (DE_NULL)
 380 {
 381 }
 382
 383 BufferAgeTest::~BufferAgeTest (void)
 384 {
 385         deinit();
 386 }
 387
 388 void BufferAgeTest::init (void)
 389 {
 390         const Library&  egl     = m_eglTestCtx.getLibrary();
 391
 392         m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 393         m_eglConfig      = getEGLConfig(m_eglTestCtx.getLibrary(), m_eglDisplay, m_preserveColorBuffer);
 394
 395         if (m_eglConfig == DE_NULL)
 396                 TCU_THROW(NotSupportedError, "No supported config found");
 397
 398         //create surface and context and make them current
 399         initEGLSurface(m_eglConfig);
 400         initEGLContext(m_eglConfig);
 401
 402         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 403
 404         if (eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_buffer_age") == false)
 405                 TCU_THROW(NotSupportedError, "EGL_EXT_buffer_age is not supported");
 406
 407         m_gles2Renderer = new GLES2Renderer(m_gl);
 408         m_refRenderer   = new ReferenceRenderer();
 409 }
 410
 411 void BufferAgeTest::deinit (void)
 412 {
 413         const Library& egl = m_eglTestCtx.getLibrary();
 414
 415         delete m_refRenderer;
 416         m_refRenderer = DE_NULL;
 417
 418         delete m_gles2Renderer;
 419         m_gles2Renderer = DE_NULL;
 420
 421         if (m_eglContext != EGL_NO_CONTEXT)
 422         {
 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;
 426         }
 427
 428         if (m_eglSurface != EGL_NO_SURFACE)
 429         {
 430                 egl.destroySurface(m_eglDisplay, m_eglSurface);
 431                 m_eglSurface = EGL_NO_SURFACE;
 432         }
 433
 434         if (m_eglDisplay != EGL_NO_DISPLAY)
 435         {
 436                 egl.terminate(m_eglDisplay);
 437                 m_eglDisplay = EGL_NO_DISPLAY;
 438         }
 439
 440         delete m_window;
 441         m_window = DE_NULL;
 442 }
 443
 444 void BufferAgeTest::initEGLSurface (EGLConfig config)
 445 {
 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);
 450 }
 451
 452 void BufferAgeTest::initEGLContext (EGLConfig config)
 453 {
 454         const Library&  egl                      = m_eglTestCtx.getLibrary();
 455         const EGLint    attribList[] =
 456         {
 457                 EGL_CONTEXT_CLIENT_VERSION, 2,
 458                 EGL_NONE
 459         };
 460
 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");
 467 }
 468
 469 // return indices of frames that have been written to the given buffer
 470 vector<int> getFramesOnBuffer (const vector<int>& bufferAges, int frameNdx)
 471 {
 472         DE_ASSERT(frameNdx < (int)bufferAges.size());
 473         vector<int> frameOnBuffer;
 474         int                     age = bufferAges[frameNdx];
 475         while (age != 0)
 476         {
 477                 frameNdx = frameNdx - age;
 478                 DE_ASSERT(frameNdx >= 0);
 479                 frameOnBuffer.push_back(frameNdx);
 480                 age = bufferAges[frameNdx];
 481         }
 482
 483         reverse(frameOnBuffer.begin(), frameOnBuffer.end());
 484         return frameOnBuffer;
 485 }
 486
 487 TestCase::IterateResult BufferAgeTest::iterate (void)
 488 {
 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;
 501
 502         if (m_preserveColorBuffer)
 503                 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
 504         else
 505                 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
 506
 507         for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
 508         {
 509                 tcu::Surface                                    currentBuffer                   (width, height);
 510                 tcu::Surface                                    refBuffer                               (width, height);
 511                 Frame                                                   newFrame                                (width, height);
 512                 EGLint                                                  currentBufferAge                = -1;
 513
 514                 if (frameNdx % 2 == 0)
 515                         generateRandomFrame(&newFrame, m_evenFrameDrawType, rnd);
 516                 else
 517                         generateRandomFrame(&newFrame, m_oddFrameDrawType, rnd);
 518
 519                 frameSequence.push_back(newFrame);
 520
 521                 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_EXT, &currentBufferAge));
 522
 523                 if (currentBufferAge > frameNdx || currentBufferAge < 0) // invalid buffer age
 524                 {
 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());
 528                         return STOP;
 529                 }
 530
 531                 if (frameNdx > 0 && m_preserveColorBuffer && currentBufferAge != 1)
 532                 {
 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());
 536                         return STOP;
 537                 }
 538
 539                 bufferAges.push_back(currentBufferAge);
 540                 DE_ASSERT((int)bufferAges.size() == frameNdx+1);
 541
 542                 // during first half, just keep rendering without reading pixel back to mimic ordinary use case
 543                 if (frameNdx < numFrames/2)
 544                 {
 545                         if (currentBufferAge == 0)
 546                                 clearColorScreen(m_gl, clearColor);
 547
 548                         m_gles2Renderer->render(width, height, newFrame);
 549
 550                         if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
 551                         {
 552                                 if (frameNdx % 2 == 0)
 553                                         m_window->setSurfaceSize(IVec2(width*2, height/2));
 554                                 else
 555                                         m_window->setSurfaceSize(IVec2(height/2, width*2));
 556                         }
 557
 558                         EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
 559
 560                         if (m_resizeType == RESIZETYPE_AFTER_SWAP)
 561                         {
 562                                 if (frameNdx % 2 == 0)
 563                                         m_window->setSurfaceSize(IVec2(width*2, height/2));
 564                                 else
 565                                         m_window->setSurfaceSize(IVec2(height/2, width*2));
 566                         }
 567
 568                         continue;
 569                 }
 570
 571                 // do verification in the second half
 572                 if (currentBufferAge > 0) //buffer contain previous content, need to verify
 573                 {
 574                         const vector<int> framesOnBuffer = getFramesOnBuffer(bufferAges, frameNdx);
 575                         readPixels(m_gl, &currentBuffer);
 576                         clearColorReference(&refBuffer, clearColor);
 577
 578                         for (vector<int>::const_iterator it = framesOnBuffer.begin(); it != framesOnBuffer.end(); it++)
 579                                 m_refRenderer->render(&refBuffer, frameSequence[*it]);
 580
 581                         if (compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx-currentBufferAge) == false)
 582                         {
 583                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, buffer content is not well preserved when age > 0");
 584                                 return STOP;
 585                         }
 586                 }
 587                 else // currentBufferAge == 0, content is undefined, clear the buffer, currentBufferAge < 0 is ruled out at the beginning
 588                 {
 589                         clearColorScreen(m_gl, clearColor);
 590                         clearColorReference(&refBuffer, clearColor);
 591                 }
 592
 593                 m_gles2Renderer->render(width, height, newFrame);
 594                 m_refRenderer->render(&refBuffer, newFrame);
 595
 596                 readPixels(m_gl, &currentBuffer);
 597
 598                 if (compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx) == false)
 599                 {
 600                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, render result is wrong");
 601                         return STOP;
 602                 }
 603
 604                 if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
 605                 {
 606                         if (frameNdx % 2 == 0)
 607                                 m_window->setSurfaceSize(IVec2(width*2, height/2));
 608                         else
 609                                 m_window->setSurfaceSize(IVec2(height/2, width*2));
 610                 }
 611
 612                 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
 613
 614                 if (m_resizeType == RESIZETYPE_AFTER_SWAP)
 615                 {
 616                         if (frameNdx % 2 == 0)
 617                                 m_window->setSurfaceSize(IVec2(width*2, height/2));
 618                         else
 619                                 m_window->setSurfaceSize(IVec2(height/2, width*2));
 620                 }
 621         }
 622
 623         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 624         return STOP;
 625 }
 626
 627 string generateDrawTypeName (const vector<BufferAgeTest::DrawType>& drawTypes)
 628 {
 629         std::ostringstream stream;
 630         if (drawTypes.size() == 0)
 631                 return string("_none");
 632
 633         for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
 634         {
 635                 if (drawTypes[ndx] == BufferAgeTest::DRAWTYPE_GLES2_RENDER)
 636                         stream << "_render";
 637                 else if (drawTypes[ndx] == BufferAgeTest::DRAWTYPE_GLES2_CLEAR)
 638                         stream << "_clear";
 639                 else
 640                         DE_ASSERT(false);
 641         }
 642         return stream.str();
 643 }
 644
 645 string generateTestName (const vector<BufferAgeTest::DrawType>& oddFrameDrawType, const vector<BufferAgeTest::DrawType>& evenFrameDrawType)
 646 {
 647         return "odd" + generateDrawTypeName(oddFrameDrawType) + "_even" + generateDrawTypeName(evenFrameDrawType);
 648 }
 649
 650 string generateResizeGroupName (BufferAgeTest::ResizeType resizeType)
 651 {
 652         switch (resizeType)
 653         {
 654                 case BufferAgeTest::RESIZETYPE_NONE:
 655                         return "no_resize";
 656
 657                 case BufferAgeTest::RESIZETYPE_AFTER_SWAP:
 658                         return "resize_after_swap";
 659
 660                 case BufferAgeTest::RESIZETYPE_BEFORE_SWAP:
 661                         return "resize_before_swap";
 662
 663                 default:
 664                         DE_FATAL("Unknown resize type");
 665                         return "";
 666         }
 667 }
 668
 669 bool isWindow (const eglu::CandidateConfig& c)
 670 {
 671         return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
 672 }
 673
 674 bool isES2Renderable (const eglu::CandidateConfig& c)
 675 {
 676         return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
 677 }
 678
 679 bool hasPreserveSwap (const eglu::CandidateConfig& c)
 680 {
 681         return (c.surfaceType() & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
 682 }
 683
 684 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, bool preserveColorBuffer)
 685 {
 686         eglu::FilterList filters;
 687         filters << isWindow << isES2Renderable;
 688         if (preserveColorBuffer)
 689                 filters << hasPreserveSwap;
 690         return eglu::chooseSingleConfig(egl, eglDisplay, filters);
 691 }
 692
 693 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor)
 694 {
 695         gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
 696         gl.clear(GL_COLOR_BUFFER_BIT);
 697 }
 698
 699 void clearColorReference (tcu::Surface* ref, const tcu::Vec4& clearColor)
 700 {
 701         tcu::clear(ref->getAccess(), clearColor);
 702 }
 703
 704 void readPixels (const glw::Functions& gl, tcu::Surface* screen)
 705 {
 706         gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(),  GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
 707 }
 708
 709 float windowToDeviceCoordinates (int x, int length)
 710 {
 711         return (2.0f * float(x) / float(length)) - 1.0f;
 712 }
 713
 714 bool compareToReference (tcu::TestLog& log,      const tcu::Surface& reference, const tcu::Surface& buffer, int frameNdx, int bufferNum)
 715 {
 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);
 720 }
 721
 722 } // anonymous
 723
 724 BufferAgeTests::BufferAgeTests (EglTestContext& eglTestCtx)
 725         : TestCaseGroup(eglTestCtx, "buffer_age", "Color buffer age tests")
 726 {
 727 }
 728
 729 void BufferAgeTests::init (void)
 730 {
 731         const BufferAgeTest::DrawType clearRender[] =
 732         {
 733                 BufferAgeTest::DRAWTYPE_GLES2_CLEAR,
 734                 BufferAgeTest::DRAWTYPE_GLES2_RENDER
 735         };
 736
 737         const BufferAgeTest::DrawType renderClear[] =
 738         {
 739                 BufferAgeTest::DRAWTYPE_GLES2_RENDER,
 740                 BufferAgeTest::DRAWTYPE_GLES2_CLEAR
 741         };
 742
 743         const BufferAgeTest::ResizeType resizeTypes[] =
 744         {
 745                 BufferAgeTest::RESIZETYPE_NONE,
 746                 BufferAgeTest::RESIZETYPE_BEFORE_SWAP,
 747                 BufferAgeTest::RESIZETYPE_AFTER_SWAP
 748         };
 749
 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)));
 758
 759         for (int preserveNdx = 0; preserveNdx < 2; preserveNdx++)
 760         {
 761                 const bool                              preserve                = (preserveNdx == 0);
 762                 TestCaseGroup* const    preserveGroup   = new TestCaseGroup(m_eglTestCtx, (preserve ? "preserve" : "no_preserve"), "");
 763
 764                 for (size_t resizeTypeNdx = 0; resizeTypeNdx < DE_LENGTH_OF_ARRAY(resizeTypes); resizeTypeNdx++)
 765                 {
 766                         const BufferAgeTest::ResizeType resizeType      = resizeTypes[resizeTypeNdx];
 767                         TestCaseGroup* const                    resizeGroup     = new TestCaseGroup(m_eglTestCtx, generateResizeGroupName(resizeType).c_str(), "");
 768
 769                         for (size_t evenNdx = 0; evenNdx < frameDrawTypes.size(); evenNdx++)
 770                         {
 771                                 const vector<BufferAgeTest::DrawType>& evenFrameDrawType = frameDrawTypes[evenNdx];
 772
 773                                 for (size_t oddNdx = evenNdx; oddNdx < frameDrawTypes.size(); oddNdx++)
 774                                 {
 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(), ""));
 778                                 }
 779                         }
 780
 781                         preserveGroup->addChild(resizeGroup);
 782                 }
 783                 addChild(preserveGroup);
 784         }
 785 }
 786
 787 } // egl
 788 } // deqp