/*
* 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
// Ignore for this file because it flags every instance of
// ASSERT_EQ(GL_NO_ERROR, glGetError());
#pragma clang diagnostic ignored "-Wsign-compare"
#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, android_dataspace dataSpace) {
ASSERT_EQ(mLockedBuffer.format, format);
ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
ASSERT_EQ(mLockedBuffer.dataSpace, dataSpace);
}
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, static_cast<uint32_t>(outBuffer.width));
ASSERT_EQ(mLockedBuffer.height, static_cast<uint32_t>(outBuffer.height));
ASSERT_EQ(mLockedBuffer.stride, static_cast<uint32_t>(outBuffer.stride));
if (mLockedBuffer.format == outBuffer.format) {
memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
} else {
ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_RGBA_8888);
ASSERT_EQ(mLockedBuffer.dataSpace, HAL_DATASPACE_SRGB);
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, HAL_DATASPACE_UNKNOWN));
// 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
}
// XXX: Disabled since we don't currently expect this to work
TEST_F(SRGBTest, DISABLED_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, HAL_DATASPACE_UNKNOWN));
// 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_RGBA_8888, HAL_DATASPACE_SRGB));
// 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