Merge "libgui: Add a test for SRGB surfaces" (9ef78fe2) · Commits · e / os / android_frameworks_native

include/ui/PixelFormat.h

+9 −7

Original line number	Diff line number	Diff line
		@@ -63,6 +63,8 @@ enum {
		PIXEL_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, // 4x8-bit BGRA
		PIXEL_FORMAT_RGBA_5551 = 6, // 16-bit ARGB
		PIXEL_FORMAT_RGBA_4444 = 7, // 16-bit ARGB
		PIXEL_FORMAT_sRGB_A_8888 = HAL_PIXEL_FORMAT_sRGB_A_8888, // 4x8-bit sRGB + A
		PIXEL_FORMAT_sRGB_X_8888 = HAL_PIXEL_FORMAT_sRGB_X_8888, // 4x8-bit sRGB, no A
		};

		typedef int32_t PixelFormat;

libs/gui/tests/SRGB_test.cpp

+222 −93

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@ protected:
		enum {
		DISPLAY_WIDTH = 512,
		DISPLAY_HEIGHT = 512,
		PIXEL_SIZE = 4, // bytes
		PIXEL_SIZE = 4, // bytes or components
		DISPLAY_SIZE = DISPLAY_WIDTH * DISPLAY_HEIGHT * PIXEL_SIZE,
		ALPHA_VALUE = 223, // should be in [0, 255]
		TOLERANCE = 1,
		@@ -68,13 +68,13 @@ protected:
		}

		virtual void SetUp() {
		sp<BufferQueue> bufferQueue = new BufferQueue();
		ASSERT_EQ(NO_ERROR, bufferQueue->setDefaultBufferSize(
		mBufferQueue = new BufferQueue();
		ASSERT_EQ(NO_ERROR, mBufferQueue->setDefaultBufferSize(
		DISPLAY_WIDTH, DISPLAY_HEIGHT));
		mCpuConsumer = new CpuConsumer(bufferQueue, 1);
		mCpuConsumer = new CpuConsumer(mBufferQueue, 1);
		String8 name("CpuConsumer_for_SRGBTest");
		mCpuConsumer->setName(name);
		mInputSurface = new Surface(bufferQueue);
		mInputSurface = new Surface(mBufferQueue);

		ASSERT_NO_FATAL_FAILURE(createEGLSurface(mInputSurface.get()));
		ASSERT_NO_FATAL_FAILURE(createDebugSurface());
		@@ -82,7 +82,7 @@ protected:

		virtual void TearDown() {
		ASSERT_NO_FATAL_FAILURE(copyToDebugSurface());
		mCpuConsumer->unlockBuffer(mLockedBuffer);
		ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
		}

		static float linearToSRGB(float l) {
		@@ -93,6 +93,19 @@ protected:
		}
		}

		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];

		@@ -122,12 +135,93 @@ protected:
		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<BufferQueue> mBufferQueue;
		sp<Surface> mInputSurface;
		sp<CpuConsumer> mCpuConsumer;
		CpuConsumer::LockedBuffer mLockedBuffer;
		@@ -206,14 +300,13 @@ private:
		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;
		int rowOffset = y * outBuffer.stride; // pixels
		for (int x = 0; x < outBuffer.width; ++x) {
		int colOffset = rowOffset + x;
		for (int c = 0; c < 4; ++c) {
		int offset = colOffset * PIXEL_SIZE + c;
		uint8_t* bytePointer =
		reinterpret_cast<uint8_t*>(outBuffer.bits);
		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;
		}
		}
		@@ -230,10 +323,33 @@ private:
		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);
		ASSERT_EQ(mLockedBuffer.format, outBuffer.format);

		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));
		@@ -244,100 +360,113 @@ private:
		const char SRGBTest::SHOW_DEBUG_STRING[] = "DEBUG_OUTPUT_SECONDS";

		TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
		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";
		ASSERT_NO_FATAL_FAILURE(initShaders());

		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";
		// The RGB texture is displayed in the top half
		ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, DISPLAY_HEIGHT / 2,
		DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));

		GLuint program;
		{
		SCOPED_TRACE("Creating shader program");
		ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(
		vertexSource, fragmentSource, &program));
		// 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);
		}

		GLint positionHandle = glGetAttribLocation(program, "vPosition");
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		ASSERT_NE(-1, positionHandle);
		// mLockedBuffer is unlocked in TearDown so we can copy data from it to
		// the debug surface if necessary
		}

		GLint samplerHandle = glGetUniformLocation(program, "texSampler");
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		ASSERT_NE(-1, samplerHandle);
		TEST_F(SRGBTest, RenderToSRGBSurface) {
		ASSERT_NO_FATAL_FAILURE(initShaders());

		static const GLfloat vertices[] = {
		-1.0f, 1.0f,
		-1.0f, -1.0f,
		1.0f, -1.0f,
		1.0f, 1.0f,
		};
		// By default, the first buffer we write into will be RGB

		glVertexAttribPointer(positionHandle, 2, GL_FLOAT, GL_FALSE, 0, vertices);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		glEnableVertexAttribArray(positionHandle);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		// 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());

		glUseProgram(program);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		glUniform1i(samplerHandle, 0);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		// Lock
		ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
		ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));

		GLuint textureHandle;
		glGenTextures(1, &textureHandle);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		glBindTexture(GL_TEXTURE_2D, textureHandle);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		// 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];
		}

		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());
		// Unlock
		ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));

		// The RGB texture is displayed in the top half
		ASSERT_NO_FATAL_FAILURE(fillTexture(false));
		glViewport(0, DISPLAY_HEIGHT / 2, DISPLAY_WIDTH, DISPLAY_HEIGHT / 2);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		// Switch to SRGB window surface
		#define EGL_GL_COLORSPACE_KHR EGL_VG_COLORSPACE
		#define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB

		// The SRGB texture is displayed in the bottom half
		ASSERT_NO_FATAL_FAILURE(fillTexture(true));
		glViewport(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT / 2);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
		ASSERT_EQ(GL_NO_ERROR, glGetError());
		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));
		ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_RGBA_8888);
		ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
		ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
		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 < 4; ++c) {
		ASSERT_PRED2(withinTolerance,
		static_cast<int>(mLockedBuffer.data[midRGBOffset]),
		static_cast<int>(mLockedBuffer.data[midSRGBOffset]));

		// 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
		}

libs/ui/PixelFormat.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,8 @@ ssize_t bytesPerPixel(PixelFormat format) {
		case PIXEL_FORMAT_RGBA_8888:
		case PIXEL_FORMAT_RGBX_8888:
		case PIXEL_FORMAT_BGRA_8888:
		case PIXEL_FORMAT_sRGB_A_8888:
		case PIXEL_FORMAT_sRGB_X_8888:
		return 4;
		case PIXEL_FORMAT_RGB_888:
		return 3;