Merge vulkan-cts-1.0 into vulkan-cts-1.0-dev
[platform/upstream/VK-GL-CTS.git] / modules / egl / teglResizeTests.cpp
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:
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:
116         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
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
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
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
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:
220                                         ChangeSurfaceSizeCase   (EglTestContext&                eglTestCtx,
221                                                                                          const ResizeParams&    params)
222                                                 : ResizeTest(eglTestCtx, params) {}
223
224         IterateResult   iterate                                 (void);
225 };
226
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
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
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.
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
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>
315 inline bool hasBits (T bitSet, T requiredBits)
316 {
317         return (bitSet & requiredBits) == requiredBits;
318 }
319
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
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
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:
372                                         PreserveBackBufferCase  (EglTestContext&                eglTestCtx,
373                                                                                          const ResizeParams&    params)
374                                                 : ResizeTest(eglTestCtx, params) {}
375
376         IterateResult   iterate                                 (void);
377         EGLenum                 surfaceType                             (void) const;
378 };
379
380 EGLenum PreserveBackBufferCase::surfaceType (void) const
381 {
382         return EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
383 }
384
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:
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
446 IvVec2 ivVec2 (const IVec2& vec)
447 {
448         return IvVec2(double(vec.x()), double(vec.y()));
449 }
450
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
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
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
515 ResizeTests::ResizeTests (EglTestContext& eglTestCtx)
516         : TestCaseGroup(eglTestCtx, "resize", "Tests resizing the native surface")
517 {
518 }
519
520 template <class Case>
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
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