#include "pipe/p_context.h"
#include "pipe/p_screen.h"
-#include "util/u_format.h"
+#include "util/format/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"
+#include "util/u_memory.h"
struct hash_table;
struct st_manager_private
{
struct hash_table *stfbi_ht; /* framebuffer iface objects hash table */
- mtx_t st_mutex;
+ simple_mtx_t st_mutex;
};
}
+void
+st_set_ws_renderbuffer_surface(struct st_renderbuffer *strb,
+ struct pipe_surface *surf)
+{
+ pipe_surface_reference(&strb->surface_srgb, NULL);
+ pipe_surface_reference(&strb->surface_linear, NULL);
+
+ if (util_format_is_srgb(surf->format))
+ pipe_surface_reference(&strb->surface_srgb, surf);
+ else
+ pipe_surface_reference(&strb->surface_linear, surf);
+
+ strb->surface = surf; /* just assign, don't ref */
+ pipe_resource_reference(&strb->texture, surf->texture);
+
+ strb->Base.Width = surf->width;
+ strb->Base.Height = surf->height;
+}
+
+
/**
* 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
struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
uint width, height;
unsigned i;
- boolean changed = FALSE;
+ bool changed = false;
int32_t new_stamp;
new_stamp = p_atomic_read(&stfb->iface->stamp);
u_surface_default_template(&surf_tmpl, textures[i]);
ps = st->pipe->create_surface(st->pipe, textures[i], &surf_tmpl);
if (ps) {
- struct pipe_surface **psurf =
- util_format_is_srgb(ps->format) ? &strb->surface_srgb :
- &strb->surface_linear;
-
- pipe_surface_reference(psurf, ps);
- strb->surface = *psurf;
- pipe_resource_reference(&strb->texture, ps->texture);
- /* ownership transfered */
+ st_set_ws_renderbuffer_surface(strb, ps);
pipe_surface_reference(&ps, NULL);
- changed = TRUE;
-
- strb->Base.Width = strb->surface->width;
- strb->Base.Height = strb->surface->height;
+ changed = true;
width = strb->Base.Width;
height = strb->Base.Height;
* Add a renderbuffer to the framebuffer. The framebuffer is one that
* corresponds to a window and is not a user-created FBO.
*/
-static boolean
+static bool
st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,
- gl_buffer_index idx)
+ gl_buffer_index idx, bool prefer_srgb)
{
struct gl_renderbuffer *rb;
enum pipe_format format;
- boolean sw;
+ bool sw;
assert(_mesa_is_winsys_fbo(&stfb->Base));
switch (idx) {
case BUFFER_DEPTH:
format = stfb->iface->visual->depth_stencil_format;
- sw = FALSE;
+ sw = false;
break;
case BUFFER_ACCUM:
format = stfb->iface->visual->accum_format;
- sw = TRUE;
+ sw = true;
break;
default:
format = stfb->iface->visual->color_format;
- if (stfb->Base.Visual.sRGBCapable)
+ if (prefer_srgb)
format = util_format_srgb(format);
- sw = FALSE;
+ sw = false;
break;
}
if (format == PIPE_FORMAT_NONE)
- return FALSE;
+ return false;
rb = st_new_renderbuffer_fb(format, stfb->iface->visual->samples, sw);
if (!rb)
- return FALSE;
+ return false;
if (idx != BUFFER_DEPTH) {
_mesa_attach_and_own_rb(&stfb->Base, idx, rb);
- return TRUE;
+ return true;
}
bool rb_ownership_taken = false;
_mesa_attach_and_own_rb(&stfb->Base, BUFFER_STENCIL, rb);
}
- return TRUE;
+ return true;
}
mode->stereoMode = GL_TRUE;
if (visual->color_format != PIPE_FORMAT_NONE) {
- mode->rgbMode = GL_TRUE;
-
mode->redBits =
util_format_get_component_bits(visual->color_format,
UTIL_FORMAT_COLORSPACE_RGB, 0);
mode->stencilBits =
util_format_get_component_bits(visual->depth_stencil_format,
UTIL_FORMAT_COLORSPACE_ZS, 1);
-
- mode->haveDepthBuffer = mode->depthBits > 0;
- mode->haveStencilBuffer = mode->stencilBits > 0;
}
if (visual->accum_format != PIPE_FORMAT_NONE) {
- mode->haveAccumBuffer = GL_TRUE;
-
mode->accumRedBits =
util_format_get_component_bits(visual->accum_format,
UTIL_FORMAT_COLORSPACE_RGB, 0);
struct st_framebuffer *stfb;
struct gl_config mode;
gl_buffer_index idx;
+ bool prefer_srgb = false;
if (!stfbi)
return NULL;
* format such that util_format_srgb(visual->color_format) can be supported
* by the pipe driver. We still need to advertise the capability here.
*
- * For GLES, however, sRGB framebuffer write is controlled only by the
- * capability of the framebuffer. There is GL_EXT_sRGB_write_control to
- * give applications the control back, but sRGB write is still enabled by
- * default. To avoid unexpected results, we should not advertise the
- * capability. This could change when we add support for
- * EGL_KHR_gl_colorspace.
+ * For GLES, however, sRGB framebuffer write is initially only controlled
+ * by the capability of the framebuffer, with GL_EXT_sRGB_write_control
+ * control is given back to the applications, but GL_FRAMEBUFFER_SRGB is
+ * still enabled by default since this is the behaviour when
+ * EXT_sRGB_write_control is not available. Since GL_EXT_sRGB_write_control
+ * brings GLES on par with desktop GLs EXT_framebuffer_sRGB, in mesa this
+ * is also expressed by using the same extension flag
*/
- if (_mesa_is_desktop_gl(st->ctx)) {
+ if (_mesa_has_EXT_framebuffer_sRGB(st->ctx)) {
struct pipe_screen *screen = st->pipe->screen;
const enum pipe_format srgb_format =
util_format_srgb(stfbi->visual->color_format);
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)))
+ PIPE_BIND_RENDER_TARGET))) {
mode.sRGBCapable = GL_TRUE;
+ /* Since GL_FRAMEBUFFER_SRGB is enabled by default on GLES we must not
+ * create renderbuffers with an sRGB format derived from the
+ * visual->color_format, but we still want sRGB for desktop GL.
+ */
+ prefer_srgb = _mesa_is_desktop_gl(st->ctx);
+ }
}
_mesa_initialize_window_framebuffer(&stfb->Base, &mode);
/* add the color buffer */
idx = stfb->Base._ColorDrawBufferIndexes[0];
- if (!st_framebuffer_add_renderbuffer(stfb, idx)) {
+ if (!st_framebuffer_add_renderbuffer(stfb, idx, prefer_srgb)) {
free(stfb);
return NULL;
}
- st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);
- st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);
+ st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH, false);
+ st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM, false);
stfb->stamp = 0;
st_framebuffer_update_attachments(stfb);
st_framebuffer_reference(struct st_framebuffer **ptr,
struct st_framebuffer *stfb)
{
- struct gl_framebuffer *fb = &stfb->Base;
+ struct gl_framebuffer *fb = stfb ? &stfb->Base : NULL;
_mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);
}
}
-static boolean
+static bool
st_framebuffer_iface_lookup(struct st_manager *smapi,
const struct st_framebuffer_iface *stfbi)
{
assert(smPriv);
assert(smPriv->stfbi_ht);
- mtx_lock(&smPriv->st_mutex);
+ simple_mtx_lock(&smPriv->st_mutex);
entry = _mesa_hash_table_search(smPriv->stfbi_ht, stfbi);
- mtx_unlock(&smPriv->st_mutex);
+ simple_mtx_unlock(&smPriv->st_mutex);
return entry != NULL;
}
-static boolean
+static bool
st_framebuffer_iface_insert(struct st_manager *smapi,
struct st_framebuffer_iface *stfbi)
{
assert(smPriv);
assert(smPriv->stfbi_ht);
- mtx_lock(&smPriv->st_mutex);
+ simple_mtx_lock(&smPriv->st_mutex);
entry = _mesa_hash_table_insert(smPriv->stfbi_ht, stfbi, stfbi);
- mtx_unlock(&smPriv->st_mutex);
+ simple_mtx_unlock(&smPriv->st_mutex);
return entry != NULL;
}
if (!smPriv || !smPriv->stfbi_ht)
return;
- mtx_lock(&smPriv->st_mutex);
+ simple_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);
+ simple_mtx_unlock(&smPriv->st_mutex);
}
* deleted.
*/
if (!st_framebuffer_iface_lookup(smapi, stfbi)) {
- LIST_DEL(&stfb->head);
+ 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 pipe_fence_handle **fence,
+ void (*before_flush_cb) (void*),
+ void* args)
{
struct st_context *st = (struct st_context *) stctxi;
unsigned pipe_flags = 0;
if (flags & ST_FLUSH_FENCE_FD)
pipe_flags |= PIPE_FLUSH_FENCE_FD;
+ /* If both the bitmap cache is dirty and there are unflushed vertices,
+ * it means that glBitmap was called first and then glBegin.
+ */
+ st_flush_bitmap_cache(st);
FLUSH_VERTICES(st->ctx, 0);
- FLUSH_CURRENT(st->ctx, 0);
+
+ /* Notify the caller that we're ready to flush */
+ if (before_flush_cb)
+ before_flush_cb(args);
st_flush(st, fence, pipe_flags);
if ((flags & ST_FLUSH_WAIT) && fence && *fence) {
st->gfx_shaders_may_be_dirty = true;
}
-static boolean
+static bool
st_context_teximage(struct st_context_iface *stctxi,
enum st_texture_type tex_type,
int level, enum pipe_format pipe_format,
- struct pipe_resource *tex, boolean mipmap)
+ struct pipe_resource *tex, bool mipmap)
{
struct st_context *st = (struct st_context *) stctxi;
struct gl_context *ctx = st->ctx;
_mesa_dirty_texobj(ctx, texObj);
_mesa_unlock_texture(ctx, texObj);
- return TRUE;
+ return true;
}
}
-static boolean
+static bool
st_context_share(struct st_context_iface *stctxi,
struct st_context_iface *stsrci)
{
struct st_context *st = (struct st_context *) stctxi;
_mesa_glthread_init(st->ctx);
+
+ /* Pin all driver threads to one L3 cache for optimal performance
+ * on AMD Zen. This is only done if glthread is enabled.
+ *
+ * If glthread is disabled, st_draw.c re-pins driver threads regularly
+ * based on the location of the app thread.
+ */
+ struct glthread_state *glthread = &st->ctx->GLThread;
+ if (glthread->enabled && st->pipe->set_context_param) {
+ util_pin_driver_threads_to_random_L3(st->pipe, &glthread->queue.threads[0]);
+ }
}
if (smPriv && smPriv->stfbi_ht) {
_mesa_hash_table_destroy(smPriv->stfbi_ht, NULL);
- mtx_destroy(&smPriv->st_mutex);
+ simple_mtx_destroy(&smPriv->st_mutex);
free(smPriv);
smapi->st_manager_private = NULL;
}
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;
return NULL;
}
+ _mesa_initialize();
+
/* Create a hash table for the framebuffer interface objects
* if it has not been created for this st manager.
*/
struct st_manager_private *smPriv;
smPriv = CALLOC_STRUCT(st_manager_private);
- mtx_init(&smPriv->st_mutex, mtx_plain);
+ simple_mtx_init(&smPriv->st_mutex, mtx_plain);
smPriv->stfbi_ht = _mesa_hash_table_create(NULL,
st_framebuffer_iface_hash,
st_framebuffer_iface_equal);
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;
+
+ if (attribs->flags & ST_CONTEXT_FLAG_RESET_NOTIFICATION_ENABLED)
+ ctx_flags |= PIPE_CONTEXT_LOSE_CONTEXT_ON_RESET;
+
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,
+
+ 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;
}
}
+ st->can_scissor_clear = !!st->pipe->screen->get_param(st->pipe->screen, PIPE_CAP_CLEAR_SCISSORED);
+
st->invalidate_on_gl_viewport =
smapi->get_param(smapi, ST_MANAGER_BROKEN_INVALIDATE);
}
/* add to the context's winsys buffers list */
- LIST_ADD(&cur->head, &st->winsys_buffers);
+ list_add(&cur->head, &st->winsys_buffers);
st_framebuffer_reference(&stfb, cur);
}
}
-static boolean
+static bool
st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
struct st_framebuffer_iface *stdrawi,
struct st_framebuffer_iface *streadi)
{
struct st_context *st = (struct st_context *) stctxi;
struct st_framebuffer *stdraw, *stread;
- boolean ret;
-
- _glapi_check_multithread();
+ bool ret;
if (st) {
/* reuse or create the draw fb */
st_framebuffers_purge(st);
}
else {
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (ctx) {
+ /* Before releasing the context, release its associated
+ * winsys buffers first. Then purge the context's winsys buffers list
+ * to free the resources of any winsys buffers that no longer have
+ * an existing drawable.
+ */
+ ret = _mesa_make_current(ctx, NULL, NULL);
+ st_framebuffers_purge(ctx->st);
+ }
+
ret = _mesa_make_current(NULL, NULL, NULL);
}
struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);
struct st_renderbuffer *strb = NULL;
- if (stfb)
- strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].
- Renderbuffer);
+ if (!stfb)
+ return;
+
+ /* If the context uses a doublebuffered visual, but the buffer is
+ * single-buffered, guess that it's a pbuffer, which doesn't need
+ * flushing.
+ */
+ if (st->ctx->Visual.doubleBufferMode &&
+ !stfb->Base.Visual.doubleBufferMode)
+ 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?
* Add a color renderbuffer on demand. The FBO must correspond to a window,
* not a user-created FBO.
*/
-boolean
+bool
st_manager_add_color_renderbuffer(struct st_context *st,
struct gl_framebuffer *fb,
gl_buffer_index idx)
/* FBO */
if (!stfb)
- return FALSE;
+ return false;
assert(_mesa_is_winsys_fbo(fb));
if (stfb->Base.Attachment[idx].Renderbuffer)
- return TRUE;
+ return true;
switch (idx) {
case BUFFER_FRONT_LEFT:
case BUFFER_BACK_RIGHT:
break;
default:
- return FALSE;
+ return false;
}
- if (!st_framebuffer_add_renderbuffer(stfb, idx))
- return FALSE;
+ if (!st_framebuffer_add_renderbuffer(stfb, idx,
+ stfb->Base.Visual.sRGBCapable))
+ return false;
st_framebuffer_update_attachments(stfb);
/*
- * Force a call to the state tracker manager to validate the
+ * Force a call to the frontend manager to validate the
* new renderbuffer. It might be that there is a window system
* renderbuffer available.
*/
st_invalidate_buffers(st);
- return TRUE;
+ return true;
}
st_init_limits(screen, &consts, &extensions);
st_init_extensions(screen, &consts, &extensions, options, api);
-
- return _mesa_get_version(&extensions, &consts, api);
+ version = _mesa_get_version(&extensions, &consts, api);
+ free(consts.SpirVExtensions);
+ return version;
}
projects / mesa.git / blobdiff