1664 lines
53 KiB
C++
1664 lines
53 KiB
C++
/*
|
|
** Copyright 2007, 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 "GLLogger"
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <dlfcn.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#if HAVE_ANDROID_OS
|
|
#include <linux/android_pmem.h>
|
|
#endif
|
|
|
|
#include <GLES/egl.h>
|
|
|
|
#include <cutils/log.h>
|
|
#include <cutils/atomic.h>
|
|
#include <cutils/properties.h>
|
|
#include <cutils/memory.h>
|
|
|
|
#include <utils/IMemory.h>
|
|
#include <utils/KeyedVector.h>
|
|
#include <utils/threads.h>
|
|
#include <utils/IServiceManager.h>
|
|
#include <utils/IPCThreadState.h>
|
|
#include <utils/Parcel.h>
|
|
|
|
#include <ui/EGLDisplaySurface.h>
|
|
#include <ui/ISurfaceComposer.h>
|
|
|
|
#include "gl_logger.h"
|
|
|
|
#undef NELEM
|
|
|
|
#define GL_LOGGER 0
|
|
#define USE_SLOW_BINDING 0
|
|
#define NELEM(x) (sizeof(x)/sizeof(*(x)))
|
|
#define MAX_NUMBER_OF_GL_EXTENSIONS 32
|
|
#define MAKE_CONFIG(_impl, _index) ((EGLConfig)(((_impl)<<24) | (_index)))
|
|
#define setError(_e, _r) setErrorEtc(__FUNCTION__, __LINE__, _e, _r)
|
|
|
|
// ----------------------------------------------------------------------------
|
|
namespace android {
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// EGLDisplay are global, not attached to a given thread
|
|
static const unsigned int NUM_DISPLAYS = 1;
|
|
static const unsigned int IMPL_HARDWARE = 0;
|
|
static const unsigned int IMPL_SOFTWARE = 1;
|
|
static const unsigned int IMPL_HARDWARE_CONTEXT_LOST = 2;
|
|
static const unsigned int IMPL_SOFTWARE_CONTEXT_LOST = 3;
|
|
static const unsigned int IMPL_NO_CONTEXT = 4;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct gl_hooks_t;
|
|
|
|
struct egl_connection_t
|
|
{
|
|
void volatile * dso;
|
|
gl_hooks_t * hooks;
|
|
EGLint major;
|
|
EGLint minor;
|
|
int unavailable;
|
|
};
|
|
|
|
template <int MAGIC>
|
|
struct egl_object_t
|
|
{
|
|
egl_object_t() : magic(MAGIC) { }
|
|
~egl_object_t() { magic = 0; }
|
|
bool isValid() const { return magic == MAGIC; }
|
|
private:
|
|
uint32_t magic;
|
|
};
|
|
|
|
struct egl_display_t : public egl_object_t<'_dpy'>
|
|
{
|
|
EGLDisplay dpys[2];
|
|
EGLConfig* configs[2];
|
|
EGLint numConfigs[2];
|
|
EGLint numTotalConfigs;
|
|
char const* extensionsString;
|
|
volatile int32_t refs;
|
|
struct strings_t {
|
|
char const * vendor;
|
|
char const * version;
|
|
char const * clientApi;
|
|
char const * extensions;
|
|
char const * extensions_config;
|
|
};
|
|
strings_t queryString[2];
|
|
};
|
|
|
|
struct egl_surface_t : public egl_object_t<'_srf'>
|
|
{
|
|
egl_surface_t(EGLDisplay dpy, EGLSurface surface,
|
|
NativeWindowType window, int impl, egl_connection_t const* cnx)
|
|
: dpy(dpy), surface(surface), window(window), impl(impl), cnx(cnx)
|
|
{
|
|
// NOTE: window must be incRef'ed and connected already
|
|
}
|
|
~egl_surface_t() {
|
|
if (window) {
|
|
if (window->disconnect)
|
|
window->disconnect(window);
|
|
window->decRef(window);
|
|
}
|
|
}
|
|
EGLDisplay dpy;
|
|
EGLSurface surface;
|
|
NativeWindowType window;
|
|
int impl;
|
|
egl_connection_t const* cnx;
|
|
};
|
|
|
|
struct egl_context_t : public egl_object_t<'_ctx'>
|
|
{
|
|
egl_context_t(EGLDisplay dpy, EGLContext context,
|
|
int impl, egl_connection_t const* cnx)
|
|
: dpy(dpy), context(context), read(0), draw(0), impl(impl), cnx(cnx)
|
|
{
|
|
}
|
|
EGLDisplay dpy;
|
|
EGLContext context;
|
|
EGLSurface read;
|
|
EGLSurface draw;
|
|
int impl;
|
|
egl_connection_t const* cnx;
|
|
};
|
|
|
|
struct tls_t
|
|
{
|
|
tls_t() : error(EGL_SUCCESS), ctx(0) { }
|
|
EGLint error;
|
|
EGLContext ctx;
|
|
};
|
|
|
|
|
|
// GL / EGL hooks
|
|
|
|
typedef void(*proc_t)();
|
|
|
|
struct gl_hooks_t {
|
|
struct gl_t {
|
|
#define GL_ENTRY(_r, _api, ...) _r (*_api)(__VA_ARGS__);
|
|
#include "gl_entries.cpp"
|
|
#undef GL_ENTRY
|
|
} gl;
|
|
struct egl_t {
|
|
#define EGL_ENTRY(_r, _api, ...) _r (*_api)(__VA_ARGS__);
|
|
#include "egl_entries.cpp"
|
|
#undef EGL_ENTRY
|
|
} egl;
|
|
struct gl_ext_t {
|
|
void (*extensions[MAX_NUMBER_OF_GL_EXTENSIONS])(void);
|
|
} ext;
|
|
};
|
|
|
|
static char const * const gl_names[] = {
|
|
#define GL_ENTRY(_r, _api, ...) #_api,
|
|
#include "gl_entries.cpp"
|
|
#undef GL_ENTRY
|
|
NULL
|
|
};
|
|
|
|
static char const * const egl_names[] = {
|
|
#define EGL_ENTRY(_r, _api, ...) #_api,
|
|
#include "egl_entries.cpp"
|
|
#undef EGL_ENTRY
|
|
NULL
|
|
};
|
|
|
|
static void gl_unimplemented() {
|
|
LOGE("called unimplemented OpenGL ES API");
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static egl_connection_t gEGLImpl[2];
|
|
static egl_display_t gDisplay[NUM_DISPLAYS];
|
|
static gl_hooks_t gHooks[5];
|
|
static pthread_mutex_t gThreadLocalStorageKeyMutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_key_t gEGLThreadLocalStorageKey = -1;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if defined(HAVE_ANDROID_OS) && !USE_SLOW_BINDING && !GL_LOGGER
|
|
|
|
#include <sys/tls.h>
|
|
// We have a dedicated TLS slot in bionic
|
|
static inline void setGlThreadSpecific(gl_hooks_t const *value) {
|
|
((uint32_t *)__get_tls())[TLS_SLOT_OPENGL_API] = (uint32_t)value;
|
|
}
|
|
static gl_hooks_t const* getGlThreadSpecific() {
|
|
gl_hooks_t const* hooks = (gl_hooks_t const *)(((unsigned const *)__get_tls())[TLS_SLOT_OPENGL_API]);
|
|
if (hooks) return hooks;
|
|
return &gHooks[IMPL_NO_CONTEXT];
|
|
}
|
|
|
|
#else
|
|
|
|
static pthread_key_t gGLWrapperKey = -1;
|
|
static inline void setGlThreadSpecific(gl_hooks_t const *value) {
|
|
pthread_setspecific(gGLWrapperKey, value);
|
|
}
|
|
static gl_hooks_t const* getGlThreadSpecific() {
|
|
gl_hooks_t const* hooks = static_cast<gl_hooks_t*>(pthread_getspecific(gGLWrapperKey));
|
|
if (hooks) return hooks;
|
|
return &gHooks[IMPL_NO_CONTEXT];
|
|
}
|
|
|
|
#endif
|
|
|
|
static __attribute__((noinline))
|
|
const char *egl_strerror(EGLint err)
|
|
{
|
|
switch (err){
|
|
case EGL_SUCCESS: return "EGL_SUCCESS";
|
|
case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
|
|
case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
|
|
case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
|
|
case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
|
|
case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
|
|
case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
|
|
case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
|
|
case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
|
|
case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
|
|
case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
|
|
case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
|
|
case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
|
|
case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
|
|
case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
|
|
default: return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
void clearTLS() {
|
|
if (gEGLThreadLocalStorageKey != -1) {
|
|
tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
|
|
if (tls) {
|
|
delete tls;
|
|
pthread_setspecific(gEGLThreadLocalStorageKey, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static tls_t* getTLS()
|
|
{
|
|
tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
|
|
if (tls == 0) {
|
|
tls = new tls_t;
|
|
pthread_setspecific(gEGLThreadLocalStorageKey, tls);
|
|
}
|
|
return tls;
|
|
}
|
|
|
|
template<typename T>
|
|
static __attribute__((noinline))
|
|
T setErrorEtc(const char* caller, int line, EGLint error, T returnValue) {
|
|
if (gEGLThreadLocalStorageKey == -1) {
|
|
pthread_mutex_lock(&gThreadLocalStorageKeyMutex);
|
|
if (gEGLThreadLocalStorageKey == -1)
|
|
pthread_key_create(&gEGLThreadLocalStorageKey, NULL);
|
|
pthread_mutex_unlock(&gThreadLocalStorageKeyMutex);
|
|
}
|
|
tls_t* tls = getTLS();
|
|
if (tls->error != error) {
|
|
LOGE("%s:%d error %x (%s)", caller, line, error, egl_strerror(error));
|
|
tls->error = error;
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
GLint getError() {
|
|
if (gEGLThreadLocalStorageKey == -1)
|
|
return EGL_SUCCESS;
|
|
tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
|
|
if (!tls) return EGL_SUCCESS;
|
|
GLint error = tls->error;
|
|
tls->error = EGL_SUCCESS;
|
|
return error;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
void setContext(EGLContext ctx) {
|
|
if (gEGLThreadLocalStorageKey == -1) {
|
|
pthread_mutex_lock(&gThreadLocalStorageKeyMutex);
|
|
if (gEGLThreadLocalStorageKey == -1)
|
|
pthread_key_create(&gEGLThreadLocalStorageKey, NULL);
|
|
pthread_mutex_unlock(&gThreadLocalStorageKeyMutex);
|
|
}
|
|
tls_t* tls = getTLS();
|
|
tls->ctx = ctx;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
EGLContext getContext() {
|
|
if (gEGLThreadLocalStorageKey == -1)
|
|
return EGL_NO_CONTEXT;
|
|
tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
|
|
if (!tls) return EGL_NO_CONTEXT;
|
|
return tls->ctx;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/*
|
|
* we provide our own allocators for the GPU regions, these
|
|
* allocators go through surfaceflinger
|
|
*/
|
|
|
|
static Mutex gRegionsLock;
|
|
static request_gpu_t gRegions;
|
|
static sp<ISurfaceComposer> gSurfaceManager;
|
|
ISurfaceComposer* GLES_localSurfaceManager = 0;
|
|
|
|
const sp<ISurfaceComposer>& getSurfaceFlinger()
|
|
{
|
|
Mutex::Autolock _l(gRegionsLock);
|
|
|
|
/*
|
|
* There is a little bit of voodoo magic here. We want to access
|
|
* surfaceflinger for allocating GPU regions, however, when we are
|
|
* running as part of surfaceflinger, we want to bypass the
|
|
* service manager because surfaceflinger might not be registered yet.
|
|
* SurfaceFlinger will populate "GLES_localSurfaceManager" with its
|
|
* own address, so we can just use that.
|
|
*/
|
|
if (gSurfaceManager == 0) {
|
|
if (GLES_localSurfaceManager) {
|
|
// we're running in SurfaceFlinger's context
|
|
gSurfaceManager = GLES_localSurfaceManager;
|
|
} else {
|
|
// we're a remote process or not part of surfaceflinger,
|
|
// go through the service manager
|
|
sp<IServiceManager> sm = defaultServiceManager();
|
|
if (sm != NULL) {
|
|
sp<IBinder> binder = sm->getService(String16("SurfaceFlinger"));
|
|
gSurfaceManager = interface_cast<ISurfaceComposer>(binder);
|
|
}
|
|
}
|
|
}
|
|
return gSurfaceManager;
|
|
}
|
|
|
|
class GPURevokeRequester : public BnGPUCallback
|
|
{
|
|
public:
|
|
virtual void gpuLost() {
|
|
LOGD("CONTEXT_LOST: Releasing GPU upon request from SurfaceFlinger.");
|
|
gEGLImpl[IMPL_HARDWARE].hooks = &gHooks[IMPL_HARDWARE_CONTEXT_LOST];
|
|
}
|
|
};
|
|
|
|
static sp<GPURevokeRequester> gRevokerCallback;
|
|
|
|
static request_gpu_t* gpu_acquire(void* user)
|
|
{
|
|
sp<ISurfaceComposer> server( getSurfaceFlinger() );
|
|
|
|
Mutex::Autolock _l(gRegionsLock);
|
|
if (server == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
ISurfaceComposer::gpu_info_t info;
|
|
gRevokerCallback = new GPURevokeRequester();
|
|
status_t err = server->requestGPU(gRevokerCallback, &info);
|
|
if (err != NO_ERROR) {
|
|
LOGD("requestGPU returned %d", err);
|
|
return 0;
|
|
}
|
|
|
|
bool failed = false;
|
|
request_gpu_t* gpu = &gRegions;
|
|
memset(gpu, 0, sizeof(*gpu));
|
|
|
|
if (info.regs != 0) {
|
|
sp<IMemoryHeap> heap(info.regs->getMemory());
|
|
if (heap != 0) {
|
|
int fd = heap->heapID();
|
|
gpu->regs.fd = fd;
|
|
gpu->regs.base = info.regs->pointer();
|
|
gpu->regs.size = info.regs->size();
|
|
gpu->regs.user = info.regs.get();
|
|
#if HAVE_ANDROID_OS
|
|
struct pmem_region region;
|
|
if (ioctl(fd, PMEM_GET_PHYS, ®ion) >= 0)
|
|
gpu->regs.phys = (void*)region.offset;
|
|
#endif
|
|
info.regs->incStrong(gpu);
|
|
} else {
|
|
LOGE("GPU register handle %p is invalid!", info.regs.get());
|
|
failed = true;
|
|
}
|
|
}
|
|
|
|
for (size_t i=0 ; i<info.count && !failed ; i++) {
|
|
sp<IMemory>& region(info.regions[i].region);
|
|
if (region != 0) {
|
|
sp<IMemoryHeap> heap(region->getMemory());
|
|
if (heap != 0) {
|
|
const int fd = heap->heapID();
|
|
gpu->gpu[i].fd = fd;
|
|
gpu->gpu[i].base = region->pointer();
|
|
gpu->gpu[i].size = region->size();
|
|
gpu->gpu[i].user = region.get();
|
|
gpu->gpu[i].offset = info.regions[i].reserved;
|
|
#if HAVE_ANDROID_OS
|
|
struct pmem_region reg;
|
|
if (ioctl(fd, PMEM_GET_PHYS, ®) >= 0)
|
|
gpu->gpu[i].phys = (void*)reg.offset;
|
|
#endif
|
|
region->incStrong(gpu);
|
|
} else {
|
|
LOGE("GPU region handle [%d, %p] is invalid!", i, region.get());
|
|
failed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (failed) {
|
|
// something went wrong, clean up everything!
|
|
if (gpu->regs.user) {
|
|
static_cast<IMemory*>(gpu->regs.user)->decStrong(gpu);
|
|
for (size_t i=0 ; i<info.count ; i++) {
|
|
if (gpu->gpu[i].user) {
|
|
static_cast<IMemory*>(gpu->gpu[i].user)->decStrong(gpu);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
gpu->count = info.count;
|
|
return gpu;
|
|
}
|
|
|
|
static int gpu_release(void*, request_gpu_t* gpu)
|
|
{
|
|
sp<IMemory> regs;
|
|
|
|
{ // scope for lock
|
|
Mutex::Autolock _l(gRegionsLock);
|
|
regs = static_cast<IMemory*>(gpu->regs.user);
|
|
gpu->regs.user = 0;
|
|
if (regs != 0) regs->decStrong(gpu);
|
|
|
|
for (int i=0 ; i<gpu->count ; i++) {
|
|
sp<IMemory> r(static_cast<IMemory*>(gpu->gpu[i].user));
|
|
gpu->gpu[i].user = 0;
|
|
if (r != 0) r->decStrong(gpu);
|
|
}
|
|
}
|
|
|
|
// there is a special transaction to relinquish the GPU
|
|
// (it will happen automatically anyway if we don't do this)
|
|
Parcel data, reply;
|
|
// NOTE: this transaction does not require an interface token
|
|
regs->asBinder()->transact(1000, data, &reply);
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static __attribute__((noinline))
|
|
void *load_driver(const char* driver, gl_hooks_t* hooks)
|
|
{
|
|
void* dso = dlopen(driver, RTLD_NOW | RTLD_LOCAL);
|
|
LOGE_IF(!dso,
|
|
"couldn't load <%s> library (%s)",
|
|
driver, dlerror());
|
|
|
|
if (dso) {
|
|
void** curr;
|
|
char const * const * api;
|
|
gl_hooks_t::gl_t* gl = &hooks->gl;
|
|
curr = (void**)gl;
|
|
api = gl_names;
|
|
while (*api) {
|
|
void* f = dlsym(dso, *api);
|
|
//LOGD("<%s> @ 0x%p", *api, f);
|
|
if (f == NULL) {
|
|
//LOGW("<%s> not found in %s", *api, driver);
|
|
f = (void*)gl_unimplemented;
|
|
}
|
|
*curr++ = f;
|
|
api++;
|
|
}
|
|
gl_hooks_t::egl_t* egl = &hooks->egl;
|
|
curr = (void**)egl;
|
|
api = egl_names;
|
|
while (*api) {
|
|
void* f = dlsym(dso, *api);
|
|
if (f == NULL) {
|
|
//LOGW("<%s> not found in %s", *api, driver);
|
|
f = (void*)0;
|
|
}
|
|
*curr++ = f;
|
|
api++;
|
|
}
|
|
|
|
// hook this driver up with surfaceflinger if needed
|
|
register_gpu_t register_gpu =
|
|
(register_gpu_t)dlsym(dso, "oem_register_gpu");
|
|
|
|
if (register_gpu != NULL) {
|
|
if (getSurfaceFlinger() != 0) {
|
|
register_gpu(dso, gpu_acquire, gpu_release);
|
|
}
|
|
}
|
|
}
|
|
return dso;
|
|
}
|
|
|
|
template<typename T>
|
|
static __attribute__((noinline))
|
|
int binarySearch(
|
|
T const sortedArray[], int first, int last, T key)
|
|
{
|
|
while (first <= last) {
|
|
int mid = (first + last) / 2;
|
|
if (key > sortedArray[mid]) {
|
|
first = mid + 1;
|
|
} else if (key < sortedArray[mid]) {
|
|
last = mid - 1;
|
|
} else {
|
|
return mid;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int cmp_configs(const void* a, const void *b)
|
|
{
|
|
EGLConfig c0 = *(EGLConfig const *)a;
|
|
EGLConfig c1 = *(EGLConfig const *)b;
|
|
return c0<c1 ? -1 : (c0>c1 ? 1 : 0);
|
|
}
|
|
|
|
static char const * const gVendorString = "Android";
|
|
static char const * const gVersionString = "1.2 Android META-EGL";
|
|
static char const * const gClientApiString = "OpenGL ES";
|
|
|
|
struct extention_map_t {
|
|
const char* name;
|
|
void (*address)(void);
|
|
};
|
|
|
|
static const extention_map_t gExtentionMap[] = {
|
|
{ "eglSwapRectangleANDROID", (void(*)())&eglSwapRectangleANDROID },
|
|
{ "eglQueryStringConfigANDROID", (void(*)())&eglQueryStringConfigANDROID },
|
|
};
|
|
|
|
static extention_map_t gGLExtentionMap[MAX_NUMBER_OF_GL_EXTENSIONS];
|
|
|
|
static void(*findProcAddress(const char* name,
|
|
const extention_map_t* map, size_t n))()
|
|
{
|
|
for (uint32_t i=0 ; i<n ; i++) {
|
|
if (!strcmp(name, map[i].name)) {
|
|
return map[i].address;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// extensions for the framework
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
|
|
const GLvoid *ptr, GLsizei count) {
|
|
glColorPointer(size, type, stride, ptr);
|
|
}
|
|
void glNormalPointerBounds(GLenum type, GLsizei stride,
|
|
const GLvoid *pointer, GLsizei count) {
|
|
glNormalPointer(type, stride, pointer);
|
|
}
|
|
void glTexCoordPointerBounds(GLint size, GLenum type,
|
|
GLsizei stride, const GLvoid *pointer, GLsizei count) {
|
|
glTexCoordPointer(size, type, stride, pointer);
|
|
}
|
|
void glVertexPointerBounds(GLint size, GLenum type,
|
|
GLsizei stride, const GLvoid *pointer, GLsizei count) {
|
|
glVertexPointer(size, type, stride, pointer);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Actual GL wrappers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if __OPTIMIZE__ && defined(__arm__) && !defined(__thumb__) && !USE_SLOW_BINDING && !GL_LOGGER
|
|
|
|
#define API_ENTRY(_api) __attribute__((naked)) _api
|
|
#define CALL_GL_API(_api, ...) \
|
|
asm volatile( \
|
|
"mov r12, #0xFFFF0FFF \n" \
|
|
"ldr r12, [r12, #-15] \n" \
|
|
"ldr r12, [r12, %[tls]] \n" \
|
|
"cmp r12, #0 \n" \
|
|
"ldrne pc, [r12, %[api]] \n" \
|
|
"bx lr \n" \
|
|
: \
|
|
: [tls] "J"(TLS_SLOT_OPENGL_API*4), \
|
|
[api] "J"(__builtin_offsetof(gl_hooks_t, gl._api)) \
|
|
: \
|
|
);
|
|
|
|
#define CALL_GL_API_RETURN(_api, ...) \
|
|
CALL_GL_API(_api, __VA_ARGS__) \
|
|
return 0; // placate gcc's warnings. never reached.
|
|
|
|
#else
|
|
|
|
#define API_ENTRY(_api) _api
|
|
#if GL_LOGGER
|
|
|
|
#define CALL_GL_API(_api, ...) \
|
|
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
|
|
log_##_api(__VA_ARGS__); \
|
|
_c->_api(__VA_ARGS__);
|
|
|
|
#define CALL_GL_API_RETURN(_api, ...) \
|
|
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
|
|
log_##_api(__VA_ARGS__); \
|
|
return _c->_api(__VA_ARGS__)
|
|
|
|
#else
|
|
|
|
#define CALL_GL_API(_api, ...) \
|
|
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
|
|
_c->_api(__VA_ARGS__);
|
|
|
|
#define CALL_GL_API_RETURN(_api, ...) \
|
|
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
|
|
return _c->_api(__VA_ARGS__)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#include "gl_api.cpp"
|
|
|
|
#undef API_ENTRY
|
|
#undef CALL_GL_API
|
|
#undef CALL_GL_API_RETURN
|
|
|
|
// ----------------------------------------------------------------------------
|
|
namespace android {
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static int gl_context_lost() {
|
|
setGlThreadSpecific(&gHooks[IMPL_HARDWARE_CONTEXT_LOST]);
|
|
return 0;
|
|
}
|
|
static int egl_context_lost() {
|
|
setGlThreadSpecific(&gHooks[IMPL_HARDWARE_CONTEXT_LOST]);
|
|
return EGL_FALSE;
|
|
}
|
|
static EGLBoolean egl_context_lost_swap_buffers(void*, void*) {
|
|
usleep(100000); // don't use all the CPU
|
|
setGlThreadSpecific(&gHooks[IMPL_HARDWARE_CONTEXT_LOST]);
|
|
return EGL_FALSE;
|
|
}
|
|
static GLint egl_context_lost_get_error() {
|
|
return EGL_CONTEXT_LOST;
|
|
}
|
|
static int ext_context_lost() {
|
|
return 0;
|
|
}
|
|
|
|
static void gl_no_context() {
|
|
LOGE("call to OpenGL ES API with no current context");
|
|
}
|
|
static void early_egl_init(void)
|
|
{
|
|
#if !defined(HAVE_ANDROID_OS) || USE_SLOW_BINDING || GL_LOGGER
|
|
pthread_key_create(&gGLWrapperKey, NULL);
|
|
#endif
|
|
uint32_t addr = (uint32_t)((void*)gl_no_context);
|
|
android_memset32((uint32_t*)(void*)&gHooks[IMPL_NO_CONTEXT], addr, sizeof(gHooks[IMPL_NO_CONTEXT]));
|
|
setGlThreadSpecific(&gHooks[IMPL_NO_CONTEXT]);
|
|
}
|
|
|
|
static pthread_once_t once_control = PTHREAD_ONCE_INIT;
|
|
static int sEarlyInitState = pthread_once(&once_control, &early_egl_init);
|
|
|
|
|
|
static inline
|
|
egl_display_t* get_display(EGLDisplay dpy)
|
|
{
|
|
uintptr_t index = uintptr_t(dpy)-1U;
|
|
return (index >= NUM_DISPLAYS) ? NULL : &gDisplay[index];
|
|
}
|
|
|
|
static inline
|
|
egl_surface_t* get_surface(EGLSurface surface)
|
|
{
|
|
egl_surface_t* s = (egl_surface_t *)surface;
|
|
return s;
|
|
}
|
|
|
|
static inline
|
|
egl_context_t* get_context(EGLContext context)
|
|
{
|
|
egl_context_t* c = (egl_context_t *)context;
|
|
return c;
|
|
}
|
|
|
|
static egl_connection_t* validate_display_config(
|
|
EGLDisplay dpy, EGLConfig config,
|
|
egl_display_t const*& dp, int& impl, int& index)
|
|
{
|
|
dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, (egl_connection_t*)NULL);
|
|
|
|
impl = uintptr_t(config)>>24;
|
|
if (uint32_t(impl) >= 2) {
|
|
return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
|
|
}
|
|
index = uintptr_t(config) & 0xFFFFFF;
|
|
if (index >= dp->numConfigs[impl]) {
|
|
return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
|
|
}
|
|
egl_connection_t* const cnx = &gEGLImpl[impl];
|
|
if (cnx->dso == 0) {
|
|
return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
|
|
}
|
|
return cnx;
|
|
}
|
|
|
|
static EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx)
|
|
{
|
|
if ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS)
|
|
return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
if (!get_display(dpy)->isValid())
|
|
return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
if (!ctx) // TODO: make sure context is a valid object
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
if (!get_context(ctx)->isValid())
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
static EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface)
|
|
{
|
|
if ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS)
|
|
return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
if (!get_display(dpy)->isValid())
|
|
return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
if (!surface) // TODO: make sure surface is a valid object
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
if (!get_surface(surface)->isValid())
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
static void add_extension(egl_display_t* dp, char const*& p, const char* ext)
|
|
{
|
|
if (!strstr(p, ext)) {
|
|
p = (char const*)realloc((void*)p, strlen(p) + 1 + strlen(ext) + 1);
|
|
strcat((char*)p, " ");
|
|
strcat((char*)p, ext);
|
|
}
|
|
if (!strstr(dp->extensionsString, ext)) {
|
|
char const*& es = dp->extensionsString;
|
|
es = (char const*)realloc((void*)es, strlen(es) + 1 + strlen(ext) + 1);
|
|
strcat((char*)es, " ");
|
|
strcat((char*)es, ext);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLDisplay eglGetDisplay(NativeDisplayType display)
|
|
{
|
|
if (sEarlyInitState) {
|
|
return EGL_NO_DISPLAY;
|
|
}
|
|
|
|
uint32_t index = uint32_t(display);
|
|
if (index >= NUM_DISPLAYS) {
|
|
return EGL_NO_DISPLAY;
|
|
}
|
|
|
|
EGLDisplay dpy = EGLDisplay(uintptr_t(display) + 1LU);
|
|
egl_display_t* d = &gDisplay[index];
|
|
|
|
// dynamically load all our EGL implementations for that display
|
|
// and call into the real eglGetGisplay()
|
|
egl_connection_t* cnx = &gEGLImpl[IMPL_SOFTWARE];
|
|
if (cnx->dso == 0) {
|
|
cnx->hooks = &gHooks[IMPL_SOFTWARE];
|
|
cnx->dso = load_driver("libagl.so", cnx->hooks);
|
|
}
|
|
if (cnx->dso && d->dpys[IMPL_SOFTWARE]==EGL_NO_DISPLAY) {
|
|
d->dpys[IMPL_SOFTWARE] = cnx->hooks->egl.eglGetDisplay(display);
|
|
LOGE_IF(d->dpys[IMPL_SOFTWARE]==EGL_NO_DISPLAY,
|
|
"No EGLDisplay for software EGL!");
|
|
}
|
|
|
|
cnx = &gEGLImpl[IMPL_HARDWARE];
|
|
if (cnx->dso == 0 && cnx->unavailable == 0) {
|
|
char value[PROPERTY_VALUE_MAX];
|
|
property_get("debug.egl.hw", value, "1");
|
|
if (atoi(value) != 0) {
|
|
cnx->hooks = &gHooks[IMPL_HARDWARE];
|
|
cnx->dso = load_driver("libhgl.so", cnx->hooks);
|
|
} else {
|
|
LOGD("3D hardware acceleration is disabled");
|
|
}
|
|
}
|
|
if (cnx->dso && d->dpys[IMPL_HARDWARE]==EGL_NO_DISPLAY) {
|
|
android_memset32(
|
|
(uint32_t*)(void*)&gHooks[IMPL_HARDWARE_CONTEXT_LOST].gl,
|
|
(uint32_t)((void*)gl_context_lost),
|
|
sizeof(gHooks[IMPL_HARDWARE_CONTEXT_LOST].gl));
|
|
android_memset32(
|
|
(uint32_t*)(void*)&gHooks[IMPL_HARDWARE_CONTEXT_LOST].egl,
|
|
(uint32_t)((void*)egl_context_lost),
|
|
sizeof(gHooks[IMPL_HARDWARE_CONTEXT_LOST].egl));
|
|
android_memset32(
|
|
(uint32_t*)(void*)&gHooks[IMPL_HARDWARE_CONTEXT_LOST].ext,
|
|
(uint32_t)((void*)ext_context_lost),
|
|
sizeof(gHooks[IMPL_HARDWARE_CONTEXT_LOST].ext));
|
|
|
|
gHooks[IMPL_HARDWARE_CONTEXT_LOST].egl.eglSwapBuffers =
|
|
egl_context_lost_swap_buffers;
|
|
|
|
gHooks[IMPL_HARDWARE_CONTEXT_LOST].egl.eglGetError =
|
|
egl_context_lost_get_error;
|
|
|
|
gHooks[IMPL_HARDWARE_CONTEXT_LOST].egl.eglTerminate =
|
|
gHooks[IMPL_HARDWARE].egl.eglTerminate;
|
|
|
|
d->dpys[IMPL_HARDWARE] = cnx->hooks->egl.eglGetDisplay(display);
|
|
if (d->dpys[IMPL_HARDWARE] == EGL_NO_DISPLAY) {
|
|
dlclose((void*)cnx->dso);
|
|
cnx->dso = 0;
|
|
// in case of failure, we want to make sure we don't try again
|
|
// as it's expensive.
|
|
cnx->unavailable = 1;
|
|
}
|
|
}
|
|
|
|
return dpy;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Initialization
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
|
|
{
|
|
egl_display_t * const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
|
|
if (android_atomic_inc(&dp->refs) > 0) {
|
|
if (major != NULL) *major = 1;
|
|
if (minor != NULL) *minor = 2;
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
setGlThreadSpecific(&gHooks[IMPL_NO_CONTEXT]);
|
|
|
|
// initialize each EGL and
|
|
// build our own extension string first, based on the extension we know
|
|
// and the extension supported by our client implementation
|
|
dp->extensionsString = strdup("EGL_ANDROID_query_string_config");
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
cnx->major = -1;
|
|
cnx->minor = -1;
|
|
if (cnx->dso && cnx->hooks->egl.eglInitialize(
|
|
dp->dpys[i], &cnx->major, &cnx->minor)) {
|
|
|
|
//LOGD("initialized %d dpy=%p, ver=%d.%d, cnx=%p",
|
|
// i, dp->dpys[i], cnx->major, cnx->minor, cnx);
|
|
|
|
// get the query-strings for this display for each implementation
|
|
dp->queryString[i].vendor =
|
|
cnx->hooks->egl.eglQueryString(dp->dpys[i], EGL_VENDOR);
|
|
dp->queryString[i].version =
|
|
cnx->hooks->egl.eglQueryString(dp->dpys[i], EGL_VERSION);
|
|
dp->queryString[i].extensions = strdup(
|
|
cnx->hooks->egl.eglQueryString(dp->dpys[i], EGL_EXTENSIONS));
|
|
dp->queryString[i].clientApi =
|
|
cnx->hooks->egl.eglQueryString(dp->dpys[i], EGL_CLIENT_APIS);
|
|
|
|
// Dynamically insert extensions we know about
|
|
if (cnx->hooks->egl.eglSwapRectangleANDROID)
|
|
add_extension(dp, dp->queryString[i].extensions,
|
|
"EGL_ANDROID_swap_rectangle");
|
|
|
|
if (cnx->hooks->egl.eglQueryStringConfigANDROID)
|
|
add_extension(dp, dp->queryString[i].extensions,
|
|
"EGL_ANDROID_query_string_config");
|
|
}
|
|
}
|
|
|
|
// Build the extension list that depends on the current config.
|
|
// It is the intersection of our extension list and the
|
|
// underlaying EGL's extensions list
|
|
EGLBoolean res = EGL_FALSE;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso && cnx->major>=0 && cnx->minor>=0) {
|
|
char const* const their_extensions = dp->queryString[i].extensions;
|
|
char* our_extensions = strdup(dp->extensionsString);
|
|
char* const our_extensions_org = our_extensions;
|
|
char* extensions_config = (char*)calloc(strlen(our_extensions)+2, 1);
|
|
char* p;
|
|
do {
|
|
p = strchr(our_extensions, ' ');
|
|
if (p) *p++ = 0;
|
|
else p = strchr(our_extensions, 0);
|
|
if (strstr(their_extensions, our_extensions)) {
|
|
strcat(extensions_config, our_extensions);
|
|
strcat(extensions_config, " ");
|
|
}
|
|
our_extensions = p;
|
|
} while (*p);
|
|
free((void*)our_extensions_org);
|
|
|
|
// remove the trailling white space
|
|
if (extensions_config[0] != 0) {
|
|
size_t l = strlen(extensions_config) - 1; // new size
|
|
extensions_config[l] = 0; // remove the trailling white space
|
|
extensions_config = (char*)realloc(extensions_config, l+1);
|
|
} else {
|
|
extensions_config = (char*)realloc(extensions_config, 1);
|
|
}
|
|
dp->queryString[i].extensions_config = extensions_config;
|
|
|
|
EGLint n;
|
|
if (cnx->hooks->egl.eglGetConfigs(dp->dpys[i], 0, 0, &n)) {
|
|
dp->configs[i] = (EGLConfig*)malloc(sizeof(EGLConfig)*n);
|
|
if (dp->configs[i]) {
|
|
if (cnx->hooks->egl.eglGetConfigs(
|
|
dp->dpys[i], dp->configs[i], n, &dp->numConfigs[i]))
|
|
{
|
|
// sort the configurations so we can do binary searches
|
|
qsort( dp->configs[i],
|
|
dp->numConfigs[i],
|
|
sizeof(EGLConfig), cmp_configs);
|
|
|
|
dp->numTotalConfigs += n;
|
|
res = EGL_TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (res == EGL_TRUE) {
|
|
if (major != NULL) *major = 1;
|
|
if (minor != NULL) *minor = 2;
|
|
return EGL_TRUE;
|
|
}
|
|
return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
|
|
}
|
|
|
|
EGLBoolean eglTerminate(EGLDisplay dpy)
|
|
{
|
|
egl_display_t* const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
if (android_atomic_dec(&dp->refs) != 1)
|
|
return EGL_TRUE;
|
|
|
|
EGLBoolean res = EGL_FALSE;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
cnx->hooks->egl.eglTerminate(dp->dpys[i]);
|
|
|
|
/* REVISIT: it's unclear what to do if eglTerminate() fails,
|
|
* on one end we shouldn't care, on the other end if it fails
|
|
* it might not be safe to call dlclose() (there could be some
|
|
* threads around). */
|
|
|
|
free(dp->configs[i]);
|
|
free((void*)dp->queryString[i].extensions_config);
|
|
free((void*)dp->queryString[i].extensions);
|
|
dp->numConfigs[i] = 0;
|
|
dp->dpys[i] = EGL_NO_DISPLAY;
|
|
dlclose((void*)cnx->dso);
|
|
cnx->dso = 0;
|
|
res = EGL_TRUE;
|
|
}
|
|
}
|
|
free((void*)dp->extensionsString);
|
|
dp->extensionsString = 0;
|
|
dp->numTotalConfigs = 0;
|
|
clearTLS();
|
|
return res;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// configuration
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLBoolean eglGetConfigs( EGLDisplay dpy,
|
|
EGLConfig *configs,
|
|
EGLint config_size, EGLint *num_config)
|
|
{
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
|
|
GLint numConfigs = dp->numTotalConfigs;
|
|
if (!configs) {
|
|
*num_config = numConfigs;
|
|
return EGL_TRUE;
|
|
}
|
|
GLint n = 0;
|
|
for (int j=0 ; j<2 ; j++) {
|
|
for (int i=0 ; i<dp->numConfigs[j] && config_size ; i++) {
|
|
*configs++ = MAKE_CONFIG(j, i);
|
|
config_size--;
|
|
n++;
|
|
}
|
|
}
|
|
|
|
*num_config = n;
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
|
|
EGLConfig *configs, EGLint config_size,
|
|
EGLint *num_config)
|
|
{
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
|
|
if (configs == 0) {
|
|
*num_config = 0;
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
EGLBoolean res = EGL_FALSE;
|
|
*num_config = 0;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
EGLint n;
|
|
if (cnx->hooks->egl.eglChooseConfig(
|
|
dp->dpys[i], attrib_list, configs, config_size, &n))
|
|
{
|
|
// now we need to convert these client EGLConfig to our
|
|
// internal EGLConfig format. This is done in O(n log n).
|
|
for (int j=0 ; j<n ; j++) {
|
|
int index = binarySearch<EGLConfig>(
|
|
dp->configs[i], 0, dp->numConfigs[i]-1, configs[j]);
|
|
if (index >= 0) {
|
|
configs[j] = MAKE_CONFIG(i, index);
|
|
} else {
|
|
return setError(EGL_BAD_CONFIG, EGL_FALSE);
|
|
}
|
|
}
|
|
configs += n;
|
|
config_size -= n;
|
|
*num_config += n;
|
|
res = EGL_TRUE;
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
|
|
EGLint attribute, EGLint *value)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (!cnx) return EGL_FALSE;
|
|
return cnx->hooks->egl.eglGetConfigAttrib(
|
|
dp->dpys[i], dp->configs[i][index], attribute, value);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// surfaces
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
|
|
NativeWindowType window,
|
|
const EGLint *attrib_list)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (cnx) {
|
|
// window must be connected upon calling underlying
|
|
// eglCreateWindowSurface
|
|
if (window) {
|
|
window->incRef(window);
|
|
if (window->connect)
|
|
window->connect(window);
|
|
}
|
|
|
|
EGLSurface surface = cnx->hooks->egl.eglCreateWindowSurface(
|
|
dp->dpys[i], dp->configs[i][index], window, attrib_list);
|
|
if (surface != EGL_NO_SURFACE) {
|
|
egl_surface_t* s = new egl_surface_t(dpy, surface, window, i, cnx);
|
|
return s;
|
|
}
|
|
|
|
// something went wrong, disconnect and free window
|
|
// (will disconnect() automatically)
|
|
if (window) {
|
|
window->decRef(window);
|
|
}
|
|
}
|
|
return EGL_NO_SURFACE;
|
|
}
|
|
|
|
EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
|
|
NativePixmapType pixmap,
|
|
const EGLint *attrib_list)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (cnx) {
|
|
EGLSurface surface = cnx->hooks->egl.eglCreatePixmapSurface(
|
|
dp->dpys[i], dp->configs[i][index], pixmap, attrib_list);
|
|
if (surface != EGL_NO_SURFACE) {
|
|
egl_surface_t* s = new egl_surface_t(dpy, surface, NULL, i, cnx);
|
|
return s;
|
|
}
|
|
}
|
|
return EGL_NO_SURFACE;
|
|
}
|
|
|
|
EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
|
|
const EGLint *attrib_list)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (cnx) {
|
|
EGLSurface surface = cnx->hooks->egl.eglCreatePbufferSurface(
|
|
dp->dpys[i], dp->configs[i][index], attrib_list);
|
|
if (surface != EGL_NO_SURFACE) {
|
|
egl_surface_t* s = new egl_surface_t(dpy, surface, NULL, i, cnx);
|
|
return s;
|
|
}
|
|
}
|
|
return EGL_NO_SURFACE;
|
|
}
|
|
|
|
EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
|
|
EGLBoolean result = s->cnx->hooks->egl.eglDestroySurface(
|
|
dp->dpys[s->impl], s->surface);
|
|
|
|
delete s;
|
|
return result;
|
|
}
|
|
|
|
EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
|
|
EGLint attribute, EGLint *value)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
|
|
return s->cnx->hooks->egl.eglQuerySurface(
|
|
dp->dpys[s->impl], s->surface, attribute, value);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// contextes
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
|
|
EGLContext share_list, const EGLint *attrib_list)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (cnx) {
|
|
EGLContext context = cnx->hooks->egl.eglCreateContext(
|
|
dp->dpys[i], dp->configs[i][index], share_list, attrib_list);
|
|
if (context != EGL_NO_CONTEXT) {
|
|
egl_context_t* c = new egl_context_t(dpy, context, i, cnx);
|
|
return c;
|
|
}
|
|
}
|
|
return EGL_NO_CONTEXT;
|
|
}
|
|
|
|
EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
|
|
{
|
|
if (!validate_display_context(dpy, ctx))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_context_t * const c = get_context(ctx);
|
|
EGLBoolean result = c->cnx->hooks->egl.eglDestroyContext(
|
|
dp->dpys[c->impl], c->context);
|
|
delete c;
|
|
return result;
|
|
}
|
|
|
|
EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
|
|
EGLSurface read, EGLContext ctx)
|
|
{
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
|
|
if (read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE &&
|
|
ctx == EGL_NO_CONTEXT)
|
|
{
|
|
EGLBoolean result = EGL_TRUE;
|
|
ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t * const c = get_context(ctx);
|
|
result = c->cnx->hooks->egl.eglMakeCurrent(dp->dpys[c->impl], 0, 0, 0);
|
|
if (result == EGL_TRUE) {
|
|
setGlThreadSpecific(&gHooks[IMPL_NO_CONTEXT]);
|
|
setContext(EGL_NO_CONTEXT);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
if (!validate_display_context(dpy, ctx))
|
|
return EGL_FALSE;
|
|
|
|
egl_context_t * const c = get_context(ctx);
|
|
if (draw != EGL_NO_SURFACE) {
|
|
egl_surface_t const * d = get_surface(draw);
|
|
if (!d) return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
if (d->impl != c->impl)
|
|
return setError(EGL_BAD_MATCH, EGL_FALSE);
|
|
draw = d->surface;
|
|
}
|
|
if (read != EGL_NO_SURFACE) {
|
|
egl_surface_t const * r = get_surface(read);
|
|
if (!r) return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
if (r->impl != c->impl)
|
|
return setError(EGL_BAD_MATCH, EGL_FALSE);
|
|
read = r->surface;
|
|
}
|
|
EGLBoolean result = c->cnx->hooks->egl.eglMakeCurrent(
|
|
dp->dpys[c->impl], draw, read, c->context);
|
|
|
|
if (result == EGL_TRUE) {
|
|
setGlThreadSpecific(c->cnx->hooks);
|
|
setContext(ctx);
|
|
c->read = read;
|
|
c->draw = draw;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
|
|
EGLint attribute, EGLint *value)
|
|
{
|
|
if (!validate_display_context(dpy, ctx))
|
|
return EGL_FALSE;
|
|
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_context_t * const c = get_context(ctx);
|
|
|
|
return c->cnx->hooks->egl.eglQueryContext(
|
|
dp->dpys[c->impl], c->context, attribute, value);
|
|
}
|
|
|
|
EGLContext eglGetCurrentContext(void)
|
|
{
|
|
EGLContext ctx = getContext();
|
|
return ctx;
|
|
}
|
|
|
|
EGLSurface eglGetCurrentSurface(EGLint readdraw)
|
|
{
|
|
EGLContext ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t const * const c = get_context(ctx);
|
|
if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
|
|
switch (readdraw) {
|
|
case EGL_READ: return c->read;
|
|
case EGL_DRAW: return c->draw;
|
|
default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
|
|
}
|
|
}
|
|
return EGL_NO_SURFACE;
|
|
}
|
|
|
|
EGLDisplay eglGetCurrentDisplay(void)
|
|
{
|
|
EGLContext ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t const * const c = get_context(ctx);
|
|
if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
|
|
return c->dpy;
|
|
}
|
|
return EGL_NO_DISPLAY;
|
|
}
|
|
|
|
EGLBoolean eglWaitGL(void)
|
|
{
|
|
EGLBoolean res = EGL_TRUE;
|
|
EGLContext ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t const * const c = get_context(ctx);
|
|
if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
if (uint32_t(c->impl)>=2)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
egl_connection_t* const cnx = &gEGLImpl[c->impl];
|
|
if (!cnx->dso)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
res = cnx->hooks->egl.eglWaitGL();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
EGLBoolean eglWaitNative(EGLint engine)
|
|
{
|
|
EGLBoolean res = EGL_TRUE;
|
|
EGLContext ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t const * const c = get_context(ctx);
|
|
if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
if (uint32_t(c->impl)>=2)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
egl_connection_t* const cnx = &gEGLImpl[c->impl];
|
|
if (!cnx->dso)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
res = cnx->hooks->egl.eglWaitNative(engine);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
EGLint eglGetError(void)
|
|
{
|
|
EGLint result = EGL_SUCCESS;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
EGLint err = EGL_SUCCESS;
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso)
|
|
err = cnx->hooks->egl.eglGetError();
|
|
if (err!=EGL_SUCCESS && result==EGL_SUCCESS)
|
|
result = err;
|
|
}
|
|
if (result == EGL_SUCCESS)
|
|
result = getError();
|
|
return result;
|
|
}
|
|
|
|
void (*eglGetProcAddress(const char *procname))()
|
|
{
|
|
void (*addr)();
|
|
addr = findProcAddress(procname, gExtentionMap, NELEM(gExtentionMap));
|
|
if (addr) return addr;
|
|
|
|
return NULL; // TODO: finish implementation below
|
|
|
|
addr = findProcAddress(procname, gGLExtentionMap, NELEM(gGLExtentionMap));
|
|
if (addr) return addr;
|
|
|
|
addr = 0;
|
|
int slot = -1;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
if (cnx->hooks->egl.eglGetProcAddress) {
|
|
addr = cnx->hooks->egl.eglGetProcAddress(procname);
|
|
if (addr) {
|
|
if (slot == -1) {
|
|
slot = 0; // XXX: find free slot
|
|
if (slot == -1) {
|
|
addr = 0;
|
|
break;
|
|
}
|
|
}
|
|
cnx->hooks->ext.extensions[slot] = addr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slot >= 0) {
|
|
addr = 0; // XXX: address of stub 'slot'
|
|
gGLExtentionMap[slot].name = strdup(procname);
|
|
gGLExtentionMap[slot].address = addr;
|
|
}
|
|
|
|
return addr;
|
|
|
|
|
|
/*
|
|
* TODO: For OpenGL ES extensions, we must generate a stub
|
|
* that looks like
|
|
* mov r12, #0xFFFF0FFF
|
|
* ldr r12, [r12, #-15]
|
|
* ldr r12, [r12, #TLS_SLOT_OPENGL_API*4]
|
|
* mov r12, [r12, #api_offset]
|
|
* ldrne pc, r12
|
|
* mov pc, #unsupported_extension
|
|
*
|
|
* and write the address of the extension in *all*
|
|
* gl_hooks_t::gl_ext_t at offset "api_offset" from gl_hooks_t
|
|
*
|
|
*/
|
|
}
|
|
|
|
EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
|
|
{
|
|
if (!validate_display_surface(dpy, draw))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(draw);
|
|
return s->cnx->hooks->egl.eglSwapBuffers(dp->dpys[s->impl], s->surface);
|
|
}
|
|
|
|
EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
|
|
NativePixmapType target)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
return s->cnx->hooks->egl.eglCopyBuffers(
|
|
dp->dpys[s->impl], s->surface, target);
|
|
}
|
|
|
|
const char* eglQueryString(EGLDisplay dpy, EGLint name)
|
|
{
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
switch (name) {
|
|
case EGL_VENDOR:
|
|
return gVendorString;
|
|
case EGL_VERSION:
|
|
return gVersionString;
|
|
case EGL_EXTENSIONS:
|
|
return dp->extensionsString;
|
|
case EGL_CLIENT_APIS:
|
|
return gClientApiString;
|
|
}
|
|
return setError(EGL_BAD_PARAMETER, (const char *)0);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// EGL 1.1
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLBoolean eglSurfaceAttrib(
|
|
EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
if (s->cnx->hooks->egl.eglSurfaceAttrib) {
|
|
return s->cnx->hooks->egl.eglSurfaceAttrib(
|
|
dp->dpys[s->impl], s->surface, attribute, value);
|
|
}
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
}
|
|
|
|
EGLBoolean eglBindTexImage(
|
|
EGLDisplay dpy, EGLSurface surface, EGLint buffer)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
if (s->cnx->hooks->egl.eglBindTexImage) {
|
|
return s->cnx->hooks->egl.eglBindTexImage(
|
|
dp->dpys[s->impl], s->surface, buffer);
|
|
}
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
}
|
|
|
|
EGLBoolean eglReleaseTexImage(
|
|
EGLDisplay dpy, EGLSurface surface, EGLint buffer)
|
|
{
|
|
if (!validate_display_surface(dpy, surface))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(surface);
|
|
if (s->cnx->hooks->egl.eglReleaseTexImage) {
|
|
return s->cnx->hooks->egl.eglReleaseTexImage(
|
|
dp->dpys[s->impl], s->surface, buffer);
|
|
}
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
}
|
|
|
|
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
|
|
{
|
|
egl_display_t * const dp = get_display(dpy);
|
|
if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
|
|
|
|
EGLBoolean res = EGL_TRUE;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
if (cnx->hooks->egl.eglSwapInterval) {
|
|
if (cnx->hooks->egl.eglSwapInterval(dp->dpys[i], interval) == EGL_FALSE) {
|
|
res = EGL_FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// EGL 1.2
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLBoolean eglWaitClient(void)
|
|
{
|
|
EGLBoolean res = EGL_TRUE;
|
|
EGLContext ctx = getContext();
|
|
if (ctx) {
|
|
egl_context_t const * const c = get_context(ctx);
|
|
if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
if (uint32_t(c->impl)>=2)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
egl_connection_t* const cnx = &gEGLImpl[c->impl];
|
|
if (!cnx->dso)
|
|
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
|
|
if (cnx->hooks->egl.eglWaitClient) {
|
|
res = cnx->hooks->egl.eglWaitClient();
|
|
} else {
|
|
res = cnx->hooks->egl.eglWaitGL();
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
EGLBoolean eglBindAPI(EGLenum api)
|
|
{
|
|
// bind this API on all EGLs
|
|
EGLBoolean res = EGL_TRUE;
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
if (cnx->hooks->egl.eglBindAPI) {
|
|
if (cnx->hooks->egl.eglBindAPI(api) == EGL_FALSE) {
|
|
res = EGL_FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
EGLenum eglQueryAPI(void)
|
|
{
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
if (cnx->hooks->egl.eglQueryAPI) {
|
|
// the first one we find is okay, because they all
|
|
// should be the same
|
|
return cnx->hooks->egl.eglQueryAPI();
|
|
}
|
|
}
|
|
}
|
|
// or, it can only be OpenGL ES
|
|
return EGL_OPENGL_ES_API;
|
|
}
|
|
|
|
EGLBoolean eglReleaseThread(void)
|
|
{
|
|
for (int i=0 ; i<2 ; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso) {
|
|
if (cnx->hooks->egl.eglReleaseThread) {
|
|
cnx->hooks->egl.eglReleaseThread();
|
|
}
|
|
}
|
|
}
|
|
clearTLS();
|
|
return EGL_TRUE;
|
|
}
|
|
|
|
EGLSurface eglCreatePbufferFromClientBuffer(
|
|
EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
|
|
EGLConfig config, const EGLint *attrib_list)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (!cnx) return EGL_FALSE;
|
|
if (cnx->hooks->egl.eglCreatePbufferFromClientBuffer) {
|
|
return cnx->hooks->egl.eglCreatePbufferFromClientBuffer(
|
|
dp->dpys[i], buftype, buffer, dp->configs[i][index], attrib_list);
|
|
}
|
|
return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Android extentions
|
|
// ----------------------------------------------------------------------------
|
|
|
|
EGLBoolean eglSwapRectangleANDROID(
|
|
EGLDisplay dpy, EGLSurface draw,
|
|
EGLint l, EGLint t, EGLint w, EGLint h)
|
|
{
|
|
if (!validate_display_surface(dpy, draw))
|
|
return EGL_FALSE;
|
|
egl_display_t const * const dp = get_display(dpy);
|
|
egl_surface_t const * const s = get_surface(draw);
|
|
if (s->cnx->hooks->egl.eglSwapRectangleANDROID) {
|
|
return s->cnx->hooks->egl.eglSwapRectangleANDROID(
|
|
dp->dpys[s->impl], s->surface, l, t, w, h);
|
|
}
|
|
return setError(EGL_BAD_SURFACE, EGL_FALSE);
|
|
}
|
|
|
|
const char* eglQueryStringConfigANDROID(
|
|
EGLDisplay dpy, EGLConfig config, EGLint name)
|
|
{
|
|
egl_display_t const* dp = 0;
|
|
int i=0, index=0;
|
|
egl_connection_t* cnx = validate_display_config(dpy, config, dp, i, index);
|
|
if (cnx) {
|
|
return dp->queryString[i].extensions_config;
|
|
}
|
|
return setError(EGL_BAD_PARAMETER, (const char *)0);
|
|
}
|