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 "gluContextInfo.hpp"
42 #include "gluShaderProgram.hpp"
43
44 #include "glw.h"
45 #include "glwDefs.hpp"
46 #include "glwEnums.hpp"
47 #include "glwFunctions.hpp"
48
49 #include "deMath.h"
50 #include "deRandom.hpp"
51 #include "deString.h"
52 #include "deStringUtil.hpp"
53
54 #include <string>
55 #include <vector>
56 #include <sstream>
57
58 using std::string;
59 using std::vector;
60 using glw::GLubyte;
61 using glw::GLfloat;
62 using tcu::IVec2;
63
64 using namespace eglw;
65
66 namespace deqp
67 {
68 namespace egl
69 {
70 namespace
71 {
72
73 typedef tcu::Vec4 Color;
74
75 class GLES2Renderer;
76
77 class ReferenceRenderer;
78
79 class WideColorTests : public TestCaseGroup
80 {
81 public:
82 WideColorTests (EglTestContext& eglTestCtx);
83 void init (void);
84
85 private:
86 WideColorTests (const WideColorTests&);
87 WideColorTests& operator= (const WideColorTests&);
88 };
89
90 class WideColorTest : public TestCase
91 {
92 public:
93 enum DrawType
94 {
95 DRAWTYPE_GLES2_CLEAR,
96 DRAWTYPE_GLES2_RENDER
97 };
98
99 WideColorTest (EglTestContext& eglTestCtx, const char* name, const char* description);
100 ~WideColorTest (void);
101
102 void init (void);
103 void deinit (void);
104 void checkPixelFloatSupport (void);
105 void checkColorSpaceSupport (void);
106 void checkDisplayP3Support (void);
107 void checkDisplayP3PassthroughSupport (void);
108 void check1010102Support (void);
109 void checkFP16Support (void);
110 void checkSCRGBSupport (void);
111 void checkSCRGBLinearSupport (void);
112 void checkbt2020linear (void);
113 void checkbt2020pq (void);
114 void checkSMPTE2086 (void);
115 void checkCTA861_3 (void);
116
117 protected:
118 void initEGLSurface (EGLConfig config);
119 void initEGLContext (EGLConfig config);
120
121 EGLDisplay m_eglDisplay;
122 glw::Functions m_gl;
123 };
124
125 struct ColoredRect
126 {
127 public:
128 ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_);
129 IVec2 bottomLeft;
130 IVec2 topRight;
131 Color color;
132 };
133
ColoredRect(const IVec2 & bottomLeft_,const IVec2 & topRight_,const Color & color_)134 ColoredRect::ColoredRect (const IVec2& bottomLeft_, const IVec2& topRight_, const Color& color_)
135 : bottomLeft (bottomLeft_)
136 , topRight (topRight_)
137 , color (color_)
138 {
139 }
140
clearColorScreen(const glw::Functions & gl,const Color & clearColor)141 void clearColorScreen (const glw::Functions& gl, const Color& clearColor)
142 {
143 gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
144 gl.clear(GL_COLOR_BUFFER_BIT);
145 }
146
windowToDeviceCoordinates(int x,int length)147 float windowToDeviceCoordinates (int x, int length)
148 {
149 return (2.0f * float(x) / float(length)) - 1.0f;
150 }
151
152 class GLES2Renderer
153 {
154 public:
155 GLES2Renderer (const glw::Functions& gl, int width, int height);
156 ~GLES2Renderer (void);
157 void render (const ColoredRect& coloredRect) const;
158
159 private:
160 GLES2Renderer (const GLES2Renderer&);
161 GLES2Renderer& operator= (const GLES2Renderer&);
162
163 const glw::Functions& m_gl;
164 glu::ShaderProgram m_glProgram;
165 glw::GLuint m_coordLoc;
166 glw::GLuint m_colorLoc;
167 glw::GLuint m_bufWidth;
168 glw::GLuint m_bufHeight;
169 };
170
171 // generate sources for vertex and fragment buffer
getSources(void)172 glu::ProgramSources getSources (void)
173 {
174 const char* const vertexShaderSource =
175 "attribute mediump vec2 a_pos;\n"
176 "attribute mediump vec4 a_color;\n"
177 "varying mediump vec4 v_color;\n"
178 "void main(void)\n"
179 "{\n"
180 "\tv_color = a_color;\n"
181 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
182 "}";
183
184 const char* const fragmentShaderSource =
185 "varying mediump vec4 v_color;\n"
186 "void main(void)\n"
187 "{\n"
188 "\tgl_FragColor = v_color;\n"
189 "}";
190
191 return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
192 }
193
GLES2Renderer(const glw::Functions & gl,int width,int height)194 GLES2Renderer::GLES2Renderer (const glw::Functions& gl, int width, int height)
195 : m_gl (gl)
196 , m_glProgram (gl, getSources())
197 , m_coordLoc ((glw::GLuint)-1)
198 , m_colorLoc ((glw::GLuint)-1)
199 , m_bufWidth (width)
200 , m_bufHeight (height)
201 {
202 m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
203 m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
204 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
205 }
206
~GLES2Renderer(void)207 GLES2Renderer::~GLES2Renderer (void)
208 {
209 }
210
render(const struct ColoredRect & coloredRect) const211 void GLES2Renderer::render (const struct ColoredRect &coloredRect) const
212 {
213 const float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), m_bufWidth);
214 const float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), m_bufHeight);
215 const float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), m_bufWidth);
216 const float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), m_bufHeight);
217
218 const glw::GLfloat coords[] =
219 {
220 x1, y1, 0.0f, 1.0f,
221 x1, y2, 0.0f, 1.0f,
222 x2, y2, 0.0f, 1.0f,
223
224 x2, y2, 0.0f, 1.0f,
225 x2, y1, 0.0f, 1.0f,
226 x1, y1, 0.0f, 1.0f
227 };
228
229 const glw::GLfloat colors[] =
230 {
231 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
232 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
233 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
234
235 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
236 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
237 coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), coloredRect.color.w(),
238 };
239
240 m_gl.useProgram(m_glProgram.getProgram());
241 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
242
243 m_gl.enableVertexAttribArray(m_coordLoc);
244 m_gl.enableVertexAttribArray(m_colorLoc);
245 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
246
247 m_gl.vertexAttribPointer(m_coordLoc, 4, GL_FLOAT, GL_FALSE, 0, coords);
248 m_gl.vertexAttribPointer(m_colorLoc, 4, GL_FLOAT, GL_TRUE, 0, colors);
249 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
250
251 m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords)/4);
252 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");
253
254 m_gl.disableVertexAttribArray(m_coordLoc);
255 m_gl.disableVertexAttribArray(m_colorLoc);
256 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
257
258 m_gl.useProgram(0);
259 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
260 }
261
262 class ReferenceRenderer
263 {
264 public:
265 ReferenceRenderer (void);
266 private:
267 ReferenceRenderer (const ReferenceRenderer&);
268 ReferenceRenderer& operator= (const ReferenceRenderer&);
269 };
270
WideColorTest(EglTestContext & eglTestCtx,const char * name,const char * description)271 WideColorTest::WideColorTest (EglTestContext& eglTestCtx, const char* name, const char* description)
272 : TestCase (eglTestCtx, name, description)
273 , m_eglDisplay (EGL_NO_DISPLAY)
274 {
275 }
276
~WideColorTest(void)277 WideColorTest::~WideColorTest (void)
278 {
279 deinit();
280 }
281
init(void)282 void WideColorTest::init (void)
283 {
284 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
285
286 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
287 }
288
checkPixelFloatSupport(void)289 void WideColorTest::checkPixelFloatSupport (void)
290 {
291 const Library& egl = m_eglTestCtx.getLibrary();
292
293 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_pixel_format_float"))
294 TCU_THROW(NotSupportedError, "EGL_EXT_pixel_format_float is not supported");
295 }
296
checkColorSpaceSupport(void)297 void WideColorTest::checkColorSpaceSupport (void)
298 {
299 const Library& egl = m_eglTestCtx.getLibrary();
300
301 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_gl_colorspace"))
302 TCU_THROW(NotSupportedError, "EGL_KHR_gl_colorspace is not supported");
303 }
304
checkDisplayP3Support(void)305 void WideColorTest::checkDisplayP3Support (void)
306 {
307 const Library& egl = m_eglTestCtx.getLibrary();
308
309 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_display_p3"))
310 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_display_p3 is not supported");
311 }
312
checkDisplayP3PassthroughSupport(void)313 void WideColorTest::checkDisplayP3PassthroughSupport (void)
314 {
315 const Library& egl = m_eglTestCtx.getLibrary();
316
317 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_display_p3_passthrough"))
318 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_display_p3_passthrough is not supported");
319 }
320
checkSCRGBSupport(void)321 void WideColorTest::checkSCRGBSupport (void)
322 {
323 const Library& egl = m_eglTestCtx.getLibrary();
324
325 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_scrgb"))
326 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_scrgb is not supported");
327 }
328
checkSCRGBLinearSupport(void)329 void WideColorTest::checkSCRGBLinearSupport (void)
330 {
331 const Library& egl = m_eglTestCtx.getLibrary();
332
333 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_scrgb_linear"))
334 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_scrgb_linear is not supported");
335 }
336
checkbt2020linear(void)337 void WideColorTest::checkbt2020linear (void)
338 {
339 const Library& egl = m_eglTestCtx.getLibrary();
340
341 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_bt2020_linear"))
342 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_bt2020_linear is not supported");
343 }
344
checkbt2020pq(void)345 void WideColorTest::checkbt2020pq (void)
346 {
347 const Library& egl = m_eglTestCtx.getLibrary();
348
349 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_gl_colorspace_bt2020_pq"))
350 TCU_THROW(NotSupportedError, "EGL_EXT_gl_colorspace_bt2020_pq is not supported");
351 }
352
checkSMPTE2086(void)353 void WideColorTest::checkSMPTE2086 (void)
354 {
355 const Library& egl = m_eglTestCtx.getLibrary();
356
357 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_surface_SMPTE2086_metadata"))
358 TCU_THROW(NotSupportedError, "EGL_EXT_surface_SMPTE2086_metadata is not supported");
359 }
360
checkCTA861_3(void)361 void WideColorTest::checkCTA861_3 (void)
362 {
363 const Library& egl = m_eglTestCtx.getLibrary();
364
365 if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_surface_CTA861_3_metadata"))
366 TCU_THROW(NotSupportedError, "EGL_EXT_surface_CTA861_3_metadata is not supported");
367 }
368
check1010102Support(void)369 void WideColorTest::check1010102Support (void)
370 {
371 const Library& egl = m_eglTestCtx.getLibrary();
372 tcu::TestLog& log = m_testCtx.getLog();
373
374 const EGLint attribList[] =
375 {
376 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
377 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
378 EGL_RED_SIZE, 10,
379 EGL_GREEN_SIZE, 10,
380 EGL_BLUE_SIZE, 10,
381 EGL_ALPHA_SIZE, 2,
382 EGL_NONE, EGL_NONE
383 };
384 EGLint numConfigs = 0;
385 EGLConfig config;
386
387 // Query from EGL implementation
388 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], DE_NULL, 0, &numConfigs));
389
390 if (numConfigs <= 0)
391 {
392 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
393 TCU_THROW(NotSupportedError, "10:10:10:2 pixel format is not supported");
394 }
395
396 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
397
398 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], &config, 1, &numConfigs));
399 if (numConfigs > 1)
400 {
401 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
402 TCU_FAIL("Too many configs returned");
403 }
404
405 EGLint components[4];
406
407 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_RED_SIZE, &components[0]));
408 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_GREEN_SIZE, &components[1]));
409 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_BLUE_SIZE, &components[2]));
410 EGLU_CHECK_CALL(egl, getConfigAttrib(m_eglDisplay, config, EGL_ALPHA_SIZE, &components[3]));
411
412 TCU_CHECK_MSG(components[0] == 10, "Missing 10bit deep red channel");
413 TCU_CHECK_MSG(components[1] == 10, "Missing 10bit deep green channel");
414 TCU_CHECK_MSG(components[2] == 10, "Missing 10bit deep blue channel");
415 TCU_CHECK_MSG(components[3] == 2, "Missing 2bit deep alpha channel");
416 }
417
checkFP16Support(void)418 void WideColorTest::checkFP16Support (void)
419 {
420 const Library& egl = m_eglTestCtx.getLibrary();
421 tcu::TestLog& log = m_testCtx.getLog();
422 EGLint numConfigs = 0;
423 EGLConfig config;
424
425 const EGLint attribList[] =
426 {
427 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
428 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
429 EGL_RED_SIZE, 16,
430 EGL_GREEN_SIZE, 16,
431 EGL_BLUE_SIZE, 16,
432 EGL_ALPHA_SIZE, 16,
433 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
434 EGL_NONE, EGL_NONE
435 };
436
437 // Query from EGL implementation
438 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &attribList[0], DE_NULL, 0, &numConfigs));
439
440 if (numConfigs <= 0)
441 {
442 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
443 TCU_THROW(NotSupportedError, "16:16:16:16 pixel format is not supported");
444 }
445
446 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
447
448 EGLBoolean success = egl.chooseConfig(m_eglDisplay, &attribList[0], &config, 1, &numConfigs);
449 if (success != EGL_TRUE)
450 {
451 log << tcu::TestLog::Message << "Fail, eglChooseConfig returned an error." << tcu::TestLog::EndMessage;
452 TCU_FAIL("eglChooseConfig failed");
453 }
454 if (numConfigs > 1)
455 {
456 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
457 TCU_FAIL("Too many configs returned");
458 }
459
460 EGLint components[4];
461
462 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_RED_SIZE, &components[0]);
463 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
464 EGLU_CHECK(egl);
465 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_GREEN_SIZE, &components[1]);
466 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
467 EGLU_CHECK(egl);
468 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_BLUE_SIZE, &components[2]);
469 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
470 EGLU_CHECK(egl);
471 success = egl.getConfigAttrib(m_eglDisplay, config, EGL_ALPHA_SIZE, &components[3]);
472 TCU_CHECK_MSG(success == EGL_TRUE, "eglGetConfigAttrib failed");
473 EGLU_CHECK(egl);
474
475 TCU_CHECK_MSG(components[0] == 16, "Missing 16bit deep red channel");
476 TCU_CHECK_MSG(components[1] == 16, "Missing 16bit deep green channel");
477 TCU_CHECK_MSG(components[2] == 16, "Missing 16bit deep blue channel");
478 TCU_CHECK_MSG(components[3] == 16, "Missing 16bit deep alpha channel");
479 }
480
deinit(void)481 void WideColorTest::deinit (void)
482 {
483 const Library& egl = m_eglTestCtx.getLibrary();
484
485 if (m_eglDisplay != EGL_NO_DISPLAY)
486 {
487 egl.terminate(m_eglDisplay);
488 m_eglDisplay = EGL_NO_DISPLAY;
489 }
490 }
491
492 class WideColorFP16Test : public WideColorTest
493 {
494 public:
495 WideColorFP16Test (EglTestContext& eglTestCtx, const char* name, const char* description);
496
497 void init (void);
498 void executeTest (void);
499 IterateResult iterate (void);
500 };
501
WideColorFP16Test(EglTestContext & eglTestCtx,const char * name,const char * description)502 WideColorFP16Test::WideColorFP16Test (EglTestContext& eglTestCtx,
503 const char* name,
504 const char* description)
505 : WideColorTest(eglTestCtx, name, description)
506 {
507 }
508
509
executeTest(void)510 void WideColorFP16Test::executeTest (void)
511 {
512 checkPixelFloatSupport();
513 checkFP16Support();
514 }
515
iterate(void)516 TestCase::IterateResult WideColorFP16Test::iterate (void)
517 {
518 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
519 executeTest();
520 return STOP;
521 }
522
init(void)523 void WideColorFP16Test::init (void)
524 {
525 WideColorTest::init();
526 }
527
528 class WideColor1010102Test : public WideColorTest
529 {
530 public:
531 WideColor1010102Test (EglTestContext& eglTestCtx,
532 const char* name,
533 const char* description);
534
535 void executeTest (void);
536 IterateResult iterate (void);
537 };
538
WideColor1010102Test(EglTestContext & eglTestCtx,const char * name,const char * description)539 WideColor1010102Test::WideColor1010102Test (EglTestContext& eglTestCtx, const char* name, const char* description)
540 : WideColorTest(eglTestCtx, name, description)
541 {
542 }
543
executeTest(void)544 void WideColor1010102Test::executeTest (void)
545 {
546 check1010102Support();
547 }
548
iterate(void)549 TestCase::IterateResult WideColor1010102Test::iterate (void)
550 {
551 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
552 executeTest();
553 return STOP;
554 }
555
556 struct Iteration
557 {
558 float start;
559 float increment;
560 int iterationCount;
Iterationdeqp::egl::__anon49bc5d6f0111::Iteration561 Iteration(float s, float i, int c)
562 : start(s), increment(i), iterationCount(c) {}
563 };
564
565 class WideColorSurfaceTest : public WideColorTest
566 {
567 public:
568 WideColorSurfaceTest (EglTestContext& eglTestCtx,
569 const char* name,
570 const char* description,
571 const EGLint* attribList,
572 EGLint colorSpace,
573 const std::vector<Iteration>& iterations);
574
575 void init (void);
576 void executeTest (void);
577 IterateResult iterate (void);
578 void addTestAttributes (const EGLint* attributes);
579
580 protected:
581 void readPixels (const glw::Functions& gl, float* dataPtr);
582 void readPixels (const glw::Functions& gl, deUint32* dataPtr);
583 void readPixels (const glw::Functions& gl, deUint8* dataPtr);
584 deUint32 expectedUint10 (float reference);
585 deUint32 expectedUint2 (float reference);
586 deUint8 expectedUint8 (float reference);
587 deUint8 expectedAlpha8 (float reference);
588 bool checkWithThreshold8 (deUint8 value, deUint8 reference, deUint8 threshold = 1);
589 bool checkWithThreshold10 (deUint32 value, deUint32 reference, deUint32 threshold = 1);
590 bool checkWithThresholdFloat (float value, float reference, float threshold);
591 void doClearTest (EGLSurface surface);
592 void testPixels (float reference, float increment);
593 void testFramebufferColorEncoding ();
594 void writeEglConfig (EGLConfig config);
595
596 private:
597 std::vector<EGLint> m_attribList;
598 std::vector<EGLint> m_testAttribList;
599 EGLConfig m_eglConfig;
600 EGLint m_surfaceType;
601 EGLint m_componentType;
602 EGLint m_requestedRedSize;
603 EGLint m_redSize;
604 EGLint m_alphaSize;
605 EGLint m_colorSpace;
606 const std::vector<struct Iteration> m_iterations;
607 std::stringstream m_debugLog;
608 };
609
WideColorSurfaceTest(EglTestContext & eglTestCtx,const char * name,const char * description,const EGLint * attribList,EGLint colorSpace,const std::vector<struct Iteration> & iterations)610 WideColorSurfaceTest::WideColorSurfaceTest (EglTestContext& eglTestCtx, const char* name, const char* description, const EGLint* attribList, EGLint colorSpace, const std::vector<struct Iteration>& iterations)
611 : WideColorTest (eglTestCtx, name, description)
612 , m_surfaceType (0)
613 , m_componentType (EGL_COLOR_COMPONENT_TYPE_FIXED_EXT)
614 , m_requestedRedSize (0)
615 , m_redSize (0)
616 , m_alphaSize (0)
617 , m_colorSpace (colorSpace)
618 , m_iterations (iterations)
619 {
620 deUint32 idx = 0;
621 while (attribList[idx] != EGL_NONE)
622 {
623 if (attribList[idx] == EGL_COLOR_COMPONENT_TYPE_EXT)
624 {
625 m_componentType = attribList[idx + 1];
626 }
627 else if (attribList[idx] == EGL_SURFACE_TYPE)
628 {
629 m_surfaceType = attribList[idx+1];
630 }
631 else if (attribList[idx] == EGL_RED_SIZE)
632 {
633 m_requestedRedSize = attribList[idx + 1];
634 }
635 m_attribList.push_back(attribList[idx++]);
636 m_attribList.push_back(attribList[idx++]);
637 }
638 m_attribList.push_back(EGL_NONE);
639 }
640
addTestAttributes(const EGLint * attributes)641 void WideColorSurfaceTest::addTestAttributes(const EGLint *attributes)
642 {
643 deUint32 idx = 0;
644 if (attributes == DE_NULL) return;
645
646 while (attributes[idx] != EGL_NONE)
647 {
648 m_testAttribList.push_back(attributes[idx++]);
649 m_testAttribList.push_back(attributes[idx++]);
650 }
651 }
652
init(void)653 void WideColorSurfaceTest::init (void)
654 {
655 const Library& egl = m_eglTestCtx.getLibrary();
656 tcu::TestLog& log = m_testCtx.getLog();
657
658 WideColorTest::init();
659
660 // Only check for pixel format required for this specific run
661 // If not available, check will abort test with "NotSupported"
662 switch (m_requestedRedSize)
663 {
664 case 10:
665 check1010102Support();
666 break;
667 case 16:
668 checkPixelFloatSupport();
669 checkFP16Support();
670 break;
671 }
672
673 if (m_colorSpace != EGL_NONE && !eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_gl_colorspace"))
674 TCU_THROW(NotSupportedError, "EGL_KHR_gl_colorspace is not supported");
675
676 switch (m_colorSpace) {
677 case EGL_GL_COLORSPACE_SRGB_KHR:
678 checkColorSpaceSupport();
679 break;
680 case EGL_GL_COLORSPACE_DISPLAY_P3_EXT:
681 checkDisplayP3Support();
682 break;
683 case EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT:
684 checkDisplayP3PassthroughSupport();
685 break;
686 case EGL_GL_COLORSPACE_SCRGB_EXT:
687 checkSCRGBSupport();
688 break;
689 case EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT:
690 checkSCRGBLinearSupport();
691 break;
692 case EGL_GL_COLORSPACE_BT2020_LINEAR_EXT:
693 checkbt2020linear();
694 break;
695 case EGL_GL_COLORSPACE_BT2020_PQ_EXT:
696 checkbt2020pq();
697 break;
698 default:
699 break;
700 }
701
702 EGLint numConfigs = 0;
703
704 // Query from EGL implementation
705 EGLU_CHECK_CALL(egl, chooseConfig(m_eglDisplay, &m_attribList[0], DE_NULL, 0, &numConfigs));
706
707 if (numConfigs <= 0)
708 {
709 log << tcu::TestLog::Message << "No configs returned." << tcu::TestLog::EndMessage;
710 TCU_THROW(NotSupportedError, "No configs available with the requested attributes");
711 }
712
713 log << tcu::TestLog::Message << numConfigs << " configs returned" << tcu::TestLog::EndMessage;
714
715 EGLBoolean success = egl.chooseConfig(m_eglDisplay, &m_attribList[0], &m_eglConfig, 1, &numConfigs);
716 if (success != EGL_TRUE)
717 {
718 log << tcu::TestLog::Message << "Fail, eglChooseConfig returned an error." << tcu::TestLog::EndMessage;
719 TCU_FAIL("eglChooseConfig failed");
720 }
721 if (numConfigs > 1)
722 {
723 log << tcu::TestLog::Message << "Fail, more configs returned than requested." << tcu::TestLog::EndMessage;
724 TCU_FAIL("Too many configs returned");
725 }
726
727 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
728
729 m_redSize = eglu::getConfigAttribInt(egl, m_eglDisplay, m_eglConfig, EGL_RED_SIZE);
730 m_alphaSize = eglu::getConfigAttribInt(egl, m_eglDisplay, m_eglConfig, EGL_ALPHA_SIZE);
731 writeEglConfig(m_eglConfig);
732 }
733
readPixels(const glw::Functions & gl,float * dataPtr)734 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, float* dataPtr)
735 {
736 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, dataPtr);
737 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with floats");
738 }
739
readPixels(const glw::Functions & gl,deUint32 * dataPtr)740 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, deUint32 *dataPtr)
741 {
742 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, dataPtr);
743 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with RGBA_1010102 (32bits)");
744 }
745
readPixels(const glw::Functions & gl,deUint8 * dataPtr)746 void WideColorSurfaceTest::readPixels (const glw::Functions& gl, deUint8 *dataPtr)
747 {
748 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, dataPtr);
749 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glReadPixels with RGBA_8888 (8 bit components)");
750 }
751
writeEglConfig(EGLConfig config)752 void WideColorSurfaceTest::writeEglConfig (EGLConfig config)
753 {
754 const Library& egl = m_eglTestCtx.getLibrary();
755 tcu::TestLog& log = m_testCtx.getLog();
756 qpEglConfigInfo info;
757 EGLint val = 0;
758
759 info.bufferSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BUFFER_SIZE);
760
761 info.redSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_RED_SIZE);
762
763 info.greenSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_GREEN_SIZE);
764
765 info.blueSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BLUE_SIZE);
766
767 info.luminanceSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_LUMINANCE_SIZE);
768
769 info.alphaSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_ALPHA_SIZE);
770
771 info.alphaMaskSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_ALPHA_MASK_SIZE);
772
773 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BIND_TO_TEXTURE_RGB);
774 info.bindToTextureRGB = val == EGL_TRUE ? true : false;
775
776 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_BIND_TO_TEXTURE_RGBA);
777 info.bindToTextureRGBA = val == EGL_TRUE ? true : false;
778
779 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_COLOR_BUFFER_TYPE);
780 std::string colorBufferType = de::toString(eglu::getColorBufferTypeStr(val));
781 info.colorBufferType = colorBufferType.c_str();
782
783 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFIG_CAVEAT);
784 std::string caveat = de::toString(eglu::getConfigCaveatStr(val));
785 info.configCaveat = caveat.c_str();
786
787 info.configID = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFIG_ID);
788
789 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_CONFORMANT);
790 std::string conformant = de::toString(eglu::getAPIBitsStr(val));
791 info.conformant = conformant.c_str();
792
793 info.depthSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_DEPTH_SIZE);
794
795 info.level = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_LEVEL);
796
797 info.maxPBufferWidth = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_WIDTH);
798
799 info.maxPBufferHeight = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_HEIGHT);
800
801 info.maxPBufferPixels = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_PBUFFER_PIXELS);
802
803 info.maxSwapInterval = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MAX_SWAP_INTERVAL);
804
805 info.minSwapInterval = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_MIN_SWAP_INTERVAL);
806
807 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_NATIVE_RENDERABLE);
808 info.nativeRenderable = val == EGL_TRUE ? true : false;
809
810 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_RENDERABLE_TYPE);
811 std::string renderableTypes = de::toString(eglu::getAPIBitsStr(val));
812 info.renderableType = renderableTypes.c_str();
813
814 info.sampleBuffers = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SAMPLE_BUFFERS);
815
816 info.samples = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SAMPLES);
817
818 info.stencilSize = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_STENCIL_SIZE);
819
820 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_SURFACE_TYPE);
821 std::string surfaceTypes = de::toString(eglu::getSurfaceBitsStr(val));
822 info.surfaceTypes = surfaceTypes.c_str();
823
824 val = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_TYPE);
825 std::string transparentType = de::toString(eglu::getTransparentTypeStr(val));
826 info.transparentType = transparentType.c_str();
827
828 info.transparentRedValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_RED_VALUE);
829
830 info.transparentGreenValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_GREEN_VALUE);
831
832 info.transparentBlueValue = eglu::getConfigAttribInt(egl, m_eglDisplay, config, EGL_TRANSPARENT_BLUE_VALUE);
833
834 log.writeEglConfig(&info);
835 }
836
expectedUint10(float reference)837 deUint32 WideColorSurfaceTest::expectedUint10 (float reference)
838 {
839 deUint32 expected;
840
841 if (reference < 0.0)
842 {
843 expected = 0;
844 }
845 else if (reference > 1.0)
846 {
847 expected = 1023;
848 }
849 else
850 {
851 expected = static_cast<deUint32>(deRound(reference * 1023.0));
852 }
853
854 return expected;
855 }
856
expectedUint2(float reference)857 deUint32 WideColorSurfaceTest::expectedUint2 (float reference)
858 {
859 deUint32 expected;
860
861 if (reference < 0.0)
862 {
863 expected = 0;
864 }
865 else if (reference > 1.0)
866 {
867 expected = 3;
868 }
869 else
870 {
871 expected = static_cast<deUint32>(deRound(reference * 3.0));
872 }
873
874 return expected;
875 }
876
expectedUint8(float reference)877 deUint8 WideColorSurfaceTest::expectedUint8 (float reference)
878 {
879 deUint8 expected;
880 if (reference < 0.0)
881 {
882 expected = 0;
883 }
884 else if (reference >= 1.0)
885 {
886 expected = 255;
887 }
888 else
889 {
890 // Apply sRGB transfer function when colorspace is sRGB or Display P3 and
891 // pixel component size is 8 bits (which is why we are here in expectedUint8).
892 if (m_colorSpace == EGL_GL_COLORSPACE_SRGB_KHR ||
893 m_colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT)
894 {
895 float srgbReference;
896
897 if (reference <= 0.0031308)
898 {
899 srgbReference = 12.92f * reference;
900 }
901 else
902 {
903 float powRef = deFloatPow(reference, (1.0f/2.4f));
904 srgbReference = (1.055f * powRef) - 0.055f;
905 }
906 expected = static_cast<deUint8>(deRound(srgbReference * 255.0));
907 }
908 else
909 {
910 expected = static_cast<deUint8>(deRound(reference * 255.0));
911 }
912 }
913 return expected;
914 }
915
expectedAlpha8(float reference)916 deUint8 WideColorSurfaceTest::expectedAlpha8 (float reference)
917 {
918 deUint8 expected;
919 if (m_alphaSize == 0)
920 {
921 // Surfaces without alpha are read back as opaque.
922 expected = 255;
923 }
924 else if (reference < 0.0)
925 {
926 expected = 0;
927 }
928 else if (reference >= 1.0)
929 {
930 expected = 255;
931 }
932 else
933 {
934 // The sRGB transfer function is not applied to alpha
935 expected = static_cast<deUint8>(deRound(reference * 255.0));
936 }
937 return expected;
938 }
939
940 // Return true for value out of range (fail)
checkWithThreshold8(deUint8 value,deUint8 reference,deUint8 threshold)941 bool WideColorSurfaceTest::checkWithThreshold8(deUint8 value, deUint8 reference, deUint8 threshold)
942 {
943 const deUint8 low = reference >= threshold ? static_cast<deUint8>(reference - threshold) : 0;
944 const deUint8 high = reference <= (255 - threshold) ? static_cast<deUint8>(reference + threshold) : 255;
945 return !((value >= low) && (value <= high));
946 }
947
checkWithThreshold10(deUint32 value,deUint32 reference,deUint32 threshold)948 bool WideColorSurfaceTest::checkWithThreshold10(deUint32 value, deUint32 reference, deUint32 threshold)
949 {
950 const deUint32 low = reference >= threshold ? reference - threshold : 0;
951 const deUint32 high = reference <= (1023 - threshold) ? reference + threshold : 1023;
952 return !((value >= low) && (value <= high));
953 }
954
checkWithThresholdFloat(float value,float reference,float threshold)955 bool WideColorSurfaceTest::checkWithThresholdFloat(float value, float reference, float threshold)
956 {
957 const float low = reference - threshold;
958 const float high = reference + threshold;
959 return !((value >= low) && (value <= high));
960 }
961
testPixels(float reference,float increment)962 void WideColorSurfaceTest::testPixels (float reference, float increment)
963 {
964 tcu::TestLog& log = m_testCtx.getLog();
965
966 if (m_componentType == EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT)
967 {
968 float pixels[16];
969 const float expected[4] =
970 {
971 reference,
972 reference + increment,
973 reference - increment,
974 reference + 2 * increment
975 };
976 readPixels(m_gl, pixels);
977
978 if (checkWithThresholdFloat(pixels[0], expected[0], increment) ||
979 checkWithThresholdFloat(pixels[1], expected[1], increment) ||
980 checkWithThresholdFloat(pixels[2], expected[2], increment) ||
981 checkWithThresholdFloat(pixels[3], expected[3], increment))
982 {
983 if (m_debugLog.str().size() > 0)
984 {
985 log << tcu::TestLog::Message
986 << "Prior passing tests\n"
987 << m_debugLog.str()
988 << tcu::TestLog::EndMessage;
989 m_debugLog.str("");
990 }
991 log << tcu::TestLog::Message
992 << "Image comparison failed: "
993 << "reference = " << reference
994 << ", expected = " << expected[0]
995 << ":" << expected[1]
996 << ":" << expected[2]
997 << ":" << expected[3]
998 << ", result = " << pixels[0]
999 << ":" << pixels[1]
1000 << ":" << pixels[2]
1001 << ":" << pixels[3]
1002 << tcu::TestLog::EndMessage;
1003 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
1004 }
1005 else
1006 {
1007 // Pixel matches expected value
1008 m_debugLog << "Image comparison passed: "
1009 << "reference = " << reference
1010 << ", result = " << pixels[0]
1011 << ":" << pixels[1]
1012 << ":" << pixels[2]
1013 << ":" << pixels[3]
1014 << "\n";
1015 }
1016 }
1017 else if (m_redSize > 8)
1018 {
1019 deUint32 buffer[16];
1020 readPixels(m_gl, buffer);
1021 deUint32 pixels[4];
1022 deUint32 expected[4];
1023
1024 pixels[0] = buffer[0] & 0x3ff;
1025 pixels[1] = (buffer[0] >> 10) & 0x3ff;
1026 pixels[2] = (buffer[0] >> 20) & 0x3ff;
1027 pixels[3] = (buffer[0] >> 30) & 0x3;
1028
1029 expected[0] = expectedUint10(reference);
1030 expected[1] = expectedUint10(reference + increment);
1031 expected[2] = expectedUint10(reference - increment);
1032 expected[3] = expectedUint2(reference + 2 * increment);
1033 if (checkWithThreshold10(pixels[0], expected[0]) || checkWithThreshold10(pixels[1], expected[1])
1034 || checkWithThreshold10(pixels[2], expected[2]) || checkWithThreshold10(pixels[3], expected[3]))
1035 {
1036 if (m_debugLog.str().size() > 0) {
1037 log << tcu::TestLog::Message
1038 << "Prior passing tests\n"
1039 << m_debugLog.str()
1040 << tcu::TestLog::EndMessage;
1041 m_debugLog.str("");
1042 }
1043 log << tcu::TestLog::Message
1044 << "Image comparison failed: "
1045 << "reference = " << reference
1046 << ", expected = " << static_cast<deUint32>(expected[0])
1047 << ":" << static_cast<deUint32>(expected[1])
1048 << ":" << static_cast<deUint32>(expected[2])
1049 << ":" << static_cast<deUint32>(expected[3])
1050 << ", result = " << static_cast<deUint32>(pixels[0])
1051 << ":" << static_cast<deUint32>(pixels[1])
1052 << ":" << static_cast<deUint32>(pixels[2])
1053 << ":" << static_cast<deUint32>(pixels[3])
1054 << tcu::TestLog::EndMessage;
1055 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
1056 }
1057 else
1058 {
1059 // Pixel matches expected value
1060 m_debugLog << "Image comparison passed: "
1061 << "reference = " << reference
1062 << ", result = " << static_cast<deUint32>(pixels[0])
1063 << ":" << static_cast<deUint32>(pixels[1])
1064 << ":" << static_cast<deUint32>(pixels[2])
1065 << ":" << static_cast<deUint32>(pixels[3])
1066 << "\n";
1067 }
1068 }
1069 else
1070 {
1071 deUint8 pixels[16];
1072 deUint8 expected[4];
1073 readPixels(m_gl, pixels);
1074
1075 expected[0] = expectedUint8(reference);
1076 expected[1] = expectedUint8(reference + increment);
1077 expected[2] = expectedUint8(reference - increment);
1078 expected[3] = expectedAlpha8(reference + 2 * increment);
1079 if (checkWithThreshold8(pixels[0], expected[0]) || checkWithThreshold8(pixels[1], expected[1])
1080 || checkWithThreshold8(pixels[2], expected[2]) || checkWithThreshold8(pixels[3], expected[3]))
1081 {
1082 if (m_debugLog.str().size() > 0) {
1083 log << tcu::TestLog::Message
1084 << "Prior passing tests\n"
1085 << m_debugLog.str()
1086 << tcu::TestLog::EndMessage;
1087 m_debugLog.str("");
1088 }
1089 log << tcu::TestLog::Message
1090 << "Image comparison failed: "
1091 << "reference = " << reference
1092 << ", expected = " << static_cast<deUint32>(expected[0])
1093 << ":" << static_cast<deUint32>(expected[1])
1094 << ":" << static_cast<deUint32>(expected[2])
1095 << ":" << static_cast<deUint32>(expected[3])
1096 << ", result = " << static_cast<deUint32>(pixels[0])
1097 << ":" << static_cast<deUint32>(pixels[1])
1098 << ":" << static_cast<deUint32>(pixels[2])
1099 << ":" << static_cast<deUint32>(pixels[3])
1100 << tcu::TestLog::EndMessage;
1101 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Color test failed");
1102 }
1103 else
1104 {
1105 // Pixel matches expected value
1106 m_debugLog << "Image comparison passed: "
1107 << "reference = " << reference
1108 << ", result = " << static_cast<deUint32>(pixels[0])
1109 << ":" << static_cast<deUint32>(pixels[1])
1110 << ":" << static_cast<deUint32>(pixels[2])
1111 << ":" << static_cast<deUint32>(pixels[3])
1112 << "\n";
1113 }
1114 }
1115 }
1116
testFramebufferColorEncoding()1117 void WideColorSurfaceTest::testFramebufferColorEncoding()
1118 {
1119 GLint framebufferColorEncoding;
1120 m_gl.getFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_BACK, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &framebufferColorEncoding);
1121 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Get framebuffer color encoding");
1122 bool correct = false;
1123 if (m_colorSpace == EGL_GL_COLORSPACE_SRGB_KHR || m_colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT)
1124 {
1125 if (m_redSize == 8)
1126 {
1127 correct = framebufferColorEncoding == GL_SRGB;
1128 }
1129 else if (m_redSize == 16)
1130 {
1131 correct = framebufferColorEncoding == GL_LINEAR;
1132 }
1133 else if (m_redSize == 10)
1134 {
1135 correct = true;
1136 }
1137 }
1138 else
1139 {
1140 correct = framebufferColorEncoding == GL_LINEAR;
1141 }
1142 if (!correct)
1143 {
1144 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Framebuffer color encoding is wrong");
1145 }
1146 }
1147
doClearTest(EGLSurface surface)1148 void WideColorSurfaceTest::doClearTest (EGLSurface surface)
1149 {
1150 tcu::TestLog& log = m_testCtx.getLog();
1151 const Library& egl = m_eglTestCtx.getLibrary();
1152 const EGLint attribList[] =
1153 {
1154 EGL_CONTEXT_CLIENT_VERSION, 2,
1155 EGL_NONE
1156 };
1157 EGLContext eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList);
1158 EGLU_CHECK_MSG(egl, "eglCreateContext");
1159
1160 egl.makeCurrent(m_eglDisplay, surface, surface, eglContext);
1161 EGLU_CHECK_MSG(egl, "eglMakeCurrent");
1162
1163 {
1164 // put gles2Renderer inside it's own scope so that it's cleaned
1165 // up before we hit the destroyContext
1166 const GLES2Renderer gles2Renderer(m_gl, 128, 128);
1167
1168 std::vector<Iteration>::const_iterator it; // declare an Iterator to a vector of strings
1169 log << tcu::TestLog::Message << "m_iterations.count = " << m_iterations.size() << tcu::TestLog::EndMessage;
1170 for(it = m_iterations.begin() ; it < m_iterations.end(); it++)
1171 {
1172 float reference = it->start;
1173 log << tcu::TestLog::Message << "start = " << it->start
1174 << tcu::TestLog::EndMessage;
1175 log << tcu::TestLog::Message
1176 << "increment = " << it->increment
1177 << tcu::TestLog::EndMessage;
1178 log << tcu::TestLog::Message
1179 << "count = " << it->iterationCount
1180 << tcu::TestLog::EndMessage;
1181 m_debugLog.str("");
1182 for (int iterationCount = 0; iterationCount < it->iterationCount; iterationCount++)
1183 {
1184 const Color clearColor(reference, reference + it->increment, reference - it->increment, reference + 2 * it->increment);
1185
1186 clearColorScreen(m_gl, clearColor);
1187 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Clear to test value");
1188
1189 testPixels(reference, it->increment);
1190
1191 // reset buffer contents so that we know render below did something
1192 const Color clearColor2(1.0f - reference, 1.0f, 1.0f, 1.0f);
1193 clearColorScreen(m_gl, clearColor2);
1194 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Clear to 1.0f - reference value");
1195
1196 const ColoredRect coloredRect (IVec2(0, 0), IVec2(1, 1), clearColor);
1197 gles2Renderer.render(coloredRect);
1198 testPixels(reference, it->increment);
1199
1200 reference += it->increment;
1201
1202 // If this device is ES3 compatible, so do some additional testing
1203 if (glu::IsES3Compatible(m_gl))
1204 testFramebufferColorEncoding();
1205 }
1206
1207 EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, surface));
1208 }
1209 }
1210
1211 // disconnect surface & context so they can be destroyed when
1212 // this function exits.
1213 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
1214
1215 egl.destroyContext(m_eglDisplay, eglContext);
1216 }
1217
executeTest(void)1218 void WideColorSurfaceTest::executeTest (void)
1219 {
1220 tcu::TestLog& log = m_testCtx.getLog();
1221 const Library& egl = m_eglTestCtx.getLibrary();
1222 const eglu::NativeDisplayFactory& displayFactory = m_eglTestCtx.getNativeDisplayFactory();
1223 eglu::NativeDisplay& nativeDisplay = m_eglTestCtx.getNativeDisplay();
1224 egl.bindAPI(EGL_OPENGL_ES_API);
1225
1226 if (m_surfaceType & EGL_PBUFFER_BIT)
1227 {
1228 log << tcu::TestLog::Message << "Test Pbuffer" << tcu::TestLog::EndMessage;
1229
1230 std::vector<EGLint> attribs;
1231 attribs.push_back(EGL_WIDTH);
1232 attribs.push_back(128);
1233 attribs.push_back(EGL_HEIGHT);
1234 attribs.push_back(128);
1235 if (m_colorSpace != EGL_NONE)
1236 {
1237 attribs.push_back(EGL_GL_COLORSPACE_KHR);
1238 attribs.push_back(m_colorSpace);
1239 }
1240 attribs.push_back(EGL_NONE);
1241 attribs.push_back(EGL_NONE);
1242 const EGLSurface surface = egl.createPbufferSurface(m_eglDisplay, m_eglConfig, attribs.data());
1243 if ((surface == EGL_NO_SURFACE) && (egl.getError() == EGL_BAD_MATCH))
1244 {
1245 TCU_THROW(NotSupportedError, "Colorspace is not supported with this format");
1246 }
1247 TCU_CHECK(surface != EGL_NO_SURFACE);
1248 EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");
1249
1250 doClearTest(surface);
1251
1252 egl.destroySurface(m_eglDisplay, surface);
1253 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1254 }
1255 else if (m_surfaceType & EGL_WINDOW_BIT)
1256 {
1257 log << tcu::TestLog::Message << "Test Window" << tcu::TestLog::EndMessage;
1258
1259 const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(displayFactory, m_testCtx.getCommandLine());
1260
1261 de::UniquePtr<eglu::NativeWindow> window (windowFactory.createWindow(&nativeDisplay, m_eglDisplay, m_eglConfig, DE_NULL, eglu::WindowParams(128, 128, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))));
1262 std::vector<EGLAttrib> attribs;
1263 if (m_colorSpace != EGL_NONE)
1264 {
1265 attribs.push_back(EGL_GL_COLORSPACE_KHR);
1266 attribs.push_back(m_colorSpace);
1267 }
1268 attribs.push_back(EGL_NONE);
1269 attribs.push_back(EGL_NONE);
1270
1271 EGLSurface surface;
1272 try
1273 {
1274 surface = eglu::createWindowSurface(nativeDisplay, *window, m_eglDisplay, m_eglConfig, attribs.data());
1275 }
1276 catch (const eglu::Error& error)
1277 {
1278 if (error.getError() == EGL_BAD_MATCH)
1279 TCU_THROW(NotSupportedError, "createWindowSurface is not supported for this config");
1280
1281 throw;
1282 }
1283 TCU_CHECK(surface != EGL_NO_SURFACE);
1284 EGLU_CHECK_MSG(egl, "eglCreateWindowSurface()");
1285
1286 doClearTest(surface);
1287
1288 if (m_testAttribList.size() > 0)
1289 {
1290 for (deUint32 i = 0; i < m_testAttribList.size(); i +=2)
1291 {
1292 if (!egl.surfaceAttrib(m_eglDisplay, surface, m_testAttribList[i], m_testAttribList[i+1]))
1293 {
1294 // Implementation can return EGL_BAD_PARAMETER if given value is not supported.
1295 EGLint error = egl.getError();
1296 if (error != EGL_BAD_PARAMETER)
1297 TCU_FAIL("Unable to set HDR metadata on surface");
1298
1299 log << tcu::TestLog::Message <<
1300 "Warning: Metadata value " << m_testAttribList[i+1] << " for attrib 0x" <<
1301 std::hex << m_testAttribList[i] << std::dec <<
1302 " not supported by the implementation." << tcu::TestLog::EndMessage;
1303 m_testAttribList[i+1] = EGL_BAD_PARAMETER;
1304 }
1305 }
1306 for (deUint32 i = 0; i < m_testAttribList.size(); i +=2)
1307 {
1308 // Skip unsupported values.
1309 if (m_testAttribList[i+1] == EGL_BAD_PARAMETER)
1310 continue;
1311
1312 EGLint value;
1313 egl.querySurface(m_eglDisplay, surface, m_testAttribList[i], &value);
1314 TCU_CHECK(value == m_testAttribList[i+1]);
1315 }
1316 }
1317
1318 egl.destroySurface(m_eglDisplay, surface);
1319 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1320 }
1321 else if (m_surfaceType & EGL_PIXMAP_BIT)
1322 {
1323 log << tcu::TestLog::Message << "Test Pixmap" << tcu::TestLog::EndMessage;
1324
1325 const eglu::NativePixmapFactory& pixmapFactory = eglu::selectNativePixmapFactory(displayFactory, m_testCtx.getCommandLine());
1326
1327 de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory.createPixmap(&nativeDisplay, m_eglDisplay, m_eglConfig, DE_NULL, 128, 128));
1328 const EGLSurface surface = eglu::createPixmapSurface(nativeDisplay, *pixmap, m_eglDisplay, m_eglConfig, DE_NULL);
1329 TCU_CHECK(surface != EGL_NO_SURFACE);
1330 EGLU_CHECK_MSG(egl, "eglCreatePixmapSurface()");
1331
1332 doClearTest(surface);
1333
1334 egl.destroySurface(m_eglDisplay, surface);
1335 EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1336 }
1337 else
1338 TCU_FAIL("No valid surface types supported in config");
1339 }
1340
iterate(void)1341 TestCase::IterateResult WideColorSurfaceTest::iterate (void)
1342 {
1343 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1344 executeTest();
1345 return STOP;
1346 }
1347
1348 } // anonymous
1349
WideColorTests(EglTestContext & eglTestCtx)1350 WideColorTests::WideColorTests (EglTestContext& eglTestCtx)
1351 : TestCaseGroup(eglTestCtx, "wide_color", "Wide Color tests")
1352 {
1353 }
1354
init(void)1355 void WideColorTests::init (void)
1356 {
1357 addChild(new WideColorFP16Test(m_eglTestCtx, "fp16", "Verify that FP16 pixel format is present"));
1358 addChild(new WideColor1010102Test(m_eglTestCtx, "1010102", "Check if 1010102 pixel format is present"));
1359
1360 // This is an increment FP16 can do between -1.0 to 1.0
1361 const float fp16Increment1 = deFloatPow(2.0, -11.0);
1362 // This is an increment FP16 can do between 1.0 to 2.0
1363 const float fp16Increment2 = deFloatPow(2.0, -10.0);
1364
1365 std::vector<Iteration> iterations;
1366 // -0.333251953125f ~ -1/3 as seen in FP16
1367 // Negative values will be 0 on read with fixed point pixel formats
1368 iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1369 // test crossing 0
1370 iterations.push_back(Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1371 // test crossing 1.0
1372 // Values > 1.0 will be truncated to 1.0 with fixed point pixel formats
1373 iterations.push_back(Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1374
1375 const EGLint windowAttribListFP16[] =
1376 {
1377 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1378 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1379 EGL_RED_SIZE, 16,
1380 EGL_GREEN_SIZE, 16,
1381 EGL_BLUE_SIZE, 16,
1382 EGL_ALPHA_SIZE, 16,
1383 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
1384 EGL_NONE, EGL_NONE
1385 };
1386 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_default_colorspace", "FP16 window surface has FP16 pixels in it", windowAttribListFP16, EGL_NONE, iterations));
1387 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_srgb", "FP16 window surface, explicit sRGB colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1388 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_p3", "FP16 window surface, explicit Display-P3 colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1389 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_p3_passthrough", "FP16 window surface, explicit Display-P3 colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1390 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_scrgb", "FP16 window surface, explicit scRGB colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SCRGB_EXT, iterations));
1391 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_fp16_colorspace_scrgb_linear", "FP16 window surface, explicit scRGB linear colorspace", windowAttribListFP16, EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT, iterations));
1392
1393 const EGLint pbufferAttribListFP16[] =
1394 {
1395 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1396 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1397 EGL_RED_SIZE, 16,
1398 EGL_GREEN_SIZE, 16,
1399 EGL_BLUE_SIZE, 16,
1400 EGL_ALPHA_SIZE, 16,
1401 EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
1402 EGL_NONE, EGL_NONE
1403 };
1404 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_default_colorspace", "FP16 pbuffer surface has FP16 pixels in it", pbufferAttribListFP16, EGL_NONE, iterations));
1405 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_srgb", "FP16 pbuffer surface, explicit sRGB colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1406 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_p3", "FP16 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1407 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_p3_passthrough", "FP16 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1408 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_scrgb", "FP16 pbuffer surface, explicit scRGB colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SCRGB_EXT, iterations));
1409 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_fp16_colorspace_scrgb_linear", "FP16 pbuffer surface, explicit scRGB linear colorspace", pbufferAttribListFP16, EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT, iterations));
1410
1411 const EGLint windowAttribList1010102[] =
1412 {
1413 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1414 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1415 EGL_RED_SIZE, 10,
1416 EGL_GREEN_SIZE, 10,
1417 EGL_BLUE_SIZE, 10,
1418 EGL_ALPHA_SIZE, 2,
1419 EGL_NONE, EGL_NONE
1420 };
1421 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_default", "1010102 Window surface, default (sRGB) colorspace", windowAttribList1010102, EGL_NONE, iterations));
1422 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_srgb", "1010102 Window surface, explicit sRGB colorspace", windowAttribList1010102, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1423 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_p3", "1010102 Window surface, explicit Display-P3 colorspace", windowAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1424 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_1010102_colorspace_p3_passthrough", "1010102 Window surface, explicit Display-P3 colorspace", windowAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1425
1426 const EGLint pbufferAttribList1010102[] =
1427 {
1428 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1429 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1430 EGL_RED_SIZE, 10,
1431 EGL_GREEN_SIZE, 10,
1432 EGL_BLUE_SIZE, 10,
1433 EGL_ALPHA_SIZE, 2,
1434 EGL_NONE, EGL_NONE
1435 };
1436 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_default", "1010102 pbuffer surface, default (sRGB) colorspace", pbufferAttribList1010102, EGL_NONE, iterations));
1437 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_srgb", "1010102 pbuffer surface, explicit sRGB colorspace", pbufferAttribList1010102, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1438 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_p3", "1010102 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1439 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_1010102_colorspace_p3_passthrough", "1010102 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList1010102, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1440
1441 const EGLint windowAttribList8888[] =
1442 {
1443 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1444 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1445 EGL_RED_SIZE, 8,
1446 EGL_GREEN_SIZE, 8,
1447 EGL_BLUE_SIZE, 8,
1448 EGL_ALPHA_SIZE, 8,
1449 EGL_NONE, EGL_NONE
1450 };
1451 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_default", "8888 window surface, default (sRGB) colorspace", windowAttribList8888, EGL_NONE, iterations));
1452 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_srgb", "8888 window surface, explicit sRGB colorspace", windowAttribList8888, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1453 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_p3", "8888 window surface, explicit Display-P3 colorspace", windowAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1454 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_8888_colorspace_p3_passthrough", "8888 window surface, explicit Display-P3 colorspace", windowAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1455
1456 const EGLint pbufferAttribList8888[] =
1457 {
1458 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1459 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1460 EGL_RED_SIZE, 8,
1461 EGL_GREEN_SIZE, 8,
1462 EGL_BLUE_SIZE, 8,
1463 EGL_ALPHA_SIZE, 8,
1464 EGL_NONE, EGL_NONE
1465 };
1466 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_default", "8888 pbuffer surface, default (sRGB) colorspace", pbufferAttribList8888, EGL_NONE, iterations));
1467 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_srgb", "8888 pbuffer surface, explicit sRGB colorspace", pbufferAttribList8888, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1468 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_p3", "8888 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1469 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_8888_colorspace_p3_passthrough", "8888 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList8888, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1470
1471 const EGLint windowAttribList888[] =
1472 {
1473 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1474 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1475 EGL_RED_SIZE, 8,
1476 EGL_GREEN_SIZE, 8,
1477 EGL_BLUE_SIZE, 8,
1478 EGL_NONE, EGL_NONE
1479 };
1480 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_888_colorspace_default", "888 window surface, default (sRGB) colorspace", windowAttribList888, EGL_NONE, iterations));
1481 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_888_colorspace_srgb", "888 window surface, explicit sRGB colorspace", windowAttribList888, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1482 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_888_colorspace_p3", "888 window surface, explicit Display-P3 colorspace", windowAttribList888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1483 addChild(new WideColorSurfaceTest(m_eglTestCtx, "window_888_colorspace_p3_passthrough", "888 window surface, explicit Display-P3 colorspace", windowAttribList888, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1484
1485 const EGLint pbufferAttribList888[] =
1486 {
1487 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1488 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1489 EGL_RED_SIZE, 8,
1490 EGL_GREEN_SIZE, 8,
1491 EGL_BLUE_SIZE, 8,
1492 EGL_NONE, EGL_NONE
1493 };
1494 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_888_colorspace_default", "888 pbuffer surface, default (sRGB) colorspace", pbufferAttribList888, EGL_NONE, iterations));
1495 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_888_colorspace_srgb", "888 pbuffer surface, explicit sRGB colorspace", pbufferAttribList888, EGL_GL_COLORSPACE_SRGB_KHR, iterations));
1496 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_888_colorspace_p3", "888 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList888, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, iterations));
1497 addChild(new WideColorSurfaceTest(m_eglTestCtx, "pbuffer_888_colorspace_p3_passthrough", "888 pbuffer surface, explicit Display-P3 colorspace", pbufferAttribList888, EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT, iterations));
1498
1499 }
1500
createWideColorTests(EglTestContext & eglTestCtx)1501 TestCaseGroup* createWideColorTests (EglTestContext& eglTestCtx)
1502 {
1503 return new WideColorTests(eglTestCtx);
1504 }
1505
1506 class Smpte2086ColorTest : public WideColorTest
1507 {
1508 public:
1509 Smpte2086ColorTest (EglTestContext& eglTestCtx,
1510 const char* name,
1511 const char* description);
1512
1513 void executeTest (void);
1514 IterateResult iterate (void);
1515 };
1516
Smpte2086ColorTest(EglTestContext & eglTestCtx,const char * name,const char * description)1517 Smpte2086ColorTest::Smpte2086ColorTest (EglTestContext& eglTestCtx, const char* name, const char* description)
1518 : WideColorTest(eglTestCtx, name, description)
1519 {
1520 }
1521
1522 #define METADATA_SCALE(x) (static_cast<EGLint>(x * EGL_METADATA_SCALING_EXT))
1523
executeTest(void)1524 void Smpte2086ColorTest::executeTest (void)
1525 {
1526 tcu::TestLog& log = m_testCtx.getLog();
1527 const Library& egl = m_eglTestCtx.getLibrary();
1528 egl.bindAPI(EGL_OPENGL_ES_API);
1529
1530 log << tcu::TestLog::Message << "Test SMPTE 2086 Metadata on Window" << tcu::TestLog::EndMessage;
1531
1532 checkSMPTE2086();
1533
1534 // This is an increment FP16 can do between -1.0 to 1.0
1535 const float fp16Increment1 = deFloatPow(2.0, -11.0);
1536 // This is an increment FP16 can do between 1.0 to 2.0
1537 const float fp16Increment2 = deFloatPow(2.0, -10.0);
1538
1539 std::vector<Iteration> int8888Iterations;
1540 // -0.333251953125f ~ -1/3 as seen in fp16
1541 // Negative values will be 0 on read with fixed point pixel formats
1542 int8888Iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1543 // test crossing 0
1544 int8888Iterations.push_back(Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1545 // test crossing 1.0
1546 // Values > 1.0 will be truncated to 1.0 with fixed point pixel formats
1547 int8888Iterations.push_back(Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1548
1549 const EGLint windowAttribList8888[] =
1550 {
1551 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1552 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1553 EGL_RED_SIZE, 8,
1554 EGL_GREEN_SIZE, 8,
1555 EGL_BLUE_SIZE, 8,
1556 EGL_ALPHA_SIZE, 8,
1557 EGL_NONE, EGL_NONE
1558 };
1559
1560 WideColorSurfaceTest testObj(m_eglTestCtx, "window_8888_colorspace_default", "8888 window surface, default (sRGB) colorspace", windowAttribList8888, EGL_NONE, int8888Iterations);
1561
1562 const EGLint testAttrs[] =
1563 {
1564 EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT, METADATA_SCALE(0.680),
1565 EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT, METADATA_SCALE(0.320),
1566 EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT, METADATA_SCALE(0.265),
1567 EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT, METADATA_SCALE(0.690),
1568 EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT, METADATA_SCALE(0.440),
1569 EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT, METADATA_SCALE(0.320),
1570 EGL_SMPTE2086_WHITE_POINT_X_EXT, METADATA_SCALE(0.2200),
1571 EGL_SMPTE2086_WHITE_POINT_Y_EXT, METADATA_SCALE(0.2578),
1572 EGL_SMPTE2086_MAX_LUMINANCE_EXT, METADATA_SCALE(1.31),
1573 EGL_SMPTE2086_MIN_LUMINANCE_EXT, METADATA_SCALE(0.123),
1574 EGL_NONE
1575 };
1576 testObj.addTestAttributes(testAttrs);
1577
1578 testObj.init();
1579 testObj.executeTest();
1580 }
1581
iterate(void)1582 TestCase::IterateResult Smpte2086ColorTest::iterate (void)
1583 {
1584 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1585 executeTest();
1586 return STOP;
1587 }
1588
1589 class Cta8613ColorTest : public WideColorTest
1590 {
1591 public:
1592 Cta8613ColorTest (EglTestContext& eglTestCtx,
1593 const char* name,
1594 const char* description);
1595
1596 void executeTest (void);
1597 IterateResult iterate (void);
1598 };
1599
Cta8613ColorTest(EglTestContext & eglTestCtx,const char * name,const char * description)1600 Cta8613ColorTest::Cta8613ColorTest (EglTestContext& eglTestCtx, const char* name, const char* description)
1601 : WideColorTest(eglTestCtx, name, description)
1602 {
1603 }
1604
1605 #define METADATA_SCALE(x) (static_cast<EGLint>(x * EGL_METADATA_SCALING_EXT))
1606
executeTest(void)1607 void Cta8613ColorTest::executeTest (void)
1608 {
1609 tcu::TestLog& log = m_testCtx.getLog();
1610 const Library& egl = m_eglTestCtx.getLibrary();
1611 egl.bindAPI(EGL_OPENGL_ES_API);
1612
1613 log << tcu::TestLog::Message << "Test CTA 861.3 Metadata on Window" << tcu::TestLog::EndMessage;
1614
1615 checkCTA861_3();
1616
1617 // This is an increment FP16 can do between -1.0 to 1.0
1618 const float fp16Increment1 = deFloatPow(2.0, -11.0);
1619 // This is an increment FP16 can do between 1.0 to 2.0
1620 const float fp16Increment2 = deFloatPow(2.0, -10.0);
1621
1622 std::vector<Iteration> int8888Iterations;
1623 // -0.333251953125f ~ -1/3 as seen in fp16
1624 // Negative values will be 0 on read with fixed point pixel formats
1625 int8888Iterations.push_back(Iteration(-0.333251953125f, fp16Increment1, 10));
1626 // test crossing 0
1627 int8888Iterations.push_back(Iteration(-fp16Increment1 * 5.0f, fp16Increment1, 10));
1628 // test crossing 1.0
1629 // Values > 1.0 will be truncated to 1.0 with fixed point pixel formats
1630 int8888Iterations.push_back(Iteration(1.0f - fp16Increment2 * 5.0f, fp16Increment2, 10));
1631
1632 const EGLint windowAttribList8888[] =
1633 {
1634 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1635 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1636 EGL_RED_SIZE, 8,
1637 EGL_GREEN_SIZE, 8,
1638 EGL_BLUE_SIZE, 8,
1639 EGL_ALPHA_SIZE, 8,
1640 EGL_NONE, EGL_NONE
1641 };
1642
1643 WideColorSurfaceTest testObj(m_eglTestCtx, "window_8888_colorspace_default", "8888 window surface, default (sRGB) colorspace", windowAttribList8888, EGL_NONE, int8888Iterations);
1644
1645 const EGLint testAttrs[] =
1646 {
1647 EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT, METADATA_SCALE(1.31),
1648 EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT, METADATA_SCALE(0.6),
1649 EGL_NONE
1650 };
1651 testObj.addTestAttributes(testAttrs);
1652
1653 testObj.init();
1654 testObj.executeTest();
1655 }
1656
iterate(void)1657 TestCase::IterateResult Cta8613ColorTest::iterate (void)
1658 {
1659 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1660 executeTest();
1661 return STOP;
1662 }
1663
1664 class HdrColorTests : public TestCaseGroup
1665 {
1666 public:
1667 HdrColorTests (EglTestContext& eglTestCtx);
1668 void init (void);
1669
1670 private:
1671 HdrColorTests (const HdrColorTests&);
1672 HdrColorTests& operator= (const HdrColorTests&);
1673 };
1674
HdrColorTests(EglTestContext & eglTestCtx)1675 HdrColorTests::HdrColorTests (EglTestContext& eglTestCtx)
1676 : TestCaseGroup(eglTestCtx, "hdr_metadata", "HDR Metadata tests")
1677 {
1678 }
1679
init(void)1680 void HdrColorTests::init (void)
1681 {
1682 addChild(new Smpte2086ColorTest(m_eglTestCtx, "smpte2086", "Verify that SMPTE 2086 extension exists"));
1683 addChild(new Cta8613ColorTest(m_eglTestCtx, "cta861_3", "Verify that CTA 861.3 extension exists"));
1684 }
1685
createHdrColorTests(EglTestContext & eglTestCtx)1686 TestCaseGroup* createHdrColorTests (EglTestContext& eglTestCtx)
1687 {
1688 return new HdrColorTests(eglTestCtx);
1689 }
1690
1691 } // egl
1692 } // deqp
1693