diff options
Diffstat (limited to 'sample-implementation-tmp')
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 + |