split libandroid.so (89ed4c8c) · Commits · e / os / platform_frameworks_native

cmds/surfacereplayer/replayer/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,7 @@ LOCAL_SHARED_LIBRARIES := \
		libutils \
		libprotobuf-cpp-lite \
		libbase \
		libnativewindow \

		LOCAL_STATIC_LIBRARIES := \
		libtrace_proto \

libs/gui/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -107,6 +107,7 @@ cc_library_shared {
		"libGLESv2",
		"libui",
		"libutils",
		"libnativewindow",
		"liblog",
		],

libs/gui/tests/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -15,7 +15,6 @@ cc_test {
		"IGraphicBufferProducer_test.cpp",
		"MultiTextureConsumer_test.cpp",
		"Sensor_test.cpp",
		"SRGB_test.cpp",
		"StreamSplitter_test.cpp",
		"SurfaceTextureClient_test.cpp",
		"SurfaceTextureFBO_test.cpp",
		@@ -37,5 +36,6 @@ cc_test {
		"libgui",
		"libui",
		"libutils",
		"libnativewindow"
		],
		}

libs/gui/tests/SRGB_test.cpp

deleted100644 → 0

+0 −486

Original line number	Diff line number	Diff line
		/*
		* 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
		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

libs/nativewindow/AHardwareBuffer.cpp

0 → 100644

+369 −0

File added.

Preview size limit exceeded, changes collapsed.