AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
332a7c9c6e
gtk2/tests/video-timer.c

400 lines
11 KiB
C
Raw Normal View History

video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
#include <math.h>
#include <gtk/gtk.h>
#include "variable.h"
typedef struct {
gdouble angle;
gint64 stream_time;
gint64 clock_time;
gint64 frame_counter;
} FrameData;
static FrameData *displayed_frame;
static GtkWidget *window;
static GList *past_frames;
static Variable latency_error = VARIABLE_INIT;
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
static Variable time_factor_stats = VARIABLE_INIT;
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
static int dropped_frames = 0;
static int n_frames = 0;
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
static gboolean pll;
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
static int fps = 24;
/* Thread-safe frame queue */
#define MAX_QUEUE_LENGTH 5
static GQueue *frame_queue;
static GMutex frame_mutex;
static GCond frame_cond;
static void
queue_frame (FrameData *frame_data)
{
g_mutex_lock (&frame_mutex);
while (frame_queue->length == MAX_QUEUE_LENGTH)
g_cond_wait (&frame_cond, &frame_mutex);
g_queue_push_tail (frame_queue, frame_data);
g_mutex_unlock (&frame_mutex);
}
static FrameData *
unqueue_frame (void)
{
FrameData *frame_data;
g_mutex_lock (&frame_mutex);
if (frame_queue->length > 0)
{
frame_data = g_queue_pop_head (frame_queue);
g_cond_signal (&frame_cond);
}
else
{
frame_data = NULL;
}
g_mutex_unlock (&frame_mutex);
return frame_data;
}
static FrameData *
peek_pending_frame (void)
{
FrameData *frame_data;
g_mutex_lock (&frame_mutex);
if (frame_queue->head)
frame_data = frame_queue->head->data;
else
frame_data = NULL;
g_mutex_unlock (&frame_mutex);
return frame_data;
}
static FrameData *
peek_next_frame (void)
{
FrameData *frame_data;
g_mutex_lock (&frame_mutex);
if (frame_queue->head && frame_queue->head->next)
frame_data = frame_queue->head->next->data;
else
frame_data = NULL;
g_mutex_unlock (&frame_mutex);
return frame_data;
}
/* Frame producer thread */
static gpointer
create_frames_thread (gpointer data)
{
int frame_count = 0;
while (TRUE)
{
FrameData *frame_data = g_slice_new0 (FrameData);
frame_data->angle = 2 * M_PI * (frame_count % fps) / (double)fps;
frame_data->stream_time = (G_GINT64_CONSTANT (1000000) * frame_count) / fps;
queue_frame (frame_data);
frame_count++;
}
return NULL;
}
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
/* Clock management:
*
* The logic here, which is activated by the --pll argument
* demonstrates adjusting the playback rate so that the frames exactly match
* when they are displayed both frequency and phase. If there was an
* accompanying audio track, you would need to resample the audio to match
* the clock.
*
* The algorithm isn't exactly a PLL - I wrote it first that way, but
* it oscillicated before coming into sync and this approach was easier than
* fine-tuning the PLL filter.
*
* A more complicated algorithm could also establish sync when the playback
* rate isn't exactly an integral divisor of the VBlank rate, such as 24fps
* video on a 60fps display.
*/
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
#define PRE_BUFFER_TIME 500000
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
static gint64 stream_time_base;
static gint64 clock_time_base;
static double time_factor = 1.0;
static double frequency_time_factor = 1.0;
static double phase_time_factor = 1.0;
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
static gint64
stream_time_to_clock_time (gint64 stream_time)
{
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
return clock_time_base + (stream_time - stream_time_base) * time_factor;
}
static void
adjust_clock_for_phase (gint64 frame_clock_time,
gint64 presentation_time)
{
static gint count = 0;
static gint64 previous_frame_clock_time;
static gint64 previous_presentation_time;
gint64 phase = presentation_time - frame_clock_time;
count++;
if (count >= fps) /* Give a second of warmup */
{
gint64 time_delta = frame_clock_time - previous_frame_clock_time;
gint64 previous_phase = previous_presentation_time - previous_frame_clock_time;
double expected_phase_delta;
stream_time_base += (frame_clock_time - clock_time_base) / time_factor;
clock_time_base = frame_clock_time;
expected_phase_delta = time_delta * (1 - phase_time_factor);
/* If the phase is increasing that means the computed clock times are
* increasing too slowly. We increase the frequency time factor to compensate,
* but decrease the compensation so that it takes effect over 1 second to
* avoid jitter */
frequency_time_factor += (phase - previous_phase - expected_phase_delta) / (double)time_delta / fps;
/* We also want to increase or decrease the frequency to bring the phase
* into sync. We do that again so that the phase should sync up over 1 seconds
*/
phase_time_factor = 1 + phase / 2000000.;
time_factor = frequency_time_factor * phase_time_factor;
}
previous_frame_clock_time = frame_clock_time;
previous_presentation_time = presentation_time;
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
}
/* Drawing */
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);
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
displayed_frame->frame_counter = gdk_frame_clock_get_frame_counter (frame_clock);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
}
}
}
static void
collect_old_frames (void)
{
GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (window);
GList *l, *l_next;
for (l = past_frames; l; l = l_next)
{
FrameData *frame_data = l->data;
gboolean remove = FALSE;
l_next = l->next;
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
GdkFrameTimings *timings = gdk_frame_clock_get_timings (frame_clock,
Merge GdkFrameHistory into GdkFrameClock Now that GdkFrameClock is a class, not interface, there's no real advantage to splitting the frame history into an aggregate object, so directly merge it into GdkFrameClock.
2013-02-12 20:47:38 +00:00
frame_data->frame_counter);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
if (timings == NULL)
{
remove = TRUE;
}
else if (gdk_frame_timings_get_complete (timings))
{
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
gint64 presentation_time = gdk_frame_timings_get_predicted_presentation_time (timings);
gint64 refresh_interval = gdk_frame_timings_get_refresh_interval (timings);
if (pll &&
presentation_time && refresh_interval &&
presentation_time > frame_data->clock_time - refresh_interval / 2 &&
presentation_time < frame_data->clock_time + refresh_interval / 2)
adjust_clock_for_phase (frame_data->clock_time, presentation_time);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
if (presentation_time)
variable_add (&latency_error,
presentation_time - frame_data->clock_time);
remove = TRUE;
}
if (remove)
{
past_frames = g_list_delete_link (past_frames, l);
g_slice_free (FrameData, frame_data);
}
}
}
static void
print_statistics (void)
{
gint64 now = g_get_monotonic_time ();
static gint64 last_print_time = 0;
if (last_print_time == 0)
last_print_time = now;
else if (now -last_print_time > 5000000)
{
g_print ("dropped_frames: %d/%d\n",
dropped_frames, n_frames);
g_print ("collected_frames: %g/%d\n",
latency_error.weight, n_frames);
g_print ("latency_error: %g +/- %g\n",
variable_mean (&latency_error),
variable_standard_deviation (&latency_error));
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
if (pll)
g_print ("playback rate adjustment: %g +/- %g %%\n",
(variable_mean (&time_factor_stats) - 1) * 100,
variable_standard_deviation (&time_factor_stats) * 100);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
variable_reset (&latency_error);
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
variable_reset (&time_factor_stats);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
dropped_frames = 0;
n_frames = 0;
last_print_time = now;
}
}
static void
on_update (GdkFrameClock *frame_clock,
gpointer data)
{
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
GdkFrameTimings *timings = gdk_frame_clock_get_current_timings (frame_clock);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
gint64 frame_time = gdk_frame_timings_get_frame_time (timings);
gint64 predicted_presentation_time = gdk_frame_timings_get_predicted_presentation_time (timings);
gint64 refresh_interval;
FrameData *pending_frame;
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
if (clock_time_base == 0)
clock_time_base = frame_time + PRE_BUFFER_TIME;
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
gdk_frame_clock_get_refresh_info (frame_clock, frame_time,
&refresh_interval, NULL);
pending_frame = peek_pending_frame ();
if (stream_time_to_clock_time (pending_frame->stream_time)
< predicted_presentation_time + refresh_interval / 2)
{
while (TRUE)
{
FrameData *next_frame = peek_next_frame ();
if (next_frame &&
stream_time_to_clock_time (next_frame->stream_time)
< predicted_presentation_time + refresh_interval / 2)
{
g_slice_free (FrameData, unqueue_frame ());
n_frames++;
dropped_frames++;
pending_frame = next_frame;
}
else
break;
}
if (displayed_frame)
past_frames = g_list_prepend (past_frames, displayed_frame);
n_frames++;
displayed_frame = unqueue_frame ();
displayed_frame->clock_time = stream_time_to_clock_time (displayed_frame->stream_time);
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
displayed_frame->frame_counter = gdk_frame_timings_get_frame_counter (timings);
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
variable_add (&time_factor_stats, time_factor);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
collect_old_frames ();
print_statistics ();
gtk_widget_queue_draw (window);
}
}
static GOptionEntry options[] = {
video-timer: add simple example of PLL-style clock adjustment The first version of the video-timer simply played back the video according to the wall clock, and showed each frame at the neareste presentatin time. But an alternative strategy for playing back video is that if the frame-rate is an integer-divisor of the display refresh rate, or very close to that, is to change the playback speed to complete avoid frame drops and changes in latency. (This would require resampling audio if present.) Demonstrate this technique by adding a --pll option to the video-timer demo. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-16 15:47:17 +00:00
{ "pll", 'p', 0, G_OPTION_ARG_NONE, &pll, "Sync frame rate to refresh", NULL },
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
{ "fps", 'f', 0, G_OPTION_ARG_INT, &fps, "Frame rate", "FPS" },
{ NULL }
};
int
main(int argc, char **argv)
{
GError *error = NULL;
GdkFrameClock *frame_clock;
if (!gtk_init_with_args (&argc, &argv, "",
options, NULL, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
g_signal_connect (window, "draw",
G_CALLBACK (on_window_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (window);
frame_queue = g_queue_new ();
g_mutex_init (&frame_mutex);
g_cond_init (&frame_cond);
g_thread_new ("Create Frames", create_frames_thread, NULL);
frame_clock = gtk_widget_get_frame_clock (window);
g_signal_connect (frame_clock, "update",
G_CALLBACK (on_update), NULL);
Add gdk_frame_clock_begin/end_updating() Add an API to start or stop continually updating the frame clock. This is a slight convenience for applcations and avoids the problem of getting one more frame run after an animation stops, but the primary motivation for this is because it looks like we might have to use timeBeginPeriod()/timeEndPeriod() on Windows to get reasonably accurate timing, and for that we'll need to know if there is an animation running. https://bugzilla.gnome.org/show_bug.cgi?id=693934
2013-02-15 22:04:39 +00:00
gdk_frame_clock_begin_updating (frame_clock);
video-timer: add a test case for display at a constant frame rate Add a test case that simulates the timing operaton that goes on when showing a constant frame rate stream like a video - each frame is shown at the VBlank interval that is closest to when it would ideally be timed. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-11-15 22:39:30 +00:00
gtk_main ();
return 0;
}
Reference in New Issue Copy Permalink