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 /**

    21  * SECTION:element-playbin

    22  *

    23  * <refsect2>

    24  * <para>

    25  * Playbin provides a stand-alone everything-in-one abstraction for an

    26  * audio and/or video player.

    27  * </para>

    28  * <para>

    29  * It can handle both audio and video files and features

    30  * <itemizedlist>

    31  * <listitem>

    32  * automatic file type recognition and based on that automatic

    33  * selection and usage of the right audio/video/subtitle demuxers/decoders

    34  * </listitem>

    35  * <listitem>

    36  * visualisations for audio files

    37  * </listitem>

    38  * <listitem>

    39  * subtitle support for video files

    40  * </listitem>

    41  * <listitem>

    42  * stream selection between different audio/subtitles streams

    43  * </listitem>

    44  * <listitem>

    45  * meta info (tag) extraction

    46  * </listitem>

    47  * <listitem>

    48  * easy access to the last video frame

    49  * </listitem>

    50  * <listitem>

    51  * buffering when playing streams over a network

    52  * </listitem>

    53  * <listitem>

    54  * volume control

    55  * </listitem>

    56  * </itemizedlist>

    57  * </para>

    58  * <title>Usage</title>

    59  * <para>

    60  * A playbin element can be created just like any other element using

    61  * gst_element_factory_make(). The file/URI to play should be set via the "uri"

    62  * property. This must be an absolute URI, relative file paths are not allowed.

    63  * Example URIs are file:///home/joe/movie.avi or http://www.joedoe.com/foo.ogg

    64  * </para>

    65  * <para>

    66  * Playbin is a #GstPipeline. It will notify the application of everything

    67  * that's happening (errors, end of stream, tags found, state changes, etc.)

    68  * by posting messages on its #GstBus. The application needs to watch the

    69  * bus.

    70  * </para>

    71  * <para>

    72  * Playback can be initiated by setting the element to PLAYING state using

    73  * gst_element_set_state(). Note that the state change will take place in

    74  * the background in a separate thread, when the function returns playback

    75  * is probably not happening yet and any errors might not have occured yet.

    76  * Applications using playbin should ideally be written to deal with things

    77  * completely asynchroneous.

    78  * </para>

    79  * <para>

    80  * When playback has finished (an EOS message has been received on the bus)

    81  * or an error has occured (an ERROR message has been received on the bus) or

    82  * the user wants to play a different track, playbin should be set back to

    83  * READY or NULL state, then the "uri" property should be set to the new

    84  * location and then playbin be set to PLAYING state again.

    85  * </para>

    86  * <para>

    87  * Seeking can be done using gst_element_seek_simple() or gst_element_seek()

    88  * on the playbin element. Again, the seek will not be executed

    89  * instantaneously, but will be done in a background thread. When the seek

    90  * call returns the seek will most likely still be in process. An application

    91  * may wait for the seek to finish (or fail) using gst_element_get_state() with

    92  * -1 as the timeout, but this will block the user interface and is not

    93  * recommended at all.

    94  * </para>

    95  * <para>

    96  * Applications may query the current position and duration of the stream

    97  * via gst_element_query_position() and gst_element_query_duration() and

    98  * setting the format passed to GST_FORMAT_TIME. If the query was successful,

    99  * the duration or position will have been returned in units of nanoseconds.

   100  * </para>

   101  * <title>Advanced Usage: specifying the audio and video sink</title>

   102  * <para>

   103  * By default, if no audio sink or video sink has been specified via the

   104  * "audio-sink" or "video-sink" property, playbin will use the autoaudiosink

   105  * and autovideosink elements to find the first-best available output method.

   106  * This should work in most cases, but is not always desirable. Often either

   107  * the user or application might want to specify more explicitly what to use

   108  * for audio and video output.

   109  * </para>

   110  * <para>

   111  * If the application wants more control over how audio or video should be

   112  * output, it may create the audio/video sink elements itself (for example

   113  * using gst_element_factory_make()) and provide them to playbin using the

   114  * "audio-sink" or "video-sink" property.

   115  * </para>

   116  * <para>

   117  * GNOME-based applications, for example, will usually want to create

   118  * gconfaudiosink and gconfvideosink elements and make playbin use those,

   119  * so that output happens to whatever the user has configured in the GNOME

   120  * Multimedia System Selector confinguration dialog.

   121  * </para>

   122  * <para>

   123  * The sink elements do not necessarily need to be ready-made sinks. It is

   124  * possible to create container elements that look like a sink to playbin,

   125  * but in reality contain a number of custom elements linked together. This

   126  * can be achieved by creating a #GstBin and putting elements in there and

   127  * linking them, and then creating a sink #GstGhostPad for the bin and pointing

   128  * it to the sink pad of the first element within the bin. This can be used

   129  * for a number of purposes, for example to force output to a particular

   130  * format or to modify or observe the data before it is output.

   131  * </para>

   132  * <para>

   133  * It is also possible to 'suppress' audio and/or video output by using

   134  * 'fakesink' elements (or capture it from there using the fakesink element's

   135  * "handoff" signal, which, nota bene, is fired from the streaming thread!).

   136  * </para>

   137  * <title>Retrieving Tags and Other Meta Data</title>

   138  * <para>

   139  * Most of the common meta data (artist, title, etc.) can be retrieved by

   140  * watching for TAG messages on the pipeline's bus (see above).

   141  * </para>

   142  * <para>

   143  * Other more specific meta information like width/height/framerate of video

   144  * streams or samplerate/number of channels of audio streams can be obtained

   145  * using the "stream-info" property, which will return a GList of stream info

   146  * objects, one for each stream. These are opaque objects that can only be

   147  * accessed via the standard GObject property interface, ie. g_object_get().

   148  * Each stream info object has the following properties:

   149  * <itemizedlist>

   150  * <listitem>"object" (GstObject) (the decoder source pad usually)</listitem>

   151  * <listitem>"type" (enum) (if this is an audio/video/subtitle stream)</listitem>

   152  * <listitem>"decoder" (string) (name of decoder used to decode this stream)</listitem>

   153  * <listitem>"mute" (boolean) (to mute or unmute this stream)</listitem>

   154  * <listitem>"caps" (GstCaps) (caps of the decoded stream)</listitem>

   155  * <listitem>"language-code" (string) (ISO-639 language code for this stream, mostly used for audio/subtitle streams)</listitem>

   156  * <listitem>"codec" (string) (format this stream was encoded in)</listitem>

   157  * </itemizedlist>

   158  * Stream information from the stream-info properties is best queried once

   159  * playbin has changed into PAUSED or PLAYING state (which can be detected

   160  * via a state-changed message on the bus where old_state=READY and

   161  * new_state=PAUSED), since before that the list might not be complete yet or

   162  * not contain all available information (like language-codes).

   163  * </para>

   164  * <title>Buffering</title>

   165  * <para>

   166  * Playbin handles buffering automatically for the most part, but applications

   167  * need to handle parts of the buffering process as well. Whenever playbin is

   168  * buffering, it will post BUFFERING messages on the bus with a percentage

   169  * value that shows the progress of the buffering process. Applications need

   170  * to set playbin to PLAYING or PAUSED state in response to these messages.

   171  * They may also want to convey the buffering progress to the user in some

   172  * way. Here is how to extract the percentage information from the message

   173  * (requires GStreamer >= 0.10.11):

   174  * </para>

   175  * <para>

   176  * <programlisting>

   177  * switch (GST_MESSAGE_TYPE (msg)) {

   178  *   case GST_MESSAGE_BUFFERING: {

   179  *     gint percent = 0;

   180  *     gst_message_parse_buffering (msg, &percent);

   181  *     g_print ("Buffering (%%u percent done)", percent);

   182  *     break;

   183  *   }

   184  *   ...

   185  * }

   186  * </programlisting>

   187  * Note that applications should keep/set the pipeline in the PAUSED state when

   188  * a BUFFERING message is received with a buffer percent value < 100 and set

   189  * the pipeline back to PLAYING state when a BUFFERING message with a value

   190  * of 100 percent is received (if PLAYING is the desired state, that is).

   191  * </para>

   192  * <title>Embedding the video window in your application</title>

   193  * <para>

   194  * By default, playbin (or rather the video sinks used) will create their own

   195  * window. Applications will usually want to force output to a window of their

   196  * own, however. This can be done using the GstXOverlay interface, which most

   197  * video sinks implement. See the documentation there for more details.

   198  * </para>

   199  * <title>Specifying which CD/DVD device to use</title>

   200  * <para>

   201  * The device to use for CDs/DVDs needs to be set on the source element

   202  * playbin creates before it is opened. The only way to do this at the moment

   203  * is to connect to playbin's "notify::source" signal, which will be emitted

   204  * by playbin when it has created the source element for a particular URI.

   205  * In the signal callback you can check if the source element has a "device"

   206  * property and set it appropriately. In future ways might be added to specify

   207  * the device as part of the URI, but at the time of writing this is not

   208  * possible yet.

   209  * </para>

   210  * <title>Examples</title>

   211  * <para>

   212  * Here is a simple pipeline to play back a video or audio file:

   213  * <programlisting>

   214  * gst-launch -v playbin uri=file:///path/to/somefile.avi

   215  * </programlisting>

   216  * This will play back the given AVI video file, given that the video and

   217  * audio decoders required to decode the content are installed. Since no

   218  * special audio sink or video sink is supplied (not possible via gst-launch),

   219  * playbin will try to find a suitable audio and video sink automatically

   220  * using the autoaudiosink and autovideosink elements.

   221  * </para>

   222  * <para>

   223  * Here is a another pipeline to play track 4 of an audio CD:

   224  * <programlisting>

   225  * gst-launch -v playbin uri=cdda://4

   226  * </programlisting>

   227  * This will play back track 4 on an audio CD in your disc drive (assuming

   228  * the drive is detected automatically by the plugin).

   229  * </para>

   230  * <para>

   231  * Here is a another pipeline to play title 1 of a DVD:

   232  * <programlisting>

   233  * gst-launch -v playbin uri=dvd://1

   234  * </programlisting>

   235  * This will play back title 1 of a DVD in your disc drive (assuming

   236  * the drive is detected automatically by the plugin).

   237  * </para>

   238  * </refsect2>

   239  */

   240 

   241 #ifdef HAVE_CONFIG_H

   242 #include "config.h"

   243 #endif

   244 

   245 #include <string.h>

   246 #include <gst/gst.h>

   247 

   248 #include <gst/gst-i18n-plugin.h>

   249 #include <gst/pbutils/pbutils.h>

   250 

   251 #include "gstplaybasebin.h"

   252 

   253 #ifdef __SYMBIAN32__

   254 #include <glib_global.h>

   255 #endif

   256 

   257 GST_DEBUG_CATEGORY_STATIC (gst_play_bin_debug);

   258 #define GST_CAT_DEFAULT gst_play_bin_debug

   259 

   260 #define GST_TYPE_PLAY_BIN               (gst_play_bin_get_type())

   261 #define GST_PLAY_BIN(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PLAY_BIN,GstPlayBin))

   262 #define GST_PLAY_BIN_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PLAY_BIN,GstPlayBinClass))

   263 #define GST_IS_PLAY_BIN(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PLAY_BIN))

   264 #define GST_IS_PLAY_BIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PLAY_BIN))

   265 

   266 #define VOLUME_MAX_DOUBLE 10.0

   267 

   268 typedef struct _GstPlayBin GstPlayBin;

   269 typedef struct _GstPlayBinClass GstPlayBinClass;

   270 

   271 struct _GstPlayBin

   272 {

   273   GstPlayBaseBin parent;

   274 

   275   /* the configurable elements */

   276   GstElement *fakesink;

   277   GstElement *audio_sink;

   278   GstElement *video_sink;

   279   GstElement *visualisation;

   280   GstElement *pending_visualisation;

   281   GstElement *volume_element;

   282   GstElement *textoverlay_element;

   283   gfloat volume;

   284 

   285   /* these are the currently active sinks */

   286   GList *sinks;

   287 

   288   /* the last captured frame for snapshots */

   289   GstBuffer *frame;

   290 

   291   /* our cache for the sinks */

   292   GHashTable *cache;

   293 

   294   /* font description */

   295   gchar *font_desc;

   296 

   297   /* indication if the pipeline is live */

   298   gboolean is_live;

   299 };

   300 

   301 struct _GstPlayBinClass

   302 {

   303   GstPlayBaseBinClass parent_class;

   304 };

   305 

   306 /* props */

   307 enum

   308 {

   309   ARG_0,

   310   ARG_AUDIO_SINK,

   311   ARG_VIDEO_SINK,

   312   ARG_VIS_PLUGIN,

   313   ARG_VOLUME,

   314   ARG_FRAME,

   315   ARG_FONT_DESC

   316 };

   317 

   318 /* signals */

   319 enum

   320 {

   321   LAST_SIGNAL

   322 };

   323 

   324 static void gst_play_bin_class_init (GstPlayBinClass * klass);

   325 static void gst_play_bin_init (GstPlayBin * play_bin);

   326 static void gst_play_bin_dispose (GObject * object);

   327 

   328 static gboolean setup_sinks (GstPlayBaseBin * play_base_bin,

   329     GstPlayBaseGroup * group);

   330 static void remove_sinks (GstPlayBin * play_bin);

   331 static void playbin_set_subtitles_visible (GstPlayBaseBin * play_base_bin,

   332     gboolean visible);

   333 

   334 static void gst_play_bin_set_property (GObject * object, guint prop_id,

   335     const GValue * value, GParamSpec * spec);

   336 static void gst_play_bin_get_property (GObject * object, guint prop_id,

   337     GValue * value, GParamSpec * spec);

   338 

   339 static gboolean gst_play_bin_send_event (GstElement * element,

   340     GstEvent * event);

   341 static GstStateChangeReturn gst_play_bin_change_state (GstElement * element,

   342     GstStateChange transition);

   343 

   344 static void gst_play_bin_handle_message (GstBin * bin, GstMessage * message);

   345 

   346 static GstElementClass *parent_class;

   347 

   348 //static guint gst_play_bin_signals[LAST_SIGNAL] = { 0 };

   349 

   350 static const GstElementDetails gst_play_bin_details =

   351 GST_ELEMENT_DETAILS ("Player Bin",

   352     "Generic/Bin/Player",

   353     "Autoplug and play media from an uri",

   354     "Wim Taymans <wim.taymans@gmail.com>");

   355 

   356 static GType

   357 gst_play_bin_get_type (void)

   358 {

   359   static GType gst_play_bin_type = 0;

   360 

   361   if (!gst_play_bin_type) {

   362     static const GTypeInfo gst_play_bin_info = {

   363       sizeof (GstPlayBinClass),

   364       NULL,

   365       NULL,

   366       (GClassInitFunc) gst_play_bin_class_init,

   367       NULL,

   368       NULL,

   369       sizeof (GstPlayBin),

   370       0,

   371       (GInstanceInitFunc) gst_play_bin_init,

   372       NULL

   373     };

   374 

   375     gst_play_bin_type = g_type_register_static (GST_TYPE_PLAY_BASE_BIN,

   376         "GstPlayBin", &gst_play_bin_info, 0);

   377   }

   378 

   379   return gst_play_bin_type;

   380 }

   381 

   382 static void

   383 gst_play_bin_class_init (GstPlayBinClass * klass)

   384 {

   385   GObjectClass *gobject_klass;

   386   GstElementClass *gstelement_klass;

   387   GstBinClass *gstbin_klass;

   388   GstPlayBaseBinClass *playbasebin_klass;

   389 

   390   gobject_klass = (GObjectClass *) klass;

   391   gstelement_klass = (GstElementClass *) klass;

   392   gstbin_klass = (GstBinClass *) klass;

   393   playbasebin_klass = (GstPlayBaseBinClass *) klass;

   394 

   395   parent_class = g_type_class_peek_parent (klass);

   396 

   397   gobject_klass->set_property = gst_play_bin_set_property;

   398   gobject_klass->get_property = gst_play_bin_get_property;

   399 

   400   g_object_class_install_property (gobject_klass, ARG_VIDEO_SINK,

   401       g_param_spec_object ("video-sink", "Video Sink",

   402           "the video output element to use (NULL = default sink)",

   403           GST_TYPE_ELEMENT, G_PARAM_READWRITE));

   404   g_object_class_install_property (gobject_klass, ARG_AUDIO_SINK,

   405       g_param_spec_object ("audio-sink", "Audio Sink",

   406           "the audio output element to use (NULL = default sink)",

   407           GST_TYPE_ELEMENT, G_PARAM_READWRITE));

   408   g_object_class_install_property (gobject_klass, ARG_VIS_PLUGIN,

   409       g_param_spec_object ("vis-plugin", "Vis plugin",

   410           "the visualization element to use (NULL = none)",

   411           GST_TYPE_ELEMENT, G_PARAM_READWRITE));

   412   g_object_class_install_property (gobject_klass, ARG_VOLUME,

   413       g_param_spec_double ("volume", "volume", "volume",

   414           0.0, VOLUME_MAX_DOUBLE, 1.0, G_PARAM_READWRITE));

   415   g_object_class_install_property (gobject_klass, ARG_FRAME,

   416       gst_param_spec_mini_object ("frame", "Frame",

   417           "The last frame (NULL = no video available)",

   418           GST_TYPE_BUFFER, G_PARAM_READABLE));

   419   g_object_class_install_property (gobject_klass, ARG_FONT_DESC,

   420       g_param_spec_string ("subtitle-font-desc",

   421           "Subtitle font description",

   422           "Pango font description of font "

   423           "to be used for subtitle rendering", NULL, G_PARAM_WRITABLE));

   424 

   425   gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_bin_dispose);

   426 

   427   gst_element_class_set_details (gstelement_klass, &gst_play_bin_details);

   428 

   429   gstelement_klass->change_state =

   430       GST_DEBUG_FUNCPTR (gst_play_bin_change_state);

   431   gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_bin_send_event);

   432 

   433   gstbin_klass->handle_message =

   434       GST_DEBUG_FUNCPTR (gst_play_bin_handle_message);

   435 

   436   playbasebin_klass->setup_output_pads = setup_sinks;

   437   playbasebin_klass->set_subtitles_visible = playbin_set_subtitles_visible;

   438 }

   439 

   440 static void

   441 gst_play_bin_init (GstPlayBin * play_bin)

   442 {

   443   play_bin->video_sink = NULL;

   444   play_bin->audio_sink = NULL;

   445   play_bin->visualisation = NULL;

   446   play_bin->pending_visualisation = NULL;

   447   play_bin->volume_element = NULL;

   448   play_bin->textoverlay_element = NULL;

   449   play_bin->volume = 1.0;

   450   play_bin->sinks = NULL;

   451   play_bin->frame = NULL;

   452   play_bin->font_desc = NULL;

   453   play_bin->cache = g_hash_table_new_full (g_str_hash, g_str_equal,

   454       NULL, (GDestroyNotify) gst_object_unref);

   455 }

   456 

   457 static void

   458 gst_play_bin_dispose (GObject * object)

   459 {

   460   GstPlayBin *play_bin;

   461 

   462   play_bin = GST_PLAY_BIN (object);

   463 

   464   if (play_bin->cache != NULL) {

   465     remove_sinks (play_bin);

   466     g_hash_table_destroy (play_bin->cache);

   467     play_bin->cache = NULL;

   468   }

   469 

   470   if (play_bin->audio_sink != NULL) {

   471     gst_element_set_state (play_bin->audio_sink, GST_STATE_NULL);

   472     gst_object_unref (play_bin->audio_sink);

   473     play_bin->audio_sink = NULL;

   474   }

   475   if (play_bin->video_sink != NULL) {

   476     gst_element_set_state (play_bin->video_sink, GST_STATE_NULL);

   477     gst_object_unref (play_bin->video_sink);

   478     play_bin->video_sink = NULL;

   479   }

   480   if (play_bin->visualisation != NULL) {

   481     gst_element_set_state (play_bin->visualisation, GST_STATE_NULL);

   482     gst_object_unref (play_bin->visualisation);

   483     play_bin->visualisation = NULL;

   484   }

   485   if (play_bin->pending_visualisation != NULL) {

   486     gst_element_set_state (play_bin->pending_visualisation, GST_STATE_NULL);

   487     gst_object_unref (play_bin->pending_visualisation);

   488     play_bin->pending_visualisation = NULL;

   489   }

   490   if (play_bin->textoverlay_element != NULL) {

   491     gst_object_unref (play_bin->textoverlay_element);

   492     play_bin->textoverlay_element = NULL;

   493   }

   494   g_free (play_bin->font_desc);

   495   play_bin->font_desc = NULL;

   496 

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

   498 }

   499 

   500 static void

   501 gst_play_bin_vis_unblocked (GstPad * tee_pad, gboolean blocked,

   502     gpointer user_data)

   503 {

   504   GstPlayBin *play_bin = GST_PLAY_BIN (user_data);

   505 

   506   if (play_bin->pending_visualisation)

   507     gst_pad_set_blocked_async (tee_pad, FALSE, gst_play_bin_vis_unblocked,

   508         play_bin);

   509 }

   510 

   511 static void

   512 gst_play_bin_vis_blocked (GstPad * tee_pad, gboolean blocked,

   513     gpointer user_data)

   514 {

   515   GstPlayBin *play_bin = GST_PLAY_BIN (user_data);

   516   GstBin *vis_bin = NULL;

   517   GstPad *vis_sink_pad = NULL, *vis_src_pad = NULL, *vqueue_pad = NULL;

   518   GstState bin_state;

   519   GstElement *pending_visualisation;

   520 

   521   GST_OBJECT_LOCK (play_bin);

   522   pending_visualisation = play_bin->pending_visualisation;

   523   play_bin->pending_visualisation = NULL;

   524   GST_OBJECT_UNLOCK (play_bin);

   525 

   526   /* We want to disable visualisation */

   527   if (!GST_IS_ELEMENT (pending_visualisation)) {

   528     /* Set visualisation element to READY */

   529     gst_element_set_state (play_bin->visualisation, GST_STATE_READY);

   530     goto beach;

   531   }

   532 

   533   vis_bin =

   534       GST_BIN_CAST (gst_object_get_parent (GST_OBJECT_CAST (play_bin->

   535               visualisation)));

   536 

   537   if (!GST_IS_BIN (vis_bin) || !GST_IS_PAD (tee_pad)) {

   538     goto beach;

   539   }

   540 

   541   vis_src_pad = gst_element_get_pad (play_bin->visualisation, "src");

   542   vis_sink_pad = gst_pad_get_peer (tee_pad);

   543 

   544   /* Can be fakesink */

   545   if (GST_IS_PAD (vis_src_pad)) {

   546     vqueue_pad = gst_pad_get_peer (vis_src_pad);

   547   }

   548 

   549   if (!GST_IS_PAD (vis_sink_pad)) {

   550     goto beach;

   551   }

   552 

   553   /* Check the bin's state */

   554   GST_OBJECT_LOCK (vis_bin);

   555   bin_state = GST_STATE (vis_bin);

   556   GST_OBJECT_UNLOCK (vis_bin);

   557 

   558   /* Unlink */

   559   gst_pad_unlink (tee_pad, vis_sink_pad);

   560   gst_object_unref (vis_sink_pad);

   561   vis_sink_pad = NULL;

   562 

   563   if (GST_IS_PAD (vqueue_pad)) {

   564     gst_pad_unlink (vis_src_pad, vqueue_pad);

   565     gst_object_unref (vis_src_pad);

   566     vis_src_pad = NULL;

   567   }

   568 

   569   /* Remove from vis_bin */

   570   gst_bin_remove (vis_bin, play_bin->visualisation);

   571   /* Set state to NULL */

   572   gst_element_set_state (play_bin->visualisation, GST_STATE_NULL);

   573   /* And loose our ref */

   574   gst_object_unref (play_bin->visualisation);

   575 

   576   if (pending_visualisation) {

   577     /* Ref this new visualisation element before adding to the bin */

   578     gst_object_ref (pending_visualisation);

   579     /* Add the new one */

   580     gst_bin_add (vis_bin, pending_visualisation);

   581     /* Synchronizing state */

   582     gst_element_set_state (pending_visualisation, bin_state);

   583 

   584     vis_sink_pad = gst_element_get_pad (pending_visualisation, "sink");

   585     vis_src_pad = gst_element_get_pad (pending_visualisation, "src");

   586 

   587     if (!GST_IS_PAD (vis_sink_pad) || !GST_IS_PAD (vis_src_pad)) {

   588       goto beach;

   589     }

   590 

   591     /* Link */

   592     gst_pad_link (tee_pad, vis_sink_pad);

   593     gst_pad_link (vis_src_pad, vqueue_pad);

   594   }

   595 

   596   /* We are done */

   597   gst_object_unref (play_bin->visualisation);

   598   play_bin->visualisation = pending_visualisation;

   599 

   600 beach:

   601   if (vis_sink_pad) {

   602     gst_object_unref (vis_sink_pad);

   603   }

   604   if (vis_src_pad) {

   605     gst_object_unref (vis_src_pad);

   606   }

   607   if (vqueue_pad) {

   608     gst_object_unref (vqueue_pad);

   609   }

   610   if (vis_bin) {

   611     gst_object_unref (vis_bin);

   612   }

   613 

   614   /* Unblock the pad */

   615   gst_pad_set_blocked_async (tee_pad, FALSE, gst_play_bin_vis_unblocked,

   616       play_bin);

   617 }

   618 

   619 static void

   620 gst_play_bin_set_property (GObject * object, guint prop_id,

   621     const GValue * value, GParamSpec * pspec)

   622 {

   623   GstPlayBin *play_bin;

   624 

   625   play_bin = GST_PLAY_BIN (object);

   626 

   627   switch (prop_id) {

   628     case ARG_VIDEO_SINK:

   629       if (play_bin->video_sink != NULL) {

   630         gst_object_unref (play_bin->video_sink);

   631       }

   632       play_bin->video_sink = g_value_get_object (value);

   633       if (play_bin->video_sink != NULL) {

   634         gst_object_ref (play_bin->video_sink);

   635         gst_object_sink (GST_OBJECT_CAST (play_bin->video_sink));

   636       }

   637       /* when changing the videosink, we just remove the

   638        * video pipeline from the cache so that it will be

   639        * regenerated with the new sink element */

   640       g_hash_table_remove (play_bin->cache, "vbin");

   641       break;

   642     case ARG_AUDIO_SINK:

   643       if (play_bin->audio_sink != NULL) {

   644         gst_object_unref (play_bin->audio_sink);

   645       }

   646       play_bin->audio_sink = g_value_get_object (value);

   647       if (play_bin->audio_sink != NULL) {

   648         gst_object_ref (play_bin->audio_sink);

   649         gst_object_sink (GST_OBJECT_CAST (play_bin->audio_sink));

   650       }

   651       g_hash_table_remove (play_bin->cache, "abin");

   652       break;

   653     case ARG_VIS_PLUGIN:

   654     {

   655       GstElement *pending_visualisation =

   656           GST_ELEMENT_CAST (g_value_get_object (value));

   657 

   658       /* Take ownership */

   659       if (pending_visualisation) {

   660         gst_object_ref (pending_visualisation);

   661         gst_object_sink (pending_visualisation);

   662       }

   663 

   664       /* Do we already have a visualisation change pending ? */

   665       GST_OBJECT_LOCK (play_bin);

   666       if (play_bin->pending_visualisation) {

   667         gst_object_unref (play_bin->pending_visualisation);

   668         play_bin->pending_visualisation = pending_visualisation;

   669         GST_OBJECT_UNLOCK (play_bin);

   670       } else {

   671         GST_OBJECT_UNLOCK (play_bin);

   672         /* Was there a visualisation already set ? */

   673         if (play_bin->visualisation != NULL) {

   674           GstBin *vis_bin = NULL;

   675 

   676           vis_bin =

   677               GST_BIN_CAST (gst_object_get_parent (GST_OBJECT_CAST (play_bin->

   678                       visualisation)));

   679 

   680           /* Check if the visualisation is already in a bin */

   681           if (GST_IS_BIN (vis_bin)) {

   682             GstPad *vis_sink_pad = NULL, *tee_pad = NULL;

   683 

   684             /* Now get tee pad and block it async */

   685             vis_sink_pad = gst_element_get_pad (play_bin->visualisation,

   686                 "sink");

   687             if (!GST_IS_PAD (vis_sink_pad)) {

   688               goto beach;

   689             }

   690             tee_pad = gst_pad_get_peer (vis_sink_pad);

   691             if (!GST_IS_PAD (tee_pad)) {

   692               goto beach;

   693             }

   694 

   695             play_bin->pending_visualisation = pending_visualisation;

   696             /* Block with callback */

   697             gst_pad_set_blocked_async (tee_pad, TRUE, gst_play_bin_vis_blocked,

   698                 play_bin);

   699           beach:

   700             if (vis_sink_pad) {

   701               gst_object_unref (vis_sink_pad);

   702             }

   703             if (tee_pad) {

   704               gst_object_unref (tee_pad);

   705             }

   706             gst_object_unref (vis_bin);

   707           } else {

   708             play_bin->visualisation = pending_visualisation;

   709           }

   710         } else {

   711           play_bin->visualisation = pending_visualisation;

   712         }

   713       }

   714       break;

   715     }

   716     case ARG_VOLUME:

   717       play_bin->volume = g_value_get_double (value);

   718       if (play_bin->volume_element) {

   719         g_object_set (G_OBJECT (play_bin->volume_element), "volume",

   720             play_bin->volume, NULL);

   721       }

   722       break;

   723     case ARG_FONT_DESC:

   724       g_free (play_bin->font_desc);

   725       play_bin->font_desc = g_strdup (g_value_get_string (value));

   726       if (play_bin->textoverlay_element) {

   727         g_object_set (G_OBJECT (play_bin->textoverlay_element),

   728             "font-desc", g_value_get_string (value), NULL);

   729       }

   730       break;

   731     default:

   732       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   733       break;

   734   }

   735 }

   736 

   737 static void

   738 gst_play_bin_get_property (GObject * object, guint prop_id, GValue * value,

   739     GParamSpec * pspec)

   740 {

   741   GstPlayBin *play_bin;

   742 

   743   play_bin = GST_PLAY_BIN (object);

   744 

   745   switch (prop_id) {

   746     case ARG_VIDEO_SINK:

   747       g_value_set_object (value, play_bin->video_sink);

   748       break;

   749     case ARG_AUDIO_SINK:

   750       g_value_set_object (value, play_bin->audio_sink);

   751       break;

   752     case ARG_VIS_PLUGIN:

   753       g_value_set_object (value, play_bin->visualisation);

   754       break;

   755     case ARG_VOLUME:

   756       g_value_set_double (value, play_bin->volume);

   757       break;

   758     case ARG_FRAME:{

   759       GstBuffer *cur_frame = NULL;

   760 

   761       gst_buffer_replace (&cur_frame, play_bin->frame);

   762       gst_value_take_buffer (value, cur_frame);

   763       break;

   764     }

   765     default:

   766       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   767       break;

   768   }

   769 }

   770 

   771 /* signal fired when the identity has received a new buffer. This is used for

   772  * making screenshots.

   773  */

   774 static void

   775 handoff (GstElement * identity, GstBuffer * frame, gpointer data)

   776 {

   777   GstPlayBin *play_bin = GST_PLAY_BIN (data);

   778 

   779   /* applications need to know the buffer caps,

   780    * make sure they are always set on the frame */

   781   if (GST_BUFFER_CAPS (frame) == NULL) {

   782     GstPad *pad;

   783 

   784     if ((pad = gst_element_get_pad (identity, "sink"))) {

   785       gst_buffer_set_caps (frame, GST_PAD_CAPS (pad));

   786       gst_object_unref (pad);

   787     }

   788   }

   789 

   790   gst_buffer_replace (&play_bin->frame, frame);

   791 }

   792 

   793 static void

   794 post_missing_element_message (GstPlayBin * playbin, const gchar * name)

   795 {

   796   GstMessage *msg;

   797 

   798   msg = gst_missing_element_message_new (GST_ELEMENT_CAST (playbin), name);

   799   gst_element_post_message (GST_ELEMENT_CAST (playbin), msg);

   800 }

   801 

   802 /* make the element (bin) that contains the elements needed to perform

   803  * video display. We connect a handoff signal to identity so that we

   804  * can grab snapshots. Identity's sinkpad is ghosted to vbin.

   805  *

   806  *  +-------------------------------------------------------------+

   807  *  | vbin                                                        |

   808  *  |      +--------+   +----------+   +----------+   +---------+ |

   809  *  |      |identity|   |colorspace|   |videoscale|   |videosink| |

   810  *  |   +-sink     src-sink       src-sink       src-sink       | |

   811  *  |   |  +---+----+   +----------+   +----------+   +---------+ |

   812  * sink-+      |                                                  |

   813  *  +----------|--------------------------------------------------+

   814  *           handoff

   815  */

   816 static GstElement *

   817 gen_video_element (GstPlayBin * play_bin)

   818 {

   819   GstElement *element;

   820   GstElement *conv;

   821 

   822   GstElement *scale;

   823   GstElement *sink;

   824   GstElement *identity;

   825   GstPad *pad;

   826 

   827   /* first see if we have it in the cache */

   828   element = g_hash_table_lookup (play_bin->cache, "vbin");

   829   if (element != NULL) {

   830     return element;

   831   }

   832 

   833   if (play_bin->video_sink) {

   834     sink = play_bin->video_sink;

   835   } else {

   836     sink = gst_element_factory_make ("autovideosink", "videosink");

   837     if (sink == NULL) {

   838       sink = gst_element_factory_make ("xvimagesink", "videosink");

   839     }

   840     if (sink == NULL)

   841       goto no_sinks;

   842   }

   843   gst_object_ref (sink);

   844   g_hash_table_insert (play_bin->cache, "video_sink", sink);

   845 

   846   /* create a bin to hold objects, as we create them we add them to this bin so

   847    * that when something goes wrong we only need to unref the bin */

   848   element = gst_bin_new ("vbin");

   849   gst_bin_add (GST_BIN_CAST (element), sink);

   850 

   851   conv = gst_element_factory_make ("ffmpegcolorspace", "vconv");

   852   if (conv == NULL)

   853     goto no_colorspace;

   854   gst_bin_add (GST_BIN_CAST (element), conv);

   855 

   856   scale = gst_element_factory_make ("videoscale", "vscale");

   857   if (scale == NULL)

   858     goto no_videoscale;

   859   gst_bin_add (GST_BIN_CAST (element), scale);

   860 

   861   identity = gst_element_factory_make ("identity", "id");

   862   g_object_set (identity, "silent", TRUE, NULL);

   863   g_signal_connect (identity, "handoff", G_CALLBACK (handoff), play_bin);

   864   gst_bin_add (GST_BIN_CAST (element), identity);

   865 

   866   gst_element_link_pads (identity, "src", conv, "sink");

   867   gst_element_link_pads (conv, "src", scale, "sink");

   868   /* be more careful with the pad from the custom sink element, it might not

   869    * be named 'sink' */

   870   if (!gst_element_link_pads (scale, "src", sink, NULL))

   871     goto link_failed;

   872 

   873   pad = gst_element_get_pad (identity, "sink");

   874   gst_element_add_pad (element, gst_ghost_pad_new ("sink", pad));

   875   gst_object_unref (pad);

   876 

   877   gst_element_set_state (element, GST_STATE_READY);

   878 

   879   /* since we're gonna add it to a bin but don't want to lose it,

   880    * we keep a reference. */

   881   gst_object_ref (element);

   882   g_hash_table_insert (play_bin->cache, "vbin", element);

   883 

   884   return element;

   885 

   886   /* ERRORS */

   887 no_sinks:

   888   {

   889     post_missing_element_message (play_bin, "autovideosink");

   890     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

   891         (_("Both autovideosink and xvimagesink elements are missing.")),

   892         (NULL));

   893     return NULL;

   894   }

   895 no_colorspace:

   896   {

   897     post_missing_element_message (play_bin, "ffmpegcolorspace");

   898     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

   899         (_("Missing element '%s' - check your GStreamer installation."),

   900             "ffmpegcolorspace"), (NULL));

   901     gst_object_unref (element);

   902     return NULL;

   903   }

   904 

   905 no_videoscale:

   906   {

   907     post_missing_element_message (play_bin, "videoscale");

   908     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

   909         (_("Missing element '%s' - check your GStreamer installation."),

   910             "videoscale"), ("possibly a liboil version mismatch?"));

   911     gst_object_unref (element);

   912     return NULL;

   913   }

   914 link_failed:

   915   {

   916     GST_ELEMENT_ERROR (play_bin, CORE, PAD,

   917         (NULL), ("Failed to configure the video sink."));

   918     gst_object_unref (element);

   919     return NULL;

   920   }

   921 }

   922 

   923 /* make an element for playback of video with subtitles embedded.

   924  *

   925  *  +--------------------------------------------------+

   926  *  | tbin                  +-------------+            |

   927  *  |          +-----+      | textoverlay |   +------+ |

   928  *  |          | csp | +--video_sink      |   | vbin | |

   929  * video_sink-sink  src+ +-text_sink     src-sink    | |

   930  *  |          +-----+   |  +-------------+   +------+ |

   931  * text_sink-------------+                             |

   932  *  +--------------------------------------------------+

   933  *

   934  *  If there is no subtitle renderer this function will simply return the

   935  *  videosink without the text_sink pad.

   936  */

   937 static GstElement *

   938 gen_text_element (GstPlayBin * play_bin)

   939 {

   940   GstElement *element, *csp, *overlay, *vbin;

   941   GstPad *pad;

   942 

   943   /* Create the video rendering bin, error is posted when this fails. */

   944   vbin = gen_video_element (play_bin);

   945   if (!vbin)

   946     return NULL;

   947 

   948   /* Text overlay */

   949   overlay = gst_element_factory_make ("textoverlay", "overlay");

   950 

   951   /* If no overlay return the video bin without subtitle support. */

   952   if (!overlay)

   953     goto no_overlay;

   954 

   955   /* Create our bin */

   956   element = gst_bin_new ("textbin");

   957 

   958   /* Set some parameters */

   959   g_object_set (G_OBJECT (overlay),

   960       "halign", "center", "valign", "bottom", NULL);

   961   if (play_bin->font_desc) {

   962     g_object_set (G_OBJECT (overlay), "font-desc", play_bin->font_desc, NULL);

   963   }

   964 

   965   /* Take a ref */

   966   play_bin->textoverlay_element = GST_ELEMENT_CAST (gst_object_ref (overlay));

   967 

   968   /* we know this will succeed, as the video bin already created one before */

   969   csp = gst_element_factory_make ("ffmpegcolorspace", "subtitlecsp");

   970 

   971   /* Add our elements */

   972   gst_bin_add_many (GST_BIN_CAST (element), csp, overlay, vbin, NULL);

   973 

   974   /* Link */

   975   gst_element_link_pads (csp, "src", overlay, "video_sink");

   976   gst_element_link_pads (overlay, "src", vbin, "sink");

   977 

   978   /* Add ghost pads on the subtitle bin */

   979   pad = gst_element_get_pad (overlay, "text_sink");

   980   gst_element_add_pad (element, gst_ghost_pad_new ("text_sink", pad));

   981   gst_object_unref (pad);

   982 

   983   pad = gst_element_get_pad (csp, "sink");

   984   gst_element_add_pad (element, gst_ghost_pad_new ("sink", pad));

   985   gst_object_unref (pad);

   986 

   987   /* Set state to READY */

   988   gst_element_set_state (element, GST_STATE_READY);

   989 

   990   return element;

   991 

   992   /* ERRORS */

   993 no_overlay:

   994   {

   995     post_missing_element_message (play_bin, "textoverlay");

   996     GST_WARNING_OBJECT (play_bin,

   997         "No overlay (pango) element, subtitles disabled");

   998     return vbin;

   999   }

  1000 }

  1001 

  1002 /* make the element (bin) that contains the elements needed to perform

  1003  * audio playback.

  1004  *

  1005  *  +-------------------------------------------------------------+

  1006  *  | abin                                                        |

  1007  *  |      +---------+   +----------+   +---------+   +---------+ |

  1008  *  |      |audioconv|   |audioscale|   | volume  |   |audiosink| |

  1009  *  |   +-sink      src-sink       src-sink      src-sink       | |

  1010  *  |   |  +---------+   +----------+   +---------+   +---------+ |

  1011  * sink-+                                                         |

  1012  *  +-------------------------------------------------------------+

  1013  */

  1014 static GstElement *

  1015 gen_audio_element (GstPlayBin * play_bin)

  1016 {

  1017   gboolean res;

  1018   GstElement *element;

  1019   GstElement *conv;

  1020   GstElement *scale;

  1021   GstElement *sink;

  1022   GstElement *volume;

  1023   GstPad *pad;

  1024 

  1025   element = g_hash_table_lookup (play_bin->cache, "abin");

  1026   if (element != NULL)

  1027     return element;

  1028 

  1029   if (play_bin->audio_sink) {

  1030     sink = play_bin->audio_sink;

  1031   } else {

  1032     sink = gst_element_factory_make ("autoaudiosink", "audiosink");

  1033     if (sink == NULL) {

  1034     #ifdef __SYMBIAN32__

  1035       sink = gst_element_factory_make ("devsoundsink", "audiosink");

  1036     #else    

  1037       sink = gst_element_factory_make ("alsasink", "audiosink");

  1038     #endif

  1039     }

  1040     if (sink == NULL)

  1041       goto no_sinks;

  1042 

  1043     play_bin->audio_sink = GST_ELEMENT_CAST (gst_object_ref (sink));

  1044   }

  1045 

  1046   gst_object_ref (sink);

  1047   g_hash_table_insert (play_bin->cache, "audio_sink", sink);

  1048 

  1049   element = gst_bin_new ("abin");

  1050   gst_bin_add (GST_BIN_CAST (element), sink);

  1051 

  1052   conv = gst_element_factory_make ("audioconvert", "aconv");

  1053   if (conv == NULL)

  1054     goto no_audioconvert;

  1055   gst_bin_add (GST_BIN_CAST (element), conv);

  1056 

  1057   scale = gst_element_factory_make ("audioresample", "aresample");

  1058   if (scale == NULL)

  1059     goto no_audioresample;

  1060   gst_bin_add (GST_BIN_CAST (element), scale);

  1061 #ifndef __SYMBIAN32__

  1062   volume = gst_element_factory_make ("volume", "volume");

  1063   if (volume == NULL)

  1064     goto no_volume;

  1065   g_object_set (G_OBJECT (volume), "volume", play_bin->volume, NULL);

  1066   play_bin->volume_element = volume;

  1067   gst_bin_add (GST_BIN_CAST (element), volume);

  1068 #endif

  1069 

  1070   res = gst_element_link_pads (conv, "src", scale, "sink");

  1071 #ifndef __SYMBIAN32__

  1072   res &= gst_element_link_pads (scale, "src", volume, "sink");

  1073 #else

  1074   res &= gst_element_link_pads (scale, "src", sink, NULL);

  1075 #endif

  1076 #ifndef __SYMBIAN32__

  1077   res &= gst_element_link_pads (volume, "src", sink, NULL);

  1078 #endif

  1079   if (!res)

  1080     goto link_failed;

  1081 

  1082   pad = gst_element_get_pad (conv, "sink");

  1083   gst_element_add_pad (element, gst_ghost_pad_new ("sink", pad));

  1084   gst_object_unref (pad);

  1085 

  1086   gst_element_set_state (element, GST_STATE_READY);

  1087 

  1088   /* since we're gonna add it to a bin but don't want to lose it,

  1089    * we keep a reference. */

  1090   gst_object_ref (element);

  1091   g_hash_table_insert (play_bin->cache, "abin", element);

  1092 

  1093   return element;

  1094 

  1095   /* ERRORS */

  1096 no_sinks:

  1097   {

  1098     post_missing_element_message (play_bin, "autoaudiosink");

  1099     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

  1100         (_("Both autoaudiosink and alsasink elements are missing.")), (NULL));

  1101     return NULL;

  1102   }

  1103 no_audioconvert:

  1104   {

  1105     post_missing_element_message (play_bin, "audioconvert");

  1106     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

  1107         (_("Missing element '%s' - check your GStreamer installation."),

  1108             "audioconvert"), ("possibly a liboil version mismatch?"));

  1109     gst_object_unref (element);

  1110     return NULL;

  1111   }

  1112 no_audioresample:

  1113   {

  1114     post_missing_element_message (play_bin, "audioresample");

  1115     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

  1116         (_("Missing element '%s' - check your GStreamer installation."),

  1117             "audioresample"), ("possibly a liboil version mismatch?"));

  1118     gst_object_unref (element);

  1119     return NULL;

  1120   }

  1121 no_volume:

  1122   {

  1123     post_missing_element_message (play_bin, "volume");

  1124     GST_ELEMENT_ERROR (play_bin, CORE, MISSING_PLUGIN,

  1125         (_("Missing element '%s' - check your GStreamer installation."),

  1126             "volume"), ("possibly a liboil version mismatch?"));

  1127     gst_object_unref (element);

  1128     return NULL;

  1129   }

  1130 link_failed:

  1131   {

  1132     GST_ELEMENT_ERROR (play_bin, CORE, PAD,

  1133         (NULL), ("Failed to configure the audio sink."));

  1134     gst_object_unref (element);