libs/gui/tests/SRGB_test.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "SRGB_test"
 //#define LOG_NDEBUG 0

 #include "GLTest.h"

 #include <math.h>

 #include <gui/CpuConsumer.h>
 #include <gui/Surface.h>
 #include <gui/SurfaceComposerClient.h>

 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include <GLES3/gl3.h>

 #include <android/native_window.h>

 #include <gtest/gtest.h>

 namespace android {

 class SRGBTest : public ::testing::Test {
 protected:
     // Class constants
     enum {
         DISPLAY_WIDTH = 512,
         DISPLAY_HEIGHT = 512,
         PIXEL_SIZE = 4, // bytes or components
         DISPLAY_SIZE = DISPLAY_WIDTH * DISPLAY_HEIGHT * PIXEL_SIZE,
         ALPHA_VALUE = 223, // should be in [0, 255]
         TOLERANCE = 1,
     };
     static const char SHOW_DEBUG_STRING[];

     SRGBTest() :
             mInputSurface(), mCpuConsumer(), mLockedBuffer(),
             mEglDisplay(EGL_NO_DISPLAY), mEglConfig(),
             mEglContext(EGL_NO_CONTEXT), mEglSurface(EGL_NO_SURFACE),
             mComposerClient(), mSurfaceControl(), mOutputSurface() {
     }

     virtual ~SRGBTest() {
         if (mEglDisplay != EGL_NO_DISPLAY) {
             if (mEglSurface != EGL_NO_SURFACE) {
                 eglDestroySurface(mEglDisplay, mEglSurface);
             }
             if (mEglContext != EGL_NO_CONTEXT) {
                 eglDestroyContext(mEglDisplay, mEglContext);
             }
             eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
                     EGL_NO_CONTEXT);
             eglTerminate(mEglDisplay);
         }
     }

     virtual void SetUp() {
         sp<IGraphicBufferProducer> producer;
         sp<IGraphicBufferConsumer> consumer;
         BufferQueue::createBufferQueue(&producer, &consumer);
         ASSERT_EQ(NO_ERROR, consumer->setDefaultBufferSize(
                 DISPLAY_WIDTH, DISPLAY_HEIGHT));
         mCpuConsumer = new CpuConsumer(consumer, 1);
         String8 name("CpuConsumer_for_SRGBTest");
         mCpuConsumer->setName(name);
         mInputSurface = new Surface(producer);

         ASSERT_NO_FATAL_FAILURE(createEGLSurface(mInputSurface.get()));
         ASSERT_NO_FATAL_FAILURE(createDebugSurface());
     }

     virtual void TearDown() {
         ASSERT_NO_FATAL_FAILURE(copyToDebugSurface());
         ASSERT_TRUE(mLockedBuffer.data != NULL);
         ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
     }

     static float linearToSRGB(float l) {
         if (l <= 0.0031308f) {
             return l * 12.92f;
         } else {
             return 1.055f * pow(l, (1 / 2.4f)) - 0.055f;
         }
     }

     static float srgbToLinear(float s) {
         if (s <= 0.04045) {
             return s / 12.92f;
         } else {
             return pow(((s + 0.055f) / 1.055f), 2.4f);
         }
     }

     static uint8_t srgbToLinear(uint8_t u) {
         float f = u / 255.0f;
         return static_cast<uint8_t>(srgbToLinear(f) * 255.0f + 0.5f);
     }

     void fillTexture(bool writeAsSRGB) {
         uint8_t* textureData = new uint8_t[DISPLAY_SIZE];

         for (int y = 0; y < DISPLAY_HEIGHT; ++y) {
             for (int x = 0; x < DISPLAY_WIDTH; ++x) {
                 float realValue = static_cast<float>(x) / (DISPLAY_WIDTH - 1);
                 realValue *= ALPHA_VALUE / 255.0f; // Premultiply by alpha
                 if (writeAsSRGB) {
                     realValue = linearToSRGB(realValue);
                 }

                 int offset = (y * DISPLAY_WIDTH + x) * PIXEL_SIZE;
                 for (int c = 0; c < 3; ++c) {
                     uint8_t intValue = static_cast<uint8_t>(
                             realValue * 255.0f + 0.5f);
                     textureData[offset + c] = intValue;
                 }
                 textureData[offset + 3] = ALPHA_VALUE;
             }
         }

         glTexImage2D(GL_TEXTURE_2D, 0, writeAsSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA8,
                 DISPLAY_WIDTH, DISPLAY_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 textureData);
         ASSERT_EQ(GL_NO_ERROR, glGetError());

         delete[] textureData;
     }

     void initShaders() {
         static const char vertexSource[] =
             "attribute vec4 vPosition;\n"
             "varying vec2 texCoords;\n"
             "void main() {\n"
             "  texCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
             "  gl_Position = vPosition;\n"
             "}\n";

         static const char fragmentSource[] =
             "precision mediump float;\n"
             "uniform sampler2D texSampler;\n"
             "varying vec2 texCoords;\n"
             "void main() {\n"
             "  gl_FragColor = texture2D(texSampler, texCoords);\n"
             "}\n";

         GLuint program;
         {
             SCOPED_TRACE("Creating shader program");
             ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(
                     vertexSource, fragmentSource, &program));
         }

         GLint positionHandle = glGetAttribLocation(program, "vPosition");
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         ASSERT_NE(-1, positionHandle);

         GLint samplerHandle = glGetUniformLocation(program, "texSampler");
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         ASSERT_NE(-1, samplerHandle);

         static const GLfloat vertices[] = {
             -1.0f, 1.0f,
             -1.0f, -1.0f,
             1.0f, -1.0f,
             1.0f, 1.0f,
         };

         glVertexAttribPointer(positionHandle, 2, GL_FLOAT, GL_FALSE, 0, vertices);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glEnableVertexAttribArray(positionHandle);
         ASSERT_EQ(GL_NO_ERROR, glGetError());

         glUseProgram(program);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glUniform1i(samplerHandle, 0);
         ASSERT_EQ(GL_NO_ERROR, glGetError());

         GLuint textureHandle;
         glGenTextures(1, &textureHandle);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glBindTexture(GL_TEXTURE_2D, textureHandle);
         ASSERT_EQ(GL_NO_ERROR, glGetError());

         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
     }

     void drawTexture(bool asSRGB, GLint x, GLint y, GLsizei width,
             GLsizei height) {
         ASSERT_NO_FATAL_FAILURE(fillTexture(asSRGB));
         glViewport(x, y, width, height);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
         ASSERT_EQ(GL_NO_ERROR, glGetError());
     }

     void checkLockedBuffer(PixelFormat format) {
         ASSERT_EQ(mLockedBuffer.format, format);
         ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
         ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
     }

     static bool withinTolerance(int a, int b) {
         int diff = a - b;
         return diff >= 0 ? diff <= TOLERANCE : -diff <= TOLERANCE;
     }

     // Primary producer and consumer
     sp<Surface> mInputSurface;
     sp<CpuConsumer> mCpuConsumer;
     CpuConsumer::LockedBuffer mLockedBuffer;

     EGLDisplay mEglDisplay;
     EGLConfig mEglConfig;
     EGLContext mEglContext;
     EGLSurface mEglSurface;

     // Auxiliary display output
     sp<SurfaceComposerClient> mComposerClient;
     sp<SurfaceControl> mSurfaceControl;
     sp<Surface> mOutputSurface;

 private:
     void createEGLSurface(Surface* inputSurface) {
         mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
         ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);

         EXPECT_TRUE(eglInitialize(mEglDisplay, NULL, NULL));
         ASSERT_EQ(EGL_SUCCESS, eglGetError());

         static const EGLint configAttribs[] = {
             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
             EGL_RED_SIZE, 8,
             EGL_GREEN_SIZE, 8,
             EGL_BLUE_SIZE, 8,
             EGL_ALPHA_SIZE, 8,
             EGL_NONE };

         EGLint numConfigs = 0;
         EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &mEglConfig, 1,
                 &numConfigs));
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
         ASSERT_GT(numConfigs, 0);

         static const EGLint contextAttribs[] = {
             EGL_CONTEXT_CLIENT_VERSION, 3,
             EGL_NONE } ;

         mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT,
                 contextAttribs);
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
         ASSERT_NE(EGL_NO_CONTEXT, mEglContext);

         mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
                 inputSurface, NULL);
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
         ASSERT_NE(EGL_NO_SURFACE, mEglSurface);

         EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
                 mEglContext));
         ASSERT_EQ(EGL_SUCCESS, eglGetError());
     }

     void createDebugSurface() {
         if (getenv(SHOW_DEBUG_STRING) == NULL) return;

         mComposerClient = new SurfaceComposerClient;
         ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());

         mSurfaceControl = mComposerClient->createSurface(
                 String8("SRGBTest Surface"), DISPLAY_WIDTH, DISPLAY_HEIGHT,
                 PIXEL_FORMAT_RGBA_8888);

         ASSERT_TRUE(mSurfaceControl != NULL);
         ASSERT_TRUE(mSurfaceControl->isValid());

         SurfaceComposerClient::openGlobalTransaction();
         ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
         ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
         SurfaceComposerClient::closeGlobalTransaction();

         ANativeWindow_Buffer outBuffer;
         ARect inOutDirtyBounds;
         mOutputSurface = mSurfaceControl->getSurface();
         mOutputSurface->lock(&outBuffer, &inOutDirtyBounds);
         uint8_t* bytePointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
         for (int y = 0; y < outBuffer.height; ++y) {
             int rowOffset = y * outBuffer.stride; // pixels
             for (int x = 0; x < outBuffer.width; ++x) {
                 int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
                 for (int c = 0; c < PIXEL_SIZE; ++c) {
                     int offset = colOffset + c;
                     bytePointer[offset] = ((c + 1) * 56) - 1;
                 }
             }
         }
         mOutputSurface->unlockAndPost();
     }

     void copyToDebugSurface() {
         if (!mOutputSurface.get()) return;

         size_t bufferSize = mLockedBuffer.height * mLockedBuffer.stride *
                 PIXEL_SIZE;

         ANativeWindow_Buffer outBuffer;
         ARect outBufferBounds;
         mOutputSurface->lock(&outBuffer, &outBufferBounds);
         ASSERT_EQ(mLockedBuffer.width, outBuffer.width);
         ASSERT_EQ(mLockedBuffer.height, outBuffer.height);
         ASSERT_EQ(mLockedBuffer.stride, outBuffer.stride);

         if (mLockedBuffer.format == outBuffer.format) {
             memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
         } else {
             ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_sRGB_A_8888);
             ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
             uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
             for (int y = 0; y < outBuffer.height; ++y) {
                 int rowOffset = y * outBuffer.stride; // pixels
                 for (int x = 0; x < outBuffer.width; ++x) {
                     int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes

                     // RGB are converted
                     for (int c = 0; c < (PIXEL_SIZE - 1); ++c) {
                         outPointer[colOffset + c] = srgbToLinear(
                                 mLockedBuffer.data[colOffset + c]);
                     }

                     // Alpha isn't converted
                     outPointer[colOffset + 3] =
                             mLockedBuffer.data[colOffset + 3];
                 }
             }
         }
         mOutputSurface->unlockAndPost();

         int sleepSeconds = atoi(getenv(SHOW_DEBUG_STRING));
         sleep(sleepSeconds);
     }
 };

 const char SRGBTest::SHOW_DEBUG_STRING[] = "DEBUG_OUTPUT_SECONDS";

 TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
     ASSERT_NO_FATAL_FAILURE(initShaders());

     // The RGB texture is displayed in the top half
     ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, DISPLAY_HEIGHT / 2,
             DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));

     // The SRGB texture is displayed in the bottom half
     ASSERT_NO_FATAL_FAILURE(drawTexture(true, 0, 0,
             DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));

     eglSwapBuffers(mEglDisplay, mEglSurface);
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     // Lock
     ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
     ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));

     // Compare a pixel in the middle of each texture
     int midSRGBOffset = (DISPLAY_HEIGHT / 4) * mLockedBuffer.stride *
             PIXEL_SIZE;
     int midRGBOffset = midSRGBOffset * 3;
     midRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
     midSRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
     for (int c = 0; c < PIXEL_SIZE; ++c) {
         int expectedValue = mLockedBuffer.data[midRGBOffset + c];
         int actualValue = mLockedBuffer.data[midSRGBOffset + c];
         ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
     }

     // mLockedBuffer is unlocked in TearDown so we can copy data from it to
     // the debug surface if necessary
 }

 TEST_F(SRGBTest, RenderToSRGBSurface) {
     ASSERT_NO_FATAL_FAILURE(initShaders());

     // By default, the first buffer we write into will be RGB

     // Render an RGB texture across the whole surface
     ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
             DISPLAY_WIDTH, DISPLAY_HEIGHT));
     eglSwapBuffers(mEglDisplay, mEglSurface);
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     // Lock
     ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
     ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));

     // Save the values of the middle pixel for later comparison against SRGB
     uint8_t values[PIXEL_SIZE] = {};
     int middleOffset = (DISPLAY_HEIGHT / 2) * mLockedBuffer.stride *
             PIXEL_SIZE;
     middleOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
     for (int c = 0; c < PIXEL_SIZE; ++c) {
         values[c] = mLockedBuffer.data[middleOffset + c];
     }

     // Unlock
     ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));

     // Switch to SRGB window surface
 #define EGL_GL_COLORSPACE_KHR      EGL_VG_COLORSPACE
 #define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB

     static const int srgbAttribs[] = {
         EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR,
         EGL_NONE,
     };

     EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
             mEglContext));
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     EXPECT_TRUE(eglDestroySurface(mEglDisplay, mEglSurface));
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
             mInputSurface.get(), srgbAttribs);
     ASSERT_EQ(EGL_SUCCESS, eglGetError());
     ASSERT_NE(EGL_NO_SURFACE, mEglSurface);

     EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
             mEglContext));
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     // Render the texture again
     ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
             DISPLAY_WIDTH, DISPLAY_HEIGHT));
     eglSwapBuffers(mEglDisplay, mEglSurface);
     ASSERT_EQ(EGL_SUCCESS, eglGetError());

     // Lock
     ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));

     // Make sure we actually got the SRGB buffer on the consumer side
     ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_sRGB_A_8888));

     // Verify that the stored value is the same, accounting for RGB/SRGB
     for (int c = 0; c < PIXEL_SIZE; ++c) {
         // The alpha value should be equivalent before linear->SRGB
         float rgbAsSRGB = (c == 3) ? values[c] / 255.0f :
                 linearToSRGB(values[c] / 255.0f);
         int expectedValue = rgbAsSRGB * 255.0f + 0.5f;
         int actualValue = mLockedBuffer.data[middleOffset + c];
         ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
     }

     // mLockedBuffer is unlocked in TearDown so we can copy data from it to
     // the debug surface if necessary
 }

 } // namespace android
	/*
	* Copyright 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "SRGB_test"
	//#define LOG_NDEBUG 0

	#include "GLTest.h"

	#include <math.h>

	#include <gui/CpuConsumer.h>
	#include <gui/Surface.h>
	#include <gui/SurfaceComposerClient.h>

	#include <EGL/egl.h>
	#include <EGL/eglext.h>
	#include <GLES3/gl3.h>

	#include <android/native_window.h>

	#include <gtest/gtest.h>

	namespace android {

	class SRGBTest : public ::testing::Test {
	protected:
	// Class constants
	enum {
	DISPLAY_WIDTH = 512,
	DISPLAY_HEIGHT = 512,
	PIXEL_SIZE = 4, // bytes or components
	DISPLAY_SIZE = DISPLAY_WIDTH * DISPLAY_HEIGHT * PIXEL_SIZE,
	ALPHA_VALUE = 223, // should be in [0, 255]
	TOLERANCE = 1,
	};
	static const char SHOW_DEBUG_STRING[];

	SRGBTest() :
	mInputSurface(), mCpuConsumer(), mLockedBuffer(),
	mEglDisplay(EGL_NO_DISPLAY), mEglConfig(),
	mEglContext(EGL_NO_CONTEXT), mEglSurface(EGL_NO_SURFACE),
	mComposerClient(), mSurfaceControl(), mOutputSurface() {
	}

	virtual ~SRGBTest() {
	if (mEglDisplay != EGL_NO_DISPLAY) {
	if (mEglSurface != EGL_NO_SURFACE) {
	eglDestroySurface(mEglDisplay, mEglSurface);
	}
	if (mEglContext != EGL_NO_CONTEXT) {
	eglDestroyContext(mEglDisplay, mEglContext);
	}
	eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
	EGL_NO_CONTEXT);
	eglTerminate(mEglDisplay);
	}
	}

	virtual void SetUp() {
	sp<IGraphicBufferProducer> producer;
	sp<IGraphicBufferConsumer> consumer;
	BufferQueue::createBufferQueue(&producer, &consumer);
	ASSERT_EQ(NO_ERROR, consumer->setDefaultBufferSize(
	DISPLAY_WIDTH, DISPLAY_HEIGHT));
	mCpuConsumer = new CpuConsumer(consumer, 1);
	String8 name("CpuConsumer_for_SRGBTest");
	mCpuConsumer->setName(name);
	mInputSurface = new Surface(producer);

	ASSERT_NO_FATAL_FAILURE(createEGLSurface(mInputSurface.get()));
	ASSERT_NO_FATAL_FAILURE(createDebugSurface());
	}

	virtual void TearDown() {
	ASSERT_NO_FATAL_FAILURE(copyToDebugSurface());
	ASSERT_TRUE(mLockedBuffer.data != NULL);
	ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
	}

	static float linearToSRGB(float l) {
	if (l <= 0.0031308f) {
	return l * 12.92f;
	} else {
	return 1.055f * pow(l, (1 / 2.4f)) - 0.055f;
	}
	}

	static float srgbToLinear(float s) {
	if (s <= 0.04045) {
	return s / 12.92f;
	} else {
	return pow(((s + 0.055f) / 1.055f), 2.4f);
	}
	}

	static uint8_t srgbToLinear(uint8_t u) {
	float f = u / 255.0f;
	return static_cast<uint8_t>(srgbToLinear(f) * 255.0f + 0.5f);
	}

	void fillTexture(bool writeAsSRGB) {
	uint8_t* textureData = new uint8_t[DISPLAY_SIZE];

	for (int y = 0; y < DISPLAY_HEIGHT; ++y) {
	for (int x = 0; x < DISPLAY_WIDTH; ++x) {
	float realValue = static_cast<float>(x) / (DISPLAY_WIDTH - 1);
	realValue *= ALPHA_VALUE / 255.0f; // Premultiply by alpha
	if (writeAsSRGB) {
	realValue = linearToSRGB(realValue);
	}

	int offset = (y * DISPLAY_WIDTH + x) * PIXEL_SIZE;
	for (int c = 0; c < 3; ++c) {
	uint8_t intValue = static_cast<uint8_t>(
	realValue * 255.0f + 0.5f);
	textureData[offset + c] = intValue;
	}
	textureData[offset + 3] = ALPHA_VALUE;
	}
	}

	glTexImage2D(GL_TEXTURE_2D, 0, writeAsSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA8,
	DISPLAY_WIDTH, DISPLAY_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE,
	textureData);
	ASSERT_EQ(GL_NO_ERROR, glGetError());

	delete[] textureData;
	}

	void initShaders() {
	static const char vertexSource[] =
	"attribute vec4 vPosition;\n"
	"varying vec2 texCoords;\n"
	"void main() {\n"
	" texCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
	" gl_Position = vPosition;\n"
	"}\n";

	static const char fragmentSource[] =
	"precision mediump float;\n"
	"uniform sampler2D texSampler;\n"
	"varying vec2 texCoords;\n"
	"void main() {\n"
	" gl_FragColor = texture2D(texSampler, texCoords);\n"
	"}\n";

	GLuint program;
	{
	SCOPED_TRACE("Creating shader program");
	ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(
	vertexSource, fragmentSource, &program));
	}

	GLint positionHandle = glGetAttribLocation(program, "vPosition");
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	ASSERT_NE(-1, positionHandle);

	GLint samplerHandle = glGetUniformLocation(program, "texSampler");
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	ASSERT_NE(-1, samplerHandle);

	static const GLfloat vertices[] = {
	-1.0f, 1.0f,
	-1.0f, -1.0f,
	1.0f, -1.0f,
	1.0f, 1.0f,
	};

	glVertexAttribPointer(positionHandle, 2, GL_FLOAT, GL_FALSE, 0, vertices);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glEnableVertexAttribArray(positionHandle);
	ASSERT_EQ(GL_NO_ERROR, glGetError());

	glUseProgram(program);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glUniform1i(samplerHandle, 0);
	ASSERT_EQ(GL_NO_ERROR, glGetError());

	GLuint textureHandle;
	glGenTextures(1, &textureHandle);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glBindTexture(GL_TEXTURE_2D, textureHandle);
	ASSERT_EQ(GL_NO_ERROR, glGetError());

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	}

	void drawTexture(bool asSRGB, GLint x, GLint y, GLsizei width,
	GLsizei height) {
	ASSERT_NO_FATAL_FAILURE(fillTexture(asSRGB));
	glViewport(x, y, width, height);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
	ASSERT_EQ(GL_NO_ERROR, glGetError());
	}

	void checkLockedBuffer(PixelFormat format) {
	ASSERT_EQ(mLockedBuffer.format, format);
	ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
	ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
	}

	static bool withinTolerance(int a, int b) {
	int diff = a - b;
	return diff >= 0 ? diff <= TOLERANCE : -diff <= TOLERANCE;
	}

	// Primary producer and consumer
	sp<Surface> mInputSurface;
	sp<CpuConsumer> mCpuConsumer;
	CpuConsumer::LockedBuffer mLockedBuffer;

	EGLDisplay mEglDisplay;
	EGLConfig mEglConfig;
	EGLContext mEglContext;
	EGLSurface mEglSurface;

	// Auxiliary display output
	sp<SurfaceComposerClient> mComposerClient;
	sp<SurfaceControl> mSurfaceControl;
	sp<Surface> mOutputSurface;

	private:
	void createEGLSurface(Surface* inputSurface) {
	mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);

	EXPECT_TRUE(eglInitialize(mEglDisplay, NULL, NULL));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	static const EGLint configAttribs[] = {
	EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
	EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
	EGL_RED_SIZE, 8,
	EGL_GREEN_SIZE, 8,
	EGL_BLUE_SIZE, 8,
	EGL_ALPHA_SIZE, 8,
	EGL_NONE };

	EGLint numConfigs = 0;
	EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &mEglConfig, 1,
	&numConfigs));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	ASSERT_GT(numConfigs, 0);

	static const EGLint contextAttribs[] = {
	EGL_CONTEXT_CLIENT_VERSION, 3,
	EGL_NONE } ;

	mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT,
	contextAttribs);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	ASSERT_NE(EGL_NO_CONTEXT, mEglContext);

	mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
	inputSurface, NULL);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	ASSERT_NE(EGL_NO_SURFACE, mEglSurface);

	EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
	mEglContext));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	}

	void createDebugSurface() {
	if (getenv(SHOW_DEBUG_STRING) == NULL) return;

	mComposerClient = new SurfaceComposerClient;
	ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());

	mSurfaceControl = mComposerClient->createSurface(
	String8("SRGBTest Surface"), DISPLAY_WIDTH, DISPLAY_HEIGHT,
	PIXEL_FORMAT_RGBA_8888);

	ASSERT_TRUE(mSurfaceControl != NULL);
	ASSERT_TRUE(mSurfaceControl->isValid());

	SurfaceComposerClient::openGlobalTransaction();
	ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
	ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
	SurfaceComposerClient::closeGlobalTransaction();

	ANativeWindow_Buffer outBuffer;
	ARect inOutDirtyBounds;
	mOutputSurface = mSurfaceControl->getSurface();
	mOutputSurface->lock(&outBuffer, &inOutDirtyBounds);
	uint8_t* bytePointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
	for (int y = 0; y < outBuffer.height; ++y) {
	int rowOffset = y * outBuffer.stride; // pixels
	for (int x = 0; x < outBuffer.width; ++x) {
	int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
	for (int c = 0; c < PIXEL_SIZE; ++c) {
	int offset = colOffset + c;
	bytePointer[offset] = ((c + 1) * 56) - 1;
	}
	}
	}
	mOutputSurface->unlockAndPost();
	}

	void copyToDebugSurface() {
	if (!mOutputSurface.get()) return;

	size_t bufferSize = mLockedBuffer.height * mLockedBuffer.stride *
	PIXEL_SIZE;

	ANativeWindow_Buffer outBuffer;
	ARect outBufferBounds;
	mOutputSurface->lock(&outBuffer, &outBufferBounds);
	ASSERT_EQ(mLockedBuffer.width, outBuffer.width);
	ASSERT_EQ(mLockedBuffer.height, outBuffer.height);
	ASSERT_EQ(mLockedBuffer.stride, outBuffer.stride);

	if (mLockedBuffer.format == outBuffer.format) {
	memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
	} else {
	ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_sRGB_A_8888);
	ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
	uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
	for (int y = 0; y < outBuffer.height; ++y) {
	int rowOffset = y * outBuffer.stride; // pixels
	for (int x = 0; x < outBuffer.width; ++x) {
	int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes

	// RGB are converted
	for (int c = 0; c < (PIXEL_SIZE - 1); ++c) {
	outPointer[colOffset + c] = srgbToLinear(
	mLockedBuffer.data[colOffset + c]);
	}

	// Alpha isn't converted
	outPointer[colOffset + 3] =
	mLockedBuffer.data[colOffset + 3];
	}
	}
	}
	mOutputSurface->unlockAndPost();

	int sleepSeconds = atoi(getenv(SHOW_DEBUG_STRING));
	sleep(sleepSeconds);
	}
	};

	const char SRGBTest::SHOW_DEBUG_STRING[] = "DEBUG_OUTPUT_SECONDS";

	TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
	ASSERT_NO_FATAL_FAILURE(initShaders());

	// The RGB texture is displayed in the top half
	ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, DISPLAY_HEIGHT / 2,
	DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));

	// The SRGB texture is displayed in the bottom half
	ASSERT_NO_FATAL_FAILURE(drawTexture(true, 0, 0,
	DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));

	eglSwapBuffers(mEglDisplay, mEglSurface);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	// Lock
	ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
	ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));

	// Compare a pixel in the middle of each texture
	int midSRGBOffset = (DISPLAY_HEIGHT / 4) * mLockedBuffer.stride *
	PIXEL_SIZE;
	int midRGBOffset = midSRGBOffset * 3;
	midRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
	midSRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
	for (int c = 0; c < PIXEL_SIZE; ++c) {
	int expectedValue = mLockedBuffer.data[midRGBOffset + c];
	int actualValue = mLockedBuffer.data[midSRGBOffset + c];
	ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
	}

	// mLockedBuffer is unlocked in TearDown so we can copy data from it to
	// the debug surface if necessary
	}

	TEST_F(SRGBTest, RenderToSRGBSurface) {
	ASSERT_NO_FATAL_FAILURE(initShaders());

	// By default, the first buffer we write into will be RGB

	// Render an RGB texture across the whole surface
	ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
	DISPLAY_WIDTH, DISPLAY_HEIGHT));
	eglSwapBuffers(mEglDisplay, mEglSurface);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	// Lock
	ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
	ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));

	// Save the values of the middle pixel for later comparison against SRGB
	uint8_t values[PIXEL_SIZE] = {};
	int middleOffset = (DISPLAY_HEIGHT / 2) * mLockedBuffer.stride *
	PIXEL_SIZE;
	middleOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
	for (int c = 0; c < PIXEL_SIZE; ++c) {
	values[c] = mLockedBuffer.data[middleOffset + c];
	}

	// Unlock
	ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));

	// Switch to SRGB window surface
	#define EGL_GL_COLORSPACE_KHR EGL_VG_COLORSPACE
	#define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB

	static const int srgbAttribs[] = {
	EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR,
	EGL_NONE,
	};

	EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
	mEglContext));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	EXPECT_TRUE(eglDestroySurface(mEglDisplay, mEglSurface));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
	mInputSurface.get(), srgbAttribs);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());
	ASSERT_NE(EGL_NO_SURFACE, mEglSurface);

	EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
	mEglContext));
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	// Render the texture again
	ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
	DISPLAY_WIDTH, DISPLAY_HEIGHT));
	eglSwapBuffers(mEglDisplay, mEglSurface);
	ASSERT_EQ(EGL_SUCCESS, eglGetError());

	// Lock
	ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));

	// Make sure we actually got the SRGB buffer on the consumer side
	ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_sRGB_A_8888));

	// Verify that the stored value is the same, accounting for RGB/SRGB
	for (int c = 0; c < PIXEL_SIZE; ++c) {
	// The alpha value should be equivalent before linear->SRGB
	float rgbAsSRGB = (c == 3) ? values[c] / 255.0f :
	linearToSRGB(values[c] / 255.0f);
	int expectedValue = rgbAsSRGB * 255.0f + 0.5f;
	int actualValue = mLockedBuffer.data[middleOffset + c];
	ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
	}

	// mLockedBuffer is unlocked in TearDown so we can copy data from it to
	// the debug surface if necessary
	}

	} // namespace android