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

/* GStreamer
 * Copyright (C) 1999,2000,2001,2002 Erik Walthinsen <omega@cse.ogi.edu>
 *                    2000,2001,2002 Wim Taymans <wtay@chello.be>
 *                              2002 Steve Baker <steve@stevebaker.org>
 *                              2003 Julien Moutte <julien@moutte.net>
 *
 * play.c: GstPlay object code
 *
 * 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.
 */

#include "play.h"

enum
{
  STREAM_END,
  INFORMATION,
  STATE_CHANGE,
  STREAM_LENGTH,
  TIME_TICK,
  HAVE_XID,
  HAVE_VIS_XID,
  HAVE_VIDEO_SIZE,
  PIPELINE_ERROR,
  /* put additional signals before this comment */
  LAST_SIGNAL,
};

/* this struct is used to decouple signals coming out of threaded pipelines */

typedef struct _GstPlaySignal GstPlaySignal;

struct _GstPlaySignal
{
  gint signal_id;
  union
  {
    struct
    {
      gint width;
      gint height;
    }
    video_size;
    struct
    {
      gint xid;
    }
    video_xid;
    struct
    {
      GstElementState old_state;
      GstElementState new_state;
    }
    state;
    struct
    {
      GstObject *object;
      GParamSpec *param;
    }
    info;
    struct
    {
      GstElement *element;
      char *error;
    }
    error;
  }
  signal_data;
};

enum
{
  ARG_0,
  ARG_LOCATION,
  ARG_VOLUME,
  ARG_MUTE,
  /* FILL ME */
};

static guint gst_play_signals[LAST_SIGNAL] = { 0 };

static GstElementClass *parent_class = NULL;

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

/* =========================================== */
/*                                             */
/*                  Tool Box                   */
/*                                             */
/* =========================================== */

static GQuark
gst_play_error_quark (void)
{
  static GQuark quark = 0;
  if (quark == 0)
    {
      quark = g_quark_from_static_string ("gst-play-error-quark");
    }

  return quark;
}

/* GError creation when plugin is missing
 * If we want to make error messages less
 * generic and have more errors than only
 * plug-ins, move the message creation to the switch */
static void
gst_play_error_plugin (GstPlayError type, GError ** error)
{
  gchar *name;

  if (error == NULL)
    return;

  switch (type)
    {
    case GST_PLAY_ERROR_THREAD:
      name = g_strdup ("thread");
      break;
    case GST_PLAY_ERROR_QUEUE:
      name = g_strdup ("queue");
      break;
    case GST_PLAY_ERROR_FAKESINK:
      name = g_strdup ("fakesink");
      break;
    case GST_PLAY_ERROR_VOLUME:
      name = g_strdup ("volume");
      break;
    case GST_PLAY_ERROR_COLORSPACE:
      name = g_strdup ("colorspace");
      break;
    case GST_PLAY_ERROR_GNOMEVFSSRC:
      name = g_strdup ("gnomevfssrc");
      break;
    default:
      name = g_strdup ("unknown");
      break;
    }

  *error = g_error_new (GST_PLAY_ERROR,
			type,
			"The %s plug-in could not be found. "
			"This plug-in is essential for libgstplay. "
			"Please install it and verify that it works "
			"by running 'gst-inspect %s'", name, name);
  g_free (name);
  return;
}

static void
gst_play_set_property (GObject * object,
		       guint prop_id,
		       const GValue * value, GParamSpec * pspec)
{
  GstPlay *play;
  g_return_if_fail (object != NULL);
  g_return_if_fail (GST_IS_PLAY (object));
  play = GST_PLAY (object);

  switch (prop_id)
    {
    case ARG_LOCATION:
      gst_play_set_location (play, g_value_get_string (value));
      break;
    case ARG_VOLUME:
      gst_play_set_volume (play, g_value_get_float (value));
      break;
    case ARG_MUTE:
      gst_play_set_mute (play, g_value_get_boolean (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gst_play_get_property (GObject * object,
		       guint prop_id, GValue * value, GParamSpec * pspec)
{
  GstPlay *play;
  g_return_if_fail (object != NULL);
  g_return_if_fail (GST_IS_PLAY (object));
  play = GST_PLAY (object);

  switch (prop_id)
    {
    case ARG_LOCATION:
      g_value_set_string (value, gst_play_get_location (play));
      break;
    case ARG_VOLUME:
      g_value_set_float (value, gst_play_get_volume (play));
      break;
    case ARG_MUTE:
      g_value_set_boolean (value, gst_play_get_mute (play));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

/* =========================================== */
/*                                             */
/*          Event Handlers, Callbacks          */
/*                                             */
/* =========================================== */

static gboolean
gst_play_get_length_callback (GstPlay * play)
{
  gint64 value;
  GstFormat format = GST_FORMAT_TIME;
  gboolean query_worked = FALSE;

  if ((play->audio_sink_element != NULL) &&
      (GST_IS_ELEMENT (play->audio_sink_element)))
    {
      query_worked =
	gst_element_query (play->audio_sink_element, GST_QUERY_TOTAL, &format,
			   &value);
    }
  else if ((play->video_sink_element != NULL) &&
	   (GST_IS_ELEMENT (play->video_sink_element)))
    {
      query_worked =
	gst_element_query (play->video_sink_element, GST_QUERY_TOTAL, &format,
			   &value);
    }
  if (query_worked)
    {
      g_signal_emit (G_OBJECT (play), gst_play_signals[STREAM_LENGTH], 0,
		     value);
      play->length_nanos = value;
      return FALSE;
    }
  else
    {
      if (play->get_length_attempt-- < 1)
	{
	  /* we've tried enough times, give up */
	  return FALSE;
	}
    }
  return (gst_element_get_state (play->pipeline) == GST_STATE_PLAYING);
}

static gboolean
gst_play_tick_callback (GstPlay * play)
{
  gint secs;

  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);

  play->clock = gst_bin_get_clock (GST_BIN (play->pipeline));
  play->time_nanos = gst_clock_get_time (play->clock);
  secs = (gint) (play->time_nanos / GST_SECOND);
  if (secs != play->time_seconds)
    {
      play->time_seconds = secs;
      g_signal_emit (G_OBJECT (play), gst_play_signals[TIME_TICK], 0,
		     play->time_nanos);
    }

  return (gst_element_get_state (play->pipeline) == GST_STATE_PLAYING);
}

static gboolean
gst_play_default_idle (GstPlayIdleData * idle_data)
{
  if (idle_data->func (idle_data->data))
    {
      /* call this function again in the future */
      return TRUE;
    }
  /* this function should no longer be called */
  g_free (idle_data);
  return FALSE;
}

static guint
gst_play_default_timeout_add (guint interval,
			      GSourceFunc function, gpointer data)
{
  GstPlayIdleData *idle_data = g_new0 (GstPlayIdleData, 1);
  idle_data->func = function;
  idle_data->data = data;

  return g_timeout_add (interval, (GSourceFunc) gst_play_default_idle,
			idle_data);
}

static guint
gst_play_default_idle_add (GSourceFunc function, gpointer data)
{
  GstPlayIdleData *idle_data = g_new0 (GstPlayIdleData, 1);
  idle_data->func = function;
  idle_data->data = data;

  return g_idle_add ((GSourceFunc) gst_play_default_idle, idle_data);
}

static gboolean
gst_play_idle_callback (GstPlay * play)
{
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);

  return gst_bin_iterate (GST_BIN (play->pipeline));
}

static gboolean
gst_play_idle_signal (GstPlay * play)
{
  GstPlaySignal *signal;
  gint queue_length;

  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);

  signal = g_async_queue_try_pop (play->signal_queue);
  if (signal == NULL)
    {
      return FALSE;
    }

  switch (signal->signal_id)
    {
    case HAVE_XID:
      g_signal_emit (G_OBJECT (play), gst_play_signals[HAVE_XID], 0,
		     signal->signal_data.video_xid.xid);
      break;
    case HAVE_VIS_XID:
      g_signal_emit (G_OBJECT (play), gst_play_signals[HAVE_VIS_XID], 0,
		     signal->signal_data.video_xid.xid);
      break;
    case HAVE_VIDEO_SIZE:
      g_signal_emit (G_OBJECT (play), gst_play_signals[HAVE_VIDEO_SIZE], 0,
		     signal->signal_data.video_size.width,
		     signal->signal_data.video_size.height);
      break;
    case STATE_CHANGE:
      g_signal_emit (G_OBJECT (play), gst_play_signals[STATE_CHANGE], 0,
		     signal->signal_data.state.old_state,
		     signal->signal_data.state.new_state);
      break;
    case INFORMATION:
      g_signal_emit (G_OBJECT (play), gst_play_signals[INFORMATION], 0,
		     signal->signal_data.info.object,
		     signal->signal_data.info.param);
      gst_object_unref (signal->signal_data.info.object);
      break;
    case PIPELINE_ERROR:

      if (gst_element_get_state (play->pipeline) == GST_STATE_PLAYING)
	if (gst_element_set_state (play->pipeline, GST_STATE_READY) !=
	    GST_STATE_SUCCESS)
	  g_warning ("PIPELINE_ERROR: set to READY failed");
      g_signal_emit (G_OBJECT (play), gst_play_signals[PIPELINE_ERROR], 0,
		     signal->signal_data.error.element,
		     signal->signal_data.error.error);
      if (signal->signal_data.error.error)
	g_free (signal->signal_data.error.error);
      gst_object_unref (GST_OBJECT (signal->signal_data.error.element));
      break;
    default:
      break;
    }

  g_free (signal);
  queue_length = g_async_queue_length (play->signal_queue);

  return (queue_length > 0);
}

static gboolean
gst_play_idle_eos (GstPlay * play)
{
  g_signal_emit (G_OBJECT (play), gst_play_signals[STREAM_END], 0);
  return FALSE;
}

static void
callback_audio_sink_eos (GstElement * element, GstPlay * play)
{
  play->idle_add_func ((GSourceFunc) gst_play_idle_eos, play);
}

static void
callback_video_have_xid (GstElement * element, gint xid, GstPlay * play)
{
  GstPlaySignal *signal;

  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = HAVE_XID;
  signal->signal_data.video_xid.xid = xid;

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

static void
callback_video_have_vis_xid (GstElement * element, gint xid, GstPlay * play)
{
  GstPlaySignal *signal;

  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = HAVE_VIS_XID;
  signal->signal_data.video_xid.xid = xid;

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

static void
callback_video_have_size (GstElement * element,
			  gint width, gint height, GstPlay * play)
{
  GstPlaySignal *signal;

  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = HAVE_VIDEO_SIZE;
  signal->signal_data.video_size.width = width;
  signal->signal_data.video_size.height = height;

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

static void
callback_pipeline_error (GstElement * object,
			 GstElement * orig, char *error, GstPlay * play)
{
  GstPlaySignal *signal;

  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = PIPELINE_ERROR;
  signal->signal_data.error.element = orig;
  signal->signal_data.error.error = g_strdup (error);

  gst_object_ref (GST_OBJECT (orig));

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

static void
callback_pipeline_deep_notify (GstObject * element,
			       GstObject * orig,
			       GParamSpec * param, GstPlay * play)
{
  GstPlaySignal *signal;

  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = INFORMATION;
  signal->signal_data.info.object = orig;
  signal->signal_data.info.param = param;

  gst_object_ref (orig);

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

static void
callback_pipeline_state_change (GstElement * element,
				GstElementState old,
				GstElementState state, GstPlay * play)
{
  GstPlaySignal *signal;

  g_return_if_fail (play != NULL);
  g_return_if_fail (element != NULL);
  g_return_if_fail (GST_IS_ELEMENT (element));
  g_return_if_fail (GST_IS_PLAY (play));
  g_return_if_fail (element == play->pipeline);

  /*g_print ("got state change %s to %s\n", gst_element_state_get_name (old), gst_element_state_get_name (state)); */

  /* do additional stuff depending on state */
  if (GST_IS_PIPELINE (play->pipeline))
    {
      switch (state)
	{
	case GST_STATE_PLAYING:
	  play->idle_add_func ((GSourceFunc) gst_play_idle_callback, play);
	  play->timeout_add_func (200,
				  (GSourceFunc) gst_play_tick_callback, play);
	  if (play->length_nanos == 0LL)
	    {
	      /* try to get the length up to 16 times */
	      play->get_length_attempt = 16;
	      play->timeout_add_func (200,
				      (GSourceFunc)
				      gst_play_get_length_callback, play);
	    }
	  break;
	default:
	  break;
	}
    }
  signal = g_new0 (GstPlaySignal, 1);
  signal->signal_id = STATE_CHANGE;
  signal->signal_data.state.old_state = old;
  signal->signal_data.state.new_state = state;

  g_async_queue_push (play->signal_queue, signal);

  play->idle_add_func ((GSourceFunc) gst_play_idle_signal, play);
}

/* split static pipeline functions to a seperate file */
#include "playpipelines.c"

/* =========================================== */
/*                                             */
/*              Init & 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);

  /* Removing all sources */
  while (g_source_remove_by_user_data (play));

  G_OBJECT_CLASS (parent_class)->dispose (object);
}

static void
gst_play_class_init (GstPlayClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  parent_class = g_type_class_ref (GST_TYPE_OBJECT);

  klass->information = NULL;
  klass->state_changed = NULL;
  klass->stream_end = NULL;

  gobject_class->dispose = gst_play_dispose;
  gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_play_set_property);
  gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_play_get_property);

  g_object_class_install_property (gobject_class,
				   ARG_LOCATION,
				   g_param_spec_string ("location",
							"location of file",
							"location of the file to play",
							NULL,
							G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,
				   ARG_VOLUME,
				   g_param_spec_float ("volume",
						       "Playing volume",
						       "Playing volume",
						       0, 1.0, 0,
						       G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,
				   ARG_MUTE,
				   g_param_spec_boolean ("mute",
							 "Volume muted",
							 "Playing volume muted",
							 FALSE,
							 G_PARAM_READWRITE));

  gst_play_signals[INFORMATION] =
    g_signal_new ("information",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, information),
		  NULL, NULL,
		  gst_marshal_VOID__OBJECT_PARAM,
		  G_TYPE_NONE, 2, G_TYPE_OBJECT, G_TYPE_PARAM);

  gst_play_signals[PIPELINE_ERROR] =
    g_signal_new ("pipeline_error",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, pipeline_error),
		  NULL, NULL,
		  gst_marshal_VOID__OBJECT_STRING,
		  G_TYPE_NONE, 2, G_TYPE_OBJECT, G_TYPE_STRING);

  gst_play_signals[STATE_CHANGE] =
    g_signal_new ("state_change",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, state_changed),
		  NULL, NULL,
		  gst_marshal_VOID__INT_INT,
		  G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);

  gst_play_signals[STREAM_END] =
    g_signal_new ("stream_end",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, stream_end),
		  NULL, NULL, gst_marshal_VOID__VOID, G_TYPE_NONE, 0);

  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_XID] =
    g_signal_new ("have_xid",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, have_xid),
		  NULL, NULL,
		  gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);

  gst_play_signals[HAVE_VIS_XID] =
    g_signal_new ("have_vis_xid",
		  G_TYPE_FROM_CLASS (klass),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GstPlayClass, have_vis_xid),
		  NULL, NULL,
		  gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);

  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);

  gst_control_init (NULL, NULL);
}



static void
gst_play_init (GstPlay * play)
{
  play->pipeline = NULL;
  play->source = NULL;
  play->autoplugger = NULL;
  play->audio_sink = NULL;
  play->audio_sink_element = NULL;
  play->video_sink = NULL;
  play->video_sink_element = NULL;
  play->volume = NULL;
  play->other_elements = g_hash_table_new (g_str_hash, g_str_equal);

  gst_play_set_idle_timeout_funcs (play,
				   gst_play_default_timeout_add,
				   gst_play_default_idle_add);
}

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

/* =========================================== */
/*                                             */
/*                   Toolbox                   */
/*                                             */
/* =========================================== */

/**
 * gst_play_seek_to_time:
 * @play: a #GstPlay.
 * @time_nanos: a #gint64 indicating a time position.
 *
 * Performs a seek on @play until @time_nanos.
 */
void
gst_play_seek_to_time (GstPlay * play, gint64 time_nanos)
{
  GstEvent *s_event;
  guint8 prev_state;
  gboolean audio_seek_worked = FALSE;
  gboolean video_seek_worked = FALSE;
  gboolean visualisation_seek_worked = FALSE;

  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));
  if (time_nanos < 0LL)
    {
      play->seek_time = 0LL;
    }
  else if (time_nanos < 0LL)
    {
      play->seek_time = play->length_nanos;
    }
  else
    {
      play->seek_time = time_nanos;
    }

  /*g_print("doing seek to %lld\n", play->seek_time); */
  prev_state = GST_STATE (play->pipeline);
  if (gst_play_set_state (play, GST_STATE_PAUSED) != GST_STATE_SUCCESS)
    g_warning ("gst_play_seek: setting to READY failed\n");

  s_event = gst_event_new_seek (GST_FORMAT_TIME |
				GST_SEEK_METHOD_SET |
				GST_SEEK_FLAG_FLUSH, play->seek_time);
  if (play->audio_sink_element != NULL)
    {
      gst_event_ref (s_event);
      audio_seek_worked =
	gst_element_send_event (play->audio_sink_element, s_event);
    }
  if (play->visualisation_sink_element != NULL)
    {
      gst_event_ref (s_event);
      visualisation_seek_worked =
	gst_element_send_event (play->visualisation_sink_element, s_event);
    }
  if (play->video_sink_element != NULL)
    {
      gst_event_ref (s_event);
      video_seek_worked =
	gst_element_send_event (play->video_sink_element, s_event);
    }
  gst_event_unref (s_event);

  if (audio_seek_worked || video_seek_worked)
    {
      play->time_nanos = gst_clock_get_time (play->clock);
      g_signal_emit (G_OBJECT (play), gst_play_signals[TIME_TICK], 0,
		     play->time_nanos);
    }
  if (gst_element_set_state (play->pipeline, prev_state) != GST_STATE_SUCCESS)
    g_warning ("gst_play_seek_to_time: setting to READY failed\n");
}

/**
 * gst_play_need_new_video_window:
 * @play: a #GstPlay.
 *
 * Request a new video window for @play.
 */
void
gst_play_need_new_video_window (GstPlay * play)
{
  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));
  if (GST_IS_ELEMENT (play->video_sink_element))
    {
      g_object_set (G_OBJECT (play->video_sink_element),
		    "need_new_window", TRUE, NULL);
    }
  if (GST_IS_ELEMENT (play->visualisation_sink_element))
    {
      g_object_set (G_OBJECT (play->visualisation_sink_element),
		    "need_new_window", TRUE, NULL);
    }
}

void
gst_play_set_idle_timeout_funcs (GstPlay * play,
				 GstPlayTimeoutAdd timeout_add_func,
				 GstPlayIdleAdd idle_add_func)
{
  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));
  play->timeout_add_func = timeout_add_func;
  play->idle_add_func = idle_add_func;
}

/**
 * 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;
		  caps = gst_pad_get_caps (GST_PAD (pads->data));
		  while (caps)
		    {
		      gboolean has_video_cap = FALSE, has_audio_cap = FALSE;
		      if (g_ascii_strcasecmp (gst_caps_get_mime (caps),
					      "audio/x-raw-int") == 0)
			{
			  has_audio_cap = TRUE;
			}
		      if ((g_ascii_strcasecmp (gst_caps_get_mime (caps),
					      "video/x-raw-yuv") == 0) ||
			  (g_ascii_strcasecmp (gst_caps_get_mime (caps),
					       "video/x-raw-rgb") == 0))
									 
			{
			  has_video_cap = TRUE;
			}

		      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;
			}
		      caps = caps->next;
		    }
		}
	      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;
}

/* =========================================== */
/*                                             */
/*      State, Mute, Volume, Location          */
/*                                             */
/* =========================================== */

/**
 * gst_play_set_state:
 * @play: a #GstPlay.
 * @state: a #GstElementState.
 *
 * Set state of @play 's pipeline to @state.
 *
 * Returns: a #GstElementStateReturn indicating if the operation succeeded.
 */
GstElementStateReturn
gst_play_set_state (GstPlay * play, GstElementState state)
{
  g_return_val_if_fail (play != NULL, GST_STATE_FAILURE);
  g_return_val_if_fail (GST_IS_PLAY (play), GST_STATE_FAILURE);
  g_return_val_if_fail (GST_IS_ELEMENT (play->pipeline), GST_STATE_FAILURE);

  return gst_element_set_state (play->pipeline, state);
}

/**
 * gst_play_get_state:
 * @play: a #GstPlay.
 *
 * Get state of @play 's pipeline.
 *
 * Returns: a #GstElementState indicating @play 's pipeline current state.
 */
GstElementState
gst_play_get_state (GstPlay * play)
{
  g_return_val_if_fail (play != NULL, GST_STATE_FAILURE);
  g_return_val_if_fail (GST_IS_PLAY (play), GST_STATE_FAILURE);
  g_return_val_if_fail (play->pipeline, GST_STATE_FAILURE);

  return gst_element_get_state (play->pipeline);
}

/**
 * gst_play_set_location:
 * @play: a #GstPlay.
 * @location: a const #gchar 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 gchar * location)
{
  GstElementState current_state;
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (location != NULL, FALSE);

  current_state = gst_play_get_state (play);
  if (current_state != GST_STATE_READY)
    {
      if (gst_play_set_state (play, GST_STATE_READY) != GST_STATE_SUCCESS)
	g_warning ("gst_play_set_location: setting to READY failed\n");
    }

  if (play->set_autoplugger)
    {
      if (!play->
	  set_autoplugger (play,
			   gst_element_factory_make ("spider",
						     "autoplugger")))
	{
	  g_warning ("couldn't replace autoplugger\n");
	  return FALSE;
	}
    }

  /* FIXME check for valid location (somehow) */
  g_object_set (G_OBJECT (play->source), "location", location, NULL);

  /* reset time/length values */
  play->time_seconds = 0;
  play->length_nanos = 0LL;
  play->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);
  play->need_stream_length = TRUE;

  return TRUE;
}

/**
 * gst_play_get_location:
 * @play: a #GstPlay.
 *
 * Get current location of @play.
 *
 * Returns: a #gchar pointer to current location.
 */
gchar *
gst_play_get_location (GstPlay * play)
{
  gchar *location;
  g_return_val_if_fail (play != NULL, NULL);
  g_return_val_if_fail (GST_IS_PLAY (play), NULL);
  g_return_val_if_fail (GST_IS_ELEMENT (play->source), NULL);
  g_object_get (G_OBJECT (play->source), "location", &location, NULL);
  return location;
}

/**
 * gst_play_set_volume:
 * @play: a #GstPlay.
 * @volume: a #gfloat indicating volume level.
 *
 * Set current volume of @play.
 */
void
gst_play_set_volume (GstPlay * play, gfloat volume)
{
  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));

  g_object_set (G_OBJECT (play->vol_dparam), "value_float", volume, NULL);
}

/**
 * gst_play_get_volume:
 * @play: a #GstPlay.
 *
 * Get current volume of @play.
 *
 * Returns: a #gfloat indicating current volume level.
 */
gfloat
gst_play_get_volume (GstPlay * play)
{
  gfloat volume;

  g_return_val_if_fail (play != NULL, 0);
  g_return_val_if_fail (GST_IS_PLAY (play), 0);

  g_object_get (G_OBJECT (play->vol_dparam), "value_float", &volume, NULL);

  return volume;
}

/**
 * gst_play_set_mute:
 * @play: a #GstPlay.
 * @mute: a #gboolean indicating wether audio is muted or not.
 *
 * Mutes/Unmutes audio playback of @play.
 */
void
gst_play_set_mute (GstPlay * play, gboolean mute)
{
  g_return_if_fail (play != NULL);
  g_return_if_fail (GST_IS_PLAY (play));

  g_object_set (G_OBJECT (play->volume), "mute", mute, NULL);
}

/**
 * gst_play_get_mute:
 * @play: a #GstPlay.
 *
 * Get current muted status of @play.
 *
 * Returns: a #gboolean indicating if audio is muted or not.
 */
gboolean
gst_play_get_mute (GstPlay * play)
{
  gboolean mute;

  g_return_val_if_fail (play != NULL, 0);
  g_return_val_if_fail (GST_IS_PLAY (play), 0);

  g_object_get (G_OBJECT (play->volume), "mute", &mute, NULL);

  return mute;
}

/* =========================================== */
/*                                             */
/*    Audio sink, Video sink, Data src         */
/*                                             */
/* =========================================== */

/**
 * 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)
{
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (data_src != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (data_src), FALSE);

  if (gst_play_get_state (play) != GST_STATE_READY)
    {
      if (gst_play_set_state (play, GST_STATE_READY) != GST_STATE_SUCCESS)
	g_warning ("gst_play_set_data_src: setting to READY failed\n");
    }

  if (play->set_data_src)
    {
      return play->set_data_src (play, data_src);
    }

  /* if there is no set_data_src func, fail quietly */
  return FALSE;
}

/**
 * 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)
{
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (video_sink != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (video_sink), FALSE);

  if (gst_play_get_state (play) != GST_STATE_READY)
    {
      if (gst_play_set_state (play, GST_STATE_READY) != GST_STATE_SUCCESS)
	g_warning ("gst_play_set_video_sink: setting to READY failed\n");
    }

  if (play->set_video_sink)
    {
      return play->set_video_sink (play, video_sink);
    }

  /* if there is no set_video_sink func, fail quietly */
  return FALSE;
}

/**
 * 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)
{
  g_return_val_if_fail (play != NULL, FALSE);
  g_return_val_if_fail (audio_sink != NULL, FALSE);
  g_return_val_if_fail (GST_IS_PLAY (play), FALSE);
  g_return_val_if_fail (GST_IS_ELEMENT (audio_sink), FALSE);

  if (gst_play_get_state (play) != GST_STATE_READY)
    {
      if (gst_play_set_state (play, GST_STATE_READY) != GST_STATE_SUCCESS)
	g_warning ("gst_play_set_audio_sink: setting to READY failed\n");
    }

  if (play->set_audio_sink)
    {
      return play->set_audio_sink (play, audio_sink);
    }

  /* if there is no set_audio_sink func, fail quietly */
  return FALSE;
}

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

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

  if (!play_type)
    {
      static const GTypeInfo play_info = {
	sizeof (GstPlayClass),
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
	(GClassInitFunc) gst_play_class_init,
	NULL, NULL, sizeof (GstPlay),
	0, (GInstanceInitFunc) gst_play_init,
	NULL
      };

      play_type =
	g_type_register_static (G_TYPE_OBJECT, "GstPlay", &play_info, 0);
    }

  return play_type;
}


GstPlay *
gst_play_new (GstPlayPipeType pipe_type, GError ** error)
{
  GstPlay *play;

  play = g_object_new (GST_TYPE_PLAY, NULL);

  /* FIXME: looks like only VIDEO ever gets used ! */
  switch (pipe_type)
    {
    case GST_PLAY_PIPE_VIDEO:
      play->setup_pipeline = gst_play_video_setup;
      play->teardown_pipeline = NULL;
      play->set_data_src = gst_play_video_set_data_src;
      play->set_autoplugger = gst_play_video_set_auto;
      play->set_video_sink = gst_play_video_set_video;
      play->set_audio_sink = gst_play_video_set_audio;
      break;
    case GST_PLAY_PIPE_VIDEO_VISUALISATION:
      play->setup_pipeline = gst_play_video_vis_setup;
      play->teardown_pipeline = NULL;
      play->set_data_src = gst_play_video_set_data_src;
      play->set_autoplugger = gst_play_video_set_auto;
      play->set_video_sink = gst_play_video_vis_set_video;
      play->set_audio_sink = gst_play_video_vis_set_audio;
      break;
    case GST_PLAY_PIPE_AUDIO:
      /* we can reuse the threaded set functions */
      play->setup_pipeline = gst_play_audio_setup;
      play->teardown_pipeline = NULL;
      play->set_data_src = gst_play_simple_set_data_src;
      play->set_autoplugger = gst_play_audiot_set_auto;
      play->set_video_sink = NULL;
      play->set_audio_sink = gst_play_audiot_set_audio;
      break;
    case GST_PLAY_PIPE_AUDIO_THREADED:
      play->setup_pipeline = gst_play_audiot_setup;
      play->teardown_pipeline = NULL;
      play->set_data_src = gst_play_simple_set_data_src;
      play->set_autoplugger = gst_play_audiot_set_auto;
      play->set_video_sink = NULL;
      play->set_audio_sink = gst_play_audiot_set_audio;
      break;
    case GST_PLAY_PIPE_AUDIO_HYPER_THREADED:
      play->setup_pipeline = gst_play_audioht_setup;
      play->teardown_pipeline = NULL;
      play->set_data_src = gst_play_simple_set_data_src;
      play->set_autoplugger = gst_play_audioht_set_auto;
      play->set_video_sink = NULL;
      play->set_audio_sink = gst_play_audioht_set_audio;
      break;
    default:
      g_warning ("unknown pipeline type: %d\n", pipe_type);
    }

  /* init pipeline */
  if ((play->setup_pipeline) && (!play->setup_pipeline (play, error)))
    {
      g_object_unref (play);
      return NULL;
    }


  if (play->pipeline)
    {
      /* connect to pipeline events */
      g_signal_connect (G_OBJECT (play->pipeline),
			"deep_notify",
			G_CALLBACK (callback_pipeline_deep_notify), play);
      g_signal_connect (G_OBJECT (play->pipeline),
			"state_change",
			G_CALLBACK (callback_pipeline_state_change), play);
      g_signal_connect (G_OBJECT (play->pipeline),
			"error", G_CALLBACK (callback_pipeline_error), play);
    }

  if (play->volume)
    {
      play->vol_dpman = gst_dpman_get_manager (play->volume);
      play->vol_dparam = gst_dpsmooth_new (G_TYPE_FLOAT);

      g_object_set (G_OBJECT (play->vol_dparam),
		    "update_period", 2000000LL, NULL);

      g_object_set (G_OBJECT (play->vol_dparam),
		    "slope_delta_float", 0.1F, NULL);
      g_object_set (G_OBJECT (play->vol_dparam),
		    "slope_time", 10000000LL, NULL);

      if (!gst_dpman_attach_dparam (play->vol_dpman,
				    "volume", play->vol_dparam))
	g_warning ("could not attach dparam to volume element\n");

      gst_dpman_set_mode (play->vol_dpman, "asynchronous");
      gst_play_set_volume (play, 0.9);
    }

  play->signal_queue = g_async_queue_new ();

  return play;
}