jyapayne/anbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Import goldfish HAL sources from devices/generic/goldfish

Browse source 
We import all code here so we can customize and keep in sync with what
we do on the host side more easily.
This commit is contained in:
Simon Fels 2017-01-09 08:05:04 +01:00
commit 23392b9732
196 changed files with 62159 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

41
android/opengl/system/egl/Android.mk Normal file
View file

@ -0,0 +1,41 @@
ifneq (false,$(BUILD_EMULATOR_OPENGL_DRIVER))
LOCAL_PATH := $(call my-dir)
$(call emugl-begin-shared-library,libEGL_emulation)
$(call emugl-import,libOpenglSystemCommon)
$(call emugl-set-shared-library-subpath,egl)
LOCAL_CFLAGS += -DLOG_TAG=\"EGL_emulation\" -DEGL_EGLEXT_PROTOTYPES -DWITH_GLES2
LOCAL_SRC_FILES := \
eglDisplay.cpp \
egl.cpp \
ClientAPIExts.cpp
LOCAL_SHARED_LIBRARIES += libdl
# Used to access the Bionic private OpenGL TLS slot
LOCAL_C_INCLUDES += bionic/libc/private
$(call emugl-end-module)
#### egl.cfg ####
# Ensure that this file is only copied to emulator-specific builds.
# Other builds are device-specific and will provide their own
# version of this file to point to the appropriate HW EGL libraries.
#
ifneq (,$(filter aosp_arm aosp_x86 aosp_mips full full_x86 full_mips sdk sdk_x86 sdk_mips google_sdk google_sdk_x86 google_sdk_mips,$(TARGET_PRODUCT)))
include $(CLEAR_VARS)
LOCAL_MODULE := egl.cfg
LOCAL_SRC_FILES := $(LOCAL_MODULE)
LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl
LOCAL_MODULE_CLASS := ETC
include $(BUILD_PREBUILT)
endif # TARGET_PRODUCT in 'full full_x86 full_mips sdk sdk_x86 sdk_mips google_sdk google_sdk_x86 google_sdk_mips')
endif # BUILD_EMULATOR_OPENGL_DRIVER != false

157
android/opengl/system/egl/ClientAPIExts.cpp Normal file
View file

@ -0,0 +1,157 @@
/*
* Copyright (C) 2011 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 "ClientAPIExts.h"
#include "ThreadInfo.h"
#include <GLES/gl.h>
#include <GLES/glext.h>
#include "eglContext.h"
namespace ClientAPIExts
{
//
// define function pointer type for each extention function
// typename has the form __egl_{funcname}_t
//
#define FUNC_TYPE(fname) __egl_ ## fname ## _t
#define API_ENTRY(fname,params,args) \
typedef void (GL_APIENTRY *FUNC_TYPE(fname)) params;
#define API_ENTRY_RET(rtype,fname,params,args) \
typedef rtype (GL_APIENTRY *FUNC_TYPE(fname)) params;
#include "ClientAPIExts.in"
#undef API_ENTRY
#undef API_ENTRY_RET
/////
// Define static table to store the function value for each
// client API. functions pointers will get initialized through
// ClientAPIExts::initClientFuncs function after each client API has been
// loaded.
/////
#define API_ENTRY(fname,params,args) \
FUNC_TYPE(fname) fname;
#define API_ENTRY_RET(rtype,fname,params,args) \
API_ENTRY(fname,params,args)
static struct _ext_table
{
#include "ClientAPIExts.in"
} s_client_extensions[2];
#undef API_ENTRY
#undef API_ENTRY_RET
//
// This function initialized each entry in the s_client_extensions
// struct at the givven index using the givven client interface
//
void initClientFuncs(const EGLClient_glesInterface *iface, int idx)
{
#define API_ENTRY(fname,params,args) \
s_client_extensions[idx].fname = \
(FUNC_TYPE(fname))iface->getProcAddress(#fname);
#define API_ENTRY_RET(rtype,fname,params,args) \
API_ENTRY(fname,params,args)
//
// reset all func pointers to NULL
//
memset(&s_client_extensions[idx], 0, sizeof(struct _ext_table));
//
// And now query the GLES library for each proc address
//
#include "ClientAPIExts.in"
#undef API_ENTRY
#undef API_ENTRY_RET
}
//
// Define implementation for each extension function which checks
// the current context version and calls to the correct client API
// function.
//
#define API_ENTRY(fname,params,args) \
static void _egl_ ## fname params \
{ \
EGLThreadInfo* thread = getEGLThreadInfo(); \
if (!thread->currentContext) { \
return; \
} \
int idx = (int)thread->currentContext->version - 1; \
if (!s_client_extensions[idx].fname) { \
return; \
} \
(*s_client_extensions[idx].fname) args; \
}
#define API_ENTRY_RET(rtype,fname,params,args) \
static rtype _egl_ ## fname params \
{ \
EGLThreadInfo* thread = getEGLThreadInfo(); \
if (!thread->currentContext) { \
return (rtype)0; \
} \
int idx = (int)thread->currentContext->version - 1; \
if (!s_client_extensions[idx].fname) { \
return (rtype)0; \
} \
return (*s_client_extensions[idx].fname) args; \
}
#include "ClientAPIExts.in"
#undef API_ENTRY
#undef API_ENTRY_RET
//
// Define a table to map function names to the local _egl_ version of
// the extension function, to be used in eglGetProcAddress.
//
#define API_ENTRY(fname,params,args) \
{ #fname, (void*)_egl_ ## fname},
#define API_ENTRY_RET(rtype,fname,params,args) \
API_ENTRY(fname,params,args)
static const struct _client_ext_funcs {
const char *fname;
void* proc;
} s_client_ext_funcs[] = {
#include "ClientAPIExts.in"
};
static const int numExtFuncs = sizeof(s_client_ext_funcs) /
sizeof(s_client_ext_funcs[0]);
#undef API_ENTRY
#undef API_ENTRY_RET
//
// returns the __egl_ version of the givven extension function name.
//
void* getProcAddress(const char *fname)
{
for (int i=0; i<numExtFuncs; i++) {
if (!strcmp(fname, s_client_ext_funcs[i].fname)) {
return s_client_ext_funcs[i].proc;
}
}
return NULL;
}
} // of namespace ClientAPIExts

29
android/opengl/system/egl/ClientAPIExts.h Normal file
View file

@ -0,0 +1,29 @@
/*
* Copyright (C) 2011 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 _CLIENT_APIS_EXTS_H
#define _CLIENT_APIS_EXTS_H
#include "EGLClientIface.h"
namespace ClientAPIExts
{
void initClientFuncs(const EGLClient_glesInterface *iface, int idx);
void* getProcAddress(const char *fname);
} // of namespace ClientAPIExts
#endif

201
android/opengl/system/egl/ClientAPIExts.in Normal file
View file

@ -0,0 +1,201 @@
//
// Each extension function should have one of the following
// macro definitions:
// API_ENTRY(funcname, paramlist, arglist)
// -or- (if the function has a return value)
// API_ENTRY_RET(return_type,funcname, paramlist, arglist)
//
API_ENTRY(glEGLImageTargetTexture2DOES,
(GLenum target, GLeglImageOES image),
(target, image))
API_ENTRY(glEGLImageTargetRenderbufferStorageOES,
(GLenum target, GLeglImageOES image),
(target, image))
API_ENTRY(glBlendEquationSeparateOES,
(GLenum modeRGB, GLenum modeAlpha),
(modeRGB, modeAlpha))
API_ENTRY(glBlendFuncSeparateOES,
(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha),
(srcRGB, dstRGB, srcAlpha, dstAlpha))
API_ENTRY(glBlendEquationOES,
(GLenum mode),
(mode))
API_ENTRY(glCurrentPaletteMatrixOES,
(GLuint matrixpaletteindex),
(matrixpaletteindex))
API_ENTRY(glLoadPaletteFromModelViewMatrixOES,
(void),
())
API_ENTRY(glMatrixIndexPointerOES,
(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer),
(size, type, stride, pointer))
API_ENTRY(glWeightPointerOES,
(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer),
(size, type, stride, pointer))
API_ENTRY(glDepthRangefOES,
(GLclampf zNear, GLclampf zFar),
(zNear, zFar))
API_ENTRY(glFrustumfOES,
(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar),
(left, right, bottom, top, zNear, zFar))
API_ENTRY(glOrthofOES,
(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar),
(left, right, bottom, top, zNear, zFar))
API_ENTRY(glClipPlanefOES,
(GLenum plane, const GLfloat *equation),
(plane, equation))
API_ENTRY(glGetClipPlanefOES,
(GLenum pname, GLfloat * eqn),
(pname, eqn))
API_ENTRY(glClearDepthfOES,
(GLclampf depth),
(depth))
API_ENTRY(glPointSizePointerOES,
(GLenum type, GLsizei stride, const GLvoid *pointer),
(type, stride, pointer))
API_ENTRY(glTexGenfOES,
(GLenum coord, GLenum pname, GLfloat param),
(coord, pname, param))
API_ENTRY(glTexGenfvOES,
(GLenum coord, GLenum pname, const GLfloat *params),
(coord, pname, params))
API_ENTRY(glTexGeniOES,
(GLenum coord, GLenum pname, GLint param),
(coord, pname, param))
API_ENTRY(glTexGenivOES,
(GLenum coord, GLenum pname, const GLint *params),
(coord, pname, params))
API_ENTRY(glTexGenxOES,
(GLenum coord, GLenum pname, GLfixed param),
(coord, pname, param))
API_ENTRY(glTexGenxvOES,
(GLenum coord, GLenum pname, const GLfixed *params),
(coord, pname, params))
API_ENTRY(glGetTexGenfvOES,
(GLenum coord, GLenum pname, GLfloat *params),
(coord, pname, params))
API_ENTRY(glGetTexGenivOES,
(GLenum coord, GLenum pname, GLint *params),
(coord, pname, params))
API_ENTRY(glGetTexGenxvOES,
(GLenum coord, GLenum pname, GLfixed *params),
(coord, pname, params))
API_ENTRY_RET(GLboolean,
glIsRenderbufferOES,
(GLuint renderbuffer),
(renderbuffer))
API_ENTRY(glBindRenderbufferOES,
(GLenum target, GLuint renderbuffer),
(target, renderbuffer))
API_ENTRY(glDeleteRenderbuffersOES,
(GLsizei n, const GLuint* renderbuffers),
(n, renderbuffers))
API_ENTRY(glGenRenderbuffersOES,
(GLsizei n, GLuint* renderbuffers),
(n, renderbuffers))
API_ENTRY(glRenderbufferStorageOES,
(GLenum target, GLenum internalformat, GLsizei width, GLsizei height),
(target, internalformat, width, height))
API_ENTRY(glGetRenderbufferParameterivOES,
(GLenum target, GLenum pname, GLint* params),
(target, pname, params))
API_ENTRY_RET(GLboolean,
glIsFramebufferOES,
(GLuint framebuffer),
(framebuffer))
API_ENTRY(glBindFramebufferOES,
(GLenum target, GLuint framebuffer),
(target, framebuffer))
API_ENTRY(glDeleteFramebuffersOES,
(GLsizei n, const GLuint* framebuffers),
(n, framebuffers))
API_ENTRY(glGenFramebuffersOES,
(GLsizei n, GLuint* framebuffers),
(n, framebuffers))
API_ENTRY_RET(GLenum,
glCheckFramebufferStatusOES,
(GLenum target),
(target))
API_ENTRY(glFramebufferTexture2DOES,
(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level),
(target, attachment, textarget, texture, level))
API_ENTRY(glFramebufferRenderbufferOES,
(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer),
(target, attachment, renderbuffertarget, renderbuffer))
API_ENTRY(glGetFramebufferAttachmentParameterivOES,
(GLenum target, GLenum attachment, GLenum pname, GLint* params),
(target, attachment, pname, params))
API_ENTRY(glGenerateMipmapOES,
(GLenum target),
(target))
API_ENTRY(glDrawTexsOES,
(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height),
(x, y, z, width, height))
API_ENTRY(glDrawTexiOES,
(GLint x, GLint y, GLint z, GLint width, GLint height),
(x, y, z, width, height))
API_ENTRY(glDrawTexfOES,
(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height),
(x, y, z, width, height))
API_ENTRY(glDrawTexxOES,
(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height),
(x, y, z, width, height))
API_ENTRY(glDrawTexsvOES,
(const GLshort *coords),
(coords))
API_ENTRY(glDrawTexivOES,
(const GLint *coords),
(coords))
API_ENTRY(glDrawTexfvOES,
(const GLfloat *coords),
(coords))
API_ENTRY(glDrawTexxvOES,
(const GLfixed *coords),
(coords))

1
android/opengl/system/egl/egl.cfg Normal file
View file

@ -0,0 +1 @@
0 0 emulation

1379
android/opengl/system/egl/egl.cpp Normal file
View file

File diff suppressed because it is too large Load diff

52
android/opengl/system/egl/eglContext.h Normal file
View file

@ -0,0 +1,52 @@
/*
* Copyright (C) 2011 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 _EGL_CONTEXT_H
#define _EGL_CONTEXT_H
#include "GLClientState.h"
#include "GLSharedGroup.h"
struct EGLContext_t {
enum {
IS_CURRENT = 0x00010000,
NEVER_CURRENT = 0x00020000
};
EGLContext_t(EGLDisplay dpy, EGLConfig config, EGLContext_t* shareCtx);
~EGLContext_t();
uint32_t flags;
EGLDisplay dpy;
EGLConfig config;
EGLSurface read;
EGLSurface draw;
EGLContext_t * shareCtx;
EGLint version;
uint32_t rcContext;
const char* versionString;
const char* vendorString;
const char* rendererString;
const char* shaderVersionString;
const char* extensionString;
EGLint deletePending;
GLClientState * getClientState(){ return clientState; }
GLSharedGroupPtr getSharedGroup(){ return sharedGroup; }
private:
GLClientState * clientState;
GLSharedGroupPtr sharedGroup;
};
#endif

485
android/opengl/system/egl/eglDisplay.cpp Normal file
View file

@ -0,0 +1,485 @@
/*
* Copyright (C) 2011 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 "eglDisplay.h"
#include "HostConnection.h"
#include <dlfcn.h>
static const int systemEGLVersionMajor = 1;
static const int systemEGLVersionMinor = 4;
static const char systemEGLVendor[] = "Google Android emulator";
// list of extensions supported by this EGL implementation
// NOTE that each extension name should be suffixed with space
static const char systemStaticEGLExtensions[] =
"EGL_ANDROID_image_native_buffer "
"EGL_KHR_fence_sync "
"EGL_KHR_image_base "
"EGL_KHR_gl_texture_2d_image ";
static void *s_gles_lib = NULL;
static void *s_gles2_lib = NULL;
// The following function will be called when we (libEGL)
// gets unloaded
// At this point we want to unload the gles libraries we
// might have loaded during initialization
static void __attribute__ ((destructor)) do_on_unload(void)
{
if (s_gles_lib) {
dlclose(s_gles_lib);
}
if (s_gles2_lib) {
dlclose(s_gles2_lib);
}
}
eglDisplay::eglDisplay() :
m_initialized(false),
m_major(0),
m_minor(0),
m_hostRendererVersion(0),
m_numConfigs(0),
m_numConfigAttribs(0),
m_attribs(DefaultKeyedVector<EGLint, EGLint>(ATTRIBUTE_NONE)),
m_configs(NULL),
m_gles_iface(NULL),
m_gles2_iface(NULL),
m_versionString(NULL),
m_vendorString(NULL),
m_extensionString(NULL)
{
pthread_mutex_init(&m_lock, NULL);
}
eglDisplay::~eglDisplay()
{
pthread_mutex_destroy(&m_lock);
}
bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
{
pthread_mutex_lock(&m_lock);
if (!m_initialized) {
//
// load GLES client API
//
#if __LP64__
m_gles_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv1_CM_emulation.so",
eglIface,
&s_gles_lib);
#else
m_gles_iface = loadGLESClientAPI("/system/lib/egl/libGLESv1_CM_emulation.so",
eglIface,
&s_gles_lib);
#endif
if (!m_gles_iface) {
pthread_mutex_unlock(&m_lock);
ALOGE("Failed to load gles1 iface");
return false;
}
#ifdef WITH_GLES2
#if __LP64__
m_gles2_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv2_emulation.so",
eglIface,
&s_gles2_lib);
#else
m_gles2_iface = loadGLESClientAPI("/system/lib/egl/libGLESv2_emulation.so",
eglIface,
&s_gles2_lib);
#endif
// Note that if loading gles2 failed, we can still run with no
// GLES2 support, having GLES2 is not mandatory.
#endif
//
// establish connection with the host
//
HostConnection *hcon = HostConnection::get();
if (!hcon) {
pthread_mutex_unlock(&m_lock);
ALOGE("Failed to establish connection with the host\n");
return false;
}
//
// get renderControl encoder instance
//
renderControl_encoder_context_t *rcEnc = hcon->rcEncoder();
if (!rcEnc) {
pthread_mutex_unlock(&m_lock);
ALOGE("Failed to get renderControl encoder instance");
return false;
}
//
// Query host reneder and EGL version
//
m_hostRendererVersion = rcEnc->rcGetRendererVersion(rcEnc);
EGLint status = rcEnc->rcGetEGLVersion(rcEnc, &m_major, &m_minor);
if (status != EGL_TRUE) {
// host EGL initialization failed !!
pthread_mutex_unlock(&m_lock);
return false;
}
//
// Take minimum version beween what we support and what the host support
//
if (m_major > systemEGLVersionMajor) {
m_major = systemEGLVersionMajor;
m_minor = systemEGLVersionMinor;
}
else if (m_major == systemEGLVersionMajor &&
m_minor > systemEGLVersionMinor) {
m_minor = systemEGLVersionMinor;
}
//
// Query the host for the set of configs
//
m_numConfigs = rcEnc->rcGetNumConfigs(rcEnc, (uint32_t*)&m_numConfigAttribs);
if (m_numConfigs <= 0 || m_numConfigAttribs <= 0) {
// just sanity check - should never happen
pthread_mutex_unlock(&m_lock);
return false;
}
uint32_t nInts = m_numConfigAttribs * (m_numConfigs + 1);
EGLint tmp_buf[nInts];
m_configs = new EGLint[nInts-m_numConfigAttribs];
if (!m_configs) {
pthread_mutex_unlock(&m_lock);
return false;
}
//EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), m_configs);
EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), (GLuint*)tmp_buf);
if (n != m_numConfigs) {
pthread_mutex_unlock(&m_lock);
return false;
}
//Fill the attributes vector.
//The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
for (int i=0; i<m_numConfigAttribs; i++) {
m_attribs.add(tmp_buf[i], i);
}
//Copy the actual configs data to m_configs
memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
m_initialized = true;
}
pthread_mutex_unlock(&m_lock);
processConfigs();
return true;
}
void eglDisplay::processConfigs()
{
for (intptr_t i=0; i<m_numConfigs; i++) {
EGLConfig config = (EGLConfig)i;
//Setup the EGL_NATIVE_VISUAL_ID attribute
PixelFormat format;
if (getConfigNativePixelFormat(config, &format)) {
setConfigAttrib(config, EGL_NATIVE_VISUAL_ID, format);
}
}
}
void eglDisplay::terminate()
{
pthread_mutex_lock(&m_lock);
if (m_initialized) {
m_initialized = false;
delete [] m_configs;
m_configs = NULL;
if (m_versionString) {
free(m_versionString);
m_versionString = NULL;
}
if (m_vendorString) {
free(m_vendorString);
m_vendorString = NULL;
}
if (m_extensionString) {
free(m_extensionString);
m_extensionString = NULL;
}
}
pthread_mutex_unlock(&m_lock);
}
EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *libName,
EGLClient_eglInterface *eglIface,
void **libHandle)
{
void *lib = dlopen(libName, RTLD_NOW);
if (!lib) {
ALOGE("Failed to dlopen %s", libName);
return NULL;
}
init_emul_gles_t init_gles_func = (init_emul_gles_t)dlsym(lib,"init_emul_gles");
if (!init_gles_func) {
ALOGE("Failed to find init_emul_gles");
dlclose((void*)lib);
return NULL;
}
*libHandle = lib;
return (*init_gles_func)(eglIface);
}
static char *queryHostEGLString(EGLint name)
{
HostConnection *hcon = HostConnection::get();
if (hcon) {
renderControl_encoder_context_t *rcEnc = hcon->rcEncoder();
if (rcEnc) {
int n = rcEnc->rcQueryEGLString(rcEnc, name, NULL, 0);
if (n < 0) {
// allocate space for the string with additional
// space charachter to be suffixed at the end.
char *str = (char *)malloc(-n+2);
n = rcEnc->rcQueryEGLString(rcEnc, name, str, -n);
if (n > 0) {
// add extra space at end of string which will be
// needed later when filtering the extension list.
strcat(str, " ");
return str;
}
free(str);
}
}
}
return NULL;
}
static bool findExtInList(const char* token, int tokenlen, const char* list)
{
const char* p = list;
while (*p != '\0') {
const char* q = strchr(p, ' ');
if (q == NULL) {
/* should not happen, list must be space-terminated */
break;
}
if (tokenlen == (q - p) && !memcmp(token, p, tokenlen)) {
return true; /* found it */
}
p = q+1;
}
return false; /* not found */
}
static char *buildExtensionString()
{
//Query host extension string
char *hostExt = queryHostEGLString(EGL_EXTENSIONS);
if (!hostExt || (hostExt[1] == '\0')) {
// no extensions on host - only static extension list supported
return strdup(systemStaticEGLExtensions);
}
int n = strlen(hostExt);
if (n > 0) {
char *str;
asprintf(&str,"%s%s", systemStaticEGLExtensions, hostExt);
free((char*)hostExt);
return str;
}
else {
free((char*)hostExt);
return strdup(systemStaticEGLExtensions);
}
}
const char *eglDisplay::queryString(EGLint name)
{
if (name == EGL_CLIENT_APIS) {
return "OpenGL_ES";
}
else if (name == EGL_VERSION) {
pthread_mutex_lock(&m_lock);
if (m_versionString) {
pthread_mutex_unlock(&m_lock);
return m_versionString;
}
// build version string
asprintf(&m_versionString, "%d.%d", m_major, m_minor);
pthread_mutex_unlock(&m_lock);
return m_versionString;
}
else if (name == EGL_VENDOR) {
pthread_mutex_lock(&m_lock);
if (m_vendorString) {
pthread_mutex_unlock(&m_lock);
return m_vendorString;
}
// build vendor string
const char *hostVendor = queryHostEGLString(EGL_VENDOR);
if (hostVendor) {
asprintf(&m_vendorString, "%s Host: %s",
systemEGLVendor, hostVendor);
free((char*)hostVendor);
}
else {
m_vendorString = (char *)systemEGLVendor;
}
pthread_mutex_unlock(&m_lock);
return m_vendorString;
}
else if (name == EGL_EXTENSIONS) {
pthread_mutex_lock(&m_lock);
if (m_extensionString) {
pthread_mutex_unlock(&m_lock);
return m_extensionString;
}
// build extension string
m_extensionString = buildExtensionString();
pthread_mutex_unlock(&m_lock);
return m_extensionString;
}
else {
ALOGE("[%s] Unknown name %d\n", __FUNCTION__, name);
return NULL;
}
}
/* To get the value of attribute <a> of config <c> use the following formula:
* value = *(m_configs + (int)c*m_numConfigAttribs + a);
*/
EGLBoolean eglDisplay::getAttribValue(EGLConfig config, EGLint attribIdx, EGLint * value)
{
if (attribIdx == ATTRIBUTE_NONE)
{
ALOGE("[%s] Bad attribute idx\n", __FUNCTION__);
return EGL_FALSE;
}
*value = *(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx);
return EGL_TRUE;
}
EGLBoolean eglDisplay::getConfigAttrib(EGLConfig config, EGLint attrib, EGLint * value)
{
//Though it seems that valueFor() is thread-safe, we don't take chanses
pthread_mutex_lock(&m_lock);
EGLBoolean ret = getAttribValue(config, m_attribs.valueFor(attrib), value);
pthread_mutex_unlock(&m_lock);
return ret;
}
void eglDisplay::dumpConfig(EGLConfig config)
{
EGLint value = 0;
DBG("^^^^^^^^^^ dumpConfig %d ^^^^^^^^^^^^^^^^^^", (int)config);
for (int i=0; i<m_numConfigAttribs; i++) {
getAttribValue(config, i, &value);
DBG("{%d}[%d] %d\n", (int)config, i, value);
}
}
/* To set the value of attribute <a> of config <c> use the following formula:
* *(m_configs + (int)c*m_numConfigAttribs + a) = value;
*/
EGLBoolean eglDisplay::setAttribValue(EGLConfig config, EGLint attribIdx, EGLint value)
{
if (attribIdx == ATTRIBUTE_NONE)
{
ALOGE("[%s] Bad attribute idx\n", __FUNCTION__);
return EGL_FALSE;
}
*(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx) = value;
return EGL_TRUE;
}
EGLBoolean eglDisplay::setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value)
{
//Though it seems that valueFor() is thread-safe, we don't take chanses
pthread_mutex_lock(&m_lock);
EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value);
pthread_mutex_unlock(&m_lock);
return ret;
}
EGLBoolean eglDisplay::getConfigNativePixelFormat(EGLConfig config, PixelFormat * format)
{
EGLint redSize, blueSize, greenSize, alphaSize;
if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
{
ALOGE("Couldn't find value for one of the pixel format attributes");
return EGL_FALSE;
}
//calculate the GL internal format
if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==8)) *format = PIXEL_FORMAT_RGBA_8888; //XXX: BGR?
else if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGBX_8888; //XXX or PIXEL_FORMAT_RGB_888
else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGB_565;
else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = PIXEL_FORMAT_RGBA_5551;
else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = PIXEL_FORMAT_RGBA_4444;
else {
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLBoolean eglDisplay::getConfigGLPixelFormat(EGLConfig config, GLenum * format)
{
EGLint redSize, blueSize, greenSize, alphaSize;
if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
{
ALOGE("Couldn't find value for one of the pixel format attributes");
return EGL_FALSE;
}
//calculate the GL internal format
if ((redSize == greenSize) && (redSize == blueSize) &&
((redSize == 8) || (redSize == 16) || (redSize == 32)))
{
if (alphaSize == 0) *format = GL_RGB;
else *format = GL_RGBA;
}
else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = GL_RGB565_OES;
else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = GL_RGB5_A1_OES;
else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = GL_RGBA4_OES;
else return EGL_FALSE;
return EGL_TRUE;
}

89
android/opengl/system/egl/eglDisplay.h Normal file
View file

@ -0,0 +1,89 @@
/*
* Copyright (C) 2011 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 _SYSTEM_EGL_DISPLAY_H
#define _SYSTEM_EGL_DISPLAY_H
#include <pthread.h>
#include "glUtils.h"
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "EGLClientIface.h"
#include <utils/KeyedVector.h>
#include <ui/PixelFormat.h>
#define ATTRIBUTE_NONE -1
//FIXME: are we in this namespace?
using namespace android;
class eglDisplay
{
public:
eglDisplay();
~eglDisplay();
bool initialize(EGLClient_eglInterface *eglIface);
void terminate();
int getVersionMajor() const { return m_major; }
int getVersionMinor() const { return m_minor; }
bool initialized() const { return m_initialized; }
const char *queryString(EGLint name);
const EGLClient_glesInterface *gles_iface() const { return m_gles_iface; }
const EGLClient_glesInterface *gles2_iface() const { return m_gles2_iface; }
int getNumConfigs(){ return m_numConfigs; }
EGLBoolean getConfigAttrib(EGLConfig config, EGLint attrib, EGLint * value);
EGLBoolean setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value);
EGLBoolean getConfigGLPixelFormat(EGLConfig config, GLenum * format);
EGLBoolean getConfigNativePixelFormat(EGLConfig config, PixelFormat * format);
void dumpConfig(EGLConfig config);
private:
EGLClient_glesInterface *loadGLESClientAPI(const char *libName,
EGLClient_eglInterface *eglIface,
void **libHandle);
EGLBoolean getAttribValue(EGLConfig config, EGLint attribIdxi, EGLint * value);
EGLBoolean setAttribValue(EGLConfig config, EGLint attribIdxi, EGLint value);
void processConfigs();
private:
pthread_mutex_t m_lock;
bool m_initialized;
int m_major;
int m_minor;
int m_hostRendererVersion;
int m_numConfigs;
int m_numConfigAttribs;
/* This is the mapping between an attribute name to it's index in any given config */
DefaultKeyedVector<EGLint, EGLint> m_attribs;
/* This is an array of all config's attributes values stored in the following sequencial fasion (read: v[c,a] = the value of attribute <a> of config <c>)
* v[0,0],..,v[0,m_numConfigAttribs-1],
*...
* v[m_numConfigs-1,0],..,v[m_numConfigs-1,m_numConfigAttribs-1]
*/
EGLint *m_configs;
EGLClient_glesInterface *m_gles_iface;
EGLClient_glesInterface *m_gles2_iface;
char *m_versionString;
char *m_vendorString;
char *m_extensionString;
};
#endif

64
android/opengl/system/egl/egl_ftable.h Normal file
View file

@ -0,0 +1,64 @@
/*
* Copyright (C) 2011 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.
*/
static const struct _egl_funcs_by_name {
const char *name;
void *proc;
} egl_funcs_by_name[] = {
{"eglGetError", (void *)eglGetError},
{"eglGetDisplay", (void *)eglGetDisplay},
{"eglInitialize", (void *)eglInitialize},
{"eglTerminate", (void *)eglTerminate},
{"eglQueryString", (void *)eglQueryString},
{"eglGetConfigs", (void *)eglGetConfigs},
{"eglChooseConfig", (void *)eglChooseConfig},
{"eglGetConfigAttrib", (void *)eglGetConfigAttrib},
{"eglCreateWindowSurface", (void *)eglCreateWindowSurface},
{"eglCreatePbufferSurface", (void *)eglCreatePbufferSurface},
{"eglCreatePixmapSurface", (void *)eglCreatePixmapSurface},
{"eglDestroySurface", (void *)eglDestroySurface},
{"eglQuerySurface", (void *)eglQuerySurface},
{"eglBindAPI", (void *)eglBindAPI},
{"eglQueryAPI", (void *)eglQueryAPI},
{"eglWaitClient", (void *)eglWaitClient},
{"eglReleaseThread", (void *)eglReleaseThread},
{"eglCreatePbufferFromClientBuffer", (void *)eglCreatePbufferFromClientBuffer},
{"eglSurfaceAttrib", (void *)eglSurfaceAttrib},
{"eglBindTexImage", (void *)eglBindTexImage},
{"eglReleaseTexImage", (void *)eglReleaseTexImage},
{"eglSwapInterval", (void *)eglSwapInterval},
{"eglCreateContext", (void *)eglCreateContext},
{"eglDestroyContext", (void *)eglDestroyContext},
{"eglMakeCurrent", (void *)eglMakeCurrent},
{"eglGetCurrentContext", (void *)eglGetCurrentContext},
{"eglGetCurrentSurface", (void *)eglGetCurrentSurface},
{"eglGetCurrentDisplay", (void *)eglGetCurrentDisplay},
{"eglQueryContext", (void *)eglQueryContext},
{"eglWaitGL", (void *)eglWaitGL},
{"eglWaitNative", (void *)eglWaitNative},
{"eglSwapBuffers", (void *)eglSwapBuffers},
{"eglCopyBuffers", (void *)eglCopyBuffers},
{"eglGetProcAddress", (void *)eglGetProcAddress},
{"eglLockSurfaceKHR", (void *)eglLockSurfaceKHR},
{"eglUnlockSurfaceKHR", (void *)eglUnlockSurfaceKHR},
{"eglCreateImageKHR", (void *)eglCreateImageKHR},
{"eglDestroyImageKHR", (void *)eglDestroyImageKHR},
{"eglCreateSyncKHR", (void *)eglCreateSyncKHR},
{"eglDestroySyncKHR", (void *)eglDestroySyncKHR},
{"eglClientWaitSyncKHR", (void *)eglClientWaitSyncKHR},
{"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR}
};
static const int egl_num_funcs = sizeof(egl_funcs_by_name) / sizeof(struct _egl_funcs_by_name);