#include "util/list.h"
struct hash_table;
-static struct hash_table *st_fbi_ht; /* framebuffer iface objects hash table */
+struct st_manager_private
+{
+ struct hash_table *stfbi_ht; /* framebuffer iface objects hash table */
+ mtx_t st_mutex;
+};
-static mtx_t st_mutex = _MTX_INITIALIZER_NP;
+static void st_manager_destroy(struct st_manager *);
/**
* Map an attachment to a buffer index.
static boolean
-st_framebuffer_iface_lookup(const struct st_framebuffer_iface *stfbi)
+st_framebuffer_iface_lookup(struct st_manager *smapi,
+ const struct st_framebuffer_iface *stfbi)
{
+ struct st_manager_private *smPriv =
+ (struct st_manager_private *)smapi->st_manager_private;
struct hash_entry *entry;
- mtx_lock(&st_mutex);
- entry = _mesa_hash_table_search(st_fbi_ht, stfbi);
- mtx_unlock(&st_mutex);
+ assert(smPriv);
+ assert(smPriv->stfbi_ht);
+
+ mtx_lock(&smPriv->st_mutex);
+ entry = _mesa_hash_table_search(smPriv->stfbi_ht, stfbi);
+ mtx_unlock(&smPriv->st_mutex);
return entry != NULL;
}
static boolean
-st_framebuffer_iface_insert(struct st_framebuffer_iface *stfbi)
+st_framebuffer_iface_insert(struct st_manager *smapi,
+ struct st_framebuffer_iface *stfbi)
{
+ struct st_manager_private *smPriv =
+ (struct st_manager_private *)smapi->st_manager_private;
struct hash_entry *entry;
- mtx_lock(&st_mutex);
- entry = _mesa_hash_table_insert(st_fbi_ht, stfbi, stfbi);
- mtx_unlock(&st_mutex);
+ assert(smPriv);
+ assert(smPriv->stfbi_ht);
+
+ mtx_lock(&smPriv->st_mutex);
+ entry = _mesa_hash_table_insert(smPriv->stfbi_ht, stfbi, stfbi);
+ mtx_unlock(&smPriv->st_mutex);
return entry != NULL;
}
static void
-st_framebuffer_iface_remove(struct st_framebuffer_iface *stfbi)
+st_framebuffer_iface_remove(struct st_manager *smapi,
+ struct st_framebuffer_iface *stfbi)
{
+ struct st_manager_private *smPriv =
+ (struct st_manager_private *)smapi->st_manager_private;
struct hash_entry *entry;
- mtx_lock(&st_mutex);
- entry = _mesa_hash_table_search(st_fbi_ht, stfbi);
+ if (!smPriv || !smPriv->stfbi_ht)
+ return;
+
+ mtx_lock(&smPriv->st_mutex);
+ entry = _mesa_hash_table_search(smPriv->stfbi_ht, stfbi);
if (!entry)
goto unlock;
- _mesa_hash_table_remove(st_fbi_ht, entry);
+ _mesa_hash_table_remove(smPriv->stfbi_ht, entry);
unlock:
- mtx_unlock(&st_mutex);
+ mtx_unlock(&smPriv->st_mutex);
}
st_api_destroy_drawable(struct st_api *stapi,
struct st_framebuffer_iface *stfbi)
{
- st_framebuffer_iface_remove(stfbi);
+ if (!stfbi)
+ return;
+
+ st_framebuffer_iface_remove(stfbi->state_manager, stfbi);
}
static void
st_framebuffers_purge(struct st_context *st)
{
+ struct st_context_iface *st_iface = &st->iface;
+ struct st_manager *smapi = st_iface->state_manager;
struct st_framebuffer *stfb, *next;
+ assert(smapi);
+
LIST_FOR_EACH_ENTRY_SAFE_REV(stfb, next, &st->winsys_buffers, head) {
+ struct st_framebuffer_iface *stfbi = stfb->iface;
+
+ assert(stfbi);
+
/**
* If the corresponding framebuffer interface object no longer exists,
* remove the framebuffer object from the context's winsys buffers list,
* and unreference the framebuffer object, so its resources can be
* deleted.
*/
- if (!st_framebuffer_iface_lookup(stfb->iface)) {
+ if (!st_framebuffer_iface_lookup(smapi, stfbi)) {
LIST_DEL(&stfb->head);
st_framebuffer_reference(&stfb, NULL);
}
st_flush(st, fence, pipe_flags);
- if ((flags & ST_FLUSH_WAIT) && fence) {
+ if ((flags & ST_FLUSH_WAIT) && fence && *fence) {
st->pipe->screen->fence_finish(st->pipe->screen, NULL, *fence,
PIPE_TIMEOUT_INFINITE);
st->pipe->screen->fence_reference(st->pipe->screen, fence, NULL);
if (flags & ST_FLUSH_FRONT)
st_manager_flush_frontbuffer(st);
+
+ /* DRI3 changes the framebuffer after SwapBuffers, but we need to invoke
+ * st_manager_validate_framebuffers to notice that.
+ *
+ * Set gfx_shaders_may_be_dirty to invoke st_validate_state in the next
+ * draw call, which will invoke st_manager_validate_framebuffers, but it
+ * won't dirty states if there is no change.
+ */
+ if (flags & ST_FLUSH_END_OF_FRAME)
+ st->gfx_shaders_may_be_dirty = true;
}
static boolean
stObj = st_texture_object(texObj);
/* switch to surface based */
if (!stObj->surface_based) {
- _mesa_clear_texture_object(ctx, texObj);
+ _mesa_clear_texture_object(ctx, texObj, NULL);
stObj->surface_based = GL_TRUE;
}
return NULL;
}
+ /* Create a hash table for the framebuffer interface objects
+ * if it has not been created for this st manager.
+ */
+ if (smapi->st_manager_private == NULL) {
+ struct st_manager_private *smPriv;
+
+ smPriv = CALLOC_STRUCT(st_manager_private);
+ mtx_init(&smPriv->st_mutex, mtx_plain);
+ smPriv->stfbi_ht = _mesa_hash_table_create(NULL,
+ st_framebuffer_iface_hash,
+ st_framebuffer_iface_equal);
+ smapi->st_manager_private = smPriv;
+ smapi->destroy = st_manager_destroy;
+ }
+
if (attribs->flags & ST_CONTEXT_FLAG_ROBUST_ACCESS)
ctx_flags |= PIPE_CONTEXT_ROBUST_BUFFER_ACCESS;
st->iface.st_context_private = (void *) smapi;
st->iface.cso_context = st->cso_context;
st->iface.pipe = st->pipe;
+ st->iface.state_manager = smapi;
*error = ST_CONTEXT_SUCCESS;
return &st->iface;
/* add the referenced framebuffer interface object to
* the framebuffer interface object hash table.
*/
- if (!st_framebuffer_iface_insert(stfbi)) {
+ if (!st_framebuffer_iface_insert(stfbi->state_manager, stfbi)) {
st_framebuffer_reference(&cur, NULL);
return NULL;
}
static void
st_api_destroy(struct st_api *stapi)
{
- _mesa_hash_table_destroy(st_fbi_ht, NULL);
- mtx_destroy(&st_mutex);
}
/**
if (stfb)
strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
- if (!strb)
- return;
- /* never a dummy fb */
- stfb->iface->flush_front(&st->iface, stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
+ /* Do we have a front color buffer and has it been drawn to since last
+ * frontbuffer flush?
+ */
+ if (strb && strb->defined) {
+ stfb->iface->flush_front(&st->iface, stfb->iface,
+ ST_ATTACHMENT_FRONT_LEFT);
+ strb->defined = GL_FALSE;
+
+ /* Trigger an update of strb->defined on next draw */
+ st->dirty |= ST_NEW_FB_STATE;
+ }
}
/**
st_context_validate(st, stdraw, stread);
}
+
+/**
+ * Flush any outstanding swapbuffers on the current draw framebuffer.
+ */
+void
+st_manager_flush_swapbuffers(void)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct st_context *st = (ctx) ? ctx->st : NULL;
+ struct st_framebuffer *stfb;
+
+ if (!st)
+ return;
+
+ stfb = st_ws_framebuffer(ctx->DrawBuffer);
+ if (!stfb || !stfb->iface->flush_swapbuffers)
+ return;
+
+ stfb->iface->flush_swapbuffers(&st->iface, stfb->iface);
+}
+
+
/**
* Add a color renderbuffer on demand. The FBO must correspond to a window,
* not a user-created FBO.
return TRUE;
}
+static void
+st_manager_destroy(struct st_manager *smapi)
+{
+ struct st_manager_private *smPriv = smapi->st_manager_private;
+
+ if (smPriv && smPriv->stfbi_ht) {
+ _mesa_hash_table_destroy(smPriv->stfbi_ht, NULL);
+ mtx_destroy(&smPriv->st_mutex);
+ free(smPriv);
+ smapi->st_manager_private = NULL;
+ }
+}
+
static unsigned
get_version(struct pipe_screen *screen,
struct st_config_options *options, gl_api api)
_mesa_init_extensions(&extensions);
st_init_limits(screen, &consts, &extensions);
- st_init_extensions(screen, &consts, &extensions, options, GL_TRUE);
+ st_init_extensions(screen, &consts, &extensions, options);
return _mesa_get_version(&extensions, &consts, api);
}
struct st_api *
st_gl_api_create(void)
{
- /* Create a hash table for all the framebuffer interface objects */
-
- mtx_init(&st_mutex, mtx_plain);
- st_fbi_ht = _mesa_hash_table_create(NULL,
- st_framebuffer_iface_hash,
- st_framebuffer_iface_equal);
-
return (struct st_api *) &st_gl_api;
}