diff options
Diffstat (limited to 'sample-implementation-tmp')
5 files changed, 2391 insertions, 0 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 new file mode 100644 index 0000000..98f1372 --- /dev/null +++ b/sample-implementation-tmp/0001-gallium-Add-st_api.h.patch @@ -0,0 +1,420 @@ +From 94e420c2b04c3e14a920106d117a94aaf74404b2 Mon Sep 17 00:00:00 2001 +From: Chia-I Wu <olvaffe@gmail.com> +Date: Wed, 13 Jan 2010 17:57:35 +0800 +Subject: [PATCH 1/5] gallium: Add st_api.h. + +--- + src/gallium/include/state_tracker/st_api.h | 401 ++++++++++++++++++++++++++++ + 1 files changed, 401 insertions(+), 0 deletions(-) + create mode 100644 src/gallium/include/state_tracker/st_api.h + +diff --git a/src/gallium/include/state_tracker/st_api.h b/src/gallium/include/state_tracker/st_api.h +new file mode 100644 +index 0000000..8feaade +--- /dev/null ++++ b/src/gallium/include/state_tracker/st_api.h +@@ -0,0 +1,401 @@ ++/********************************************************** ++ * Copyright 2010 VMware, Inc. All rights reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person ++ * obtaining a copy of this software and associated documentation ++ * files (the "Software"), to deal in the Software without ++ * restriction, including without limitation the rights to use, copy, ++ * modify, merge, publish, distribute, sublicense, and/or sell copies ++ * of the Software, and to permit persons to whom the Software is ++ * furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be ++ * included in all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ **********************************************************/ ++ ++ ++#ifndef _ST_API_H_ ++#define _ST_API_H_ ++ ++#include "pipe/p_compiler.h" ++#include "pipe/p_format.h" ++ ++/** ++ * \file API for communication between state trackers and state tracker ++ * managers. ++ * ++ * While both are state tackers, we use the term state tracker for rendering ++ * APIs such as OpenGL or OpenVG, and state tracker manager for window system ++ * APIs such as EGL or GLX in this file. ++ * ++ * This file defines an API to be implemented by both state trackers and state ++ * tracker managers. ++ */ ++ ++/** ++ * The entry points of the state trackers. ++ */ ++#define ST_MODULE_OPENGL_SYMBOL "st_module_OpenGL" ++#define ST_MODULE_OPENGL_ES1_SYMBOL "st_module_OpenGL_ES1" ++#define ST_MODULE_OPENGL_ES2_SYMBOL "st_module_OpenGL_ES2" ++#define ST_MODULE_OPENVG_SYMBOL "st_module_OpenVG" ++ ++/** ++ * The supported rendering API of a state tracker. ++ */ ++enum st_api_type { ++ ST_API_OPENGL, ++ ST_API_OPENGL_ES1, ++ ST_API_OPENGL_ES2, ++ ST_API_OPENVG, ++ ++ ST_API_COUNT ++}; ++ ++/** ++ * Used in st_context->teximage. ++ */ ++enum st_texture_type { ++ ST_TEXTURE_1D, ++ ST_TEXTURE_2D, ++ ST_TEXTURE_3D, ++ ST_TEXTURE_RECT, ++}; ++ ++/** ++ * Available attachments of framebuffer. ++ */ ++enum st_attachment_type { ++ ST_ATTACHMENT_FRONT_LEFT, ++ ST_ATTACHMENT_BACK_LEFT, ++ ST_ATTACHMENT_FRONT_RIGHT, ++ ST_ATTACHMENT_BACK_RIGHT, ++ ST_ATTACHMENT_DEPTH_STENCIL, ++ ST_ATTACHMENT_ACCUM, ++ ST_ATTACHMENT_SAMPLE, ++ ++ ST_ATTACHMENT_COUNT, ++ ST_ATTACHMENT_INVALID = -1 ++}; ++ ++/* for buffer_mask in st_visual */ ++#define ST_ATTACHMENT_FRONT_LEFT_MASK (1 << ST_ATTACHMENT_FRONT_LEFT) ++#define ST_ATTACHMENT_BACK_LEFT_MASK (1 << ST_ATTACHMENT_BACK_LEFT) ++#define ST_ATTACHMENT_FRONT_RIGHT_MASK (1 << ST_ATTACHMENT_FRONT_RIGHT) ++#define ST_ATTACHMENT_BACK_RIGHT_MASK (1 << ST_ATTACHMENT_BACK_RIGHT) ++#define ST_ATTACHMENT_DEPTH_STENCIL_MASK (1 << ST_ATTACHMENT_DEPTH_STENCIL) ++#define ST_ATTACHMENT_ACCUM_MASK (1 << ST_ATTACHMENT_ACCUM) ++#define ST_ATTACHMENT_SAMPLE_MASK (1 << ST_ATTACHMENT_SAMPLE) ++ ++/** ++ * Enumerations of state tracker manager resources. ++ */ ++enum st_manager_resource_type { ++ /* return struct pipe_surface (this is likely to change) */ ++ ST_MANAGER_RESOURCE_EGL_IMAGE, ++}; ++ ++/** ++ * Enumerations of state tracker context resources. ++ */ ++enum st_context_resource_type { ++ /* all of them return struct pipe_texture */ ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_2D, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_3D, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_X, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_X, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Y, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Y, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_POSITIVE_Z, ++ ST_CONTEXT_RESOURCE_OPENGL_TEXTURE_CUBE_MAP_NEGATIVE_Z, ++ ST_CONTEXT_RESOURCE_OPENGL_RENDERBUFFER, ++ ST_CONTEXT_RESOURCE_OPENVG_PARENT_IMAGE, ++}; ++ ++/** ++ * The return type of st_api->get_proc_address. ++ */ ++typedef void (*st_proc_t)(void); ++ ++struct pipe_context; ++struct pipe_texture; ++struct pipe_fence_handle; ++ ++/** ++ * Represent the visual of a framebuffer. ++ */ ++struct st_visual ++{ ++ /** ++ * Available buffers. Tested with ST_FRAMEBUFFER_*_MASK. ++ */ ++ unsigned buffer_mask; ++ ++ /** ++ * Buffer formats. The formats are always set even when the buffer is ++ * not available. ++ */ ++ enum pipe_format color_format; ++ enum pipe_format depth_stencil_format; ++ enum pipe_format accum_format; ++ int samples; ++ ++ /** ++ * Desired render buffer. ++ */ ++ enum st_attachment_type render_buffer; ++}; ++ ++/** ++ * Represent a windowing system drawable. ++ * ++ * The framebuffer is implemented by the state tracker manager and ++ * used by the state trackers. ++ * ++ * Instead of the winsys pokeing into the API context to figure ++ * out what buffers that might be needed in the future by the API ++ * context, it calls into the framebuffer to get the textures. ++ * ++ * This structure along with the notify_invalid_framebuffer ++ * allows framebuffers to be shared between different threads ++ * but at the same make the API context free from thread ++ * syncronisation primitves, with the exception of a small ++ * atomic flag used for notification of framebuffer dirty status. ++ * ++ * The thread syncronisation is put inside the framebuffer ++ * and only called once the framebuffer has become dirty. ++ */ ++struct st_framebuffer ++{ ++ /** ++ * Available for the state tracker manager to use. ++ */ ++ void *st_manager_private; ++ ++ /** ++ * The visual of a framebuffer. ++ */ ++ const struct st_visual *visual; ++ ++ /** ++ * Flush the front buffer. ++ * ++ * On some window systems, changes to the front buffers are not immediately ++ * visible. They need to be flushed. ++ * ++ * @att is one of the front buffer attachments. ++ */ ++ boolean (*flush_front)(struct st_framebuffer *stfb, ++ enum st_attachment_type statt); ++ ++ /** ++ * The state tracker asks for the textures it needs. ++ * ++ * It should try to only ask for attachments that it currently renders ++ * to, thus allowing the winsys to delay the allocation of textures not ++ * needed. For example front buffer attachments are not needed if you ++ * only do back buffer rendering. ++ * ++ * The implementor of this function needs to also ensure ++ * thread safty as this call might be done from multiple threads. ++ * ++ * The returned textures are owned by the caller. They should be ++ * unreferenced when no longer used. If this function is called multiple ++ * times with different sets of attachments, those buffers not included in ++ * the last call might be destroyed. This behavior might change in the ++ * future. ++ */ ++ boolean (*validate)(struct st_framebuffer *stfb, ++ const enum st_attachment_type *statts, ++ unsigned count, ++ struct pipe_texture **out); ++}; ++ ++/** ++ * Represent a rendering context. ++ * ++ * This entity is created from st_api and used by the state tracker manager. ++ */ ++struct st_context ++{ ++ /** ++ * The API of the context. ++ */ ++ enum st_api_type api; ++ ++ /** ++ * Available for the state tracker to use. ++ */ ++ void *st_api_private; ++ ++ /** ++ * Destroy the context. ++ */ ++ void (*destroy)(struct st_context *stctx); ++ ++ /** ++ * Lock and unlock a state tracker context resource. ++ * ++ * This gives access to the underlying data structure of a state tracker ++ * context resource. Unless there is some mechanism not defined here that ++ * can lengthen the lifetime of the data structure, it is valid only until ++ * unlocked. ++ */ ++ void *(*lock_resource)(struct st_context *stctx, ++ enum st_context_resource_type type, void *res); ++ void (*unlock_resource)(struct st_context *stctx, ++ enum st_context_resource_type type, void *res); ++ ++ /** ++ * Invalidate the current textures that was taken from a framebuffer. ++ * ++ * The state tracker manager calls this function to let the rendering ++ * context know that it should update the textures it got from ++ * st_framebuffer::validate. It should do so at the latest time possible. ++ * Possible right before sending triangles to the pipe context. ++ * ++ * For certain platforms this function might be called from a thread other ++ * than the thread that the context is currently bound in, and must ++ * therefore be thread safe. But it is the state tracker manager's ++ * responsibility to make sure that the framebuffer is bound to the context ++ * and the API context is current for the duration of this call. ++ * ++ * Thus reducing the sync primitive needed to a single atomic flag. ++ */ ++ void (*notify_invalid_framebuffer)(struct st_context *stctx, ++ struct st_framebuffer *stfb); ++ ++ /** ++ * Flush all drawing from context to the pipe also flushes the pipe. ++ */ ++ void (*flush)(struct st_context *stctx, unsigned flags, ++ struct pipe_fence_handle **fence); ++ ++ /** ++ * Replace the texture image of a texture object at the specified level. ++ * ++ * This function is optional. ++ */ ++ boolean (*teximage)(struct st_context *stctx, enum st_texture_type target, ++ int level, enum pipe_format internal_format, ++ struct pipe_texture *tex, boolean mipmap); ++ ++ /** ++ * Used to implement glXCopyContext. ++ */ ++ void (*copy)(struct st_context *stctx, struct st_context *stsrc, ++ unsigned mask); ++}; ++ ++ ++/** ++ * Represent a state tracker manager. ++ * ++ * This interface is implemented by the state tracker manager. It corresponds ++ * to a "display" in the window system. ++ */ ++struct st_manager ++{ ++ /** ++ * Lock and unlock a state tracker manager resource. ++ * ++ * This gives access to the underlying data structure of a state tracker ++ * manager resource. Unless there is some mechanism not defined here that ++ * can lengthen the lifetime of the data structure, it is valid only until ++ * unlocked. ++ */ ++ void *(*lock_resource)(struct st_manager *smapi, struct st_context *stctx, ++ enum st_manager_resource_type type, void *res); ++ void (*unlock_resource)(struct st_manager *smapi, struct st_context *stctx, ++ enum st_manager_resource_type type, void *res); ++}; ++ ++/** ++ * Represent a rendering API such as OpenGL or OpenVG. ++ * ++ * Implemented by the state tracker and used by the state tracker manager. ++ */ ++struct st_api ++{ ++ /** ++ * Destroy the API. ++ */ ++ void (*destroy)(struct st_api *stapi); ++ ++ /** ++ * Return an API entry point. ++ * ++ * For GL this is the same as _glapi_get_proc_address. ++ */ ++ st_proc_t (*get_proc_address)(struct st_api *stapi, const char *procname); ++ ++ /** ++ * Return true if the visual is supported by the state tracker. ++ */ ++ boolean (*is_visual_supported)(struct st_api *stapi, ++ const struct st_visual *visual); ++ ++ /** ++ * Create a rendering context. ++ * ++ * XXX: The pipe argument should go away once ++ * the pipe_screen can create contexts. ++ * XXX: Is visual needed? ++ */ ++ struct st_context *(*create_context)(struct st_api *stapi, ++ struct st_manager *smapi, ++ struct pipe_context *pipe, ++ const struct st_visual *visual, ++ struct st_context *stshare); ++ ++ /** ++ * Bind the context to the calling thread with draw and read as drawables. ++ */ ++ boolean (*make_current)(struct st_api *stapi, ++ struct st_context *stctx, ++ struct st_framebuffer *stdraw, ++ struct st_framebuffer *stread); ++ ++ /** ++ * Get the currently bound context in the calling thread. ++ */ ++ struct st_context *(*get_current)(struct st_api *stapi); ++}; ++ ++/** ++ * Represent a state tracker. ++ * ++ * This is the entry point of a state tracker. ++ */ ++struct st_module ++{ ++ enum st_api_type api; ++ struct st_api *(*create_api)(void); ++}; ++ ++/** ++ * Return true if the visual has the specified buffers. ++ */ ++static INLINE boolean ++st_visual_have_buffers(const struct st_visual *visual, unsigned mask) ++{ ++ return ((visual->buffer_mask & mask) == mask); ++} ++ ++/* these symbols may need to be dynamically lookup up */ ++extern PUBLIC const struct st_module st_module_OpenGL; ++extern PUBLIC const struct st_module st_module_OpenGL_ES1; ++extern PUBLIC const struct st_module st_module_OpenGL_ES2; ++extern PUBLIC const struct st_module st_module_OpenVG; ++ ++#endif /* _ST_API_H_ */ +-- +1.6.5 + diff --git a/sample-implementation-tmp/0002-gallium-Suffix-st_framebuffer-and-st_context-with-_i.patch b/sample-implementation-tmp/0002-gallium-Suffix-st_framebuffer-and-st_context-with-_i.patch new file mode 100644 index 0000000..22990fd --- /dev/null +++ b/sample-implementation-tmp/0002-gallium-Suffix-st_framebuffer-and-st_context-with-_i.patch @@ -0,0 +1,175 @@ +From e2bd293a0f9c775487ea007c72ba9feca2a52afc Mon Sep 17 00:00:00 2001 +From: Chia-I Wu <olvaffe@gmail.com> +Date: Tue, 2 Feb 2010 13:45:53 +0800 +Subject: [PATCH 2/5] gallium: Suffix st_framebuffer and st_context with _iface. + +--- + src/gallium/include/state_tracker/st_api.h | 54 ++++++++++++++------------- + 1 files changed, 28 insertions(+), 26 deletions(-) + +diff --git a/src/gallium/include/state_tracker/st_api.h b/src/gallium/include/state_tracker/st_api.h +index 8feaade..5a47b63 100644 +--- a/src/gallium/include/state_tracker/st_api.h ++++ b/src/gallium/include/state_tracker/st_api.h +@@ -63,7 +63,7 @@ enum st_api_type { + }; + + /** +- * Used in st_context->teximage. ++ * Used in st_context_iface->teximage. + */ + enum st_texture_type { + ST_TEXTURE_1D, +@@ -175,7 +175,7 @@ struct st_visual + * The thread syncronisation is put inside the framebuffer + * and only called once the framebuffer has become dirty. + */ +-struct st_framebuffer ++struct st_framebuffer_iface + { + /** + * Available for the state tracker manager to use. +@@ -195,7 +195,7 @@ struct st_framebuffer + * + * @att is one of the front buffer attachments. + */ +- boolean (*flush_front)(struct st_framebuffer *stfb, ++ boolean (*flush_front)(struct st_framebuffer_iface *stfbi, + enum st_attachment_type statt); + + /** +@@ -215,7 +215,7 @@ struct st_framebuffer + * the last call might be destroyed. This behavior might change in the + * future. + */ +- boolean (*validate)(struct st_framebuffer *stfb, ++ boolean (*validate)(struct st_framebuffer_iface *stfbi, + const enum st_attachment_type *statts, + unsigned count, + struct pipe_texture **out); +@@ -226,7 +226,7 @@ struct st_framebuffer + * + * This entity is created from st_api and used by the state tracker manager. + */ +-struct st_context ++struct st_context_iface + { + /** + * The API of the context. +@@ -241,7 +241,7 @@ struct st_context + /** + * Destroy the context. + */ +- void (*destroy)(struct st_context *stctx); ++ void (*destroy)(struct st_context_iface *stctxi); + + /** + * Lock and unlock a state tracker context resource. +@@ -251,9 +251,9 @@ struct st_context + * can lengthen the lifetime of the data structure, it is valid only until + * unlocked. + */ +- void *(*lock_resource)(struct st_context *stctx, ++ void *(*lock_resource)(struct st_context_iface *stctxi, + enum st_context_resource_type type, void *res); +- void (*unlock_resource)(struct st_context *stctx, ++ void (*unlock_resource)(struct st_context_iface *stctxi, + enum st_context_resource_type type, void *res); + + /** +@@ -261,7 +261,7 @@ struct st_context + * + * The state tracker manager calls this function to let the rendering + * context know that it should update the textures it got from +- * st_framebuffer::validate. It should do so at the latest time possible. ++ * st_framebuffer_iface::validate. It should do so at the latest time possible. + * Possible right before sending triangles to the pipe context. + * + * For certain platforms this function might be called from a thread other +@@ -272,13 +272,13 @@ struct st_context + * + * Thus reducing the sync primitive needed to a single atomic flag. + */ +- void (*notify_invalid_framebuffer)(struct st_context *stctx, +- struct st_framebuffer *stfb); ++ void (*notify_invalid_framebuffer)(struct st_context_iface *stctxi, ++ struct st_framebuffer_iface *stfbi); + + /** + * Flush all drawing from context to the pipe also flushes the pipe. + */ +- void (*flush)(struct st_context *stctx, unsigned flags, ++ void (*flush)(struct st_context_iface *stctxi, unsigned flags, + struct pipe_fence_handle **fence); + + /** +@@ -286,15 +286,15 @@ struct st_context + * + * This function is optional. + */ +- boolean (*teximage)(struct st_context *stctx, enum st_texture_type target, ++ boolean (*teximage)(struct st_context_iface *stctxi, enum st_texture_type target, + int level, enum pipe_format internal_format, + struct pipe_texture *tex, boolean mipmap); + + /** + * Used to implement glXCopyContext. + */ +- void (*copy)(struct st_context *stctx, struct st_context *stsrc, +- unsigned mask); ++ void (*copy)(struct st_context_iface *stctxi, ++ struct st_context_iface *stsrci, unsigned mask); + }; + + +@@ -314,9 +314,11 @@ struct st_manager + * can lengthen the lifetime of the data structure, it is valid only until + * unlocked. + */ +- void *(*lock_resource)(struct st_manager *smapi, struct st_context *stctx, ++ void *(*lock_resource)(struct st_manager *smapi, ++ struct st_context_iface *stctxi, + enum st_manager_resource_type type, void *res); +- void (*unlock_resource)(struct st_manager *smapi, struct st_context *stctx, ++ void (*unlock_resource)(struct st_manager *smapi, ++ struct st_context_iface *stctxi, + enum st_manager_resource_type type, void *res); + }; + +@@ -352,24 +354,24 @@ struct st_api + * the pipe_screen can create contexts. + * XXX: Is visual needed? + */ +- struct st_context *(*create_context)(struct st_api *stapi, +- struct st_manager *smapi, +- struct pipe_context *pipe, +- const struct st_visual *visual, +- struct st_context *stshare); ++ struct st_context_iface *(*create_context)(struct st_api *stapi, ++ struct st_manager *smapi, ++ struct pipe_context *pipe, ++ const struct st_visual *visual, ++ struct st_context_iface *stsharei); + + /** + * Bind the context to the calling thread with draw and read as drawables. + */ + boolean (*make_current)(struct st_api *stapi, +- struct st_context *stctx, +- struct st_framebuffer *stdraw, +- struct st_framebuffer *stread); ++ struct st_context_iface *stctxi, ++ struct st_framebuffer_iface *stdrawi, ++ struct st_framebuffer_iface *streadi); + + /** + * Get the currently bound context in the calling thread. + */ +- struct st_context *(*get_current)(struct st_api *stapi); ++ struct st_context_iface *(*get_current)(struct st_api *stapi); + }; + + /** +-- +1.6.5 + diff --git a/sample-implementation-tmp/0003-st-vega-Implement-st_api-interface.patch b/sample-implementation-tmp/0003-st-vega-Implement-st_api-interface.patch new file mode 100644 index 0000000..4e47567 --- /dev/null +++ b/sample-implementation-tmp/0003-st-vega-Implement-st_api-interface.patch @@ -0,0 +1,504 @@ +From 9cb428781f56af4e210669ed6a1cfd6381932aac 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 3/5] st/vega: Implement st_api interface. + +--- + src/gallium/state_trackers/vega/Makefile | 1 + + src/gallium/state_trackers/vega/api_context.c | 3 + + src/gallium/state_trackers/vega/api_masks.c | 5 +- + src/gallium/state_trackers/vega/vg_api.c | 368 +++++++++++++++++++++++++ + src/gallium/state_trackers/vega/vg_api.h | 18 ++ + src/gallium/state_trackers/vega/vg_context.h | 6 + + 6 files changed, 398 insertions(+), 3 deletions(-) + create mode 100644 src/gallium/state_trackers/vega/vg_api.c + create mode 100644 src/gallium/state_trackers/vega/vg_api.h + +diff --git a/src/gallium/state_trackers/vega/Makefile b/src/gallium/state_trackers/vega/Makefile +index 037d8dc..1f0d0e5 100644 +--- a/src/gallium/state_trackers/vega/Makefile ++++ b/src/gallium/state_trackers/vega/Makefile +@@ -24,6 +24,7 @@ VG_SOURCES = \ + api_text.c \ + api_transform.c \ + vgu.c \ ++ vg_api.c \ + vg_context.c \ + vg_state.c \ + vg_tracker.c \ +diff --git a/src/gallium/state_trackers/vega/api_context.c b/src/gallium/state_trackers/vega/api_context.c +index 47db102..de3f44a 100644 +--- a/src/gallium/state_trackers/vega/api_context.c ++++ b/src/gallium/state_trackers/vega/api_context.c +@@ -26,6 +26,7 @@ + + #include "VG/openvg.h" + ++#include "vg_api.h" + #include "vg_context.h" + + #include "pipe/p_context.h" +@@ -55,6 +56,8 @@ void vgFlush(void) + + pipe = ctx->pipe; + pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); ++ ++ st_flush_frontbuffer(); + } + + void vgFinish(void) +diff --git a/src/gallium/state_trackers/vega/api_masks.c b/src/gallium/state_trackers/vega/api_masks.c +index 9c123a4..9a308f9 100644 +--- a/src/gallium/state_trackers/vega/api_masks.c ++++ b/src/gallium/state_trackers/vega/api_masks.c +@@ -29,6 +29,7 @@ + #include "mask.h" + #include "renderer.h" + ++#include "vg_api.h" + #include "vg_context.h" + #include "pipe/p_context.h" + #include "util/u_inlines.h" +@@ -115,9 +116,7 @@ clear_with_quad(struct vg_context *st, float x0, float y0, + x1, y1); + */ + +- if (st->pipe->screen && st->pipe->screen->update_buffer) +- st->pipe->screen->update_buffer( st->pipe->screen, +- st->pipe->priv ); ++ st_validate_buffer(); + + cso_save_blend(st->cso_context); + cso_save_rasterizer(st->cso_context); +diff --git a/src/gallium/state_trackers/vega/vg_api.c b/src/gallium/state_trackers/vega/vg_api.c +new file mode 100644 +index 0000000..dcde186 +--- /dev/null ++++ b/src/gallium/state_trackers/vega/vg_api.c +@@ -0,0 +1,368 @@ ++#include "state_tracker/st_api.h" ++ ++#include "pipe/p_context.h" ++#include "pipe/p_screen.h" ++#include "util/u_memory.h" ++#include "util/u_inlines.h" ++ ++#include "vg_api.h" ++#include "vg_context.h" ++#include "vg_tracker.h" /* for st_resize_framebuffer */ ++#include "image.h" ++ ++/** ++ * Return a reference to the pipe texture of the EGLImage. ++ */ ++struct pipe_texture * ++st_manager_reference_egl_image(VGeglImageKHR eglimg) ++{ ++ struct vg_context *ctx = vg_current_context(); ++ struct st_manager *smapi = ctx->iface.st_api_private; ++ struct pipe_texture *pt = NULL, *res; ++ ++ if (!smapi) ++ return NULL; ++ ++ res = (struct pipe_texture *) smapi->lock_resource(smapi, &ctx->iface, ++ ST_MANAGER_RESOURCE_EGL_IMAGE, (void *) eglimg); ++ pipe_texture_reference(&pt, res); ++ smapi->unlock_resource(smapi, &ctx->iface, ++ ST_MANAGER_RESOURCE_EGL_IMAGE, (void *) eglimg); ++ ++ return pt; ++} ++ ++/** ++ * Flush the front buffer if the current context renders to the front buffer. ++ */ ++void ++st_flush_frontbuffer(void) ++{ ++ struct vg_context *ctx = vg_current_context(); ++ struct st_framebuffer *stfb = ctx->draw_buffer; ++ ++ if (stfb) { ++ switch (stfb->strb_att) { ++ case ST_ATTACHMENT_FRONT_LEFT: ++ case ST_ATTACHMENT_FRONT_RIGHT: ++ stfb->iface->flush_front(stfb->iface, stfb->strb_att); ++ break; ++ default: ++ break; ++ } ++ } ++} ++ ++/** ++ * Re-validate the framebuffer. ++ */ ++void ++st_validate_buffer(void) ++{ ++ struct vg_context *ctx = vg_current_context(); ++ struct st_framebuffer *stfb = ctx->draw_buffer; ++ ++ if (stfb) ++ ctx->iface.notify_invalid_framebuffer(&ctx->iface, stfb->iface); ++} ++ ++ ++static void ++st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi, ++ struct st_framebuffer_iface *stfbi) ++{ ++ struct vg_context *ctx = (struct vg_context *) stctxi; ++ struct pipe_screen *screen = ctx->pipe->screen; ++ struct st_framebuffer *stfb = ctx->draw_buffer; ++ struct st_renderbuffer *rb; ++ struct pipe_texture *pt; ++ ++ /* no binding surface */ ++ if (!stfb) ++ return; ++ ++ assert(stfb->iface == stfbi); ++ if (stfb->strb_att == ST_ATTACHMENT_INVALID) ++ return; ++ ++ /* validate the fb */ ++ if (!stfb->iface->validate(stfb->iface, &stfb->strb_att, 1, &pt) || !pt) ++ return; ++ ++ rb = stfb->strb; ++ if (rb->texture == pt) { ++ pipe_texture_reference(&pt, NULL); ++ return; ++ } ++ ++ /* unreference existing ones */ ++ pipe_surface_reference(&rb->surface, NULL); ++ pipe_texture_reference(&rb->texture, NULL); ++ ++ rb->texture = pt; ++ rb->surface = screen->get_tex_surface(screen, rb->texture, 0, 0, 0, ++ PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE); ++ ++ rb->width = rb->surface->width; ++ rb->height = rb->surface->height; ++ ++ st_resize_framebuffer(stfb, rb->width, rb->height); ++} ++ ++static void ++st_context_flush(struct st_context_iface *stctxi, unsigned flags, ++ struct pipe_fence_handle **fence) ++{ ++ struct vg_context *ctx = (struct vg_context *) stctxi; ++ ctx->pipe->flush(ctx->pipe, flags, fence); ++} ++ ++static void * ++st_context_lock_resource(struct st_context_iface *stctxi, ++ enum st_context_resource_type type, void *res) ++{ ++ struct vg_image *img; ++ struct pipe_texture *pt = NULL; ++ ++ if (type != ST_CONTEXT_RESOURCE_OPENVG_PARENT_IMAGE || ++ (VGImage) res == VG_INVALID_HANDLE) ++ return NULL; ++ ++ /* mark the image locked? */ ++ img = (struct vg_image *) res; ++ pipe_texture_reference(&pt, img->texture); ++ ++ return (void *) pt; ++} ++ ++static void ++st_context_unlock_resource(struct st_context_iface *stctxi, ++ enum st_context_resource_type type, void *res) ++{ ++ struct vg_image *img; ++ struct pipe_texture *pt; ++ ++ if (type != ST_CONTEXT_RESOURCE_OPENVG_PARENT_IMAGE || ++ (VGImage) res == VG_INVALID_HANDLE) ++ return; ++ ++ img = (struct vg_image *) res; ++ pt = img->texture; ++ pipe_texture_reference(&pt, NULL); ++} ++ ++static void ++st_context_destroy(struct st_context_iface *stctxi) ++{ ++ struct vg_context *ctx = (struct vg_context *) stctxi; ++ vg_destroy_context(ctx); ++} ++ ++static struct st_context_iface * ++st_api_create_context(struct st_api *stapi, struct st_manager *smapi, ++ struct pipe_context *pipe, ++ const struct st_visual *visual, ++ struct st_context_iface *shared_stctxi) ++{ ++ struct vg_context *shared_ctx = (struct vg_context *) shared_stctxi; ++ struct vg_context *ctx; ++ ++ ctx = vg_create_context(pipe, NULL, shared_ctx); ++ if (!ctx) ++ return NULL; ++ ++ ctx->iface.api = ST_API_OPENVG; ++ ctx->iface.destroy = st_context_destroy; ++ ctx->iface.lock_resource = st_context_lock_resource; ++ ctx->iface.unlock_resource = st_context_unlock_resource; ++ ++ ctx->iface.notify_invalid_framebuffer = ++ st_context_notify_invalid_framebuffer; ++ ctx->iface.flush = st_context_flush; ++ ++ ctx->iface.teximage = NULL; ++ ctx->iface.copy = NULL; ++ ++ ctx->iface.st_api_private = (void *) smapi; ++ ++ return &ctx->iface; ++} ++ ++static struct st_renderbuffer * ++create_renderbuffer(enum pipe_format format) ++{ ++ struct st_renderbuffer *strb; ++ ++ strb = CALLOC_STRUCT(st_renderbuffer); ++ if (strb) ++ strb->format = format; ++ ++ return strb; ++} ++ ++static void ++destroy_renderbuffer(struct st_renderbuffer *strb) ++{ ++ pipe_surface_reference(&strb->surface, NULL); ++ pipe_texture_reference(&strb->texture, NULL); ++ free(strb); ++} ++ ++/** ++ * Return the attachment of the render buffer. ++ */ ++static enum st_attachment_type ++choose_attachment(struct st_framebuffer_iface *stfbi) ++{ ++ enum st_attachment_type statt; ++ ++ statt = stfbi->visual->render_buffer; ++ if (!st_visual_have_buffers(stfbi->visual, 1 << statt)) { ++ switch (statt) { ++ case ST_ATTACHMENT_BACK_LEFT: ++ statt = ST_ATTACHMENT_FRONT_LEFT; ++ break; ++ case ST_ATTACHMENT_BACK_RIGHT: ++ statt = ST_ATTACHMENT_FRONT_RIGHT; ++ break; ++ default: ++ break; ++ } ++ ++ if (!st_visual_have_buffers(stfbi->visual, 1 << statt)) ++ statt = ST_ATTACHMENT_INVALID; ++ } ++ ++ return statt; ++} ++ ++static boolean ++st_context_bind_framebuffers(struct st_context_iface *stctxi, ++ struct st_framebuffer_iface *stdrawi, ++ struct st_framebuffer_iface *streadi) ++{ ++ struct vg_context *ctx = (struct vg_context *) stctxi; ++ struct st_framebuffer *stfb; ++ ++ if (stdrawi != streadi) ++ return FALSE; ++ ++ if (ctx->draw_buffer) { ++ stfb = ctx->draw_buffer; ++ ++ /* free the existing fb */ ++ if (!stdrawi || ++ stfb->strb->format != stdrawi->visual->color_format || ++ stfb->dsrb->format != stdrawi->visual->depth_stencil_format) { ++ destroy_renderbuffer(stfb->strb); ++ destroy_renderbuffer(stfb->dsrb); ++ free(stfb); ++ ++ ctx->draw_buffer = NULL; ++ } ++ } ++ ++ if (!stdrawi) ++ return TRUE; ++ ++ /* create a new fb */ ++ if (!ctx->draw_buffer) { ++ stfb = CALLOC_STRUCT(st_framebuffer); ++ if (!stfb) ++ return FALSE; ++ ++ stfb->strb = create_renderbuffer(stdrawi->visual->color_format); ++ if (!stfb->strb) { ++ free(stfb); ++ return FALSE; ++ } ++ ++ stfb->dsrb = create_renderbuffer(stdrawi->visual->depth_stencil_format); ++ if (!stfb->dsrb) { ++ free(stfb->strb); ++ free(stfb); ++ return FALSE; ++ } ++ ++ stfb->width = 0; ++ stfb->height = 0; ++ ++ ctx->draw_buffer = stfb; ++ } ++ ++ ctx->draw_buffer->iface = stdrawi; ++ ctx->draw_buffer->strb_att = choose_attachment(stdrawi); ++ ++ return TRUE; ++} ++ ++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 vg_context *ctx = (struct vg_context *) stctxi; ++ ++ if (stctxi) ++ st_context_bind_framebuffers(stctxi, stdrawi, streadi); ++ vg_set_current_context(ctx); ++ ++ return TRUE; ++} ++ ++static struct st_context_iface * ++st_api_get_current(struct st_api *stapi) ++{ ++ struct vg_context *ctx = vg_current_context(); ++ ++ return (ctx) ? &ctx->iface : NULL; ++} ++ ++static st_proc_t ++st_api_get_proc_address(struct st_api *stapi, const char *procname) ++{ ++ /* TODO */ ++ return (st_proc_t) NULL; ++} ++ ++static boolean ++st_api_is_visual_supported(struct st_api *stapi, ++ const struct st_visual *visual) ++{ ++ /* the impl requires a depth/stencil buffer */ ++ if (visual->depth_stencil_format == PIPE_FORMAT_NONE) ++ return FALSE; ++ ++ return TRUE; ++} ++ ++static void ++st_api_destroy(struct st_api *stapi) ++{ ++ free(stapi); ++} ++ ++static 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; ++} ++ ++const struct st_module st_module_OpenVG = { ++ .api = ST_API_OPENVG, ++ .create_api = st_module_create_api, ++}; +diff --git a/src/gallium/state_trackers/vega/vg_api.h b/src/gallium/state_trackers/vega/vg_api.h +new file mode 100644 +index 0000000..06c65f0 +--- /dev/null ++++ b/src/gallium/state_trackers/vega/vg_api.h +@@ -0,0 +1,18 @@ ++#ifndef VG_API_H ++#define VG_API_H ++ ++#include "VG/openvg.h" ++#include "VG/vgext.h" ++ ++#include "pipe/p_state.h" ++ ++struct pipe_texture * ++st_manager_reference_egl_image(VGeglImageKHR eglimg); ++ ++void ++st_flush_frontbuffer(void); ++ ++void ++st_validate_buffer(void); ++ ++#endif /* VG_API_H */ +diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h +index bc88c8d..91300ff 100644 +--- a/src/gallium/state_trackers/vega/vg_context.h ++++ b/src/gallium/state_trackers/vega/vg_context.h +@@ -33,6 +33,7 @@ + #include "pipe/p_state.h" + #include "util/u_pointer.h" + #include "util/u_math.h" ++#include "state_tracker/st_api.h" + + #include "cso_cache/cso_hash.h" + #include "cso_cache/cso_context.h" +@@ -58,6 +59,9 @@ struct st_framebuffer { + + struct pipe_texture *blend_texture; + ++ struct st_framebuffer_iface *iface; ++ enum st_attachment_type strb_att; ++ + void *privateData; + }; + +@@ -84,6 +88,8 @@ enum dirty_state { + + struct vg_context + { ++ struct st_context_iface iface; ++ + struct pipe_context *pipe; + + struct { +-- +1.6.5 + diff --git a/sample-implementation-tmp/0004-st-egl-Add-support-for-loading-st_api-modules.patch b/sample-implementation-tmp/0004-st-egl-Add-support-for-loading-st_api-modules.patch new file mode 100644 index 0000000..a8dcce3 --- /dev/null +++ b/sample-implementation-tmp/0004-st-egl-Add-support-for-loading-st_api-modules.patch @@ -0,0 +1,189 @@ +From f8f6f9c3917a72da94b36912f1cbd0303899a191 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 4/5] st/egl: Add support for loading st_api modules. + +--- + src/gallium/state_trackers/egl/common/egl_st_api.c | 116 ++++++++++++++++++++ + src/gallium/state_trackers/egl/common/egl_st_api.h | 46 ++++++++ + 2 files changed, 162 insertions(+), 0 deletions(-) + create mode 100644 src/gallium/state_trackers/egl/common/egl_st_api.c + create mode 100644 src/gallium/state_trackers/egl/common/egl_st_api.h + +diff --git a/src/gallium/state_trackers/egl/common/egl_st_api.c b/src/gallium/state_trackers/egl/common/egl_st_api.c +new file mode 100644 +index 0000000..bfcc49e +--- /dev/null ++++ b/src/gallium/state_trackers/egl/common/egl_st_api.c +@@ -0,0 +1,116 @@ ++#include "util/u_memory.h" ++#include "util/u_dl.h" ++#include "eglimage.h" ++ ++#include "egl_st_api.h" ++ ++struct egl_g3d_st_manager { ++ struct st_manager base; ++ _EGLDisplay *display; ++}; ++ ++static INLINE struct egl_g3d_st_manager * ++egl_g3d_st_manager(struct st_manager *smapi) ++{ ++ return (struct egl_g3d_st_manager *) smapi; ++} ++ ++static void * ++egl_g3d_st_manager_lock_resource(struct st_manager *smapi, ++ struct st_context_iface *stctxi, ++ enum st_manager_resource_type type, ++ void *res) ++{ ++ struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi); ++ void *ret; ++ ++ switch (type) { ++ case ST_MANAGER_RESOURCE_EGL_IMAGE: ++ { ++ EGLImageKHR handle = (EGLImageKHR) res; ++ _EGLImage *img = _eglLookupImage(handle, gsmapi->display); ++ ++ /* TODO retrieve the pipe texture of the image */ ++ (void) img; ++ ++ ret = NULL; ++ } ++ break; ++ default: ++ ret = NULL; ++ break; ++ } ++ ++ return ret; ++} ++ ++static void ++egl_g3d_st_manager_unlock_resource(struct st_manager *smapi, ++ struct st_context_iface *stctxi, ++ enum st_manager_resource_type type, ++ void *res) ++{ ++} ++ ++struct st_manager * ++egl_g3d_create_st_manager(_EGLDisplay *dpy) ++{ ++ struct egl_g3d_st_manager *gsmapi; ++ ++ gsmapi = CALLOC_STRUCT(egl_g3d_st_manager); ++ if (gsmapi) { ++ gsmapi->display = dpy; ++ ++ gsmapi->base.lock_resource = egl_g3d_st_manager_lock_resource; ++ gsmapi->base.unlock_resource = egl_g3d_st_manager_unlock_resource; ++ } ++ ++ return &gsmapi->base;; ++} ++ ++void ++egl_g3d_destroy_st_manager(struct st_manager *smapi) ++{ ++ struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi); ++ free(gsmapi); ++} ++ ++struct st_api * ++egl_g3d_create_st_api(enum st_api_type api) ++{ ++ const char *stmod_name; ++ struct util_dl_library *lib; ++ const struct st_module *mod; ++ ++ switch (api) { ++ case ST_API_OPENGL: ++ stmod_name = ST_MODULE_OPENGL_SYMBOL; ++ break; ++ case ST_API_OPENGL_ES1: ++ stmod_name = ST_MODULE_OPENGL_ES1_SYMBOL; ++ break; ++ case ST_API_OPENGL_ES2: ++ stmod_name = ST_MODULE_OPENGL_ES2_SYMBOL; ++ break; ++ case ST_API_OPENVG: ++ stmod_name = ST_MODULE_OPENVG_SYMBOL; ++ break; ++ default: ++ stmod_name = NULL; ++ break; ++ } ++ if (!stmod_name) ++ return NULL; ++ ++ mod = NULL; ++ lib = util_dl_open(NULL); ++ if (lib) { ++ mod = (const struct st_module *) ++ util_dl_get_proc_address(lib, stmod_name); ++ util_dl_close(lib); ++ } ++ if (!mod || mod->api != api) ++ return NULL; ++ ++ return mod->create_api(); ++} +diff --git a/src/gallium/state_trackers/egl/common/egl_st_api.h b/src/gallium/state_trackers/egl/common/egl_st_api.h +new file mode 100644 +index 0000000..f39f318 +--- /dev/null ++++ b/src/gallium/state_trackers/egl/common/egl_st_api.h +@@ -0,0 +1,46 @@ ++#ifndef _EGL_ST_API_H_ ++#define _EGL_ST_API_H_ ++ ++#include "pipe/p_compiler.h" ++#include "state_tracker/st_api.h" ++#include "egltypedefs.h" ++ ++struct st_manager * ++egl_g3d_create_st_manager(_EGLDisplay *dpy); ++ ++void ++egl_g3d_destroy_st_manager(struct st_manager *smapi); ++ ++struct st_api * ++egl_g3d_create_st_api(enum st_api_type api); ++ ++/** ++ * Return the EGL_<api>_BIT of the st api. ++ */ ++static INLINE int ++egl_g3d_st_api_bit(enum st_api_type api) ++{ ++ int bit; ++ ++ switch (api) { ++ case ST_API_OPENGL: ++ bit = EGL_OPENGL_BIT; ++ break; ++ case ST_API_OPENGL_ES1: ++ bit = EGL_OPENGL_ES_BIT; ++ break; ++ case ST_API_OPENGL_ES2: ++ bit = EGL_OPENGL_ES2_BIT; ++ break; ++ case ST_API_OPENVG: ++ bit = EGL_OPENVG_BIT; ++ break; ++ default: ++ bit = 0; ++ break; ++ } ++ ++ return bit; ++} ++ ++#endif /* _EGL_ST_API_H_ */ +-- +1.6.5 + diff --git a/sample-implementation-tmp/0005-st-egl-Use-st_api.h-instead-of-st_public.h.patch b/sample-implementation-tmp/0005-st-egl-Use-st_api.h-instead-of-st_public.h.patch new file mode 100644 index 0000000..f5dbec7 --- /dev/null +++ b/sample-implementation-tmp/0005-st-egl-Use-st_api.h-instead-of-st_public.h.patch @@ -0,0 +1,1103 @@ +From 61f5bc139286416251a1e42fad239b53feaa654c Mon Sep 17 00:00:00 2001 +From: Chia-I Wu <olvaffe@gmail.com> +Date: Mon, 25 Jan 2010 22:18:29 +0800 +Subject: [PATCH 5/5] st/egl: Use st_api.h instead of st_public.h. + +--- + src/gallium/state_trackers/egl/common/egl_g3d.c | 539 ++++++++------------ + src/gallium/state_trackers/egl/common/egl_g3d.h | 19 +- + src/gallium/state_trackers/egl/common/egl_st.c | 131 ----- + src/gallium/state_trackers/egl/common/egl_st.h | 73 --- + .../state_trackers/egl/common/st_public_tmp.h | 20 - + 5 files changed, 233 insertions(+), 549 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..8c51e99 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 @@ + + #include "native.h" + #include "egl_g3d.h" +-#include "egl_st.h" +- +-/** +- * Validate the draw/read surfaces of the context. +- */ +-static void +-egl_g3d_validate_context(_EGLDisplay *dpy, _EGLContext *ctx) +-{ +- struct egl_g3d_display *gdpy = egl_g3d_display(dpy); +- struct pipe_screen *screen = gdpy->native->screen; +- struct egl_g3d_context *gctx = egl_g3d_context(ctx); +- const uint st_att_map[NUM_NATIVE_ATTACHMENTS] = { +- ST_SURFACE_FRONT_LEFT, +- ST_SURFACE_BACK_LEFT, +- ST_SURFACE_FRONT_RIGHT, +- ST_SURFACE_BACK_RIGHT, +- }; +- EGLint num_surfaces, s; +- +- /* validate draw and/or read buffers */ +- num_surfaces = (gctx->base.ReadSurface == gctx->base.DrawSurface) ? 1 : 2; +- for (s = 0; s < num_surfaces; s++) { +- struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS]; +- struct egl_g3d_surface *gsurf; +- struct egl_g3d_buffer *gbuf; +- EGLint att; +- +- if (s == 0) { +- gsurf = egl_g3d_surface(gctx->base.DrawSurface); +- gbuf = &gctx->draw; +- } +- else { +- gsurf = egl_g3d_surface(gctx->base.ReadSurface); +- gbuf = &gctx->read; +- } +- +- if (!gctx->force_validate) { +- unsigned int seq_num; +- +- gsurf->native->validate(gsurf->native, gbuf->attachment_mask, +- &seq_num, NULL, NULL, NULL); +- /* skip validation */ +- if (gsurf->sequence_number == seq_num) +- continue; +- } +- +- pipe_surface_reference(&gsurf->render_surface, NULL); +- memset(textures, 0, sizeof(textures)); +- +- gsurf->native->validate(gsurf->native, gbuf->attachment_mask, +- &gsurf->sequence_number, textures, +- &gsurf->base.Width, &gsurf->base.Height); +- for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) { +- struct pipe_texture *pt = textures[att]; +- struct pipe_surface *ps; +- +- if (native_attachment_mask_test(gbuf->attachment_mask, att) && pt) { +- ps = screen->get_tex_surface(screen, pt, 0, 0, 0, +- PIPE_BUFFER_USAGE_GPU_READ | +- PIPE_BUFFER_USAGE_GPU_WRITE); +- gctx->stapi->st_set_framebuffer_surface(gbuf->st_fb, +- st_att_map[att], ps); +- +- if (gsurf->render_att == att) +- pipe_surface_reference(&gsurf->render_surface, ps); +- +- pipe_surface_reference(&ps, NULL); +- pipe_texture_reference(&pt, NULL); +- } +- } +- +- gctx->stapi->st_resize_framebuffer(gbuf->st_fb, +- gsurf->base.Width, gsurf->base.Height); +- } +- +- gctx->force_validate = EGL_FALSE; +- +-} +- +-/** +- * Create a st_framebuffer. +- */ +-static struct st_framebuffer * +-create_framebuffer(_EGLContext *ctx, _EGLSurface *surf) +-{ +- struct egl_g3d_context *gctx = egl_g3d_context(ctx); +- struct egl_g3d_surface *gsurf = egl_g3d_surface(surf); +- struct egl_g3d_config *gconf = egl_g3d_config(gsurf->base.Config); +- +- return gctx->stapi->st_create_framebuffer(&gconf->native->mode, +- gconf->native->color_format, gconf->native->depth_format, +- gconf->native->stencil_format, +- gsurf->base.Width, gsurf->base.Height, &gsurf->base); +-} +- +-/** +- * Update the attachments of draw/read surfaces. +- */ +-static void +-egl_g3d_route_context(_EGLDisplay *dpy, _EGLContext *ctx) +-{ +- struct egl_g3d_context *gctx = egl_g3d_context(ctx); +- EGLint s; +- +- /* route draw and read buffers' attachments */ +- for (s = 0; s < 2; s++) { +- struct egl_g3d_surface *gsurf; +- struct egl_g3d_buffer *gbuf; +- +- if (s == 0) { +- gsurf = egl_g3d_surface(gctx->base.DrawSurface); +- gbuf = &gctx->draw; +- } +- else { +- gsurf = egl_g3d_surface(gctx->base.ReadSurface); +- gbuf = &gctx->read; +- } +- +- gbuf->attachment_mask = (1 << gsurf->render_att); +- +- /* FIXME OpenGL defaults to draw the front or back buffer when the +- * context is single-buffered or double-buffered respectively. In EGL, +- * however, the buffer to be drawn is determined by the surface, instead +- * of the context. As a result, rendering to a pixmap surface with a +- * double-buffered context does not work as expected. +- * +- * gctx->stapi->st_draw_front_buffer(gctx->st_ctx, natt == +- * NATIVE_ATTACHMENT_FRONT_LEFT); +- */ +- +- /* +- * FIXME If the back buffer is asked for here, and the front buffer is +- * later needed by the client API (e.g. glDrawBuffer is called to draw +- * the front buffer), it will create a new pipe texture and draw there. +- * One fix is to ask for both buffers here, but it would be a waste if +- * the front buffer is never used. A better fix is to add a callback to +- * the pipe screen with context private (just like flush_frontbuffer). +- */ +- } +-} +- +-/** +- * Reallocate the context's framebuffers after draw/read surfaces change. +- */ +-static EGLBoolean +-egl_g3d_realloc_context(_EGLDisplay *dpy, _EGLContext *ctx) +-{ +- struct egl_g3d_context *gctx = egl_g3d_context(ctx); +- struct egl_g3d_surface *gdraw = egl_g3d_surface(gctx->base.DrawSurface); +- struct egl_g3d_surface *gread = egl_g3d_surface(gctx->base.ReadSurface); +- +- /* unreference the old framebuffers */ +- if (gctx->draw.st_fb) { +- EGLBoolean is_equal = (gctx->draw.st_fb == gctx->read.st_fb); +- void *priv; +- +- priv = gctx->stapi->st_framebuffer_private(gctx->draw.st_fb); +- if (!gdraw || priv != (void *) &gdraw->base) { +- gctx->stapi->st_unreference_framebuffer(gctx->draw.st_fb); +- gctx->draw.st_fb = NULL; +- gctx->draw.attachment_mask = 0x0; +- } +- +- if (is_equal) { +- gctx->read.st_fb = NULL; +- gctx->draw.attachment_mask = 0x0; +- } +- else { +- priv = gctx->stapi->st_framebuffer_private(gctx->read.st_fb); +- if (!gread || priv != (void *) &gread->base) { +- gctx->stapi->st_unreference_framebuffer(gctx->read.st_fb); +- gctx->read.st_fb = NULL; +- gctx->draw.attachment_mask = 0x0; +- } +- } +- } +- +- if (!gdraw) +- return EGL_TRUE; +- +- /* create the draw fb */ +- if (!gctx->draw.st_fb) { +- gctx->draw.st_fb = create_framebuffer(&gctx->base, &gdraw->base); +- if (!gctx->draw.st_fb) +- return EGL_FALSE; +- } +- +- /* create the read fb */ +- if (!gctx->read.st_fb) { +- if (gread != gdraw) { +- gctx->read.st_fb = create_framebuffer(&gctx->base, &gread->base); +- if (!gctx->read.st_fb) { +- gctx->stapi->st_unreference_framebuffer(gctx->draw.st_fb); +- gctx->draw.st_fb = NULL; +- return EGL_FALSE; +- } +- } +- else { +- /* there is no st_reference_framebuffer... */ +- gctx->read.st_fb = gctx->draw.st_fb; +- } +- } +- +- egl_g3d_route_context(dpy, &gctx->base); +- gctx->force_validate = EGL_TRUE; +- +- return EGL_TRUE; +-} ++#include "egl_st_api.h" + + /** + * Return the state tracker for the given context. + */ +-static const struct egl_g3d_st * ++static struct st_api * + egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx) + { + struct egl_g3d_driver *gdrv = egl_g3d_driver(drv); +- const struct egl_g3d_st *stapi; ++ struct st_api *stapi; + EGLint idx = -1; + + switch (ctx->ClientAPI) { + case EGL_OPENGL_ES_API: + switch (ctx->ClientVersion) { + case 1: +- idx = EGL_G3D_ST_OPENGL_ES; ++ idx = ST_API_OPENGL_ES1; + break; + case 2: +- idx = EGL_G3D_ST_OPENGL_ES2; ++ idx = ST_API_OPENGL_ES2; + break; + default: + _eglLog(_EGL_WARNING, "unknown client version %d", +@@ -271,10 +64,10 @@ egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx) + } + break; + case EGL_OPENVG_API: +- idx = EGL_G3D_ST_OPENVG; ++ idx = ST_API_OPENVG; + break; + case EGL_OPENGL_API: +- idx = EGL_G3D_ST_OPENGL; ++ idx = ST_API_OPENGL; + break; + default: + _eglLog(_EGL_WARNING, "unknown client API 0x%04x", ctx->ClientAPI); +@@ -298,10 +91,10 @@ egl_g3d_init_st(_EGLDriver *drv) + if (gdrv->api_mask) + return; + +- for (i = 0; i < NUM_EGL_G3D_STS; i++) { +- gdrv->stapis[i] = egl_g3d_get_st(i); ++ for (i = 0; i < ST_API_COUNT; i++) { ++ gdrv->stapis[i] = egl_g3d_create_st_api(i); + if (gdrv->stapis[i]) +- gdrv->api_mask |= gdrv->stapis[i]->api_bit; ++ gdrv->api_mask |= egl_g3d_st_api_bit(i); + } + + if (gdrv->api_mask) +@@ -507,36 +300,6 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id) + return id; + } + +-/** +- * Flush the front buffer of the context's draw surface. +- */ +-static void +-egl_g3d_flush_frontbuffer(struct pipe_screen *screen, +- struct pipe_surface *surf, void *context_private) +-{ +- struct egl_g3d_context *gctx = egl_g3d_context(context_private); +- struct egl_g3d_surface *gsurf = egl_g3d_surface(gctx->base.DrawSurface); +- +- if (gsurf) +- gsurf->native->flush_frontbuffer(gsurf->native); +-} +- +-/** +- * Re-validate the context. +- */ +-static void +-egl_g3d_update_buffer(struct pipe_screen *screen, void *context_private) +-{ +- struct egl_g3d_context *gctx = egl_g3d_context(context_private); +- +- /** +- * It is likely that the surface has changed when this function is called. +- * Set force_validate to skip an unnecessary check. +- */ +- gctx->force_validate = EGL_TRUE; +- egl_g3d_validate_context(gctx->base.Resource.Display, &gctx->base); +-} +- + static EGLBoolean + egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy) + { +@@ -555,6 +318,9 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy) + free(dpy->Screens); + } + ++ if (gdpy->smapi) ++ egl_g3d_destroy_st_manager(gdpy->smapi); ++ + if (gdpy->native) + gdpy->native->destroy(gdpy->native); + +@@ -587,9 +353,6 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, + goto fail; + } + +- gdpy->native->screen->flush_frontbuffer = egl_g3d_flush_frontbuffer; +- gdpy->native->screen->update_buffer = egl_g3d_update_buffer; +- + egl_g3d_init_st(&gdrv->base); + dpy->ClientAPIsMask = gdrv->api_mask; + +@@ -598,6 +361,13 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, + goto fail; + } + ++ gdpy->smapi = egl_g3d_create_st_manager(dpy); ++ if (!gdpy->smapi) { ++ _eglError(EGL_NOT_INITIALIZED, ++ "eglInitialize(failed to create st manager)"); ++ goto fail; ++ } ++ + #ifdef EGL_MESA_screen_surface + /* enable MESA_screen_surface */ + if (gdpy->native->modeset) { +@@ -652,9 +422,9 @@ egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, + return NULL; + } + +- gctx->st_ctx = gctx->stapi->st_create_context(gctx->pipe, mode, +- (gshare) ? gshare->st_ctx : NULL); +- if (!gctx->st_ctx) { ++ gctx->stctxi = gctx->stapi->create_context(gctx->stapi, gdpy->smapi, ++ gctx->pipe, NULL, (gshare) ? gshare->stctxi : NULL); ++ if (!gctx->stctxi) { + gctx->pipe->destroy(gctx->pipe); + free(gctx); + return NULL; +@@ -675,9 +445,8 @@ destroy_context(_EGLDisplay *dpy, _EGLContext *ctx) + if (!dpy->Initialized) + _eglLog(_EGL_FATAL, "destroy a context with an unitialized display"); + +- egl_g3d_realloc_context(dpy, &gctx->base); +- /* it will destroy the associated pipe context */ +- gctx->stapi->st_destroy_context(gctx->st_ctx); ++ /* it will destroy the pipe context */ ++ gctx->stctxi->destroy(gctx->stctxi); + + free(gctx); + } +@@ -690,6 +459,140 @@ egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx) + return EGL_TRUE; + } + ++static boolean ++egl_g3d_framebuffer_flush_front(struct st_framebuffer_iface *stfbi, ++ enum st_attachment_type statt) ++{ ++ _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private; ++ struct egl_g3d_surface *gsurf = egl_g3d_surface(surf); ++ ++ return gsurf->native->flush_frontbuffer(gsurf->native); ++} ++ ++static boolean ++egl_g3d_framebuffer_validate(struct st_framebuffer_iface *stfbi, ++ const enum st_attachment_type *statts, ++ unsigned count, ++ struct pipe_texture **out) ++{ ++ _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private; ++ struct egl_g3d_surface *gsurf = egl_g3d_surface(surf); ++ struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS]; ++ uint attachment_mask = 0; ++ unsigned i; ++ ++ for (i = 0; i < count; i++) { ++ int natt; ++ ++ switch (statts[i]) { ++ case ST_ATTACHMENT_FRONT_LEFT: ++ natt = NATIVE_ATTACHMENT_FRONT_LEFT; ++ break; ++ case ST_ATTACHMENT_BACK_LEFT: ++ natt = NATIVE_ATTACHMENT_BACK_LEFT; ++ break; ++ case ST_ATTACHMENT_FRONT_RIGHT: ++ natt = NATIVE_ATTACHMENT_FRONT_RIGHT; ++ break; ++ case ST_ATTACHMENT_BACK_RIGHT: ++ natt = NATIVE_ATTACHMENT_BACK_RIGHT; ++ default: ++ natt = -1; ++ break; ++ } ++ ++ if (natt >= 0) ++ attachment_mask |= 1 << natt; ++ } ++ ++ if (!gsurf->native->validate(gsurf->native, attachment_mask, ++ &gsurf->sequence_number, textures, &gsurf->base.Width, ++ &gsurf->base.Height)) ++ return FALSE; ++ ++ for (i = 0; i < count; i++) { ++ struct pipe_texture *tex; ++ int natt; ++ ++ switch (statts[i]) { ++ case ST_ATTACHMENT_FRONT_LEFT: ++ natt = NATIVE_ATTACHMENT_FRONT_LEFT; ++ break; ++ case ST_ATTACHMENT_BACK_LEFT: ++ natt = NATIVE_ATTACHMENT_BACK_LEFT; ++ break; ++ case ST_ATTACHMENT_FRONT_RIGHT: ++ natt = NATIVE_ATTACHMENT_FRONT_RIGHT; ++ break; ++ case ST_ATTACHMENT_BACK_RIGHT: ++ natt = NATIVE_ATTACHMENT_BACK_RIGHT; ++ break; ++ default: ++ natt = -1; ++ break; ++ } ++ ++ if (natt >= 0) { ++ tex = textures[natt]; ++ ++ if (attachment_mask & (1 << natt)) { ++ /* transfer the ownership to the caller */ ++ out[i] = tex; ++ attachment_mask &= ~(1 << natt); ++ } ++ else { ++ /* the attachment is listed more than once */ ++ pipe_texture_reference(&out[i], tex); ++ } ++ } ++ } ++ ++ return TRUE; ++} ++ ++static EGLBoolean ++init_surface_framebuffer(_EGLSurface *surf, _EGLConfig *conf) ++{ ++ 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.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; ++ stfbi->validate = egl_g3d_framebuffer_validate; ++ stfbi->st_manager_private = (void *) &gsurf->base; ++ ++ gsurf->stfbi = stfbi; ++ ++ return EGL_TRUE; ++} ++ + static EGLBoolean + init_surface_geometry(_EGLSurface *surf) + { +@@ -727,16 +630,13 @@ egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy, + return NULL; + } + +- if (!init_surface_geometry(&gsurf->base)) { ++ if (!init_surface_geometry(&gsurf->base) || ++ !init_surface_framebuffer(&gsurf->base, &gconf->base)) { + gsurf->native->destroy(gsurf->native); + free(gsurf); + return NULL; + } + +- gsurf->render_att = (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER || +- !gconf->native->mode.doubleBufferMode) ? +- NATIVE_ATTACHMENT_FRONT_LEFT : NATIVE_ATTACHMENT_BACK_LEFT; +- + return &gsurf->base; + } + +@@ -767,14 +667,13 @@ egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy, + return NULL; + } + +- if (!init_surface_geometry(&gsurf->base)) { ++ if (!init_surface_geometry(&gsurf->base) || ++ !init_surface_framebuffer(&gsurf->base, &gconf->base)) { + gsurf->native->destroy(gsurf->native); + free(gsurf); + return NULL; + } + +- gsurf->render_att = NATIVE_ATTACHMENT_FRONT_LEFT; +- + return &gsurf->base; + } + +@@ -805,15 +704,13 @@ egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, + return NULL; + } + +- if (!init_surface_geometry(&gsurf->base)) { ++ if (!init_surface_geometry(&gsurf->base) || ++ !init_surface_framebuffer(&gsurf->base, &gconf->base)) { + gsurf->native->destroy(gsurf->native); + free(gsurf); + return NULL; + } + +- gsurf->render_att = (!gconf->native->mode.doubleBufferMode) ? +- NATIVE_ATTACHMENT_FRONT_LEFT : NATIVE_ATTACHMENT_BACK_LEFT; +- + return &gsurf->base; + } + +@@ -831,6 +728,7 @@ destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf) + + pipe_surface_reference(&gsurf->render_surface, NULL); + gsurf->native->destroy(gsurf->native); ++ free(gsurf->stfbi); + free(gsurf); + } + +@@ -848,6 +746,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); ++ struct egl_g3d_surface *gread = egl_g3d_surface(read); + struct egl_g3d_context *old_gctx; + EGLBoolean ok = EGL_TRUE; + +@@ -858,34 +757,29 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy, + + if (old_gctx) { + /* flush old context */ +- old_gctx->stapi->st_flush(old_gctx->st_ctx, ++ old_gctx->stctxi->flush(old_gctx->stctxi, + PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); +- +- /* +- * The old context is no longer current, and egl_g3d_realloc_context() +- * should be called to destroy the framebuffers. However, it is possible +- * that it will be made current again with the same draw/read surfaces. +- * It might be better to keep it around. +- */ + } + + if (gctx) { +- ok = egl_g3d_realloc_context(dpy, &gctx->base); ++ ok = gctx->stapi->make_current(gctx->stapi, gctx->stctxi, ++ (gdraw) ? gdraw->stfbi : NULL, (gread) ? gread->stfbi : NULL); + if (ok) { +- ok = gctx->stapi->st_make_current(gctx->st_ctx, +- gctx->draw.st_fb, gctx->read.st_fb); +- if (ok) { +- egl_g3d_validate_context(dpy, &gctx->base); +- if (gdraw->base.Type == EGL_WINDOW_BIT) { +- gctx->base.WindowRenderBuffer = +- (gdraw->render_att == NATIVE_ATTACHMENT_FRONT_LEFT) ? +- EGL_SINGLE_BUFFER : EGL_BACK_BUFFER; +- } ++ gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gdraw->stfbi); ++ if (gread != gdraw) { ++ gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, ++ gread->stfbi); ++ } ++ ++ if (gdraw->base.Type == EGL_WINDOW_BIT) { ++ gctx->base.WindowRenderBuffer = ++ (gdraw->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT) ? ++ EGL_SINGLE_BUFFER : EGL_BACK_BUFFER; + } + } + } + else if (old_gctx) { +- ok = old_gctx->stapi->st_make_current(NULL, NULL, NULL); ++ ok = old_gctx->stapi->make_current(old_gctx->stapi, NULL, NULL, NULL); + old_gctx->base.WindowRenderBuffer = EGL_NONE; + } + +@@ -912,15 +806,17 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf) + return EGL_TRUE; + + /* or when the surface is single-buffered */ +- if (gsurf->render_att == NATIVE_ATTACHMENT_FRONT_LEFT) ++ if (gsurf->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT) + return EGL_TRUE; + + if (ctx && ctx->DrawSurface == surf) + gctx = egl_g3d_context(ctx); + + /* flush if the surface is current */ +- if (gctx) +- gctx->stapi->st_notify_swapbuffers(gctx->draw.st_fb); ++ if (gctx) { ++ gctx->stctxi->flush(gctx->stctxi, ++ PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); ++ } + + /* + * We drew on the back buffer, unless there was no back buffer. +@@ -933,11 +829,9 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf) + if (gctx) { + struct egl_g3d_config *gconf = egl_g3d_config(gsurf->base.Config); + +- /* force validation if the swap method is not copy */ +- if (gconf->native->mode.swapMethod != GLX_SWAP_COPY_OML) { +- gctx->force_validate = EGL_TRUE; +- egl_g3d_validate_context(dpy, &gctx->base); +- } ++ /* validate if the swap method is not copy */ ++ if (gconf->native->mode.swapMethod != GLX_SWAP_COPY_OML) ++ gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gsurf->stfbi); + } + + return EGL_TRUE; +@@ -1011,7 +905,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); +- gctx->stapi->st_flush(gctx->st_ctx, ++ gctx->stctxi->flush(gctx->stctxi, + PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + } + +@@ -1041,8 +935,16 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, + static EGLBoolean + egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx) + { ++ struct egl_g3d_display *gdpy = egl_g3d_display(dpy); + struct egl_g3d_context *gctx = egl_g3d_context(ctx); +- gctx->stapi->st_finish(gctx->st_ctx); ++ struct pipe_screen *screen = gdpy->native->screen; ++ struct pipe_fence_handle *fence = NULL; ++ ++ gctx->stctxi->flush(gctx->stctxi, ++ PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence); ++ screen->fence_finish(screen, fence, 0); ++ screen->fence_reference(screen, &fence, NULL); ++ + return EGL_TRUE; + } + +@@ -1072,10 +974,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); + +- for (i = 0; i < NUM_EGL_G3D_STS; i++) { +- const struct egl_g3d_st *stapi = gdrv->stapis[i]; ++ for (i = 0; i < ST_API_COUNT; i++) { ++ struct st_api *stapi = gdrv->stapis[i]; + if (stapi) { +- proc = (_EGLProc) stapi->st_get_proc_address(procname); ++ proc = (_EGLProc) stapi->get_proc_address(stapi, procname); + if (proc) + return proc; + } +@@ -1091,8 +993,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; +- enum pipe_format target_format; +- int target; ++ enum pipe_format internal_format; ++ enum st_texture_type target; + + if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT) + return _eglError(EGL_BAD_SURFACE, "eglBindTexImage"); +@@ -1103,10 +1005,10 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy, + + switch (gsurf->base.TextureFormat) { + case EGL_TEXTURE_RGB: +- target_format = PIPE_FORMAT_R8G8B8_UNORM; ++ internal_format = PIPE_FORMAT_R8G8B8_UNORM; + break; + case EGL_TEXTURE_RGBA: +- target_format = PIPE_FORMAT_A8R8G8B8_UNORM; ++ internal_format = PIPE_FORMAT_A8R8G8B8_UNORM; + break; + default: + return _eglError(EGL_BAD_MATCH, "eglBindTexImage"); +@@ -1128,15 +1030,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); +- gctx->stapi->st_flush(gctx->st_ctx, ++ gctx->stctxi->flush(gctx->stctxi, + PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + } + + gctx = egl_g3d_context(es1); +- gctx->stapi->st_bind_texture_surface(gsurf->render_surface, +- target, gsurf->base.MipmapLevel, target_format); +- +- gsurf->base.BoundToTexture = EGL_TRUE; ++ if (gctx->stctxi->teximage) { ++ if (!gctx->stctxi->teximage(gctx->stctxi, target, ++ gsurf->base.MipmapLevel, internal_format, ++ gsurf->render_surface->texture, gsurf->base.MipmapTexture)) ++ return EGL_FALSE; ++ gsurf->base.BoundToTexture = EGL_TRUE; ++ } + + return EGL_TRUE; + } +@@ -1158,9 +1063,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? */ +- if (gctx) +- gctx->stapi->st_unbind_texture_surface(gsurf->render_surface, +- ST_TEXTURE_2D, gsurf->base.MipmapLevel); ++ if (gctx) { ++ gctx->stctxi->teximage(gctx->stctxi, ST_TEXTURE_2D, ++ gsurf->base.MipmapLevel, PIPE_FORMAT_NONE, NULL, FALSE); ++ } + } + + gsurf->base.BoundToTexture = EGL_FALSE; +@@ -1198,9 +1104,6 @@ egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy, + return NULL; + } + +- gsurf->render_att = (!gconf->native->mode.doubleBufferMode) ? +- NATIVE_ATTACHMENT_FRONT_LEFT : NATIVE_ATTACHMENT_BACK_LEFT; +- + return &gsurf->base; + } + +@@ -1294,6 +1197,12 @@ static void + egl_g3d_unload(_EGLDriver *drv) + { + struct egl_g3d_driver *gdrv = egl_g3d_driver(drv); ++ EGLint i; ++ ++ for (i = 0; i < ST_API_COUNT; i++) { ++ if (gdrv->stapis[i]) ++ gdrv->stapis[i]->destroy(gdrv->stapis[i]); ++ } + + 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 3dae8c4..e2b73bb 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 @@ + #include "eglmode.h" + + #include "native.h" +-#include "egl_st.h" ++#include "egl_st_api.h" + + struct egl_g3d_driver { + _EGLDriver base; +- const struct egl_g3d_st *stapis[NUM_EGL_G3D_STS]; ++ struct st_api *stapis[ST_API_COUNT]; + EGLint api_mask; + + EGLint probe_key; +@@ -50,28 +50,27 @@ struct egl_g3d_driver { + + struct egl_g3d_display { + struct native_display *native; +-}; + +-struct egl_g3d_buffer { +- struct st_framebuffer *st_fb; +- uint attachment_mask; ++ struct st_manager *smapi; + }; + + struct egl_g3d_context { + _EGLContext base; + +- const struct egl_g3d_st *stapi; ++ struct st_api *stapi; + struct pipe_context *pipe; + +- struct st_context *st_ctx; ++ struct st_context_iface *stctxi; + EGLBoolean force_validate; +- struct egl_g3d_buffer draw, read; + }; + + struct egl_g3d_surface { + _EGLSurface base; ++ ++ struct st_visual stvis; ++ struct st_framebuffer_iface *stfbi; ++ + struct native_surface *native; +- enum native_attachment render_att; + struct pipe_surface *render_surface; + unsigned int sequence_number; + }; +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 +--- a/src/gallium/state_trackers/egl/common/egl_st.c ++++ /dev/null +@@ -1,131 +0,0 @@ +-/* +- * Mesa 3-D graphics library +- * Version: 7.8 +- * +- * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org> +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included +- * in all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +- */ +- +-#include <dlfcn.h> +-#include "pipe/p_compiler.h" +-#include "util/u_memory.h" +-#include "egllog.h" +-#include "EGL/egl.h" /* for EGL_api_BIT */ +- +-#include "egl_st.h" +- +-#ifndef HAVE_DLADDR +-#define HAVE_DLADDR 1 +-#endif +- +-#if HAVE_DLADDR +- +-static const char * +-egl_g3d_st_names[] = { +-#define ST_PUBLIC(name, ...) #name, +-#include "st_public_tmp.h" +- NULL +-}; +- +-static boolean +-egl_g3d_fill_st(struct egl_g3d_st *stapi, void *sym) +-{ +- st_proc *procs = (st_proc *) stapi; +- void *handle; +- Dl_info info; +- const char **name; +- +- if (!dladdr(sym, &info)) +- return FALSE; +- handle = dlopen(info.dli_fname, RTLD_LAZY | RTLD_LOCAL | RTLD_NODELETE); +- if (!handle) +- return FALSE; +- +- for (name = egl_g3d_st_names; *name; name++) { +- st_proc proc = (st_proc) dlsym(handle, *name); +- if (!proc) { +- _eglLog(_EGL_WARNING, "%s is missing in %s", *name, info.dli_fname); +- memset(stapi, 0, sizeof(*stapi)); +- dlclose(handle); +- return FALSE; +- } +- *procs++ = proc; +- } +- +- dlclose(handle); +- return TRUE; +-} +- +-#else /* HAVE_DLADDR */ +- +-static boolean +-egl_g3d_fill_st(struct egl_g3d_st *stapi, void *sym) +-{ +-#define ST_PUBLIC(name, ...) stapi->name = name; +-#include "st_public_tmp.h" +- return TRUE; +-} +- +-#endif /* HAVE_DLADDR */ +- +-static boolean +-egl_g3d_init_st(struct egl_g3d_st *stapi, const char *api) +-{ +- void *handle, *sym; +- boolean res = FALSE; +- +- /* already initialized */ +- if (stapi->st_notify_swapbuffers != NULL) +- return TRUE; +- +- handle = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL); +- if (!handle) +- return FALSE; +- +- sym = dlsym(handle, api); +- if (sym && egl_g3d_fill_st(stapi, sym)) +- res = TRUE; +- +- dlclose(handle); +- return res; +-} +- +-static struct { +- const char *symbol; +- EGLint api_bit; +-} egl_g3d_st_info[NUM_EGL_G3D_STS] = { +- { "st_api_OpenGL_ES1", EGL_OPENGL_ES_BIT }, +- { "st_api_OpenVG", EGL_OPENVG_BIT }, +- { "st_api_OpenGL_ES2", EGL_OPENGL_ES2_BIT }, +- { "st_api_OpenGL", EGL_OPENGL_BIT }, +-}; +- +-const struct egl_g3d_st * +-egl_g3d_get_st(enum egl_g3d_st_api api) +-{ +- static struct egl_g3d_st all_trackers[NUM_EGL_G3D_STS]; +- +- if (egl_g3d_init_st(&all_trackers[api], egl_g3d_st_info[api].symbol)) { +- all_trackers[api].api_bit = egl_g3d_st_info[api].api_bit; +- return &all_trackers[api]; +- } +- else { +- return NULL; +- } +-} +diff --git a/src/gallium/state_trackers/egl/common/egl_st.h b/src/gallium/state_trackers/egl/common/egl_st.h +deleted file mode 100644 +index 8fb464b..0000000 +--- a/src/gallium/state_trackers/egl/common/egl_st.h ++++ /dev/null +@@ -1,73 +0,0 @@ +-/* +- * Mesa 3-D graphics library +- * Version: 7.8 +- * +- * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org> +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included +- * in all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +- */ +- +-#ifndef _EGL_ST_H_ +-#define _EGL_ST_H_ +- +-#include "GL/gl.h" /* for GL types */ +-#include "GL/internal/glcore.h" /* for __GLcontextModes */ +- +-#include "pipe/p_compiler.h" +-#include "pipe/p_format.h" +-#include "pipe/p_context.h" +- +-/* avoid calling st functions directly */ +-#if 1 +- +-#define ST_SURFACE_FRONT_LEFT 0 +-#define ST_SURFACE_BACK_LEFT 1 +-#define ST_SURFACE_FRONT_RIGHT 2 +-#define ST_SURFACE_BACK_RIGHT 3 +- +-#define ST_TEXTURE_2D 0x2 +- +-struct st_context; +-struct st_framebuffer; +-typedef void (*st_proc)(); +- +-#else +-#include "state_tracker/st_public.h" +-#endif +- +-/* remember to update egl_g3d_get_st() when update the enums */ +-enum egl_g3d_st_api { +- EGL_G3D_ST_OPENGL_ES = 0, +- EGL_G3D_ST_OPENVG, +- EGL_G3D_ST_OPENGL_ES2, +- EGL_G3D_ST_OPENGL, +- +- NUM_EGL_G3D_STS +-}; +- +-struct egl_g3d_st { +-#define ST_PUBLIC(name, ret, ...) ret (*name)(__VA_ARGS__); +-#include "st_public_tmp.h" +- /* fields must be added here */ +- EGLint api_bit; +-}; +- +-const struct egl_g3d_st * +-egl_g3d_get_st(enum egl_g3d_st_api api); +- +-#endif /* _EGL_ST_H_ */ +diff --git a/src/gallium/state_trackers/egl/common/st_public_tmp.h b/src/gallium/state_trackers/egl/common/st_public_tmp.h +deleted file mode 100644 +index 507a0ec..0000000 +--- a/src/gallium/state_trackers/egl/common/st_public_tmp.h ++++ /dev/null +@@ -1,20 +0,0 @@ +-ST_PUBLIC(st_create_context, struct st_context *, struct pipe_context *pipe, const __GLcontextModes *visual, struct st_context *share) +-ST_PUBLIC(st_destroy_context, void, struct st_context *st) +-ST_PUBLIC(st_copy_context_state, void, struct st_context *dst, struct st_context *src, uint mask) +-ST_PUBLIC(st_create_framebuffer, struct st_framebuffer *, const __GLcontextModes *visual, enum pipe_format colorFormat, enum pipe_format depthFormat, enum pipe_format stencilFormat, uint width, uint height, void *privateData) +-ST_PUBLIC(st_resize_framebuffer, void, struct st_framebuffer *stfb, uint width, uint height) +-ST_PUBLIC(st_set_framebuffer_surface, void, struct st_framebuffer *stfb, uint surfIndex, struct pipe_surface *surf) +-ST_PUBLIC(st_get_framebuffer_dimensions, void, struct st_framebuffer *stfb, uint *width, uint *height) +-ST_PUBLIC(st_get_framebuffer_surface, int, struct st_framebuffer *stfb, uint surfIndex, struct pipe_surface **surface) +-ST_PUBLIC(st_get_framebuffer_texture, int, struct st_framebuffer *stfb, uint surfIndex, struct pipe_texture **texture) +-ST_PUBLIC(st_framebuffer_private, void *, struct st_framebuffer *stfb) +-ST_PUBLIC(st_unreference_framebuffer, void, struct st_framebuffer *stfb) +-ST_PUBLIC(st_make_current, GLboolean, struct st_context *st, struct st_framebuffer *draw, struct st_framebuffer *read) +-ST_PUBLIC(st_get_current, struct st_context *, void) +-ST_PUBLIC(st_flush, void, struct st_context *st, uint pipeFlushFlags, struct pipe_fence_handle **fence) +-ST_PUBLIC(st_finish, void, struct st_context *st) +-ST_PUBLIC(st_notify_swapbuffers, void, struct st_framebuffer *stfb) +-ST_PUBLIC(st_bind_texture_surface, int, struct pipe_surface *ps, int target, int level, enum pipe_format format) +-ST_PUBLIC(st_unbind_texture_surface, int, struct pipe_surface *ps, int target, int level) +-ST_PUBLIC(st_get_proc_address, st_proc, const char *procname) +-#undef ST_PUBLIC +-- +1.6.5 + |