static void on_window_draw (GtkWidget *widget, cairo_t *cr) { GdkRectangle allocation; double cx, cy, r; cairo_set_source_rgb (cr, 1., 1., 1.); cairo_paint (cr); cairo_set_source_rgb (cr, 0., 0., 0.); gtk_widget_get_allocation (widget, &allocation); cx = allocation.width / 2.; cy = allocation.height / 2.; r = MIN (allocation.width, allocation.height) / 2.; cairo_arc (cr, cx, cy, r, 0, 2 * M_PI); cairo_stroke (cr); if (displayed_frame) { cairo_move_to (cr, cx, cy); cairo_line_to (cr, cx + r * cos(displayed_frame->angle - M_PI / 2), cy + r * sin(displayed_frame->angle - M_PI / 2)); cairo_stroke (cr); if (displayed_frame->frame_counter == 0) { GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (window); displayed_frame->frame_counter = gdk_frame_clock_get_frame_counter (frame_clock); } } }
static gboolean gtk_gears_tick (GtkWidget *widget, GdkFrameClock *frame_clock, gpointer user_data) { GtkGears *gears = GTK_GEARS (widget); GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears); GdkFrameTimings *timings, *previous_timings; gint64 previous_frame_time = 0; gint64 frame_time; gint64 history_start, history_len; gint64 frame; char *s; frame = gdk_frame_clock_get_frame_counter (frame_clock); frame_time = gdk_frame_clock_get_frame_time (frame_clock); if (priv->first_frame_time == 0) { /* No need for changes on first frame */ priv->first_frame_time = frame_time; if (priv->fps_label) gtk_label_set_label (priv->fps_label, "FPS: ---"); return G_SOURCE_CONTINUE; } /* glxgears advances 70 degrees per second, so do the same */ priv->angle = fmod ((frame_time - priv->first_frame_time) / (double)G_USEC_PER_SEC * 70.0, 360.0); gtk_widget_queue_draw (widget); history_start = gdk_frame_clock_get_history_start (frame_clock); if (priv->fps_label && frame % 60 == 0) { history_len = frame - history_start; if (history_len > 0) { previous_timings = gdk_frame_clock_get_timings (frame_clock, frame - history_len); previous_frame_time = gdk_frame_timings_get_frame_time (previous_timings); s = g_strdup_printf ("FPS: %-4.1f", (G_USEC_PER_SEC * history_len) / (double)(frame_time - previous_frame_time)); gtk_label_set_label (priv->fps_label, s); g_free (s); } } timings = gdk_frame_clock_get_current_timings (frame_clock); previous_timings = gdk_frame_clock_get_timings (frame_clock, gdk_frame_timings_get_frame_counter (timings) - 1); if (previous_timings != NULL) previous_frame_time = gdk_frame_timings_get_frame_time (previous_timings); return G_SOURCE_CONTINUE; }
/** * gdk_frame_clock_get_refresh_info: * @frame_clock: a #GdkFrameClock * @base_time: base time for determining a presentaton time * @refresh_interval_return: a location to store the determined refresh * interval, or %NULL. A default refresh interval of 1/60th of * a second will be stored if no history is present. * @presentation_time_return: a location to store the next * candidate presentation time after the given base time. * 0 will be will be stored if no history is present. * * Using the frame history stored in the frame clock, finds the last * known presentation time and refresh interval, and assuming that * presentation times are separated by the refresh interval, * predicts a presentation time that is a multiple of the refresh * interval after the last presentation time, and later than @base_time. * * Since: 3.8 */ void gdk_frame_clock_get_refresh_info (GdkFrameClock *frame_clock, gint64 base_time, gint64 *refresh_interval_return, gint64 *presentation_time_return) { gint64 frame_counter; g_return_if_fail (GDK_IS_FRAME_CLOCK (frame_clock)); frame_counter = gdk_frame_clock_get_frame_counter (frame_clock); if (presentation_time_return) *presentation_time_return = 0; if (refresh_interval_return) *refresh_interval_return = DEFAULT_REFRESH_INTERVAL; while (TRUE) { GdkFrameTimings *timings = gdk_frame_clock_get_timings (frame_clock, frame_counter); gint64 presentation_time; gint64 refresh_interval; if (timings == NULL) return; refresh_interval = timings->refresh_interval; presentation_time = timings->presentation_time; if (presentation_time != 0) { if (presentation_time > base_time - MAX_HISTORY_AGE && presentation_time_return) { if (refresh_interval == 0) refresh_interval = DEFAULT_REFRESH_INTERVAL; if (refresh_interval_return) *refresh_interval_return = refresh_interval; while (presentation_time < base_time) presentation_time += refresh_interval; if (presentation_time_return) *presentation_time_return = presentation_time; } return; } frame_counter--; } }
static void handle_frame_stats (GdkFrameClock *frame_clock) { static int num_stats = 0; static double last_print_time = 0; static int frames_since_last_print = 0; static gint64 frame_counter; static gint64 last_handled_frame = -1; static Variable latency = VARIABLE_INIT; double current_time; current_time = g_get_monotonic_time (); if (current_time >= last_print_time + 1000000 * statistics_time) { if (frames_since_last_print) { if (num_stats == 0 && machine_readable) { g_print ("# load_factor frame_rate latency\n"); } num_stats++; if (machine_readable) g_print ("%g ", load_factor); print_double ("Frame rate ", frames_since_last_print / ((current_time - last_print_time) / 1000000.)); print_variable ("Latency", &latency); g_print ("\n"); } last_print_time = current_time; frames_since_last_print = 0; variable_reset (&latency); if (num_stats == max_stats) gtk_main_quit (); } frames_since_last_print++; for (frame_counter = last_handled_frame; frame_counter < gdk_frame_clock_get_frame_counter (frame_clock); frame_counter++) { GdkFrameTimings *timings = gdk_frame_clock_get_timings (frame_clock, frame_counter); GdkFrameTimings *previous_timings = gdk_frame_clock_get_timings (frame_clock, frame_counter - 1); if (!timings || gdk_frame_timings_get_complete (timings)) last_handled_frame = frame_counter; if (timings && gdk_frame_timings_get_complete (timings) && previous_timings && gdk_frame_timings_get_presentation_time (timings) != 0 && gdk_frame_timings_get_presentation_time (previous_timings) != 0) { double display_time = (gdk_frame_timings_get_presentation_time (timings) - gdk_frame_timings_get_presentation_time (previous_timings)) / 1000.; double frame_latency = (gdk_frame_timings_get_presentation_time (previous_timings) - gdk_frame_timings_get_frame_time (previous_timings)) / 1000. + display_time / 2; variable_add_weighted (&latency, frame_latency, display_time); } } }