Home | History | Annotate | Download | only in egl
      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_swap_buffer_with_damage
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "teglSwapBuffersWithDamageTests.hpp"
     25 
     26 #include "tcuImageCompare.hpp"
     27 #include "tcuSurface.hpp"
     28 #include "tcuTextureUtil.hpp"
     29 
     30 #include "egluNativeWindow.hpp"
     31 #include "egluUtil.hpp"
     32 #include "egluConfigFilter.hpp"
     33 
     34 #include "eglwLibrary.hpp"
     35 #include "eglwEnums.hpp"
     36 
     37 #include "gluDefs.hpp"
     38 #include "gluRenderContext.hpp"
     39 #include "gluShaderProgram.hpp"
     40 
     41 #include "glwDefs.hpp"
     42 #include "glwEnums.hpp"
     43 #include "glwFunctions.hpp"
     44 
     45 #include "deRandom.hpp"
     46 #include "deString.h"
     47 
     48 #include <string>
     49 #include <vector>
     50 #include <sstream>
     51 
     52 using std::string;
     53 using std::vector;
     54 using glw::GLubyte;
     55 using tcu::IVec2;
     56 
     57 using namespace eglw;
     58 
     59 namespace deqp
     60 {
     61 namespace egl
     62 {
     63 namespace
     64 {
     65 
     66 typedef	tcu::Vector<GLubyte, 3> Color;
     67 
     68 enum DrawType
     69 {
     70     DRAWTYPE_GLES2_CLEAR,
     71     DRAWTYPE_GLES2_RENDER
     72 };
     73 
     74 enum ResizeType
     75 {
     76 	RESIZETYPE_NONE = 0,
     77 	RESIZETYPE_BEFORE_SWAP,
     78 	RESIZETYPE_AFTER_SWAP,
     79 
     80 	RESIZETYPE_LAST
     81 };
     82 
     83 struct ColoredRect
     84 {
     85 public:
     86 				ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
     87 	IVec2		bottomLeft;
     88 	IVec2		topRight;
     89 	Color 		color;
     90 };
     91 
     92 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
     93 	: bottomLeft	(bottomLeft_)
     94 	, topRight		(topRight_)
     95 	, color			(color_)
     96 {
     97 }
     98 
     99 struct DrawCommand
    100 {
    101 				DrawCommand (DrawType drawType_, const ColoredRect& rect_);
    102     DrawType	drawType;
    103 	ColoredRect	rect;
    104 };
    105 
    106 DrawCommand::DrawCommand (DrawType drawType_, const ColoredRect& rect_)
    107 	: drawType	(drawType_)
    108 	, rect		(rect_)
    109 {
    110 }
    111 
    112 struct Frame
    113 {
    114 						Frame (int width_, int height_);
    115 	int 				width;
    116 	int					height;
    117 	vector<DrawCommand> draws;
    118 };
    119 
    120 Frame::Frame (int width_, int height_)
    121 	: width (width_)
    122 	, height(height_)
    123 {
    124 }
    125 
    126 typedef vector<Frame> FrameSequence;
    127 
    128 //helper function declaration
    129 EGLConfig		getEGLConfig					(const Library& egl, EGLDisplay eglDisplay, bool preserveBuffer);
    130 void			clearColorScreen				(const glw::Functions& gl, const tcu::Vec4& clearColor);
    131 float			windowToDeviceCoordinates		(int x, int length);
    132 
    133 class GLES2Renderer
    134 {
    135 public:
    136 							GLES2Renderer		(const glw::Functions& gl);
    137 							~GLES2Renderer		(void);
    138 	void					render				(int width, int height, const Frame& frame) const;
    139 
    140 private:
    141 							GLES2Renderer		(const GLES2Renderer&);
    142 	GLES2Renderer&			operator=			(const GLES2Renderer&);
    143 
    144 	const glw::Functions&	m_gl;
    145 	glu::ShaderProgram		m_glProgram;
    146 	glw::GLuint				m_coordLoc;
    147 	glw::GLuint				m_colorLoc;
    148 };
    149 
    150 // generate sources for vertex and fragment buffer
    151 glu::ProgramSources getSources (void)
    152 {
    153 	const char* const vertexShaderSource =
    154 		"attribute mediump vec2 a_pos;\n"
    155 		"attribute mediump vec4 a_color;\n"
    156 		"varying mediump vec4 v_color;\n"
    157 		"void main(void)\n"
    158 		"{\n"
    159 		"\tv_color = a_color;\n"
    160 		"\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
    161 		"}";
    162 
    163 	const char* const fragmentShaderSource =
    164 		"varying mediump vec4 v_color;\n"
    165 		"void main(void)\n"
    166 		"{\n"
    167 		"\tgl_FragColor = v_color;\n"
    168 		"}";
    169 
    170 	return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
    171 }
    172 
    173 GLES2Renderer::GLES2Renderer (const glw::Functions& gl)
    174 	: m_gl        (gl)
    175 	, m_glProgram (gl, getSources())
    176 	, m_coordLoc  ((glw::GLuint)-1)
    177 	, m_colorLoc  ((glw::GLuint)-1)
    178 {
    179 	m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
    180 	m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
    181 	GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
    182 }
    183 
    184 GLES2Renderer::~GLES2Renderer (void)
    185 {
    186 }
    187 
    188 void GLES2Renderer::render (int width, int height, const Frame& frame) const
    189 {
    190 	for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
    191 	{
    192 		const ColoredRect& coloredRect = frame.draws[drawNdx].rect;
    193 
    194 		if (frame.draws[drawNdx].drawType == DRAWTYPE_GLES2_RENDER)
    195 		{
    196 			const float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), width);
    197 			const float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), height);
    198 			const float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), width);
    199 			const float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), height);
    200 
    201 			const glw::GLfloat coords[] =
    202 			{
    203 				x1, y1,
    204 				x1, y2,
    205 				x2, y2,
    206 
    207 				x2, y2,
    208 				x2, y1,
    209 				x1, y1,
    210 			};
    211 
    212 			const glw::GLubyte colors[] =
    213 			{
    214 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    215 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    216 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    217 
    218 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    219 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    220 				coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
    221 			};
    222 
    223 			m_gl.useProgram(m_glProgram.getProgram());
    224 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
    225 
    226 			m_gl.enableVertexAttribArray(m_coordLoc);
    227 			m_gl.enableVertexAttribArray(m_colorLoc);
    228 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
    229 
    230 			m_gl.vertexAttribPointer(m_coordLoc, 2, GL_FLOAT, GL_FALSE, 0, coords);
    231 			m_gl.vertexAttribPointer(m_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);
    232 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
    233 
    234 			m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/2);
    235 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
    236 
    237 			m_gl.disableVertexAttribArray(m_coordLoc);
    238 			m_gl.disableVertexAttribArray(m_colorLoc);
    239 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
    240 
    241 			m_gl.useProgram(0);
    242 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
    243 		}
    244 		else if (frame.draws[drawNdx].drawType == DRAWTYPE_GLES2_CLEAR)
    245 		{
    246 			m_gl.enable(GL_SCISSOR_TEST);
    247 			m_gl.scissor(coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
    248 						 coloredRect.topRight.x()-coloredRect.bottomLeft.x(), coloredRect.topRight.y()-coloredRect.bottomLeft.y());
    249 			m_gl.clearColor(coloredRect.color.x()/255.0f, coloredRect.color.y()/255.0f, coloredRect.color.z()/255.0f, 1.0f);
    250 			m_gl.clear(GL_COLOR_BUFFER_BIT);
    251 			m_gl.disable(GL_SCISSOR_TEST);
    252 		}
    253 		else
    254 			DE_FATAL("Invalid drawtype");
    255 	}
    256 }
    257 
    258 class SwapBuffersWithDamageTest : public TestCase
    259 {
    260 public:
    261 								SwapBuffersWithDamageTest		(EglTestContext&			eglTestCtx,
    262 																 const vector<DrawType>&	frameDrawType,
    263 																 int						iterationTimes,
    264 																 ResizeType					resizeType,
    265 																 const char*				name,
    266 																 const char*				description);
    267 
    268 								~SwapBuffersWithDamageTest		(void);
    269 
    270 	virtual void				init							(void);
    271 	void						deinit							(void);
    272 	virtual IterateResult		iterate							(void);
    273 
    274 protected:
    275 	virtual EGLConfig			getConfig						(const Library& egl, EGLDisplay eglDisplay);
    276 	virtual void				checkExtension					(const Library& egl, EGLDisplay eglDisplay);
    277 	void						initEGLSurface					(EGLConfig config);
    278 	void						initEGLContext					(EGLConfig config);
    279 
    280 	eglu::NativeWindow*			m_window;
    281 	EGLConfig					m_eglConfig;
    282 	EGLContext					m_eglContext;
    283 	const int					m_seed;
    284 	const int					m_iterationTimes;
    285 	const vector<DrawType>		m_frameDrawType;
    286 	const ResizeType			m_resizeType;
    287 	EGLDisplay					m_eglDisplay;
    288 	EGLSurface					m_eglSurface;
    289 	glw::Functions				m_gl;
    290 	GLES2Renderer*				m_gles2Renderer;
    291 };
    292 
    293 SwapBuffersWithDamageTest::SwapBuffersWithDamageTest (EglTestContext& eglTestCtx, const vector<DrawType>& frameDrawType, int iterationTimes, ResizeType resizeType, const char* name, const char* description)
    294 	: TestCase			(eglTestCtx, name, description)
    295 	, m_window			(DE_NULL)
    296 	, m_eglContext		(EGL_NO_CONTEXT)
    297 	, m_seed			(deStringHash(name))
    298 	, m_iterationTimes	(iterationTimes)
    299 	, m_frameDrawType	(frameDrawType)
    300 	, m_resizeType		(resizeType)
    301 	, m_eglDisplay		(EGL_NO_DISPLAY)
    302 	, m_eglSurface		(EGL_NO_SURFACE)
    303 	, m_gles2Renderer	 (DE_NULL)
    304 {
    305 }
    306 
    307 SwapBuffersWithDamageTest::~SwapBuffersWithDamageTest (void)
    308 {
    309 	deinit();
    310 }
    311 
    312 EGLConfig SwapBuffersWithDamageTest::getConfig (const Library& egl, EGLDisplay eglDisplay)
    313 {
    314 	return getEGLConfig(egl, eglDisplay, false);
    315 }
    316 
    317 void SwapBuffersWithDamageTest::checkExtension (const Library& egl, EGLDisplay eglDisplay)
    318 {
    319 	if (!eglu::hasExtension(egl, eglDisplay, "EGL_KHR_swap_buffers_with_damage"))
    320 		TCU_THROW(NotSupportedError, "EGL_KHR_swap_buffers_with_damage is not supported");
    321 }
    322 
    323 void SwapBuffersWithDamageTest::init (void)
    324 {
    325 	const Library& egl = m_eglTestCtx.getLibrary();
    326 
    327 	m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
    328 	m_eglConfig  = getConfig(egl, m_eglDisplay);
    329 
    330 	checkExtension(egl, m_eglDisplay);
    331 
    332 	initEGLSurface(m_eglConfig);
    333 	initEGLContext(m_eglConfig);
    334 
    335 	m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
    336 	m_gles2Renderer = new GLES2Renderer(m_gl);
    337 }
    338 
    339 void SwapBuffersWithDamageTest::deinit (void)
    340 {
    341 	const Library& egl = m_eglTestCtx.getLibrary();
    342 
    343 	delete m_gles2Renderer;
    344 	m_gles2Renderer = DE_NULL;
    345 
    346 	if (m_eglContext != EGL_NO_CONTEXT)
    347 	{
    348 		egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    349 		egl.destroyContext(m_eglDisplay, m_eglContext);
    350 		m_eglContext = EGL_NO_CONTEXT;
    351 	}
    352 
    353 	if (m_eglSurface != EGL_NO_SURFACE)
    354 	{
    355 		egl.destroySurface(m_eglDisplay, m_eglSurface);
    356 		m_eglSurface = EGL_NO_SURFACE;
    357 	}
    358 
    359 	if (m_eglDisplay != EGL_NO_DISPLAY)
    360 	{
    361 		egl.terminate(m_eglDisplay);
    362 		m_eglDisplay = EGL_NO_DISPLAY;
    363 	}
    364 
    365 	delete m_window;
    366 	m_window = DE_NULL;
    367 }
    368 
    369 void SwapBuffersWithDamageTest::initEGLSurface (EGLConfig config)
    370 {
    371 	const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
    372 	m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, config, DE_NULL,
    373 									eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
    374 	m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, config, DE_NULL);
    375 }
    376 
    377 void SwapBuffersWithDamageTest::initEGLContext (EGLConfig config)
    378 {
    379 	const Library& 	egl 		 = m_eglTestCtx.getLibrary();
    380 	const EGLint 	attribList[] =
    381 	{
    382 		EGL_CONTEXT_CLIENT_VERSION, 2,
    383 		EGL_NONE
    384 	};
    385 
    386 	egl.bindAPI(EGL_OPENGL_ES_API);
    387 	m_eglContext = egl.createContext(m_eglDisplay, config, EGL_NO_CONTEXT, attribList);
    388 	EGLU_CHECK_MSG(egl, "eglCreateContext");
    389 	TCU_CHECK(m_eglSurface != EGL_NO_SURFACE);
    390 	egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
    391 	EGLU_CHECK_MSG(egl, "eglMakeCurrent");
    392 }
    393 
    394 FrameSequence	generateFrameSequence	(const vector<DrawType>& frameDrawType, de::Random& rnd, int numFrames, int width, int height);
    395 vector<EGLint>	getDamageRegion			(const Frame& frame);
    396 
    397 TestCase::IterateResult SwapBuffersWithDamageTest::iterate (void)
    398 {
    399 	de::Random			rnd				(m_seed);
    400 	const Library&		egl				= m_eglTestCtx.getLibrary();
    401 	const int			width			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    402 	const int			height			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    403 	const float			clearRed		= rnd.getFloat();
    404 	const float			clearGreen		= rnd.getFloat();
    405 	const float			clearBlue		= rnd.getFloat();
    406 	const tcu::Vec4		clearColor		(clearRed, clearGreen, clearBlue, 1.0f);
    407 	const int			numFrames		= 24; // (width, height) = (480, 480) --> numFrame = 24, divisible
    408 	const FrameSequence frameSequence	= generateFrameSequence(m_frameDrawType, rnd, numFrames, width, height);
    409 
    410 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    411 	EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
    412 
    413 	for (int iterationNdx = 0; iterationNdx < m_iterationTimes; iterationNdx++)
    414 	{
    415 		for (int currentFrameNdx = 0; currentFrameNdx < numFrames; currentFrameNdx++)
    416 		{
    417 			vector<EGLint>	damageRegion = getDamageRegion(frameSequence[currentFrameNdx]);
    418 
    419 			clearColorScreen(m_gl, clearColor);
    420 			for (int ndx = 0; ndx <= currentFrameNdx; ndx++)
    421 				m_gles2Renderer->render(width, height, frameSequence[ndx]);
    422 
    423 			if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
    424 			{
    425 				if (iterationNdx % 2 == 0)
    426 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    427 				else
    428 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    429 			}
    430 
    431 			EGLU_CHECK_CALL(egl, swapBuffersWithDamageKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
    432 
    433 			if (m_resizeType == RESIZETYPE_AFTER_SWAP)
    434 			{
    435 				if (iterationNdx % 2 == 0)
    436 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    437 				else
    438 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    439 			}
    440 		}
    441 	}
    442 	return STOP;
    443 }
    444 
    445 class SwapBuffersWithDamageAndPreserveBufferTest : public SwapBuffersWithDamageTest
    446 {
    447 public:
    448 					SwapBuffersWithDamageAndPreserveBufferTest	(EglTestContext&			eglTestCtx,
    449 																 const vector<DrawType>&	frameDrawType,
    450 																 int						iterationTimes,
    451 																 ResizeType					resizeType,
    452 																 const char*				name,
    453 																 const char*				description);
    454 
    455 	IterateResult	iterate										(void);
    456 
    457 protected:
    458 	EGLConfig		getConfig									(const Library& egl, EGLDisplay eglDisplay);
    459 };
    460 
    461 SwapBuffersWithDamageAndPreserveBufferTest::SwapBuffersWithDamageAndPreserveBufferTest (EglTestContext&			eglTestCtx,
    462 																						const vector<DrawType>&	frameDrawType,
    463 																						int						iterationTimes,
    464 																						ResizeType				resizeType,
    465 																						const char*				name,
    466 																						const char*				description)
    467 	: SwapBuffersWithDamageTest (eglTestCtx, frameDrawType, iterationTimes, resizeType, name, description)
    468 {
    469 }
    470 
    471 EGLConfig SwapBuffersWithDamageAndPreserveBufferTest::getConfig (const Library& egl, EGLDisplay eglDisplay)
    472 {
    473 	return getEGLConfig(egl, eglDisplay, true);
    474 }
    475 
    476 TestCase::IterateResult SwapBuffersWithDamageAndPreserveBufferTest::iterate (void)
    477 {
    478 
    479 	de::Random			rnd				(m_seed);
    480 	const Library&		egl				= m_eglTestCtx.getLibrary();
    481 	const int			width			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    482 	const int			height			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    483 	const float			clearRed		= rnd.getFloat();
    484 	const float			clearGreen		= rnd.getFloat();
    485 	const float			clearBlue		= rnd.getFloat();
    486 	const tcu::Vec4		clearColor		(clearRed, clearGreen, clearBlue, 1.0f);
    487 	const int			numFrames		= 24; // (width, height) = (480, 480) --> numFrame = 24, divisible
    488 	const FrameSequence frameSequence	= generateFrameSequence(m_frameDrawType, rnd, numFrames, width, height);
    489 
    490 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    491 	EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
    492 
    493 	for (int iterationNdx = 0; iterationNdx < m_iterationTimes; iterationNdx++)
    494 	{
    495 		clearColorScreen(m_gl, clearColor);
    496 		EGLU_CHECK_CALL(egl, swapBuffersWithDamageKHR(m_eglDisplay, m_eglSurface, DE_NULL, 0));
    497 
    498 		for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
    499 		{
    500 			const Frame&	currentFrame = frameSequence[frameNdx];
    501 			vector<EGLint>	damageRegion = getDamageRegion(currentFrame);
    502 
    503 			m_gles2Renderer->render(width, height, currentFrame);
    504 
    505 			if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
    506 			{
    507 				if (iterationNdx % 2 == 0)
    508 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    509 				else
    510 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    511 			}
    512 
    513 			EGLU_CHECK_CALL(egl, swapBuffersWithDamageKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
    514 
    515 			if (m_resizeType == RESIZETYPE_AFTER_SWAP)
    516 			{
    517 				if (iterationNdx % 2 == 0)
    518 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    519 				else
    520 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    521 			}
    522 		}
    523 	}
    524 
    525 	return STOP;
    526 }
    527 
    528 class SwapBuffersWithDamageAndBufferAgeTest : public SwapBuffersWithDamageTest
    529 {
    530 public:
    531 					SwapBuffersWithDamageAndBufferAgeTest	(EglTestContext&			eglTestCtx,
    532 															 const vector<DrawType>&	frameDrawType,
    533 															 int						iterationTimes,
    534 															 ResizeType					resizeType,
    535 															 const char*				name,
    536 															 const char*				description);
    537 
    538 	IterateResult	iterate									(void);
    539 
    540 protected:
    541 	void			checkExtension							(const Library& egl, EGLDisplay eglDisplay);
    542 };
    543 
    544 SwapBuffersWithDamageAndBufferAgeTest::SwapBuffersWithDamageAndBufferAgeTest (EglTestContext&			eglTestCtx,
    545 																			  const vector<DrawType>&	frameDrawType,
    546 																			  int						iterationTimes,
    547 																			  ResizeType				resizeType,
    548 																			  const char*				name,
    549 																			  const char*				description)
    550 	: SwapBuffersWithDamageTest (eglTestCtx, frameDrawType, iterationTimes, resizeType, name, description)
    551 {
    552 }
    553 
    554 
    555 void SwapBuffersWithDamageAndBufferAgeTest::checkExtension (const Library& egl, EGLDisplay eglDisplay)
    556 {
    557 	if (!eglu::hasExtension(egl, eglDisplay, "EGL_KHR_swap_buffers_with_damage"))
    558 		TCU_THROW(NotSupportedError, "EGL_KHR_swap_buffers_with_damage is not supported");
    559 
    560 	if (!eglu::hasExtension(egl, eglDisplay, "EGL_EXT_buffer_age"))
    561 		TCU_THROW(NotSupportedError, "EGL_EXT_buffer_age not supported");
    562 }
    563 
    564 TestCase::IterateResult SwapBuffersWithDamageAndBufferAgeTest::iterate (void)
    565 {
    566 
    567 	de::Random			rnd				(m_seed);
    568 	const Library&		egl				= m_eglTestCtx.getLibrary();
    569 	const int			width			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    570 	const int			height			= eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    571 	const float			clearRed		= rnd.getFloat();
    572 	const float			clearGreen		= rnd.getFloat();
    573 	const float			clearBlue		= rnd.getFloat();
    574 	const tcu::Vec4		clearColor		(clearRed, clearGreen, clearBlue, 1.0f);
    575 	const int			numFrames		= 24; // (width, height) = (480, 480) --> numFrame = 24, divisible
    576 	const FrameSequence frameSequence	= generateFrameSequence(m_frameDrawType, rnd, numFrames, width, height);
    577 
    578 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    579 	EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
    580 
    581 	for (int iterationNdx = 0; iterationNdx < m_iterationTimes; iterationNdx++)
    582 	{
    583 		clearColorScreen(m_gl, clearColor);
    584 		EGLU_CHECK_CALL(egl, swapBuffersWithDamageKHR(m_eglDisplay, m_eglSurface, DE_NULL, 0));
    585 
    586 		for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
    587 		{
    588 			vector<EGLint>	damageRegion;
    589 			int				bufferAge		= -1;
    590 			int				startFrameNdx	= -1;
    591 			int				endFrameNdx		= frameNdx;
    592 
    593 			EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_EXT, &bufferAge));
    594 
    595 			if (bufferAge < 0) // invalid buffer age
    596 			{
    597 				std::ostringstream stream;
    598 				stream << "Fail, the age is invalid. Age: " << bufferAge << ", frameNdx: " << frameNdx;
    599 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, stream.str().c_str());
    600 				return STOP;
    601 			}
    602 
    603 			if (bufferAge == 0 || bufferAge > frameNdx)
    604 			{
    605 				clearColorScreen(m_gl, clearColor);
    606 				startFrameNdx = 0;
    607 			}
    608 			else
    609 				startFrameNdx = frameNdx-bufferAge+1;
    610 
    611 			for (int ndx = startFrameNdx; ndx <= endFrameNdx; ndx++)
    612 			{
    613 				const vector<EGLint> partialDamageRegion = getDamageRegion(frameSequence[ndx]);
    614 
    615 				damageRegion.insert(damageRegion.end(), partialDamageRegion.begin(), partialDamageRegion.end());
    616 				m_gles2Renderer->render(width, height, frameSequence[ndx]);
    617 			}
    618 
    619 			if (m_resizeType == RESIZETYPE_BEFORE_SWAP)
    620 			{
    621 				if (iterationNdx % 2 == 0)
    622 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    623 				else
    624 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    625 			}
    626 
    627 			EGLU_CHECK_CALL(egl, swapBuffersWithDamageKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size()/4));
    628 
    629 			if (m_resizeType == RESIZETYPE_AFTER_SWAP)
    630 			{
    631 				if (iterationNdx % 2 == 0)
    632 					m_window->setSurfaceSize(IVec2(width*2, height/2));
    633 				else
    634 					m_window->setSurfaceSize(IVec2(height/2, width*2));
    635 			}
    636 		}
    637 	}
    638 	return STOP;
    639 }
    640 
    641 // generate a frame sequence with certain frame for visual verification
    642 FrameSequence generateFrameSequence (const vector<DrawType>& frameDrawType, de::Random& rnd, int numFrames, int width, int height)
    643 {
    644 	const int			frameDiff		= height / numFrames;
    645 	const GLubyte		r				= rnd.getUint8();
    646 	const GLubyte		g				= rnd.getUint8();
    647 	const GLubyte		b				= rnd.getUint8();
    648 	const Color			color			(r, g, b);
    649 	FrameSequence		frameSequence;
    650 
    651 	for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
    652 	{
    653 		Frame frame (width, height);
    654 
    655 		for (int rectNdx = 0; rectNdx < (int)frameDrawType.size(); rectNdx++)
    656 		{
    657 			const int			rectHeight		= frameDiff / (int)frameDrawType.size();
    658 			const ColoredRect	rect			(IVec2(0, frameNdx*frameDiff+rectNdx*rectHeight), IVec2(width, frameNdx*frameDiff+(rectNdx+1)*rectHeight), color);
    659 			const DrawCommand	drawCommand		(frameDrawType[rectNdx], rect);
    660 
    661 			frame.draws.push_back(drawCommand);
    662 		}
    663 		frameSequence.push_back(frame);
    664 	}
    665 	return frameSequence;
    666 }
    667 
    668 vector<EGLint> getDamageRegion (const Frame& frame)
    669 {
    670 	vector<EGLint> damageRegion;
    671 	for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
    672 	{
    673 		const ColoredRect& rect = frame.draws[drawNdx].rect;
    674 		damageRegion.push_back(rect.bottomLeft.x());
    675 		damageRegion.push_back(rect.bottomLeft.y());
    676 		damageRegion.push_back(rect.topRight.x() - rect.bottomLeft.x());
    677 		damageRegion.push_back(rect.topRight.y() - rect.bottomLeft.y());
    678 	}
    679 
    680 	DE_ASSERT(damageRegion.size() % 4 == 0);
    681 	return damageRegion;
    682 }
    683 
    684 string generateTestName (const vector<DrawType>& frameDrawType)
    685 {
    686 	std::ostringstream stream;
    687 
    688 	for (size_t ndx = 0; ndx < frameDrawType.size(); ndx++)
    689 	{
    690 		if (frameDrawType[ndx] == DRAWTYPE_GLES2_RENDER)
    691 			stream << "render";
    692 		else if (frameDrawType[ndx] == DRAWTYPE_GLES2_CLEAR)
    693 			stream << "clear";
    694 		else
    695 			DE_ASSERT(false);
    696 
    697 		if (ndx < frameDrawType.size()-1)
    698 			stream << "_";
    699 	}
    700 
    701 	return stream.str();
    702 }
    703 
    704 string generateResizeGroupName (ResizeType resizeType)
    705 {
    706 	switch (resizeType)
    707 	{
    708 		case RESIZETYPE_NONE:
    709 			return "no_resize";
    710 
    711 		case RESIZETYPE_AFTER_SWAP:
    712 			return "resize_after_swap";
    713 
    714 		case RESIZETYPE_BEFORE_SWAP:
    715 			return "resize_before_swap";
    716 
    717 		default:
    718 			DE_FATAL("Unknown resize type");
    719 			return "";
    720 	}
    721 }
    722 
    723 bool isWindow (const eglu::CandidateConfig& c)
    724 {
    725 	return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
    726 }
    727 
    728 bool isES2Renderable (const eglu::CandidateConfig& c)
    729 {
    730 	return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
    731 }
    732 
    733 bool hasPreserveSwap (const eglu::CandidateConfig& c)
    734 {
    735 	return (c.surfaceType() & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
    736 }
    737 
    738 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, bool preserveBuffer)
    739 {
    740 	eglu::FilterList filters;
    741 
    742 	filters << isWindow << isES2Renderable;
    743 	if (preserveBuffer)
    744 		filters << hasPreserveSwap;
    745 
    746 	return eglu::chooseSingleConfig(egl, eglDisplay, filters);
    747 }
    748 
    749 void clearColorScreen (const glw::Functions& gl, const tcu::Vec4& clearColor)
    750 {
    751 	gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
    752 	gl.clear(GL_COLOR_BUFFER_BIT);
    753 }
    754 
    755 float windowToDeviceCoordinates (int x, int length)
    756 {
    757 	return (2.0f * float(x) / float(length)) - 1.0f;
    758 }
    759 
    760 } // anonymous
    761 
    762 SwapBuffersWithDamageTests::SwapBuffersWithDamageTests (EglTestContext& eglTestCtx)
    763 	: TestCaseGroup(eglTestCtx, "swap_buffers_with_damage", "Swap buffers with damages tests")
    764 {
    765 }
    766 
    767 void SwapBuffersWithDamageTests::init (void)
    768 {
    769 	const DrawType clearRender[2] =
    770 	{
    771 		DRAWTYPE_GLES2_CLEAR,
    772 		DRAWTYPE_GLES2_RENDER
    773 	};
    774 
    775 	const DrawType renderClear[2] =
    776 	{
    777 		DRAWTYPE_GLES2_RENDER,
    778 		DRAWTYPE_GLES2_CLEAR
    779 	};
    780 
    781 	const ResizeType resizeTypes[] =
    782 	{
    783 		RESIZETYPE_NONE,
    784 		RESIZETYPE_BEFORE_SWAP,
    785 		RESIZETYPE_AFTER_SWAP
    786 	};
    787 
    788 	vector< vector<DrawType> > frameDrawTypes;
    789 	frameDrawTypes.push_back(vector<DrawType> (1, DRAWTYPE_GLES2_CLEAR));
    790 	frameDrawTypes.push_back(vector<DrawType> (1, DRAWTYPE_GLES2_RENDER));
    791 	frameDrawTypes.push_back(vector<DrawType> (2, DRAWTYPE_GLES2_CLEAR));
    792 	frameDrawTypes.push_back(vector<DrawType> (2, DRAWTYPE_GLES2_RENDER));
    793 	frameDrawTypes.push_back(vector<DrawType> (DE_ARRAY_BEGIN(clearRender), DE_ARRAY_END(clearRender)));
    794 	frameDrawTypes.push_back(vector<DrawType> (DE_ARRAY_BEGIN(renderClear), DE_ARRAY_END(renderClear)));
    795 
    796 	for (size_t resizeTypeNdx = 0; resizeTypeNdx < DE_LENGTH_OF_ARRAY(resizeTypes); resizeTypeNdx++)
    797 	{
    798 		const ResizeType		resizeType	= resizeTypes[resizeTypeNdx];
    799 		TestCaseGroup* const	resizeGroup	= new TestCaseGroup(m_eglTestCtx, generateResizeGroupName(resizeType).c_str(), "");
    800 
    801 		for (size_t drawTypeNdx = 0; drawTypeNdx < frameDrawTypes.size(); drawTypeNdx++)
    802 		{
    803 			string name = generateTestName(frameDrawTypes[drawTypeNdx]);
    804 			resizeGroup->addChild(new SwapBuffersWithDamageTest(m_eglTestCtx, frameDrawTypes[drawTypeNdx], 4, resizeType, name.c_str(), ""));
    805 		}
    806 
    807 		for (size_t drawTypeNdx = 0; drawTypeNdx < frameDrawTypes.size(); drawTypeNdx++)
    808 		{
    809 			string name = "preserve_buffer_" + generateTestName(frameDrawTypes[drawTypeNdx]);
    810 			resizeGroup->addChild(new SwapBuffersWithDamageAndPreserveBufferTest(m_eglTestCtx, frameDrawTypes[drawTypeNdx], 4, resizeType, name.c_str(), ""));
    811 		}
    812 
    813 		for (size_t drawTypeNdx = 0; drawTypeNdx < frameDrawTypes.size(); drawTypeNdx++)
    814 		{
    815 			string name = "buffer_age_" + generateTestName(frameDrawTypes[drawTypeNdx]);
    816 			resizeGroup->addChild(new SwapBuffersWithDamageAndBufferAgeTest(m_eglTestCtx, frameDrawTypes[drawTypeNdx], 4, resizeType, name.c_str(),  ""));
    817 		}
    818 
    819 		addChild(resizeGroup);
    820 	}
    821 }
    822 
    823 } // egl
    824 } // deqp
    825