1 /* GStreamer

     2  * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>

     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 <gst/gst-i18n-plugin.h>

    25 #include <string.h>

    26 #include "gstplaybasebin.h"

    27 #include "gststreamselector.h"

    28 #include "gstplay-marshal.h"

    29 

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

    31 

    32 #ifdef __SYMBIAN32__

    33 #include <glib_global.h>

    34 #endif

    35 

    36 GST_DEBUG_CATEGORY_STATIC (gst_play_base_bin_debug);

    37 #define GST_CAT_DEFAULT gst_play_base_bin_debug

    38 

    39 #define DEFAULT_QUEUE_SIZE          (3 * GST_SECOND)

    40 #define DEFAULT_QUEUE_MIN_THRESHOLD ((DEFAULT_QUEUE_SIZE * 30) / 100)

    41 #define DEFAULT_QUEUE_THRESHOLD     ((DEFAULT_QUEUE_SIZE * 95) / 100)

    42 #define DEFAULT_CONNECTION_SPEED    0

    43 

    44 #define GROUP_LOCK(pbb) g_mutex_lock (pbb->group_lock)

    45 #define GROUP_UNLOCK(pbb) g_mutex_unlock (pbb->group_lock)

    46 #define GROUP_WAIT(pbb) g_cond_wait (pbb->group_cond, pbb->group_lock)

    47 #define GROUP_SIGNAL(pbb) g_cond_signal (pbb->group_cond)

    48 

    49 /* props */

    50 enum

    51 {

    52   ARG_0,

    53   ARG_URI,

    54   ARG_SUBURI,

    55   ARG_QUEUE_SIZE,

    56   ARG_QUEUE_THRESHOLD,

    57   ARG_QUEUE_MIN_THRESHOLD,

    58   ARG_NSTREAMS,

    59   ARG_STREAMINFO,

    60   ARG_STREAMINFO_VALUES,

    61   ARG_SOURCE,

    62   ARG_VIDEO,

    63   ARG_AUDIO,

    64   ARG_TEXT,

    65   ARG_SUBTITLE_ENCODING,

    66   ARG_CONNECTION_SPEED

    67 };

    68 

    69 static void gst_play_base_bin_class_init (GstPlayBaseBinClass * klass);

    70 static void gst_play_base_bin_init (GstPlayBaseBin * play_base_bin);

    71 static void gst_play_base_bin_dispose (GObject * object);

    72 static void gst_play_base_bin_finalize (GObject * object);

    73 

    74 static void gst_play_base_bin_set_property (GObject * object, guint prop_id,

    75     const GValue * value, GParamSpec * spec);

    76 static void gst_play_base_bin_get_property (GObject * object, guint prop_id,

    77     GValue * value, GParamSpec * spec);

    78 static void gst_play_base_bin_handle_message_func (GstBin * bin,

    79     GstMessage * msg);

    80 

    81 static GstStateChangeReturn gst_play_base_bin_change_state (GstElement *

    82     element, GstStateChange transition);

    83 

    84 static const GList *gst_play_base_bin_get_streaminfo (GstPlayBaseBin * bin);

    85 static GValueArray *gst_play_base_bin_get_streaminfo_value_array (GstPlayBaseBin

    86     * play_base_bin);

    87 static void preroll_remove_overrun (GstElement * element,

    88     GstPlayBaseBin * play_base_bin);

    89 static void queue_remove_probe (GstElement * queue, GstPlayBaseBin

    90     * play_base_bin);

    91 

    92 static GstElement *make_decoder (GstPlayBaseBin * play_base_bin);

    93 static gboolean has_all_raw_caps (GstPad * pad, gboolean * all_raw);

    94 

    95 static gboolean prepare_output (GstPlayBaseBin * play_base_bin);

    96 static void set_active_source (GstPlayBaseBin * play_base_bin,

    97     GstStreamType type, gint source_num);

    98 static gboolean probe_triggered (GstPad * pad, GstEvent * event,

    99     gpointer user_data);

   100 static void setup_substreams (GstPlayBaseBin * play_base_bin);

   101 

   102 static GstPipelineClass *parent_class;

   103 

   104 /*

   105  * GObject playbasebin wrappers.

   106  */

   107 #ifdef __SYMBIAN32__

   108 EXPORT_C

   109 #endif

   110 

   111 

   112 GType

   113 gst_play_base_bin_get_type (void)

   114 {

   115   static GType gst_play_base_bin_type = 0;

   116 

   117   if (!gst_play_base_bin_type) {

   118     static const GTypeInfo gst_play_base_bin_info = {

   119       sizeof (GstPlayBaseBinClass),

   120       NULL,

   121       NULL,

   122       (GClassInitFunc) gst_play_base_bin_class_init,

   123       NULL,

   124       NULL,

   125       sizeof (GstPlayBaseBin),

   126       0,

   127       (GInstanceInitFunc) gst_play_base_bin_init,

   128       NULL

   129     };

   130 

   131     gst_play_base_bin_type = g_type_register_static (GST_TYPE_PIPELINE,

   132         "GstPlayBaseBin", &gst_play_base_bin_info, 0);

   133   }

   134 

   135   return gst_play_base_bin_type;

   136 }

   137 

   138 static void

   139 gst_play_base_bin_class_init (GstPlayBaseBinClass * klass)

   140 {

   141   GObjectClass *gobject_klass;

   142   GstElementClass *gstelement_klass;

   143   GstBinClass *gstbin_klass;

   144 

   145   gobject_klass = (GObjectClass *) klass;

   146   gstelement_klass = (GstElementClass *) klass;

   147   gstbin_klass = (GstBinClass *) klass;

   148 

   149   parent_class = g_type_class_peek_parent (klass);

   150 

   151   gobject_klass->set_property = gst_play_base_bin_set_property;

   152   gobject_klass->get_property = gst_play_base_bin_get_property;

   153 

   154   g_object_class_install_property (gobject_klass, ARG_URI,

   155       g_param_spec_string ("uri", "URI", "URI of the media to play",

   156           NULL, G_PARAM_READWRITE));

   157   g_object_class_install_property (gobject_klass, ARG_SUBURI,

   158       g_param_spec_string ("suburi", ".sub-URI", "Optional URI of a subtitle",

   159           NULL, G_PARAM_READWRITE));

   160 

   161   g_object_class_install_property (gobject_klass, ARG_QUEUE_SIZE,

   162       g_param_spec_uint64 ("queue-size", "Queue size",

   163           "Size of internal queues in nanoseconds", 0, G_MAXINT64,

   164           DEFAULT_QUEUE_SIZE, G_PARAM_READWRITE));

   165   g_object_class_install_property (gobject_klass, ARG_QUEUE_THRESHOLD,

   166       g_param_spec_uint64 ("queue-threshold", "Queue threshold",

   167           "Buffering threshold of internal queues in nanoseconds", 0,

   168           G_MAXINT64, DEFAULT_QUEUE_THRESHOLD, G_PARAM_READWRITE));

   169   g_object_class_install_property (gobject_klass, ARG_QUEUE_MIN_THRESHOLD,

   170       g_param_spec_uint64 ("queue-min-threshold", "Queue min threshold",

   171           "Buffering low threshold of internal queues in nanoseconds", 0,

   172           G_MAXINT64, DEFAULT_QUEUE_MIN_THRESHOLD, G_PARAM_READWRITE));

   173 

   174   g_object_class_install_property (gobject_klass, ARG_NSTREAMS,

   175       g_param_spec_int ("nstreams", "NStreams", "number of streams",

   176           0, G_MAXINT, 0, G_PARAM_READABLE));

   177   g_object_class_install_property (gobject_klass, ARG_STREAMINFO,

   178       g_param_spec_pointer ("stream-info", "Stream info", "List of streaminfo",

   179           G_PARAM_READABLE));

   180   g_object_class_install_property (gobject_klass, ARG_STREAMINFO_VALUES,

   181       g_param_spec_value_array ("stream-info-value-array",

   182           "StreamInfo GValueArray", "value array of streaminfo",

   183           g_param_spec_object ("streaminfo", "StreamInfo", "Streaminfo object",

   184               GST_TYPE_STREAM_INFO, G_PARAM_READABLE), G_PARAM_READABLE));

   185   g_object_class_install_property (gobject_klass, ARG_SOURCE,

   186       g_param_spec_object ("source", "Source", "Source element",

   187           GST_TYPE_ELEMENT, G_PARAM_READABLE));

   188 

   189   g_object_class_install_property (gobject_klass, ARG_VIDEO,

   190       g_param_spec_int ("current-video", "Current video",

   191           "Currently playing video stream (-1 = none)",

   192           -1, G_MAXINT, -1, G_PARAM_READWRITE));

   193   g_object_class_install_property (gobject_klass, ARG_AUDIO,

   194       g_param_spec_int ("current-audio", "Current audio",

   195           "Currently playing audio stream (-1 = none)",

   196           -1, G_MAXINT, -1, G_PARAM_READWRITE));

   197   g_object_class_install_property (gobject_klass, ARG_TEXT,

   198       g_param_spec_int ("current-text", "Current text",

   199           "Currently playing text stream (-1 = none)",

   200           -1, G_MAXINT, -1, G_PARAM_READWRITE));

   201   g_object_class_install_property (gobject_klass, ARG_SUBTITLE_ENCODING,

   202       g_param_spec_string ("subtitle-encoding", "subtitle encoding",

   203           "Encoding to assume if input subtitles are not in UTF-8 encoding. "

   204           "If not set, the GST_SUBTITLE_ENCODING environment variable will "

   205           "be checked for an encoding to use. If that is not set either, "

   206           "ISO-8859-15 will be assumed.", NULL, G_PARAM_READWRITE));

   207   /**

   208    * GstPlayBin::connection-speed

   209    *

   210    * Network connection speed in kbps (0 = unknown)

   211    *

   212    * Since: 0.10.10 at gstplaybin.c, 0.10.15 moved to gstplaybasebin

   213    **/

   214   g_object_class_install_property (gobject_klass, ARG_CONNECTION_SPEED,

   215       g_param_spec_uint ("connection-speed", "Connection Speed",

   216           "Network connection speed in kbps (0 = unknown)",

   217           0, G_MAXUINT, DEFAULT_CONNECTION_SPEED, G_PARAM_READWRITE));

   218 

   219   GST_DEBUG_CATEGORY_INIT (gst_play_base_bin_debug, "playbasebin", 0,

   220       "playbasebin");

   221 

   222   gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_base_bin_dispose);

   223   gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_play_base_bin_finalize);

   224 

   225   gstbin_klass->handle_message =

   226       GST_DEBUG_FUNCPTR (gst_play_base_bin_handle_message_func);

   227 

   228   gstelement_klass->change_state =

   229       GST_DEBUG_FUNCPTR (gst_play_base_bin_change_state);

   230 }

   231 

   232 static void

   233 gst_play_base_bin_init (GstPlayBaseBin * play_base_bin)

   234 {

   235   play_base_bin->uri = NULL;

   236   play_base_bin->suburi = NULL;

   237   play_base_bin->need_rebuild = TRUE;

   238   play_base_bin->is_stream = FALSE;

   239   play_base_bin->source = NULL;

   240   play_base_bin->decoders = NULL;

   241   play_base_bin->subtitle = NULL;

   242   play_base_bin->subencoding = NULL;

   243   play_base_bin->subtitle_elements = NULL;

   244   play_base_bin->sub_lock = g_mutex_new ();

   245 

   246   play_base_bin->group_lock = g_mutex_new ();

   247   play_base_bin->group_cond = g_cond_new ();

   248 

   249   play_base_bin->building_group = NULL;

   250   play_base_bin->queued_groups = NULL;

   251 

   252   play_base_bin->queue_size = DEFAULT_QUEUE_SIZE;

   253   play_base_bin->queue_threshold = DEFAULT_QUEUE_THRESHOLD;

   254   play_base_bin->queue_min_threshold = DEFAULT_QUEUE_MIN_THRESHOLD;

   255   play_base_bin->connection_speed = DEFAULT_CONNECTION_SPEED;

   256 }

   257 

   258 static void

   259 gst_play_base_bin_dispose (GObject * object)

   260 {

   261   GstPlayBaseBin *play_base_bin;

   262 

   263   play_base_bin = GST_PLAY_BASE_BIN (object);

   264   g_free (play_base_bin->uri);

   265   play_base_bin->uri = NULL;

   266   g_free (play_base_bin->suburi);

   267   play_base_bin->suburi = NULL;

   268   g_free (play_base_bin->subencoding);

   269   play_base_bin->subencoding = NULL;

   270   if (play_base_bin->subtitle_elements) {

   271     g_slist_free (play_base_bin->subtitle_elements);

   272     play_base_bin->subtitle_elements = NULL;

   273   }

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

   275 }

   276 

   277 static void

   278 gst_play_base_bin_finalize (GObject * object)

   279 {

   280   GstPlayBaseBin *play_base_bin = GST_PLAY_BASE_BIN (object);

   281 

   282   g_mutex_free (play_base_bin->group_lock);

   283   g_cond_free (play_base_bin->group_cond);

   284 

   285   g_mutex_free (play_base_bin->sub_lock);

   286 

   287   G_OBJECT_CLASS (parent_class)->finalize (object);

   288 }

   289 

   290 /*

   291  * playbasebingroup stuff.

   292  */

   293 

   294 static GstPlayBaseGroup *

   295 group_create (GstPlayBaseBin * play_base_bin)

   296 {

   297   GstPlayBaseGroup *group;

   298 

   299   group = g_new0 (GstPlayBaseGroup, 1);

   300   group->bin = play_base_bin;

   301   group->streaminfo_value_array = g_value_array_new (0);

   302 

   303   GST_DEBUG_OBJECT (play_base_bin, "created new group %p", group);

   304 

   305   return group;

   306 }

   307 

   308 /*

   309  * Gets the currently playing group.

   310  *

   311  * Callers must have group-lock held when calling this.

   312  */

   313 

   314 static GstPlayBaseGroup *

   315 get_active_group (GstPlayBaseBin * play_base_bin)

   316 {

   317   GstPlayBaseGroup *group = NULL;

   318 

   319   if (play_base_bin->queued_groups)

   320     group = play_base_bin->queued_groups->data;

   321 

   322   return group;

   323 }

   324 

   325 /*

   326  * get the group used for discovering the different streams.

   327  * This function creates a group is there is none.

   328  *

   329  * Callers must have group-lock held when calling this.

   330  */

   331 static GstPlayBaseGroup *

   332 get_building_group (GstPlayBaseBin * play_base_bin)

   333 {

   334   GstPlayBaseGroup *group;

   335 

   336   group = play_base_bin->building_group;

   337   if (group == NULL) {

   338     group = group_create (play_base_bin);

   339     play_base_bin->building_group = group;

   340   }

   341 

   342   return group;

   343 }

   344 

   345 /*

   346  * Callers must have lock held when calling this!

   347  */

   348 

   349 static void

   350 group_destroy (GstPlayBaseGroup * group)

   351 {

   352   GstPlayBaseBin *play_base_bin = group->bin;

   353   gint n;

   354 

   355   GST_LOG ("removing group %p", group);

   356 

   357   /* remove the preroll queues */

   358   for (n = 0; n < NUM_TYPES; n++) {

   359     GstElement *element = group->type[n].preroll;

   360     GstElement *fakesrc;

   361     GstElement *sel;

   362     const GList *item;

   363 

   364     if (!element)

   365       continue;

   366 

   367     sel = group->type[n].selector;

   368 

   369     /* remove any fakesrc elements for this preroll element */

   370     for (item = sel->pads; item != NULL; item = item->next) {

   371       GstPad *pad = GST_PAD (item->data);

   372       guint sig_id;

   373 

   374       if (GST_PAD_DIRECTION (pad) != GST_PAD_SINK)

   375         continue;

   376 

   377       sig_id =

   378           GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pad), "unlinked_id"));

   379 

   380       if (sig_id != 0) {

   381         GST_LOG ("removing unlink signal %s:%s", GST_DEBUG_PAD_NAME (pad));

   382         g_signal_handler_disconnect (G_OBJECT (pad), sig_id);

   383         g_object_set_data (G_OBJECT (pad), "unlinked_id", GINT_TO_POINTER (0));

   384       }

   385 

   386       fakesrc = (GstElement *) g_object_get_data (G_OBJECT (pad), "fakesrc");

   387       if (fakesrc != NULL) {

   388         GST_LOG ("removing fakesrc from %s:%s",

   389             GST_PAD_NAME (pad), GST_ELEMENT_NAME (GST_PAD_PARENT (pad)));

   390         gst_element_set_state (fakesrc, GST_STATE_NULL);

   391         gst_bin_remove (GST_BIN_CAST (play_base_bin), fakesrc);

   392       }

   393     }

   394 

   395     /* if the group is currently being played, we have to remove the element

   396      * from the thread */

   397     gst_element_set_state (element, GST_STATE_NULL);

   398     gst_element_set_state (group->type[n].selector, GST_STATE_NULL);

   399 

   400     GST_LOG ("removing preroll element %s", GST_ELEMENT_NAME (element));

   401 

   402     gst_bin_remove (group->type[n].bin, element);

   403     gst_bin_remove (group->type[n].bin, group->type[n].selector);

   404 

   405     group->type[n].preroll = NULL;

   406     group->type[n].selector = NULL;

   407     group->type[n].bin = NULL;

   408   }

   409 

   410   /* free the streaminfo too */

   411   g_list_foreach (group->streaminfo, (GFunc) g_object_unref, NULL);

   412   g_list_free (group->streaminfo);

   413   g_value_array_free (group->streaminfo_value_array);

   414   g_free (group);

   415 }

   416 

   417 /*

   418  * is called when the current building group is completely finished

   419  * and ready for playback

   420  *

   421  * This function grabs lock, so take care when calling.

   422  */

   423 static void

   424 group_commit (GstPlayBaseBin * play_base_bin, gboolean fatal, gboolean subtitle)

   425 {

   426   GstPlayBaseGroup *group;

   427   gboolean had_active_group;

   428   gboolean res;

   429 

   430   GROUP_LOCK (play_base_bin);

   431   group = play_base_bin->building_group;

   432   had_active_group = (get_active_group (play_base_bin) != NULL);

   433 

   434   GST_DEBUG_OBJECT (play_base_bin, "commit group %p, had active %d",

   435       group, had_active_group);

   436 

   437   /* if an element signalled a no-more-pads after we stopped due

   438    * to preroll, the group is NULL. This is not an error */

   439   if (group == NULL) {

   440     if (!fatal) {

   441       GROUP_UNLOCK (play_base_bin);

   442       return;

   443     } else {

   444       GST_DEBUG_OBJECT (play_base_bin, "Group loading failed, bailing out");

   445     }

   446   } else {

   447     if (!subtitle) {

   448       gint n;

   449 

   450       GST_DEBUG_OBJECT (play_base_bin, "group %p done", group);

   451 

   452       play_base_bin->queued_groups =

   453           g_list_append (play_base_bin->queued_groups, group);

   454 

   455       play_base_bin->building_group = NULL;

   456 

   457       /* remove signals. We don't want anymore signals from the preroll

   458        * elements at this stage. */

   459       for (n = 0; n < NUM_TYPES; n++) {

   460         GstElement *element = group->type[n].preroll;

   461 

   462         if (!element)

   463           continue;

   464 

   465         preroll_remove_overrun (element, play_base_bin);

   466         /* if overrun is removed, probe alse has to be removed */

   467         queue_remove_probe (element, play_base_bin);

   468       }

   469     } else {

   470       /* this is a special subtitle bin, we don't commit the group but

   471        * mark the subtitles as detected before we signal. */

   472       GST_DEBUG_OBJECT (play_base_bin, "marking subtitle bin as complete");

   473       play_base_bin->subtitle_done = TRUE;

   474     }

   475   }

   476 

   477   GST_DEBUG_OBJECT (play_base_bin, "signal group done");

   478   GROUP_SIGNAL (play_base_bin);

   479   GST_DEBUG_OBJECT (play_base_bin, "signaled group done");

   480 

   481   if (!subtitle && !had_active_group) {

   482     if (!prepare_output (play_base_bin)) {

   483       GROUP_UNLOCK (play_base_bin);

   484       return;

   485     }

   486 

   487     setup_substreams (play_base_bin);

   488     GST_DEBUG_OBJECT (play_base_bin, "Emitting signal");

   489     res = GST_PLAY_BASE_BIN_GET_CLASS (play_base_bin)->

   490         setup_output_pads (play_base_bin, group);

   491     GST_DEBUG_OBJECT (play_base_bin, "done");

   492 

   493     GROUP_UNLOCK (play_base_bin);

   494 

   495     g_object_notify (G_OBJECT (play_base_bin), "stream-info");

   496   } else {

   497     GROUP_UNLOCK (play_base_bin);

   498   }

   499 }

   500 

   501 /*

   502  * check if there are streams in the group that are not muted

   503  *

   504  * Callers must have group-lock held when calling this.

   505  */

   506 static gboolean

   507 group_is_muted (GstPlayBaseGroup * group)

   508 {

   509   gint n;

   510 

   511   for (n = 0; n < NUM_TYPES; n++) {

   512     if (group->type[n].preroll && !group->type[n].done)

   513       return FALSE;

   514   }

   515 

   516   return TRUE;

   517 }

   518 

   519 /*

   520  * Buffer/cache checking.

   521  */

   522 

   523 static inline void

   524 fill_buffer (GstPlayBaseBin * play_base_bin, gint percent)

   525 {

   526   GST_DEBUG_OBJECT (play_base_bin, "buffering %d", percent);

   527   gst_element_post_message (GST_ELEMENT_CAST (play_base_bin),

   528       gst_message_new_buffering (GST_OBJECT_CAST (play_base_bin), percent));

   529 }

   530 

   531 static gboolean

   532 check_queue_event (GstPad * pad, GstEvent * event, gpointer user_data)

   533 {

   534   GstElement *queue = GST_ELEMENT_CAST (user_data);

   535 

   536   switch (GST_EVENT_TYPE (event)) {

   537     case GST_EVENT_EOS:

   538       GST_DEBUG ("EOS event, mark EOS");

   539       g_object_set_data (G_OBJECT (queue), "eos", "1");

   540       break;

   541     case GST_EVENT_FLUSH_STOP:

   542       GST_DEBUG ("FLUSH_STOP event, remove EOS");

   543       g_object_set_data (G_OBJECT (queue), "eos", NULL);

   544       break;

   545     default:

   546       GST_DEBUG ("uninteresting event %s", GST_EVENT_TYPE_NAME (event));

   547       break;

   548   }

   549   return TRUE;

   550 }

   551 

   552 static gboolean

   553 check_queue (GstPad * pad, GstBuffer * data, gpointer user_data)

   554 {

   555   GstElement *queue = GST_ELEMENT_CAST (user_data);

   556   GstPlayBaseBin *play_base_bin = g_object_get_data (G_OBJECT (queue), "pbb");

   557   guint64 level = 0;

   558 

   559   GST_DEBUG_OBJECT (queue, "check queue triggered");

   560 

   561   g_object_get (G_OBJECT (queue), "current-level-time", &level, NULL);

   562   GST_DEBUG_OBJECT (play_base_bin, "Queue size: %" GST_TIME_FORMAT,

   563       GST_TIME_ARGS (level));

   564 

   565   if (play_base_bin->queue_threshold > 0) {

   566     level = level * 99 / play_base_bin->queue_threshold;

   567     if (level > 99)

   568       level = 99;

   569   } else

   570     level = 99;

   571 

   572   fill_buffer (play_base_bin, level);

   573 

   574   /* continue! */

   575   return TRUE;

   576 }

   577 

   578 /* If a queue overruns and we are buffer in streaming mode (we have a min-time)

   579  * we can potentially create a deadlock when:

   580  *

   581  *  1) the max-bytes is hit and

   582  *  2) the min-time is not hit.

   583  *

   584  * We recover from this situation in this callback by

   585  * setting the max-bytes to unlimited if we see that there is

   586  * a current-time-level (which means some sort of timestamping is

   587  * done).

   588  */

   589 static void

   590 queue_deadlock_check (GstElement * queue, GstPlayBaseBin * play_base_bin)

   591 {

   592   guint64 time, min_time;

   593   guint bytes;

   594 

   595   GST_DEBUG_OBJECT (play_base_bin, "overrun signal received from queue %s",

   596       GST_ELEMENT_NAME (queue));

   597 

   598   /* figure out where we are */

   599   g_object_get (G_OBJECT (queue), "current-level-time", &time,

   600       "current-level-bytes", &bytes, "min-threshold-time", &min_time, NULL);

   601 

   602   GST_DEBUG_OBJECT (play_base_bin, "streaming mode, queue %s current %"

   603       GST_TIME_FORMAT ", min %" GST_TIME_FORMAT

   604       ", bytes %d", GST_ELEMENT_NAME (queue),

   605       GST_TIME_ARGS (time), GST_TIME_ARGS (min_time), bytes);

   606 

   607   /* if the bytes in the queue represent time, we disable bytes

   608    * overrun checking to not cause deadlocks.

   609    */

   610   if (bytes && time != 0 && time < min_time) {

   611     GST_DEBUG_OBJECT (play_base_bin,

   612         "possible deadlock found, removing byte limit");

   613 

   614     /* queue knows about time but is filled with bytes that do

   615      * not represent min-threshold time, disable bytes checking so

   616      * the queue can grow some more. */

   617     g_object_set (G_OBJECT (queue), "max-size-bytes", 0, NULL);

   618 

   619     /* bytes limit is removed, we cannot deadlock anymore */

   620     g_signal_handlers_disconnect_by_func (queue,

   621         (gpointer) queue_deadlock_check, play_base_bin);

   622   } else {

   623     GST_DEBUG_OBJECT (play_base_bin, "no deadlock");

   624   }

   625 }

   626 

   627 static void

   628 queue_remove_probe (GstElement * queue, GstPlayBaseBin * play_base_bin)

   629 {

   630   gpointer data;

   631   GstPad *sinkpad;

   632 

   633   data = g_object_get_data (G_OBJECT (queue), "probe");

   634   sinkpad = gst_element_get_pad (queue, "sink");

   635 

   636   if (data) {

   637     GST_DEBUG_OBJECT (play_base_bin,

   638         "Removing buffer probe from pad %s:%s (%p)",

   639         GST_DEBUG_PAD_NAME (sinkpad), sinkpad);

   640 

   641     g_object_set_data (G_OBJECT (queue), "probe", NULL);

   642     gst_pad_remove_buffer_probe (sinkpad, GPOINTER_TO_INT (data));

   643   } else {

   644     GST_DEBUG_OBJECT (play_base_bin,

   645         "No buffer probe to remove from %s:%s (%p)",

   646         GST_DEBUG_PAD_NAME (sinkpad), sinkpad);

   647   }

   648   gst_object_unref (sinkpad);

   649 }

   650 

   651 /* Used for time-based buffering in streaming mode and is called when a queue

   652  * emits the running signal. This means that the high watermark threshold is

   653  * reached and the buffering is completed. */

   654 static void

   655 queue_threshold_reached (GstElement * queue, GstPlayBaseBin * play_base_bin)

   656 {

   657   GstPlayBaseGroup *group;

   658   gpointer data;

   659   gint n;

   660 

   661   GST_DEBUG_OBJECT (play_base_bin, "running signal received from queue %s",

   662       GST_ELEMENT_NAME (queue));

   663 

   664   /* we disconnect the signal so that we don't get called for every buffer. */

   665   g_signal_handlers_disconnect_by_func (queue,

   666       (gpointer) queue_threshold_reached, play_base_bin);

   667 

   668   data = g_object_get_data (G_OBJECT (queue), "eos");

   669   if (data) {

   670     GST_DEBUG_OBJECT (play_base_bin, "disable min threshold time, we are EOS");

   671     g_object_set (queue, "min-threshold-time", (guint64) 0, NULL);

   672   } else {

   673     /* now place the limits at the low threshold. When we hit this limit, the

   674      * underrun signal will be called. The underrun signal is always connected. */

   675     GST_DEBUG_OBJECT (play_base_bin,

   676         "setting min threshold time to %" G_GUINT64_FORMAT,

   677         play_base_bin->queue_min_threshold);

   678     g_object_set (queue, "min-threshold-time",

   679         play_base_bin->queue_min_threshold, NULL);

   680   }

   681 

   682   GROUP_LOCK (play_base_bin);

   683   group = get_active_group (play_base_bin);

   684   if (!group) {

   685     GROUP_UNLOCK (play_base_bin);

   686     return;

   687   }

   688 

   689   /* we remove the probe now because we don't need it anymore to give progress

   690    * about the buffering. */

   691   for (n = 0; n < NUM_TYPES; n++) {

   692     GstElement *element = group->type[n].preroll;

   693 

   694     if (!element)

   695       continue;

   696 

   697     queue_remove_probe (element, play_base_bin);

   698   }

   699 

   700   GROUP_UNLOCK (play_base_bin);

   701 

   702   /* we post a 100% buffering message to notify the app that buffering is

   703    * completed and playback can start/continue */

   704   if (play_base_bin->is_stream)

   705     fill_buffer (play_base_bin, 100);

   706 }

   707 

   708 /* this signal will be fired when one of the queues with raw

   709  * data is filled. This means that the group building stage is over 

   710  * and playback of the new queued group should start. This is a rather unusual

   711  * situation because normally the group is commited when the "no_more_pads"

   712  * signal is fired.

   713  */

   714 static void

   715 queue_overrun (GstElement * queue, GstPlayBaseBin * play_base_bin)

   716 {

   717   GST_DEBUG_OBJECT (play_base_bin, "queue %s overrun",

   718       GST_ELEMENT_NAME (queue));

   719 

   720   preroll_remove_overrun (queue, play_base_bin);

   721 

   722   group_commit (play_base_bin, FALSE,

   723       GST_OBJECT_PARENT (GST_OBJECT_CAST (queue)) ==

   724       GST_OBJECT_CAST (play_base_bin->subtitle));

   725 

   726   /* notify end of buffering */

   727   queue_threshold_reached (queue, play_base_bin);

   728 }

   729 

   730 /* this signal is only added when in streaming mode to catch underruns

   731  */

   732 static void

   733 queue_out_of_data (GstElement * queue, GstPlayBaseBin * play_base_bin)

   734 {

   735   GST_DEBUG_OBJECT (play_base_bin, "underrun signal received from queue %s",

   736       GST_ELEMENT_NAME (queue));

   737 

   738   /* On underrun, we want to temoprarily pause playback, set a "min-size"

   739    * threshold and wait for the running signal and then play again.

   740    *

   741    * This signal could never be called because the queue max-size limits are set

   742    * too low. We take care of this possible deadlock in the the overrun signal

   743    * handler. */

   744   g_signal_connect (G_OBJECT (queue), "pushing",

   745       G_CALLBACK (queue_threshold_reached), play_base_bin);

   746   GST_DEBUG_OBJECT (play_base_bin,

   747       "setting min threshold time to %" G_GUINT64_FORMAT,

   748       (guint64) play_base_bin->queue_threshold);

   749   g_object_set (queue, "min-threshold-time",

   750       (guint64) play_base_bin->queue_threshold, NULL);

   751 

   752   /* re-connect probe, this will fire feedback about the percentage that we

   753    * buffered and is posted in the BUFFERING message. */

   754   if (!g_object_get_data (G_OBJECT (queue), "probe")) {

   755     GstPad *sinkpad;

   756     guint id;

   757 

   758     sinkpad = gst_element_get_pad (queue, "sink");

   759     id = gst_pad_add_buffer_probe (sinkpad, G_CALLBACK (check_queue), queue);

   760     g_object_set_data (G_OBJECT (queue), "probe", GINT_TO_POINTER (id));

   761     GST_DEBUG_OBJECT (play_base_bin,

   762         "Re-attaching buffering probe to pad %s:%s %p",

   763         GST_DEBUG_PAD_NAME (sinkpad), sinkpad);

   764     gst_object_unref (sinkpad);

   765 

   766     fill_buffer (play_base_bin, 0);

   767   }

   768 }

   769 

   770 /*

   771  * generate a preroll element which is simply a queue. While there

   772  * are still dynamic elements in the pipeline, we wait for one

   773  * of the queues to fill. The assumption is that all the dynamic

   774  * streams will be detected by that time.

   775  *

   776  * Callers must have the group-lock held when calling this.

   777  */

   778 static void

   779 gen_preroll_element (GstPlayBaseBin * play_base_bin,

   780     GstPlayBaseGroup * group, GstStreamType type, GstPad * pad,

   781     GstStreamInfo * info)

   782 {

   783   GstElement *selector, *preroll;

   784   gchar *name, *padname;

   785   const gchar *prename;

   786   guint overrun_sig;

   787   GstPad *preroll_pad;

   788   GstBin *target;

   789   GstState state;

   790 

   791   if (type == GST_STREAM_TYPE_VIDEO)

   792     prename = "video";

   793   else if (type == GST_STREAM_TYPE_TEXT)

   794     prename = "text";

   795   else if (type == GST_STREAM_TYPE_AUDIO)

   796     prename = "audio";

   797   else

   798     g_return_if_reached ();

   799 

   800   /* create stream selector */

   801   selector = g_object_new (GST_TYPE_STREAM_SELECTOR, NULL);

   802   padname = gst_pad_get_name (pad);

   803   name = g_strdup_printf ("selector_%s_%s", prename, padname);

   804   gst_object_set_name (GST_OBJECT_CAST (selector), name);

   805   g_free (name);

   806 

   807   /* create preroll queue */

   808   name = g_strdup_printf ("preroll_%s_%s", prename, padname);

   809   preroll = gst_element_factory_make ("queue", name);

   810   g_free (name);

   811   g_free (padname);

   812 

   813   /* for buffering of raw data we ideally want to buffer a

   814    * very small amount of buffers since the memory used by

   815    * this raw data can be enormously huge.

   816    *

   817    * We use an upper limit of typically a few seconds here but

   818    * cap in case no timestamps are set on the raw data (bad!).

   819    *

   820    * FIXME: we abuse this buffer to do network buffering since

   821    * we can then easily do time-based buffering. The better

   822    * solution would be to add a specific network queue right

   823    * after the source that measures the datarate and scales this

   824    * queue of encoded data instead.

   825    */

   826   g_object_set (G_OBJECT (preroll),

   827       "max-size-buffers", 0, "max-size-bytes",

   828       ((type == GST_STREAM_TYPE_VIDEO) ? 25 : 2) * 1024 * 1024,

   829       "max-size-time", play_base_bin->queue_size, NULL);

   830 

   831   /* the overrun signal is always attached and serves two purposes:

   832    *

   833    *  1) when we are building a group and the overrun is called, we commit the 

   834    *     group. The reason being that if we fill the entire queue without a

   835    *     normal group commit (with _no_more_pads()) we can assume the

   836    *     audio/video is completely wacked or the element just does not know when

   837    *     it is ready with all the pads (mpeg).

   838    *  2) When we are doing network buffering, we keep track of low/high

   839    *     watermarks in the queue. It is possible that we set the high watermark

   840    *     higher than the max-size limits to trigger an overrun. In this case we

   841    *     will never get a running signal but we can use the overrun signal to

   842    *     detect this deadlock and correct it.

   843    */

   844   overrun_sig = g_signal_connect (G_OBJECT (preroll), "overrun",

   845       G_CALLBACK (queue_overrun), play_base_bin);

   846 

   847   /* keep a ref to the signal id so that we can disconnect the signal callback

   848    * when we are done with the preroll */

   849   g_object_set_data (G_OBJECT (preroll), "overrun_signal_id",

   850       GINT_TO_POINTER (overrun_sig));

   851 

   852   if (play_base_bin->is_stream &&

   853       ((type == GST_STREAM_TYPE_VIDEO &&

   854               group->type[GST_STREAM_TYPE_AUDIO - 1].npads == 0) ||

   855           (type == GST_STREAM_TYPE_AUDIO &&

   856               group->type[GST_STREAM_TYPE_VIDEO - 1].npads == 0))) {

   857     GstPad *sinkpad;

   858     guint id;

   859 

   860     /* catch deadlocks when we are network buffering in time but the max-limit

   861      * in bytes is hit. */

   862     g_signal_connect (G_OBJECT (preroll), "overrun",

   863         G_CALLBACK (queue_deadlock_check), play_base_bin);

   864 

   865     /* attach pointer to playbasebin */

   866     g_object_set_data (G_OBJECT (preroll), "pbb", play_base_bin);

   867 

   868     /* give updates on queue size */

   869     sinkpad = gst_element_get_pad (preroll, "sink");

   870     id = gst_pad_add_buffer_probe (sinkpad, G_CALLBACK (check_queue), preroll);

   871     GST_DEBUG_OBJECT (play_base_bin, "Attaching probe to pad %s:%s (%p)",

   872         GST_DEBUG_PAD_NAME (sinkpad), sinkpad);

   873     gst_object_unref (sinkpad);

   874     g_object_set_data (G_OBJECT (preroll), "probe", GINT_TO_POINTER (id));

   875 

   876     /* catch eos and flush events so that we can ignore underruns */

   877     id = gst_pad_add_event_probe (sinkpad, G_CALLBACK (check_queue_event),

   878         preroll);

   879     g_object_set_data (G_OBJECT (preroll), "eos_probe", GINT_TO_POINTER (id));

   880 

   881     /* When we connect this queue, it will start running and immediatly

   882      * fire an underrun. */

   883     g_signal_connect (G_OBJECT (preroll), "underrun",

   884         G_CALLBACK (queue_out_of_data), play_base_bin);

   885     /* configure threshold and callbacks */

   886     queue_out_of_data (preroll, play_base_bin);

   887   }

   888 

   889   /* listen for EOS so we can switch groups when one ended. */

   890   preroll_pad = gst_element_get_pad (preroll, "src");

   891   gst_pad_add_event_probe (preroll_pad, G_CALLBACK (probe_triggered), info);

   892   gst_object_unref (preroll_pad);

   893 

   894   /* add to group list */

   895   group->type[type - 1].selector = selector;

   896   group->type[type - 1].preroll = preroll;

   897 

   898   /* figure out where the preroll element should go */

   899   if (type == GST_STREAM_TYPE_TEXT && play_base_bin->subtitle)

   900     target = GST_BIN_CAST (play_base_bin->subtitle);

   901   else

   902     target = GST_BIN_CAST (play_base_bin);

   903 

   904   group->type[type - 1].bin = target;

   905   gst_bin_add (target, selector);

   906   gst_bin_add (target, preroll);

   907 

   908   gst_element_link (selector, preroll);

   909 

   910   /* figure out target state and set */

   911   state = (GST_STATE (play_base_bin) == GST_STATE_PLAYING ?

   912       GST_STATE_PLAYING : GST_STATE_PAUSED);

   913 

   914   gst_element_set_state (selector, state);

   915   gst_element_set_state (preroll, state);

   916 }

   917 

   918 static void

   919 preroll_remove_overrun (GstElement * element, GstPlayBaseBin * play_base_bin)

   920 {

   921   guint overrun_sig;

   922   GObject *obj = G_OBJECT (element);

   923 

   924   overrun_sig = GPOINTER_TO_INT (g_object_get_data (obj, "overrun_signal_id"));

   925   if (overrun_sig) {

   926     GST_LOG_OBJECT (play_base_bin, "removing preroll signal %s",

   927         GST_ELEMENT_NAME (element));

   928     g_signal_handler_disconnect (obj, overrun_sig);

   929     /* We have disconnected this signal, remove the signal_id from the object

   930      * data */

   931     g_object_set_data (obj, "overrun_signal_id", NULL);

   932   }

   933 }

   934 

   935 static void

   936 remove_groups (GstPlayBaseBin * play_base_bin)

   937 {

   938   GROUP_LOCK (play_base_bin);

   939 

   940   /* first destroy the group we were building if any */

   941   if (play_base_bin->building_group) {

   942     group_destroy (play_base_bin->building_group);

   943     play_base_bin->building_group = NULL;

   944   }

   945 

   946   /* remove the queued groups */

   947   g_list_foreach (play_base_bin->queued_groups, (GFunc) group_destroy, NULL);

   948   g_list_free (play_base_bin->queued_groups);

   949   play_base_bin->queued_groups = NULL;

   950 

   951   /* clear subs */

   952   if (play_base_bin->subtitle) {

   953     gst_element_set_state (play_base_bin->subtitle, GST_STATE_NULL);

   954     gst_bin_remove (GST_BIN_CAST (play_base_bin), play_base_bin->subtitle);

   955     play_base_bin->subtitle = NULL;

   956   }

   957 

   958   GROUP_UNLOCK (play_base_bin);

   959 }

   960 

   961 /*

   962  * Add/remove a single stream to current building group.

   963  *

   964  * Must be called with group-lock held.

   965  */

   966 static void

   967 add_stream (GstPlayBaseGroup * group, GstStreamInfo * info)

   968 {

   969   GValue v = { 0, };

   970   GST_DEBUG ("add stream to group %p", group);

   971 

   972   /* keep ref to the group */

   973   g_object_set_data (G_OBJECT (info), "group", group);

   974 

   975   g_value_init (&v, G_TYPE_OBJECT);

   976   g_value_set_object (&v, info);

   977   g_value_array_append (group->streaminfo_value_array, &v);

   978   g_value_unset (&v);

   979   group->streaminfo = g_list_append (group->streaminfo, info);

   980   if (info->type > 0 && info->type <= NUM_TYPES) {

   981     group->type[info->type - 1].npads++;

   982   }

   983 }

   984 

   985 static gboolean

   986 string_arr_has_str (const gchar * values[], const gchar * value)

   987 {

   988   if (values && value) {

   989     while (*values != NULL) {

   990       if (strcmp (value, *values) == 0)

   991         return TRUE;

   992       ++values;

   993     }

   994   }

   995   return FALSE;

   996 }

   997 

   998 /* mime types we are not handling on purpose right now, don't post a

   999  * missing-plugin message for these */

  1000 static const gchar *blacklisted_mimes[] = {

  1001   "video/x-dvd-subpicture", NULL

  1002 };

  1003 

  1004 #define IS_BLACKLISTED_MIME(type) (string_arr_has_str(blacklisted_mimes,type))

  1005 

  1006 static void

  1007 gst_play_base_bin_handle_message_func (GstBin * bin, GstMessage * msg)

  1008 {

  1009   if (gst_is_missing_plugin_message (msg)) {

  1010     gchar *detail;

  1011     guint i;

  1012 

  1013     detail = gst_missing_plugin_message_get_installer_detail (msg);

  1014     for (i = 0; detail != NULL && blacklisted_mimes[i] != NULL; ++i) {

  1015       if (strstr (detail, "|decoder-") && strstr (detail, blacklisted_mimes[i])) {

  1016         GST_LOG_OBJECT (bin, "suppressing message %" GST_PTR_FORMAT, msg);

  1017         gst_message_unref (msg);

  1018         g_free (detail);

  1019         return;

  1020       }

  1021     }

  1022     g_free (detail);

  1023   }

  1024   GST_BIN_CLASS (parent_class)->handle_message (bin, msg);

  1025 }

  1026 

  1027 /*

  1028  * signal fired when an unknown stream is found. We create a new

  1029  * UNKNOWN streaminfo object.

  1030  */

  1031 static void

  1032 unknown_type (GstElement * element, GstPad * pad, GstCaps * caps,

  1033     GstPlayBaseBin * play_base_bin)

  1034 {

  1035   const gchar *type_name;

  1036   GstStreamInfo *info;

  1037   GstPlayBaseGroup *group;

  1038 

  1039   type_name = gst_structure_get_name (gst_caps_get_structure (caps, 0));

  1040   if (type_name && !IS_BLACKLISTED_MIME (type_name)) {

  1041     gchar *capsstr;

  1042 

  1043     capsstr = gst_caps_to_string (caps);

  1044     GST_DEBUG_OBJECT (play_base_bin, "don't know how to handle %s", capsstr);

  1045     /* FIXME, g_message() ? */

  1046     g_message ("don't know how to handle %s", capsstr);

  1047     g_free (capsstr);

  1048   } else {

  1049     /* don't spew stuff to the terminal or send message if it's blacklisted */

  1050     GST_DEBUG_OBJECT (play_base_bin, "media type %s not handled on purpose, "

  1051         "not posting a missing-plugin message on the bus", type_name);

  1052   }

  1053 

  1054   GROUP_LOCK (play_base_bin);

  1055 

  1056   group = get_building_group (play_base_bin);

  1057 

  1058   /* add the stream to the list */

  1059   info = gst_stream_info_new (GST_OBJECT_CAST (pad), GST_STREAM_TYPE_UNKNOWN,

  1060       NULL, caps);

  1061   info->origin = GST_OBJECT_CAST (pad);

  1062   add_stream (group, info);

  1063 

  1064   GROUP_UNLOCK (play_base_bin);

  1065 }

  1066 

  1067 /* add a streaminfo that indicates that the stream is handled by the

  1068  * given element. This usually means that a stream without actual data is

  1069  * produced but one that is sunken by an element. Examples of this are:

  1070  * cdaudio, a hardware decoder/sink, dvd meta bins etc...

  1071  */

  1072 static void

  1073 add_element_stream (GstElement * element, GstPlayBaseBin * play_base_bin)

  1074 {

  1075   GstStreamInfo *info;

  1076   GstPlayBaseGroup *group;

  1077 

  1078   GROUP_LOCK (play_base_bin);

  1079 

  1080   group = get_building_group (play_base_bin);

  1081 

  1082   /* add the stream to the list */

  1083   info =

  1084       gst_stream_info_new (GST_OBJECT_CAST (element), GST_STREAM_TYPE_ELEMENT,

  1085       NULL, NULL);

  1086   info->origin = GST_OBJECT_CAST (element);

  1087   add_stream (group, info);

  1088 

  1089   GROUP_UNLOCK (play_base_bin);

  1090 }

  1091 

  1092 /* when the decoder element signals that no more pads will be generated, we

  1093  * can commit the current group.

  1094  */

  1095 static void

  1096 no_more_pads_full (GstElement * element, gboolean subs,

  1097     GstPlayBaseBin * play_base_bin)

  1098 {

  1099   /* setup phase */

  1100   GST_DEBUG_OBJECT (element, "no more pads, %d pending",

  1101       play_base_bin->pending);

  1102 

  1103   /* nothing pending, we can exit */

  1104   if (play_base_bin->pending == 0)

  1105     return;

  1106 

  1107   /* the object has no pending no_more_pads */

  1108   if (!g_object_get_data (G_OBJECT (element), "pending"))

  1109     return;

  1110 

  1111   g_object_set_data (G_OBJECT (element), "pending", NULL);

  1112 

  1113   play_base_bin->pending--;

  1114 

  1115   GST_DEBUG_OBJECT (element, "remove pending, now %d pending",

  1116       play_base_bin->pending);

  1117 

  1118   if (play_base_bin->pending == 0) {

  1119     /* we can commit this group for playback now */

  1120     group_commit (play_base_bin, play_base_bin->is_stream, subs);

  1121   }

  1122 }

  1123 

  1124 static void

  1125 no_more_pads (GstElement * element, GstPlayBaseBin * play_base_bin)

  1126 {

  1127   no_more_pads_full (element, FALSE, play_base_bin);

  1128 }

  1129 

  1130 static void

  1131 sub_no_more_pads (GstElement * element, GstPlayBaseBin * play_base_bin)

  1132 {

  1133   no_more_pads_full (element, TRUE, play_base_bin);

  1134 }