st/osmesa: new OSMesa gallium state tracker

Reviewed-by: José Fonseca <jfonseca@vmware.com>

src/gallium/state_trackers/osmesa/osmesa.c

@@ -0,0 +1,793 @@
+/*
+ * Copyright (c) 2013  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * Off-Screen rendering into client memory.
+ * State tracker for gallium (for softpipe and llvmpipe)
+ *
+ * Notes:
+ *
+ * If Gallium is built with LLVM support we use the llvmpipe driver.
+ * Otherwise we use softpipe.  The GALLIUM_DRIVER environment variable
+ * may be set to "softpipe" or "llvmpipe" to override.
+ *
+ * With softpipe we could render directly into the user's buffer by using a
+ * display target resource.  However, softpipe doesn't suport "upside-down"
+ * rendering which would be needed for the OSMESA_Y_UP=TRUE case.
+ *
+ * With llvmpipe we could only render directly into the user's buffer when its
+ * width and height is a multiple of the tile size (64 pixels).
+ *
+ * Because of these constraints we always render into ordinary resources then
+ * copy the results to the user's buffer in the flush_front() function which
+ * is called when the app calls glFlush/Finish.
+ *
+ * In general, the OSMesa interface is pretty ugly and not a good match
+ * for Gallium.  But we're interested in doing the best we can to preserve
+ * application portability.  With a little work we could come up with a
+ * much nicer, new off-screen Gallium interface...
+ */
+
+
+#include "GL/osmesa.h"
+
+#include "glapi/glapi.h"  /* for OSMesaGetProcAddress below */
+
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_state.h"
+
+#include "util/u_atomic.h"
+#include "util/u_box.h"
+#include "util/u_format.h"
+#include "util/u_memory.h"
+
+#include "state_tracker/st_api.h"
+#include "state_tracker/st_gl_api.h"
+
+
+
+extern struct pipe_screen *
+osmesa_create_screen(void);
+
+
+
+struct osmesa_buffer
+{
+   struct st_framebuffer_iface *stfb;
+   struct st_visual visual;
+   unsigned width, height;
+
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
+
+   void *map;
+};
+
+
+struct osmesa_context
+{
+   struct st_context_iface *stctx;
+
+   struct osmesa_buffer *current_buffer;
+
+   enum pipe_format depth_stencil_format, accum_format;
+
+   GLenum format;         /*< User-specified context format */
+   GLenum type;           /*< Buffer's data type */
+   GLint user_row_length; /*< user-specified number of pixels per row */
+   GLboolean y_up;        /*< TRUE  -> Y increases upward */
+                          /*< FALSE -> Y increases downward */
+};
+
+
+
+/**
+ * Called from the ST manager.
+ */
+static int
+osmesa_st_get_param(struct st_manager *smapi, enum st_manager_param param)
+{
+   /* no-op */
+   return 0;
+}
+
+
+/**
+ * Create/return singleton st_api object.
+ */
+static struct st_api *
+get_st_api(void)
+{
+   static struct st_api *stapi = NULL;
+   if (!stapi) {
+      stapi = st_gl_api_create();
+   }
+   return stapi;
+}
+
+
+/**
+ * Create/return a singleton st_manager object.
+ */
+static struct st_manager *
+get_st_manager(void)
+{
+   static struct st_manager *stmgr = NULL;
+   if (!stmgr) {
+      stmgr = CALLOC_STRUCT(st_manager);
+      if (stmgr) {
+         stmgr->screen = osmesa_create_screen();
+         stmgr->get_param = osmesa_st_get_param;
+         stmgr->get_egl_image = NULL;
+      }         
+   }
+   return stmgr;
+}
+
+
+static INLINE boolean
+little_endian(void)
+{
+   const unsigned ui = 1;
+   return *((const char *) &ui);
+}
+
+
+/**
+ * Given an OSMESA_x format and a GL_y type, return the best
+ * matching PIPE_FORMAT_z.
+ * Note that we can't exactly match all user format/type combinations
+ * with gallium formats.  If we find this to be a problem, we can
+ * implement more elaborate format/type conversion in the flush_front()
+ * function.
+ */
+static enum pipe_format
+osmesa_choose_format(GLenum format, GLenum type)
+{
+   switch (format) {
+   case OSMESA_RGBA:
+      if (type == GL_UNSIGNED_BYTE) {
+         if (little_endian())
+            return PIPE_FORMAT_R8G8B8A8_UNORM;
+         else
+            return PIPE_FORMAT_A8B8G8R8_UNORM;
+      }
+      else if (type == GL_UNSIGNED_SHORT) {
+         return PIPE_FORMAT_R16G16B16A16_UNORM;
+      }
+      else if (type == GL_FLOAT) {
+         return PIPE_FORMAT_R32G32B32A32_FLOAT;
+      }
+      else {
+         return PIPE_FORMAT_NONE;
+      }
+      break;
+   case OSMESA_BGRA:
+      if (type == GL_UNSIGNED_BYTE) {
+         if (little_endian())
+            return PIPE_FORMAT_B8G8R8A8_UNORM;
+         else
+            return PIPE_FORMAT_A8R8G8B8_UNORM;
+      }
+      else if (type == GL_UNSIGNED_SHORT) {
+         return PIPE_FORMAT_R16G16B16A16_UNORM;
+      }
+      else if (type == GL_FLOAT) {
+         return PIPE_FORMAT_R32G32B32A32_FLOAT;
+      }
+      else {
+         return PIPE_FORMAT_NONE;
+      }
+      break;
+   case OSMESA_ARGB:
+      if (type == GL_UNSIGNED_BYTE) {
+         if (little_endian())
+            return PIPE_FORMAT_A8R8G8B8_UNORM;
+         else
+            return PIPE_FORMAT_B8G8R8A8_UNORM;
+      }
+      else if (type == GL_UNSIGNED_SHORT) {
+         return PIPE_FORMAT_R16G16B16A16_UNORM;
+      }
+      else if (type == GL_FLOAT) {
+         return PIPE_FORMAT_R32G32B32A32_FLOAT;
+      }
+      else {
+         return PIPE_FORMAT_NONE;
+      }
+      break;
+   case OSMESA_RGB:
+      if (type == GL_UNSIGNED_BYTE) {
+         return PIPE_FORMAT_R8G8B8_UNORM;
+      }
+      else if (type == GL_UNSIGNED_SHORT) {
+         return PIPE_FORMAT_R16G16B16_UNORM;
+      }
+      else if (type == GL_FLOAT) {
+         return PIPE_FORMAT_R32G32B32_FLOAT;
+      }
+      else {
+         return PIPE_FORMAT_NONE;
+      }
+      break;
+   case OSMESA_BGR:
+      /* No gallium format for this one */
+      return PIPE_FORMAT_NONE;
+   case OSMESA_RGB_565:
+      return PIPE_FORMAT_B5G6R5_UNORM;
+   default:
+      ; /* fall-through */
+   }
+   return PIPE_FORMAT_NONE;
+}
+
+
+/**
+ * Initialize an st_visual object.
+ */
+static void
+osmesa_init_st_visual(struct st_visual *vis,
+                      enum pipe_format color_format,
+                      enum pipe_format ds_format,
+                      enum pipe_format accum_format)
+{
+   vis->buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
+   vis->color_format = color_format;
+   vis->depth_stencil_format = ds_format;
+   vis->accum_format = accum_format;
+   vis->samples = 1;
+   vis->render_buffer = ST_ATTACHMENT_FRONT_LEFT;
+}
+
+
+/**
+ * Return the osmesa_buffer that corresponds to an st_framebuffer_iface.
+ */
+static INLINE struct osmesa_buffer *
+stfbi_to_osbuffer(struct st_framebuffer_iface *stfbi)
+{
+   return (struct osmesa_buffer *) stfbi->st_manager_private;
+}
+
+
+/**
+ * Called via glFlush/glFinish.  This is where we copy the contents
+ * of the driver's color buffer into the user-specified buffer.
+ */
+static boolean
+osmesa_st_framebuffer_flush_front(struct st_context_iface *stctx,
+                                  struct st_framebuffer_iface *stfbi,
+                                  enum st_attachment_type statt)
+{
+   OSMesaContext osmesa = OSMesaGetCurrentContext();
+   struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi);
+   struct pipe_context *pipe = stctx->pipe;
+   struct pipe_resource *res = osbuffer->textures[statt];
+   struct pipe_transfer *transfer = NULL;
+   struct pipe_box box;
+   void *map;
+   ubyte *src, *dst;
+   unsigned y, bytes, bpp;
+   int dst_stride;
+
+   u_box_2d(0, 0, res->width0, res->height0, &box);
+
+   map = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box,
+                            &transfer);
+
+   /*
+    * Copy the color buffer from the resource to the user's buffer.
+    */
+   bpp = util_format_get_blocksize(osbuffer->visual.color_format);
+   src = map;
+   dst = osbuffer->map;
+   if (osmesa->user_row_length)
+      dst_stride = bpp * osmesa->user_row_length;
+   else
+      dst_stride = bpp * osbuffer->width;
+   bytes = bpp * res->width0;
+
+   if (osmesa->y_up) {
+      /* need to flip image upside down */
+      dst = dst + (res->height0 - 1) * dst_stride;
+      dst_stride = -dst_stride;
+   }
+
+   for (y = 0; y < res->height0; y++) {
+      memcpy(dst, src, bytes);
+      dst += dst_stride;
+      src += transfer->stride;
+   }
+
+   pipe->transfer_unmap(pipe, transfer);
+
+   return TRUE;
+}
+
+
+/**
+ * Called by the st manager to validate the framebuffer (allocate
+ * its resources).
+ */
+static boolean
+osmesa_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
+                               const enum st_attachment_type *statts,
+                               unsigned count,
+                               struct pipe_resource **out)
+{
+   struct pipe_screen *screen = get_st_manager()->screen;
+   enum st_attachment_type i;
+   struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi);
+   struct pipe_resource templat;
+
+   memset(&templat, 0, sizeof(templat));
+   templat.target = PIPE_TEXTURE_RECT;
+   templat.format = 0; /* setup below */
+   templat.last_level = 0;
+   templat.width0 = osbuffer->width;
+   templat.height0 = osbuffer->height;
+   templat.depth0 = 1;
+   templat.array_size = 1;
+   templat.usage = PIPE_USAGE_DEFAULT;
+   templat.bind = 0; /* setup below */
+   templat.flags = 0;
+
+   for (i = 0; i < count; i++) {
+      enum pipe_format format;
+      unsigned bind;
+
+      /*
+       * At this time, we really only need to handle the front-left color
+       * attachment, since that's all we specified for the visual in
+       * osmesa_init_st_visual().
+       */
+      if (statts[i] == ST_ATTACHMENT_FRONT_LEFT) {
+         format = osbuffer->visual.color_format;
+         bind = PIPE_BIND_RENDER_TARGET;
+      }
+      else if (statts[i] == ST_ATTACHMENT_DEPTH_STENCIL) {
+         format = osbuffer->visual.depth_stencil_format;
+         bind = PIPE_BIND_DEPTH_STENCIL;
+      }
+      else if (statts[i] == ST_ATTACHMENT_ACCUM) {
+         format = osbuffer->visual.accum_format;
+         bind = PIPE_BIND_RENDER_TARGET;
+      }
+
+      templat.format = format;
+      templat.bind = bind;
+      out[i] = osbuffer->textures[i] =
+         screen->resource_create(screen, &templat);
+   }
+
+   return TRUE;
+}
+
+
+static struct st_framebuffer_iface *
+osmesa_create_st_framebuffer(void)
+{
+   struct st_framebuffer_iface *stfbi = CALLOC_STRUCT(st_framebuffer_iface);
+   if (stfbi) {
+      stfbi->flush_front = osmesa_st_framebuffer_flush_front;
+      stfbi->validate = osmesa_st_framebuffer_validate;
+      p_atomic_set(&stfbi->stamp, 1);
+   }
+   return stfbi;
+}
+
+
+static struct osmesa_buffer *
+osmesa_create_buffer(enum pipe_format color_format,
+                     enum pipe_format ds_format,
+                     enum pipe_format accum_format)
+{
+   struct osmesa_buffer *osbuffer = CALLOC_STRUCT(osmesa_buffer);
+   if (osbuffer) {
+      osbuffer->stfb = osmesa_create_st_framebuffer();
+
+      osbuffer->stfb->st_manager_private = osbuffer;
+      osbuffer->stfb->visual = &osbuffer->visual;
+
+      osmesa_init_st_visual(&osbuffer->visual, color_format,
+                            ds_format, accum_format);
+   }
+   return osbuffer;
+}
+
+
+static void
+osmesa_destroy_buffer(struct osmesa_buffer *osbuffer)
+{
+   FREE(osbuffer->stfb);
+   FREE(osbuffer);
+}
+
+
+
+/**********************************************************************/
+/*****                    Public Functions                        *****/
+/**********************************************************************/
+
+
+/**
+ * Create an Off-Screen Mesa rendering context.  The only attribute needed is
+ * an RGBA vs Color-Index mode flag.
+ *
+ * Input:  format - Must be GL_RGBA
+ *         sharelist - specifies another OSMesaContext with which to share
+ *                     display lists.  NULL indicates no sharing.
+ * Return:  an OSMesaContext or 0 if error
+ */
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaCreateContext(GLenum format, OSMesaContext sharelist)
+{
+   return OSMesaCreateContextExt(format, 24, 8, 0, sharelist);
+}
+
+
+/**
+ * New in Mesa 3.5
+ *
+ * Create context and specify size of ancillary buffers.
+ */
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaCreateContextExt(GLenum format, GLint depthBits, GLint stencilBits,
+                       GLint accumBits, OSMesaContext sharelist)
+{
+   OSMesaContext osmesa;
+   struct st_context_iface *st_shared;
+   enum st_context_error st_error = 0;
+   struct st_context_attribs attribs;
+   struct st_api *stapi = get_st_api();
+
+   if (sharelist) {
+      st_shared = sharelist->stctx;
+   }
+   else {
+      st_shared = NULL;
+   }
+
+   osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
+   if (!osmesa)
+      return NULL;
+
+   /* Choose depth/stencil/accum buffer formats */
+   if (accumBits > 0) {
+      osmesa->accum_format = PIPE_FORMAT_R16G16B16A16_SNORM;
+   }
+   if (depthBits > 0 && stencilBits > 0) {
+      osmesa->depth_stencil_format = PIPE_FORMAT_Z24_UNORM_S8_UINT;
+   }
+   else if (stencilBits > 0) {
+      osmesa->depth_stencil_format = PIPE_FORMAT_S8_UINT;
+   }
+   else if (depthBits >= 24) {
+      osmesa->depth_stencil_format = PIPE_FORMAT_Z24X8_UNORM;
+   }
+   else if (depthBits >= 16) {
+      osmesa->depth_stencil_format = PIPE_FORMAT_Z16_UNORM;
+   }
+
+   /*
+    * Create the rendering context
+    */
+   attribs.profile = ST_PROFILE_DEFAULT;
+   attribs.major = 2;
+   attribs.minor = 1;
+   attribs.flags = 0;  /* ST_CONTEXT_FLAG_x */
+   attribs.options.force_glsl_extensions_warn = FALSE;
+
+   osmesa_init_st_visual(&attribs.visual,
+                         PIPE_FORMAT_R8G8B8A8_UNORM,
+                         osmesa->depth_stencil_format,
+                         osmesa->accum_format);
+
+   osmesa->stctx = stapi->create_context(stapi, get_st_manager(),
+                                         &attribs, &st_error, st_shared);
+   if (!osmesa->stctx) {
+      FREE(osmesa);
+      return NULL;
+   }
+
+   osmesa->stctx->st_manager_private = osmesa;
+
+   osmesa->format = format;
+   osmesa->user_row_length = 0;
+   osmesa->y_up = GL_TRUE;
+
+   return osmesa;
+}
+
+
+/**
+ * Destroy an Off-Screen Mesa rendering context.
+ *
+ * \param osmesa  the context to destroy
+ */
+GLAPI void GLAPIENTRY
+OSMesaDestroyContext(OSMesaContext osmesa)
+{
+   if (osmesa) {
+      osmesa->stctx->destroy(osmesa->stctx);
+      FREE(osmesa);
+   }
+}
+
+
+/**
+ * Bind an OSMesaContext to an image buffer.  The image buffer is just a
+ * block of memory which the client provides.  Its size must be at least
+ * as large as width*height*pixelSize.  Its address should be a multiple
+ * of 4 if using RGBA mode.
+ *
+ * By default, image data is stored in the order of glDrawPixels: row-major
+ * order with the lower-left image pixel stored in the first array position
+ * (ie. bottom-to-top).
+ *
+ * If the context's viewport hasn't been initialized yet, it will now be
+ * initialized to (0,0,width,height).
+ *
+ * Input:  osmesa - the rendering context
+ *         buffer - the image buffer memory
+ *         type - data type for pixel components
+ *                GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT
+ *                or GL_FLOAT.
+ *         width, height - size of image buffer in pixels, at least 1
+ * Return:  GL_TRUE if success, GL_FALSE if error because of invalid osmesa,
+ *          invalid type, invalid size, etc.
+ */
+GLAPI GLboolean GLAPIENTRY
+OSMesaMakeCurrent(OSMesaContext osmesa, void *buffer, GLenum type,
+                  GLsizei width, GLsizei height)
+{
+   struct st_api *stapi = get_st_api();
+   struct osmesa_buffer *osbuffer;
+   enum pipe_format color_format;
+
+   if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) {
+      return GL_FALSE;
+   }
+   if (width < 1 || height < 1) {
+      return GL_FALSE;
+   }
+
+   color_format = osmesa_choose_format(osmesa->format, type);
+   if (color_format == PIPE_FORMAT_NONE) {
+      fprintf(stderr, "OSMesaMakeCurrent(unsupported format/type)\n");
+      return GL_FALSE;
+   }
+
+   osbuffer = osmesa_create_buffer(color_format,
+                                   osmesa->depth_stencil_format,
+                                   osmesa->accum_format);
+
+   osbuffer->width = width;
+   osbuffer->height = height;
+   osbuffer->map = buffer;
+
+   if (osmesa->current_buffer) {
+      /* free old buffer */
+      osmesa_destroy_buffer(osmesa->current_buffer);
+   }
+
+   osmesa->current_buffer = osbuffer;
+   osmesa->type = type;
+
+   stapi->make_current(stapi, osmesa->stctx, osbuffer->stfb, osbuffer->stfb);
+
+   return GL_TRUE;
+}
+
+
+
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaGetCurrentContext(void)
+{
+   struct st_api *stapi = get_st_api();
+   struct st_context_iface *st = stapi->get_current(stapi);
+   return st ? (OSMesaContext) st->st_manager_private : NULL;
+}
+
+
+
+GLAPI void GLAPIENTRY
+OSMesaPixelStore(GLint pname, GLint value)
+{
+   OSMesaContext osmesa = OSMesaGetCurrentContext();
+
+   switch (pname) {
+   case OSMESA_ROW_LENGTH:
+      osmesa->user_row_length = value;
+      break;
+   case OSMESA_Y_UP:
+      osmesa->y_up = value ? GL_TRUE : GL_FALSE;
+      break;
+   default:
+      fprintf(stderr, "Invalid pname in OSMesaPixelStore()\n");
+      return;
+   }
+}
+
+
+GLAPI void GLAPIENTRY
+OSMesaGetIntegerv(GLint pname, GLint *value)
+{
+   OSMesaContext osmesa = OSMesaGetCurrentContext();
+   struct osmesa_buffer *osbuffer = osmesa ? osmesa->current_buffer : NULL;
+
+   switch (pname) {
+   case OSMESA_WIDTH:
+      *value = osbuffer ? osbuffer->width : 0;
+      return;
+   case OSMESA_HEIGHT:
+      *value = osbuffer ? osbuffer->height : 0;
+      return;
+   case OSMESA_FORMAT:
+      *value = osmesa->format;
+      return;
+   case OSMESA_TYPE:
+      /* current color buffer's data type */
+      *value = osmesa->type;
+      return;
+   case OSMESA_ROW_LENGTH:
+      *value = osmesa->user_row_length;
+      return;
+   case OSMESA_Y_UP:
+      *value = osmesa->y_up;
+      return;
+   case OSMESA_MAX_WIDTH:
+      /* fall-through */
+   case OSMESA_MAX_HEIGHT:
+      {
+         struct pipe_screen *screen = get_st_manager()->screen;
+         int maxLevels = screen->get_param(screen,
+                                           PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
+         *value = 1 << (maxLevels - 1);
+         *value = 8 * 1024;
+      }
+      return;
+   default:
+      fprintf(stderr, "Invalid pname in OSMesaGetIntegerv()\n");
+      return;
+   }
+}
+
+
+/**
+ * Return information about the depth buffer associated with an OSMesa context.
+ * Input:  c - the OSMesa context
+ * Output:  width, height - size of buffer in pixels
+ *          bytesPerValue - bytes per depth value (2 or 4)
+ *          buffer - pointer to depth buffer values
+ * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
+ */
+GLAPI GLboolean GLAPIENTRY
+OSMesaGetDepthBuffer(OSMesaContext c, GLint *width, GLint *height,
+                     GLint *bytesPerValue, void **buffer)
+{
+   struct osmesa_buffer *osbuffer = c->current_buffer;
+   struct pipe_context *pipe = c->stctx->pipe;
+   struct pipe_resource *res = osbuffer->textures[ST_ATTACHMENT_DEPTH_STENCIL];
+   struct pipe_transfer *transfer = NULL;
+   struct pipe_box box;
+
+   /*
+    * Note: we can't really implement this function with gallium as
+    * we did for swrast.  We can't just map the resource and leave it
+    * mapped (and there's no OSMesaUnmapDepthBuffer() function) so
+    * we unmap the buffer here and return a 'stale' pointer.  This should
+    * actually be OK in most cases where the caller of this function
+    * immediately uses the pointer.
+    */
+
+   u_box_2d(0, 0, res->width0, res->height0, &box);
+
+   *buffer = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box,
+                                &transfer);
+   if (!*buffer) {
+      return GL_FALSE;
+   }
+
+   *width = res->width0;
+   *height = res->height0;
+   *bytesPerValue = util_format_get_blocksize(res->format);
+
+   pipe->transfer_unmap(pipe, transfer);
+
+   return GL_TRUE;
+}
+
+
+/**
+ * Return the color buffer associated with an OSMesa context.
+ * Input:  c - the OSMesa context
+ * Output:  width, height - size of buffer in pixels
+ *          format - the pixel format (OSMESA_FORMAT)
+ *          buffer - pointer to color buffer values
+ * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
+ */
+GLAPI GLboolean GLAPIENTRY
+OSMesaGetColorBuffer(OSMesaContext osmesa, GLint *width,
+                      GLint *height, GLint *format, void **buffer)
+{
+   struct osmesa_buffer *osbuffer = osmesa->current_buffer;
+
+   if (osbuffer) {
+      *width = osbuffer->width;
+      *height = osbuffer->height;
+      *format = osmesa->format;
+      *buffer = osbuffer->map;
+      return GL_TRUE;
+   }
+   else {
+      *width = 0;
+      *height = 0;
+      *format = 0;
+      *buffer = 0;
+      return GL_FALSE;
+   }
+}
+
+
+struct name_function
+{
+   const char *Name;
+   OSMESAproc Function;
+};
+
+static struct name_function functions[] = {
+   { "OSMesaCreateContext", (OSMESAproc) OSMesaCreateContext },
+   { "OSMesaCreateContextExt", (OSMESAproc) OSMesaCreateContextExt },
+   { "OSMesaDestroyContext", (OSMESAproc) OSMesaDestroyContext },
+   { "OSMesaMakeCurrent", (OSMESAproc) OSMesaMakeCurrent },
+   { "OSMesaGetCurrentContext", (OSMESAproc) OSMesaGetCurrentContext },
+   { "OSMesaPixelsStore", (OSMESAproc) OSMesaPixelStore },
+   { "OSMesaGetIntegerv", (OSMESAproc) OSMesaGetIntegerv },
+   { "OSMesaGetDepthBuffer", (OSMESAproc) OSMesaGetDepthBuffer },
+   { "OSMesaGetColorBuffer", (OSMESAproc) OSMesaGetColorBuffer },
+   { "OSMesaGetProcAddress", (OSMESAproc) OSMesaGetProcAddress },
+   { "OSMesaColorClamp", (OSMESAproc) OSMesaColorClamp },
+   { NULL, NULL }
+};
+
+
+GLAPI OSMESAproc GLAPIENTRY
+OSMesaGetProcAddress(const char *funcName)
+{
+   int i;
+   for (i = 0; functions[i].Name; i++) {
+      if (strcmp(functions[i].Name, funcName) == 0)
+         return functions[i].Function;
+   }
+   return _glapi_get_proc_address(funcName);
+}
+
+
+GLAPI void GLAPIENTRY
+OSMesaColorClamp(GLboolean enable)
+{
+   extern void GLAPIENTRY _mesa_ClampColor(GLenum target, GLenum clamp);
+
+   _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
+                    enable ? GL_TRUE : GL_FIXED_ONLY_ARB);
+}