#include "config.h"
#include "gdkinternals.h"
+#include "gdkframeclockprivate.h"
#include "gdkframeclockidle.h"
#include "gdk.h"
struct _GdkFrameClockIdlePrivate
{
- GdkFrameHistory *history;
GTimer *timer;
/* timer_base is used to avoid ever going backward */
- guint64 timer_base;
- guint64 frame_time;
- guint64 min_next_frame_time;
+ gint64 timer_base;
+ gint64 frame_time;
+ gint64 min_next_frame_time;
gint64 sleep_serial;
guint flush_idle_id;
static gboolean gdk_frame_clock_flush_idle (void *data);
static gboolean gdk_frame_clock_paint_idle (void *data);
-static void gdk_frame_clock_idle_finalize (GObject *object);
-static void gdk_frame_clock_idle_interface_init (GdkFrameClockInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (GdkFrameClockIdle, gdk_frame_clock_idle, G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE (GDK_TYPE_FRAME_CLOCK,
- gdk_frame_clock_idle_interface_init))
+G_DEFINE_TYPE (GdkFrameClockIdle, gdk_frame_clock_idle, GDK_TYPE_FRAME_CLOCK)
static gint64 sleep_serial;
static gint64 sleep_source_prepare_time;
static GSource *sleep_source;
-gboolean
+static gboolean
sleep_source_prepare (GSource *source,
gint *timeout)
{
return FALSE;
}
-gboolean
+static gboolean
sleep_source_check (GSource *source)
{
if (g_source_get_time (source) != sleep_source_prepare_time)
return FALSE;
}
-gboolean
+static gboolean
sleep_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
return sleep_serial;
}
-static void
-gdk_frame_clock_idle_class_init (GdkFrameClockIdleClass *klass)
-{
- GObjectClass *gobject_class = (GObjectClass*) klass;
-
- gobject_class->finalize = gdk_frame_clock_idle_finalize;
-
- g_type_class_add_private (klass, sizeof (GdkFrameClockIdlePrivate));
-}
-
static void
gdk_frame_clock_idle_init (GdkFrameClockIdle *frame_clock_idle)
{
GdkFrameClockIdlePrivate);
priv = frame_clock_idle->priv;
- priv->history = gdk_frame_history_new ();
- priv->timer = g_timer_new ();
priv->freeze_count = 0;
}
static void
-gdk_frame_clock_idle_finalize (GObject *object)
+gdk_frame_clock_idle_dispose (GObject *object)
{
GdkFrameClockIdlePrivate *priv = GDK_FRAME_CLOCK_IDLE (object)->priv;
- g_timer_destroy (priv->timer);
+ if (priv->flush_idle_id != 0)
+ {
+ g_source_remove (priv->flush_idle_id);
+ priv->flush_idle_id = 0;
+ }
+
+ if (priv->paint_idle_id != 0)
+ {
+ g_source_remove (priv->paint_idle_id);
+ priv->paint_idle_id = 0;
+ }
- G_OBJECT_CLASS (gdk_frame_clock_idle_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_frame_clock_idle_parent_class)->dispose (object);
}
-static guint64
+static gint64
compute_frame_time (GdkFrameClockIdle *idle)
{
GdkFrameClockIdlePrivate *priv = idle->priv;
- guint64 computed_frame_time;
- guint64 elapsed;
+ gint64 computed_frame_time;
+ gint64 elapsed;
elapsed = g_get_monotonic_time () + priv->timer_base;
if (elapsed < priv->frame_time)
return computed_frame_time;
}
-static guint64
+static gint64
gdk_frame_clock_idle_get_frame_time (GdkFrameClock *clock)
{
GdkFrameClockIdlePrivate *priv = GDK_FRAME_CLOCK_IDLE (clock)->priv;
- guint64 computed_frame_time;
+ gint64 computed_frame_time;
/* can't change frame time during a paint */
if (priv->phase != GDK_FRAME_CLOCK_PHASE_NONE &&
{
GdkFrameClockIdlePrivate *priv = clock_idle->priv;
- if (priv->freeze_count == 0)
+ if (priv->freeze_count == 0 && priv->requested != 0)
{
guint min_interval = 0;
if (priv->min_next_frame_time != 0)
{
- guint64 now = compute_frame_time (clock_idle);
- guint64 min_interval_us = MAX (priv->min_next_frame_time, now) - now;
+ gint64 now = compute_frame_time (clock_idle);
+ gint64 min_interval_us = MAX (priv->min_next_frame_time, now) - now;
min_interval = (min_interval_us + 500) / 1000;
}
gdk_frame_clock_paint_idle,
g_object_ref (clock_idle),
(GDestroyNotify) g_object_unref);
-
- gdk_frame_clock_frame_requested (GDK_FRAME_CLOCK (clock_idle));
}
}
}
+static gint64
+compute_min_next_frame_time (GdkFrameClockIdle *clock_idle,
+ gint64 last_frame_time)
+{
+ gint64 presentation_time;
+ gint64 refresh_interval;
+
+ gdk_frame_clock_get_refresh_info (GDK_FRAME_CLOCK (clock_idle),
+ last_frame_time,
+ &refresh_interval, &presentation_time);
+
+ if (presentation_time == 0)
+ return last_frame_time + refresh_interval;
+ else
+ return presentation_time + refresh_interval / 2;
+}
+
static gboolean
gdk_frame_clock_flush_idle (void *data)
{
GdkFrameClockIdlePrivate *priv = clock_idle->priv;
gboolean skip_to_resume_events;
GdkFrameTimings *timings = NULL;
- gint64 frame_counter = 0;
priv->paint_idle_id = 0;
priv->in_paint_idle = TRUE;
+ priv->min_next_frame_time = 0;
skip_to_resume_events =
(priv->requested & ~(GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS | GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS)) == 0;
if (priv->phase > GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT)
{
- frame_counter = gdk_frame_history_get_frame_counter (priv->history);
- timings = gdk_frame_history_get_timings (priv->history, frame_counter);
+ timings = gdk_frame_clock_get_current_timings (clock);
}
if (!skip_to_resume_events)
{
priv->frame_time = compute_frame_time (clock_idle);
- gdk_frame_history_begin_frame (priv->history);
- frame_counter = gdk_frame_history_get_frame_counter (priv->history);
- timings = gdk_frame_history_get_timings (priv->history, frame_counter);
-
- gdk_frame_timings_set_frame_time (timings, priv->frame_time);
+ _gdk_frame_clock_begin_frame (clock);
+ timings = gdk_frame_clock_get_current_timings (clock);
- gdk_frame_timings_set_slept_before (timings,
- priv->sleep_serial != get_sleep_serial ());
+ timings->frame_time = priv->frame_time;
+ timings->slept_before = priv->sleep_serial != get_sleep_serial ();
priv->phase = GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT;
{
if (priv->phase != GDK_FRAME_CLOCK_PHASE_LAYOUT &&
(priv->requested & GDK_FRAME_CLOCK_PHASE_LAYOUT))
- _gdk_frame_timings_set_layout_start_time (timings, g_get_monotonic_time ());
+ timings->layout_start_time = g_get_monotonic_time ();
}
#endif /* G_ENABLE_DEBUG */
{
if (priv->phase != GDK_FRAME_CLOCK_PHASE_PAINT &&
(priv->requested & GDK_FRAME_CLOCK_PHASE_PAINT))
- _gdk_frame_timings_set_paint_start_time (timings, g_get_monotonic_time ());
+ timings->paint_start_time = g_get_monotonic_time ();
}
#endif /* G_ENABLE_DEBUG */
#ifdef G_ENABLE_DEBUG
if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0)
- _gdk_frame_timings_set_frame_end_time (timings, g_get_monotonic_time ());
+ timings->frame_end_time = g_get_monotonic_time ();
#endif /* G_ENABLE_DEBUG */
}
case GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS:
#ifdef G_ENABLE_DEBUG
if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0)
{
- if (gdk_frame_timings_get_complete (timings))
- _gdk_frame_history_debug_print (priv->history, timings);
+ if (timings->complete)
+ _gdk_frame_clock_debug_print_timings (clock, timings);
}
#endif /* G_ENABLE_DEBUG */
priv->in_paint_idle = FALSE;
- if (priv->freeze_count == 0 && priv->requested != 0)
+ /* If there is throttling in the backend layer, then we'll do another
+ * update as soon as the backend unthrottles (if there is work to do),
+ * otherwise we need to figure when the next frame should be.
+ */
+ if (priv->freeze_count == 0)
{
- /* We need to start over again immediately - this implies that there is no
- * throttling at the backend layer, so we need to back-off ourselves.
- */
- gdk_flush ();
- priv->min_next_frame_time = priv->frame_time + FRAME_INTERVAL;
+ priv->min_next_frame_time = compute_min_next_frame_time (clock_idle,
+ priv->frame_time);
maybe_start_idle (clock_idle);
}
- else
- {
- priv->min_next_frame_time = 0;
- }
if (priv->freeze_count == 0)
priv->sleep_serial = get_sleep_serial ();
maybe_start_idle (clock_idle);
}
-static GdkFrameClockPhase
-gdk_frame_clock_idle_get_requested (GdkFrameClock *clock)
-{
- GdkFrameClockIdlePrivate *priv = GDK_FRAME_CLOCK_IDLE (clock)->priv;
-
- return priv->requested;
-}
-
static void
gdk_frame_clock_idle_freeze (GdkFrameClock *clock)
{
}
}
-static GdkFrameHistory *
-gdk_frame_clock_idle_get_history (GdkFrameClock *clock)
+static void
+gdk_frame_clock_idle_class_init (GdkFrameClockIdleClass *klass)
{
- GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock);
- GdkFrameClockIdlePrivate *priv = clock_idle->priv;
+ GObjectClass *gobject_class = (GObjectClass*) klass;
+ GdkFrameClockClass *frame_clock_class = (GdkFrameClockClass *)klass;
- return priv->history;
-}
+ gobject_class->dispose = gdk_frame_clock_idle_dispose;
-static void
-gdk_frame_clock_idle_interface_init (GdkFrameClockInterface *iface)
-{
- iface->get_frame_time = gdk_frame_clock_idle_get_frame_time;
- iface->request_phase = gdk_frame_clock_idle_request_phase;
- iface->get_requested = gdk_frame_clock_idle_get_requested;
- iface->freeze = gdk_frame_clock_idle_freeze;
- iface->thaw = gdk_frame_clock_idle_thaw;
- iface->get_history = gdk_frame_clock_idle_get_history;
+ frame_clock_class->get_frame_time = gdk_frame_clock_idle_get_frame_time;
+ frame_clock_class->request_phase = gdk_frame_clock_idle_request_phase;
+ frame_clock_class->freeze = gdk_frame_clock_idle_freeze;
+ frame_clock_class->thaw = gdk_frame_clock_idle_thaw;
+
+ g_type_class_add_private (klass, sizeof (GdkFrameClockIdlePrivate));
}
GdkFrameClock *
projects / ~andy / gtk / blobdiff