Update SI again with experimental OpenGL support.

6 files changed, 995 insertions, 61 deletions

diff --git a/sample-implementation-tmp/0001-gallium-Add-st_api.h.patch b/sample-implementation-tmp/0001-gallium-Add-st_api.h.patch
index 8dae1b4..ba3f6bc 100644
--- a/sample-implementation-tmp/0001-gallium-Add-st_api.h.patch
+++ b/sample-implementation-tmp/0001-gallium-Add-st_api.h.patch
@@ -1,7 +1,7 @@
 From 505cf68e37db2a13503466221e70e999edd5b9eb Mon Sep 17 00:00:00 2001
 From: Chia-I Wu <olv@lunarg.com>
 Date: Sun, 7 Feb 2010 00:52:02 +0800
-Subject: [PATCH 1/4] gallium: Add st_api.h.
+Subject: [PATCH 1/6] gallium: Add st_api.h.
 
 ---
  src/gallium/include/state_tracker/st_api.h |  410 ++++++++++++++++++++++++++++
diff --git a/sample-implementation-tmp/0002-st-vega-Implement-st_api-interface.patch b/sample-implementation-tmp/0002-st-vega-Implement-st_api-interface.patch
index 2289eee..d854474 100644
--- a/sample-implementation-tmp/0002-st-vega-Implement-st_api-interface.patch
+++ b/sample-implementation-tmp/0002-st-vega-Implement-st_api-interface.patch
@@ -1,7 +1,7 @@
 From 15419adf260b9314f487bcb855585821fa6a0d73 Mon Sep 17 00:00:00 2001
 From: Chia-I Wu <olvaffe@gmail.com>
 Date: Thu, 14 Jan 2010 12:19:32 +0800
-Subject: [PATCH 2/4] st/vega: Implement st_api interface.
+Subject: [PATCH 2/6] st/vega: Implement st_api interface.
 
 ---
  src/gallium/state_trackers/vega/Makefile      |    1 +
diff --git a/sample-implementation-tmp/0003-st-egl-Add-support-for-loading-st_api-modules.patch b/sample-implementation-tmp/0003-st-egl-Add-support-for-loading-st_api-modules.patch
index 1db01c4..aa6446d 100644
--- a/sample-implementation-tmp/0003-st-egl-Add-support-for-loading-st_api-modules.patch
+++ b/sample-implementation-tmp/0003-st-egl-Add-support-for-loading-st_api-modules.patch
@@ -1,7 +1,7 @@
 From 83339a659017402745437c03240d1837cad3649f Mon Sep 17 00:00:00 2001
 From: Chia-I Wu <olvaffe@gmail.com>
 Date: Thu, 14 Jan 2010 16:05:36 +0800
-Subject: [PATCH 3/4] st/egl: Add support for loading st_api modules.
+Subject: [PATCH 3/6] st/egl: Add support for loading st_api modules.
 
 ---
  src/gallium/state_trackers/egl/common/egl_st_api.c |  116 ++++++++++++++++++++
diff --git a/sample-implementation-tmp/0004-st-egl-Use-st_api.h-instead-of-st_public.h.patch b/sample-implementation-tmp/0004-st-egl-Use-st_api.h-instead-of-st_public.h.patch
index 8cc9ba0..5c39b3c 100644
--- a/sample-implementation-tmp/0004-st-egl-Use-st_api.h-instead-of-st_public.h.patch
+++ b/sample-implementation-tmp/0004-st-egl-Use-st_api.h-instead-of-st_public.h.patch
@@ -1,22 +1,22 @@
-From 6134333acceea0f03bcd92869ab4e13210a4034f Mon Sep 17 00:00:00 2001
+From 2aa90754de3813d10d9a5ac2e066498283b09f2b Mon Sep 17 00:00:00 2001
 From: Chia-I Wu <olv@lunarg.com>
 Date: Sun, 7 Feb 2010 00:52:11 +0800
-Subject: [PATCH 4/4] st/egl: Use st_api.h instead of st_public.h.
+Subject: [PATCH 4/6] st/egl: Use st_api.h instead of st_public.h.
 
 ---
- src/gallium/state_trackers/egl/common/egl_g3d.c    |  549 ++++++++------------
- src/gallium/state_trackers/egl/common/egl_g3d.h    |   20 +-
+ src/gallium/state_trackers/egl/common/egl_g3d.c    |  556 ++++++++------------
+ src/gallium/state_trackers/egl/common/egl_g3d.h    |   21 +-
  src/gallium/state_trackers/egl/common/egl_st.c     |  131 -----
  src/gallium/state_trackers/egl/common/egl_st.h     |   73 ---
  src/gallium/state_trackers/egl/common/egl_st_api.c |   13 +
  .../state_trackers/egl/common/st_public_tmp.h      |   20 -
- 6 files changed, 248 insertions(+), 558 deletions(-)
+ 6 files changed, 254 insertions(+), 560 deletions(-)
  delete mode 100644 src/gallium/state_trackers/egl/common/egl_st.c
  delete mode 100644 src/gallium/state_trackers/egl/common/egl_st.h
  delete mode 100644 src/gallium/state_trackers/egl/common/st_public_tmp.h
 
 diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c
-index 7021617..3734756 100644
+index 7021617..deaab38 100644
 --- a/src/gallium/state_trackers/egl/common/egl_g3d.c
 +++ b/src/gallium/state_trackers/egl/common/egl_g3d.c
 @@ -36,233 +36,26 @@
@@ -285,7 +285,47 @@ index 7021617..3734756 100644
     }
  
     if (gdrv->api_mask)
-@@ -507,36 +300,6 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
+@@ -379,6 +172,31 @@ get_mode_api_mask(const __GLcontextModes *mode, EGLint api_mask)
+    return api_mask;
+ }
+ 
++static void
++init_st_visual(_EGLConfig *conf)
++{
++   struct egl_g3d_config *gconf = egl_g3d_config(conf);
++   unsigned buffer_mask;
++
++   buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
++   if (gconf->native->mode.doubleBufferMode)
++      buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
++   if (gconf->native->mode.stereoMode) {
++      buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
++      if (gconf->native->mode.doubleBufferMode)
++         buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
++   }
++
++   gconf->stvis.buffer_mask = buffer_mask;
++   gconf->stvis.color_format = gconf->native->color_format;
++   gconf->stvis.depth_stencil_format = gconf->native->depth_format;
++   gconf->stvis.accum_format = PIPE_FORMAT_NONE;
++   gconf->stvis.samples = 0;
++
++   gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT) ?
++      ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
++}
++
+ #ifdef EGL_MESA_screen_surface
+ 
+ static void
+@@ -499,6 +317,7 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
+       }
+ 
+       gconf->native = native_configs[i];
++      init_st_visual(&gconf->base);
+       _eglAddConfig(dpy, &gconf->base);
+       id++;
+    }
+@@ -507,36 +326,6 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
     return id;
  }
  
@@ -322,7 +362,7 @@ index 7021617..3734756 100644
  static EGLBoolean
  egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
  {
-@@ -555,6 +318,9 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
+@@ -555,6 +344,9 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
        free(dpy->Screens);
     }
  
@@ -332,7 +372,7 @@ index 7021617..3734756 100644
     if (gdpy->native)
        gdpy->native->destroy(gdpy->native);
  
-@@ -587,9 +353,6 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -587,9 +379,6 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
        goto fail;
     }
  
@@ -342,7 +382,7 @@ index 7021617..3734756 100644
     egl_g3d_init_st(&gdrv->base);
     dpy->ClientAPIsMask = gdrv->api_mask;
  
-@@ -598,6 +361,13 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -598,6 +387,13 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
        goto fail;
     }
  
@@ -356,18 +396,19 @@ index 7021617..3734756 100644
  #ifdef EGL_MESA_screen_surface
     /* enable MESA_screen_surface */
     if (gdpy->native->modeset) {
-@@ -626,6 +396,7 @@ egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+@@ -625,7 +421,6 @@ egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+    struct egl_g3d_context *gshare = egl_g3d_context(share);
     struct egl_g3d_config *gconf = egl_g3d_config(conf);
     struct egl_g3d_context *gctx;
-    const __GLcontextModes *mode;
-+   struct st_visual stvis;
+-   const __GLcontextModes *mode;
  
     gctx = CALLOC_STRUCT(egl_g3d_context);
     if (!gctx) {
-@@ -645,17 +416,11 @@ egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+@@ -644,18 +439,9 @@ egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+       return NULL;
     }
  
-    mode = &gconf->native->mode;
+-   mode = &gconf->native->mode;
 -   gctx->pipe =
 -      gdpy->native->create_context(gdpy->native, (void *) &gctx->base);
 -   if (!gctx->pipe) {
@@ -379,15 +420,13 @@ index 7021617..3734756 100644
 -                        (gshare) ? gshare->st_ctx : NULL);
 -   if (!gctx->st_ctx) {
 -      gctx->pipe->destroy(gctx->pipe);
-+   /* not sure if a visual is needed */
-+   memset(&stvis, 0, sizeof(stvis));
 +   gctx->stctxi = gctx->stapi->create_context(gctx->stapi, gdpy->smapi,
-+         &stvis, (gshare) ? gshare->stctxi : NULL);
++         &gconf->stvis, (gshare) ? gshare->stctxi : NULL);
 +   if (!gctx->stctxi) {
        free(gctx);
        return NULL;
     }
-@@ -675,9 +440,7 @@ destroy_context(_EGLDisplay *dpy, _EGLContext *ctx)
+@@ -675,9 +461,7 @@ destroy_context(_EGLDisplay *dpy, _EGLContext *ctx)
     if (!dpy->Initialized)
        _eglLog(_EGL_FATAL, "destroy a context with an unitialized display");
  
@@ -398,7 +437,7 @@ index 7021617..3734756 100644
  
     free(gctx);
  }
-@@ -690,6 +453,140 @@ egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
+@@ -690,6 +474,122 @@ egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
     return EGL_TRUE;
  }
  
@@ -499,32 +538,14 @@ index 7021617..3734756 100644
 +   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 +   struct egl_g3d_config *gconf = egl_g3d_config(conf);
 +   struct st_framebuffer_iface *stfbi;
-+   unsigned buffer_mask;
 +
 +   stfbi = CALLOC_STRUCT(st_framebuffer_iface);
 +   if (!stfbi)
 +      return EGL_FALSE;
 +
-+   buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
-+   if (gconf->native->mode.doubleBufferMode)
-+      buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
-+   if (gconf->native->mode.stereoMode) {
-+      buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
-+      if (gconf->native->mode.doubleBufferMode)
-+         buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
-+   }
-+
-+   gsurf->stvis.buffer_mask = buffer_mask;
-+   gsurf->stvis.color_format = gconf->native->color_format;
-+   gsurf->stvis.depth_stencil_format = gconf->native->depth_format;
-+   gsurf->stvis.accum_format = PIPE_FORMAT_NONE;
-+   gsurf->stvis.samples = 0;
-+
-+   if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER ||
-+       !(buffer_mask & ST_ATTACHMENT_BACK_LEFT))
++   gsurf->stvis = gconf->stvis;
++   if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER)
 +      gsurf->stvis.render_buffer = ST_ATTACHMENT_FRONT_LEFT;
-+   else
-+      gsurf->stvis.render_buffer = ST_ATTACHMENT_BACK_LEFT;
 +
 +   stfbi->visual = &gsurf->stvis;
 +   stfbi->flush_front = egl_g3d_framebuffer_flush_front;
@@ -539,7 +560,7 @@ index 7021617..3734756 100644
  static EGLBoolean
  init_surface_geometry(_EGLSurface *surf)
  {
-@@ -727,16 +624,13 @@ egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -727,16 +627,13 @@ egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
        return NULL;
     }
  
@@ -558,7 +579,7 @@ index 7021617..3734756 100644
     return &gsurf->base;
  }
  
-@@ -767,14 +661,13 @@ egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -767,14 +664,13 @@ egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
        return NULL;
     }
  
@@ -575,7 +596,7 @@ index 7021617..3734756 100644
     return &gsurf->base;
  }
  
-@@ -805,15 +698,13 @@ egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -805,15 +701,13 @@ egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
        return NULL;
     }
  
@@ -593,7 +614,7 @@ index 7021617..3734756 100644
     return &gsurf->base;
  }
  
-@@ -831,6 +722,7 @@ destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf)
+@@ -831,6 +725,7 @@ destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf)
  
     pipe_surface_reference(&gsurf->render_surface, NULL);
     gsurf->native->destroy(gsurf->native);
@@ -601,7 +622,7 @@ index 7021617..3734756 100644
     free(gsurf);
  }
  
-@@ -848,6 +740,7 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -848,6 +743,7 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
  {
     struct egl_g3d_context *gctx = egl_g3d_context(ctx);
     struct egl_g3d_surface *gdraw = egl_g3d_surface(draw);
@@ -609,7 +630,7 @@ index 7021617..3734756 100644
     struct egl_g3d_context *old_gctx;
     EGLBoolean ok = EGL_TRUE;
  
-@@ -858,34 +751,29 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -858,34 +754,29 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
  
     if (old_gctx) {
        /* flush old context */
@@ -658,7 +679,7 @@ index 7021617..3734756 100644
        old_gctx->base.WindowRenderBuffer = EGL_NONE;
     }
  
-@@ -912,15 +800,17 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
+@@ -912,15 +803,17 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
        return EGL_TRUE;
  
     /* or when the surface is single-buffered */
@@ -679,7 +700,7 @@ index 7021617..3734756 100644
  
     /*
      * We drew on the back buffer, unless there was no back buffer.
-@@ -933,11 +823,9 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
+@@ -933,11 +826,9 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
     if (gctx) {
        struct egl_g3d_config *gconf = egl_g3d_config(gsurf->base.Config);
  
@@ -694,7 +715,7 @@ index 7021617..3734756 100644
     }
  
     return EGL_TRUE;
-@@ -1011,7 +899,7 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
+@@ -1011,7 +902,7 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
     /* flush if the surface is current */
     if (ctx && ctx->DrawSurface == &gsurf->base) {
        struct egl_g3d_context *gctx = egl_g3d_context(ctx);
@@ -703,7 +724,7 @@ index 7021617..3734756 100644
              PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
     }
  
-@@ -1041,8 +929,16 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
+@@ -1041,8 +932,16 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
  static EGLBoolean
  egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
  {
@@ -721,7 +742,7 @@ index 7021617..3734756 100644
     return EGL_TRUE;
  }
  
-@@ -1072,10 +968,10 @@ egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
+@@ -1072,10 +971,10 @@ egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
     /* in case this is called before a display is initialized */
     egl_g3d_init_st(&gdrv->base);
  
@@ -735,7 +756,7 @@ index 7021617..3734756 100644
           if (proc)
              return proc;
        }
-@@ -1091,8 +987,8 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -1091,8 +990,8 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
     struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
     _EGLContext *es1 = _eglGetAPIContext(EGL_OPENGL_ES_API);
     struct egl_g3d_context *gctx;
@@ -746,7 +767,7 @@ index 7021617..3734756 100644
  
     if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT)
        return _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
-@@ -1103,10 +999,10 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -1103,10 +1002,10 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
  
     switch (gsurf->base.TextureFormat) {
     case EGL_TEXTURE_RGB:
@@ -759,7 +780,7 @@ index 7021617..3734756 100644
        break;
     default:
        return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
-@@ -1128,15 +1024,18 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -1128,15 +1027,18 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
     /* flush properly if the surface is bound */
     if (gsurf->base.CurrentContext) {
        gctx = egl_g3d_context(gsurf->base.CurrentContext);
@@ -783,7 +804,7 @@ index 7021617..3734756 100644
  
     return EGL_TRUE;
  }
-@@ -1158,9 +1057,10 @@ egl_g3d_release_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -1158,9 +1060,10 @@ egl_g3d_release_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
        struct egl_g3d_context *gctx = egl_g3d_context(ctx);
  
        /* what if the context the surface binds to is no longer current? */
@@ -797,7 +818,7 @@ index 7021617..3734756 100644
     }
  
     gsurf->base.BoundToTexture = EGL_FALSE;
-@@ -1198,9 +1098,6 @@ egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+@@ -1198,9 +1101,6 @@ egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
        return NULL;
     }
  
@@ -807,7 +828,7 @@ index 7021617..3734756 100644
     return &gsurf->base;
  }
  
-@@ -1294,6 +1191,12 @@ static void
+@@ -1294,6 +1194,12 @@ static void
  egl_g3d_unload(_EGLDriver *drv)
  {
     struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
@@ -821,7 +842,7 @@ index 7021617..3734756 100644
     egl_g3d_destroy_probe(drv, NULL);
     free(gdrv);
 diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.h b/src/gallium/state_trackers/egl/common/egl_g3d.h
-index 5d2d9c4..ef92c34 100644
+index 5d2d9c4..8dba070 100644
 --- a/src/gallium/state_trackers/egl/common/egl_g3d.h
 +++ b/src/gallium/state_trackers/egl/common/egl_g3d.h
 @@ -38,11 +38,11 @@
@@ -874,6 +895,14 @@ index 5d2d9c4..ef92c34 100644
     struct pipe_surface *render_surface;
     unsigned int sequence_number;
  };
+@@ -79,6 +77,7 @@ struct egl_g3d_surface {
+ struct egl_g3d_config {
+    _EGLConfig base;
+    const struct native_config *native;
++   struct st_visual stvis;
+ };
+ 
+ struct egl_g3d_screen {
 diff --git a/src/gallium/state_trackers/egl/common/egl_st.c b/src/gallium/state_trackers/egl/common/egl_st.c
 deleted file mode 100644
 index a88ff91..0000000
diff --git a/sample-implementation-tmp/0005-st-mesa-Implement-st_api.h.patch b/sample-implementation-tmp/0005-st-mesa-Implement-st_api.h.patch
new file mode 100644
index 0000000..21c07e9
--- /dev/null
+++ b/sample-implementation-tmp/0005-st-mesa-Implement-st_api.h.patch
@@ -0,0 +1,826 @@
+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
+
diff --git a/sample-implementation-tmp/0006-winsys-xlib-st-es-Advertise-st_api.h-support.patch b/sample-implementation-tmp/0006-winsys-xlib-st-es-Advertise-st_api.h-support.patch
new file mode 100644
index 0000000..8229027
--- /dev/null
+++ b/sample-implementation-tmp/0006-winsys-xlib-st-es-Advertise-st_api.h-support.patch
@@ -0,0 +1,79 @@
+From 7a244a27fa8613acfb67d1e8cf08909136d2b4b3 Mon Sep 17 00:00:00 2001
+From: Chia-I Wu <olv@lunarg.com>
+Date: Sun, 7 Feb 2010 20:17:48 +0800
+Subject: [PATCH 6/6] winsys/xlib, st/es: Advertise st_api.h support.
+
+---
+ src/gallium/state_trackers/es/Makefile |    1 +
+ src/gallium/state_trackers/es/st_es1.c |    6 ++++++
+ src/gallium/state_trackers/es/st_es2.c |    6 ++++++
+ src/gallium/winsys/xlib/xlib.c         |    6 ++++++
+ 4 files changed, 19 insertions(+), 0 deletions(-)
+
+diff --git a/src/gallium/state_trackers/es/Makefile b/src/gallium/state_trackers/es/Makefile
+index b036551..e33685d 100644
+--- a/src/gallium/state_trackers/es/Makefile
++++ b/src/gallium/state_trackers/es/Makefile
+@@ -38,6 +38,7 @@ SYS_LIBS = -lm -pthread
+ 
+ 
+ INCLUDE_DIRS = \
++	-I$(TOP)/src/mesa \
+ 	-I$(TOP)/src/gallium/include
+ 
+ .c.o:
+diff --git a/src/gallium/state_trackers/es/st_es1.c b/src/gallium/state_trackers/es/st_es1.c
+index 25bc53b..eb4d129 100644
+--- a/src/gallium/state_trackers/es/st_es1.c
++++ b/src/gallium/state_trackers/es/st_es1.c
+@@ -1,3 +1,9 @@
+ #include "pipe/p_compiler.h"
++#include "state_tracker/gl_api.h"
+ 
+ PUBLIC const int st_api_OpenGL_ES1 = 1;
++
++PUBLIC const struct st_module st_module_OpenGL_ES1 = {
++   .api = ST_API_OPENGL_ES1,
++   .create_api = st_module_create_api
++};
+diff --git a/src/gallium/state_trackers/es/st_es2.c b/src/gallium/state_trackers/es/st_es2.c
+index 171ea62..25626b7 100644
+--- a/src/gallium/state_trackers/es/st_es2.c
++++ b/src/gallium/state_trackers/es/st_es2.c
+@@ -1,3 +1,9 @@
+ #include "pipe/p_compiler.h"
++#include "state_tracker/gl_api.h"
+ 
+ PUBLIC const int st_api_OpenGL_ES2 = 1;
++
++PUBLIC const struct st_module st_module_OpenGL_ES2 = {
++   .api = ST_API_OPENGL_ES2,
++   .create_api = st_module_create_api
++};
+diff --git a/src/gallium/winsys/xlib/xlib.c b/src/gallium/winsys/xlib/xlib.c
+index 67617a4..fd66e2b 100644
+--- a/src/gallium/winsys/xlib/xlib.c
++++ b/src/gallium/winsys/xlib/xlib.c
+@@ -36,6 +36,7 @@
+ 
+ #include <stdlib.h>
+ #include <assert.h>
++#include "state_tracker/gl_api.h"
+ 
+ /* Todo, replace all this with callback-structs provided by the
+  * individual implementations.
+@@ -50,6 +51,11 @@ enum mode {
+ /* advertise OpenGL support */
+ PUBLIC const int st_api_OpenGL = 1;
+ 
++PUBLIC const struct st_module st_module_OpenGL = {
++   .api = ST_API_OPENGL,
++   .create_api = st_module_create_api
++};
++
+ static enum mode get_mode()
+ {
+ #ifdef GALLIUM_CELL
+-- 
+1.6.4.3
+