Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes 20345,20346,20347

Browse Source 
* changes:
  update most gl tests to use EGLUtils
  added two EGL helpers for selecting a config matching a certain pixelformat or native window type
  added NATIVE_WINDOW_FORMAT attribute to android_native_window_t
This commit is contained in:
Android (Google) Code Review
2009-08-06 16:27:47 -07:00
parent 8851e163fc a1f6eff297
commit 43a6d88e4e
17 changed files with 269 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
include/ui/EGLUtils.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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 */

3
include/ui/egl/android_natives.h
View File

@@ -63,7 +63,8 @@ struct android_native_base_t
/* attributes queriable with query() */
enum {
NATIVE_WINDOW_WIDTH = 0,
NATIVE_WINDOW_HEIGHT = 1
NATIVE_WINDOW_HEIGHT = 1,
NATIVE_WINDOW_FORMAT = 2,
};
struct android_native_window_t

32
libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp
View File

@@ -26,6 +26,7 @@
#include <ui/PixelFormat.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
#include <GLES/gl.h>
#include <EGL/egl.h>
@@ -144,32 +145,11 @@ void DisplayHardware::init(uint32_t dpy)
eglInitialize(display, NULL, NULL);
eglGetConfigs(display, NULL, 0, &numConfigs);
// Get all the "potential match" configs...
EGLConfig* const configs = new EGLConfig[numConfigs];
eglChooseConfig(display, attribs, configs, numConfigs, &n);
LOGE_IF(n<=0, "no EGLConfig available!");
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;
EGLConfig config;
status_t err = EGLUtils::selectConfigForPixelFormat(
display, attribs, fbDev->format, &config);
LOGE_IF(err, "couldn't find an EGLConfig matching the screen format");
/*
* Gather EGL extensions
*/

2
libs/ui/Android.mk
View File

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

104
libs/ui/EGLUtils.cpp Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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
// ----------------------------------------------------------------------------

3
libs/ui/FramebufferNativeWindow.cpp
View File

@@ -212,6 +212,9 @@ int FramebufferNativeWindow::query(android_native_window_t* window,
case NATIVE_WINDOW_HEIGHT:
*value = fb->height;
return NO_ERROR;
case NATIVE_WINDOW_FORMAT:
*value = fb->format;
return NO_ERROR;
}
return BAD_VALUE;
}

3
libs/ui/Surface.cpp
View File

@@ -620,6 +620,9 @@ int Surface::query(int what, int* value)
case NATIVE_WINDOW_HEIGHT:
*value = int(mHeight);
return NO_ERROR;
case NATIVE_WINDOW_FORMAT:
*value = int(mFormat);
return NO_ERROR;
}
return BAD_VALUE;
}

2
opengl/tests/angeles/Android.mk
View File

@@ -2,7 +2,7 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= app-linux.c demo.c.arm
LOCAL_SRC_FILES:= app-linux.cpp demo.c.arm
LOCAL_SHARED_LIBRARIES := libEGL libGLESv1_CM libui
LOCAL_MODULE:= angeles
LOCAL_MODULE_TAGS := optional

75
opengl/tests/angeles/app-linux.c → opengl/tests/angeles/app-linux.cpp
View File

@@ -52,6 +52,11 @@
#include <EGL/egl.h>
#include <GLES/gl.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
#include "app.h"
@@ -115,76 +120,32 @@ static void checkEGLErrors()
static int initGraphics()
{
EGLint s_configAttribs[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
#if 1
EGL_DEPTH_SIZE, 16,
EGL_STENCIL_SIZE, 0,
#else
EGL_ALPHA_SIZE, EGL_DONT_CARE,
EGL_DEPTH_SIZE, EGL_DONT_CARE,
EGL_STENCIL_SIZE, EGL_DONT_CARE,
EGL_SURFACE_TYPE, EGL_DONT_CARE,
#endif
EGLint configAttribs[] = {
EGL_DEPTH_SIZE, 16,
EGL_NONE
};
EGLint numConfigs = -1;
EGLint n = 0;
EGLint majorVersion;
EGLint minorVersion;
EGLConfig config;
EGLContext context;
EGLConfig config;
EGLSurface surface;
EGLint w, h;
EGLDisplay dpy;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
egl_error("eglGetDisplay");
fprintf(stderr,"dpy = 0x%08x\n", (unsigned) dpy);
eglInitialize(dpy, &majorVersion, &minorVersion);
egl_error("eglInitialize");
eglGetConfigs(dpy, NULL, 0, &numConfigs);
// Get all the "potential match" configs...
EGLConfig* const configs = malloc(sizeof(EGLConfig)*numConfigs);
eglChooseConfig(dpy, s_configAttribs, configs, numConfigs, &n);
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 = 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;
}
}
EGLNativeWindowType window = android_createDisplaySurface();
status_t err = EGLUtils::selectConfigForNativeWindow(
dpy, configAttribs, window, &config);
if (err) {
fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
return 0;
}
free(configs);
//eglGetConfigs(dpy, NULL, 0, &numConfigs);
//egl_error("eglGetConfigs");
//fprintf(stderr,"num configs %d\n", numConfigs);
//eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);
//egl_error("eglChooseConfig");
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
surface = eglCreateWindowSurface(dpy, config, window, NULL);
egl_error("eglCreateWindowSurface");
fprintf(stderr,"surface = %p\n", surface);

42
opengl/tests/fillrate/fillrate.cpp
View File

@@ -26,6 +26,7 @@
#include <utils/StopWatch.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
@@ -36,48 +37,27 @@ int main(int argc, char** argv)
EGL_NONE
};
EGLint numConfigs = -1, n=0;
EGLint majorVersion;
EGLint minorVersion;
EGLConfig config;
EGLContext context;
EGLConfig config;
EGLSurface surface;
EGLint w, h;
EGLDisplay dpy;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(dpy, &majorVersion, &minorVersion);
EGLNativeWindowType window = android_createDisplaySurface();
// Get all the "potential match" configs...
eglGetConfigs(dpy, NULL, 0, &numConfigs);
EGLConfig* const configs = (EGLConfig*)malloc(sizeof(EGLConfig)*numConfigs);
eglChooseConfig(dpy, configAttribs, configs, numConfigs, &n);
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 = 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;
}
}
status_t err = EGLUtils::selectConfigForNativeWindow(
dpy, configAttribs, window, &config);
if (err) {
fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
return 0;
}
free(configs);
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
surface = eglCreateWindowSurface(dpy, config, window, NULL);
context = eglCreateContext(dpy, config, NULL, NULL);
eglMakeCurrent(dpy, surface, surface, context);
eglQuerySurface(dpy, surface, EGL_WIDTH, &w);

4
opengl/tests/filter/Android.mk
View File

@@ -2,7 +2,7 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
filter.c
filter.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
@@ -14,4 +14,6 @@ LOCAL_MODULE:= test-opengl-filter
LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES
include $(BUILD_EXECUTABLE)

13
opengl/tests/filter/filter.c → opengl/tests/filter/filter.cpp
View File

@@ -5,6 +5,11 @@
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
int main(int argc, char** argv)
{
if (argc!=2 && argc!=3) {
@@ -34,12 +39,14 @@ int main(int argc, char** argv)
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(dpy, &majorVersion, &minorVersion);
eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);
if (!usePbuffer) {
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
EGLNativeWindowType window = android_createDisplaySurface();
surface = eglCreateWindowSurface(dpy, config, window, NULL);
EGLUtils::selectConfigForNativeWindow(
dpy, s_configAttribs, window, &config);
} else {
printf("using pbuffer\n");
eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);
EGLint attribs[] = { EGL_WIDTH, 320, EGL_HEIGHT, 480, EGL_NONE };
surface = eglCreatePbufferSurface(dpy, config, attribs);
if (surface == EGL_NO_SURFACE) {

4
opengl/tests/finish/Android.mk
View File

@@ -2,7 +2,7 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
finish.c
finish.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
@@ -14,4 +14,6 @@ LOCAL_MODULE:= test-opengl-finish
LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES
include $(BUILD_EXECUTABLE)

40
opengl/tests/finish/finish.c → opengl/tests/finish/finish.cpp
View File

@@ -24,39 +24,41 @@
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <utils/Timers.h>
long long systemTime()
{
struct timespec t;
t.tv_sec = t.tv_nsec = 0;
clock_gettime(CLOCK_MONOTONIC, &t);
return (long long)(t.tv_sec)*1000000000LL + t.tv_nsec;
}
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
int main(int argc, char** argv)
{
EGLint s_configAttribs[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGLint configAttribs[] = {
EGL_DEPTH_SIZE, 0,
EGL_NONE
};
EGLint numConfigs = -1;
EGLint majorVersion;
EGLint minorVersion;
EGLConfig config;
EGLContext context;
EGLConfig config;
EGLSurface surface;
EGLint w, h;
EGLDisplay dpy;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(dpy, &majorVersion, &minorVersion);
eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
EGLNativeWindowType window = android_createDisplaySurface();
status_t err = EGLUtils::selectConfigForNativeWindow(
dpy, configAttribs, window, &config);
if (err) {
fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
return 0;
}
surface = eglCreateWindowSurface(dpy, config, window, NULL);
context = eglCreateContext(dpy, config, NULL, NULL);
eglMakeCurrent(dpy, surface, surface, context);
eglQuerySurface(dpy, surface, EGL_WIDTH, &w);
@@ -75,13 +77,13 @@ int main(int argc, char** argv)
long long now, t;
int i;
char* texels = malloc(512*512*2);
char* texels = (char*)malloc(512*512*2);
memset(texels,0xFF,512*512*2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
512, 512, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, texels);
char* dst = malloc(320*480*2);
char* dst = (char*)malloc(320*480*2);
memset(dst, 0, 320*480*2);
printf("307200 bytes memcpy\n");
for (i=0 ; i<4 ; i++) {

42
opengl/tests/swapinterval/swapinterval.cpp
View File

@@ -26,6 +26,7 @@
#include <utils/StopWatch.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
@@ -36,48 +37,27 @@ int main(int argc, char** argv)
EGL_NONE
};
EGLint numConfigs = -1, n=0;
EGLint majorVersion;
EGLint minorVersion;
EGLConfig config;
EGLContext context;
EGLConfig config;
EGLSurface surface;
EGLint w, h;
EGLDisplay dpy;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(dpy, &majorVersion, &minorVersion);
EGLNativeWindowType window = android_createDisplaySurface();
// Get all the "potential match" configs...
eglGetConfigs(dpy, NULL, 0, &numConfigs);
EGLConfig* const configs = (EGLConfig*)malloc(sizeof(EGLConfig)*numConfigs);
eglChooseConfig(dpy, configAttribs, configs, numConfigs, &n);
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 = 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;
}
}
status_t err = EGLUtils::selectConfigForNativeWindow(
dpy, configAttribs, window, &config);
if (err) {
fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
return 0;
}
free(configs);
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
surface = eglCreateWindowSurface(dpy, config, window, NULL);
context = eglCreateContext(dpy, config, NULL, NULL);
eglMakeCurrent(dpy, surface, surface, context);
eglQuerySurface(dpy, surface, EGL_WIDTH, &w);

4
opengl/tests/textures/Android.mk
View File

@@ -2,7 +2,7 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
textures.c
textures.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
@@ -14,4 +14,6 @@ LOCAL_MODULE:= test-opengl-textures
LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES
include $(BUILD_EXECUTABLE)

54
opengl/tests/textures/textures.c → opengl/tests/textures/textures.cpp
View File

@@ -22,59 +22,39 @@
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
int main(int argc, char** argv)
{
EGLint s_configAttribs[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGLint configAttribs[] = {
EGL_DEPTH_SIZE, 0,
EGL_NONE
};
EGLint numConfigs = -1, n=0;
EGLint majorVersion;
EGLint minorVersion;
EGLConfig config;
EGLContext context;
EGLConfig config;
EGLSurface surface;
EGLint w, h;
EGLDisplay dpy;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(dpy, &majorVersion, &minorVersion);
EGLNativeWindowType window = android_createDisplaySurface();
// Get all the "potential match" configs...
eglGetConfigs(dpy, NULL, 0, &numConfigs);
EGLConfig* const configs = malloc(sizeof(EGLConfig)*numConfigs);
eglChooseConfig(dpy, s_configAttribs, configs, numConfigs, &n);
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 = 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;
}
}
status_t err = EGLUtils::selectConfigForNativeWindow(
dpy, configAttribs, window, &config);
if (err) {
fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");
return 0;
}
free(configs);
surface = eglCreateWindowSurface(dpy, config,
android_createDisplaySurface(), NULL);
surface = eglCreateWindowSurface(dpy, config, window, NULL);
context = eglCreateContext(dpy, config, NULL, NULL);
eglMakeCurrent(dpy, surface, surface, context);
eglQuerySurface(dpy, surface, EGL_WIDTH, &w);