Move emulator GLES from development.git to sdk.git

The emulator GLES support has two interfaces: a host shared library
interface used by QEMU, and a protocol between the platform and the
host. The host library interface is not versioned; QEMU and the GLES
renderer must match. The protocol on the other hand must be backwards
compatible: a new GLES renderer must support an older platform image.

Thus for branching purposes it makes more sense to put the GLES
renderer in sdk.git, which is branched along with qemu.git for SDK
releases. Platform images will be built against the protocol version
in the platform branch of sdk.git.

Change-Id: I2c3bce627ecfd0a4b3e688d1839fe10755a21e58

34 files changed, 5012 insertions, 0 deletions

diff --git a/emulator/opengl/host/libs/libOpenglRender/Android.mk b/emulator/opengl/host/libs/libOpenglRender/Android.mk
new file mode 100644
index 0000000..1d923b4
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/Android.mk
@@ -0,0 +1,83 @@
+LOCAL_PATH := $(call my-dir)
+
+host_OS_SRCS :=
+host_common_LDLIBS :=
+
+ifeq ($(HOST_OS),linux)
+    host_OS_SRCS = NativeLinuxSubWindow.cpp
+    host_common_LDLIBS += -lX11
+endif
+
+ifeq ($(HOST_OS),darwin)
+    host_OS_SRCS = NativeMacSubWindow.m
+    host_common_LDLIBS += -Wl,-framework,AppKit
+endif
+
+ifeq ($(HOST_OS),windows)
+    host_OS_SRCS = NativeWindowsSubWindow.cpp
+endif
+
+host_common_SRC_FILES := \
+    $(host_OS_SRCS) \
+    render_api.cpp \
+    ColorBuffer.cpp \
+    EGLDispatch.cpp \
+    FBConfig.cpp \
+    FrameBuffer.cpp \
+    GLDispatch.cpp \
+    GL2Dispatch.cpp \
+    RenderContext.cpp \
+    WindowSurface.cpp \
+    RenderControl.cpp \
+    ThreadInfo.cpp \
+    RenderThread.cpp \
+    ReadBuffer.cpp \
+    RenderServer.cpp
+
+host_common_CFLAGS :=
+
+#For gl debbuging
+#host_common_CFLAGS += -DCHECK_GL_ERROR
+
+
+### host libOpenglRender #################################################
+$(call emugl-begin-host-shared-library,libOpenglRender)
+
+$(call emugl-import,libGLESv1_dec libGLESv2_dec lib_renderControl_dec libOpenglCodecCommon libOpenglOsUtils)
+
+LOCAL_LDLIBS += $(host_common_LDLIBS)
+
+LOCAL_SRC_FILES := $(host_common_SRC_FILES)
+$(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+
+# use Translator's egl/gles headers
+LOCAL_C_INCLUDES += $(EMUGL_PATH)/host/libs/Translator/include
+
+LOCAL_STATIC_LIBRARIES += libutils liblog
+
+$(call emugl-export,CFLAGS,$(host_common_CFLAGS))
+
+$(call emugl-end-module)
+
+
+### host libOpenglRender, 64-bit #########################################
+$(call emugl-begin-host-shared-library,lib64OpenglRender)
+
+$(call emugl-import,lib64GLESv1_dec lib64GLESv2_dec lib64_renderControl_dec lib64OpenglCodecCommon lib64OpenglOsUtils)
+
+#LOCAL_LDFLAGS += -m64  # adding -m64 here doesn't work, because it somehow appear BEFORE -m32 in command-line.
+LOCAL_LDLIBS += $(host_common_LDLIBS) -m64  # Put -m64 it in LOCAL_LDLIBS instead.
+
+LOCAL_SRC_FILES := $(host_common_SRC_FILES)
+$(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+
+# use Translator's egl/gles headers
+LOCAL_C_INCLUDES += $(EMUGL_PATH)/host/libs/Translator/include
+
+LOCAL_STATIC_LIBRARIES += lib64utils lib64log
+
+$(call emugl-export,CFLAGS,$(host_common_CFLAGS) -m64)
+
+$(call emugl-end-module)
diff --git a/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.cpp b/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.cpp
new file mode 100644
index 0000000..218f32b
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.cpp
@@ -0,0 +1,346 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "ColorBuffer.h"
+#include "FrameBuffer.h"
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+#include "ThreadInfo.h"
+#ifdef WITH_GLES2
+#include "GL2Dispatch.h"
+#endif
+#include <stdio.h>
+
+ColorBuffer *ColorBuffer::create(int p_width, int p_height,
+                                 GLenum p_internalFormat)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+
+    GLenum texInternalFormat = 0;
+
+    switch(p_internalFormat) {
+        case GL_RGB:
+        case GL_RGB565_OES:
+            texInternalFormat = GL_RGB;
+            break;
+
+        case GL_RGBA:
+        case GL_RGB5_A1_OES:
+        case GL_RGBA4_OES:
+            texInternalFormat = GL_RGBA;
+            break;
+
+        default:
+            return NULL;
+            break;
+    }
+
+    if (!fb->bind_locked()) {
+        return NULL;
+    }
+
+    ColorBuffer *cb = new ColorBuffer();
+
+
+    s_gl.glGenTextures(1, &cb->m_tex);
+    s_gl.glBindTexture(GL_TEXTURE_2D, cb->m_tex);
+    int nComp = (texInternalFormat == GL_RGB ? 3 : 4);
+    char *zBuff = new char[nComp*p_width*p_height];
+    if (zBuff) {
+        memset(zBuff, 0, nComp*p_width*p_height);
+    }
+    s_gl.glTexImage2D(GL_TEXTURE_2D, 0, texInternalFormat,
+                      p_width, p_height, 0,
+                      texInternalFormat,
+                      GL_UNSIGNED_BYTE, zBuff);
+    delete [] zBuff;
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    s_gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    //
+    // create another texture for that colorbuffer for blit
+    //
+    s_gl.glGenTextures(1, &cb->m_blitTex);
+    s_gl.glBindTexture(GL_TEXTURE_2D, cb->m_blitTex);
+    s_gl.glTexImage2D(GL_TEXTURE_2D, 0, texInternalFormat,
+                      p_width, p_height, 0,
+                      texInternalFormat,
+                      GL_UNSIGNED_BYTE, NULL);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    s_gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    s_gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    cb->m_width = p_width;
+    cb->m_height = p_height;
+    cb->m_internalFormat = texInternalFormat;
+
+    if (fb->getCaps().has_eglimage_texture_2d) {
+        cb->m_eglImage = s_egl.eglCreateImageKHR(fb->getDisplay(),
+                                                 s_egl.eglGetCurrentContext(),
+                                                 EGL_GL_TEXTURE_2D_KHR,
+                                                 (EGLClientBuffer)cb->m_tex,
+                                                 NULL);
+
+        cb->m_blitEGLImage = s_egl.eglCreateImageKHR(fb->getDisplay(),
+                                                 s_egl.eglGetCurrentContext(),
+                                                 EGL_GL_TEXTURE_2D_KHR,
+                                                 (EGLClientBuffer)cb->m_blitTex,
+                                                 NULL);
+    }
+
+    fb->unbind_locked();
+    return cb;
+}
+
+ColorBuffer::ColorBuffer() :
+    m_tex(0),
+    m_eglImage(NULL),
+    m_fbo(0),
+    m_internalFormat(0),
+    m_warYInvertBug(false)
+{
+#if __APPLE__
+    // On Macs running OS X 10.6 and 10.7 with Intel HD Graphics 3000, some
+    // screens or parts of the screen are displayed upside down. The exact
+    // conditions/sequence that triggers this aren't known yet; I haven't
+    // been able to reproduce it in a standalone test. This way of enabling the
+    // workaround will break if it is a driver bug (rather than a bug in this
+    // code which works by accident elsewhere) and Apple/Intel release a fix for
+    // it. Running a standalone test to detect the problem at runtime would be
+    // more robust.
+    if (strstr((const char*)s_gl.glGetString(GL_RENDERER), "Intel HD Graphics 3000"))
+        m_warYInvertBug = true;
+#endif
+}
+
+ColorBuffer::~ColorBuffer()
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    fb->bind_locked();
+    s_gl.glDeleteTextures(1, &m_tex);
+    if (m_eglImage) {
+        s_egl.eglDestroyImageKHR(fb->getDisplay(), m_eglImage);
+    }
+    if (m_fbo) {
+        s_gl.glDeleteFramebuffersOES(1, &m_fbo);
+    }
+    fb->unbind_locked();
+}
+
+void ColorBuffer::subUpdate(int x, int y, int width, int height, GLenum p_format, GLenum p_type, void *pixels)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb->bind_locked()) return;
+    s_gl.glBindTexture(GL_TEXTURE_2D, m_tex);
+    s_gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    s_gl.glTexSubImage2D(GL_TEXTURE_2D, 0, x, y,
+                         width, height, p_format, p_type, pixels);
+    fb->unbind_locked();
+}
+
+bool ColorBuffer::blitFromCurrentReadBuffer()
+{
+    RenderThreadInfo *tInfo = getRenderThreadInfo();
+    if (!tInfo->currContext.Ptr()) {
+        // no Current context
+        return false;
+    }
+
+    //
+    // Create a temporary texture inside the current context
+    // from the blit_texture EGLImage and copy the pixels
+    // from the current read buffer to that texture
+    //
+    GLuint tmpTex;
+    GLint currTexBind;
+    if (tInfo->currContext->isGL2()) {
+        s_gl2.glGetIntegerv(GL_TEXTURE_BINDING_2D, &currTexBind);
+        s_gl2.glGenTextures(1,&tmpTex);
+        s_gl2.glBindTexture(GL_TEXTURE_2D, tmpTex);
+        s_gl2.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_blitEGLImage);
+        s_gl2.glCopyTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat,
+                               0, 0, m_width, m_height, 0);
+    }
+    else {
+        s_gl.glGetIntegerv(GL_TEXTURE_BINDING_2D, &currTexBind);
+        s_gl.glGenTextures(1,&tmpTex);
+        s_gl.glBindTexture(GL_TEXTURE_2D, tmpTex);
+        s_gl.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_blitEGLImage);
+        s_gl.glCopyTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat,
+                              0, 0, m_width, m_height, 0);
+    }
+
+
+    //
+    // Now bind the frame buffer context and blit from
+    // m_blitTex into m_tex
+    //
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (fb->bind_locked()) {
+
+        //
+        // bind FBO object which has this colorbuffer as render target
+        //
+        if (bind_fbo()) {
+
+            //
+            // save current viewport and match it to the current
+            // colorbuffer size
+            //
+            GLint vport[4];
+            s_gl.glGetIntegerv(GL_VIEWPORT, vport);
+            s_gl.glViewport(0, 0, m_width, m_height);
+
+            // render m_blitTex
+            s_gl.glBindTexture(GL_TEXTURE_2D, m_blitTex);
+            s_gl.glEnable(GL_TEXTURE_2D);
+            s_gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+            drawTexQuad(!m_warYInvertBug);
+
+            // unbind the fbo
+            s_gl.glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
+
+            // restrore previous viewport
+            s_gl.glViewport(vport[0], vport[1], vport[2], vport[3]);
+        }
+
+        // unbind from the FrameBuffer context
+        fb->unbind_locked();
+    }
+
+    //
+    // delete the temporary texture and restore the texture binding
+    // inside the current context
+    //
+    if (tInfo->currContext->isGL2()) {
+        s_gl2.glDeleteTextures(1, &tmpTex);
+        s_gl2.glBindTexture(GL_TEXTURE_2D, currTexBind);
+    }
+    else {
+        s_gl.glDeleteTextures(1, &tmpTex);
+        s_gl.glBindTexture(GL_TEXTURE_2D, currTexBind);
+    }
+
+    return true;
+}
+
+bool ColorBuffer::bindToTexture()
+{
+    if (m_eglImage) {
+        RenderThreadInfo *tInfo = getRenderThreadInfo();
+        if (tInfo->currContext.Ptr()) {
+#ifdef WITH_GLES2
+            if (tInfo->currContext->isGL2()) {
+                s_gl2.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_eglImage);
+            }
+            else {
+                s_gl.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_eglImage);
+            }
+#else
+            s_gl.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_eglImage);
+#endif
+            return true;
+        }
+    }
+    return false;
+}
+
+bool ColorBuffer::bindToRenderbuffer()
+{
+    if (m_eglImage) {
+        RenderThreadInfo *tInfo = getRenderThreadInfo();
+        if (tInfo->currContext.Ptr()) {
+#ifdef WITH_GLES2
+            if (tInfo->currContext->isGL2()) {
+                s_gl2.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, m_eglImage);
+            }
+            else {
+                s_gl.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, m_eglImage);
+            }
+#else
+            s_gl.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, m_eglImage);
+#endif
+            return true;
+        }
+    }
+    return false;
+}
+
+bool ColorBuffer::bind_fbo()
+{
+    if (m_fbo) {
+        // fbo already exist - just bind
+        s_gl.glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_fbo);
+        return true;
+    }
+
+    s_gl.glGenFramebuffersOES(1, &m_fbo);
+    s_gl.glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_fbo);
+    s_gl.glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES,
+                                   GL_COLOR_ATTACHMENT0_OES,
+                                   GL_TEXTURE_2D, m_tex, 0);
+    GLenum status = s_gl.glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
+    if (status != GL_FRAMEBUFFER_COMPLETE_OES) {
+        s_gl.glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
+        s_gl.glDeleteFramebuffersOES(1, &m_fbo);
+        m_fbo = 0;
+        return false;
+    }
+
+    return true;
+}
+
+bool ColorBuffer::post()
+{
+    s_gl.glBindTexture(GL_TEXTURE_2D, m_tex);
+    s_gl.glEnable(GL_TEXTURE_2D);
+    s_gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    drawTexQuad(true);
+
+    return true;
+}
+
+void ColorBuffer::drawTexQuad(bool flipy)
+{
+    GLfloat verts[] = { -1.0f, -1.0f, 0.0f,
+                         -1.0f, +1.0f, 0.0f,
+                         +1.0f, -1.0f, 0.0f,
+                         +1.0f, +1.0f, 0.0f };
+
+    GLfloat tcoords[] = { 0.0f, 1.0f,
+                           0.0f, 0.0f,
+                           1.0f, 1.0f,
+                           1.0f, 0.0f };
+
+    if (!flipy) {
+        for (int i = 0; i < 4; i++) {
+            // swap 0.0/1.0 in second element of each tcoord vector
+            tcoords[2*i + 1] = tcoords[2*i + 1] == 0.0f ? 1.0f : 0.0f;
+        }
+    }
+
+    s_gl.glClientActiveTexture(GL_TEXTURE0);
+    s_gl.glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    s_gl.glTexCoordPointer(2, GL_FLOAT, 0, tcoords);
+
+    s_gl.glEnableClientState(GL_VERTEX_ARRAY);
+    s_gl.glVertexPointer(3, GL_FLOAT, 0, verts);
+    s_gl.glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.h b/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.h
new file mode 100644
index 0000000..4a2c6b4
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ColorBuffer.h
@@ -0,0 +1,60 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIBRENDER_COLORBUFFER_H
+#define _LIBRENDER_COLORBUFFER_H
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <SmartPtr.h>
+
+class ColorBuffer
+{
+public:
+    static ColorBuffer *create(int p_width, int p_height,
+                               GLenum p_internalFormat);
+    ~ColorBuffer();
+
+    GLuint getGLTextureName() const { return m_tex; }
+    GLuint getWidth() const { return m_width; }
+    GLuint getHeight() const { return m_height; }
+
+    void subUpdate(int x, int y, int width, int height, GLenum p_format, GLenum p_type, void *pixels);
+    bool post();
+    bool bindToTexture();
+    bool bindToRenderbuffer();
+    bool blitFromCurrentReadBuffer();
+
+private:
+    ColorBuffer();
+    void drawTexQuad(bool flipy);
+    bool bind_fbo();  // binds a fbo which have this texture as render target
+
+private:
+    GLuint m_tex;
+    GLuint m_blitTex;
+    EGLImageKHR m_eglImage;
+    EGLImageKHR m_blitEGLImage;
+    GLuint m_width;
+    GLuint m_height;
+    GLuint m_fbo;
+    GLenum m_internalFormat;
+    bool m_warYInvertBug;
+};
+
+typedef SmartPtr<ColorBuffer> ColorBufferPtr;
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.cpp b/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.cpp
new file mode 100644
index 0000000..3cf5dbc
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.cpp
@@ -0,0 +1,87 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "EGLDispatch.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "osDynLibrary.h"
+
+EGLDispatch s_egl;
+
+#define DEFAULT_EGL_LIB EMUGL_LIBNAME("EGL_translator")
+
+bool init_egl_dispatch()
+{
+
+    const char *libName = getenv("ANDROID_EGL_LIB");
+    if (!libName) libName = DEFAULT_EGL_LIB;
+
+    osUtils::dynLibrary *lib = osUtils::dynLibrary::open(libName);
+    if (!lib) {
+        printf("Failed to open %s\n", libName);
+        return NULL;
+    }
+    s_egl.eglGetError = (eglGetError_t) lib->findSymbol("eglGetError");
+    s_egl.eglGetDisplay = (eglGetDisplay_t) lib->findSymbol("eglGetDisplay");
+    s_egl.eglInitialize = (eglInitialize_t) lib->findSymbol("eglInitialize");
+    s_egl.eglTerminate = (eglTerminate_t) lib->findSymbol("eglTerminate");
+    s_egl.eglQueryString = (eglQueryString_t) lib->findSymbol("eglQueryString");
+    s_egl.eglGetConfigs = (eglGetConfigs_t) lib->findSymbol("eglGetConfigs");
+    s_egl.eglChooseConfig = (eglChooseConfig_t) lib->findSymbol("eglChooseConfig");
+    s_egl.eglGetConfigAttrib = (eglGetConfigAttrib_t) lib->findSymbol("eglGetConfigAttrib");
+    s_egl.eglCreateWindowSurface = (eglCreateWindowSurface_t) lib->findSymbol("eglCreateWindowSurface");
+    s_egl.eglCreatePbufferSurface = (eglCreatePbufferSurface_t) lib->findSymbol("eglCreatePbufferSurface");
+    s_egl.eglCreatePixmapSurface = (eglCreatePixmapSurface_t) lib->findSymbol("eglCreatePixmapSurface");
+    s_egl.eglDestroySurface = (eglDestroySurface_t) lib->findSymbol("eglDestroySurface");
+    s_egl.eglQuerySurface = (eglQuerySurface_t) lib->findSymbol("eglQuerySurface");
+    s_egl.eglBindAPI = (eglBindAPI_t) lib->findSymbol("eglBindAPI");
+    s_egl.eglQueryAPI = (eglQueryAPI_t) lib->findSymbol("eglQueryAPI");
+    s_egl.eglWaitClient = (eglWaitClient_t) lib->findSymbol("eglWaitClient");
+    s_egl.eglReleaseThread = (eglReleaseThread_t) lib->findSymbol("eglReleaseThread");
+    s_egl.eglCreatePbufferFromClientBuffer = (eglCreatePbufferFromClientBuffer_t) lib->findSymbol("eglCreatePbufferFromClientBuffer");
+    s_egl.eglSurfaceAttrib = (eglSurfaceAttrib_t) lib->findSymbol("eglSurfaceAttrib");
+    s_egl.eglBindTexImage = (eglBindTexImage_t) lib->findSymbol("eglBindTexImage");
+    s_egl.eglReleaseTexImage = (eglReleaseTexImage_t) lib->findSymbol("eglReleaseTexImage");
+    s_egl.eglSwapInterval = (eglSwapInterval_t) lib->findSymbol("eglSwapInterval");
+    s_egl.eglCreateContext = (eglCreateContext_t) lib->findSymbol("eglCreateContext");
+    s_egl.eglDestroyContext = (eglDestroyContext_t) lib->findSymbol("eglDestroyContext");
+    s_egl.eglMakeCurrent = (eglMakeCurrent_t) lib->findSymbol("eglMakeCurrent");
+    s_egl.eglGetCurrentContext = (eglGetCurrentContext_t) lib->findSymbol("eglGetCurrentContext");
+    s_egl.eglGetCurrentSurface = (eglGetCurrentSurface_t) lib->findSymbol("eglGetCurrentSurface");
+    s_egl.eglGetCurrentDisplay = (eglGetCurrentDisplay_t) lib->findSymbol("eglGetCurrentDisplay");
+    s_egl.eglQueryContext = (eglQueryContext_t) lib->findSymbol("eglQueryContext");
+    s_egl.eglWaitGL = (eglWaitGL_t) lib->findSymbol("eglWaitGL");
+    s_egl.eglWaitNative = (eglWaitNative_t) lib->findSymbol("eglWaitNative");
+    s_egl.eglSwapBuffers = (eglSwapBuffers_t) lib->findSymbol("eglSwapBuffers");
+    s_egl.eglCopyBuffers = (eglCopyBuffers_t) lib->findSymbol("eglCopyBuffers");
+    s_egl.eglGetProcAddress = (eglGetProcAddress_t) lib->findSymbol("eglGetProcAddress");
+
+#define INIT_EGL_EXT_FUNC(name) \
+    if (s_egl.eglGetProcAddress) s_egl.name = (name ## _t) s_egl.eglGetProcAddress(#name); \
+    if (!s_egl.name || !s_egl.eglGetProcAddress) s_egl.name = (name ## _t) lib->findSymbol(#name)
+
+    INIT_EGL_EXT_FUNC(eglLockSurfaceKHR);
+    INIT_EGL_EXT_FUNC(eglUnlockSurfaceKHR);
+    INIT_EGL_EXT_FUNC(eglCreateImageKHR);
+    INIT_EGL_EXT_FUNC(eglDestroyImageKHR);
+    INIT_EGL_EXT_FUNC(eglCreateSyncKHR);
+    INIT_EGL_EXT_FUNC(eglDestroySyncKHR);
+    INIT_EGL_EXT_FUNC(eglClientWaitSyncKHR);
+    INIT_EGL_EXT_FUNC(eglSignalSyncKHR);
+    INIT_EGL_EXT_FUNC(eglGetSyncAttribKHR);
+    INIT_EGL_EXT_FUNC(eglSetSwapRectangleANDROID);
+
+    return true;
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.h b/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.h
new file mode 100644
index 0000000..f74acba
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/EGLDispatch.h
@@ -0,0 +1,72 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _EGL_DISPATCH_H
+#define _EGL_DISPATCH_H
+
+#include "egl_proc.h"
+
+struct EGLDispatch {
+    eglGetError_t eglGetError;
+    eglGetDisplay_t eglGetDisplay;
+    eglInitialize_t eglInitialize;
+    eglTerminate_t eglTerminate;
+    eglQueryString_t eglQueryString;
+    eglGetConfigs_t eglGetConfigs;
+    eglChooseConfig_t eglChooseConfig;
+    eglGetConfigAttrib_t eglGetConfigAttrib;
+    eglCreateWindowSurface_t eglCreateWindowSurface;
+    eglCreatePbufferSurface_t eglCreatePbufferSurface;
+    eglCreatePixmapSurface_t eglCreatePixmapSurface;
+    eglDestroySurface_t eglDestroySurface;
+    eglQuerySurface_t eglQuerySurface;
+    eglBindAPI_t eglBindAPI;
+    eglQueryAPI_t eglQueryAPI;
+    eglWaitClient_t eglWaitClient;
+    eglReleaseThread_t eglReleaseThread;
+    eglCreatePbufferFromClientBuffer_t eglCreatePbufferFromClientBuffer;
+    eglSurfaceAttrib_t eglSurfaceAttrib;
+    eglBindTexImage_t eglBindTexImage;
+    eglReleaseTexImage_t eglReleaseTexImage;
+    eglSwapInterval_t eglSwapInterval;
+    eglCreateContext_t eglCreateContext;
+    eglDestroyContext_t eglDestroyContext;
+    eglMakeCurrent_t eglMakeCurrent;
+    eglGetCurrentContext_t eglGetCurrentContext;
+    eglGetCurrentSurface_t eglGetCurrentSurface;
+    eglGetCurrentDisplay_t eglGetCurrentDisplay;
+    eglQueryContext_t eglQueryContext;
+    eglWaitGL_t eglWaitGL;
+    eglWaitNative_t eglWaitNative;
+    eglSwapBuffers_t eglSwapBuffers;
+    eglCopyBuffers_t eglCopyBuffers;
+    eglGetProcAddress_t eglGetProcAddress;
+    eglLockSurfaceKHR_t eglLockSurfaceKHR;
+    eglUnlockSurfaceKHR_t eglUnlockSurfaceKHR;
+    eglCreateImageKHR_t eglCreateImageKHR;
+    eglDestroyImageKHR_t eglDestroyImageKHR;
+    eglCreateSyncKHR_t eglCreateSyncKHR;
+    eglDestroySyncKHR_t eglDestroySyncKHR;
+    eglClientWaitSyncKHR_t eglClientWaitSyncKHR;
+    eglSignalSyncKHR_t eglSignalSyncKHR;
+    eglGetSyncAttribKHR_t eglGetSyncAttribKHR;
+    eglSetSwapRectangleANDROID_t eglSetSwapRectangleANDROID;
+};
+
+bool init_egl_dispatch();
+
+extern EGLDispatch s_egl;
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/FBConfig.cpp b/emulator/opengl/host/libs/libOpenglRender/FBConfig.cpp
new file mode 100644
index 0000000..089f1da
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/FBConfig.cpp
@@ -0,0 +1,258 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "FBConfig.h"
+#include "FrameBuffer.h"
+#include "EGLDispatch.h"
+#include <stdio.h>
+
+FBConfig **FBConfig::s_fbConfigs = NULL;
+int FBConfig::s_numConfigs = 0;
+
+const GLuint FBConfig::s_configAttribs[] = {
+    EGL_DEPTH_SIZE,     // must be first - see getDepthSize()
+    EGL_STENCIL_SIZE,   // must be second - see getStencilSize()
+    EGL_RENDERABLE_TYPE,// must be third - see getRenderableType()
+    EGL_SURFACE_TYPE,   // must be fourth - see getSurfaceType()
+    EGL_CONFIG_ID,      // must be fifth  - see chooseConfig()
+    EGL_BUFFER_SIZE,
+    EGL_ALPHA_SIZE,
+    EGL_BLUE_SIZE,
+    EGL_GREEN_SIZE,
+    EGL_RED_SIZE,
+    EGL_CONFIG_CAVEAT,
+    EGL_LEVEL,
+    EGL_MAX_PBUFFER_HEIGHT,
+    EGL_MAX_PBUFFER_PIXELS,
+    EGL_MAX_PBUFFER_WIDTH,
+    EGL_NATIVE_RENDERABLE,
+    EGL_NATIVE_VISUAL_ID,
+    EGL_NATIVE_VISUAL_TYPE,
+    EGL_SAMPLES,
+    EGL_SAMPLE_BUFFERS,
+    EGL_TRANSPARENT_TYPE,
+    EGL_TRANSPARENT_BLUE_VALUE,
+    EGL_TRANSPARENT_GREEN_VALUE,
+    EGL_TRANSPARENT_RED_VALUE,
+    EGL_BIND_TO_TEXTURE_RGB,
+    EGL_BIND_TO_TEXTURE_RGBA,
+    EGL_MIN_SWAP_INTERVAL,
+    EGL_MAX_SWAP_INTERVAL,
+    EGL_LUMINANCE_SIZE,
+    EGL_ALPHA_MASK_SIZE,
+    EGL_COLOR_BUFFER_TYPE,
+    //EGL_MATCH_NATIVE_PIXMAP,
+    EGL_CONFORMANT
+};
+
+const int FBConfig::s_numConfigAttribs = sizeof(FBConfig::s_configAttribs) / sizeof(GLuint);
+
+InitConfigStatus FBConfig::initConfigList(FrameBuffer *fb)
+{
+    InitConfigStatus ret = INIT_CONFIG_FAILED;
+
+    if (!fb) {
+        return ret;
+    }
+
+    const FrameBufferCaps &caps = fb->getCaps();
+    EGLDisplay dpy = fb->getDisplay();
+
+    if (dpy == EGL_NO_DISPLAY) {
+        fprintf(stderr,"Could not get EGL Display\n");
+        return ret;
+    }
+
+    //
+    // Query the set of configs in the EGL backend
+    //
+    EGLint nConfigs;
+    if (!s_egl.eglGetConfigs(dpy, NULL, 0, &nConfigs)) {
+        fprintf(stderr, "Could not get number of available configs\n");
+        return ret;
+    }
+    EGLConfig *configs = new EGLConfig[nConfigs];
+    s_egl.eglGetConfigs(dpy, configs, nConfigs, &nConfigs);
+
+    //
+    // copy the config attributes, filter out
+    // configs we do not want to support.
+    //
+    int j = 0;
+    s_fbConfigs = new FBConfig*[nConfigs];
+    for (int i=0; i<nConfigs; i++) {
+
+        //
+        // filter out configs which does not support pbuffers.
+        // we only support pbuffer configs since we use a pbuffer
+        // handle to bind a guest created window object.
+        //
+        EGLint surfaceType;
+        s_egl.eglGetConfigAttrib(dpy, configs[i],
+                                 EGL_SURFACE_TYPE, &surfaceType);
+        if (!(surfaceType & EGL_PBUFFER_BIT)) continue;
+
+        //
+        // Filter out not RGB configs
+        //
+        EGLint redSize, greenSize, blueSize;
+        s_egl.eglGetConfigAttrib(dpy, configs[i], EGL_RED_SIZE, &redSize);
+        s_egl.eglGetConfigAttrib(dpy, configs[i], EGL_BLUE_SIZE, &blueSize);
+        s_egl.eglGetConfigAttrib(dpy, configs[i], EGL_GREEN_SIZE, &greenSize);
+        if (redSize==0 || greenSize==0 || blueSize==0) continue;
+
+        s_fbConfigs[j++] = new FBConfig(dpy, configs[i]);
+    }
+    s_numConfigs = j;
+
+    delete[] configs;
+
+    return s_numConfigs > 0 ? INIT_CONFIG_PASSED : INIT_CONFIG_FAILED;
+}
+
+const FBConfig *FBConfig::get(int p_config)
+{
+    if (p_config >= 0 && p_config < s_numConfigs) {
+        return s_fbConfigs[p_config];
+    }
+    return NULL;
+}
+
+int FBConfig::getNumConfigs()
+{
+    return s_numConfigs;
+}
+
+void FBConfig::packConfigsInfo(GLuint *buffer)
+{
+    memcpy(buffer, s_configAttribs, s_numConfigAttribs * sizeof(GLuint));
+    for (int i=0; i<s_numConfigs; i++) {
+        memcpy(buffer+(i+1)*s_numConfigAttribs,
+               s_fbConfigs[i]->m_attribValues,
+               s_numConfigAttribs * sizeof(GLuint));
+    }
+}
+
+int FBConfig::chooseConfig(FrameBuffer *fb, EGLint * attribs, uint32_t * configs, uint32_t configs_size)
+{
+    EGLDisplay dpy = fb->getDisplay();
+    int ret = 0;
+
+    if (dpy == EGL_NO_DISPLAY) {
+        fprintf(stderr,"Could not get EGL Display\n");
+        return ret;
+    }
+    //
+    // Query the num of configs in the EGL backend
+    //
+    EGLint nConfigs;
+    if (!s_egl.eglGetConfigs(dpy, NULL, 0, &nConfigs)) {
+        fprintf(stderr, "Could not get number of available configs\n");
+        return ret;
+    }
+    //
+    // Query the max matching configs in the backend
+    //
+    EGLConfig *matchedConfigs = new EGLConfig[nConfigs];
+
+    //
+    //Until we have EGLImage implementation, we force pbuf configs
+    //
+    bool needToAddPbufAttr = true;
+    int attribCnt = 0;
+    EGLint * attrib_p = attribs;
+    if (attribs) {
+        while (attrib_p[0] != EGL_NONE) {
+            if (attrib_p[0] == EGL_SURFACE_TYPE) {
+                attrib_p[1] = EGL_PBUFFER_BIT; //replace whatever was there before
+                needToAddPbufAttr = false;
+            }
+            attrib_p += 2;
+            attribCnt += 2;
+        }
+    }
+    EGLint * newAttribs = new EGLint[attribCnt + 1 + ((needToAddPbufAttr) ? 2 : 0)];
+    attrib_p = newAttribs;
+    if (needToAddPbufAttr) {
+        *(attrib_p++) = EGL_SURFACE_TYPE;
+        *(attrib_p++) = EGL_PBUFFER_BIT;
+    }
+    memcpy(attrib_p, attribs, attribCnt*sizeof(EGLint));
+    attrib_p += attribCnt;
+    *attrib_p = EGL_NONE;
+
+#if 0
+    if (newAttribs) {
+        EGLint * attrib_p = newAttribs;
+        while (attrib_p[0] != EGL_NONE) {
+            DBG("attr: 0x%x %d, ", attrib_p[0], attrib_p[1]);
+            attrib_p += 2;
+        }
+    }
+#endif
+
+    s_egl.eglChooseConfig(dpy, newAttribs, matchedConfigs, nConfigs, &nConfigs);
+
+    delete[] newAttribs;
+
+    //
+    // From all matchedConfigs we need only config_size FBConfigs, so we intersect both lists compating the CONFIG_ID attribute
+    //
+    uint32_t nVerifiedCfgs = 0;
+    for (int matchedIdx=0; matchedIdx<nConfigs; matchedIdx++) {
+        if ((configs != NULL) && (configs_size > 0) && (nVerifiedCfgs >= configs_size)) break; //We have enouhgt configs
+        int sCfgId;
+        s_egl.eglGetConfigAttrib(dpy, matchedConfigs[matchedIdx], EGL_CONFIG_ID, &sCfgId);
+        for (int fbIdx=0; fbIdx<s_numConfigs; fbIdx++) {
+            int dCfgId = s_fbConfigs[fbIdx]->m_attribValues[4]; //CONFIG_ID
+            if (sCfgId == dCfgId) {
+                //This config matches the requested attributes and filtered into fbConfigs, so we're happy with it
+                if (configs && nVerifiedCfgs < configs_size) {
+                    configs[nVerifiedCfgs] = fbIdx;
+                }
+                nVerifiedCfgs++;
+                break;
+            }
+        }
+    }
+
+    delete[] matchedConfigs;
+
+    return nVerifiedCfgs;
+}
+
+FBConfig::FBConfig(EGLDisplay p_eglDpy, EGLConfig p_eglCfg)
+{
+    m_eglConfig = p_eglCfg;
+    m_attribValues = new GLint[s_numConfigAttribs];
+    for (int i=0; i<s_numConfigAttribs; i++) {
+        m_attribValues[i] = 0;
+        s_egl.eglGetConfigAttrib(p_eglDpy, p_eglCfg, s_configAttribs[i], &m_attribValues[i]);
+
+        //
+        // All exported configs supports android native window rendering
+        //
+        if (s_configAttribs[i] == EGL_SURFACE_TYPE) {
+            m_attribValues[i] |= EGL_WINDOW_BIT;
+        }
+    }
+}
+
+FBConfig::~FBConfig()
+{
+    if (m_attribValues) {
+        delete[] m_attribValues;
+    }
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/FBConfig.h b/emulator/opengl/host/libs/libOpenglRender/FBConfig.h
new file mode 100644
index 0000000..6388549
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/FBConfig.h
@@ -0,0 +1,60 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIBRENDER_FBCONFIG_H
+#define _LIBRENDER_FBCONFIG_H
+
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+class FrameBuffer;
+
+enum InitConfigStatus {
+    INIT_CONFIG_FAILED = 0,
+    INIT_CONFIG_PASSED = 1
+};
+
+class FBConfig
+{
+public:
+    static InitConfigStatus initConfigList(FrameBuffer *fb);
+    static const FBConfig *get(int p_config);
+    static int getNumConfigs();
+    static int getNumAttribs() { return s_numConfigAttribs; }
+    static void packConfigsInfo(GLuint *buffer);
+    static int chooseConfig(FrameBuffer *fb, EGLint * attribs, uint32_t * configs, uint32_t configs_size);
+    ~FBConfig();
+
+    EGLConfig getEGLConfig() const { return m_eglConfig; }
+    GLuint  getDepthSize() const { return (m_attribValues ? m_attribValues[0] : 0); }
+    GLuint  getStencilSize() const { return (m_attribValues ? m_attribValues[1] : 0); }
+    GLuint  getRenderableType() const { return (m_attribValues ? m_attribValues[2] : 0); }
+    GLuint getSurfaceType() const { return (m_attribValues ? m_attribValues[3] : 0); }
+
+private:
+    FBConfig(EGLDisplay p_eglDpy, EGLConfig p_eglCfg);
+
+private:
+    static FBConfig **s_fbConfigs;
+    static int s_numConfigs;
+    static const int s_numConfigAttribs;
+    static const GLuint s_configAttribs[];
+
+private:
+    EGLConfig m_eglConfig;
+    GLint *m_attribValues;
+};
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.cpp b/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.cpp
new file mode 100644
index 0000000..b7599ce
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.cpp
@@ -0,0 +1,868 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "FrameBuffer.h"
+#include "NativeSubWindow.h"
+#include "FBConfig.h"
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+#include "GL2Dispatch.h"
+#include "ThreadInfo.h"
+#include <stdio.h>
+#include "TimeUtils.h"
+
+FrameBuffer *FrameBuffer::s_theFrameBuffer = NULL;
+HandleType FrameBuffer::s_nextHandle = 0;
+
+#ifdef WITH_GLES2
+static const char *getGLES2ExtensionString(EGLDisplay p_dpy)
+{
+    EGLConfig config;
+    EGLSurface surface;
+
+    GLint configAttribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_NONE
+    };
+
+    int n;
+    if (!s_egl.eglChooseConfig(p_dpy, configAttribs,
+                               &config, 1, &n)) {
+        return NULL;
+    }
+
+    EGLint pbufAttribs[] = {
+        EGL_WIDTH, 1,
+        EGL_HEIGHT, 1,
+        EGL_NONE
+    };
+
+    surface = s_egl.eglCreatePbufferSurface(p_dpy, config, pbufAttribs);
+    if (surface == EGL_NO_SURFACE) {
+        return NULL;
+    }
+
+    GLint gl2ContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+
+    EGLContext ctx = s_egl.eglCreateContext(p_dpy, config,
+                                            EGL_NO_CONTEXT,
+                                            gl2ContextAttribs);
+    if (ctx == EGL_NO_CONTEXT) {
+        s_egl.eglDestroySurface(p_dpy, surface);
+        return NULL;
+    }
+
+    if (!s_egl.eglMakeCurrent(p_dpy, surface, surface, ctx)) {
+        s_egl.eglDestroySurface(p_dpy, surface);
+        s_egl.eglDestroyContext(p_dpy, ctx);
+        return NULL;
+    }
+
+    const char *extString = (const char *)s_gl2.glGetString(GL_EXTENSIONS);
+    if (!extString) {
+        extString = "";
+    }
+
+    s_egl.eglMakeCurrent(p_dpy, NULL, NULL, NULL);
+    s_egl.eglDestroyContext(p_dpy, ctx);
+    s_egl.eglDestroySurface(p_dpy, surface);
+
+    return extString;
+}
+#endif
+
+void FrameBuffer::finalize(){
+    if(s_theFrameBuffer){
+        s_theFrameBuffer->removeSubWindow();
+        s_theFrameBuffer->m_colorbuffers.clear();
+        s_theFrameBuffer->m_windows.clear();
+        s_theFrameBuffer->m_contexts.clear();
+        s_egl.eglMakeCurrent(s_theFrameBuffer->m_eglDisplay, NULL, NULL, NULL);
+        s_egl.eglDestroyContext(s_theFrameBuffer->m_eglDisplay,s_theFrameBuffer->m_eglContext);
+        s_egl.eglDestroyContext(s_theFrameBuffer->m_eglDisplay,s_theFrameBuffer->m_pbufContext);
+        s_egl.eglDestroySurface(s_theFrameBuffer->m_eglDisplay,s_theFrameBuffer->m_pbufSurface);
+        s_theFrameBuffer = NULL;
+    }
+}
+
+bool FrameBuffer::initialize(int width, int height, OnPostFn onPost, void* onPostContext)
+{
+    if (s_theFrameBuffer != NULL) {
+        return true;
+    }
+
+    //
+    // allocate space for the FrameBuffer object
+    //
+    FrameBuffer *fb = new FrameBuffer(width, height, onPost, onPostContext);
+    if (!fb) {
+        ERR("Failed to create fb\n");
+        return false;
+    }
+
+#ifdef WITH_GLES2
+    //
+    // Try to load GLES2 Plugin, not mandatory
+    //
+    if (getenv("ANDROID_NO_GLES2")) {
+        fb->m_caps.hasGL2 = false;
+    }
+    else {
+        fb->m_caps.hasGL2 = s_gl2_enabled;
+    }
+#else
+    fb->m_caps.hasGL2 = false;
+#endif
+
+    //
+    // Initialize backend EGL display
+    //
+    fb->m_eglDisplay = s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (fb->m_eglDisplay == EGL_NO_DISPLAY) {
+        ERR("Failed to Initialize backend EGL display\n");
+        delete fb;
+        return false;
+    }
+
+    if (!s_egl.eglInitialize(fb->m_eglDisplay, &fb->m_caps.eglMajor, &fb->m_caps.eglMinor)) {
+        ERR("Failed to eglInitialize\n");
+        delete fb;
+        return false;
+    }
+
+    DBG("egl: %d %d\n", fb->m_caps.eglMajor, fb->m_caps.eglMinor);
+    s_egl.eglBindAPI(EGL_OPENGL_ES_API);
+
+    //
+    // if GLES2 plugin has loaded - try to make GLES2 context and
+    // get GLES2 extension string
+    //
+    const char *gl2Extensions = NULL;
+#ifdef WITH_GLES2
+    if (fb->m_caps.hasGL2) {
+        gl2Extensions = getGLES2ExtensionString(fb->m_eglDisplay);
+        if (!gl2Extensions) {
+            // Could not create GLES2 context - drop GL2 capability
+            fb->m_caps.hasGL2 = false;
+        }
+    }
+#endif
+
+    //
+    // Create EGL context for framebuffer post rendering.
+    //
+#if 0
+    GLint configAttribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
+        EGL_NONE
+    };
+#else
+    GLint configAttribs[] = {
+        EGL_RED_SIZE, 1,
+        EGL_GREEN_SIZE, 1,
+        EGL_BLUE_SIZE, 1,
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+        EGL_NONE
+    };
+#endif
+
+    int n;
+    if (!s_egl.eglChooseConfig(fb->m_eglDisplay, configAttribs,
+                               &fb->m_eglConfig, 1, &n)) {
+        ERR("Failed on eglChooseConfig\n");
+        delete fb;
+        return false;
+    }
+
+    GLint glContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 1,
+        EGL_NONE
+    };
+
+    fb->m_eglContext = s_egl.eglCreateContext(fb->m_eglDisplay, fb->m_eglConfig,
+                                              EGL_NO_CONTEXT,
+                                              glContextAttribs);
+    if (fb->m_eglContext == EGL_NO_CONTEXT) {
+        printf("Failed to create Context 0x%x\n", s_egl.eglGetError());
+        delete fb;
+        return false;
+    }
+
+    //
+    // Create another context which shares with the eglContext to be used
+    // when we bind the pbuffer. That prevent switching drawable binding
+    // back and forth on framebuffer context.
+    // The main purpose of it is to solve a "blanking" behaviour we see on
+    // on Mac platform when switching binded drawable for a context however
+    // it is more efficient on other platforms as well.
+    //
+    fb->m_pbufContext = s_egl.eglCreateContext(fb->m_eglDisplay, fb->m_eglConfig,
+                                               fb->m_eglContext,
+                                               glContextAttribs);
+    if (fb->m_pbufContext == EGL_NO_CONTEXT) {
+        printf("Failed to create Pbuffer Context 0x%x\n", s_egl.eglGetError());
+        delete fb;
+        return false;
+    }
+
+    //
+    // create a 1x1 pbuffer surface which will be used for binding
+    // the FB context.
+    // The FB output will go to a subwindow, if one exist.
+    //
+    EGLint pbufAttribs[] = {
+        EGL_WIDTH, 1,
+        EGL_HEIGHT, 1,
+        EGL_NONE
+    };
+
+    fb->m_pbufSurface = s_egl.eglCreatePbufferSurface(fb->m_eglDisplay,
+                                                  fb->m_eglConfig,
+                                                  pbufAttribs);
+    if (fb->m_pbufSurface == EGL_NO_SURFACE) {
+        printf("Failed to create pbuf surface for FB 0x%x\n", s_egl.eglGetError());
+        delete fb;
+        return false;
+    }
+
+    // Make the context current
+    if (!fb->bind_locked()) {
+        ERR("Failed to make current\n");
+        delete fb;
+        return false;
+    }
+
+    //
+    // Initilize framebuffer capabilities
+    //
+    const char *glExtensions = (const char *)s_gl.glGetString(GL_EXTENSIONS);
+    bool has_gl_oes_image = false;
+    if (glExtensions) {
+        has_gl_oes_image = strstr(glExtensions, "GL_OES_EGL_image") != NULL;
+    }
+
+    if (fb->m_caps.hasGL2 && has_gl_oes_image) {
+        has_gl_oes_image &= (strstr(gl2Extensions, "GL_OES_EGL_image") != NULL);
+    }
+
+    const char *eglExtensions = s_egl.eglQueryString(fb->m_eglDisplay,
+                                                     EGL_EXTENSIONS);
+
+    if (eglExtensions && has_gl_oes_image) {
+        fb->m_caps.has_eglimage_texture_2d =
+             strstr(eglExtensions, "EGL_KHR_gl_texture_2D_image") != NULL;
+        fb->m_caps.has_eglimage_renderbuffer =
+             strstr(eglExtensions, "EGL_KHR_gl_renderbuffer_image") != NULL;
+    }
+    else {
+        fb->m_caps.has_eglimage_texture_2d = false;
+        fb->m_caps.has_eglimage_renderbuffer = false;
+    }
+
+    //
+    // Fail initialization if not all of the following extensions
+    // exist:
+    //     EGL_KHR_gl_texture_2d_image
+    //     GL_OES_EGL_IMAGE (by both GLES implementations [1 and 2])
+    //
+    if (!fb->m_caps.has_eglimage_texture_2d) {
+        ERR("Failed: Missing egl_image related extension(s)\n");
+        delete fb;
+        return false;
+    }
+
+    //
+    // Initialize set of configs
+    //
+    InitConfigStatus configStatus = FBConfig::initConfigList(fb);
+    if (configStatus == INIT_CONFIG_FAILED) {
+        ERR("Failed: Initialize set of configs\n");
+        delete fb;
+        return false;
+    }
+
+    //
+    // Check that we have config for each GLES and GLES2
+    //
+    int nConfigs = FBConfig::getNumConfigs();
+    int nGLConfigs = 0;
+    int nGL2Configs = 0;
+    for (int i=0; i<nConfigs; i++) {
+        GLint rtype = FBConfig::get(i)->getRenderableType();
+        if (0 != (rtype & EGL_OPENGL_ES_BIT)) {
+            nGLConfigs++;
+        }
+        if (0 != (rtype & EGL_OPENGL_ES2_BIT)) {
+            nGL2Configs++;
+        }
+    }
+
+    //
+    // Fail initialization if no GLES configs exist
+    //
+    if (nGLConfigs == 0) {
+        delete fb;
+        return false;
+    }
+
+    //
+    // If no GLES2 configs exist - not GLES2 capability
+    //
+    if (nGL2Configs == 0) {
+        fb->m_caps.hasGL2 = false;
+    }
+
+    //
+    // Initialize some GL state in the pbuffer context
+    //
+    fb->initGLState();
+
+    //
+    // Allocate space for the onPost framebuffer image
+    //
+    if (onPost) {
+        fb->m_fbImage = (unsigned char*)malloc(4 * width * height);
+        if (!fb->m_fbImage) {
+            delete fb;
+            return false;
+        }
+    }
+
+    // release the FB context
+    fb->unbind_locked();
+
+    //
+    // Keep the singleton framebuffer pointer
+    //
+    s_theFrameBuffer = fb;
+    return true;
+}
+
+FrameBuffer::FrameBuffer(int p_width, int p_height,
+        OnPostFn onPost, void* onPostContext) :
+    m_width(p_width),
+    m_height(p_height),
+    m_eglDisplay(EGL_NO_DISPLAY),
+    m_eglSurface(EGL_NO_SURFACE),
+    m_eglContext(EGL_NO_CONTEXT),
+    m_pbufContext(EGL_NO_CONTEXT),
+    m_prevContext(EGL_NO_CONTEXT),
+    m_prevReadSurf(EGL_NO_SURFACE),
+    m_prevDrawSurf(EGL_NO_SURFACE),
+    m_subWin(NULL),
+    m_subWinDisplay(NULL),
+    m_lastPostedColorBuffer(0),
+    m_zRot(0.0f),
+    m_eglContextInitialized(false),
+    m_statsNumFrames(0),
+    m_statsStartTime(0LL),
+    m_onPost(onPost),
+    m_onPostContext(onPostContext),
+    m_fbImage(NULL)
+{
+    m_fpsStats = getenv("SHOW_FPS_STATS") != NULL;
+}
+
+FrameBuffer::~FrameBuffer()
+{
+    free(m_fbImage);
+}
+
+bool FrameBuffer::setupSubWindow(FBNativeWindowType p_window,
+                                  int p_x, int p_y,
+                                  int p_width, int p_height, float zRot)
+{
+    bool success = false;
+
+    if (s_theFrameBuffer) {
+        s_theFrameBuffer->m_lock.lock();
+        FrameBuffer *fb = s_theFrameBuffer;
+        if (!fb->m_subWin) {
+
+            // create native subwindow for FB display output
+            fb->m_subWin = createSubWindow(p_window,
+                                           &fb->m_subWinDisplay,
+                                           p_x,p_y,p_width,p_height);
+            if (fb->m_subWin) {
+                fb->m_nativeWindow = p_window;
+
+                // create EGLSurface from the generated subwindow
+                fb->m_eglSurface = s_egl.eglCreateWindowSurface(fb->m_eglDisplay, 
+                                                    fb->m_eglConfig,
+                                                    fb->m_subWin,
+                                                    NULL);
+
+                if (fb->m_eglSurface == EGL_NO_SURFACE) {
+                    ERR("Failed to create surface\n");
+                    destroySubWindow(fb->m_subWinDisplay, fb->m_subWin);
+                    fb->m_subWin = NULL;
+                }
+                else if (fb->bindSubwin_locked()) {
+                    // Subwin creation was successfull,
+                    // update viewport and z rotation and draw
+                    // the last posted color buffer.
+                    s_gl.glViewport(0, 0, p_width, p_height);
+                    fb->m_zRot = zRot;
+                    fb->post( fb->m_lastPostedColorBuffer, false );
+                    fb->unbind_locked();
+                    success = true;
+                }
+             }
+        }
+        s_theFrameBuffer->m_lock.unlock();
+     }
+
+    return success;
+}
+
+bool FrameBuffer::removeSubWindow()
+{
+    bool removed = false;
+    if (s_theFrameBuffer) {
+        s_theFrameBuffer->m_lock.lock();
+        if (s_theFrameBuffer->m_subWin) {
+            s_egl.eglMakeCurrent(s_theFrameBuffer->m_eglDisplay, NULL, NULL, NULL);
+            s_egl.eglDestroySurface(s_theFrameBuffer->m_eglDisplay,
+                                    s_theFrameBuffer->m_eglSurface);
+            destroySubWindow(s_theFrameBuffer->m_subWinDisplay,
+                             s_theFrameBuffer->m_subWin);
+
+            s_theFrameBuffer->m_eglSurface = EGL_NO_SURFACE;
+            s_theFrameBuffer->m_subWin = NULL;
+            removed = true;
+        }
+        s_theFrameBuffer->m_lock.unlock();
+    }
+    return removed;
+}
+
+HandleType FrameBuffer::genHandle()
+{
+    HandleType id;
+    do {
+        id = ++s_nextHandle;
+    } while( id == 0 ||
+             m_contexts.find(id) != m_contexts.end() ||
+             m_windows.find(id) != m_windows.end() );
+
+    return id;
+}
+
+HandleType FrameBuffer::createColorBuffer(int p_width, int p_height,
+                                          GLenum p_internalFormat)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    HandleType ret = 0;
+
+    ColorBufferPtr cb( ColorBuffer::create(p_width, p_height, p_internalFormat) );
+    if (cb.Ptr() != NULL) {
+        ret = genHandle();
+        m_colorbuffers[ret].cb = cb;
+        m_colorbuffers[ret].refcount = 1;
+    }
+    return ret;
+}
+
+HandleType FrameBuffer::createRenderContext(int p_config, HandleType p_share,
+                                            bool p_isGL2)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    HandleType ret = 0;
+
+    RenderContextPtr share(NULL);
+    if (p_share != 0) {
+        RenderContextMap::iterator s( m_contexts.find(p_share) );
+        if (s == m_contexts.end()) {
+            return 0;
+        }
+        share = (*s).second;
+    }
+
+    RenderContextPtr rctx( RenderContext::create(p_config, share, p_isGL2) );
+    if (rctx.Ptr() != NULL) {
+        ret = genHandle();
+        m_contexts[ret] = rctx;
+    }
+    return ret;
+}
+
+HandleType FrameBuffer::createWindowSurface(int p_config, int p_width, int p_height)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    HandleType ret = 0;
+    WindowSurfacePtr win( WindowSurface::create(p_config, p_width, p_height) );
+    if (win.Ptr() != NULL) {
+        ret = genHandle();
+        m_windows[ret] = win;
+    }
+
+    return ret;
+}
+
+void FrameBuffer::DestroyRenderContext(HandleType p_context)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    m_contexts.erase(p_context);
+}
+
+void FrameBuffer::DestroyWindowSurface(HandleType p_surface)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    m_windows.erase(p_surface);
+}
+
+void FrameBuffer::openColorBuffer(HandleType p_colorbuffer)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    ColorBufferMap::iterator c(m_colorbuffers.find(p_colorbuffer));
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return;
+    }
+    (*c).second.refcount++;
+}
+
+void FrameBuffer::closeColorBuffer(HandleType p_colorbuffer)
+{
+    android::Mutex::Autolock mutex(m_lock);
+    ColorBufferMap::iterator c(m_colorbuffers.find(p_colorbuffer));
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return;
+    }
+    if (--(*c).second.refcount == 0) {
+        m_colorbuffers.erase(c);
+    }
+}
+
+bool FrameBuffer::flushWindowSurfaceColorBuffer(HandleType p_surface)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    WindowSurfaceMap::iterator w( m_windows.find(p_surface) );
+    if (w == m_windows.end()) {
+        // bad surface handle
+        return false;
+    }
+
+    (*w).second->flushColorBuffer();
+
+    return true;
+}
+
+bool FrameBuffer::setWindowSurfaceColorBuffer(HandleType p_surface,
+                                              HandleType p_colorbuffer)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    WindowSurfaceMap::iterator w( m_windows.find(p_surface) );
+    if (w == m_windows.end()) {
+        // bad surface handle
+        return false;
+    }
+
+    ColorBufferMap::iterator c( m_colorbuffers.find(p_colorbuffer) );
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    (*w).second->setColorBuffer( (*c).second.cb );
+
+    return true;
+}
+
+bool FrameBuffer::updateColorBuffer(HandleType p_colorbuffer,
+                                    int x, int y, int width, int height,
+                                    GLenum format, GLenum type, void *pixels)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    ColorBufferMap::iterator c( m_colorbuffers.find(p_colorbuffer) );
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    (*c).second.cb->subUpdate(x, y, width, height, format, type, pixels);
+
+    return true;
+}
+
+bool FrameBuffer::bindColorBufferToTexture(HandleType p_colorbuffer)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    ColorBufferMap::iterator c( m_colorbuffers.find(p_colorbuffer) );
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return (*c).second.cb->bindToTexture();
+}
+
+bool FrameBuffer::bindColorBufferToRenderbuffer(HandleType p_colorbuffer)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    ColorBufferMap::iterator c( m_colorbuffers.find(p_colorbuffer) );
+    if (c == m_colorbuffers.end()) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return (*c).second.cb->bindToRenderbuffer();
+}
+
+bool FrameBuffer::bindContext(HandleType p_context,
+                              HandleType p_drawSurface,
+                              HandleType p_readSurface)
+{
+    android::Mutex::Autolock mutex(m_lock);
+
+    WindowSurfacePtr draw(NULL), read(NULL);
+    RenderContextPtr ctx(NULL);
+
+    //
+    // if this is not an unbind operation - make sure all handles are good
+    //
+    if (p_context || p_drawSurface || p_readSurface) {
+        RenderContextMap::iterator r( m_contexts.find(p_context) );
+        if (r == m_contexts.end()) {
+            // bad context handle
+            return false;
+        }
+
+        ctx = (*r).second;
+        WindowSurfaceMap::iterator w( m_windows.find(p_drawSurface) );
+        if (w == m_windows.end()) {
+            // bad surface handle
+            return false;
+        }
+        draw = (*w).second;
+
+        if (p_readSurface != p_drawSurface) {
+            WindowSurfaceMap::iterator w( m_windows.find(p_readSurface) );
+            if (w == m_windows.end()) {
+                // bad surface handle
+                return false;
+            }
+            read = (*w).second;
+        }
+        else {
+            read = draw;
+        }
+    }
+
+    if (!s_egl.eglMakeCurrent(m_eglDisplay,
+                              draw ? draw->getEGLSurface() : EGL_NO_SURFACE,
+                              read ? read->getEGLSurface() : EGL_NO_SURFACE,
+                              ctx ? ctx->getEGLContext() : EGL_NO_CONTEXT)) {
+        // MakeCurrent failed
+        return false;
+    }
+
+    //
+    // Bind the surface(s) to the context
+    //
+    RenderThreadInfo *tinfo = getRenderThreadInfo();
+    if (draw.Ptr() == NULL && read.Ptr() == NULL) {
+        // if this is an unbind operation - make sure the current bound
+        // surfaces get unbound from the context.
+        draw = tinfo->currDrawSurf;
+        read = tinfo->currReadSurf;
+    }
+
+    if (draw.Ptr() != NULL && read.Ptr() != NULL) {
+        if (p_readSurface != p_drawSurface) {
+            draw->bind( ctx, SURFACE_BIND_DRAW );
+            read->bind( ctx, SURFACE_BIND_READ );
+        }
+        else {
+            draw->bind( ctx, SURFACE_BIND_READDRAW );
+        }
+    }
+
+    //
+    // update thread info with current bound context
+    //
+    tinfo->currContext = ctx;
+    tinfo->currDrawSurf = draw;
+    tinfo->currReadSurf = read;
+    if (ctx) {
+        if (ctx->isGL2()) tinfo->m_gl2Dec.setContextData(&ctx->decoderContextData());
+        else tinfo->m_glDec.setContextData(&ctx->decoderContextData());
+    }
+    else {
+        tinfo->m_glDec.setContextData(NULL);
+        tinfo->m_gl2Dec.setContextData(NULL);
+    }
+    return true;
+}
+
+//
+// The framebuffer lock should be held when calling this function !
+//
+bool FrameBuffer::bind_locked()
+{
+    EGLContext prevContext = s_egl.eglGetCurrentContext();
+    EGLSurface prevReadSurf = s_egl.eglGetCurrentSurface(EGL_READ);
+    EGLSurface prevDrawSurf = s_egl.eglGetCurrentSurface(EGL_DRAW);
+
+    if (!s_egl.eglMakeCurrent(m_eglDisplay, m_pbufSurface,
+                              m_pbufSurface, m_pbufContext)) {
+        ERR("eglMakeCurrent failed\n");
+        return false;
+    }
+
+    m_prevContext = prevContext;
+    m_prevReadSurf = prevReadSurf;
+    m_prevDrawSurf = prevDrawSurf;
+    return true;
+}
+
+bool FrameBuffer::bindSubwin_locked()
+{
+    EGLContext prevContext = s_egl.eglGetCurrentContext();
+    EGLSurface prevReadSurf = s_egl.eglGetCurrentSurface(EGL_READ);
+    EGLSurface prevDrawSurf = s_egl.eglGetCurrentSurface(EGL_DRAW);
+
+    if (!s_egl.eglMakeCurrent(m_eglDisplay, m_eglSurface,
+                              m_eglSurface, m_eglContext)) {
+        ERR("eglMakeCurrent failed\n");
+        return false;
+    }
+
+    //
+    // initialize GL state in eglContext if not yet initilaized
+    //
+    if (!m_eglContextInitialized) {
+        initGLState();
+        m_eglContextInitialized = true;
+    }
+
+    m_prevContext = prevContext;
+    m_prevReadSurf = prevReadSurf;
+    m_prevDrawSurf = prevDrawSurf;
+    return true;
+}
+
+bool FrameBuffer::unbind_locked()
+{
+    if (!s_egl.eglMakeCurrent(m_eglDisplay, m_prevDrawSurf,
+                              m_prevReadSurf, m_prevContext)) {
+        return false;
+    }
+
+    m_prevContext = EGL_NO_CONTEXT;
+    m_prevReadSurf = EGL_NO_SURFACE;
+    m_prevDrawSurf = EGL_NO_SURFACE;
+    return true;
+}
+
+bool FrameBuffer::post(HandleType p_colorbuffer, bool needLock)
+{
+    if (needLock) m_lock.lock();
+    bool ret = false;
+
+    ColorBufferMap::iterator c( m_colorbuffers.find(p_colorbuffer) );
+    if (c != m_colorbuffers.end()) {
+
+        m_lastPostedColorBuffer = p_colorbuffer;
+        if (!m_subWin) {
+            // no subwindow created for the FB output
+            // cannot post the colorbuffer
+            if (needLock) m_lock.unlock();
+            return ret;
+        }
+
+
+        // bind the subwindow eglSurface
+        if (!bindSubwin_locked()) {
+            ERR("FrameBuffer::post eglMakeCurrent failed\n");
+            if (needLock) m_lock.unlock();
+            return false;
+        }
+
+        //
+        // render the color buffer to the window
+        //
+        s_gl.glPushMatrix();
+        s_gl.glRotatef(m_zRot, 0.0f, 0.0f, 1.0f);
+        if (m_zRot != 0.0f) {
+            s_gl.glClear(GL_COLOR_BUFFER_BIT);
+        }
+        ret = (*c).second.cb->post();
+        s_gl.glPopMatrix();
+
+        if (ret) {
+            //
+            // Send framebuffer (without FPS overlay) to callback
+            //
+            if (m_onPost) {
+                s_gl.glReadPixels(0, 0, m_width, m_height,
+                        GL_RGBA, GL_UNSIGNED_BYTE, m_fbImage);
+                m_onPost(m_onPostContext, m_width, m_height, -1,
+                        GL_RGBA, GL_UNSIGNED_BYTE, m_fbImage);
+            }
+
+            //
+            // output FPS statistics
+            //
+            if (m_fpsStats) {
+                long long currTime = GetCurrentTimeMS();
+                m_statsNumFrames++;
+                if (currTime - m_statsStartTime >= 1000) {
+                    float dt = (float)(currTime - m_statsStartTime) / 1000.0f;
+                    printf("FPS: %5.3f\n", (float)m_statsNumFrames / dt);
+                    m_statsStartTime = currTime;
+                    m_statsNumFrames = 0;
+                }
+            }
+
+            s_egl.eglSwapBuffers(m_eglDisplay, m_eglSurface);
+        }
+ 
+        // restore previous binding
+        unbind_locked();
+    }
+
+    if (needLock) m_lock.unlock();
+    return ret;
+}
+
+bool FrameBuffer::repost()
+{
+    if (m_lastPostedColorBuffer) {
+        return post( m_lastPostedColorBuffer );
+    }
+    return false;
+}
+
+void FrameBuffer::initGLState()
+{
+    s_gl.glMatrixMode(GL_PROJECTION);
+    s_gl.glLoadIdentity();
+    s_gl.glOrthof(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
+    s_gl.glMatrixMode(GL_MODELVIEW);
+    s_gl.glLoadIdentity();
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.h b/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.h
new file mode 100644
index 0000000..343f384
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/FrameBuffer.h
@@ -0,0 +1,137 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIBRENDER_FRAMEBUFFER_H
+#define _LIBRENDER_FRAMEBUFFER_H
+
+#include "libOpenglRender/render_api.h"
+#include "ColorBuffer.h"
+#include "RenderContext.h"
+#include "WindowSurface.h"
+#include <utils/threads.h>
+#include <map>
+#include <EGL/egl.h>
+#include <stdint.h>
+
+typedef uint32_t HandleType;
+struct ColorBufferRef {
+    ColorBufferPtr cb;
+    uint32_t refcount;  // number of client-side references
+};
+typedef std::map<HandleType, RenderContextPtr> RenderContextMap;
+typedef std::map<HandleType, WindowSurfacePtr> WindowSurfaceMap;
+typedef std::map<HandleType, ColorBufferRef> ColorBufferMap;
+
+struct FrameBufferCaps
+{
+    bool hasGL2;
+    bool has_eglimage_texture_2d;
+    bool has_eglimage_renderbuffer;
+    EGLint eglMajor;
+    EGLint eglMinor;
+};
+
+class FrameBuffer
+{
+public:
+    static bool initialize(int width, int height, OnPostFn onPost, void* onPostContext);
+    static bool setupSubWindow(FBNativeWindowType p_window,
+                                int x, int y,
+                                int width, int height, float zRot);
+    static bool removeSubWindow();
+    static void finalize();
+    static FrameBuffer *getFB() { return s_theFrameBuffer; }
+
+    const FrameBufferCaps &getCaps() const { return m_caps; }
+
+    int getWidth() const { return m_width; }
+    int getHeight() const { return m_height; }
+
+    HandleType createRenderContext(int p_config, HandleType p_share, bool p_isGL2 = false);
+    HandleType createWindowSurface(int p_config, int p_width, int p_height);
+    HandleType createColorBuffer(int p_width, int p_height, GLenum p_internalFormat);
+    void DestroyRenderContext(HandleType p_context);
+    void DestroyWindowSurface(HandleType p_surface);
+    void openColorBuffer(HandleType p_colorbuffer);
+    void closeColorBuffer(HandleType p_colorbuffer);
+
+    bool  bindContext(HandleType p_context, HandleType p_drawSurface, HandleType p_readSurface);
+    bool  setWindowSurfaceColorBuffer(HandleType p_surface, HandleType p_colorbuffer);
+    bool  flushWindowSurfaceColorBuffer(HandleType p_surface);
+    bool  bindColorBufferToTexture(HandleType p_colorbuffer);
+    bool  bindColorBufferToRenderbuffer(HandleType p_colorbuffer);
+    bool updateColorBuffer(HandleType p_colorbuffer,
+                           int x, int y, int width, int height,
+                           GLenum format, GLenum type, void *pixels);
+
+    bool post(HandleType p_colorbuffer, bool needLock = true);
+    bool repost();
+
+    EGLDisplay getDisplay() const { return m_eglDisplay; }
+    EGLNativeWindowType getSubWindow() const { return m_subWin; }
+    bool bind_locked();
+    bool unbind_locked();
+
+    void setDisplayRotation(float zRot) {
+        m_zRot = zRot;
+        repost();
+    }
+
+private:
+    FrameBuffer(int p_width, int p_height, OnPostFn onPost, void* onPostContext);
+    ~FrameBuffer();
+    HandleType genHandle();
+    bool bindSubwin_locked();
+    void initGLState();
+
+private:
+    static FrameBuffer *s_theFrameBuffer;
+    static HandleType s_nextHandle;
+    int m_x;
+    int m_y;
+    int m_width;
+    int m_height;
+    android::Mutex m_lock;
+    FBNativeWindowType m_nativeWindow;
+    FrameBufferCaps m_caps;
+    EGLDisplay m_eglDisplay;
+    RenderContextMap m_contexts;
+    WindowSurfaceMap m_windows;
+    ColorBufferMap m_colorbuffers;
+
+    EGLSurface m_eglSurface;
+    EGLContext m_eglContext;
+    EGLSurface m_pbufSurface;
+    EGLContext m_pbufContext;
+
+    EGLContext m_prevContext;
+    EGLSurface m_prevReadSurf;
+    EGLSurface m_prevDrawSurf;
+    EGLNativeWindowType m_subWin;
+    EGLNativeDisplayType m_subWinDisplay;
+    EGLConfig  m_eglConfig;
+    HandleType m_lastPostedColorBuffer;
+    float      m_zRot;
+    bool       m_eglContextInitialized;
+
+    int m_statsNumFrames;
+    long long m_statsStartTime;
+    bool m_fpsStats;
+
+    OnPostFn m_onPost;
+    void* m_onPostContext;
+    unsigned char* m_fbImage;
+};
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.cpp b/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.cpp
new file mode 100644
index 0000000..cda205f
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.cpp
@@ -0,0 +1,64 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifdef WITH_GLES2
+#include "GL2Dispatch.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "osDynLibrary.h"
+
+gl2_decoder_context_t s_gl2;
+int                   s_gl2_enabled;
+
+static osUtils::dynLibrary *s_gles2_lib = NULL;
+
+#define DEFAULT_GLES_V2_LIB EMUGL_LIBNAME("GLES_V2_translator")
+
+//
+// This function is called only once during initialiation before
+// any thread has been created - hence it should NOT be thread safe.
+//
+bool init_gl2_dispatch()
+{
+    const char *libName = getenv("ANDROID_GLESv2_LIB");
+    if (!libName) libName = DEFAULT_GLES_V2_LIB;
+
+    //
+    // Load the GLES library
+    //
+    s_gles2_lib = osUtils::dynLibrary::open(libName);
+    if (!s_gles2_lib) return false;
+
+    //
+    // init the GLES dispatch table
+    //
+    s_gl2.initDispatchByName( gl2_dispatch_get_proc_func, NULL );
+    s_gl2_enabled = true;
+    return true;
+}
+
+//
+// This function is called only during initialiation before
+// any thread has been created - hence it should NOT be thread safe.
+//
+void *gl2_dispatch_get_proc_func(const char *name, void *userData)
+{
+    if (!s_gles2_lib) {
+        return NULL;
+    }
+    return (void *)s_gles2_lib->findSymbol(name);
+}
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.h b/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.h
new file mode 100644
index 0000000..89f3651
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/GL2Dispatch.h
@@ -0,0 +1,30 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _GLES2_DISPATCH_H
+#define _GLES2_DISPATCH_H
+
+#ifdef WITH_GLES2
+
+#include "gl2_dec.h"
+
+bool init_gl2_dispatch();
+void *gl2_dispatch_get_proc_func(const char *name, void *userData);
+
+extern gl2_decoder_context_t s_gl2;
+extern int                   s_gl2_enabled;
+
+#endif
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/GLDispatch.cpp b/emulator/opengl/host/libs/libOpenglRender/GLDispatch.cpp
new file mode 100644
index 0000000..089512a
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/GLDispatch.cpp
@@ -0,0 +1,325 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "GLDispatch.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "osDynLibrary.h"
+
+GLDispatch s_gl;
+
+static osUtils::dynLibrary *s_gles_lib = NULL;
+
+//
+// This function is called only once during initialiation before
+// any thread has been created - hence it should NOT be thread safe.
+//
+
+#define DEFAULT_GLES_CM_LIB EMUGL_LIBNAME("GLES_CM_translator")
+
+bool init_gl_dispatch()
+{
+    const char *libName = getenv("ANDROID_GLESv1_LIB");
+    if (!libName) libName = DEFAULT_GLES_CM_LIB;
+
+    s_gles_lib = osUtils::dynLibrary::open(libName);
+    if (!s_gles_lib) return false;
+
+    s_gl.glAlphaFunc = (glAlphaFunc_t) s_gles_lib->findSymbol("glAlphaFunc");
+    s_gl.glClearColor = (glClearColor_t) s_gles_lib->findSymbol("glClearColor");
+    s_gl.glClearDepthf = (glClearDepthf_t) s_gles_lib->findSymbol("glClearDepthf");
+    s_gl.glClipPlanef = (glClipPlanef_t) s_gles_lib->findSymbol("glClipPlanef");
+    s_gl.glColor4f = (glColor4f_t) s_gles_lib->findSymbol("glColor4f");
+    s_gl.glDepthRangef = (glDepthRangef_t) s_gles_lib->findSymbol("glDepthRangef");
+    s_gl.glFogf = (glFogf_t) s_gles_lib->findSymbol("glFogf");
+    s_gl.glFogfv = (glFogfv_t) s_gles_lib->findSymbol("glFogfv");
+    s_gl.glFrustumf = (glFrustumf_t) s_gles_lib->findSymbol("glFrustumf");
+    s_gl.glGetClipPlanef = (glGetClipPlanef_t) s_gles_lib->findSymbol("glGetClipPlanef");
+    s_gl.glGetFloatv = (glGetFloatv_t) s_gles_lib->findSymbol("glGetFloatv");
+    s_gl.glGetLightfv = (glGetLightfv_t) s_gles_lib->findSymbol("glGetLightfv");
+    s_gl.glGetMaterialfv = (glGetMaterialfv_t) s_gles_lib->findSymbol("glGetMaterialfv");
+    s_gl.glGetTexEnvfv = (glGetTexEnvfv_t) s_gles_lib->findSymbol("glGetTexEnvfv");
+    s_gl.glGetTexParameterfv = (glGetTexParameterfv_t) s_gles_lib->findSymbol("glGetTexParameterfv");
+    s_gl.glLightModelf = (glLightModelf_t) s_gles_lib->findSymbol("glLightModelf");
+    s_gl.glLightModelfv = (glLightModelfv_t) s_gles_lib->findSymbol("glLightModelfv");
+    s_gl.glLightf = (glLightf_t) s_gles_lib->findSymbol("glLightf");
+    s_gl.glLightfv = (glLightfv_t) s_gles_lib->findSymbol("glLightfv");
+    s_gl.glLineWidth = (glLineWidth_t) s_gles_lib->findSymbol("glLineWidth");
+    s_gl.glLoadMatrixf = (glLoadMatrixf_t) s_gles_lib->findSymbol("glLoadMatrixf");
+    s_gl.glMaterialf = (glMaterialf_t) s_gles_lib->findSymbol("glMaterialf");
+    s_gl.glMaterialfv = (glMaterialfv_t) s_gles_lib->findSymbol("glMaterialfv");
+    s_gl.glMultMatrixf = (glMultMatrixf_t) s_gles_lib->findSymbol("glMultMatrixf");
+    s_gl.glMultiTexCoord4f = (glMultiTexCoord4f_t) s_gles_lib->findSymbol("glMultiTexCoord4f");
+    s_gl.glNormal3f = (glNormal3f_t) s_gles_lib->findSymbol("glNormal3f");
+    s_gl.glOrthof = (glOrthof_t) s_gles_lib->findSymbol("glOrthof");
+    s_gl.glPointParameterf = (glPointParameterf_t) s_gles_lib->findSymbol("glPointParameterf");
+    s_gl.glPointParameterfv = (glPointParameterfv_t) s_gles_lib->findSymbol("glPointParameterfv");
+    s_gl.glPointSize = (glPointSize_t) s_gles_lib->findSymbol("glPointSize");
+    s_gl.glPolygonOffset = (glPolygonOffset_t) s_gles_lib->findSymbol("glPolygonOffset");
+    s_gl.glRotatef = (glRotatef_t) s_gles_lib->findSymbol("glRotatef");
+    s_gl.glScalef = (glScalef_t) s_gles_lib->findSymbol("glScalef");
+    s_gl.glTexEnvf = (glTexEnvf_t) s_gles_lib->findSymbol("glTexEnvf");
+    s_gl.glTexEnvfv = (glTexEnvfv_t) s_gles_lib->findSymbol("glTexEnvfv");
+    s_gl.glTexParameterf = (glTexParameterf_t) s_gles_lib->findSymbol("glTexParameterf");
+    s_gl.glTexParameterfv = (glTexParameterfv_t) s_gles_lib->findSymbol("glTexParameterfv");
+    s_gl.glTranslatef = (glTranslatef_t) s_gles_lib->findSymbol("glTranslatef");
+    s_gl.glActiveTexture = (glActiveTexture_t) s_gles_lib->findSymbol("glActiveTexture");
+    s_gl.glAlphaFuncx = (glAlphaFuncx_t) s_gles_lib->findSymbol("glAlphaFuncx");
+    s_gl.glBindBuffer = (glBindBuffer_t) s_gles_lib->findSymbol("glBindBuffer");
+    s_gl.glBindTexture = (glBindTexture_t) s_gles_lib->findSymbol("glBindTexture");
+    s_gl.glBlendFunc = (glBlendFunc_t) s_gles_lib->findSymbol("glBlendFunc");
+    s_gl.glBufferData = (glBufferData_t) s_gles_lib->findSymbol("glBufferData");
+    s_gl.glBufferSubData = (glBufferSubData_t) s_gles_lib->findSymbol("glBufferSubData");
+    s_gl.glClear = (glClear_t) s_gles_lib->findSymbol("glClear");
+    s_gl.glClearColorx = (glClearColorx_t) s_gles_lib->findSymbol("glClearColorx");
+    s_gl.glClearDepthx = (glClearDepthx_t) s_gles_lib->findSymbol("glClearDepthx");
+    s_gl.glClearStencil = (glClearStencil_t) s_gles_lib->findSymbol("glClearStencil");
+    s_gl.glClientActiveTexture = (glClientActiveTexture_t) s_gles_lib->findSymbol("glClientActiveTexture");
+    s_gl.glClipPlanex = (glClipPlanex_t) s_gles_lib->findSymbol("glClipPlanex");
+    s_gl.glColor4ub = (glColor4ub_t) s_gles_lib->findSymbol("glColor4ub");
+    s_gl.glColor4x = (glColor4x_t) s_gles_lib->findSymbol("glColor4x");
+    s_gl.glColorMask = (glColorMask_t) s_gles_lib->findSymbol("glColorMask");
+    s_gl.glColorPointer = (glColorPointer_t) s_gles_lib->findSymbol("glColorPointer");
+    s_gl.glCompressedTexImage2D = (glCompressedTexImage2D_t) s_gles_lib->findSymbol("glCompressedTexImage2D");
+    s_gl.glCompressedTexSubImage2D = (glCompressedTexSubImage2D_t) s_gles_lib->findSymbol("glCompressedTexSubImage2D");
+    s_gl.glCopyTexImage2D = (glCopyTexImage2D_t) s_gles_lib->findSymbol("glCopyTexImage2D");
+    s_gl.glCopyTexSubImage2D = (glCopyTexSubImage2D_t) s_gles_lib->findSymbol("glCopyTexSubImage2D");
+    s_gl.glCullFace = (glCullFace_t) s_gles_lib->findSymbol("glCullFace");
+    s_gl.glDeleteBuffers = (glDeleteBuffers_t) s_gles_lib->findSymbol("glDeleteBuffers");
+    s_gl.glDeleteTextures = (glDeleteTextures_t) s_gles_lib->findSymbol("glDeleteTextures");
+    s_gl.glDepthFunc = (glDepthFunc_t) s_gles_lib->findSymbol("glDepthFunc");
+    s_gl.glDepthMask = (glDepthMask_t) s_gles_lib->findSymbol("glDepthMask");
+    s_gl.glDepthRangex = (glDepthRangex_t) s_gles_lib->findSymbol("glDepthRangex");
+    s_gl.glDisable = (glDisable_t) s_gles_lib->findSymbol("glDisable");
+    s_gl.glDisableClientState = (glDisableClientState_t) s_gles_lib->findSymbol("glDisableClientState");
+    s_gl.glDrawArrays = (glDrawArrays_t) s_gles_lib->findSymbol("glDrawArrays");
+    s_gl.glDrawElements = (glDrawElements_t) s_gles_lib->findSymbol("glDrawElements");
+    s_gl.glEnable = (glEnable_t) s_gles_lib->findSymbol("glEnable");
+    s_gl.glEnableClientState = (glEnableClientState_t) s_gles_lib->findSymbol("glEnableClientState");
+    s_gl.glFinish = (glFinish_t) s_gles_lib->findSymbol("glFinish");
+    s_gl.glFlush = (glFlush_t) s_gles_lib->findSymbol("glFlush");
+    s_gl.glFogx = (glFogx_t) s_gles_lib->findSymbol("glFogx");
+    s_gl.glFogxv = (glFogxv_t) s_gles_lib->findSymbol("glFogxv");
+    s_gl.glFrontFace = (glFrontFace_t) s_gles_lib->findSymbol("glFrontFace");
+    s_gl.glFrustumx = (glFrustumx_t) s_gles_lib->findSymbol("glFrustumx");
+    s_gl.glGetBooleanv = (glGetBooleanv_t) s_gles_lib->findSymbol("glGetBooleanv");
+    s_gl.glGetBufferParameteriv = (glGetBufferParameteriv_t) s_gles_lib->findSymbol("glGetBufferParameteriv");
+    s_gl.glGetClipPlanex = (glGetClipPlanex_t) s_gles_lib->findSymbol("glGetClipPlanex");
+    s_gl.glGenBuffers = (glGenBuffers_t) s_gles_lib->findSymbol("glGenBuffers");
+    s_gl.glGenTextures = (glGenTextures_t) s_gles_lib->findSymbol("glGenTextures");
+    s_gl.glGetError = (glGetError_t) s_gles_lib->findSymbol("glGetError");
+    s_gl.glGetFixedv = (glGetFixedv_t) s_gles_lib->findSymbol("glGetFixedv");
+    s_gl.glGetIntegerv = (glGetIntegerv_t) s_gles_lib->findSymbol("glGetIntegerv");
+    s_gl.glGetLightxv = (glGetLightxv_t) s_gles_lib->findSymbol("glGetLightxv");
+    s_gl.glGetMaterialxv = (glGetMaterialxv_t) s_gles_lib->findSymbol("glGetMaterialxv");
+    s_gl.glGetPointerv = (glGetPointerv_t) s_gles_lib->findSymbol("glGetPointerv");
+    s_gl.glGetString = (glGetString_t) s_gles_lib->findSymbol("glGetString");
+    s_gl.glGetTexEnviv = (glGetTexEnviv_t) s_gles_lib->findSymbol("glGetTexEnviv");
+    s_gl.glGetTexEnvxv = (glGetTexEnvxv_t) s_gles_lib->findSymbol("glGetTexEnvxv");
+    s_gl.glGetTexParameteriv = (glGetTexParameteriv_t) s_gles_lib->findSymbol("glGetTexParameteriv");
+    s_gl.glGetTexParameterxv = (glGetTexParameterxv_t) s_gles_lib->findSymbol("glGetTexParameterxv");
+    s_gl.glHint = (glHint_t) s_gles_lib->findSymbol("glHint");
+    s_gl.glIsBuffer = (glIsBuffer_t) s_gles_lib->findSymbol("glIsBuffer");
+    s_gl.glIsEnabled = (glIsEnabled_t) s_gles_lib->findSymbol("glIsEnabled");
+    s_gl.glIsTexture = (glIsTexture_t) s_gles_lib->findSymbol("glIsTexture");
+    s_gl.glLightModelx = (glLightModelx_t) s_gles_lib->findSymbol("glLightModelx");
+    s_gl.glLightModelxv = (glLightModelxv_t) s_gles_lib->findSymbol("glLightModelxv");
+    s_gl.glLightx = (glLightx_t) s_gles_lib->findSymbol("glLightx");
+    s_gl.glLightxv = (glLightxv_t) s_gles_lib->findSymbol("glLightxv");
+    s_gl.glLineWidthx = (glLineWidthx_t) s_gles_lib->findSymbol("glLineWidthx");
+    s_gl.glLoadIdentity = (glLoadIdentity_t) s_gles_lib->findSymbol("glLoadIdentity");
+    s_gl.glLoadMatrixx = (glLoadMatrixx_t) s_gles_lib->findSymbol("glLoadMatrixx");
+    s_gl.glLogicOp = (glLogicOp_t) s_gles_lib->findSymbol("glLogicOp");
+    s_gl.glMaterialx = (glMaterialx_t) s_gles_lib->findSymbol("glMaterialx");
+    s_gl.glMaterialxv = (glMaterialxv_t) s_gles_lib->findSymbol("glMaterialxv");
+    s_gl.glMatrixMode = (glMatrixMode_t) s_gles_lib->findSymbol("glMatrixMode");
+    s_gl.glMultMatrixx = (glMultMatrixx_t) s_gles_lib->findSymbol("glMultMatrixx");
+    s_gl.glMultiTexCoord4x = (glMultiTexCoord4x_t) s_gles_lib->findSymbol("glMultiTexCoord4x");
+    s_gl.glNormal3x = (glNormal3x_t) s_gles_lib->findSymbol("glNormal3x");
+    s_gl.glNormalPointer = (glNormalPointer_t) s_gles_lib->findSymbol("glNormalPointer");
+    s_gl.glOrthox = (glOrthox_t) s_gles_lib->findSymbol("glOrthox");
+    s_gl.glPixelStorei = (glPixelStorei_t) s_gles_lib->findSymbol("glPixelStorei");
+    s_gl.glPointParameterx = (glPointParameterx_t) s_gles_lib->findSymbol("glPointParameterx");
+    s_gl.glPointParameterxv = (glPointParameterxv_t) s_gles_lib->findSymbol("glPointParameterxv");
+    s_gl.glPointSizex = (glPointSizex_t) s_gles_lib->findSymbol("glPointSizex");
+    s_gl.glPolygonOffsetx = (glPolygonOffsetx_t) s_gles_lib->findSymbol("glPolygonOffsetx");
+    s_gl.glPopMatrix = (glPopMatrix_t) s_gles_lib->findSymbol("glPopMatrix");
+    s_gl.glPushMatrix = (glPushMatrix_t) s_gles_lib->findSymbol("glPushMatrix");
+    s_gl.glReadPixels = (glReadPixels_t) s_gles_lib->findSymbol("glReadPixels");
+    s_gl.glRotatex = (glRotatex_t) s_gles_lib->findSymbol("glRotatex");
+    s_gl.glSampleCoverage = (glSampleCoverage_t) s_gles_lib->findSymbol("glSampleCoverage");
+    s_gl.glSampleCoveragex = (glSampleCoveragex_t) s_gles_lib->findSymbol("glSampleCoveragex");
+    s_gl.glScalex = (glScalex_t) s_gles_lib->findSymbol("glScalex");
+    s_gl.glScissor = (glScissor_t) s_gles_lib->findSymbol("glScissor");
+    s_gl.glShadeModel = (glShadeModel_t) s_gles_lib->findSymbol("glShadeModel");
+    s_gl.glStencilFunc = (glStencilFunc_t) s_gles_lib->findSymbol("glStencilFunc");
+    s_gl.glStencilMask = (glStencilMask_t) s_gles_lib->findSymbol("glStencilMask");
+    s_gl.glStencilOp = (glStencilOp_t) s_gles_lib->findSymbol("glStencilOp");
+    s_gl.glTexCoordPointer = (glTexCoordPointer_t) s_gles_lib->findSymbol("glTexCoordPointer");
+    s_gl.glTexEnvi = (glTexEnvi_t) s_gles_lib->findSymbol("glTexEnvi");
+    s_gl.glTexEnvx = (glTexEnvx_t) s_gles_lib->findSymbol("glTexEnvx");
+    s_gl.glTexEnviv = (glTexEnviv_t) s_gles_lib->findSymbol("glTexEnviv");
+    s_gl.glTexEnvxv = (glTexEnvxv_t) s_gles_lib->findSymbol("glTexEnvxv");
+    s_gl.glTexImage2D = (glTexImage2D_t) s_gles_lib->findSymbol("glTexImage2D");
+    s_gl.glTexParameteri = (glTexParameteri_t) s_gles_lib->findSymbol("glTexParameteri");
+    s_gl.glTexParameterx = (glTexParameterx_t) s_gles_lib->findSymbol("glTexParameterx");
+    s_gl.glTexParameteriv = (glTexParameteriv_t) s_gles_lib->findSymbol("glTexParameteriv");
+    s_gl.glTexParameterxv = (glTexParameterxv_t) s_gles_lib->findSymbol("glTexParameterxv");
+    s_gl.glTexSubImage2D = (glTexSubImage2D_t) s_gles_lib->findSymbol("glTexSubImage2D");
+    s_gl.glTranslatex = (glTranslatex_t) s_gles_lib->findSymbol("glTranslatex");
+    s_gl.glVertexPointer = (glVertexPointer_t) s_gles_lib->findSymbol("glVertexPointer");
+    s_gl.glViewport = (glViewport_t) s_gles_lib->findSymbol("glViewport");
+    s_gl.glPointSizePointerOES = (glPointSizePointerOES_t) s_gles_lib->findSymbol("glPointSizePointerOES");
+    s_gl.glBlendEquationSeparateOES = (glBlendEquationSeparateOES_t) s_gles_lib->findSymbol("glBlendEquationSeparateOES");
+    s_gl.glBlendFuncSeparateOES = (glBlendFuncSeparateOES_t) s_gles_lib->findSymbol("glBlendFuncSeparateOES");
+    s_gl.glBlendEquationOES = (glBlendEquationOES_t) s_gles_lib->findSymbol("glBlendEquationOES");
+    s_gl.glDrawTexsOES = (glDrawTexsOES_t) s_gles_lib->findSymbol("glDrawTexsOES");
+    s_gl.glDrawTexiOES = (glDrawTexiOES_t) s_gles_lib->findSymbol("glDrawTexiOES");
+    s_gl.glDrawTexxOES = (glDrawTexxOES_t) s_gles_lib->findSymbol("glDrawTexxOES");
+    s_gl.glDrawTexsvOES = (glDrawTexsvOES_t) s_gles_lib->findSymbol("glDrawTexsvOES");
+    s_gl.glDrawTexivOES = (glDrawTexivOES_t) s_gles_lib->findSymbol("glDrawTexivOES");
+    s_gl.glDrawTexxvOES = (glDrawTexxvOES_t) s_gles_lib->findSymbol("glDrawTexxvOES");
+    s_gl.glDrawTexfOES = (glDrawTexfOES_t) s_gles_lib->findSymbol("glDrawTexfOES");
+    s_gl.glDrawTexfvOES = (glDrawTexfvOES_t) s_gles_lib->findSymbol("glDrawTexfvOES");
+    s_gl.glEGLImageTargetTexture2DOES = (glEGLImageTargetTexture2DOES_t) s_gles_lib->findSymbol("glEGLImageTargetTexture2DOES");
+    s_gl.glEGLImageTargetRenderbufferStorageOES = (glEGLImageTargetRenderbufferStorageOES_t) s_gles_lib->findSymbol("glEGLImageTargetRenderbufferStorageOES");
+    s_gl.glAlphaFuncxOES = (glAlphaFuncxOES_t) s_gles_lib->findSymbol("glAlphaFuncxOES");
+    s_gl.glClearColorxOES = (glClearColorxOES_t) s_gles_lib->findSymbol("glClearColorxOES");
+    s_gl.glClearDepthxOES = (glClearDepthxOES_t) s_gles_lib->findSymbol("glClearDepthxOES");
+    s_gl.glClipPlanexOES = (glClipPlanexOES_t) s_gles_lib->findSymbol("glClipPlanexOES");
+    s_gl.glColor4xOES = (glColor4xOES_t) s_gles_lib->findSymbol("glColor4xOES");
+    s_gl.glDepthRangexOES = (glDepthRangexOES_t) s_gles_lib->findSymbol("glDepthRangexOES");
+    s_gl.glFogxOES = (glFogxOES_t) s_gles_lib->findSymbol("glFogxOES");
+    s_gl.glFogxvOES = (glFogxvOES_t) s_gles_lib->findSymbol("glFogxvOES");
+    s_gl.glFrustumxOES = (glFrustumxOES_t) s_gles_lib->findSymbol("glFrustumxOES");
+    s_gl.glGetClipPlanexOES = (glGetClipPlanexOES_t) s_gles_lib->findSymbol("glGetClipPlanexOES");
+    s_gl.glGetFixedvOES = (glGetFixedvOES_t) s_gles_lib->findSymbol("glGetFixedvOES");
+    s_gl.glGetLightxvOES = (glGetLightxvOES_t) s_gles_lib->findSymbol("glGetLightxvOES");
+    s_gl.glGetMaterialxvOES = (glGetMaterialxvOES_t) s_gles_lib->findSymbol("glGetMaterialxvOES");
+    s_gl.glGetTexEnvxvOES = (glGetTexEnvxvOES_t) s_gles_lib->findSymbol("glGetTexEnvxvOES");
+    s_gl.glGetTexParameterxvOES = (glGetTexParameterxvOES_t) s_gles_lib->findSymbol("glGetTexParameterxvOES");
+    s_gl.glLightModelxOES = (glLightModelxOES_t) s_gles_lib->findSymbol("glLightModelxOES");
+    s_gl.glLightModelxvOES = (glLightModelxvOES_t) s_gles_lib->findSymbol("glLightModelxvOES");
+    s_gl.glLightxOES = (glLightxOES_t) s_gles_lib->findSymbol("glLightxOES");
+    s_gl.glLightxvOES = (glLightxvOES_t) s_gles_lib->findSymbol("glLightxvOES");
+    s_gl.glLineWidthxOES = (glLineWidthxOES_t) s_gles_lib->findSymbol("glLineWidthxOES");
+    s_gl.glLoadMatrixxOES = (glLoadMatrixxOES_t) s_gles_lib->findSymbol("glLoadMatrixxOES");
+    s_gl.glMaterialxOES = (glMaterialxOES_t) s_gles_lib->findSymbol("glMaterialxOES");
+    s_gl.glMaterialxvOES = (glMaterialxvOES_t) s_gles_lib->findSymbol("glMaterialxvOES");
+    s_gl.glMultMatrixxOES = (glMultMatrixxOES_t) s_gles_lib->findSymbol("glMultMatrixxOES");
+    s_gl.glMultiTexCoord4xOES = (glMultiTexCoord4xOES_t) s_gles_lib->findSymbol("glMultiTexCoord4xOES");
+    s_gl.glNormal3xOES = (glNormal3xOES_t) s_gles_lib->findSymbol("glNormal3xOES");
+    s_gl.glOrthoxOES = (glOrthoxOES_t) s_gles_lib->findSymbol("glOrthoxOES");
+    s_gl.glPointParameterxOES = (glPointParameterxOES_t) s_gles_lib->findSymbol("glPointParameterxOES");
+    s_gl.glPointParameterxvOES = (glPointParameterxvOES_t) s_gles_lib->findSymbol("glPointParameterxvOES");
+    s_gl.glPointSizexOES = (glPointSizexOES_t) s_gles_lib->findSymbol("glPointSizexOES");
+    s_gl.glPolygonOffsetxOES = (glPolygonOffsetxOES_t) s_gles_lib->findSymbol("glPolygonOffsetxOES");
+    s_gl.glRotatexOES = (glRotatexOES_t) s_gles_lib->findSymbol("glRotatexOES");
+    s_gl.glSampleCoveragexOES = (glSampleCoveragexOES_t) s_gles_lib->findSymbol("glSampleCoveragexOES");
+    s_gl.glScalexOES = (glScalexOES_t) s_gles_lib->findSymbol("glScalexOES");
+    s_gl.glTexEnvxOES = (glTexEnvxOES_t) s_gles_lib->findSymbol("glTexEnvxOES");
+    s_gl.glTexEnvxvOES = (glTexEnvxvOES_t) s_gles_lib->findSymbol("glTexEnvxvOES");
+    s_gl.glTexParameterxOES = (glTexParameterxOES_t) s_gles_lib->findSymbol("glTexParameterxOES");
+    s_gl.glTexParameterxvOES = (glTexParameterxvOES_t) s_gles_lib->findSymbol("glTexParameterxvOES");
+    s_gl.glTranslatexOES = (glTranslatexOES_t) s_gles_lib->findSymbol("glTranslatexOES");
+    s_gl.glIsRenderbufferOES = (glIsRenderbufferOES_t) s_gles_lib->findSymbol("glIsRenderbufferOES");
+    s_gl.glBindRenderbufferOES = (glBindRenderbufferOES_t) s_gles_lib->findSymbol("glBindRenderbufferOES");
+    s_gl.glDeleteRenderbuffersOES = (glDeleteRenderbuffersOES_t) s_gles_lib->findSymbol("glDeleteRenderbuffersOES");
+    s_gl.glGenRenderbuffersOES = (glGenRenderbuffersOES_t) s_gles_lib->findSymbol("glGenRenderbuffersOES");
+    s_gl.glRenderbufferStorageOES = (glRenderbufferStorageOES_t) s_gles_lib->findSymbol("glRenderbufferStorageOES");
+    s_gl.glGetRenderbufferParameterivOES = (glGetRenderbufferParameterivOES_t) s_gles_lib->findSymbol("glGetRenderbufferParameterivOES");
+    s_gl.glIsFramebufferOES = (glIsFramebufferOES_t) s_gles_lib->findSymbol("glIsFramebufferOES");
+    s_gl.glBindFramebufferOES = (glBindFramebufferOES_t) s_gles_lib->findSymbol("glBindFramebufferOES");
+    s_gl.glDeleteFramebuffersOES = (glDeleteFramebuffersOES_t) s_gles_lib->findSymbol("glDeleteFramebuffersOES");
+    s_gl.glGenFramebuffersOES = (glGenFramebuffersOES_t) s_gles_lib->findSymbol("glGenFramebuffersOES");
+    s_gl.glCheckFramebufferStatusOES = (glCheckFramebufferStatusOES_t) s_gles_lib->findSymbol("glCheckFramebufferStatusOES");
+    s_gl.glFramebufferRenderbufferOES = (glFramebufferRenderbufferOES_t) s_gles_lib->findSymbol("glFramebufferRenderbufferOES");
+    s_gl.glFramebufferTexture2DOES = (glFramebufferTexture2DOES_t) s_gles_lib->findSymbol("glFramebufferTexture2DOES");
+    s_gl.glGetFramebufferAttachmentParameterivOES = (glGetFramebufferAttachmentParameterivOES_t) s_gles_lib->findSymbol("glGetFramebufferAttachmentParameterivOES");
+    s_gl.glGenerateMipmapOES = (glGenerateMipmapOES_t) s_gles_lib->findSymbol("glGenerateMipmapOES");
+    s_gl.glMapBufferOES = (glMapBufferOES_t) s_gles_lib->findSymbol("glMapBufferOES");
+    s_gl.glUnmapBufferOES = (glUnmapBufferOES_t) s_gles_lib->findSymbol("glUnmapBufferOES");
+    s_gl.glGetBufferPointervOES = (glGetBufferPointervOES_t) s_gles_lib->findSymbol("glGetBufferPointervOES");
+    s_gl.glCurrentPaletteMatrixOES = (glCurrentPaletteMatrixOES_t) s_gles_lib->findSymbol("glCurrentPaletteMatrixOES");
+    s_gl.glLoadPaletteFromModelViewMatrixOES = (glLoadPaletteFromModelViewMatrixOES_t) s_gles_lib->findSymbol("glLoadPaletteFromModelViewMatrixOES");
+    s_gl.glMatrixIndexPointerOES = (glMatrixIndexPointerOES_t) s_gles_lib->findSymbol("glMatrixIndexPointerOES");
+    s_gl.glWeightPointerOES = (glWeightPointerOES_t) s_gles_lib->findSymbol("glWeightPointerOES");
+    s_gl.glQueryMatrixxOES = (glQueryMatrixxOES_t) s_gles_lib->findSymbol("glQueryMatrixxOES");
+    s_gl.glDepthRangefOES = (glDepthRangefOES_t) s_gles_lib->findSymbol("glDepthRangefOES");
+    s_gl.glFrustumfOES = (glFrustumfOES_t) s_gles_lib->findSymbol("glFrustumfOES");
+    s_gl.glOrthofOES = (glOrthofOES_t) s_gles_lib->findSymbol("glOrthofOES");
+    s_gl.glClipPlanefOES = (glClipPlanefOES_t) s_gles_lib->findSymbol("glClipPlanefOES");
+    s_gl.glGetClipPlanefOES = (glGetClipPlanefOES_t) s_gles_lib->findSymbol("glGetClipPlanefOES");
+    s_gl.glClearDepthfOES = (glClearDepthfOES_t) s_gles_lib->findSymbol("glClearDepthfOES");
+    s_gl.glTexGenfOES = (glTexGenfOES_t) s_gles_lib->findSymbol("glTexGenfOES");
+    s_gl.glTexGenfvOES = (glTexGenfvOES_t) s_gles_lib->findSymbol("glTexGenfvOES");
+    s_gl.glTexGeniOES = (glTexGeniOES_t) s_gles_lib->findSymbol("glTexGeniOES");
+    s_gl.glTexGenivOES = (glTexGenivOES_t) s_gles_lib->findSymbol("glTexGenivOES");
+    s_gl.glTexGenxOES = (glTexGenxOES_t) s_gles_lib->findSymbol("glTexGenxOES");
+    s_gl.glTexGenxvOES = (glTexGenxvOES_t) s_gles_lib->findSymbol("glTexGenxvOES");
+    s_gl.glGetTexGenfvOES = (glGetTexGenfvOES_t) s_gles_lib->findSymbol("glGetTexGenfvOES");
+    s_gl.glGetTexGenivOES = (glGetTexGenivOES_t) s_gles_lib->findSymbol("glGetTexGenivOES");
+    s_gl.glGetTexGenxvOES = (glGetTexGenxvOES_t) s_gles_lib->findSymbol("glGetTexGenxvOES");
+    s_gl.glBindVertexArrayOES = (glBindVertexArrayOES_t) s_gles_lib->findSymbol("glBindVertexArrayOES");
+    s_gl.glDeleteVertexArraysOES = (glDeleteVertexArraysOES_t) s_gles_lib->findSymbol("glDeleteVertexArraysOES");
+    s_gl.glGenVertexArraysOES = (glGenVertexArraysOES_t) s_gles_lib->findSymbol("glGenVertexArraysOES");
+    s_gl.glIsVertexArrayOES = (glIsVertexArrayOES_t) s_gles_lib->findSymbol("glIsVertexArrayOES");
+    s_gl.glDiscardFramebufferEXT = (glDiscardFramebufferEXT_t) s_gles_lib->findSymbol("glDiscardFramebufferEXT");
+    s_gl.glMultiDrawArraysEXT = (glMultiDrawArraysEXT_t) s_gles_lib->findSymbol("glMultiDrawArraysEXT");
+    s_gl.glMultiDrawElementsEXT = (glMultiDrawElementsEXT_t) s_gles_lib->findSymbol("glMultiDrawElementsEXT");
+    s_gl.glClipPlanefIMG = (glClipPlanefIMG_t) s_gles_lib->findSymbol("glClipPlanefIMG");
+    s_gl.glClipPlanexIMG = (glClipPlanexIMG_t) s_gles_lib->findSymbol("glClipPlanexIMG");
+    s_gl.glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_t) s_gles_lib->findSymbol("glRenderbufferStorageMultisampleIMG");
+    s_gl.glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_t) s_gles_lib->findSymbol("glFramebufferTexture2DMultisampleIMG");
+    s_gl.glDeleteFencesNV = (glDeleteFencesNV_t) s_gles_lib->findSymbol("glDeleteFencesNV");
+    s_gl.glGenFencesNV = (glGenFencesNV_t) s_gles_lib->findSymbol("glGenFencesNV");
+    s_gl.glIsFenceNV = (glIsFenceNV_t) s_gles_lib->findSymbol("glIsFenceNV");
+    s_gl.glTestFenceNV = (glTestFenceNV_t) s_gles_lib->findSymbol("glTestFenceNV");
+    s_gl.glGetFenceivNV = (glGetFenceivNV_t) s_gles_lib->findSymbol("glGetFenceivNV");
+    s_gl.glFinishFenceNV = (glFinishFenceNV_t) s_gles_lib->findSymbol("glFinishFenceNV");
+    s_gl.glSetFenceNV = (glSetFenceNV_t) s_gles_lib->findSymbol("glSetFenceNV");
+    s_gl.glGetDriverControlsQCOM = (glGetDriverControlsQCOM_t) s_gles_lib->findSymbol("glGetDriverControlsQCOM");
+    s_gl.glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_t) s_gles_lib->findSymbol("glGetDriverControlStringQCOM");
+    s_gl.glEnableDriverControlQCOM = (glEnableDriverControlQCOM_t) s_gles_lib->findSymbol("glEnableDriverControlQCOM");
+    s_gl.glDisableDriverControlQCOM = (glDisableDriverControlQCOM_t) s_gles_lib->findSymbol("glDisableDriverControlQCOM");
+    s_gl.glExtGetTexturesQCOM = (glExtGetTexturesQCOM_t) s_gles_lib->findSymbol("glExtGetTexturesQCOM");
+    s_gl.glExtGetBuffersQCOM = (glExtGetBuffersQCOM_t) s_gles_lib->findSymbol("glExtGetBuffersQCOM");
+    s_gl.glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_t) s_gles_lib->findSymbol("glExtGetRenderbuffersQCOM");
+    s_gl.glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_t) s_gles_lib->findSymbol("glExtGetFramebuffersQCOM");
+    s_gl.glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_t) s_gles_lib->findSymbol("glExtGetTexLevelParameterivQCOM");
+    s_gl.glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_t) s_gles_lib->findSymbol("glExtTexObjectStateOverrideiQCOM");
+    s_gl.glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_t) s_gles_lib->findSymbol("glExtGetTexSubImageQCOM");
+    s_gl.glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_t) s_gles_lib->findSymbol("glExtGetBufferPointervQCOM");
+    s_gl.glExtGetShadersQCOM = (glExtGetShadersQCOM_t) s_gles_lib->findSymbol("glExtGetShadersQCOM");
+    s_gl.glExtGetProgramsQCOM = (glExtGetProgramsQCOM_t) s_gles_lib->findSymbol("glExtGetProgramsQCOM");
+    s_gl.glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_t) s_gles_lib->findSymbol("glExtIsProgramBinaryQCOM");
+    s_gl.glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_t) s_gles_lib->findSymbol("glExtGetProgramBinarySourceQCOM");
+    s_gl.glStartTilingQCOM = (glStartTilingQCOM_t) s_gles_lib->findSymbol("glStartTilingQCOM");
+    s_gl.glEndTilingQCOM = (glEndTilingQCOM_t) s_gles_lib->findSymbol("glEndTilingQCOM");
+
+    return true;
+}
+
+//
+// This function is called only during initialiation before
+// any thread has been created - hence it should NOT be thread safe.
+//
+void *gl_dispatch_get_proc_func(const char *name, void *userData)
+{
+    if (!s_gles_lib) {
+        return NULL;
+    }
+    return (void *)s_gles_lib->findSymbol(name);
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/GLDispatch.h b/emulator/opengl/host/libs/libOpenglRender/GLDispatch.h
new file mode 100644
index 0000000..5fe98f1
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/GLDispatch.h
@@ -0,0 +1,300 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _GLES_DISPATCH_H
+#define _GLES_DISPATCH_H
+
+#include "gl_proc.h"
+
+
+struct GLDispatch {
+    glAlphaFunc_t glAlphaFunc;
+    glClearColor_t glClearColor;
+    glClearDepthf_t glClearDepthf;
+    glClipPlanef_t glClipPlanef;
+    glColor4f_t glColor4f;
+    glDepthRangef_t glDepthRangef;
+    glFogf_t glFogf;
+    glFogfv_t glFogfv;
+    glFrustumf_t glFrustumf;
+    glGetClipPlanef_t glGetClipPlanef;
+    glGetFloatv_t glGetFloatv;
+    glGetLightfv_t glGetLightfv;
+    glGetMaterialfv_t glGetMaterialfv;
+    glGetTexEnvfv_t glGetTexEnvfv;
+    glGetTexParameterfv_t glGetTexParameterfv;
+    glLightModelf_t glLightModelf;
+    glLightModelfv_t glLightModelfv;
+    glLightf_t glLightf;
+    glLightfv_t glLightfv;
+    glLineWidth_t glLineWidth;
+    glLoadMatrixf_t glLoadMatrixf;
+    glMaterialf_t glMaterialf;
+    glMaterialfv_t glMaterialfv;
+    glMultMatrixf_t glMultMatrixf;
+    glMultiTexCoord4f_t glMultiTexCoord4f;
+    glNormal3f_t glNormal3f;
+    glOrthof_t glOrthof;
+    glPointParameterf_t glPointParameterf;
+    glPointParameterfv_t glPointParameterfv;
+    glPointSize_t glPointSize;
+    glPolygonOffset_t glPolygonOffset;
+    glRotatef_t glRotatef;
+    glScalef_t glScalef;
+    glTexEnvf_t glTexEnvf;
+    glTexEnvfv_t glTexEnvfv;
+    glTexParameterf_t glTexParameterf;
+    glTexParameterfv_t glTexParameterfv;
+    glTranslatef_t glTranslatef;
+    glActiveTexture_t glActiveTexture;
+    glAlphaFuncx_t glAlphaFuncx;
+    glBindBuffer_t glBindBuffer;
+    glBindTexture_t glBindTexture;
+    glBlendFunc_t glBlendFunc;
+    glBufferData_t glBufferData;
+    glBufferSubData_t glBufferSubData;
+    glClear_t glClear;
+    glClearColorx_t glClearColorx;
+    glClearDepthx_t glClearDepthx;
+    glClearStencil_t glClearStencil;
+    glClientActiveTexture_t glClientActiveTexture;
+    glClipPlanex_t glClipPlanex;
+    glColor4ub_t glColor4ub;
+    glColor4x_t glColor4x;
+    glColorMask_t glColorMask;
+    glColorPointer_t glColorPointer;
+    glCompressedTexImage2D_t glCompressedTexImage2D;
+    glCompressedTexSubImage2D_t glCompressedTexSubImage2D;
+    glCopyTexImage2D_t glCopyTexImage2D;
+    glCopyTexSubImage2D_t glCopyTexSubImage2D;
+    glCullFace_t glCullFace;
+    glDeleteBuffers_t glDeleteBuffers;
+    glDeleteTextures_t glDeleteTextures;
+    glDepthFunc_t glDepthFunc;
+    glDepthMask_t glDepthMask;
+    glDepthRangex_t glDepthRangex;
+    glDisable_t glDisable;
+    glDisableClientState_t glDisableClientState;
+    glDrawArrays_t glDrawArrays;
+    glDrawElements_t glDrawElements;
+    glEnable_t glEnable;
+    glEnableClientState_t glEnableClientState;
+    glFinish_t glFinish;
+    glFlush_t glFlush;
+    glFogx_t glFogx;
+    glFogxv_t glFogxv;
+    glFrontFace_t glFrontFace;
+    glFrustumx_t glFrustumx;
+    glGetBooleanv_t glGetBooleanv;
+    glGetBufferParameteriv_t glGetBufferParameteriv;
+    glGetClipPlanex_t glGetClipPlanex;
+    glGenBuffers_t glGenBuffers;
+    glGenTextures_t glGenTextures;
+    glGetError_t glGetError;
+    glGetFixedv_t glGetFixedv;
+    glGetIntegerv_t glGetIntegerv;
+    glGetLightxv_t glGetLightxv;
+    glGetMaterialxv_t glGetMaterialxv;
+    glGetPointerv_t glGetPointerv;
+    glGetString_t glGetString;
+    glGetTexEnviv_t glGetTexEnviv;
+    glGetTexEnvxv_t glGetTexEnvxv;
+    glGetTexParameteriv_t glGetTexParameteriv;
+    glGetTexParameterxv_t glGetTexParameterxv;
+    glHint_t glHint;
+    glIsBuffer_t glIsBuffer;
+    glIsEnabled_t glIsEnabled;
+    glIsTexture_t glIsTexture;
+    glLightModelx_t glLightModelx;
+    glLightModelxv_t glLightModelxv;
+    glLightx_t glLightx;
+    glLightxv_t glLightxv;
+    glLineWidthx_t glLineWidthx;
+    glLoadIdentity_t glLoadIdentity;
+    glLoadMatrixx_t glLoadMatrixx;
+    glLogicOp_t glLogicOp;
+    glMaterialx_t glMaterialx;
+    glMaterialxv_t glMaterialxv;
+    glMatrixMode_t glMatrixMode;
+    glMultMatrixx_t glMultMatrixx;
+    glMultiTexCoord4x_t glMultiTexCoord4x;
+    glNormal3x_t glNormal3x;
+    glNormalPointer_t glNormalPointer;
+    glOrthox_t glOrthox;
+    glPixelStorei_t glPixelStorei;
+    glPointParameterx_t glPointParameterx;
+    glPointParameterxv_t glPointParameterxv;
+    glPointSizex_t glPointSizex;
+    glPolygonOffsetx_t glPolygonOffsetx;
+    glPopMatrix_t glPopMatrix;
+    glPushMatrix_t glPushMatrix;
+    glReadPixels_t glReadPixels;
+    glRotatex_t glRotatex;
+    glSampleCoverage_t glSampleCoverage;
+    glSampleCoveragex_t glSampleCoveragex;
+    glScalex_t glScalex;
+    glScissor_t glScissor;
+    glShadeModel_t glShadeModel;
+    glStencilFunc_t glStencilFunc;
+    glStencilMask_t glStencilMask;
+    glStencilOp_t glStencilOp;
+    glTexCoordPointer_t glTexCoordPointer;
+    glTexEnvi_t glTexEnvi;
+    glTexEnvx_t glTexEnvx;
+    glTexEnviv_t glTexEnviv;
+    glTexEnvxv_t glTexEnvxv;
+    glTexImage2D_t glTexImage2D;
+    glTexParameteri_t glTexParameteri;
+    glTexParameterx_t glTexParameterx;
+    glTexParameteriv_t glTexParameteriv;
+    glTexParameterxv_t glTexParameterxv;
+    glTexSubImage2D_t glTexSubImage2D;
+    glTranslatex_t glTranslatex;
+    glVertexPointer_t glVertexPointer;
+    glViewport_t glViewport;
+    glPointSizePointerOES_t glPointSizePointerOES;
+    glBlendEquationSeparateOES_t glBlendEquationSeparateOES;
+    glBlendFuncSeparateOES_t glBlendFuncSeparateOES;
+    glBlendEquationOES_t glBlendEquationOES;
+    glDrawTexsOES_t glDrawTexsOES;
+    glDrawTexiOES_t glDrawTexiOES;
+    glDrawTexxOES_t glDrawTexxOES;
+    glDrawTexsvOES_t glDrawTexsvOES;
+    glDrawTexivOES_t glDrawTexivOES;
+    glDrawTexxvOES_t glDrawTexxvOES;
+    glDrawTexfOES_t glDrawTexfOES;
+    glDrawTexfvOES_t glDrawTexfvOES;
+    glEGLImageTargetTexture2DOES_t glEGLImageTargetTexture2DOES;
+    glEGLImageTargetRenderbufferStorageOES_t glEGLImageTargetRenderbufferStorageOES;
+    glAlphaFuncxOES_t glAlphaFuncxOES;
+    glClearColorxOES_t glClearColorxOES;
+    glClearDepthxOES_t glClearDepthxOES;
+    glClipPlanexOES_t glClipPlanexOES;
+    glColor4xOES_t glColor4xOES;
+    glDepthRangexOES_t glDepthRangexOES;
+    glFogxOES_t glFogxOES;
+    glFogxvOES_t glFogxvOES;
+    glFrustumxOES_t glFrustumxOES;
+    glGetClipPlanexOES_t glGetClipPlanexOES;
+    glGetFixedvOES_t glGetFixedvOES;
+    glGetLightxvOES_t glGetLightxvOES;
+    glGetMaterialxvOES_t glGetMaterialxvOES;
+    glGetTexEnvxvOES_t glGetTexEnvxvOES;
+    glGetTexParameterxvOES_t glGetTexParameterxvOES;
+    glLightModelxOES_t glLightModelxOES;
+    glLightModelxvOES_t glLightModelxvOES;
+    glLightxOES_t glLightxOES;
+    glLightxvOES_t glLightxvOES;
+    glLineWidthxOES_t glLineWidthxOES;
+    glLoadMatrixxOES_t glLoadMatrixxOES;
+    glMaterialxOES_t glMaterialxOES;
+    glMaterialxvOES_t glMaterialxvOES;
+    glMultMatrixxOES_t glMultMatrixxOES;
+    glMultiTexCoord4xOES_t glMultiTexCoord4xOES;
+    glNormal3xOES_t glNormal3xOES;
+    glOrthoxOES_t glOrthoxOES;
+    glPointParameterxOES_t glPointParameterxOES;
+    glPointParameterxvOES_t glPointParameterxvOES;
+    glPointSizexOES_t glPointSizexOES;
+    glPolygonOffsetxOES_t glPolygonOffsetxOES;
+    glRotatexOES_t glRotatexOES;
+    glSampleCoveragexOES_t glSampleCoveragexOES;
+    glScalexOES_t glScalexOES;
+    glTexEnvxOES_t glTexEnvxOES;
+    glTexEnvxvOES_t glTexEnvxvOES;
+    glTexParameterxOES_t glTexParameterxOES;
+    glTexParameterxvOES_t glTexParameterxvOES;
+    glTranslatexOES_t glTranslatexOES;
+    glIsRenderbufferOES_t glIsRenderbufferOES;
+    glBindRenderbufferOES_t glBindRenderbufferOES;
+    glDeleteRenderbuffersOES_t glDeleteRenderbuffersOES;
+    glGenRenderbuffersOES_t glGenRenderbuffersOES;
+    glRenderbufferStorageOES_t glRenderbufferStorageOES;
+    glGetRenderbufferParameterivOES_t glGetRenderbufferParameterivOES;
+    glIsFramebufferOES_t glIsFramebufferOES;
+    glBindFramebufferOES_t glBindFramebufferOES;
+    glDeleteFramebuffersOES_t glDeleteFramebuffersOES;
+    glGenFramebuffersOES_t glGenFramebuffersOES;
+    glCheckFramebufferStatusOES_t glCheckFramebufferStatusOES;
+    glFramebufferRenderbufferOES_t glFramebufferRenderbufferOES;
+    glFramebufferTexture2DOES_t glFramebufferTexture2DOES;
+    glGetFramebufferAttachmentParameterivOES_t glGetFramebufferAttachmentParameterivOES;
+    glGenerateMipmapOES_t glGenerateMipmapOES;
+    glMapBufferOES_t glMapBufferOES;
+    glUnmapBufferOES_t glUnmapBufferOES;
+    glGetBufferPointervOES_t glGetBufferPointervOES;
+    glCurrentPaletteMatrixOES_t glCurrentPaletteMatrixOES;
+    glLoadPaletteFromModelViewMatrixOES_t glLoadPaletteFromModelViewMatrixOES;
+    glMatrixIndexPointerOES_t glMatrixIndexPointerOES;
+    glWeightPointerOES_t glWeightPointerOES;
+    glQueryMatrixxOES_t glQueryMatrixxOES;
+    glDepthRangefOES_t glDepthRangefOES;
+    glFrustumfOES_t glFrustumfOES;
+    glOrthofOES_t glOrthofOES;
+    glClipPlanefOES_t glClipPlanefOES;
+    glGetClipPlanefOES_t glGetClipPlanefOES;
+    glClearDepthfOES_t glClearDepthfOES;
+    glTexGenfOES_t glTexGenfOES;
+    glTexGenfvOES_t glTexGenfvOES;
+    glTexGeniOES_t glTexGeniOES;
+    glTexGenivOES_t glTexGenivOES;
+    glTexGenxOES_t glTexGenxOES;
+    glTexGenxvOES_t glTexGenxvOES;
+    glGetTexGenfvOES_t glGetTexGenfvOES;
+    glGetTexGenivOES_t glGetTexGenivOES;
+    glGetTexGenxvOES_t glGetTexGenxvOES;
+    glBindVertexArrayOES_t glBindVertexArrayOES;
+    glDeleteVertexArraysOES_t glDeleteVertexArraysOES;
+    glGenVertexArraysOES_t glGenVertexArraysOES;
+    glIsVertexArrayOES_t glIsVertexArrayOES;
+    glDiscardFramebufferEXT_t glDiscardFramebufferEXT;
+    glMultiDrawArraysEXT_t glMultiDrawArraysEXT;
+    glMultiDrawElementsEXT_t glMultiDrawElementsEXT;
+    glClipPlanefIMG_t glClipPlanefIMG;
+    glClipPlanexIMG_t glClipPlanexIMG;
+    glRenderbufferStorageMultisampleIMG_t glRenderbufferStorageMultisampleIMG;
+    glFramebufferTexture2DMultisampleIMG_t glFramebufferTexture2DMultisampleIMG;
+    glDeleteFencesNV_t glDeleteFencesNV;
+    glGenFencesNV_t glGenFencesNV;
+    glIsFenceNV_t glIsFenceNV;
+    glTestFenceNV_t glTestFenceNV;
+    glGetFenceivNV_t glGetFenceivNV;
+    glFinishFenceNV_t glFinishFenceNV;
+    glSetFenceNV_t glSetFenceNV;
+    glGetDriverControlsQCOM_t glGetDriverControlsQCOM;
+    glGetDriverControlStringQCOM_t glGetDriverControlStringQCOM;
+    glEnableDriverControlQCOM_t glEnableDriverControlQCOM;
+    glDisableDriverControlQCOM_t glDisableDriverControlQCOM;
+    glExtGetTexturesQCOM_t glExtGetTexturesQCOM;
+    glExtGetBuffersQCOM_t glExtGetBuffersQCOM;
+    glExtGetRenderbuffersQCOM_t glExtGetRenderbuffersQCOM;
+    glExtGetFramebuffersQCOM_t glExtGetFramebuffersQCOM;
+    glExtGetTexLevelParameterivQCOM_t glExtGetTexLevelParameterivQCOM;
+    glExtTexObjectStateOverrideiQCOM_t glExtTexObjectStateOverrideiQCOM;
+    glExtGetTexSubImageQCOM_t glExtGetTexSubImageQCOM;
+    glExtGetBufferPointervQCOM_t glExtGetBufferPointervQCOM;
+    glExtGetShadersQCOM_t glExtGetShadersQCOM;
+    glExtGetProgramsQCOM_t glExtGetProgramsQCOM;
+    glExtIsProgramBinaryQCOM_t glExtIsProgramBinaryQCOM;
+    glExtGetProgramBinarySourceQCOM_t glExtGetProgramBinarySourceQCOM;
+    glStartTilingQCOM_t glStartTilingQCOM;
+    glEndTilingQCOM_t glEndTilingQCOM;
+};
+
+bool init_gl_dispatch();
+void *gl_dispatch_get_proc_func(const char *name, void *userData);
+
+extern GLDispatch s_gl;
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/NativeLinuxSubWindow.cpp b/emulator/opengl/host/libs/libOpenglRender/NativeLinuxSubWindow.cpp
new file mode 100644
index 0000000..ff335df
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/NativeLinuxSubWindow.cpp
@@ -0,0 +1,48 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "NativeSubWindow.h"
+
+static Bool WaitForMapNotify(Display *d, XEvent *e, char *arg)
+{
+    if (e->type == MapNotify && e->xmap.window == (Window)arg) {
+	    return 1;
+    }
+    return 0;
+}
+
+static Display *s_display = NULL;
+
+EGLNativeWindowType createSubWindow(FBNativeWindowType p_window,
+                                    EGLNativeDisplayType* display_out,
+                                    int x, int y,int width, int height){
+
+   // The call to this function is protected by a lock
+   // in FrameBuffer so it is safe to check and initialize s_display here
+   if (!s_display) s_display = XOpenDisplay(NULL);
+   *display_out = s_display;
+
+    XSetWindowAttributes wa;
+    wa.event_mask = StructureNotifyMask;
+    Window win = XCreateWindow(*display_out,p_window,x,y, width,height,0,CopyFromParent,CopyFromParent,CopyFromParent,CWEventMask,&wa);
+    XMapWindow(*display_out,win);
+    XEvent e;
+    XIfEvent(*display_out, &e, WaitForMapNotify, (char *)win);
+    return win;
+}
+
+void destroySubWindow(EGLNativeDisplayType dis,EGLNativeWindowType win){
+    XDestroyWindow(dis, win);
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/NativeMacSubWindow.m b/emulator/opengl/host/libs/libOpenglRender/NativeMacSubWindow.m
new file mode 100644
index 0000000..f57f661
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/NativeMacSubWindow.m
@@ -0,0 +1,64 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "NativeSubWindow.h"
+#include <Cocoa/Cocoa.h>
+
+/*
+ * EmuGLView inherit from NSView and override the isOpaque
+ * method to return YES. That prevents drawing of underlying window/view
+ * when the view needs to be redrawn.
+ */
+@interface EmuGLView : NSView {
+} @end
+
+@implementation EmuGLView
+
+  - (BOOL)isOpaque {
+      return YES;
+  }
+
+@end
+
+
+EGLNativeWindowType createSubWindow(FBNativeWindowType p_window,
+                                    EGLNativeDisplayType* display_out,
+                                    int x, int y,int width, int height){
+    NSWindow *win = (NSWindow *)p_window;
+    if (!win) {
+        return NULL;
+    }
+
+    /* (x,y) assume an upper-left origin, but Cocoa uses a lower-left origin */
+    NSRect content_rect = [win contentRectForFrameRect:[win frame]];
+    int cocoa_y = (int)content_rect.size.height - (y + height);
+    NSRect contentRect = NSMakeRect(x, cocoa_y, width, height);
+
+    NSView *glView = [[EmuGLView alloc] initWithFrame:contentRect];
+    if (glView) {
+        [[win contentView] addSubview:glView];
+        [win makeKeyAndOrderFront:nil];
+    }
+
+    return (EGLNativeWindowType)glView;
+}
+
+void destroySubWindow(EGLNativeDisplayType dis,EGLNativeWindowType win){
+    if(win){
+        NSView *glView = (NSView *)win;
+        [glView removeFromSuperview];
+        [glView release];
+    }
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/NativeSubWindow.h b/emulator/opengl/host/libs/libOpenglRender/NativeSubWindow.h
new file mode 100644
index 0000000..1965978
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/NativeSubWindow.h
@@ -0,0 +1,37 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef NATIVE_SUB_WINDOW_H
+#define NATIVE_SUB_WINDOW_H
+
+#include <EGL/egl.h>
+#include "libOpenglRender/render_api_platform_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EGLNativeWindowType createSubWindow(FBNativeWindowType p_window,
+                                    EGLNativeDisplayType* display_out,
+                                    int x, int y,int width, int height);
+
+
+void destroySubWindow(EGLNativeDisplayType dis,EGLNativeWindowType win);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/NativeWindowsSubWindow.cpp b/emulator/opengl/host/libs/libOpenglRender/NativeWindowsSubWindow.cpp
new file mode 100644
index 0000000..e519b68
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/NativeWindowsSubWindow.cpp
@@ -0,0 +1,57 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "NativeSubWindow.h"
+#include <stdio.h>
+
+LRESULT CALLBACK myWndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
+{
+    return DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+
+EGLNativeWindowType createSubWindow(FBNativeWindowType p_window,
+                                    EGLNativeDisplayType* display_out,
+                                    int x, int y,int width, int height){
+    WNDCLASS wc;
+    wc.style =  CS_OWNDC |CS_HREDRAW |CS_VREDRAW;  // redraw if size changes
+    wc.lpfnWndProc = myWndProc;                 // points to window procedure
+    wc.cbClsExtra = 0;                             // no extra class memory
+    wc.cbWndExtra = sizeof(void*);                 // save extra window memory, to store VasWindow instance
+    wc.hInstance = NULL;                           // handle to instance
+    wc.hIcon = NULL;                               // predefined app. icon
+    wc.hCursor = NULL;
+    wc.hbrBackground = NULL;                       // no background brush
+    wc.lpszMenuName =  NULL;                       // name of menu resource
+    wc.lpszClassName = "subWin";                 // name of window class
+
+    RegisterClass(&wc);
+    printf("creating window %d %d %d %d\n",x,y,width,height);
+    EGLNativeWindowType ret = CreateWindowEx(
+                        WS_EX_NOPARENTNOTIFY,  // do not bother our parent window
+                        "subWin",
+                        "sub",
+                        WS_CHILD|WS_DISABLED,
+                        x,y,width,height,
+                        p_window,
+                        NULL,
+                        NULL,
+                        NULL);
+    ShowWindow(ret,SW_SHOW);
+    return ret;
+}
+
+void destroySubWindow(EGLNativeDisplayType dis,EGLNativeWindowType win){
+    PostMessage(win, WM_CLOSE, 0, 0);
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.cpp b/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.cpp
new file mode 100644
index 0000000..837b094
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.cpp
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "ReadBuffer.h"
+#include <string.h>
+#include <assert.h>
+#include <limits.h>
+#include "ErrorLog.h"
+
+ReadBuffer::ReadBuffer(IOStream *stream, size_t bufsize)
+{
+    m_size = bufsize;
+    m_stream = stream;
+    m_buf = (unsigned char*)malloc(m_size*sizeof(unsigned char));
+    m_validData = 0;
+    m_readPtr = m_buf;
+}
+
+ReadBuffer::~ReadBuffer()
+{
+    free(m_buf);
+}
+
+int ReadBuffer::getData()
+{
+    if ((m_validData > 0) && (m_readPtr > m_buf)) {
+        memmove(m_buf, m_readPtr, m_validData);
+    }
+    // get fresh data into the buffer;
+    size_t len = m_size - m_validData;
+    if (len==0) {
+        //we need to inc our buffer
+        size_t new_size = m_size*2;
+        unsigned char* new_buf;
+        if (new_size < m_size) { // overflow check
+            new_size = INT_MAX;
+        }
+
+        new_buf = (unsigned char*)realloc(m_buf, new_size);
+        if (!new_buf) {
+            ERR("Failed to alloc %zu bytes for ReadBuffer\n", new_size);
+            return -1;
+        }
+        m_size = new_size;
+        m_buf  = new_buf;
+        len    = m_size - m_validData;
+    }
+    m_readPtr = m_buf;
+    if (NULL != m_stream->read(m_buf + m_validData, &len)) {
+        m_validData += len;
+        return len;
+    }
+    return -1;
+}
+
+void ReadBuffer::consume(size_t amount)
+{
+    assert(amount <= m_validData);
+    m_validData -= amount;
+    m_readPtr += amount;
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.h b/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.h
new file mode 100644
index 0000000..f2dfbce
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ReadBuffer.h
@@ -0,0 +1,36 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _READ_BUFFER_H
+#define _READ_BUFFER_H
+
+#include "IOStream.h"
+
+class ReadBuffer {
+public:
+    ReadBuffer(IOStream *stream, size_t bufSize);
+    ~ReadBuffer();
+    int getData(); // get fresh data from the stream
+    unsigned char *buf() { return m_readPtr; } // return the next read location
+    size_t validData() { return m_validData; } // return the amount of valid data in readptr
+    void consume(size_t amount); // notify that 'amount' data has been consumed;
+private:
+    unsigned char *m_buf;
+    unsigned char *m_readPtr;
+    size_t m_size;
+    size_t m_validData;
+    IOStream *m_stream;
+};
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderContext.cpp b/emulator/opengl/host/libs/libOpenglRender/RenderContext.cpp
new file mode 100644
index 0000000..f5cbd67
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderContext.cpp
@@ -0,0 +1,76 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "RenderContext.h"
+#include "FBConfig.h"
+#include "FrameBuffer.h"
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+
+RenderContext *RenderContext::create(int p_config,
+                                     RenderContextPtr p_shareContext,
+                                     bool p_isGL2)
+{
+    const FBConfig *fbconf = FBConfig::get(p_config);
+    if (!fbconf) {
+        return NULL;
+    }
+
+    RenderContext *c = new RenderContext();
+    if (!c) {
+        return NULL;
+    }
+
+    EGLContext share = EGL_NO_CONTEXT;
+    if (p_shareContext.Ptr() != NULL) {
+        share = p_shareContext->getEGLContext();
+    }
+
+    GLint glContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 1,
+        EGL_NONE
+    };
+
+    if (p_isGL2) {
+        glContextAttribs[1] = 2;
+        c->m_isGL2 = true;
+    }
+
+    c->m_ctx = s_egl.eglCreateContext(FrameBuffer::getFB()->getDisplay(),
+                                      fbconf->getEGLConfig(), share,
+                                      glContextAttribs);
+
+    if (c->m_ctx == EGL_NO_CONTEXT) {
+        delete c;
+        return NULL;
+    }
+
+    c->m_config = p_config;
+    return c;
+}
+
+RenderContext::RenderContext() :
+    m_ctx(EGL_NO_CONTEXT),
+    m_config(0),
+    m_isGL2(false)
+{
+}
+
+RenderContext::~RenderContext()
+{
+    if (m_ctx != EGL_NO_CONTEXT) {
+        s_egl.eglDestroyContext(FrameBuffer::getFB()->getDisplay(), m_ctx);
+    }
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderContext.h b/emulator/opengl/host/libs/libOpenglRender/RenderContext.h
new file mode 100644
index 0000000..9cbb5fc
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderContext.h
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIBRENDER_RENDERCONTEXT_H
+#define _LIBRENDER_RENDERCONTEXT_H
+
+#include "SmartPtr.h"
+#include <EGL/egl.h>
+#include "GLDecoderContextData.h"
+
+class RenderContext;
+typedef SmartPtr<RenderContext> RenderContextPtr;
+
+class RenderContext
+{
+public:
+    static RenderContext *create(int p_config, RenderContextPtr p_shareContext,
+                                 bool p_isGL2 = false);
+    ~RenderContext();
+    int getConfig() const { return m_config; }
+
+    EGLContext getEGLContext() const { return m_ctx; }
+    bool isGL2() const { return m_isGL2; }
+
+    GLDecoderContextData & decoderContextData() { return m_contextData; }
+
+private:
+    RenderContext();
+
+private:
+    EGLContext m_ctx;
+    int        m_config;
+    bool       m_isGL2;
+    GLDecoderContextData    m_contextData;
+};
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderControl.cpp b/emulator/opengl/host/libs/libOpenglRender/RenderControl.cpp
new file mode 100644
index 0000000..6b8f8fd
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderControl.cpp
@@ -0,0 +1,360 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "renderControl_dec.h"
+#include "FrameBuffer.h"
+#include "FBConfig.h"
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+#include "GL2Dispatch.h"
+#include "ThreadInfo.h"
+
+static const GLint rendererVersion = 1;
+
+static GLint rcGetRendererVersion()
+{
+    return rendererVersion;
+}
+
+static EGLint rcGetEGLVersion(EGLint* major, EGLint* minor)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return EGL_FALSE;
+    }
+    *major = (EGLint)fb->getCaps().eglMajor;
+    *minor = (EGLint)fb->getCaps().eglMinor;
+
+    return EGL_TRUE;
+}
+
+static EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    const char *str = s_egl.eglQueryString(fb->getDisplay(), name);
+    if (!str) {
+        return 0;
+    }
+
+    int len = strlen(str) + 1;
+    if (!buffer || len > bufferSize) {
+        return -len;
+    }
+
+    strcpy((char *)buffer, str);
+    return len;
+}
+
+static EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize)
+{
+    RenderThreadInfo *tInfo = getRenderThreadInfo();
+    if (!tInfo || !tInfo->currContext.Ptr()) {
+        return 0;
+    }
+
+    const char *str = NULL;
+#ifdef WITH_GLES2
+    if (tInfo->currContext->isGL2()) {
+        str = (const char *)s_gl2.glGetString(name);
+    }
+    else {
+#endif
+        str = (const char *)s_gl.glGetString(name);
+#ifdef WITH_GLES2
+    }
+#endif
+
+    if (!str) {
+        return 0;
+    }
+
+    int len = strlen(str) + 1;
+    if (!buffer || len > bufferSize) {
+        return -len;
+    }
+
+    strcpy((char *)buffer, str);
+    return len;
+}
+
+static EGLint rcGetNumConfigs(uint32_t* numAttribs)
+{
+    if (numAttribs) {
+        *numAttribs = FBConfig::getNumAttribs();
+    }
+    return FBConfig::getNumConfigs();
+}
+
+static EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer)
+{
+    int configSize = FBConfig::getNumAttribs();
+    int nConfigs = FBConfig::getNumConfigs();
+    uint32_t neededSize = (nConfigs + 1) * configSize * sizeof(GLuint);
+    if (!buffer || bufSize < neededSize) {
+        return -neededSize;
+    }
+    FBConfig::packConfigsInfo(buffer);
+    return nConfigs;
+}
+
+static EGLint rcChooseConfig(EGLint *attribs, uint32_t attribs_size, uint32_t *configs, uint32_t configs_size)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    return FBConfig::chooseConfig(fb, attribs, configs, configs_size);
+}
+
+static EGLint rcGetFBParam(EGLint param)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    EGLint ret = 0;
+
+    switch(param) {
+        case FB_WIDTH:
+            ret = fb->getWidth();
+            break;
+        case FB_HEIGHT:
+            ret = fb->getHeight();
+            break;
+        case FB_XDPI:
+            ret = 72; // XXX: should be implemented
+            break;
+        case FB_YDPI:
+            ret = 72; // XXX: should be implemented
+            break;
+        case FB_FPS:
+            ret = 60;
+            break;
+        case FB_MIN_SWAP_INTERVAL:
+            ret = 1; // XXX: should be implemented
+            break;
+        case FB_MAX_SWAP_INTERVAL:
+            ret = 1; // XXX: should be implemented
+            break;
+        default:
+            break;
+    }
+
+    return ret;
+}
+
+static uint32_t rcCreateContext(uint32_t config,
+                                uint32_t share, uint32_t glVersion)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    HandleType ret = fb->createRenderContext(config, share, glVersion == 2);
+    return ret;
+}
+
+static void rcDestroyContext(uint32_t context)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+
+    fb->DestroyRenderContext(context);
+}
+
+static uint32_t rcCreateWindowSurface(uint32_t config,
+                                      uint32_t width, uint32_t height)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    return fb->createWindowSurface(config, width, height);
+}
+
+static void rcDestroyWindowSurface(uint32_t windowSurface)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+
+    fb->DestroyWindowSurface( windowSurface );
+}
+
+static uint32_t rcCreateColorBuffer(uint32_t width,
+                                    uint32_t height, GLenum internalFormat)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return 0;
+    }
+
+    return fb->createColorBuffer(width, height, internalFormat);
+}
+
+static void rcOpenColorBuffer(uint32_t colorbuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+    fb->openColorBuffer( colorbuffer );
+}
+
+static void rcCloseColorBuffer(uint32_t colorbuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+    fb->closeColorBuffer( colorbuffer );
+}
+
+static int rcFlushWindowColorBuffer(uint32_t windowSurface)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return -1;
+    }
+    fb->flushWindowSurfaceColorBuffer(windowSurface);
+    return 0;
+}
+
+static void rcSetWindowColorBuffer(uint32_t windowSurface,
+                                   uint32_t colorBuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+    fb->setWindowSurfaceColorBuffer(windowSurface, colorBuffer);
+}
+
+static EGLint rcMakeCurrent(uint32_t context,
+                            uint32_t drawSurf, uint32_t readSurf)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return EGL_FALSE;
+    }
+
+    bool ret = fb->bindContext(context, drawSurf, readSurf);
+
+    return (ret ? EGL_TRUE : EGL_FALSE);
+}
+
+static void rcFBPost(uint32_t colorBuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+
+    fb->post(colorBuffer);
+}
+
+static void rcFBSetSwapInterval(EGLint interval)
+{
+   // XXX: TBD - should be implemented
+}
+
+static void rcBindTexture(uint32_t colorBuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+
+    fb->bindColorBufferToTexture(colorBuffer);
+}
+
+static void rcBindRenderbuffer(uint32_t colorBuffer)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return;
+    }
+
+    fb->bindColorBufferToRenderbuffer(colorBuffer);
+}
+
+static EGLint rcColorBufferCacheFlush(uint32_t colorBuffer,
+                                      EGLint postCount, int forRead)
+{
+   // XXX: TBD - should be implemented
+   return 0;
+}
+
+static void rcReadColorBuffer(uint32_t colorBuffer,
+                              GLint x, GLint y,
+                              GLint width, GLint height,
+                              GLenum format, GLenum type, void* pixels)
+{
+   // XXX: TBD - should be implemented
+}
+
+static int rcUpdateColorBuffer(uint32_t colorBuffer,
+                                GLint x, GLint y,
+                                GLint width, GLint height,
+                                GLenum format, GLenum type, void* pixels)
+{
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!fb) {
+        return -1;
+    }
+
+    fb->updateColorBuffer(colorBuffer, x, y, width, height, format, type, pixels);
+    return 0;
+}
+
+void initRenderControlContext(renderControl_decoder_context_t *dec)
+{
+    dec->set_rcGetRendererVersion(rcGetRendererVersion);
+    dec->set_rcGetEGLVersion(rcGetEGLVersion);
+    dec->set_rcQueryEGLString(rcQueryEGLString);
+    dec->set_rcGetGLString(rcGetGLString);
+    dec->set_rcGetNumConfigs(rcGetNumConfigs);
+    dec->set_rcGetConfigs(rcGetConfigs);
+    dec->set_rcChooseConfig(rcChooseConfig);
+    dec->set_rcGetFBParam(rcGetFBParam);
+    dec->set_rcCreateContext(rcCreateContext);
+    dec->set_rcDestroyContext(rcDestroyContext);
+    dec->set_rcCreateWindowSurface(rcCreateWindowSurface);
+    dec->set_rcDestroyWindowSurface(rcDestroyWindowSurface);
+    dec->set_rcCreateColorBuffer(rcCreateColorBuffer);
+    dec->set_rcOpenColorBuffer(rcOpenColorBuffer);
+    dec->set_rcCloseColorBuffer(rcCloseColorBuffer);
+    dec->set_rcSetWindowColorBuffer(rcSetWindowColorBuffer);
+    dec->set_rcFlushWindowColorBuffer(rcFlushWindowColorBuffer);
+    dec->set_rcMakeCurrent(rcMakeCurrent);
+    dec->set_rcFBPost(rcFBPost);
+    dec->set_rcFBSetSwapInterval(rcFBSetSwapInterval);
+    dec->set_rcBindTexture(rcBindTexture);
+    dec->set_rcBindRenderbuffer(rcBindRenderbuffer);
+    dec->set_rcColorBufferCacheFlush(rcColorBufferCacheFlush);
+    dec->set_rcReadColorBuffer(rcReadColorBuffer);
+    dec->set_rcUpdateColorBuffer(rcUpdateColorBuffer);
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderControl.h b/emulator/opengl/host/libs/libOpenglRender/RenderControl.h
new file mode 100644
index 0000000..233e809
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderControl.h
@@ -0,0 +1,21 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _RENDER_CONTROL_H
+#define _RENDER_CONTROL_H
+
+void initRenderControlContext(renderControl_decoder_context_t *dec);
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderServer.cpp b/emulator/opengl/host/libs/libOpenglRender/RenderServer.cpp
new file mode 100644
index 0000000..78f305c
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderServer.cpp
@@ -0,0 +1,142 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "RenderServer.h"
+#include "TcpStream.h"
+#ifdef _WIN32
+#include "Win32PipeStream.h"
+#else
+#include "UnixStream.h"
+#endif
+#include "RenderThread.h"
+#include "FrameBuffer.h"
+#include <set>
+
+typedef std::set<RenderThread *> RenderThreadsSet;
+
+RenderServer::RenderServer() :
+    m_listenSock(NULL),
+    m_exiting(false)
+{
+}
+
+extern "C" int gRendererStreamMode;
+
+RenderServer *RenderServer::create(int port)
+{
+    RenderServer *server = new RenderServer();
+    if (!server) {
+        return NULL;
+    }
+
+    if (gRendererStreamMode == STREAM_MODE_TCP) {
+        server->m_listenSock = new TcpStream();
+    } else {
+#ifdef _WIN32
+        server->m_listenSock = new Win32PipeStream();
+#else
+        server->m_listenSock = new UnixStream();
+#endif
+    }
+
+    if (server->m_listenSock->listen(port) < 0) {
+        ERR("RenderServer::create failed to listen on port %d\n", port);
+        delete server;
+        return NULL;
+    }
+
+    return server;
+}
+
+int RenderServer::Main()
+{
+    RenderThreadsSet threads;
+
+    while(1) {
+        SocketStream *stream = m_listenSock->accept();
+        if (!stream) {
+            fprintf(stderr,"Error accepting connection, aborting\n");
+            break;
+        }
+
+        unsigned int clientFlags;
+        if (!stream->readFully(&clientFlags, sizeof(unsigned int))) {
+            fprintf(stderr,"Error reading clientFlags\n");
+            delete stream;
+            continue;
+        }
+
+        DBG("\n\n\n\n Got new stream!!!! \n\n\n\n\n");
+        // check if we have been requested to exit while waiting on accept
+        if ((clientFlags & IOSTREAM_CLIENT_EXIT_SERVER) != 0) {
+            m_exiting = true;
+            break;
+        }
+
+        RenderThread *rt = RenderThread::create(stream);
+        if (!rt) {
+            fprintf(stderr,"Failed to create RenderThread\n");
+            delete stream;
+        }
+
+        if (!rt->start()) {
+            fprintf(stderr,"Failed to start RenderThread\n");
+            delete stream;
+            delete rt;
+        }
+
+        //
+        // remove from the threads list threads which are
+        // no longer running
+        //
+        for (RenderThreadsSet::iterator n,t = threads.begin();
+             t != threads.end();
+             t = n) {
+            // first find next iterator
+            n = t;
+            n++;
+
+            // delete and erase the current iterator
+            // if thread is no longer running
+            if ((*t)->isFinished()) {
+                delete (*t);
+                threads.erase(t);
+            }
+        }
+
+        // insert the added thread to the list
+        threads.insert(rt);
+
+        DBG("Started new RenderThread\n");
+    }
+
+    //
+    // Wait for all threads to finish
+    //
+    for (RenderThreadsSet::iterator t = threads.begin();
+         t != threads.end();
+         t++) {
+        int exitStatus;
+        (*t)->wait(&exitStatus);
+        delete (*t);
+    }
+    threads.clear();
+
+    //
+    // de-initialize the FrameBuffer object
+    //
+    FrameBuffer::finalize();
+    return 0;
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderServer.h b/emulator/opengl/host/libs/libOpenglRender/RenderServer.h
new file mode 100644
index 0000000..98e9890
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderServer.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIB_OPENGL_RENDER_RENDER_SERVER_H
+#define _LIB_OPENGL_RENDER_RENDER_SERVER_H
+
+#include "SocketStream.h"
+#include "osThread.h"
+
+class RenderServer : public osUtils::Thread
+{
+public:
+    static RenderServer *create(int port);
+    virtual int Main();
+
+    bool isExiting() const { return m_exiting; }
+
+private:
+    RenderServer();
+
+private:
+    SocketStream *m_listenSock;
+    bool m_exiting;
+};
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderThread.cpp b/emulator/opengl/host/libs/libOpenglRender/RenderThread.cpp
new file mode 100644
index 0000000..0119133
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderThread.cpp
@@ -0,0 +1,162 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "RenderThread.h"
+#include "RenderControl.h"
+#include "ThreadInfo.h"
+#include "ReadBuffer.h"
+#include "TimeUtils.h"
+#include "GLDispatch.h"
+#include "GL2Dispatch.h"
+#include "EGLDispatch.h"
+
+#define STREAM_BUFFER_SIZE 4*1024*1024
+
+RenderThread::RenderThread() :
+    osUtils::Thread(),
+    m_stream(NULL),
+    m_finished(false)
+{
+}
+
+RenderThread *RenderThread::create(IOStream *p_stream)
+{
+    RenderThread *rt = new RenderThread();
+    if (!rt) {
+        return NULL;
+    }
+
+    rt->m_stream = p_stream;
+
+    return rt;
+}
+
+int RenderThread::Main()
+{
+    RenderThreadInfo * tInfo = getRenderThreadInfo();
+    //
+    // initialize decoders
+    //
+    tInfo->m_glDec.initGL( gl_dispatch_get_proc_func, NULL );
+    tInfo->m_gl2Dec.initGL( gl2_dispatch_get_proc_func, NULL );
+    initRenderControlContext( &m_rcDec );
+
+    ReadBuffer readBuf(m_stream, STREAM_BUFFER_SIZE);
+
+    int stats_totalBytes = 0;
+    long long stats_t0 = GetCurrentTimeMS();
+
+    //
+    // open dump file if RENDER_DUMP_DIR is defined
+    //
+    const char *dump_dir = getenv("RENDERER_DUMP_DIR");
+    FILE *dumpFP = NULL;
+    if (dump_dir) {
+        size_t bsize = strlen(dump_dir) + 32;
+        char *fname = new char[bsize];
+        snprintf(fname,bsize,"%s/stream_%p", dump_dir, this);
+        dumpFP = fopen(fname, "wb");
+        if (!dumpFP) {
+            fprintf(stderr,"Warning: stream dump failed to open file %s\n",fname);
+        }
+        delete [] fname;
+    }
+
+    while (1) {
+
+        int stat = readBuf.getData();
+        if (stat <= 0) {
+            break;
+        }
+
+        //
+        // log received bandwidth statistics
+        //
+        stats_totalBytes += readBuf.validData();
+        long long dt = GetCurrentTimeMS() - stats_t0;
+        if (dt > 1000) {
+            float dts = (float)dt / 1000.0f;
+            //printf("Used Bandwidth %5.3f MB/s\n", ((float)stats_totalBytes / dts) / (1024.0f*1024.0f));
+            stats_totalBytes = 0;
+            stats_t0 = GetCurrentTimeMS();
+        }
+
+        //
+        // dump stream to file if needed
+        //
+        if (dumpFP) {
+            int skip = readBuf.validData() - stat;
+            fwrite(readBuf.buf()+skip, 1, readBuf.validData()-skip, dumpFP);
+            fflush(dumpFP);
+        }
+
+        bool progress;
+        do {
+            progress = false;
+
+            //
+            // try to process some of the command buffer using the GLESv1 decoder
+            //
+            size_t last = tInfo->m_glDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
+            if (last > 0) {
+                progress = true;
+                readBuf.consume(last);
+            }
+
+            //
+            // try to process some of the command buffer using the GLESv2 decoder
+            //
+            last = tInfo->m_gl2Dec.decode(readBuf.buf(), readBuf.validData(), m_stream);
+            if (last > 0) {
+                progress = true;
+                readBuf.consume(last);
+            }
+
+            //
+            // try to process some of the command buffer using the
+            // renderControl decoder
+            //
+            last = m_rcDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
+            if (last > 0) {
+                readBuf.consume(last);
+                progress = true;
+            }
+
+        } while( progress );
+
+    }
+
+    if (dumpFP) {
+        fclose(dumpFP);
+    }
+
+    //
+    // release the thread from any EGL context
+    // if bound to context.
+    //
+    EGLDisplay eglDpy = s_egl.eglGetCurrentDisplay();
+    if (eglDpy != EGL_NO_DISPLAY) {
+        s_egl.eglMakeCurrent(eglDpy, 
+                             EGL_NO_SURFACE,
+                             EGL_NO_SURFACE,
+                             EGL_NO_CONTEXT);
+    }
+
+    //
+    // flag that this thread has finished execution
+    m_finished = true;
+
+    return 0;
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/RenderThread.h b/emulator/opengl/host/libs/libOpenglRender/RenderThread.h
new file mode 100644
index 0000000..67d423f
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/RenderThread.h
@@ -0,0 +1,41 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIB_OPENGL_RENDER_RENDER_THREAD_H
+#define _LIB_OPENGL_RENDER_RENDER_THREAD_H
+
+#include "IOStream.h"
+#include "GLDecoder.h"
+#include "renderControl_dec.h"
+#include "osThread.h"
+
+class RenderThread : public osUtils::Thread
+{
+public:
+    static RenderThread *create(IOStream *p_stream);
+
+    bool isFinished() const { return m_finished; }
+
+private:
+    RenderThread();
+    virtual int Main();
+
+private:
+    IOStream *m_stream;
+    renderControl_decoder_context_t m_rcDec;
+    bool m_finished;
+};
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.cpp b/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.cpp
new file mode 100644
index 0000000..2f2a962
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.cpp
@@ -0,0 +1,53 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "ThreadInfo.h"
+
+#ifdef __linux__
+
+static __thread RenderThreadInfo *tinfo = NULL;
+
+RenderThreadInfo *getRenderThreadInfo()
+{
+    if (!tinfo) {
+        tinfo = new RenderThreadInfo();
+    }
+    return tinfo;
+}
+
+#else
+
+#include <cutils/threads.h>
+static thread_store_t s_tls = THREAD_STORE_INITIALIZER;
+
+static void tlsDestruct(void *ptr)
+{
+    if (ptr) {
+        RenderThreadInfo *ti = (RenderThreadInfo *)ptr;
+        delete ti;
+    }
+}
+
+RenderThreadInfo *getRenderThreadInfo()
+{
+    RenderThreadInfo *ti = (RenderThreadInfo *)thread_store_get(&s_tls);
+    if (!ti) {
+        ti = new RenderThreadInfo();
+        thread_store_set(&s_tls, ti, tlsDestruct);
+    }
+    return ti;
+}
+#endif
+
diff --git a/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.h b/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.h
new file mode 100644
index 0000000..b147290
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/ThreadInfo.h
@@ -0,0 +1,35 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIB_OPENGL_RENDER_THREAD_INFO_H
+#define _LIB_OPENGL_RENDER_THREAD_INFO_H
+
+#include "RenderContext.h"
+#include "WindowSurface.h"
+#include "GLDecoder.h"
+#include "GL2Decoder.h"
+
+struct RenderThreadInfo
+{
+    RenderContextPtr currContext;
+    WindowSurfacePtr currDrawSurf;
+    WindowSurfacePtr currReadSurf;
+    GLDecoder        m_glDec;
+    GL2Decoder       m_gl2Dec;
+};
+
+RenderThreadInfo *getRenderThreadInfo();
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/WindowSurface.cpp b/emulator/opengl/host/libs/libOpenglRender/WindowSurface.cpp
new file mode 100644
index 0000000..3674120
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/WindowSurface.cpp
@@ -0,0 +1,236 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "WindowSurface.h"
+#include "FBConfig.h"
+#include "FrameBuffer.h"
+#include <GLES/glext.h>
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+#include "GL2Dispatch.h"
+#include <stdio.h>
+#include <string.h>
+#include "GLErrorLog.h"
+
+WindowSurface::WindowSurface() :
+    m_fbObj(0),
+    m_depthRB(0),
+    m_stencilRB(0),
+    m_eglSurface(NULL),
+    m_attachedColorBuffer(NULL),
+    m_readContext(NULL),
+    m_drawContext(NULL),
+    m_width(0),
+    m_height(0),
+    m_pbufWidth(0),
+    m_pbufHeight(0)
+{
+}
+
+WindowSurface::~WindowSurface()
+{
+    s_egl.eglDestroySurface(FrameBuffer::getFB()->getDisplay(), m_eglSurface);
+}
+
+WindowSurface *WindowSurface::create(int p_config, int p_width, int p_height)
+{
+    const FBConfig *fbconf = FBConfig::get(p_config);
+    if (!fbconf) {
+        return NULL;
+    }
+
+    // allocate space for the WindowSurface object
+    WindowSurface *win = new WindowSurface();
+    if (!win) {
+        return NULL;
+    }
+    win->m_fbconf = fbconf;
+
+    FrameBuffer *fb = FrameBuffer::getFB();
+    const FrameBufferCaps &caps = fb->getCaps();
+
+    //
+    // Create a pbuffer to be used as the egl surface
+    // for that window.
+    //
+    if (!win->resizePbuffer(p_width, p_height)) {
+        delete win;
+        return NULL;
+    }
+
+    win->m_width = p_width;
+    win->m_height = p_height;
+
+    return win;
+}
+
+//
+// flushColorBuffer - The function makes sure that the
+//    previous attached color buffer is updated, if copy or blit should be done
+//    in order to update it - it is being done here.
+//
+void WindowSurface::flushColorBuffer()
+{
+    if (m_attachedColorBuffer.Ptr() != NULL) {
+        blitToColorBuffer();
+    }
+}
+
+//
+// setColorBuffer - this function is called when a new color buffer needs to
+//    be attached to the surface. The function doesn't make sure that the
+//    previous attached color buffer is updated, this is done by flushColorBuffer
+//
+void WindowSurface::setColorBuffer(ColorBufferPtr p_colorBuffer)
+{
+    m_attachedColorBuffer = p_colorBuffer;
+
+    //
+    // resize the window if the attached color buffer is of different
+    // size
+    //
+    unsigned int cbWidth = m_attachedColorBuffer->getWidth();
+    unsigned int cbHeight = m_attachedColorBuffer->getHeight();
+
+    if (cbWidth != m_width || cbHeight != m_height) {
+
+        if (m_pbufWidth && m_pbufHeight) {
+            // if we use pbuffer, need to resize it
+            resizePbuffer(cbWidth, cbHeight);
+        }
+
+        m_width = cbWidth;
+        m_height = cbHeight;
+    }
+}
+
+//
+// This function is called after the context and eglSurface is already
+// bound in the current thread (eglMakeCurrent has been called).
+// This function should take actions required on the other surface objects
+// when being bind/unbound
+//
+void WindowSurface::bind(RenderContextPtr p_ctx, SurfaceBindType p_bindType)
+{
+    if (p_bindType == SURFACE_BIND_READ) {
+        m_readContext = p_ctx;
+    }
+    else if (p_bindType == SURFACE_BIND_DRAW) {
+        m_drawContext = p_ctx;
+    }
+    else if (p_bindType == SURFACE_BIND_READDRAW) {
+        m_readContext = p_ctx;
+        m_drawContext = p_ctx;
+    }
+    else {
+        return;  // bad param
+    }
+
+}
+
+void WindowSurface::blitToColorBuffer()
+{
+    if (!m_width && !m_height) return;
+
+    if (m_attachedColorBuffer->getWidth() != m_width ||
+        m_attachedColorBuffer->getHeight() != m_height) {
+        // XXX: should never happen - how this needs to be handled?
+        return;
+    }
+
+    //
+    // Make the surface current
+    //
+    EGLContext prevContext = s_egl.eglGetCurrentContext();
+    EGLSurface prevReadSurf = s_egl.eglGetCurrentSurface(EGL_READ);
+    EGLSurface prevDrawSurf = s_egl.eglGetCurrentSurface(EGL_DRAW);
+    FrameBuffer *fb = FrameBuffer::getFB();
+    if (!s_egl.eglMakeCurrent(fb->getDisplay(), m_eglSurface,
+                              m_eglSurface, m_drawContext->getEGLContext())) {
+        return;
+    }
+
+    m_attachedColorBuffer->blitFromCurrentReadBuffer();
+
+    // restore current context/surface
+    s_egl.eglMakeCurrent(fb->getDisplay(), prevDrawSurf,
+                         prevReadSurf, prevContext);
+
+}
+
+bool WindowSurface::resizePbuffer(unsigned int p_width, unsigned int p_height)
+{
+    if (m_eglSurface && 
+        m_pbufWidth == p_width &&
+        m_pbufHeight == p_height) {
+        // no need to resize
+        return true;
+    }
+
+    FrameBuffer *fb = FrameBuffer::getFB();
+
+    EGLContext prevContext = s_egl.eglGetCurrentContext();
+    EGLSurface prevReadSurf = s_egl.eglGetCurrentSurface(EGL_READ);
+    EGLSurface prevDrawSurf = s_egl.eglGetCurrentSurface(EGL_DRAW);
+    EGLSurface prevPbuf = m_eglSurface;
+    bool needRebindContext = m_eglSurface &&
+                             (prevReadSurf == m_eglSurface ||
+                              prevDrawSurf == m_eglSurface);
+
+    if (needRebindContext) {
+        s_egl.eglMakeCurrent(fb->getDisplay(), EGL_NO_SURFACE,
+                              EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    }
+
+    //
+    // Destroy previous surface
+    //
+    if (m_eglSurface) {
+        s_egl.eglDestroySurface(fb->getDisplay(), m_eglSurface);
+        m_eglSurface = NULL;
+    }
+
+    const FrameBufferCaps &caps = fb->getCaps();
+
+    //
+    // Create pbuffer surface.
+    //
+    EGLint pbufAttribs[5];
+    pbufAttribs[0] = EGL_WIDTH;
+    pbufAttribs[1] = p_width;
+    pbufAttribs[2] = EGL_HEIGHT;
+    pbufAttribs[3] = p_height;
+    pbufAttribs[4] = EGL_NONE;
+
+    m_eglSurface = s_egl.eglCreatePbufferSurface(fb->getDisplay(),
+                                                 m_fbconf->getEGLConfig(),
+                                                 pbufAttribs);
+    if (m_eglSurface == EGL_NO_SURFACE) {
+        fprintf(stderr, "Renderer error: failed to create/resize pbuffer!!\n");
+        return false;
+    }
+
+    m_pbufWidth = p_width;
+    m_pbufHeight = p_height;
+
+    if (needRebindContext) {
+        s_egl.eglMakeCurrent(fb->getDisplay(), 
+                     (prevDrawSurf==prevPbuf) ? m_eglSurface : prevDrawSurf,
+                     (prevReadSurf==prevPbuf) ? m_eglSurface : prevReadSurf,
+                     prevContext);
+    }
+
+    return true;
+}
diff --git a/emulator/opengl/host/libs/libOpenglRender/WindowSurface.h b/emulator/opengl/host/libs/libOpenglRender/WindowSurface.h
new file mode 100644
index 0000000..1b655c9
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/WindowSurface.h
@@ -0,0 +1,71 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _LIBRENDER_WINDOWSURFACE_H
+#define _LIBRENDER_WINDOWSURFACE_H
+
+#include "ColorBuffer.h"
+#include "RenderContext.h"
+#include "FBConfig.h"
+#include "SmartPtr.h"
+#include "FixedBuffer.h"
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+enum SurfaceBindType {
+    SURFACE_BIND_READ,
+    SURFACE_BIND_DRAW,
+    SURFACE_BIND_READDRAW
+};
+
+class WindowSurface
+{
+public:
+    static WindowSurface *create(int p_config, int p_width, int p_height);
+    ~WindowSurface();
+    EGLSurface getEGLSurface() const { return m_eglSurface; }
+
+    void setColorBuffer(ColorBufferPtr p_colorBuffer);
+    void flushColorBuffer();
+    void bind(RenderContextPtr p_ctx, SurfaceBindType p_bindType);
+
+private:
+    WindowSurface();
+
+    void blitToColorBuffer();  // copy pbuffer content with texload and blit
+    bool resizePbuffer(unsigned int p_width, unsigned int p_height);
+
+private:
+    GLuint m_fbObj;   // GLES Framebuffer object (when EGLimage is used)
+    GLuint m_depthRB;
+    GLuint m_stencilRB;
+    EGLSurface m_eglSurface;
+    ColorBufferPtr m_attachedColorBuffer;
+    RenderContextPtr m_readContext;
+    RenderContextPtr m_drawContext;
+    GLuint m_width;
+    GLuint m_height;
+    GLuint m_pbufWidth;
+    GLuint m_pbufHeight;
+    bool m_useEGLImage;
+    bool m_useBindToTexture;
+    FixedBuffer m_xferBuffer;
+    FixedBuffer m_xUpdateBuf;
+    const FBConfig *m_fbconf;
+};
+
+typedef SmartPtr<WindowSurface> WindowSurfacePtr;
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/egl_proc.h b/emulator/opengl/host/libs/libOpenglRender/egl_proc.h
new file mode 100644
index 0000000..01dc4ae
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/egl_proc.h
@@ -0,0 +1,68 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _EGL_PROC_H
+#define _EGL_PROC_H
+
+#include <EGL/egl.h>
+#define EGL_EGLEXT_PROTOTYPES
+#include <EGL/eglext.h>
+
+typedef EGLint (EGLAPIENTRY *eglGetError_t) ();
+typedef EGLDisplay (EGLAPIENTRY *eglGetDisplay_t) (EGLNativeDisplayType);
+typedef EGLBoolean (EGLAPIENTRY *eglInitialize_t) (EGLDisplay, EGLint*, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglTerminate_t) (EGLDisplay);
+typedef char* (EGLAPIENTRY *eglQueryString_t) (EGLDisplay, EGLint);
+typedef EGLBoolean (EGLAPIENTRY *eglGetConfigs_t) (EGLDisplay, EGLConfig*, EGLint, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglChooseConfig_t) (EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglGetConfigAttrib_t) (EGLDisplay, EGLConfig, EGLint, EGLint*);
+typedef EGLSurface (EGLAPIENTRY *eglCreateWindowSurface_t) (EGLDisplay, EGLConfig, EGLNativeWindowType, const EGLint*);
+typedef EGLSurface (EGLAPIENTRY *eglCreatePbufferSurface_t) (EGLDisplay, EGLConfig, const EGLint*);
+typedef EGLSurface (EGLAPIENTRY *eglCreatePixmapSurface_t) (EGLDisplay, EGLConfig, EGLNativePixmapType, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglDestroySurface_t) (EGLDisplay, EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY *eglQuerySurface_t) (EGLDisplay, EGLSurface, EGLint, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglBindAPI_t) (EGLenum);
+typedef EGLenum (* eglQueryAPI_t) ();
+typedef EGLBoolean (EGLAPIENTRY *eglWaitClient_t) ();
+typedef EGLBoolean (EGLAPIENTRY *eglReleaseThread_t) ();
+typedef EGLSurface (EGLAPIENTRY *eglCreatePbufferFromClientBuffer_t) (EGLDisplay, EGLenum, EGLClientBuffer, EGLConfig, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglSurfaceAttrib_t) (EGLDisplay, EGLSurface, EGLint, EGLint);
+typedef EGLBoolean (EGLAPIENTRY *eglBindTexImage_t) (EGLDisplay, EGLSurface, EGLint);
+typedef EGLBoolean (EGLAPIENTRY *eglReleaseTexImage_t) (EGLDisplay, EGLSurface, EGLint);
+typedef EGLBoolean (EGLAPIENTRY *eglSwapInterval_t) (EGLDisplay, EGLint);
+typedef EGLContext (EGLAPIENTRY *eglCreateContext_t) (EGLDisplay, EGLConfig, EGLContext, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglDestroyContext_t) (EGLDisplay, EGLContext);
+typedef EGLBoolean (EGLAPIENTRY *eglMakeCurrent_t) (EGLDisplay, EGLSurface, EGLSurface, EGLContext);
+typedef EGLContext (EGLAPIENTRY *eglGetCurrentContext_t) ();
+typedef EGLSurface (EGLAPIENTRY *eglGetCurrentSurface_t) (EGLint);
+typedef EGLDisplay (EGLAPIENTRY *eglGetCurrentDisplay_t) ();
+typedef EGLBoolean (EGLAPIENTRY *eglQueryContext_t) (EGLDisplay, EGLContext, EGLint, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglWaitGL_t) ();
+typedef EGLBoolean (EGLAPIENTRY *eglWaitNative_t) (EGLint);
+typedef EGLBoolean (EGLAPIENTRY *eglSwapBuffers_t) (EGLDisplay, EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY *eglCopyBuffers_t) (EGLDisplay, EGLSurface, EGLNativePixmapType);
+typedef __eglMustCastToProperFunctionPointerType (EGLAPIENTRY *eglGetProcAddress_t) (const char*);
+typedef EGLBoolean (EGLAPIENTRY *eglLockSurfaceKHR_t) (EGLDisplay, EGLSurface, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglUnlockSurfaceKHR_t) (EGLDisplay, EGLSurface);
+typedef EGLImageKHR (EGLAPIENTRY *eglCreateImageKHR_t) (EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglDestroyImageKHR_t) (EGLDisplay, EGLImageKHR image);
+typedef EGLSyncKHR (EGLAPIENTRY *eglCreateSyncKHR_t) (EGLDisplay, EGLenum, const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglDestroySyncKHR_t) (EGLDisplay, EGLSyncKHR sync);
+typedef EGLint (EGLAPIENTRY *eglClientWaitSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR timeout);
+typedef EGLBoolean (EGLAPIENTRY *eglSignalSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLenum);
+typedef EGLBoolean (EGLAPIENTRY *eglGetSyncAttribKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglSetSwapRectangleANDROID_t) (EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint);
+
+#endif // of  _EGL_PROC_H
diff --git a/emulator/opengl/host/libs/libOpenglRender/gl_proc.h b/emulator/opengl/host/libs/libOpenglRender/gl_proc.h
new file mode 100644
index 0000000..465a10d
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/gl_proc.h
@@ -0,0 +1,296 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef _GLES_PROC_H
+#define _GLES_PROC_H
+
+#include <GLES/gl.h>
+#define GL_GLEXT_PROTOTYPES
+#include <GLES/glext.h>
+
+typedef void (GL_APIENTRY *glAlphaFunc_t) (GLenum, GLclampf);
+typedef void (GL_APIENTRY *glClearColor_t) (GLclampf, GLclampf, GLclampf, GLclampf);
+typedef void (GL_APIENTRY *glClearDepthf_t) (GLclampf);
+typedef void (GL_APIENTRY *glClipPlanef_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glColor4f_t) (GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glDepthRangef_t) (GLclampf, GLclampf);
+typedef void (GL_APIENTRY *glFogf_t) (GLenum, GLfloat);
+typedef void (GL_APIENTRY *glFogfv_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glFrustumf_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glGetClipPlanef_t) (GLenum, GLfloat);
+typedef void (GL_APIENTRY *glGetFloatv_t) (GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glGetLightfv_t) (GLenum, GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glGetMaterialfv_t) (GLenum, GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glGetTexEnvfv_t) (GLenum, GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glGetTexParameterfv_t) (GLenum, GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glLightModelf_t) (GLenum, GLfloat);
+typedef void (GL_APIENTRY *glLightModelfv_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glLightf_t) (GLenum, GLenum, GLfloat);
+typedef void (GL_APIENTRY *glLightfv_t) (GLenum, GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glLineWidth_t) (GLfloat);
+typedef void (GL_APIENTRY *glLoadMatrixf_t) (const GLfloat*);
+typedef void (GL_APIENTRY *glMaterialf_t) (GLenum, GLenum, GLfloat);
+typedef void (GL_APIENTRY *glMaterialfv_t) (GLenum, GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glMultMatrixf_t) (const GLfloat*);
+typedef void (GL_APIENTRY *glMultiTexCoord4f_t) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glNormal3f_t) (GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glOrthof_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glPointParameterf_t) (GLenum, GLfloat);
+typedef void (GL_APIENTRY *glPointParameterfv_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glPointSize_t) (GLfloat);
+typedef void (GL_APIENTRY *glPolygonOffset_t) (GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glRotatef_t) (GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glScalef_t) (GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glTexEnvf_t) (GLenum, GLenum, GLfloat);
+typedef void (GL_APIENTRY *glTexEnvfv_t) (GLenum, GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glTexParameterf_t) (GLenum, GLenum, GLfloat);
+typedef void (GL_APIENTRY *glTexParameterfv_t) (GLenum, GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glTranslatef_t) (GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glActiveTexture_t) (GLenum);
+typedef void (GL_APIENTRY *glAlphaFuncx_t) (GLenum, GLclampx);
+typedef void (GL_APIENTRY *glBindBuffer_t) (GLenum, GLuint);
+typedef void (GL_APIENTRY *glBindTexture_t) (GLenum, GLuint);
+typedef void (GL_APIENTRY *glBlendFunc_t) (GLenum, GLenum);
+typedef void (GL_APIENTRY *glBufferData_t) (GLenum, GLsizeiptr, const GLvoid*, GLenum);
+typedef void (GL_APIENTRY *glBufferSubData_t) (GLenum, GLintptr, GLsizeiptr, const GLvoid*);
+typedef void (GL_APIENTRY *glClear_t) (GLbitfield);
+typedef void (GL_APIENTRY *glClearColorx_t) (GLclampx, GLclampx, GLclampx, GLclampx);
+typedef void (GL_APIENTRY *glClearDepthx_t) (GLclampx);
+typedef void (GL_APIENTRY *glClearStencil_t) (GLint);
+typedef void (GL_APIENTRY *glClientActiveTexture_t) (GLenum);
+typedef void (GL_APIENTRY *glClipPlanex_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glColor4ub_t) (GLubyte, GLubyte, GLubyte, GLubyte);
+typedef void (GL_APIENTRY *glColor4x_t) (GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glColorMask_t) (GLboolean, GLboolean, GLboolean, GLboolean);
+typedef void (GL_APIENTRY *glColorPointer_t) (GLint, GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glCompressedTexImage2D_t) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glCompressedTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glCopyTexImage2D_t) (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+typedef void (GL_APIENTRY *glCopyTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+typedef void (GL_APIENTRY *glCullFace_t) (GLenum);
+typedef void (GL_APIENTRY *glDeleteBuffers_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glDeleteTextures_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glDepthFunc_t) (GLenum);
+typedef void (GL_APIENTRY *glDepthMask_t) (GLboolean);
+typedef void (GL_APIENTRY *glDepthRangex_t) (GLclampx, GLclampx);
+typedef void (GL_APIENTRY *glDisable_t) (GLenum);
+typedef void (GL_APIENTRY *glDisableClientState_t) (GLenum);
+typedef void (GL_APIENTRY *glDrawArrays_t) (GLenum, GLint, GLsizei);
+typedef void (GL_APIENTRY *glDrawElements_t) (GLenum, GLsizei, GLenum, const GLvoid*);
+typedef void (GL_APIENTRY *glEnable_t) (GLenum);
+typedef void (GL_APIENTRY *glEnableClientState_t) (GLenum);
+typedef void (GL_APIENTRY *glFinish_t) ();
+typedef void (GL_APIENTRY *glFlush_t) ();
+typedef void (GL_APIENTRY *glFogx_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glFogxv_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glFrontFace_t) (GLenum);
+typedef void (GL_APIENTRY *glFrustumx_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glGetBooleanv_t) (GLenum, GLboolean*);
+typedef void (GL_APIENTRY *glGetBufferParameteriv_t) (GLenum, GLenum, GLint*);
+typedef void (GL_APIENTRY *glGetClipPlanex_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glGenBuffers_t) (GLsizei, GLuint*);
+typedef void (GL_APIENTRY *glGenTextures_t) (GLsizei, GLuint*);
+typedef GLenum (GL_APIENTRY *glGetError_t) ();
+typedef void (GL_APIENTRY *glGetFixedv_t) (GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetIntegerv_t) (GLenum, GLint*);
+typedef void (GL_APIENTRY *glGetLightxv_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetMaterialxv_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetPointerv_t) (GLenum, GLvoid*);
+typedef const GLubyte* (GL_APIENTRY *glGetString_t) (GLenum);
+typedef void (GL_APIENTRY *glGetTexEnviv_t) (GLenum, GLenum, GLint*);
+typedef void (GL_APIENTRY *glGetTexEnvxv_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetTexParameteriv_t) (GLenum, GLenum, GLint*);
+typedef void (GL_APIENTRY *glGetTexParameterxv_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glHint_t) (GLenum, GLenum);
+typedef GLboolean (GL_APIENTRY *glIsBuffer_t) (GLuint);
+typedef GLboolean (GL_APIENTRY *glIsEnabled_t) (GLenum);
+typedef GLboolean (GL_APIENTRY *glIsTexture_t) (GLuint);
+typedef void (GL_APIENTRY *glLightModelx_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glLightModelxv_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glLightx_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glLightxv_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glLineWidthx_t) (GLfixed);
+typedef void (GL_APIENTRY *glLoadIdentity_t) ();
+typedef void (GL_APIENTRY *glLoadMatrixx_t) (const GLfixed*);
+typedef void (GL_APIENTRY *glLogicOp_t) (GLenum);
+typedef void (GL_APIENTRY *glMaterialx_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glMaterialxv_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glMatrixMode_t) (GLenum);
+typedef void (GL_APIENTRY *glMultMatrixx_t) (const GLfixed*);
+typedef void (GL_APIENTRY *glMultiTexCoord4x_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glNormal3x_t) (GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glNormalPointer_t) (GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glOrthox_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glPixelStorei_t) (GLenum, GLint);
+typedef void (GL_APIENTRY *glPointParameterx_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glPointParameterxv_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glPointSizex_t) (GLfixed);
+typedef void (GL_APIENTRY *glPolygonOffsetx_t) (GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glPopMatrix_t) ();
+typedef void (GL_APIENTRY *glPushMatrix_t) ();
+typedef void (GL_APIENTRY *glReadPixels_t) (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*);
+typedef void (GL_APIENTRY *glRotatex_t) (GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glSampleCoverage_t) (GLclampf, GLboolean);
+typedef void (GL_APIENTRY *glSampleCoveragex_t) (GLclampx, GLboolean);
+typedef void (GL_APIENTRY *glScalex_t) (GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glScissor_t) (GLint, GLint, GLsizei, GLsizei);
+typedef void (GL_APIENTRY *glShadeModel_t) (GLenum);
+typedef void (GL_APIENTRY *glStencilFunc_t) (GLenum, GLint, GLuint);
+typedef void (GL_APIENTRY *glStencilMask_t) (GLuint);
+typedef void (GL_APIENTRY *glStencilOp_t) (GLenum, GLenum, GLenum);
+typedef void (GL_APIENTRY *glTexCoordPointer_t) (GLint, GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glTexEnvi_t) (GLenum, GLenum, GLint);
+typedef void (GL_APIENTRY *glTexEnvx_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glTexEnviv_t) (GLenum, GLenum, const GLint*);
+typedef void (GL_APIENTRY *glTexEnvxv_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glTexImage2D_t) (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
+typedef void (GL_APIENTRY *glTexParameteri_t) (GLenum, GLenum, GLint);
+typedef void (GL_APIENTRY *glTexParameterx_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glTexParameteriv_t) (GLenum, GLenum, const GLint*);
+typedef void (GL_APIENTRY *glTexParameterxv_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*);
+typedef void (GL_APIENTRY *glTranslatex_t) (GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glVertexPointer_t) (GLint, GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glViewport_t) (GLint, GLint, GLsizei, GLsizei);
+typedef void (GL_APIENTRY *glPointSizePointerOES_t) (GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glBlendEquationSeparateOES_t) (GLenum, GLenum);
+typedef void (GL_APIENTRY *glBlendFuncSeparateOES_t) (GLenum, GLenum, GLenum, GLenum);
+typedef void (GL_APIENTRY *glBlendEquationOES_t) (GLenum);
+typedef void (GL_APIENTRY *glDrawTexsOES_t) (GLshort, GLshort, GLshort, GLshort, GLshort);
+typedef void (GL_APIENTRY *glDrawTexiOES_t) (GLint, GLint, GLint, GLint, GLint);
+typedef void (GL_APIENTRY *glDrawTexxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glDrawTexsvOES_t) (const GLshort*);
+typedef void (GL_APIENTRY *glDrawTexivOES_t) (const GLint*);
+typedef void (GL_APIENTRY *glDrawTexxvOES_t) (const GLfixed*);
+typedef void (GL_APIENTRY *glDrawTexfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glDrawTexfvOES_t) (const GLfloat*);
+typedef void (GL_APIENTRY *glEGLImageTargetTexture2DOES_t) (GLenum, GLeglImageOES);
+typedef void (GL_APIENTRY *glEGLImageTargetRenderbufferStorageOES_t) (GLenum, GLeglImageOES);
+typedef void (GL_APIENTRY *glAlphaFuncxOES_t) (GLenum, GLclampx);
+typedef void (GL_APIENTRY *glClearColorxOES_t) (GLclampx, GLclampx, GLclampx, GLclampx);
+typedef void (GL_APIENTRY *glClearDepthxOES_t) (GLclampx);
+typedef void (GL_APIENTRY *glClipPlanexOES_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glColor4xOES_t) (GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glDepthRangexOES_t) (GLclampx, GLclampx);
+typedef void (GL_APIENTRY *glFogxOES_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glFogxvOES_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glFrustumxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glGetClipPlanexOES_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glGetFixedvOES_t) (GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetLightxvOES_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetMaterialxvOES_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetTexEnvxvOES_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glGetTexParameterxvOES_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glLightModelxOES_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glLightModelxvOES_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glLightxOES_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glLightxvOES_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glLineWidthxOES_t) (GLfixed);
+typedef void (GL_APIENTRY *glLoadMatrixxOES_t) (const GLfixed*);
+typedef void (GL_APIENTRY *glMaterialxOES_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glMaterialxvOES_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glMultMatrixxOES_t) (const GLfixed*);
+typedef void (GL_APIENTRY *glMultiTexCoord4xOES_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glNormal3xOES_t) (GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glOrthoxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glPointParameterxOES_t) (GLenum, GLfixed);
+typedef void (GL_APIENTRY *glPointParameterxvOES_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glPointSizexOES_t) (GLfixed);
+typedef void (GL_APIENTRY *glPolygonOffsetxOES_t) (GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glRotatexOES_t) (GLfixed, GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glSampleCoveragexOES_t) (GLclampx, GLboolean);
+typedef void (GL_APIENTRY *glScalexOES_t) (GLfixed, GLfixed, GLfixed);
+typedef void (GL_APIENTRY *glTexEnvxOES_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glTexEnvxvOES_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glTexParameterxOES_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glTexParameterxvOES_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glTranslatexOES_t) (GLfixed, GLfixed, GLfixed);
+typedef GLboolean (GL_APIENTRY *glIsRenderbufferOES_t) (GLuint);
+typedef void (GL_APIENTRY *glBindRenderbufferOES_t) (GLenum, GLuint);
+typedef void (GL_APIENTRY *glDeleteRenderbuffersOES_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glGenRenderbuffersOES_t) (GLsizei, GLuint*);
+typedef void (GL_APIENTRY *glRenderbufferStorageOES_t) (GLenum, GLenum, GLsizei, GLsizei);
+typedef void (GL_APIENTRY *glGetRenderbufferParameterivOES_t) (GLenum, GLenum, GLint*);
+typedef GLboolean (GL_APIENTRY *glIsFramebufferOES_t) (GLuint);
+typedef void (GL_APIENTRY *glBindFramebufferOES_t) (GLenum, GLuint);
+typedef void (GL_APIENTRY *glDeleteFramebuffersOES_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glGenFramebuffersOES_t) (GLsizei, GLuint*);
+typedef GLenum (GL_APIENTRY *glCheckFramebufferStatusOES_t) (GLenum);
+typedef void (GL_APIENTRY *glFramebufferRenderbufferOES_t) (GLenum, GLenum, GLenum, GLuint);
+typedef void (GL_APIENTRY *glFramebufferTexture2DOES_t) (GLenum, GLenum, GLenum, GLuint, GLint);
+typedef void (GL_APIENTRY *glGetFramebufferAttachmentParameterivOES_t) (GLenum, GLenum, GLenum, GLint*);
+typedef void (GL_APIENTRY *glGenerateMipmapOES_t) (GLenum);
+typedef void* (GL_APIENTRY *glMapBufferOES_t) (GLenum, GLenum);
+typedef GLboolean (GL_APIENTRY *glUnmapBufferOES_t) (GLenum);
+typedef void (GL_APIENTRY *glGetBufferPointervOES_t) (GLenum, GLenum, GLvoid*);
+typedef void (GL_APIENTRY *glCurrentPaletteMatrixOES_t) (GLuint);
+typedef void (GL_APIENTRY *glLoadPaletteFromModelViewMatrixOES_t) ();
+typedef void (GL_APIENTRY *glMatrixIndexPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*);
+typedef void (GL_APIENTRY *glWeightPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*);
+typedef GLbitfield (GL_APIENTRY *glQueryMatrixxOES_t) (GLfixed, GLint);
+typedef void (GL_APIENTRY *glDepthRangefOES_t) (GLclampf, GLclampf);
+typedef void (GL_APIENTRY *glFrustumfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glOrthofOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (GL_APIENTRY *glClipPlanefOES_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glGetClipPlanefOES_t) (GLenum, GLfloat);
+typedef void (GL_APIENTRY *glClearDepthfOES_t) (GLclampf);
+typedef void (GL_APIENTRY *glTexGenfOES_t) (GLenum, GLenum, GLfloat);
+typedef void (GL_APIENTRY *glTexGenfvOES_t) (GLenum, GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glTexGeniOES_t) (GLenum, GLenum, GLint);
+typedef void (GL_APIENTRY *glTexGenivOES_t) (GLenum, GLenum, const GLint*);
+typedef void (GL_APIENTRY *glTexGenxOES_t) (GLenum, GLenum, GLfixed);
+typedef void (GL_APIENTRY *glTexGenxvOES_t) (GLenum, GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glGetTexGenfvOES_t) (GLenum, GLenum, GLfloat*);
+typedef void (GL_APIENTRY *glGetTexGenivOES_t) (GLenum, GLenum, GLint*);
+typedef void (GL_APIENTRY *glGetTexGenxvOES_t) (GLenum, GLenum, GLfixed*);
+typedef void (GL_APIENTRY *glBindVertexArrayOES_t) (GLuint);
+typedef void (GL_APIENTRY *glDeleteVertexArraysOES_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glGenVertexArraysOES_t) (GLsizei, GLuint*);
+typedef GLboolean (GL_APIENTRY *glIsVertexArrayOES_t) (GLuint);
+typedef void (GL_APIENTRY *glDiscardFramebufferEXT_t) (GLenum, GLsizei, const GLenum*);
+typedef void (GL_APIENTRY *glMultiDrawArraysEXT_t) (GLenum, GLint*, GLsizei*, GLsizei);
+typedef void (GL_APIENTRY *glMultiDrawElementsEXT_t) (GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei);
+typedef void (GL_APIENTRY *glClipPlanefIMG_t) (GLenum, const GLfloat*);
+typedef void (GL_APIENTRY *glClipPlanexIMG_t) (GLenum, const GLfixed*);
+typedef void (GL_APIENTRY *glRenderbufferStorageMultisampleIMG_t) (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+typedef void (GL_APIENTRY *glFramebufferTexture2DMultisampleIMG_t) (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei);
+typedef void (GL_APIENTRY *glDeleteFencesNV_t) (GLsizei, const GLuint*);
+typedef void (GL_APIENTRY *glGenFencesNV_t) (GLsizei, GLuint*);
+typedef GLboolean (GL_APIENTRY *glIsFenceNV_t) (GLuint);
+typedef GLboolean (GL_APIENTRY *glTestFenceNV_t) (GLuint);
+typedef void (GL_APIENTRY *glGetFenceivNV_t) (GLuint, GLenum, GLint*);
+typedef void (GL_APIENTRY *glFinishFenceNV_t) (GLuint);
+typedef void (GL_APIENTRY *glSetFenceNV_t) (GLuint, GLenum);
+typedef void (GL_APIENTRY *glGetDriverControlsQCOM_t) (GLint*, GLsizei, GLuint*);
+typedef void (GL_APIENTRY *glGetDriverControlStringQCOM_t) (GLuint, GLsizei, GLsizei*, GLchar*);
+typedef void (GL_APIENTRY *glEnableDriverControlQCOM_t) (GLuint);
+typedef void (GL_APIENTRY *glDisableDriverControlQCOM_t) (GLuint);
+typedef void (GL_APIENTRY *glExtGetTexturesQCOM_t) (GLuint*, GLint, GLint*);
+typedef void (GL_APIENTRY *glExtGetBuffersQCOM_t) (GLuint*, GLint, GLint*);
+typedef void (GL_APIENTRY *glExtGetRenderbuffersQCOM_t) (GLuint*, GLint, GLint*);
+typedef void (GL_APIENTRY *glExtGetFramebuffersQCOM_t) (GLuint*, GLint, GLint*);
+typedef void (GL_APIENTRY *glExtGetTexLevelParameterivQCOM_t) (GLuint, GLenum, GLint, GLenum, GLint*);
+typedef void (GL_APIENTRY *glExtTexObjectStateOverrideiQCOM_t) (GLenum, GLenum, GLint);
+typedef void (GL_APIENTRY *glExtGetTexSubImageQCOM_t) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid*);
+typedef void (GL_APIENTRY *glExtGetBufferPointervQCOM_t) (GLenum, GLvoid*);
+typedef void (GL_APIENTRY *glExtGetShadersQCOM_t) (GLuint*, GLint, GLint*);
+typedef void (GL_APIENTRY *glExtGetProgramsQCOM_t) (GLuint*, GLint, GLint*);
+typedef GLboolean (GL_APIENTRY *glExtIsProgramBinaryQCOM_t) (GLuint);
+typedef void (GL_APIENTRY *glExtGetProgramBinarySourceQCOM_t) (GLuint, GLenum, GLchar*, GLint*);
+typedef void (GL_APIENTRY *glStartTilingQCOM_t) (GLuint, GLuint, GLuint, GLuint, GLbitfield);
+typedef void (GL_APIENTRY *glEndTilingQCOM_t) (GLbitfield);
+
+
+#endif
diff --git a/emulator/opengl/host/libs/libOpenglRender/render_api.cpp b/emulator/opengl/host/libs/libOpenglRender/render_api.cpp
new file mode 100644
index 0000000..c8d3e06
--- /dev/null
+++ b/emulator/opengl/host/libs/libOpenglRender/render_api.cpp
@@ -0,0 +1,359 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "libOpenglRender/render_api.h"
+#include "IOStream.h"
+#include "FrameBuffer.h"
+#include "RenderServer.h"
+#include "osProcess.h"
+#include "TimeUtils.h"
+
+#include "TcpStream.h"
+#ifdef _WIN32
+#include "Win32PipeStream.h"
+#else
+#include "UnixStream.h"
+#endif
+
+#include "EGLDispatch.h"
+#include "GLDispatch.h"
+#include "GL2Dispatch.h"
+
+static osUtils::childProcess *s_renderProc = NULL;
+static RenderServer *s_renderThread = NULL;
+static int s_renderPort = 0;
+
+static IOStream *createRenderThread(int p_stream_buffer_size,
+                                    unsigned int clientFlags);
+
+//
+// For now run the renderer as a thread inside the calling
+// process instead as running it in a separate process for all
+// platforms.
+// at the future we want it to run as a seperate process except for
+// Mac OS X since it is imposibble on this platform to make one process
+// render to a window created by another process.
+//
+//#ifdef __APPLE__
+#define  RENDER_API_USE_THREAD
+//#endif
+
+bool initLibrary(void)
+{
+    //
+    // Load EGL Plugin
+    //
+    if (!init_egl_dispatch()) {
+        // Failed to load EGL
+        printf("Failed to init_egl_dispatch\n");
+        return false;
+    }
+
+    //
+    // Load GLES Plugin
+    //
+    if (!init_gl_dispatch()) {
+        // Failed to load GLES
+        ERR("Failed to init_gl_dispatch\n");
+        return false;
+    }
+
+    /* failure to init the GLES2 dispatch table is not fatal */
+    init_gl2_dispatch();
+
+    return true;
+}
+
+bool initOpenGLRenderer(int width, int height, int portNum,
+        OnPostFn onPost, void* onPostContext)
+{
+
+    //
+    // Fail if renderer is already initialized
+    //
+    if (s_renderProc || s_renderThread) {
+        return false;
+    }
+
+    s_renderPort = portNum;
+
+#ifdef RENDER_API_USE_THREAD  // should be defined for mac
+    //
+    // initialize the renderer and listen to connections
+    // on a thread in the current process.
+    //
+    bool inited = FrameBuffer::initialize(width, height, onPost, onPostContext);
+    if (!inited) {
+        return false;
+    }
+
+    s_renderThread = RenderServer::create(portNum);
+    if (!s_renderThread) {
+        return false;
+    }
+
+    s_renderThread->start();
+
+#else
+    if (onPost) {
+        // onPost callback not supported with separate renderer process.
+        //
+        // If we ever revive separate process support, we could make the choice
+        // between thread and process at runtime instead of compile time, and
+        // choose the thread path if an onPost callback is requested. Or, the
+        // callback could be supported with a separate process using shmem or
+        // other IPC mechanism.
+        return false;
+    }
+
+    //
+    // Launch emulator_renderer
+    //
+    char cmdLine[128];
+    snprintf(cmdLine, 128, "emulator_renderer -windowid %d -port %d -x %d -y %d -width %d -height %d",
+             (int)window, portNum, x, y, width, height);
+
+    s_renderProc = osUtils::childProcess::create(cmdLine, NULL);
+    if (!s_renderProc) {
+        return false;
+    }
+
+    //
+    // try to connect to the renderer in order to check it
+    // was successfully initialized.
+    //
+    int nTrys = 0;
+    IOStream *dummy = NULL;
+    do {
+        ++nTrys;
+
+        //
+        // Wait a bit to make the renderer process a chance to be
+        // initialized.
+        // On Windows we need during this time to handle windows
+        // events since the renderer generates a subwindow of this
+        // process's window, we need to be responsive for windows
+        // during this time to let the renderer generates this subwindow.
+        //
+#ifndef _WIN32
+        TimeSleepMS(300);
+#else
+        long long t0 = GetCurrentTimeMS();
+        while( (GetCurrentTimeMS() - t0) < 300 ) {
+            MSG msg;
+            int n = 0;
+            while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
+            {
+                n++;
+                TranslateMessage( &msg );
+                DispatchMessage( &msg );
+            }
+            if (n == 0) TimeSleepMS(10);
+        }
+#endif
+
+        dummy = createRenderThread(8, 0);
+
+        if (!dummy) {
+            // stop if the process is no longer running
+            if (!osUtils::isProcessRunning(s_renderProc->getPID())) {
+                break;
+            }
+        }
+    } while(!dummy && nTrys < 10); // give up after 3 seconds, XXX: ???
+
+    if (!dummy) {
+        //
+        // Failed - make sure the process is killed
+        //
+        osUtils::KillProcess(s_renderProc->getPID(), true);
+        delete s_renderProc;
+        s_renderProc = NULL;
+        return false;
+    }
+
+    // destroy the dummy connection
+    delete dummy;
+#endif
+
+    return true;
+}
+
+bool stopOpenGLRenderer()
+{
+    bool ret = false;
+
+    // open a dummy connection to the renderer to make it
+    // realize the exit request.
+    // (send the exit request in clientFlags)
+    IOStream *dummy = createRenderThread(8, IOSTREAM_CLIENT_EXIT_SERVER);
+    if (!dummy) return false;
+
+    if (s_renderProc) {
+        //
+        // wait for the process to exit
+        //
+        int exitStatus;
+        ret = s_renderProc->wait(&exitStatus);
+
+        delete s_renderProc;
+        s_renderProc = NULL;
+    }
+    else if (s_renderThread) {
+
+        // wait for the thread to exit
+        int status;
+        ret = s_renderThread->wait(&status);
+
+        delete s_renderThread;
+        s_renderThread = NULL;
+    }
+
+    return ret;
+}
+
+bool createOpenGLSubwindow(FBNativeWindowType window,
+                           int x, int y, int width, int height, float zRot)
+{
+    if (s_renderThread) {
+        return FrameBuffer::setupSubWindow(window,x,y,width,height, zRot);
+    }
+    else {
+        //
+        // XXX: should be implemented by sending the renderer process
+        //      a request
+        ERR("%s not implemented for separate renderer process !!!\n",
+            __FUNCTION__);
+    }
+    return false;
+}
+
+bool destroyOpenGLSubwindow()
+{
+    if (s_renderThread) {
+        return FrameBuffer::removeSubWindow();
+    }
+    else {
+        //
+        // XXX: should be implemented by sending the renderer process
+        //      a request
+        ERR("%s not implemented for separate renderer process !!!\n",
+                __FUNCTION__);
+        return false;
+    }
+}
+
+void setOpenGLDisplayRotation(float zRot)
+{
+    if (s_renderThread) {
+        FrameBuffer *fb = FrameBuffer::getFB();
+        if (fb) {
+            fb->setDisplayRotation(zRot);
+        }
+    }
+    else {
+        //
+        // XXX: should be implemented by sending the renderer process
+        //      a request
+        ERR("%s not implemented for separate renderer process !!!\n",
+                __FUNCTION__);
+    }
+}
+
+void repaintOpenGLDisplay()
+{
+    if (s_renderThread) {
+        FrameBuffer *fb = FrameBuffer::getFB();
+        if (fb) {
+            fb->repost();
+        }
+    }
+    else {
+        //
+        // XXX: should be implemented by sending the renderer process
+        //      a request
+        ERR("%s not implemented for separate renderer process !!!\n",
+                __FUNCTION__);
+    }
+}
+
+
+/* NOTE: For now, always use TCP mode by default, until the emulator
+ *        has been updated to support Unix and Win32 pipes
+ */
+#define  DEFAULT_STREAM_MODE  STREAM_MODE_TCP
+
+int gRendererStreamMode = DEFAULT_STREAM_MODE;
+
+IOStream *createRenderThread(int p_stream_buffer_size, unsigned int clientFlags)
+{
+    SocketStream*  stream = NULL;
+
+    if (gRendererStreamMode == STREAM_MODE_TCP) {
+        stream = new TcpStream(p_stream_buffer_size);
+    } else {
+#ifdef _WIN32
+        stream = new Win32PipeStream(p_stream_buffer_size);
+#else /* !_WIN32 */
+        stream = new UnixStream(p_stream_buffer_size);
+#endif
+    }
+
+    if (!stream) {
+        ERR("createRenderThread failed to create stream\n");
+        return NULL;
+    }
+    if (stream->connect(s_renderPort) < 0) {
+        ERR("createRenderThread failed to connect\n");
+        delete stream;
+        return NULL;
+    }
+
+    //
+    // send clientFlags to the renderer
+    //
+    unsigned int *pClientFlags =
+                (unsigned int *)stream->allocBuffer(sizeof(unsigned int));
+    *pClientFlags = clientFlags;
+    stream->commitBuffer(sizeof(unsigned int));
+
+    return stream;
+}
+
+int
+setStreamMode(int mode)
+{
+    switch (mode) {
+        case STREAM_MODE_DEFAULT:
+            mode = DEFAULT_STREAM_MODE;
+            break;
+
+        case STREAM_MODE_TCP:
+            break;
+
+#ifndef _WIN32
+        case STREAM_MODE_UNIX:
+            break;
+#else /* _WIN32 */
+        case STREAM_MODE_PIPE:
+            break;
+#endif /* _WIN32 */
+        default:
+            // Invalid stream mode
+            return -1;
+    }
+    gRendererStreamMode = mode;
+    return 0;
+}