]> git.cworth.org Git - apitrace/blobdiff - glstate.cpp
Split gl shader dumping into a separate file.
[apitrace] / glstate.cpp
index 2fa4cb5577e08879d9b333379c6b537aec1aa5bf..614b069eb59e7c244e19439b65a5ad91263adfc0 100644 (file)
 
 
 #include <string.h>
-#include <iostream>
+
 #include <algorithm>
+#include <iostream>
 
 #include "image.hpp"
 #include "json.hpp"
 #include "glproc.hpp"
 #include "glsize.hpp"
 #include "glstate.hpp"
+#include "glstate_internal.hpp"
 
 
 #ifdef __APPLE__
 extern "C" {
 #endif
 
-typedef int CGSConnectionID;
-typedef int CGSWindowID;
-typedef int CGSSurfaceID;
-
-CGLError CGLGetSurface(CGLContextObj, CGSConnectionID*, CGSWindowID*, CGSSurfaceID*);
 OSStatus CGSGetSurfaceBounds(CGSConnectionID, CGWindowID, CGSSurfaceID, CGRect *);
 
 #ifdef __cplusplus
@@ -57,165 +54,74 @@ OSStatus CGSGetSurfaceBounds(CGSConnectionID, CGWindowID, CGSSurfaceID, CGRect *
 #endif /* __APPLE__ */
 
 
-namespace glstate {
-
-
-static void
-dumpShader(JSONWriter &json, GLuint shader)
-{
-    if (!shader) {
-        return;
-    }
-
-    GLint shader_type = 0;
-    glGetShaderiv(shader, GL_SHADER_TYPE, &shader_type);
-    if (!shader_type) {
-        return;
-    }
-
-    GLint source_length = 0;
-    glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &source_length);
-    if (!source_length) {
-        return;
-    }
-
-    GLchar *source = new GLchar[source_length];
-    GLsizei length = 0;
-    source[0] = 0;
-    glGetShaderSource(shader, source_length, &length, source);
-
-    json.beginMember(enumToString(shader_type));
-    json.writeString(source);
-    json.endMember();
-
-    delete [] source;
-}
-
+/* Change thi to one to force interpreting depth buffers as RGBA, which enables
+ * visualizing full dynamic range, until we can transmit HDR images to the GUI */
+#define DEPTH_AS_RGBA 0
 
-static void
-dumpShaderObj(JSONWriter &json, GLhandleARB shaderObj)
-{
-    if (!shaderObj) {
-        return;
-    }
 
-    GLint shader_type = 0;
-    glGetObjectParameterivARB(shaderObj, GL_OBJECT_TYPE_ARB, &shader_type);
-    if (!shader_type) {
-        return;
-    }
-
-    GLint source_length = 0;
-    glGetObjectParameterivARB(shaderObj, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &source_length);
-    if (!source_length) {
-        return;
-    }
-
-    GLcharARB *source = new GLcharARB[source_length];
-    GLsizei length = 0;
-    source[0] = 0;
-    glGetShaderSource(shaderObj, source_length, &length, source);
-
-    json.beginMember(enumToString(shader_type));
-    json.writeString(source);
-    json.endMember();
-
-    delete [] source;
-}
+namespace glstate {
 
 
-static inline void
-dumpCurrentProgram(JSONWriter &json)
-{
-    GLint program = 0;
-    glGetIntegerv(GL_CURRENT_PROGRAM, &program);
-    if (!program) {
-        return;
+Context::Context(void) {
+    memset(this, 0, sizeof *this);
+
+    const char *version = (const char *)glGetString(GL_VERSION);
+    if (version) {
+        if (version[0] == 'O' &&
+            version[1] == 'p' &&
+            version[2] == 'e' &&
+            version[3] == 'n' &&
+            version[4] == 'G' &&
+            version[5] == 'L' &&
+            version[6] == ' ' &&
+            version[7] == 'E' &&
+            version[8] == 'S' &&
+            version[9] == ' ') {
+            ES = true;
+        }
     }
 
-    GLint attached_shaders = 0;
-    glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
-    if (!attached_shaders) {
-        return;
-    }
+    ARB_draw_buffers = !ES;
 
-    GLuint *shaders = new GLuint[attached_shaders];
-    GLsizei count = 0;
-    glGetAttachedShaders(program, attached_shaders, &count, shaders);
-    for (GLsizei i = 0; i < count; ++ i) {
-       dumpShader(json, shaders[i]);
-    }
-    delete [] shaders;
+    // TODO: Check extensions we use below
 }
 
-
-static inline void
-dumpCurrentProgramObj(JSONWriter &json)
-{
-    GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
-    if (!programObj) {
-        return;
-    }
-
-    GLint attached_shaders = 0;
-    glGetProgramivARB(programObj, GL_OBJECT_ATTACHED_OBJECTS_ARB, &attached_shaders);
-    if (!attached_shaders) {
-        return;
-    }
-
-    GLhandleARB *shaderObjs = new GLhandleARB[attached_shaders];
-    GLsizei count = 0;
-    glGetAttachedObjectsARB(programObj, attached_shaders, &count, shaderObjs);
-    for (GLsizei i = 0; i < count; ++ i) {
-       dumpShaderObj(json, shaderObjs[i]);
+void
+Context::resetPixelPackState(void) {
+    if (!ES) {
+        glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+        glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+        glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
+        glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+        glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
+        glPixelStorei(GL_PACK_SKIP_ROWS, 0);
+        glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+        glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
+    } else {
+        packAlignment = 4;
+        glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment);
     }
-    delete [] shaderObjs;
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
 }
 
-
-static inline void
-dumpArbProgram(JSONWriter &json, GLenum target)
-{
-    if (!glIsEnabled(target)) {
-        return;
-    }
-
-    GLint program_length = 0;
-    glGetProgramivARB(target, GL_PROGRAM_LENGTH_ARB, &program_length);
-    if (!program_length) {
-        return;
+void
+Context::restorePixelPackState(void) {
+    if (!ES) {
+        glPopClientAttrib();
+    } else {
+        glPixelStorei(GL_PACK_ALIGNMENT, packAlignment);
     }
-
-    GLchar *source = new GLchar[program_length + 1];
-    source[0] = 0;
-    glGetProgramStringARB(target, GL_PROGRAM_STRING_ARB, source);
-    source[program_length] = 0;
-
-    json.beginMember(enumToString(target));
-    json.writeString(source);
-    json.endMember();
-
-    delete [] source;
-}
-
-
-static inline void
-dumpShaders(JSONWriter &json)
-{
-    json.beginMember("shaders");
-    json.beginObject();
-    dumpCurrentProgram(json);
-    dumpArbProgram(json, GL_FRAGMENT_PROGRAM_ARB);
-    dumpArbProgram(json, GL_VERTEX_PROGRAM_ARB);
-    json.endObject();
-    json.endMember(); //shaders
 }
 
 
 static inline void
-dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
+dumpTextureImage(JSONWriter &json, Context &context, GLenum target, GLint level)
 {
     GLint width, height = 1, depth = 1;
+    GLint format;
+
+    glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &format);
 
     width = 0;
     glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
@@ -236,7 +142,8 @@ dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
 
         GLint active_texture = GL_TEXTURE0;
         glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
-        snprintf(label, sizeof label, "%s, %s, level = %i", enumToString(active_texture), enumToString(target), level);
+        snprintf(label, sizeof label, "%s, %s, level = %d",
+                 enumToString(active_texture), enumToString(target), level);
 
         json.beginMember(label);
 
@@ -249,6 +156,8 @@ dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
         json.writeNumberMember("__height__", height);
         json.writeNumberMember("__depth__", depth);
 
+        json.writeStringMember("__format__", enumToString(format));
+
         // Hardcoded for now, but we could chose types more adequate to the
         // texture internal format
         json.writeStringMember("__type__", "uint8");
@@ -257,12 +166,16 @@ dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
 
         GLubyte *pixels = new GLubyte[depth*width*height*4];
 
+        context.resetPixelPackState();
+
         glGetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
+        context.restorePixelPackState();
+
         json.beginMember("__data__");
         char *pngBuffer;
         int pngBufferSize;
-        Image::writePixelsToBuffer(pixels, width, height, 4, false, &pngBuffer, &pngBufferSize);
+        image::writePixelsToBuffer(pixels, width, height, 4, true, &pngBuffer, &pngBufferSize);
         json.writeBase64(pngBuffer, pngBufferSize);
         free(pngBuffer);
         json.endMember(); // __data__
@@ -274,7 +187,7 @@ dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
 
 
 static inline void
-dumpTexture(JSONWriter &json, GLenum target, GLenum binding)
+dumpTexture(JSONWriter &json, Context &context, GLenum target, GLenum binding)
 {
     GLint texture_binding = 0;
     glGetIntegerv(binding, &texture_binding);
@@ -293,10 +206,10 @@ dumpTexture(JSONWriter &json, GLenum target, GLenum binding)
 
         if (target == GL_TEXTURE_CUBE_MAP) {
             for (int face = 0; face < 6; ++face) {
-                dumpTextureImage(json, GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level);
+                dumpTextureImage(json, context, GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level);
             }
         } else {
-            dumpTextureImage(json, target, level);
+            dumpTextureImage(json, context, target, level);
         }
 
         ++level;
@@ -305,7 +218,7 @@ dumpTexture(JSONWriter &json, GLenum target, GLenum binding)
 
 
 static inline void
-dumpTextures(JSONWriter &json)
+dumpTextures(JSONWriter &json, Context &context)
 {
     json.beginMember("textures");
     json.beginObject();
@@ -319,11 +232,11 @@ dumpTextures(JSONWriter &json)
     for (GLint unit = 0; unit < max_units; ++unit) {
         GLenum texture = GL_TEXTURE0 + unit;
         glActiveTexture(texture);
-        dumpTexture(json, GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D);
-        dumpTexture(json, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D);
-        dumpTexture(json, GL_TEXTURE_3D, GL_TEXTURE_BINDING_3D);
-        dumpTexture(json, GL_TEXTURE_RECTANGLE, GL_TEXTURE_BINDING_RECTANGLE);
-        dumpTexture(json, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP);
+        dumpTexture(json, context, GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D);
+        dumpTexture(json, context, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D);
+        dumpTexture(json, context, GL_TEXTURE_3D, GL_TEXTURE_BINDING_3D);
+        dumpTexture(json, context, GL_TEXTURE_RECTANGLE, GL_TEXTURE_BINDING_RECTANGLE);
+        dumpTexture(json, context, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP);
     }
     glActiveTexture(active_texture);
     json.endObject();
@@ -333,7 +246,31 @@ dumpTextures(JSONWriter &json)
 
 static bool
 getDrawableBounds(GLint *width, GLint *height) {
-#if defined(_WIN32)
+#if defined(TRACE_EGL)
+
+    EGLContext currentContext = eglGetCurrentContext();
+    if (currentContext == EGL_NO_CONTEXT) {
+        return false;
+    }
+
+    EGLSurface currentSurface = eglGetCurrentSurface(EGL_DRAW);
+    if (currentSurface == EGL_NO_SURFACE) {
+        return false;
+    }
+
+    EGLDisplay currentDisplay = eglGetCurrentDisplay();
+    if (currentDisplay == EGL_NO_DISPLAY) {
+        return false;
+    }
+
+    if (!eglQuerySurface(currentDisplay, currentSurface, EGL_WIDTH, width) ||
+        !eglQuerySurface(currentDisplay, currentSurface, EGL_HEIGHT, height)) {
+        return false;
+    }
+
+    return true;
+
+#elif defined(_WIN32)
 
     HDC hDC = wglGetCurrentDC();
     if (!hDC) {
@@ -349,6 +286,7 @@ getDrawableBounds(GLint *width, GLint *height) {
 
     *width  = rect.right  - rect.left;
     *height = rect.bottom - rect.top;
+    return true;
 
 #elif defined(__APPLE__)
 
@@ -373,8 +311,9 @@ getDrawableBounds(GLint *width, GLint *height) {
 
     *width = rect.size.width;
     *height = rect.size.height;
+    return true;
 
-#else
+#elif defined(HAVE_X11)
 
     Display *display;
     Drawable drawable;
@@ -398,118 +337,356 @@ getDrawableBounds(GLint *width, GLint *height) {
 
     *width = w;
     *height = h;
+    return true;
+
+#else
+
+    return false;
 
 #endif
+}
 
-    return true;
+
+static const GLenum texture_bindings[][2] = {
+    {GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D},
+    {GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D},
+    {GL_TEXTURE_3D, GL_TEXTURE_BINDING_3D},
+    {GL_TEXTURE_RECTANGLE, GL_TEXTURE_BINDING_RECTANGLE},
+    {GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP}
+};
+
+
+static bool
+bindTexture(GLint texture, GLenum &target, GLint &bound_texture)
+{
+
+    for (unsigned i = 0; i < sizeof(texture_bindings)/sizeof(texture_bindings[0]); ++i) {
+        target  = texture_bindings[i][0];
+
+        GLenum binding = texture_bindings[i][1];
+
+        while (glGetError() != GL_NO_ERROR)
+            ;
+
+        glGetIntegerv(binding, &bound_texture);
+        glBindTexture(target, texture);
+
+        if (glGetError() == GL_NO_ERROR) {
+            return true;
+        }
+
+        glBindTexture(target, bound_texture);
+    }
+
+    target = GL_NONE;
+
+    return false;
 }
 
 
-Image::Image *
-getDrawBufferImage(GLenum format) {
-    GLint width, height;
+static bool
+getTextureLevelSize(GLint texture, GLint level, GLint *width, GLint *height)
+{
+    *width = 0;
+    *height = 0;
 
-    if (format != GL_RGBA) {
-        // FIXME: this function can only handle 4-channel images
-        return NULL;
+    GLenum target;
+    GLint bound_texture = 0;
+    if (!bindTexture(texture, target, bound_texture)) {
+        return false;
     }
 
-    if (!getDrawableBounds(&width, &height)) {
+    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, width);
+    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, height);
+
+    glBindTexture(target, bound_texture);
+
+    return *width > 0 && *height > 0;
+}
+
+
+static GLenum
+getTextureLevelFormat(GLint texture, GLint level)
+{
+    GLenum target;
+    GLint bound_texture = 0;
+    if (!bindTexture(texture, target, bound_texture)) {
+        return GL_NONE;
+    }
+
+    GLint format = GL_NONE;
+    glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &format);
+
+    glBindTexture(target, bound_texture);
+
+    return format;
+}
+
+
+
+static bool
+getRenderbufferSize(GLint renderbuffer, GLint *width, GLint *height)
+{
+    GLint bound_renderbuffer = 0;
+    glGetIntegerv(GL_RENDERBUFFER_BINDING, &bound_renderbuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
+
+    *width = 0;
+    *height = 0;
+    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, width);
+    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, height);
+
+    glBindRenderbuffer(GL_RENDERBUFFER, bound_renderbuffer);
+    
+    return *width > 0 && *height > 0;
+}
+
+
+static GLenum
+getRenderbufferFormat(GLint renderbuffer)
+{
+    GLint bound_renderbuffer = 0;
+    glGetIntegerv(GL_RENDERBUFFER_BINDING, &bound_renderbuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
+
+    GLint format = GL_NONE;
+    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
+
+    glBindRenderbuffer(GL_RENDERBUFFER, bound_renderbuffer);
+    
+    return format;
+}
+
+
+static bool
+getFramebufferAttachmentSize(GLenum target, GLenum attachment, GLint *width, GLint *height)
+{
+    GLint object_type = GL_NONE;
+    glGetFramebufferAttachmentParameteriv(target, attachment,
+                                          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
+                                          &object_type);
+    if (object_type == GL_NONE) {
+        return false;
+    }
+
+    GLint object_name = 0;
+    glGetFramebufferAttachmentParameteriv(target, attachment,
+                                          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
+                                          &object_name);
+    if (object_name == 0) {
+        return false;
+    }
+
+    if (object_type == GL_RENDERBUFFER) {
+        return getRenderbufferSize(object_name, width, height);
+    } else if (object_type == GL_TEXTURE) {
+        GLint texture_level = 0;
+        glGetFramebufferAttachmentParameteriv(target, attachment,
+                                              GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
+                                              &texture_level);
+        return getTextureLevelSize(object_name, texture_level, width, height);
+    } else {
+        std::cerr << "warning: unexpected GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = " << object_type << "\n";
+        return false;
+    }
+}
+
+
+
+static GLint
+getFramebufferAttachmentFormat(GLenum target, GLenum attachment)
+{
+    GLint object_type = GL_NONE;
+    glGetFramebufferAttachmentParameteriv(target, attachment,
+                                          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
+                                          &object_type);
+    if (object_type == GL_NONE) {
+        return GL_NONE;
+    }
+
+    GLint object_name = 0;
+    glGetFramebufferAttachmentParameteriv(target, attachment,
+                                          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
+                                          &object_name);
+    if (object_name == 0) {
+        return GL_NONE;
+    }
+
+    if (object_type == GL_RENDERBUFFER) {
+        return getRenderbufferFormat(object_name);
+    } else if (object_type == GL_TEXTURE) {
+        GLint texture_level = 0;
+        glGetFramebufferAttachmentParameteriv(target, attachment,
+                                              GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
+                                              &texture_level);
+        return getTextureLevelFormat(object_name, texture_level);
+    } else {
+        std::cerr << "warning: unexpected GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = " << object_type << "\n";
+        return GL_NONE;
+    }
+}
+
+
+
+image::Image *
+getDrawBufferImage() {
+    GLenum format = GL_RGB;
+    GLint channels = __gl_format_channels(format);
+    if (channels > 4) {
         return NULL;
     }
 
-    Image::Image *image = new Image::Image(width, height, true);
+    Context context;
+
+    GLenum framebuffer_binding;
+    GLenum framebuffer_target;
+    if (context.ES) {
+        framebuffer_binding = GL_FRAMEBUFFER_BINDING;
+        framebuffer_target = GL_FRAMEBUFFER;
+    } else {
+        framebuffer_binding = GL_DRAW_FRAMEBUFFER_BINDING;
+        framebuffer_target = GL_DRAW_FRAMEBUFFER;
+    }
+
+    GLint draw_framebuffer = 0;
+    glGetIntegerv(framebuffer_binding, &draw_framebuffer);
+
+    GLint draw_buffer = GL_NONE;
+    GLint width, height;
+    if (draw_framebuffer) {
+        if (context.ARB_draw_buffers) {
+            glGetIntegerv(GL_DRAW_BUFFER0, &draw_buffer);
+            if (draw_buffer == GL_NONE) {
+                return NULL;
+            }
+        }
+
+        if (!getFramebufferAttachmentSize(framebuffer_target, draw_buffer, &width, &height)) {
+            return NULL;
+        }
+    } else {
+        if (!context.ES) {
+            glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
+            if (draw_buffer == GL_NONE) {
+                return NULL;
+            }
+        }
+
+        if (!getDrawableBounds(&width, &height)) {
+            return NULL;
+        }
+    }
+
+    GLenum type = GL_UNSIGNED_BYTE;
+
+#if DEPTH_AS_RGBA
+    if (format == GL_DEPTH_COMPONENT) {
+        type = GL_UNSIGNED_INT;
+        channels = 4;
+    }
+#endif
+
+    image::Image *image = new image::Image(width, height, channels, true);
     if (!image) {
         return NULL;
     }
 
-    GLint drawbuffer = GL_NONE;
-    GLint readbuffer = GL_NONE;
-    glGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);
-    glGetIntegerv(GL_READ_BUFFER, &readbuffer);
-    glReadBuffer(drawbuffer);
+    while (glGetError() != GL_NO_ERROR) {}
 
-    glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
-    glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
-    glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
-    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-    glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
-    glPixelStorei(GL_PACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    GLint read_framebuffer = 0;
+    GLint read_buffer = GL_NONE;
+    if (!context.ES) {
+        glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_framebuffer);
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, draw_framebuffer);
 
-    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
+        glGetIntegerv(GL_READ_BUFFER, &read_buffer);
+        glReadBuffer(draw_buffer);
+    }
+
+    // TODO: reset imaging state too
+    context.resetPixelPackState();
+
+    glReadPixels(0, 0, width, height, format, type, image->pixels);
 
-    glPopClientAttrib();
+    context.restorePixelPackState();
 
-    glReadBuffer(readbuffer);
+    if (!context.ES) {
+        glReadBuffer(read_buffer);
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer);
+    }
 
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR) {
+        do {
+            std::cerr << "warning: " << enumToString(error) << " while getting snapshot\n";
+            error = glGetError();
+        } while(error != GL_NO_ERROR);
+        delete image;
+        return NULL;
+    }
+     
     return image;
 }
 
 
+/**
+ * Dump the image of the currently bound read buffer.
+ */
 static inline void
-dumpDrawBufferImage(JSONWriter &json, GLenum format)
+dumpReadBufferImage(JSONWriter &json, GLint width, GLint height, GLenum format,
+                    GLint internalFormat = GL_NONE)
 {
     GLint channels = __gl_format_channels(format);
 
-    GLint width, height;
+    Context context;
 
-    if (!getDrawableBounds(&width, &height)) {
-        json.writeNull();
-    } else {
-        json.beginObject();
+    json.beginObject();
 
-        // Tell the GUI this is no ordinary object, but an image
-        json.writeStringMember("__class__", "image");
+    // Tell the GUI this is no ordinary object, but an image
+    json.writeStringMember("__class__", "image");
 
-        json.writeNumberMember("__width__", width);
-        json.writeNumberMember("__height__", height);
-        json.writeNumberMember("__depth__", 1);
+    json.writeNumberMember("__width__", width);
+    json.writeNumberMember("__height__", height);
+    json.writeNumberMember("__depth__", 1);
 
-        // Hardcoded for now, but we could chose types more adequate to the
-        // texture internal format
-        json.writeStringMember("__type__", "uint8");
-        json.writeBoolMember("__normalized__", true);
-        json.writeNumberMember("__channels__", channels);
+    json.writeStringMember("__format__", enumToString(internalFormat));
 
-        GLubyte *pixels = new GLubyte[width*height*channels];
+    // Hardcoded for now, but we could chose types more adequate to the
+    // texture internal format
+    json.writeStringMember("__type__", "uint8");
+    json.writeBoolMember("__normalized__", true);
+    json.writeNumberMember("__channels__", channels);
 
-        GLint drawbuffer = GL_NONE;
-        GLint readbuffer = GL_NONE;
-        glGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);
-        glGetIntegerv(GL_READ_BUFFER, &readbuffer);
-        glReadBuffer(drawbuffer);
+    GLenum type = GL_UNSIGNED_BYTE;
 
-        glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
-        glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
-        glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
-        glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-        glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
-        glPixelStorei(GL_PACK_SKIP_ROWS, 0);
-        glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
-        glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
-        glPixelStorei(GL_PACK_ALIGNMENT, 1);
+#if DEPTH_AS_RGBA
+    if (format == GL_DEPTH_COMPONENT) {
+        type = GL_UNSIGNED_INT;
+        channels = 4;
+    }
+#endif
 
-        glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, pixels);
+    GLubyte *pixels = new GLubyte[width*height*channels];
 
-        glPopClientAttrib();
-        glReadBuffer(readbuffer);
+    // TODO: reset imaging state too
+    context.resetPixelPackState();
 
-        json.beginMember("__data__");
-        char *pngBuffer;
-        int pngBufferSize;
-        Image::writePixelsToBuffer(pixels, width, height, channels, false, &pngBuffer, &pngBufferSize);
-        //std::cerr <<" Before = "<<(width * height * channels * sizeof *pixels)
-        //          <<", after = "<<pngBufferSize << ", ratio = " << double(width * height * channels * sizeof *pixels)/pngBufferSize;
-        json.writeBase64(pngBuffer, pngBufferSize);
-        free(pngBuffer);
-        json.endMember(); // __data__
+    glReadPixels(0, 0, width, height, format, type, pixels);
 
-        delete [] pixels;
-        json.endObject();
-    }
+    context.restorePixelPackState();
+
+    json.beginMember("__data__");
+    char *pngBuffer;
+    int pngBufferSize;
+    image::writePixelsToBuffer(pixels, width, height, channels, true, &pngBuffer, &pngBufferSize);
+    //std::cerr <<" Before = "<<(width * height * channels * sizeof *pixels)
+    //          <<", after = "<<pngBufferSize << ", ratio = " << double(width * height * channels * sizeof *pixels)/pngBufferSize;
+    json.writeBase64(pngBuffer, pngBufferSize);
+    free(pngBuffer);
+    json.endMember(); // __data__
+
+    delete [] pixels;
+    json.endObject();
 }
 
 
@@ -624,29 +801,136 @@ downsampledFramebuffer(GLuint oldFbo, GLint drawbuffer,
 }
 
 
+/**
+ * Dump images of current draw drawable/window.
+ */
 static void
-dumpDrawBuffers(JSONWriter &json, GLboolean dumpDepth, GLboolean dumpStencil)
+dumpDrawableImages(JSONWriter &json, Context &context)
 {
-    json.beginMember("GL_RGBA");
-    dumpDrawBufferImage(json, GL_RGBA);
-    json.endMember();
+    GLint width, height;
 
-    if (dumpDepth) {
-        json.beginMember("GL_DEPTH_COMPONENT");
-        dumpDrawBufferImage(json, GL_DEPTH_COMPONENT);
-        json.endMember();
+    if (!getDrawableBounds(&width, &height)) {
+        return;
     }
 
-    if (dumpStencil) {
-        json.beginMember("GL_STENCIL_INDEX");
-        dumpDrawBufferImage(json, GL_STENCIL_INDEX);
+    GLint draw_buffer = GL_NONE;
+    if (context.ES) {
+        draw_buffer = GL_BACK;
+    } else {
+        glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
+        glReadBuffer(draw_buffer);
+    }
+
+    if (draw_buffer != GL_NONE) {
+        GLint read_buffer = GL_NONE;
+        if (!context.ES) {
+            glGetIntegerv(GL_READ_BUFFER, &read_buffer);
+        }
+
+        GLint alpha_bits = 0;
+#if 0
+        // XXX: Ignore alpha until we are able to match the traced visual
+        glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
+#endif
+        GLenum format = alpha_bits ? GL_RGBA : GL_RGB;
+        json.beginMember(enumToString(draw_buffer));
+        dumpReadBufferImage(json, width, height, format);
         json.endMember();
+
+        if (!context.ES) {
+            glReadBuffer(read_buffer);
+        }
+    }
+
+    if (!context.ES) {
+        GLint depth_bits = 0;
+        glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
+        if (depth_bits) {
+            json.beginMember("GL_DEPTH_COMPONENT");
+            dumpReadBufferImage(json, width, height, GL_DEPTH_COMPONENT);
+            json.endMember();
+        }
+
+        GLint stencil_bits = 0;
+        glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
+        if (stencil_bits) {
+            json.beginMember("GL_STENCIL_INDEX");
+            dumpReadBufferImage(json, width, height, GL_STENCIL_INDEX);
+            json.endMember();
+        }
     }
 }
 
 
+/**
+ * Dump the specified framebuffer attachment.
+ *
+ * In the case of a color attachment, it assumes it is already bound for read.
+ */
 static void
-dumpFramebuffer(JSONWriter &json)
+dumpFramebufferAttachment(JSONWriter &json, GLenum target, GLenum attachment, GLenum format)
+{
+    GLint width = 0, height = 0;
+    if (!getFramebufferAttachmentSize(target, attachment, &width, &height)) {
+        return;
+    }
+
+    GLint internalFormat = getFramebufferAttachmentFormat(target, attachment);
+
+    json.beginMember(enumToString(attachment));
+    dumpReadBufferImage(json, width, height, format, internalFormat);
+    json.endMember();
+}
+
+
+static void
+dumpFramebufferAttachments(JSONWriter &json, Context &context, GLenum target)
+{
+    GLint read_framebuffer = 0;
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_framebuffer);
+
+    GLint read_buffer = GL_NONE;
+    glGetIntegerv(GL_READ_BUFFER, &read_buffer);
+
+    GLint max_draw_buffers = 1;
+    glGetIntegerv(GL_MAX_DRAW_BUFFERS, &max_draw_buffers);
+    GLint max_color_attachments = 0;
+    glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_color_attachments);
+
+    for (GLint i = 0; i < max_draw_buffers; ++i) {
+        GLint draw_buffer = GL_NONE;
+        glGetIntegerv(GL_DRAW_BUFFER0 + i, &draw_buffer);
+        if (draw_buffer != GL_NONE) {
+            glReadBuffer(draw_buffer);
+            GLint attachment;
+            if (draw_buffer >= GL_COLOR_ATTACHMENT0 && draw_buffer < GL_COLOR_ATTACHMENT0 + max_color_attachments) {
+                attachment = draw_buffer;
+            } else {
+                std::cerr << "warning: unexpected GL_DRAW_BUFFER" << i << " = " << draw_buffer << "\n";
+                attachment = GL_COLOR_ATTACHMENT0;
+            }
+            GLint alpha_size = 0;
+            glGetFramebufferAttachmentParameteriv(target, attachment,
+                                                  GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
+                                                  &alpha_size);
+            GLenum format = alpha_size ? GL_RGBA : GL_RGB;
+            dumpFramebufferAttachment(json, target, attachment, format);
+        }
+    }
+
+    glReadBuffer(read_buffer);
+
+    if (!context.ES) {
+        dumpFramebufferAttachment(json, target, GL_DEPTH_ATTACHMENT, GL_DEPTH_COMPONENT);
+        dumpFramebufferAttachment(json, target, GL_STENCIL_ATTACHMENT, GL_STENCIL_INDEX);
+    }
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer);
+}
+
+
+static void
+dumpFramebuffer(JSONWriter &json, Context &context)
 {
     json.beginMember("framebuffer");
     json.beginObject();
@@ -655,66 +939,76 @@ dumpFramebuffer(JSONWriter &json)
     glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &boundDrawFbo);
     glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &boundReadFbo);
     if (!boundDrawFbo) {
-        GLint depth_bits = 0;
-        glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
-        GLint stencil_bits = 0;
-        glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
-        dumpDrawBuffers(json, depth_bits, stencil_bits);
+        dumpDrawableImages(json, context);
+    } else if (context.ES) {
+        dumpFramebufferAttachments(json, context, GL_FRAMEBUFFER);
     } else {
-        GLint colorRb, stencilRb, depthRb;
-        GLint boundRb;
+        GLint colorRb = 0, stencilRb = 0, depthRb = 0;
+        GLint draw_buffer0 = GL_NONE;
+        glGetIntegerv(GL_DRAW_BUFFER0, &draw_buffer0);
+        bool multisample = false;
+
+        GLint boundRb = 0;
         glGetIntegerv(GL_RENDERBUFFER_BINDING, &boundRb);
-        GLint drawbuffer = GL_NONE;
-        glGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);
-
-        glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
-                                              drawbuffer,
-                                              GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
-                                              &colorRb);
-        glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
-                                              GL_DEPTH_ATTACHMENT,
-                                              GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
-                                              &depthRb);
-        glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
-                                              GL_STENCIL_ATTACHMENT,
-                                              GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
-                                              &stencilRb);
-
-        GLint colorSamples, depthSamples, stencilSamples;
+
+        GLint object_type;
+        glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, draw_buffer0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
+        if (object_type == GL_RENDERBUFFER) {
+            glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, draw_buffer0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &colorRb);
+            glBindRenderbuffer(GL_RENDERBUFFER, colorRb);
+            GLint samples = 0;
+            glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
+            if (samples) {
+                multisample = true;
+            }
+        }
+
+        glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
+        if (object_type == GL_RENDERBUFFER) {
+            glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthRb);
+            glBindRenderbuffer(GL_RENDERBUFFER, depthRb);
+            GLint samples = 0;
+            glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
+            if (samples) {
+                multisample = true;
+            }
+        }
+
+        glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
+        if (object_type == GL_RENDERBUFFER) {
+            glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &stencilRb);
+            glBindRenderbuffer(GL_RENDERBUFFER, stencilRb);
+            GLint samples = 0;
+            glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
+            if (samples) {
+                multisample = true;
+            }
+        }
+
+        glBindRenderbuffer(GL_RENDERBUFFER, boundRb);
+
         GLuint rbs[3];
         GLint numRbs = 0;
         GLuint fboCopy = 0;
-        glBindRenderbuffer(GL_RENDERBUFFER, colorRb);
-        glGetRenderbufferParameteriv(GL_RENDERBUFFER,
-                                     GL_RENDERBUFFER_SAMPLES, &colorSamples);
-        glBindRenderbuffer(GL_RENDERBUFFER, depthRb);
-        glGetRenderbufferParameteriv(GL_RENDERBUFFER,
-                                     GL_RENDERBUFFER_SAMPLES, &depthSamples);
-        glBindRenderbuffer(GL_RENDERBUFFER, stencilRb);
-        glGetRenderbufferParameteriv(GL_RENDERBUFFER,
-                                     GL_RENDERBUFFER_SAMPLES, &stencilSamples);
-        glBindRenderbuffer(GL_RENDERBUFFER, boundRb);
 
-        if (colorSamples || depthSamples || stencilSamples) {
-            //glReadPixels doesnt support multisampled buffers so we need
+        if (multisample) {
+            // glReadPixels doesnt support multisampled buffers so we need
             // to blit the fbo to a temporary one
-            fboCopy = downsampledFramebuffer(boundDrawFbo, drawbuffer,
+            fboCopy = downsampledFramebuffer(boundDrawFbo, draw_buffer0,
                                              colorRb, depthRb, stencilRb,
                                              rbs, &numRbs);
         }
-        glDrawBuffer(drawbuffer);
-        glReadBuffer(drawbuffer);
 
-        dumpDrawBuffers(json, depthRb, stencilRb);
+        dumpFramebufferAttachments(json, context, GL_DRAW_FRAMEBUFFER);
 
-        if (fboCopy) {
-            glBindFramebuffer(GL_FRAMEBUFFER, boundDrawFbo);
-            glBindFramebuffer(GL_READ_FRAMEBUFFER, boundReadFbo);
-            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, boundDrawFbo);
+        if (multisample) {
             glBindRenderbuffer(GL_RENDERBUFFER_BINDING, boundRb);
             glDeleteRenderbuffers(numRbs, rbs);
             glDeleteFramebuffers(1, &fboCopy);
         }
+
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, boundReadFbo);
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, boundDrawFbo);
     }
 
     json.endObject();
@@ -722,13 +1016,62 @@ dumpFramebuffer(JSONWriter &json)
 }
 
 
+static const GLenum bindings[] = {
+    GL_DRAW_BUFFER,
+    GL_READ_BUFFER,
+    GL_PIXEL_PACK_BUFFER_BINDING,
+    GL_PIXEL_UNPACK_BUFFER_BINDING,
+    GL_TEXTURE_BINDING_1D,
+    GL_TEXTURE_BINDING_2D,
+    GL_TEXTURE_BINDING_3D,
+    GL_TEXTURE_BINDING_RECTANGLE,
+    GL_TEXTURE_BINDING_CUBE_MAP,
+    GL_DRAW_FRAMEBUFFER_BINDING,
+    GL_READ_FRAMEBUFFER_BINDING,
+    GL_RENDERBUFFER_BINDING,
+    GL_DRAW_BUFFER0,
+    GL_DRAW_BUFFER1,
+    GL_DRAW_BUFFER2,
+    GL_DRAW_BUFFER3,
+    GL_DRAW_BUFFER4,
+    GL_DRAW_BUFFER5,
+    GL_DRAW_BUFFER6,
+    GL_DRAW_BUFFER7,
+};
+
+
+#define NUM_BINDINGS sizeof(bindings)/sizeof(bindings[0])
+
+
 void dumpCurrentContext(std::ostream &os)
 {
     JSONWriter json(os);
-    dumpParameters(json);
-    dumpShaders(json);
-    dumpTextures(json);
-    dumpFramebuffer(json);
+
+#ifndef NDEBUG
+    GLint old_bindings[NUM_BINDINGS];
+    for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
+        old_bindings[i] = 0;
+        glGetIntegerv(bindings[i], &old_bindings[i]);
+    }
+#endif
+
+    Context context;
+
+    dumpParameters(json, context);
+    dumpShadersUniforms(json);
+    dumpTextures(json, context);
+    dumpFramebuffer(json, context);
+
+#ifndef NDEBUG
+    for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
+        GLint new_binding = 0;
+        glGetIntegerv(bindings[i], &new_binding);
+        if (new_binding != old_bindings[i]) {
+            std::cerr << "warning: " << enumToString(bindings[i]) << " was clobbered\n";
+        }
+    }
+#endif
+
 }