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 KHR_partial_update
22 *//*--------------------------------------------------------------------*/
23
24 #include "teglPartialUpdateTests.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 PartialUpdateTest : public TestCase
74 {
75 public:
76 enum DrawType
77 {
78 DRAWTYPE_GLES2_CLEAR,
79 DRAWTYPE_GLES2_RENDER
80 };
81
82 PartialUpdateTest (EglTestContext& eglTestCtx,
83 const vector<DrawType>& oddFrameDrawType,
84 const vector<DrawType>& evenFrameDrawType,
85 const char* name,
86 const char* description);
87 ~PartialUpdateTest (void);
88
89 void init (void);
90 void deinit (void);
91 IterateResult iterate (void);
92
93 private:
94 eglu::NativeWindow* m_window;
95 EGLConfig m_eglConfig;
96 EGLContext m_eglContext;
97
98 protected:
99 void initEGLSurface (EGLConfig config);
100 void initEGLContext (EGLConfig config);
101
102 const int m_seed;
103 const vector<DrawType> m_oddFrameDrawType;
104 const vector<DrawType> m_evenFrameDrawType;
105
106 bool m_supportBufferAge;
107 EGLDisplay m_eglDisplay;
108 EGLSurface m_eglSurface;
109 glw::Functions m_gl;
110
111 GLES2Renderer* m_gles2Renderer;
112 ReferenceRenderer* m_refRenderer;
113 };
114
115 struct ColoredRect
116 {
117 public:
118 ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
119 IVec2 bottomLeft;
120 IVec2 topRight;
121 Color color;
122 };
123
ColoredRect(const IVec2 & bottomLeft_,const IVec2 & topRight_,const Color & color_)124 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
125 : bottomLeft (bottomLeft_)
126 , topRight (topRight_)
127 , color (color_)
128 {
129 }
130
131 struct DrawCommand
132 {
133 DrawCommand (const PartialUpdateTest::DrawType drawType_, const ColoredRect& rect_);
134 PartialUpdateTest::DrawType drawType;
135 ColoredRect rect;
136 };
137
DrawCommand(const PartialUpdateTest::DrawType drawType_,const ColoredRect & rect_)138 DrawCommand::DrawCommand (const PartialUpdateTest::DrawType drawType_, const ColoredRect& rect_)
139 : drawType (drawType_)
140 , rect (rect_)
141 {
142 }
143
144 struct Frame
145 {
146 Frame (int width_, int height_);
147 int width;
148 int height;
149 vector<DrawCommand> draws;
150 };
151
Frame(int width_,int height_)152 Frame::Frame (int width_, int height_)
153 : width (width_)
154 , height(height_)
155 {
156 }
157
158 // (x1,y1) lie in the lower-left quadrant while (x2,y2) lie in the upper-right.
159 // the coords are multiplied by 4 to amplify the minimial difference between coords to 4 (if not zero)
160 // to avoid the situation where two edges are too close to each other which makes the rounding error
161 // intoleratable by compareToReference()
generateRandomFrame(Frame & dst,const vector<PartialUpdateTest::DrawType> & drawTypes,de::Random & rnd)162 void generateRandomFrame (Frame& dst, const vector<PartialUpdateTest::DrawType>& drawTypes, de::Random& rnd)
163 {
164 for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
165 {
166 const int x1 = rnd.getInt(0, (dst.width-1)/8) * 4;
167 const int y1 = rnd.getInt(0, (dst.height-1)/8) * 4;
168 const int x2 = rnd.getInt((dst.width-1)/8, (dst.width-1)/4) * 4;
169 const int y2 = rnd.getInt((dst.height-1)/8, (dst.height-1)/4) * 4;
170 const GLubyte r = rnd.getUint8();
171 const GLubyte g = rnd.getUint8();
172 const GLubyte b = rnd.getUint8();
173 const ColoredRect coloredRect (IVec2(x1, y1), IVec2(x2, y2), Color(r, g, b));
174 const DrawCommand drawCommand (drawTypes[ndx], coloredRect);
175
176 dst.draws.push_back(drawCommand);
177 }
178 }
179
180 typedef vector<Frame> FrameSequence;
181
182 //helper function declaration
183 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay);
184 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor);
185 void clearColorReference (tcu::Surface* ref, const tcu::Vec4& clearColor);
186 void readPixels (const glw::Functions& gl, tcu::Surface* screen);
187 float windowToDeviceCoordinates (int x, int length);
188 bool compareToReference (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& buffer, int frameNdx, int bufferNum);
189 vector<int> getFramesOnBuffer (const vector<int>& bufferAges, int frameNdx);
190
191 class GLES2Renderer
192 {
193 public:
194 GLES2Renderer (const glw::Functions& gl);
195 ~GLES2Renderer (void);
196 void render (int width, int height, const Frame& frame) const;
197
198 private:
199 GLES2Renderer (const GLES2Renderer&);
200 GLES2Renderer& operator= (const GLES2Renderer&);
201
202 const glw::Functions& m_gl;
203 glu::ShaderProgram m_glProgram;
204 glw::GLuint m_coordLoc;
205 glw::GLuint m_colorLoc;
206 };
207
208 // generate sources for vertex and fragment buffer
getSources(void)209 glu::ProgramSources getSources (void)
210 {
211 const char* const vertexShaderSource =
212 "attribute mediump vec2 a_pos;\n"
213 "attribute mediump vec4 a_color;\n"
214 "varying mediump vec4 v_color;\n"
215 "void main(void)\n"
216 "{\n"
217 "\tv_color = a_color;\n"
218 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
219 "}";
220
221 const char* const fragmentShaderSource =
222 "varying mediump vec4 v_color;\n"
223 "void main(void)\n"
224 "{\n"
225 "\tgl_FragColor = v_color;\n"
226 "}";
227
228 return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
229 }
230
GLES2Renderer(const glw::Functions & gl)231 GLES2Renderer::GLES2Renderer (const glw::Functions& gl)
232 : m_gl (gl)
233 , m_glProgram (gl, getSources())
234 , m_coordLoc ((glw::GLuint)-1)
235 , m_colorLoc ((glw::GLuint)-1)
236 {
237 m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
238 m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
239 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
240 }
241
~GLES2Renderer(void)242 GLES2Renderer::~GLES2Renderer (void)
243 {
244 }
245
render(int width,int height,const Frame & frame) const246 void GLES2Renderer::render (int width, int height, const Frame& frame) const
247 {
248 for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
249 {
250 const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
251
252 if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_RENDER)
253 {
254 const float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), width);
255 const float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), height);
256 const float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), width);
257 const float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), height);
258
259 const glw::GLfloat coords[] =
260 {
261 x1, y1,
262 x1, y2,
263 x2, y2,
264
265 x2, y2,
266 x2, y1,
267 x1, y1,
268 };
269
270 const glw::GLubyte colors[] =
271 {
272 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
273 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
274 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
275
276 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
277 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
278 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
279 };
280
281 m_gl.useProgram(m_glProgram.getProgram());
282 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
283
284 m_gl.enableVertexAttribArray(m_coordLoc);
285 m_gl.enableVertexAttribArray(m_colorLoc);
286 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
287
288 m_gl.vertexAttribPointer(m_coordLoc, 2, GL_FLOAT, GL_FALSE, 0, coords);
289 m_gl.vertexAttribPointer(m_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);
290 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
291
292 m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/2);
293 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
294
295 m_gl.disableVertexAttribArray(m_coordLoc);
296 m_gl.disableVertexAttribArray(m_colorLoc);
297 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
298
299 m_gl.useProgram(0);
300 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
301 }
302 else if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
303 {
304 m_gl.enable(GL_SCISSOR_TEST);
305 m_gl.scissor(coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
306 coloredRect.topRight.x()-coloredRect.bottomLeft.x(), coloredRect.topRight.y()-coloredRect.bottomLeft.y());
307 m_gl.clearColor(coloredRect.color.x()/255.0f, coloredRect.color.y()/255.0f, coloredRect.color.z()/255.0f, 1.0f);
308 m_gl.clear(GL_COLOR_BUFFER_BIT);
309 m_gl.disable(GL_SCISSOR_TEST);
310 }
311 else
312 DE_FATAL("Invalid drawtype");
313 }
314 }
315
316 class ReferenceRenderer
317 {
318 public:
319 ReferenceRenderer (void);
320 void render (tcu::Surface* target, const Frame& frame) const;
321 private:
322 ReferenceRenderer (const ReferenceRenderer&);
323 ReferenceRenderer& operator= (const ReferenceRenderer&);
324 };
325
ReferenceRenderer(void)326 ReferenceRenderer::ReferenceRenderer(void)
327 {
328 }
329
render(tcu::Surface * target,const Frame & frame) const330 void ReferenceRenderer::render (tcu::Surface* target, const Frame& frame) const
331 {
332 for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
333 {
334 const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
335 if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_RENDER || frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
336 {
337 const tcu::UVec4 color(coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255);
338 tcu::clear(tcu::getSubregion(target->getAccess(), coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
339 coloredRect.topRight.x()-coloredRect.bottomLeft.x(), coloredRect.topRight.y()-coloredRect.bottomLeft.y()), color);
340 }
341 else
342 DE_FATAL("Invalid drawtype");
343 }
344 }
345
PartialUpdateTest(EglTestContext & eglTestCtx,const vector<DrawType> & oddFrameDrawType,const vector<DrawType> & evenFrameDrawType,const char * name,const char * description)346 PartialUpdateTest::PartialUpdateTest (EglTestContext& eglTestCtx,
347 const vector<DrawType>& oddFrameDrawType,
348 const vector<DrawType>& evenFrameDrawType,
349 const char* name, const char* description)
350 : TestCase (eglTestCtx, name, description)
351 , m_window (DE_NULL)
352 , m_eglContext (EGL_NO_CONTEXT)
353 , m_seed (deStringHash(name))
354 , m_oddFrameDrawType (oddFrameDrawType)
355 , m_evenFrameDrawType (evenFrameDrawType)
356 , m_supportBufferAge (false)
357 , m_eglDisplay (EGL_NO_DISPLAY)
358 , m_eglSurface (EGL_NO_SURFACE)
359 , m_gles2Renderer (DE_NULL)
360 , m_refRenderer (DE_NULL)
361 {
362 }
363
~PartialUpdateTest(void)364 PartialUpdateTest::~PartialUpdateTest (void)
365 {
366 deinit();
367 }
368
init(void)369 void PartialUpdateTest::init (void)
370 {
371 const Library& egl = m_eglTestCtx.getLibrary();
372
373 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
374 m_eglConfig = getEGLConfig(m_eglTestCtx.getLibrary(), m_eglDisplay);
375
376 //create surface and context and make them current
377 initEGLSurface(m_eglConfig);
378 initEGLContext(m_eglConfig);
379
380 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
381
382 m_supportBufferAge = eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_buffer_age");
383
384 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_partial_update"))
385 TCU_THROW(NotSupportedError, "EGL_KHR_partial_update is not supported");
386
387 m_gles2Renderer = new GLES2Renderer(m_gl);
388 m_refRenderer = new ReferenceRenderer();
389 }
390
deinit(void)391 void PartialUpdateTest::deinit (void)
392 {
393 const Library& egl = m_eglTestCtx.getLibrary();
394
395 delete m_refRenderer;
396 m_refRenderer = DE_NULL;
397
398 delete m_gles2Renderer;
399 m_gles2Renderer = DE_NULL;
400
401 if (m_eglContext != EGL_NO_CONTEXT)
402 {
403 egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
404 egl.destroyContext(m_eglDisplay, m_eglContext);
405 m_eglContext = EGL_NO_CONTEXT;
406 }
407
408 if (m_eglSurface != EGL_NO_SURFACE)
409 {
410 egl.destroySurface(m_eglDisplay, m_eglSurface);
411 m_eglSurface = EGL_NO_SURFACE;
412 }
413
414 if (m_eglDisplay != EGL_NO_DISPLAY)
415 {
416 egl.terminate(m_eglDisplay);
417 m_eglDisplay = EGL_NO_DISPLAY;
418 }
419
420 delete m_window;
421 m_window = DE_NULL;
422 }
423
initEGLSurface(EGLConfig config)424 void PartialUpdateTest::initEGLSurface (EGLConfig config)
425 {
426 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
427 m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, config, DE_NULL,
428 eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
429 m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, config, DE_NULL);
430 }
431
initEGLContext(EGLConfig config)432 void PartialUpdateTest::initEGLContext (EGLConfig config)
433 {
434 const Library& egl = m_eglTestCtx.getLibrary();
435 const EGLint attribList[] =
436 {
437 EGL_CONTEXT_CLIENT_VERSION, 2,
438 EGL_NONE
439 };
440
441 egl.bindAPI(EGL_OPENGL_ES_API);
442 m_eglContext = egl.createContext(m_eglDisplay, config, EGL_NO_CONTEXT, attribList);
443 EGLU_CHECK_MSG(egl, "eglCreateContext");
444 TCU_CHECK(m_eglSurface != EGL_NO_SURFACE);
445 egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
446 EGLU_CHECK_MSG(egl, "eglMakeCurrent");
447 }
448
449 // return indices of frames that have been written to the given buffer
getFramesOnBuffer(const vector<int> & bufferAges,int frameNdx)450 vector<int> getFramesOnBuffer (const vector<int>& bufferAges, int frameNdx)
451 {
452 DE_ASSERT(frameNdx < (int)bufferAges.size());
453 vector<int> frameOnBuffer;
454 int age = bufferAges[frameNdx];
455 while (age != 0)
456 {
457 frameNdx = frameNdx - age;
458 DE_ASSERT(frameNdx >= 0);
459 frameOnBuffer.push_back(frameNdx);
460 age = bufferAges[frameNdx];
461 }
462
463 reverse(frameOnBuffer.begin(), frameOnBuffer.end());
464 return frameOnBuffer;
465 }
466
getDamageRegion(const Frame & frame,int marginLeft,int marginBottom,int marginRight,int marginTop)467 vector<EGLint> getDamageRegion (const Frame& frame, int marginLeft, int marginBottom, int marginRight, int marginTop)
468 {
469 vector<EGLint> damageRegion;
470 for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
471 {
472 const ColoredRect& rect = frame.draws[drawNdx].rect;
473 damageRegion.push_back(rect.bottomLeft.x() - marginLeft);
474 damageRegion.push_back(rect.bottomLeft.y() - marginBottom);
475 damageRegion.push_back(rect.topRight.x() - rect.bottomLeft.x() + marginLeft + marginRight);
476 damageRegion.push_back(rect.topRight.y() - rect.bottomLeft.y() + marginBottom + marginTop);
477 }
478
479 DE_ASSERT(damageRegion.size() % 4 == 0);
480 return damageRegion;
481 }
482
iterate(void)483 TestCase::IterateResult PartialUpdateTest::iterate (void)
484 {
485 de::Random rnd (m_seed);
486 const Library& egl = m_eglTestCtx.getLibrary();
487 tcu::TestLog& log = m_testCtx.getLog();
488 const int width = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
489 const int height = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
490 const float clearRed = rnd.getFloat();
491 const float clearGreen = rnd.getFloat();
492 const float clearBlue = rnd.getFloat();
493 const tcu::Vec4 clearColor (clearRed, clearGreen, clearBlue, 1.0f);
494 const int numFrames = 20;
495 FrameSequence frameSequence;
496 vector<int> bufferAges;
497 bool hasPositiveAge = false;
498
499 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
500
501 for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
502 {
503 tcu::Surface currentBuffer (width, height);
504 tcu::Surface refBuffer (width, height);
505 Frame newFrame (width, height);
506 EGLint currentBufferAge = -1;
507 vector<EGLint> damageRegion;
508
509 if (frameNdx % 2 == 0)
510 generateRandomFrame(newFrame, m_evenFrameDrawType, rnd);
511 else
512 generateRandomFrame(newFrame, m_oddFrameDrawType, rnd);
513
514 frameSequence.push_back(newFrame);
515
516 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, ¤tBufferAge));
517
518 if (currentBufferAge > frameNdx || currentBufferAge < 0) // invalid buffer age
519 {
520 std::ostringstream stream;
521 stream << "Fail, the age is invalid. Age: " << currentBufferAge << ", frameNdx: " << frameNdx;
522 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, stream.str().c_str());
523 return STOP;
524 }
525
526 bufferAges.push_back(currentBufferAge);
527 DE_ASSERT((int)bufferAges.size() == frameNdx+1);
528
529 if (currentBufferAge > 0)
530 {
531 hasPositiveAge = true;
532
533 if (m_supportBufferAge)
534 damageRegion = getDamageRegion(newFrame, 10, 10, 10, 10);
535 else
536 damageRegion = getDamageRegion(newFrame, 0, 0, 0, 0);
537
538 EGLU_CHECK_CALL(egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
539 }
540 else
541 {
542 EGLU_CHECK_CALL(egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, NULL, 0));
543 clearColorScreen(m_gl, clearColor);
544 }
545
546 // during first half, just keep rendering without reading pixel back to mimic ordinary use case
547 if (frameNdx < numFrames/2)
548 m_gles2Renderer->render(width, height, newFrame);
549 else // do verification in the second half
550 {
551 const vector<int> framesOnBuffer = getFramesOnBuffer(bufferAges, frameNdx);
552
553 clearColorReference(&refBuffer, clearColor);
554
555 for (vector<int>::const_iterator it = framesOnBuffer.begin(); it != framesOnBuffer.end(); it++)
556 m_refRenderer->render(&refBuffer, frameSequence[*it]);
557
558 m_gles2Renderer->render(width, height, newFrame);
559 m_refRenderer->render(&refBuffer, newFrame);
560
561 readPixels(m_gl, ¤tBuffer);
562
563 if (!compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx))
564 {
565 string errorMessage("Fail, render result is wrong. Buffer age is ");
566 errorMessage += (m_supportBufferAge ? "supported" : "not supported");
567 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, errorMessage.c_str());
568 return STOP;
569 }
570 }
571 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
572 }
573
574 if (!hasPositiveAge) // fraud behavior, pretend to support partial_update
575 {
576 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, claim to support partial_update but buffer age is always 0");
577 return STOP;
578 }
579
580 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
581 return STOP;
582 }
583
generateDrawTypeName(const vector<PartialUpdateTest::DrawType> & drawTypes)584 string generateDrawTypeName (const vector<PartialUpdateTest::DrawType>& drawTypes)
585 {
586 std::ostringstream stream;
587 if (drawTypes.size() == 0)
588 return string("_none");
589
590 for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
591 {
592 if (drawTypes[ndx] == PartialUpdateTest::DRAWTYPE_GLES2_RENDER)
593 stream << "_render";
594 else if (drawTypes[ndx] == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
595 stream << "_clear";
596 else
597 DE_ASSERT(false);
598 }
599 return stream.str();
600 }
601
generateTestName(const vector<PartialUpdateTest::DrawType> & oddFrameDrawType,const vector<PartialUpdateTest::DrawType> & evenFrameDrawType)602 string generateTestName (const vector<PartialUpdateTest::DrawType>& oddFrameDrawType, const vector<PartialUpdateTest::DrawType>& evenFrameDrawType)
603 {
604 return "odd" + generateDrawTypeName(oddFrameDrawType) + "_even" + generateDrawTypeName(evenFrameDrawType);
605 }
606
isWindow(const eglu::CandidateConfig & c)607 bool isWindow (const eglu::CandidateConfig& c)
608 {
609 return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
610 }
611
isES2Renderable(const eglu::CandidateConfig & c)612 bool isES2Renderable (const eglu::CandidateConfig& c)
613 {
614 return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
615 }
616
getEGLConfig(const Library & egl,EGLDisplay eglDisplay)617 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay)
618 {
619 eglu::FilterList filters;
620 filters << isWindow << isES2Renderable;
621 return eglu::chooseSingleConfig(egl, eglDisplay, filters);
622 }
623
clearColorScreen(const glw::Functions & gl,const tcu::Vec4 & clearColor)624 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor)
625 {
626 gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
627 gl.clear(GL_COLOR_BUFFER_BIT);
628 }
629
clearColorReference(tcu::Surface * ref,const tcu::Vec4 & clearColor)630 void clearColorReference (tcu::Surface* ref, const tcu::Vec4& clearColor)
631 {
632 tcu::clear(ref->getAccess(), clearColor);
633 }
634
readPixels(const glw::Functions & gl,tcu::Surface * screen)635 void readPixels (const glw::Functions& gl, tcu::Surface* screen)
636 {
637 gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
638 }
639
windowToDeviceCoordinates(int x,int length)640 float windowToDeviceCoordinates (int x, int length)
641 {
642 return (2.0f * float(x) / float(length)) - 1.0f;
643 }
644
compareToReference(tcu::TestLog & log,const tcu::Surface & reference,const tcu::Surface & buffer,int frameNdx,int bufferNum)645 bool compareToReference (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& buffer, int frameNdx, int bufferNum)
646 {
647 std::ostringstream stream;
648 stream << "FrameNdx = " << frameNdx << ", compare current buffer (numbered: " << bufferNum << ") to reference";
649 return tcu::intThresholdPositionDeviationCompare(log, "partial update test", stream.str().c_str(), reference.getAccess(), buffer.getAccess(),
650 tcu::UVec4(8, 8, 8, 0), tcu::IVec3(2,2,0), true, tcu::COMPARE_LOG_RESULT);
651 }
652
653 class RenderOutsideDamageRegion : public PartialUpdateTest
654 {
655 public:
656 RenderOutsideDamageRegion (EglTestContext& eglTestCtx);
657 TestCase::IterateResult iterate (void);
658 };
659
RenderOutsideDamageRegion(EglTestContext & eglTestCtx)660 RenderOutsideDamageRegion::RenderOutsideDamageRegion (EglTestContext& eglTestCtx)
661 : PartialUpdateTest (eglTestCtx, vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), "render_outside_damage_region", "")
662 {
663 }
664
iterate(void)665 TestCase::IterateResult RenderOutsideDamageRegion::iterate (void)
666 {
667 de::Random rnd (m_seed);
668 const Library& egl = m_eglTestCtx.getLibrary();
669 tcu::TestLog& log = m_testCtx.getLog();
670 const int width = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
671 const int height = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
672 const float clearRed = rnd.getFloat();
673 const float clearGreen = rnd.getFloat();
674 const float clearBlue = rnd.getFloat();
675 const tcu::Vec4 clearColor (clearRed, clearGreen, clearBlue, 1.0f);
676 tcu::Surface currentBuffer (width, height);
677 tcu::Surface refBuffer (width, height);
678 Frame frame (width, height);
679
680 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
681
682 generateRandomFrame(frame, m_evenFrameDrawType, rnd);
683
684 {
685 // render outside the region
686 EGLint bufferAge = -1;
687 vector<EGLint> damageRegion = getDamageRegion(frame, 0, 0, 0, 0);
688
689 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
690 EGLU_CHECK_CALL(egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
691 clearColorScreen(m_gl, clearColor);
692 m_gles2Renderer->render(width, height, frame);
693
694 // next line will make the bug on Nexus 6 disappear
695 // readPixels(m_gl, ¤tBuffer);
696 }
697
698 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
699
700 // render a new frame
701 clearColorScreen(m_gl, clearColor);
702 m_gles2Renderer->render(width, height, frame);
703 clearColorReference(&refBuffer, clearColor);
704 m_refRenderer->render(&refBuffer, frame);
705 readPixels(m_gl, ¤tBuffer);
706
707 if (!compareToReference(log, refBuffer, currentBuffer, 0, 0))
708 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, fail to recover after rendering outside damageRegion");
709 else
710 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
711
712 return STOP;
713 }
714
715 class RenderBeforeSetDamageRegion : public PartialUpdateTest
716 {
717 public:
718 RenderBeforeSetDamageRegion (EglTestContext& eglTestCtx);
719 TestCase::IterateResult iterate (void);
720 };
721
RenderBeforeSetDamageRegion(EglTestContext & eglTestCtx)722 RenderBeforeSetDamageRegion::RenderBeforeSetDamageRegion (EglTestContext& eglTestCtx)
723 : PartialUpdateTest (eglTestCtx, vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), "render_before_set_damage_region", "")
724 {
725 }
726
iterate(void)727 TestCase::IterateResult RenderBeforeSetDamageRegion::iterate (void)
728 {
729 de::Random rnd (m_seed);
730 const Library& egl = m_eglTestCtx.getLibrary();
731 tcu::TestLog& log = m_testCtx.getLog();
732 const int width = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
733 const int height = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
734 const float clearRed = rnd.getFloat();
735 const float clearGreen = rnd.getFloat();
736 const float clearBlue = rnd.getFloat();
737 const tcu::Vec4 clearColor (clearRed, clearGreen, clearBlue, 1.0f);
738 tcu::Surface currentBuffer (width, height);
739 tcu::Surface refBuffer (width, height);
740 Frame frame (width, height);
741
742 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
743
744 generateRandomFrame(frame, m_evenFrameDrawType, rnd);
745
746 {
747 // render before setDamageRegion
748 EGLint bufferAge = -1;
749 vector<EGLint> damageRegion = getDamageRegion(frame, 0, 0, 0, 0);
750
751 m_gles2Renderer->render(width, height, frame);
752 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
753 EGLU_CHECK_CALL(egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
754
755 // next line will make the bug on Nexus 6 disappear
756 // readPixels(m_gl, ¤tBuffer);
757 }
758
759 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
760
761 // render a new frame
762 clearColorScreen(m_gl, clearColor);
763 m_gles2Renderer->render(width, height, frame);
764 clearColorReference(&refBuffer, clearColor);
765 m_refRenderer->render(&refBuffer, frame);
766 readPixels(m_gl, ¤tBuffer);
767
768 if (!compareToReference(log, refBuffer, currentBuffer, 0, 0))
769 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
770 else
771 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
772
773 return STOP;
774 }
775
776 } // anonymous
777
PartialUpdateTests(EglTestContext & eglTestCtx)778 PartialUpdateTests::PartialUpdateTests (EglTestContext& eglTestCtx)
779 : TestCaseGroup(eglTestCtx, "partial_update", "Partial update tests")
780 {
781 }
782
init(void)783 void PartialUpdateTests::init (void)
784 {
785 const PartialUpdateTest::DrawType clearRender[2] =
786 {
787 PartialUpdateTest::DRAWTYPE_GLES2_CLEAR,
788 PartialUpdateTest::DRAWTYPE_GLES2_RENDER
789 };
790
791 const PartialUpdateTest::DrawType renderClear[2] =
792 {
793 PartialUpdateTest::DRAWTYPE_GLES2_RENDER,
794 PartialUpdateTest::DRAWTYPE_GLES2_CLEAR
795 };
796
797 vector< vector<PartialUpdateTest::DrawType> > frameDrawTypes;
798 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> ());
799 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (1, PartialUpdateTest::DRAWTYPE_GLES2_CLEAR));
800 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (1, PartialUpdateTest::DRAWTYPE_GLES2_RENDER));
801 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (2, PartialUpdateTest::DRAWTYPE_GLES2_CLEAR));
802 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (2, PartialUpdateTest::DRAWTYPE_GLES2_RENDER));
803 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (DE_ARRAY_BEGIN(clearRender), DE_ARRAY_END(clearRender)));
804 frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType> (DE_ARRAY_BEGIN(renderClear), DE_ARRAY_END(renderClear)));
805
806 for (size_t evenNdx = 0; evenNdx < frameDrawTypes.size(); evenNdx++)
807 {
808 const vector<PartialUpdateTest::DrawType>& evenFrameDrawType = frameDrawTypes[evenNdx];
809
810 for (size_t oddNdx = evenNdx; oddNdx < frameDrawTypes.size(); oddNdx++)
811 {
812 const vector<PartialUpdateTest::DrawType>& oddFrameDrawType = frameDrawTypes[oddNdx];
813 const std::string name = generateTestName(oddFrameDrawType, evenFrameDrawType);
814 if (oddFrameDrawType.size() == 0 && evenFrameDrawType.size() == 0)
815 continue;
816
817 addChild(new PartialUpdateTest(m_eglTestCtx, oddFrameDrawType, evenFrameDrawType, name.c_str(), ""));
818 }
819 }
820 addChild(new RenderOutsideDamageRegion(m_eglTestCtx));
821 addChild(new RenderBeforeSetDamageRegion(m_eglTestCtx));
822 }
823
824 } // egl
825 } // deqp
826