isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-25 17:40:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

cogl: Turn CoglFramebuffer, CoglOffscreen and CoglOnscreen into GObjects

Browse Source 
A first step towards abandoning the CoglObject type system: convert
CoglFramebuffer, CoglOffscreen and CoglOnscreen into GObjects.
CoglFramebuffer is turned into an abstract GObject, while the two others
are currently final. The "winsys" and "platform" are still sprinkled
'void *' in the the non-abstract type instances however.

https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1496
This commit is contained in:
Jonas Ådahl 2020-10-13 11:35:47 +02:00 committed by Georges Basile Stavracas Neto
parent de4e59a39b
commit eb14da3874
43 changed files with 393 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clutter/clutter/clutter-backend.c
View File

@ -93,7 +93,7 @@ clutter_backend_dispose (GObject *gobject)
/* clear the events still in the queue of the main context */ /* clear the events still in the queue of the main context */
_clutter_clear_events_queue (); _clutter_clear_events_queue ();
g_clear_pointer (&backend->dummy_onscreen, cogl_object_unref); g_clear_object (&backend->dummy_onscreen);
if (backend->stage_window) if (backend->stage_window)
{ {
g_object_remove_weak_pointer (G_OBJECT (backend->stage_window), g_object_remove_weak_pointer (G_OBJECT (backend->stage_window),

16
clutter/clutter/clutter-offscreen-effect.c
View File

@ -118,7 +118,7 @@ clutter_offscreen_effect_set_actor (ClutterActorMeta *meta,
meta_class->set_actor (meta, actor); meta_class->set_actor (meta, actor);
/* clear out the previous state */ /* clear out the previous state */
g_clear_pointer (&priv->offscreen, cogl_object_unref); g_clear_object (&priv->offscreen);
/* we keep a back pointer here, to avoid going through the ActorMeta */ /* we keep a back pointer here, to avoid going through the ActorMeta */
priv->actor = clutter_actor_meta_get_actor (meta); priv->actor = clutter_actor_meta_get_actor (meta);
@ -161,7 +161,7 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
static void static void
video_memory_purged (ClutterOffscreenEffect *self) video_memory_purged (ClutterOffscreenEffect *self)
{ {
g_clear_pointer (&self->priv->offscreen, cogl_object_unref); g_clear_object (&self->priv->offscreen);
} }
static gboolean static gboolean
@ -221,7 +221,7 @@ update_fbo (ClutterEffect *effect,
} }
g_clear_pointer (&priv->texture, cogl_object_unref); g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_pointer (&priv->offscreen, cogl_object_unref); g_clear_object (&priv->offscreen);
priv->texture = priv->texture =
clutter_offscreen_effect_create_texture (self, target_width, target_height); clutter_offscreen_effect_create_texture (self, target_width, target_height);
@ -239,7 +239,7 @@ update_fbo (ClutterEffect *effect,
g_warning ("Failed to create offscreen effect framebuffer: %s", g_warning ("Failed to create offscreen effect framebuffer: %s",
error->message); error->message);
cogl_object_unref (offscreen); g_object_unref (offscreen);
cogl_object_unref (priv->pipeline); cogl_object_unref (priv->pipeline);
priv->pipeline = NULL; priv->pipeline = NULL;
@ -369,7 +369,7 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect,
return TRUE; return TRUE;
disable_effect: disable_effect:
cogl_clear_object (&priv->offscreen); g_clear_object (&priv->offscreen);
return FALSE; return FALSE;
} }
@ -476,7 +476,7 @@ clutter_offscreen_effect_paint (ClutterEffect *effect,
if (flags & CLUTTER_EFFECT_PAINT_BYPASS_EFFECT) if (flags & CLUTTER_EFFECT_PAINT_BYPASS_EFFECT)
{ {
clutter_actor_continue_paint (priv->actor, paint_context); clutter_actor_continue_paint (priv->actor, paint_context);
cogl_clear_object (&priv->offscreen); g_clear_object (&priv->offscreen);
return; return;
} }
@ -503,7 +503,7 @@ clutter_offscreen_effect_set_enabled (ClutterActorMeta *meta,
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (meta); ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (meta);
ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv; ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv;
g_clear_pointer (&priv->offscreen, cogl_object_unref); g_clear_object (&priv->offscreen);
parent_class->set_enabled (meta, is_enabled); parent_class->set_enabled (meta, is_enabled);
} }
@ -514,7 +514,7 @@ clutter_offscreen_effect_finalize (GObject *gobject)
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (gobject); ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (gobject);
ClutterOffscreenEffectPrivate *priv = self->priv; ClutterOffscreenEffectPrivate *priv = self->priv;
g_clear_pointer (&priv->offscreen, cogl_object_unref); g_clear_object (&priv->offscreen);
g_clear_pointer (&priv->texture, cogl_object_unref); g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_pointer (&priv->pipeline, cogl_object_unref); g_clear_pointer (&priv->pipeline, cogl_object_unref);

7
clutter/clutter/clutter-paint-context.c
View File

@ -86,8 +86,7 @@ clutter_paint_context_ref (ClutterPaintContext *paint_context)
static void static void
clutter_paint_context_dispose (ClutterPaintContext *paint_context) clutter_paint_context_dispose (ClutterPaintContext *paint_context)
{ {
g_list_free_full (paint_context->framebuffers, g_list_free_full (paint_context->framebuffers, g_object_unref);
cogl_object_unref);
paint_context->framebuffers = NULL; paint_context->framebuffers = NULL;
g_clear_pointer (&paint_context->redraw_clip, cairo_region_destroy); g_clear_pointer (&paint_context->redraw_clip, cairo_region_destroy);
} }
@ -114,7 +113,7 @@ clutter_paint_context_push_framebuffer (ClutterPaintContext *paint_context,
CoglFramebuffer *framebuffer) CoglFramebuffer *framebuffer)
{ {
paint_context->framebuffers = g_list_prepend (paint_context->framebuffers, paint_context->framebuffers = g_list_prepend (paint_context->framebuffers,
cogl_object_ref (framebuffer)); g_object_ref (framebuffer));
} }
void void
@ -122,7 +121,7 @@ clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context)
{ {
g_return_if_fail (paint_context->framebuffers); g_return_if_fail (paint_context->framebuffers);
cogl_object_unref (paint_context->framebuffers->data); g_object_unref (paint_context->framebuffers->data);
paint_context->framebuffers = paint_context->framebuffers =
g_list_delete_link (paint_context->framebuffers, g_list_delete_link (paint_context->framebuffers,
paint_context->framebuffers); paint_context->framebuffers);

13
clutter/clutter/clutter-paint-nodes.c
View File

@ -130,7 +130,7 @@ clutter_root_node_finalize (ClutterPaintNode *node)
{ {
ClutterRootNode *rnode = (ClutterRootNode *) node; ClutterRootNode *rnode = (ClutterRootNode *) node;
cogl_object_unref (rnode->framebuffer); g_object_unref (rnode->framebuffer);
CLUTTER_PAINT_NODE_CLASS (clutter_root_node_parent_class)->finalize (node); CLUTTER_PAINT_NODE_CLASS (clutter_root_node_parent_class)->finalize (node);
} }
@ -177,7 +177,7 @@ clutter_root_node_new (CoglFramebuffer *framebuffer,
clear_color->alpha); clear_color->alpha);
cogl_color_premultiply (&res->clear_color); cogl_color_premultiply (&res->clear_color);
res->framebuffer = cogl_object_ref (framebuffer); res->framebuffer = g_object_ref (framebuffer);
res->clear_flags = clear_flags; res->clear_flags = clear_flags;
return (ClutterPaintNode *) res; return (ClutterPaintNode *) res;
@ -326,7 +326,7 @@ clutter_dummy_node_finalize (ClutterPaintNode *node)
{ {
ClutterDummyNode *dnode = (ClutterDummyNode *) node; ClutterDummyNode *dnode = (ClutterDummyNode *) node;
cogl_clear_object (&dnode->framebuffer); g_clear_object (&dnode->framebuffer);
CLUTTER_PAINT_NODE_CLASS (clutter_dummy_node_parent_class)->finalize (node); CLUTTER_PAINT_NODE_CLASS (clutter_dummy_node_parent_class)->finalize (node);
} }
@ -358,7 +358,7 @@ _clutter_dummy_node_new (ClutterActor *actor,
dnode = (ClutterDummyNode *) res; dnode = (ClutterDummyNode *) res;
dnode->actor = actor; dnode->actor = actor;
dnode->framebuffer = cogl_object_ref (framebuffer); dnode->framebuffer = g_object_ref (framebuffer);
return res; return res;
} }
@ -1361,8 +1361,7 @@ clutter_layer_node_finalize (ClutterPaintNode *node)
if (lnode->pipeline != NULL) if (lnode->pipeline != NULL)
cogl_object_unref (lnode->pipeline); cogl_object_unref (lnode->pipeline);
if (lnode->offscreen != NULL) g_clear_object (&lnode->offscreen);
cogl_object_unref (lnode->offscreen);
CLUTTER_PAINT_NODE_CLASS (clutter_layer_node_parent_class)->finalize (node); CLUTTER_PAINT_NODE_CLASS (clutter_layer_node_parent_class)->finalize (node);
} }
@ -1440,7 +1439,7 @@ clutter_layer_node_new (const graphene_matrix_t *projection,
{ {
g_warning ("Unable to create an allocate paint node offscreen: %s", g_warning ("Unable to create an allocate paint node offscreen: %s",
error->message); error->message);
cogl_object_unref (offscreen); g_object_unref (offscreen);
goto out; goto out;
} }

4
clutter/clutter/clutter-pick-context.c
View File

@ -38,7 +38,7 @@ clutter_pick_context_new_for_view (ClutterStageView *view)
pick_context = g_new0 (ClutterPickContext, 1); pick_context = g_new0 (ClutterPickContext, 1);
g_ref_count_init (&pick_context->ref_count); g_ref_count_init (&pick_context->ref_count);
pick_context->framebuffer = pick_context->framebuffer =
cogl_object_ref (clutter_stage_view_get_framebuffer (view)); g_object_ref (clutter_stage_view_get_framebuffer (view));
return pick_context; return pick_context;
} }
@ -53,7 +53,7 @@ clutter_pick_context_ref (ClutterPickContext *pick_context)
static void static void
clutter_pick_context_dispose (ClutterPickContext *pick_context) clutter_pick_context_dispose (ClutterPickContext *pick_context)
{ {
g_clear_pointer (&pick_context->framebuffer, cogl_object_unref); g_clear_object (&pick_context->framebuffer);
} }
void void

34
clutter/clutter/clutter-stage-view.c
View File

@ -321,7 +321,7 @@ init_dma_buf_shadowfbs (ClutterStageView *view,
return FALSE; return FALSE;
} }
if (!cogl_is_onscreen (priv->framebuffer)) if (!COGL_IS_ONSCREEN (priv->framebuffer))
{ {
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Tried to use shadow buffer without onscreen"); "Tried to use shadow buffer without onscreen");
@ -348,7 +348,7 @@ init_dma_buf_shadowfbs (ClutterStageView *view,
initial_shadowfb = initial_shadowfb =
cogl_dma_buf_handle_get_framebuffer (priv->shadow.dma_buf.handles[0]); cogl_dma_buf_handle_get_framebuffer (priv->shadow.dma_buf.handles[0]);
priv->shadow.framebuffer = cogl_object_ref (initial_shadowfb); priv->shadow.framebuffer = COGL_OFFSCREEN (g_object_ref (initial_shadowfb));
return TRUE; return TRUE;
} }
@ -376,7 +376,7 @@ create_offscreen_framebuffer (CoglContext *context,
cogl_object_unref (texture); cogl_object_unref (texture);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (framebuffer), error)) if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (framebuffer), error))
{ {
cogl_object_unref (framebuffer); g_object_unref (framebuffer);
return FALSE; return FALSE;
} }
@ -631,8 +631,8 @@ swap_dma_buf_framebuffer (ClutterStageView *view)
next_dma_buf_handle = priv->shadow.dma_buf.handles[next_idx]; next_dma_buf_handle = priv->shadow.dma_buf.handles[next_idx];
next_framebuffer = next_framebuffer =
cogl_dma_buf_handle_get_framebuffer (next_dma_buf_handle); cogl_dma_buf_handle_get_framebuffer (next_dma_buf_handle);
cogl_clear_object (&priv->shadow.framebuffer); g_clear_object (&priv->shadow.framebuffer);
priv->shadow.framebuffer = cogl_object_ref (next_framebuffer); priv->shadow.framebuffer = COGL_OFFSCREEN (g_object_ref (next_framebuffer));
} }
static void static void
@ -1165,7 +1165,7 @@ clutter_stage_view_set_framebuffer (ClutterStageView *view,
g_warn_if_fail (!priv->framebuffer); g_warn_if_fail (!priv->framebuffer);
if (framebuffer) if (framebuffer)
{ {
priv->framebuffer = cogl_object_ref (framebuffer); priv->framebuffer = g_object_ref (framebuffer);
sanity_check_framebuffer (view); sanity_check_framebuffer (view);
} }
} }
@ -1192,10 +1192,10 @@ clutter_stage_view_get_property (GObject *object,
g_value_set_boxed (value, &priv->layout); g_value_set_boxed (value, &priv->layout);
break; break;
case PROP_FRAMEBUFFER: case PROP_FRAMEBUFFER:
g_value_set_boxed (value, priv->framebuffer); g_value_set_object (value, priv->framebuffer);
break; break;
case PROP_OFFSCREEN: case PROP_OFFSCREEN:
g_value_set_boxed (value, priv->offscreen); g_value_set_object (value, priv->offscreen);
break; break;
case PROP_USE_SHADOWFB: case PROP_USE_SHADOWFB:
g_value_set_boolean (value, priv->use_shadowfb); g_value_set_boolean (value, priv->use_shadowfb);
@ -1235,10 +1235,10 @@ clutter_stage_view_set_property (GObject *object,
priv->layout = *layout; priv->layout = *layout;
break; break;
case PROP_FRAMEBUFFER: case PROP_FRAMEBUFFER:
clutter_stage_view_set_framebuffer (view, g_value_get_boxed (value)); clutter_stage_view_set_framebuffer (view, g_value_get_object (value));
break; break;
case PROP_OFFSCREEN: case PROP_OFFSCREEN:
priv->offscreen = g_value_dup_boxed (value); priv->offscreen = g_value_dup_object (value);
break; break;
case PROP_USE_SHADOWFB: case PROP_USE_SHADOWFB:
priv->use_shadowfb = g_value_get_boolean (value); priv->use_shadowfb = g_value_get_boolean (value);
@ -1281,7 +1281,7 @@ clutter_stage_view_dispose (GObject *object)
g_clear_pointer (&priv->name, g_free); g_clear_pointer (&priv->name, g_free);
g_clear_pointer (&priv->shadow.framebuffer, cogl_object_unref); g_clear_object (&priv->shadow.framebuffer);
for (i = 0; i < G_N_ELEMENTS (priv->shadow.dma_buf.handles); i++) for (i = 0; i < G_N_ELEMENTS (priv->shadow.dma_buf.handles); i++)
{ {
g_clear_pointer (&priv->shadow.dma_buf.handles[i], g_clear_pointer (&priv->shadow.dma_buf.handles[i],
@ -1290,7 +1290,7 @@ clutter_stage_view_dispose (GObject *object)
g_clear_pointer (&priv->shadow.dma_buf.damage_history, g_clear_pointer (&priv->shadow.dma_buf.damage_history,
clutter_damage_history_free); clutter_damage_history_free);
g_clear_pointer (&priv->offscreen, cogl_object_unref); g_clear_object (&priv->offscreen);
g_clear_pointer (&priv->offscreen_pipeline, cogl_object_unref); g_clear_pointer (&priv->offscreen_pipeline, cogl_object_unref);
g_clear_pointer (&priv->redraw_clip, cairo_region_destroy); g_clear_pointer (&priv->redraw_clip, cairo_region_destroy);
g_clear_pointer (&priv->frame_clock, clutter_frame_clock_destroy); g_clear_pointer (&priv->frame_clock, clutter_frame_clock_destroy);
@ -1305,7 +1305,7 @@ clutter_stage_view_finalize (GObject *object)
ClutterStageViewPrivate *priv = ClutterStageViewPrivate *priv =
clutter_stage_view_get_instance_private (view); clutter_stage_view_get_instance_private (view);
g_clear_pointer (&priv->framebuffer, cogl_object_unref); g_clear_object (&priv->framebuffer);
G_OBJECT_CLASS (clutter_stage_view_parent_class)->dispose (object); G_OBJECT_CLASS (clutter_stage_view_parent_class)->dispose (object);
} }
@ -1364,19 +1364,19 @@ clutter_stage_view_class_init (ClutterStageViewClass *klass)
G_PARAM_STATIC_STRINGS); G_PARAM_STATIC_STRINGS);
obj_props[PROP_FRAMEBUFFER] = obj_props[PROP_FRAMEBUFFER] =
g_param_spec_boxed ("framebuffer", g_param_spec_object ("framebuffer",
"View framebuffer", "View framebuffer",
"The front buffer of the view", "The front buffer of the view",
COGL_TYPE_HANDLE, COGL_TYPE_FRAMEBUFFER,
G_PARAM_READWRITE | G_PARAM_READWRITE |
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS); G_PARAM_STATIC_STRINGS);
obj_props[PROP_OFFSCREEN] = obj_props[PROP_OFFSCREEN] =
g_param_spec_boxed ("offscreen", g_param_spec_object ("offscreen",
"Offscreen buffer", "Offscreen buffer",
"Framebuffer used as intermediate buffer", "Framebuffer used as intermediate buffer",
COGL_TYPE_HANDLE, COGL_TYPE_OFFSCREEN,
G_PARAM_READWRITE | G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS); G_PARAM_STATIC_STRINGS);

2
clutter/clutter/clutter-stage.c
View File

@ -3731,7 +3731,7 @@ clutter_stage_paint_to_buffer (ClutterStage *stage,
bitmap); bitmap);
cogl_object_unref (bitmap); cogl_object_unref (bitmap);
cogl_object_unref (framebuffer); g_object_unref (framebuffer);
return TRUE; return TRUE;
} }

10
clutter/clutter/cogl/clutter-stage-cogl.c
View File

@ -257,7 +257,7 @@ swap_framebuffer (ClutterStageWindow *stage_window,
clutter_stage_view_before_swap_buffer (view, swap_region); clutter_stage_view_before_swap_buffer (view, swap_region);
if (cogl_is_onscreen (framebuffer)) if (COGL_IS_ONSCREEN (framebuffer))
{ {
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer); CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
int *damage, n_rects, i; int *damage, n_rects, i;
@ -481,10 +481,10 @@ clutter_stage_cogl_redraw_view_primary (ClutterStageCogl *stage_cogl,
fb_height = cogl_framebuffer_get_height (fb); fb_height = cogl_framebuffer_get_height (fb);
can_blit_sub_buffer = can_blit_sub_buffer =
cogl_is_onscreen (onscreen) && COGL_IS_ONSCREEN (onscreen) &&
cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION); cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION);
has_buffer_age = cogl_is_onscreen (onscreen) && is_buffer_age_enabled (); has_buffer_age = COGL_IS_ONSCREEN (onscreen) && is_buffer_age_enabled ();
redraw_clip = clutter_stage_view_take_redraw_clip (view); redraw_clip = clutter_stage_view_take_redraw_clip (view);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION)) if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION))
@ -661,7 +661,7 @@ clutter_stage_cogl_scanout_view (ClutterStageCogl *stage_cogl,
CoglOnscreen *onscreen; CoglOnscreen *onscreen;
CoglFrameInfo *frame_info; CoglFrameInfo *frame_info;
g_assert (cogl_is_onscreen (framebuffer)); g_assert (COGL_IS_ONSCREEN (framebuffer));
onscreen = COGL_ONSCREEN (framebuffer); onscreen = COGL_ONSCREEN (framebuffer);
@ -807,7 +807,7 @@ clutter_stage_view_cogl_constructed (GObject *object)
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
framebuffer = clutter_stage_view_get_onscreen (view); framebuffer = clutter_stage_view_get_onscreen (view);
if (framebuffer && cogl_is_onscreen (framebuffer)) if (framebuffer && COGL_IS_ONSCREEN (framebuffer))
{ {
view_priv->frame_cb_closure = view_priv->frame_cb_closure =
cogl_onscreen_add_frame_callback (COGL_ONSCREEN (framebuffer), cogl_onscreen_add_frame_callback (COGL_ONSCREEN (framebuffer),

18
cogl/cogl/cogl-blit.c
View File

@ -62,7 +62,7 @@ _cogl_blit_texture_render_begin (CoglBlitData *data)
if (!cogl_framebuffer_allocate (fb, &ignore_error)) if (!cogl_framebuffer_allocate (fb, &ignore_error))
{ {
g_error_free (ignore_error); g_error_free (ignore_error);
cogl_object_unref (fb); g_object_unref (fb);
return FALSE; return FALSE;
} }
@ -142,7 +142,7 @@ _cogl_blit_texture_render_end (CoglBlitData *data)
cogl_pipeline_set_layer_texture (ctx->blit_texture_pipeline, 0, cogl_pipeline_set_layer_texture (ctx->blit_texture_pipeline, 0,
data->dst_tex); data->dst_tex);
cogl_object_unref (data->dest_fb); g_object_unref (data->dest_fb);
} }
static gboolean static gboolean
@ -190,10 +190,8 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
error: error:
if (dst_offscreen) g_clear_object (&dst_offscreen);
cogl_object_unref (dst_offscreen); g_clear_object (&src_offscreen);
if (src_offscreen)
cogl_object_unref (src_offscreen);
return FALSE; return FALSE;
} }
@ -218,8 +216,8 @@ _cogl_blit_framebuffer_blit (CoglBlitData *data,
static void static void
_cogl_blit_framebuffer_end (CoglBlitData *data) _cogl_blit_framebuffer_end (CoglBlitData *data)
{ {
cogl_object_unref (data->src_fb); g_object_unref (data->src_fb);
cogl_object_unref (data->dest_fb); g_object_unref (data->dest_fb);
} }
static gboolean static gboolean
@ -240,7 +238,7 @@ _cogl_blit_copy_tex_sub_image_begin (CoglBlitData *data)
if (!cogl_framebuffer_allocate (fb, &ignore_error)) if (!cogl_framebuffer_allocate (fb, &ignore_error))
{ {
g_error_free (ignore_error); g_error_free (ignore_error);
cogl_object_unref (fb); g_object_unref (fb);
return FALSE; return FALSE;
} }
@ -269,7 +267,7 @@ _cogl_blit_copy_tex_sub_image_blit (CoglBlitData *data,
static void static void
_cogl_blit_copy_tex_sub_image_end (CoglBlitData *data) _cogl_blit_copy_tex_sub_image_end (CoglBlitData *data)
{ {
cogl_object_unref (data->src_fb); g_object_unref (data->src_fb);
} }
static gboolean static gboolean

4
cogl/cogl/cogl-dma-buf-handle.c
View File

@ -71,7 +71,7 @@ cogl_dma_buf_handle_new (CoglFramebuffer *framebuffer,
g_assert (dmabuf_fd != -1); g_assert (dmabuf_fd != -1);
dmabuf_handle = g_new0 (CoglDmaBufHandle, 1); dmabuf_handle = g_new0 (CoglDmaBufHandle, 1);
dmabuf_handle->framebuffer = cogl_object_ref (framebuffer); dmabuf_handle->framebuffer = g_object_ref (framebuffer);
dmabuf_handle->dmabuf_fd = dmabuf_fd; dmabuf_handle->dmabuf_fd = dmabuf_fd;
dmabuf_handle->user_data = user_data; dmabuf_handle->user_data = user_data;
dmabuf_handle->destroy_func = destroy_func; dmabuf_handle->destroy_func = destroy_func;
@ -90,7 +90,7 @@ cogl_dma_buf_handle_free (CoglDmaBufHandle *dmabuf_handle)
{ {
g_return_if_fail (dmabuf_handle != NULL); g_return_if_fail (dmabuf_handle != NULL);
g_clear_pointer (&dmabuf_handle->framebuffer, cogl_object_unref); g_clear_object (&dmabuf_handle->framebuffer);
if (dmabuf_handle->destroy_func) if (dmabuf_handle->destroy_func)
g_clear_pointer (&dmabuf_handle->user_data, dmabuf_handle->destroy_func); g_clear_pointer (&dmabuf_handle->user_data, dmabuf_handle->destroy_func);

21
cogl/cogl/cogl-framebuffer-private.h
View File

@ -41,12 +41,6 @@
#include "cogl-gl-header.h" #include "cogl-gl-header.h"
#include "cogl-clip-stack.h" #include "cogl-clip-stack.h"
typedef enum _CoglFramebufferType
{
COGL_FRAMEBUFFER_TYPE_ONSCREEN,
COGL_FRAMEBUFFER_TYPE_OFFSCREEN
} CoglFramebufferType;
typedef struct typedef struct
{ {
CoglSwapChain *swap_chain; CoglSwapChain *swap_chain;
@ -116,12 +110,6 @@ typedef struct
int stencil; int stencil;
} CoglFramebufferBits; } CoglFramebufferBits;
struct _CoglFramebuffer
{
CoglObject _parent;
gpointer priv;
};
typedef enum typedef enum
{ {
COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL = 1L<<0, COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL = 1L<<0,
@ -138,7 +126,7 @@ typedef struct _CoglGLFramebuffer
struct _CoglOffscreen struct _CoglOffscreen
{ {
CoglFramebuffer _parent; CoglFramebuffer parent;
CoglGLFramebuffer gl_framebuffer; CoglGLFramebuffer gl_framebuffer;
@ -155,13 +143,6 @@ struct _CoglOffscreen
CoglOffscreenFlags create_flags; CoglOffscreenFlags create_flags;
}; };
void
_cogl_framebuffer_init (CoglFramebuffer *framebuffer,
CoglContext *ctx,
CoglFramebufferType type,
int width,
int height);
gboolean gboolean
cogl_framebuffer_is_allocated (CoglFramebuffer *framebuffer); cogl_framebuffer_is_allocated (CoglFramebuffer *framebuffer);

267
cogl/cogl/cogl-framebuffer.c
View File

@ -53,7 +53,27 @@
#include "cogl-gtype-private.h" #include "cogl-gtype-private.h"
#include "winsys/cogl-winsys-private.h" #include "winsys/cogl-winsys-private.h"
extern CoglObjectClass _cogl_onscreen_class; enum
{
PROP_0,
PROP_CONTEXT,
PROP_WIDTH,
PROP_HEIGHT,
N_PROPS
};
static GParamSpec *obj_props[N_PROPS];
enum
{
DESTROY,
N_SIGNALS
};
static guint signals[N_SIGNALS];
#ifdef COGL_ENABLE_DEBUG #ifdef COGL_ENABLE_DEBUG
static CoglUserDataKey wire_pipeline_key; static CoglUserDataKey wire_pipeline_key;
@ -62,7 +82,6 @@ static CoglUserDataKey wire_pipeline_key;
typedef struct _CoglFramebufferPrivate typedef struct _CoglFramebufferPrivate
{ {
CoglContext *context; CoglContext *context;
CoglFramebufferType type;
/* The user configuration before allocation... */ /* The user configuration before allocation... */
CoglFramebufferConfig config; CoglFramebufferConfig config;
@ -125,26 +144,11 @@ typedef struct _CoglFramebufferPrivate
GDestroyNotify driver_private_destroy; GDestroyNotify driver_private_destroy;
} CoglFramebufferPrivate; } CoglFramebufferPrivate;
static void _cogl_offscreen_free (CoglOffscreen *offscreen); G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (CoglFramebuffer, cogl_framebuffer,
G_TYPE_OBJECT)
COGL_OBJECT_DEFINE_WITH_CODE_GTYPE (Offscreen, offscreen, G_DEFINE_TYPE (CoglOffscreen, cogl_offscreen,
_cogl_offscreen_class.virt_unref = COGL_TYPE_FRAMEBUFFER)
_cogl_framebuffer_unref);
COGL_GTYPE_DEFINE_CLASS (Offscreen, offscreen,
COGL_GTYPE_IMPLEMENT_INTERFACE (framebuffer));
COGL_GTYPE_DEFINE_INTERFACE (Framebuffer, framebuffer);
/* XXX:
* The CoglObject macros don't support any form of inheritance, so for
* now we implement the CoglObject support for the CoglFramebuffer
* abstract class manually.
*/
static CoglFramebufferPrivate *
cogl_framebuffer_get_instance_private (CoglFramebuffer *framebuffer)
{
return framebuffer->priv;
}
uint32_t uint32_t
cogl_framebuffer_error_quark (void) cogl_framebuffer_error_quark (void)
@ -155,43 +159,83 @@ cogl_framebuffer_error_quark (void)
gboolean gboolean
cogl_is_framebuffer (void *object) cogl_is_framebuffer (void *object)
{ {
CoglObject *obj = object; return COGL_IS_FRAMEBUFFER (object);
if (obj == NULL)
return FALSE;
return (obj->klass == &_cogl_onscreen_class ||
obj->klass == &_cogl_offscreen_class);
} }
void static void
_cogl_framebuffer_init (CoglFramebuffer *framebuffer, cogl_framebuffer_get_property (GObject *object,
CoglContext *ctx, guint prop_id,
CoglFramebufferType type, GValue *value,
int width, GParamSpec *pspec)
int height)
{ {
CoglFramebufferPrivate *priv; CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (object);
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
framebuffer->priv = priv = g_new0 (CoglFramebufferPrivate, 1); switch (prop_id)
priv->context = ctx; {
case PROP_CONTEXT:
g_value_set_boxed (value, priv->context);
break;
case PROP_WIDTH:
g_value_set_int (value, priv->width);
break;
case PROP_HEIGHT:
g_value_set_int (value, priv->height);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
cogl_framebuffer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (object);
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
switch (prop_id)
{
case PROP_CONTEXT:
priv->context = g_value_get_boxed (value);
break;
case PROP_WIDTH:
priv->width = g_value_get_int (value);
break;
case PROP_HEIGHT:
priv->height = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
cogl_framebuffer_constructed (GObject *object)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (object);
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
g_assert (priv->context);
priv->type = type;
priv->width = width;
priv->height = height;
priv->internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE; priv->internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE;
priv->viewport_x = 0; priv->viewport_x = 0;
priv->viewport_y = 0; priv->viewport_y = 0;
priv->viewport_width = width; priv->viewport_width = priv->width;
priv->viewport_height = height; priv->viewport_height = priv->height;
priv->viewport_age = 0; priv->viewport_age = 0;
priv->viewport_age_for_scissor_workaround = -1; priv->viewport_age_for_scissor_workaround = -1;
priv->dither_enabled = TRUE; priv->dither_enabled = TRUE;
priv->depth_writing_enabled = TRUE; priv->depth_writing_enabled = TRUE;
priv->depth_buffer_clear_needed = TRUE; priv->depth_buffer_clear_needed = TRUE;
priv->modelview_stack = cogl_matrix_stack_new (ctx); priv->modelview_stack = cogl_matrix_stack_new (priv->context);
priv->projection_stack = cogl_matrix_stack_new (ctx); priv->projection_stack = cogl_matrix_stack_new (priv->context);
priv->samples_per_pixel = 0; priv->samples_per_pixel = 0;
@ -232,7 +276,8 @@ _cogl_framebuffer_init (CoglFramebuffer *framebuffer,
* we don't have to worry about retaining references to OpenGL * we don't have to worry about retaining references to OpenGL
* texture coordinates that may later become invalid. * texture coordinates that may later become invalid.
*/ */
ctx->framebuffers = g_list_prepend (ctx->framebuffers, framebuffer); priv->context->framebuffers = g_list_prepend (priv->context->framebuffers,
framebuffer);
} }
void void
@ -274,15 +319,20 @@ cogl_framebuffer_init_config (CoglFramebuffer *framebuffer,
cogl_object_ref (priv->config.swap_chain); cogl_object_ref (priv->config.swap_chain);
} }
void static void
_cogl_framebuffer_free (CoglFramebuffer *framebuffer) cogl_framebuffer_dispose (GObject *object)
{ {
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (object);
CoglFramebufferPrivate *priv = CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer); cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context; CoglContext *ctx = priv->context;
_cogl_fence_cancel_fences_for_framebuffer (framebuffer); if (priv->journal)
{
g_signal_emit (framebuffer, signals[DESTROY], 0);
_cogl_fence_cancel_fences_for_framebuffer (framebuffer);
}
g_clear_pointer (&priv->clip_stack, _cogl_clip_stack_unref); g_clear_pointer (&priv->clip_stack, _cogl_clip_stack_unref);
cogl_clear_object (&priv->modelview_stack); cogl_clear_object (&priv->modelview_stack);
@ -298,10 +348,65 @@ _cogl_framebuffer_free (CoglFramebuffer *framebuffer)
if (priv->driver_private_destroy) if (priv->driver_private_destroy)
priv->driver_private_destroy (priv->driver_private); priv->driver_private_destroy (priv->driver_private);
priv->driver_private_destroy = NULL;
priv->driver_private = NULL; priv->driver_private = NULL;
priv->driver_private_destroy = NULL;
}
g_clear_pointer (&framebuffer->priv, g_free); static void
cogl_framebuffer_init (CoglFramebuffer *framebuffer)
{
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
priv->width = -1;
priv->height = -1;
}
static void
cogl_framebuffer_class_init (CoglFramebufferClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = cogl_framebuffer_dispose;
object_class->constructed = cogl_framebuffer_constructed;
object_class->get_property = cogl_framebuffer_get_property;
object_class->set_property = cogl_framebuffer_set_property;
obj_props[PROP_CONTEXT] =
g_param_spec_boxed ("context",
"context",
"CoglContext",
COGL_TYPE_HANDLE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
obj_props[PROP_WIDTH] =
g_param_spec_int ("width",
"width",
"framebuffer width",
-1, INT_MAX, -1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS);
obj_props[PROP_HEIGHT] =
g_param_spec_int ("height",
"height",
"framebuffer height",
-1, INT_MAX, -1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, N_PROPS, obj_props);
signals[DESTROY] =
g_signal_new (I_("destroy"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
0);
} }
const CoglWinsysVtable * const CoglWinsysVtable *
@ -564,7 +669,7 @@ ensure_size_initialized (CoglFramebuffer *framebuffer)
{ {
/* Currently we assume the size is always initialized for /* Currently we assume the size is always initialized for
* onscreen framebuffers. */ * onscreen framebuffers. */
g_return_if_fail (cogl_is_offscreen (framebuffer)); g_return_if_fail (COGL_IS_OFFSCREEN (framebuffer));
/* We also assume the size would have been initialized if the /* We also assume the size would have been initialized if the
* framebuffer were allocated. */ * framebuffer were allocated. */
@ -765,7 +870,7 @@ _cogl_framebuffer_add_dependency (CoglFramebuffer *framebuffer,
* cogl_object_set_user_data or for pipeline children as a way to * cogl_object_set_user_data or for pipeline children as a way to
* avoid quite a lot of mid-scene micro allocations here... */ * avoid quite a lot of mid-scene micro allocations here... */
priv->deps = priv->deps =
g_list_prepend (priv->deps, cogl_object_ref (dependency)); g_list_prepend (priv->deps, g_object_ref (dependency));
} }
void void
@ -787,7 +892,7 @@ _cogl_framebuffer_flush_dependency_journals (CoglFramebuffer *framebuffer)
for (l = priv->deps; l; l = l->next) for (l = priv->deps; l; l = l->next)
_cogl_framebuffer_flush_journal (l->data); _cogl_framebuffer_flush_journal (l->data);
for (l = priv->deps; l; l = l->next) for (l = priv->deps; l; l = l->next)
cogl_object_unref (l->data); g_object_unref (l->data);
g_list_free (priv->deps); g_list_free (priv->deps);
priv->deps = NULL; priv->deps = NULL;
} }
@ -800,11 +905,12 @@ _cogl_offscreen_new_with_texture_full (CoglTexture *texture,
CoglContext *ctx = texture->context; CoglContext *ctx = texture->context;
CoglOffscreen *offscreen; CoglOffscreen *offscreen;
CoglFramebuffer *fb; CoglFramebuffer *fb;
CoglOffscreen *ret;
g_return_val_if_fail (cogl_is_texture (texture), NULL); g_return_val_if_fail (cogl_is_texture (texture), NULL);
offscreen = g_new0 (CoglOffscreen, 1); offscreen = g_object_new (COGL_TYPE_OFFSCREEN,
"context", ctx,
NULL);
offscreen->texture = cogl_object_ref (texture); offscreen->texture = cogl_object_ref (texture);
offscreen->texture_level = level; offscreen->texture_level = level;
offscreen->create_flags = create_flags; offscreen->create_flags = create_flags;
@ -816,17 +922,9 @@ _cogl_offscreen_new_with_texture_full (CoglTexture *texture,
* texture is being loaded from a file then the file might not * texture is being loaded from a file then the file might not
* have been read yet. */ * have been read yet. */
_cogl_framebuffer_init (fb,
ctx,
COGL_FRAMEBUFFER_TYPE_OFFSCREEN,
-1, /* unknown width, until allocation */
-1); /* unknown height until allocation */
ret = _cogl_offscreen_object_new (offscreen);
_cogl_texture_associate_framebuffer (texture, fb); _cogl_texture_associate_framebuffer (texture, fb);
return ret; return offscreen;
} }
CoglOffscreen * CoglOffscreen *
@ -842,25 +940,34 @@ cogl_offscreen_get_texture (CoglOffscreen *offscreen)
} }
static void static void
_cogl_offscreen_free (CoglOffscreen *offscreen) cogl_offscreen_dispose (GObject *object)
{ {
CoglOffscreen *offscreen = COGL_OFFSCREEN (object);
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (offscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (offscreen);
CoglFramebufferPrivate *priv = CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer); cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context; CoglContext *ctx = priv->context;
if (offscreen->texture)
ctx->driver_vtable->offscreen_free (offscreen); ctx->driver_vtable->offscreen_free (offscreen);
/* Chain up to parent */ G_OBJECT_CLASS (cogl_offscreen_parent_class)->dispose (object);
_cogl_framebuffer_free (framebuffer);
if (offscreen->texture != NULL) cogl_clear_object (&offscreen->texture);
cogl_object_unref (offscreen->texture); cogl_clear_object (&offscreen->depth_texture);
}
if (offscreen->depth_texture != NULL) static void
cogl_object_unref (offscreen->depth_texture); cogl_offscreen_init (CoglOffscreen *offscreen)
{
}
g_free (offscreen); static void
cogl_offscreen_class_init (CoglOffscreenClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = cogl_offscreen_dispose;
} }
gboolean gboolean
@ -878,15 +985,16 @@ cogl_framebuffer_allocate (CoglFramebuffer *framebuffer,
{ {
CoglFramebufferPrivate *priv = CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer); cogl_framebuffer_get_instance_private (framebuffer);
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
const CoglWinsysVtable *winsys = _cogl_framebuffer_get_winsys (framebuffer); const CoglWinsysVtable *winsys = _cogl_framebuffer_get_winsys (framebuffer);
CoglContext *ctx = priv->context; CoglContext *ctx = priv->context;
if (priv->allocated) if (priv->allocated)
return TRUE; return TRUE;
if (priv->type == COGL_FRAMEBUFFER_TYPE_ONSCREEN) if (COGL_IS_ONSCREEN (framebuffer))
{ {
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
if (!winsys->onscreen_init (onscreen, error)) if (!winsys->onscreen_init (onscreen, error))
return FALSE; return FALSE;
@ -948,7 +1056,7 @@ _cogl_framebuffer_compare_viewport_state (CoglFramebuffer *a,
priv_a->viewport_height != priv_b->viewport_height || priv_a->viewport_height != priv_b->viewport_height ||
/* NB: we render upside down to offscreen framebuffers and that /* NB: we render upside down to offscreen framebuffers and that
* can affect how we setup the GL viewport... */ * can affect how we setup the GL viewport... */
priv_a->type != priv_b->type) G_OBJECT_TYPE (a) != G_OBJECT_TYPE (b))
return COGL_FRAMEBUFFER_STATE_VIEWPORT; return COGL_FRAMEBUFFER_STATE_VIEWPORT;
else else
return 0; return 0;
@ -1002,10 +1110,7 @@ static unsigned long
_cogl_framebuffer_compare_front_face_winding_state (CoglFramebuffer *a, _cogl_framebuffer_compare_front_face_winding_state (CoglFramebuffer *a,
CoglFramebuffer *b) CoglFramebuffer *b)
{ {
CoglFramebufferPrivate *priv_a = cogl_framebuffer_get_instance_private (a); if (G_OBJECT_TYPE (a) != G_OBJECT_TYPE (b))
CoglFramebufferPrivate *priv_b = cogl_framebuffer_get_instance_private (b);
if (priv_a->type != priv_b->type)
return COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING; return COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING;
else else
return 0; return 0;
@ -1628,7 +1733,7 @@ cogl_blit_framebuffer (CoglFramebuffer *framebuffer,
/* Offscreens we do the normal way, onscreens need an y-flip. Even if /* Offscreens we do the normal way, onscreens need an y-flip. Even if
* we consider offscreens to be rendered upside-down, the offscreen * we consider offscreens to be rendered upside-down, the offscreen
* orientation is in this function's API. */ * orientation is in this function's API. */
if (cogl_is_offscreen (framebuffer)) if (COGL_IS_OFFSCREEN (framebuffer))
{ {
src_x1 = src_x; src_x1 = src_x;
src_y1 = src_y; src_y1 = src_y;
@ -1643,7 +1748,7 @@ cogl_blit_framebuffer (CoglFramebuffer *framebuffer,
src_y2 = src_y1 - height; src_y2 = src_y1 - height;
} }
if (cogl_is_offscreen (dst)) if (COGL_IS_OFFSCREEN (dst))
{ {
dst_x1 = dst_x; dst_x1 = dst_x;
dst_y1 = dst_y; dst_y1 = dst_y;

28
cogl/cogl/cogl-framebuffer.h
View File

@ -35,19 +35,6 @@
#ifndef __COGL_FRAMEBUFFER_H #ifndef __COGL_FRAMEBUFFER_H
#define __COGL_FRAMEBUFFER_H #define __COGL_FRAMEBUFFER_H
/* We forward declare the CoglFramebuffer type here to avoid some circular
* dependency issues with the following headers.
*/
#if defined(__COGL_H_INSIDE__) && !defined(COGL_ENABLE_MUTTER_API) && \
!defined(COGL_GIR_SCANNING)
/* For the public C api we typedef interface types as void to avoid needing
* lots of casting in code and instead we will rely on runtime type checking
* for these objects. */
typedef void CoglFramebuffer;
#else
typedef struct _CoglFramebuffer CoglFramebuffer;
#define COGL_FRAMEBUFFER(X) ((CoglFramebuffer *)(X))
#endif
#include <cogl/cogl-pipeline.h> #include <cogl/cogl-pipeline.h>
#include <cogl/cogl-indices.h> #include <cogl/cogl-indices.h>
@ -98,13 +85,16 @@ G_BEGIN_DECLS
* configuration. * configuration.
*/ */
/** #define COGL_TYPE_FRAMEBUFFER (cogl_framebuffer_get_type ())
* cogl_framebuffer_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT COGL_EXPORT
GType cogl_framebuffer_get_gtype (void); G_DECLARE_DERIVABLE_TYPE (CoglFramebuffer, cogl_framebuffer,
COGL, FRAMEBUFFER, GObject)
struct _CoglFramebufferClass
{
/*< private >*/
GObjectClass parent_class;
};
/** /**
* cogl_framebuffer_allocate: * cogl_framebuffer_allocate:

4
cogl/cogl/cogl-journal.c
View File

@ -1272,7 +1272,7 @@ _cogl_journal_discard (CoglJournal *journal)
/* The journal only holds a reference to the framebuffer while the /* The journal only holds a reference to the framebuffer while the
journal is not empty */ journal is not empty */
cogl_object_unref (journal->framebuffer); g_object_unref (journal->framebuffer);
} }
/* Note: A return value of FALSE doesn't mean 'no' it means /* Note: A return value of FALSE doesn't mean 'no' it means
@ -1533,7 +1533,7 @@ _cogl_journal_log_quad (CoglJournal *journal,
reference to the current framebuffer. This reference will be reference to the current framebuffer. This reference will be
removed when the journal is flushed */ removed when the journal is flushed */
if (journal->vertices->len == 0) if (journal->vertices->len == 0)
cogl_object_ref (framebuffer); g_object_ref (framebuffer);
/* The vertex data is logged into a separate array. The data needs /* The vertex data is logged into a separate array. The data needs
to be copied into a vertex array before it's given to GL so we to be copied into a vertex array before it's given to GL so we

31
cogl/cogl/cogl-offscreen.h
View File

@ -50,20 +50,14 @@ G_BEGIN_DECLS
* Cogl allows creating and operating on offscreen framebuffers. * Cogl allows creating and operating on offscreen framebuffers.
*/ */
typedef struct _CoglOffscreen CoglOffscreen;
#define COGL_OFFSCREEN(X) ((CoglOffscreen *)X)
/**
* cogl_offscreen_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT
GType cogl_offscreen_get_gtype (void);
/* Offscreen api */ /* Offscreen api */
#define COGL_TYPE_OFFSCREEN (cogl_offscreen_get_type ())
COGL_EXPORT
G_DECLARE_FINAL_TYPE (CoglOffscreen, cogl_offscreen,
COGL, OFFSCREEN,
CoglFramebuffer)
/** /**
* cogl_offscreen_new_with_texture: * cogl_offscreen_new_with_texture:
* @texture: A #CoglTexture pointer * @texture: A #CoglTexture pointer
@ -99,19 +93,6 @@ GType cogl_offscreen_get_gtype (void);
COGL_EXPORT CoglOffscreen * COGL_EXPORT CoglOffscreen *
cogl_offscreen_new_with_texture (CoglTexture *texture); cogl_offscreen_new_with_texture (CoglTexture *texture);
/**
* cogl_is_offscreen:
* @object: A pointer to a #CoglObject
*
* Determines whether the given #CoglObject references an offscreen
* framebuffer object.
*
* Returns: %TRUE if @object is a #CoglOffscreen framebuffer,
* %FALSE otherwise
*/
COGL_EXPORT gboolean
cogl_is_offscreen (void *object);
/** /**
* cogl_offscreen_get_texture: (skip) * cogl_offscreen_get_texture: (skip)
*/ */

2
cogl/cogl/cogl-onscreen-private.h
View File

@ -57,7 +57,7 @@ typedef struct _CoglOnscreenQueuedDirty
struct _CoglOnscreen struct _CoglOnscreen
{ {
CoglFramebuffer _parent; CoglFramebuffer parent;
CoglList frame_closures; CoglList frame_closures;

57
cogl/cogl/cogl-onscreen.c
View File

@ -42,13 +42,7 @@
#include "cogl-poll-private.h" #include "cogl-poll-private.h"
#include "cogl-gtype-private.h" #include "cogl-gtype-private.h"
static void _cogl_onscreen_free (CoglOnscreen *onscreen); G_DEFINE_TYPE (CoglOnscreen, cogl_onscreen, COGL_TYPE_FRAMEBUFFER)
COGL_OBJECT_DEFINE_WITH_CODE_GTYPE (Onscreen, onscreen,
_cogl_onscreen_class.virt_unref =
_cogl_framebuffer_unref);
COGL_GTYPE_DEFINE_CLASS (Onscreen, onscreen,
COGL_GTYPE_IMPLEMENT_INTERFACE (framebuffer));
static gpointer static gpointer
cogl_dummy_copy (gpointer data) cogl_dummy_copy (gpointer data)
@ -102,21 +96,21 @@ cogl_onscreen_new (CoglContext *ctx, int width, int height)
is not premultiplied in case it is being used for some special is not premultiplied in case it is being used for some special
purpose. */ purpose. */
onscreen = g_new0 (CoglOnscreen, 1); onscreen = g_object_new (COGL_TYPE_ONSCREEN,
_cogl_framebuffer_init (COGL_FRAMEBUFFER (onscreen), "context", ctx,
ctx, "width", width,
COGL_FRAMEBUFFER_TYPE_ONSCREEN, "height", height,
width, /* width */ NULL);
height); /* height */
_cogl_onscreen_init_from_template (onscreen, ctx->display->onscreen_template); _cogl_onscreen_init_from_template (onscreen, ctx->display->onscreen_template);
return _cogl_onscreen_object_new (onscreen); return onscreen;
} }
static void static void
_cogl_onscreen_free (CoglOnscreen *onscreen) cogl_onscreen_dispose (GObject *object)
{ {
CoglOnscreen *onscreen = COGL_ONSCREEN (object);
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys = _cogl_framebuffer_get_winsys (framebuffer); const CoglWinsysVtable *winsys = _cogl_framebuffer_get_winsys (framebuffer);
CoglFrameInfo *frame_info; CoglFrameInfo *frame_info;
@ -129,13 +123,24 @@ _cogl_onscreen_free (CoglOnscreen *onscreen)
cogl_object_unref (frame_info); cogl_object_unref (frame_info);
g_queue_clear (&onscreen->pending_frame_infos); g_queue_clear (&onscreen->pending_frame_infos);
if (onscreen->winsys)
winsys->onscreen_deinit (onscreen); winsys->onscreen_deinit (onscreen);
g_return_if_fail (onscreen->winsys == NULL); g_return_if_fail (onscreen->winsys == NULL);
/* Chain up to parent */ G_OBJECT_CLASS (cogl_onscreen_parent_class)->dispose (object);
_cogl_framebuffer_free (framebuffer); }
g_free (onscreen); static void
cogl_onscreen_init (CoglOnscreen *onscreen)
{
}
static void
cogl_onscreen_class_init (CoglOnscreenClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = cogl_onscreen_dispose;
} }
static void static void
@ -172,7 +177,7 @@ _cogl_dispatch_onscreen_cb (CoglContext *context)
notify_event (onscreen, event->type, info); notify_event (onscreen, event->type, info);
cogl_object_unref (onscreen); g_object_unref (onscreen);
cogl_object_unref (info); cogl_object_unref (info);
g_slice_free (CoglOnscreenEvent, event); g_slice_free (CoglOnscreenEvent, event);
@ -192,7 +197,7 @@ _cogl_dispatch_onscreen_cb (CoglContext *context)
qe->onscreen, qe->onscreen,
&qe->info); &qe->info);
cogl_object_unref (qe->onscreen); g_object_unref (qe->onscreen);
g_slice_free (CoglOnscreenQueuedDirty, qe); g_slice_free (CoglOnscreenQueuedDirty, qe);
} }
@ -223,7 +228,7 @@ _cogl_onscreen_queue_dirty (CoglOnscreen *onscreen,
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer); CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
CoglOnscreenQueuedDirty *qe = g_slice_new (CoglOnscreenQueuedDirty); CoglOnscreenQueuedDirty *qe = g_slice_new (CoglOnscreenQueuedDirty);
qe->onscreen = cogl_object_ref (onscreen); qe->onscreen = g_object_ref (onscreen);
qe->info = *info; qe->info = *info;
_cogl_list_insert (ctx->onscreen_dirty_queue.prev, &qe->link); _cogl_list_insert (ctx->onscreen_dirty_queue.prev, &qe->link);
@ -254,7 +259,7 @@ _cogl_onscreen_queue_event (CoglOnscreen *onscreen,
CoglOnscreenEvent *event = g_slice_new (CoglOnscreenEvent); CoglOnscreenEvent *event = g_slice_new (CoglOnscreenEvent);
event->onscreen = cogl_object_ref (onscreen); event->onscreen = g_object_ref (onscreen);
event->info = cogl_object_ref (info); event->info = cogl_object_ref (info);
event->type = type; event->type = type;
@ -272,7 +277,7 @@ cogl_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys; const CoglWinsysVtable *winsys;
g_return_if_fail (cogl_is_onscreen (framebuffer)); g_return_if_fail (COGL_IS_ONSCREEN (framebuffer));
info->frame_counter = onscreen->frame_counter; info->frame_counter = onscreen->frame_counter;
g_queue_push_tail (&onscreen->pending_frame_infos, info); g_queue_push_tail (&onscreen->pending_frame_infos, info);
@ -321,7 +326,7 @@ cogl_onscreen_swap_region (CoglOnscreen *onscreen,
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys; const CoglWinsysVtable *winsys;
g_return_if_fail (cogl_is_onscreen (framebuffer)); g_return_if_fail (COGL_IS_ONSCREEN (framebuffer));
info->frame_counter = onscreen->frame_counter; info->frame_counter = onscreen->frame_counter;
g_queue_push_tail (&onscreen->pending_frame_infos, info); g_queue_push_tail (&onscreen->pending_frame_infos, info);
@ -367,7 +372,7 @@ cogl_onscreen_get_buffer_age (CoglOnscreen *onscreen)
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys; const CoglWinsysVtable *winsys;
g_return_val_if_fail (cogl_is_onscreen (framebuffer), 0); g_return_val_if_fail (COGL_IS_ONSCREEN (framebuffer), 0);
winsys = _cogl_framebuffer_get_winsys (framebuffer); winsys = _cogl_framebuffer_get_winsys (framebuffer);
@ -386,7 +391,7 @@ cogl_onscreen_direct_scanout (CoglOnscreen *onscreen,
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys; const CoglWinsysVtable *winsys;
g_warn_if_fail (cogl_is_onscreen (framebuffer)); g_warn_if_fail (COGL_IS_ONSCREEN (framebuffer));
g_warn_if_fail (_cogl_winsys_has_feature (COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT)); g_warn_if_fail (_cogl_winsys_has_feature (COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT));
info->frame_counter = onscreen->frame_counter; info->frame_counter = onscreen->frame_counter;

29
cogl/cogl/cogl-onscreen.h
View File

@ -47,19 +47,14 @@
G_BEGIN_DECLS G_BEGIN_DECLS
typedef struct _CoglOnscreen CoglOnscreen; #define COGL_TYPE_ONSCREEN (cogl_onscreen_get_type ())
#define COGL_ONSCREEN(X) ((CoglOnscreen *)(X)) COGL_EXPORT
G_DECLARE_FINAL_TYPE (CoglOnscreen, cogl_onscreen,
COGL, ONSCREEN,
CoglFramebuffer)
typedef struct _CoglScanout CoglScanout; typedef struct _CoglScanout CoglScanout;
/**
* cogl_onscreen_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT
GType cogl_onscreen_get_gtype (void);
/** /**
* cogl_onscreen_new: (constructor) (skip) * cogl_onscreen_new: (constructor) (skip)
* @context: A #CoglContext * @context: A #CoglContext
@ -750,20 +745,6 @@ COGL_EXPORT void
cogl_onscreen_remove_dirty_callback (CoglOnscreen *onscreen, cogl_onscreen_remove_dirty_callback (CoglOnscreen *onscreen,
CoglOnscreenDirtyClosure *closure); CoglOnscreenDirtyClosure *closure);
/**
* cogl_is_onscreen:
* @object: A #CoglObject pointer
*
* Gets whether the given object references a #CoglOnscreen.
*
* Return value: %TRUE if the object references a #CoglOnscreen
* and %FALSE otherwise.
* Since: 1.10
* Stability: unstable
*/
COGL_EXPORT gboolean
cogl_is_onscreen (void *object);
/** /**
* cogl_onscreen_get_frame_counter: * cogl_onscreen_get_frame_counter:
* *

22
cogl/cogl/cogl-texture.c
View File

@ -579,7 +579,7 @@ get_texture_bits_via_offscreen (CoglTexture *meta_texture,
cogl_object_unref (bitmap); cogl_object_unref (bitmap);
cogl_object_unref (framebuffer); g_object_unref (framebuffer);
return ret; return ret;
} }
@ -892,31 +892,23 @@ cogl_texture_get_data (CoglTexture *texture,
} }
static void static void
_cogl_texture_framebuffer_destroy_cb (void *user_data, on_framebuffer_destroy (CoglFramebuffer *framebuffer,
void *instance) CoglTexture *texture)
{ {
CoglTexture *tex = user_data; texture->framebuffers = g_list_remove (texture->framebuffers, framebuffer);
CoglFramebuffer *framebuffer = instance;
tex->framebuffers = g_list_remove (tex->framebuffers, framebuffer);
} }
void void
_cogl_texture_associate_framebuffer (CoglTexture *texture, _cogl_texture_associate_framebuffer (CoglTexture *texture,
CoglFramebuffer *framebuffer) CoglFramebuffer *framebuffer)
{ {
static CoglUserDataKey framebuffer_destroy_notify_key;
/* Note: we don't take a reference on the framebuffer here because /* Note: we don't take a reference on the framebuffer here because
* that would introduce a circular reference. */ * that would introduce a circular reference. */
texture->framebuffers = g_list_prepend (texture->framebuffers, framebuffer); texture->framebuffers = g_list_prepend (texture->framebuffers, framebuffer);
/* Since we haven't taken a reference on the framebuffer we setup g_signal_connect (framebuffer, "destroy",
* some private data so we will be notified if it is destroyed... */ G_CALLBACK (on_framebuffer_destroy),
_cogl_object_set_user_data (COGL_OBJECT (framebuffer), texture);
&framebuffer_destroy_notify_key,
texture,
_cogl_texture_framebuffer_destroy_cb);
} }
const GList * const GList *

2
cogl/cogl/cogl-types.h
View File

@ -86,6 +86,8 @@ typedef void * CoglHandle;
COGL_EXPORT GType COGL_EXPORT GType
cogl_handle_get_type (void) G_GNUC_CONST; cogl_handle_get_type (void) G_GNUC_CONST;
typedef struct _CoglFramebuffer CoglFramebuffer;
/** /**
* CoglAngle: * CoglAngle:
* *

1
cogl/cogl/deprecated/cogl-type-casts.h
View File

@ -45,7 +45,6 @@
*/ */
#if !defined(COGL_ENABLE_MUTTER_API) && !defined(COGL_GIR_SCANNING) #if !defined(COGL_ENABLE_MUTTER_API) && !defined(COGL_GIR_SCANNING)
#define COGL_FRAMEBUFFER(X) (X)
#define COGL_BUFFER(X) (X) #define COGL_BUFFER(X) (X)
#define COGL_TEXTURE(X) (X) #define COGL_TEXTURE(X) (X)
#define COGL_META_TEXTURE(X) (X) #define COGL_META_TEXTURE(X) (X)

2
cogl/cogl/driver/gl/cogl-clip-stack-gl.c
View File

@ -453,7 +453,7 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
* down so in this case no conversion is needed. * down so in this case no conversion is needed.
*/ */
if (cogl_is_offscreen (framebuffer)) if (COGL_IS_OFFSCREEN (framebuffer))
scissor_y_start = scissor_y0; scissor_y_start = scissor_y0;
else else
{ {

24
cogl/cogl/driver/gl/cogl-framebuffer-gl.c
View File

@ -153,7 +153,7 @@ _cogl_framebuffer_gl_flush_viewport_state (CoglFramebuffer *framebuffer)
* left, while Cogl defines them to be top left. * left, while Cogl defines them to be top left.
* NB: We render upside down to offscreen framebuffers so we don't * NB: We render upside down to offscreen framebuffers so we don't
* need to convert the y offset in this case. */ * need to convert the y offset in this case. */
if (cogl_is_offscreen (framebuffer)) if (COGL_IS_OFFSCREEN (framebuffer))
gl_viewport_y = viewport_y; gl_viewport_y = viewport_y;
else else
gl_viewport_y = gl_viewport_y =
@ -255,7 +255,7 @@ _cogl_framebuffer_gl_flush_stereo_mode_state (CoglFramebuffer *framebuffer)
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer); CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
GLenum draw_buffer = GL_BACK; GLenum draw_buffer = GL_BACK;
if (cogl_is_offscreen (framebuffer)) if (COGL_IS_OFFSCREEN (framebuffer))
return; return;
if (!ctx->glDrawBuffer) if (!ctx->glDrawBuffer)
@ -290,7 +290,7 @@ _cogl_framebuffer_gl_bind (CoglFramebuffer *framebuffer, GLenum target)
{ {
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer); CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
if (cogl_is_offscreen (framebuffer)) if (COGL_IS_OFFSCREEN (framebuffer))
{ {
CoglOffscreen *offscreen = COGL_OFFSCREEN (framebuffer); CoglOffscreen *offscreen = COGL_OFFSCREEN (framebuffer);
GE (ctx, glBindFramebuffer (target, GE (ctx, glBindFramebuffer (target,
@ -986,11 +986,11 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
#ifdef HAVE_COGL_GL #ifdef HAVE_COGL_GL
if ((ctx->driver == COGL_DRIVER_GL3 && if ((ctx->driver == COGL_DRIVER_GL3 &&
cogl_is_onscreen (framebuffer)) || COGL_IS_ONSCREEN (framebuffer)) ||
(_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS) && (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS) &&
cogl_is_offscreen (framebuffer))) COGL_IS_OFFSCREEN (framebuffer)))
{ {
gboolean is_offscreen = cogl_is_offscreen (framebuffer); gboolean is_offscreen = COGL_IS_OFFSCREEN (framebuffer);
const struct { const struct {
GLenum attachment, pname; GLenum attachment, pname;
size_t offset; size_t offset;
@ -1040,7 +1040,7 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
/* If we don't have alpha textures then the alpha bits are actually /* If we don't have alpha textures then the alpha bits are actually
* stored in the red component */ * stored in the red component */
if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) && if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
cogl_is_offscreen (framebuffer) && COGL_IS_OFFSCREEN (framebuffer) &&
cogl_framebuffer_get_internal_format (framebuffer) == COGL_PIXEL_FORMAT_A_8) cogl_framebuffer_get_internal_format (framebuffer) == COGL_PIXEL_FORMAT_A_8)
{ {
framebuffer_gl->bits.alpha = framebuffer_gl->bits.red; framebuffer_gl->bits.alpha = framebuffer_gl->bits.red;
@ -1050,7 +1050,7 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
COGL_NOTE (OFFSCREEN, COGL_NOTE (OFFSCREEN,
"RGBA/D/S Bits for framebuffer[%p, %s]: %d, %d, %d, %d, %d, %d", "RGBA/D/S Bits for framebuffer[%p, %s]: %d, %d, %d, %d, %d, %d",
framebuffer, framebuffer,
cogl_is_offscreen (framebuffer) ? "offscreen" : "onscreen", COGL_IS_OFFSCREEN (framebuffer) ? "offscreen" : "onscreen",
framebuffer_gl->bits.red, framebuffer_gl->bits.red,
framebuffer_gl->bits.blue, framebuffer_gl->bits.blue,
framebuffer_gl->bits.green, framebuffer_gl->bits.green,
@ -1098,7 +1098,7 @@ _cogl_framebuffer_gl_discard_buffers (CoglFramebuffer *framebuffer,
GLenum attachments[3]; GLenum attachments[3];
int i = 0; int i = 0;
if (cogl_is_onscreen (framebuffer)) if (COGL_IS_ONSCREEN (framebuffer))
{ {
if (buffers & COGL_BUFFER_BIT_COLOR) if (buffers & COGL_BUFFER_BIT_COLOR)
attachments[i++] = GL_COLOR; attachments[i++] = GL_COLOR;
@ -1245,7 +1245,7 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
* NB: all offscreen rendering is done upside down so no conversion * NB: all offscreen rendering is done upside down so no conversion
* is necissary in this case. * is necissary in this case.
*/ */
if (!cogl_is_offscreen (framebuffer)) if (!COGL_IS_OFFSCREEN (framebuffer))
y = framebuffer_height - y - height; y = framebuffer_height - y - height;
required_format = ctx->driver_vtable->pixel_format_to_gl (ctx, required_format = ctx->driver_vtable->pixel_format_to_gl (ctx,
@ -1258,7 +1258,7 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
* to flip in this case... */ * to flip in this case... */
if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_MESA_PACK_INVERT) && if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_MESA_PACK_INVERT) &&
(source & COGL_READ_PIXELS_NO_FLIP) == 0 && (source & COGL_READ_PIXELS_NO_FLIP) == 0 &&
!cogl_is_offscreen (framebuffer)) !COGL_IS_OFFSCREEN (framebuffer))
{ {
if (ctx->driver == COGL_DRIVER_GLES2) if (ctx->driver == COGL_DRIVER_GLES2)
gl_pack_enum = GL_PACK_REVERSE_ROW_ORDER_ANGLE; gl_pack_enum = GL_PACK_REVERSE_ROW_ORDER_ANGLE;
@ -1415,7 +1415,7 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
/* NB: All offscreen rendering is done upside down so there is no need /* NB: All offscreen rendering is done upside down so there is no need
* to flip in this case... */ * to flip in this case... */
if (!cogl_is_offscreen (framebuffer) && if (!COGL_IS_OFFSCREEN (framebuffer) &&
(source & COGL_READ_PIXELS_NO_FLIP) == 0 && (source & COGL_READ_PIXELS_NO_FLIP) == 0 &&
!pack_invert_set) !pack_invert_set)
{ {

2
cogl/cogl/driver/gl/cogl-pipeline-opengl.c
View File

@ -428,7 +428,7 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
/* If we are painting to an offscreen framebuffer then we /* If we are painting to an offscreen framebuffer then we
need to invert the winding of the front face because need to invert the winding of the front face because
everything is painted upside down */ everything is painted upside down */
invert_winding = cogl_is_offscreen (ctx->current_draw_buffer); invert_winding = COGL_IS_OFFSCREEN (ctx->current_draw_buffer);
switch (cull_face_state->front_winding) switch (cull_face_state->front_winding)
{ {

2
cogl/cogl/driver/gl/cogl-pipeline-progend-glsl.c
View File

@ -1016,7 +1016,7 @@ _cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline,
if (modelview_entry == NULL || projection_entry == NULL) if (modelview_entry == NULL || projection_entry == NULL)
return; return;
needs_flip = cogl_is_offscreen (ctx->current_draw_buffer); needs_flip = COGL_IS_OFFSCREEN (ctx->current_draw_buffer);
projection_changed = projection_changed =
_cogl_matrix_entry_cache_maybe_update (&program_state->projection_cache, _cogl_matrix_entry_cache_maybe_update (&program_state->projection_cache,

4
cogl/cogl/winsys/cogl-winsys-egl-x11.c
View File

@ -81,7 +81,7 @@ find_onscreen_for_xid (CoglContext *context, uint32_t xid)
CoglOnscreenEGL *egl_onscreen; CoglOnscreenEGL *egl_onscreen;
CoglOnscreenXlib *xlib_onscreen; CoglOnscreenXlib *xlib_onscreen;
if (!cogl_is_onscreen (framebuffer)) if (!COGL_IS_ONSCREEN (framebuffer))
continue; continue;
egl_onscreen = COGL_ONSCREEN (framebuffer)->winsys; egl_onscreen = COGL_ONSCREEN (framebuffer)->winsys;
@ -99,7 +99,7 @@ flush_pending_resize_notifications_cb (void *data,
{ {
CoglFramebuffer *framebuffer = data; CoglFramebuffer *framebuffer = data;
if (cogl_is_onscreen (framebuffer)) if (COGL_IS_ONSCREEN (framebuffer))
{ {
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer); CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
CoglOnscreenEGL *egl_onscreen = onscreen->winsys; CoglOnscreenEGL *egl_onscreen = onscreen->winsys;

6
cogl/cogl/winsys/cogl-winsys-glx.c
View File

@ -178,7 +178,7 @@ find_onscreen_for_xid (CoglContext *context, uint32_t xid)
CoglFramebuffer *framebuffer = l->data; CoglFramebuffer *framebuffer = l->data;
CoglOnscreenXlib *xlib_onscreen; CoglOnscreenXlib *xlib_onscreen;
if (!cogl_is_onscreen (framebuffer)) if (!COGL_IS_ONSCREEN (framebuffer))
continue; continue;
/* Does the GLXEvent have the GLXDrawable or the X Window? */ /* Does the GLXEvent have the GLXDrawable or the X Window? */
@ -331,7 +331,7 @@ flush_pending_notifications_cb (void *data,
{ {
CoglFramebuffer *framebuffer = data; CoglFramebuffer *framebuffer = data;
if (cogl_is_onscreen (framebuffer)) if (COGL_IS_ONSCREEN (framebuffer))
{ {
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer); CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
CoglOnscreenGLX *glx_onscreen = onscreen->winsys; CoglOnscreenGLX *glx_onscreen = onscreen->winsys;
@ -633,7 +633,7 @@ update_all_outputs (CoglRenderer *renderer)
{ {
CoglFramebuffer *framebuffer = l->data; CoglFramebuffer *framebuffer = l->data;
if (!cogl_is_onscreen (framebuffer)) if (!COGL_IS_ONSCREEN (framebuffer))
continue; continue;
update_output (COGL_ONSCREEN (framebuffer)); update_output (COGL_ONSCREEN (framebuffer));

2
cogl/test-fixtures/test-utils.c
View File

@ -164,7 +164,7 @@ void
test_utils_fini (void) test_utils_fini (void)
{ {
if (test_fb) if (test_fb)
cogl_object_unref (test_fb); g_object_unref (test_fb);
if (test_ctx) if (test_ctx)
cogl_object_unref (test_ctx); cogl_object_unref (test_ctx);

4
cogl/tests/conform/test-backface-culling.c
View File

@ -303,12 +303,12 @@ test_backface_culling (void)
state.width, state.height, state.width, state.height,
TEST_UTILS_TEXTURE_NO_SLICING, TEST_UTILS_TEXTURE_NO_SLICING,
COGL_TEXTURE_COMPONENTS_RGBA); COGL_TEXTURE_COMPONENTS_RGBA);
state.offscreen = cogl_offscreen_new_with_texture (tex); state.offscreen = COGL_FRAMEBUFFER (cogl_offscreen_new_with_texture (tex));
state.offscreen_tex = tex; state.offscreen_tex = tex;
paint (&state); paint (&state);
cogl_object_unref (state.offscreen); g_object_unref (state.offscreen);
cogl_object_unref (state.offscreen_tex); cogl_object_unref (state.offscreen_tex);
cogl_object_unref (state.texture); cogl_object_unref (state.texture);

8
cogl/tests/conform/test-framebuffer-get-bits.c
View File

@ -11,13 +11,13 @@ test_framebuffer_get_bits (void)
16, 16); /* width/height */ 16, 16); /* width/height */
CoglOffscreen *offscreen_a = CoglOffscreen *offscreen_a =
cogl_offscreen_new_with_texture (tex_a); cogl_offscreen_new_with_texture (tex_a);
CoglFramebuffer *fb_a = offscreen_a; CoglFramebuffer *fb_a = COGL_FRAMEBUFFER (offscreen_a);
CoglTexture2D *tex_rgba = CoglTexture2D *tex_rgba =
cogl_texture_2d_new_with_size (test_ctx, cogl_texture_2d_new_with_size (test_ctx,
16, 16); /* width/height */ 16, 16); /* width/height */
CoglOffscreen *offscreen_rgba = CoglOffscreen *offscreen_rgba =
cogl_offscreen_new_with_texture (tex_rgba); cogl_offscreen_new_with_texture (tex_rgba);
CoglFramebuffer *fb_rgba = offscreen_rgba; CoglFramebuffer *fb_rgba = COGL_FRAMEBUFFER (offscreen_rgba);
cogl_texture_set_components (tex_a, cogl_texture_set_components (tex_a,
COGL_TEXTURE_COMPONENTS_A); COGL_TEXTURE_COMPONENTS_A);
@ -34,8 +34,8 @@ test_framebuffer_get_bits (void)
g_assert_cmpint (cogl_framebuffer_get_blue_bits (fb_rgba), >=, 1); g_assert_cmpint (cogl_framebuffer_get_blue_bits (fb_rgba), >=, 1);
g_assert_cmpint (cogl_framebuffer_get_alpha_bits (fb_rgba), >=, 1); g_assert_cmpint (cogl_framebuffer_get_alpha_bits (fb_rgba), >=, 1);
cogl_object_unref (fb_rgba); g_object_unref (fb_rgba);
cogl_object_unref (tex_rgba); cogl_object_unref (tex_rgba);
cogl_object_unref (fb_a); g_object_unref (fb_a);
cogl_object_unref (tex_a); cogl_object_unref (tex_a);
} }

26
cogl/tests/conform/test-offscreen.c
View File

@ -44,6 +44,7 @@ test_paint (TestState *state)
CoglTexture2D *tex_2d; CoglTexture2D *tex_2d;
CoglTexture *tex; CoglTexture *tex;
CoglOffscreen *offscreen; CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglPipeline *opaque_pipeline; CoglPipeline *opaque_pipeline;
CoglPipeline *texture_pipeline; CoglPipeline *texture_pipeline;
@ -53,6 +54,7 @@ test_paint (TestState *state)
tex = tex_2d; tex = tex_2d;
offscreen = cogl_offscreen_new_with_texture (tex); offscreen = cogl_offscreen_new_with_texture (tex);
framebuffer = COGL_FRAMEBUFFER (offscreen);
/* Set a scale and translate transform on the window framebuffer /* Set a scale and translate transform on the window framebuffer
* before switching to the offscreen framebuffer so we can verify it * before switching to the offscreen framebuffer so we can verify it
@ -76,20 +78,24 @@ test_paint (TestState *state)
opaque_pipeline = cogl_pipeline_new (test_ctx); opaque_pipeline = cogl_pipeline_new (test_ctx);
/* red, top left */ /* red, top left */
cogl_pipeline_set_color4ub (opaque_pipeline, 0xff, 0x00, 0x00, 0xff); cogl_pipeline_set_color4ub (opaque_pipeline, 0xff, 0x00, 0x00, 0xff);
cogl_framebuffer_draw_rectangle (offscreen, opaque_pipeline, -0.5, 0.5, 0, 0); cogl_framebuffer_draw_rectangle (framebuffer, opaque_pipeline,
-0.5, 0.5, 0, 0);
/* green, top right */ /* green, top right */
cogl_pipeline_set_color4ub (opaque_pipeline, 0x00, 0xff, 0x00, 0xff); cogl_pipeline_set_color4ub (opaque_pipeline, 0x00, 0xff, 0x00, 0xff);
cogl_framebuffer_draw_rectangle (offscreen, opaque_pipeline, 0, 0.5, 0.5, 0); cogl_framebuffer_draw_rectangle (framebuffer, opaque_pipeline,
0, 0.5, 0.5, 0);
/* blue, bottom left */ /* blue, bottom left */
cogl_pipeline_set_color4ub (opaque_pipeline, 0x00, 0x00, 0xff, 0xff); cogl_pipeline_set_color4ub (opaque_pipeline, 0x00, 0x00, 0xff, 0xff);
cogl_framebuffer_draw_rectangle (offscreen, opaque_pipeline, -0.5, 0, 0, -0.5); cogl_framebuffer_draw_rectangle (framebuffer, opaque_pipeline,
-0.5, 0, 0, -0.5);
/* white, bottom right */ /* white, bottom right */
cogl_pipeline_set_color4ub (opaque_pipeline, 0xff, 0xff, 0xff, 0xff); cogl_pipeline_set_color4ub (opaque_pipeline, 0xff, 0xff, 0xff, 0xff);
cogl_framebuffer_draw_rectangle (offscreen, opaque_pipeline, 0, 0, 0.5, -0.5); cogl_framebuffer_draw_rectangle (framebuffer, opaque_pipeline,
0, 0, 0.5, -0.5);
/* Cogl should release the last reference when we call cogl_pop_framebuffer() /* Cogl should release the last reference when we call cogl_pop_framebuffer()
*/ */
cogl_object_unref (offscreen); g_object_unref (offscreen);
texture_pipeline = cogl_pipeline_new (test_ctx); texture_pipeline = cogl_pipeline_new (test_ctx);
cogl_pipeline_set_layer_texture (texture_pipeline, 0, tex); cogl_pipeline_set_layer_texture (texture_pipeline, 0, tex);
@ -121,6 +127,7 @@ test_flush (TestState *state)
CoglTexture2D *tex_2d; CoglTexture2D *tex_2d;
CoglTexture *tex; CoglTexture *tex;
CoglOffscreen *offscreen; CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglColor clear_color; CoglColor clear_color;
int i; int i;
@ -138,15 +145,16 @@ test_flush (TestState *state)
tex = tex_2d; tex = tex_2d;
offscreen = cogl_offscreen_new_with_texture (tex); offscreen = cogl_offscreen_new_with_texture (tex);
framebuffer = COGL_FRAMEBUFFER (offscreen);
cogl_color_init_from_4ub (&clear_color, 0, 0, 0, 255); cogl_color_init_from_4ub (&clear_color, 0, 0, 0, 255);
cogl_framebuffer_clear (offscreen, COGL_BUFFER_BIT_COLOR, &clear_color); cogl_framebuffer_clear (framebuffer, COGL_BUFFER_BIT_COLOR, &clear_color);
cogl_framebuffer_draw_rectangle (offscreen, pipeline, -1, -1, 1, 1); cogl_framebuffer_draw_rectangle (framebuffer, pipeline, -1, -1, 1, 1);
if (i == 0) if (i == 0)
/* First time check using read pixels on the offscreen */ /* First time check using read pixels on the offscreen */
test_utils_check_region (offscreen, test_utils_check_region (framebuffer,
1, 1, 15, 15, 0xff0000ff); 1, 1, 15, 15, 0xff0000ff);
else if (i == 1) else if (i == 1)
{ {
@ -178,7 +186,7 @@ test_flush (TestState *state)
} }
cogl_object_unref (tex_2d); cogl_object_unref (tex_2d);
cogl_object_unref (offscreen); g_object_unref (offscreen);
} }
cogl_object_unref (pipeline); cogl_object_unref (pipeline);

4
cogl/tests/conform/test-pipeline-shader-state.c
View File

@ -25,9 +25,9 @@ test_pipeline_shader_state (void)
tex = cogl_texture_2d_new_with_size (test_ctx, 128, 128); tex = cogl_texture_2d_new_with_size (test_ctx, 128, 128);
offscreen = cogl_offscreen_new_with_texture (tex); offscreen = cogl_offscreen_new_with_texture (tex);
fb = offscreen; fb = COGL_FRAMEBUFFER (offscreen);
cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1); cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_object_unref (offscreen); g_object_unref (offscreen);
cogl_framebuffer_clear4f (test_fb, COGL_BUFFER_BIT_COLOR, 1, 1, 0, 1); cogl_framebuffer_clear4f (test_fb, COGL_BUFFER_BIT_COLOR, 1, 1, 0, 1);

2
cogl/tests/conform/test-readpixels.c
View File

@ -83,7 +83,7 @@ on_paint (ClutterActor *actor,
g_free (pixels); g_free (pixels);
cogl_pop_framebuffer (); cogl_pop_framebuffer ();
cogl_object_unref (offscreen); g_object_unref (offscreen);
/* Now verify reading back from an onscreen framebuffer... /* Now verify reading back from an onscreen framebuffer...
*/ */

2
cogl/tests/conform/test-viewport.c
View File

@ -337,7 +337,7 @@ on_paint (ClutterActor *actor,
cogl_set_viewport (0, 0, 10, 10); cogl_set_viewport (0, 0, 10, 10);
cogl_pop_framebuffer (); cogl_pop_framebuffer ();
cogl_object_unref (offscreen); g_object_unref (offscreen);
/* /*
* Verify that the previous onscreen framebuffer's viewport was restored * Verify that the previous onscreen framebuffer's viewport was restored

4
src/backends/meta-screen-cast-stream-src.c
View File

@ -214,7 +214,7 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
cogl_object_unref (bitmap_texture); cogl_object_unref (bitmap_texture);
if (!cogl_framebuffer_allocate (fb, error)) if (!cogl_framebuffer_allocate (fb, error))
{ {
cogl_object_unref (fb); g_object_unref (fb);
return FALSE; return FALSE;
} }
@ -234,7 +234,7 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
bitmap_width, bitmap_height, bitmap_width, bitmap_height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_PIXEL_FORMAT_RGBA_8888_PRE,
bitmap_data); bitmap_data);
cogl_object_unref (fb); g_object_unref (fb);
return TRUE; return TRUE;
} }

24
src/backends/native/meta-renderer-native.c
View File

@ -1278,7 +1278,7 @@ queue_dummy_power_save_page_flip (CoglOnscreen *onscreen)
renderer_native->power_save_page_flip_onscreens = renderer_native->power_save_page_flip_onscreens =
g_list_prepend (renderer_native->power_save_page_flip_onscreens, g_list_prepend (renderer_native->power_save_page_flip_onscreens,
cogl_object_ref (onscreen)); g_object_ref (onscreen));
} }
static void static void
@ -1635,7 +1635,7 @@ create_dma_buf_framebuffer (MetaRendererNative *renderer_native,
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (cogl_fbo), error)) if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (cogl_fbo), error))
{ {
cogl_object_unref (cogl_fbo); g_object_unref (cogl_fbo);
return NULL; return NULL;
} }
@ -1706,11 +1706,11 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
dumb_fb->height, dumb_fb->height,
&error)) &error))
{ {
cogl_object_unref (dmabuf_fb); g_object_unref (dmabuf_fb);
return FALSE; return FALSE;
} }
cogl_object_unref (dmabuf_fb); g_object_unref (dmabuf_fb);
g_clear_object (&secondary_gpu_state->gbm.next_fb); g_clear_object (&secondary_gpu_state->gbm.next_fb);
buffer_dumb = meta_drm_buffer_dumb_new (dumb_fb->fb_id); buffer_dumb = meta_drm_buffer_dumb_new (dumb_fb->fb_id);
@ -2051,7 +2051,7 @@ meta_renderer_native_create_dma_buf (CoglRenderer *cogl_renderer,
width, height, stride, offset, bpp, width, height, stride, offset, bpp,
new_bo, new_bo,
(GDestroyNotify) gbm_bo_destroy); (GDestroyNotify) gbm_bo_destroy);
cogl_object_unref (dmabuf_fb); g_object_unref (dmabuf_fb);
return dmabuf_handle; return dmabuf_handle;
} }
break; break;
@ -2790,7 +2790,7 @@ meta_renderer_native_create_onscreen (MetaRendererNative *renderer_native,
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error)) if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error))
{ {
cogl_object_unref (onscreen); g_object_unref (onscreen);
return NULL; return NULL;
} }
@ -2805,7 +2805,7 @@ meta_renderer_native_create_onscreen (MetaRendererNative *renderer_native,
{ {
if (!init_secondary_gpu_state (renderer_native, onscreen, error)) if (!init_secondary_gpu_state (renderer_native, onscreen, error))
{ {
cogl_object_unref (onscreen); g_object_unref (onscreen);
return NULL; return NULL;
} }
} }
@ -2836,7 +2836,7 @@ meta_renderer_native_create_offscreen (MetaRendererNative *renderer,
cogl_object_unref (tex); cogl_object_unref (tex);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (fb), error)) if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (fb), error))
{ {
cogl_object_unref (fb); g_object_unref (fb);
return FALSE; return FALSE;
} }
@ -3075,20 +3075,20 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
"transform", view_transform, "transform", view_transform,
"refresh-rate", crtc_mode_info->refresh_rate, "refresh-rate", crtc_mode_info->refresh_rate,
NULL); NULL);
g_clear_pointer (&offscreen, cogl_object_unref); g_clear_object (&offscreen);
meta_onscreen_native_set_view (onscreen, view); meta_onscreen_native_set_view (onscreen, view);
if (!meta_onscreen_native_allocate (onscreen, &error)) if (!meta_onscreen_native_allocate (onscreen, &error))
{ {
g_warning ("Could not create onscreen: %s", error->message); g_warning ("Could not create onscreen: %s", error->message);
cogl_object_unref (onscreen); g_object_unref (onscreen);
g_object_unref (view); g_object_unref (view);
g_error_free (error); g_error_free (error);
return NULL; return NULL;
} }
cogl_object_unref (onscreen); g_object_unref (onscreen);
/* Ensure we don't point to stale surfaces when creating the offscreen */ /* Ensure we don't point to stale surfaces when creating the offscreen */
onscreen_egl = onscreen->winsys; onscreen_egl = onscreen->winsys;
@ -3857,7 +3857,7 @@ meta_renderer_native_finalize (GObject *object)
if (renderer_native->power_save_page_flip_onscreens) if (renderer_native->power_save_page_flip_onscreens)
{ {
g_list_free_full (renderer_native->power_save_page_flip_onscreens, g_list_free_full (renderer_native->power_save_page_flip_onscreens,
(GDestroyNotify) cogl_object_unref); g_object_unref);
g_clear_handle_id (&renderer_native->power_save_page_flip_source_id, g_clear_handle_id (&renderer_native->power_save_page_flip_source_id,
g_source_remove); g_source_remove);
} }

4
src/backends/x11/meta-stage-x11.c
View File

@ -251,7 +251,7 @@ meta_stage_x11_unrealize (ClutterStageWindow *stage_window)
clutter_stage_window_parent_iface->unrealize (stage_window); clutter_stage_window_parent_iface->unrealize (stage_window);
g_clear_pointer (&stage_x11->onscreen, cogl_object_unref); g_clear_object (&stage_x11->onscreen);
} }
static gboolean static gboolean
@ -289,7 +289,7 @@ meta_stage_x11_realize (ClutterStageWindow *stage_window)
{ {
g_warning ("Failed to allocate stage: %s", error->message); g_warning ("Failed to allocate stage: %s", error->message);
g_error_free (error); g_error_free (error);
cogl_object_unref (stage_x11->onscreen); g_object_unref (stage_x11->onscreen);
abort(); abort();
} }

14
src/compositor/meta-background.c
View File

@ -94,11 +94,8 @@ free_fbos (MetaBackground *self)
for (i = 0; i < self->n_monitors; i++) for (i = 0; i < self->n_monitors; i++)
{ {
MetaBackgroundMonitor *monitor = &self->monitors[i]; MetaBackgroundMonitor *monitor = &self->monitors[i];
if (monitor->fbo)
{ g_clear_object (&monitor->fbo);
cogl_object_unref (monitor->fbo);
monitor->fbo = NULL;
}
if (monitor->texture) if (monitor->texture)
{ {
cogl_object_unref (monitor->texture); cogl_object_unref (monitor->texture);
@ -698,7 +695,7 @@ ensure_wallpaper_texture (MetaBackground *self,
cogl_object_unref (self->wallpaper_texture); cogl_object_unref (self->wallpaper_texture);
self->wallpaper_texture = NULL; self->wallpaper_texture = NULL;
cogl_object_unref (fbo); g_object_unref (fbo);
self->wallpaper_allocation_failed = TRUE; self->wallpaper_allocation_failed = TRUE;
return FALSE; return FALSE;
@ -723,7 +720,7 @@ ensure_wallpaper_texture (MetaBackground *self,
cogl_object_unref (pipeline); cogl_object_unref (pipeline);
} }
cogl_object_unref (fbo); g_object_unref (fbo);
} }
return self->wallpaper_texture != NULL; return self->wallpaper_texture != NULL;
@ -860,8 +857,7 @@ meta_background_get_texture (MetaBackground *self,
*/ */
cogl_object_unref (monitor->texture); cogl_object_unref (monitor->texture);
monitor->texture = NULL; monitor->texture = NULL;
cogl_object_unref (monitor->fbo); g_clear_object (&monitor->fbo);
monitor->fbo = NULL;
g_error_free (catch_error); g_error_free (catch_error);
return NULL; return NULL;

2
src/compositor/meta-compositor-native.c
View File

@ -98,7 +98,7 @@ maybe_assign_primary_plane (MetaCompositor *compositor)
return; return;
framebuffer = clutter_stage_view_get_framebuffer (CLUTTER_STAGE_VIEW (view)); framebuffer = clutter_stage_view_get_framebuffer (CLUTTER_STAGE_VIEW (view));
if (!cogl_is_onscreen (framebuffer)) if (!COGL_IS_ONSCREEN (framebuffer))
return; return;
surface_actor = meta_window_actor_get_surface (window_actor); surface_actor = meta_window_actor_get_surface (window_actor);

4
src/compositor/meta-shaped-texture.c
View File

@ -1402,7 +1402,7 @@ get_image_via_offscreen (MetaShapedTexture *stex,
if (!cogl_framebuffer_allocate (fb, &error)) if (!cogl_framebuffer_allocate (fb, &error))
{ {
g_error_free (error); g_error_free (error);
cogl_object_unref (fb); g_object_unref (fb);
return FALSE; return FALSE;
} }
@ -1445,7 +1445,7 @@ get_image_via_offscreen (MetaShapedTexture *stex,
clip->width, clip->height, clip->width, clip->height,
CLUTTER_CAIRO_FORMAT_ARGB32, CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_data (surface)); cairo_image_surface_get_data (surface));
cogl_object_unref (fb); g_object_unref (fb);
cairo_surface_mark_dirty (surface); cairo_surface_mark_dirty (surface);

6
src/compositor/meta-texture-tower.c
View File

@ -132,11 +132,7 @@ meta_texture_tower_set_base_texture (MetaTextureTower *tower,
tower->textures[i] = NULL; tower->textures[i] = NULL;
} }
if (tower->fbos[i] != NULL) g_clear_object (&tower->fbos[i]);
{
cogl_object_unref (tower->fbos[i]);
tower->fbos[i] = NULL;
}
} }
cogl_object_unref (tower->textures[0]); cogl_object_unref (tower->textures[0]);

4
src/compositor/meta-window-actor.c
View File

@ -1486,7 +1486,7 @@ meta_window_actor_get_image (MetaWindowActor *self,
{ {
g_warning ("Failed to allocate framebuffer for screenshot: %s", g_warning ("Failed to allocate framebuffer for screenshot: %s",
error->message); error->message);
cogl_object_unref (framebuffer); g_object_unref (framebuffer);
cogl_object_unref (texture); cogl_object_unref (texture);
goto out; goto out;
} }
@ -1533,7 +1533,7 @@ meta_window_actor_get_image (MetaWindowActor *self,
CLUTTER_CAIRO_FORMAT_ARGB32, CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_data (surface)); cairo_image_surface_get_data (surface));
cogl_object_unref (framebuffer); g_object_unref (framebuffer);
cairo_surface_mark_dirty (surface); cairo_surface_mark_dirty (surface);

2
src/tests/clutter/interactive/test-cogl-offscreen.c
View File

@ -146,7 +146,7 @@ test_coglbox_dispose (GObject *object)
priv = TEST_COGLBOX_GET_PRIVATE (object); priv = TEST_COGLBOX_GET_PRIVATE (object);
cogl_object_unref (priv->texture_id); cogl_object_unref (priv->texture_id);
cogl_object_unref (priv->framebuffer); g_object_unref (priv->framebuffer);
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object); G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
} }