16 files changed, 241 insertions, 79 deletions

diff --git a/src/glx/Makefile b/src/glx/Makefile
index 2c94ef1cd4..dd96973ea8 100644
--- a/src/glx/Makefile
+++ b/src/glx/Makefile
@@ -46,6 +46,12 @@ SOURCES = \
 	  applegl_glx.c
 
 
+ifeq ($(SHARED_GLAPI),1)
+GL_LIB_DEPS := -L$(TOP)/$(LIB_DIR) -l$(GLAPI_LIB) $(GL_LIB_DEPS)
+EXTRA_DEFINES += -DGLX_SHARED_GLAPI
+endif
+
+# override GLAPI_LIB
 GLAPI_LIB = $(TOP)/src/mapi/glapi/libglapi.a
 
 OBJECTS = $(SOURCES:.c=.o)
@@ -58,6 +64,7 @@ INCLUDES = -I. \
 	-I$(TOP)/src/mapi/glapi \
 	$(LIBDRM_CFLAGS) \
 	$(DRI2PROTO_CFLAGS) \
+	$(GLPROTO_CFLAGS) \
 	$(X11_INCLUDES)
 
 
diff --git a/src/glx/dri2_glx.c b/src/glx/dri2_glx.c
index b0559b24d7..2c28bc2715 100644
--- a/src/glx/dri2_glx.c
+++ b/src/glx/dri2_glx.c
@@ -535,8 +535,13 @@ dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
     CARD64 ret = 0;
 
 #ifdef __DRI2_FLUSH
-    if (psc->f)
-    	(*psc->f->flush)(priv->driDrawable);
+    if (psc->f) {
+       struct glx_context *gc = __glXGetCurrentContext();
+
+       if (gc) {
+	  (*psc->f->flush)(priv->driDrawable);
+       }
+    }
 #endif
 
     /* Old servers don't send invalidate events */
@@ -719,6 +724,27 @@ dri2_bind_tex_image(Display * dpy,
 static void
 dri2_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
 {
+#if __DRI_TEX_BUFFER_VERSION >= 3
+   struct glx_context *gc = __glXGetCurrentContext();
+   struct dri2_context *pcp = (struct dri2_context *) gc;
+   __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
+   struct glx_display *dpyPriv = __glXInitialize(dpy);
+   struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
+   struct dri2_display *pdp =
+      (struct dri2_display *) dpyPriv->dri2Display;
+   struct dri2_screen *psc;
+
+   if (pdraw != NULL) {
+      psc = (struct dri2_screen *) base->psc;
+
+      if (psc->texBuffer->base.version >= 3 &&
+          psc->texBuffer->releaseTexBuffer != NULL) {
+         (*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
+                                           pdraw->base.textureTarget,
+                                           pdraw->driDrawable);
+      }
+   }
+#endif
 }
 
 static const struct glx_context_vtable dri2_context_vtable = {
@@ -783,11 +809,16 @@ dri2CreateScreen(int screen, struct glx_display * priv)
       return NULL;
 
    memset(psc, 0, sizeof *psc);
-   if (!glx_screen_init(&psc->base, screen, priv))
-       return NULL;
+   psc->fd = -1;
+
+   if (!glx_screen_init(&psc->base, screen, priv)) {
+      Xfree(psc);
+      return NULL;
+   }
 
    if (!DRI2Connect(priv->dpy, RootWindow(priv->dpy, screen),
 		    &driverName, &deviceName)) {
+      glx_screen_cleanup(&psc->base);
       XFree(psc);
       return NULL;
    }
@@ -897,12 +928,15 @@ dri2CreateScreen(int screen, struct glx_display * priv)
    return &psc->base;
 
 handle_error:
+   if (psc->fd >= 0)
+      close(psc->fd);
+   if (psc->driver)
+      dlclose(psc->driver);
    Xfree(driverName);
    Xfree(deviceName);
+   glx_screen_cleanup(&psc->base);
    XFree(psc);
 
-   /* FIXME: clean up here */
-
    return NULL;
 }
 
diff --git a/src/glx/dri_common.c b/src/glx/dri_common.c
index 83d6e3c310..06a73e4a6b 100644
--- a/src/glx/dri_common.c
+++ b/src/glx/dri_common.c
@@ -222,7 +222,9 @@ __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB, bindToTextureRgb),
       __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA, bindToTextureRgba),
       __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,
                      bindToMipmapTexture),
-      __ATTRIB(__DRI_ATTRIB_YINVERTED, yInverted),};
+      __ATTRIB(__DRI_ATTRIB_YINVERTED, yInverted),
+      __ATTRIB(__DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE, sRGBCapable)
+};
 
 static int
 scalarEqual(struct glx_config *mode, unsigned int attrib, unsigned int value)
diff --git a/src/glx/dri_glx.c b/src/glx/dri_glx.c
index 42b263c637..ff027dc9e9 100644
--- a/src/glx/dri_glx.c
+++ b/src/glx/dri_glx.c
@@ -836,26 +836,24 @@ driCreateScreen(int screen, struct glx_display *priv)
       return NULL;
 
    memset(psc, 0, sizeof *psc);
-   if (!glx_screen_init(&psc->base, screen, priv))
-       return NULL;
-
-   if (!driGetDriverName(priv->dpy, screen, &driverName)) {
+   if (!glx_screen_init(&psc->base, screen, priv)) {
       Xfree(psc);
       return NULL;
    }
 
+   if (!driGetDriverName(priv->dpy, screen, &driverName)) {
+      goto cleanup;
+   }
+
    psc->driver = driOpenDriver(driverName);
    Xfree(driverName);
-   if (psc->driver == NULL) {
-      Xfree(psc);
-      return NULL;
-   }
+   if (psc->driver == NULL)
+      goto cleanup;
 
    extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
    if (extensions == NULL) {
       ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
-      Xfree(psc);
-      return NULL;
+      goto cleanup;
    }
 
    for (i = 0; extensions[i]; i++) {
@@ -865,19 +863,14 @@ driCreateScreen(int screen, struct glx_display *priv)
 	 psc->legacy = (__DRIlegacyExtension *) extensions[i];
    }
 
-   if (psc->core == NULL || psc->legacy == NULL) {
-      Xfree(psc);
-      return NULL;
-   }
+   if (psc->core == NULL || psc->legacy == NULL)
+      goto cleanup;
 
    pdp = (struct dri_display *) priv->driDisplay;
    psc->driScreen =
       CallCreateNewScreen(psc->base.dpy, screen, psc, pdp);
-   if (psc->driScreen == NULL) {
-      dlclose(psc->driver);
-      Xfree(psc);
-      return NULL;
-   }
+   if (psc->driScreen == NULL)
+      goto cleanup;
 
    extensions = psc->core->getExtensions(psc->driScreen);
    driBindExtensions(psc, extensions);
@@ -902,6 +895,14 @@ driCreateScreen(int screen, struct glx_display *priv)
    psp->getSwapInterval = driGetSwapInterval;
 
    return &psc->base;
+
+cleanup:
+   if (psc->driver)
+      dlclose(psc->driver);
+   glx_screen_cleanup(&psc->base);
+   Xfree(psc);
+
+   return NULL;
 }
 
 /* Called from __glXFreeDisplayPrivate.
diff --git a/src/glx/drisw_glx.c b/src/glx/drisw_glx.c
index 237ce17617..5c7f40cdff 100644
--- a/src/glx/drisw_glx.c
+++ b/src/glx/drisw_glx.c
@@ -452,8 +452,10 @@ driCreateScreen(int screen, struct glx_display *priv)
       return NULL;
 
    memset(psc, 0, sizeof *psc);
-   if (!glx_screen_init(&psc->base, screen, priv))
-       return NULL;
+   if (!glx_screen_init(&psc->base, screen, priv)) {
+      Xfree(psc);
+      return NULL;
+   }
 
    psc->driver = driOpenSwrast();
    if (psc->driver == NULL)
@@ -504,6 +506,7 @@ driCreateScreen(int screen, struct glx_display *priv)
  handle_error:
    if (psc->driver)
       dlclose(psc->driver);
+   glx_screen_cleanup(&psc->base);
    Xfree(psc);
 
    ErrorMessageF("reverting to indirect rendering\n");
diff --git a/src/glx/glx_pbuffer.c b/src/glx/glx_pbuffer.c
index 34892e8b1a..5f91bc623a 100644
--- a/src/glx/glx_pbuffer.c
+++ b/src/glx/glx_pbuffer.c
@@ -106,7 +106,7 @@ ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable,
    if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
       xGLXChangeDrawableAttributesReq *req;
 
-      GetReqExtra(GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req);
+      GetReqExtra(GLXChangeDrawableAttributes, 8 * num_attribs, req);
       output = (CARD32 *) (req + 1);
 
       req->reqType = opcode;
@@ -117,7 +117,7 @@ ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable,
    else {
       xGLXVendorPrivateWithReplyReq *vpreq;
 
-      GetReqExtra(GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq);
+      GetReqExtra(GLXVendorPrivateWithReply, 8 + (8 * num_attribs), vpreq);
       output = (CARD32 *) (vpreq + 1);
 
       vpreq->reqType = opcode;
@@ -125,7 +125,8 @@ ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable,
       vpreq->vendorCode = X_GLXvop_ChangeDrawableAttributesSGIX;
 
       output[0] = (CARD32) drawable;
-      output++;
+      output[1] = num_attribs;
+      output += 2;
    }
 
    (void) memcpy(output, attribs, sizeof(CARD32) * 2 * num_attribs);
@@ -297,7 +298,7 @@ GetDrawableAttribute(Display * dpy, GLXDrawable drawable,
    if (use_glx_1_3) {
       xGLXGetDrawableAttributesReq *req;
 
-      GetReqExtra(GLXGetDrawableAttributes, 4, req);
+      GetReq(GLXGetDrawableAttributes, req);
       req->reqType = opcode;
       req->glxCode = X_GLXGetDrawableAttributes;
       req->drawable = drawable;
@@ -435,7 +436,7 @@ DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode)
 
    LockDisplay(dpy);
 
-   GetReqExtra(GLXDestroyPbuffer, 4, req);
+   GetReq(GLXDestroyPbuffer, req);
    req->reqType = opcode;
    req->glxCode = glxCode;
    req->pbuffer = (GLXPbuffer) drawable;
diff --git a/src/glx/glxclient.h b/src/glx/glxclient.h
index 36a0808c04..2b6966f2e0 100644
--- a/src/glx/glxclient.h
+++ b/src/glx/glxclient.h
@@ -419,9 +419,9 @@ struct glx_context
    /*@} */
 
    /**
-    * Thread ID we're currently current in. Zero if none.
+    * Number of threads we're currently current in.
     */
-   unsigned long thread_id;
+   unsigned long thread_refcount;
 
    char gl_extension_bits[__GL_EXT_BYTES];
 };
@@ -585,6 +585,8 @@ struct glx_display
 extern int
 glx_screen_init(struct glx_screen *psc,
 		int screen, struct glx_display * priv);
+extern void
+glx_screen_cleanup(struct glx_screen *psc);
 
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 extern __GLXDRIdrawable *
diff --git a/src/glx/glxcmds.c b/src/glx/glxcmds.c
index 4f7e84ef5f..22bebab26b 100644
--- a/src/glx/glxcmds.c
+++ b/src/glx/glxcmds.c
@@ -36,6 +36,7 @@
 #include "glxclient.h"
 #include "glapi.h"
 #include "glxextensions.h"
+#include "indirect.h"
 
 #ifdef GLX_DIRECT_RENDERING
 #ifdef GLX_USE_APPLEGL
@@ -214,12 +215,16 @@ CreateContext(Display * dpy, int generic_id,
               Bool allowDirect,
 	      unsigned code, int renderType, int screen)
 {
-   struct glx_context *gc = NULL;
-   struct glx_screen *const psc = GetGLXScreenConfigs(dpy, screen);
+   struct glx_context *gc;
+   struct glx_screen *psc;
    struct glx_context *shareList = (struct glx_context *) shareList_user;
    if (dpy == NULL)
       return NULL;
 
+   psc = GetGLXScreenConfigs(dpy, screen);
+   if (psc == NULL)
+      return NULL;
+
    if (generic_id == None)
       return NULL;
 
@@ -722,11 +727,16 @@ glXSwapBuffers(Display * dpy, GLXDrawable drawable)
    xGLXSwapBuffersReq *req;
 #endif
 
+   gc = __glXGetCurrentContext();
+
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
 
    if (pdraw != NULL) {
-      glFlush();
+      if (gc && drawable == gc->currentDrawable) {
+	 glFlush();
+      }
+
       (*pdraw->psc->driScreen->swapBuffers)(pdraw, 0, 0, 0);
       return;
    }
@@ -741,7 +751,6 @@ glXSwapBuffers(Display * dpy, GLXDrawable drawable)
     ** The calling thread may or may not have a current context.  If it
     ** does, send the context tag so the server can do a flush.
     */
-   gc = __glXGetCurrentContext();
    if ((gc != NULL) && (dpy == gc->currentDpy) &&
        ((drawable == gc->currentDrawable)
         || (drawable == gc->currentReadable))) {
@@ -2514,7 +2523,11 @@ _X_EXPORT void (*glXGetProcAddressARB(const GLubyte * procName)) (void)
    f = (gl_function) get_glx_proc_address((const char *) procName);
    if ((f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
        && (procName[2] != 'X')) {
-      f = (gl_function) _glapi_get_proc_address((const char *) procName);
+#ifdef GLX_SHARED_GLAPI
+      f = (gl_function) __indirect_get_proc_address((const char *) procName);
+#endif
+      if (!f)
+         f = (gl_function) _glapi_get_proc_address((const char *) procName);
    }
 #endif
    return f;
diff --git a/src/glx/glxconfig.c b/src/glx/glxconfig.c
index 1d9678f48c..c3e1d5a568 100644
--- a/src/glx/glxconfig.c
+++ b/src/glx/glxconfig.c
@@ -188,6 +188,10 @@ glx_config_get(struct glx_config * mode, int attribute, int *value_return)
       *value_return = mode->yInverted;
       return 0;
 
+   case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT:
+      *value_return = mode->sRGBCapable;
+      return 0;
+
       /* Applications are NOT allowed to query GLX_VISUAL_SELECT_GROUP_SGIX.
        * It is ONLY for communication between the GLX client and the GLX
        * server.
@@ -251,6 +255,7 @@ glx_config_create_list(unsigned count)
       (*next)->bindToMipmapTexture = GLX_DONT_CARE;
       (*next)->bindToTextureTargets = GLX_DONT_CARE;
       (*next)->yInverted = GLX_DONT_CARE;
+      (*next)->sRGBCapable = GLX_DONT_CARE;
 
       next = &((*next)->next);
    }
diff --git a/src/glx/glxconfig.h b/src/glx/glxconfig.h
index f7ee958e4b..2f1074ca5f 100644
--- a/src/glx/glxconfig.h
+++ b/src/glx/glxconfig.h
@@ -100,6 +100,9 @@ struct glx_config {
     GLint bindToMipmapTexture;
     GLint bindToTextureTargets;
     GLint yInverted;
+
+    /* EXT_framebuffer_sRGB */
+    GLint sRGBCapable;
 };
 
 #define __GLX_MIN_CONFIG_PROPS	18
diff --git a/src/glx/glxcurrent.c b/src/glx/glxcurrent.c
index 3631738354..1f845ce65e 100644
--- a/src/glx/glxcurrent.c
+++ b/src/glx/glxcurrent.c
@@ -189,7 +189,7 @@ glXGetCurrentDrawable(void)
 }
 
 static void
-__glXGenerateError(Display * dpy, struct glx_context *gc, XID resource,
+__glXGenerateError(Display * dpy, XID resource,
                    BYTE errorCode, CARD16 minorCode)
 {
    xError error;
@@ -198,7 +198,7 @@ __glXGenerateError(Display * dpy, struct glx_context *gc, XID resource,
    error.resourceID = resource;
    error.sequenceNumber = dpy->request;
    error.type = X_Error;
-   error.majorCode = gc->majorOpcode;
+   error.majorCode = __glXSetupForCommand(dpy);
    error.minorCode = minorCode;
    _XError(dpy, &error);
 }
@@ -216,6 +216,16 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
    struct glx_context *oldGC = __glXGetCurrentContext();
    int ret = Success;
 
+   /* XXX: If this is left out, then libGL ends up not having this
+    * symbol, and drivers using it fail to load.  Compare the
+    * implementation of this symbol to _glapi_noop_enable_warnings(),
+    * though, which gets into the library despite no callers, the same
+    * prototypes, and the same compile flags to the files containing
+    * them.  Moving the definition to glapi_nop.c gets it into the
+    * library, though.
+    */
+   (void)_glthread_GetID();
+
    /* Make sure that the new context has a nonzero ID.  In the request,
     * a zero context ID is used only to mean that we bind to no current
     * context.
@@ -225,55 +235,56 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
    }
 
    if (gc == NULL && (draw != None || read != None)) {
-      __glXGenerateError(dpy, gc, (draw != None) ? draw : read,
+      __glXGenerateError(dpy, (draw != None) ? draw : read,
                          BadMatch, X_GLXMakeContextCurrent);
       return False;
    }
    if (gc != NULL && (draw == None || read == None)) {
-      __glXGenerateError(dpy, gc, None, BadMatch, X_GLXMakeContextCurrent);
+      __glXGenerateError(dpy, None, BadMatch, X_GLXMakeContextCurrent);
       return False;
    }
 
    _glapi_check_multithread();
 
-   if (gc != NULL && gc->thread_id != 0 && gc->thread_id != _glthread_GetID()) {
-      __glXGenerateError(dpy, gc, gc->xid,
-                         BadAccess, X_GLXMakeContextCurrent);
-      return False;
-   }
-
+   __glXLock();
    if (oldGC == gc &&
-       gc->currentDrawable == draw && gc->currentReadable == read)
+       gc->currentDrawable == draw && gc->currentReadable == read) {
+      __glXUnlock();
       return True;
+   }
 
    if (oldGC != &dummyContext) {
-      oldGC->vtable->unbind(oldGC, gc);
-      oldGC->currentDpy = 0;
-      oldGC->currentDrawable = None;
-      oldGC->currentReadable = None;
-      oldGC->thread_id = 0;
+      if (--oldGC->thread_refcount == 0) {
+	 oldGC->vtable->unbind(oldGC, gc);
+	 oldGC->currentDpy = 0;
+	 oldGC->currentDrawable = None;
+	 oldGC->currentReadable = None;
+
+	 if (oldGC->xid == None && oldGC != gc) {
+	    /* We are switching away from a context that was
+	     * previously destroyed, so we need to free the memory
+	     * for the old handle. */
+	    oldGC->vtable->destroy(oldGC);
+	 }
+      }
    }
 
    if (gc) {
-      gc->currentDpy = dpy;
-      gc->currentDrawable = draw;
-      gc->currentReadable = read;
-      gc->thread_id = _glthread_GetID();
+      if (gc->thread_refcount++ == 0) {
+	 gc->currentDpy = dpy;
+	 gc->currentDrawable = draw;
+	 gc->currentReadable = read;
+      }
       __glXSetCurrentContext(gc);
       ret = gc->vtable->bind(gc, oldGC, draw, read);
    } else {
       __glXSetCurrentContextNull();
    }
 
-   if (oldGC != &dummyContext && oldGC->xid == None && oldGC != gc) {
-      /* We are switching away from a context that was
-       * previously destroyed, so we need to free the memory
-       * for the old handle. */
-      oldGC->vtable->destroy(oldGC);
-   }
+   __glXUnlock();
 
    if (ret) {
-      __glXGenerateError(dpy, gc, None, ret, X_GLXMakeContextCurrent);
+      __glXGenerateError(dpy, None, ret, X_GLXMakeContextCurrent);
       return GL_FALSE;
    }
 
diff --git a/src/glx/glxext.c b/src/glx/glxext.c
index c5e9d0510b..e35dcb73e8 100644
--- a/src/glx/glxext.c
+++ b/src/glx/glxext.c
@@ -194,17 +194,7 @@ FreeScreenConfigs(struct glx_display * priv)
    screens = ScreenCount(priv->dpy);
    for (i = 0; i < screens; i++) {
       psc = priv->screens[i];
-      if (psc->configs) {
-	 glx_config_destroy_list(psc->configs);
-         if (psc->effectiveGLXexts)
-            Xfree(psc->effectiveGLXexts);
-         psc->configs = NULL;   /* NOTE: just for paranoia */
-      }
-      if (psc->visuals) {
-	 glx_config_destroy_list(psc->visuals);
-	 psc->visuals = NULL;   /* NOTE: just for paranoia */
-      }
-      Xfree((char *) psc->serverGLXexts);
+      glx_screen_cleanup(psc);
 
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
       if (psc->driScreen) {
@@ -556,6 +546,10 @@ __glXInitializeVisualConfigFromTags(struct glx_config * config, int count,
          config->yInverted = *bp++;
          break;
 #endif
+      case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT:
+         config->sRGBCapable = *bp++;
+         break;
+
       case GLX_USE_GL:
          if (fbconfig_style_tags)
             bp++;
@@ -688,7 +682,7 @@ static GLboolean
    }
    else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
       GetReqExtra(GLXVendorPrivateWithReply,
-                  sz_xGLXGetFBConfigsSGIXReq +
+                  sz_xGLXGetFBConfigsSGIXReq -
                   sz_xGLXVendorPrivateWithReplyReq, vpreq);
       sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
       sgi_req->reqType = priv->majorOpcode;
@@ -728,6 +722,22 @@ glx_screen_init(struct glx_screen *psc,
    return GL_TRUE;
 }
 
+_X_HIDDEN void
+glx_screen_cleanup(struct glx_screen *psc)
+{
+   if (psc->configs) {
+      glx_config_destroy_list(psc->configs);
+      if (psc->effectiveGLXexts)
+          Xfree(psc->effectiveGLXexts);
+      psc->configs = NULL;   /* NOTE: just for paranoia */
+   }
+   if (psc->visuals) {
+      glx_config_destroy_list(psc->visuals);
+      psc->visuals = NULL;   /* NOTE: just for paranoia */
+   }
+   Xfree((char *) psc->serverGLXexts);
+}
+
 /*
 ** Allocate the memory for the per screen configs for each screen.
 ** If that works then fetch the per screen configs data.
diff --git a/src/glx/glxextensions.c b/src/glx/glxextensions.c
index 3a0e64c46d..d6eb408309 100644
--- a/src/glx/glxextensions.c
+++ b/src/glx/glxextensions.c
@@ -83,6 +83,7 @@ static const struct extension_info known_glx_extensions[] = {
    { GLX(EXT_visual_info),             VER(0,0), Y, Y, N, N },
 #endif
    { GLX(EXT_visual_rating),           VER(0,0), Y, Y, N, N },
+   { GLX(EXT_framebuffer_sRGB),        VER(0,0), Y, Y, N, N },
 #ifdef GLX_USE_APPLEGL
    { GLX(MESA_agp_offset),             VER(0,0), N, N, N, N }, /* Deprecated */
    { GLX(MESA_copy_sub_buffer),        VER(0,0), N, N, N, N },
@@ -90,6 +91,7 @@ static const struct extension_info known_glx_extensions[] = {
    { GLX(MESA_agp_offset),             VER(0,0), N, N, N, Y }, /* Deprecated */
    { GLX(MESA_copy_sub_buffer),        VER(0,0), Y, N, N, N },
 #endif
+   { GLX(MESA_multithread_makecurrent),VER(0,0), Y, N, Y, N },
    { GLX(MESA_pixmap_colormap),        VER(0,0), N, N, N, N }, /* Deprecated */
    { GLX(MESA_release_buffers),        VER(0,0), N, N, N, N }, /* Deprecated */
 #ifdef GLX_USE_APPLEGL
@@ -189,6 +191,7 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(EXT_framebuffer_blit),           VER(0,0), Y, N, N, N },
    { GL(EXT_framebuffer_multisample),    VER(0,0), Y, N, N, N },
    { GL(EXT_framebuffer_object),         VER(0,0), Y, N, N, N },
+   { GL(EXT_framebuffer_sRGB),           VER(0,0), Y, N, N, N },
    { GL(EXT_multi_draw_arrays),          VER(1,4), Y, N, Y, N },
    { GL(EXT_packed_depth_stencil),       VER(0,0), Y, N, N, N },
    { GL(EXT_packed_pixels),              VER(1,2), Y, N, N, N },
diff --git a/src/glx/glxextensions.h b/src/glx/glxextensions.h
index 7877661833..4fa7a61d33 100644
--- a/src/glx/glxextensions.h
+++ b/src/glx/glxextensions.h
@@ -40,9 +40,11 @@ enum
    EXT_visual_info_bit,
    EXT_visual_rating_bit,
    EXT_import_context_bit,
+   EXT_framebuffer_sRGB_bit,
    MESA_agp_offset_bit,
    MESA_copy_sub_buffer_bit,
    MESA_depth_float_bit,
+   MESA_multithread_makecurrent_bit,
    MESA_pixmap_colormap_bit,
    MESA_release_buffers_bit,
    MESA_swap_control_bit,
@@ -117,6 +119,7 @@ enum
    GL_EXT_framebuffer_blit_bit,
    GL_EXT_framebuffer_multisample_bit,
    GL_EXT_framebuffer_object_bit,
+   GL_EXT_framebuffer_sRGB_bit,
    GL_EXT_multi_draw_arrays_bit,
    GL_EXT_packed_depth_stencil_bit,
    GL_EXT_packed_pixels_bit,
diff --git a/src/glx/indirect.c b/src/glx/indirect.c
index 49938a167a..b2675c2958 100644
--- a/src/glx/indirect.c
+++ b/src/glx/indirect.c
@@ -10657,5 +10657,65 @@ __indirect_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment,
 }
 
 
+#ifdef GLX_SHARED_GLAPI
+
+static const struct proc_pair {
+    const char *name;
+    _glapi_proc proc;
+} proc_pairs[20] = {
+    {
+    "AreTexturesResidentEXT", (_glapi_proc) glAreTexturesResidentEXT}, {
+    "DeleteTexturesEXT", (_glapi_proc) glDeleteTexturesEXT}, {
+    "GenTexturesEXT", (_glapi_proc) glGenTexturesEXT}, {
+    "GetColorTableEXT", (_glapi_proc) glGetColorTableEXT}, {
+    "GetColorTableParameterfvEXT",
+            (_glapi_proc) glGetColorTableParameterfvEXT}, {
+    "GetColorTableParameterfvSGI",
+            (_glapi_proc) glGetColorTableParameterfvEXT}, {
+    "GetColorTableParameterivEXT",
+            (_glapi_proc) glGetColorTableParameterivEXT}, {
+    "GetColorTableParameterivSGI",
+            (_glapi_proc) glGetColorTableParameterivEXT}, {
+    "GetColorTableSGI", (_glapi_proc) glGetColorTableEXT}, {
+    "GetConvolutionFilterEXT", (_glapi_proc) gl_dispatch_stub_356}, {
+    "GetConvolutionParameterfvEXT", (_glapi_proc) gl_dispatch_stub_357}, {
+    "GetConvolutionParameterivEXT", (_glapi_proc) gl_dispatch_stub_358}, {
+    "GetHistogramEXT", (_glapi_proc) gl_dispatch_stub_361}, {
+    "GetHistogramParameterfvEXT", (_glapi_proc) gl_dispatch_stub_362}, {
+    "GetHistogramParameterivEXT", (_glapi_proc) gl_dispatch_stub_363}, {
+    "GetMinmaxEXT", (_glapi_proc) gl_dispatch_stub_364}, {
+    "GetMinmaxParameterfvEXT", (_glapi_proc) gl_dispatch_stub_365}, {
+    "GetMinmaxParameterivEXT", (_glapi_proc) gl_dispatch_stub_366}, {
+    "GetSeparableFilterEXT", (_glapi_proc) gl_dispatch_stub_359}, {
+    "IsTextureEXT", (_glapi_proc) glIsTextureEXT}
+};
+
+static int
+__indirect_get_proc_compare(const void *key, const void *memb)
+{
+    const struct proc_pair *pair = (const struct proc_pair *) memb;
+    return strcmp((const char *) key, pair->name);
+}
+
+_glapi_proc
+__indirect_get_proc_address(const char *name)
+{
+    const struct proc_pair *pair;
+
+    /* skip "gl" */
+    name += 2;
+
+    pair = (const struct proc_pair *) bsearch((const void *) name,
+                                              (const void *) proc_pairs,
+                                              ARRAY_SIZE(proc_pairs),
+                                              sizeof(proc_pairs[0]),
+                                              __indirect_get_proc_compare);
+
+    return (pair) ? pair->proc : NULL;
+}
+
+#endif /* GLX_SHARED_GLAPI */
+
+
 #  undef FASTCALL
 #  undef NOINLINE
diff --git a/src/glx/indirect.h b/src/glx/indirect.h
index f3222077bf..b610cc2027 100644
--- a/src/glx/indirect.h
+++ b/src/glx/indirect.h
@@ -715,6 +715,10 @@ extern HIDDEN void __indirect_glRenderbufferStorageEXT(GLenum target, GLenum int
 extern HIDDEN void __indirect_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
 extern HIDDEN void __indirect_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
 
+#ifdef GLX_SHARED_GLAPI
+extern HIDDEN void (*__indirect_get_proc_address(const char *name))(void);
+#endif
+
 #  undef HIDDEN
 #  undef FASTCALL
 #  undef NOINLINE