added two EGL helpers for selecting a config matching a certain pixelformat or native window type (6cf50a77) · Commits · e / os / android_frameworks_native

include/ui/EGLUtils.h

0 → 100644

+51 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2009 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_UI_EGLUTILS_H
			#define ANDROID_UI_EGLUTILS_H

			#include <utils/Errors.h>
			#include <ui/PixelFormat.h>
			#include <EGL/egl.h>


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

			class EGLUtils
			{
			public:

			static status_t selectConfigForPixelFormat(
			EGLDisplay dpy,
			EGLint const* attrs,
			PixelFormat format,
			EGLConfig* outConfig);

			static status_t selectConfigForNativeWindow(
			EGLDisplay dpy,
			EGLint const* attrs,
			EGLNativeWindowType window,
			EGLConfig* outConfig);
			};

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

			#endif /* ANDROID_UI_EGLUTILS_H */

libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp

+6 −26

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@

	#include <ui/PixelFormat.h>		#include <ui/PixelFormat.h>
	#include <ui/FramebufferNativeWindow.h>		#include <ui/FramebufferNativeWindow.h>
			#include <ui/EGLUtils.h>

	#include <GLES/gl.h>		#include <GLES/gl.h>
	#include <EGL/egl.h>		#include <EGL/egl.h>
	@@ -144,31 +145,10 @@ void DisplayHardware::init(uint32_t dpy)
	eglInitialize(display, NULL, NULL);		eglInitialize(display, NULL, NULL);
	eglGetConfigs(display, NULL, 0, &numConfigs);		eglGetConfigs(display, NULL, 0, &numConfigs);

	// Get all the "potential match" configs...		EGLConfig config;
	EGLConfig* const configs = new EGLConfig[numConfigs];		status_t err = EGLUtils::selectConfigForPixelFormat(
	eglChooseConfig(display, attribs, configs, numConfigs, &n);		display, attribs, fbDev->format, &config);
	LOGE_IF(n<=0, "no EGLConfig available!");		LOGE_IF(err, "couldn't find an EGLConfig matching the screen format");
	EGLConfig config = configs[0];
	if (n > 1) {
	// if there is more than one candidate, go through the list
	// and pick one that matches our framebuffer format
	int fbSzA = fbFormatInfo.getSize(PixelFormatInfo::INDEX_ALPHA);
	int fbSzR = fbFormatInfo.getSize(PixelFormatInfo::INDEX_RED);
	int fbSzG = fbFormatInfo.getSize(PixelFormatInfo::INDEX_GREEN);
	int fbSzB = fbFormatInfo.getSize(PixelFormatInfo::INDEX_BLUE);
	for (int i=0 ; i<n ; i++) {
	EGLint r,g,b,a;
	eglGetConfigAttrib(display, configs[i], EGL_RED_SIZE, &r);
	eglGetConfigAttrib(display, configs[i], EGL_GREEN_SIZE, &g);
	eglGetConfigAttrib(display, configs[i], EGL_BLUE_SIZE, &b);
	eglGetConfigAttrib(display, configs[i], EGL_ALPHA_SIZE, &a);
	if (fbSzA == a && fbSzR == r && fbSzG == g && fbSzB == b) {
	config = configs[i];
	break;
	}
	}
	}
	delete [] configs;

	/*		/*
	* Gather EGL extensions		* Gather EGL extensions

libs/ui/Android.mk

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -5,6 +5,7 @@ LOCAL_SRC_FILES:= \
	BufferMapper.cpp \		BufferMapper.cpp \
	Camera.cpp \		Camera.cpp \
	CameraParameters.cpp \		CameraParameters.cpp \
			EGLUtils.cpp \
	EventHub.cpp \		EventHub.cpp \
	EventRecurrence.cpp \		EventRecurrence.cpp \
	FramebufferNativeWindow.cpp \		FramebufferNativeWindow.cpp \
	@@ -29,6 +30,7 @@ LOCAL_SRC_FILES:= \
	LOCAL_SHARED_LIBRARIES := \		LOCAL_SHARED_LIBRARIES := \
	libcutils \		libcutils \
	libutils \		libutils \
			libEGL \
	libbinder \		libbinder \
	libpixelflinger \		libpixelflinger \
	libhardware \		libhardware \

libs/ui/EGLUtils.cpp

0 → 100644

+104 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2009 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 "EGLUtils"

			#include <utils/Errors.h>

			#include <ui/EGLUtils.h>

			#include <EGL/egl.h>

			#include <private/ui/android_natives_priv.h>

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

			status_t EGLUtils::selectConfigForPixelFormat(
			EGLDisplay dpy,
			EGLint const* attrs,
			PixelFormat format,
			EGLConfig* outConfig)
			{
			EGLint numConfigs = -1, n=0;

			if (outConfig == NULL)
			return BAD_VALUE;

			int err;
			PixelFormatInfo fbFormatInfo;
			if ((err = getPixelFormatInfo(PixelFormat(format), &fbFormatInfo)) < 0) {
			return err;
			}

			// Get all the "potential match" configs...
			if (eglGetConfigs(dpy, NULL, 0, &numConfigs) == EGL_FALSE)
			return BAD_VALUE;

			EGLConfig* const configs = (EGLConfig)malloc(sizeof(EGLConfig)numConfigs);
			if (eglChooseConfig(dpy, attrs, configs, numConfigs, &n) == EGL_FALSE) {
			free(configs);
			return BAD_VALUE;
			}

			const int fbSzA = fbFormatInfo.getSize(PixelFormatInfo::INDEX_ALPHA);
			const int fbSzR = fbFormatInfo.getSize(PixelFormatInfo::INDEX_RED);
			const int fbSzG = fbFormatInfo.getSize(PixelFormatInfo::INDEX_GREEN);
			const int fbSzB = fbFormatInfo.getSize(PixelFormatInfo::INDEX_BLUE);

			EGLConfig config = NULL;
			for (int i=0 ; i<n ; i++) {
			EGLint r,g,b,a;
			eglGetConfigAttrib(dpy, configs[i], EGL_RED_SIZE, &r);
			eglGetConfigAttrib(dpy, configs[i], EGL_GREEN_SIZE, &g);
			eglGetConfigAttrib(dpy, configs[i], EGL_BLUE_SIZE, &b);
			eglGetConfigAttrib(dpy, configs[i], EGL_ALPHA_SIZE, &a);
			if (fbSzA == a && fbSzR == r && fbSzG == g && fbSzB == b) {
			config = configs[i];
			break;
			}
			}

			free(configs);

			if (config) {
			*outConfig = config;
			return NO_ERROR;
			}

			return NAME_NOT_FOUND;
			}

			status_t EGLUtils::selectConfigForNativeWindow(
			EGLDisplay dpy,
			EGLint const* attrs,
			EGLNativeWindowType window,
			EGLConfig* outConfig)
			{
			int err;
			int format;
			if ((err = window->query(window, NATIVE_WINDOW_FORMAT, &format)) < 0) {
			return err;
			}

			return selectConfigForPixelFormat(dpy, attrs, format, outConfig);
			}

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

opengl/tests/swapinterval/swapinterval.cpp

+11 −31

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@

	#include <utils/StopWatch.h>		#include <utils/StopWatch.h>
	#include <ui/FramebufferNativeWindow.h>		#include <ui/FramebufferNativeWindow.h>
			#include <ui/EGLUtils.h>

	using namespace android;		using namespace android;

	@@ -36,48 +37,27 @@ int main(int argc, char** argv)
	EGL_NONE		EGL_NONE
	};		};

	EGLint numConfigs = -1, n=0;
	EGLint majorVersion;		EGLint majorVersion;
	EGLint minorVersion;		EGLint minorVersion;
	EGLConfig config;
	EGLContext context;		EGLContext context;
			EGLConfig config;
	EGLSurface surface;		EGLSurface surface;
	EGLint w, h;		EGLint w, h;

	EGLDisplay dpy;		EGLDisplay dpy;

	dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);		dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	eglInitialize(dpy, &majorVersion, &minorVersion);		eglInitialize(dpy, &majorVersion, &minorVersion);

	// Get all the "potential match" configs...		EGLNativeWindowType window = android_createDisplaySurface();
	eglGetConfigs(dpy, NULL, 0, &numConfigs);
	EGLConfig* const configs = (EGLConfig)malloc(sizeof(EGLConfig)numConfigs);		status_t err = EGLUtils::selectConfigForNativeWindow(
	eglChooseConfig(dpy, configAttribs, configs, numConfigs, &n);		dpy, configAttribs, window, &config);
	config = configs[0];		if (err) {
	if (n > 1) {		fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
	// if there is more than one candidate, go through the list		return 0;
	// and pick one that matches our framebuffer format
	int fbSzA = 0; // should not hardcode
	int fbSzR = 5; // should not hardcode
	int fbSzG = 6; // should not hardcode
	int fbSzB = 5; // should not hardcode
	int i;
	for (i=0 ; i<n ; i++) {
	EGLint r,g,b,a;
	eglGetConfigAttrib(dpy, configs[i], EGL_RED_SIZE, &r);
	eglGetConfigAttrib(dpy, configs[i], EGL_GREEN_SIZE, &g);
	eglGetConfigAttrib(dpy, configs[i], EGL_BLUE_SIZE, &b);
	eglGetConfigAttrib(dpy, configs[i], EGL_ALPHA_SIZE, &a);
	if (fbSzA == a && fbSzR == r && fbSzG == g && fbSzB == b) {
	config = configs[i];
	break;
	}
	}
	}		}
	free(configs);

	surface = eglCreateWindowSurface(dpy, config,		surface = eglCreateWindowSurface(dpy, config, window, NULL);
	android_createDisplaySurface(), NULL);
	context = eglCreateContext(dpy, config, NULL, NULL);		context = eglCreateContext(dpy, config, NULL, NULL);
	eglMakeCurrent(dpy, surface, surface, context);		eglMakeCurrent(dpy, surface, surface, context);
	eglQuerySurface(dpy, surface, EGL_WIDTH, &w);		eglQuerySurface(dpy, surface, EGL_WIDTH, &w);