diff --git a/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.cpp b/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.cpp
index 979549029..0826a14ad 100644
--- a/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.cpp
@@ -35,6 +35,7 @@ GLClientState::GLClientState(int nLocations)
     for (int i = 0; i < m_nLocations; i++) {
         m_states[i].enabled = 0;
         m_states[i].enableDirty = false;
+        m_states[i].data = 0;
     }
     m_currentArrayVbo = 0;
     m_currentIndexVbo = 0;
@@ -224,6 +225,8 @@ int GLClientState::setPixelStore(GLenum param, GLint value)
 
 size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const
 {
+    if (width <= 0 || height <= 0) return 0;
+
     int pixelsize = glUtilsPixelBitSize(format, type) >> 3;
 
     int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment;
diff --git a/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.h b/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.h
index c86329b44..09ee57175 100644
--- a/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.h
+++ b/tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.h
@@ -91,6 +91,12 @@ public:
     void setActiveTexture(int texUnit) {m_activeTexture = texUnit; };
     int getActiveTexture() const { return m_activeTexture; }
 
+    void unBindBuffer(GLuint id)
+    {
+        if (m_currentArrayVbo == id) m_currentArrayVbo = 0;
+        else if (m_currentIndexVbo == id) m_currentIndexVbo = 0;
+    }
+
     int bindBuffer(GLenum target, GLuint id)
     {
         int err = 0;
diff --git a/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp b/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp
index 8504f7f78..b079b6dae 100644
--- a/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp
+++ b/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp
@@ -16,10 +16,19 @@
 
 #include "GLSharedGroup.h"
 
+/**** KeyedVector utilities ****/
+
+template <typename T>
+static void clearObjectMap(android::DefaultKeyedVector<GLuint, T>& v) {
+    for (size_t i = 0; i < v.size(); i++)
+        delete v.valueAt(i);
+    v.clear();
+}
+
 /**** BufferData ****/
 
 BufferData::BufferData() : m_size(0) {};
-BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size) 
+BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size)
 {
     void * buffer = NULL;
     if (size>0) buffer = m_fixedBuffer.alloc(size);
@@ -55,7 +64,7 @@ ProgramData::~ProgramData()
 }
 
 void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
-{   
+{
     if (index>=m_numIndexes)
         return;
     m_Indexes[index].base = base;
@@ -87,7 +96,7 @@ GLuint ProgramData::getIndexForLocation(GLint location)
     for (GLuint i=0;i<m_numIndexes;++i)
     {
         GLint dist = location - m_Indexes[i].base;
-        if (dist >= 0 && 
+        if (dist >= 0 &&
             (minDist < 0 || dist < minDist)) {
             index = i;
             minDist = dist;
@@ -126,7 +135,7 @@ GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex)
     GLuint index = getIndexForLocation(hostLoc);
     if (index<m_numIndexes) {
         if (arrIndex > 0) {
-            m_Indexes[index].hostLocsPerElement = 
+            m_Indexes[index].hostLocsPerElement =
                               (hostLoc - m_Indexes[index].base) / arrIndex;
         }
         return m_Indexes[index].appBase + arrIndex;
@@ -226,12 +235,21 @@ GLSharedGroup::~GLSharedGroup()
 {
     m_buffers.clear();
     m_programs.clear();
+    clearObjectMap(m_buffers);
+    clearObjectMap(m_programs);
+    clearObjectMap(m_shaders);
+}
+
+bool GLSharedGroup::isObject(GLuint obj)
+{
+    android::AutoMutex _lock(m_lock);
+    return ((m_shaders.valueFor(obj)!=NULL) || (m_programs.valueFor(obj)!=NULL));
 }
 
 BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
 {
     android::AutoMutex _lock(m_lock);
-    return m_buffers.valueFor(bufferId);    
+    return m_buffers.valueFor(bufferId);
 }
 
 void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
@@ -243,32 +261,42 @@ void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
 void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data)
 {
     android::AutoMutex _lock(m_lock);
-    m_buffers.replaceValueFor(bufferId, new BufferData(size, data));
+    ssize_t idx = m_buffers.indexOfKey(bufferId);
+    if (idx >= 0) {
+        delete m_buffers.valueAt(idx);
+        m_buffers.editValueAt(idx) = new BufferData(size, data);
+    } else {
+        m_buffers.add(bufferId, new BufferData(size, data));
+    }
 }
 
 GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data)
 {
     android::AutoMutex _lock(m_lock);
     BufferData * buf = m_buffers.valueFor(bufferId);
-    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE; 
+    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
 
     //it's safe to update now
     memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
-    return GL_NO_ERROR; 
+    return GL_NO_ERROR;
 }
 
 void GLSharedGroup::deleteBufferData(GLuint bufferId)
 {
     android::AutoMutex _lock(m_lock);
-    m_buffers.removeItem(bufferId);
+    ssize_t idx = m_buffers.indexOfKey(bufferId);
+    if (idx >= 0) {
+        delete m_buffers.valueAt(idx);
+        m_buffers.removeItemsAt(idx);
+    }
 }
 
 void GLSharedGroup::addProgramData(GLuint program)
 {
     android::AutoMutex _lock(m_lock);
     ProgramData *pData = m_programs.valueFor(program);
-    if (pData) 
-    {   
+    if (pData)
+    {
         m_programs.removeItem(program);
         delete pData;
     }
@@ -290,7 +318,7 @@ bool GLSharedGroup::isProgramInitialized(GLuint program)
 {
     android::AutoMutex _lock(m_lock);
     ProgramData* pData = m_programs.valueFor(program);
-    if (pData) 
+    if (pData)
     {
         return pData->isInitialized();
     }
@@ -303,7 +331,7 @@ void GLSharedGroup::deleteProgramData(GLuint program)
     ProgramData *pData = m_programs.valueFor(program);
     if (pData)
         delete pData;
-    m_programs.removeItem(program); 
+    m_programs.removeItem(program);
 }
 
 void GLSharedGroup::attachShader(GLuint program, GLuint shader)
@@ -363,7 +391,7 @@ GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
     android::AutoMutex _lock(m_lock);
     ProgramData* pData = m_programs.valueFor(program);
     GLenum type=0;
-    if (pData) 
+    if (pData)
     {
         type = pData->getTypeForLocation(location);
     }
diff --git a/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.h b/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.h
index 61b8f0056..6dfcd8f51 100644
--- a/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -110,6 +110,7 @@ private:
 public:
     GLSharedGroup();
     ~GLSharedGroup();
+    bool isObject(GLuint obj);
     BufferData * getBufferData(GLuint bufferId);
     void    addBufferData(GLuint bufferId, GLsizeiptr size, void * data);
     void    updateBufferData(GLuint bufferId, GLsizeiptr size, void * data);
diff --git a/tools/emulator/opengl/system/GLESv1_enc/GLEncoder.cpp b/tools/emulator/opengl/system/GLESv1_enc/GLEncoder.cpp
index 4414f2461..989c26fcb 100644
--- a/tools/emulator/opengl/system/GLESv1_enc/GLEncoder.cpp
+++ b/tools/emulator/opengl/system/GLESv1_enc/GLEncoder.cpp
@@ -464,19 +464,19 @@ void GLEncoder::sendVertexData(unsigned int first, unsigned int count)
                 switch(i) {
                 case GLClientState::VERTEX_LOCATION:
                     this->glVertexPointerOffset(this, state->size, state->type, state->stride,
-                                                (GLuint)state->data + firstIndex);
+                                                (uintptr_t)state->data + firstIndex);
                     break;
                 case GLClientState::NORMAL_LOCATION:
                     this->glNormalPointerOffset(this, state->type, state->stride,
-                                                (GLuint) state->data + firstIndex);
+                                                (uintptr_t)state->data + firstIndex);
                     break;
                 case GLClientState::POINTSIZE_LOCATION:
                     this->glPointSizePointerOffset(this, state->type, state->stride,
-                                                   (GLuint) state->data + firstIndex);
+                                                   (uintptr_t)state->data + firstIndex);
                     break;
                 case GLClientState::COLOR_LOCATION:
                     this->glColorPointerOffset(this, state->size, state->type, state->stride,
-                                               (GLuint) state->data + firstIndex);
+                                               (uintptr_t)state->data + firstIndex);
                     break;
                 case GLClientState::TEXCOORD0_LOCATION:
                 case GLClientState::TEXCOORD1_LOCATION:
@@ -487,17 +487,17 @@ void GLEncoder::sendVertexData(unsigned int first, unsigned int count)
                 case GLClientState::TEXCOORD6_LOCATION:
                 case GLClientState::TEXCOORD7_LOCATION:
                     this->glTexCoordPointerOffset(this, state->size, state->type, state->stride,
-                                                  (GLuint) state->data + firstIndex);
+                                                  (uintptr_t)state->data + firstIndex);
                     break;
                 case GLClientState::WEIGHT_LOCATION:
                     this->glWeightPointerOffset(this,state->size,state->type,state->stride,
-                                                (GLuint)state->data+firstIndex);
+                                                (uintptr_t)state->data+firstIndex);
                     break;
                 case GLClientState::MATRIXINDEX_LOCATION:
                     this->glMatrixIndexPointerOffset(this,state->size,state->type,state->stride,
-                                              (GLuint)state->data+firstIndex);
+                                              (uintptr_t)state->data+firstIndex);
                     break;
-                }                
+                }
                 this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo());
             }
         } else {
@@ -545,14 +545,14 @@ void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum
         if (!has_immediate_arrays) {
             ctx->sendVertexData(0, count);
             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo());
-            ctx->glDrawElementsOffset(ctx, mode, count, type, (GLuint)indices);
+            ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices);
             adjustIndices = false;
         } else {
             BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo());
             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0);
             indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices);
         }
-    } 
+    }
     if (adjustIndices) {
         void *adjustedIndices = (void*)indices;
         int minIndex = 0, maxIndex = 0;
diff --git a/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.cpp b/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.cpp
index d8fedf3bd..b567f62e7 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.cpp
+++ b/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.cpp
@@ -79,6 +79,11 @@ GL2Encoder::GL2Encoder(IOStream *stream) : gl2_encoder_context_t(stream)
     m_glDeleteShader_enc = set_glDeleteShader(s_glDeleteShader);
     m_glAttachShader_enc = set_glAttachShader(s_glAttachShader);
     m_glDetachShader_enc = set_glDetachShader(s_glDetachShader);
+    m_glGetAttachedShaders_enc = set_glGetAttachedShaders(s_glGetAttachedShaders);
+    m_glGetShaderSource_enc = set_glGetShaderSource(s_glGetShaderSource);
+    m_glGetShaderInfoLog_enc = set_glGetShaderInfoLog(s_glGetShaderInfoLog);
+    m_glGetProgramInfoLog_enc = set_glGetProgramInfoLog(s_glGetProgramInfoLog);
+
     m_glGetUniformLocation_enc = set_glGetUniformLocation(s_glGetUniformLocation);
     m_glUseProgram_enc = set_glUseProgram(s_glUseProgram);
 
@@ -111,6 +116,7 @@ GL2Encoder::GL2Encoder(IOStream *stream) : gl2_encoder_context_t(stream)
     m_glTexParameterfv_enc = set_glTexParameterfv(s_glTexParameterfv);
     m_glTexParameteri_enc = set_glTexParameteri(s_glTexParameteri);
     m_glTexParameteriv_enc = set_glTexParameteriv(s_glTexParameteriv);
+    m_glTexImage2D_enc = set_glTexImage2D(s_glTexImage2D);
 }
 
 GL2Encoder::~GL2Encoder()
@@ -179,6 +185,7 @@ void GL2Encoder::s_glBindBuffer(void *self, GLenum target, GLuint id)
 void GL2Encoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)
 {
     GL2Encoder *ctx = (GL2Encoder *) self;
+    SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM);
     GLuint bufferId = ctx->m_state->getBuffer(target);
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
     SET_ERROR_IF(size<0, GL_INVALID_VALUE);
@@ -190,6 +197,7 @@ void GL2Encoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, con
 void GL2Encoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)
 {
     GL2Encoder *ctx = (GL2Encoder *) self;
+    SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM);
     GLuint bufferId = ctx->m_state->getBuffer(target);
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
 
@@ -205,6 +213,7 @@ void GL2Encoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffer
     SET_ERROR_IF(n<0, GL_INVALID_VALUE);
     for (int i=0; i<n; i++) {
         ctx->m_shared->deleteBufferData(buffers[i]);
+        ctx->m_state->unBindBuffer(buffers[i]);
         ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]);
     }
 }
@@ -348,6 +357,7 @@ void GL2Encoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr)
         if (!ctx->m_state->getClientStateParameter<GLboolean>(param, ptr)) {
             ctx->m_glGetBooleanv_enc(self, param, ptr);
         }
+        *ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE;
         break;
     }
 }
@@ -424,15 +434,15 @@ void GL2Encoder::sendVertexAttributes(GLint first, GLsizei count)
             int stride = state->stride == 0 ? state->elementSize : state->stride;
             int firstIndex = stride * first;
 
+            this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state->bufferObject);
             if (state->bufferObject == 0) {
                 this->glVertexAttribPointerData(this, i, state->size, state->type, state->normalized, state->stride,
                                                 (unsigned char *)state->data + firstIndex, datalen);
             } else {
-                this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state->bufferObject);
                 this->glVertexAttribPointerOffset(this, i, state->size, state->type, state->normalized, state->stride,
-                                                  (GLuint) state->data + firstIndex);
-                this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo());
+                                                  (uintptr_t) state->data + firstIndex);
             }
+            this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo());
         } else {
             this->m_glDisableVertexAttribArray_enc(this, i);
         }
@@ -479,14 +489,14 @@ void GL2Encoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum
         if (!has_immediate_arrays) {
             ctx->sendVertexAttributes(0, count);
             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo());
-            ctx->glDrawElementsOffset(ctx, mode, count, type, (GLuint)indices);
+            ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices);
             adjustIndices = false;
         } else {
             BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo());
             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0);
             indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices);
         }
-    } 
+    }
     if (adjustIndices) {
         void *adjustedIndices = (void*)indices;
         int minIndex = 0, maxIndex = 0;
@@ -637,7 +647,9 @@ void GL2Encoder::s_glShaderSource(void *self, GLuint shader, GLsizei count, cons
 {
     GL2Encoder* ctx = (GL2Encoder*)self;
     ShaderData* shaderData = ctx->m_shared->getShaderData(shader);
-    SET_ERROR_IF(!shaderData, GL_INVALID_VALUE);
+    SET_ERROR_IF(!ctx->m_shared->isObject(shader), GL_INVALID_VALUE);
+    SET_ERROR_IF(!shaderData, GL_INVALID_OPERATION);
+    SET_ERROR_IF((count<0), GL_INVALID_VALUE);
 
     int len = glUtilsCalcShaderSourceLen((char**)string, (GLint*)length, count);
     char *str = new char[len + 1];
@@ -686,7 +698,7 @@ void GL2Encoder::s_glLinkProgram(void * self, GLuint program)
     GLchar *name = new GLchar[maxLength+1];
     GLint location;
     //for each active uniform, get its size and starting location.
-    for (GLint i=0 ; i<numUniforms ; ++i) 
+    for (GLint i=0 ; i<numUniforms ; ++i)
     {
         ctx->glGetActiveUniform(self, program, i, maxLength, NULL, &size, &type, name);
         location = ctx->m_glGetUniformLocation_enc(self, program, name);
@@ -746,6 +758,38 @@ GLuint GL2Encoder::s_glCreateShader(void *self, GLenum shaderType)
     return shader;
 }
 
+void GL2Encoder::s_glGetAttachedShaders(void *self, GLuint program, GLsizei maxCount,
+        GLsizei* count, GLuint* shaders)
+{
+    GL2Encoder *ctx = (GL2Encoder*)self;
+    SET_ERROR_IF(maxCount < 0, GL_INVALID_VALUE);
+    ctx->m_glGetAttachedShaders_enc(self, program, maxCount, count, shaders);
+}
+
+void GL2Encoder::s_glGetShaderSource(void *self, GLuint shader, GLsizei bufsize,
+            GLsizei* length, GLchar* source)
+{
+    GL2Encoder *ctx = (GL2Encoder*)self;
+    SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE);
+    ctx->m_glGetShaderSource_enc(self, shader, bufsize, length, source);
+}
+
+void GL2Encoder::s_glGetShaderInfoLog(void *self, GLuint shader, GLsizei bufsize,
+        GLsizei* length, GLchar* infolog)
+{
+    GL2Encoder *ctx = (GL2Encoder*)self;
+    SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE);
+    ctx->m_glGetShaderInfoLog_enc(self, shader, bufsize, length, infolog);
+}
+
+void GL2Encoder::s_glGetProgramInfoLog(void *self, GLuint program, GLsizei bufsize,
+        GLsizei* length, GLchar* infolog)
+{
+    GL2Encoder *ctx = (GL2Encoder*)self;
+    SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE);
+    ctx->m_glGetProgramInfoLog_enc(self, program, bufsize, length, infolog);
+}
+
 void GL2Encoder::s_glDeleteShader(void *self, GLenum shader)
 {
     GL2Encoder *ctx = (GL2Encoder*)self;
@@ -784,7 +828,7 @@ int GL2Encoder::s_glGetUniformLocation(void *self, GLuint program, const GLchar
             if (!brace || sscanf(brace+1,"%d",&arrIndex) != 1) {
                 return -1;
             }
-        
+
         }
     }
 
@@ -1161,6 +1205,23 @@ void GL2Encoder::s_glTexParameteri(void* self,
     }
 }
 
+void GL2Encoder::s_glTexImage2D(void* self, GLenum target, GLint level,
+        GLint internalformat, GLsizei width, GLsizei height, GLint border,
+        GLenum format, GLenum type, const GLvoid* pixels)
+{
+    GL2Encoder* ctx = (GL2Encoder*)self;
+    if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
+        ctx->override2DTextureTarget(target);
+        ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width,
+                height, border, format, type, pixels);
+        ctx->restore2DTextureTarget();
+    } else {
+        ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width,
+                height, border, format, type, pixels);
+    }
+}
+
+
 void GL2Encoder::s_glTexParameteriv(void* self,
         GLenum target, GLenum pname, const GLint* params)
 {
diff --git a/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.h b/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.h
index f9235d747..a16f4903c 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.h
+++ b/tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.h
@@ -74,7 +74,7 @@ private:
     glBindBuffer_client_proc_t m_glBindBuffer_enc;
     static void s_glBindBuffer(void *self, GLenum target, GLuint id);
 
-    
+
     glBufferData_client_proc_t m_glBufferData_enc;
     static void s_glBufferData(void *self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
     glBufferSubData_client_proc_t m_glBufferSubData_enc;
@@ -148,6 +148,22 @@ private:
     glDetachShader_client_proc_t m_glDetachShader_enc;
     static void s_glDetachShader(void *self, GLuint program, GLuint shader);
 
+    glGetAttachedShaders_client_proc_t m_glGetAttachedShaders_enc;
+    static void s_glGetAttachedShaders(void *self, GLuint program, GLsizei maxCount,
+            GLsizei* count, GLuint* shaders);
+
+    glGetShaderSource_client_proc_t m_glGetShaderSource_enc;
+    static void s_glGetShaderSource(void *self, GLuint shader, GLsizei bufsize,
+            GLsizei* length, GLchar* source);
+
+    glGetShaderInfoLog_client_proc_t m_glGetShaderInfoLog_enc;
+    static void s_glGetShaderInfoLog(void *self,GLuint shader,
+            GLsizei bufsize, GLsizei* length, GLchar* infolog);
+
+    glGetProgramInfoLog_client_proc_t m_glGetProgramInfoLog_enc;
+    static void s_glGetProgramInfoLog(void *self,GLuint program,
+            GLsizei bufsize, GLsizei* length, GLchar* infolog);
+
     glGetUniformLocation_client_proc_t m_glGetUniformLocation_enc;
     static int s_glGetUniformLocation(void *self, GLuint program, const GLchar *name);
     glUseProgram_client_proc_t m_glUseProgram_enc;
@@ -202,6 +218,7 @@ private:
     glTexParameterfv_client_proc_t m_glTexParameterfv_enc;
     glTexParameteri_client_proc_t m_glTexParameteri_enc;
     glTexParameteriv_client_proc_t m_glTexParameteriv_enc;
+    glTexImage2D_client_proc_t m_glTexImage2D_enc;
 
     static void s_glActiveTexture(void* self, GLenum texture);
     static void s_glBindTexture(void* self, GLenum target, GLuint texture);
@@ -212,5 +229,9 @@ private:
     static void s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params);
     static void s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param);
     static void s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params);
+    static void s_glTexImage2D(void* self, GLenum target, GLint level, GLint internalformat,
+            GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
+            const GLvoid* pixels);
+
 };
 #endif
diff --git a/tools/emulator/opengl/system/GLESv2_enc/gl2_client_proc.h b/tools/emulator/opengl/system/GLESv2_enc/gl2_client_proc.h
index b8ff005f3..771480808 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/gl2_client_proc.h
+++ b/tools/emulator/opengl/system/GLESv2_enc/gl2_client_proc.h
@@ -7,7 +7,7 @@
 
 #include "gl2_types.h"
 #ifndef gl2_APIENTRY
-#define gl2_APIENTRY 
+#define gl2_APIENTRY
 #endif
 typedef void (gl2_APIENTRY *glActiveTexture_client_proc_t) (void * ctx, GLenum);
 typedef void (gl2_APIENTRY *glAttachShader_client_proc_t) (void * ctx, GLuint, GLuint);
diff --git a/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.cpp b/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.cpp
index 46684e9f0..592969799 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.cpp
+++ b/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.cpp
@@ -1162,7 +1162,7 @@ void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsiz
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_length =  sizeof(GLsizei);
+	const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
 	const unsigned int __size_infolog =  bufsize;
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + __size_length + __size_infolog + 2*4;
@@ -1174,7 +1174,7 @@ void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsiz
 		memcpy(ptr, &bufsize, 4); ptr += 4;
 	*(unsigned int *)(ptr) = __size_length; ptr += 4;
 	*(unsigned int *)(ptr) = __size_infolog; ptr += 4;
-	stream->readback(length, __size_length);
+	if (length != NULL) stream->readback(length, __size_length);
 	stream->readback(infolog, __size_infolog);
 }
 
@@ -1923,7 +1923,7 @@ void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset,
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels =  pixelDataSize(self, width, height, format, type, 0);
+	const unsigned int __size_pixels = ((pixels != NULL) ?  pixelDataSize(self, width, height, format, type, 0) : 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -1940,7 +1940,7 @@ void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset,
 		memcpy(ptr, &type, 4); ptr += 4;
 	stream->flush();
 	stream->writeFully(&__size_pixels,4);
-	stream->writeFully(pixels, __size_pixels);
+	if (pixels != NULL) stream->writeFully(pixels, __size_pixels);
 }
 
 void glUniform1f_enc(void *self , GLint location, GLfloat x)
diff --git a/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.h b/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.h
index f422c1133..51bfee67c 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.h
+++ b/tools/emulator/opengl/system/GLESv2_enc/gl2_enc.h
@@ -231,4 +231,4 @@ extern "C" {
 	void glShaderString_enc(void *self , GLuint shader, const GLchar* string, GLsizei len);
 	int glFinishRoundTrip_enc(void *self );
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/tools/emulator/opengl/system/GLESv2_enc/gl2_entry.cpp b/tools/emulator/opengl/system/GLESv2_enc/gl2_entry.cpp
index f98fe750d..4f57d728f 100644
--- a/tools/emulator/opengl/system/GLESv2_enc/gl2_entry.cpp
+++ b/tools/emulator/opengl/system/GLESv2_enc/gl2_entry.cpp
@@ -220,1264 +220,1264 @@ extern "C" {
 #ifndef GET_CONTEXT
 static gl2_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 void gl2_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
-#define GET_CONTEXT gl2_client_context_t * ctx = getCurrentContext() 
+#define GET_CONTEXT gl2_client_context_t * ctx = getCurrentContext()
 #endif
 
 void glActiveTexture(GLenum texture)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glActiveTexture(ctx, texture);
 }
 
 void glAttachShader(GLuint program, GLuint shader)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glAttachShader(ctx, program, shader);
 }
 
 void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindAttribLocation(ctx, program, index, name);
 }
 
 void glBindBuffer(GLenum target, GLuint buffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindBuffer(ctx, target, buffer);
 }
 
 void glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindFramebuffer(ctx, target, framebuffer);
 }
 
 void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindRenderbuffer(ctx, target, renderbuffer);
 }
 
 void glBindTexture(GLenum target, GLuint texture)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindTexture(ctx, target, texture);
 }
 
 void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBlendColor(ctx, red, green, blue, alpha);
 }
 
 void glBlendEquation(GLenum mode)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBlendEquation(ctx, mode);
 }
 
 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha);
 }
 
 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBlendFunc(ctx, sfactor, dfactor);
 }
 
 void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBufferData(ctx, target, size, data, usage);
 }
 
 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBufferSubData(ctx, target, offset, size, data);
 }
 
 GLenum glCheckFramebufferStatus(GLenum target)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glCheckFramebufferStatus(ctx, target);
 }
 
 void glClear(GLbitfield mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glClear(ctx, mask);
 }
 
 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glClearColor(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthf(GLclampf depth)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glClearDepthf(ctx, depth);
 }
 
 void glClearStencil(GLint s)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glClearStencil(ctx, s);
 }
 
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glColorMask(ctx, red, green, blue, alpha);
 }
 
 void glCompileShader(GLuint shader)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCompileShader(ctx, shader);
 }
 
 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
 }
 
 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
 }
 
 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 }
 
 GLuint glCreateProgram()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glCreateProgram(ctx);
 }
 
 GLuint glCreateShader(GLenum type)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glCreateShader(ctx, type);
 }
 
 void glCullFace(GLenum mode)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCullFace(ctx, mode);
 }
 
 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glDeleteBuffers(ctx, n, buffers);
 }
 
 void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glDeleteFramebuffers(ctx, n, framebuffers);
 }
 
 void glDeleteProgram(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDeleteProgram(ctx, program);
 }
 
 void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glDeleteRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glDeleteShader(GLuint shader)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDeleteShader(ctx, shader);
 }
 
 void glDeleteTextures(GLsizei n, const GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glDeleteTextures(ctx, n, textures);
 }
 
 void glDepthFunc(GLenum func)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDepthFunc(ctx, func);
 }
 
 void glDepthMask(GLboolean flag)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDepthMask(ctx, flag);
 }
 
 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDepthRangef(ctx, zNear, zFar);
 }
 
 void glDetachShader(GLuint program, GLuint shader)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDetachShader(ctx, program, shader);
 }
 
 void glDisable(GLenum cap)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDisable(ctx, cap);
 }
 
 void glDisableVertexAttribArray(GLuint index)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDisableVertexAttribArray(ctx, index);
 }
 
 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDrawArrays(ctx, mode, first, count);
 }
 
 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDrawElements(ctx, mode, count, type, indices);
 }
 
 void glEnable(GLenum cap)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEnable(ctx, cap);
 }
 
 void glEnableVertexAttribArray(GLuint index)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEnableVertexAttribArray(ctx, index);
 }
 
 void glFinish()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFinish(ctx);
 }
 
 void glFlush()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFlush(ctx);
 }
 
 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level);
 }
 
 void glFrontFace(GLenum mode)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFrontFace(ctx, mode);
 }
 
 void glGenBuffers(GLsizei n, GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glGenBuffers(ctx, n, buffers);
 }
 
 void glGenerateMipmap(GLenum target)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGenerateMipmap(ctx, target);
 }
 
 void glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glGenFramebuffers(ctx, n, framebuffers);
 }
 
 void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glGenRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glGenTextures(GLsizei n, GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glGenTextures(ctx, n, textures);
 }
 
 void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders);
 }
 
 int glGetAttribLocation(GLuint program, const GLchar* name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glGetAttribLocation(ctx, program, name);
 }
 
 void glGetBooleanv(GLenum pname, GLboolean* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetBooleanv(ctx, pname, params);
 }
 
 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetBufferParameteriv(ctx, target, pname, params);
 }
 
 GLenum glGetError()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glGetError(ctx);
 }
 
 void glGetFloatv(GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetFloatv(ctx, pname, params);
 }
 
 void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params);
 }
 
 void glGetIntegerv(GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetIntegerv(ctx, pname, params);
 }
 
 void glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetProgramiv(ctx, program, pname, params);
 }
 
 void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog);
 }
 
 void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetRenderbufferParameteriv(ctx, target, pname, params);
 }
 
 void glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetShaderiv(ctx, shader, pname, params);
 }
 
 void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog);
 }
 
 void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision);
 }
 
 void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetShaderSource(ctx, shader, bufsize, length, source);
 }
 
 const GLubyte* glGetString(GLenum name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glGetString(ctx, name);
 }
 
 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetTexParameterfv(ctx, target, pname, params);
 }
 
 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetTexParameteriv(ctx, target, pname, params);
 }
 
 void glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetUniformfv(ctx, program, location, params);
 }
 
 void glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetUniformiv(ctx, program, location, params);
 }
 
 int glGetUniformLocation(GLuint program, const GLchar* name)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glGetUniformLocation(ctx, program, name);
 }
 
 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetVertexAttribfv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetVertexAttribiv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer);
 }
 
 void glHint(GLenum target, GLenum mode)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glHint(ctx, target, mode);
 }
 
 GLboolean glIsBuffer(GLuint buffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsBuffer(ctx, buffer);
 }
 
 GLboolean glIsEnabled(GLenum cap)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsEnabled(ctx, cap);
 }
 
 GLboolean glIsFramebuffer(GLuint framebuffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsFramebuffer(ctx, framebuffer);
 }
 
 GLboolean glIsProgram(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsProgram(ctx, program);
 }
 
 GLboolean glIsRenderbuffer(GLuint renderbuffer)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsRenderbuffer(ctx, renderbuffer);
 }
 
 GLboolean glIsShader(GLuint shader)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsShader(ctx, shader);
 }
 
 GLboolean glIsTexture(GLuint texture)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsTexture(ctx, texture);
 }
 
 void glLineWidth(GLfloat width)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glLineWidth(ctx, width);
 }
 
 void glLinkProgram(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glLinkProgram(ctx, program);
 }
 
 void glPixelStorei(GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glPixelStorei(ctx, pname, param);
 }
 
 void glPolygonOffset(GLfloat factor, GLfloat units)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glPolygonOffset(ctx, factor, units);
 }
 
 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
 }
 
 void glReleaseShaderCompiler()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glReleaseShaderCompiler(ctx);
 }
 
 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glRenderbufferStorage(ctx, target, internalformat, width, height);
 }
 
 void glSampleCoverage(GLclampf value, GLboolean invert)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glSampleCoverage(ctx, value, invert);
 }
 
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glScissor(ctx, x, y, width, height);
 }
 
 void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length);
 }
 
 void glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glShaderSource(ctx, shader, count, string, length);
 }
 
 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilFunc(ctx, func, ref, mask);
 }
 
 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilFuncSeparate(ctx, face, func, ref, mask);
 }
 
 void glStencilMask(GLuint mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilMask(ctx, mask);
 }
 
 void glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilMaskSeparate(ctx, face, mask);
 }
 
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilOp(ctx, fail, zfail, zpass);
 }
 
 void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass);
 }
 
 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexParameterf(ctx, target, pname, param);
 }
 
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexParameterfv(ctx, target, pname, params);
 }
 
 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexParameteri(ctx, target, pname, param);
 }
 
 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexParameteriv(ctx, target, pname, params);
 }
 
 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void glUniform1f(GLint location, GLfloat x)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform1f(ctx, location, x);
 }
 
 void glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform1fv(ctx, location, count, v);
 }
 
 void glUniform1i(GLint location, GLint x)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform1i(ctx, location, x);
 }
 
 void glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform1iv(ctx, location, count, v);
 }
 
 void glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform2f(ctx, location, x, y);
 }
 
 void glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform2fv(ctx, location, count, v);
 }
 
 void glUniform2i(GLint location, GLint x, GLint y)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform2i(ctx, location, x, y);
 }
 
 void glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform2iv(ctx, location, count, v);
 }
 
 void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform3f(ctx, location, x, y, z);
 }
 
 void glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform3fv(ctx, location, count, v);
 }
 
 void glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform3i(ctx, location, x, y, z);
 }
 
 void glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform3iv(ctx, location, count, v);
 }
 
 void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform4f(ctx, location, x, y, z, w);
 }
 
 void glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform4fv(ctx, location, count, v);
 }
 
 void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform4i(ctx, location, x, y, z, w);
 }
 
 void glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniform4iv(ctx, location, count, v);
 }
 
 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniformMatrix2fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniformMatrix3fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUniformMatrix4fv(ctx, location, count, transpose, value);
 }
 
 void glUseProgram(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glUseProgram(ctx, program);
 }
 
 void glValidateProgram(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glValidateProgram(ctx, program);
 }
 
 void glVertexAttrib1f(GLuint indx, GLfloat x)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib1f(ctx, indx, x);
 }
 
 void glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib1fv(ctx, indx, values);
 }
 
 void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib2f(ctx, indx, x, y);
 }
 
 void glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib2fv(ctx, indx, values);
 }
 
 void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib3f(ctx, indx, x, y, z);
 }
 
 void glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib3fv(ctx, indx, values);
 }
 
 void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib4f(ctx, indx, x, y, z, w);
 }
 
 void glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttrib4fv(ctx, indx, values);
 }
 
 void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr);
 }
 
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glViewport(ctx, x, y, width, height);
 }
 
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
 }
 
 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
 }
 
 void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary);
 }
 
 void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length);
 }
 
 void* glMapBufferOES(GLenum target, GLenum access)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glMapBufferOES(ctx, target, access);
 }
 
 GLboolean glUnmapBufferOES(GLenum target)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glUnmapBufferOES(ctx, target);
 }
 
 void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset);
 }
 
 void glBindVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBindVertexArrayOES(ctx, array);
 }
 
 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glDeleteVertexArraysOES(ctx, n, arrays);
 }
 
 void glGenVertexArraysOES(GLsizei n, GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 	 ctx->glGenVertexArraysOES(ctx, n, arrays);
 }
 
 GLboolean glIsVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsVertexArrayOES(ctx, array);
 }
 
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
 }
 
 void glMultiDrawArraysEXT(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
 }
 
 void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups);
 }
 
 void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters);
 }
 
 void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString);
 }
 
 void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString);
 }
 
 void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data);
 }
 
 void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGenPerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDeletePerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList);
 }
 
 void glBeginPerfMonitorAMD(GLuint monitor)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glBeginPerfMonitorAMD(ctx, monitor);
 }
 
 void glEndPerfMonitorAMD(GLuint monitor)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEndPerfMonitorAMD(ctx, monitor);
 }
 
 void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten);
 }
 
 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
 }
 
 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
 }
 
 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDeleteFencesNV(ctx, n, fences);
 }
 
 void glGenFencesNV(GLsizei n, GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGenFencesNV(ctx, n, fences);
 }
 
 GLboolean glIsFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glIsFenceNV(ctx, fence);
 }
 
 GLboolean glTestFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glTestFenceNV(ctx, fence);
 }
 
 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetFenceivNV(ctx, fence, pname, params);
 }
 
 void glFinishFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glFinishFenceNV(ctx, fence);
 }
 
 void glSetFenceNV(GLuint fence, GLenum condition)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glSetFenceNV(ctx, fence, condition);
 }
 
 void glCoverageMaskNV(GLboolean mask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCoverageMaskNV(ctx, mask);
 }
 
 void glCoverageOperationNV(GLenum operation)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glCoverageOperationNV(ctx, operation);
 }
 
 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
 }
 
 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
 }
 
 void glEnableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEnableDriverControlQCOM(ctx, driverControl);
 }
 
 void glDisableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDisableDriverControlQCOM(ctx, driverControl);
 }
 
 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
 }
 
 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
 }
 
 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
 }
 
 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
 }
 
 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
 }
 
 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
 }
 
 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
 }
 
 void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetBufferPointervQCOM(ctx, target, params);
 }
 
 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
 }
 
 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
 }
 
 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glExtIsProgramBinaryQCOM(ctx, program);
 }
 
 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
 }
 
 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
 }
 
 void glEndTilingQCOM(GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glEndTilingQCOM(ctx, preserveMask);
 }
 
 void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen);
 }
 
 void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset);
 }
 
 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
 }
 
 void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
 }
 
 void glGetCompressedTextureFormats(int count, GLint* formats)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glGetCompressedTextureFormats(ctx, count, formats);
 }
 
 void glShaderString(GLuint shader, const GLchar* string, GLsizei len)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 ctx->glShaderString(ctx, shader, string, len);
 }
 
 int glFinishRoundTrip()
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 return ctx->glFinishRoundTrip(ctx);
 }
 
diff --git a/tools/emulator/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp b/tools/emulator/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp
index 50c3d8bb1..57983704c 100644
--- a/tools/emulator/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp
+++ b/tools/emulator/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp
@@ -40,6 +40,7 @@ QemuPipeStream::QemuPipeStream(int sock, size_t bufSize) :
 QemuPipeStream::~QemuPipeStream()
 {
     if (m_sock >= 0) {
+        flush();
         ::close(m_sock);
     }
     if (m_buf != NULL) {
@@ -86,6 +87,10 @@ int QemuPipeStream::writeFully(const void *buf, size_t len)
 {
     //DBG(">> QemuPipeStream::writeFully %d\n", len);
     if (!valid()) return -1;
+    if (!buf) {
+        if (len>0) ERR("QemuPipeStream::writeFully failed, buf=NULL, len %d", len);
+        return 0;
+    }
 
     size_t res = len;
     int retval = 0;
diff --git a/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.cpp b/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
index 75da8f29f..f9c8521db 100644
--- a/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -24,6 +24,7 @@ static void tlsDestruct(void *ptr)
         EGLThreadInfo *ti = (EGLThreadInfo *)ptr;
         delete ti->hostConn;
         delete ti;
+        ((intptr_t *)__get_tls())[TLS_SLOT_OPENGL] = NULL;
     }
 }
 
diff --git a/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.h b/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.h
index 032873340..f59ce2ae4 100644
--- a/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.h
+++ b/tools/emulator/opengl/system/OpenglSystemCommon/ThreadInfo.h
@@ -40,10 +40,10 @@ EGLThreadInfo *slow_getEGLThreadInfo();
     // We have a dedicated TLS slot in bionic
     inline EGLThreadInfo* getEGLThreadInfo() {
         EGLThreadInfo *tInfo =
-             (EGLThreadInfo *)(((unsigned *)__get_tls())[TLS_SLOT_OPENGL]);
+             (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]);
         if (!tInfo) {
             tInfo = slow_getEGLThreadInfo();
-            ((uint32_t *)__get_tls())[TLS_SLOT_OPENGL] = (uint32_t)tInfo;
+            ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo;
         }
         return tInfo;
     }
diff --git a/tools/emulator/opengl/system/OpenglSystemCommon/gralloc_cb.h b/tools/emulator/opengl/system/OpenglSystemCommon/gralloc_cb.h
index a20740119..d2d6f3526 100644
--- a/tools/emulator/opengl/system/OpenglSystemCommon/gralloc_cb.h
+++ b/tools/emulator/opengl/system/OpenglSystemCommon/gralloc_cb.h
@@ -30,13 +30,14 @@
 struct cb_handle_t : public native_handle {
 
     cb_handle_t(int p_fd, int p_ashmemSize, int p_usage,
-                int p_width, int p_height, int p_format,
-                int p_glFormat, int p_glType) :
+                int p_width, int p_height, int p_frameworkFormat,
+                int p_format, int p_glFormat, int p_glType) :
         fd(p_fd),
         magic(BUFFER_HANDLE_MAGIC),
         usage(p_usage),
         width(p_width),
         height(p_height),
+        frameworkFormat(p_frameworkFormat),
         format(p_format),
         glFormat(p_glFormat),
         glType(p_glType),
@@ -70,8 +71,8 @@ struct cb_handle_t : public native_handle {
         numInts = CB_HANDLE_NUM_INTS(numFds);
     }
 
-    static bool validate(cb_handle_t * hnd) {
-        return (hnd && 
+    static bool validate(const cb_handle_t* hnd) {
+        return (hnd &&
                 hnd->version == sizeof(native_handle) &&
                 hnd->magic == BUFFER_HANDLE_MAGIC &&
                 hnd->numInts == CB_HANDLE_NUM_INTS(hnd->numFds));
@@ -89,12 +90,17 @@ struct cb_handle_t : public native_handle {
     int usage;              // usage bits the buffer was created with
     int width;              // buffer width
     int height;             // buffer height
+    int frameworkFormat;    // format requested by the Android framework
     int format;             // real internal pixel format format
     int glFormat;           // OpenGL format enum used for host h/w color buffer
     int glType;             // OpenGL type enum used when uploading to host
     int ashmemSize;         // ashmem region size for the buffer (0 unless is HW_FB buffer or
                             //                                    s/w access is needed)
-    int ashmemBase;         // CPU address of the mapped ashmem region
+    union {
+        intptr_t ashmemBase;    // CPU address of the mapped ashmem region
+        uint64_t padding;       // enforce same size on 32-bit/64-bit
+    } __attribute__((aligned(8)));
+
     int ashmemBasePid;      // process id which mapped the ashmem region
     int mappedPid;          // process id which succeeded gralloc_register call
     int lockedLeft;         // region of buffer locked for s/w write
diff --git a/tools/emulator/opengl/system/egl/egl.cpp b/tools/emulator/opengl/system/egl/egl.cpp
index da89c4dee..65ff39e5a 100644
--- a/tools/emulator/opengl/system/egl/egl.cpp
+++ b/tools/emulator/opengl/system/egl/egl.cpp
@@ -86,7 +86,7 @@ const char *  eglStrError(EGLint err)
 #endif //LOG_EGL_ERRORS
 
 #define VALIDATE_CONFIG(cfg,ret) \
-    if(((int)cfg<0)||((int)cfg>s_display.getNumConfigs())) { \
+    if(((intptr_t)cfg<0)||((intptr_t)cfg>s_display.getNumConfigs())) { \
         RETURN_ERROR(ret,EGL_BAD_CONFIG); \
     }
 
@@ -140,7 +140,9 @@ EGLContext_t::EGLContext_t(EGLDisplay dpy, EGLConfig config, EGLContext_t* share
     versionString(NULL),
     vendorString(NULL),
     rendererString(NULL),
-    extensionString(NULL)
+    shaderVersionString(NULL),
+    extensionString(NULL),
+    deletePending(0)
 {
     flags = 0;
     version = 1;
@@ -157,6 +159,7 @@ EGLContext_t::~EGLContext_t()
     delete [] versionString;
     delete [] vendorString;
     delete [] rendererString;
+    delete [] shaderVersionString;
     delete [] extensionString;
 }
 
@@ -268,7 +271,7 @@ EGLBoolean egl_window_surface_t::init()
     }
 
     DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
-    rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uint32_t)config,
+    rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config,
             getWidth(), getHeight());
     if (!rcSurface) {
         ALOGE("rcCreateWindowSurface returned 0");
@@ -371,7 +374,7 @@ EGLBoolean egl_pbuffer_surface_t::init(GLenum pixelFormat)
 {
     DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
 
-    rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uint32_t)config,
+    rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config,
             getWidth(), getHeight());
     if (!rcSurface) {
         ALOGE("rcCreateWindowSurface returned 0");
@@ -415,6 +418,7 @@ static const char *getGLString(int glEnum)
 #define GL_VENDOR                         0x1F00
 #define GL_RENDERER                       0x1F01
 #define GL_VERSION                        0x1F02
+#define GL_SHADING_LANGUAGE_VERSION       0x8B8C
 #define GL_EXTENSIONS                     0x1F03
 
     switch(glEnum) {
@@ -427,6 +431,9 @@ static const char *getGLString(int glEnum)
         case GL_RENDERER:
             strPtr = &tInfo->currentContext->rendererString;
             break;
+        case GL_SHADING_LANGUAGE_VERSION:
+            strPtr = &tInfo->currentContext->shaderVersionString;
+            break;
         case GL_EXTENSIONS:
             strPtr = &tInfo->currentContext->extensionString;
             break;
@@ -526,15 +533,6 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
         }
     }
 
-    //
-    // Make sure display is initialized before searching in client APIs
-    //
-    if (!s_display.initialized()) {
-        if (!s_display.initialize(&s_eglIface)) {
-            return NULL;
-        }
-    }
-
     // look in gles client api's extensions table
     return (__eglMustCastToProperFunctionPointerType)ClientAPIExts::getProcAddress(procname);
 
@@ -563,7 +561,7 @@ EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
         return EGL_TRUE;
     }
 
-    int i=0;
+    uintptr_t i=0;
     for (i=0 ; i<numConfigs && i<config_size ; i++) {
         *configs++ = (EGLConfig)i;
     }
@@ -585,9 +583,18 @@ EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig
         attribs_size++; //for the terminating EGL_NONE
     }
 
+    uint32_t* tempConfigs[config_size];
     DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
-    *num_config = rcEnc->rcChooseConfig(rcEnc, (EGLint*)attrib_list, attribs_size * sizeof(EGLint), (uint32_t*)configs, config_size);
+    *num_config = rcEnc->rcChooseConfig(rcEnc, (EGLint*)attrib_list, attribs_size * sizeof(EGLint), (uint32_t*)tempConfigs, config_size);
+    if (configs!=NULL) {
+        EGLint i=0;
+        for (i=0;i<(*num_config);i++) {
+             *((uintptr_t*)configs+i) = *((uint32_t*)tempConfigs+i);
+        }
+    }
 
+    if (*num_config <= 0)
+        return EGL_FALSE;
     return EGL_TRUE;
 }
 
@@ -873,7 +880,7 @@ EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_c
     }
 
     DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_NO_CONTEXT);
-    uint32_t rcContext = rcEnc->rcCreateContext(rcEnc, (uint32_t)config, rcShareCtx, version);
+    uint32_t rcContext = rcEnc->rcCreateContext(rcEnc, (uintptr_t)config, rcShareCtx, version);
     if (!rcContext) {
         ALOGE("rcCreateContext returned 0");
         setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
@@ -897,9 +904,11 @@ EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 
     EGLContext_t * context = static_cast<EGLContext_t*>(ctx);
 
-    if (getEGLThreadInfo()->currentContext == context)
-    {
-        eglMakeCurrent(dpy, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
+    if (!context) return EGL_TRUE;
+
+    if (getEGLThreadInfo()->currentContext == context) {
+        getEGLThreadInfo()->currentContext->deletePending = 1;
+        return EGL_TRUE;
     }
 
     if (context->rcContext) {
@@ -934,12 +943,21 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
     // Nothing to do if no binding change has made
     //
     EGLThreadInfo *tInfo = getEGLThreadInfo();
+
     if (tInfo->currentContext == context &&
         (context == NULL ||
         (context && context->draw == draw && context->read == read))) {
         return EGL_TRUE;
     }
 
+    if (tInfo->currentContext && tInfo->currentContext->deletePending) {
+        if (tInfo->currentContext != context) {
+            EGLContext_t * contextToDelete = tInfo->currentContext;
+            tInfo->currentContext = 0;
+            eglDestroyContext(dpy, contextToDelete);
+        }
+    }
+
     if (context && (context->flags & EGLContext_t::IS_CURRENT) && (context != tInfo->currentContext)) {
         //context is current to another thread
         setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE);
@@ -966,7 +984,7 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
             hostCon->glEncoder()->setSharedGroup(context->getSharedGroup());
         }
     } 
-    else {
+    else if (tInfo->currentContext) {
         //release ClientState & SharedGroup
         if (tInfo->currentContext->version == 2) {
             hostCon->gl2Encoder()->setClientState(NULL);
diff --git a/tools/emulator/opengl/system/egl/eglContext.h b/tools/emulator/opengl/system/egl/eglContext.h
index 2ca6d0c21..5b6a428e8 100644
--- a/tools/emulator/opengl/system/egl/eglContext.h
+++ b/tools/emulator/opengl/system/egl/eglContext.h
@@ -39,8 +39,9 @@ struct EGLContext_t {
     const char*         versionString;
     const char*         vendorString;
     const char*         rendererString;
+    const char*         shaderVersionString;
     const char*         extensionString;
-
+    EGLint              deletePending;
     GLClientState * getClientState(){ return clientState; }
     GLSharedGroupPtr getSharedGroup(){ return sharedGroup; }
 private:
diff --git a/tools/emulator/opengl/system/egl/eglDisplay.cpp b/tools/emulator/opengl/system/egl/eglDisplay.cpp
index bcb0d4bbe..96540aa1e 100644
--- a/tools/emulator/opengl/system/egl/eglDisplay.cpp
+++ b/tools/emulator/opengl/system/egl/eglDisplay.cpp
@@ -84,9 +84,15 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
         //
         // load GLES client API
         //
+#if __LP64__
+        m_gles_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv1_CM_emulation.so",
+                                         eglIface,
+                                         &s_gles_lib);
+#else
         m_gles_iface = loadGLESClientAPI("/system/lib/egl/libGLESv1_CM_emulation.so",
                                          eglIface,
                                          &s_gles_lib);
+#endif
         if (!m_gles_iface) {
             pthread_mutex_unlock(&m_lock);
             ALOGE("Failed to load gles1 iface");
@@ -94,9 +100,15 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
         }
 
 #ifdef WITH_GLES2
+#if __LP64__
+        m_gles2_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv2_emulation.so",
+                                          eglIface,
+                                          &s_gles2_lib);
+#else
         m_gles2_iface = loadGLESClientAPI("/system/lib/egl/libGLESv2_emulation.so",
                                           eglIface,
                                           &s_gles2_lib);
+#endif
         // Note that if loading gles2 failed, we can still run with no
         // GLES2 support, having GLES2 is not mandatory.
 #endif
@@ -189,7 +201,7 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
 
 void eglDisplay::processConfigs()
 {
-    for (int i=0; i<m_numConfigs; i++) {
+    for (intptr_t i=0; i<m_numConfigs; i++) {
         EGLConfig config = (EGLConfig)i;
         //Setup the EGL_NATIVE_VISUAL_ID attribute
         PixelFormat format;
@@ -401,7 +413,7 @@ EGLBoolean eglDisplay::getAttribValue(EGLConfig config, EGLint attribIdx, EGLint
         ALOGE("[%s] Bad attribute idx\n", __FUNCTION__);
         return EGL_FALSE;
     }
-    *value = *(m_configs + (int)config*m_numConfigAttribs + attribIdx);
+    *value = *(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx);
     return EGL_TRUE;
 }
 
@@ -434,7 +446,7 @@ EGLBoolean eglDisplay::setAttribValue(EGLConfig config, EGLint attribIdx, EGLint
         ALOGE("[%s] Bad attribute idx\n", __FUNCTION__);
         return EGL_FALSE;
     }
-    *(m_configs + (int)config*m_numConfigAttribs + attribIdx) = value;
+    *(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx) = value;
     return EGL_TRUE;
 }
 
diff --git a/tools/emulator/opengl/system/gralloc/gralloc.cpp b/tools/emulator/opengl/system/gralloc/gralloc.cpp
index ac20d492e..a7b1d6006 100644
--- a/tools/emulator/opengl/system/gralloc/gralloc.cpp
+++ b/tools/emulator/opengl/system/gralloc/gralloc.cpp
@@ -15,11 +15,7 @@
 */
 #include <string.h>
 #include <pthread.h>
-#ifdef HAVE_ANDROID_OS      // just want PAGE_SIZE define
-# include <asm/page.h>
-#else
-# include <sys/user.h>
-#endif
+#include <limits.h>
 #include <cutils/ashmem.h>
 #include <unistd.h>
 #include <errno.h>
@@ -154,6 +150,8 @@ static int gralloc_alloc(alloc_device_t* dev,
     bool hw_cam_read = usage & GRALLOC_USAGE_HW_CAMERA_READ;
     bool hw_vid_enc_read = usage & GRALLOC_USAGE_HW_VIDEO_ENCODER;
 
+    // Keep around original requested format for later validation
+    int frameworkFormat = format;
     // Pick the right concrete pixel format given the endpoints as encoded in
     // the usage bits.  Every end-point pair needs explicit listing here.
     if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
@@ -179,7 +177,6 @@ static int gralloc_alloc(alloc_device_t* dev,
             return -EINVAL;
         }
     }
-
     bool yuv_format = false;
 
     int ashmem_size = 0;
@@ -297,7 +294,8 @@ static int gralloc_alloc(alloc_device_t* dev,
     }
 
     cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage,
-                                      w, h, format, glFormat, glType);
+                                      w, h, frameworkFormat, format,
+                                      glFormat, glType);
 
     if (ashmem_size > 0) {
         //
@@ -444,7 +442,7 @@ static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
     DEFINE_AND_VALIDATE_HOST_CONNECTION;
 
     // increment the post count of the buffer
-    uint32_t *postCountPtr = (uint32_t *)cb->ashmemBase;
+    intptr_t *postCountPtr = (intptr_t *)cb->ashmemBase;
     if (!postCountPtr) {
         // This should not happen
         return -EINVAL;
@@ -529,7 +527,7 @@ static int gralloc_register_buffer(gralloc_module_t const* module,
     if (cb->hostHandle != 0) {
         DEFINE_AND_VALIDATE_HOST_CONNECTION;
         D("Opening host ColorBuffer 0x%x\n", cb->hostHandle);
-        rcEnc->rcOpenColorBuffer(rcEnc, cb->hostHandle);
+        rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
     }
 
     //
@@ -580,7 +578,7 @@ static int gralloc_unregister_buffer(gralloc_module_t const* module,
             ERR("gralloc_unregister_buffer(%p): unmap failed", cb);
             return -EINVAL;
         }
-        cb->ashmemBase = NULL;
+        cb->ashmemBase = 0;
         cb->mappedPid = 0;
     }
 
@@ -630,7 +628,7 @@ static int gralloc_lock(gralloc_module_t const* module,
         return -EINVAL;
     }
 
-    EGLint postCount = 0;
+    intptr_t postCount = 0;
     void *cpu_addr = NULL;
 
     //
@@ -644,8 +642,8 @@ static int gralloc_lock(gralloc_module_t const* module,
         }
 
         if (cb->canBePosted()) {
-            postCount = *((int *)cb->ashmemBase);
-            cpu_addr = (void *)(cb->ashmemBase + sizeof(int));
+            postCount = *((intptr_t *)cb->ashmemBase);
+            cpu_addr = (void *)(cb->ashmemBase + sizeof(intptr_t));
         }
         else {
             cpu_addr = (void *)(cb->ashmemBase);
@@ -916,7 +914,11 @@ fallback_init(void)
         return;
     }
     ALOGD("Emulator without GPU emulation detected.");
+#if __LP64__
+    module = dlopen("/system/lib64/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL);
+#else
     module = dlopen("/system/lib/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL);
+#endif
     if (module != NULL) {
         sFallback = reinterpret_cast<gralloc_module_t*>(dlsym(module, HAL_MODULE_INFO_SYM_AS_STR));
         if (sFallback == NULL) {
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.cpp b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.cpp
index 948824847..a4bdb251f 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.cpp
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.cpp
@@ -37,6 +37,7 @@ int renderControl_client_context_t::initDispatchByName(void *(*getProc)(const ch
 	ptr = getProc("rcColorBufferCacheFlush", userData); set_rcColorBufferCacheFlush((rcColorBufferCacheFlush_client_proc_t)ptr);
 	ptr = getProc("rcReadColorBuffer", userData); set_rcReadColorBuffer((rcReadColorBuffer_client_proc_t)ptr);
 	ptr = getProc("rcUpdateColorBuffer", userData); set_rcUpdateColorBuffer((rcUpdateColorBuffer_client_proc_t)ptr);
+	ptr = getProc("rcOpenColorBuffer2", userData); set_rcOpenColorBuffer2((rcOpenColorBuffer2_client_proc_t)ptr);
 	return 0;
 }
 
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.h b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.h
index ed2b1fbf4..46a007f6e 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.h
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_context.h
@@ -33,6 +33,7 @@ struct renderControl_client_context_t {
 	rcColorBufferCacheFlush_client_proc_t rcColorBufferCacheFlush;
 	rcReadColorBuffer_client_proc_t rcReadColorBuffer;
 	rcUpdateColorBuffer_client_proc_t rcUpdateColorBuffer;
+	rcOpenColorBuffer2_client_proc_t rcOpenColorBuffer2;
 	//Accessors 
 	virtual rcGetRendererVersion_client_proc_t set_rcGetRendererVersion(rcGetRendererVersion_client_proc_t f) { rcGetRendererVersion_client_proc_t retval = rcGetRendererVersion; rcGetRendererVersion = f; return retval;}
 	virtual rcGetEGLVersion_client_proc_t set_rcGetEGLVersion(rcGetEGLVersion_client_proc_t f) { rcGetEGLVersion_client_proc_t retval = rcGetEGLVersion; rcGetEGLVersion = f; return retval;}
@@ -59,6 +60,7 @@ struct renderControl_client_context_t {
 	virtual rcColorBufferCacheFlush_client_proc_t set_rcColorBufferCacheFlush(rcColorBufferCacheFlush_client_proc_t f) { rcColorBufferCacheFlush_client_proc_t retval = rcColorBufferCacheFlush; rcColorBufferCacheFlush = f; return retval;}
 	virtual rcReadColorBuffer_client_proc_t set_rcReadColorBuffer(rcReadColorBuffer_client_proc_t f) { rcReadColorBuffer_client_proc_t retval = rcReadColorBuffer; rcReadColorBuffer = f; return retval;}
 	virtual rcUpdateColorBuffer_client_proc_t set_rcUpdateColorBuffer(rcUpdateColorBuffer_client_proc_t f) { rcUpdateColorBuffer_client_proc_t retval = rcUpdateColorBuffer; rcUpdateColorBuffer = f; return retval;}
+	virtual rcOpenColorBuffer2_client_proc_t set_rcOpenColorBuffer2(rcOpenColorBuffer2_client_proc_t f) { rcOpenColorBuffer2_client_proc_t retval = rcOpenColorBuffer2; rcOpenColorBuffer2 = f; return retval;}
 	 virtual ~renderControl_client_context_t() {}
 
 	typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_proc.h b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_proc.h
index 3e00290b9..85200cf1e 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_client_proc.h
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_client_proc.h
@@ -34,6 +34,7 @@ typedef void (renderControl_APIENTRY *rcBindRenderbuffer_client_proc_t) (void *
 typedef EGLint (renderControl_APIENTRY *rcColorBufferCacheFlush_client_proc_t) (void * ctx, uint32_t, EGLint, int);
 typedef void (renderControl_APIENTRY *rcReadColorBuffer_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*);
 typedef int (renderControl_APIENTRY *rcUpdateColorBuffer_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*);
+typedef int (renderControl_APIENTRY *rcOpenColorBuffer2_client_proc_t) (void * ctx, uint32_t);
 
 
 #endif
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.cpp b/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.cpp
index 94e256ad3..a40a501ac 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.cpp
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.cpp
@@ -311,6 +311,8 @@ void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
 
 		memcpy(ptr, &colorbuffer, 4); ptr += 4;
+
+	stream->flush();
 }
 
 void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer)
@@ -503,6 +505,25 @@ int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y,
 	return retval;
 }
 
+int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
+{
+
+	renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+	IOStream *stream = ctx->m_stream;
+
+	 unsigned char *ptr;
+	 const size_t packetSize = 8 + 4;
+	ptr = stream->alloc(packetSize);
+	int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
+	memcpy(ptr, &packetSize, 4);  ptr += 4;
+
+		memcpy(ptr, &colorbuffer, 4); ptr += 4;
+
+	int retval;
+	stream->readback(&retval, 4);
+	return retval;
+}
+
 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream)
 {
 	m_stream = stream;
@@ -532,5 +553,6 @@ renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *strea
 	set_rcColorBufferCacheFlush(rcColorBufferCacheFlush_enc);
 	set_rcReadColorBuffer(rcReadColorBuffer_enc);
 	set_rcUpdateColorBuffer(rcUpdateColorBuffer_enc);
+	set_rcOpenColorBuffer2(rcOpenColorBuffer2_enc);
 }
 
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.h b/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.h
index 712eeb9d3..92ef76e5f 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.h
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_enc.h
@@ -47,5 +47,6 @@ extern "C" {
 	EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead);
 	void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
 	int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
+	int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer);
 };
 #endif
\ No newline at end of file
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_entry.cpp b/tools/emulator/opengl/system/renderControl_enc/renderControl_entry.cpp
index 9a0bba99c..a15fd1446 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_entry.cpp
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_entry.cpp
@@ -31,6 +31,7 @@ extern "C" {
 	EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead);
 	void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
 	int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
+	int rcOpenColorBuffer2(uint32_t colorbuffer);
 };
 
 #endif
@@ -190,3 +191,9 @@ int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLi
 	 return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
 }
 
+int rcOpenColorBuffer2(uint32_t colorbuffer)
+{
+	GET_CONTEXT; 
+	 return ctx->rcOpenColorBuffer2(ctx, colorbuffer);
+}
+
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_ftable.h b/tools/emulator/opengl/system/renderControl_enc/renderControl_ftable.h
index 1e9e2f937..a43fe5bc7 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_ftable.h
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_ftable.h
@@ -33,6 +33,7 @@ static struct _renderControl_funcs_by_name {
 	{"rcColorBufferCacheFlush", (void*)rcColorBufferCacheFlush},
 	{"rcReadColorBuffer", (void*)rcReadColorBuffer},
 	{"rcUpdateColorBuffer", (void*)rcUpdateColorBuffer},
+	{"rcOpenColorBuffer2", (void*)rcOpenColorBuffer2},
 };
 static int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
 
diff --git a/tools/emulator/opengl/system/renderControl_enc/renderControl_opcodes.h b/tools/emulator/opengl/system/renderControl_enc/renderControl_opcodes.h
index b44f5d06a..a00dc7775 100644
--- a/tools/emulator/opengl/system/renderControl_enc/renderControl_opcodes.h
+++ b/tools/emulator/opengl/system/renderControl_enc/renderControl_opcodes.h
@@ -28,7 +28,8 @@
 #define OP_rcColorBufferCacheFlush 					10022
 #define OP_rcReadColorBuffer 					10023
 #define OP_rcUpdateColorBuffer 					10024
-#define OP_last 					10025
+#define OP_rcOpenColorBuffer2 					10025
+#define OP_last 					10026
 
 
 #endif