am 081bc5c4: fix [2793164] Spam 2x/second with TOT master in SurfaceFlinger (256fc043) · Commits · e / os / android_frameworks_base

libs/surfaceflinger/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -6,6 +6,7 @@ LOCAL_SRC_FILES:= \
		DisplayHardware/DisplayHardware.cpp \
		DisplayHardware/DisplayHardwareBase.cpp \
		BlurFilter.cpp.arm \
		GLExtensions.cpp \
		Layer.cpp \
		LayerBase.cpp \
		LayerBuffer.cpp \

libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp

+59 −74

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@
		#include <hardware/overlay.h>
		#include <hardware/gralloc.h>

		#include "GLExtensions.h"

		using namespace android;


		@@ -73,7 +75,8 @@ void checkEGLErrors(const char* token)
		DisplayHardware::DisplayHardware(
		const sp<SurfaceFlinger>& flinger,
		uint32_t dpy)
		: DisplayHardwareBase(flinger, dpy), mFlags(0)
		: DisplayHardwareBase(flinger, dpy),
		mFlags(0)
		{
		init(dpy);
		}
		@@ -97,6 +100,9 @@ void DisplayHardware::init(uint32_t dpy)
		{
		mNativeWindow = new FramebufferNativeWindow();
		framebuffer_device_t const * fbDev = mNativeWindow->getDevice();
		mDpiX = mNativeWindow->xdpi;
		mDpiY = mNativeWindow->ydpi;
		mRefreshRate = fbDev->fps;

		mOverlayEngine = NULL;
		hw_module_t const* module;
		@@ -104,6 +110,11 @@ void DisplayHardware::init(uint32_t dpy)
		overlay_control_open(module, &mOverlayEngine);
		}

		EGLint w, h, dummy;
		EGLint numConfigs=0;
		EGLSurface surface;
		EGLContext context;

		// initialize EGL
		EGLint attribs[] = {
		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		@@ -121,11 +132,6 @@ void DisplayHardware::init(uint32_t dpy)
		}
		}

		EGLint w, h, dummy;
		EGLint numConfigs=0;
		EGLSurface surface;
		EGLContext context;

		// TODO: all the extensions below should be queried through
		// eglGetProcAddress().

		@@ -144,22 +150,6 @@ void DisplayHardware::init(uint32_t dpy)
		eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
		eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);

		/*
		* Gather EGL extensions
		*/

		const char* const egl_extensions = eglQueryString(
		display, EGL_EXTENSIONS);

		LOGI("EGL informations:");
		LOGI("# of configs : %d", numConfigs);
		LOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
		LOGI("version : %s", eglQueryString(display, EGL_VERSION));
		LOGI("extensions: %s", egl_extensions);
		LOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
		LOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);


		if (mNativeWindow->isUpdateOnDemand()) {
		mFlags \|= PARTIAL_UPDATES;
		}
		@@ -174,6 +164,8 @@ void DisplayHardware::init(uint32_t dpy)
		*/

		surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL);
		eglQuerySurface(display, surface, EGL_WIDTH, &mWidth);
		eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight);

		if (mFlags & PARTIAL_UPDATES) {
		// if we have partial updates, we definitely don't need to
		@@ -188,31 +180,6 @@ void DisplayHardware::init(uint32_t dpy)
		}
		}

		eglQuerySurface(display, surface, EGL_WIDTH, &mWidth);
		eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight);

		#ifdef EGL_ANDROID_swap_rectangle
		if (strstr(egl_extensions, "EGL_ANDROID_swap_rectangle")) {
		if (eglSetSwapRectangleANDROID(display, surface,
		0, 0, mWidth, mHeight) == EGL_TRUE) {
		// This could fail if this extension is not supported by this
		// specific surface (of config)
		mFlags \|= SWAP_RECTANGLE;
		}
		}
		// when we have the choice between PARTIAL_UPDATES and SWAP_RECTANGLE
		// choose PARTIAL_UPDATES, which should be more efficient
		if (mFlags & PARTIAL_UPDATES)
		mFlags &= ~SWAP_RECTANGLE;
		#endif


		LOGI("flags : %08x", mFlags);

		mDpiX = mNativeWindow->xdpi;
		mDpiY = mNativeWindow->ydpi;
		mRefreshRate = fbDev->fps;

		/* Read density from build-specific ro.sf.lcd_density property
		* except if it is overridden by qemu.sf.lcd_density.
		*/
		@@ -234,49 +201,67 @@ void DisplayHardware::init(uint32_t dpy)

		context = eglCreateContext(display, config, NULL, NULL);

		mDisplay = display;
		mConfig = config;
		mSurface = surface;
		mContext = context;
		mFormat = fbDev->format;
		mPageFlipCount = 0;

		/*
		* Gather OpenGL ES extensions
		*/

		eglMakeCurrent(display, surface, surface, context);
		const char* const gl_extensions = (const char*)glGetString(GL_EXTENSIONS);
		const char* const gl_renderer = (const char*)glGetString(GL_RENDERER);
		LOGI("OpenGL informations:");
		LOGI("vendor : %s", glGetString(GL_VENDOR));
		LOGI("renderer : %s", gl_renderer);
		LOGI("version : %s", glGetString(GL_VERSION));
		LOGI("extensions: %s", gl_extensions);

		GLExtensions& extensions(GLExtensions::getInstance());
		extensions.initWithGLStrings(
		glGetString(GL_VENDOR),
		glGetString(GL_RENDERER),
		glGetString(GL_VERSION),
		glGetString(GL_EXTENSIONS),
		eglQueryString(display, EGL_VENDOR),
		eglQueryString(display, EGL_VERSION),
		eglQueryString(display, EGL_EXTENSIONS));

		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
		glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &mMaxViewportDims);
		LOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);
		LOGI("GL_MAX_VIEWPORT_DIMS = %d", mMaxViewportDims);


		if (strstr(gl_extensions, "GL_ARB_texture_non_power_of_two")) {
		mFlags \|= NPOT_EXTENSION;
		#ifdef EGL_ANDROID_swap_rectangle
		if (extensions.hasExtension("EGL_ANDROID_swap_rectangle")) {
		if (eglSetSwapRectangleANDROID(display, surface,
		0, 0, mWidth, mHeight) == EGL_TRUE) {
		// This could fail if this extension is not supported by this
		// specific surface (of config)
		mFlags \|= SWAP_RECTANGLE;
		}
		#ifdef EGL_ANDROID_image_native_buffer
		if (strstr( gl_extensions, "GL_OES_EGL_image") &&
		(strstr(egl_extensions, "EGL_KHR_image_base") \|\|
		strstr(egl_extensions, "EGL_KHR_image")) &&
		strstr(egl_extensions, "EGL_ANDROID_image_native_buffer")) {
		mFlags \|= DIRECT_TEXTURE;
		}
		#else
		#warning "EGL_ANDROID_image_native_buffer not supported"
		// when we have the choice between PARTIAL_UPDATES and SWAP_RECTANGLE
		// choose PARTIAL_UPDATES, which should be more efficient
		if (mFlags & PARTIAL_UPDATES)
		mFlags &= ~SWAP_RECTANGLE;
		#endif

		LOGI("EGL informations:");
		LOGI("# of configs : %d", numConfigs);
		LOGI("vendor : %s", extensions.getEglVendor());
		LOGI("version : %s", extensions.getEglVersion());
		LOGI("extensions: %s", extensions.getEglExtension());
		LOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
		LOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);

		LOGI("OpenGL informations:");
		LOGI("vendor : %s", extensions.getVendor());
		LOGI("renderer : %s", extensions.getRenderer());
		LOGI("version : %s", extensions.getVersion());
		LOGI("extensions: %s", extensions.getExtension());
		LOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);
		LOGI("GL_MAX_VIEWPORT_DIMS = %d", mMaxViewportDims);
		LOGI("flags = %08x", mFlags);

		// Unbind the context from this thread
		eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

		mDisplay = display;
		mConfig = config;
		mSurface = surface;
		mContext = context;
		mFormat = fbDev->format;
		mPageFlipCount = 0;
		}

		/*

libs/surfaceflinger/DisplayHardware/DisplayHardware.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@

		#include <pixelflinger/pixelflinger.h>

		#include "GLExtensions.h"

		#include "DisplayHardware/DisplayHardwareBase.h"

		struct overlay_control_device_t;
		@@ -43,9 +45,7 @@ class DisplayHardware : public DisplayHardwareBase
		{
		public:
		enum {
		DIRECT_TEXTURE = 0x00000002,
		COPY_BITS_EXTENSION = 0x00000008,
		NPOT_EXTENSION = 0x00000100,
		BUFFER_PRESERVED = 0x00010000,
		PARTIAL_UPDATES = 0x00020000, // video driver feature
		SLOW_CONFIG = 0x00040000, // software

libs/surfaceflinger/GLExtensions.cpp

0 → 100644

+133 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.
		*/

		#include <stdlib.h>
		#include <stdio.h>
		#include <stdint.h>

		#include "GLExtensions.h"

		namespace android {
		// ---------------------------------------------------------------------------

		ANDROID_SINGLETON_STATIC_INSTANCE( GLExtensions )

		GLExtensions::GLExtensions()
		: mHaveTextureExternal(false),
		mHaveNpot(false),
		mHaveDirectTexture(false)
		{
		}

		void GLExtensions::initWithGLStrings(
		GLubyte const* vendor,
		GLubyte const* renderer,
		GLubyte const* version,
		GLubyte const* extensions,
		char const* egl_vendor,
		char const* egl_version,
		char const* egl_extensions)
		{
		mVendor = (char const*)vendor;
		mRenderer = (char const*)renderer;
		mVersion = (char const*)version;
		mExtensions = (char const*)extensions;
		mEglVendor = egl_vendor;
		mEglVersion = egl_version;
		mEglExtensions = egl_extensions;

		char const* curr = (char const*)extensions;
		char const* head = curr;
		do {
		head = strchr(curr, ' ');
		String8 s(curr, head ? head-curr : strlen(curr));
		if (s.length()) {
		mExtensionList.add(s);
		}
		curr = head+1;
		} while (head);

		curr = egl_extensions;
		head = curr;
		do {
		head = strchr(curr, ' ');
		String8 s(curr, head ? head-curr : strlen(curr));
		if (s.length()) {
		mExtensionList.add(s);
		}
		curr = head+1;
		} while (head);

		#ifdef EGL_ANDROID_image_native_buffer
		if (hasExtension("GL_OES_EGL_image") &&
		(hasExtension("EGL_KHR_image_base") \|\| hasExtension("EGL_KHR_image")) &&
		hasExtension("EGL_ANDROID_image_native_buffer"))
		{
		mHaveDirectTexture = true;
		}
		#else
		#warning "EGL_ANDROID_image_native_buffer not supported"
		#endif

		if (hasExtension("GL_ARB_texture_non_power_of_two")) {
		mHaveNpot = true;
		}

		if (hasExtension("GL_OES_texture_external")) {
		mHaveTextureExternal = true;
		} else if (strstr(mRenderer.string(), "Adreno")) {
		// hack for Adreno 200
		mHaveTextureExternal = true;
		}
		}

		bool GLExtensions::hasExtension(char const* extension) const
		{
		const String8 s(extension);
		return mExtensionList.indexOf(s) >= 0;
		}

		char const* GLExtensions::getVendor() const {
		return mVendor.string();
		}

		char const* GLExtensions::getRenderer() const {
		return mRenderer.string();
		}

		char const* GLExtensions::getVersion() const {
		return mVersion.string();
		}

		char const* GLExtensions::getExtension() const {
		return mExtensions.string();
		}

		char const* GLExtensions::getEglVendor() const {
		return mEglVendor.string();
		}

		char const* GLExtensions::getEglVersion() const {
		return mEglVersion.string();
		}

		char const* GLExtensions::getEglExtension() const {
		return mEglExtensions.string();
		}


		// ---------------------------------------------------------------------------
		}; // namespace android

libs/surfaceflinger/GLExtensions.h

0 → 100644

+94 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.
		*/

		#ifndef ANDROID_SF_GLEXTENSION_H
		#define ANDROID_SF_GLEXTENSION_H

		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/String8.h>
		#include <utils/SortedVector.h>
		#include <utils/Singleton.h>

		#include <EGL/egl.h>
		#include <EGL/eglext.h>
		#include <GLES/gl.h>
		#include <GLES/glext.h>

		namespace android {
		// ---------------------------------------------------------------------------

		class GLExtensions : public Singleton<GLExtensions>
		{
		friend class Singleton<GLExtensions>;

		bool mHaveTextureExternal : 1;
		bool mHaveNpot : 1;
		bool mHaveDirectTexture : 1;

		String8 mVendor;
		String8 mRenderer;
		String8 mVersion;
		String8 mExtensions;
		String8 mEglVendor;
		String8 mEglVersion;
		String8 mEglExtensions;
		SortedVector<String8> mExtensionList;

		GLExtensions(const GLExtensions&);
		GLExtensions& operator = (const GLExtensions&);

		protected:
		GLExtensions();

		public:
		inline bool haveTextureExternal() const {
		return mHaveTextureExternal;
		}
		inline bool haveNpot() const {
		return mHaveNpot;
		}
		inline bool haveDirectTexture() const {
		return mHaveDirectTexture;
		}

		void initWithGLStrings(
		GLubyte const* vendor,
		GLubyte const* renderer,
		GLubyte const* version,
		GLubyte const* extensions,
		char const* egl_vendor,
		char const* egl_version,
		char const* egl_extensions);

		char const* getVendor() const;
		char const* getRenderer() const;
		char const* getVersion() const;
		char const* getExtension() const;

		char const* getEglVendor() const;
		char const* getEglVersion() const;
		char const* getEglExtension() const;

		bool hasExtension(char const* extension) const;
		};


		// ---------------------------------------------------------------------------
		}; // namespace android

		#endif // ANDROID_SF_GLEXTENSION_H