mutter/clutter/gdk/clutter-master-clock-gdk.c

/*
 * 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;
}