gstreamer/gst-libs/gst/play/play.c

/* GStreamer
 * Copyright (C) 2003 Julien Moutte <julien@moutte.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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>

#include "gstplay.h"

enum
{
  TIME_TICK,
  STREAM_LENGTH,
  HAVE_VIDEO_SIZE,
  LAST_SIGNAL
};

struct _GstPlayPrivate {  
  char *location;
  
  GHashTable *elements;
  
  gint64 time_nanos;
  gint64 length_nanos;
  
  gint get_length_attempt;
  
  guint tick_id;
  guint length_id;
};

static guint gst_play_signals[LAST_SIGNAL] = { 0 };

static GstPipelineClass *parent_class = NULL;

/* ======================================================= */
/*                                                         */
/*                    Private Methods                      */
/*                                                         */
/* ======================================================= */

static gboolean
gst_play_pipeline_setup (GstPlay *play)
{
  /* Threads */
  GstElement *work_thread, *audio_thread, *video_thread;
  /* Main Thread elements */
  GstElement *source, *autoplugger, *audioconvert, *volume, *tee, *vis_element;
  /* Video Thread elements */
  GstElement *video_queue, *video_cs, *video_balance, *balance_cs;
  GstElement *video_scaler, *video_sink;
  /* Audio Thread elements */
  GstElement *audio_queue, *audio_sink;
  /* Some useful pads */
  GstPad *tee_pad1, *tee_pad2;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  /* Creating main thread and its elements 
     { fakesrc ! spider ! audioconvert ! volume ! tee } */
  {
  work_thread = gst_element_factory_make ("thread", "work_thread");
  if (!GST_IS_ELEMENT (work_thread))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "work_thread", work_thread);
  gst_bin_add (GST_BIN (play), work_thread);

  /* Placeholder for datasrc */
  source = gst_element_factory_make ("fakesrc", "source");
  if (!GST_IS_ELEMENT (source))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "source", source);
  
  /* Autoplugger */
  autoplugger = gst_element_factory_make ("spider", "autoplugger");
  if (!GST_IS_ELEMENT (autoplugger))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "autoplugger", autoplugger);
  
  /* Make sure we convert audio to the needed format */
  audioconvert = gst_element_factory_make ("audioconvert",
                                           "audioconvert");
  if (!GST_IS_ELEMENT (audioconvert))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "volume", audioconvert);
  
  /* Volume control */
  volume = gst_element_factory_make ("volume", "volume");
  if (!GST_IS_ELEMENT (volume))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "audioconvert", volume);
  
  /* Duplicate audio signal to audio sink and visualization thread */
  tee = gst_element_factory_make ("tee", "tee");
  if (!GST_IS_ELEMENT (tee))
    return FALSE;
  
  tee_pad1 = gst_element_get_request_pad (tee, "src%d");
  tee_pad2 = gst_element_get_request_pad (tee, "src%d");
  g_hash_table_insert (play->priv->elements, "tee_pad1", tee_pad1);
  g_hash_table_insert (play->priv->elements, "tee_pad2", tee_pad2);
  g_hash_table_insert (play->priv->elements, "tee", tee);
  
  gst_bin_add_many (GST_BIN (work_thread), source, autoplugger,/* audioconvert,*/
                    volume, tee, NULL);
  gst_element_link_many (source, autoplugger,/* audioconvert,*/ volume, tee, NULL);
  
  /* Visualization element placeholder (note: it s not added to the pipeline
     yet) */
  vis_element = gst_element_factory_make ("identity", "vis_element");
  if (!GST_IS_ELEMENT (vis_element))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "vis_element", vis_element);
  
  }
  /* Creating our video output bin */
  {
  video_thread = gst_element_factory_make ("thread", "video_thread");
  if (!GST_IS_ELEMENT (video_thread))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "video_thread", video_thread);
  gst_bin_add (GST_BIN (work_thread), video_thread);
  
  /* Buffer queue for video data */
  video_queue = gst_element_factory_make ("queue", "video_queue");
  if (!GST_IS_ELEMENT (video_queue))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "video_queue", video_queue);
  
  /* Colorspace conversion */
  video_cs = gst_element_factory_make ("ffcolorspace", "video_cs");
  if (!GST_IS_ELEMENT (video_cs)) {
    video_cs = gst_element_factory_make ("colorspace", "video_cs");
    if (!GST_IS_ELEMENT (video_cs))
      return FALSE;
  }
  
  g_hash_table_insert (play->priv->elements, "video_cs", video_cs);
  
  /* Software colorbalance */
  video_balance = gst_element_factory_make ("videobalance",
                                            "video_balance");
  if (!GST_IS_ELEMENT (video_balance))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "video_balance",
                       video_balance);
  
  /* Colorspace conversion */
  balance_cs = gst_element_factory_make ("ffcolorspace", "balance_cs");
  if (!GST_IS_ELEMENT (balance_cs)) {
    balance_cs = gst_element_factory_make ("colorspace", "balance_cs");
    if (!GST_IS_ELEMENT (balance_cs))
      return FALSE;
  }
  
  g_hash_table_insert (play->priv->elements, "balance_cs", balance_cs);
  
  /* Software scaling of video stream */
  video_scaler = gst_element_factory_make ("videoscale", "video_scaler");
  if (!GST_IS_ELEMENT (video_scaler))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "video_scaler", video_scaler);
  
  /* Placeholder for future video sink bin */
  video_sink = gst_element_factory_make ("fakesink", "video_sink");
  if (!GST_IS_ELEMENT (video_sink))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "video_sink", video_sink);
  
  gst_bin_add_many (GST_BIN (video_thread), video_queue, video_cs,
                    video_balance, balance_cs, video_scaler, video_sink, NULL);
  gst_element_link_many (video_queue, video_cs, video_balance, balance_cs,
                         video_scaler, video_sink, NULL);
  gst_element_add_ghost_pad (video_thread,
                             gst_element_get_pad (video_queue, "sink"),
                             "sink");
  gst_element_link (autoplugger, video_thread);
  }
  /* Creating our audio output bin 
     { queue ! fakesink } */
  {
  audio_thread = gst_element_factory_make ("thread", "audio_thread");
  if (!GST_IS_ELEMENT (audio_thread))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "audio_thread", audio_thread);
  gst_bin_add (GST_BIN (work_thread), audio_thread);
  
  /* Buffer queue for our audio thread */
  audio_queue = gst_element_factory_make ("queue", "audio_queue");
  if (!GST_IS_ELEMENT (audio_queue))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "audio_queue", audio_queue);
  
  /* Placeholder for future audio sink bin */
  audio_sink = gst_element_factory_make ("fakesink", "audio_sink");
  if (!GST_IS_ELEMENT (audio_sink))
    return FALSE;
  
  g_hash_table_insert (play->priv->elements, "audio_sink", audio_sink);
  
  gst_bin_add_many (GST_BIN (audio_thread), audio_queue, audio_sink, NULL);
  gst_element_link (audio_queue, audio_sink);
  gst_element_add_ghost_pad (audio_thread,
                             gst_element_get_pad (audio_queue, "sink"),
                             "sink");
  gst_pad_link (tee_pad2, gst_element_get_pad (audio_queue, "sink"));
  }
  
  return TRUE;
}

static void
gst_play_have_video_size (GstElement *element, gint width,
                          gint height, GstPlay *play)
{
  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));
  g_signal_emit (G_OBJECT (play), gst_play_signals[HAVE_VIDEO_SIZE],
                 0, width, height);
}

static gboolean
gst_play_tick_callback (GstPlay *play)
{
  GstElement* audio_sink_element;
  GstClockTime time;
  
  g_return_val_if_fail (play != NULL, FALSE);
  
  if (!GST_IS_PLAY (play)) {
    play->priv->tick_id = 0;
    return FALSE;
  }
  
  audio_sink_element = g_hash_table_lookup (play->priv->elements,
                                            "audio_sink_element");
  time = gst_element_get_time (audio_sink_element);
  play->priv->time_nanos = GST_CLOCK_TIME_IS_VALID (time) ? time : 0;
  
  g_signal_emit (G_OBJECT (play), gst_play_signals[TIME_TICK],
                 0,play->priv->time_nanos);
  
  if (GST_STATE (GST_ELEMENT (play)) == GST_STATE_PLAYING)
    return TRUE;
  else {
    play->priv->tick_id = 0;
    return FALSE;
  }
}

static gboolean
gst_play_get_length_callback (GstPlay *play)
{
  GstElement *audio_sink_element, *video_sink_element;
  GstFormat format = GST_FORMAT_TIME;
  gint64 value;
  gboolean q = FALSE;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  /* We try to get length from all real sink elements */
  audio_sink_element = g_hash_table_lookup (play->priv->elements,
                                            "audio_sink_element");
  video_sink_element = g_hash_table_lookup (play->priv->elements,
                                            "video_sink_element");
  if (!GST_IS_ELEMENT (audio_sink_element) &&
      !GST_IS_ELEMENT (video_sink_element)) {
    play->priv->length_id = 0;
    return FALSE;
  }
  
  /* Audio first and then Video */
  if (GST_IS_ELEMENT (audio_sink_element))
    q = gst_element_query (audio_sink_element, GST_QUERY_TOTAL, &format,
                           &value);
  if ( (!q) && (GST_IS_ELEMENT (video_sink_element)) )
    q = gst_element_query (video_sink_element, GST_QUERY_TOTAL, &format,
                           &value);
   
  if (q) {
    play->priv->length_nanos = value;
    g_signal_emit (G_OBJECT (play), gst_play_signals[STREAM_LENGTH],
                   0,play->priv->length_nanos);
    play->priv->length_id = 0;
    return FALSE;
  }
  
  play->priv->get_length_attempt++;
  
  /* We try 16 times */
  if (play->priv->get_length_attempt > 15) {
    play->priv->length_id = 0;
    return FALSE;
  }
  else
    return TRUE;
}

static void
gst_play_state_change (GstElement *element, GstElementState old,
                       GstElementState state)
{
  GstPlay *play;
  
  g_return_if_fail (element != NULL);
  g_return_if_fail (GST_IS_PLAY (element));
  
  play = GST_PLAY (element);
  
  if (state == GST_STATE_PLAYING) {
    if (play->priv->tick_id) {
      g_source_remove (play->priv->tick_id);
      play->priv->tick_id = 0;
    }
        
    play->priv->tick_id = g_timeout_add (200,
                                         (GSourceFunc) gst_play_tick_callback,
                                         play);
      
    play->priv->get_length_attempt = 0;
    
    if (play->priv->length_id) {
      g_source_remove (play->priv->length_id);
      play->priv->length_id = 0;
    }
        
    play->priv->length_id = g_timeout_add (200,
                                   (GSourceFunc) gst_play_get_length_callback,
                                   play);
  }
    
  if (GST_ELEMENT_CLASS (parent_class)->state_change)
    GST_ELEMENT_CLASS (parent_class)->state_change (element, old, state);
}

/* =========================================== */
/*                                             */
/*         Init & Dispose & Class init         */
/*                                             */
/* =========================================== */

static void
gst_play_dispose (GObject *object)
{
  GstPlay *play;
  
  g_return_if_fail (object != NULL);
  g_return_if_fail (GST_IS_PLAY (object));
  
  play = GST_PLAY (object);
  
  if (play->priv->length_id) {
    g_source_remove (play->priv->length_id);
    play->priv->length_id = 0;
  }
    
  if (play->priv->tick_id) {
    g_source_remove (play->priv->tick_id);
    play->priv->tick_id = 0;
  }
    
  if (play->priv->location) {
    g_free (play->priv->location);
    play->priv->location = NULL;
  }
  
  if (play->priv->elements) {
    g_hash_table_destroy (play->priv->elements);
    play->priv->elements = NULL;
  }
    
  G_OBJECT_CLASS (parent_class)->dispose (object);
}

static void
gst_play_init (GstPlay *play)
{
  play->priv = g_new0 (GstPlayPrivate, 1);
  play->priv->location = NULL;
  play->priv->length_nanos = 0;
  play->priv->time_nanos = 0;
  play->priv->elements = g_hash_table_new (g_str_hash, g_str_equal);
  
  if (!gst_play_pipeline_setup (play))
    g_warning ("libgstplay: failed initializing pipeline");
}

static void
gst_play_class_init (GstPlayClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  
  parent_class = g_type_class_peek_parent (klass);

  gobject_class->dispose = gst_play_dispose;

  element_class->state_change = gst_play_state_change;
  
  gst_play_signals[TIME_TICK] =
    g_signal_new ("time_tick", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GstPlayClass, time_tick), NULL, NULL,
                  gst_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
  gst_play_signals[STREAM_LENGTH] =
    g_signal_new ("stream_length", G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GstPlayClass, stream_length), NULL, NULL,
                  gst_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
  gst_play_signals[HAVE_VIDEO_SIZE] =
    g_signal_new ("have_video_size", G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GstPlayClass, have_video_size), NULL, NULL,
                  gst_marshal_VOID__INT_INT, G_TYPE_NONE, 2,
                  G_TYPE_INT, G_TYPE_INT);
}

/* ======================================================= */
/*                                                         */
/*                     Public Methods                      */
/*                                                         */
/* ======================================================= */

/**
 * gst_play_set_location:
 * @play: a #GstPlay.
 * @location: a const #char* indicating location to play
 *
 * Set location of @play to @location.
 *
 * Returns: TRUE if location was set successfully.
 */
gboolean
gst_play_set_location (GstPlay *play, const char *location)
{
  GstElement *work_thread, *source, *autoplugger;
  GstElement *audioconvert, *video_thread;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  if (play->priv->location)
    g_free (play->priv->location);
  
  play->priv->location = g_strdup (location);
  
  if (GST_STATE (GST_ELEMENT (play)) != GST_STATE_READY)
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
  
  work_thread = g_hash_table_lookup (play->priv->elements, "work_thread");
  if (!GST_IS_ELEMENT (work_thread))
    return FALSE;
  source = g_hash_table_lookup (play->priv->elements, "source");
  if (!GST_IS_ELEMENT (source))
    return FALSE;
  autoplugger = g_hash_table_lookup (play->priv->elements, "autoplugger");
  if (!GST_IS_ELEMENT (autoplugger))
    return FALSE;
  audioconvert = g_hash_table_lookup (play->priv->elements, "audioconvert");
  if (!GST_IS_ELEMENT (audioconvert))
    return FALSE;
  video_thread = g_hash_table_lookup (play->priv->elements, "video_thread");
  if (!GST_IS_ELEMENT (video_thread))
    return FALSE;
  
  /* Spider can autoplugg only once. We remove the actual one and put a new
     autoplugger */
  gst_element_unlink (source, autoplugger);
  gst_element_unlink (autoplugger, video_thread);
  gst_element_unlink (autoplugger, audioconvert);
  gst_bin_remove (GST_BIN (work_thread), autoplugger);
  
  autoplugger = gst_element_factory_make ("spider", "autoplugger");
  if (!GST_IS_ELEMENT (autoplugger))
    return FALSE;
  
  gst_bin_add (GST_BIN (work_thread), autoplugger);
  gst_element_link (source, autoplugger);
  gst_element_link (autoplugger, video_thread);
  gst_element_link (autoplugger, audioconvert);
  
  g_hash_table_replace (play->priv->elements, "autoplugger", autoplugger);
  
  /* FIXME: Why don't we have an interface to do that kind of stuff ? */
  g_object_set (G_OBJECT (source), "location", play->priv->location, NULL);
  
  play->priv->length_nanos = 0LL;
  play->priv->time_nanos = 0LL;
  
  g_signal_emit (G_OBJECT (play), gst_play_signals[STREAM_LENGTH], 0, 0LL);
  g_signal_emit (G_OBJECT (play), gst_play_signals[TIME_TICK], 0, 0LL);
  
  return TRUE;
}

/**
 * gst_play_get_location:
 * @play: a #GstPlay.
 *
 * Get current location of @play.
 *
 * Returns: a const #char* pointer to current location.
 */
char *
gst_play_get_location (GstPlay *play)
{
  g_return_val_if_fail (play != NULL, NULL);
  g_return_val_if_fail (GST_IS_PLAY (play), NULL);
  return g_strdup (play->priv->location);
}

/**
 * gst_play_seek_to_time:
 * @play: a #GstPlay.
 * @time_nanos: a #gint64 indicating a time position.
 *
 * Performs a seek on @play until @time_nanos.
 */
gboolean
gst_play_seek_to_time (GstPlay * play, gint64 time_nanos)
{
  GstElement *audio_sink_element, *video_sink_element;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  if (time_nanos < 0LL)
    time_nanos = 0LL;
  
  audio_sink_element = g_hash_table_lookup (play->priv->elements,
                                            "audio_sink_element");
  video_sink_element = g_hash_table_lookup (play->priv->elements,
                                            "video_sink_element");
  
  if (GST_IS_ELEMENT (audio_sink_element) &&
      GST_IS_ELEMENT (video_sink_element)) {
    gboolean s = FALSE;
   
    s = gst_element_seek (audio_sink_element, GST_FORMAT_TIME |
                          GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH,
                          time_nanos);
    if (!s) {
      s = gst_element_seek (video_sink_element, GST_FORMAT_TIME |
                            GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH,
                            time_nanos);
    }
    
    if (s) {
      GstClockTime time;
      time = gst_element_get_time (audio_sink_element);
      play->priv->time_nanos = GST_CLOCK_TIME_IS_VALID (time) ? time : 0;
      g_signal_emit (G_OBJECT (play), gst_play_signals[TIME_TICK],
                     0,play->priv->time_nanos);
    }
  }
  
  return TRUE;
}

/**
 * gst_play_set_data_src:
 * @play: a #GstPlay.
 * @data_src: a #GstElement.
 *
 * Set @data_src as the source element of @play.
 *
 * Returns: TRUE if call succeeded.
 */
gboolean
gst_play_set_data_src (GstPlay *play, GstElement *data_src)
{
  GstElement *work_thread, *old_data_src, *autoplugger;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  /* We bring back the pipeline to READY */
  if (GST_STATE (GST_ELEMENT (play)) != GST_STATE_READY)
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
  
  /* Getting needed objects */
  work_thread = g_hash_table_lookup (play->priv->elements, "work_thread");
  if (!GST_IS_ELEMENT (work_thread))
    return FALSE;
  old_data_src = g_hash_table_lookup (play->priv->elements, "source");
  if (!GST_IS_ELEMENT (old_data_src))
    return FALSE;
  autoplugger = g_hash_table_lookup (play->priv->elements, "autoplugger");
  if (!GST_IS_ELEMENT (autoplugger))
    return FALSE;
  
  /* Unlinking old source from autoplugger, removing it from pipeline, adding
     the new one and connecting it to autoplugger FIXME: we should put a new
     autoplugger here as spider can autoplugg only once */
  gst_element_unlink (old_data_src, autoplugger);
  gst_bin_remove (GST_BIN (work_thread), old_data_src);
  gst_bin_add (GST_BIN (work_thread), data_src);
  gst_element_link (data_src, autoplugger);
  
  g_hash_table_replace (play->priv->elements, "source", data_src);
  
  return TRUE;
}

/**
 * gst_play_set_video_sink:
 * @play: a #GstPlay.
 * @video_sink: a #GstElement.
 *
 * Set @video_sink as the video sink element of @play.
 *
 * Returns: TRUE if call succeeded.
 */
gboolean
gst_play_set_video_sink (GstPlay *play, GstElement *video_sink)
{
  GstElement *video_thread, *old_video_sink, *video_scaler, *video_sink_element;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (video_sink != NULL, FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (video_sink), FALSE);
  
  /* We bring back the pipeline to READY */
  if (GST_STATE (GST_ELEMENT (play)) != GST_STATE_READY)
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
  
  /* Getting needed objects */
  video_thread = g_hash_table_lookup (play->priv->elements, "video_thread");
  if (!GST_IS_ELEMENT (video_thread))
    return FALSE;
  old_video_sink = g_hash_table_lookup (play->priv->elements, "video_sink");
  if (!GST_IS_ELEMENT (old_video_sink))
    return FALSE;
  video_scaler = g_hash_table_lookup (play->priv->elements, "video_scaler");
  if (!GST_IS_ELEMENT (video_scaler))
    return FALSE;
  
  /* Unlinking old video sink from video scaler, removing it from pipeline,
     adding the new one and linking it */
  gst_element_unlink (video_scaler, old_video_sink);
  gst_bin_remove (GST_BIN (video_thread), old_video_sink);
  gst_bin_add (GST_BIN (video_thread), video_sink);
  gst_element_link (video_scaler, video_sink);
  
  g_hash_table_replace (play->priv->elements, "video_sink", video_sink);
  
  video_sink_element = gst_play_get_sink_element (play, video_sink,
                                                  GST_PLAY_SINK_TYPE_VIDEO);
  if (GST_IS_ELEMENT (video_sink_element)) {
    g_hash_table_replace (play->priv->elements, "video_sink_element",
                          video_sink_element);
    if (GST_IS_X_OVERLAY (video_sink_element)) {
      g_signal_connect (G_OBJECT (video_sink_element),
                        "desired_size_changed",
                         G_CALLBACK (gst_play_have_video_size), play);
    }
  } 
  
  gst_element_set_state (video_sink, GST_STATE (GST_ELEMENT(play)));
  
  return TRUE;
}

/**
 * gst_play_set_audio_sink:
 * @play: a #GstPlay.
 * @audio_sink: a #GstElement.
 *
 * Set @audio_sink as the audio sink element of @play.
 *
 * Returns: TRUE if call succeeded.
 */
gboolean
gst_play_set_audio_sink (GstPlay *play, GstElement *audio_sink)
{
  GstElement *old_audio_sink, *audio_thread, *audio_queue, *audio_sink_element;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (audio_sink != NULL, FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (audio_sink), FALSE);
  
  /* We bring back the pipeline to READY */
  if (GST_STATE (GST_ELEMENT (play)) != GST_STATE_READY)
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
  
  /* Getting needed objects */
  old_audio_sink = g_hash_table_lookup (play->priv->elements, "audio_sink");
  if (!GST_IS_ELEMENT (old_audio_sink))
    return FALSE;
  audio_thread = g_hash_table_lookup (play->priv->elements, "audio_thread");
  if (!GST_IS_ELEMENT (audio_thread))
    return FALSE;
  audio_queue = g_hash_table_lookup (play->priv->elements, "audio_queue");
  if (!GST_IS_ELEMENT (audio_queue))
    return FALSE;
  
  /* Unlinking old audiosink, removing it from pipeline, putting the new one
     and linking it */
  gst_element_unlink (audio_queue, old_audio_sink);
  gst_bin_remove (GST_BIN (audio_thread), old_audio_sink);
  gst_bin_add (GST_BIN (audio_thread), audio_sink);
  gst_element_link (audio_queue, audio_sink);
  
  g_hash_table_replace (play->priv->elements, "audio_sink", audio_sink);
  
  audio_sink_element = gst_play_get_sink_element (play, audio_sink,
                                                  GST_PLAY_SINK_TYPE_AUDIO);
  if (GST_IS_ELEMENT (audio_sink_element)) {
    g_hash_table_replace (play->priv->elements, "audio_sink_element",
                          audio_sink_element);
  }
  
  gst_element_set_state (audio_sink, GST_STATE (GST_ELEMENT(play)));
  
  return TRUE;
}

/**
 * gst_play_set_visualization:
 * @play: a #GstPlay.
 * @element: a #GstElement.
 *
 * Set @video_sink as the video sink element of @play.
 *
 * Returns: TRUE if call succeeded.
 */
gboolean
gst_play_set_visualization (GstPlay *play, GstElement *vis_element)
{
  GstElement *work_thread, *old_vis_element, *video_thread;
  GstPad *tee_pad1;
  gboolean was_playing = FALSE;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (vis_element != NULL, FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (vis_element), FALSE);
  
  /* Getting needed objects */
  work_thread = g_hash_table_lookup (play->priv->elements, "work_thread");
  if (!GST_IS_ELEMENT (work_thread))
    return FALSE;
  old_vis_element = g_hash_table_lookup (play->priv->elements,
                                         "vis_element");
  if (!GST_IS_ELEMENT (old_vis_element))
    return FALSE;
  tee_pad1 = g_hash_table_lookup (play->priv->elements, "tee_pad1");
  if (!GST_IS_PAD (tee_pad1))
    return FALSE;
  video_thread = g_hash_table_lookup (play->priv->elements, "video_thread");
  if (!GST_IS_ELEMENT (video_thread))
    return FALSE;
  
  /* Let's check if the current vis element has a managing bin. If yes that
     means the element is inside the pipeline and need to be unlinked and 
     removed. We also need to pause the pipeline if it is currently playing. */
  if (gst_element_get_managing_bin (old_vis_element)) {
    GstPad *vis_element_pad;

    /* We bring back the pipeline to PAUSED */
    if (GST_STATE (GST_ELEMENT (play)) == GST_STATE_PLAYING) {
      gst_element_set_state (GST_ELEMENT (play), GST_STATE_PAUSED);
      was_playing = TRUE;
    }
    
    /* Unlinking, removing the old element then adding and linking the new one */
    vis_element_pad = gst_element_get_pad (old_vis_element, "sink");
    if (GST_IS_PAD (vis_element_pad))
      gst_pad_unlink (tee_pad1, vis_element_pad);
    gst_element_unlink (old_vis_element, video_thread);
    gst_bin_remove (GST_BIN (work_thread), old_vis_element);
    gst_bin_add (GST_BIN (work_thread), vis_element);
    vis_element_pad = gst_element_get_pad (vis_element, "sink");
    if (GST_IS_PAD (vis_element_pad))
      gst_pad_link (tee_pad1, vis_element_pad);
    gst_element_link (vis_element, video_thread);
  }
  else {
    gst_object_unref (GST_OBJECT (old_vis_element));
  }
  
  g_hash_table_replace (play->priv->elements, "vis_element", vis_element);
  
  if (was_playing)
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_PLAYING);
  
  return TRUE;
}

/**
 * gst_play_connect_visualization:
 * @play: a #GstPlay.
 * @connect: a #gboolean indicating wether or not
 * visualization should be connected.
 *
 * Connect or disconnect visualization bin in @play.
 *
 * Returns: TRUE if call succeeded.
 */
gboolean
gst_play_connect_visualization (GstPlay * play, gboolean connect)
{
  GstElement *work_thread, *vis_element, *autoplugger, *video_thread;
  GstElement *audioconvert, *source;
  GstPad *tee_pad1, *vis_element_pad;
  
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  
  /* Getting needed objects */
  work_thread = g_hash_table_lookup (play->priv->elements, "work_thread");
  if (!GST_IS_ELEMENT (work_thread))
    return FALSE;
  vis_element = g_hash_table_lookup (play->priv->elements, "vis_element");
  if (!GST_IS_ELEMENT (vis_element))
    return FALSE;
  tee_pad1 = g_hash_table_lookup (play->priv->elements, "tee_pad1");
  if (!GST_IS_PAD (tee_pad1))
    return FALSE;
  video_thread = g_hash_table_lookup (play->priv->elements, "video_thread");
  if (!GST_IS_ELEMENT (video_thread))
    return FALSE;
  autoplugger = g_hash_table_lookup (play->priv->elements, "autoplugger");
  if (!GST_IS_ELEMENT (autoplugger))
    return FALSE;
  source = g_hash_table_lookup (play->priv->elements, "source");
  if (!GST_IS_ELEMENT (source))
    return FALSE;
  audioconvert = g_hash_table_lookup (play->priv->elements, "audioconvert");
  if (!GST_IS_ELEMENT (audioconvert))
    return FALSE;

  /* Check if the vis element is in the pipeline. That means visualization is
     connected already */
  if (gst_element_get_managing_bin (vis_element)) {
    
    /* If we are supposed to connect then nothing to do we return */
    if (connect) {
      return TRUE;
    }
    
    /* We have to modify the pipeline. Changing autoplugger requires going to
       READY */
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
    
    /* Otherwise we unlink and remove the vis element refing it  so that
       it won't be destroyed when removed from the bin. */
    vis_element_pad = gst_element_get_pad (vis_element, "sink");
    if (GST_IS_PAD (vis_element_pad))
      gst_pad_unlink (tee_pad1, vis_element_pad);
    gst_element_unlink (vis_element, video_thread);
    gst_object_ref (GST_OBJECT (vis_element));
    gst_bin_remove (GST_BIN (work_thread), vis_element);
    
    /* Removing autoplugger */
    gst_element_unlink (source, autoplugger);
    gst_element_unlink (autoplugger, audioconvert);
    gst_bin_remove (GST_BIN (work_thread), autoplugger);
  
    autoplugger = gst_element_factory_make ("spider", "autoplugger");
    if (!GST_IS_ELEMENT (autoplugger))
      return FALSE;
  
    /* Adding and connecting a new autoplugger connected to video_thread */
    gst_bin_add (GST_BIN (work_thread), autoplugger);
    gst_element_link (source, autoplugger);
    gst_element_link (autoplugger, video_thread);
    gst_element_link (autoplugger, audioconvert);
    
    g_hash_table_replace (play->priv->elements, "autoplugger", autoplugger);
  }
  else {
    GstCaps *filtered_caps;
    
    /* If we are supposed to disconnect then nothing to do we return */
    if (!connect) {
      return TRUE;
    }
    
    /* We have to modify the pipeline. Changing autoplugger requires going to
       READY */
    gst_element_set_state (GST_ELEMENT (play), GST_STATE_READY);
    
    /* Removing autoplugger */
    gst_element_unlink (source, autoplugger);
    gst_element_unlink (autoplugger, video_thread);
    gst_element_unlink (autoplugger, audioconvert);
    gst_bin_remove (GST_BIN (work_thread), autoplugger);
  
    autoplugger = gst_element_factory_make ("spider", "autoplugger");
    if (!GST_IS_ELEMENT (autoplugger))
      return FALSE;
  
    /* Adding and connecting a new autoplugger */
    gst_bin_add (GST_BIN (work_thread), autoplugger);
    gst_element_link (source, autoplugger);
    gst_element_link (autoplugger, audioconvert);
    
    g_hash_table_replace (play->priv->elements, "autoplugger", autoplugger);
    
    /* Otherwise we add the element to the bin and link it to video_thread */
    gst_bin_add (GST_BIN (work_thread), vis_element);
    vis_element_pad = gst_element_get_pad (vis_element, "sink");
    if (GST_IS_PAD (vis_element_pad))
      gst_pad_link (tee_pad1, vis_element_pad);
    
    filtered_caps = gst_caps_from_string ("video/x-raw-rgb, "
                                            "framerate = 30.0; "
                                          "video/x-raw-yuv, "
                                            "framerate = 30.0");
    
    if (!gst_element_link_filtered (vis_element, video_thread, filtered_caps))
      g_message ("failed linking filtered vis with video thread");
    
    gst_caps_free (filtered_caps);
  }

  return TRUE;
}

/**
 * gst_play_get_sink_element:
 * @play: a #GstPlay.
 * @element: a #GstElement.
 * @sink_type: a #GstPlaySinkType.
 *
 * Searches recursively for a sink #GstElement with
 * type @sink_type in @element which is supposed to be a #GstBin.
 *
 * Returns: the sink #GstElement of @element.
 */
GstElement *
gst_play_get_sink_element (GstPlay *play,
                           GstElement *element, GstPlaySinkType sink_type)
{
  GList *elements = NULL;
  const GList *pads = NULL;
  gboolean has_src, has_correct_type;

  g_return_val_if_fail (play != NULL, NULL);
  g_return_val_if_fail (element != NULL, NULL);
  g_return_val_if_fail (GST_IS_PLAY (play), NULL);
  g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

  if (!GST_IS_BIN (element)) {
    /* since its not a bin, we'll presume this 
     * element is a sink element */
    return element;
  }

  elements = (GList *) gst_bin_get_list (GST_BIN (element));

  /* traverse all elements looking for a src pad */

  while (elements) {
    element = GST_ELEMENT (elements->data);

    /* Recursivity :) */

    if (GST_IS_BIN (element)) {
      element = gst_play_get_sink_element (play, element, sink_type);
      if (GST_IS_ELEMENT (element))
        return element;
    }
    else {
      pads = gst_element_get_pad_list (element);
      has_src = FALSE;
      has_correct_type = FALSE;
      while (pads) {
        /* check for src pad */
        if (GST_PAD_DIRECTION (GST_PAD (pads->data)) == GST_PAD_SRC) {
          has_src = TRUE;
          break;
        }
        else {
          /* If not a src pad checking caps */
          GstCaps *caps;
          GstStructure *structure;
          gboolean has_video_cap = FALSE;
          gboolean has_audio_cap = FALSE;

          caps = gst_pad_get_caps (GST_PAD (pads->data));
          structure = gst_caps_get_structure (caps, 0);
          
          if (strcmp (gst_structure_get_name (structure),
                                  "audio/x-raw-int") == 0) {
            has_audio_cap = TRUE;
          }
          
          if (strcmp (gst_structure_get_name (structure),
                                   "video/x-raw-yuv") == 0 ||
              strcmp (gst_structure_get_name (structure),
                                   "video/x-raw-rgb") == 0) {
            has_video_cap = TRUE;
          }

          gst_caps_free (caps);
          
          switch (sink_type) {
            case GST_PLAY_SINK_TYPE_AUDIO:
              if (has_audio_cap)
                has_correct_type = TRUE;
              break;;
            case GST_PLAY_SINK_TYPE_VIDEO:
              if (has_video_cap)
                has_correct_type = TRUE;
              break;;
            case GST_PLAY_SINK_TYPE_ANY:
              if ((has_video_cap) || (has_audio_cap))
                has_correct_type = TRUE;
              break;;
            default:
              has_correct_type = FALSE;
          }
        }
        
        pads = g_list_next (pads);
        
      }
      
      if ((!has_src) && (has_correct_type))
        return element;
    }
    
    elements = g_list_next (elements);
  }
  
  /* we didn't find a sink element */
  
  return NULL;
}

GstPlay *
gst_play_new (void)
{
  GstPlay *play = g_object_new (GST_TYPE_PLAY, NULL);
  
  return play;
}

/* =========================================== */
/*                                             */
/*          Object typing & Creation           */
/*                                             */
/* =========================================== */

GType
gst_play_get_type (void)
{
  static GType play_type = 0;

  if (!play_type) {
    static const GTypeInfo play_info = {
      sizeof (GstPlayClass),
      NULL,
      NULL,
      (GClassInitFunc) gst_play_class_init,
      NULL,
      NULL,
      sizeof (GstPlay),
      0,
      (GInstanceInitFunc) gst_play_init,
      NULL
    };
      
    play_type = g_type_register_static (GST_TYPE_PIPELINE, "GstPlay",
                                        &play_info, 0);
  }

  return play_type;
}