gst/playback/gstplaysink.c

   1 /* GStreamer
   2  * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
   3  * Copyright (C) <2011> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <string.h>
  26 #include <gst/gst.h>
  27
  28 #include <gst/gst-i18n-plugin.h>
  29 #include <gst/pbutils/pbutils.h>
  30 #include <gst/video/video.h>
  31
  32 #include "gstplaysink.h"
  33 #include "gststreamsynchronizer.h"
  34 #include "gstplaysinkvideoconvert.h"
  35 #include "gstplaysinkaudioconvert.h"
  36
  37 GST_DEBUG_CATEGORY_STATIC (gst_play_sink_debug);
  38 #define GST_CAT_DEFAULT gst_play_sink_debug
  39
  40 #define VOLUME_MAX_DOUBLE 10.0
  41
  42 #define DEFAULT_FLAGS             GST_PLAY_FLAG_AUDIO | GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_TEXT | \
  43                                   GST_PLAY_FLAG_SOFT_VOLUME
  44
  45 #define GST_PLAY_CHAIN(c) ((GstPlayChain *)(c))
  46
  47 /* holds the common data fields for the audio and video pipelines. We keep them
  48  * in a structure to more easily have all the info available. */
  49 typedef struct
  50 {
  51   GstPlaySink *playsink;
  52   GstElement *bin;
  53   gboolean added;
  54   gboolean activated;
  55   gboolean raw;
  56 } GstPlayChain;
  57
  58 typedef struct
  59 {
  60   GstPlayChain chain;
  61   GstPad *sinkpad;
  62   GstElement *queue;
  63   GstElement *conv;
  64   GstElement *volume;           /* element with the volume property */
  65   gboolean sink_volume;         /* if the volume was provided by the sink */
  66   GstElement *mute;             /* element with the mute property */
  67   GstElement *sink;
  68   GstElement *ts_offset;
  69 } GstPlayAudioChain;
  70
  71 typedef struct
  72 {
  73   GstPlayChain chain;
  74   GstPad *sinkpad, *srcpad;
  75   GstElement *conv;
  76   GstElement *deinterlace;
  77 } GstPlayVideoDeinterlaceChain;
  78
  79 typedef struct
  80 {
  81   GstPlayChain chain;
  82   GstPad *sinkpad;
  83   GstElement *queue;
  84   GstElement *conv;
  85   GstElement *sink;
  86   gboolean async;
  87   GstElement *ts_offset;
  88 } GstPlayVideoChain;
  89
  90 typedef struct
  91 {
  92   GstPlayChain chain;
  93   GstPad *sinkpad;
  94   GstElement *queue;
  95   GstElement *conv;
  96   GstElement *resample;
  97   GstPad *blockpad;             /* srcpad of resample, used for switching the vis */
  98   GstPad *vissinkpad;           /* visualisation sinkpad, */
  99   GstElement *vis;
 100   GstPad *vissrcpad;            /* visualisation srcpad, */
 101   GstPad *srcpad;               /* outgoing srcpad, used to connect to the next
 102                                  * chain */
 103 } GstPlayVisChain;
 104
 105 typedef struct
 106 {
 107   GstPlayChain chain;
 108   GstPad *sinkpad;
 109   GstElement *queue;
 110   GstElement *identity;
 111   GstElement *overlay;
 112   GstPad *videosinkpad;
 113   GstPad *textsinkpad;
 114   GstPad *srcpad;               /* outgoing srcpad, used to connect to the next
 115                                  * chain */
 116   GstElement *sink;             /* custom sink to receive subtitle buffers */
 117 } GstPlayTextChain;
 118
 119 #define GST_PLAY_SINK_GET_LOCK(playsink) (&((GstPlaySink *)playsink)->lock)
 120 #define GST_PLAY_SINK_LOCK(playsink)     G_STMT_START { \
 121   GST_LOG_OBJECT (playsink, "locking from thread %p", g_thread_self ()); \
 122   g_static_rec_mutex_lock (GST_PLAY_SINK_GET_LOCK (playsink)); \
 123   GST_LOG_OBJECT (playsink, "locked from thread %p", g_thread_self ()); \
 124 } G_STMT_END
 125 #define GST_PLAY_SINK_UNLOCK(playsink)   G_STMT_START { \
 126   GST_LOG_OBJECT (playsink, "unlocking from thread %p", g_thread_self ()); \
 127   g_static_rec_mutex_unlock (GST_PLAY_SINK_GET_LOCK (playsink)); \
 128 } G_STMT_END
 129
 130 #define PENDING_FLAG_SET(playsink, flagtype) \
 131   ((playsink->pending_blocked_pads) |= (1 << flagtype))
 132 #define PENDING_FLAG_UNSET(playsink, flagtype) \
 133   ((playsink->pending_blocked_pads) &= ~(1 << flagtype))
 134 #define PENDING_FLAG_IS_SET(playsink, flagtype) \
 135   ((playsink->pending_blocked_pads) & (1 << flagtype))
 136 #define PENDING_VIDEO_BLOCK(playsink) \
 137   ((playsink->pending_blocked_pads) & (1 << GST_PLAY_SINK_TYPE_VIDEO_RAW | 1 << GST_PLAY_SINK_TYPE_VIDEO))
 138 #define PENDING_AUDIO_BLOCK(playsink) \
 139   ((playsink->pending_blocked_pads) & (1 << GST_PLAY_SINK_TYPE_AUDIO_RAW | 1 << GST_PLAY_SINK_TYPE_AUDIO))
 140 #define PENDING_TEXT_BLOCK(playsink) \
 141   PENDING_FLAG_IS_SET(playsink, GST_PLAY_SINK_TYPE_TEXT)
 142
 143 struct _GstPlaySink
 144 {
 145   GstBin bin;
 146
 147   GStaticRecMutex lock;
 148
 149   gboolean async_pending;
 150   gboolean need_async_start;
 151
 152   GstPlayFlags flags;
 153
 154   GstStreamSynchronizer *stream_synchronizer;
 155
 156   /* chains */
 157   GstPlayAudioChain *audiochain;
 158   GstPlayVideoDeinterlaceChain *videodeinterlacechain;
 159   GstPlayVideoChain *videochain;
 160   GstPlayVisChain *vischain;
 161   GstPlayTextChain *textchain;
 162
 163   /* audio */
 164   GstPad *audio_pad;
 165   gboolean audio_pad_raw;
 166   gboolean audio_pad_blocked;
 167   GstPad *audio_srcpad_stream_synchronizer;
 168   GstPad *audio_sinkpad_stream_synchronizer;
 169   gulong audio_block_id;
 170   /* audio tee */
 171   GstElement *audio_tee;
 172   GstPad *audio_tee_sink;
 173   GstPad *audio_tee_asrc;
 174   GstPad *audio_tee_vissrc;
 175   /* video */
 176   GstPad *video_pad;
 177   gboolean video_pad_raw;
 178   gboolean video_pad_blocked;
 179   GstPad *video_srcpad_stream_synchronizer;
 180   GstPad *video_sinkpad_stream_synchronizer;
 181   gulong video_block_id;
 182   /* text */
 183   GstPad *text_pad;
 184   gboolean text_pad_blocked;
 185   GstPad *text_srcpad_stream_synchronizer;
 186   GstPad *text_sinkpad_stream_synchronizer;
 187   gulong text_block_id;
 188
 189   guint32 pending_blocked_pads;
 190
 191   /* properties */
 192   GstElement *audio_sink;
 193   GstElement *video_sink;
 194   GstElement *visualisation;
 195   GstElement *text_sink;
 196   gdouble volume;
 197   gboolean mute;
 198   gchar *font_desc;             /* font description */
 199   gchar *subtitle_encoding;     /* subtitle encoding */
 200   guint connection_speed;       /* connection speed in bits/sec (0 = unknown) */
 201   guint count;
 202   gboolean volume_changed;      /* volume/mute changed while no audiochain */
 203   gboolean mute_changed;        /* ... has been created yet */
 204   gint64 av_offset;
 205 };
 206
 207 struct _GstPlaySinkClass
 208 {
 209   GstBinClass parent_class;
 210
 211     gboolean (*reconfigure) (GstPlaySink * playsink);
 212
 213   GstSample *(*convert_sample) (GstPlaySink * playsink, GstCaps * caps);
 214 };
 215
 216
 217 static GstStaticPadTemplate audiotemplate =
 218 GST_STATIC_PAD_TEMPLATE ("audio_sink",
 219     GST_PAD_SINK,
 220     GST_PAD_REQUEST,
 221     GST_STATIC_CAPS_ANY);
 222 static GstStaticPadTemplate videotemplate =
 223 GST_STATIC_PAD_TEMPLATE ("video_sink",
 224     GST_PAD_SINK,
 225     GST_PAD_REQUEST,
 226     GST_STATIC_CAPS_ANY);
 227 static GstStaticPadTemplate texttemplate = GST_STATIC_PAD_TEMPLATE ("text_sink",
 228     GST_PAD_SINK,
 229     GST_PAD_REQUEST,
 230     GST_STATIC_CAPS_ANY);
 231
 232 /* FIXME 0.11: Remove */
 233 static GstStaticPadTemplate audiorawtemplate =
 234 GST_STATIC_PAD_TEMPLATE ("audio_raw_sink",
 235     GST_PAD_SINK,
 236     GST_PAD_REQUEST,
 237     GST_STATIC_CAPS_ANY);
 238 static GstStaticPadTemplate videorawtemplate =
 239 GST_STATIC_PAD_TEMPLATE ("video_raw_sink",
 240     GST_PAD_SINK,
 241     GST_PAD_REQUEST,
 242     GST_STATIC_CAPS_ANY);
 243
 244
 245 /* props */
 246 enum
 247 {
 248   PROP_0,
 249   PROP_FLAGS,
 250   PROP_MUTE,
 251   PROP_VOLUME,
 252   PROP_FONT_DESC,
 253   PROP_SUBTITLE_ENCODING,
 254   PROP_VIS_PLUGIN,
 255   PROP_SAMPLE,
 256   PROP_AV_OFFSET,
 257   PROP_VIDEO_SINK,
 258   PROP_AUDIO_SINK,
 259   PROP_TEXT_SINK,
 260   PROP_LAST
 261 };
 262
 263 /* signals */
 264 enum
 265 {
 266   LAST_SIGNAL
 267 };
 268
 269 static void gst_play_sink_dispose (GObject * object);
 270 static void gst_play_sink_finalize (GObject * object);
 271 static void gst_play_sink_set_property (GObject * object, guint prop_id,
 272     const GValue * value, GParamSpec * spec);
 273 static void gst_play_sink_get_property (GObject * object, guint prop_id,
 274     GValue * value, GParamSpec * spec);
 275
 276 static GstPad *gst_play_sink_request_new_pad (GstElement * element,
 277     GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
 278 static void gst_play_sink_release_request_pad (GstElement * element,
 279     GstPad * pad);
 280 static gboolean gst_play_sink_send_event (GstElement * element,
 281     GstEvent * event);
 282 static GstStateChangeReturn gst_play_sink_change_state (GstElement * element,
 283     GstStateChange transition);
 284
 285 static void gst_play_sink_handle_message (GstBin * bin, GstMessage * message);
 286
 287 static void notify_volume_cb (GObject * object, GParamSpec * pspec,
 288     GstPlaySink * playsink);
 289 static void notify_mute_cb (GObject * object, GParamSpec * pspec,
 290     GstPlaySink * playsink);
 291
 292 static void update_av_offset (GstPlaySink * playsink);
 293
 294 void
 295 gst_play_marshal_SAMPLE__BOXED (GClosure * closure,
 296     GValue * return_value G_GNUC_UNUSED,
 297     guint n_param_values,
 298     const GValue * param_values,
 299     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 300 {
 301   typedef GstSample *(*GMarshalFunc_OBJECT__BOXED) (gpointer data1,
 302       gpointer arg_1, gpointer data2);
 303   register GMarshalFunc_OBJECT__BOXED callback;
 304   register GCClosure *cc = (GCClosure *) closure;
 305   register gpointer data1, data2;
 306   GstSample *v_return;
 307   g_return_if_fail (return_value != NULL);
 308   g_return_if_fail (n_param_values == 2);
 309
 310   if (G_CCLOSURE_SWAP_DATA (closure)) {
 311     data1 = closure->data;
 312     data2 = g_value_peek_pointer (param_values + 0);
 313   } else {
 314     data1 = g_value_peek_pointer (param_values + 0);
 315     data2 = closure->data;
 316   }
 317   callback =
 318       (GMarshalFunc_OBJECT__BOXED) (marshal_data ? marshal_data : cc->callback);
 319
 320   v_return = callback (data1, g_value_get_boxed (param_values + 1), data2);
 321
 322   gst_value_take_sample (return_value, v_return);
 323 }
 324
 325 /* static guint gst_play_sink_signals[LAST_SIGNAL] = { 0 }; */
 326
 327 G_DEFINE_TYPE (GstPlaySink, gst_play_sink, GST_TYPE_BIN);
 328
 329 static void
 330 gst_play_sink_class_init (GstPlaySinkClass * klass)
 331 {
 332   GObjectClass *gobject_klass;
 333   GstElementClass *gstelement_klass;
 334   GstBinClass *gstbin_klass;
 335
 336   gobject_klass = (GObjectClass *) klass;
 337   gstelement_klass = (GstElementClass *) klass;
 338   gstbin_klass = (GstBinClass *) klass;
 339
 340   gobject_klass->dispose = gst_play_sink_dispose;
 341   gobject_klass->finalize = gst_play_sink_finalize;
 342   gobject_klass->set_property = gst_play_sink_set_property;
 343   gobject_klass->get_property = gst_play_sink_get_property;
 344
 345
 346   /**
 347    * GstPlaySink:flags
 348    *
 349    * Control the behaviour of playsink.
 350    */
 351   g_object_class_install_property (gobject_klass, PROP_FLAGS,
 352       g_param_spec_flags ("flags", "Flags", "Flags to control behaviour",
 353           GST_TYPE_PLAY_FLAGS, DEFAULT_FLAGS,
 354           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 355
 356   /**
 357    * GstPlaySink:volume:
 358    *
 359    * Get or set the current audio stream volume. 1.0 means 100%,
 360    * 0.0 means mute. This uses a linear volume scale.
 361    *
 362    */
 363   g_object_class_install_property (gobject_klass, PROP_VOLUME,
 364       g_param_spec_double ("volume", "Volume", "The audio volume, 1.0=100%",
 365           0.0, VOLUME_MAX_DOUBLE, 1.0,
 366           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 367   g_object_class_install_property (gobject_klass, PROP_MUTE,
 368       g_param_spec_boolean ("mute", "Mute",
 369           "Mute the audio channel without changing the volume", FALSE,
 370           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 371   g_object_class_install_property (gobject_klass, PROP_FONT_DESC,
 372       g_param_spec_string ("subtitle-font-desc",
 373           "Subtitle font description",
 374           "Pango font description of font "
 375           "to be used for subtitle rendering", NULL,
 376           G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
 377   g_object_class_install_property (gobject_klass, PROP_SUBTITLE_ENCODING,
 378       g_param_spec_string ("subtitle-encoding", "subtitle encoding",
 379           "Encoding to assume if input subtitles are not in UTF-8 encoding. "
 380           "If not set, the GST_SUBTITLE_ENCODING environment variable will "
 381           "be checked for an encoding to use. If that is not set either, "
 382           "ISO-8859-15 will be assumed.", NULL,
 383           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 384   g_object_class_install_property (gobject_klass, PROP_VIS_PLUGIN,
 385       g_param_spec_object ("vis-plugin", "Vis plugin",
 386           "the visualization element to use (NULL = default)",
 387           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 388   /**
 389    * GstPlaySink:sample:
 390    *
 391    * Get the currently rendered or prerolled sample in the video sink.
 392    * The #GstCaps in the sample will describe the format of the buffer.
 393    */
 394   g_object_class_install_property (gobject_klass, PROP_SAMPLE,
 395       g_param_spec_boxed ("sample", "Sample",
 396           "The last sample (NULL = no video available)",
 397           GST_TYPE_SAMPLE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 398   /**
 399    * GstPlaySink:av-offset:
 400    *
 401    * Control the synchronisation offset between the audio and video streams.
 402    * Positive values make the audio ahead of the video and negative values make
 403    * the audio go behind the video.
 404    *
 405    * Since: 0.10.30
 406    */
 407   g_object_class_install_property (gobject_klass, PROP_AV_OFFSET,
 408       g_param_spec_int64 ("av-offset", "AV Offset",
 409           "The synchronisation offset between audio and video in nanoseconds",
 410           G_MININT64, G_MAXINT64, 0,
 411           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 412
 413   /**
 414    * GstPlaySink:video-sink:
 415    *
 416    * Set the used video sink element. NULL will use the default sink. playsink
 417    * must be in %GST_STATE_NULL
 418    *
 419    * Since: 0.10.36
 420    */
 421   g_object_class_install_property (gobject_klass, PROP_VIDEO_SINK,
 422       g_param_spec_object ("video-sink", "Video Sink",
 423           "the video output element to use (NULL = default sink)",
 424           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 425   /**
 426    * GstPlaySink:audio-sink:
 427    *
 428    * Set the used audio sink element. NULL will use the default sink. playsink
 429    * must be in %GST_STATE_NULL
 430    *
 431    * Since: 0.10.36
 432    */
 433   g_object_class_install_property (gobject_klass, PROP_AUDIO_SINK,
 434       g_param_spec_object ("audio-sink", "Audio Sink",
 435           "the audio output element to use (NULL = default sink)",
 436           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 437   /**
 438    * GstPlaySink:text-sink:
 439    *
 440    * Set the used text sink element. NULL will use the default sink. playsink
 441    * must be in %GST_STATE_NULL
 442    *
 443    * Since: 0.10.36
 444    */
 445   g_object_class_install_property (gobject_klass, PROP_TEXT_SINK,
 446       g_param_spec_object ("text-sink", "Text sink",
 447           "the text output element to use (NULL = default textoverlay)",
 448           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 449
 450
 451   g_signal_new ("reconfigure", G_TYPE_FROM_CLASS (klass),
 452       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstPlaySinkClass,
 453           reconfigure), NULL, NULL, gst_marshal_BOOLEAN__VOID, G_TYPE_BOOLEAN,
 454       0, G_TYPE_NONE);
 455   /**
 456    * GstPlaySink::convert-sample
 457    * @playsink: a #GstPlaySink
 458    * @caps: the target format of the sample
 459    *
 460    * Action signal to retrieve the currently playing video sample in the format
 461    * specified by @caps.
 462    * If @caps is %NULL, no conversion will be performed and this function is
 463    * equivalent to the #GstPlaySink::sample property.
 464    *
 465    * Returns: a #GstSample of the current video sample converted to #caps.
 466    * The caps in the sample will describe the final layout of the buffer data.
 467    * %NULL is returned when no current sample can be retrieved or when the
 468    * conversion failed.
 469    */
 470   g_signal_new ("convert-sample", G_TYPE_FROM_CLASS (klass),
 471       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 472       G_STRUCT_OFFSET (GstPlaySinkClass, convert_sample), NULL, NULL,
 473       gst_play_marshal_SAMPLE__BOXED, GST_TYPE_SAMPLE, 1, GST_TYPE_CAPS);
 474
 475   gst_element_class_add_pad_template (gstelement_klass,
 476       gst_static_pad_template_get (&audiorawtemplate));
 477   gst_element_class_add_pad_template (gstelement_klass,
 478       gst_static_pad_template_get (&audiotemplate));
 479   gst_element_class_add_pad_template (gstelement_klass,
 480       gst_static_pad_template_get (&videorawtemplate));
 481   gst_element_class_add_pad_template (gstelement_klass,
 482       gst_static_pad_template_get (&videotemplate));
 483   gst_element_class_add_pad_template (gstelement_klass,
 484       gst_static_pad_template_get (&texttemplate));
 485   gst_element_class_set_details_simple (gstelement_klass, "Player Sink",
 486       "Generic/Bin/Sink",
 487       "Convenience sink for multiple streams",
 488       "Wim Taymans <wim.taymans@gmail.com>");
 489
 490   gstelement_klass->change_state =
 491       GST_DEBUG_FUNCPTR (gst_play_sink_change_state);
 492   gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_sink_send_event);
 493   gstelement_klass->request_new_pad =
 494       GST_DEBUG_FUNCPTR (gst_play_sink_request_new_pad);
 495   gstelement_klass->release_pad =
 496       GST_DEBUG_FUNCPTR (gst_play_sink_release_request_pad);
 497
 498   gstbin_klass->handle_message =
 499       GST_DEBUG_FUNCPTR (gst_play_sink_handle_message);
 500
 501   klass->reconfigure = GST_DEBUG_FUNCPTR (gst_play_sink_reconfigure);
 502   klass->convert_sample = GST_DEBUG_FUNCPTR (gst_play_sink_convert_sample);
 503 }
 504
 505 static void
 506 gst_play_sink_init (GstPlaySink * playsink)
 507 {
 508   /* init groups */
 509   playsink->video_sink = NULL;
 510   playsink->audio_sink = NULL;
 511   playsink->visualisation = NULL;
 512   playsink->text_sink = NULL;
 513   playsink->volume = 1.0;
 514   playsink->font_desc = NULL;
 515   playsink->subtitle_encoding = NULL;
 516   playsink->flags = DEFAULT_FLAGS;
 517
 518   playsink->stream_synchronizer =
 519       g_object_new (GST_TYPE_STREAM_SYNCHRONIZER, NULL);
 520   gst_bin_add (GST_BIN_CAST (playsink),
 521       GST_ELEMENT_CAST (playsink->stream_synchronizer));
 522
 523   g_static_rec_mutex_init (&playsink->lock);
 524   GST_OBJECT_FLAG_SET (playsink, GST_ELEMENT_FLAG_SINK);
 525 }
 526
 527 static void
 528 disconnect_chain (GstPlayAudioChain * chain, GstPlaySink * playsink)
 529 {
 530   if (chain) {
 531     if (chain->volume)
 532       g_signal_handlers_disconnect_by_func (chain->volume, notify_volume_cb,
 533           playsink);
 534     if (chain->mute)
 535       g_signal_handlers_disconnect_by_func (chain->mute, notify_mute_cb,
 536           playsink);
 537   }
 538 }
 539
 540 static void
 541 free_chain (GstPlayChain * chain)
 542 {
 543   if (chain) {
 544     if (chain->bin)
 545       gst_object_unref (chain->bin);
 546     g_free (chain);
 547   }
 548 }
 549
 550 static void
 551 gst_play_sink_dispose (GObject * object)
 552 {
 553   GstPlaySink *playsink;
 554
 555   playsink = GST_PLAY_SINK (object);
 556
 557   if (playsink->audio_sink != NULL) {
 558     gst_element_set_state (playsink->audio_sink, GST_STATE_NULL);
 559     gst_object_unref (playsink->audio_sink);
 560     playsink->audio_sink = NULL;
 561   }
 562   if (playsink->video_sink != NULL) {
 563     gst_element_set_state (playsink->video_sink, GST_STATE_NULL);
 564     gst_object_unref (playsink->video_sink);
 565     playsink->video_sink = NULL;
 566   }
 567   if (playsink->visualisation != NULL) {
 568     gst_element_set_state (playsink->visualisation, GST_STATE_NULL);
 569     gst_object_unref (playsink->visualisation);
 570     playsink->visualisation = NULL;
 571   }
 572   if (playsink->text_sink != NULL) {
 573     gst_element_set_state (playsink->text_sink, GST_STATE_NULL);
 574     gst_object_unref (playsink->text_sink);
 575     playsink->text_sink = NULL;
 576   }
 577
 578   free_chain ((GstPlayChain *) playsink->videodeinterlacechain);
 579   playsink->videodeinterlacechain = NULL;
 580   free_chain ((GstPlayChain *) playsink->videochain);
 581   playsink->videochain = NULL;
 582   free_chain ((GstPlayChain *) playsink->audiochain);
 583   playsink->audiochain = NULL;
 584   free_chain ((GstPlayChain *) playsink->vischain);
 585   playsink->vischain = NULL;
 586   free_chain ((GstPlayChain *) playsink->textchain);
 587   playsink->textchain = NULL;
 588
 589   if (playsink->audio_tee_sink) {
 590     gst_object_unref (playsink->audio_tee_sink);
 591     playsink->audio_tee_sink = NULL;
 592   }
 593
 594   if (playsink->audio_tee_vissrc) {
 595     gst_element_release_request_pad (playsink->audio_tee,
 596         playsink->audio_tee_vissrc);
 597     gst_object_unref (playsink->audio_tee_vissrc);
 598     playsink->audio_tee_vissrc = NULL;
 599   }
 600
 601   if (playsink->audio_tee_asrc) {
 602     gst_element_release_request_pad (playsink->audio_tee,
 603         playsink->audio_tee_asrc);
 604     gst_object_unref (playsink->audio_tee_asrc);
 605     playsink->audio_tee_asrc = NULL;
 606   }
 607
 608   g_free (playsink->font_desc);
 609   playsink->font_desc = NULL;
 610
 611   g_free (playsink->subtitle_encoding);
 612   playsink->subtitle_encoding = NULL;
 613
 614   playsink->stream_synchronizer = NULL;
 615
 616   G_OBJECT_CLASS (gst_play_sink_parent_class)->dispose (object);
 617 }
 618
 619 static void
 620 gst_play_sink_finalize (GObject * object)
 621 {
 622   GstPlaySink *playsink;
 623
 624   playsink = GST_PLAY_SINK (object);
 625
 626   g_static_rec_mutex_free (&playsink->lock);
 627
 628   G_OBJECT_CLASS (gst_play_sink_parent_class)->finalize (object);
 629 }
 630
 631 void
 632 gst_play_sink_set_sink (GstPlaySink * playsink, GstPlaySinkType type,
 633     GstElement * sink)
 634 {
 635   GstElement **elem = NULL, *old = NULL;
 636
 637   GST_LOG ("Setting sink %" GST_PTR_FORMAT " as sink type %d", sink, type);
 638
 639   GST_PLAY_SINK_LOCK (playsink);
 640   switch (type) {
 641     case GST_PLAY_SINK_TYPE_AUDIO:
 642     case GST_PLAY_SINK_TYPE_AUDIO_RAW:
 643       elem = &playsink->audio_sink;
 644       break;
 645     case GST_PLAY_SINK_TYPE_VIDEO:
 646     case GST_PLAY_SINK_TYPE_VIDEO_RAW:
 647       elem = &playsink->video_sink;
 648       break;
 649     case GST_PLAY_SINK_TYPE_TEXT:
 650       elem = &playsink->text_sink;
 651       break;
 652     default:
 653       break;
 654   }
 655   if (elem) {
 656     old = *elem;
 657     if (sink)
 658       gst_object_ref (sink);
 659     *elem = sink;
 660   }
 661   GST_PLAY_SINK_UNLOCK (playsink);
 662
 663   if (old) {
 664     if (old != sink)
 665       gst_element_set_state (old, GST_STATE_NULL);
 666     gst_object_unref (old);
 667   }
 668 }
 669
 670 GstElement *
 671 gst_play_sink_get_sink (GstPlaySink * playsink, GstPlaySinkType type)
 672 {
 673   GstElement *result = NULL;
 674   GstElement *elem = NULL, *chainp = NULL;
 675
 676   GST_PLAY_SINK_LOCK (playsink);
 677   switch (type) {
 678     case GST_PLAY_SINK_TYPE_AUDIO:
 679     case GST_PLAY_SINK_TYPE_AUDIO_RAW:
 680     {
 681       GstPlayAudioChain *chain;
 682       if ((chain = (GstPlayAudioChain *) playsink->audiochain))
 683         chainp = chain->sink;
 684       elem = playsink->audio_sink;
 685       break;
 686     }
 687     case GST_PLAY_SINK_TYPE_VIDEO:
 688     case GST_PLAY_SINK_TYPE_VIDEO_RAW:
 689     {
 690       GstPlayVideoChain *chain;
 691       if ((chain = (GstPlayVideoChain *) playsink->videochain))
 692         chainp = chain->sink;
 693       elem = playsink->video_sink;
 694       break;
 695     }
 696     case GST_PLAY_SINK_TYPE_TEXT:
 697     {
 698       GstPlayTextChain *chain;
 699       if ((chain = (GstPlayTextChain *) playsink->textchain))
 700         chainp = chain->sink;
 701       elem = playsink->text_sink;
 702       break;
 703     }
 704     default:
 705       break;
 706   }
 707   if (chainp) {
 708     /* we have an active chain with a sink, get the sink */
 709     result = gst_object_ref (chainp);
 710   }
 711   /* nothing found, return last configured sink */
 712   if (result == NULL && elem)
 713     result = gst_object_ref (elem);
 714   GST_PLAY_SINK_UNLOCK (playsink);
 715
 716   return result;
 717 }
 718
 719 static GstPadProbeReturn
 720 gst_play_sink_vis_blocked (GstPad * tee_pad, GstPadProbeInfo * info,
 721     gpointer user_data)
 722 {
 723   GstPlaySink *playsink;
 724   GstPlayVisChain *chain;
 725
 726   playsink = GST_PLAY_SINK (user_data);
 727
 728   GST_PLAY_SINK_LOCK (playsink);
 729   GST_DEBUG_OBJECT (playsink, "vis pad blocked");
 730   /* now try to change the plugin in the running vis chain */
 731   if (!(chain = (GstPlayVisChain *) playsink->vischain))
 732     goto done;
 733
 734   /* unlink the old plugin and unghost the pad */
 735   gst_pad_unlink (chain->blockpad, chain->vissinkpad);
 736   gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad), NULL);
 737
 738   /* set the old plugin to NULL and remove */
 739   gst_element_set_state (chain->vis, GST_STATE_NULL);
 740   gst_bin_remove (GST_BIN_CAST (chain->chain.bin), chain->vis);
 741
 742   /* add new plugin and set state to playing */
 743   chain->vis = playsink->visualisation;
 744   gst_bin_add (GST_BIN_CAST (chain->chain.bin), chain->vis);
 745   gst_element_set_state (chain->vis, GST_STATE_PLAYING);
 746
 747   /* get pads */
 748   chain->vissinkpad = gst_element_get_static_pad (chain->vis, "sink");
 749   chain->vissrcpad = gst_element_get_static_pad (chain->vis, "src");
 750
 751   /* link pads */
 752   gst_pad_link_full (chain->blockpad, chain->vissinkpad,
 753       GST_PAD_LINK_CHECK_NOTHING);
 754   gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad),
 755       chain->vissrcpad);
 756
 757 done:
 758   GST_PLAY_SINK_UNLOCK (playsink);
 759
 760   /* remove the probe and unblock the pad */
 761   return GST_PAD_PROBE_REMOVE;
 762 }
 763
 764 void
 765 gst_play_sink_set_vis_plugin (GstPlaySink * playsink, GstElement * vis)
 766 {
 767   GstPlayVisChain *chain;
 768
 769   /* setting NULL means creating the default vis plugin */
 770   if (vis == NULL)
 771     vis = gst_element_factory_make ("goom", "vis");
 772
 773   /* simply return if we don't have a vis plugin here */
 774   if (vis == NULL)
 775     return;
 776
 777   GST_PLAY_SINK_LOCK (playsink);
 778   /* first store the new vis */
 779   if (playsink->visualisation)
 780     gst_object_unref (playsink->visualisation);
 781   /* take ownership */
 782   gst_object_ref_sink (vis);
 783   playsink->visualisation = vis;
 784
 785   /* now try to change the plugin in the running vis chain, if we have no chain,
 786    * we don't bother, any future vis chain will be created with the new vis
 787    * plugin. */
 788   if (!(chain = (GstPlayVisChain *) playsink->vischain))
 789     goto done;
 790
 791   /* block the pad, the next time the callback is called we can change the
 792    * visualisation. It's possible that this never happens or that the pad was
 793    * already blocked. If the callback never happens, we don't have new data so
 794    * we don't need the new vis plugin. If the pad was already blocked, the
 795    * function returns FALSE but the previous pad block will do the right thing
 796    * anyway. */
 797   GST_DEBUG_OBJECT (playsink, "blocking vis pad");
 798   gst_pad_add_probe (chain->blockpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
 799       gst_play_sink_vis_blocked, playsink, NULL);
 800 done:
 801   GST_PLAY_SINK_UNLOCK (playsink);
 802
 803   return;
 804 }
 805
 806 GstElement *
 807 gst_play_sink_get_vis_plugin (GstPlaySink * playsink)
 808 {
 809   GstElement *result = NULL;
 810   GstPlayVisChain *chain;
 811
 812   GST_PLAY_SINK_LOCK (playsink);
 813   if ((chain = (GstPlayVisChain *) playsink->vischain)) {
 814     /* we have an active chain, get the sink */
 815     if (chain->vis)
 816       result = gst_object_ref (chain->vis);
 817   }
 818   /* nothing found, return last configured sink */
 819   if (result == NULL && playsink->visualisation)
 820     result = gst_object_ref (playsink->visualisation);
 821   GST_PLAY_SINK_UNLOCK (playsink);
 822
 823   return result;
 824 }
 825
 826 void
 827 gst_play_sink_set_volume (GstPlaySink * playsink, gdouble volume)
 828 {
 829   GstPlayAudioChain *chain;
 830
 831   GST_PLAY_SINK_LOCK (playsink);
 832   playsink->volume = volume;
 833   chain = (GstPlayAudioChain *) playsink->audiochain;
 834   if (chain && chain->volume) {
 835     GST_LOG_OBJECT (playsink, "elements: volume=%" GST_PTR_FORMAT ", mute=%"
 836         GST_PTR_FORMAT "; new volume=%.03f, mute=%d", chain->volume,
 837         chain->mute, volume, playsink->mute);
 838     /* if there is a mute element or we are not muted, set the volume */
 839     if (chain->mute || !playsink->mute)
 840       g_object_set (chain->volume, "volume", volume, NULL);
 841   } else {
 842     GST_LOG_OBJECT (playsink, "no volume element");
 843     playsink->volume_changed = TRUE;
 844   }
 845   GST_PLAY_SINK_UNLOCK (playsink);
 846 }
 847
 848 gdouble
 849 gst_play_sink_get_volume (GstPlaySink * playsink)
 850 {
 851   gdouble result;
 852   GstPlayAudioChain *chain;
 853
 854   GST_PLAY_SINK_LOCK (playsink);
 855   chain = (GstPlayAudioChain *) playsink->audiochain;
 856   result = playsink->volume;
 857   if (chain && chain->volume) {
 858     if (chain->mute || !playsink->mute) {
 859       g_object_get (chain->volume, "volume", &result, NULL);
 860       playsink->volume = result;
 861     }
 862   }
 863   GST_PLAY_SINK_UNLOCK (playsink);
 864
 865   return result;
 866 }
 867
 868 void
 869 gst_play_sink_set_mute (GstPlaySink * playsink, gboolean mute)
 870 {
 871   GstPlayAudioChain *chain;
 872
 873   GST_PLAY_SINK_LOCK (playsink);
 874   playsink->mute = mute;
 875   chain = (GstPlayAudioChain *) playsink->audiochain;
 876   if (chain) {
 877     if (chain->mute) {
 878       g_object_set (chain->mute, "mute", mute, NULL);
 879     } else if (chain->volume) {
 880       if (mute)
 881         g_object_set (chain->volume, "volume", (gdouble) 0.0, NULL);
 882       else
 883         g_object_set (chain->volume, "volume", (gdouble) playsink->volume,
 884             NULL);
 885     }
 886   } else {
 887     playsink->mute_changed = TRUE;
 888   }
 889   GST_PLAY_SINK_UNLOCK (playsink);
 890 }
 891
 892 gboolean
 893 gst_play_sink_get_mute (GstPlaySink * playsink)
 894 {
 895   gboolean result;
 896   GstPlayAudioChain *chain;
 897
 898   GST_PLAY_SINK_LOCK (playsink);
 899   chain = (GstPlayAudioChain *) playsink->audiochain;
 900   if (chain && chain->mute) {
 901     g_object_get (chain->mute, "mute", &result, NULL);
 902     playsink->mute = result;
 903   } else {
 904     result = playsink->mute;
 905   }
 906   GST_PLAY_SINK_UNLOCK (playsink);
 907
 908   return result;
 909 }
 910
 911 static void
 912 post_missing_element_message (GstPlaySink * playsink, const gchar * name)
 913 {
 914   GstMessage *msg;
 915
 916   msg = gst_missing_element_message_new (GST_ELEMENT_CAST (playsink), name);
 917   gst_element_post_message (GST_ELEMENT_CAST (playsink), msg);
 918 }
 919
 920 static gboolean
 921 add_chain (GstPlayChain * chain, gboolean add)
 922 {
 923   if (chain->added == add)
 924     return TRUE;
 925
 926   if (add)
 927     gst_bin_add (GST_BIN_CAST (chain->playsink), chain->bin);
 928   else {
 929     gst_bin_remove (GST_BIN_CAST (chain->playsink), chain->bin);
 930     /* we don't want to lose our sink status */
 931     GST_OBJECT_FLAG_SET (chain->playsink, GST_ELEMENT_FLAG_SINK);
 932   }
 933
 934   chain->added = add;
 935
 936   return TRUE;
 937 }
 938
 939 static gboolean
 940 activate_chain (GstPlayChain * chain, gboolean activate)
 941 {
 942   GstState state;
 943
 944   if (chain->activated == activate)
 945     return TRUE;
 946
 947   GST_OBJECT_LOCK (chain->playsink);
 948   state = GST_STATE_TARGET (chain->playsink);
 949   GST_OBJECT_UNLOCK (chain->playsink);
 950
 951   if (activate)
 952     gst_element_set_state (chain->bin, state);
 953   else
 954     gst_element_set_state (chain->bin, GST_STATE_NULL);
 955
 956   chain->activated = activate;
 957
 958   return TRUE;
 959 }
 960
 961 static gboolean
 962 element_is_sink (GstElement * element)
 963 {
 964   gboolean is_sink;
 965
 966   GST_OBJECT_LOCK (element);
 967   is_sink = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SINK);
 968   GST_OBJECT_UNLOCK (element);
 969
 970   GST_DEBUG_OBJECT (element, "is a sink: %s", (is_sink) ? "yes" : "no");
 971   return is_sink;
 972 }
 973
 974 static gboolean
 975 element_has_property (GstElement * element, const gchar * pname, GType type)
 976 {
 977   GParamSpec *pspec;
 978
 979   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (element), pname);
 980
 981   if (pspec == NULL) {
 982     GST_DEBUG_OBJECT (element, "no %s property", pname);
 983     return FALSE;
 984   }
 985
 986   if (type == G_TYPE_INVALID || type == pspec->value_type ||
 987       g_type_is_a (pspec->value_type, type)) {
 988     GST_DEBUG_OBJECT (element, "has %s property of type %s", pname,
 989         (type == G_TYPE_INVALID) ? "any type" : g_type_name (type));
 990     return TRUE;
 991   }
 992
 993   GST_WARNING_OBJECT (element, "has %s property, but property is of type %s "
 994       "and we expected it to be of type %s", pname,
 995       g_type_name (pspec->value_type), g_type_name (type));
 996
 997   return FALSE;
 998 }
 999
1000 typedef struct
1001 {
1002   const gchar *prop_name;
1003   GType prop_type;
1004   gboolean need_sink;
1005 } FindPropertyHelper;
1006
1007 static gint
1008 find_property (const GValue * item, FindPropertyHelper * helper)
1009 {
1010   GstElement *element = g_value_get_object (item);
1011   if (helper->need_sink && !element_is_sink (element)) {
1012     return 1;
1013   }
1014
1015   if (!element_has_property (element, helper->prop_name, helper->prop_type)) {
1016     return 1;
1017   }
1018
1019   GST_INFO_OBJECT (element, "found %s with %s property", helper->prop_name,
1020       (helper->need_sink) ? "sink" : "element");
1021   return 0;                     /* keep it */
1022 }
1023
1024 /* FIXME: why not move these functions into core? */
1025 /* find a sink in the hierarchy with a property named @name. This function does
1026  * not increase the refcount of the returned object and thus remains valid as
1027  * long as the bin is valid. */
1028 static GstElement *
1029 gst_play_sink_find_property_sinks (GstPlaySink * playsink, GstElement * obj,
1030     const gchar * name, GType expected_type)
1031 {
1032   GstElement *result = NULL;
1033   GstIterator *it;
1034
1035   if (element_has_property (obj, name, expected_type)) {
1036     result = obj;
1037   } else if (GST_IS_BIN (obj)) {
1038     gboolean found;
1039     GValue item = { 0, };
1040     FindPropertyHelper helper = { name, expected_type, TRUE };
1041
1042     it = gst_bin_iterate_recurse (GST_BIN_CAST (obj));
1043     found = gst_iterator_find_custom (it,
1044         (GCompareFunc) find_property, &item, &helper);
1045     gst_iterator_free (it);
1046     if (found) {
1047       result = g_value_get_object (&item);
1048       /* we don't need the extra ref */
1049       g_value_unset (&item);
1050     }
1051   }
1052   return result;
1053 }
1054
1055 /* find an object in the hierarchy with a property named @name */
1056 static GstElement *
1057 gst_play_sink_find_property (GstPlaySink * playsink, GstElement * obj,
1058     const gchar * name, GType expected_type)
1059 {
1060   GstElement *result = NULL;
1061   GstIterator *it;
1062
1063   if (GST_IS_BIN (obj)) {
1064     gboolean found;
1065     GValue item = { 0, };
1066     FindPropertyHelper helper = { name, expected_type, FALSE };
1067
1068     it = gst_bin_iterate_recurse (GST_BIN_CAST (obj));
1069     found = gst_iterator_find_custom (it,
1070         (GCompareFunc) find_property, &item, &helper);
1071     gst_iterator_free (it);
1072     if (found)
1073       result = g_value_dup_object (&item);
1074     g_value_unset (&item);
1075   } else {
1076     if (element_has_property (obj, name, expected_type)) {
1077       result = obj;
1078       gst_object_ref (obj);
1079     }
1080   }
1081   return result;
1082 }
1083
1084 static void
1085 do_async_start (GstPlaySink * playsink)
1086 {
1087   GstMessage *message;
1088
1089   if (!playsink->need_async_start) {
1090     GST_INFO_OBJECT (playsink, "no async_start needed");
1091     return;
1092   }
1093
1094   playsink->async_pending = TRUE;
1095
1096   GST_INFO_OBJECT (playsink, "Sending async_start message");
1097   message = gst_message_new_async_start (GST_OBJECT_CAST (playsink));
1098   GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (GST_BIN_CAST
1099       (playsink), message);
1100 }
1101
1102 static void
1103 do_async_done (GstPlaySink * playsink)
1104 {
1105   GstMessage *message;
1106
1107   if (playsink->async_pending) {
1108     GST_INFO_OBJECT (playsink, "Sending async_done message");
1109     message = gst_message_new_async_done (GST_OBJECT_CAST (playsink), FALSE);
1110     GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (GST_BIN_CAST
1111         (playsink), message);
1112
1113     playsink->async_pending = FALSE;
1114   }
1115
1116   playsink->need_async_start = FALSE;
1117 }
1118
1119 /* try to change the state of an element. This function returns the element when
1120  * the state change could be performed. When this function returns NULL an error
1121  * occured and the element is unreffed if @unref is TRUE. */
1122 static GstElement *
1123 try_element (GstPlaySink * playsink, GstElement * element, gboolean unref)
1124 {
1125   GstStateChangeReturn ret;
1126
1127   if (element) {
1128     ret = gst_element_set_state (element, GST_STATE_READY);
1129     if (ret == GST_STATE_CHANGE_FAILURE) {
1130       GST_DEBUG_OBJECT (playsink, "failed state change..");
1131       gst_element_set_state (element, GST_STATE_NULL);
1132       if (unref)
1133         gst_object_unref (element);
1134       element = NULL;
1135     }
1136   }
1137   return element;
1138 }
1139
1140 /* make the element (bin) that contains the elements needed to perform
1141  * video display. Only used for *raw* video streams.
1142  *
1143  *  +------------------------------------------------------------+
1144  *  | vbin                                                       |
1145  *  |      +-------+   +----------+   +----------+   +---------+ |
1146  *  |      | queue |   |colorspace|   |videoscale|   |videosink| |
1147  *  |   +-sink    src-sink       src-sink       src-sink       | |
1148  *  |   |  +-------+   +----------+   +----------+   +---------+ |
1149  * sink-+                                                        |
1150  *  +------------------------------------------------------------+
1151  *
1152  */
1153 static GstPlayVideoDeinterlaceChain *
1154 gen_video_deinterlace_chain (GstPlaySink * playsink)
1155 {
1156   GstPlayVideoDeinterlaceChain *chain;
1157   GstBin *bin;
1158   GstPad *pad;
1159   GstElement *head = NULL, *prev = NULL;
1160
1161   chain = g_new0 (GstPlayVideoDeinterlaceChain, 1);
1162   chain->chain.playsink = playsink;
1163
1164   GST_DEBUG_OBJECT (playsink, "making video deinterlace chain %p", chain);
1165
1166   /* create a bin to hold objects, as we create them we add them to this bin so
1167    * that when something goes wrong we only need to unref the bin */
1168   chain->chain.bin = gst_bin_new ("vdbin");
1169   bin = GST_BIN_CAST (chain->chain.bin);
1170   gst_object_ref_sink (bin);
1171
1172   GST_DEBUG_OBJECT (playsink, "creating " COLORSPACE);
1173   chain->conv = gst_element_factory_make (COLORSPACE, "vdconv");
1174   if (chain->conv == NULL) {
1175     post_missing_element_message (playsink, COLORSPACE);
1176     GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1177         (_("Missing element '%s' - check your GStreamer installation."),
1178             COLORSPACE), ("video rendering might fail"));
1179   } else {
1180     gst_bin_add (bin, chain->conv);
1181     head = chain->conv;
1182     prev = chain->conv;
1183   }
1184
1185   GST_DEBUG_OBJECT (playsink, "creating deinterlace");
1186   chain->deinterlace = gst_element_factory_make ("deinterlace", "deinterlace");
1187   if (chain->deinterlace == NULL) {
1188     post_missing_element_message (playsink, "deinterlace");
1189     GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1190         (_("Missing element '%s' - check your GStreamer installation."),
1191             "deinterlace"), ("deinterlacing won't work"));
1192   } else {
1193     gst_bin_add (bin, chain->deinterlace);
1194     if (prev) {
1195       if (!gst_element_link_pads_full (prev, "src", chain->deinterlace, "sink",
1196               GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
1197         goto link_failed;
1198     } else {
1199       head = chain->deinterlace;
1200     }
1201     prev = chain->deinterlace;
1202   }
1203
1204   if (head) {
1205     pad = gst_element_get_static_pad (head, "sink");
1206     chain->sinkpad = gst_ghost_pad_new ("sink", pad);
1207     gst_object_unref (pad);
1208   } else {
1209     chain->sinkpad = gst_ghost_pad_new_no_target ("sink", GST_PAD_SINK);
1210   }
1211
1212   if (prev) {
1213     pad = gst_element_get_static_pad (prev, "src");
1214     chain->srcpad = gst_ghost_pad_new ("src", pad);
1215     gst_object_unref (pad);
1216   } else {
1217     chain->srcpad = gst_ghost_pad_new ("src", chain->sinkpad);
1218   }
1219
1220   gst_element_add_pad (chain->chain.bin, chain->sinkpad);
1221   gst_element_add_pad (chain->chain.bin, chain->srcpad);
1222
1223   return chain;
1224
1225 link_failed:
1226   {
1227     GST_ELEMENT_ERROR (playsink, CORE, PAD,
1228         (NULL), ("Failed to configure the video deinterlace chain."));
1229     free_chain ((GstPlayChain *) chain);
1230     return NULL;
1231   }
1232 }
1233
1234 /* make the element (bin) that contains the elements needed to perform
1235  * video display.
1236  *
1237  *  +------------------------------------------------------------+
1238  *  | vbin                                                       |
1239  *  |      +-------+   +----------+   +----------+   +---------+ |
1240  *  |      | queue |   |colorspace|   |videoscale|   |videosink| |
1241  *  |   +-sink    src-sink       src-sink       src-sink       | |
1242  *  |   |  +-------+   +----------+   +----------+   +---------+ |
1243  * sink-+                                                        |
1244  *  +------------------------------------------------------------+
1245  *
1246  */
1247 static GstPlayVideoChain *
1248 gen_video_chain (GstPlaySink * playsink, gboolean raw, gboolean async)
1249 {
1250   GstPlayVideoChain *chain;
1251   GstBin *bin;
1252   GstPad *pad;
1253   GstElement *head = NULL, *prev = NULL, *elem = NULL;
1254
1255   chain = g_new0 (GstPlayVideoChain, 1);
1256   chain->chain.playsink = playsink;
1257   chain->chain.raw = raw;
1258
1259   GST_DEBUG_OBJECT (playsink, "making video chain %p", chain);
1260
1261   if (playsink->video_sink) {
1262     GST_DEBUG_OBJECT (playsink, "trying configured videosink");
1263     chain->sink = try_element (playsink, playsink->video_sink, FALSE);
1264   } else {
1265     /* only try fallback if no specific sink was chosen */
1266     if (chain->sink == NULL) {
1267       GST_DEBUG_OBJECT (playsink, "trying autovideosink");
1268       elem = gst_element_factory_make ("autovideosink", "videosink");
1269       chain->sink = try_element (playsink, elem, TRUE);
1270     }
1271     if (chain->sink == NULL) {
1272       /* if default sink from config.h is different then try it too */
1273       if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
1274         GST_DEBUG_OBJECT (playsink, "trying " DEFAULT_VIDEOSINK);
1275         elem = gst_element_factory_make (DEFAULT_VIDEOSINK, "videosink");
1276         chain->sink = try_element (playsink, elem, TRUE);
1277       }
1278     }
1279     if (chain->sink)
1280       playsink->video_sink = gst_object_ref (chain->sink);
1281   }
1282   if (chain->sink == NULL)
1283     goto no_sinks;
1284   head = chain->sink;
1285
1286   /* if we can disable async behaviour of the sink, we can avoid adding a
1287    * queue for the audio chain. */
1288   elem =
1289       gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
1290       G_TYPE_BOOLEAN);
1291   if (elem) {
1292     GST_DEBUG_OBJECT (playsink, "setting async property to %d on element %s",
1293         async, GST_ELEMENT_NAME (elem));
1294     g_object_set (elem, "async", async, NULL);
1295     chain->async = async;
1296   } else {
1297     GST_DEBUG_OBJECT (playsink, "no async property on the sink");
1298     chain->async = TRUE;
1299   }
1300
1301   /* find ts-offset element */
1302   gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
1303       gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
1304           G_TYPE_INT64));
1305
1306   /* create a bin to hold objects, as we create them we add them to this bin so
1307    * that when something goes wrong we only need to unref the bin */
1308   chain->chain.bin = gst_bin_new ("vbin");
1309   bin = GST_BIN_CAST (chain->chain.bin);
1310   gst_object_ref_sink (bin);
1311   gst_bin_add (bin, chain->sink);
1312
1313   /* decouple decoder from sink, this improves playback quite a lot since the
1314    * decoder can continue while the sink blocks for synchronisation. We don't
1315    * need a lot of buffers as this consumes a lot of memory and we don't want
1316    * too little because else we would be context switching too quickly. */
1317   chain->queue = gst_element_factory_make ("queue", "vqueue");
1318   if (chain->queue == NULL) {
1319     post_missing_element_message (playsink, "queue");
1320     GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1321         (_("Missing element '%s' - check your GStreamer installation."),
1322             "queue"), ("video rendering might be suboptimal"));
1323     head = chain->sink;
1324     prev = NULL;
1325   } else {
1326     g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
1327         "max-size-bytes", 0, "max-size-time", (gint64) 0, "silent", TRUE, NULL);
1328     gst_bin_add (bin, chain->queue);
1329     head = prev = chain->queue;
1330   }
1331
1332   if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_VIDEO)) {
1333     GST_DEBUG_OBJECT (playsink, "creating videoconverter");
1334     chain->conv =
1335         g_object_new (GST_TYPE_PLAY_SINK_VIDEO_CONVERT, "name", "vconv", NULL);
1336     gst_bin_add (bin, chain->conv);
1337     if (prev) {
1338       if (!gst_element_link_pads_full (prev, "src", chain->conv, "sink",
1339               GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
1340         goto link_failed;
1341     } else {
1342       head = chain->conv;
1343     }
1344     prev = chain->conv;
1345   }
1346
1347   if (prev) {
1348     GST_DEBUG_OBJECT (playsink, "linking to sink");
1349     if (!gst_element_link_pads_full (prev, "src", chain->sink, NULL,
1350             GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
1351       goto link_failed;
1352   }
1353
1354   pad = gst_element_get_static_pad (head, "sink");
1355   chain->sinkpad = gst_ghost_pad_new ("sink", pad);
1356   gst_object_unref (pad);
1357
1358   gst_element_add_pad (chain->chain.bin, chain->sinkpad);
1359
1360   return chain;
1361
1362   /* ERRORS */
1363 no_sinks:
1364   {
1365     if (!elem && !playsink->video_sink) {
1366       post_missing_element_message (playsink, "autovideosink");
1367       if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
1368         post_missing_element_message (playsink, DEFAULT_VIDEOSINK);
1369         GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
1370             (_("Both autovideosink and %s elements are missing."),
1371                 DEFAULT_VIDEOSINK), (NULL));
1372       } else {
1373         GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
1374             (_("The autovideosink element is missing.")), (NULL));
1375       }
1376     } else {
1377       if (playsink->video_sink) {
1378         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1379             (_("Configured videosink %s is not working."),
1380                 GST_ELEMENT_NAME (playsink->video_sink)), (NULL));
1381       } else if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
1382         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1383             (_("Both autovideosink and %s elements are not working."),
1384                 DEFAULT_VIDEOSINK), (NULL));
1385       } else {
1386         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1387             (_("The autovideosink element is not working.")), (NULL));
1388       }
1389     }
1390     free_chain ((GstPlayChain *) chain);
1391     return NULL;
1392   }
1393 link_failed:
1394   {
1395     GST_ELEMENT_ERROR (playsink, CORE, PAD,
1396         (NULL), ("Failed to configure the video sink."));
1397     /* checking sink made it READY */
1398     gst_element_set_state (chain->sink, GST_STATE_NULL);
1399     /* Remove chain from the bin to allow reuse later */
1400     gst_bin_remove (bin, chain->sink);
1401     free_chain ((GstPlayChain *) chain);
1402     return NULL;
1403   }
1404 }
1405
1406 static gboolean
1407 setup_video_chain (GstPlaySink * playsink, gboolean raw, gboolean async)
1408 {
1409   GstElement *elem;
1410   GstPlayVideoChain *chain;
1411   GstStateChangeReturn ret;
1412
1413   chain = playsink->videochain;
1414
1415   chain->chain.raw = raw;
1416
1417   /* if the chain was active we don't do anything */
1418   if (GST_PLAY_CHAIN (chain)->activated == TRUE)
1419     return TRUE;
1420
1421   /* try to set the sink element to READY again */
1422   ret = gst_element_set_state (chain->sink, GST_STATE_READY);
1423   if (ret == GST_STATE_CHANGE_FAILURE)
1424     return FALSE;
1425
1426   /* find ts-offset element */
1427
1428   gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
1429       gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
1430           G_TYPE_INT64));
1431
1432   /* if we can disable async behaviour of the sink, we can avoid adding a
1433    * queue for the audio chain. */
1434   elem =
1435       gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
1436       G_TYPE_BOOLEAN);
1437   if (elem) {
1438     GST_DEBUG_OBJECT (playsink, "setting async property to %d on element %s",
1439         async, GST_ELEMENT_NAME (elem));
1440     g_object_set (elem, "async", async, NULL);
1441     chain->async = async;
1442   } else {
1443     GST_DEBUG_OBJECT (playsink, "no async property on the sink");
1444     chain->async = TRUE;
1445   }
1446   return TRUE;
1447 }
1448
1449 /* make an element for playback of video with subtitles embedded.
1450  * Only used for *raw* video streams.
1451  *
1452  *  +--------------------------------------------+
1453  *  | tbin                                       |
1454  *  |     +--------+      +-----------------+    |
1455  *  |     | queue  |      | subtitleoverlay |    |
1456  * video--src     sink---video_sink         |    |
1457  *  |     +--------+     |                src--src
1458  * text------------------text_sink          |    |
1459  *  |                     +-----------------+    |
1460  *  +--------------------------------------------+
1461  *
1462  */
1463 static GstPlayTextChain *
1464 gen_text_chain (GstPlaySink * playsink)
1465 {
1466   GstPlayTextChain *chain;
1467   GstBin *bin;
1468   GstElement *elem;
1469   GstPad *videosinkpad, *textsinkpad, *srcpad;
1470
1471   chain = g_new0 (GstPlayTextChain, 1);
1472   chain->chain.playsink = playsink;
1473
1474   GST_DEBUG_OBJECT (playsink, "making text chain %p", chain);
1475
1476   chain->chain.bin = gst_bin_new ("tbin");
1477   bin = GST_BIN_CAST (chain->chain.bin);
1478   gst_object_ref_sink (bin);
1479
1480   videosinkpad = textsinkpad = srcpad = NULL;
1481
1482   /* first try to hook the text pad to the custom sink */
1483   if (playsink->text_sink) {
1484     GST_DEBUG_OBJECT (playsink, "trying configured textsink");
1485     chain->sink = try_element (playsink, playsink->text_sink, FALSE);
1486     if (chain->sink) {
1487       elem =
1488           gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
1489           G_TYPE_BOOLEAN);
1490       if (elem) {
1491         /* make sure the sparse subtitles don't participate in the preroll */
1492         g_object_set (elem, "async", FALSE, NULL);
1493         GST_DEBUG_OBJECT (playsink, "adding custom text sink");
1494         gst_bin_add (bin, chain->sink);
1495         /* NOTE streamsynchronizer needs streams decoupled */
1496         /* make a little queue */
1497         chain->queue = gst_element_factory_make ("queue", "subqueue");
1498         if (chain->queue == NULL) {
1499           post_missing_element_message (playsink, "queue");
1500           GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1501               (_("Missing element '%s' - check your GStreamer installation."),
1502                   "queue"), ("rendering might be suboptimal"));
1503         } else {
1504           g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
1505               "max-size-bytes", 0, "max-size-time", (gint64) 0,
1506               "silent", TRUE, NULL);
1507           gst_bin_add (bin, chain->queue);
1508         }
1509         /* we have a custom sink, this will be our textsinkpad */
1510         if (gst_element_link_pads_full (chain->queue, "src", chain->sink,
1511                 "sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS)) {
1512           /* we're all fine now and we can add the sink to the chain */
1513           GST_DEBUG_OBJECT (playsink, "using custom text sink");
1514           textsinkpad = gst_element_get_static_pad (chain->queue, "sink");
1515         } else {
1516           GST_WARNING_OBJECT (playsink,
1517               "can't find a sink pad on custom text sink");
1518           gst_bin_remove (bin, chain->sink);
1519           gst_bin_remove (bin, chain->queue);
1520           chain->sink = NULL;
1521           chain->queue = NULL;
1522         }
1523         /* try to set sync to true but it's no biggie when we can't */
1524         if ((elem =
1525                 gst_play_sink_find_property_sinks (playsink, chain->sink,
1526                     "sync", G_TYPE_BOOLEAN)))
1527           g_object_set (elem, "sync", TRUE, NULL);
1528
1529         if (!textsinkpad)
1530           gst_bin_remove (bin, chain->sink);
1531       } else {
1532         GST_WARNING_OBJECT (playsink,
1533             "can't find async property in custom text sink");
1534       }
1535     }
1536     if (textsinkpad == NULL) {
1537       GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1538           (_("Custom text sink element is not usable.")),
1539           ("fallback to default textoverlay"));
1540     }
1541   }
1542
1543   if (textsinkpad == NULL) {
1544     if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_VIDEO)) {
1545       /* make a little queue */
1546       chain->queue = gst_element_factory_make ("queue", "vqueue");
1547       if (chain->queue == NULL) {
1548         post_missing_element_message (playsink, "queue");
1549         GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1550             (_("Missing element '%s' - check your GStreamer installation."),
1551                 "queue"), ("video rendering might be suboptimal"));
1552       } else {
1553         g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
1554             "max-size-bytes", 0, "max-size-time", (gint64) 0,
1555             "silent", TRUE, NULL);
1556         gst_bin_add (bin, chain->queue);
1557         videosinkpad = gst_element_get_static_pad (chain->queue, "sink");
1558       }
1559
1560       chain->overlay =
1561           gst_element_factory_make ("subtitleoverlay", "suboverlay");
1562       if (chain->overlay == NULL) {
1563         post_missing_element_message (playsink, "subtitleoverlay");
1564         GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1565             (_("Missing element '%s' - check your GStreamer installation."),
1566                 "subtitleoverlay"), ("subtitle rendering disabled"));
1567       } else {
1568         GstElement *element;
1569
1570         gst_bin_add (bin, chain->overlay);
1571
1572         g_object_set (G_OBJECT (chain->overlay), "silent", FALSE, NULL);
1573         if (playsink->font_desc) {
1574           g_object_set (G_OBJECT (chain->overlay), "font-desc",
1575               playsink->font_desc, NULL);
1576         }
1577         if (playsink->subtitle_encoding) {
1578           g_object_set (G_OBJECT (chain->overlay), "subtitle-encoding",
1579               playsink->subtitle_encoding, NULL);
1580         }
1581
1582         gst_element_link_pads_full (chain->queue, "src", chain->overlay,
1583             "video_sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS);
1584
1585         /* make another little queue to decouple streams */
1586         element = gst_element_factory_make ("queue", "subqueue");
1587         if (element == NULL) {
1588           post_missing_element_message (playsink, "queue");
1589           GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1590               (_("Missing element '%s' - check your GStreamer installation."),
1591                   "queue"), ("rendering might be suboptimal"));
1592         } else {
1593           g_object_set (G_OBJECT (element), "max-size-buffers", 3,
1594               "max-size-bytes", 0, "max-size-time", (gint64) 0,
1595               "silent", TRUE, NULL);
1596           gst_bin_add (bin, element);
1597           gst_element_link_pads_full (element, "src", chain->overlay,
1598               "subtitle_sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS);
1599           textsinkpad = gst_element_get_static_pad (element, "sink");
1600           srcpad = gst_element_get_static_pad (chain->overlay, "src");
1601         }
1602       }
1603     }
1604   }
1605
1606   if (videosinkpad == NULL) {
1607     /* if we still don't have a videosink, we don't have an overlay. the only
1608      * thing we can do is insert an identity and ghost the src
1609      * and sink pads. */
1610     chain->identity = gst_element_factory_make ("identity", "tidentity");
1611     if (chain->identity == NULL) {
1612       post_missing_element_message (playsink, "identity");
1613       GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
1614           (_("Missing element '%s' - check your GStreamer installation."),
1615               "identity"), (NULL));
1616     } else {
1617       g_object_set (chain->identity, "signal-handoffs", FALSE, NULL);
1618       g_object_set (chain->identity, "silent", TRUE, NULL);
1619       gst_bin_add (bin, chain->identity);
1620       srcpad = gst_element_get_static_pad (chain->identity, "src");
1621       videosinkpad = gst_element_get_static_pad (chain->identity, "sink");
1622     }
1623   }
1624
1625   /* expose the ghostpads */
1626   if (videosinkpad) {
1627     chain->videosinkpad = gst_ghost_pad_new ("sink", videosinkpad);
1628     gst_object_unref (videosinkpad);
1629     gst_element_add_pad (chain->chain.bin, chain->videosinkpad);
1630   }
1631   if (textsinkpad) {
1632     chain->textsinkpad = gst_ghost_pad_new ("text_sink", textsinkpad);
1633     gst_object_unref (textsinkpad);
1634     gst_element_add_pad (chain->chain.bin, chain->textsinkpad);
1635   }
1636   if (srcpad) {
1637     chain->srcpad = gst_ghost_pad_new ("src", srcpad);
1638     gst_object_unref (srcpad);
1639     gst_element_add_pad (chain->chain.bin, chain->srcpad);
1640   }
1641
1642   return chain;
1643 }
1644
1645 static void
1646 notify_volume_cb (GObject * object, GParamSpec * pspec, GstPlaySink * playsink)
1647 {
1648   gdouble vol;
1649
1650   g_object_get (object, "volume", &vol, NULL);
1651   playsink->volume = vol;
1652
1653   g_object_notify (G_OBJECT (playsink), "volume");
1654 }
1655
1656 static void
1657 notify_mute_cb (GObject * object, GParamSpec * pspec, GstPlaySink * playsink)
1658 {
1659   gboolean mute;
1660
1661   g_object_get (object, "mute", &mute, NULL);
1662   playsink->mute = mute;
1663
1664   g_object_notify (G_OBJECT (playsink), "mute");
1665 }
1666
1667 /* make the chain that contains the elements needed to perform
1668  * audio playback.
1669  *
1670  * We add a tee as the first element so that we can link the visualisation chain
1671  * to it when requested.
1672  *
1673  *  +-------------------------------------------------------------+
1674  *  | abin                                                        |
1675  *  |      +---------+   +----------+   +---------+   +---------+ |
1676  *  |      |audioconv|   |audioscale|   | volume  |   |audiosink| |
1677  *  |   +-srck      src-sink       src-sink      src-sink       | |
1678  *  |   |  +---------+   +----------+   +---------+   +---------+ |
1679  * sink-+                                                         |
1680  *  +-------------------------------------------------------------+
1681  */
1682 static GstPlayAudioChain *
1683 gen_audio_chain (GstPlaySink * playsink, gboolean raw)
1684 {
1685   GstPlayAudioChain *chain;
1686   GstBin *bin;
1687   gboolean have_volume;
1688   GstPad *pad;
1689   GstElement *head, *prev, *elem = NULL;
1690
1691   chain = g_new0 (GstPlayAudioChain, 1);
1692   chain->chain.playsink = playsink;
1693   chain->chain.raw = raw;
1694
1695   GST_DEBUG_OBJECT (playsink, "making audio chain %p", chain);
1696
1697   if (playsink->audio_sink) {
1698     GST_DEBUG_OBJECT (playsink, "trying configured audiosink %" GST_PTR_FORMAT,
1699         playsink->audio_sink);
1700     chain->sink = try_element (playsink, playsink->audio_sink, FALSE);
1701   } else {
1702     /* only try fallback if no specific sink was chosen */
1703     if (chain->sink == NULL) {
1704       GST_DEBUG_OBJECT (playsink, "trying autoaudiosink");
1705       elem = gst_element_factory_make ("autoaudiosink", "audiosink");
1706       chain->sink = try_element (playsink, elem, TRUE);
1707     }
1708     if (chain->sink == NULL) {
1709       /* if default sink from config.h is different then try it too */
1710       if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
1711         GST_DEBUG_OBJECT (playsink, "trying " DEFAULT_AUDIOSINK);
1712         elem = gst_element_factory_make (DEFAULT_AUDIOSINK, "audiosink");
1713         chain->sink = try_element (playsink, elem, TRUE);
1714       }
1715     }
1716     if (chain->sink)
1717       playsink->audio_sink = gst_object_ref (chain->sink);
1718   }
1719   if (chain->sink == NULL)
1720     goto no_sinks;
1721
1722   chain->chain.bin = gst_bin_new ("abin");
1723   bin = GST_BIN_CAST (chain->chain.bin);
1724   gst_object_ref_sink (bin);
1725   gst_bin_add (bin, chain->sink);
1726
1727   /* we have to add a queue when we need to decouple for the video sink in
1728    * visualisations and for streamsynchronizer */
1729   GST_DEBUG_OBJECT (playsink, "adding audio queue");
1730   chain->queue = gst_element_factory_make ("queue", "aqueue");
1731   if (chain->queue == NULL) {
1732     post_missing_element_message (playsink, "queue");
1733     GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
1734         (_("Missing element '%s' - check your GStreamer installation."),
1735             "queue"), ("audio playback and visualizations might not work"));
1736     head = chain->sink;
1737     prev = NULL;
1738   } else {
1739     g_object_set (chain->queue, "silent", TRUE, NULL);
1740     gst_bin_add (bin, chain->queue);
1741     prev = head = chain->queue;
1742   }
1743
1744   /* find ts-offset element */
1745   gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
1746       gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
1747           G_TYPE_INT64));
1748
1749   /* check if the sink, or something within the sink, has the volume property.
1750    * If it does we don't need to add a volume element.  */
1751   elem =
1752       gst_play_sink_find_property_sinks (playsink, chain->sink, "volume",
1753       G_TYPE_DOUBLE);
1754   if (elem) {
1755     chain->volume = elem;
1756
1757     g_signal_connect (chain->volume, "notify::volume",
1758         G_CALLBACK (notify_volume_cb), playsink);
1759
1760     GST_DEBUG_OBJECT (playsink, "the sink has a volume property");
1761     have_volume = TRUE;
1762     chain->sink_volume = TRUE;
1763     /* if the sink also has a mute property we can use this as well. We'll only
1764      * use the mute property if there is a volume property. We can simulate the
1765      * mute with the volume otherwise. */
1766     chain->mute =
1767         gst_play_sink_find_property_sinks (playsink, chain->sink, "mute",
1768         G_TYPE_BOOLEAN);
1769     if (chain->mute) {
1770       GST_DEBUG_OBJECT (playsink, "the sink has a mute property");
1771       g_signal_connect (chain->mute, "notify::mute",
1772           G_CALLBACK (notify_mute_cb), playsink);
1773     }
1774     /* use the sink to control the volume and mute */
1775     if (playsink->volume_changed) {
1776       g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
1777       playsink->volume_changed = FALSE;
1778     }
1779     if (playsink->mute_changed) {
1780       if (chain->mute) {
1781         g_object_set (chain->mute, "mute", playsink->mute, NULL);
1782       } else {
1783         if (playsink->mute)
1784           g_object_set (chain->volume, "volume", (gdouble) 0.0, NULL);
1785       }
1786       playsink->mute_changed = FALSE;
1787     }
1788   } else {
1789     /* no volume, we need to add a volume element when we can */
1790     GST_DEBUG_OBJECT (playsink, "the sink has no volume property");
1791     have_volume = FALSE;
1792     chain->sink_volume = FALSE;
1793   }
1794
1795   if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_AUDIO) || (!have_volume
1796           && playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME)) {
1797     gboolean use_converters = !(playsink->flags & GST_PLAY_FLAG_NATIVE_AUDIO);
1798     gboolean use_volume =
1799         !have_volume && playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME;
1800     GST_DEBUG_OBJECT (playsink,
1801         "creating audioconvert with use-converters %d, use-volume %d",
1802         use_converters, use_volume);
1803     chain->conv =
1804         g_object_new (GST_TYPE_PLAY_SINK_AUDIO_CONVERT, "name", "aconv",
1805         "use-converters", use_converters, "use-volume", use_volume, NULL);
1806     gst_bin_add (bin, chain->conv);
1807     if (prev) {
1808       if (!gst_element_link_pads_full (prev, "src", chain->conv, "sink",
1809               GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
1810         goto link_failed;
1811     } else {
1812       head = chain->conv;
1813     }
1814     prev = chain->conv;
1815
1816     if (!have_volume && playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME) {
1817       GstPlaySinkAudioConvert *conv =
1818           GST_PLAY_SINK_AUDIO_CONVERT_CAST (chain->conv);
1819
1820       if (conv->volume) {
1821         chain->volume = conv->volume;
1822         have_volume = TRUE;
1823
1824         g_signal_connect (chain->volume, "notify::volume",
1825             G_CALLBACK (notify_volume_cb), playsink);
1826
1827         /* volume also has the mute property */
1828         chain->mute = chain->volume;
1829         g_signal_connect (chain->mute, "notify::mute",
1830             G_CALLBACK (notify_mute_cb), playsink);
1831
1832         /* configure with the latest volume and mute */
1833         g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume,
1834             NULL);
1835         g_object_set (G_OBJECT (chain->mute), "mute", playsink->mute, NULL);
1836       }
1837     }
1838   }
1839
1840   if (prev) {
1841     /* we only have to link to the previous element if we have something in
1842      * front of the sink */
1843     GST_DEBUG_OBJECT (playsink, "linking to sink");
1844     if (!gst_element_link_pads_full (prev, "src", chain->sink, NULL,
1845             GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
1846       goto link_failed;
1847   }
1848
1849   /* post a warning if we have no way to configure the volume */
1850   if (!have_volume) {
1851     GST_ELEMENT_WARNING (playsink, STREAM, NOT_IMPLEMENTED,
1852         (_("No volume control found")), ("Volume/mute is not available"));
1853   }
1854
1855   /* and ghost the sinkpad of the headmost element */
1856   GST_DEBUG_OBJECT (playsink, "ghosting sink pad");
1857   pad = gst_element_get_static_pad (head, "sink");
1858   chain->sinkpad = gst_ghost_pad_new ("sink", pad);
1859   gst_object_unref (pad);
1860   gst_element_add_pad (chain->chain.bin, chain->sinkpad);
1861
1862   return chain;
1863
1864   /* ERRORS */
1865 no_sinks:
1866   {
1867     if (!elem && !playsink->audio_sink) {
1868       post_missing_element_message (playsink, "autoaudiosink");
1869       if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
1870         post_missing_element_message (playsink, DEFAULT_AUDIOSINK);
1871         GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
1872             (_("Both autoaudiosink and %s elements are missing."),
1873                 DEFAULT_AUDIOSINK), (NULL));
1874       } else {
1875         GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
1876             (_("The autoaudiosink element is missing.")), (NULL));
1877       }
1878     } else {
1879       if (playsink->audio_sink) {
1880         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1881             (_("Configured audiosink %s is not working."),
1882                 GST_ELEMENT_NAME (playsink->audio_sink)), (NULL));
1883       } else if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
1884         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1885             (_("Both autoaudiosink and %s elements are not working."),
1886                 DEFAULT_AUDIOSINK), (NULL));
1887       } else {
1888         GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
1889             (_("The autoaudiosink element is not working.")), (NULL));
1890       }
1891     }
1892     free_chain ((GstPlayChain *) chain);
1893     return NULL;
1894   }
1895 link_failed:
1896   {
1897     GST_ELEMENT_ERROR (playsink, CORE, PAD,
1898         (NULL), ("Failed to configure the audio sink."));
1899     /* checking sink made it READY */
1900     gst_element_set_state (chain->sink, GST_STATE_NULL);
1901     /* Remove chain from the bin to allow reuse later */
1902     gst_bin_remove (bin, chain->sink);
1903     free_chain ((GstPlayChain *) chain);
1904     return NULL;
1905   }
1906 }
1907
1908 static gboolean
1909 setup_audio_chain (GstPlaySink * playsink, gboolean raw)
1910 {
1911   GstElement *elem;
1912   GstPlayAudioChain *chain;
1913   GstStateChangeReturn ret;
1914
1915   chain = playsink->audiochain;
1916
1917   chain->chain.raw = raw;
1918
1919   /* if the chain was active we don't do anything */
1920   if (GST_PLAY_CHAIN (chain)->activated == TRUE)
1921     return TRUE;
1922
1923   /* try to set the sink element to READY again */
1924   ret = gst_element_set_state (chain->sink, GST_STATE_READY);
1925   if (ret == GST_STATE_CHANGE_FAILURE)
1926     return FALSE;
1927
1928   /* find ts-offset element */
1929   gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
1930       gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
1931           G_TYPE_INT64));
1932
1933   /* check if the sink, or something within the sink, has the volume property.
1934    * If it does we don't need to add a volume element.  */
1935   elem =
1936       gst_play_sink_find_property_sinks (playsink, chain->sink, "volume",
1937       G_TYPE_DOUBLE);
1938   if (elem) {
1939     chain->volume = elem;
1940
1941     if (playsink->volume_changed) {
1942       GST_DEBUG_OBJECT (playsink, "the sink has a volume property, setting %f",
1943           playsink->volume);
1944       /* use the sink to control the volume */
1945       g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
1946       playsink->volume_changed = FALSE;
1947     }
1948
1949     g_signal_connect (chain->volume, "notify::volume",
1950         G_CALLBACK (notify_volume_cb), playsink);
1951     /* if the sink also has a mute property we can use this as well. We'll only
1952      * use the mute property if there is a volume property. We can simulate the
1953      * mute with the volume otherwise. */
1954     chain->mute =
1955         gst_play_sink_find_property_sinks (playsink, chain->sink, "mute",
1956         G_TYPE_BOOLEAN);
1957     if (chain->mute) {
1958       GST_DEBUG_OBJECT (playsink, "the sink has a mute property");
1959       g_signal_connect (chain->mute, "notify::mute",
1960           G_CALLBACK (notify_mute_cb), playsink);
1961     }
1962
1963     g_object_set (chain->conv, "use-volume", FALSE, NULL);
1964   } else {
1965     GstPlaySinkAudioConvert *conv =
1966         GST_PLAY_SINK_AUDIO_CONVERT_CAST (chain->conv);
1967
1968     /* no volume, we need to add a volume element when we can */
1969     g_object_set (chain->conv, "use-volume", TRUE, NULL);
1970     GST_DEBUG_OBJECT (playsink, "the sink has no volume property");
1971
1972     /* Disconnect signals */
1973     disconnect_chain (chain, playsink);
1974
1975     if (conv->volume) {
1976       chain->volume = conv->volume;
1977       chain->mute = chain->volume;
1978
1979       g_signal_connect (chain->volume, "notify::volume",
1980           G_CALLBACK (notify_volume_cb), playsink);
1981
1982       g_signal_connect (chain->mute, "notify::mute",
1983           G_CALLBACK (notify_mute_cb), playsink);
1984
1985       /* configure with the latest volume and mute */
1986       g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
1987       g_object_set (G_OBJECT (chain->mute), "mute", playsink->mute, NULL);
1988     }
1989
1990     GST_DEBUG_OBJECT (playsink, "reusing existing volume element");
1991   }
1992   return TRUE;
1993 }
1994
1995 /*
1996  *  +-------------------------------------------------------------------+
1997  *  | visbin                                                            |
1998  *  |      +----------+   +------------+   +----------+   +-------+     |
1999  *  |      | visqueue |   | audioconv  |   | audiores |   |  vis  |     |
2000  *  |   +-sink       src-sink + samp  src-sink       src-sink    src-+  |
2001  *  |   |  +----------+   +------------+   +----------+   +-------+  |  |
2002  * sink-+                                                            +-src
2003  *  +-------------------------------------------------------------------+
2004  *
2005  */
2006 static GstPlayVisChain *
2007 gen_vis_chain (GstPlaySink * playsink)
2008 {
2009   GstPlayVisChain *chain;
2010   GstBin *bin;
2011   gboolean res;
2012   GstPad *pad;
2013   GstElement *elem;
2014
2015   chain = g_new0 (GstPlayVisChain, 1);
2016   chain->chain.playsink = playsink;
2017
2018   GST_DEBUG_OBJECT (playsink, "making vis chain %p", chain);
2019
2020   chain->chain.bin = gst_bin_new ("visbin");
2021   bin = GST_BIN_CAST (chain->chain.bin);
2022   gst_object_ref_sink (bin);
2023
2024   /* we're queuing raw audio here, we can remove this queue when we can disable
2025    * async behaviour in the video sink. */
2026   chain->queue = gst_element_factory_make ("queue", "visqueue");
2027   if (chain->queue == NULL)
2028     goto no_queue;
2029   g_object_set (chain->queue, "silent", TRUE, NULL);
2030   gst_bin_add (bin, chain->queue);
2031
2032   chain->conv = gst_element_factory_make ("audioconvert", "aconv");
2033   if (chain->conv == NULL)
2034     goto no_audioconvert;
2035   gst_bin_add (bin, chain->conv);
2036
2037   chain->resample = gst_element_factory_make ("audioresample", "aresample");
2038   if (chain->resample == NULL)
2039     goto no_audioresample;
2040   gst_bin_add (bin, chain->resample);
2041
2042   /* this pad will be used for blocking the dataflow and switching the vis
2043    * plugin */
2044   chain->blockpad = gst_element_get_static_pad (chain->resample, "src");
2045
2046   if (playsink->visualisation) {
2047     GST_DEBUG_OBJECT (playsink, "trying configure vis");
2048     chain->vis = try_element (playsink, playsink->visualisation, FALSE);
2049   }
2050   if (chain->vis == NULL) {
2051     GST_DEBUG_OBJECT (playsink, "trying goom");
2052     elem = gst_element_factory_make ("goom", "vis");
2053     chain->vis = try_element (playsink, elem, TRUE);
2054   }
2055   if (chain->vis == NULL)
2056     goto no_goom;
2057
2058   gst_bin_add (bin, chain->vis);
2059
2060   res = gst_element_link_pads_full (chain->queue, "src", chain->conv, "sink",
2061       GST_PAD_LINK_CHECK_NOTHING);
2062   res &=
2063       gst_element_link_pads_full (chain->conv, "src", chain->resample, "sink",
2064       GST_PAD_LINK_CHECK_NOTHING);
2065   res &=
2066       gst_element_link_pads_full (chain->resample, "src", chain->vis, "sink",
2067       GST_PAD_LINK_CHECK_NOTHING);
2068   if (!res)
2069     goto link_failed;
2070
2071   chain->vissinkpad = gst_element_get_static_pad (chain->vis, "sink");
2072   chain->vissrcpad = gst_element_get_static_pad (chain->vis, "src");
2073
2074   pad = gst_element_get_static_pad (chain->queue, "sink");
2075   chain->sinkpad = gst_ghost_pad_new ("sink", pad);
2076   gst_object_unref (pad);
2077   gst_element_add_pad (chain->chain.bin, chain->sinkpad);
2078
2079   chain->srcpad = gst_ghost_pad_new ("src", chain->vissrcpad);
2080   gst_element_add_pad (chain->chain.bin, chain->srcpad);
2081
2082   return chain;
2083
2084   /* ERRORS */
2085 no_queue:
2086   {
2087     post_missing_element_message (playsink, "queue");
2088     GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
2089         (_("Missing element '%s' - check your GStreamer installation."),
2090             "queue"), (NULL));
2091     free_chain ((GstPlayChain *) chain);
2092     return NULL;
2093   }
2094 no_audioconvert:
2095   {
2096     post_missing_element_message (playsink, "audioconvert");
2097     GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
2098         (_("Missing element '%s' - check your GStreamer installation."),
2099             "audioconvert"), ("possibly a liboil version mismatch?"));
2100     free_chain ((GstPlayChain *) chain);
2101     return NULL;
2102   }
2103 no_audioresample:
2104   {
2105     post_missing_element_message (playsink, "audioresample");
2106     GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
2107         (_("Missing element '%s' - check your GStreamer installation."),
2108             "audioresample"), (NULL));
2109     free_chain ((GstPlayChain *) chain);
2110     return NULL;
2111   }
2112 no_goom:
2113   {
2114     post_missing_element_message (playsink, "goom");
2115     GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
2116         (_("Missing element '%s' - check your GStreamer installation."),
2117             "goom"), (NULL));
2118     free_chain ((GstPlayChain *) chain);
2119     return NULL;
2120   }
2121 link_failed:
2122   {
2123     GST_ELEMENT_ERROR (playsink, CORE, PAD,
2124         (NULL), ("Failed to configure the visualisation element."));
2125     /* element made it to READY */
2126     gst_element_set_state (chain->vis, GST_STATE_NULL);
2127     free_chain ((GstPlayChain *) chain);
2128     return NULL;
2129   }
2130 }
2131
2132 /* this function is called when all the request pads are requested and when we
2133  * have to construct the final pipeline. Based on the flags we construct the
2134  * final output pipelines.
2135  */
2136 gboolean
2137 gst_play_sink_reconfigure (GstPlaySink * playsink)
2138 {
2139   GstPlayFlags flags;
2140   gboolean need_audio, need_video, need_deinterlace, need_vis, need_text;
2141
2142   GST_DEBUG_OBJECT (playsink, "reconfiguring");
2143
2144   /* assume we need nothing */
2145   need_audio = need_video = need_deinterlace = need_vis = need_text = FALSE;
2146
2147   GST_PLAY_SINK_LOCK (playsink);
2148   GST_OBJECT_LOCK (playsink);
2149   /* get flags, there are protected with the object lock */
2150   flags = playsink->flags;
2151   GST_OBJECT_UNLOCK (playsink);
2152
2153   /* figure out which components we need */
2154   if (flags & GST_PLAY_FLAG_TEXT && playsink->text_pad) {
2155     /* we have subtitles and we are requested to show it */
2156     need_text = TRUE;
2157   }
2158
2159   if (((flags & GST_PLAY_FLAG_VIDEO)
2160           || (flags & GST_PLAY_FLAG_NATIVE_VIDEO)) && playsink->video_pad) {
2161     /* we have video and we are requested to show it */
2162     need_video = TRUE;
2163
2164     /* we only deinterlace if native video is not requested and
2165      * we have raw video */
2166     if ((flags & GST_PLAY_FLAG_DEINTERLACE)
2167         && !(flags & GST_PLAY_FLAG_NATIVE_VIDEO) && playsink->video_pad_raw)
2168       need_deinterlace = TRUE;
2169   }
2170
2171   if (playsink->audio_pad) {
2172     if ((flags & GST_PLAY_FLAG_AUDIO) || (flags & GST_PLAY_FLAG_NATIVE_AUDIO)) {
2173       need_audio = TRUE;
2174     }
2175     if (playsink->audio_pad_raw) {
2176       /* only can do vis with raw uncompressed audio */
2177       if (flags & GST_PLAY_FLAG_VIS && !need_video) {
2178         /* also add video when we add visualisation */
2179         need_video = TRUE;
2180         need_vis = TRUE;
2181       }
2182     }
2183   }
2184
2185   /* we have a text_pad and we need text rendering, in this case we need a
2186    * video_pad to combine the video with the text or visualizations */
2187   if (need_text && !need_video) {
2188     if (playsink->video_pad) {
2189       need_video = TRUE;
2190     } else if (need_audio) {
2191       GST_ELEMENT_WARNING (playsink, STREAM, FORMAT,
2192           (_("Can't play a text file without video or visualizations.")),
2193           ("Have text pad but no video pad or visualizations"));
2194       need_text = FALSE;
2195     } else {
2196       GST_ELEMENT_ERROR (playsink, STREAM, FORMAT,
2197           (_("Can't play a text file without video or visualizations.")),
2198           ("Have text pad but no video pad or visualizations"));
2199       GST_PLAY_SINK_UNLOCK (playsink);
2200       return FALSE;
2201     }
2202   }
2203
2204   GST_DEBUG_OBJECT (playsink, "audio:%d, video:%d, vis:%d, text:%d", need_audio,
2205       need_video, need_vis, need_text);
2206
2207   /* set up video pipeline */
2208   if (need_video) {
2209     gboolean raw, async;
2210
2211     /* we need a raw sink when we do vis or when we have a raw pad */
2212     raw = need_vis ? TRUE : playsink->video_pad_raw;
2213     /* we try to set the sink async=FALSE when we need vis, this way we can
2214      * avoid a queue in the audio chain. */
2215     async = !need_vis;
2216
2217     GST_DEBUG_OBJECT (playsink, "adding video, raw %d",
2218         playsink->video_pad_raw);
2219
2220     if (playsink->videochain) {
2221       /* try to reactivate the chain */
2222       if (!setup_video_chain (playsink, raw, async)) {
2223         if (playsink->video_sinkpad_stream_synchronizer) {
2224           gst_element_release_request_pad (GST_ELEMENT_CAST
2225               (playsink->stream_synchronizer),
2226               playsink->video_sinkpad_stream_synchronizer);
2227           gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
2228           playsink->video_sinkpad_stream_synchronizer = NULL;
2229           gst_object_unref (playsink->video_srcpad_stream_synchronizer);
2230           playsink->video_srcpad_stream_synchronizer = NULL;
2231         }
2232
2233         add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
2234
2235         /* Remove the sink from the bin to keep its state
2236          * and unparent it to allow reuse */
2237         if (playsink->videochain->sink)
2238           gst_bin_remove (GST_BIN_CAST (playsink->videochain->chain.bin),
2239               playsink->videochain->sink);
2240
2241         activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
2242         free_chain ((GstPlayChain *) playsink->videochain);
2243         playsink->videochain = NULL;
2244       }
2245     }
2246
2247     if (!playsink->videochain)
2248       playsink->videochain = gen_video_chain (playsink, raw, async);
2249     if (!playsink->videochain)
2250       goto no_chain;
2251
2252     if (!playsink->video_sinkpad_stream_synchronizer) {
2253       GValue item = { 0, };
2254       GstIterator *it;
2255
2256       playsink->video_sinkpad_stream_synchronizer =
2257           gst_element_get_request_pad (GST_ELEMENT_CAST
2258           (playsink->stream_synchronizer), "sink_%u");
2259       it = gst_pad_iterate_internal_links
2260           (playsink->video_sinkpad_stream_synchronizer);
2261       g_assert (it);
2262       gst_iterator_next (it, &item);
2263       playsink->video_srcpad_stream_synchronizer = g_value_dup_object (&item);
2264       g_value_unset (&item);
2265       g_assert (playsink->video_srcpad_stream_synchronizer);
2266       gst_iterator_free (it);
2267     }
2268
2269     if (playsink->video_pad)
2270       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad),
2271           playsink->video_sinkpad_stream_synchronizer);
2272
2273     if (need_deinterlace) {
2274       if (!playsink->videodeinterlacechain)
2275         playsink->videodeinterlacechain =
2276             gen_video_deinterlace_chain (playsink);
2277       if (!playsink->videodeinterlacechain)
2278         goto no_chain;
2279
2280       GST_DEBUG_OBJECT (playsink, "adding video deinterlace chain");
2281
2282       GST_DEBUG_OBJECT (playsink, "setting up deinterlacing chain");
2283
2284       add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), TRUE);
2285       activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), TRUE);
2286
2287       gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
2288           playsink->videodeinterlacechain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2289     } else {
2290       if (playsink->videodeinterlacechain) {
2291         add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
2292         activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain),
2293             FALSE);
2294       }
2295     }
2296
2297     GST_DEBUG_OBJECT (playsink, "adding video chain");
2298     add_chain (GST_PLAY_CHAIN (playsink->videochain), TRUE);
2299     activate_chain (GST_PLAY_CHAIN (playsink->videochain), TRUE);
2300     /* if we are not part of vis or subtitles, set the ghostpad target */
2301     if (!need_vis && !need_text && (!playsink->textchain
2302             || !playsink->text_pad)) {
2303       GST_DEBUG_OBJECT (playsink, "ghosting video sinkpad");
2304       if (need_deinterlace)
2305         gst_pad_link_full (playsink->videodeinterlacechain->srcpad,
2306             playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2307       else
2308         gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
2309             playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2310     }
2311   } else {
2312     GST_DEBUG_OBJECT (playsink, "no video needed");
2313     if (playsink->videochain) {
2314       GST_DEBUG_OBJECT (playsink, "removing video chain");
2315       if (playsink->vischain) {
2316         GstPad *srcpad;
2317
2318         GST_DEBUG_OBJECT (playsink, "unlinking vis chain");
2319
2320         /* also had visualisation, release the tee srcpad before we then
2321          * unlink the video from it */
2322         if (playsink->audio_tee_vissrc) {
2323           gst_element_release_request_pad (playsink->audio_tee,
2324               playsink->audio_tee_vissrc);
2325           gst_object_unref (playsink->audio_tee_vissrc);
2326           playsink->audio_tee_vissrc = NULL;
2327         }
2328         srcpad =
2329             gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
2330         gst_pad_unlink (srcpad, playsink->videochain->sinkpad);
2331       }
2332
2333       if (playsink->video_sinkpad_stream_synchronizer) {
2334         gst_element_release_request_pad (GST_ELEMENT_CAST
2335             (playsink->stream_synchronizer),
2336             playsink->video_sinkpad_stream_synchronizer);
2337         gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
2338         playsink->video_sinkpad_stream_synchronizer = NULL;
2339         gst_object_unref (playsink->video_srcpad_stream_synchronizer);
2340         playsink->video_srcpad_stream_synchronizer = NULL;
2341       }
2342
2343       add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
2344       activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
2345       if (playsink->videochain->ts_offset)
2346         gst_object_unref (playsink->videochain->ts_offset);
2347       playsink->videochain->ts_offset = NULL;
2348     }
2349
2350     if (playsink->videodeinterlacechain) {
2351       add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
2352       activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
2353     }
2354
2355     if (playsink->video_pad)
2356       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad), NULL);
2357   }
2358
2359   if (need_audio) {
2360     gboolean raw;
2361
2362     GST_DEBUG_OBJECT (playsink, "adding audio");
2363
2364     /* get a raw sink if we are asked for a raw pad */
2365     raw = playsink->audio_pad_raw;
2366
2367     if (playsink->audiochain) {
2368       /* try to reactivate the chain */
2369       if (!setup_audio_chain (playsink, raw)) {
2370         GST_DEBUG_OBJECT (playsink, "removing current audio chain");
2371         if (playsink->audio_tee_asrc) {
2372           gst_element_release_request_pad (playsink->audio_tee,
2373               playsink->audio_tee_asrc);
2374           gst_object_unref (playsink->audio_tee_asrc);
2375           playsink->audio_tee_asrc = NULL;
2376         }
2377
2378         if (playsink->audio_sinkpad_stream_synchronizer) {
2379           gst_element_release_request_pad (GST_ELEMENT_CAST
2380               (playsink->stream_synchronizer),
2381               playsink->audio_sinkpad_stream_synchronizer);
2382           gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
2383           playsink->audio_sinkpad_stream_synchronizer = NULL;
2384           gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
2385           playsink->audio_srcpad_stream_synchronizer = NULL;
2386         }
2387
2388         add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
2389
2390         /* Remove the sink from the bin to keep its state
2391          * and unparent it to allow reuse */
2392         if (playsink->audiochain->sink)
2393           gst_bin_remove (GST_BIN_CAST (playsink->audiochain->chain.bin),
2394               playsink->audiochain->sink);
2395
2396         activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
2397         disconnect_chain (playsink->audiochain, playsink);
2398         playsink->audiochain->volume = NULL;
2399         playsink->audiochain->mute = NULL;
2400         if (playsink->audiochain->ts_offset)
2401           gst_object_unref (playsink->audiochain->ts_offset);
2402         playsink->audiochain->ts_offset = NULL;
2403         free_chain ((GstPlayChain *) playsink->audiochain);
2404         playsink->audiochain = NULL;
2405         playsink->volume_changed = playsink->mute_changed = FALSE;
2406       }
2407     }
2408
2409     if (!playsink->audiochain) {
2410       GST_DEBUG_OBJECT (playsink, "creating new audio chain");
2411       playsink->audiochain = gen_audio_chain (playsink, raw);
2412     }
2413
2414     if (!playsink->audio_sinkpad_stream_synchronizer) {
2415       GValue item = { 0, };
2416       GstIterator *it;
2417
2418       playsink->audio_sinkpad_stream_synchronizer =
2419           gst_element_get_request_pad (GST_ELEMENT_CAST
2420           (playsink->stream_synchronizer), "sink_%u");
2421       it = gst_pad_iterate_internal_links
2422           (playsink->audio_sinkpad_stream_synchronizer);
2423       g_assert (it);
2424       gst_iterator_next (it, &item);
2425       playsink->audio_srcpad_stream_synchronizer = g_value_dup_object (&item);
2426       g_value_unset (&item);
2427       g_assert (playsink->audio_srcpad_stream_synchronizer);
2428       gst_iterator_free (it);
2429     }
2430
2431     if (playsink->audiochain) {
2432       GST_DEBUG_OBJECT (playsink, "adding audio chain");
2433       if (playsink->audio_tee_asrc == NULL) {
2434         playsink->audio_tee_asrc =
2435             gst_element_get_request_pad (playsink->audio_tee, "src_%u");
2436       }
2437       add_chain (GST_PLAY_CHAIN (playsink->audiochain), TRUE);
2438       activate_chain (GST_PLAY_CHAIN (playsink->audiochain), TRUE);
2439       gst_pad_link_full (playsink->audio_tee_asrc,
2440           playsink->audio_sinkpad_stream_synchronizer,
2441           GST_PAD_LINK_CHECK_NOTHING);
2442       gst_pad_link_full (playsink->audio_srcpad_stream_synchronizer,
2443           playsink->audiochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2444     }
2445   } else {
2446     GST_DEBUG_OBJECT (playsink, "no audio needed");
2447     /* we have no audio or we are requested to not play audio */
2448     if (playsink->audiochain) {
2449       GST_DEBUG_OBJECT (playsink, "removing audio chain");
2450       /* release the audio pad */
2451       if (playsink->audio_tee_asrc) {
2452         gst_element_release_request_pad (playsink->audio_tee,
2453             playsink->audio_tee_asrc);
2454         gst_object_unref (playsink->audio_tee_asrc);
2455         playsink->audio_tee_asrc = NULL;
2456       }
2457
2458       if (playsink->audio_sinkpad_stream_synchronizer) {
2459         gst_element_release_request_pad (GST_ELEMENT_CAST
2460             (playsink->stream_synchronizer),
2461             playsink->audio_sinkpad_stream_synchronizer);
2462         gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
2463         playsink->audio_sinkpad_stream_synchronizer = NULL;
2464         gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
2465         playsink->audio_srcpad_stream_synchronizer = NULL;
2466       }
2467
2468       if (playsink->audiochain->sink_volume) {
2469         disconnect_chain (playsink->audiochain, playsink);
2470         playsink->audiochain->volume = NULL;
2471         playsink->audiochain->mute = NULL;
2472         if (playsink->audiochain->ts_offset)
2473           gst_object_unref (playsink->audiochain->ts_offset);
2474         playsink->audiochain->ts_offset = NULL;
2475       }
2476       add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
2477       activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
2478     }
2479   }
2480
2481   if (need_vis) {
2482     GstPad *srcpad;
2483
2484     if (!playsink->vischain)
2485       playsink->vischain = gen_vis_chain (playsink);
2486
2487     GST_DEBUG_OBJECT (playsink, "adding visualisation");
2488
2489     if (playsink->vischain) {
2490       GST_DEBUG_OBJECT (playsink, "setting up vis chain");
2491       srcpad =
2492           gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
2493       add_chain (GST_PLAY_CHAIN (playsink->vischain), TRUE);
2494       activate_chain (GST_PLAY_CHAIN (playsink->vischain), TRUE);
2495       if (playsink->audio_tee_vissrc == NULL) {
2496         playsink->audio_tee_vissrc =
2497             gst_element_get_request_pad (playsink->audio_tee, "src_%u");
2498       }
2499       gst_pad_link_full (playsink->audio_tee_vissrc,
2500           playsink->vischain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2501       gst_pad_link_full (srcpad, playsink->video_sinkpad_stream_synchronizer,
2502           GST_PAD_LINK_CHECK_NOTHING);
2503       gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
2504           playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2505       gst_object_unref (srcpad);
2506     }
2507   } else {
2508     GST_DEBUG_OBJECT (playsink, "no vis needed");
2509     if (playsink->vischain) {
2510       if (playsink->audio_tee_vissrc) {
2511         gst_element_release_request_pad (playsink->audio_tee,
2512             playsink->audio_tee_vissrc);
2513         gst_object_unref (playsink->audio_tee_vissrc);
2514         playsink->audio_tee_vissrc = NULL;
2515       }
2516       GST_DEBUG_OBJECT (playsink, "removing vis chain");
2517       add_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
2518       activate_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
2519     }
2520   }
2521
2522   if (need_text) {
2523     GST_DEBUG_OBJECT (playsink, "adding text");
2524     if (!playsink->textchain) {
2525       GST_DEBUG_OBJECT (playsink, "creating text chain");
2526       playsink->textchain = gen_text_chain (playsink);
2527     }
2528     if (playsink->textchain) {
2529       GstIterator *it;
2530
2531       GST_DEBUG_OBJECT (playsink, "adding text chain");
2532       if (playsink->textchain->overlay)
2533         g_object_set (G_OBJECT (playsink->textchain->overlay), "silent", FALSE,
2534             NULL);
2535       add_chain (GST_PLAY_CHAIN (playsink->textchain), TRUE);
2536
2537       if (!playsink->text_sinkpad_stream_synchronizer) {
2538         GValue item = { 0, };
2539
2540         playsink->text_sinkpad_stream_synchronizer =
2541             gst_element_get_request_pad (GST_ELEMENT_CAST
2542             (playsink->stream_synchronizer), "sink_%u");
2543         it = gst_pad_iterate_internal_links
2544             (playsink->text_sinkpad_stream_synchronizer);
2545         g_assert (it);
2546         gst_iterator_next (it, &item);
2547         playsink->text_srcpad_stream_synchronizer = g_value_dup_object (&item);
2548         g_value_unset (&item);
2549         g_assert (playsink->text_srcpad_stream_synchronizer);
2550         gst_iterator_free (it);
2551
2552         gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->text_pad),
2553             playsink->text_sinkpad_stream_synchronizer);
2554         gst_pad_link_full (playsink->text_srcpad_stream_synchronizer,
2555             playsink->textchain->textsinkpad, GST_PAD_LINK_CHECK_NOTHING);
2556       }
2557
2558       if (need_vis) {
2559         GstPad *srcpad;
2560
2561         srcpad =
2562             gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
2563         gst_pad_unlink (srcpad, playsink->videochain->sinkpad);
2564         gst_pad_link_full (srcpad, playsink->textchain->videosinkpad,
2565             GST_PAD_LINK_CHECK_NOTHING);
2566         gst_object_unref (srcpad);
2567       } else {
2568         if (need_deinterlace)
2569           gst_pad_link_full (playsink->videodeinterlacechain->srcpad,
2570               playsink->textchain->videosinkpad, GST_PAD_LINK_CHECK_NOTHING);
2571         else
2572           gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
2573               playsink->textchain->videosinkpad, GST_PAD_LINK_CHECK_NOTHING);
2574       }
2575       gst_pad_link_full (playsink->textchain->srcpad,
2576           playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
2577
2578       activate_chain (GST_PLAY_CHAIN (playsink->textchain), TRUE);
2579     }
2580   } else {
2581     GST_DEBUG_OBJECT (playsink, "no text needed");
2582     /* we have no subtitles/text or we are requested to not show them */
2583
2584     if (playsink->text_sinkpad_stream_synchronizer) {
2585       gst_element_release_request_pad (GST_ELEMENT_CAST
2586           (playsink->stream_synchronizer),
2587           playsink->text_sinkpad_stream_synchronizer);
2588       gst_object_unref (playsink->text_sinkpad_stream_synchronizer);
2589       playsink->text_sinkpad_stream_synchronizer = NULL;
2590       gst_object_unref (playsink->text_srcpad_stream_synchronizer);
2591       playsink->text_srcpad_stream_synchronizer = NULL;
2592     }
2593
2594     if (playsink->textchain) {
2595       if (playsink->text_pad == NULL) {
2596         /* no text pad, remove the chain entirely */
2597         GST_DEBUG_OBJECT (playsink, "removing text chain");
2598         add_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
2599         activate_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
2600       } else {
2601         /* we have a chain and a textpad, turn the subtitles off */
2602         GST_DEBUG_OBJECT (playsink, "turning off the text");
2603         if (playsink->textchain->overlay)
2604           g_object_set (G_OBJECT (playsink->textchain->overlay), "silent", TRUE,
2605               NULL);
2606       }
2607     }
2608     if (!need_video && playsink->video_pad) {
2609       if (playsink->video_sinkpad_stream_synchronizer) {
2610         gst_element_release_request_pad (GST_ELEMENT_CAST
2611             (playsink->stream_synchronizer),
2612             playsink->video_sinkpad_stream_synchronizer);
2613         gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
2614         playsink->video_sinkpad_stream_synchronizer = NULL;
2615         gst_object_unref (playsink->video_srcpad_stream_synchronizer);
2616         playsink->video_srcpad_stream_synchronizer = NULL;
2617       }
2618
2619       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad), NULL);
2620     }
2621
2622     if (playsink->text_pad && !playsink->textchain)
2623       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->text_pad), NULL);
2624   }
2625   update_av_offset (playsink);
2626   do_async_done (playsink);
2627   GST_PLAY_SINK_UNLOCK (playsink);
2628
2629   return TRUE;
2630
2631   /* ERRORS */
2632 no_chain:
2633   {
2634     /* gen_ chain already posted error */
2635     GST_DEBUG_OBJECT (playsink, "failed to setup chain");
2636     GST_PLAY_SINK_UNLOCK (playsink);
2637     return FALSE;
2638   }
2639 }
2640
2641 /**
2642  * gst_play_sink_set_flags:
2643  * @playsink: a #GstPlaySink
2644  * @flags: #GstPlayFlags
2645  *
2646  * Configure @flags on @playsink. The flags control the behaviour of @playsink
2647  * when constructing the sink pipelins.
2648  *
2649  * Returns: TRUE if the flags could be configured.
2650  */
2651 gboolean
2652 gst_play_sink_set_flags (GstPlaySink * playsink, GstPlayFlags flags)
2653 {
2654   g_return_val_if_fail (GST_IS_PLAY_SINK (playsink), FALSE);
2655
2656   GST_OBJECT_LOCK (playsink);
2657   playsink->flags = flags;
2658   GST_OBJECT_UNLOCK (playsink);
2659
2660   return TRUE;
2661 }
2662
2663 /**
2664  * gst_play_sink_get_flags:
2665  * @playsink: a #GstPlaySink
2666  *
2667  * Get the flags of @playsink. That flags control the behaviour of the sink when
2668  * it constructs the sink pipelines.
2669  *
2670  * Returns: the currently configured #GstPlayFlags.
2671  */
2672 GstPlayFlags
2673 gst_play_sink_get_flags (GstPlaySink * playsink)
2674 {
2675   GstPlayFlags res;
2676
2677   g_return_val_if_fail (GST_IS_PLAY_SINK (playsink), 0);
2678
2679   GST_OBJECT_LOCK (playsink);
2680   res = playsink->flags;
2681   GST_OBJECT_UNLOCK (playsink);
2682
2683   return res;
2684 }
2685
2686 void
2687 gst_play_sink_set_font_desc (GstPlaySink * playsink, const gchar * desc)
2688 {
2689   GstPlayTextChain *chain;
2690
2691   GST_PLAY_SINK_LOCK (playsink);
2692   chain = (GstPlayTextChain *) playsink->textchain;
2693   g_free (playsink->font_desc);
2694   playsink->font_desc = g_strdup (desc);
2695   if (chain && chain->overlay) {
2696     g_object_set (chain->overlay, "font-desc", desc, NULL);
2697   }
2698   GST_PLAY_SINK_UNLOCK (playsink);
2699 }
2700
2701 gchar *
2702 gst_play_sink_get_font_desc (GstPlaySink * playsink)
2703 {
2704   gchar *result = NULL;
2705   GstPlayTextChain *chain;
2706
2707   GST_PLAY_SINK_LOCK (playsink);
2708   chain = (GstPlayTextChain *) playsink->textchain;
2709   if (chain && chain->overlay) {
2710     g_object_get (chain->overlay, "font-desc", &result, NULL);
2711     playsink->font_desc = g_strdup (result);
2712   } else {
2713     result = g_strdup (playsink->font_desc);
2714   }
2715   GST_PLAY_SINK_UNLOCK (playsink);
2716
2717   return result;
2718 }
2719
2720 void
2721 gst_play_sink_set_subtitle_encoding (GstPlaySink * playsink,
2722     const gchar * encoding)
2723 {
2724   GstPlayTextChain *chain;
2725
2726   GST_PLAY_SINK_LOCK (playsink);
2727   chain = (GstPlayTextChain *) playsink->textchain;
2728   g_free (playsink->subtitle_encoding);
2729   playsink->subtitle_encoding = g_strdup (encoding);
2730   if (chain && chain->overlay) {
2731     g_object_set (chain->overlay, "subtitle-encoding", encoding, NULL);
2732   }
2733   GST_PLAY_SINK_UNLOCK (playsink);
2734 }
2735
2736 gchar *
2737 gst_play_sink_get_subtitle_encoding (GstPlaySink * playsink)
2738 {
2739   gchar *result = NULL;
2740   GstPlayTextChain *chain;
2741
2742   GST_PLAY_SINK_LOCK (playsink);
2743   chain = (GstPlayTextChain *) playsink->textchain;
2744   if (chain && chain->overlay) {
2745     g_object_get (chain->overlay, "subtitle-encoding", &result, NULL);
2746     playsink->subtitle_encoding = g_strdup (result);
2747   } else {
2748     result = g_strdup (playsink->subtitle_encoding);
2749   }
2750   GST_PLAY_SINK_UNLOCK (playsink);
2751
2752   return result;
2753 }
2754
2755 static void
2756 update_av_offset (GstPlaySink * playsink)
2757 {
2758   gint64 av_offset;
2759   GstPlayAudioChain *achain;
2760   GstPlayVideoChain *vchain;
2761
2762   av_offset = playsink->av_offset;
2763   achain = (GstPlayAudioChain *) playsink->audiochain;
2764   vchain = (GstPlayVideoChain *) playsink->videochain;
2765
2766   if (achain && vchain && achain->ts_offset && vchain->ts_offset) {
2767     g_object_set (achain->ts_offset, "ts-offset", MAX (0, -av_offset), NULL);
2768     g_object_set (vchain->ts_offset, "ts-offset", MAX (0, av_offset), NULL);
2769   } else {
2770     GST_LOG_OBJECT (playsink, "no ts_offset elements");
2771   }
2772 }
2773
2774 void
2775 gst_play_sink_set_av_offset (GstPlaySink * playsink, gint64 av_offset)
2776 {
2777   GST_PLAY_SINK_LOCK (playsink);
2778   playsink->av_offset = av_offset;
2779   update_av_offset (playsink);
2780   GST_PLAY_SINK_UNLOCK (playsink);
2781 }
2782
2783 gint64
2784 gst_play_sink_get_av_offset (GstPlaySink * playsink)
2785 {
2786   gint64 result;
2787
2788   GST_PLAY_SINK_LOCK (playsink);
2789   result = playsink->av_offset;
2790   GST_PLAY_SINK_UNLOCK (playsink);
2791
2792   return result;
2793 }
2794
2795 /**
2796  * gst_play_sink_get_last_sample:
2797  * @playsink: a #GstPlaySink
2798  *
2799  * Get the last displayed sample from @playsink. This sample is in the native
2800  * format of the sink element, the caps in the result sample contain the format
2801  * of the frame data.
2802  *
2803  * Returns: a #GstSample with the frame data or %NULL when no video frame is
2804  * available.
2805  */
2806 GstSample *
2807 gst_play_sink_get_last_sample (GstPlaySink * playsink)
2808 {
2809   GstSample *result = NULL;
2810   GstPlayVideoChain *chain;
2811
2812   GST_PLAY_SINK_LOCK (playsink);
2813   GST_DEBUG_OBJECT (playsink, "taking last sample");
2814   /* get the video chain if we can */
2815   if ((chain = (GstPlayVideoChain *) playsink->videochain)) {
2816     GST_DEBUG_OBJECT (playsink, "found video chain");
2817     /* see if the chain is active */
2818     if (chain->chain.activated && chain->sink) {
2819       GstElement *elem;
2820
2821       GST_DEBUG_OBJECT (playsink, "video chain active and has a sink");
2822
2823       /* find and get the last-buffer property now */
2824       if ((elem =
2825               gst_play_sink_find_property (playsink, chain->sink,
2826                   "last-sample", GST_TYPE_SAMPLE))) {
2827         GST_DEBUG_OBJECT (playsink, "getting last-sample property");
2828         g_object_get (elem, "last-sample", &result, NULL);
2829         gst_object_unref (elem);
2830       }
2831     }
2832   }
2833   GST_PLAY_SINK_UNLOCK (playsink);
2834
2835   return result;
2836 }
2837
2838 /**
2839  * gst_play_sink_convert_sample:
2840  * @playsink: a #GstPlaySink
2841  * @caps: a #GstCaps
2842  *
2843  * Get the last displayed frame from @playsink. If caps is %NULL, the video will
2844  * be in the native format of the sink element and the caps on the buffer
2845  * describe the format of the frame. If @caps is not %NULL, the video
2846  * frame will be converted to the format of the caps.
2847  *
2848  * Returns: a #GstBuffer with the frame data or %NULL when no video frame is
2849  * available or when the conversion failed.
2850  */
2851 GstSample *
2852 gst_play_sink_convert_sample (GstPlaySink * playsink, GstCaps * caps)
2853 {
2854   GstSample *result;
2855   GError *err = NULL;
2856
2857   result = gst_play_sink_get_last_sample (playsink);
2858   if (result != NULL && caps != NULL) {
2859     GstSample *temp;
2860
2861     temp = gst_video_convert_sample (result, caps, 25 * GST_SECOND, &err);
2862     if (temp == NULL && err)
2863       goto error;
2864
2865     gst_sample_unref (result);
2866     result = temp;
2867   }
2868   return result;
2869
2870   /* ERRORS */
2871 error:
2872   {
2873     /* I'm really uncertain whether we should make playsink post an error
2874      * on the bus or not. It's not like it's a critical issue regarding
2875      * playsink behaviour. */
2876     GST_ERROR ("Error converting frame: %s", err->message);
2877     gst_sample_unref (result);
2878     g_error_free (err);
2879     return NULL;
2880   }
2881 }
2882
2883 static gboolean
2884 is_raw_structure (GstStructure * s)
2885 {
2886   const gchar *name;
2887
2888   name = gst_structure_get_name (s);
2889
2890   if (g_str_has_prefix (name, "video/x-raw") ||
2891       g_str_has_prefix (name, "audio/x-raw"))
2892     return TRUE;
2893   return FALSE;
2894 }
2895
2896 static gboolean
2897 is_raw_pad (GstPad * pad)
2898 {
2899   GstPad *peer = gst_pad_get_peer (pad);
2900   GstCaps *caps;
2901   gboolean raw = TRUE;
2902
2903   if (!peer)
2904     return raw;
2905
2906   caps = gst_pad_get_current_caps (peer);
2907   if (!caps) {
2908     guint i, n;
2909
2910     caps = gst_pad_query_caps (peer, NULL);
2911
2912     n = gst_caps_get_size (caps);
2913     for (i = 0; i < n; i++) {
2914       gboolean r = is_raw_structure (gst_caps_get_structure (caps, i));
2915
2916       if (i == 0) {
2917         raw = r;
2918       } else if (raw != r) {
2919         GST_ERROR_OBJECT (pad,
2920             "Caps contains raw and non-raw structures: %" GST_PTR_FORMAT, caps);
2921         raw = FALSE;
2922         break;
2923       }
2924     }
2925   } else {
2926     raw = is_raw_structure (gst_caps_get_structure (caps, 0));
2927   }
2928   gst_caps_unref (caps);
2929   gst_object_unref (peer);
2930
2931   return raw;
2932 }
2933
2934 static GstPadProbeReturn
2935 sinkpad_blocked_cb (GstPad * blockedpad, GstPadProbeInfo * info,
2936     gpointer user_data);
2937
2938 static void
2939 video_set_blocked (GstPlaySink * playsink, gboolean blocked)
2940 {
2941   if (playsink->video_pad) {
2942     GstPad *opad =
2943         GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
2944             (playsink->video_pad)));
2945     if (blocked && playsink->video_block_id == 0) {
2946       playsink->video_block_id =
2947           gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
2948           sinkpad_blocked_cb, gst_object_ref (playsink),
2949           (GDestroyNotify) gst_object_unref);
2950     } else if (!blocked && playsink->video_block_id) {
2951       gst_pad_remove_probe (opad, playsink->video_block_id);
2952       PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_VIDEO_RAW);
2953       PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_VIDEO);
2954       playsink->video_block_id = 0;
2955       playsink->video_pad_blocked = FALSE;
2956     }
2957     gst_object_unref (opad);
2958   }
2959 }
2960
2961 static void
2962 audio_set_blocked (GstPlaySink * playsink, gboolean blocked)
2963 {
2964   if (playsink->audio_pad) {
2965     GstPad *opad =
2966         GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
2967             (playsink->audio_pad)));
2968     if (blocked && playsink->audio_block_id == 0) {
2969       playsink->audio_block_id =
2970           gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
2971           sinkpad_blocked_cb, gst_object_ref (playsink),
2972           (GDestroyNotify) gst_object_unref);
2973     } else if (!blocked && playsink->audio_block_id) {
2974       gst_pad_remove_probe (opad, playsink->audio_block_id);
2975       PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_AUDIO_RAW);
2976       PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_AUDIO);
2977       playsink->audio_block_id = 0;
2978       playsink->audio_pad_blocked = FALSE;
2979     }
2980     gst_object_unref (opad);
2981   }
2982 }
2983
2984 static void
2985 text_set_blocked (GstPlaySink * playsink, gboolean blocked)
2986 {
2987   if (playsink->text_pad) {
2988     GstPad *opad =
2989         GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
2990             (playsink->text_pad)));
2991     if (blocked && playsink->text_block_id == 0) {
2992       playsink->text_block_id =
2993           gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
2994           sinkpad_blocked_cb, gst_object_ref (playsink),
2995           (GDestroyNotify) gst_object_unref);
2996     } else if (!blocked && playsink->text_block_id) {
2997       gst_pad_remove_probe (opad, playsink->text_block_id);
2998       PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_TEXT);
2999       playsink->text_block_id = 0;
3000       playsink->text_pad_blocked = FALSE;
3001     }
3002     gst_object_unref (opad);
3003   }
3004 }
3005
3006 static GstPadProbeReturn
3007 sinkpad_blocked_cb (GstPad * blockedpad, GstPadProbeInfo * info,
3008     gpointer user_data)
3009 {
3010   GstPlaySink *playsink = (GstPlaySink *) user_data;
3011   GstPad *pad;
3012
3013   GST_PLAY_SINK_LOCK (playsink);
3014
3015   pad = GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (blockedpad)));
3016   if (pad == playsink->video_pad) {
3017     playsink->video_pad_blocked = TRUE;
3018     GST_DEBUG_OBJECT (pad, "Video pad blocked");
3019   } else if (pad == playsink->audio_pad) {
3020     playsink->audio_pad_blocked = TRUE;
3021     GST_DEBUG_OBJECT (pad, "Audio pad blocked");
3022   } else if (pad == playsink->text_pad) {
3023     playsink->text_pad_blocked = TRUE;
3024     GST_DEBUG_OBJECT (pad, "Text pad blocked");
3025   }
3026
3027   /* We reconfigure when for ALL streams:
3028    * * there isn't a pad
3029    * * OR the pad is blocked
3030    * * OR there are no pending blocks on that pad
3031    */
3032
3033   if ((!playsink->video_pad || playsink->video_pad_blocked
3034           || !PENDING_VIDEO_BLOCK (playsink)) && (!playsink->audio_pad
3035           || playsink->audio_pad_blocked || !PENDING_AUDIO_BLOCK (playsink))
3036       && (!playsink->text_pad || playsink->text_pad_blocked
3037           || !PENDING_TEXT_BLOCK (playsink))) {
3038     GST_DEBUG_OBJECT (playsink, "All pads blocked -- reconfiguring");
3039
3040     if (playsink->video_pad) {
3041       playsink->video_pad_raw = is_raw_pad (playsink->video_pad);
3042       GST_DEBUG_OBJECT (playsink, "Video pad is raw: %d",
3043           playsink->video_pad_raw);
3044     }
3045
3046     if (playsink->audio_pad) {
3047       playsink->audio_pad_raw = is_raw_pad (playsink->audio_pad);
3048       GST_DEBUG_OBJECT (playsink, "Audio pad is raw: %d",
3049           playsink->audio_pad_raw);
3050     }
3051
3052     gst_play_sink_reconfigure (playsink);
3053
3054     video_set_blocked (playsink, FALSE);
3055     audio_set_blocked (playsink, FALSE);
3056     text_set_blocked (playsink, FALSE);
3057   }
3058
3059   gst_object_unref (pad);
3060
3061   GST_PLAY_SINK_UNLOCK (playsink);
3062
3063   return GST_PAD_PROBE_OK;
3064 }
3065
3066 static void
3067 caps_notify_cb (GstPad * pad, GParamSpec * unused, GstPlaySink * playsink)
3068 {
3069   gboolean reconfigure = FALSE;
3070   GstCaps *caps;
3071   gboolean raw;
3072
3073   g_object_get (pad, "caps", &caps, NULL);
3074   if (!caps)
3075     return;
3076
3077   if (pad == playsink->audio_pad) {
3078     raw = is_raw_pad (pad);
3079     reconfigure = (! !playsink->audio_pad_raw != ! !raw)
3080         && playsink->audiochain;
3081     GST_DEBUG_OBJECT (pad,
3082         "Audio caps changed: raw %d reconfigure %d caps %" GST_PTR_FORMAT, raw,
3083         reconfigure, caps);
3084   } else if (pad == playsink->video_pad) {
3085     raw = is_raw_pad (pad);
3086     reconfigure = (! !playsink->video_pad_raw != ! !raw)
3087         && playsink->videochain;
3088     GST_DEBUG_OBJECT (pad,
3089         "Video caps changed: raw %d reconfigure %d caps %" GST_PTR_FORMAT, raw,
3090         reconfigure, caps);
3091   }
3092
3093   gst_caps_unref (caps);
3094
3095   if (reconfigure) {
3096     GST_PLAY_SINK_LOCK (playsink);
3097     video_set_blocked (playsink, TRUE);
3098     audio_set_blocked (playsink, TRUE);
3099     text_set_blocked (playsink, TRUE);
3100     GST_PLAY_SINK_UNLOCK (playsink);
3101   }
3102 }
3103
3104 /**
3105  * gst_play_sink_request_pad
3106  * @playsink: a #GstPlaySink
3107  * @type: a #GstPlaySinkType
3108  *
3109  * Create or return a pad of @type.
3110  *
3111  * Returns: a #GstPad of @type or %NULL when the pad could not be created.
3112  */
3113 GstPad *
3114 gst_play_sink_request_pad (GstPlaySink * playsink, GstPlaySinkType type)
3115 {
3116   GstPad *res = NULL;
3117   gboolean created = FALSE;
3118   gboolean activate = TRUE;
3119   const gchar *pad_name = NULL;
3120   gulong *block_id = NULL;
3121
3122   GST_DEBUG_OBJECT (playsink, "request pad type %d", type);
3123
3124   GST_PLAY_SINK_LOCK (playsink);
3125   switch (type) {
3126     case GST_PLAY_SINK_TYPE_AUDIO_RAW:
3127     case GST_PLAY_SINK_TYPE_AUDIO:
3128       pad_name = "audio_sink";
3129       if (!playsink->audio_tee) {
3130         GST_LOG_OBJECT (playsink, "creating tee");
3131         /* create tee when needed. This element will feed the audio sink chain
3132          * and the vis chain. */
3133         playsink->audio_tee = gst_element_factory_make ("tee", "audiotee");
3134         if (playsink->audio_tee == NULL) {
3135           post_missing_element_message (playsink, "tee");
3136           GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
3137               (_("Missing element '%s' - check your GStreamer installation."),
3138                   "tee"), (NULL));
3139           res = NULL;
3140           break;
3141         } else {
3142           playsink->audio_tee_sink =
3143               gst_element_get_static_pad (playsink->audio_tee, "sink");
3144           gst_bin_add (GST_BIN_CAST (playsink), playsink->audio_tee);
3145           gst_element_set_state (playsink->audio_tee, GST_STATE_PAUSED);
3146         }
3147       } else {
3148         gst_element_set_state (playsink->audio_tee, GST_STATE_PAUSED);
3149       }
3150       if (!playsink->audio_pad) {
3151         GST_LOG_OBJECT (playsink, "ghosting tee sinkpad");
3152         playsink->audio_pad =
3153             gst_ghost_pad_new (pad_name, playsink->audio_tee_sink);
3154         g_signal_connect (G_OBJECT (playsink->audio_pad), "notify::caps",
3155             G_CALLBACK (caps_notify_cb), playsink);
3156         created = TRUE;
3157       }
3158       playsink->audio_pad_raw = FALSE;
3159       res = playsink->audio_pad;
3160       block_id = &playsink->audio_block_id;
3161       break;
3162     case GST_PLAY_SINK_TYPE_VIDEO_RAW:
3163     case GST_PLAY_SINK_TYPE_VIDEO:
3164       pad_name = "video_sink";
3165       if (!playsink->video_pad) {
3166         GST_LOG_OBJECT (playsink, "ghosting videosink");
3167         playsink->video_pad =
3168             gst_ghost_pad_new_no_target (pad_name, GST_PAD_SINK);
3169         g_signal_connect (G_OBJECT (playsink->video_pad), "notify::caps",
3170             G_CALLBACK (caps_notify_cb), playsink);
3171         created = TRUE;
3172       }
3173       playsink->video_pad_raw = FALSE;
3174       res = playsink->video_pad;
3175       block_id = &playsink->video_block_id;
3176       break;
3177     case GST_PLAY_SINK_TYPE_TEXT:
3178       GST_LOG_OBJECT (playsink, "ghosting text");
3179       if (!playsink->text_pad) {
3180         playsink->text_pad =
3181             gst_ghost_pad_new_no_target ("text_sink", GST_PAD_SINK);
3182         created = TRUE;
3183       }
3184       res = playsink->text_pad;
3185       block_id = &playsink->text_block_id;
3186       break;
3187     case GST_PLAY_SINK_TYPE_FLUSHING:
3188     {
3189       gchar *padname;
3190
3191       /* we need a unique padname for the flushing pad. */
3192       padname = g_strdup_printf ("flushing_%u", playsink->count);
3193       res = gst_ghost_pad_new_no_target (padname, GST_PAD_SINK);
3194       g_free (padname);
3195       playsink->count++;
3196       activate = FALSE;
3197       created = TRUE;
3198       break;
3199     }
3200     default:
3201       res = NULL;
3202       break;
3203   }
3204   GST_PLAY_SINK_UNLOCK (playsink);
3205
3206   if (created && res) {
3207     /* we have to add the pad when it's active or we get an error when the
3208      * element is 'running' */
3209     gst_pad_set_active (res, TRUE);
3210     gst_element_add_pad (GST_ELEMENT_CAST (playsink), res);
3211     if (block_id && *block_id == 0) {
3212       GstPad *blockpad =
3213           GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (res)));
3214
3215       *block_id =
3216           gst_pad_add_probe (blockpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
3217           sinkpad_blocked_cb, gst_object_ref (playsink),
3218           (GDestroyNotify) gst_object_unref);
3219       PENDING_FLAG_SET (playsink, type);
3220       gst_object_unref (blockpad);
3221     }
3222     if (!activate)
3223       gst_pad_set_active (res, activate);
3224   }
3225
3226   return res;
3227 }
3228
3229 static GstPad *
3230 gst_play_sink_request_new_pad (GstElement * element, GstPadTemplate * templ,
3231     const gchar * name, const GstCaps * caps)
3232 {
3233   GstPlaySink *psink;
3234   GstPad *pad;
3235   GstPlaySinkType type;
3236   const gchar *tplname;
3237
3238   g_return_val_if_fail (templ != NULL, NULL);
3239
3240   GST_DEBUG_OBJECT (element, "name:%s", name);
3241
3242   psink = GST_PLAY_SINK (element);
3243   tplname = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);
3244
3245   /* Figure out the GstPlaySinkType based on the template */
3246   if (!strcmp (tplname, "audio_sink"))
3247     type = GST_PLAY_SINK_TYPE_AUDIO;
3248   else if (!strcmp (tplname, "audio_raw_sink"))
3249     type = GST_PLAY_SINK_TYPE_AUDIO_RAW;
3250   else if (!strcmp (tplname, "video_sink"))
3251     type = GST_PLAY_SINK_TYPE_VIDEO;
3252   else if (!strcmp (tplname, "video_raw_sink"))
3253     type = GST_PLAY_SINK_TYPE_VIDEO_RAW;
3254   else if (!strcmp (tplname, "text_sink"))
3255     type = GST_PLAY_SINK_TYPE_TEXT;
3256   else
3257     goto unknown_template;
3258
3259   pad = gst_play_sink_request_pad (psink, type);
3260   return pad;
3261
3262 unknown_template:
3263   GST_WARNING_OBJECT (element, "Unknown pad template");
3264   return NULL;
3265 }
3266
3267 void
3268 gst_play_sink_release_pad (GstPlaySink * playsink, GstPad * pad)
3269 {
3270   GstPad **res = NULL;
3271   gboolean untarget = TRUE;
3272
3273   GST_DEBUG_OBJECT (playsink, "release pad %" GST_PTR_FORMAT, pad);
3274
3275   GST_PLAY_SINK_LOCK (playsink);
3276   if (pad == playsink->video_pad) {
3277     res = &playsink->video_pad;
3278     g_signal_handlers_disconnect_by_func (playsink->video_pad, caps_notify_cb,
3279         playsink);
3280   } else if (pad == playsink->audio_pad) {
3281     res = &playsink->audio_pad;
3282     g_signal_handlers_disconnect_by_func (playsink->audio_pad, caps_notify_cb,
3283         playsink);
3284   } else if (pad == playsink->text_pad) {
3285     res = &playsink->text_pad;
3286   } else {
3287     /* try to release the given pad anyway, these could be the FLUSHING pads. */
3288     res = &pad;
3289     untarget = FALSE;
3290   }
3291   GST_PLAY_SINK_UNLOCK (playsink);
3292
3293   if (*res) {
3294     GST_DEBUG_OBJECT (playsink, "deactivate pad %" GST_PTR_FORMAT, *res);
3295     gst_pad_set_active (*res, FALSE);
3296     if (untarget) {
3297       GST_DEBUG_OBJECT (playsink, "untargeting pad %" GST_PTR_FORMAT, *res);
3298       gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (*res), NULL);
3299     }
3300     GST_DEBUG_OBJECT (playsink, "remove pad %" GST_PTR_FORMAT, *res);
3301     gst_element_remove_pad (GST_ELEMENT_CAST (playsink), *res);
3302     *res = NULL;
3303   }
3304 }
3305
3306 static void
3307 gst_play_sink_release_request_pad (GstElement * element, GstPad * pad)
3308 {
3309   GstPlaySink *psink = GST_PLAY_SINK (element);
3310
3311   gst_play_sink_release_pad (psink, pad);
3312 }
3313
3314 static void
3315 gst_play_sink_handle_message (GstBin * bin, GstMessage * message)
3316 {
3317   GstPlaySink *playsink;
3318
3319   playsink = GST_PLAY_SINK_CAST (bin);
3320
3321   switch (GST_MESSAGE_TYPE (message)) {
3322     case GST_MESSAGE_STEP_DONE:
3323     {
3324       GstFormat format;
3325       guint64 amount;
3326       gdouble rate;
3327       gboolean flush, intermediate, eos;
3328       guint64 duration;
3329
3330       GST_INFO_OBJECT (playsink, "Handling step-done message");
3331       gst_message_parse_step_done (message, &format, &amount, &rate, &flush,
3332           &intermediate, &duration, &eos);
3333
3334       if (format == GST_FORMAT_BUFFERS) {
3335         /* for the buffer format, we align the other streams */
3336         if (playsink->audiochain) {
3337           GstEvent *event;
3338
3339           event =
3340               gst_event_new_step (GST_FORMAT_TIME, duration, rate, flush,
3341               intermediate);
3342
3343           if (!gst_element_send_event (playsink->audiochain->chain.bin, event)) {
3344             GST_DEBUG_OBJECT (playsink, "Event failed when sent to audio sink");
3345           }
3346         }
3347       }
3348       GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (bin, message);
3349       break;
3350     }
3351     default:
3352       GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (bin, message);
3353       break;
3354   }
3355 }
3356
3357 /* Send an event to our sinks until one of them works; don't then send to the
3358  * remaining sinks (unlike GstBin)
3359  * Special case: If a text sink is set we need to send the event
3360  * to them in case it's source is different from the a/v stream's source.
3361  */
3362 static gboolean
3363 gst_play_sink_send_event_to_sink (GstPlaySink * playsink, GstEvent * event)
3364 {
3365   gboolean res = TRUE;
3366
3367   if (playsink->textchain && playsink->textchain->sink) {
3368     gst_event_ref (event);
3369     if ((res = gst_element_send_event (playsink->textchain->chain.bin, event))) {
3370       GST_DEBUG_OBJECT (playsink, "Sent event successfully to text sink");
3371     } else {
3372       GST_DEBUG_OBJECT (playsink, "Event failed when sent to text sink");
3373     }
3374   }
3375
3376   if (playsink->videochain) {
3377     gst_event_ref (event);
3378     if ((res = gst_element_send_event (playsink->videochain->chain.bin, event))) {
3379       GST_DEBUG_OBJECT (playsink, "Sent event successfully to video sink");
3380       goto done;
3381     }
3382     GST_DEBUG_OBJECT (playsink, "Event failed when sent to video sink");
3383   }
3384   if (playsink->audiochain) {
3385     gst_event_ref (event);
3386     if ((res = gst_element_send_event (playsink->audiochain->chain.bin, event))) {
3387       GST_DEBUG_OBJECT (playsink, "Sent event successfully to audio sink");
3388       goto done;
3389     }
3390     GST_DEBUG_OBJECT (playsink, "Event failed when sent to audio sink");
3391   }
3392
3393 done:
3394   gst_event_unref (event);
3395   return res;
3396 }
3397
3398 /* We only want to send the event to a single sink (overriding GstBin's
3399  * behaviour), but we want to keep GstPipeline's behaviour - wrapping seek
3400  * events appropriately. So, this is a messy duplication of code. */
3401 static gboolean
3402 gst_play_sink_send_event (GstElement * element, GstEvent * event)
3403 {
3404   gboolean res = FALSE;
3405   GstEventType event_type = GST_EVENT_TYPE (event);
3406   GstPlaySink *playsink;
3407
3408   playsink = GST_PLAY_SINK_CAST (element);
3409
3410   switch (event_type) {
3411     case GST_EVENT_SEEK:
3412       GST_DEBUG_OBJECT (element, "Sending event to a sink");
3413       res = gst_play_sink_send_event_to_sink (playsink, event);
3414       break;
3415     case GST_EVENT_STEP:
3416     {
3417       GstFormat format;
3418       guint64 amount;
3419       gdouble rate;
3420       gboolean flush, intermediate;
3421
3422       gst_event_parse_step (event, &format, &amount, &rate, &flush,
3423           &intermediate);
3424
3425       if (format == GST_FORMAT_BUFFERS) {
3426         /* for buffers, we will try to step video frames, for other formats we
3427          * send the step to all sinks */
3428         res = gst_play_sink_send_event_to_sink (playsink, event);
3429       } else {
3430         res =
3431             GST_ELEMENT_CLASS (gst_play_sink_parent_class)->send_event (element,
3432             event);
3433       }
3434       break;
3435     }
3436     default:
3437       res =
3438           GST_ELEMENT_CLASS (gst_play_sink_parent_class)->send_event (element,
3439           event);
3440       break;
3441   }
3442   return res;
3443 }
3444
3445 static GstStateChangeReturn
3446 gst_play_sink_change_state (GstElement * element, GstStateChange transition)
3447 {
3448   GstStateChangeReturn ret;
3449   GstStateChangeReturn bret;
3450
3451   GstPlaySink *playsink;
3452
3453   playsink = GST_PLAY_SINK (element);
3454
3455   switch (transition) {
3456     case GST_STATE_CHANGE_READY_TO_PAUSED:
3457       playsink->need_async_start = TRUE;
3458       /* we want to go async to PAUSED until we managed to configure and add the
3459        * sinks */
3460       do_async_start (playsink);
3461       ret = GST_STATE_CHANGE_ASYNC;
3462       break;
3463     case GST_STATE_CHANGE_PAUSED_TO_READY:
3464       /* unblock all pads here */
3465       GST_PLAY_SINK_LOCK (playsink);
3466       video_set_blocked (playsink, FALSE);
3467       audio_set_blocked (playsink, FALSE);
3468       text_set_blocked (playsink, FALSE);
3469       GST_PLAY_SINK_UNLOCK (playsink);
3470       /* fall through */
3471     case GST_STATE_CHANGE_READY_TO_NULL:
3472       if (playsink->audiochain && playsink->audiochain->sink_volume) {
3473         /* remove our links to the mute and volume elements when they were
3474          * provided by a sink */
3475         disconnect_chain (playsink->audiochain, playsink);
3476         playsink->audiochain->volume = NULL;
3477         playsink->audiochain->mute = NULL;
3478       }
3479
3480       if (playsink->audiochain && playsink->audiochain->ts_offset) {
3481         gst_object_unref (playsink->audiochain->ts_offset);
3482         playsink->audiochain->ts_offset = NULL;
3483       }
3484
3485       if (playsink->videochain && playsink->videochain->ts_offset) {
3486         gst_object_unref (playsink->videochain->ts_offset);
3487         playsink->videochain->ts_offset = NULL;
3488       }
3489       ret = GST_STATE_CHANGE_SUCCESS;
3490       break;
3491     default:
3492       /* all other state changes return SUCCESS by default, this value can be
3493        * overridden by the result of the children */
3494       ret = GST_STATE_CHANGE_SUCCESS;
3495       break;
3496   }
3497
3498   /* do the state change of the children */
3499   bret =
3500       GST_ELEMENT_CLASS (gst_play_sink_parent_class)->change_state (element,
3501       transition);
3502   /* now look at the result of our children and adjust the return value */
3503   switch (bret) {
3504     case GST_STATE_CHANGE_FAILURE:
3505       /* failure, we stop */
3506       goto activate_failed;
3507     case GST_STATE_CHANGE_NO_PREROLL:
3508       /* some child returned NO_PREROLL. This is strange but we never know. We
3509        * commit our async state change (if any) and return the NO_PREROLL */
3510       do_async_done (playsink);
3511       ret = bret;
3512       break;
3513     case GST_STATE_CHANGE_ASYNC:
3514       /* some child was async, return this */
3515       ret = bret;
3516       break;
3517     default:
3518       /* return our previously configured return value */
3519       break;
3520   }
3521
3522   switch (transition) {
3523     case GST_STATE_CHANGE_READY_TO_PAUSED:
3524       break;
3525     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
3526       /* FIXME Release audio device when we implement that */
3527       playsink->need_async_start = TRUE;
3528       break;
3529     case GST_STATE_CHANGE_PAUSED_TO_READY:{
3530       if (playsink->video_sinkpad_stream_synchronizer) {
3531         gst_element_release_request_pad (GST_ELEMENT_CAST
3532             (playsink->stream_synchronizer),
3533             playsink->video_sinkpad_stream_synchronizer);
3534         gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
3535         playsink->video_sinkpad_stream_synchronizer = NULL;
3536         gst_object_unref (playsink->video_srcpad_stream_synchronizer);
3537         playsink->video_srcpad_stream_synchronizer = NULL;
3538       }
3539       if (playsink->audio_sinkpad_stream_synchronizer) {
3540         gst_element_release_request_pad (GST_ELEMENT_CAST
3541             (playsink->stream_synchronizer),
3542             playsink->audio_sinkpad_stream_synchronizer);
3543         gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
3544         playsink->audio_sinkpad_stream_synchronizer = NULL;
3545         gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
3546         playsink->audio_srcpad_stream_synchronizer = NULL;
3547       }
3548       if (playsink->text_sinkpad_stream_synchronizer) {
3549         gst_element_release_request_pad (GST_ELEMENT_CAST
3550             (playsink->stream_synchronizer),
3551             playsink->text_sinkpad_stream_synchronizer);
3552         gst_object_unref (playsink->text_sinkpad_stream_synchronizer);
3553         playsink->text_sinkpad_stream_synchronizer = NULL;
3554         gst_object_unref (playsink->text_srcpad_stream_synchronizer);
3555         playsink->text_srcpad_stream_synchronizer = NULL;
3556       }
3557     }
3558       /* fall through */
3559     case GST_STATE_CHANGE_READY_TO_NULL:
3560       /* remove sinks we added */
3561       if (playsink->videodeinterlacechain) {
3562         activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain),
3563             FALSE);
3564         add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
3565       }
3566       if (playsink->videochain) {
3567         activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
3568         add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
3569       }
3570       if (playsink->audiochain) {
3571         activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
3572         add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
3573       }
3574       if (playsink->vischain) {
3575         activate_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
3576         add_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
3577       }
3578       if (playsink->textchain) {
3579         activate_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
3580         add_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
3581       }
3582       do_async_done (playsink);
3583       /* when going to READY, keep elements around as long as possible,
3584        * so they may be re-used faster next time/url around.
3585        * when really going to NULL, clean up everything completely. */
3586       if (transition == GST_STATE_CHANGE_READY_TO_NULL) {
3587
3588         /* Unparent the sinks to allow reuse */
3589         if (playsink->videochain && playsink->videochain->sink)
3590           gst_bin_remove (GST_BIN_CAST (playsink->videochain->chain.bin),
3591               playsink->videochain->sink);
3592         if (playsink->audiochain && playsink->audiochain->sink)
3593           gst_bin_remove (GST_BIN_CAST (playsink->audiochain->chain.bin),
3594               playsink->audiochain->sink);
3595         if (playsink->textchain && playsink->textchain->sink)
3596           gst_bin_remove (GST_BIN_CAST (playsink->textchain->chain.bin),
3597               playsink->textchain->sink);
3598
3599         if (playsink->audio_sink != NULL)
3600           gst_element_set_state (playsink->audio_sink, GST_STATE_NULL);
3601         if (playsink->video_sink != NULL)
3602           gst_element_set_state (playsink->video_sink, GST_STATE_NULL);
3603         if (playsink->visualisation != NULL)
3604           gst_element_set_state (playsink->visualisation, GST_STATE_NULL);
3605         if (playsink->text_sink != NULL)
3606           gst_element_set_state (playsink->text_sink, GST_STATE_NULL);
3607
3608         free_chain ((GstPlayChain *) playsink->videodeinterlacechain);
3609         playsink->videodeinterlacechain = NULL;
3610         free_chain ((GstPlayChain *) playsink->videochain);
3611         playsink->videochain = NULL;
3612         free_chain ((GstPlayChain *) playsink->audiochain);
3613         playsink->audiochain = NULL;
3614         free_chain ((GstPlayChain *) playsink->vischain);
3615         playsink->vischain = NULL;
3616         free_chain ((GstPlayChain *) playsink->textchain);
3617         playsink->textchain = NULL;
3618       }
3619       break;
3620     default:
3621       break;
3622   }
3623   return ret;
3624
3625   /* ERRORS */
3626 activate_failed:
3627   {
3628     GST_DEBUG_OBJECT (element,
3629         "element failed to change states -- activation problem?");
3630     return GST_STATE_CHANGE_FAILURE;
3631   }
3632 }
3633
3634 static void
3635 gst_play_sink_set_property (GObject * object, guint prop_id,
3636     const GValue * value, GParamSpec * spec)
3637 {
3638   GstPlaySink *playsink = GST_PLAY_SINK (object);
3639
3640   switch (prop_id) {
3641     case PROP_FLAGS:
3642       gst_play_sink_set_flags (playsink, g_value_get_flags (value));
3643       break;
3644     case PROP_VOLUME:
3645       gst_play_sink_set_volume (playsink, g_value_get_double (value));
3646       break;
3647     case PROP_MUTE:
3648       gst_play_sink_set_mute (playsink, g_value_get_boolean (value));
3649       break;
3650     case PROP_FONT_DESC:
3651       gst_play_sink_set_font_desc (playsink, g_value_get_string (value));
3652       break;
3653     case PROP_SUBTITLE_ENCODING:
3654       gst_play_sink_set_subtitle_encoding (playsink,
3655           g_value_get_string (value));
3656       break;
3657     case PROP_VIS_PLUGIN:
3658       gst_play_sink_set_vis_plugin (playsink, g_value_get_object (value));
3659       break;
3660     case PROP_AV_OFFSET:
3661       gst_play_sink_set_av_offset (playsink, g_value_get_int64 (value));
3662       break;
3663     case PROP_VIDEO_SINK:
3664       gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_VIDEO,
3665           g_value_get_object (value));
3666       break;
3667     case PROP_AUDIO_SINK:
3668       gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_AUDIO,
3669           g_value_get_object (value));
3670       break;
3671     case PROP_TEXT_SINK:
3672       gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_TEXT,
3673           g_value_get_object (value));
3674       break;
3675     default:
3676       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
3677       break;
3678   }
3679 }
3680
3681 static void
3682 gst_play_sink_get_property (GObject * object, guint prop_id,
3683     GValue * value, GParamSpec * spec)
3684 {
3685   GstPlaySink *playsink = GST_PLAY_SINK (object);
3686
3687   switch (prop_id) {
3688     case PROP_FLAGS:
3689       g_value_set_flags (value, gst_play_sink_get_flags (playsink));
3690       break;
3691     case PROP_VOLUME:
3692       g_value_set_double (value, gst_play_sink_get_volume (playsink));
3693       break;
3694     case PROP_MUTE:
3695       g_value_set_boolean (value, gst_play_sink_get_mute (playsink));
3696       break;
3697     case PROP_FONT_DESC:
3698       g_value_take_string (value, gst_play_sink_get_font_desc (playsink));
3699       break;
3700     case PROP_SUBTITLE_ENCODING:
3701       g_value_take_string (value,
3702           gst_play_sink_get_subtitle_encoding (playsink));
3703       break;
3704     case PROP_VIS_PLUGIN:
3705       g_value_take_object (value, gst_play_sink_get_vis_plugin (playsink));
3706       break;
3707     case PROP_SAMPLE:
3708       gst_value_take_sample (value, gst_play_sink_get_last_sample (playsink));
3709       break;
3710     case PROP_AV_OFFSET:
3711       g_value_set_int64 (value, gst_play_sink_get_av_offset (playsink));
3712       break;
3713     case PROP_VIDEO_SINK:
3714       g_value_take_object (value, gst_play_sink_get_sink (playsink,
3715               GST_PLAY_SINK_TYPE_VIDEO));
3716       break;
3717     case PROP_AUDIO_SINK:
3718       g_value_take_object (value, gst_play_sink_get_sink (playsink,
3719               GST_PLAY_SINK_TYPE_AUDIO));
3720       break;
3721     case PROP_TEXT_SINK:
3722       g_value_take_object (value, gst_play_sink_get_sink (playsink,
3723               GST_PLAY_SINK_TYPE_TEXT));
3724       break;
3725     default:
3726       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
3727       break;
3728   }
3729 }
3730
3731
3732 gboolean
3733 gst_play_sink_plugin_init (GstPlugin * plugin)
3734 {
3735   GST_DEBUG_CATEGORY_INIT (gst_play_sink_debug, "playsink", 0, "play bin");
3736
3737   return gst_element_register (plugin, "playsink", GST_RANK_NONE,
3738       GST_TYPE_PLAY_SINK);
3739 }