Merge vk-gl-cts/vulkan-cts-1.0.2 into vk-gl-cts/master
[platform/upstream/VK-GL-CTS.git] / modules / egl / teglRenderCase.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 Base class for rendering tests.
22  *//*--------------------------------------------------------------------*/
23
24 #include "teglRenderCase.hpp"
25
26 #include "teglSimpleConfigCase.hpp"
27
28 #include "egluNativeDisplay.hpp"
29 #include "egluNativeWindow.hpp"
30 #include "egluNativePixmap.hpp"
31 #include "egluUtil.hpp"
32 #include "egluUnique.hpp"
33
34 #include "eglwLibrary.hpp"
35 #include "eglwEnums.hpp"
36
37 #include "tcuRenderTarget.hpp"
38 #include "tcuTestLog.hpp"
39 #include "tcuCommandLine.hpp"
40
41 #include "deStringUtil.hpp"
42 #include "deUniquePtr.hpp"
43
44 #include <algorithm>
45 #include <iterator>
46 #include <memory>
47 #include <set>
48
49 namespace deqp
50 {
51 namespace egl
52 {
53
54 using std::string;
55 using std::vector;
56 using std::set;
57 using tcu::TestLog;
58 using namespace eglw;
59
60 static void postSurface (const Library& egl, EGLDisplay display, EGLSurface surface, EGLint typeBit)
61 {
62         if (typeBit == EGL_WINDOW_BIT)
63                 EGLU_CHECK_CALL(egl, swapBuffers(display, surface));
64         else if (typeBit == EGL_PIXMAP_BIT)
65                 EGLU_CHECK_CALL(egl, waitClient());
66         else if (typeBit == EGL_PBUFFER_BIT)
67                 EGLU_CHECK_CALL(egl, waitClient());
68         else
69                 DE_ASSERT(false);
70 }
71
72 // RenderCase
73
74 RenderCase::RenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint surfaceTypeMask, const eglu::FilterList& filters)
75         : SimpleConfigCase      (eglTestCtx, name, description, filters)
76         , m_surfaceTypeMask     (surfaceTypeMask)
77 {
78 }
79
80 RenderCase::~RenderCase (void)
81 {
82 }
83
84 EGLint getBuildClientAPIMask (void)
85 {
86         EGLint apiMask = 0;
87
88         // Always supported regardless of flags - dynamically loaded
89         apiMask |= EGL_OPENGL_ES2_BIT;
90         apiMask |= EGL_OPENGL_ES3_BIT;
91         apiMask |= EGL_OPENGL_BIT;
92
93 #if defined(DEQP_SUPPORT_GLES1)
94         apiMask |= EGL_OPENGL_ES_BIT;
95 #endif
96
97 #if defined(DEQP_SUPPORT_VG)
98         apiMask |= EGL_OPENVG_BIT;
99 #endif
100
101         return apiMask;
102 }
103
104 static void checkBuildClientAPISupport (EGLint requiredAPIs)
105 {
106         const EGLint    builtClientAPIs         = getBuildClientAPIMask();
107
108         if ((requiredAPIs & builtClientAPIs) != requiredAPIs)
109                 TCU_THROW(InternalError, "Test case requires client API not supported in current build");
110 }
111
112 void RenderCase::executeForConfig (EGLDisplay display, EGLConfig config)
113 {
114         const Library&                                          egl                             = m_eglTestCtx.getLibrary();
115         tcu::TestLog&                                           log                             = m_testCtx.getLog();
116         const int                                                       width                   = 128;
117         const int                                                       height                  = 128;
118         const EGLint                                            configId                = eglu::getConfigID(egl, display, config);
119
120         const eglu::NativeDisplayFactory&       displayFactory  = m_eglTestCtx.getNativeDisplayFactory();
121         eglu::NativeDisplay&                            nativeDisplay   = m_eglTestCtx.getNativeDisplay();
122
123         bool                                                            isOk                    = true;
124         string                                                          failReason              = "";
125
126         if (m_surfaceTypeMask & EGL_WINDOW_BIT)
127         {
128                 tcu::ScopedLogSection(log,
129                                                           string("Config") + de::toString(configId) + "-Window",
130                                                           string("Config ID ") + de::toString(configId) + ", window surface");
131
132                 const eglu::NativeWindowFactory&        windowFactory   = eglu::selectNativeWindowFactory(displayFactory, m_testCtx.getCommandLine());
133
134                 try
135                 {
136                         const eglu::WindowParams                        params          (width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine()));
137                         de::UniquePtr<eglu::NativeWindow>       window          (windowFactory.createWindow(&nativeDisplay, display, config, DE_NULL, params));
138                         EGLSurface                                                      eglSurface      = createWindowSurface(nativeDisplay, *window, display, config, DE_NULL);
139                         eglu::UniqueSurface                                     surface         (egl, display, eglSurface);
140
141                         executeForSurface(display, *surface, Config(config, EGL_WINDOW_BIT, 0));
142                 }
143                 catch (const tcu::TestError& e)
144                 {
145                         log << e;
146                         isOk = false;
147                         failReason = e.what();
148                 }
149         }
150
151         if (m_surfaceTypeMask & EGL_PIXMAP_BIT)
152         {
153                 tcu::ScopedLogSection(log,
154                                                           string("Config") + de::toString(configId) + "-Pixmap",
155                                                           string("Config ID ") + de::toString(configId) + ", pixmap surface");
156
157                 const eglu::NativePixmapFactory&        pixmapFactory   = eglu::selectNativePixmapFactory(displayFactory, m_testCtx.getCommandLine());
158
159                 try
160                 {
161                         de::UniquePtr<eglu::NativePixmap>       pixmap          (pixmapFactory.createPixmap(&nativeDisplay, display, config, DE_NULL, width, height));
162                         EGLSurface                                                      eglSurface      = createPixmapSurface(nativeDisplay, *pixmap, display, config, DE_NULL);
163                         eglu::UniqueSurface                                     surface         (egl, display, eglSurface);
164
165                         executeForSurface(display, *surface, Config(config, EGL_PIXMAP_BIT, 0));
166                 }
167                 catch (const tcu::TestError& e)
168                 {
169                         log << e;
170                         isOk = false;
171                         failReason = e.what();
172                 }
173         }
174
175         if (m_surfaceTypeMask & EGL_PBUFFER_BIT)
176         {
177                 tcu::ScopedLogSection(log,
178                                                           string("Config") + de::toString(configId) + "-Pbuffer",
179                                                           string("Config ID ") + de::toString(configId) + ", pbuffer surface");
180                 try
181                 {
182                         const EGLint surfaceAttribs[] =
183                         {
184                                 EGL_WIDTH,      width,
185                                 EGL_HEIGHT,     height,
186                                 EGL_NONE
187                         };
188
189                         eglu::UniqueSurface surface(egl, display, egl.createPbufferSurface(display, config, surfaceAttribs));
190                         EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");
191
192                         executeForSurface(display, *surface, Config(config, EGL_PBUFFER_BIT, 0));
193                 }
194                 catch (const tcu::TestError& e)
195                 {
196                         log << e;
197                         isOk = false;
198                         failReason = e.what();
199                 }
200         }
201
202         if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
203                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, failReason.c_str());
204 }
205
206 // SingleContextRenderCase
207
208 SingleContextRenderCase::SingleContextRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint apiMask, EGLint surfaceTypeMask, const eglu::FilterList& filters)
209         : RenderCase    (eglTestCtx, name, description, surfaceTypeMask, filters)
210         , m_apiMask             (apiMask)
211 {
212 }
213
214 SingleContextRenderCase::~SingleContextRenderCase (void)
215 {
216 }
217
218 void SingleContextRenderCase::executeForSurface (EGLDisplay display, EGLSurface surface, const Config& config)
219 {
220         const Library&          egl                             = m_eglTestCtx.getLibrary();
221         const EGLint            apis[]                  = { EGL_OPENGL_ES2_BIT, EGL_OPENGL_ES3_BIT_KHR, EGL_OPENGL_ES_BIT, EGL_OPENVG_BIT };
222         tcu::TestLog&           log                             = m_testCtx.getLog();
223         const EGLint            configApiMask   = eglu::getConfigAttribInt(egl, display, config.config, EGL_RENDERABLE_TYPE);
224
225         checkBuildClientAPISupport(m_apiMask);
226
227         for (int apiNdx = 0; apiNdx < DE_LENGTH_OF_ARRAY(apis); apiNdx++)
228         {
229                 EGLint apiBit = apis[apiNdx];
230
231                 // Skip API if build or current config doesn't support it.
232                 if ((apiBit & m_apiMask) == 0 || (apiBit & configApiMask) == 0)
233                         continue;
234
235                 EGLint                  api             = EGL_NONE;
236                 const char*             apiName = DE_NULL;
237                 vector<EGLint>  contextAttribs;
238
239                 // Select api enum and build context attributes.
240                 switch (apiBit)
241                 {
242                         case EGL_OPENGL_ES2_BIT:
243                                 api             = EGL_OPENGL_ES_API;
244                                 apiName = "OpenGL ES 2.x";
245                                 contextAttribs.push_back(EGL_CONTEXT_CLIENT_VERSION);
246                                 contextAttribs.push_back(2);
247                                 break;
248
249                         case EGL_OPENGL_ES3_BIT_KHR:
250                                 api             = EGL_OPENGL_ES_API;
251                                 apiName = "OpenGL ES 3.x";
252                                 contextAttribs.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
253                                 contextAttribs.push_back(3);
254                                 break;
255
256                         case EGL_OPENGL_ES_BIT:
257                                 api             = EGL_OPENGL_ES_API;
258                                 apiName = "OpenGL ES 1.x";
259                                 contextAttribs.push_back(EGL_CONTEXT_CLIENT_VERSION);
260                                 contextAttribs.push_back(1);
261                                 break;
262
263                         case EGL_OPENVG_BIT:
264                                 api             = EGL_OPENVG_API;
265                                 apiName = "OpenVG";
266                                 break;
267
268                         default:
269                                 DE_ASSERT(DE_FALSE);
270                 }
271
272                 contextAttribs.push_back(EGL_NONE);
273
274                 log << TestLog::Message << apiName << TestLog::EndMessage;
275
276                 EGLU_CHECK_CALL(egl, bindAPI(api));
277
278                 eglu::UniqueContext     context (egl, display, egl.createContext(display, config.config, EGL_NO_CONTEXT, &contextAttribs[0]));
279
280                 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, *context));
281                 executeForContext(display, *context, surface, Config(config.config, config.surfaceTypeBit, apiBit));
282
283                 // Call SwapBuffers() / WaitClient() to finish rendering
284                 postSurface(egl, display, surface, config.surfaceTypeBit);
285         }
286
287         EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
288 }
289
290 // MultiContextRenderCase
291
292 MultiContextRenderCase::MultiContextRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi)
293         : RenderCase                    (eglTestCtx, name, description, surfaceType, filters)
294         , m_numContextsPerApi   (numContextsPerApi)
295         , m_apiMask                             (api)
296 {
297 }
298
299 MultiContextRenderCase::~MultiContextRenderCase (void)
300 {
301 }
302
303 void MultiContextRenderCase::executeForSurface (EGLDisplay display, EGLSurface surface, const Config& config)
304 {
305         const Library&                                                  egl                             = m_eglTestCtx.getLibrary();
306         const EGLint                                                    configApiMask   = eglu::getConfigAttribInt(egl, display, config.config, EGL_RENDERABLE_TYPE);
307         vector<std::pair<EGLint, EGLContext> >  contexts;
308         contexts.reserve(3*m_numContextsPerApi); // 3 types of contexts at maximum.
309
310         checkBuildClientAPISupport(m_apiMask);
311
312         // ConfigFilter should make sure that config always supports all of the APIs.
313         TCU_CHECK_INTERNAL((configApiMask & m_apiMask) == m_apiMask);
314
315         try
316         {
317                 // Create contexts that will participate in rendering.
318                 for (int ndx = 0; ndx < m_numContextsPerApi; ndx++)
319                 {
320                         if (m_apiMask & EGL_OPENGL_ES2_BIT)
321                         {
322                                 static const EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
323                                 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
324                                 contexts.push_back(std::make_pair(EGL_OPENGL_ES2_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0])));
325                         }
326
327                         if (m_apiMask & EGL_OPENGL_ES3_BIT_KHR)
328                         {
329                                 static const EGLint attribs[] = { EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_NONE };
330                                 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
331                                 contexts.push_back(std::make_pair(EGL_OPENGL_ES3_BIT_KHR, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0])));
332                         }
333
334                         if (m_apiMask & EGL_OPENGL_ES_BIT)
335                         {
336                                 static const EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE };
337                                 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
338                                 contexts.push_back(std::make_pair(EGL_OPENGL_ES_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0])));
339                         }
340
341                         if (m_apiMask & EGL_OPENVG_BIT)
342                         {
343                                 static const EGLint attribs[] = { EGL_NONE };
344                                 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENVG_API));
345                                 contexts.push_back(std::make_pair(EGL_OPENVG_BIT, egl.createContext(display, config.config, EGL_NO_CONTEXT, &attribs[0])));
346                         }
347                 }
348
349                 EGLU_CHECK_MSG(egl, "eglCreateContext()");
350
351                 // Execute for contexts.
352                 executeForContexts(display, surface, Config(config.config, config.surfaceTypeBit, m_apiMask), contexts);
353
354                 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
355         }
356         catch (...)
357         {
358                 // Make sure all contexts have been destroyed.
359                 for (vector<std::pair<EGLint, EGLContext> >::iterator i = contexts.begin(); i != contexts.end(); i++)
360                         egl.destroyContext(display, i->second);
361                 throw;
362         }
363
364         // Destroy contexts.
365         for (vector<std::pair<EGLint, EGLContext> >::iterator i = contexts.begin(); i != contexts.end(); i++)
366                 egl.destroyContext(display, i->second);
367 }
368
369 // Utilities
370
371 template <int Red, int Green, int Blue, int Alpha>
372 static bool colorBits (const eglu::CandidateConfig& c)
373 {
374         return c.redSize()              == Red          &&
375                    c.greenSize()        == Green        &&
376                    c.blueSize()         == Blue         &&
377                    c.alphaSize()        == Alpha;
378 }
379
380 template <int Red, int Green, int Blue, int Alpha>
381 static bool notColorBits (const eglu::CandidateConfig& c)
382 {
383         return c.redSize()              != Red          ||
384                    c.greenSize()        != Green        ||
385                    c.blueSize()         != Blue         ||
386                    c.alphaSize()        != Alpha;
387 }
388
389 template <deUint32 Type>
390 static bool surfaceType (const eglu::CandidateConfig& c)
391 {
392         return (c.surfaceType() & Type) == Type;
393 }
394
395 static bool isConformant (const eglu::CandidateConfig& c)
396 {
397         return c.get(EGL_CONFIG_CAVEAT) != EGL_NON_CONFORMANT_CONFIG;
398 }
399
400 static bool notFloat (const eglu::CandidateConfig& c)
401 {
402         return c.colorComponentType() != EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT;
403 }
404
405 void getDefaultRenderFilterLists (vector<RenderFilterList>& filterLists, const eglu::FilterList& baseFilters)
406 {
407         static const struct
408         {
409                 const char*                     name;
410                 eglu::ConfigFilter      filter;
411         } s_colorRules[] =
412         {
413                 { "rgb565",             colorBits<5, 6, 5, 0>   },
414                 { "rgb888",             colorBits<8, 8, 8, 0>   },
415                 { "rgba4444",   colorBits<4, 4, 4, 4>   },
416                 { "rgba5551",   colorBits<5, 5, 5, 1>   },
417                 { "rgba8888",   colorBits<8, 8, 8, 8>   },
418         };
419
420         static const struct
421         {
422                 const char*                     name;
423                 EGLint                          bits;
424                 eglu::ConfigFilter      filter;
425         } s_surfaceRules[] =
426         {
427                 { "window",             EGL_WINDOW_BIT,         surfaceType<EGL_WINDOW_BIT>             },
428                 { "pixmap",             EGL_PIXMAP_BIT,         surfaceType<EGL_PIXMAP_BIT>,    },
429                 { "pbuffer",    EGL_PBUFFER_BIT,        surfaceType<EGL_PBUFFER_BIT>    }
430         };
431
432         for (int colorNdx = 0; colorNdx < DE_LENGTH_OF_ARRAY(s_colorRules); colorNdx++)
433         {
434                 for (int surfaceNdx = 0; surfaceNdx < DE_LENGTH_OF_ARRAY(s_surfaceRules); surfaceNdx++)
435                 {
436                         const string            name    = string(s_colorRules[colorNdx].name) + "_" + s_surfaceRules[surfaceNdx].name;
437                         RenderFilterList        filters (name.c_str(), "", s_surfaceRules[surfaceNdx].bits);
438
439                         filters << baseFilters
440                                         << s_colorRules[colorNdx].filter
441                                         << s_surfaceRules[surfaceNdx].filter
442                                         << isConformant;
443
444                         filterLists.push_back(filters);
445                 }
446         }
447
448         // Add other config ids to "other" set
449         {
450                 RenderFilterList        filters ("other", "", EGL_WINDOW_BIT|EGL_PIXMAP_BIT|EGL_PBUFFER_BIT);
451
452                 filters << baseFilters
453                                 << notColorBits<5, 6, 5, 0>
454                                 << notColorBits<8, 8, 8, 0>
455                                 << notColorBits<4, 4, 4, 4>
456                                 << notColorBits<5, 5, 5, 1>
457                                 << notColorBits<8, 8, 8, 8>
458                                 << isConformant
459                                 << notFloat;
460
461                 filterLists.push_back(filters);
462         }
463 }
464
465 } // egl
466 } // deqp