path: root/sample-implementation-tmp/0005-st-mesa-Implement-st_api.h.patch

From 6fa73e237b48f8f9b2a6d3393386301c30996401 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Sun, 7 Feb 2010 19:20:52 +0800
Subject: [PATCH 5/6] st/mesa: Implement st_api.h.

---
 src/mesa/SConscript                    |    1 +
 src/mesa/es/sources.mak                |    2 +
 src/mesa/es/state_tracker/gl_api_es1.c |    7 +
 src/mesa/es/state_tracker/gl_api_es2.c |    7 +
 src/mesa/sources.mak                   |    1 +
 src/mesa/state_tracker/gl_api.c        |  639 ++++++++++++++++++++++++++++++++
 src/mesa/state_tracker/gl_api.h        |   22 ++
 src/mesa/state_tracker/st_context.c    |    1 +
 src/mesa/state_tracker/st_context.h    |    6 +
 src/mesa/state_tracker/st_public.h     |    2 +
 10 files changed, 688 insertions(+), 0 deletions(-)
 create mode 100644 src/mesa/es/state_tracker/gl_api_es1.c
 create mode 100644 src/mesa/es/state_tracker/gl_api_es2.c
 create mode 100644 src/mesa/state_tracker/gl_api.c
 create mode 100644 src/mesa/state_tracker/gl_api.h

diff --git a/src/mesa/SConscript b/src/mesa/SConscript
index ea5bad2..fbcbe95 100644
--- a/src/mesa/SConscript
+++ b/src/mesa/SConscript
@@ -144,6 +144,7 @@ if env['platform'] != 'winddk':
 	]
 	
 	statetracker_sources = [
+		'state_tracker/gl_api.c',
 		'state_tracker/st_atom.c',
 		'state_tracker/st_atom_blend.c',
 		'state_tracker/st_atom_clip.c',
diff --git a/src/mesa/es/sources.mak b/src/mesa/es/sources.mak
index 55bb31b..0c2e617 100644
--- a/src/mesa/es/sources.mak
+++ b/src/mesa/es/sources.mak
@@ -17,6 +17,7 @@ LOCAL_ES1_SOURCES :=			\
 
 LOCAL_ES1_GALLIUM_SOURCES :=		\
 	$(LOCAL_ES1_SOURCES)		\
+	state_tracker/gl_api_es1.c	\
 	state_tracker/st_cb_drawtex.c
 
 # always use local version of GLAPI_ASM_SOURCES
@@ -38,6 +39,7 @@ LOCAL_ES2_SOURCES :=			\
 	glapi/glapi-es2/main/enums.c
 
 LOCAL_ES2_GALLIUM_SOURCES :=		\
+	state_tracker/gl_api_es2.c	\
 	$(LOCAL_ES2_SOURCES)
 
 LOCAL_ES2_API_ASM := $(subst es1,es2, $(LOCAL_ES1_API_ASM))
diff --git a/src/mesa/es/state_tracker/gl_api_es1.c b/src/mesa/es/state_tracker/gl_api_es1.c
new file mode 100644
index 0000000..b1abb52
--- /dev/null
+++ b/src/mesa/es/state_tracker/gl_api_es1.c
@@ -0,0 +1,7 @@
+#include "state_tracker/gl_api.h"
+
+void
+st_api_create_context_extra(struct st_context *st)
+{
+   st->iface.api = ST_API_OPENGL_ES1;
+}
diff --git a/src/mesa/es/state_tracker/gl_api_es2.c b/src/mesa/es/state_tracker/gl_api_es2.c
new file mode 100644
index 0000000..0c3d1ff
--- /dev/null
+++ b/src/mesa/es/state_tracker/gl_api_es2.c
@@ -0,0 +1,7 @@
+#include "state_tracker/gl_api.h"
+
+void
+st_api_create_context_extra(struct st_context *st)
+{
+   st->iface.api = ST_API_OPENGL_ES2;
+}
diff --git a/src/mesa/sources.mak b/src/mesa/sources.mak
index 12d4c28..84afea4 100644
--- a/src/mesa/sources.mak
+++ b/src/mesa/sources.mak
@@ -174,6 +174,7 @@ VBO_SOURCES = \
 	vbo/vbo_save_loopback.c 
 
 STATETRACKER_SOURCES = \
+	state_tracker/gl_api.c \
 	state_tracker/st_atom.c \
 	state_tracker/st_atom_blend.c \
 	state_tracker/st_atom_clip.c \
diff --git a/src/mesa/state_tracker/gl_api.c b/src/mesa/state_tracker/gl_api.c
new file mode 100644
index 0000000..358ffb2
--- /dev/null
+++ b/src/mesa/state_tracker/gl_api.c
@@ -0,0 +1,639 @@
+#include "state_tracker/st_api.h"
+
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_format.h"
+#include "util/u_inlines.h"
+
+#include "main/mtypes.h"
+#include "main/context.h"
+#include "main/texobj.h"
+#include "main/teximage.h"
+#include "main/texstate.h"
+#include "main/texfetch.h"
+#include "main/fbobject.h"
+#include "main/framebuffer.h"
+#include "main/renderbuffer.h"
+#include "st_texture.h"
+
+#include "st_context.h"
+#include "st_format.h"
+#include "st_cb_fbo.h"
+#include "gl_api.h"
+
+/* these two functions are defined in st_context.c */
+struct st_context *
+st_create_context(struct pipe_context *pipe,
+                  const __GLcontextModes *visual,
+                  struct st_context *share);
+void st_destroy_context(struct st_context *st);
+
+/**
+ * Return a reference to the pipe texture of the EGLImage.
+ */
+struct pipe_texture *
+st_manager_reference_egl_image(struct st_context *st, void *eglimg)
+{
+   struct st_manager *smapi = st->iface.st_api_private;
+   struct pipe_texture *pt = NULL, *res;
+
+   if (!smapi)
+      return NULL;
+
+   res = (struct pipe_texture *) smapi->lock_resource(smapi, &st->iface,
+         ST_MANAGER_RESOURCE_EGL_IMAGE, eglimg);
+   pipe_texture_reference(&pt, res);
+   smapi->unlock_resource(smapi, &st->iface,
+         ST_MANAGER_RESOURCE_EGL_IMAGE, eglimg);
+
+   return pt;
+}
+
+/**
+ * Flush the front buffer if the current context renders to the front buffer.
+ */
+void
+st_flush_frontbuffer(struct st_context *st)
+{
+   struct st_framebuffer *stfb = (struct st_framebuffer *) st->ctx->DrawBuffer;
+   struct st_renderbuffer *strb = NULL;
+
+   if (stfb)
+      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
+   if (!strb)
+      return;
+
+   if (st->frontbuffer_status == FRONT_STATUS_DIRTY || strb->defined)
+      stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
+}
+
+/**
+ * Re-validate the framebuffer.
+ */
+void
+st_validate_buffer(struct st_context *st)
+{
+   struct st_framebuffer *stfb =
+      (struct st_framebuffer *) st->ctx->DrawBuffer;
+
+   if (stfb)
+      st->iface.notify_invalid_framebuffer(&st->iface, stfb->iface);
+}
+
+
+/**
+ * Validate a framebuffer.  After calling this function, all renderbuffer
+ * buffers are guaranteed to have up-to-date storage.
+ */
+static void
+st_validate_framebuffer(struct st_context *st, struct st_framebuffer *stfb)
+{
+   struct pipe_screen *screen = st->pipe->screen;
+   struct pipe_texture *textures[ST_ATTACHMENT_COUNT];
+   uint width, height;
+   unsigned i;
+
+   /* validate the fb */
+   if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))
+      return;
+
+   width = stfb->Base.Width;
+   height = stfb->Base.Height;
+
+   for (i = 0; i < stfb->num_statts; i++) {
+      struct pipe_surface *ps;
+      gl_buffer_index idx;
+
+      if (!textures[i])
+         continue;
+
+      switch (stfb->statts[i]) {
+      case ST_ATTACHMENT_FRONT_LEFT:
+         idx = BUFFER_FRONT_LEFT;
+         break;
+      case ST_ATTACHMENT_BACK_LEFT:
+         idx = BUFFER_BACK_LEFT;
+         break;
+      case ST_ATTACHMENT_FRONT_RIGHT:
+         idx = BUFFER_FRONT_RIGHT;
+         break;
+      case ST_ATTACHMENT_BACK_RIGHT:
+         idx = BUFFER_BACK_RIGHT;
+         break;
+      case ST_ATTACHMENT_DEPTH_STENCIL:
+         idx = BUFFER_DEPTH;
+         break;
+      case ST_ATTACHMENT_ACCUM:
+         idx = BUFFER_ACCUM;
+         break;
+      case ST_ATTACHMENT_SAMPLE:
+      default:
+         idx = BUFFER_COUNT;
+         break;
+      }
+      if (idx >= BUFFER_COUNT) {
+         pipe_texture_reference(&textures[i], NULL);
+         continue;
+      }
+
+      ps = screen->get_tex_surface(screen, textures[i], 0, 0, 0,
+            PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE);
+      if (ps) {
+         struct st_renderbuffer *strb;
+
+         strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
+         assert(strb);
+
+         /* transfer the ownership */
+         pipe_surface_reference(&strb->surface, ps);
+         pipe_texture_reference(&strb->texture, ps->texture);
+         pipe_surface_reference(&ps, NULL);
+
+         st->dirty.st |= ST_NEW_FRAMEBUFFER;
+
+         strb->Base.Width = strb->surface->width;
+         strb->Base.Height = strb->surface->height;
+
+         width = strb->Base.Width;
+         height = strb->Base.Height;
+      }
+
+      pipe_texture_reference(&textures[i], NULL);
+   }
+
+   _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);
+
+   assert(stfb->Base.Width == width);
+   assert(stfb->Base.Height == height);
+}
+
+static void
+st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,
+                                      struct st_framebuffer_iface *stfbi)
+{
+   struct st_context *st = (struct st_context *) stctxi;
+   struct st_framebuffer *stfb;
+
+   stfb = (struct st_framebuffer *) st->ctx->DrawBuffer;
+   if (!stfb || stfb->iface != stfbi)
+      stfb = (struct st_framebuffer *) st->ctx->ReadBuffer;
+
+   /* no binding surface */
+   if (!stfb)
+      return;
+
+   assert(stfb->iface == stfbi);
+   st_validate_framebuffer(st, stfb);
+}
+
+static void
+st_context_flush(struct st_context_iface *stctxi, unsigned flags,
+                 struct pipe_fence_handle **fence)
+{
+   struct st_context *st = (struct st_context *) stctxi;
+   st->pipe->flush(st->pipe, flags, fence);
+}
+
+static boolean
+st_context_teximage(struct st_context_iface *stctxi, enum st_texture_type target,
+                    int level, enum pipe_format internal_format,
+                    struct pipe_texture *tex, boolean mipmap)
+{
+   return FALSE;
+   struct st_context *st = (struct st_context *) stctxi;
+   GLcontext *ctx = st->ctx;
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   struct st_texture_object *stObj;
+   struct st_texture_image *stImage;
+   GLenum internalFormat;
+
+   switch (target) {
+   case ST_TEXTURE_1D:
+      target = GL_TEXTURE_1D;
+      break;
+   case ST_TEXTURE_2D:
+      target = GL_TEXTURE_2D;
+      break;
+   case ST_TEXTURE_3D:
+      target = GL_TEXTURE_3D;
+      break;
+   case ST_TEXTURE_RECT:
+      target = GL_TEXTURE_RECTANGLE_ARB;
+      break;
+   default:
+      return FALSE;
+      break;
+   }
+
+   /* map pipe format to base format for now */
+   if (util_format_get_component_bits(internal_format,
+            UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
+      internalFormat = GL_RGBA;
+   else
+      internalFormat = GL_RGB;
+
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   _mesa_lock_texture(ctx, texObj);
+
+   stObj = st_texture_object(texObj);
+   /* switch to surface based */
+   if (!stObj->surface_based) {
+      _mesa_clear_texture_object(ctx, texObj);
+      stObj->surface_based = GL_TRUE;
+   }
+
+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+   stImage = st_texture_image(texImage);
+
+   _mesa_init_teximage_fields(ctx, target, texImage,
+                              tex->width0, tex->height0, 1, 0, internalFormat);
+   texImage->TexFormat = st_ChooseTextureFormat(ctx, internalFormat,
+                                                GL_RGBA, GL_UNSIGNED_BYTE);
+   _mesa_set_fetch_functions(texImage, 2);
+   pipe_texture_reference(&stImage->pt, tex);
+
+   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+   _mesa_unlock_texture(ctx, texObj);
+   
+   return 1;
+}
+
+static struct st_texture_object *
+st_context_lookup_texture_object(struct st_context *st, GLuint name,
+                                 enum st_context_resource_type type)
+{
+   struct gl_texture_object *texobj = _mesa_lookup_texture(st->ctx, name);
+   GLenum target;
+
+   if (!texobj)
+      return NULL;
+
+   switch (type) {
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_2D:
+      target = GL_TEXTURE_2D;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_3D:
+      target = GL_TEXTURE_3D;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_X:
+      target = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+      target = GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+      target = GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+      target = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+      target = GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+      target = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+      break;
+   default:
+      return NULL;
+      break;
+   }
+
+   return (texobj->Target == target) ? st_texture_object(texobj) : NULL;
+}
+
+static struct pipe_texture *
+st_context_lookup_resource(struct st_context_iface *stctxi,
+                           enum st_context_resource_type type, void *res)
+{
+   struct st_context *st = (struct st_context *) stctxi;
+   struct pipe_texture *pt = NULL;
+
+   switch (type) {
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_2D:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_3D:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_X:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+   case ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+      {
+         GLuint id = (GLuint) res;
+         struct st_texture_object *stobj;
+
+         stobj = st_context_lookup_texture_object(st, id, type);
+         if (stobj)
+            pt = stobj->pt;
+      }
+      break;
+   case ST_CONTEXT_RESOURCE_OPENGL_RENDERBUFFER:
+      {
+         GLuint id = (GLuint) res;
+         struct gl_renderbuffer *rb = _mesa_lookup_renderbuffer(st->ctx, id);
+         struct st_renderbuffer *strb = st_renderbuffer(rb);
+
+         if (strb)
+            pt = strb->texture;
+      }
+      break;
+   default:
+      break;
+   }
+
+   return pt;
+}
+
+static void *
+st_context_lock_resource(struct st_context_iface *stctxi,
+                         enum st_context_resource_type type, void *res)
+{
+   struct pipe_texture *pt = st_context_lookup_resource(stctxi, type, res);
+   struct pipe_texture *ret = NULL;
+
+   pipe_texture_reference(&ret, pt);
+
+   return (void *) ret;
+}
+
+static void
+st_context_unlock_resource(struct st_context_iface *stctxi,
+                           enum st_context_resource_type type, void *res)
+{
+   struct pipe_texture *pt = st_context_lookup_resource(stctxi, type, res);
+   pipe_texture_reference(&pt, NULL);
+}
+
+static void
+st_context_destroy(struct st_context_iface *stctxi)
+{
+   struct st_context *st = (struct st_context *) stctxi;
+   st_destroy_context(st);
+}
+
+static void
+st_api_init_mode_from_visual(__GLcontextModes *mode,
+                             const struct st_visual *visual)
+{
+   memset(mode, 0, sizeof(*mode));
+
+   if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))
+      mode->doubleBufferMode = GL_TRUE;
+   if (st_visual_have_buffers(visual,
+            ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))
+      mode->stereoMode = GL_TRUE;
+
+   if (visual->color_format != PIPE_FORMAT_NONE) {
+      mode->rgbMode = GL_TRUE;
+
+      mode->redBits =
+         util_format_get_component_bits(visual->color_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 0);
+      mode->greenBits =
+         util_format_get_component_bits(visual->color_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 1);
+      mode->blueBits =
+         util_format_get_component_bits(visual->color_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 2);
+      mode->alphaBits =
+         util_format_get_component_bits(visual->color_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 3);
+
+      mode->rgbBits = mode->redBits +
+         mode->greenBits + mode->blueBits + mode->alphaBits;
+   }
+   else {
+      mode->colorIndexMode = GL_TRUE;
+      mode->indexBits = 16;
+   }
+
+   if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {
+      mode->haveDepthBuffer = GL_TRUE;
+      mode->haveStencilBuffer = GL_TRUE;
+
+      mode->depthBits =
+         util_format_get_component_bits(visual->depth_stencil_format,
+               UTIL_FORMAT_COLORSPACE_ZS, 0);
+      mode->stencilBits =
+         util_format_get_component_bits(visual->depth_stencil_format,
+               UTIL_FORMAT_COLORSPACE_ZS, 1);
+   }
+
+   if (visual->accum_format != PIPE_FORMAT_NONE) {
+      mode->haveAccumBuffer = GL_TRUE;
+
+      mode->accumRedBits =
+         util_format_get_component_bits(visual->accum_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 0);
+      mode->accumGreenBits =
+         util_format_get_component_bits(visual->accum_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 1);
+      mode->accumBlueBits =
+         util_format_get_component_bits(visual->accum_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 2);
+      mode->accumAlphaBits =
+         util_format_get_component_bits(visual->accum_format,
+               UTIL_FORMAT_COLORSPACE_RGB, 3);
+   }
+
+   if (visual->samples) {
+      mode->sampleBuffers = 1;
+      mode->samples = visual->samples;
+   }
+}
+
+static struct st_context_iface *
+st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
+                      const struct st_visual *visual,
+                      struct st_context_iface *shared_stctxi)
+{
+   struct st_context *shared_ctx = (struct st_context *) shared_stctxi;
+   struct st_context *st;
+   struct pipe_context *pipe;
+   __GLcontextModes mode;
+
+   pipe = smapi->create_pipe_context(smapi);
+   if (!pipe)
+      return NULL;
+
+   st_api_init_mode_from_visual(&mode, visual);
+   st = st_create_context(pipe, &mode, shared_ctx);
+   if (!st) {
+      pipe->destroy(pipe);
+      return NULL;
+   }
+
+   st->iface.api = ST_API_OPENGL;
+   st->iface.destroy = st_context_destroy;
+   st->iface.lock_resource = st_context_lock_resource;
+   st->iface.unlock_resource = st_context_unlock_resource;
+
+   st->iface.notify_invalid_framebuffer =
+      st_context_notify_invalid_framebuffer;
+   st->iface.flush = st_context_flush;
+
+   st->iface.teximage = st_context_teximage;
+   st->iface.copy = NULL;
+
+   st->iface.st_api_private = (void *) smapi;
+
+#if FEATURE_extra_context_init
+   st_api_create_context_extra(st);
+#endif
+
+   return &st->iface;
+}
+
+static struct st_framebuffer *
+st_api_create_framebuffer(struct st_framebuffer_iface *stfbi)
+{
+   struct st_framebuffer *stfb;
+   struct gl_renderbuffer *rb;
+   __GLcontextModes mode;
+   int samples;
+
+   stfb = CALLOC_STRUCT(st_framebuffer);
+   if (!stfb)
+      return NULL;
+
+   st_api_init_mode_from_visual(&mode, stfbi->visual);
+   _mesa_initialize_window_framebuffer(&stfb->Base, &mode);
+
+   samples = stfbi->visual->samples;
+   if (!samples)
+      samples = st_get_msaa();
+
+   /* TODO other renderbuffers should be added on demand */
+   rb = st_new_renderbuffer_fb(stfbi->visual->color_format, samples, FALSE);
+   if (st_visual_have_buffers(stfbi->visual, ST_ATTACHMENT_BACK_LEFT_MASK)) {
+      _mesa_add_renderbuffer(&stfb->Base, BUFFER_BACK_LEFT, rb);
+      stfb->statts[stfb->num_statts++] = ST_ATTACHMENT_BACK_LEFT;
+   }
+   else {
+      _mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
+      stfb->statts[stfb->num_statts++] = ST_ATTACHMENT_FRONT_LEFT;
+   }
+
+   if (stfbi->visual->depth_stencil_format != PIPE_FORMAT_NONE) {
+      rb = st_new_renderbuffer_fb(stfbi->visual->depth_stencil_format,
+            samples, FALSE);
+      _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);
+      _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);
+
+      if (st_visual_have_buffers(stfbi->visual,
+               ST_ATTACHMENT_DEPTH_STENCIL_MASK))
+         stfb->statts[stfb->num_statts++] = ST_ATTACHMENT_DEPTH_STENCIL;
+   }
+
+   if (stfbi->visual->accum_format != PIPE_FORMAT_NONE) {
+      rb = st_new_renderbuffer_fb(stfbi->visual->accum_format, 0, TRUE);
+      _mesa_add_renderbuffer(&stfb->Base, BUFFER_ACCUM, rb);
+
+      if (st_visual_have_buffers(stfbi->visual, ST_ATTACHMENT_ACCUM_MASK))
+         stfb->statts[stfb->num_statts++] = ST_ATTACHMENT_ACCUM;
+   }
+
+   stfb->iface = stfbi;
+   stfb->Base.Initialized = GL_TRUE;
+
+   return stfb;
+}
+
+static void
+st_api_destroy_framebuffer(struct st_framebuffer *stfb)
+{
+   GLframebuffer *fb = &stfb->Base;
+   _mesa_reference_framebuffer(&fb, NULL);
+}
+
+static boolean
+st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
+                    struct st_framebuffer_iface *stdrawi,
+                    struct st_framebuffer_iface *streadi)
+{
+   struct st_context *st = (struct st_context *) stctxi;
+   struct st_framebuffer *stdraw, *stread;
+
+   if (!st) {
+      _glapi_check_multithread();
+      return _mesa_make_current(NULL, NULL, NULL);
+   }
+
+   /* create draw fb */
+   stdraw = st_api_create_framebuffer(stdrawi);
+   if (!stdraw)
+      return FALSE;
+   st_validate_framebuffer(st, stdraw);
+
+   /* create read fb */
+   if (streadi != stdrawi) {
+      stread = st_api_create_framebuffer(streadi);
+      if (!stread) {
+         st_api_destroy_framebuffer(stdraw);
+         return FALSE;
+      }
+      st_validate_framebuffer(st, stread);
+   }
+   else {
+      stread = stdraw;
+   }
+
+   _glapi_check_multithread();
+   if (!_mesa_make_current(st->ctx, &stdraw->Base, &stread->Base)) {
+      st_api_destroy_framebuffer(stdraw);
+      if (stread != stdraw)
+         st_api_destroy_framebuffer(stread);
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+static struct st_context_iface *
+st_api_get_current(struct st_api *stapi)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct st_context *st = (ctx) ? ctx->st : NULL;
+
+   return (st) ? &st->iface : NULL;
+}
+
+static st_proc_t
+st_api_get_proc_address(struct st_api *stapi, const char *procname)
+{
+   return (st_proc_t) _glapi_get_proc_address(procname);
+}
+
+static boolean
+st_api_is_visual_supported(struct st_api *stapi,
+                           const struct st_visual *visual)
+{
+   return TRUE;
+}
+
+static void
+st_api_destroy(struct st_api *stapi)
+{
+   free(stapi);
+}
+
+struct st_api *
+st_module_create_api(void)
+{
+   struct st_api *stapi;
+
+   stapi = CALLOC_STRUCT(st_api);
+   if (stapi) {
+      stapi->destroy = st_api_destroy;
+      stapi->is_visual_supported = st_api_is_visual_supported;
+
+      stapi->create_context = st_api_create_context;
+      stapi->make_current = st_api_make_current;
+      stapi->get_current = st_api_get_current;
+
+      stapi->get_proc_address = st_api_get_proc_address;
+   }
+
+   return stapi;
+}
diff --git a/src/mesa/state_tracker/gl_api.h b/src/mesa/state_tracker/gl_api.h
new file mode 100644
index 0000000..2584cb3
--- /dev/null
+++ b/src/mesa/state_tracker/gl_api.h
@@ -0,0 +1,22 @@
+#ifndef ST_API_H
+#define ST_API_H
+
+#include "pipe/p_state.h"
+#include "st_context.h"
+
+struct pipe_texture *
+st_manager_reference_egl_image(struct st_context *st, void *eglimg);
+
+void
+st_flush_frontbuffer(struct st_context *st);
+
+void
+st_validate_buffer(struct st_context *st);
+
+void
+st_api_create_context_extra(struct st_context *st);
+
+struct st_api *
+st_module_create_api(void);
+
+#endif /* ST_API_H */
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index 8f6a0c2..43a7154 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -30,6 +30,7 @@
 #include "vbo/vbo.h"
 #include "shader/shader_api.h"
 #include "glapi/glapi.h"
+#define NO_ST_TEXTURE
 #include "st_public.h"
 #include "st_debug.h"
 #include "st_context.h"
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 50e98d7..24c7c05 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -31,6 +31,7 @@
 #include "main/mtypes.h"
 #include "shader/prog_cache.h"
 #include "pipe/p_state.h"
+#include "state_tracker/st_api.h"
 
 
 struct st_context;
@@ -73,6 +74,8 @@ struct st_tracked_state {
 
 struct st_context
 {
+   struct st_context_iface iface;
+
    GLcontext *ctx;
 
    struct pipe_context *pipe;
@@ -199,6 +202,9 @@ static INLINE struct st_context *st_context(GLcontext *ctx)
 struct st_framebuffer
 {
    GLframebuffer Base;
+   struct st_framebuffer_iface *iface;
+   enum st_attachment_type statts[ST_ATTACHMENT_COUNT];
+   unsigned num_statts;
    void *Private;
    GLuint InitWidth, InitHeight;
 };
diff --git a/src/mesa/state_tracker/st_public.h b/src/mesa/state_tracker/st_public.h
index 98c1981..e1ccd6d 100644
--- a/src/mesa/state_tracker/st_public.h
+++ b/src/mesa/state_tracker/st_public.h
@@ -41,8 +41,10 @@
 #define ST_SURFACE_BACK_RIGHT   3
 #define ST_SURFACE_DEPTH        8
 
+#ifndef NO_ST_TEXTURE
 #define ST_TEXTURE_2D    0x2
 #define ST_TEXTURE_RECT  0x4
+#endif
 
 #define ST_TEXTURE_RGB   0x1
 #define ST_TEXTURE_RGBA  0x2
-- 
1.6.4.3