/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com>
*
* Copyright (C) 2015 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* SECTION:clutter-master-clock-gdk
* @short_description: The GDK master clock for all animations
*
* The #ClutterMasterClockDefault class is the GdkFrameClock based implementation
* of #ClutterMasterClock.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gdk/gdk.h>
#include "clutter-master-clock.h"
#include "clutter-master-clock-gdk.h"
#include "clutter-stage-gdk.h"
#include "clutter-debug.h"
#include "clutter-private.h"
#include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h"
#ifdef CLUTTER_ENABLE_DEBUG
#define clutter_warn_if_over_budget(master_clock,start_time,section) G_STMT_START { \
gint64 __delta = g_get_monotonic_time () - start_time; \
gint64 __budget = master_clock->remaining_budget; \
if (__budget > 0 && __delta >= __budget) { \
_clutter_diagnostic_message ("%s took %" G_GINT64_FORMAT " microseconds " \
"more than the remaining budget of %" G_GINT64_FORMAT \
" microseconds", \
section, __delta - __budget, __budget); \
} } G_STMT_END
#else
#define clutter_warn_if_over_budget(master_clock,start_time,section)
#endif
typedef struct _ClutterClockSource ClutterClockSource;
struct _ClutterMasterClockGdk
{
GObject parent_instance;
/* the list of timelines handled by the clock */
GSList *timelines;
/* mapping between ClutterStages and GdkFrameClocks.
*
* @stage_to_clock: a direct mapping because each stage has at most one clock
* @clock_to_stage: each clock can have more than one stage
*/
GHashTable *stage_to_clock;
GHashTable *clock_to_stage;
/* the current state of the clock, in usecs */
gint64 cur_tick;
/* the previous state of the clock, in usecs, used to compute the delta */
gint64 prev_tick;
#ifdef CLUTTER_ENABLE_DEBUG
gint64 frame_budget;
gint64 remaining_budget;
#endif
};
struct _ClutterClockSource
{
GSource source;
ClutterMasterClock *master_clock;
};
static void clutter_master_clock_iface_init (ClutterMasterClockIface *iface);
G_DEFINE_TYPE_WITH_CODE (ClutterMasterClockGdk,
clutter_master_clock_gdk,
G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_MASTER_CLOCK,
clutter_master_clock_iface_init));
static void
master_clock_schedule_forced_stages_updates (ClutterMasterClockGdk *master_clock)
{
GHashTableIter iter;
gpointer stage, frame_clock;
g_hash_table_iter_init (&iter, master_clock->stage_to_clock);
while (g_hash_table_iter_next (&iter, &stage, &frame_clock))
gdk_frame_clock_request_phase (GDK_FRAME_CLOCK (frame_clock),
GDK_FRAME_CLOCK_PHASE_PAINT);
}
static void
master_clock_sync_frame_clock_update (ClutterMasterClockGdk *master_clock)
{
gboolean updating = master_clock->timelines != NULL;
gpointer frame_clock, stage_list;
GHashTableIter iter;
g_hash_table_iter_init (&iter, master_clock->clock_to_stage);
while (g_hash_table_iter_next (&iter, &frame_clock, &stage_list))
{
gboolean clock_updating =
GPOINTER_TO_UINT (g_object_get_data (frame_clock,
"clutter-master-clock-updating"));
if (clock_updating != updating)
{
if (updating)
gdk_frame_clock_begin_updating (GDK_FRAME_CLOCK (frame_clock));
else
gdk_frame_clock_end_updating (GDK_FRAME_CLOCK (frame_clock));
g_object_set_data (frame_clock,
"clutter-master-clock-updating",
GUINT_TO_POINTER (updating));
}
}
}
static void
master_clock_schedule_stage_update (ClutterMasterClockGdk *master_clock,
ClutterStage *stage,
GdkFrameClock *frame_clock)
{
/* Clear the old update time */
_clutter_stage_clear_update_time (stage);
/* And if there is still work to be done, schedule a new one */
if (_clutter_stage_has_queued_events (stage) ||
_clutter_stage_needs_update (stage))
_clutter_stage_schedule_update (stage);
/* We can avoid to schedule a new frame if the stage doesn't need
* anymore redrawing. But in the case we still have timelines alive,
* we have no choice, we need to advance the timelines for the next
* frame. */
if (master_clock->timelines != NULL)
gdk_frame_clock_request_phase (frame_clock, GDK_FRAME_CLOCK_PHASE_PAINT);
}
static void
master_clock_process_stage_events (ClutterMasterClockGdk *master_clock,
ClutterStage *stage)
{
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
/* Process queued events */
_clutter_stage_process_queued_events (stage);
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Event processing");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
}
/*
* master_clock_advance_timelines:
* @master_clock: a #ClutterMasterClock
*
* Advances all the timelines held by the master clock. This function
* should be called before calling _clutter_stage_do_update() to
* make sure that all the timelines are advanced and the scene is updated.
*/
static void
master_clock_advance_timelines (ClutterMasterClockGdk *master_clock)
{
GSList *timelines, *l;
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
/* we protect ourselves from timelines being removed during
* the advancement by other timelines by copying the list of
* timelines, taking a reference on them, iterating over the
* copied list and then releasing the reference.
*
* we cannot simply take a reference on the timelines and still
* use the list held by the master clock because the do_tick()
* might result in the creation of a new timeline, which gets
* added at the end of the list with no reference increase and
* thus gets disposed at the end of the iteration.
*
* this implies that a newly added timeline will not be advanced
* by this clock iteration, which is perfectly fine since we're
* in its first cycle.
*
* we also cannot steal the master clock timelines list because
* a timeline might be removed as the direct result of do_tick()
* and remove_timeline() would not find the timeline, failing
* and leaving a dangling pointer behind.
*/
timelines = g_slist_copy (master_clock->timelines);
g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
for (l = timelines; l != NULL; l = l->next)
_clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
g_slist_free (timelines);
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Animations");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
}
static gboolean
master_clock_update_stage (ClutterMasterClockGdk *master_clock,
ClutterStage *stage)
{
gboolean stage_updated = FALSE;
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
_clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_PRE_PAINT);
/* Update any stage that needs redraw/relayout after the clock
* is advanced.
*/
stage_updated |= _clutter_stage_do_update (stage);
_clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_POST_PAINT);
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Updating the stage");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
return stage_updated;
}
static void
clutter_master_clock_gdk_update (GdkFrameClock *frame_clock,
ClutterMasterClockGdk *master_clock)
{
GList *stages, *l;
_clutter_threads_acquire_lock ();
/* Get the time to use for this frame */
master_clock->cur_tick = gdk_frame_clock_get_frame_time (frame_clock);
#ifdef CLUTTER_ENABLE_DEBUG
/* Update the remaining budget */
master_clock->remaining_budget = master_clock->frame_budget;
#endif
stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock);
CLUTTER_NOTE (SCHEDULER, "Updating %d stages tied to frame clock %p",
g_list_length (stages), frame_clock);
for (l = stages; l != NULL; l = l->next)
{
ClutterStage *stage = l->data;
CLUTTER_NOTE (SCHEDULER, "Master clock (stage:%p, clock:%p) [tick]", stage, frame_clock);
/* Each frame is split into three separate phases: */
/* 1. process all the events; goes through the stage's event queue
* and processes each event according to its type, then emits the
* various signals that are associated with the event
*/
master_clock_process_stage_events (master_clock, stage);
/* 2. advance the timelines */
master_clock_advance_timelines (master_clock);
/* 3. relayout and redraw the stage; the stage might have been
* destroyed in 1. when processing events, check whether it's
* still alive.
*/
if (g_hash_table_lookup (master_clock->stage_to_clock, stage) != NULL)
{
master_clock_update_stage (master_clock, stage);
master_clock_schedule_stage_update (master_clock, stage, frame_clock);
}
}
master_clock->prev_tick = master_clock->cur_tick;
_clutter_threads_release_lock ();
}
static void
clutter_master_clock_gdk_remove_stage_clock (ClutterMasterClockGdk *master_clock,
ClutterStage *stage)
{
gpointer frame_clock = g_hash_table_lookup (master_clock->stage_to_clock, stage);
GList *stages;
if (frame_clock == NULL)
return;
CLUTTER_NOTE (SCHEDULER, "Removing stage %p with clock %p", stage, frame_clock);
g_hash_table_remove (master_clock->stage_to_clock, stage);
stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock);
if (stages != NULL)
{
if (stages->next == NULL)
{
/* Deleting the last stage linked to a given clock. We can stop
listening to that clock and also tell the clock we're finish
updating it. */
if (GPOINTER_TO_UINT (g_object_get_data (frame_clock,
"clutter-master-clock-updating")))
{
gdk_frame_clock_end_updating (GDK_FRAME_CLOCK (frame_clock));
g_object_set_data (frame_clock, "clutter-master-clock-updating", NULL);
}
g_signal_handlers_disconnect_by_func (frame_clock,
clutter_master_clock_gdk_update,
master_clock);
g_hash_table_remove (master_clock->clock_to_stage, frame_clock);
g_list_free (stages);
}
else
{
stages = g_list_remove (stages, stage);
g_hash_table_replace (master_clock->clock_to_stage,
g_object_ref (frame_clock),
stages);
}
}
}
static void
clutter_master_clock_gdk_add_stage_clock (ClutterMasterClockGdk *master_clock,
ClutterStage *stage,
GdkFrameClock *frame_clock)
{
GList *stages;
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
CLUTTER_NOTE (SCHEDULER, "Adding stage %p with clock %p", stage, frame_clock);
g_hash_table_insert (master_clock->stage_to_clock, stage, g_object_ref (frame_clock));
stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock);
if (stages == NULL)
{
g_hash_table_insert (master_clock->clock_to_stage, g_object_ref (frame_clock),
g_list_append (NULL, stage));
g_signal_connect (frame_clock, "paint",
G_CALLBACK (clutter_master_clock_gdk_update),
master_clock);
}
else
stages = g_list_append (stages, stage);
if (master_clock->timelines != NULL)
{
_clutter_master_clock_start_running ((ClutterMasterClock *) master_clock);
/* We only need to synchronize the frame clock state if we have
timelines running. */
master_clock_sync_frame_clock_update (master_clock);
}
}
static void
clutter_master_clock_gdk_listen_to_stage (ClutterMasterClockGdk *master_clock,
ClutterStage *stage)
{
ClutterStageWindow *stage_window;
ClutterStageGdk *stage_window_gdk;
GdkFrameClock *frame_clock;
stage_window = _clutter_stage_get_window (stage);
if (stage_window == NULL)
{
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
return;
}
stage_window_gdk = CLUTTER_STAGE_GDK (stage_window);
if (stage_window_gdk->window == NULL)
{
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
return;
}
frame_clock = gdk_window_get_frame_clock (stage_window_gdk->window);
if (frame_clock == NULL)
{
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
return;
}
clutter_master_clock_gdk_add_stage_clock (master_clock, stage, frame_clock);
}
static void
clutter_master_clock_gdk_stage_visibility (ClutterStage *stage,
GParamSpec *spec,
ClutterMasterClockGdk *master_clock)
{
ClutterActor *actor = CLUTTER_ACTOR (stage);
if (clutter_actor_is_mapped (actor))
clutter_master_clock_gdk_listen_to_stage (master_clock, stage);
else
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
}
static void
clutter_master_clock_gdk_stage_added (ClutterStageManager *manager,
ClutterStage *stage,
ClutterMasterClockGdk *master_clock)
{
g_signal_connect (stage, "notify::mapped",
G_CALLBACK (clutter_master_clock_gdk_stage_visibility),
master_clock);
clutter_master_clock_gdk_stage_visibility (stage, NULL, master_clock);
}
static void
clutter_master_clock_gdk_stage_removed (ClutterStageManager *manager,
ClutterStage *stage,
ClutterMasterClockGdk *master_clock)
{
clutter_master_clock_gdk_remove_stage_clock (master_clock, stage);
g_signal_handlers_disconnect_by_func (stage,
clutter_master_clock_gdk_stage_visibility,
master_clock);
}
static void
clutter_master_clock_gdk_dispose (GObject *gobject)
{
ClutterStageManager *manager = clutter_stage_manager_get_default ();
g_signal_handlers_disconnect_by_func (manager,
clutter_master_clock_gdk_stage_added,
gobject);
g_signal_handlers_disconnect_by_func (manager,
clutter_master_clock_gdk_stage_removed,
gobject);
G_OBJECT_CLASS (clutter_master_clock_gdk_parent_class)->dispose (gobject);
}
static void
clutter_master_clock_gdk_finalize (GObject *gobject)
{
ClutterMasterClockGdk *master_clock = CLUTTER_MASTER_CLOCK_GDK (gobject);
g_hash_table_unref (master_clock->clock_to_stage);
g_hash_table_unref (master_clock->stage_to_clock);
g_slist_free (master_clock->timelines);
G_OBJECT_CLASS (clutter_master_clock_gdk_parent_class)->finalize (gobject);
}
static void
clutter_master_clock_gdk_class_init (ClutterMasterClockGdkClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = clutter_master_clock_gdk_dispose;
gobject_class->finalize = clutter_master_clock_gdk_finalize;
}
static void
clutter_master_clock_gdk_init (ClutterMasterClockGdk *self)
{
ClutterStageManager *manager;
const GSList *stages, *l;
#ifdef CLUTTER_ENABLE_DEBUG
self->frame_budget = G_USEC_PER_SEC / 60;
#endif
self->clock_to_stage = g_hash_table_new_full (g_direct_hash, g_direct_equal,
g_object_unref, NULL);
self->stage_to_clock = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, g_object_unref);
manager = clutter_stage_manager_get_default ();
g_signal_connect (manager, "stage-added",
G_CALLBACK (clutter_master_clock_gdk_stage_added), self);
g_signal_connect (manager, "stage-removed",
G_CALLBACK (clutter_master_clock_gdk_stage_removed), self);
stages = clutter_stage_manager_peek_stages (manager);
for (l = stages; l; l = l->next)
clutter_master_clock_gdk_stage_added (manager, l->data, self);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_CONTINUOUS_REDRAW))
g_warning ("Continuous redraw is not supported with the GDK backend.");
}
static void
clutter_master_clock_gdk_add_timeline (ClutterMasterClock *clock,
ClutterTimeline *timeline)
{
ClutterMasterClockGdk *master_clock = (ClutterMasterClockGdk *) clock;
gboolean is_first;
if (g_slist_find (master_clock->timelines, timeline))
return;
is_first = master_clock->timelines == NULL;
master_clock->timelines = g_slist_prepend (master_clock->timelines,
timeline);
if (is_first)
{
_clutter_master_clock_start_running (clock);
/* Sync frame clock update state if needed. */
master_clock_sync_frame_clock_update (master_clock);
}
}
static void
clutter_master_clock_gdk_remove_timeline (ClutterMasterClock *clock,
ClutterTimeline *timeline)
{
ClutterMasterClockGdk *master_clock = (ClutterMasterClockGdk *) clock;
master_clock->timelines = g_slist_remove (master_clock->timelines,
timeline);
/* Sync frame clock update state if we have no more timelines running. */
if (master_clock->timelines == NULL)
master_clock_sync_frame_clock_update (master_clock);
}
static void
clutter_master_clock_gdk_start_running (ClutterMasterClock *clock)
{
master_clock_schedule_forced_stages_updates ((ClutterMasterClockGdk *) clock);
}
static void
clutter_master_clock_gdk_ensure_next_iteration (ClutterMasterClock *clock)
{
master_clock_schedule_forced_stages_updates ((ClutterMasterClockGdk *) clock);
}
static void
clutter_master_clock_gdk_set_paused (ClutterMasterClock *clock,
gboolean paused)
{
/* GdkFrameClock runs the show here. We do not decide whether the
clock is paused or not. */
}
static void
clutter_master_clock_iface_init (ClutterMasterClockIface *iface)
{
iface->add_timeline = clutter_master_clock_gdk_add_timeline;
iface->remove_timeline = clutter_master_clock_gdk_remove_timeline;
iface->start_running = clutter_master_clock_gdk_start_running;
iface->ensure_next_iteration = clutter_master_clock_gdk_ensure_next_iteration;
iface->set_paused = clutter_master_clock_gdk_set_paused;
}