1 /* GStreamer

     2  *

     3  * seek.c: seeking sample application

     4  *

     5  * Copyright (C) 2005 Wim Taymans <wim@fluendo.com>

     6  *               2006 Stefan Kost <ensonic@users.sf.net>

     7  *

     8  * This library is free software; you can redistribute it and/or

     9  * modify it under the terms of the GNU Library General Public

    10  * License as published by the Free Software Foundation; either

    11  * version 2 of the License, or (at your option) any later version.

    12  *

    13  * This library is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16  * Library General Public License for more details.

    17  *

    18  * You should have received a copy of the GNU Library General Public

    19  * License along with this library; if not, write to the

    20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    21  * Boston, MA 02111-1307, USA.

    22  */

    23 /* FIXME: remove #if 0 code

    24  *

    25  */

    26 #include <stdlib.h>

    27 #include <glib.h>

    28 #include <gtk/gtk.h>

    29 #include <gst/gst.h>

    30 #include <string.h>

    31 

    32 GST_DEBUG_CATEGORY_STATIC (seek_debug);

    33 #define GST_CAT_DEFAULT (seek_debug)

    34 

    35 /* configuration */

    36 

    37 //#define SOURCE "filesrc"

    38 #define SOURCE "gnomevfssrc"

    39 

    40 #define ASINK "alsasink"

    41 //#define ASINK "osssink"

    42 

    43 #define VSINK "xvimagesink"

    44 //#define VSINK "sdlvideosink"

    45 //#define VSINK "ximagesink"

    46 //#define VSINK "aasink"

    47 //#define VSINK "cacasink"

    48 

    49 //#define UPDATE_INTERVAL 500

    50 //#define UPDATE_INTERVAL 100

    51 #define UPDATE_INTERVAL 10

    52 

    53 /* number of milliseconds to play for after a seek */

    54 #define SCRUB_TIME 100

    55 

    56 /* timeout for gst_element_get_state() after a seek */

    57 #define SEEK_TIMEOUT 40 * GST_MSECOND

    58 

    59 

    60 static GList *seekable_pads = NULL;

    61 static GList *rate_pads = NULL;

    62 static GList *seekable_elements = NULL;

    63 

    64 static gboolean accurate_seek = FALSE;

    65 static gboolean keyframe_seek = FALSE;

    66 static gboolean loop_seek = FALSE;

    67 static gboolean flush_seek = TRUE;

    68 static gboolean scrub = TRUE;

    69 static gboolean play_scrub = FALSE;

    70 static gdouble rate = 1.0;

    71 

    72 static GstElement *pipeline;

    73 static gint pipeline_type;

    74 static const gchar *pipeline_spec;

    75 static gint64 position = -1;

    76 static gint64 duration = -1;

    77 static GtkAdjustment *adjustment;

    78 static GtkWidget *hscale;

    79 static gboolean stats = FALSE;

    80 static gboolean elem_seek = FALSE;

    81 static gboolean verbose = FALSE;

    82 

    83 static GstState state = GST_STATE_NULL;

    84 static guint update_id = 0;

    85 static guint seek_timeout_id = 0;

    86 static gulong changed_id;

    87 

    88 static gint n_video = 0, n_audio = 0, n_text = 0;

    89 static gboolean need_streams = TRUE;

    90 static GtkWidget *video_combo, *audio_combo, *text_combo, *vis_combo;

    91 static GtkWidget *vis_checkbox, *video_checkbox, *audio_checkbox;

    92 static GtkWidget *text_checkbox, *mute_checkbox, *volume_spinbutton;

    93 

    94 /* we keep an array of the visualisation entries so that we can easily switch

    95  * with the combo box index. */

    96 typedef struct

    97 {

    98   GstElementFactory *factory;

    99 } VisEntry;

   100 

   101 static GArray *vis_entries;

   102 

   103 static void clear_streams (GstElement * pipeline);

   104 

   105 /* pipeline construction */

   106 

   107 typedef struct

   108 {

   109   const gchar *padname;

   110   GstPad *target;

   111   GstElement *bin;

   112 }

   113 dyn_link;

   114 

   115 static GstElement *

   116 gst_element_factory_make_or_warn (gchar * type, gchar * name)

   117 {

   118   GstElement *element = gst_element_factory_make (type, name);

   119 

   120   if (!element) {

   121     g_warning ("Failed to create element %s of type %s", name, type);

   122   }

   123 

   124   return element;

   125 }

   126 

   127 static void

   128 dynamic_link (GstPadTemplate * templ, GstPad * newpad, gpointer data)

   129 {

   130   gchar *padname;

   131   dyn_link *connect = (dyn_link *) data;

   132 

   133   padname = gst_pad_get_name (newpad);

   134 

   135   if (connect->padname == NULL || !strcmp (padname, connect->padname)) {

   136     if (connect->bin)

   137       gst_bin_add (GST_BIN (pipeline), connect->bin);

   138     gst_pad_link (newpad, connect->target);

   139 

   140     //seekable_pads = g_list_prepend (seekable_pads, newpad);

   141     rate_pads = g_list_prepend (rate_pads, newpad);

   142   }

   143   g_free (padname);

   144 }

   145 

   146 static void

   147 setup_dynamic_link (GstElement * element, const gchar * padname,

   148     GstPad * target, GstElement * bin)

   149 {

   150   dyn_link *connect;

   151 

   152   connect = g_new0 (dyn_link, 1);

   153   connect->padname = g_strdup (padname);

   154   connect->target = target;

   155   connect->bin = bin;

   156 

   157   g_signal_connect (G_OBJECT (element), "pad-added", G_CALLBACK (dynamic_link),

   158       connect);

   159 }

   160 

   161 static GstElement *

   162 make_mod_pipeline (const gchar * location)

   163 {

   164   GstElement *pipeline;

   165   GstElement *src, *decoder, *audiosink;

   166   GstPad *seekable;

   167 

   168   pipeline = gst_pipeline_new ("app");

   169 

   170   src = gst_element_factory_make_or_warn (SOURCE, "src");

   171   decoder = gst_element_factory_make_or_warn ("modplug", "decoder");

   172   audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

   173   //g_object_set (G_OBJECT (audiosink), "sync", FALSE, NULL);

   174 

   175   g_object_set (G_OBJECT (src), "location", location, NULL);

   176 

   177   gst_bin_add (GST_BIN (pipeline), src);

   178   gst_bin_add (GST_BIN (pipeline), decoder);

   179   gst_bin_add (GST_BIN (pipeline), audiosink);

   180 

   181   gst_element_link (src, decoder);

   182   gst_element_link (decoder, audiosink);

   183 

   184   seekable = gst_element_get_pad (decoder, "src");

   185   seekable_pads = g_list_prepend (seekable_pads, seekable);

   186   rate_pads = g_list_prepend (rate_pads, seekable);

   187   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   188 

   189   return pipeline;

   190 }

   191 

   192 static GstElement *

   193 make_dv_pipeline (const gchar * location)

   194 {

   195   GstElement *pipeline;

   196   GstElement *src, *demux, *decoder, *audiosink, *videosink;

   197   GstElement *a_queue, *v_queue;

   198   GstPad *seekable;

   199 

   200   pipeline = gst_pipeline_new ("app");

   201 

   202   src = gst_element_factory_make_or_warn (SOURCE, "src");

   203   demux = gst_element_factory_make_or_warn ("dvdemux", "demuxer");

   204   v_queue = gst_element_factory_make_or_warn ("queue", "v_queue");

   205   decoder = gst_element_factory_make_or_warn ("ffdec_dvvideo", "decoder");

   206   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   207   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   208   audiosink = gst_element_factory_make_or_warn ("alsasink", "a_sink");

   209 

   210   g_object_set (G_OBJECT (src), "location", location, NULL);

   211 

   212   gst_bin_add (GST_BIN (pipeline), src);

   213   gst_bin_add (GST_BIN (pipeline), demux);

   214   gst_bin_add (GST_BIN (pipeline), a_queue);

   215   gst_bin_add (GST_BIN (pipeline), audiosink);

   216   gst_bin_add (GST_BIN (pipeline), v_queue);

   217   gst_bin_add (GST_BIN (pipeline), decoder);

   218   gst_bin_add (GST_BIN (pipeline), videosink);

   219 

   220   gst_element_link (src, demux);

   221   gst_element_link (a_queue, audiosink);

   222   gst_element_link (v_queue, decoder);

   223   gst_element_link (decoder, videosink);

   224 

   225   setup_dynamic_link (demux, "video", gst_element_get_pad (v_queue, "sink"),

   226       NULL);

   227   setup_dynamic_link (demux, "audio", gst_element_get_pad (a_queue, "sink"),

   228       NULL);

   229 

   230   seekable = gst_element_get_pad (decoder, "src");

   231   seekable_pads = g_list_prepend (seekable_pads, seekable);

   232   rate_pads = g_list_prepend (rate_pads, seekable);

   233 

   234   return pipeline;

   235 }

   236 

   237 static GstElement *

   238 make_wav_pipeline (const gchar * location)

   239 {

   240   GstElement *pipeline;

   241   GstElement *src, *decoder, *audiosink;

   242 

   243   pipeline = gst_pipeline_new ("app");

   244 

   245   src = gst_element_factory_make_or_warn (SOURCE, "src");

   246   decoder = gst_element_factory_make_or_warn ("wavparse", "decoder");

   247   audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

   248 

   249   g_object_set (G_OBJECT (src), "location", location, NULL);

   250 

   251   gst_bin_add (GST_BIN (pipeline), src);

   252   gst_bin_add (GST_BIN (pipeline), decoder);

   253   gst_bin_add (GST_BIN (pipeline), audiosink);

   254 

   255   gst_element_link (src, decoder);

   256 

   257   setup_dynamic_link (decoder, "src", gst_element_get_pad (audiosink, "sink"),

   258       NULL);

   259 

   260   seekable_elements = g_list_prepend (seekable_elements, audiosink);

   261 

   262   /* force element seeking on this pipeline */

   263   elem_seek = TRUE;

   264 

   265   return pipeline;

   266 }

   267 

   268 static GstElement *

   269 make_flac_pipeline (const gchar * location)

   270 {

   271   GstElement *pipeline;

   272   GstElement *src, *decoder, *audiosink;

   273   GstPad *seekable;

   274 

   275   pipeline = gst_pipeline_new ("app");

   276 

   277   src = gst_element_factory_make_or_warn (SOURCE, "src");

   278   decoder = gst_element_factory_make_or_warn ("flacdec", "decoder");

   279   audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

   280   g_object_set (G_OBJECT (audiosink), "sync", FALSE, NULL);

   281 

   282   g_object_set (G_OBJECT (src), "location", location, NULL);

   283 

   284   gst_bin_add (GST_BIN (pipeline), src);

   285   gst_bin_add (GST_BIN (pipeline), decoder);

   286   gst_bin_add (GST_BIN (pipeline), audiosink);

   287 

   288   gst_element_link (src, decoder);

   289   gst_element_link (decoder, audiosink);

   290 

   291   seekable = gst_element_get_pad (decoder, "src");

   292   seekable_pads = g_list_prepend (seekable_pads, seekable);

   293   rate_pads = g_list_prepend (rate_pads, seekable);

   294   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   295 

   296   return pipeline;

   297 }

   298 

   299 static GstElement *

   300 make_sid_pipeline (const gchar * location)

   301 {

   302   GstElement *pipeline;

   303   GstElement *src, *decoder, *audiosink;

   304   GstPad *seekable;

   305 

   306   pipeline = gst_pipeline_new ("app");

   307 

   308   src = gst_element_factory_make_or_warn (SOURCE, "src");

   309   decoder = gst_element_factory_make_or_warn ("siddec", "decoder");

   310   audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

   311   //g_object_set (G_OBJECT (audiosink), "sync", FALSE, NULL);

   312 

   313   g_object_set (G_OBJECT (src), "location", location, NULL);

   314 

   315   gst_bin_add (GST_BIN (pipeline), src);

   316   gst_bin_add (GST_BIN (pipeline), decoder);

   317   gst_bin_add (GST_BIN (pipeline), audiosink);

   318 

   319   gst_element_link (src, decoder);

   320   gst_element_link (decoder, audiosink);

   321 

   322   seekable = gst_element_get_pad (decoder, "src");

   323   seekable_pads = g_list_prepend (seekable_pads, seekable);

   324   rate_pads = g_list_prepend (rate_pads, seekable);

   325   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   326 

   327   return pipeline;

   328 }

   329 

   330 static GstElement *

   331 make_parse_pipeline (const gchar * location)

   332 {

   333   GstElement *pipeline;

   334   GstElement *src, *parser, *fakesink;

   335   GstPad *seekable;

   336 

   337   pipeline = gst_pipeline_new ("app");

   338 

   339   src = gst_element_factory_make_or_warn (SOURCE, "src");

   340   parser = gst_element_factory_make_or_warn ("mpegparse", "parse");

   341   fakesink = gst_element_factory_make_or_warn ("fakesink", "sink");

   342   g_object_set (G_OBJECT (fakesink), "silent", TRUE, NULL);

   343   g_object_set (G_OBJECT (fakesink), "sync", TRUE, NULL);

   344 

   345   g_object_set (G_OBJECT (src), "location", location, NULL);

   346 

   347   gst_bin_add (GST_BIN (pipeline), src);

   348   gst_bin_add (GST_BIN (pipeline), parser);

   349   gst_bin_add (GST_BIN (pipeline), fakesink);

   350 

   351   gst_element_link (src, parser);

   352   gst_element_link (parser, fakesink);

   353 

   354   seekable = gst_element_get_pad (parser, "src");

   355   seekable_pads = g_list_prepend (seekable_pads, seekable);

   356   rate_pads = g_list_prepend (rate_pads, seekable);

   357   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (parser, "sink"));

   358 

   359   return pipeline;

   360 }

   361 

   362 static GstElement *

   363 make_vorbis_pipeline (const gchar * location)

   364 {

   365   GstElement *pipeline, *audio_bin;

   366   GstElement *src, *demux, *decoder, *convert, *audiosink;

   367   GstPad *pad, *seekable;

   368 

   369   pipeline = gst_pipeline_new ("app");

   370 

   371   src = gst_element_factory_make_or_warn (SOURCE, "src");

   372   demux = gst_element_factory_make_or_warn ("oggdemux", "demux");

   373   decoder = gst_element_factory_make_or_warn ("vorbisdec", "decoder");

   374   convert = gst_element_factory_make_or_warn ("audioconvert", "convert");

   375   audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

   376   g_object_set (G_OBJECT (audiosink), "sync", TRUE, NULL);

   377 

   378   g_object_set (G_OBJECT (src), "location", location, NULL);

   379 

   380   audio_bin = gst_bin_new ("a_decoder_bin");

   381 

   382   gst_bin_add (GST_BIN (pipeline), src);

   383   gst_bin_add (GST_BIN (pipeline), demux);

   384   gst_bin_add (GST_BIN (audio_bin), decoder);

   385   gst_bin_add (GST_BIN (audio_bin), convert);

   386   gst_bin_add (GST_BIN (audio_bin), audiosink);

   387   gst_bin_add (GST_BIN (pipeline), audio_bin);

   388 

   389   gst_element_link (src, demux);

   390   gst_element_link (decoder, convert);

   391   gst_element_link (convert, audiosink);

   392 

   393   pad = gst_element_get_pad (decoder, "sink");

   394   gst_element_add_pad (audio_bin, gst_ghost_pad_new ("sink", pad));

   395   gst_object_unref (pad);

   396 

   397   setup_dynamic_link (demux, NULL, gst_element_get_pad (audio_bin, "sink"),

   398       NULL);

   399 

   400   seekable = gst_element_get_pad (decoder, "src");

   401   seekable_pads = g_list_prepend (seekable_pads, seekable);

   402   rate_pads = g_list_prepend (rate_pads, seekable);

   403   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   404 

   405   return pipeline;

   406 }

   407 

   408 static GstElement *

   409 make_theora_pipeline (const gchar * location)

   410 {

   411   GstElement *pipeline, *video_bin;

   412   GstElement *src, *demux, *decoder, *convert, *videosink;

   413   GstPad *pad, *seekable;

   414 

   415   pipeline = gst_pipeline_new ("app");

   416 

   417   src = gst_element_factory_make_or_warn (SOURCE, "src");

   418   demux = gst_element_factory_make_or_warn ("oggdemux", "demux");

   419   decoder = gst_element_factory_make_or_warn ("theoradec", "decoder");

   420   convert = gst_element_factory_make_or_warn ("ffmpegcolorspace", "convert");

   421   videosink = gst_element_factory_make_or_warn (VSINK, "sink");

   422 

   423   g_object_set (G_OBJECT (src), "location", location, NULL);

   424 

   425   video_bin = gst_bin_new ("v_decoder_bin");

   426 

   427   gst_bin_add (GST_BIN (pipeline), src);

   428   gst_bin_add (GST_BIN (pipeline), demux);

   429   gst_bin_add (GST_BIN (video_bin), decoder);

   430   gst_bin_add (GST_BIN (video_bin), convert);

   431   gst_bin_add (GST_BIN (video_bin), videosink);

   432   gst_bin_add (GST_BIN (pipeline), video_bin);

   433 

   434   gst_element_link (src, demux);

   435   gst_element_link (decoder, convert);

   436   gst_element_link (convert, videosink);

   437 

   438   pad = gst_element_get_pad (decoder, "sink");

   439   gst_element_add_pad (video_bin, gst_ghost_pad_new ("sink", pad));

   440   gst_object_unref (pad);

   441 

   442   setup_dynamic_link (demux, NULL, gst_element_get_pad (video_bin, "sink"),

   443       NULL);

   444 

   445   seekable = gst_element_get_pad (decoder, "src");

   446   seekable_pads = g_list_prepend (seekable_pads, seekable);

   447   rate_pads = g_list_prepend (rate_pads, seekable);

   448   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   449 

   450   return pipeline;

   451 }

   452 

   453 static GstElement *

   454 make_vorbis_theora_pipeline (const gchar * location)

   455 {

   456   GstElement *pipeline, *audio_bin, *video_bin;

   457   GstElement *src, *demux, *a_decoder, *a_convert, *v_decoder, *v_convert;

   458   GstElement *audiosink, *videosink;

   459   GstElement *a_queue, *v_queue, *v_scale;

   460   GstPad *seekable;

   461   GstPad *pad;

   462 

   463   pipeline = gst_pipeline_new ("app");

   464 

   465   src = gst_element_factory_make_or_warn (SOURCE, "src");

   466   g_object_set (G_OBJECT (src), "location", location, NULL);

   467 

   468   demux = gst_element_factory_make_or_warn ("oggdemux", "demux");

   469 

   470   gst_bin_add (GST_BIN (pipeline), src);

   471   gst_bin_add (GST_BIN (pipeline), demux);

   472   gst_element_link (src, demux);

   473 

   474   audio_bin = gst_bin_new ("a_decoder_bin");

   475   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   476   a_decoder = gst_element_factory_make_or_warn ("vorbisdec", "a_dec");

   477   a_convert = gst_element_factory_make_or_warn ("audioconvert", "a_convert");

   478   audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

   479 

   480   gst_bin_add (GST_BIN (pipeline), audio_bin);

   481 

   482   gst_bin_add (GST_BIN (audio_bin), a_queue);

   483   gst_bin_add (GST_BIN (audio_bin), a_decoder);

   484   gst_bin_add (GST_BIN (audio_bin), a_convert);

   485   gst_bin_add (GST_BIN (audio_bin), audiosink);

   486 

   487   gst_element_link (a_queue, a_decoder);

   488   gst_element_link (a_decoder, a_convert);

   489   gst_element_link (a_convert, audiosink);

   490 

   491   pad = gst_element_get_pad (a_queue, "sink");

   492   gst_element_add_pad (audio_bin, gst_ghost_pad_new ("sink", pad));

   493   gst_object_unref (pad);

   494 

   495   setup_dynamic_link (demux, NULL, gst_element_get_pad (audio_bin, "sink"),

   496       NULL);

   497 

   498   video_bin = gst_bin_new ("v_decoder_bin");

   499   v_queue = gst_element_factory_make_or_warn ("queue", "v_queue");

   500   v_decoder = gst_element_factory_make_or_warn ("theoradec", "v_dec");

   501   v_convert =

   502       gst_element_factory_make_or_warn ("ffmpegcolorspace", "v_convert");

   503   v_scale = gst_element_factory_make_or_warn ("videoscale", "v_scale");

   504   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   505 

   506   gst_bin_add (GST_BIN (pipeline), video_bin);

   507 

   508   gst_bin_add (GST_BIN (video_bin), v_queue);

   509   gst_bin_add (GST_BIN (video_bin), v_decoder);

   510   gst_bin_add (GST_BIN (video_bin), v_convert);

   511   gst_bin_add (GST_BIN (video_bin), v_scale);

   512   gst_bin_add (GST_BIN (video_bin), videosink);

   513 

   514   gst_element_link_many (v_queue, v_decoder, v_convert, v_scale, videosink,

   515       NULL);

   516 

   517   pad = gst_element_get_pad (v_queue, "sink");

   518   gst_element_add_pad (video_bin, gst_ghost_pad_new ("sink", pad));

   519   gst_object_unref (pad);

   520 

   521   setup_dynamic_link (demux, NULL, gst_element_get_pad (video_bin, "sink"),

   522       NULL);

   523 

   524   seekable = gst_element_get_pad (a_decoder, "src");

   525   seekable_pads = g_list_prepend (seekable_pads, seekable);

   526   rate_pads = g_list_prepend (rate_pads, seekable);

   527   rate_pads =

   528       g_list_prepend (rate_pads, gst_element_get_pad (a_decoder, "sink"));

   529 

   530   return pipeline;

   531 }

   532 

   533 static GstElement *

   534 make_avi_msmpeg4v3_mp3_pipeline (const gchar * location)

   535 {

   536   GstElement *pipeline, *audio_bin, *video_bin;

   537   GstElement *src, *demux, *a_decoder, *a_convert, *v_decoder, *v_convert;

   538   GstElement *audiosink, *videosink;

   539   GstElement *a_queue, *v_queue;

   540   GstPad *seekable, *pad;

   541 

   542   pipeline = gst_pipeline_new ("app");

   543 

   544   src = gst_element_factory_make_or_warn (SOURCE, "src");

   545   g_object_set (G_OBJECT (src), "location", location, NULL);

   546 

   547   demux = gst_element_factory_make_or_warn ("avidemux", "demux");

   548 

   549   gst_bin_add (GST_BIN (pipeline), src);

   550   gst_bin_add (GST_BIN (pipeline), demux);

   551   gst_element_link (src, demux);

   552 

   553   audio_bin = gst_bin_new ("a_decoder_bin");

   554   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   555   a_decoder = gst_element_factory_make_or_warn ("mad", "a_dec");

   556   a_convert = gst_element_factory_make_or_warn ("audioconvert", "a_convert");

   557   audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

   558 

   559   gst_bin_add (GST_BIN (audio_bin), a_queue);

   560   gst_bin_add (GST_BIN (audio_bin), a_decoder);

   561   gst_bin_add (GST_BIN (audio_bin), a_convert);

   562   gst_bin_add (GST_BIN (audio_bin), audiosink);

   563 

   564   gst_element_link (a_queue, a_decoder);

   565   gst_element_link (a_decoder, a_convert);

   566   gst_element_link (a_convert, audiosink);

   567 

   568   gst_bin_add (GST_BIN (pipeline), audio_bin);

   569 

   570   pad = gst_element_get_pad (a_queue, "sink");

   571   gst_element_add_pad (audio_bin, gst_ghost_pad_new ("sink", pad));

   572   gst_object_unref (pad);

   573 

   574   setup_dynamic_link (demux, NULL, gst_element_get_pad (audio_bin, "sink"),

   575       NULL);

   576 

   577   video_bin = gst_bin_new ("v_decoder_bin");

   578   v_queue = gst_element_factory_make_or_warn ("queue", "v_queue");

   579   v_decoder = gst_element_factory_make_or_warn ("ffdec_msmpeg4", "v_dec");

   580   v_convert =

   581       gst_element_factory_make_or_warn ("ffmpegcolorspace", "v_convert");

   582   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   583 

   584   gst_bin_add (GST_BIN (video_bin), v_queue);

   585   gst_bin_add (GST_BIN (video_bin), v_decoder);

   586   gst_bin_add (GST_BIN (video_bin), v_convert);

   587   gst_bin_add (GST_BIN (video_bin), videosink);

   588 

   589   gst_element_link_many (v_queue, v_decoder, v_convert, videosink, NULL);

   590 

   591   gst_bin_add (GST_BIN (pipeline), video_bin);

   592 

   593   pad = gst_element_get_pad (v_queue, "sink");

   594   gst_element_add_pad (video_bin, gst_ghost_pad_new ("sink", pad));

   595   gst_object_unref (pad);

   596 

   597   setup_dynamic_link (demux, NULL, gst_element_get_pad (video_bin, "sink"),

   598       NULL);

   599 

   600   seekable = gst_element_get_pad (a_decoder, "src");

   601   seekable_pads = g_list_prepend (seekable_pads, seekable);

   602   rate_pads = g_list_prepend (rate_pads, seekable);

   603   rate_pads =

   604       g_list_prepend (rate_pads, gst_element_get_pad (a_decoder, "sink"));

   605 

   606   return pipeline;

   607 }

   608 

   609 static GstElement *

   610 make_mp3_pipeline (const gchar * location)

   611 {

   612   GstElement *pipeline;

   613   GstElement *src, *decoder, *osssink, *queue;

   614   GstPad *seekable;

   615 

   616   pipeline = gst_pipeline_new ("app");

   617 

   618   src = gst_element_factory_make_or_warn (SOURCE, "src");

   619   decoder = gst_element_factory_make_or_warn ("mad", "dec");

   620   queue = gst_element_factory_make_or_warn ("queue", "queue");

   621   osssink = gst_element_factory_make_or_warn (ASINK, "sink");

   622 

   623   seekable_elements = g_list_prepend (seekable_elements, osssink);

   624 

   625   g_object_set (G_OBJECT (src), "location", location, NULL);

   626   //g_object_set (G_OBJECT (osssink), "fragment", 0x00180008, NULL);

   627 

   628   gst_bin_add (GST_BIN (pipeline), src);

   629   gst_bin_add (GST_BIN (pipeline), decoder);

   630   gst_bin_add (GST_BIN (pipeline), queue);

   631   gst_bin_add (GST_BIN (pipeline), osssink);

   632 

   633   gst_element_link (src, decoder);

   634   gst_element_link (decoder, queue);

   635   gst_element_link (queue, osssink);

   636 

   637   seekable = gst_element_get_pad (queue, "src");

   638   seekable_pads = g_list_prepend (seekable_pads, seekable);

   639   rate_pads = g_list_prepend (rate_pads, seekable);

   640   rate_pads = g_list_prepend (rate_pads, gst_element_get_pad (decoder, "sink"));

   641 

   642   return pipeline;

   643 }

   644 

   645 static GstElement *

   646 make_avi_pipeline (const gchar * location)

   647 {

   648   GstElement *pipeline, *audio_bin, *video_bin;

   649   GstElement *src, *demux, *a_decoder, *v_decoder, *audiosink, *videosink;

   650   GstElement *a_queue = NULL, *v_queue = NULL;

   651   GstPad *seekable;

   652 

   653   pipeline = gst_pipeline_new ("app");

   654 

   655   src = gst_element_factory_make_or_warn (SOURCE, "src");

   656   g_object_set (G_OBJECT (src), "location", location, NULL);

   657 

   658   demux = gst_element_factory_make_or_warn ("avidemux", "demux");

   659   seekable_elements = g_list_prepend (seekable_elements, demux);

   660 

   661   gst_bin_add (GST_BIN (pipeline), src);

   662   gst_bin_add (GST_BIN (pipeline), demux);

   663   gst_element_link (src, demux);

   664 

   665   audio_bin = gst_bin_new ("a_decoder_bin");

   666   a_decoder = gst_element_factory_make_or_warn ("mad", "a_dec");

   667   audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

   668   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   669   gst_element_link (a_decoder, a_queue);

   670   gst_element_link (a_queue, audiosink);

   671   gst_bin_add (GST_BIN (audio_bin), a_decoder);

   672   gst_bin_add (GST_BIN (audio_bin), a_queue);

   673   gst_bin_add (GST_BIN (audio_bin), audiosink);

   674   gst_element_set_state (audio_bin, GST_STATE_PAUSED);

   675 

   676   setup_dynamic_link (demux, "audio_00", gst_element_get_pad (a_decoder,

   677           "sink"), audio_bin);

   678 

   679   seekable = gst_element_get_pad (a_queue, "src");

   680   seekable_pads = g_list_prepend (seekable_pads, seekable);

   681   rate_pads = g_list_prepend (rate_pads, seekable);

   682   rate_pads =

   683       g_list_prepend (rate_pads, gst_element_get_pad (a_decoder, "sink"));

   684 

   685   video_bin = gst_bin_new ("v_decoder_bin");

   686   v_decoder = gst_element_factory_make_or_warn ("ffmpegdecall", "v_dec");

   687   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   688   v_queue = gst_element_factory_make_or_warn ("queue", "v_queue");

   689   gst_element_link (v_decoder, v_queue);

   690   gst_element_link (v_queue, videosink);

   691   gst_bin_add (GST_BIN (video_bin), v_decoder);

   692   gst_bin_add (GST_BIN (video_bin), v_queue);

   693   gst_bin_add (GST_BIN (video_bin), videosink);

   694 

   695   gst_element_set_state (video_bin, GST_STATE_PAUSED);

   696 

   697   setup_dynamic_link (demux, "video_00", gst_element_get_pad (v_decoder,

   698           "sink"), video_bin);

   699 

   700   seekable = gst_element_get_pad (v_queue, "src");

   701   seekable_pads = g_list_prepend (seekable_pads, seekable);

   702   rate_pads = g_list_prepend (rate_pads, seekable);

   703   rate_pads =

   704       g_list_prepend (rate_pads, gst_element_get_pad (v_decoder, "sink"));

   705 

   706   return pipeline;

   707 }

   708 

   709 static GstElement *

   710 make_mpeg_pipeline (const gchar * location)

   711 {

   712   GstElement *pipeline, *audio_bin, *video_bin;

   713   GstElement *src, *demux, *a_decoder, *v_decoder, *v_filter;

   714   GstElement *audiosink, *videosink;

   715   GstElement *a_queue, *v_queue;

   716   GstPad *seekable;

   717   GstPad *pad;

   718 

   719   pipeline = gst_pipeline_new ("app");

   720 

   721   src = gst_element_factory_make_or_warn (SOURCE, "src");

   722   g_object_set (G_OBJECT (src), "location", location, NULL);

   723 

   724   //demux = gst_element_factory_make_or_warn ("mpegdemux", "demux");

   725   demux = gst_element_factory_make_or_warn ("flupsdemux", "demux");

   726 

   727   gst_bin_add (GST_BIN (pipeline), src);

   728   gst_bin_add (GST_BIN (pipeline), demux);

   729   gst_element_link (src, demux);

   730 

   731   audio_bin = gst_bin_new ("a_decoder_bin");

   732   a_decoder = gst_element_factory_make_or_warn ("mad", "a_dec");

   733   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   734   audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

   735   gst_bin_add (GST_BIN (audio_bin), a_decoder);

   736   gst_bin_add (GST_BIN (audio_bin), a_queue);

   737   gst_bin_add (GST_BIN (audio_bin), audiosink);

   738 

   739   gst_element_link (a_decoder, a_queue);

   740   gst_element_link (a_queue, audiosink);

   741 

   742   gst_bin_add (GST_BIN (pipeline), audio_bin);

   743 

   744   pad = gst_element_get_pad (a_decoder, "sink");

   745   gst_element_add_pad (audio_bin, gst_ghost_pad_new ("sink", pad));

   746   gst_object_unref (pad);

   747 

   748   setup_dynamic_link (demux, "audio_c0", gst_element_get_pad (audio_bin,

   749           "sink"), NULL);

   750 

   751   video_bin = gst_bin_new ("v_decoder_bin");

   752   v_decoder = gst_element_factory_make_or_warn ("mpeg2dec", "v_dec");

   753   v_queue = gst_element_factory_make_or_warn ("queue", "v_queue");

   754   v_filter = gst_element_factory_make_or_warn ("ffmpegcolorspace", "v_filter");

   755   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   756 

   757   gst_bin_add (GST_BIN (video_bin), v_decoder);

   758   gst_bin_add (GST_BIN (video_bin), v_queue);

   759   gst_bin_add (GST_BIN (video_bin), v_filter);

   760   gst_bin_add (GST_BIN (video_bin), videosink);

   761 

   762   gst_element_link (v_decoder, v_queue);

   763   gst_element_link (v_queue, v_filter);

   764   gst_element_link (v_filter, videosink);

   765 

   766   gst_bin_add (GST_BIN (pipeline), video_bin);

   767 

   768   pad = gst_element_get_pad (v_decoder, "sink");

   769   gst_element_add_pad (video_bin, gst_ghost_pad_new ("sink", pad));

   770   gst_object_unref (pad);

   771 

   772   setup_dynamic_link (demux, "video_e0", gst_element_get_pad (video_bin,

   773           "sink"), NULL);

   774 

   775   seekable = gst_element_get_pad (v_filter, "src");

   776   seekable_pads = g_list_prepend (seekable_pads, seekable);

   777   rate_pads = g_list_prepend (rate_pads, seekable);

   778   rate_pads =

   779       g_list_prepend (rate_pads, gst_element_get_pad (v_decoder, "sink"));

   780 

   781   return pipeline;

   782 }

   783 

   784 static GstElement *

   785 make_mpegnt_pipeline (const gchar * location)

   786 {

   787   GstElement *pipeline, *audio_bin, *video_bin;

   788   GstElement *src, *demux, *a_decoder, *v_decoder, *v_filter;

   789   GstElement *audiosink, *videosink;

   790   GstElement *a_queue;

   791   GstPad *seekable;

   792 

   793   pipeline = gst_pipeline_new ("app");

   794 

   795   src = gst_element_factory_make_or_warn (SOURCE, "src");

   796   g_object_set (G_OBJECT (src), "location", location, NULL);

   797 

   798   demux = gst_element_factory_make_or_warn ("mpegdemux", "demux");

   799   //g_object_set (G_OBJECT (demux), "sync", TRUE, NULL);

   800 

   801   seekable_elements = g_list_prepend (seekable_elements, demux);

   802 

   803   gst_bin_add (GST_BIN (pipeline), src);

   804   gst_bin_add (GST_BIN (pipeline), demux);

   805   gst_element_link (src, demux);

   806 

   807   audio_bin = gst_bin_new ("a_decoder_bin");

   808   a_decoder = gst_element_factory_make_or_warn ("mad", "a_dec");

   809   a_queue = gst_element_factory_make_or_warn ("queue", "a_queue");

   810   audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

   811   //g_object_set (G_OBJECT (audiosink), "fragment", 0x00180008, NULL);

   812   g_object_set (G_OBJECT (audiosink), "sync", FALSE, NULL);

   813   gst_element_link (a_decoder, a_queue);

   814   gst_element_link (a_queue, audiosink);

   815   gst_bin_add (GST_BIN (audio_bin), a_decoder);

   816   gst_bin_add (GST_BIN (audio_bin), a_queue);

   817   gst_bin_add (GST_BIN (audio_bin), audiosink);

   818 

   819   setup_dynamic_link (demux, "audio_00", gst_element_get_pad (a_decoder,

   820           "sink"), audio_bin);

   821 

   822   seekable = gst_element_get_pad (a_queue, "src");

   823   seekable_pads = g_list_prepend (seekable_pads, seekable);

   824   rate_pads = g_list_prepend (rate_pads, seekable);

   825   rate_pads =

   826       g_list_prepend (rate_pads, gst_element_get_pad (a_decoder, "sink"));

   827 

   828   video_bin = gst_bin_new ("v_decoder_bin");

   829   v_decoder = gst_element_factory_make_or_warn ("mpeg2dec", "v_dec");

   830   v_filter = gst_element_factory_make_or_warn ("ffmpegcolorspace", "v_filter");

   831   videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

   832   gst_element_link_many (v_decoder, v_filter, videosink, NULL);

   833 

   834   gst_bin_add_many (GST_BIN (video_bin), v_decoder, v_filter, videosink, NULL);

   835 

   836   setup_dynamic_link (demux, "video_00", gst_element_get_pad (v_decoder,

   837           "sink"), video_bin);

   838 

   839   seekable = gst_element_get_pad (v_decoder, "src");

   840   seekable_pads = g_list_prepend (seekable_pads, seekable);

   841   rate_pads = g_list_prepend (rate_pads, seekable);

   842   rate_pads =

   843       g_list_prepend (rate_pads, gst_element_get_pad (v_decoder, "sink"));

   844 

   845   return pipeline;

   846 }

   847 

   848 static GstElement *

   849 make_playerbin_pipeline (const gchar * location)

   850 {

   851   GstElement *player;

   852 

   853   player = gst_element_factory_make ("playbin", "player");

   854   g_assert (player);

   855 

   856   g_object_set (G_OBJECT (player), "uri", location, NULL);

   857 

   858   seekable_elements = g_list_prepend (seekable_elements, player);

   859 

   860   /* force element seeking on this pipeline */

   861   elem_seek = TRUE;

   862 

   863   return player;

   864 }

   865 

   866 static GstElement *

   867 make_playerbin2_pipeline (const gchar * location)

   868 {

   869   GstElement *player;

   870 

   871   player = gst_element_factory_make ("playbin2", "player");

   872   g_assert (player);

   873 

   874   g_object_set (G_OBJECT (player), "uri", location, NULL);

   875 

   876   seekable_elements = g_list_prepend (seekable_elements, player);

   877 

   878   /* force element seeking on this pipeline */

   879   elem_seek = TRUE;

   880 

   881   return player;

   882 }

   883 

   884 #ifndef GST_DISABLE_PARSE

   885 static GstElement *

   886 make_parselaunch_pipeline (const gchar * description)

   887 {

   888   GstElement *pipeline;

   889   GError *error;

   890 

   891   pipeline = gst_parse_launch (description, &error);

   892 

   893   seekable_elements = g_list_prepend (seekable_elements, pipeline);

   894 

   895   elem_seek = TRUE;

   896 

   897   return pipeline;

   898 }

   899 #endif

   900 

   901 typedef struct

   902 {

   903   gchar *name;

   904   GstElement *(*func) (const gchar * location);

   905 }

   906 Pipeline;

   907 

   908 static Pipeline pipelines[] = {

   909   {"mp3", make_mp3_pipeline},

   910   {"avi", make_avi_pipeline},

   911   {"mpeg1", make_mpeg_pipeline},

   912   {"mpegparse", make_parse_pipeline},

   913   {"vorbis", make_vorbis_pipeline},

   914   {"theora", make_theora_pipeline},

   915   {"ogg/v/t", make_vorbis_theora_pipeline},

   916   {"avi/msmpeg4v3/mp3", make_avi_msmpeg4v3_mp3_pipeline},

   917   {"sid", make_sid_pipeline},

   918   {"flac", make_flac_pipeline},

   919   {"wav", make_wav_pipeline},

   920   {"mod", make_mod_pipeline},

   921   {"dv", make_dv_pipeline},

   922   {"mpeg1nothreads", make_mpegnt_pipeline},

   923   {"playerbin", make_playerbin_pipeline},

   924 #ifndef GST_DISABLE_PARSE

   925   {"parse-launch", make_parselaunch_pipeline},

   926 #endif

   927   {"playerbin2", make_playerbin2_pipeline},

   928   {NULL, NULL},

   929 };

   930 

   931 #define NUM_TYPES       ((sizeof (pipelines) / sizeof (Pipeline)) - 1)

   932 

   933 /* ui callbacks and helpers */

   934 

   935 static gchar *

   936 format_value (GtkScale * scale, gdouble value)

   937 {

   938   gint64 real;

   939   gint64 seconds;

   940   gint64 subseconds;

   941 

   942   real = value * duration / 100;

   943   seconds = (gint64) real / GST_SECOND;

   944   subseconds = (gint64) real / (GST_SECOND / 100);

   945 

   946   return g_strdup_printf ("%02" G_GINT64_FORMAT ":%02" G_GINT64_FORMAT ":%02"

   947       G_GINT64_FORMAT, seconds / 60, seconds % 60, subseconds % 100);

   948 }

   949 

   950 typedef struct

   951 {

   952   const gchar *name;

   953   const GstFormat format;

   954 }

   955 seek_format;

   956 

   957 static seek_format seek_formats[] = {

   958   {"tim", GST_FORMAT_TIME},

   959   {"byt", GST_FORMAT_BYTES},

   960   {"buf", GST_FORMAT_BUFFERS},

   961   {"def", GST_FORMAT_DEFAULT},

   962   {NULL, 0},

   963 };

   964 

   965 G_GNUC_UNUSED static void

   966 query_rates (void)

   967 {

   968   GList *walk = rate_pads;

   969 

   970   while (walk) {

   971     GstPad *pad = GST_PAD (walk->data);

   972     gint i = 0;

   973 

   974     g_print ("rate/sec  %8.8s: ", GST_PAD_NAME (pad));

   975     while (seek_formats[i].name) {

   976       gint64 value;

   977       GstFormat format;

   978 

   979       format = seek_formats[i].format;

   980 

   981       if (gst_pad_query_convert (pad, GST_FORMAT_TIME, GST_SECOND, &format,

   982               &value)) {

   983         g_print ("%s %13" G_GINT64_FORMAT " | ", seek_formats[i].name, value);

   984       } else {

   985         g_print ("%s %13.13s | ", seek_formats[i].name, "*NA*");

   986       }

   987 

   988       i++;

   989     }

   990     g_print (" %s:%s\n", GST_DEBUG_PAD_NAME (pad));

   991 

   992     walk = g_list_next (walk);

   993   }

   994 }

   995 

   996 G_GNUC_UNUSED static void

   997 query_positions_elems (void)

   998 {

   999   GList *walk = seekable_elements;

  1000 

  1001   while (walk) {

  1002     GstElement *element = GST_ELEMENT (walk->data);

  1003     gint i = 0;

  1004 

  1005     g_print ("positions %8.8s: ", GST_ELEMENT_NAME (element));

  1006     while (seek_formats[i].name) {

  1007       gint64 position, total;

  1008       GstFormat format;

  1009 

  1010       format = seek_formats[i].format;

  1011 

  1012       if (gst_element_query_position (element, &format, &position) &&

  1013           gst_element_query_duration (element, &format, &total)) {

  1014         g_print ("%s %13" G_GINT64_FORMAT " / %13" G_GINT64_FORMAT " | ",

  1015             seek_formats[i].name, position, total);

  1016       } else {

  1017         g_print ("%s %13.13s / %13.13s | ", seek_formats[i].name, "*NA*",

  1018             "*NA*");

  1019       }

  1020       i++;

  1021     }

  1022     g_print (" %s\n", GST_ELEMENT_NAME (element));

  1023 

  1024     walk = g_list_next (walk);

  1025   }

  1026 }

  1027 

  1028 G_GNUC_UNUSED static void

  1029 query_positions_pads (void)

  1030 {

  1031   GList *walk = seekable_pads;

  1032 

  1033   while (walk) {

  1034     GstPad *pad = GST_PAD (walk->data);

  1035     gint i = 0;

  1036 

  1037     g_print ("positions %8.8s: ", GST_PAD_NAME (pad));

  1038     while (seek_formats[i].name) {

  1039       GstFormat format;

  1040       gint64 position, total;

  1041 

  1042       format = seek_formats[i].format;

  1043 

  1044       if (gst_pad_query_position (pad, &format, &position) &&

  1045           gst_pad_query_duration (pad, &format, &total)) {

  1046         g_print ("%s %13" G_GINT64_FORMAT " / %13" G_GINT64_FORMAT " | ",

  1047             seek_formats[i].name, position, total);

  1048       } else {

  1049         g_print ("%s %13.13s / %13.13s | ", seek_formats[i].name, "*NA*",

  1050             "*NA*");

  1051       }

  1052 

  1053       i++;

  1054     }

  1055     g_print (" %s:%s\n", GST_DEBUG_PAD_NAME (pad));

  1056 

  1057     walk = g_list_next (walk);

  1058   }

  1059 }

  1060 

  1061 static gboolean start_seek (GtkWidget * widget, GdkEventButton * event,

  1062     gpointer user_data);

  1063 static gboolean stop_seek (GtkWidget * widget, GdkEventButton * event,

  1064     gpointer user_data);

  1065 static void seek_cb (GtkWidget * widget);

  1066 

  1067 static void

  1068 set_scale (gdouble value)

  1069 {

  1070   g_signal_handlers_block_by_func (hscale, (void *) start_seek,

  1071       (void *) pipeline);

  1072   g_signal_handlers_block_by_func (hscale, (void *) stop_seek,

  1073       (void *) pipeline);

  1074   g_signal_handlers_block_by_func (hscale, (void *) seek_cb, (void *) pipeline);

  1075   gtk_adjustment_set_value (adjustment, value);

  1076   g_signal_handlers_unblock_by_func (hscale, (void *) start_seek,

  1077       (void *) pipeline);

  1078   g_signal_handlers_unblock_by_func (hscale, (void *) stop_seek,

  1079       (void *) pipeline);

  1080   g_signal_handlers_unblock_by_func (hscale, (void *) seek_cb,

  1081       (void *) pipeline);

  1082   gtk_widget_queue_draw (hscale);

  1083 }

  1084 

  1085 static gboolean

  1086 update_scale (gpointer data)

  1087 {

  1088   GstFormat format = GST_FORMAT_TIME;

  1089 

  1090   //position = 0;

  1091   //duration = 0;

  1092 

  1093   if (elem_seek) {

  1094     if (seekable_elements) {

  1095       GstElement *element = GST_ELEMENT (seekable_elements->data);

  1096 

  1097       gst_element_query_position (element, &format, &position);

  1098       gst_element_query_duration (element, &format, &duration);

  1099     }

  1100   } else {

  1101     if (seekable_pads) {

  1102       GstPad *pad = GST_PAD (seekable_pads->data);

  1103 

  1104       gst_pad_query_position (pad, &format, &position);

  1105       gst_pad_query_duration (pad, &format, &duration);

  1106     }

  1107   }

  1108 

  1109   if (stats) {

  1110     if (elem_seek) {

  1111       query_positions_elems ();

  1112     } else {

  1113       query_positions_pads ();

  1114     }

  1115     query_rates ();

  1116   }

  1117   if (position >= duration)

  1118     duration = position;

  1119 

  1120   if (duration > 0) {

  1121     set_scale (position * 100.0 / duration);

  1122   }

  1123 

  1124   return TRUE;

  1125 }

  1126 

  1127 static void do_seek (GtkWidget * widget);

  1128 static void connect_bus_signals (GstElement * pipeline);

  1129 static void set_update_scale (gboolean active);

  1130 

  1131 static gboolean

  1132 end_scrub (GtkWidget * widget)

  1133 {

  1134   GST_DEBUG ("end scrub, PAUSE");