1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL Module
3 * ---------------------------------------
4 *
5 * Copyright 2014 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 Tests for resizing the native window of a surface.
22 *//*--------------------------------------------------------------------*/
23
24 #include "teglResizeTests.hpp"
25
26 #include "teglSimpleConfigCase.hpp"
27
28 #include "tcuImageCompare.hpp"
29 #include "tcuSurface.hpp"
30 #include "tcuPlatform.hpp"
31 #include "tcuTestLog.hpp"
32 #include "tcuInterval.hpp"
33 #include "tcuTextureUtil.hpp"
34 #include "tcuResultCollector.hpp"
35
36 #include "egluNativeDisplay.hpp"
37 #include "egluNativeWindow.hpp"
38 #include "egluNativePixmap.hpp"
39 #include "egluUnique.hpp"
40 #include "egluUtil.hpp"
41
42 #include "eglwLibrary.hpp"
43 #include "eglwEnums.hpp"
44
45 #include "gluDefs.hpp"
46 #include "glwFunctions.hpp"
47 #include "glwEnums.hpp"
48
49 #include "tcuTestLog.hpp"
50 #include "tcuVector.hpp"
51
52 #include "deThread.h"
53 #include "deUniquePtr.hpp"
54
55 #include <sstream>
56
57 namespace deqp
58 {
59 namespace egl
60 {
61
62 using std::vector;
63 using std::string;
64 using std::ostringstream;
65 using de::MovePtr;
66 using tcu::CommandLine;
67 using tcu::ConstPixelBufferAccess;
68 using tcu::Interval;
69 using tcu::IVec2;
70 using tcu::Vec3;
71 using tcu::Vec4;
72 using tcu::UVec4;
73 using tcu::ResultCollector;
74 using tcu::Surface;
75 using tcu::TestLog;
76 using eglu::AttribMap;
77 using eglu::NativeDisplay;
78 using eglu::NativeWindow;
79 using eglu::ScopedCurrentContext;
80 using eglu::UniqueSurface;
81 using eglu::UniqueContext;
82 using eglu::NativeWindowFactory;
83 using eglu::WindowParams;
84 using namespace eglw;
85
86 typedef eglu::WindowParams::Visibility Visibility;
87 typedef TestCase::IterateResult IterateResult;
88
89 struct ResizeParams
90 {
91 string name;
92 string description;
93 IVec2 oldSize;
94 IVec2 newSize;
95 };
96
97 class ResizeTest : public TestCase
98 {
99 public:
ResizeTest(EglTestContext & eglTestCtx,const ResizeParams & params)100 ResizeTest (EglTestContext& eglTestCtx,
101 const ResizeParams& params)
102 : TestCase (eglTestCtx,
103 params.name.c_str(),
104 params.description.c_str())
105 , m_oldSize (params.oldSize)
106 , m_newSize (params.newSize)
107 , m_display (EGL_NO_DISPLAY)
108 , m_config (DE_NULL)
109 , m_log (m_testCtx.getLog())
110 , m_status (m_log) {}
111
112 void init (void);
113 void deinit (void);
114
115 protected:
surfaceType(void) const116 virtual EGLenum surfaceType (void) const { return EGL_WINDOW_BIT; }
117 void resize (IVec2 size);
118
119 const IVec2 m_oldSize;
120 const IVec2 m_newSize;
121 EGLDisplay m_display;
122 EGLConfig m_config;
123 MovePtr<NativeWindow> m_nativeWindow;
124 MovePtr<UniqueSurface> m_surface;
125 MovePtr<UniqueContext> m_context;
126 TestLog& m_log;
127 ResultCollector m_status;
128 glw::Functions m_gl;
129 };
130
getEGLConfig(const Library & egl,const EGLDisplay eglDisplay,EGLenum surfaceType)131 EGLConfig getEGLConfig (const Library& egl, const EGLDisplay eglDisplay, EGLenum surfaceType)
132 {
133 AttribMap attribMap;
134
135 attribMap[EGL_SURFACE_TYPE] = surfaceType;
136 attribMap[EGL_RENDERABLE_TYPE] = EGL_OPENGL_ES2_BIT;
137
138 return eglu::chooseSingleConfig(egl, eglDisplay, attribMap);
139 }
140
init(void)141 void ResizeTest::init (void)
142 {
143 TestCase::init();
144
145 const Library& egl = m_eglTestCtx.getLibrary();
146 const CommandLine& cmdLine = m_testCtx.getCommandLine();
147 const EGLDisplay eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
148 const EGLConfig eglConfig = getEGLConfig(egl, eglDisplay, surfaceType());
149 const EGLint ctxAttribs[] =
150 {
151 EGL_CONTEXT_CLIENT_VERSION, 2,
152 EGL_NONE
153 };
154 EGLContext eglContext = egl.createContext(eglDisplay,
155 eglConfig,
156 EGL_NO_CONTEXT,
157 ctxAttribs);
158 EGLU_CHECK_MSG(egl, "eglCreateContext()");
159 MovePtr<UniqueContext> context (new UniqueContext(egl, eglDisplay, eglContext));
160 const EGLint configId = eglu::getConfigAttribInt(egl,
161 eglDisplay,
162 eglConfig,
163 EGL_CONFIG_ID);
164 const Visibility visibility = eglu::parseWindowVisibility(cmdLine);
165 NativeDisplay& nativeDisplay = m_eglTestCtx.getNativeDisplay();
166 const NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(),
167 cmdLine);
168
169 const WindowParams windowParams (m_oldSize.x(), m_oldSize.y(), visibility);
170 MovePtr<NativeWindow> nativeWindow (windowFactory.createWindow(&nativeDisplay,
171 eglDisplay,
172 eglConfig,
173 DE_NULL,
174 windowParams));
175 const EGLSurface eglSurface = eglu::createWindowSurface(nativeDisplay,
176 *nativeWindow,
177 eglDisplay,
178 eglConfig,
179 DE_NULL);
180 MovePtr<UniqueSurface> surface (new UniqueSurface(egl, eglDisplay, eglSurface));
181
182 m_log << TestLog::Message
183 << "Chose EGLConfig with id " << configId << ".\n"
184 << "Created initial surface with size " << m_oldSize
185 << TestLog::EndMessage;
186
187 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2, 0));
188 m_config = eglConfig;
189 m_surface = surface;
190 m_context = context;
191 m_display = eglDisplay;
192 m_nativeWindow = nativeWindow;
193 EGLU_CHECK_MSG(egl, "init");
194 }
195
deinit(void)196 void ResizeTest::deinit (void)
197 {
198 if (m_display != EGL_NO_DISPLAY)
199 m_eglTestCtx.getLibrary().terminate(m_display);
200
201 m_config = DE_NULL;
202 m_display = EGL_NO_DISPLAY;
203 m_context.clear();
204 m_surface.clear();
205 m_nativeWindow.clear();
206 }
207
resize(IVec2 size)208 void ResizeTest::resize (IVec2 size)
209 {
210 m_nativeWindow->setSurfaceSize(size);
211 m_testCtx.getPlatform().processEvents();
212 m_log << TestLog::Message
213 << "Resized surface to size " << size
214 << TestLog::EndMessage;
215 }
216
217 class ChangeSurfaceSizeCase : public ResizeTest
218 {
219 public:
ChangeSurfaceSizeCase(EglTestContext & eglTestCtx,const ResizeParams & params)220 ChangeSurfaceSizeCase (EglTestContext& eglTestCtx,
221 const ResizeParams& params)
222 : ResizeTest(eglTestCtx, params) {}
223
224 IterateResult iterate (void);
225 };
226
drawRectangle(const glw::Functions & gl,IVec2 pos,IVec2 size,Vec3 color)227 void drawRectangle (const glw::Functions& gl, IVec2 pos, IVec2 size, Vec3 color)
228 {
229 gl.clearColor(color.x(), color.y(), color.z(), 1.0);
230 gl.scissor(pos.x(), pos.y(), size.x(), size.y());
231 gl.enable(GL_SCISSOR_TEST);
232 gl.clear(GL_COLOR_BUFFER_BIT);
233 gl.disable(GL_SCISSOR_TEST);
234 GLU_EXPECT_NO_ERROR(gl.getError(),
235 "Rectangle drawing with glScissor and glClear failed.");
236 }
237
initSurface(const glw::Functions & gl,IVec2 oldSize)238 void initSurface (const glw::Functions& gl, IVec2 oldSize)
239 {
240 const Vec3 frameColor (0.0f, 0.0f, 1.0f);
241 const Vec3 fillColor (1.0f, 0.0f, 0.0f);
242 const Vec3 markColor (0.0f, 1.0f, 0.0f);
243
244 drawRectangle(gl, IVec2(0, 0), oldSize, frameColor);
245 drawRectangle(gl, IVec2(2, 2), oldSize - IVec2(4, 4), fillColor);
246
247 drawRectangle(gl, IVec2(0, 0), IVec2(8, 4), markColor);
248 drawRectangle(gl, oldSize - IVec2(16, 16), IVec2(8, 4), markColor);
249 drawRectangle(gl, IVec2(0, oldSize.y() - 16), IVec2(8, 4), markColor);
250 drawRectangle(gl, IVec2(oldSize.x() - 16, 0), IVec2(8, 4), markColor);
251 }
252
compareRectangles(const ConstPixelBufferAccess & rectA,const ConstPixelBufferAccess & rectB)253 bool compareRectangles (const ConstPixelBufferAccess& rectA,
254 const ConstPixelBufferAccess& rectB)
255 {
256 const int width = rectA.getWidth();
257 const int height = rectA.getHeight();
258 const int depth = rectA.getDepth();
259
260 if (rectB.getWidth() != width || rectB.getHeight() != height || rectB.getDepth() != depth)
261 return false;
262
263 for (int z = 0; z < depth; ++z)
264 for (int y = 0; y < height; ++y)
265 for (int x = 0; x < width; ++x)
266 if (rectA.getPixel(x, y, z) != rectB.getPixel(x, y, z))
267 return false;
268
269 return true;
270 }
271
272 // Check whether `oldSurface` and `newSurface` share a common corner.
compareCorners(const Surface & oldSurface,const Surface & newSurface)273 bool compareCorners (const Surface& oldSurface, const Surface& newSurface)
274 {
275 const int oldWidth = oldSurface.getWidth();
276 const int oldHeight = oldSurface.getHeight();
277 const int newWidth = newSurface.getWidth();
278 const int newHeight = newSurface.getHeight();
279 const int minWidth = de::min(oldWidth, newWidth);
280 const int minHeight = de::min(oldHeight, newHeight);
281
282 for (int xCorner = 0; xCorner < 2; ++xCorner)
283 {
284 const int oldX = xCorner == 0 ? 0 : oldWidth - minWidth;
285 const int newX = xCorner == 0 ? 0 : newWidth - minWidth;
286
287 for (int yCorner = 0; yCorner < 2; ++yCorner)
288 {
289 const int oldY = yCorner == 0 ? 0 : oldHeight - minHeight;
290 const int newY = yCorner == 0 ? 0 : newHeight - minHeight;
291 ConstPixelBufferAccess oldAccess =
292 getSubregion(oldSurface.getAccess(), oldX, oldY, minWidth, minHeight);
293 ConstPixelBufferAccess newAccess =
294 getSubregion(newSurface.getAccess(), newX, newY, minWidth, minHeight);
295
296 if (compareRectangles(oldAccess, newAccess))
297 return true;
298 }
299 }
300
301 return false;
302 }
303
readSurface(const glw::Functions & gl,IVec2 size)304 Surface readSurface (const glw::Functions& gl, IVec2 size)
305 {
306 Surface ret (size.x(), size.y());
307 gl.readPixels(0, 0, size.x(), size.y(), GL_RGBA, GL_UNSIGNED_BYTE,
308 ret.getAccess().getDataPtr());
309
310 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed");
311 return ret;
312 }
313
314 template <typename T>
hasBits(T bitSet,T requiredBits)315 inline bool hasBits (T bitSet, T requiredBits)
316 {
317 return (bitSet & requiredBits) == requiredBits;
318 }
319
getNativeSurfaceSize(const NativeWindow & nativeWindow,IVec2 reqSize)320 IVec2 getNativeSurfaceSize (const NativeWindow& nativeWindow,
321 IVec2 reqSize)
322 {
323 if (hasBits(nativeWindow.getCapabilities(), NativeWindow::CAPABILITY_GET_SURFACE_SIZE))
324 return nativeWindow.getSurfaceSize();
325 return reqSize; // assume we got the requested size
326 }
327
checkSurfaceSize(const Library & egl,EGLDisplay eglDisplay,EGLSurface eglSurface,const NativeWindow & nativeWindow,IVec2 reqSize,ResultCollector & status)328 IVec2 checkSurfaceSize (const Library& egl,
329 EGLDisplay eglDisplay,
330 EGLSurface eglSurface,
331 const NativeWindow& nativeWindow,
332 IVec2 reqSize,
333 ResultCollector& status)
334 {
335 const IVec2 nativeSize = getNativeSurfaceSize(nativeWindow, reqSize);
336 IVec2 eglSize = eglu::getSurfaceSize(egl, eglDisplay, eglSurface);
337 ostringstream oss;
338
339 oss << "Size of EGL surface " << eglSize
340 << " differs from size of native window " << nativeSize;
341 status.check(eglSize == nativeSize, oss.str());
342
343 return eglSize;
344 }
345
iterate(void)346 IterateResult ChangeSurfaceSizeCase::iterate (void)
347 {
348 const Library& egl = m_eglTestCtx.getLibrary();
349 ScopedCurrentContext currentCtx (egl, m_display, **m_surface, **m_surface, **m_context);
350 IVec2 oldEglSize = checkSurfaceSize(egl,
351 m_display,
352 **m_surface,
353 *m_nativeWindow,
354 m_oldSize,
355 m_status);
356
357 initSurface(m_gl, oldEglSize);
358
359 this->resize(m_newSize);
360
361 egl.swapBuffers(m_display, **m_surface);
362 EGLU_CHECK_MSG(egl, "eglSwapBuffers()");
363 checkSurfaceSize(egl, m_display, **m_surface, *m_nativeWindow, m_newSize, m_status);
364
365 m_status.setTestContextResult(m_testCtx);
366 return STOP;
367 }
368
369 class PreserveBackBufferCase : public ResizeTest
370 {
371 public:
PreserveBackBufferCase(EglTestContext & eglTestCtx,const ResizeParams & params)372 PreserveBackBufferCase (EglTestContext& eglTestCtx,
373 const ResizeParams& params)
374 : ResizeTest(eglTestCtx, params) {}
375
376 IterateResult iterate (void);
377 EGLenum surfaceType (void) const;
378 };
379
surfaceType(void) const380 EGLenum PreserveBackBufferCase::surfaceType (void) const
381 {
382 return EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
383 }
384
iterate(void)385 IterateResult PreserveBackBufferCase::iterate (void)
386 {
387 const Library& egl = m_eglTestCtx.getLibrary();
388 ScopedCurrentContext currentCtx (egl, m_display, **m_surface, **m_surface, **m_context);
389
390 EGLU_CHECK_CALL(egl, surfaceAttrib(m_display, **m_surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
391
392 GLU_EXPECT_NO_ERROR(m_gl.getError(), "GL state erroneous upon initialization!");
393
394 {
395 const IVec2 oldEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
396 initSurface(m_gl, oldEglSize);
397
398 m_gl.finish();
399 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glFinish() failed");
400
401 {
402 const Surface oldSurface = readSurface(m_gl, oldEglSize);
403
404 egl.swapBuffers(m_display, **m_surface);
405 this->resize(m_newSize);
406 egl.swapBuffers(m_display, **m_surface);
407 EGLU_CHECK_MSG(egl, "eglSwapBuffers()");
408
409 {
410 const IVec2 newEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
411 const Surface newSurface = readSurface(m_gl, newEglSize);
412
413 m_log << TestLog::ImageSet("Corner comparison",
414 "Comparing old and new surfaces at all corners")
415 << TestLog::Image("Before resizing", "Before resizing", oldSurface)
416 << TestLog::Image("After resizing", "After resizing", newSurface)
417 << TestLog::EndImageSet;
418
419 m_status.checkResult(compareCorners(oldSurface, newSurface),
420 QP_TEST_RESULT_QUALITY_WARNING,
421 "Resizing the native window changed the contents of "
422 "the EGL surface");
423 }
424 }
425 }
426
427 m_status.setTestContextResult(m_testCtx);
428 return STOP;
429 }
430
431 typedef tcu::Vector<Interval, 2> IvVec2;
432
433 class UpdateResolutionCase : public ResizeTest
434 {
435 public:
UpdateResolutionCase(EglTestContext & eglTestCtx,const ResizeParams & params)436 UpdateResolutionCase (EglTestContext& eglTestCtx,
437 const ResizeParams& params)
438 : ResizeTest(eglTestCtx, params) {}
439
440 IterateResult iterate (void);
441
442 private:
443 IvVec2 getNativePixelsPerInch (void);
444 };
445
ivVec2(const IVec2 & vec)446 IvVec2 ivVec2 (const IVec2& vec)
447 {
448 return IvVec2(double(vec.x()), double(vec.y()));
449 }
450
approximateInt(int i)451 Interval approximateInt (int i)
452 {
453 const Interval margin(-1.0, 1.0); // The resolution may be rounded
454
455 return (Interval(i) + margin) & Interval(0.0, TCU_INFINITY);
456 }
457
getNativePixelsPerInch(void)458 IvVec2 UpdateResolutionCase::getNativePixelsPerInch (void)
459 {
460 const Library& egl = m_eglTestCtx.getLibrary();
461 const int inchPer10km = 254 * EGL_DISPLAY_SCALING;
462 const IVec2 bufSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
463 const IVec2 winSize = m_nativeWindow->getScreenSize();
464 const IVec2 bufPp10km = eglu::getSurfaceResolution(egl, m_display, **m_surface);
465 const IvVec2 bufPpiI = (IvVec2(approximateInt(bufPp10km.x()),
466 approximateInt(bufPp10km.y()))
467 / Interval(inchPer10km));
468 const IvVec2 winPpiI = ivVec2(winSize) * bufPpiI / ivVec2(bufSize);
469 const IVec2 winPpi (int(winPpiI.x().midpoint()), int(winPpiI.y().midpoint()));
470
471 m_log << TestLog::Message
472 << "EGL surface size: " << bufSize << "\n"
473 << "EGL surface pixel density (pixels / 10 km): " << bufPp10km << "\n"
474 << "Native window size: " << winSize << "\n"
475 << "Native pixel density (ppi): " << winPpi << "\n"
476 << TestLog::EndMessage;
477
478 m_status.checkResult(bufPp10km.x() >= 1 && bufPp10km.y() >= 1,
479 QP_TEST_RESULT_QUALITY_WARNING,
480 "Surface pixel density is less than one pixel per 10 km. "
481 "Is the surface really visible from space?");
482
483 return winPpiI;
484 }
485
iterate(void)486 IterateResult UpdateResolutionCase::iterate (void)
487 {
488 const Library& egl = m_eglTestCtx.getLibrary();
489 ScopedCurrentContext currentCtx (egl, m_display, **m_surface, **m_surface, **m_context);
490
491 if (!hasBits(m_nativeWindow->getCapabilities(),
492 NativeWindow::CAPABILITY_GET_SCREEN_SIZE))
493 TCU_THROW(NotSupportedError, "Unable to determine surface size in screen pixels");
494
495 {
496 const IVec2 oldEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
497 initSurface(m_gl, oldEglSize);
498 }
499 {
500 const IvVec2 oldPpi = this->getNativePixelsPerInch();
501 this->resize(m_newSize);
502 EGLU_CHECK_CALL(egl, swapBuffers(m_display, **m_surface));
503 {
504 const IvVec2 newPpi = this->getNativePixelsPerInch();
505 m_status.check(oldPpi.x().intersects(newPpi.x()) &&
506 oldPpi.y().intersects(newPpi.y()),
507 "Window PPI differs after resizing");
508 }
509 }
510
511 m_status.setTestContextResult(m_testCtx);
512 return STOP;
513 }
514
ResizeTests(EglTestContext & eglTestCtx)515 ResizeTests::ResizeTests (EglTestContext& eglTestCtx)
516 : TestCaseGroup(eglTestCtx, "resize", "Tests resizing the native surface")
517 {
518 }
519
520 template <class Case>
createCaseGroup(EglTestContext & eglTestCtx,const string & name,const string & desc)521 TestCaseGroup* createCaseGroup(EglTestContext& eglTestCtx,
522 const string& name,
523 const string& desc)
524 {
525 const ResizeParams params[] =
526 {
527 { "shrink", "Shrink in both dimensions",
528 IVec2(128, 128), IVec2(32, 32) },
529 { "grow", "Grow in both dimensions",
530 IVec2(32, 32), IVec2(128, 128) },
531 { "stretch_width", "Grow horizontally, shrink vertically",
532 IVec2(32, 128), IVec2(128, 32) },
533 { "stretch_height", "Grow vertically, shrink horizontally",
534 IVec2(128, 32), IVec2(32, 128) },
535 };
536 TestCaseGroup* const group =
537 new TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str());
538
539 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(params); ++ndx)
540 group->addChild(new Case(eglTestCtx, params[ndx]));
541
542 return group;
543 }
544
init(void)545 void ResizeTests::init (void)
546 {
547 addChild(createCaseGroup<ChangeSurfaceSizeCase>(m_eglTestCtx,
548 "surface_size",
549 "EGL surface size update"));
550 addChild(createCaseGroup<PreserveBackBufferCase>(m_eglTestCtx,
551 "back_buffer",
552 "Back buffer contents"));
553 addChild(createCaseGroup<UpdateResolutionCase>(m_eglTestCtx,
554 "pixel_density",
555 "Pixel density"));
556 }
557
558 } // egl
559 } // deqp
560