gst/playback/gstplaybin.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <string.h>
  25 #include <gst/gst.h>
  26
  27 #include <gst/gst-i18n-plugin.h>
  28
  29 #include "gstplaybasebin.h"
  30
  31 GST_DEBUG_CATEGORY_STATIC (gst_play_bin_debug);
  32 #define GST_CAT_DEFAULT gst_play_bin_debug
  33
  34 #define GST_TYPE_PLAY_BIN               (gst_play_bin_get_type())
  35 #define GST_PLAY_BIN(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PLAY_BIN,GstPlayBin))
  36 #define GST_PLAY_BIN_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PLAY_BIN,GstPlayBinClass))
  37 #define GST_IS_PLAY_BIN(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PLAY_BIN))
  38 #define GST_IS_PLAY_BIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PLAY_BIN))
  39
  40 #define VOLUME_MAX_DOUBLE 4.0
  41
  42 #ifndef GST_HAVE_GLIB_2_8
  43 #define _gst_gvalue_set_gstobject(gvalue,obj)  \
  44       if (obj != NULL) {                       \
  45         gst_object_ref (obj);                  \
  46         g_value_set_object (gvalue, obj);      \
  47         g_object_unref (obj);                  \
  48       } else {                                 \
  49         g_value_set_object (gvalue, NULL);     \
  50       }
  51 #else
  52 #define _gst_gvalue_set_gstobject(gvalue,obj)  \
  53       g_value_set_object (gvalue, obj);
  54 #endif
  55
  56 typedef struct _GstPlayBin GstPlayBin;
  57 typedef struct _GstPlayBinClass GstPlayBinClass;
  58
  59 struct _GstPlayBin
  60 {
  61   GstPlayBaseBin parent;
  62
  63   /* the configurable elements */
  64   GstElement *fakesink;
  65   GstElement *audio_sink;
  66   GstElement *video_sink;
  67   GstElement *visualisation;
  68   GstElement *volume_element;
  69   GstElement *textoverlay_element;
  70   gfloat volume;
  71
  72   /* these are the currently active sinks */
  73   GList *sinks;
  74
  75   /* the last captured frame for snapshots */
  76   GstBuffer *frame;
  77
  78   /* our cache for the sinks */
  79   GHashTable *cache;
  80
  81   /* font description */
  82   gchar *font_desc;
  83 };
  84
  85 struct _GstPlayBinClass
  86 {
  87   GstPlayBaseBinClass parent_class;
  88 };
  89
  90 /* props */
  91 enum
  92 {
  93   ARG_0,
  94   ARG_AUDIO_SINK,
  95   ARG_VIDEO_SINK,
  96   ARG_VIS_PLUGIN,
  97   ARG_VOLUME,
  98   ARG_FRAME,
  99   ARG_FONT_DESC
 100 };
 101
 102 /* signals */
 103 enum
 104 {
 105   LAST_SIGNAL
 106 };
 107
 108 static void gst_play_bin_class_init (GstPlayBinClass * klass);
 109 static void gst_play_bin_init (GstPlayBin * play_bin);
 110 static void gst_play_bin_dispose (GObject * object);
 111
 112 static gboolean setup_sinks (GstPlayBaseBin * play_base_bin,
 113     GstPlayBaseGroup * group);
 114 static void remove_sinks (GstPlayBin * play_bin);
 115
 116 static void gst_play_bin_set_property (GObject * object, guint prop_id,
 117     const GValue * value, GParamSpec * spec);
 118 static void gst_play_bin_get_property (GObject * object, guint prop_id,
 119     GValue * value, GParamSpec * spec);
 120
 121 static gboolean gst_play_bin_send_event (GstElement * element,
 122     GstEvent * event);
 123 static GstStateChangeReturn gst_play_bin_change_state (GstElement * element,
 124     GstStateChange transition);
 125
 126 static GstElementClass *parent_class;
 127
 128 //static guint gst_play_bin_signals[LAST_SIGNAL] = { 0 };
 129
 130 static GstElementDetails gst_play_bin_details = {
 131   "Player Bin",
 132   "Generic/Bin/Player",
 133   "Autoplug and play media from an uri",
 134   "Wim Taymans <wim@fluendo.com>"
 135 };
 136
 137 static GType
 138 gst_play_bin_get_type (void)
 139 {
 140   static GType gst_play_bin_type = 0;
 141
 142   if (!gst_play_bin_type) {
 143     static const GTypeInfo gst_play_bin_info = {
 144       sizeof (GstPlayBinClass),
 145       NULL,
 146       NULL,
 147       (GClassInitFunc) gst_play_bin_class_init,
 148       NULL,
 149       NULL,
 150       sizeof (GstPlayBin),
 151       0,
 152       (GInstanceInitFunc) gst_play_bin_init,
 153       NULL
 154     };
 155
 156     gst_play_bin_type = g_type_register_static (GST_TYPE_PLAY_BASE_BIN,
 157         "GstPlayBin", &gst_play_bin_info, 0);
 158   }
 159
 160   return gst_play_bin_type;
 161 }
 162
 163 static void
 164 gst_play_bin_class_init (GstPlayBinClass * klass)
 165 {
 166   GObjectClass *gobject_klass;
 167   GstElementClass *gstelement_klass;
 168   GstBinClass *gstbin_klass;
 169   GstPlayBaseBinClass *playbasebin_klass;
 170
 171   gobject_klass = (GObjectClass *) klass;
 172   gstelement_klass = (GstElementClass *) klass;
 173   gstbin_klass = (GstBinClass *) klass;
 174   playbasebin_klass = (GstPlayBaseBinClass *) klass;
 175
 176   parent_class = g_type_class_ref (gst_play_base_bin_get_type ());
 177
 178   gobject_klass->set_property = gst_play_bin_set_property;
 179   gobject_klass->get_property = gst_play_bin_get_property;
 180
 181   g_object_class_install_property (gobject_klass, ARG_VIDEO_SINK,
 182       g_param_spec_object ("video-sink", "Video Sink",
 183           "the video output element to use (NULL = default sink)",
 184           GST_TYPE_ELEMENT, G_PARAM_READWRITE));
 185   g_object_class_install_property (gobject_klass, ARG_AUDIO_SINK,
 186       g_param_spec_object ("audio-sink", "Audio Sink",
 187           "the audio output element to use (NULL = default sink)",
 188           GST_TYPE_ELEMENT, G_PARAM_READWRITE));
 189   g_object_class_install_property (gobject_klass, ARG_VIS_PLUGIN,
 190       g_param_spec_object ("vis-plugin", "Vis plugin",
 191           "the visualization element to use (NULL = none)",
 192           GST_TYPE_ELEMENT, G_PARAM_READWRITE));
 193   g_object_class_install_property (gobject_klass, ARG_VOLUME,
 194       g_param_spec_double ("volume", "volume", "volume",
 195           0.0, VOLUME_MAX_DOUBLE, 1.0, G_PARAM_READWRITE));
 196   g_object_class_install_property (gobject_klass, ARG_FRAME,
 197       gst_param_spec_mini_object ("frame", "Frame",
 198           "The last frame (NULL = no video available)",
 199           GST_TYPE_BUFFER, G_PARAM_READABLE));
 200   g_object_class_install_property (gobject_klass, ARG_FONT_DESC,
 201       g_param_spec_string ("subtitle-font-desc",
 202           "Subtitle font description",
 203           "Pango font description of font "
 204           "to be used for subtitle rendering", NULL, G_PARAM_WRITABLE));
 205
 206   gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_bin_dispose);
 207
 208   gst_element_class_set_details (gstelement_klass, &gst_play_bin_details);
 209
 210   gstelement_klass->change_state =
 211       GST_DEBUG_FUNCPTR (gst_play_bin_change_state);
 212   gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_bin_send_event);
 213
 214   playbasebin_klass->setup_output_pads = setup_sinks;
 215 }
 216
 217 static void
 218 gst_play_bin_init (GstPlayBin * play_bin)
 219 {
 220   play_bin->video_sink = NULL;
 221   play_bin->audio_sink = NULL;
 222   play_bin->visualisation = NULL;
 223   play_bin->volume_element = NULL;
 224   play_bin->textoverlay_element = NULL;
 225   play_bin->volume = 1.0;
 226   play_bin->sinks = NULL;
 227   play_bin->frame = NULL;
 228   play_bin->font_desc = NULL;
 229   play_bin->cache = g_hash_table_new_full (g_str_hash, g_str_equal,
 230       NULL, (GDestroyNotify) gst_object_unref);
 231 }
 232
 233 static void
 234 gst_play_bin_dispose (GObject * object)
 235 {
 236   GstPlayBin *play_bin;
 237
 238   play_bin = GST_PLAY_BIN (object);
 239
 240   if (play_bin->cache != NULL) {
 241     remove_sinks (play_bin);
 242     g_hash_table_destroy (play_bin->cache);
 243     play_bin->cache = NULL;
 244   }
 245
 246   if (play_bin->audio_sink != NULL) {
 247     gst_element_set_state (play_bin->audio_sink, GST_STATE_NULL);
 248     gst_object_unref (play_bin->audio_sink);
 249     play_bin->audio_sink = NULL;
 250   }
 251   if (play_bin->video_sink != NULL) {
 252     gst_element_set_state (play_bin->video_sink, GST_STATE_NULL);
 253     gst_object_unref (play_bin->video_sink);
 254     play_bin->video_sink = NULL;
 255   }
 256   if (play_bin->visualisation != NULL) {
 257     gst_element_set_state (play_bin->visualisation, GST_STATE_NULL);
 258     gst_object_unref (play_bin->visualisation);
 259     play_bin->visualisation = NULL;
 260   }
 261   g_free (play_bin->font_desc);
 262   play_bin->font_desc = NULL;
 263
 264   G_OBJECT_CLASS (parent_class)->dispose (object);
 265 }
 266
 267
 268 static void
 269 gst_play_bin_set_property (GObject * object, guint prop_id,
 270     const GValue * value, GParamSpec * pspec)
 271 {
 272   GstPlayBin *play_bin;
 273
 274   g_return_if_fail (GST_IS_PLAY_BIN (object));
 275
 276   play_bin = GST_PLAY_BIN (object);
 277
 278   switch (prop_id) {
 279     case ARG_VIDEO_SINK:
 280       if (play_bin->video_sink != NULL) {
 281         gst_object_unref (play_bin->video_sink);
 282       }
 283       play_bin->video_sink = g_value_get_object (value);
 284       if (play_bin->video_sink != NULL) {
 285         gst_object_ref (play_bin->video_sink);
 286         gst_object_sink (GST_OBJECT (play_bin->video_sink));
 287       }
 288       /* when changing the videosink, we just remove the
 289        * video pipeline from the cache so that it will be
 290        * regenerated with the new sink element */
 291       g_hash_table_remove (play_bin->cache, "vbin");
 292       break;
 293     case ARG_AUDIO_SINK:
 294       if (play_bin->audio_sink != NULL) {
 295         gst_object_unref (play_bin->audio_sink);
 296       }
 297       play_bin->audio_sink = g_value_get_object (value);
 298       if (play_bin->audio_sink != NULL) {
 299         gst_object_ref (play_bin->audio_sink);
 300         gst_object_sink (GST_OBJECT (play_bin->audio_sink));
 301       }
 302       g_hash_table_remove (play_bin->cache, "abin");
 303       break;
 304     case ARG_VIS_PLUGIN:
 305       if (play_bin->visualisation != NULL) {
 306         gst_object_unref (play_bin->visualisation);
 307       }
 308       play_bin->visualisation = g_value_get_object (value);
 309       if (play_bin->visualisation != NULL) {
 310         gst_object_ref (play_bin->visualisation);
 311         gst_object_sink (GST_OBJECT (play_bin->visualisation));
 312       }
 313       break;
 314     case ARG_VOLUME:
 315       play_bin->volume = g_value_get_double (value);
 316       if (play_bin->volume_element) {
 317         g_object_set (G_OBJECT (play_bin->volume_element), "volume",
 318             play_bin->volume, NULL);
 319       }
 320       break;
 321     case ARG_FONT_DESC:
 322       g_free (play_bin->font_desc);
 323       play_bin->font_desc = g_strdup (g_value_get_string (value));
 324       if (play_bin->textoverlay_element) {
 325         g_object_set (G_OBJECT (play_bin->textoverlay_element),
 326             "font-desc", g_value_get_string (value), NULL);
 327       }
 328       break;
 329     default:
 330       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 331       break;
 332   }
 333 }
 334
 335 static void
 336 gst_play_bin_get_property (GObject * object, guint prop_id, GValue * value,
 337     GParamSpec * pspec)
 338 {
 339   GstPlayBin *play_bin;
 340
 341   g_return_if_fail (GST_IS_PLAY_BIN (object));
 342
 343   play_bin = GST_PLAY_BIN (object);
 344
 345   switch (prop_id) {
 346     case ARG_VIDEO_SINK:
 347       _gst_gvalue_set_gstobject (value, play_bin->video_sink);
 348       break;
 349     case ARG_AUDIO_SINK:
 350       _gst_gvalue_set_gstobject (value, play_bin->audio_sink);
 351       break;
 352     case ARG_VIS_PLUGIN:
 353       _gst_gvalue_set_gstobject (value, play_bin->visualisation);
 354       break;
 355     case ARG_VOLUME:
 356       g_value_set_double (value, play_bin->volume);
 357       break;
 358     case ARG_FRAME:
 359       gst_value_set_mini_object (value, GST_MINI_OBJECT (play_bin->frame));
 360       break;
 361     default:
 362       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 363       break;
 364   }
 365 }
 366
 367 /* signal fired when the identity has received a new buffer. This is used for
 368  * making screenshots.
 369  */
 370 static void
 371 handoff (GstElement * identity, GstBuffer * frame, gpointer data)
 372 {
 373   GstPlayBin *play_bin = GST_PLAY_BIN (data);
 374
 375   gst_mini_object_replace ((GstMiniObject **) & play_bin->frame,
 376       GST_MINI_OBJECT_CAST (frame));
 377
 378   /* applications need to know the buffer caps,
 379    * make sure they are always set on the frame */
 380   if (GST_BUFFER_CAPS (play_bin->frame) == NULL) {
 381     GstPad *pad;
 382
 383     if ((pad = gst_element_get_pad (identity, "sink"))) {
 384       gst_buffer_set_caps (play_bin->frame, GST_PAD_CAPS (pad));
 385       gst_object_unref (pad);
 386     }
 387   }
 388 }
 389
 390 /* make the element (bin) that contains the elements needed to perform
 391  * video display. We connect a handoff signal to identity so that we
 392  * can grab snapshots. Identity's sinkpad is ghosted to vbin.
 393  *
 394  *  +-------------------------------------------------------------+
 395  *  | vbin                                                        |
 396  *  |      +--------+   +----------+   +----------+   +---------+ |
 397  *  |      |identity|   |colorspace|   |videoscale|   |videosink| |
 398  *  |   +-sink     src-sink       src-sink       src-sink       | |
 399  *  |   |  +---+----+   +----------+   +----------+   +---------+ |
 400  * sink-+      |                                                  |
 401  *  +----------|--------------------------------------------------+
 402  *           handoff
 403  */
 404 /* FIXME: this might return NULL if no videosink was found, handle
 405  * this in callers */
 406 static GstElement *
 407 gen_video_element (GstPlayBin * play_bin)
 408 {
 409   GstElement *element;
 410   GstElement *conv;
 411
 412   GstElement *scale;
 413   GstElement *sink;
 414   GstElement *identity;
 415   GstPad *pad;
 416
 417   /* first see if we have it in the cache */
 418   element = g_hash_table_lookup (play_bin->cache, "vbin");
 419   if (element != NULL) {
 420     return element;
 421   }
 422
 423   if (play_bin->video_sink) {
 424     sink = play_bin->video_sink;
 425   } else {
 426     sink = gst_element_factory_make ("autovideosink", "videosink");
 427     if (sink == NULL) {
 428       sink = gst_element_factory_make ("xvimagesink", "videosink");
 429     }
 430     /* FIXME: this warrants adding a CORE error category for missing
 431      * elements/plugins */
 432     if (sink == NULL) {
 433       GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,
 434           (_("Both autovideosink and xvimagesink elements are missing.")),
 435           (NULL));
 436       return NULL;
 437     }
 438   }
 439   gst_object_ref (sink);
 440   g_hash_table_insert (play_bin->cache, "video_sink", sink);
 441
 442
 443   element = gst_bin_new ("vbin");
 444   identity = gst_element_factory_make ("identity", "id");
 445   g_object_set (identity, "silent", TRUE, NULL);
 446   g_signal_connect (identity, "handoff", G_CALLBACK (handoff), play_bin);
 447   conv = gst_element_factory_make ("ffmpegcolorspace", "vconv");
 448   scale = gst_element_factory_make ("videoscale", "vscale");
 449   gst_bin_add (GST_BIN (element), identity);
 450   gst_bin_add (GST_BIN (element), conv);
 451   gst_bin_add (GST_BIN (element), scale);
 452   gst_bin_add (GST_BIN (element), sink);
 453   gst_element_link_pads (identity, "src", conv, "sink");
 454   gst_element_link_pads (conv, "src", scale, "sink");
 455   gst_element_link_pads (scale, "src", sink, "sink");
 456
 457   pad = gst_element_get_pad (identity, "sink");
 458   gst_element_add_pad (element, gst_ghost_pad_new ("sink", pad));
 459   gst_object_unref (pad);
 460
 461   gst_element_set_state (element, GST_STATE_READY);
 462
 463   /* since we're gonna add it to a bin but don't want to lose it,
 464    * we keep a reference. */
 465   gst_object_ref (element);
 466   g_hash_table_insert (play_bin->cache, "vbin", element);
 467
 468   return element;
 469 }
 470
 471 /* make an element for playback of video with subtitles embedded.
 472  *
 473  *  +--------------------------------------------------+
 474  *  | tbin                  +-------------+            |
 475  *  |          +-----+      | textoverlay |   +------+ |
 476  *  |          | csp | +--video_sink      |   | vbin | |
 477  * video_sink-sink  src+ +-text_sink     src-sink    | |
 478  *  |          +-----+   |  +-------------+   +------+ |
 479  * text_sink-------------+                             |
 480  *  +--------------------------------------------------+
 481  */
 482
 483 static GstElement *
 484 gen_text_element (GstPlayBin * play_bin)
 485 {
 486   GstElement *element, *csp, *overlay, *vbin;
 487   GstPad *pad;
 488
 489   overlay = gst_element_factory_make ("textoverlay", "overlay");
 490   g_object_set (G_OBJECT (overlay),
 491       "halign", "center", "valign", "bottom", NULL);
 492   play_bin->textoverlay_element = overlay;
 493   if (play_bin->font_desc) {
 494     g_object_set (G_OBJECT (play_bin->textoverlay_element),
 495         "font-desc", play_bin->font_desc, NULL);
 496   }
 497   vbin = gen_video_element (play_bin);
 498   if (!overlay) {
 499     g_warning ("No overlay (pango) element, subtitles disabled");
 500     return vbin;
 501   }
 502   csp = gst_element_factory_make ("ffmpegcolorspace", "subtitlecsp");
 503   element = gst_bin_new ("textbin");
 504   gst_element_link_many (csp, overlay, vbin, NULL);
 505   gst_bin_add_many (GST_BIN (element), csp, overlay, vbin, NULL);
 506
 507   pad = gst_element_get_pad (overlay, "text_sink");
 508 #define gst_element_add_ghost_pad(element, pad, name) \
 509     gst_element_add_pad (element, gst_ghost_pad_new (name, pad))
 510   gst_element_add_ghost_pad (element, pad, "text_sink");
 511   gst_object_unref (pad);
 512
 513   pad = gst_element_get_pad (csp, "sink");
 514   gst_element_add_ghost_pad (element, pad, "sink");
 515   gst_object_unref (pad);
 516
 517   return element;
 518 }
 519
 520 /* make the element (bin) that contains the elements needed to perform
 521  * audio playback.
 522  *
 523  *  +-------------------------------------------------------------+
 524  *  | abin                                                        |
 525  *  |      +---------+   +----------+   +---------+   +---------+ |
 526  *  |      |audioconv|   |audioscale|   | volume  |   |audiosink| |
 527  *  |   +-sink      src-sink       src-sink      src-sink       | |
 528  *  |   |  +---------+   +----------+   +---------+   +---------+ |
 529  * sink-+                                                         |
 530  *  +-------------------------------------------------------------+
 531  *
 532  */
 533 static GstElement *
 534 gen_audio_element (GstPlayBin * play_bin)
 535 {
 536   GstElement *element;
 537   GstElement *conv;
 538   GstElement *sink;
 539   GstElement *volume;
 540   GstElement *scale;
 541   GstPad *pad;
 542
 543   element = g_hash_table_lookup (play_bin->cache, "abin");
 544   if (element != NULL) {
 545     return element;
 546   }
 547   element = gst_bin_new ("abin");
 548   conv = gst_element_factory_make ("audioconvert", "aconv");
 549   scale = gst_element_factory_make ("audioscale", "ascale");
 550
 551   volume = gst_element_factory_make ("volume", "volume");
 552   g_object_set (G_OBJECT (volume), "volume", play_bin->volume, NULL);
 553   play_bin->volume_element = volume;
 554
 555   if (play_bin->audio_sink) {
 556     sink = play_bin->audio_sink;
 557   } else {
 558     sink = gst_element_factory_make ("autoaudiosink", "audiosink");
 559     if (sink == NULL) {
 560       sink = gst_element_factory_make ("alsasink", "audiosink");
 561     }
 562     if (sink == NULL) {
 563       GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,
 564           (_("Both autoaudiosink and alsasink elements are missing.")), (NULL));
 565       return NULL;
 566     }
 567     play_bin->audio_sink = GST_ELEMENT (gst_object_ref (sink));
 568   }
 569
 570   gst_object_ref (sink);
 571   g_hash_table_insert (play_bin->cache, "audio_sink", sink);
 572
 573   gst_bin_add (GST_BIN (element), conv);
 574   //gst_bin_add (GST_BIN (element), scale);
 575   gst_bin_add (GST_BIN (element), volume);
 576   gst_bin_add (GST_BIN (element), sink);
 577
 578   gst_element_link_pads (conv, "src",   /*scale, "sink");
 579                                            gst_element_link_pads (scale, "src", */ volume, "sink");
 580   gst_element_link_pads (volume, "src", sink, "sink");
 581
 582   pad = gst_element_get_pad (conv, "sink");
 583   gst_element_add_ghost_pad (element, pad, "sink");
 584   gst_object_unref (pad);
 585
 586   gst_element_set_state (element, GST_STATE_READY);
 587
 588   /* since we're gonna add it to a bin but don't want to lose it,
 589    * we keep a reference. */
 590   gst_object_ref (element);
 591   g_hash_table_insert (play_bin->cache, "abin", element);
 592
 593   return element;
 594 }
 595
 596 /* make the element (bin) that contains the elements needed to perform
 597  * visualisation ouput.  The idea is to split the audio using tee, then
 598  * sending the output to the regular audio bin and the other output to
 599  * the vis plugin that transforms it into a video that is rendered with the
 600  * normal video bin. The video bin is run in a thread to make sure it does
 601  * not block the audio playback pipeline.
 602  *
 603  *  +--------------------------------------------------------------------------+
 604  *  | visbin                                                                   |
 605  *  |      +------+   +----------------+                                       |
 606  *  |      | tee  |   |   abin ...     |                                       |
 607  *  |   +-sink   src-sink              |                                       |
 608  *  |   |  |      |   +----------------+                 +-------------------+ |
 609  *  |   |  |      |                                      | vthread           | |
 610  *  |   |  |      |   +---------+   +------+   +------+  | +--------------+  | |
 611  *  |   |  |      |   |audioconv|   | vis  |   |vqueue|  | | vbin ...     |  | |
 612  *  |   |  |     src-sink      src-sink   src-sink   src-sink             |  | |
 613  *  |   |  |      |   +---------+   +------+   +------+  | +--------------+  | |
 614  *  |   |  |      |                                      +-------------------+ |
 615  *  |   |  +------+                                                            |
 616  * sink-+                                                                      |
 617    +--------------------------------------------------------------------------+
 618  */
 619 static GstElement *
 620 gen_vis_element (GstPlayBin * play_bin)
 621 {
 622   GstElement *element;
 623   GstElement *tee;
 624   GstElement *asink;
 625   GstElement *vsink;
 626   GstElement *conv;
 627   GstElement *vis;
 628   GstElement *vqueue, *aqueue;
 629   GstPad *pad, *rpad;
 630
 631   element = gst_bin_new ("visbin");
 632   tee = gst_element_factory_make ("tee", "tee");
 633
 634   vqueue = gst_element_factory_make ("queue", "vqueue");
 635   aqueue = gst_element_factory_make ("queue", "aqueue");
 636
 637   asink = gen_audio_element (play_bin);
 638   vsink = gen_video_element (play_bin);
 639
 640   gst_bin_add (GST_BIN (element), asink);
 641   gst_bin_add (GST_BIN (element), vqueue);
 642   gst_bin_add (GST_BIN (element), aqueue);
 643   gst_bin_add (GST_BIN (element), vsink);
 644   gst_bin_add (GST_BIN (element), tee);
 645
 646   conv = gst_element_factory_make ("audioconvert", "aconv");
 647   if (play_bin->visualisation) {
 648     gst_object_ref (play_bin->visualisation);
 649     vis = play_bin->visualisation;
 650   } else {
 651     vis = gst_element_factory_make ("goom", "vis");
 652   }
 653
 654   gst_bin_add (GST_BIN (element), conv);
 655   gst_bin_add (GST_BIN (element), vis);
 656
 657   gst_element_link_pads (conv, "src", vis, "sink");
 658   gst_element_link_pads (vis, "src", vqueue, "sink");
 659
 660   gst_element_link_pads (vqueue, "src", vsink, "sink");
 661
 662   pad = gst_element_get_pad (aqueue, "sink");
 663   rpad = gst_element_get_request_pad (tee, "src%d");
 664   gst_pad_link (rpad, pad);
 665   gst_object_unref (rpad);
 666   gst_object_unref (pad);
 667   gst_element_link_pads (aqueue, "src", asink, "sink");
 668
 669   pad = gst_element_get_pad (conv, "sink");
 670   rpad = gst_element_get_request_pad (tee, "src%d");
 671   gst_pad_link (rpad, pad);
 672   gst_object_unref (rpad);
 673   gst_object_unref (pad);
 674
 675   pad = gst_element_get_pad (tee, "sink");
 676   gst_element_add_ghost_pad (element, pad, "sink");
 677   gst_object_unref (pad);
 678
 679   return element;
 680 }
 681
 682 /* get rid of all installed sinks */
 683 static void
 684 remove_sinks (GstPlayBin * play_bin)
 685 {
 686   GList *sinks;
 687   GstObject *parent;
 688   GstElement *element;
 689   GstPad *pad, *peer;
 690
 691   GST_DEBUG ("removesinks");
 692   element = g_hash_table_lookup (play_bin->cache, "abin");
 693   if (element != NULL) {
 694     parent = gst_element_get_parent (element);
 695     if (parent != NULL) {
 696       /* we remove the element from the parent so that
 697        * there is no unwanted state change when the parent
 698        * is disposed */
 699       play_bin->sinks = g_list_remove (play_bin->sinks, element);
 700       gst_element_set_state (element, GST_STATE_NULL);
 701       gst_bin_remove (GST_BIN (parent), element);
 702       gst_object_unref (parent);
 703     }
 704     pad = gst_element_get_pad (element, "sink");
 705     if (pad != NULL) {
 706       peer = gst_pad_get_peer (pad);
 707       if (peer != NULL) {
 708         gst_pad_unlink (peer, pad);
 709         gst_object_unref (peer);
 710       }
 711       gst_object_unref (pad);
 712     }
 713   }
 714   element = g_hash_table_lookup (play_bin->cache, "vbin");
 715   if (element != NULL) {
 716     parent = gst_element_get_parent (element);
 717     if (parent != NULL) {
 718       play_bin->sinks = g_list_remove (play_bin->sinks, element);
 719       gst_element_set_state (element, GST_STATE_NULL);
 720       gst_bin_remove (GST_BIN (parent), element);
 721       gst_object_unref (parent);
 722     }
 723     pad = gst_element_get_pad (element, "sink");
 724     if (pad != NULL) {
 725       peer = gst_pad_get_peer (pad);
 726       if (peer != NULL) {
 727         gst_pad_unlink (peer, pad);
 728         gst_object_unref (peer);
 729       }
 730       gst_object_unref (pad);
 731     }
 732   }
 733
 734   for (sinks = play_bin->sinks; sinks; sinks = g_list_next (sinks)) {
 735     GstElement *element = GST_ELEMENT (sinks->data);
 736     GstPad *pad;
 737     GstPad *peer;
 738
 739     pad = gst_element_get_pad (element, "sink");
 740
 741     GST_LOG ("removing sink %p", element);
 742
 743     peer = gst_pad_get_peer (pad);
 744     if (peer) {
 745       gst_pad_unlink (peer, pad);
 746       gst_object_unref (peer);
 747     }
 748     gst_object_unref (pad);
 749
 750     gst_element_set_state (element, GST_STATE_NULL);
 751     gst_bin_remove (GST_BIN (play_bin), element);
 752   }
 753   g_list_free (play_bin->sinks);
 754   play_bin->sinks = NULL;
 755
 756   /* FIXME: this is probably some refcounting problem */
 757   if (play_bin->visualisation && GST_OBJECT_PARENT (play_bin->visualisation)) {
 758     gst_element_set_state (play_bin->visualisation, GST_STATE_NULL);
 759     gst_bin_remove (GST_BIN (GST_OBJECT_PARENT (play_bin->visualisation)),
 760         play_bin->visualisation);
 761   }
 762
 763   if (play_bin->frame) {
 764     gst_buffer_unref (play_bin->frame);
 765     play_bin->frame = NULL;
 766   }
 767
 768   play_bin->textoverlay_element = NULL;
 769 }
 770
 771 /* loop over the streams and set up the pipeline to play this
 772  * media file. First we count the number of audio and video streams.
 773  * If there is no video stream but there exists an audio stream,
 774  * we install a visualisation pipeline.
 775  *
 776  * Also make sure to only connect the first audio and video pad. FIXME
 777  * this should eventually be handled with a tuner interface so that
 778  * one can switch the streams.
 779  */
 780 static gboolean
 781 add_sink (GstPlayBin * play_bin, GstElement * sink, GstPad * srcpad)
 782 {
 783   GstPad *sinkpad;
 784   GstPadLinkReturn linkres;
 785   GstElement *parent;
 786   GstStateChangeReturn stateret;
 787
 788   /* this is only for debugging */
 789   parent = gst_pad_get_parent_element (srcpad);
 790   if (parent) {
 791     GST_DEBUG ("Adding sink with state %d (parent: %d, peer: %d)",
 792         GST_STATE (sink), GST_STATE (play_bin), GST_STATE (parent));
 793     gst_object_unref (parent);
 794   }
 795
 796   /* bring it to the PAUSED state so we can link to the peer without
 797    * breaking the flow */
 798   if ((stateret = gst_element_set_state (sink, GST_STATE_PAUSED)) ==
 799       GST_STATE_CHANGE_FAILURE)
 800     goto state_failed;
 801
 802   gst_bin_add (GST_BIN (play_bin), sink);
 803
 804   /* we found a sink for this stream, now try to install it */
 805   sinkpad = gst_element_get_pad (sink, "sink");
 806   linkres = gst_pad_link (srcpad, sinkpad);
 807   gst_object_unref (sinkpad);
 808
 809   /* try to link the pad of the sink to the stream */
 810   if (GST_PAD_LINK_FAILED (linkres))
 811     goto link_failed;
 812
 813   /* we got the sink succesfully linked, now keep the sink
 814    * in out internal list */
 815   play_bin->sinks = g_list_prepend (play_bin->sinks, sink);
 816
 817   return TRUE;
 818
 819   /* ERRORS */
 820 state_failed:
 821   {
 822     GST_DEBUG_OBJECT (play_bin, "state change failure when adding sink");
 823     return FALSE;
 824   }
 825 link_failed:
 826   {
 827     gchar *capsstr;
 828     GstCaps *caps;
 829
 830     /* could not link this stream */
 831     caps = gst_pad_get_caps (srcpad);
 832     capsstr = gst_caps_to_string (caps);
 833     g_warning ("could not link %s: %d", capsstr, linkres);
 834     GST_DEBUG_OBJECT (play_bin,
 835         "link failed when adding sink, caps %s, reason %d", capsstr, linkres);
 836     g_free (capsstr);
 837     g_free (caps);
 838
 839     gst_element_set_state (sink, GST_STATE_NULL);
 840     gst_bin_remove (GST_BIN (play_bin), sink);
 841     return FALSE;
 842   }
 843 }
 844
 845 static gboolean
 846 setup_sinks (GstPlayBaseBin * play_base_bin, GstPlayBaseGroup * group)
 847 {
 848   GstPlayBin *play_bin = GST_PLAY_BIN (play_base_bin);
 849   GList *streaminfo = NULL, *s;
 850   gboolean need_vis = FALSE;
 851   gboolean need_text = FALSE;
 852   GstPad *textsrcpad = NULL, *textsinkpad = NULL, *pad;
 853   GstElement *sink;
 854   gboolean res = TRUE;
 855
 856   /* get rid of existing sinks */
 857   if (play_bin->sinks) {
 858     remove_sinks (play_bin);
 859   }
 860   GST_DEBUG ("setupsinks");
 861
 862   /* find out what to do */
 863   if (group->type[GST_STREAM_TYPE_VIDEO - 1].npads > 0 &&
 864       group->type[GST_STREAM_TYPE_TEXT - 1].npads > 0) {
 865     need_text = TRUE;
 866   } else if (group->type[GST_STREAM_TYPE_VIDEO - 1].npads == 0 &&
 867       group->type[GST_STREAM_TYPE_AUDIO - 1].npads > 0 &&
 868       play_bin->visualisation != NULL) {
 869     need_vis = TRUE;
 870   }
 871
 872   /* now actually connect everything */
 873   g_object_get (G_OBJECT (play_base_bin), "stream-info", &streaminfo, NULL);
 874   for (s = streaminfo; s; s = g_list_next (s)) {
 875     GObject *obj = G_OBJECT (s->data);
 876     gint type;
 877     GstObject *object;
 878
 879     g_object_get (obj, "type", &type, NULL);
 880     g_object_get (obj, "object", &object, NULL);
 881   }
 882
 883   /* link audio */
 884   if (group->type[GST_STREAM_TYPE_AUDIO - 1].npads > 0) {
 885     if (need_vis) {
 886       sink = gen_vis_element (play_bin);
 887     } else {
 888       sink = gen_audio_element (play_bin);
 889     }
 890     pad = gst_element_get_pad (group->type[GST_STREAM_TYPE_AUDIO - 1].preroll,
 891         "src");
 892     res = add_sink (play_bin, sink, pad);
 893     gst_object_unref (pad);
 894   }
 895
 896   /* link video */
 897   if (group->type[GST_STREAM_TYPE_VIDEO - 1].npads > 0) {
 898     if (need_text) {
 899       sink = gen_text_element (play_bin);
 900
 901       textsinkpad = gst_element_get_pad (sink, "text_sink");
 902       textsrcpad =
 903           gst_element_get_pad (group->type[GST_STREAM_TYPE_TEXT - 1].preroll,
 904           "src");
 905       gst_pad_link (textsrcpad, textsinkpad);
 906       gst_object_unref (textsinkpad);
 907       gst_object_unref (textsrcpad);
 908     } else {
 909       sink = gen_video_element (play_bin);
 910     }
 911     pad = gst_element_get_pad (group->type[GST_STREAM_TYPE_VIDEO - 1].preroll,
 912         "src");
 913     res = add_sink (play_bin, sink, pad);
 914     gst_object_unref (pad);
 915   }
 916
 917   /* remove the sinks now, pipeline get_state will now wait for the
 918    * sinks to preroll */
 919   if (play_bin->fakesink) {
 920     gst_element_set_state (play_bin->fakesink, GST_STATE_NULL);
 921     gst_bin_remove (GST_BIN (play_bin), play_bin->fakesink);
 922     play_bin->fakesink = NULL;
 923   }
 924
 925   return res;
 926 }
 927
 928 /* Send an event to our sinks until one of them works; don't then send to the
 929  * remaining sinks (unlike GstBin)
 930  */
 931 static gboolean
 932 gst_play_bin_send_event_to_sink (GstPlayBin * play_bin, GstEvent * event)
 933 {
 934   GList *sinks = play_bin->sinks;
 935   gboolean res = TRUE;
 936
 937   while (sinks) {
 938     GstElement *sink = GST_ELEMENT_CAST (sinks->data);
 939
 940     gst_event_ref (event);
 941     if ((res = gst_element_send_event (sink, event)))
 942       break;
 943
 944     sinks = g_list_next (sinks);
 945   }
 946
 947   gst_event_unref (event);
 948
 949   return res;
 950 }
 951
 952 static gboolean
 953 do_playbin_seek (GstElement * element, GstEvent * event)
 954 {
 955   gdouble rate;
 956   GstSeekFlags flags;
 957   gboolean flush;
 958   gboolean was_playing = FALSE;
 959   gboolean res;
 960
 961   gst_event_parse_seek (event, &rate, NULL, &flags, NULL, NULL, NULL, NULL);
 962
 963   flush = flags & GST_SEEK_FLAG_FLUSH;
 964
 965   if (flush) {
 966     GstState state;
 967
 968     /* need to call _get_state() since a bin state is only updated
 969      * with this call. */
 970     gst_element_get_state (element, &state, NULL, 0);
 971     was_playing = state == GST_STATE_PLAYING;
 972
 973     if (was_playing) {
 974       gst_element_set_state (element, GST_STATE_PAUSED);
 975     }
 976   }
 977
 978   res = gst_play_bin_send_event_to_sink (GST_PLAY_BIN (element), event);
 979
 980   if (flush && res) {
 981     /* need to reset the stream time to 0 after a flushing seek */
 982     gst_pipeline_set_new_stream_time (GST_PIPELINE (element), 0);
 983     if (was_playing)
 984       /* and continue playing */
 985       gst_element_set_state (element, GST_STATE_PLAYING);
 986   }
 987   return res;
 988 }
 989
 990 /* We only want to send the event to a single sink (overriding GstBin's
 991  * behaviour), but we want to keep GstPipeline's behaviour - wrapping seek
 992  * events appropriately. So, this is a messy duplication of code. */
 993 static gboolean
 994 gst_play_bin_send_event (GstElement * element, GstEvent * event)
 995 {
 996   gboolean res = FALSE;
 997   GstEventType event_type = GST_EVENT_TYPE (event);
 998
 999
1000   switch (event_type) {
1001     case GST_EVENT_SEEK:
1002       res = do_playbin_seek (element, event);
1003       break;
1004     default:
1005       res = gst_play_bin_send_event_to_sink (GST_PLAY_BIN (element), event);
1006       break;
1007   }
1008
1009   return res;
1010 }
1011
1012 static GstStateChangeReturn
1013 gst_play_bin_change_state (GstElement * element, GstStateChange transition)
1014 {
1015   GstStateChangeReturn ret;
1016   GstPlayBin *play_bin;
1017
1018   play_bin = GST_PLAY_BIN (element);
1019
1020
1021   switch (transition) {
1022     case GST_STATE_CHANGE_READY_TO_PAUSED:
1023       /* this really is the easiest way to make the state change return
1024        * ASYNC until we added the sinks */
1025       if (!play_bin->fakesink) {
1026         play_bin->fakesink = gst_element_factory_make ("fakesink", "test");
1027         gst_bin_add (GST_BIN (play_bin), play_bin->fakesink);
1028       }
1029       break;
1030     default:
1031       break;
1032   }
1033
1034   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1035   if (ret == GST_STATE_CHANGE_FAILURE)
1036     return ret;
1037
1038   switch (transition) {
1039     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1040       /* Set audio sink state to NULL to release the sound device,
1041        * but only if we own it (else we might be in chain-transition). */
1042       //if (play_bin->audio_sink != NULL &&
1043       //    GST_STATE (play_bin->audio_sink) == GST_STATE_PAUSED) {
1044       //  gst_element_set_state (play_bin->audio_sink, GST_STATE_NULL);
1045       //}
1046       break;
1047     case GST_STATE_CHANGE_PAUSED_TO_READY:
1048       /* Check for NULL because the state transition may be done by
1049        * gst_bin_dispose which is called by gst_play_bin_dispose, and in that
1050        * case, we don't want to run remove_sinks.
1051        * FIXME: should the NULL test be done in remove_sinks? Should we just
1052        * set the state to NULL in gst_play_bin_dispose?
1053        */
1054       if (play_bin->cache != NULL) {
1055         remove_sinks (play_bin);
1056       }
1057       if (play_bin->fakesink) {
1058         gst_element_set_state (play_bin->fakesink, GST_STATE_NULL);
1059         gst_bin_remove (GST_BIN (play_bin), play_bin->fakesink);
1060         play_bin->fakesink = NULL;
1061       }
1062       break;
1063     default:
1064       break;
1065   }
1066
1067   return ret;
1068 }
1069
1070 static gboolean
1071 plugin_init (GstPlugin * plugin)
1072 {
1073   GST_DEBUG_CATEGORY_INIT (gst_play_bin_debug, "playbin", 0, "play bin");
1074
1075   return gst_element_register (plugin, "playbin", GST_RANK_NONE,
1076       GST_TYPE_PLAY_BIN);
1077 }
1078
1079 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1080     GST_VERSION_MINOR,
1081     "playbin",
1082     "player bin", plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME,
1083     GST_PACKAGE_ORIGIN)