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