1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL Module
3 * ---------------------------------------
4 *
5 * Copyright 2017 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 Test KHR_wide_color
22 *//*--------------------------------------------------------------------*/
23
24 #include "teglWideColorTests.hpp"
25
26 #include "tcuImageCompare.hpp"
27 #include "tcuTestLog.hpp"
28 #include "tcuSurface.hpp"
29 #include "tcuTextureUtil.hpp"
30
31 #include "egluNativeWindow.hpp"
32 #include "egluStrUtil.hpp"
33 #include "egluUtil.hpp"
34 #include "egluConfigFilter.hpp"
35
36 #include "eglwLibrary.hpp"
37 #include "eglwEnums.hpp"
38
39 #include "gluDefs.hpp"
40 #include "gluRenderContext.hpp"
41 #include "gluShaderProgram.hpp"
42
43 #include "glwDefs.hpp"
44 #include "glwEnums.hpp"
45 #include "glwFunctions.hpp"
46
47 #include "deMath.h"
48 #include "deRandom.hpp"
49 #include "deString.h"
50 #include "deStringUtil.hpp"
51
52 #include <string>
53 #include <vector>
54 #include <sstream>
55
56 using std::string;
57 using std::vector;
58 using glw::GLubyte;
59 using glw::GLfloat;
60 using tcu::IVec2;
61
62 using namespace eglw;
63
64 namespace deqp
65 {
66 namespace egl
67 {
68 namespace
69 {
70
71 typedef tcu::Vec4 Color;
72
73 class GLES2Renderer;
74
75 class ReferenceRenderer;
76
77 class WideColorTests : public TestCaseGroup
78 {
79 public:
80 WideColorTests (EglTestContext& eglTestCtx);
81 void init (void);
82
83 private:
84 WideColorTests (const WideColorTests&);
85 WideColorTests& operator= (const WideColorTests&);
86 };
87
88 class WideColorTest : public TestCase
89 {
90 public:
91 enum DrawType
92 {
93 DRAWTYPE_GLES2_CLEAR,
94 DRAWTYPE_GLES2_RENDER
95 };
96
97 WideColorTest (EglTestContext& eglTestCtx, const char* name, const char* description);
98 ~WideColorTest (void);
99
100 void init (void);
101 void deinit (void);
102 void checkPixelFloatSupport (void);
103 void checkColorSpaceSupport (void);
104 void checkDisplayP3Support (void);
105 void checkDisplayP3LinearSupport (void);
106 void check1010102Support (void);
107 void checkFP16Support (void);
108 void checkSCRGBSupport (void);
109 void checkSCRGBLinearSupport (void);
110
111 protected:
112 void initEGLSurface (EGLConfig config);
113 void initEGLContext (EGLConfig config);
114
115 EGLDisplay m_eglDisplay;
116 glw::Functions m_gl;
117 };
118
119 struct ColoredRect
120 {
121 public:
122 ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
123 IVec2 bottomLeft;
124 IVec2 topRight;
125 Color color;
126 };
127
ColoredRect(const IVec2 & bottomLeft_,const IVec2 & topRight_,const Color & color_)128 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
129 : bottomLeft (bottomLeft_)
130 , topRight (topRight_)
131 , color (color_)
132 {
133 }
134
clearColorScreen(const glw::Functions & gl,const Color & clearColor)135 void clearColorScreen (const glw::Functions& gl, const Color& clearColor)
136 {
137 gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
138 gl.clear(GL_COLOR_BUFFER_BIT);
139 }
140
windowToDeviceCoordinates(int x,int length)141 float windowToDeviceCoordinates (int x, int length)
142 {
143 return (2.0f * float(x) / float(length)) - 1.0f;
144 }
145
146 class GLES2Renderer
147 {
148 public:
149 GLES2Renderer (const glw::Functions& gl, int width, int height);
150 ~GLES2Renderer (void);
151 void render (const ColoredRect& coloredRect) const;
152
153 private:
154 GLES2Renderer (const GLES2Renderer&);
155 GLES2Renderer& operator= (const GLES2Renderer&);
156
157 const glw::Functions& m_gl;
158 glu::ShaderProgram m_glProgram;
159 glw::GLuint m_coordLoc;
160 glw::GLuint m_colorLoc;
161 glw::GLuint m_bufWidth;
162 glw::GLuint m_bufHeight;
163 };
164
165 // generate sources for vertex and fragment buffer
getSources(void)166 glu::ProgramSources getSources (void)
167 {
168 const char* const vertexShaderSource =
169 "attribute mediump vec2 a_pos;\n"
170 "attribute mediump vec4 a_color;\n"
171 "varying mediump vec4 v_color;\n"
172 "void main(void)\n"
173 "{\n"
174 "\tv_color = a_color;\n"
175 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
176 "}";
177
178 const char* const fragmentShaderSource =
179 "varying mediump vec4 v_color;\n"
180 "void main(void)\n"
181 "{\n"
182 "\tgl_FragColor = v_color;\n"
183 "}";
184
185 return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
186 }
187
GLES2Renderer(const glw::Functions & gl,int width,int height)188 GLES2Renderer::GLES2Renderer (const glw::Functions& gl, int width, int height)
189 : m_gl (gl)
190 , m_glProgram (gl, getSources())
191 , m_coordLoc ((glw::GLuint)-1)
192 , m_colorLoc ((glw::GLuint)-1)
193 , m_bufWidth (width)
194 , m_bufHeight (height)
195 {
196 m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
197 m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
198 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
199 }
200
~GLES2Renderer(void)201 GLES2Renderer::~GLES2Renderer (void)
202 {
203 }
204
render(const struct ColoredRect & coloredRect) const205 void GLES2Renderer::render (const struct ColoredRect &coloredRect) const
206 {
207 const float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), m_bufWidth);
208 const float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), m_bufHeight);
209 const float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), m_bufWidth);
210 const float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), m_bufHeight);
211
212 const glw::GLfloat coords[] =
213 {
214 x1, y1, 0.0f, 1.0f,
215 x1, y2, 0.0f, 1.0f,
216 x2, y2, 0.0f, 1.0f,
217
218 x2, y2, 0.0f, 1.0f,
219 x2, y1, 0.0f, 1.0f,
220 x1, y1, 0.0f, 1.0f
221 };
222
223 const glw::GLfloat colors[] =
224 {
225 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
226 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
227 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
228
229 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
230 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
231 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
232 };
233
234 m_gl.useProgram(m_glProgram.getProgram());
235 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
236
237 m_gl.enableVertexAttribArray(m_coordLoc);
238 m_gl.enableVertexAttribArray(m_colorLoc);
239 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
240
241 m_gl.vertexAttribPointer(m_coordLoc, 4, GL_FLOAT, GL_FALSE, 0, coords);
242 m_gl.vertexAttribPointer(m_colorLoc, 4, GL_FLOAT, GL_TRUE, 0, colors);
243 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
244
245 m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/4);
246 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
247
248 m_gl.disableVertexAttribArray(m_coordLoc);
249 m_gl.disableVertexAttribArray(m_colorLoc);
250 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
251
252 m_gl.useProgram(0);
253 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
254 }
255
256 class ReferenceRenderer
257 {
258 public:
259 ReferenceRenderer (void);
260 private:
261 ReferenceRenderer (const ReferenceRenderer&);
262 ReferenceRenderer& operator= (const ReferenceRenderer&);
263 };
264
ReferenceRenderer(void)265 ReferenceRenderer::ReferenceRenderer (void)
266 {
267 }
268
WideColorTest(EglTestContext & eglTestCtx,const char * name,const char * description)269 WideColorTest::WideColorTest (EglTestContext& eglTestCtx, const char* name, const char* description)
270 : TestCase (eglTestCtx, name, description)
271 , m_eglDisplay (EGL_NO_DISPLAY)
272 {
273 }
274
~WideColorTest(void)275 WideColorTest::~WideColorTest (void)
276 {
277 deinit();
278 }
279
init(void)280 void WideColorTest::init (void)
281 {
282 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
283
284 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
285 }
286
checkPixelFloatSupport(void)287 void WideColorTest::checkPixelFloatSupport (void)
288 {
289 const Library& egl = m_eglTestCtx.getLibrary();
290
291 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_pixel_format_float"))
292 TCU_THROW(NotSupportedError, "EGL_EXT_pixel_format_float is not supported");
293 }
294
checkColorSpaceSupport(void)295 void WideColorTest::checkColorSpaceSupport (void)
296 {
297 const Library& egl = m_eglTestCtx.getLibrary();
298
299 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_gl_colorspace"))
300 TCU_THROW(NotSupportedError, "EGL_KHR_gl_colorspace is not supported");
301 }
302
checkDisplayP3Support(void)303 void WideColorTest::checkDisplayP3Support (void)
304 {
305 const Library& egl = m_eglTestCtx.getLibrary();
306
307 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_display_p3"))
308 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_display_p3 is not supported");
309 }
310
checkDisplayP3LinearSupport(void)311 void WideColorTest::checkDisplayP3LinearSupport (void)
312 {
313 const Library& egl = m_eglTestCtx.getLibrary();
314
315 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_display_p3_linear"))
316 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_display_p3_linear is not supported");
317 }
318
checkSCRGBSupport(void)319 void WideColorTest::checkSCRGBSupport (void)
320 {
321 const Library& egl = m_eglTestCtx.getLibrary();
322
323 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_scrgb"))
324 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_scrgb is not supported");
325 }
326
checkSCRGBLinearSupport(void)327 void WideColorTest::checkSCRGBLinearSupport (void)
328 {
329 const Library& egl = m_eglTestCtx.getLibrary();
330
331 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_scrgb_linear"))
332 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_scrgb_linear is not supported");
333 }
334
check1010102Support(void)335 void WideColorTest::check1010102Support (void)
336 {
337 const Library& egl = m_eglTestCtx.getLibrary();
338 tcu::TestLog& log = m_testCtx.getLog();
339
340 const EGLint attribList[] =
341 {
342 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
343 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
344 EGL_RED_SIZE, 10,
345 EGL_GREEN_SIZE, 10,
346 EGL_BLUE_SIZE, 10,
347 EGL_ALPHA_SIZE, 2,
348 EGL_NONE, EGL_NONE
349 };
350 EGLint numConfigs = 0;
351 EGLConfig config;
352
353 // Query from EGL implementation
354 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], DE_NULL, 0, &numConfigs));
355
356 if (numConfigs <= 0)
357 {
358 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
359 TCU_THROW(NotSupportedError, "10:10:10:2 pixel format is not supported");
360 }
361
362 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
363
364 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], &config, 1, &numConfigs));
365 if (numConfigs > 1)
366 {
367 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
368 TCU_FAIL("Too many configs returned");
369 }
370
371 EGLint components[4];
372
373 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_RED_SIZE, &components[0]));
374 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_GREEN_SIZE, &components[1]));
375 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_BLUE_SIZE, &components[2]));
376 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_ALPHA_SIZE, &components[3]));
377
378 TCU_CHECK_MSG(components[0] == 10, "Missing 10bit deep red channel");
379 TCU_CHECK_MSG(components[1] == 10, "Missing 10bit deep green channel");
380 TCU_CHECK_MSG(components[2] == 10, "Missing 10bit deep blue channel");
381 TCU_CHECK_MSG(components[3] == 2, "Missing 2bit deep alpha channel");
382 }
383
checkFP16Support(void)384 void WideColorTest::checkFP16Support (void)
385 {
386 const Library& egl = m_eglTestCtx.getLibrary();
387 tcu::TestLog& log = m_testCtx.getLog();
388 EGLint numConfigs = 0;
389 EGLConfig config;
390
391 const EGLint attribList[] =
392 {
393 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
394 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
395 EGL_RED_SIZE, 16,
396 EGL_GREEN_SIZE, 16,
397 EGL_BLUE_SIZE, 16,
398 EGL_ALPHA_SIZE, 16,
399 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
400 EGL_NONE, EGL_NONE
401 };
402
403 // Query from EGL implementation
404 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], DE_NULL, 0, &numConfigs));
405
406 if (numConfigs <= 0)
407 {
408 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
409 TCU_THROW(NotSupportedError, "10:10:10:2 pixel format is not supported");
410 }
411
412 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
413
414 EGLBoolean success = egl.chooseConfig(m_eglDisplay, &attribList[0], &config, 1, &numConfigs);
415 if (success != EGL_TRUE)
416 {
417 log << tcu::TestLog::Message << "Fail, eglChooseConfig returned an error." << tcu::TestLog::EndMessage;
418 TCU_FAIL("eglChooseConfig failed");
419 }
420 if (numConfigs > 1)
421 {
422 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
423 TCU_FAIL("Too many configs returned");
424 }
425
426 EGLint components[4];
427
428 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_RED_SIZE, &components[0]);
429 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
430 EGLU_CHECK(egl);
431 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_GREEN_SIZE, &components[1]);
432 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
433 EGLU_CHECK(egl);
434 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_BLUE_SIZE, &components[2]);
435 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
436 EGLU_CHECK(egl);
437 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_ALPHA_SIZE, &components[3]);
438 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
439 EGLU_CHECK(egl);
440
441 TCU_CHECK_MSG(components[0] == 16, "Missing 16bit deep red channel");
442 TCU_CHECK_MSG(components[1] == 16, "Missing 16bit deep green channel");
443 TCU_CHECK_MSG(components[2] == 16, "Missing 16bit deep blue channel");
444 TCU_CHECK_MSG(components[3] == 16, "Missing 16bit deep alpha channel");
445 }
446
deinit(void)447 void WideColorTest::deinit (void)
448 {
449 const Library& egl = m_eglTestCtx.getLibrary();
450
451 if (m_eglDisplay != EGL_NO_DISPLAY)
452 {
453 egl.terminate(m_eglDisplay);
454 m_eglDisplay = EGL_NO_DISPLAY;
455 }
456 }
457
458 class WideColorFP16Test : public WideColorTest
459 {
460 public:
461 WideColorFP16Test (EglTestContext& eglTestCtx, const char* name, const char* description);
462
463 void init (void);
464 void executeTest (void);
465 IterateResult iterate (void);
466 };
467
WideColorFP16Test(EglTestContext & eglTestCtx,const char * name,const char * description)468 WideColorFP16Test::WideColorFP16Test (EglTestContext& eglTestCtx,
469 const char* name,
470 const char* description)
471 : WideColorTest(eglTestCtx, name, description)
472 {
473 }
474
475
executeTest(void)476 void WideColorFP16Test::executeTest (void)
477 {
478 checkPixelFloatSupport();
479 checkFP16Support();
480 }
481
iterate(void)482 TestCase::IterateResult WideColorFP16Test::iterate (void)
483 {
484 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
485 executeTest();
486 return STOP;
487 }
488
init(void)489 void WideColorFP16Test::init (void)
490 {
491 WideColorTest::init();
492 }
493
494 class WideColor1010102Test : public WideColorTest
495 {
496 public:
497 WideColor1010102Test (EglTestContext& eglTestCtx,
498 const char* name,
499 const char* description);
500
501 void executeTest (void);
502 IterateResult iterate (void);
503 };
504
WideColor1010102Test(EglTestContext & eglTestCtx,const char * name,const char * description)505 WideColor1010102Test::WideColor1010102Test (EglTestContext& eglTestCtx, const char* name, const char* description)
506 : WideColorTest(eglTestCtx, name, description)
507 {
508 }
509
executeTest(void)510 void WideColor1010102Test::executeTest (void)
511 {
512 check1010102Support();
513 }
514
iterate(void)515 TestCase::IterateResult WideColor1010102Test::iterate (void)
516 {
517 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
518 executeTest();
519 return STOP;
520 }
521
522 struct Iteration
523 {
524 float start;
525 float increment;
526 int iterationCount;
Iterationdeqp::egl::__anon6e68da900111::Iteration527 Iteration(float s, float i, int c)
528 : start(s), increment(i), iterationCount(c) {}
529 };
530
531 class WideColorSurfaceTest : public WideColorTest
532 {
533 public:
534 WideColorSurfaceTest (EglTestContext& eglTestCtx,
535 const char* name,
536 const char* description,
537 const EGLint* attribList,
538 EGLint colorSpace,
539 const std::vector<Iteration>& iterations);
540
541 void init (void);
542 void executeTest (void);
543 IterateResult iterate (void);
544
545 protected:
546 void readPixels (const glw::Functions& gl, float* dataPtr);
547 void readPixels (const glw::Functions& gl, deUint32* dataPtr);
548 void readPixels (const glw::Functions& gl, deUint8* dataPtr);
549 deUint32 expectedUint10 (float reference);
550 deUint32 expectedUint2 (float reference);
551 deUint8 expectedUint8 (float reference);
552 deUint8 expectedAlpha8 (float reference);
553 bool checkWithThreshold8 (deUint8 value, deUint8 reference, deUint8 threshold = 1);
554 bool checkWithThreshold10 (deUint32 value, deUint32 reference, deUint32 threshold = 1);
555 bool checkWithThresholdFloat (float value, float reference, float threshold);
556 void doClearTest (EGLSurface surface);
557 void testPixels (float reference, float increment);
558 void writeEglConfig (EGLConfig config);
559
560 private:
561 std::vector<EGLint> m_attribList;
562 EGLConfig m_eglConfig;
563 EGLint m_surfaceType;
564 EGLint m_componentType;
565 EGLint m_redSize;
566 EGLint m_colorSpace;
567 const std::vector<struct Iteration> m_iterations;
568 std::stringstream m_debugLog;
569 };
570
WideColorSurfaceTest(EglTestContext & eglTestCtx,const char * name,const char * description,const EGLint * attribList,EGLint colorSpace,const std::vector<struct Iteration> & iterations)571 WideColorSurfaceTest::WideColorSurfaceTest (EglTestContext& eglTestCtx, const char* name, const char* description, const EGLint* attribList, EGLint colorSpace, const std::vector<struct Iteration>& iterations)
572 : WideColorTest (eglTestCtx, name, description)
573 , m_colorSpace (colorSpace)
574 , m_iterations (iterations)
575 {
576 deUint32 idx = 0;
577 while (attribList[idx] != EGL_NONE)
578 {
579 if (attribList[idx] == EGL_COLOR_COMPONENT_TYPE_EXT)
580 {
581 m_componentType = attribList[idx + 1];
582 }
583 else if (attribList[idx] == EGL_SURFACE_TYPE)
584 {
585 m_surfaceType = attribList[idx+1];
586 }
587 else if (attribList[idx] == EGL_RED_SIZE)
588 {
589 m_redSize = attribList[idx + 1];
590 }
591 m_attribList.push_back(attribList[idx++]);
592 m_attribList.push_back(attribList[idx++]);
593 }
594 m_attribList.push_back(EGL_NONE);
595 }
596
init(void)597 void WideColorSurfaceTest::init (void)
598 {
599 const Library& egl = m_eglTestCtx.getLibrary();
600 tcu::TestLog& log = m_testCtx.getLog();
601
602 WideColorTest::init();
603
604 // Only check for pixel format required for this specific run
605 // If not available, check will abort test with "NotSupported"
606 switch (m_redSize)
607 {
608 case 10:
609 check1010102Support();
610 break;
611 case 16:
612 checkPixelFloatSupport();
613 checkFP16Support();
614 break;
615 }
616
617 if (m_colorSpace != EGL_NONE && !eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_gl_colorspace"))
618 TCU_THROW(NotSupportedError, "EGL_KHR_gl_colorspace is not supported");
619
620 switch (m_colorSpace) {
621 case EGL_GL_COLORSPACE_SRGB_KHR:
622 checkColorSpaceSupport();
623 break;
624 case EGL_GL_COLORSPACE_DISPLAY_P3_EXT:
625 checkDisplayP3Support();
626 break;
627 case EGL_GL_COLORSPACE_SCRGB_EXT:
628 checkSCRGBSupport();
629 break;
630 case EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT:
631 checkSCRGBLinearSupport();
632 break;
633 default:
634 break;
635 }
636
637 EGLint numConfigs = 0;
638
639 // Query from EGL implementation
640 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &m_attribList[0], DE_NULL, 0, &numConfigs));
641
642 if (numConfigs <= 0)
643 {
644 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
645 TCU_FAIL("No configs returned");
646 }
647
648 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
649
650 EGLBoolean success = egl.chooseConfig(m_eglDisplay, &m_attribList[0], &m_eglConfig, 1, &numConfigs);
651 if (success != EGL_TRUE)
652 {
653 log << tcu::TestLog::Message << "Fail, eglChooseConfig returned an error." << tcu::TestLog::EndMessage;
654 TCU_FAIL("eglChooseConfig failed");
655 }
656 if (numConfigs > 1)
657 {
658 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
659 TCU_FAIL("Too many configs returned");
660 }
661
662 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
663
664 writeEglConfig(m_eglConfig);
665
666 }
667
readPixels(const glw::Functions & gl,float * dataPtr)668 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, float* dataPtr)
669 {
670 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, dataPtr);
671 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with floats");
672 }
673
readPixels(const glw::Functions & gl,deUint32 * dataPtr)674 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, deUint32 *dataPtr)
675 {
676 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, dataPtr);
677 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with RGBA_1010102 (32bits)");
678 }
679
readPixels(const glw::Functions & gl,deUint8 * dataPtr)680 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, deUint8 *dataPtr)
681 {
682 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, dataPtr);
683 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with RGBA_8888 (8 bit components)");
684 }
685
writeEglConfig(EGLConfig config)686 void WideColorSurfaceTest::writeEglConfig (EGLConfig config)
687 {
688 const Library& egl = m_eglTestCtx.getLibrary();
689 tcu::TestLog& log = m_testCtx.getLog();
690 qpEglConfigInfo info;
691 EGLint val = 0;
692
693 info.bufferSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BUFFER_SIZE);
694
695 info.redSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_RED_SIZE);
696
697 info.greenSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_GREEN_SIZE);
698
699 info.blueSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BLUE_SIZE);
700
701 info.luminanceSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_LUMINANCE_SIZE);
702
703 info.alphaSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_ALPHA_SIZE);
704
705 info.alphaMaskSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_ALPHA_MASK_SIZE);
706
707 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BIND_TO_TEXTURE_RGB);
708 info.bindToTextureRGB = val == EGL_TRUE ? true : false;
709
710 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BIND_TO_TEXTURE_RGBA);
711 info.bindToTextureRGBA = val == EGL_TRUE ? true : false;
712
713 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_COLOR_BUFFER_TYPE);
714 std::string colorBufferType = de::toString(eglu::getColorBufferTypeStr(val));
715 info.colorBufferType = colorBufferType.c_str();
716
717 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFIG_CAVEAT);
718 std::string caveat = de::toString(eglu::getConfigCaveatStr(val));
719 info.configCaveat = caveat.c_str();
720
721 info.configID = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFIG_ID);
722
723 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFORMANT);
724 std::string conformant = de::toString(eglu::getAPIBitsStr(val));
725 info.conformant = conformant.c_str();
726
727 info.depthSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_DEPTH_SIZE);
728
729 info.level = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_LEVEL);
730
731 info.maxPBufferWidth = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_WIDTH);
732
733 info.maxPBufferHeight = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_HEIGHT);
734
735 info.maxPBufferPixels = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_PIXELS);
736
737 info.maxSwapInterval = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_SWAP_INTERVAL);
738
739 info.minSwapInterval = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MIN_SWAP_INTERVAL);
740
741 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_NATIVE_RENDERABLE);
742 info.nativeRenderable = val == EGL_TRUE ? true : false;
743
744 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_RENDERABLE_TYPE);
745 std::string renderableTypes = de::toString(eglu::getAPIBitsStr(val));
746 info.renderableType = renderableTypes.c_str();
747
748 info.sampleBuffers = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SAMPLE_BUFFERS);
749
750 info.samples = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SAMPLES);
751
752 info.stencilSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_STENCIL_SIZE);
753
754 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SURFACE_TYPE);
755 std::string surfaceTypes = de::toString(eglu::getSurfaceBitsStr(val));
756 info.surfaceTypes = surfaceTypes.c_str();
757
758 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_TYPE);
759 std::string transparentType = de::toString(eglu::getTransparentTypeStr(val));
760 info.transparentType = transparentType.c_str();
761
762 info.transparentRedValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_RED_VALUE);
763
764 info.transparentGreenValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_GREEN_VALUE);
765
766 info.transparentBlueValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_BLUE_VALUE);
767
768 log.writeEglConfig(&info);
769 }
770
expectedUint10(float reference)771 deUint32 WideColorSurfaceTest::expectedUint10 (float reference)
772 {
773 deUint32 expected;
774
775 if (reference < 0.0)
776 {
777 expected = 0;
778 }
779 else if (reference > 1.0)
780 {
781 expected = 1023;
782 }
783 else
784 {
785 expected = static_cast<deUint32>(deRound(reference * 1023.0));
786 }
787
788 return expected;
789 }
790
expectedUint2(float reference)791 deUint32 WideColorSurfaceTest::expectedUint2 (float reference)
792 {
793 deUint32 expected;
794
795 if (reference < 0.0)
796 {
797 expected = 0;
798 }
799 else if (reference > 1.0)
800 {
801 expected = 3;
802 }
803 else
804 {
805 expected = static_cast<deUint32>(deRound(reference * 3.0));
806 }
807
808 return expected;
809 }
810
expectedUint8(float reference)811 deUint8 WideColorSurfaceTest::expectedUint8 (float reference)
812 {
813 deUint8 expected;
814 if (reference < 0.0)
815 {
816 expected = 0;
817 }
818 else if (reference >= 1.0)
819 {
820 expected = 255;
821 }
822 else
823 {
824 // Apply sRGB transfer function when colorspace is sRGB and pixel component
825 // size is 8 bits (which is why we are here in expectedUint8).
826 if (m_colorSpace == EGL_GL_COLORSPACE_SRGB_KHR)
827 {
828 float srgbReference;
829
830 if (reference <= 0.0031308)
831 {
832 srgbReference = 12.92f * reference;
833 }
834 else
835 {
836 float powRef = deFloatPow(reference, (1.0f/2.4f));
837 srgbReference = (1.055f * powRef) - 0.055f;
838 }
839 expected = static_cast<deUint8>(deRound(srgbReference * 255.0));
840 }
841 else
842 {
843 expected = static_cast<deUint8>(deRound(reference * 255.0));
844 }
845 }
846 return expected;
847 }
848
expectedAlpha8(float reference)849 deUint8 WideColorSurfaceTest::expectedAlpha8 (float reference)
850 {
851 deUint8 expected;
852 if (reference < 0.0)
853 {
854 expected = 0;
855 }
856 else if (reference >= 1.0)
857 {
858 expected = 255;
859 }
860 else
861 {
862 // The sRGB transfer function is not applied to alpha
863 expected = static_cast<deUint8>(deRound(reference * 255.0));
864 }
865 return expected;
866 }
867
868 // Return true for value out of range (fail)
checkWithThreshold8(deUint8 value,deUint8 reference,deUint8 threshold)869 bool WideColorSurfaceTest::checkWithThreshold8(deUint8 value, deUint8 reference, deUint8 threshold)
870 {
871 const deUint8 low = reference >= threshold ? static_cast<deUint8>(reference - threshold) : 0;
872 const deUint8 high = reference <= (255 - threshold) ? static_cast<deUint8>(reference + threshold) : 255;
873 return !((value >= low) && (value <= high));
874 }
875
checkWithThreshold10(deUint32 value,deUint32 reference,deUint32 threshold)876 bool WideColorSurfaceTest::checkWithThreshold10(deUint32 value, deUint32 reference, deUint32 threshold)
877 {
878 const deUint32 low = reference >= threshold ? reference - threshold : 0;
879 const deUint32 high = reference <= (1023 - threshold) ? reference + threshold : 1023;
880 return !((value >= low) && (value <= high));
881 }
882
checkWithThresholdFloat(float value,float reference,float threshold)883 bool WideColorSurfaceTest::checkWithThresholdFloat(float value, float reference, float threshold)
884 {
885 const float low = reference - threshold;
886 const float high = reference + threshold;
887 return !((value >= low) && (value <= high));
888 }
889
testPixels(float reference,float increment)890 void WideColorSurfaceTest::testPixels (float reference, float increment)
891 {
892 tcu::TestLog& log = m_testCtx.getLog();
893
894 if (m_componentType == EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT)
895 {
896 float pixels[16];
897 const float expected[4] =
898 {
899 reference,
900 reference + increment,
901 reference - increment,
902 reference + 2 * increment
903 };
904 readPixels(m_gl, pixels);
905
906 if (checkWithThresholdFloat(pixels[0], expected[0], increment) ||
907 checkWithThresholdFloat(pixels[1], expected[1], increment) ||
908 checkWithThresholdFloat(pixels[2], expected[2], increment) ||
909 checkWithThresholdFloat(pixels[3], expected[3], increment))
910 {
911 if (m_debugLog.str().size() > 0)
912 {
913 log << tcu::TestLog::Message
914 << "Prior passing tests\n"
915 << m_debugLog.str()
916 << tcu::TestLog::EndMessage;
917 m_debugLog.str("");
918 }
919 log << tcu::TestLog::Message
920 << "Image comparison failed: "
921 << "reference = " << reference
922 << ", expected = " << expected[0]
923 << ":" << expected[1]
924 << ":" << expected[2]
925 << ":" << expected[3]
926 << ", result = " << pixels[0]
927 << ":" << pixels[1]
928 << ":" << pixels[2]
929 << ":" << pixels[3]
930 << tcu::TestLog::EndMessage;
931 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
932 }
933 else
934 {
935 // Pixel matches expected value
936 m_debugLog << "Image comparison passed: "
937 << "reference = " << reference
938 << ", result = " << pixels[0]
939 << ":" << pixels[1]
940 << ":" << pixels[2]
941 << ":" << pixels[3]
942 << "\n";
943 }
944 }
945 else if (m_redSize > 8)
946 {
947 deUint32 buffer[16];
948 readPixels(m_gl, buffer);
949 deUint32 pixels[4];
950 deUint32 expected[4];
951
952 pixels[0] = buffer[0] & 0x3ff;
953 pixels[1] = (buffer[0] >> 10) & 0x3ff;
954 pixels[2] = (buffer[0] >> 20) & 0x3ff;
955 pixels[3] = (buffer[0] >> 30) & 0x3;
956
957 expected[0] = expectedUint10(reference);
958 expected[1] = expectedUint10(reference + increment);
959 expected[2] = expectedUint10(reference - increment);
960 expected[3] = expectedUint2(reference + 2 * increment);
961 if (checkWithThreshold10(pixels[0], expected[0]) || checkWithThreshold10(pixels[1], expected[1])
962 || checkWithThreshold10(pixels[2], expected[2]) || checkWithThreshold10(pixels[3], expected[3]))
963 {
964 if (m_debugLog.str().size() > 0) {
965 log << tcu::TestLog::Message
966 << "Prior passing tests\n"
967 << m_debugLog.str()
968 << tcu::TestLog::EndMessage;
969 m_debugLog.str("");
970 }
971 log << tcu::TestLog::Message
972 << "Image comparison failed: "
973 << "reference = " << reference
974 << ", expected = " << static_cast<deUint32>(expected[0])
975 << ":" << static_cast<deUint32>(expected[1])
976 << ":" << static_cast<deUint32>(expected[2])
977 << ":" << static_cast<deUint32>(expected[3])
978 << ", result = " << static_cast<deUint32>(pixels[0])
979 << ":" << static_cast<deUint32>(pixels[1])
980 << ":" << static_cast<deUint32>(pixels[2])
981 << ":" << static_cast<deUint32>(pixels[3])
982 << tcu::TestLog::EndMessage;
983 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
984 }
985 else
986 {
987 // Pixel matches expected value
988 m_debugLog << "Image comparison passed: "
989 << "reference = " << reference
990 << ", result = " << static_cast<deUint32>(pixels[0])
991 << ":" << static_cast<deUint32>(pixels[1])
992 << ":" << static_cast<deUint32>(pixels[2])
993 << ":" << static_cast<deUint32>(pixels[3])
994 << "\n";
995 }
996 }
997 else
998 {
999 deUint8 pixels[16];
1000 deUint8 expected[4];
1001 readPixels(m_gl, pixels);
1002
1003 expected[0] = expectedUint8(reference);
1004 expected[1] = expectedUint8(reference + increment);
1005 expected[2] = expectedUint8(reference - increment);
1006 expected[3] = expectedAlpha8(reference + 2 * increment);
1007 if (checkWithThreshold8(pixels[0], expected[0]) || checkWithThreshold8(pixels[1], expected[1])
1008 || checkWithThreshold8(pixels[2], expected[2]) || checkWithThreshold8(pixels[3], expected[3]))
1009 {
1010 if (m_debugLog.str().size() > 0) {
1011 log << tcu::TestLog::Message
1012 << "(C)Prior passing tests\n"
1013 << m_debugLog.str()
1014 << tcu::TestLog::EndMessage;
1015 m_debugLog.str("");
1016 }
1017 log << tcu::TestLog::Message
1018 << "Image comparison failed: "
1019 << "reference = " << reference
1020 << ", expected = " << static_cast<deUint32>(expected[0])
1021 << ":" << static_cast<deUint32>(expected[1])
1022 << ":" << static_cast<deUint32>(expected[2])
1023 << ":" << static_cast<deUint32>(expected[3])
1024 << ", result = " << static_cast<deUint32>(pixels[0])
1025 << ":" << static_cast<deUint32>(pixels[1])
1026 << ":" << static_cast<deUint32>(pixels[2])
1027 << ":" << static_cast<deUint32>(pixels[3])
1028 << tcu::TestLog::EndMessage;
1029 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
1030 }
1031 else
1032 {
1033 // Pixel matches expected value
1034 m_debugLog << "Image comparison passed: "
1035 << "reference = " << reference
1036 << ", result = " << static_cast<deUint32>(pixels[0])
1037 << ":" << static_cast<deUint32>(pixels[1])
1038 << ":" << static_cast<deUint32>(pixels[2])
1039 << ":" << static_cast<deUint32>(pixels[3])
1040 << "\n";
1041 }
1042 }
1043 }
1044
doClearTest(EGLSurface surface)1045 void WideColorSurfaceTest::doClearTest (EGLSurface surface)
1046 {
1047 tcu::TestLog& log = m_testCtx.getLog();
1048 const Library& egl = m_eglTestCtx.getLibrary();
1049 const EGLint attribList[] =
1050 {
1051 EGL_CONTEXT_CLIENT_VERSION, 2,
1052 EGL_NONE
1053 };
1054 EGLContext eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList);
1055 EGLU_CHECK_MSG(egl, "eglCreateContext");
1056
1057 egl.makeCurrent(m_eglDisplay, surface, surface, eglContext);
1058 EGLU_CHECK_MSG(egl, "eglMakeCurrent");
1059
1060 {
1061 // put gles2Renderer inside it's own scope so that it's cleaned
1062 // up before we hit the destroyContext
1063 const GLES2Renderer gles2Renderer(m_gl, 128, 128);
1064
1065 std::vector<Iteration>::const_iterator it; // declare an Iterator to a vector of strings
1066 log << tcu::TestLog::Message << "m_iterations.count = " << m_iterations.size() << tcu::TestLog::EndMessage;
1067 for(it = m_iterations.begin() ; it < m_iterations.end(); it++)
1068 {
1069 float reference = it->start;
1070 log << tcu::TestLog::Message << "start = " << it->start
1071 << tcu::TestLog::EndMessage;
1072 log << tcu::TestLog::Message
1073 << "increment = " << it->increment
1074 << tcu::TestLog::EndMessage;
1075 log << tcu::TestLog::Message
1076 << "count = " << it->iterationCount
1077 << tcu::TestLog::EndMessage;
1078 m_debugLog.str("");
1079 for (int iterationCount = 0; iterationCount < it->iterationCount; iterationCount++)
1080 {
1081 const Color clearColor(reference, reference + it->increment, reference - it->increment, reference + 2 * it->increment);
1082
1083 clearColorScreen(m_gl, clearColor);
1084 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Clear to test value");
1085
1086 testPixels(reference, it->increment);
1087
1088 // reset buffer contents so that we know render below did something
1089 const Color clearColor2(1.0f - reference, 1.0f, 1.0f, 1.0f);
1090 clearColorScreen(m_gl, clearColor2);
1091 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Clear to 1.0f - reference value");
1092
1093 const ColoredRect coloredRect (IVec2(0.0f, 0.0f), IVec2(1.0f, 1.0f), clearColor);
1094 gles2Renderer.render(coloredRect);
1095 testPixels(reference, it->increment);
1096
1097 reference += it->increment;
1098 }
1099
1100 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, surface));
1101 }
1102 }
1103
1104 // disconnect surface & context so they can be destroyed when
1105 // this function exits.
1106 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
1107
1108 egl.destroyContext(m_eglDisplay, eglContext);
1109 }
1110
executeTest(void)1111 void WideColorSurfaceTest::executeTest (void)
1112 {
1113 tcu::TestLog& log = m_testCtx.getLog();
1114 const Library& egl = m_eglTestCtx.getLibrary();
1115 const eglu::NativeDisplayFactory& displayFactory = m_eglTestCtx.getNativeDisplayFactory();
1116 eglu::NativeDisplay& nativeDisplay = m_eglTestCtx.getNativeDisplay();
1117 egl.bindAPI(EGL_OPENGL_ES_API);
1118
1119 if (m_surfaceType & EGL_PBUFFER_BIT)
1120 {
1121 log << tcu::TestLog::Message << "Test Pbuffer" << tcu::TestLog::EndMessage;
1122
1123 std::vector<EGLint> attribs;
1124 attribs.push_back(EGL_WIDTH);
1125 attribs.push_back(128);
1126 attribs.push_back(EGL_HEIGHT);
1127 attribs.push_back(128);
1128 if (m_colorSpace != EGL_NONE)
1129 {
1130 attribs.push_back(EGL_GL_COLORSPACE_KHR);
1131 attribs.push_back(m_colorSpace);
1132 }
1133 attribs.push_back(EGL_NONE);
1134 attribs.push_back(EGL_NONE);
1135 const EGLSurface surface = egl.createPbufferSurface(m_eglDisplay, m_eglConfig, attribs.data());
1136 if ((surface == EGL_NO_SURFACE) && (egl.getError() == EGL_BAD_MATCH))
1137 {
1138 TCU_THROW(NotSupportedError, "Colorspace is not supported with this format");
1139 }
1140 TCU_CHECK(surface != EGL_NO_SURFACE);
1141 EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");
1142
1143 doClearTest(surface);
1144
1145 egl.destroySurface(m_eglDisplay, surface);
1146 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1147 }
1148 else if (m_surfaceType & EGL_WINDOW_BIT)
1149 {
1150 log << tcu::TestLog::Message << "Test Window" << tcu::TestLog::EndMessage;
1151
1152 const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(displayFactory, m_testCtx.getCommandLine());
1153
1154 de::UniquePtr<eglu::NativeWindow> window (windowFactory.createWindow(&nativeDisplay, m_eglDisplay, m_eglConfig, DE_NULL, eglu::WindowParams(128, 128, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))));
1155 std::vector<EGLAttrib> attribs;
1156 if (m_colorSpace != EGL_NONE)
1157 {
1158 attribs.push_back(EGL_GL_COLORSPACE_KHR);
1159 attribs.push_back(m_colorSpace);
1160 }
1161 attribs.push_back(EGL_NONE);
1162 attribs.push_back(EGL_NONE);
1163
1164 EGLSurface surface;
1165 try
1166 {
1167 surface = eglu::createWindowSurface(nativeDisplay, *window, m_eglDisplay, m_eglConfig, attribs.data());
1168 }
1169 catch (const eglu::Error& error)
1170 {
1171 if (error.getError() == EGL_BAD_MATCH)
1172 TCU_THROW(NotSupportedError, "createWindowSurface is not supported for this config");
1173
1174 throw;
1175 }
1176 TCU_CHECK(surface != EGL_NO_SURFACE);
1177 EGLU_CHECK_MSG(egl, "eglCreateWindowSurface()");
1178
1179 doClearTest(surface);
1180
1181 egl.destroySurface(m_eglDisplay, surface);
1182 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1183 }
1184 else if (m_surfaceType & EGL_PIXMAP_BIT)
1185 {
1186 log << tcu::TestLog::Message << "Test Pixmap" << tcu::TestLog::EndMessage;
1187
1188 const eglu::NativePixmapFactory& pixmapFactory = eglu::selectNativePixmapFactory(displayFactory, m_testCtx.getCommandLine());
1189
1190 de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory.createPixmap(&nativeDisplay, m_eglDisplay, m_eglConfig, DE_NULL, 128, 128));
1191 const EGLSurface surface = eglu::createPixmapSurface(nativeDisplay, *pixmap, m_eglDisplay, m_eglConfig, DE_NULL);
1192 TCU_CHECK(surface != EGL_NO_SURFACE);
1193 EGLU_CHECK_MSG(egl, "eglCreatePixmapSurface()");
1194
1195 doClearTest(surface);
1196
1197 egl.destroySurface(m_eglDisplay, surface);
1198 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1199 }
1200 else
1201 TCU_FAIL("No valid surface types supported in config");
1202 }
1203
iterate(void)1204 TestCase::IterateResult WideColorSurfaceTest::iterate (void)
1205 {
1206 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1207 executeTest();
1208 return STOP;
1209 }
1210
1211 } // anonymous
1212
WideColorTests(EglTestContext & eglTestCtx)1213 WideColorTests::WideColorTests (EglTestContext& eglTestCtx)
1214 : TestCaseGroup(eglTestCtx, "wide_color", "Wide Color tests")
1215 {
1216 }
1217
init(void)1218 void WideColorTests::init (void)
1219 {
1220 addChild(new WideColorFP16Test(m_eglTestCtx, "fp16", "Verify that FP16 pixel format is present"));
1221 addChild(new WideColor1010102Test(m_eglTestCtx, "1010102", "Check if 1010102 pixel format is present"));
1222
1223 // This is an increment FP16 can do between -1.0 to 1.0
1224 const float fp16Increment1 = deFloatPow(2.0, -11.0);
1225 // This is an increment FP16 can do between 1.0 to 2.0
1226 const float fp16Increment2 = deFloatPow(2.0, -10.0);
1227
1228 const EGLint windowAttribListFP16[] =
1229 {
1230 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1231 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1232 EGL_RED_SIZE, 16,
1233 EGL_GREEN_SIZE, 16,
1234 EGL_BLUE_SIZE, 16,
1235 EGL_ALPHA_SIZE, 16,
1236 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
1237 EGL_NONE, EGL_NONE
1238 };
1239
1240 std::vector<Iteration> fp16Iterations;
1241 // -0.333251953125f ~ -1/3 as seen in FP16
1242 fp16Iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1243 // test crossing 0
1244 fp16Iterations.push_back( Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1245 // test crossing 1.0
1246 fp16Iterations.push_back( Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1247 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_default_colorspace", "FP16 window surface has FP16 pixels in it", windowAttribListFP16, EGL_NONE, fp16Iterations));
1248 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_srgb", "FP16 window surface, explicit sRGB colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SRGB_KHR, fp16Iterations));
1249 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_p3", "FP16 window surface, explicit Display-P3 colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, fp16Iterations));
1250 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_scrgb", "FP16 window surface, explicit scRGB colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SCRGB_EXT, fp16Iterations));
1251 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_scrgb_linear", "FP16 window surface, explicit scRGB linear colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT, fp16Iterations));
1252
1253 const EGLint pbufferAttribListFP16[] =
1254 {
1255 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1256 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1257 EGL_RED_SIZE, 16,
1258 EGL_GREEN_SIZE, 16,
1259 EGL_BLUE_SIZE, 16,
1260 EGL_ALPHA_SIZE, 16,
1261 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
1262 EGL_NONE, EGL_NONE
1263 };
1264 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_default_colorspace", "FP16 pbuffer surface has FP16 pixels in it", pbufferAttribListFP16, EGL_NONE, fp16Iterations));
1265 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_srgb", "FP16 pbuffer surface, explicit sRGB colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SRGB_KHR, fp16Iterations));
1266 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_p3", "FP16 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, fp16Iterations));
1267 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_scrgb", "FP16 pbuffer surface, explicit scRGB colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SCRGB_EXT, fp16Iterations));
1268 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_scrgb_linear", "FP16 pbuffer surface, explicit scRGB linear colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT, fp16Iterations));
1269
1270 const EGLint windowAttribList1010102[] =
1271 {
1272 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1273 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1274 EGL_RED_SIZE, 10,
1275 EGL_GREEN_SIZE, 10,
1276 EGL_BLUE_SIZE, 10,
1277 EGL_ALPHA_SIZE, 2,
1278 EGL_NONE, EGL_NONE
1279 };
1280
1281 std::vector<Iteration> int1010102Iterations;
1282 // -0.333251953125f ~ -1/3 as seen in fp16
1283 // Negative values will be 0 on read with fixed point pixel formats
1284 int1010102Iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1285 // test crossing 0
1286 int1010102Iterations.push_back(Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1287 // test crossing 1.0
1288 // Values > 1.0 will be truncated to 1.0 with fixed point pixel formats
1289 int1010102Iterations.push_back(Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1290 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_default", "1010102 Window surface, default (sRGB) colorspace", windowAttribList1010102, EGL_NONE, int1010102Iterations));
1291 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_srgb", "1010102 Window surface, explicit sRGB colorspace", windowAttribList1010102, EGL_GL_COLORSPACE_SRGB_KHR, int1010102Iterations));
1292 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_p3", "1010102 Window surface, explicit Display-P3 colorspace", windowAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, int1010102Iterations));
1293
1294 const EGLint pbufferAttribList1010102[] =
1295 {
1296 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1297 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1298 EGL_RED_SIZE, 10,
1299 EGL_GREEN_SIZE, 10,
1300 EGL_BLUE_SIZE, 10,
1301 EGL_ALPHA_SIZE, 2,
1302 EGL_NONE, EGL_NONE
1303 };
1304 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_default", "1010102 pbuffer surface, default (sRGB) colorspace", pbufferAttribList1010102, EGL_NONE, int1010102Iterations));
1305 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_srgb", "1010102 pbuffer surface, explicit sRGB colorspace", pbufferAttribList1010102, EGL_GL_COLORSPACE_SRGB_KHR, int1010102Iterations));
1306 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_p3", "1010102 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, int1010102Iterations));
1307
1308 const EGLint windowAttribList8888[] =
1309 {
1310 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1311 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1312 EGL_RED_SIZE, 8,
1313 EGL_GREEN_SIZE, 8,
1314 EGL_BLUE_SIZE, 8,
1315 EGL_ALPHA_SIZE, 8,
1316 EGL_NONE, EGL_NONE
1317 };
1318
1319 std::vector<Iteration> int8888Iterations;
1320 // -0.333251953125f ~ -1/3 as seen in fp16
1321 // Negative values will be 0 on read with fixed point pixel formats
1322 int8888Iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1323 // test crossing 0
1324 int8888Iterations.push_back(Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1325 // test crossing 1.0
1326 // Values > 1.0 will be truncated to 1.0 with fixed point pixel formats
1327 int8888Iterations.push_back(Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1328 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_default", "8888 window surface, default (sRGB) colorspace", windowAttribList8888, EGL_NONE, int8888Iterations));
1329 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_srgb", "8888 window surface, explicit sRGB colorspace", windowAttribList8888, EGL_GL_COLORSPACE_SRGB_KHR, int8888Iterations));
1330 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_p3", "8888 window surface, explicit Display-P3 colorspace", windowAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, int8888Iterations));
1331
1332 const EGLint pbufferAttribList8888[] =
1333 {
1334 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1335 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1336 EGL_RED_SIZE, 8,
1337 EGL_GREEN_SIZE, 8,
1338 EGL_BLUE_SIZE, 8,
1339 EGL_ALPHA_SIZE, 8,
1340 EGL_NONE, EGL_NONE
1341 };
1342 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_default", "8888 pbuffer surface, default (sRGB) colorspace", pbufferAttribList8888, EGL_NONE, int8888Iterations));
1343 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_srgb", "8888 pbuffer surface, explicit sRGB colorspace", pbufferAttribList8888, EGL_GL_COLORSPACE_SRGB_KHR, int8888Iterations));
1344 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_p3", "8888 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, int8888Iterations));
1345 }
1346
createWideColorTests(EglTestContext & eglTestCtx)1347 TestCaseGroup* createWideColorTests (EglTestContext& eglTestCtx)
1348 {
1349 return new WideColorTests(eglTestCtx);
1350 }
1351
1352 } // egl
1353 } // deqp
1354