1/*
2 * Copyright 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "SRGB_test"
18//#define LOG_NDEBUG 0
19
20// Ignore for this file because it flags every instance of
21// ASSERT_EQ(GL_NO_ERROR, glGetError());
22#pragma clang diagnostic ignored "-Wsign-compare"
23
24#include "GLTest.h"
25
26#include <math.h>
27
28#include <gui/CpuConsumer.h>
29#include <gui/Surface.h>
30#include <gui/SurfaceComposerClient.h>
31
32#include <EGL/egl.h>
33#include <EGL/eglext.h>
34#include <GLES3/gl3.h>
35
36#include <android/native_window.h>
37
38#include <gtest/gtest.h>
39
40namespace android {
41
42class SRGBTest : public ::testing::Test {
43protected:
44    // Class constants
45    enum {
46        DISPLAY_WIDTH = 512,
47        DISPLAY_HEIGHT = 512,
48        PIXEL_SIZE = 4, // bytes or components
49        DISPLAY_SIZE = DISPLAY_WIDTH * DISPLAY_HEIGHT * PIXEL_SIZE,
50        ALPHA_VALUE = 223, // should be in [0, 255]
51        TOLERANCE = 1,
52    };
53    static const char SHOW_DEBUG_STRING[];
54
55    SRGBTest() :
56            mInputSurface(), mCpuConsumer(), mLockedBuffer(),
57            mEglDisplay(EGL_NO_DISPLAY), mEglConfig(),
58            mEglContext(EGL_NO_CONTEXT), mEglSurface(EGL_NO_SURFACE),
59            mComposerClient(), mSurfaceControl(), mOutputSurface() {
60    }
61
62    virtual ~SRGBTest() {
63        if (mEglDisplay != EGL_NO_DISPLAY) {
64            if (mEglSurface != EGL_NO_SURFACE) {
65                eglDestroySurface(mEglDisplay, mEglSurface);
66            }
67            if (mEglContext != EGL_NO_CONTEXT) {
68                eglDestroyContext(mEglDisplay, mEglContext);
69            }
70            eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
71                    EGL_NO_CONTEXT);
72            eglTerminate(mEglDisplay);
73        }
74    }
75
76    virtual void SetUp() {
77        sp<IGraphicBufferProducer> producer;
78        sp<IGraphicBufferConsumer> consumer;
79        BufferQueue::createBufferQueue(&producer, &consumer);
80        ASSERT_EQ(NO_ERROR, consumer->setDefaultBufferSize(
81                DISPLAY_WIDTH, DISPLAY_HEIGHT));
82        mCpuConsumer = new CpuConsumer(consumer, 1);
83        String8 name("CpuConsumer_for_SRGBTest");
84        mCpuConsumer->setName(name);
85        mInputSurface = new Surface(producer);
86
87        ASSERT_NO_FATAL_FAILURE(createEGLSurface(mInputSurface.get()));
88        ASSERT_NO_FATAL_FAILURE(createDebugSurface());
89    }
90
91    virtual void TearDown() {
92        ASSERT_NO_FATAL_FAILURE(copyToDebugSurface());
93        ASSERT_TRUE(mLockedBuffer.data != NULL);
94        ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
95    }
96
97    static float linearToSRGB(float l) {
98        if (l <= 0.0031308f) {
99            return l * 12.92f;
100        } else {
101            return 1.055f * pow(l, (1 / 2.4f)) - 0.055f;
102        }
103    }
104
105    static float srgbToLinear(float s) {
106        if (s <= 0.04045) {
107            return s / 12.92f;
108        } else {
109            return pow(((s + 0.055f) / 1.055f), 2.4f);
110        }
111    }
112
113    static uint8_t srgbToLinear(uint8_t u) {
114        float f = u / 255.0f;
115        return static_cast<uint8_t>(srgbToLinear(f) * 255.0f + 0.5f);
116    }
117
118    void fillTexture(bool writeAsSRGB) {
119        uint8_t* textureData = new uint8_t[DISPLAY_SIZE];
120
121        for (int y = 0; y < DISPLAY_HEIGHT; ++y) {
122            for (int x = 0; x < DISPLAY_WIDTH; ++x) {
123                float realValue = static_cast<float>(x) / (DISPLAY_WIDTH - 1);
124                realValue *= ALPHA_VALUE / 255.0f; // Premultiply by alpha
125                if (writeAsSRGB) {
126                    realValue = linearToSRGB(realValue);
127                }
128
129                int offset = (y * DISPLAY_WIDTH + x) * PIXEL_SIZE;
130                for (int c = 0; c < 3; ++c) {
131                    uint8_t intValue = static_cast<uint8_t>(
132                            realValue * 255.0f + 0.5f);
133                    textureData[offset + c] = intValue;
134                }
135                textureData[offset + 3] = ALPHA_VALUE;
136            }
137        }
138
139        glTexImage2D(GL_TEXTURE_2D, 0, writeAsSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA8,
140                DISPLAY_WIDTH, DISPLAY_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE,
141                textureData);
142        ASSERT_EQ(GL_NO_ERROR, glGetError());
143
144        delete[] textureData;
145    }
146
147    void initShaders() {
148        static const char vertexSource[] =
149            "attribute vec4 vPosition;\n"
150            "varying vec2 texCoords;\n"
151            "void main() {\n"
152            "  texCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
153            "  gl_Position = vPosition;\n"
154            "}\n";
155
156        static const char fragmentSource[] =
157            "precision mediump float;\n"
158            "uniform sampler2D texSampler;\n"
159            "varying vec2 texCoords;\n"
160            "void main() {\n"
161            "  gl_FragColor = texture2D(texSampler, texCoords);\n"
162            "}\n";
163
164        GLuint program;
165        {
166            SCOPED_TRACE("Creating shader program");
167            ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(
168                    vertexSource, fragmentSource, &program));
169        }
170
171        GLint positionHandle = glGetAttribLocation(program, "vPosition");
172        ASSERT_EQ(GL_NO_ERROR, glGetError());
173        ASSERT_NE(-1, positionHandle);
174
175        GLint samplerHandle = glGetUniformLocation(program, "texSampler");
176        ASSERT_EQ(GL_NO_ERROR, glGetError());
177        ASSERT_NE(-1, samplerHandle);
178
179        static const GLfloat vertices[] = {
180            -1.0f, 1.0f,
181            -1.0f, -1.0f,
182            1.0f, -1.0f,
183            1.0f, 1.0f,
184        };
185
186        glVertexAttribPointer(positionHandle, 2, GL_FLOAT, GL_FALSE, 0, vertices);
187        ASSERT_EQ(GL_NO_ERROR, glGetError());
188        glEnableVertexAttribArray(positionHandle);
189        ASSERT_EQ(GL_NO_ERROR, glGetError());
190
191        glUseProgram(program);
192        ASSERT_EQ(GL_NO_ERROR, glGetError());
193        glUniform1i(samplerHandle, 0);
194        ASSERT_EQ(GL_NO_ERROR, glGetError());
195
196        GLuint textureHandle;
197        glGenTextures(1, &textureHandle);
198        ASSERT_EQ(GL_NO_ERROR, glGetError());
199        glBindTexture(GL_TEXTURE_2D, textureHandle);
200        ASSERT_EQ(GL_NO_ERROR, glGetError());
201
202        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
203        ASSERT_EQ(GL_NO_ERROR, glGetError());
204        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
205        ASSERT_EQ(GL_NO_ERROR, glGetError());
206        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
207        ASSERT_EQ(GL_NO_ERROR, glGetError());
208        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
209        ASSERT_EQ(GL_NO_ERROR, glGetError());
210    }
211
212    void drawTexture(bool asSRGB, GLint x, GLint y, GLsizei width,
213            GLsizei height) {
214        ASSERT_NO_FATAL_FAILURE(fillTexture(asSRGB));
215        glViewport(x, y, width, height);
216        ASSERT_EQ(GL_NO_ERROR, glGetError());
217        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
218        ASSERT_EQ(GL_NO_ERROR, glGetError());
219    }
220
221    void checkLockedBuffer(PixelFormat format, android_dataspace dataSpace) {
222        ASSERT_EQ(mLockedBuffer.format, format);
223        ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
224        ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
225        ASSERT_EQ(mLockedBuffer.dataSpace, dataSpace);
226    }
227
228    static bool withinTolerance(int a, int b) {
229        int diff = a - b;
230        return diff >= 0 ? diff <= TOLERANCE : -diff <= TOLERANCE;
231    }
232
233    // Primary producer and consumer
234    sp<Surface> mInputSurface;
235    sp<CpuConsumer> mCpuConsumer;
236    CpuConsumer::LockedBuffer mLockedBuffer;
237
238    EGLDisplay mEglDisplay;
239    EGLConfig mEglConfig;
240    EGLContext mEglContext;
241    EGLSurface mEglSurface;
242
243    // Auxiliary display output
244    sp<SurfaceComposerClient> mComposerClient;
245    sp<SurfaceControl> mSurfaceControl;
246    sp<Surface> mOutputSurface;
247
248private:
249    void createEGLSurface(Surface* inputSurface) {
250        mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
251        ASSERT_EQ(EGL_SUCCESS, eglGetError());
252        ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
253
254        EXPECT_TRUE(eglInitialize(mEglDisplay, NULL, NULL));
255        ASSERT_EQ(EGL_SUCCESS, eglGetError());
256
257        static const EGLint configAttribs[] = {
258            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
259            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
260            EGL_RED_SIZE, 8,
261            EGL_GREEN_SIZE, 8,
262            EGL_BLUE_SIZE, 8,
263            EGL_ALPHA_SIZE, 8,
264            EGL_NONE };
265
266        EGLint numConfigs = 0;
267        EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &mEglConfig, 1,
268                &numConfigs));
269        ASSERT_EQ(EGL_SUCCESS, eglGetError());
270        ASSERT_GT(numConfigs, 0);
271
272        static const EGLint contextAttribs[] = {
273            EGL_CONTEXT_CLIENT_VERSION, 3,
274            EGL_NONE } ;
275
276        mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT,
277                contextAttribs);
278        ASSERT_EQ(EGL_SUCCESS, eglGetError());
279        ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
280
281        mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
282                inputSurface, NULL);
283        ASSERT_EQ(EGL_SUCCESS, eglGetError());
284        ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
285
286        EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
287                mEglContext));
288        ASSERT_EQ(EGL_SUCCESS, eglGetError());
289    }
290
291    void createDebugSurface() {
292        if (getenv(SHOW_DEBUG_STRING) == NULL) return;
293
294        mComposerClient = new SurfaceComposerClient;
295        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
296
297        mSurfaceControl = mComposerClient->createSurface(
298                String8("SRGBTest Surface"), DISPLAY_WIDTH, DISPLAY_HEIGHT,
299                PIXEL_FORMAT_RGBA_8888);
300
301        ASSERT_TRUE(mSurfaceControl != NULL);
302        ASSERT_TRUE(mSurfaceControl->isValid());
303
304        SurfaceComposerClient::openGlobalTransaction();
305        ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
306        ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
307        SurfaceComposerClient::closeGlobalTransaction();
308
309        ANativeWindow_Buffer outBuffer;
310        ARect inOutDirtyBounds;
311        mOutputSurface = mSurfaceControl->getSurface();
312        mOutputSurface->lock(&outBuffer, &inOutDirtyBounds);
313        uint8_t* bytePointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
314        for (int y = 0; y < outBuffer.height; ++y) {
315            int rowOffset = y * outBuffer.stride; // pixels
316            for (int x = 0; x < outBuffer.width; ++x) {
317                int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
318                for (int c = 0; c < PIXEL_SIZE; ++c) {
319                    int offset = colOffset + c;
320                    bytePointer[offset] = ((c + 1) * 56) - 1;
321                }
322            }
323        }
324        mOutputSurface->unlockAndPost();
325    }
326
327    void copyToDebugSurface() {
328        if (!mOutputSurface.get()) return;
329
330        size_t bufferSize = mLockedBuffer.height * mLockedBuffer.stride *
331                PIXEL_SIZE;
332
333        ANativeWindow_Buffer outBuffer;
334        ARect outBufferBounds;
335        mOutputSurface->lock(&outBuffer, &outBufferBounds);
336        ASSERT_EQ(mLockedBuffer.width, static_cast<uint32_t>(outBuffer.width));
337        ASSERT_EQ(mLockedBuffer.height, static_cast<uint32_t>(outBuffer.height));
338        ASSERT_EQ(mLockedBuffer.stride, static_cast<uint32_t>(outBuffer.stride));
339
340        if (mLockedBuffer.format == outBuffer.format) {
341            memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
342        } else {
343            ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_RGBA_8888);
344            ASSERT_EQ(mLockedBuffer.dataSpace, HAL_DATASPACE_SRGB);
345            ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
346            uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
347            for (int y = 0; y < outBuffer.height; ++y) {
348                int rowOffset = y * outBuffer.stride; // pixels
349                for (int x = 0; x < outBuffer.width; ++x) {
350                    int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
351
352                    // RGB are converted
353                    for (int c = 0; c < (PIXEL_SIZE - 1); ++c) {
354                        outPointer[colOffset + c] = srgbToLinear(
355                                mLockedBuffer.data[colOffset + c]);
356                    }
357
358                    // Alpha isn't converted
359                    outPointer[colOffset + 3] =
360                            mLockedBuffer.data[colOffset + 3];
361                }
362            }
363        }
364        mOutputSurface->unlockAndPost();
365
366        int sleepSeconds = atoi(getenv(SHOW_DEBUG_STRING));
367        sleep(sleepSeconds);
368    }
369};
370
371const char SRGBTest::SHOW_DEBUG_STRING[] = "DEBUG_OUTPUT_SECONDS";
372
373TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
374    ASSERT_NO_FATAL_FAILURE(initShaders());
375
376    // The RGB texture is displayed in the top half
377    ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, DISPLAY_HEIGHT / 2,
378            DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));
379
380    // The SRGB texture is displayed in the bottom half
381    ASSERT_NO_FATAL_FAILURE(drawTexture(true, 0, 0,
382            DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));
383
384    eglSwapBuffers(mEglDisplay, mEglSurface);
385    ASSERT_EQ(EGL_SUCCESS, eglGetError());
386
387    // Lock
388    ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
389    ASSERT_NO_FATAL_FAILURE(
390        checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_UNKNOWN));
391
392    // Compare a pixel in the middle of each texture
393    int midSRGBOffset = (DISPLAY_HEIGHT / 4) * mLockedBuffer.stride *
394            PIXEL_SIZE;
395    int midRGBOffset = midSRGBOffset * 3;
396    midRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
397    midSRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
398    for (int c = 0; c < PIXEL_SIZE; ++c) {
399        int expectedValue = mLockedBuffer.data[midRGBOffset + c];
400        int actualValue = mLockedBuffer.data[midSRGBOffset + c];
401        ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
402    }
403
404    // mLockedBuffer is unlocked in TearDown so we can copy data from it to
405    // the debug surface if necessary
406}
407
408// XXX: Disabled since we don't currently expect this to work
409TEST_F(SRGBTest, DISABLED_RenderToSRGBSurface) {
410    ASSERT_NO_FATAL_FAILURE(initShaders());
411
412    // By default, the first buffer we write into will be RGB
413
414    // Render an RGB texture across the whole surface
415    ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
416            DISPLAY_WIDTH, DISPLAY_HEIGHT));
417    eglSwapBuffers(mEglDisplay, mEglSurface);
418    ASSERT_EQ(EGL_SUCCESS, eglGetError());
419
420    // Lock
421    ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
422    ASSERT_NO_FATAL_FAILURE(
423        checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_UNKNOWN));
424
425    // Save the values of the middle pixel for later comparison against SRGB
426    uint8_t values[PIXEL_SIZE] = {};
427    int middleOffset = (DISPLAY_HEIGHT / 2) * mLockedBuffer.stride *
428            PIXEL_SIZE;
429    middleOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
430    for (int c = 0; c < PIXEL_SIZE; ++c) {
431        values[c] = mLockedBuffer.data[middleOffset + c];
432    }
433
434    // Unlock
435    ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
436
437    // Switch to SRGB window surface
438#define EGL_GL_COLORSPACE_KHR      EGL_VG_COLORSPACE
439#define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB
440
441    static const int srgbAttribs[] = {
442        EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR,
443        EGL_NONE,
444    };
445
446    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
447            mEglContext));
448    ASSERT_EQ(EGL_SUCCESS, eglGetError());
449
450    EXPECT_TRUE(eglDestroySurface(mEglDisplay, mEglSurface));
451    ASSERT_EQ(EGL_SUCCESS, eglGetError());
452
453    mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
454            mInputSurface.get(), srgbAttribs);
455    ASSERT_EQ(EGL_SUCCESS, eglGetError());
456    ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
457
458    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
459            mEglContext));
460    ASSERT_EQ(EGL_SUCCESS, eglGetError());
461
462    // Render the texture again
463    ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
464            DISPLAY_WIDTH, DISPLAY_HEIGHT));
465    eglSwapBuffers(mEglDisplay, mEglSurface);
466    ASSERT_EQ(EGL_SUCCESS, eglGetError());
467
468    // Lock
469    ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
470
471    // Make sure we actually got the SRGB buffer on the consumer side
472    ASSERT_NO_FATAL_FAILURE(
473        checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_SRGB));
474
475    // Verify that the stored value is the same, accounting for RGB/SRGB
476    for (int c = 0; c < PIXEL_SIZE; ++c) {
477        // The alpha value should be equivalent before linear->SRGB
478        float rgbAsSRGB = (c == 3) ? values[c] / 255.0f :
479                linearToSRGB(values[c] / 255.0f);
480        int expectedValue = rgbAsSRGB * 255.0f + 0.5f;
481        int actualValue = mLockedBuffer.data[middleOffset + c];
482        ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
483    }
484
485    // mLockedBuffer is unlocked in TearDown so we can copy data from it to
486    // the debug surface if necessary
487}
488
489} // namespace android
490