/* GStreamer

 *

 * seek.c: seeking sample application

 *

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

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

 *

 * 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 <glib.h>

#include <glib/gstdio.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <math.h>

#include <gtk/gtk.h>

#include <gst/gst.h>

#include <string.h>

#include <linux/input.h>

#include <linux/joystick.h>

#ifdef HAVE_X

#include <gdk/gdkx.h>

#endif

#include <gst/video/videooverlay.h>

GST_DEBUG_CATEGORY_STATIC (seek_debug);

#define GST_CAT_DEFAULT (seek_debug)

/* configuration */

#define SOURCE "filesrc"

#define ASINK "alsasink"

//#define ASINK "osssink"

#define VSINK "xvimagesink"

//#define VSINK "sdlvideosink"

//#define VSINK "ximagesink"

//#define VSINK "aasink"

//#define VSINK "cacasink"

#define FILL_INTERVAL 100

//#define UPDATE_INTERVAL 500

//#define UPDATE_INTERVAL 100

//#define UPDATE_INTERVAL 10

#define UPDATE_INTERVAL 40

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

#define SCRUB_TIME 100

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

#define SEEK_TIMEOUT 40 * GST_MSECOND

#define DEFAULT_VIDEO_HEIGHT 300

/* the state to go to when stop is pressed */

#define STOP_STATE      GST_STATE_READY

static GList *seekable_pads = NULL;

static GList *rate_pads = NULL;

static GList *seekable_elements = NULL;

static gboolean accurate_seek = FALSE;

static gboolean keyframe_seek = FALSE;

static gboolean loop_seek = FALSE;

static gboolean flush_seek = TRUE;

static gboolean scrub = TRUE;

static gboolean play_scrub = FALSE;

static gboolean skip_seek = FALSE;

static gdouble rate = 1.0;

static GstElement *pipeline;

static gint pipeline_type;

static const gchar *pipeline_spec;

static gint64 position = -1;

static gint64 duration = -1;

static GtkAdjustment *adjustment;

static GtkWidget *hscale, *statusbar;

static guint status_id = 0;

static gboolean stats = FALSE;

static gboolean elem_seek = FALSE;

static gboolean verbose = FALSE;

static gchar *js_device = NULL;

static gboolean is_live = FALSE;

static gboolean buffering = FALSE;

static GstBufferingMode mode;

static gint64 buffering_left;

static GstState state = GST_STATE_NULL;

static guint update_id = 0;

static guint seek_timeout_id = 0;

static gulong changed_id;

static guint fill_id = 0;

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

static gboolean need_streams = TRUE;

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

static GtkWidget *vis_checkbox, *video_checkbox, *audio_checkbox;

static GtkWidget *text_checkbox, *mute_checkbox, *volume_spinbutton;

static GtkWidget *skip_checkbox, *video_window, *download_checkbox;

static GtkWidget *buffer_checkbox, *rate_spinbutton;

static GMutex state_mutex;

static GtkWidget *format_combo, *step_amount_spinbutton, *step_rate_spinbutton;

static GtkWidget *shuttle_checkbox, *step_button;

static GtkWidget *shuttle_hscale;

static GtkAdjustment *shuttle_adjustment;

static GList *paths = NULL, *l = NULL;

gint js_fd;

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

 * with the combo box index. */

typedef struct

{

  GstElementFactory *factory;

} VisEntry;

static GArray *vis_entries;

static void clear_streams (GstElement * pipeline);

static void volume_notify_cb (GstElement * pipeline, GParamSpec * arg,

    gpointer user_dat);

/* pipeline construction */

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 void

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

{

  gchar *padname;

  dyn_link *connect = (dyn_link *) data;

  padname = gst_pad_get_name (newpad);

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

    if (connect->bin)

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

    gst_pad_link (newpad, connect->target);

    //seekable_pads = g_list_prepend (seekable_pads, newpad);

    rate_pads = g_list_prepend (rate_pads, newpad);

  }

  g_free (padname);

}

static void

setup_dynamic_link (GstElement * element, const gchar * padname,

    GstPad * target, GstElement * bin)

{

  dyn_link *connect;

  connect = g_new0 (dyn_link, 1);

  connect->padname = g_strdup (padname);

  connect->target = target;

  connect->bin = bin;

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

      connect);

}

static GstElement *

make_mod_pipeline (const gchar * location)

{

  GstElement *pipeline;

  GstElement *src, *decoder, *audiosink;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_element_link (src, decoder);

  gst_element_link (decoder, audiosink);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_dv_pipeline (const gchar * location)

{

  GstElement *pipeline;

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

  GstElement *a_queue, *v_queue;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

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

  videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

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

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_bin_add (GST_BIN (pipeline), a_queue);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_bin_add (GST_BIN (pipeline), v_queue);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), videosink);

  gst_element_link (src, demux);

  gst_element_link (a_queue, audiosink);

  gst_element_link (v_queue, decoder);

  gst_element_link (decoder, videosink);

  setup_dynamic_link (demux, "video", gst_element_get_static_pad (v_queue,

          "sink"), NULL);

  setup_dynamic_link (demux, "audio", gst_element_get_static_pad (a_queue,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  return pipeline;

}

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 (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_element_link (src, decoder);

  setup_dynamic_link (decoder, "src", gst_element_get_static_pad (audiosink,

          "sink"), NULL);

  seekable_elements = g_list_prepend (seekable_elements, audiosink);

  /* force element seeking on this pipeline */

  elem_seek = TRUE;

  return pipeline;

}

static GstElement *

make_flac_pipeline (const gchar * location)

{

  GstElement *pipeline;

  GstElement *src, *decoder, *audiosink;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_element_link (src, decoder);

  gst_element_link (decoder, audiosink);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_sid_pipeline (const gchar * location)

{

  GstElement *pipeline;

  GstElement *src, *decoder, *audiosink;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_element_link (src, decoder);

  gst_element_link (decoder, audiosink);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_parse_pipeline (const gchar * location)

{

  GstElement *pipeline;

  GstElement *src, *parser, *fakesink;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

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

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), parser);

  gst_bin_add (GST_BIN (pipeline), fakesink);

  gst_element_link (src, parser);

  gst_element_link (parser, fakesink);

  seekable = gst_element_get_static_pad (parser, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (parser, "sink"));

  return pipeline;

}

static GstElement *

make_vorbis_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin;

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

  GstPad *pad, *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

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

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

  audio_bin = gst_bin_new ("a_decoder_bin");

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_bin_add (GST_BIN (audio_bin), decoder);

  gst_bin_add (GST_BIN (audio_bin), convert);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  gst_bin_add (GST_BIN (pipeline), audio_bin);

  gst_element_link (src, demux);

  gst_element_link (decoder, convert);

  gst_element_link (convert, audiosink);

  pad = gst_element_get_static_pad (decoder, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (audio_bin,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_theora_pipeline (const gchar * location)

{

  GstElement *pipeline, *video_bin;

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

  GstPad *pad, *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

  convert = gst_element_factory_make_or_warn ("videoconvert", "convert");

  videosink = gst_element_factory_make_or_warn (VSINK, "sink");

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

  video_bin = gst_bin_new ("v_decoder_bin");

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_bin_add (GST_BIN (video_bin), decoder);

  gst_bin_add (GST_BIN (video_bin), convert);

  gst_bin_add (GST_BIN (video_bin), videosink);

  gst_bin_add (GST_BIN (pipeline), video_bin);

  gst_element_link (src, demux);

  gst_element_link (decoder, convert);

  gst_element_link (convert, videosink);

  pad = gst_element_get_static_pad (decoder, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (video_bin,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_vorbis_theora_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin, *video_bin;

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

  GstElement *audiosink, *videosink;

  GstElement *a_queue, *v_queue, *v_scale;

  GstPad *seekable;

  GstPad *pad;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_element_link (src, demux);

  audio_bin = gst_bin_new ("a_decoder_bin");

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

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

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

  gst_bin_add (GST_BIN (pipeline), audio_bin);

  gst_bin_add (GST_BIN (audio_bin), a_queue);

  gst_bin_add (GST_BIN (audio_bin), a_decoder);

  gst_bin_add (GST_BIN (audio_bin), a_convert);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  gst_element_link (a_queue, a_decoder);

  gst_element_link (a_decoder, a_convert);

  gst_element_link (a_convert, audiosink);

  pad = gst_element_get_static_pad (a_queue, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (audio_bin,

          "sink"), NULL);

  video_bin = gst_bin_new ("v_decoder_bin");

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

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

  v_convert = gst_element_factory_make_or_warn ("videoconvert", "v_convert");

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

  videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

  gst_bin_add (GST_BIN (pipeline), video_bin);

  gst_bin_add (GST_BIN (video_bin), v_queue);

  gst_bin_add (GST_BIN (video_bin), v_decoder);

  gst_bin_add (GST_BIN (video_bin), v_convert);

  gst_bin_add (GST_BIN (video_bin), v_scale);

  gst_bin_add (GST_BIN (video_bin), videosink);

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

      NULL);

  pad = gst_element_get_static_pad (v_queue, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (video_bin,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (a_decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (a_decoder,

          "sink"));

  return pipeline;

}

static GstElement *

make_avi_msmpeg4v3_mp3_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin, *video_bin;

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

  GstElement *audiosink, *videosink;

  GstElement *a_queue, *v_queue;

  GstPad *seekable, *pad;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_element_link (src, demux);

  audio_bin = gst_bin_new ("a_decoder_bin");

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

  a_decoder = gst_element_factory_make_or_warn ("mpg123audiodec", "a_dec");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

  gst_bin_add (GST_BIN (audio_bin), a_queue);

  gst_bin_add (GST_BIN (audio_bin), a_decoder);

  gst_bin_add (GST_BIN (audio_bin), a_convert);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  gst_element_link (a_queue, a_decoder);

  gst_element_link (a_decoder, a_convert);

  gst_element_link (a_convert, audiosink);

  gst_bin_add (GST_BIN (pipeline), audio_bin);

  pad = gst_element_get_static_pad (a_queue, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (audio_bin,

          "sink"), NULL);

  video_bin = gst_bin_new ("v_decoder_bin");

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

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

  v_convert = gst_element_factory_make_or_warn ("videoconvert", "v_convert");

  videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

  gst_bin_add (GST_BIN (video_bin), v_queue);

  gst_bin_add (GST_BIN (video_bin), v_decoder);

  gst_bin_add (GST_BIN (video_bin), v_convert);

  gst_bin_add (GST_BIN (video_bin), videosink);

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

  gst_bin_add (GST_BIN (pipeline), video_bin);

  pad = gst_element_get_static_pad (v_queue, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, NULL, gst_element_get_static_pad (video_bin,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (a_decoder, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (a_decoder,

          "sink"));

  return pipeline;

}

static GstElement *

make_mp3_pipeline (const gchar * location)

{

  GstElement *pipeline;

  GstElement *src, *parser, *decoder, *audiosink, *queue;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

  parser = gst_element_factory_make_or_warn ("mpegaudioparse", "parse");

  decoder = gst_element_factory_make_or_warn ("mpg123audiodec", "dec");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "sink");

  seekable_elements = g_list_prepend (seekable_elements, audiosink);

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), parser);

  gst_bin_add (GST_BIN (pipeline), decoder);

  gst_bin_add (GST_BIN (pipeline), queue);

  gst_bin_add (GST_BIN (pipeline), audiosink);

  gst_element_link (src, parser);

  gst_element_link (parser, decoder);

  gst_element_link (decoder, queue);

  gst_element_link (queue, audiosink);

  seekable = gst_element_get_static_pad (queue, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (decoder, "sink"));

  return pipeline;

}

static GstElement *

make_avi_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin, *video_bin;

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

  GstElement *a_queue = NULL, *v_queue = NULL;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

  seekable_elements = g_list_prepend (seekable_elements, demux);

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_element_link (src, demux);

  audio_bin = gst_bin_new ("a_decoder_bin");

  a_decoder = gst_element_factory_make_or_warn ("mpg123audiodec", "a_dec");

  audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

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

  gst_element_link (a_decoder, a_queue);

  gst_element_link (a_queue, audiosink);

  gst_bin_add (GST_BIN (audio_bin), a_decoder);

  gst_bin_add (GST_BIN (audio_bin), a_queue);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  gst_element_set_state (audio_bin, GST_STATE_PAUSED);

  setup_dynamic_link (demux, "audio_00", gst_element_get_static_pad (a_decoder,

          "sink"), audio_bin);

  seekable = gst_element_get_static_pad (a_queue, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (a_decoder,

          "sink"));

  video_bin = gst_bin_new ("v_decoder_bin");

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

  videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

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

  gst_element_link (v_decoder, v_queue);

  gst_element_link (v_queue, videosink);

  gst_bin_add (GST_BIN (video_bin), v_decoder);

  gst_bin_add (GST_BIN (video_bin), v_queue);

  gst_bin_add (GST_BIN (video_bin), videosink);

  gst_element_set_state (video_bin, GST_STATE_PAUSED);

  setup_dynamic_link (demux, "video_00", gst_element_get_static_pad (v_decoder,

          "sink"), video_bin);

  seekable = gst_element_get_static_pad (v_queue, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (v_decoder,

          "sink"));

  return pipeline;

}

static GstElement *

make_mpeg_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin, *video_bin;

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

  GstElement *audiosink, *videosink;

  GstElement *a_queue, *v_queue;

  GstPad *seekable;

  GstPad *pad;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_element_link (src, demux);

  audio_bin = gst_bin_new ("a_decoder_bin");

  a_decoder = gst_element_factory_make_or_warn ("mpg123audiodec", "a_dec");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

  gst_bin_add (GST_BIN (audio_bin), a_decoder);

  gst_bin_add (GST_BIN (audio_bin), a_queue);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  gst_element_link (a_decoder, a_queue);

  gst_element_link (a_queue, audiosink);

  gst_bin_add (GST_BIN (pipeline), audio_bin);

  pad = gst_element_get_static_pad (a_decoder, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, "audio_c0", gst_element_get_static_pad (audio_bin,

          "sink"), NULL);

  video_bin = gst_bin_new ("v_decoder_bin");

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

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

  v_filter = gst_element_factory_make_or_warn ("videoconvert", "v_filter");

  videosink = gst_element_factory_make_or_warn (VSINK, "v_sink");

  gst_bin_add (GST_BIN (video_bin), v_decoder);

  gst_bin_add (GST_BIN (video_bin), v_queue);

  gst_bin_add (GST_BIN (video_bin), v_filter);

  gst_bin_add (GST_BIN (video_bin), videosink);

  gst_element_link (v_decoder, v_queue);

  gst_element_link (v_queue, v_filter);

  gst_element_link (v_filter, videosink);

  gst_bin_add (GST_BIN (pipeline), video_bin);

  pad = gst_element_get_static_pad (v_decoder, "sink");

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

  gst_object_unref (pad);

  setup_dynamic_link (demux, "video_e0", gst_element_get_static_pad (video_bin,

          "sink"), NULL);

  seekable = gst_element_get_static_pad (v_filter, "src");

  seekable_pads = g_list_prepend (seekable_pads, seekable);

  rate_pads = g_list_prepend (rate_pads, seekable);

  rate_pads =

      g_list_prepend (rate_pads, gst_element_get_static_pad (v_decoder,

          "sink"));

  return pipeline;

}

static GstElement *

make_mpegnt_pipeline (const gchar * location)

{

  GstElement *pipeline, *audio_bin, *video_bin;

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

  GstElement *audiosink, *videosink;

  GstElement *a_queue;

  GstPad *seekable;

  pipeline = gst_pipeline_new ("app");

  src = gst_element_factory_make_or_warn (SOURCE, "src");

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

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

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

  seekable_elements = g_list_prepend (seekable_elements, demux);

  gst_bin_add (GST_BIN (pipeline), src);

  gst_bin_add (GST_BIN (pipeline), demux);

  gst_element_link (src, demux);

  audio_bin = gst_bin_new ("a_decoder_bin");

  a_decoder = gst_element_factory_make_or_warn ("mpg123audiodec", "a_dec");

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

  audiosink = gst_element_factory_make_or_warn (ASINK, "a_sink");

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

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

  gst_element_link (a_decoder, a_queue);

  gst_element_link (a_queue, audiosink);

  gst_bin_add (GST_BIN (audio_bin), a_decoder);

  gst_bin_add (GST_BIN (audio_bin), a_queue);

  gst_bin_add (GST_BIN (audio_bin), audiosink);

  setup_dynamic_link (demux, "audio_00", gst_element_get_static_pad (a_decoder,

          "sink"), audio_bin);