| /* GStreamer |
| * |
| * scrubby.c: sample application to change the playback speed dynamically |
| * |
| * Copyright (C) 2005 Wim Taymans <wim.taymans@gmail.com> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library 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 |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| #include <stdlib.h> |
| #include <glib.h> |
| #include <gtk/gtk.h> |
| #include <gst/gst.h> |
| #include <string.h> |
| |
| GST_DEBUG_CATEGORY_STATIC (scrubby_debug); |
| #define GST_CAT_DEFAULT (scrubby_debug) |
| |
| static GstElement *pipeline; |
| static gint64 position; |
| static gint64 duration; |
| static GtkAdjustment *adjustment; |
| static GtkWidget *hscale; |
| static GtkAdjustment *sadjustment; |
| static GtkWidget *shscale; |
| static gboolean verbose = FALSE; |
| |
| static guint bus_watch = 0; |
| static guint update_id = 0; |
| static guint changed_id = 0; |
| static guint schanged_id = 0; |
| |
| #define SOURCE "filesrc" |
| #define ASINK "autoaudiosink" |
| //#define ASINK "alsasink" |
| //#define ASINK "osssink" |
| #define VSINK "autovideosink" |
| //#define VSINK "xvimagesink" |
| //#define VSINK "ximagesink" |
| //#define VSINK "aasink" |
| //#define VSINK "cacasink" |
| |
| #define RANGE_PREC 10000 |
| #define SEGMENT_LEN 100 |
| #define UPDATE_INTERVAL 500 |
| |
| static gdouble prev_range = -1.0; |
| static GstClockTime prev_time = GST_CLOCK_TIME_NONE; |
| static gdouble cur_range; |
| static GstClockTime cur_time; |
| static GstClockTimeDiff diff; |
| static gdouble cur_speed = 1.0; |
| |
| typedef struct |
| { |
| const gchar *padname; |
| GstPad *target; |
| GstElement *bin; |
| } |
| dyn_link; |
| |
| static GstElement * |
| gst_element_factory_make_or_warn (const gchar * type, const gchar * name) |
| { |
| GstElement *element = gst_element_factory_make (type, name); |
| |
| if (!element) { |
| g_warning ("Failed to create element %s of type %s", name, type); |
| } |
| |
| return element; |
| } |
| |
| static GstElement * |
| make_wav_pipeline (const gchar * location) |
| { |
| GstElement *pipeline; |
| GstElement *src, *decoder, *audiosink; |
| |
| pipeline = gst_pipeline_new ("app"); |
| |
| src = gst_element_factory_make_or_warn (SOURCE, "src"); |
| decoder = gst_element_factory_make_or_warn ("wavparse", "decoder"); |
| audiosink = gst_element_factory_make_or_warn (ASINK, "sink"); |
| |
| g_object_set (G_OBJECT (src), "location", location, NULL); |
| |
| gst_bin_add_many (GST_BIN (pipeline), src, decoder, audiosink, NULL); |
| gst_element_link_many (src, decoder, audiosink, NULL); |
| |
| return pipeline; |
| } |
| |
| static GstElement * |
| make_playerbin_pipeline (const gchar * location) |
| { |
| GstElement *player; |
| const gchar *uri = g_filename_to_uri (location, NULL, NULL); |
| |
| player = gst_element_factory_make ("playbin", "player"); |
| g_assert (player); |
| |
| g_object_set (G_OBJECT (player), "uri", uri, NULL); |
| |
| return player; |
| } |
| |
| static gchar * |
| format_value (GtkScale * scale, gdouble value) |
| { |
| gint64 real; |
| gint64 seconds; |
| gint64 subseconds; |
| |
| real = value * duration / RANGE_PREC; |
| seconds = (gint64) real / GST_SECOND; |
| subseconds = (gint64) real / (GST_SECOND / RANGE_PREC); |
| |
| return g_strdup_printf ("%02" G_GINT64_FORMAT ":%02" G_GINT64_FORMAT ":%02" |
| G_GINT64_FORMAT, seconds / 60, seconds % 60, subseconds % 100); |
| } |
| |
| static gboolean |
| update_scale (gpointer data) |
| { |
| position = 0; |
| duration = 0; |
| |
| gst_element_query_position (pipeline, GST_FORMAT_TIME, &position); |
| gst_element_query_duration (pipeline, GST_FORMAT_TIME, &duration); |
| |
| if (position >= duration) |
| duration = position; |
| |
| if (duration > 0) { |
| gtk_adjustment_set_value (adjustment, |
| position * (gdouble) RANGE_PREC / duration); |
| gtk_widget_queue_draw (hscale); |
| } |
| |
| return TRUE; |
| } |
| |
| static void |
| speed_cb (GtkWidget * widget) |
| { |
| GstEvent *s_event; |
| gboolean res; |
| |
| GST_DEBUG ("speed change"); |
| cur_speed = gtk_range_get_value (GTK_RANGE (widget)); |
| |
| if (cur_speed == 0.0) |
| return; |
| |
| s_event = gst_event_new_seek (cur_speed, |
| GST_FORMAT_TIME, 0, GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_NONE, -1); |
| |
| res = gst_element_send_event (pipeline, s_event); |
| if (!res) |
| g_print ("speed change failed\n"); |
| } |
| |
| static gboolean do_seek (GtkWidget * widget, gboolean flush, gboolean segment); |
| |
| static void |
| seek_cb (GtkWidget * widget) |
| { |
| if (changed_id) { |
| GST_DEBUG ("seek because of slider move"); |
| |
| if (do_seek (widget, TRUE, TRUE)) { |
| g_signal_handler_disconnect (hscale, changed_id); |
| changed_id = 0; |
| } |
| } |
| } |
| |
| static gboolean |
| do_seek (GtkWidget * widget, gboolean flush, gboolean segment) |
| { |
| gint64 start, stop; |
| gboolean res = FALSE; |
| GstEvent *s_event; |
| gdouble rate; |
| GTimeVal tv; |
| gboolean valid; |
| gdouble new_range; |
| |
| if (segment) |
| new_range = gtk_range_get_value (GTK_RANGE (widget)); |
| else { |
| new_range = (gdouble) RANGE_PREC; |
| cur_time = -1; |
| } |
| |
| valid = prev_time != -1; |
| |
| GST_DEBUG ("flush %d, segment %d, valid %d", flush, segment, valid); |
| |
| if (new_range == cur_range) |
| return FALSE; |
| |
| prev_time = cur_time; |
| prev_range = cur_range; |
| |
| cur_range = new_range; |
| |
| g_get_current_time (&tv); |
| cur_time = GST_TIMEVAL_TO_TIME (tv); |
| |
| if (!valid) |
| return FALSE; |
| |
| GST_DEBUG ("cur: %lf, %" GST_TIME_FORMAT, cur_range, |
| GST_TIME_ARGS (cur_time)); |
| GST_DEBUG ("prev: %lf, %" GST_TIME_FORMAT, prev_range, |
| GST_TIME_ARGS (prev_time)); |
| |
| diff = cur_time - prev_time; |
| |
| GST_DEBUG ("diff: %" GST_STIME_FORMAT, GST_STIME_ARGS (diff)); |
| |
| start = prev_range * duration / RANGE_PREC; |
| /* play 50 milliseconds */ |
| stop = segment ? cur_range * duration / RANGE_PREC : duration; |
| |
| if (start == stop) |
| return FALSE; |
| |
| if (segment) |
| rate = (stop - start) / (gdouble) diff; |
| else |
| rate = cur_speed; |
| |
| if (start > stop) { |
| gint64 tmp; |
| |
| tmp = start; |
| start = stop; |
| stop = tmp; |
| } |
| |
| if (rate == 0.0) |
| return TRUE; |
| |
| GST_DEBUG ("seek to %" GST_TIME_FORMAT " -- %" GST_TIME_FORMAT ", rate %lf" |
| " on element %s", |
| GST_TIME_ARGS (start), GST_TIME_ARGS (stop), rate, |
| GST_ELEMENT_NAME (pipeline)); |
| |
| s_event = gst_event_new_seek (rate, |
| GST_FORMAT_TIME, |
| (flush ? GST_SEEK_FLAG_FLUSH : 0) | |
| (segment ? GST_SEEK_FLAG_SEGMENT : 0), |
| GST_SEEK_TYPE_SET, start, GST_SEEK_TYPE_SET, stop); |
| |
| res = gst_element_send_event (pipeline, s_event); |
| if (!res) |
| g_print ("seek failed\n"); |
| |
| gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE); |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| start_seek (GtkWidget * widget, GdkEventButton * event, gpointer user_data) |
| { |
| if (update_id) { |
| g_source_remove (update_id); |
| update_id = 0; |
| } |
| |
| if (changed_id == 0) { |
| changed_id = |
| g_signal_connect (hscale, "value_changed", G_CALLBACK (seek_cb), |
| pipeline); |
| } |
| |
| GST_DEBUG ("start seek"); |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| stop_seek (GtkWidget * widget, gpointer user_data) |
| { |
| update_id = |
| g_timeout_add (UPDATE_INTERVAL, (GSourceFunc) update_scale, pipeline); |
| |
| GST_DEBUG ("stop seek"); |
| |
| if (changed_id) { |
| g_signal_handler_disconnect (hscale, changed_id); |
| changed_id = 0; |
| } |
| |
| do_seek (hscale, FALSE, FALSE); |
| |
| return FALSE; |
| } |
| |
| static void |
| play_cb (GtkButton * button, gpointer data) |
| { |
| GstState state; |
| |
| gst_element_get_state (pipeline, &state, NULL, GST_CLOCK_TIME_NONE); |
| if (state != GST_STATE_PLAYING) { |
| g_print ("PLAY pipeline\n"); |
| gst_element_set_state (pipeline, GST_STATE_PLAYING); |
| update_id = |
| g_timeout_add (UPDATE_INTERVAL, (GSourceFunc) update_scale, pipeline); |
| } |
| } |
| |
| static void |
| pause_cb (GtkButton * button, gpointer data) |
| { |
| GstState state; |
| |
| gst_element_get_state (pipeline, &state, NULL, GST_CLOCK_TIME_NONE); |
| if (state != GST_STATE_PAUSED) { |
| g_print ("PAUSE pipeline\n"); |
| gst_element_set_state (pipeline, GST_STATE_PAUSED); |
| g_source_remove (update_id); |
| } |
| } |
| |
| static void |
| stop_cb (GtkButton * button, gpointer data) |
| { |
| GstState state; |
| |
| gst_element_get_state (pipeline, &state, NULL, GST_CLOCK_TIME_NONE); |
| if (state != GST_STATE_READY) { |
| g_print ("READY pipeline\n"); |
| gst_element_set_state (pipeline, GST_STATE_READY); |
| /* position and speed return to their default values */ |
| gtk_adjustment_set_value (adjustment, 0.0); |
| gtk_adjustment_set_value (sadjustment, 1.0); |
| g_source_remove (update_id); |
| } |
| } |
| |
| static void |
| print_message (GstMessage * message) |
| { |
| const GstStructure *s; |
| |
| s = gst_message_get_structure (message); |
| g_print ("Got Message from element \"%s\"\n", |
| GST_STR_NULL (GST_ELEMENT_NAME (GST_MESSAGE_SRC (message)))); |
| |
| if (s) { |
| gchar *sstr; |
| |
| sstr = gst_structure_to_string (s); |
| g_print ("%s\n", sstr); |
| g_free (sstr); |
| } |
| } |
| |
| static gboolean |
| bus_message (GstBus * bus, GstMessage * message, gpointer data) |
| { |
| switch (GST_MESSAGE_TYPE (message)) { |
| case GST_MESSAGE_EOS: |
| g_print ("EOS\n"); |
| break; |
| case GST_MESSAGE_ERROR: |
| case GST_MESSAGE_WARNING: |
| print_message (message); |
| break; |
| case GST_MESSAGE_SEGMENT_START: |
| break; |
| case GST_MESSAGE_SEGMENT_DONE: |
| GST_DEBUG ("segment_done, doing next seek"); |
| if (!do_seek (hscale, FALSE, update_id == 0)) { |
| if (changed_id == 0) { |
| changed_id = |
| g_signal_connect (hscale, "value_changed", G_CALLBACK (seek_cb), |
| pipeline); |
| } |
| } |
| break; |
| default: |
| break; |
| } |
| |
| return TRUE; |
| } |
| |
| typedef struct |
| { |
| const gchar *name; |
| GstElement *(*func) (const gchar * location); |
| } |
| Pipeline; |
| |
| static Pipeline pipelines[] = { |
| {"wav", make_wav_pipeline}, |
| {"playerbin", make_playerbin_pipeline}, |
| {NULL, NULL}, |
| }; |
| |
| #define NUM_TYPES ((sizeof (pipelines) / sizeof (Pipeline)) - 1) |
| |
| static void |
| print_usage (int argc, char **argv) |
| { |
| gint i; |
| |
| g_print ("usage: %s <type> <filename>\n", argv[0]); |
| g_print (" possible types:\n"); |
| |
| for (i = 0; i < NUM_TYPES; i++) { |
| g_print (" %d = %s\n", i, pipelines[i].name); |
| } |
| } |
| |
| int |
| main (int argc, char **argv) |
| { |
| GtkWidget *window, *hbox, *vbox, *play_button, *pause_button, *stop_button; |
| GstBus *bus; |
| GOptionEntry options[] = { |
| {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, |
| "Verbose properties", NULL}, |
| {NULL} |
| }; |
| gint type; |
| GOptionContext *ctx; |
| GError *err = NULL; |
| |
| ctx = g_option_context_new ("seek"); |
| g_option_context_add_main_entries (ctx, options, NULL); |
| g_option_context_add_group (ctx, gst_init_get_option_group ()); |
| |
| if (!g_option_context_parse (ctx, &argc, &argv, &err)) { |
| g_print ("Error initializing: %s\n", err->message); |
| g_option_context_free (ctx); |
| g_clear_error (&err); |
| exit (1); |
| } |
| |
| GST_DEBUG_CATEGORY_INIT (scrubby_debug, "scrubby", 0, "scrubby example"); |
| |
| gtk_init (&argc, &argv); |
| |
| if (argc != 3) { |
| print_usage (argc, argv); |
| exit (-1); |
| } |
| |
| type = atoi (argv[1]); |
| |
| if (type < 0 || type >= NUM_TYPES) { |
| print_usage (argc, argv); |
| exit (-1); |
| } |
| |
| pipeline = pipelines[type].func (argv[2]); |
| g_assert (pipeline); |
| |
| /* initialize gui elements ... */ |
| window = gtk_window_new (GTK_WINDOW_TOPLEVEL); |
| hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); |
| vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); |
| play_button = gtk_button_new_with_label ("play"); |
| pause_button = gtk_button_new_with_label ("pause"); |
| stop_button = gtk_button_new_with_label ("stop"); |
| |
| adjustment = |
| GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, (gdouble) RANGE_PREC, 0.1, |
| 1.0, 1.0)); |
| hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment); |
| gtk_scale_set_digits (GTK_SCALE (hscale), 2); |
| |
| sadjustment = |
| GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 0.0, 5.0, 0.1, 1.0, 0.0)); |
| shscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, sadjustment); |
| gtk_scale_set_digits (GTK_SCALE (shscale), 2); |
| |
| schanged_id = |
| g_signal_connect (shscale, "value_changed", G_CALLBACK (speed_cb), |
| pipeline); |
| |
| g_signal_connect (hscale, "button_press_event", G_CALLBACK (start_seek), |
| pipeline); |
| g_signal_connect (hscale, "button_release_event", G_CALLBACK (stop_seek), |
| pipeline); |
| g_signal_connect (hscale, "format_value", G_CALLBACK (format_value), |
| pipeline); |
| |
| /* do the packing stuff ... */ |
| gtk_window_set_default_size (GTK_WINDOW (window), 96, 96); |
| gtk_container_add (GTK_CONTAINER (window), vbox); |
| gtk_container_add (GTK_CONTAINER (vbox), hbox); |
| gtk_box_pack_start (GTK_BOX (hbox), play_button, FALSE, FALSE, 2); |
| gtk_box_pack_start (GTK_BOX (hbox), pause_button, FALSE, FALSE, 2); |
| gtk_box_pack_start (GTK_BOX (hbox), stop_button, FALSE, FALSE, 2); |
| gtk_box_pack_start (GTK_BOX (vbox), hscale, TRUE, TRUE, 2); |
| gtk_box_pack_start (GTK_BOX (vbox), shscale, TRUE, TRUE, 2); |
| |
| /* connect things ... */ |
| g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), |
| pipeline); |
| g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), |
| pipeline); |
| g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), |
| pipeline); |
| g_signal_connect (G_OBJECT (window), "delete_event", gtk_main_quit, NULL); |
| |
| /* show the gui. */ |
| gtk_widget_show_all (window); |
| |
| if (verbose) { |
| g_signal_connect (pipeline, "deep_notify", |
| G_CALLBACK (gst_object_default_deep_notify), NULL); |
| } |
| bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); |
| g_assert (bus); |
| |
| bus_watch = gst_bus_add_watch_full (bus, |
| G_PRIORITY_HIGH, bus_message, pipeline, NULL); |
| |
| gtk_main (); |
| |
| g_print ("NULL pipeline\n"); |
| gst_element_set_state (pipeline, GST_STATE_NULL); |
| |
| gst_object_unref (bus); |
| |
| g_print ("free pipeline\n"); |
| gst_object_unref (pipeline); |
| |
| return 0; |
| } |