#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"
struct st_manager_private
{
struct hash_table *stfbi_ht; /* framebuffer iface objects hash table */
- mtx_t st_mutex;
+ simple_mtx_t st_mutex;
};
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);
st_set_ws_renderbuffer_surface(strb, ps);
pipe_surface_reference(&ps, NULL);
- changed = TRUE;
+ 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, 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 (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);
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)
{
* 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 && st->pipe->set_context_param) {
+ 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_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);
}
/* 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;
+ bool ret;
if (st) {
/* reuse or create the draw fb */
else {
GET_CURRENT_CONTEXT(ctx);
- ret = _mesa_make_current(NULL, NULL, NULL);
-
- if (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);
}
return ret;
* 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,
stfb->Base.Visual.sRGBCapable))
- return FALSE;
+ return false;
st_framebuffer_update_attachments(stfb);
st_invalidate_buffers(st);
- return TRUE;
+ return true;
}
_mesa_init_constants(&consts, api);
_mesa_init_extensions(&extensions);
- st_init_limits(screen, &consts, &extensions, api);
+ 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;
}