diff --git a/opengl/libs/EGL/egl.cpp b/opengl/libs/EGL/egl.cpp
new file mode 100644
index 0000000..3f33b67
--- /dev/null
+++ b/opengl/libs/EGL/egl.cpp
@@ -0,0 +1,1369 @@
+/* 
+ ** 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 <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+#include <cutils/properties.h>
+#include <cutils/memory.h>
+
+#include <utils/RefBase.h>
+
+#include "hooks.h"
+#include "egl_impl.h"
+
+
+#define MAKE_CONFIG(_impl, _index)  ((EGLConfig)(((_impl)<<24) | (_index)))
+#define setError(_e, _r) setErrorEtc(__FUNCTION__, __LINE__, _e, _r)
+
+// ----------------------------------------------------------------------------
+namespace android {
+// ----------------------------------------------------------------------------
+
+#define VERSION_MINOR 1
+#define VERSION_MAJOR 4
+static char const * const gVendorString     = "Android";
+static char const * const gVersionString    = "1.31 Android META-EGL";
+static char const * const gClientApiString  = "OpenGL ES";
+static char const * const gExtensionString  = "";
+
+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;
+    };
+    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;
+};
+
+static void gl_unimplemented() {
+    LOGE("called unimplemented OpenGL ES API");
+}
+
+// ----------------------------------------------------------------------------
+// GL / EGL hooks
+// ----------------------------------------------------------------------------
+
+#undef GL_ENTRY
+#undef EGL_ENTRY
+#define GL_ENTRY(_r, _api, ...) #_api,
+#define EGL_ENTRY(_r, _api, ...) #_api,
+
+static char const * const gl_names[] = {
+    #include "gl_entries.in"
+    NULL
+};
+
+static char const * const egl_names[] = {
+    #include "egl_entries.in"
+    NULL
+};
+
+#undef GL_ENTRY
+#undef EGL_ENTRY
+
+// ----------------------------------------------------------------------------
+
+egl_connection_t gEGLImpl[2];
+static egl_display_t gDisplay[NUM_DISPLAYS];
+static pthread_mutex_t gThreadLocalStorageKeyMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_key_t gEGLThreadLocalStorageKey = -1;
+
+// ----------------------------------------------------------------------------
+
+gl_hooks_t gHooks[IMPL_NUM_IMPLEMENTATIONS];
+pthread_key_t gGLWrapperKey = -1;
+
+// ----------------------------------------------------------------------------
+
+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;
+}
+
+
+/*****************************************************************************/
+
+class ISurfaceComposer;
+const sp<ISurfaceComposer>& getSurfaceFlinger();
+request_gpu_t* gpu_acquire(void* user);
+int gpu_release(void*, request_gpu_t* gpu);
+
+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 EGLint configToUniqueId(egl_display_t const* dp, int i, int index) 
+{
+    // NOTE: this mapping works only if we have no more than two EGLimpl
+    return (i>0 ? dp->numConfigs[0] : 0) + index;
+}
+
+static void uniqueIdToConfig(egl_display_t const* dp, EGLint configId,
+        int& i, int& index) 
+{
+    // NOTE: this mapping works only if we have no more than two EGLimpl
+    size_t numConfigs = dp->numConfigs[0];
+    i = configId / numConfigs;
+    index = configId % numConfigs;
+}
+
+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);
+}
+
+struct extention_map_t {
+    const char* name;
+    __eglMustCastToProperFunctionPointerType address;
+};
+
+static const extention_map_t gExtentionMap[] = {
+};
+
+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;
+}
+
+// ----------------------------------------------------------------------------
+
+static int gl_context_lost() {
+    setGlThreadSpecific(&gHooks[IMPL_CONTEXT_LOST]);
+    return 0;
+}
+static int egl_context_lost() {
+    setGlThreadSpecific(&gHooks[IMPL_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_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 !USE_FAST_TLS_KEY
+    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;
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------
+
+using 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];
+            property_get("debug.egl.profiler", value, "0");
+            if (atoi(value) == 0) {
+                cnx->dso = load_driver("libhgl.so", cnx->hooks);
+            } else {
+                LOGW("Using instrumented h/w OpenGL ES library");
+                cnx->dso = load_driver("libhgld.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_CONTEXT_LOST].gl,
+                (uint32_t)((void*)gl_context_lost),
+                sizeof(gHooks[IMPL_CONTEXT_LOST].gl));
+        android_memset32(
+                (uint32_t*)(void*)&gHooks[IMPL_CONTEXT_LOST].egl,
+                (uint32_t)((void*)egl_context_lost),
+                sizeof(gHooks[IMPL_CONTEXT_LOST].egl));
+        android_memset32(
+                (uint32_t*)(void*)&gHooks[IMPL_CONTEXT_LOST].ext,
+                (uint32_t)((void*)ext_context_lost),
+                sizeof(gHooks[IMPL_CONTEXT_LOST].ext));
+
+        gHooks[IMPL_CONTEXT_LOST].egl.eglSwapBuffers =
+                egl_context_lost_swap_buffers;
+        
+        gHooks[IMPL_CONTEXT_LOST].egl.eglGetError =
+                egl_context_lost_get_error;
+
+        gHooks[IMPL_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) {
+            LOGE("h/w accelerated eglGetDisplay() failed (%s)",
+                    egl_strerror(cnx->hooks->egl.eglGetError()));
+            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 = VERSION_MAJOR;
+        if (minor != NULL) *minor = VERSION_MINOR;
+        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(gExtensionString);
+    for (int i=0 ; i<2 ; i++) {
+        egl_connection_t* const cnx = &gEGLImpl[i];
+        cnx->major = -1;
+        cnx->minor = -1;
+        if (!cnx->dso) 
+            continue;
+
+        if (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);
+
+        } else {
+            LOGD("%d: eglInitialize() failed (%s)", 
+                    i, egl_strerror(cnx->hooks->egl.eglGetError()));
+        }
+    }
+
+    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) {
+            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);
+            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;
+    }
+
+    EGLint n;
+    EGLBoolean res = EGL_FALSE;
+    *num_config = 0;
+
+    
+    // It is unfortunate, but we need to remap the EGL_CONFIG_IDs, 
+    // to do  this, we have to go through the attrib_list array once
+    // to figure out both its size and if it contains an EGL_CONFIG_ID
+    // key. If so, the full array is copied and patched.
+    // NOTE: we assume that there can be only one occurrence
+    // of EGL_CONFIG_ID.
+    
+    EGLint patch_index = -1;
+    GLint attr;
+    size_t size = 0;
+    while ((attr=attrib_list[size])) {
+        if (attr == EGL_CONFIG_ID)
+            patch_index = size;
+        size += 2;
+    }
+    if (patch_index >= 0) {
+        size += 2; // we need copy the sentinel as well
+        EGLint* new_list = (EGLint*)malloc(size*sizeof(EGLint));
+        if (new_list == 0)
+            return setError(EGL_BAD_ALLOC, EGL_FALSE);
+        memcpy(new_list, attrib_list, size*sizeof(EGLint));
+
+        // patch the requested EGL_CONFIG_ID
+        int i, index;
+        EGLint& configId(new_list[patch_index+1]);
+        uniqueIdToConfig(dp, configId, i, index);
+        
+        egl_connection_t* const cnx = &gEGLImpl[i];
+        if (cnx->dso) {
+            cnx->hooks->egl.eglGetConfigAttrib(
+                    dp->dpys[i], dp->configs[i][index], 
+                    EGL_CONFIG_ID, &configId);
+
+            // and switch to the new list
+            attrib_list = const_cast<const EGLint *>(new_list);
+
+            // At this point, the only configuration that can match is
+            // dp->configs[i][index], however, we don't know if it would be
+            // rejected because of the other attributes, so we do have to call
+            // cnx->hooks->egl.eglChooseConfig() -- but we don't have to loop
+            // through all the EGLimpl[].
+            // We also know we can only get a single config back, and we know
+            // which one.
+
+            res = cnx->hooks->egl.eglChooseConfig(
+                    dp->dpys[i], attrib_list, configs, config_size, &n);
+            if (res && n>0) {
+                // n has to be 0 or 1, by construction, and we already know
+                // which config it will return (since there can be only one).
+                configs[0] = MAKE_CONFIG(i, index);
+                *num_config = 1;
+            }
+        }
+
+        free(const_cast<EGLint *>(attrib_list));
+        return res;
+    }
+
+    for (int i=0 ; i<2 ; i++) {
+        egl_connection_t* const cnx = &gEGLImpl[i];
+        if (cnx->dso) {
+            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;
+    
+    if (attribute == EGL_CONFIG_ID) {
+        // EGL_CONFIG_IDs must be unique, just use the order of the selected
+        // EGLConfig.
+        *value = configToUniqueId(dp, i, index);
+        return EGL_TRUE;
+    }
+    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))()
+{
+    __eglMustCastToProperFunctionPointerType 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 gExtensionString;
+        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);
+}
diff --git a/opengl/libs/EGL/gpu.cpp b/opengl/libs/EGL/gpu.cpp
new file mode 100644
index 0000000..3f9fd63
--- /dev/null
+++ b/opengl/libs/EGL/gpu.cpp
@@ -0,0 +1,212 @@
+/* 
+ ** 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 "EGL"
+
+#include <ctype.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/ioctl.h>
+
+#if HAVE_ANDROID_OS
+#include <linux/android_pmem.h>
+#endif
+
+#include <cutils/log.h>
+#include <cutils/properties.h>
+
+#include <utils/IMemory.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 "hooks.h"
+#include "egl_impl.h"
+
+// ----------------------------------------------------------------------------
+namespace android {
+// ----------------------------------------------------------------------------
+
+/*
+ * 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;
+
+extern egl_connection_t gEGLImpl[2];
+
+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_CONTEXT_LOST];
+    }
+};
+
+static sp<GPURevokeRequester> gRevokerCallback;
+
+
+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;
+    
+    if (gRevokerCallback == 0)
+        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, &region) >= 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, &reg) >= 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;
+}
+
+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;
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------