#include "main/fbobject.h"
#include "main/renderbuffer.h"
#include "main/version.h"
+#include "util/hash_table.h"
#include "st_texture.h"
#include "st_context.h"
#include "st_debug.h"
#include "st_extensions.h"
#include "st_format.h"
+#include "st_cb_bitmap.h"
#include "st_cb_fbo.h"
#include "st_cb_flush.h"
#include "st_manager.h"
+#include "st_sampler_view.h"
#include "state_tracker/st_gl_api.h"
#include "pipe/p_context.h"
#include "pipe/p_screen.h"
#include "util/u_format.h"
+#include "util/u_helpers.h"
#include "util/u_pointer.h"
#include "util/u_inlines.h"
#include "util/u_atomic.h"
#include "util/u_surface.h"
#include "util/list.h"
+struct hash_table;
+struct st_manager_private
+{
+ struct hash_table *stfbi_ht; /* framebuffer iface objects hash table */
+ mtx_t st_mutex;
+};
+
/**
* Map an attachment to a buffer index.
return index;
}
+
/**
* Map a buffer index to an attachment.
*/
return statt;
}
+
/**
* Make sure a context picks up the latest cached state of the
* drawables it binds to.
}
}
+
/**
* Validate a framebuffer to make sure up-to-date pipe_textures are used.
* The context is only used for creating pipe surfaces and for calling
if (stfb->iface_stamp == new_stamp)
return;
+ memset(textures, 0, stfb->num_statts * sizeof(textures[0]));
+
/* validate the fb */
do {
if (!stfb->iface->validate(&st->iface, stfb->iface, stfb->statts,
}
}
+
/**
* Update the attachments to validate by looping the existing renderbuffers.
*/
stfb->stamp++;
}
+
/**
* Add a renderbuffer to the framebuffer. The framebuffer is one that
* corresponds to a window and is not a user-created FBO.
return TRUE;
}
+
/**
* Intialize a struct gl_config from a visual.
*/
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;
}
}
+
/**
* Create a framebuffer from a manager interface.
*/
st_pipe_format_to_mesa_format(srgb_format) != MESA_FORMAT_NONE &&
screen->is_format_supported(screen, srgb_format,
PIPE_TEXTURE_2D, stfbi->visual->samples,
+ stfbi->visual->samples,
(PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_RENDER_TARGET)))
mode.sRGBCapable = GL_TRUE;
return stfb;
}
+
/**
* Reference a framebuffer.
*/
_mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);
}
+
+static uint32_t
+st_framebuffer_iface_hash(const void *key)
+{
+ return (uintptr_t)key;
+}
+
+
+static bool
+st_framebuffer_iface_equal(const void *a, const void *b)
+{
+ return (struct st_framebuffer_iface *)a == (struct st_framebuffer_iface *)b;
+}
+
+
+static boolean
+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;
+
+ 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_manager *smapi,
+ struct st_framebuffer_iface *stfbi)
+{
+ struct st_manager_private *smPriv =
+ (struct st_manager_private *)smapi->st_manager_private;
+ struct hash_entry *entry;
+
+ 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_manager *smapi,
+ struct st_framebuffer_iface *stfbi)
+{
+ struct st_manager_private *smPriv =
+ (struct st_manager_private *)smapi->st_manager_private;
+ struct hash_entry *entry;
+
+ 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(smPriv->stfbi_ht, entry);
+
+unlock:
+ mtx_unlock(&smPriv->st_mutex);
+}
+
+
+/**
+ * The framebuffer interface object is no longer valid.
+ * Remove the object from the framebuffer interface hash table.
+ */
+static void
+st_api_destroy_drawable(struct st_api *stapi,
+ struct st_framebuffer_iface *stfbi)
+{
+ if (!stfbi)
+ return;
+
+ st_framebuffer_iface_remove(stfbi->state_manager, stfbi);
+}
+
+
/**
* Purge the winsys buffers list to remove any references to
* non-existing framebuffer interface objects.
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 (stfb->iface->ID != stfb->iface_ID) {
+ if (!st_framebuffer_iface_lookup(smapi, stfbi)) {
LIST_DEL(&stfb->head);
st_framebuffer_reference(&stfb, NULL);
}
}
}
+
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;
unsigned pipe_flags = 0;
- if (flags & ST_FLUSH_END_OF_FRAME) {
+ if (flags & ST_FLUSH_END_OF_FRAME)
pipe_flags |= PIPE_FLUSH_END_OF_FRAME;
- }
+ if (flags & ST_FLUSH_FENCE_FD)
+ pipe_flags |= PIPE_FLUSH_FENCE_FD;
+ FLUSH_VERTICES(st->ctx, 0);
+ FLUSH_CURRENT(st->ctx, 0);
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;
}
width = height = depth = 0;
}
+ pipe_resource_reference(&stObj->pt, tex);
+ st_texture_release_all_sampler_views(st, stObj);
pipe_resource_reference(&stImage->pt, tex);
stObj->surface_format = pipe_format;
return TRUE;
}
+
static void
st_context_copy(struct st_context_iface *stctxi,
struct st_context_iface *stsrci, unsigned mask)
_mesa_copy_context(src->ctx, st->ctx, mask);
}
+
static boolean
st_context_share(struct st_context_iface *stctxi,
struct st_context_iface *stsrci)
return _mesa_share_state(st->ctx, src->ctx);
}
+
static void
st_context_destroy(struct st_context_iface *stctxi)
{
st_destroy_context(st);
}
+
static void
st_start_thread(struct st_context_iface *stctxi)
{
_mesa_glthread_init(st->ctx);
}
+
static void
st_thread_finish(struct st_context_iface *stctxi)
{
_mesa_glthread_finish(st->ctx);
}
+
+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 struct st_context_iface *
st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
const struct st_context_attribs *attribs,
struct st_context *shared_ctx = (struct st_context *) shared_stctxi;
struct st_context *st;
struct pipe_context *pipe;
+ struct gl_config* mode_ptr;
struct gl_config mode;
gl_api api;
+ bool no_error = false;
unsigned ctx_flags = PIPE_CONTEXT_PREFER_THREADED;
if (!(stapi->profile_mask & (1 << attribs->profile)))
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;
+ if (attribs->flags & ST_CONTEXT_FLAG_NO_ERROR)
+ no_error = true;
+
+ if (attribs->flags & ST_CONTEXT_FLAG_LOW_PRIORITY)
+ ctx_flags |= PIPE_CONTEXT_LOW_PRIORITY;
+ else if (attribs->flags & ST_CONTEXT_FLAG_HIGH_PRIORITY)
+ ctx_flags |= PIPE_CONTEXT_HIGH_PRIORITY;
+
pipe = smapi->screen->context_create(smapi->screen, NULL, ctx_flags);
if (!pipe) {
*error = ST_CONTEXT_ERROR_NO_MEMORY;
}
st_visual_to_context_mode(&attribs->visual, &mode);
- st = st_create_context(api, pipe, &mode, shared_ctx, &attribs->options);
+
+ if (attribs->visual.no_config)
+ mode_ptr = NULL;
+ else
+ mode_ptr = &mode;
+
+ st = st_create_context(api, pipe, mode_ptr, shared_ctx,
+ &attribs->options, no_error);
if (!st) {
*error = ST_CONTEXT_ERROR_NO_MEMORY;
pipe->destroy(pipe);
st_install_device_reset_callback(st);
}
+ if (attribs->flags & ST_CONTEXT_FLAG_RELEASE_NONE)
+ st->ctx->Const.ContextReleaseBehavior = GL_NONE;
+
/* need to perform version check */
if (attribs->major > 1 || attribs->minor > 0) {
/* Is the actual version less than the requested version?
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;
}
+
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;
+ struct st_context *st = ctx ? ctx->st : NULL;
- return (st) ? &st->iface : NULL;
+ return st ? &st->iface : NULL;
}
+
static struct st_framebuffer *
st_framebuffer_reuse_or_create(struct st_context *st,
struct gl_framebuffer *fb,
{
struct st_framebuffer *cur = NULL, *stfb = NULL;
+ if (!stfbi)
+ return NULL;
+
/* Check if there is already a framebuffer object for the specified
* framebuffer interface in this context. If there is one, use it.
*/
cur = st_framebuffer_create(st, stfbi);
if (cur) {
+ /* add the referenced framebuffer interface object to
+ * the framebuffer interface object hash table.
+ */
+ if (!st_framebuffer_iface_insert(stfbi->state_manager, stfbi)) {
+ st_framebuffer_reference(&cur, NULL);
+ return NULL;
+ }
+
/* add to the context's winsys buffers list */
LIST_ADD(&cur->head, &st->winsys_buffers);
return stfb;
}
+
static boolean
st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
struct st_framebuffer_iface *stdrawi,
struct st_framebuffer *stdraw, *stread;
boolean ret;
- _glapi_check_multithread();
-
if (st) {
/* reuse or create the draw fb */
stdraw = st_framebuffer_reuse_or_create(st,
* of the referenced drawables no longer exist.
*/
st_framebuffers_purge(st);
+
+ /* Notify the driver that the context thread may have been changed.
+ * This should pin all driver threads to a specific L3 cache for optimal
+ * performance on AMD Zen CPUs.
+ */
+ struct glthread_state *glthread = st->ctx->GLThread;
+ thrd_t *upper_thread = glthread ? &glthread->queue.threads[0] : NULL;
+
+ util_context_thread_changed(st->pipe, upper_thread);
}
else {
ret = _mesa_make_current(NULL, NULL, NULL);
return ret;
}
+
static void
st_api_destroy(struct st_api *stapi)
{
}
+
/**
* Flush the front buffer if the current context renders to the front buffer.
*/
struct st_renderbuffer *strb = NULL;
if (stfb)
- strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
- if (!strb)
- return;
+ strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].
+ Renderbuffer);
+
+ /* 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;
- /* never a dummy fb */
- stfb->iface->flush_front(&st->iface, stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
+ /* Trigger an update of strb->defined on next draw */
+ st->dirty |= ST_NEW_FB_STATE;
+ }
}
+
/**
* Re-validate the framebuffers.
*/
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 unsigned
get_version(struct pipe_screen *screen,
struct st_config_options *options, gl_api api)
_mesa_init_constants(&consts, api);
_mesa_init_extensions(&extensions);
- st_init_limits(screen, &consts, &extensions);
- st_init_extensions(screen, &consts, &extensions, options, GL_TRUE);
+ st_init_limits(screen, &consts, &extensions, api);
+ st_init_extensions(screen, &consts, &extensions, options, api);
return _mesa_get_version(&extensions, &consts, api);
}
+
static void
st_api_query_versions(struct st_api *stapi, struct st_manager *sm,
struct st_config_options *options,
*gl_es2_version = get_version(sm->screen, options, API_OPENGLES2);
}
+
static const struct st_api st_gl_api = {
.name = "Mesa " PACKAGE_VERSION,
.api = ST_API_OPENGL,
.create_context = st_api_create_context,
.make_current = st_api_make_current,
.get_current = st_api_get_current,
+ .destroy_drawable = st_api_destroy_drawable,
};
+
struct st_api *
st_gl_api_create(void)
{
projects / mesa.git / blobdiff