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 egl.swapBuffers(m_display, **m_surface);
351 IVec2 oldEglSize = checkSurfaceSize(egl,
352 m_display,
353 **m_surface,
354 *m_nativeWindow,
355 m_oldSize,
356 m_status);
357
358 initSurface(m_gl, oldEglSize);
359
360 this->resize(m_newSize);
361
362 egl.swapBuffers(m_display, **m_surface);
363 EGLU_CHECK_MSG(egl, "eglSwapBuffers()");
364 checkSurfaceSize(egl, m_display, **m_surface, *m_nativeWindow, m_newSize, m_status);
365
366 m_status.setTestContextResult(m_testCtx);
367 return STOP;
368 }
369
370 class PreserveBackBufferCase : public ResizeTest
371 {
372 public:
PreserveBackBufferCase(EglTestContext & eglTestCtx,const ResizeParams & params)373 PreserveBackBufferCase (EglTestContext& eglTestCtx,
374 const ResizeParams& params)
375 : ResizeTest(eglTestCtx, params) {}
376
377 IterateResult iterate (void);
378 EGLenum surfaceType (void) const;
379 };
380
surfaceType(void) const381 EGLenum PreserveBackBufferCase::surfaceType (void) const
382 {
383 return EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
384 }
385
iterate(void)386 IterateResult PreserveBackBufferCase::iterate (void)
387 {
388 const Library& egl = m_eglTestCtx.getLibrary();
389 ScopedCurrentContext currentCtx (egl, m_display, **m_surface, **m_surface, **m_context);
390
391 EGLU_CHECK_CALL(egl, surfaceAttrib(m_display, **m_surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
392
393 GLU_EXPECT_NO_ERROR(m_gl.getError(), "GL state erroneous upon initialization!");
394
395 {
396 const IVec2 oldEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
397 initSurface(m_gl, oldEglSize);
398
399 m_gl.finish();
400 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glFinish() failed");
401
402 {
403 const Surface oldSurface = readSurface(m_gl, oldEglSize);
404
405 egl.swapBuffers(m_display, **m_surface);
406 this->resize(m_newSize);
407 egl.swapBuffers(m_display, **m_surface);
408 EGLU_CHECK_MSG(egl, "eglSwapBuffers()");
409
410 {
411 const IVec2 newEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
412 const Surface newSurface = readSurface(m_gl, newEglSize);
413
414 m_log << TestLog::ImageSet("Corner comparison",
415 "Comparing old and new surfaces at all corners")
416 << TestLog::Image("Before resizing", "Before resizing", oldSurface)
417 << TestLog::Image("After resizing", "After resizing", newSurface)
418 << TestLog::EndImageSet;
419
420 m_status.checkResult(compareCorners(oldSurface, newSurface),
421 QP_TEST_RESULT_QUALITY_WARNING,
422 "Resizing the native window changed the contents of "
423 "the EGL surface");
424 }
425 }
426 }
427
428 m_status.setTestContextResult(m_testCtx);
429 return STOP;
430 }
431
432 typedef tcu::Vector<Interval, 2> IvVec2;
433
434 class UpdateResolutionCase : public ResizeTest
435 {
436 public:
UpdateResolutionCase(EglTestContext & eglTestCtx,const ResizeParams & params)437 UpdateResolutionCase (EglTestContext& eglTestCtx,
438 const ResizeParams& params)
439 : ResizeTest(eglTestCtx, params) {}
440
441 IterateResult iterate (void);
442
443 private:
444 IvVec2 getNativePixelsPerInch (void);
445 };
446
ivVec2(const IVec2 & vec)447 IvVec2 ivVec2 (const IVec2& vec)
448 {
449 return IvVec2(double(vec.x()), double(vec.y()));
450 }
451
approximateInt(int i)452 Interval approximateInt (int i)
453 {
454 const Interval margin(-1.0, 1.0); // The resolution may be rounded
455
456 return (Interval(i) + margin) & Interval(0.0, TCU_INFINITY);
457 }
458
getNativePixelsPerInch(void)459 IvVec2 UpdateResolutionCase::getNativePixelsPerInch (void)
460 {
461 const Library& egl = m_eglTestCtx.getLibrary();
462 const int inchPer10km = 254 * EGL_DISPLAY_SCALING;
463 const IVec2 bufSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
464 const IVec2 winSize = m_nativeWindow->getScreenSize();
465 const IVec2 bufPp10km = eglu::getSurfaceResolution(egl, m_display, **m_surface);
466 const IvVec2 bufPpiI = (IvVec2(approximateInt(bufPp10km.x()),
467 approximateInt(bufPp10km.y()))
468 / Interval(inchPer10km));
469 const IvVec2 winPpiI = ivVec2(winSize) * bufPpiI / ivVec2(bufSize);
470 const IVec2 winPpi (int(winPpiI.x().midpoint()), int(winPpiI.y().midpoint()));
471
472 m_log << TestLog::Message
473 << "EGL surface size: " << bufSize << "\n"
474 << "EGL surface pixel density (pixels / 10 km): " << bufPp10km << "\n"
475 << "Native window size: " << winSize << "\n"
476 << "Native pixel density (ppi): " << winPpi << "\n"
477 << TestLog::EndMessage;
478
479 m_status.checkResult(bufPp10km.x() >= 1 && bufPp10km.y() >= 1,
480 QP_TEST_RESULT_QUALITY_WARNING,
481 "Surface pixel density is less than one pixel per 10 km. "
482 "Is the surface really visible from space?");
483
484 return winPpiI;
485 }
486
iterate(void)487 IterateResult UpdateResolutionCase::iterate (void)
488 {
489 const Library& egl = m_eglTestCtx.getLibrary();
490 ScopedCurrentContext currentCtx (egl, m_display, **m_surface, **m_surface, **m_context);
491
492 if (!hasBits(m_nativeWindow->getCapabilities(),
493 NativeWindow::CAPABILITY_GET_SCREEN_SIZE))
494 TCU_THROW(NotSupportedError, "Unable to determine surface size in screen pixels");
495
496 {
497 const IVec2 oldEglSize = eglu::getSurfaceSize(egl, m_display, **m_surface);
498 initSurface(m_gl, oldEglSize);
499 }
500 {
501 const IvVec2 oldPpi = this->getNativePixelsPerInch();
502 this->resize(m_newSize);
503 EGLU_CHECK_CALL(egl, swapBuffers(m_display, **m_surface));
504 {
505 const IvVec2 newPpi = this->getNativePixelsPerInch();
506 m_status.check(oldPpi.x().intersects(newPpi.x()) &&
507 oldPpi.y().intersects(newPpi.y()),
508 "Window PPI differs after resizing");
509 }
510 }
511
512 m_status.setTestContextResult(m_testCtx);
513 return STOP;
514 }
515
ResizeTests(EglTestContext & eglTestCtx)516 ResizeTests::ResizeTests (EglTestContext& eglTestCtx)
517 : TestCaseGroup(eglTestCtx, "resize", "Tests resizing the native surface")
518 {
519 }
520
521 template <class Case>
createCaseGroup(EglTestContext & eglTestCtx,const string & name,const string & desc)522 TestCaseGroup* createCaseGroup(EglTestContext& eglTestCtx,
523 const string& name,
524 const string& desc)
525 {
526 const ResizeParams params[] =
527 {
528 { "shrink", "Shrink in both dimensions",
529 IVec2(128, 128), IVec2(32, 32) },
530 { "grow", "Grow in both dimensions",
531 IVec2(32, 32), IVec2(128, 128) },
532 { "stretch_width", "Grow horizontally, shrink vertically",
533 IVec2(32, 128), IVec2(128, 32) },
534 { "stretch_height", "Grow vertically, shrink horizontally",
535 IVec2(128, 32), IVec2(32, 128) },
536 };
537 TestCaseGroup* const group =
538 new TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str());
539
540 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(params); ++ndx)
541 group->addChild(new Case(eglTestCtx, params[ndx]));
542
543 return group;
544 }
545
init(void)546 void ResizeTests::init (void)
547 {
548 addChild(createCaseGroup<ChangeSurfaceSizeCase>(m_eglTestCtx,
549 "surface_size",
550 "EGL surface size update"));
551 addChild(createCaseGroup<PreserveBackBufferCase>(m_eglTestCtx,
552 "back_buffer",
553 "Back buffer contents"));
554 addChild(createCaseGroup<UpdateResolutionCase>(m_eglTestCtx,
555 "pixel_density",
556 "Pixel density"));
557 }
558
559 } // egl
560 } // deqp
561