1 /* GStreamer

     2  * Copyright (C) <2004> 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 

    26 #include <string.h>

    27 #include <gst/gst.h>

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

    29 #include <glib_global.h>

    30 

    31 #include "gstplay-marshal.h"

    32 

    33 /* generic templates */

    34 static GstStaticPadTemplate decoder_bin_sink_template =

    35 GST_STATIC_PAD_TEMPLATE ("sink",

    36     GST_PAD_SINK,

    37     GST_PAD_ALWAYS,

    38     GST_STATIC_CAPS_ANY);

    39 

    40 static GstStaticPadTemplate decoder_bin_src_template =

    41 GST_STATIC_PAD_TEMPLATE ("src%d",

    42     GST_PAD_SRC,

    43     GST_PAD_SOMETIMES,

    44     GST_STATIC_CAPS_ANY);

    45 

    46 GST_DEBUG_CATEGORY_STATIC (gst_decode_bin_debug);

    47 #define GST_CAT_DEFAULT gst_decode_bin_debug

    48 

    49 #define GST_TYPE_DECODE_BIN             (gst_decode_bin_get_type())

    50 #define GST_DECODE_BIN(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DECODE_BIN,GstDecodeBin))

    51 #define GST_DECODE_BIN_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DECODE_BIN,GstDecodeBinClass))

    52 #define GST_IS_DECODE_BIN(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DECODE_BIN))

    53 #define GST_IS_DECODE_BIN_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DECODE_BIN))

    54 

    55 typedef struct _GstDecodeBin GstDecodeBin;

    56 typedef struct _GstDecodeBinClass GstDecodeBinClass;

    57 

    58 struct _GstDecodeBin

    59 {

    60   GstBin bin;                   /* we extend GstBin */

    61 

    62   GstElement *typefind;         /* this holds the typefind object */

    63   GstElement *fakesink;

    64 

    65   GList *dynamics;              /* list of dynamic connections */

    66 

    67   GList *queues;                /* list of demuxer-decoder queues */

    68 

    69   GList *probes;                /* list of PadProbeData */

    70 

    71   GList *factories;             /* factories we can use for selecting elements */

    72   gint numpads;

    73   gint numwaiting;

    74 

    75   gboolean have_type;

    76   guint have_type_id;           /* signal id for the typefind element */

    77 

    78   gboolean shutting_down;       /* stop pluggin if we're shutting down */

    79 

    80   GType queue_type;             /* store the GType of queues, to aid in recognising them */

    81 

    82   GMutex *cb_mutex;             /* Mutex for multi-threaded callbacks, such as removing the fakesink */

    83 };

    84 

    85 struct _GstDecodeBinClass

    86 {

    87   GstBinClass parent_class;

    88 

    89   /* signal we fire when a new pad has been decoded into raw audio/video */

    90   void (*new_decoded_pad) (GstElement * element, GstPad * pad, gboolean last);

    91   /* signal we fire when a pad has been removed */

    92   void (*removed_decoded_pad) (GstElement * element, GstPad * pad);

    93   /* signal fired when we found a pad that we cannot decode */

    94   void (*unknown_type) (GstElement * element, GstPad * pad, GstCaps * caps);

    95 };

    96 

    97 /* signals */

    98 enum

    99 {

   100   SIGNAL_NEW_DECODED_PAD,

   101   SIGNAL_REMOVED_DECODED_PAD,

   102   SIGNAL_UNKNOWN_TYPE,

   103   SIGNAL_REDIRECT,

   104   LAST_SIGNAL

   105 };

   106 

   107 

   108 typedef struct

   109 {

   110   GstPad *pad;

   111   gulong sigid;

   112   gboolean done;

   113 } PadProbeData;

   114 

   115 /* this structure is created for all dynamic pads that could get created

   116  * at runtime */

   117 typedef struct

   118 {

   119   GstDecodeBin *decode_bin;     /* pointer to ourself */

   120 

   121   GstElement *element;          /* the element sending the signal */

   122   gint np_sig_id;               /* signal id of new_pad */

   123   gint nmp_sig_id;              /* signal id of no_more_pads */

   124 

   125   GstPad *pad;                  /* the pad sending the signal */

   126   gint caps_sig_id;             /* signal id of caps */

   127 }

   128 GstDynamic;

   129 

   130 static void gst_decode_bin_class_init (GstDecodeBinClass * klass);

   131 static void gst_decode_bin_init (GstDecodeBin * decode_bin);

   132 static void gst_decode_bin_dispose (GObject * object);

   133 static void gst_decode_bin_finalize (GObject * object);

   134 

   135 static GstStateChangeReturn gst_decode_bin_change_state (GstElement * element,

   136     GstStateChange transition);

   137 

   138 static gboolean add_fakesink (GstDecodeBin * decode_bin);

   139 static void remove_fakesink (GstDecodeBin * decode_bin);

   140 

   141 static void dynamic_free (GstDynamic * dyn);

   142 static void free_dynamics (GstDecodeBin * decode_bin);

   143 static void type_found (GstElement * typefind, guint probability,

   144     GstCaps * caps, GstDecodeBin * decode_bin);

   145 static GstElement *try_to_link_1 (GstDecodeBin * decode_bin,

   146     GstElement * origelement, GstPad * pad, GList * factories);

   147 static void close_link (GstElement * element, GstDecodeBin * decode_bin);

   148 static void close_pad_link (GstElement * element, GstPad * pad,

   149     GstCaps * caps, GstDecodeBin * decode_bin, gboolean more);

   150 static void unlinked (GstPad * pad, GstPad * peerpad,

   151     GstDecodeBin * decode_bin);

   152 static void new_pad (GstElement * element, GstPad * pad, GstDynamic * dynamic);

   153 static void no_more_pads (GstElement * element, GstDynamic * dynamic);

   154 static void new_caps (GstPad * pad, GParamSpec * unused, GstDynamic * dynamic);

   155 

   156 static void queue_filled_cb (GstElement * queue, GstDecodeBin * decode_bin);

   157 static void queue_underrun_cb (GstElement * queue, GstDecodeBin * decode_bin);

   158 

   159 static GstElementClass *parent_class;

   160 static guint gst_decode_bin_signals[LAST_SIGNAL] = { 0 };

   161 

   162 static const GstElementDetails gst_decode_bin_details =

   163 GST_ELEMENT_DETAILS ("Decoder Bin",

   164     "Generic/Bin/Decoder",

   165     "Autoplug and decode to raw media",

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

   167 

   168 

   169 static GType

   170 gst_decode_bin_get_type (void)

   171 {

   172   static GType gst_decode_bin_type = 0;

   173 

   174   if (!gst_decode_bin_type) {

   175     static const GTypeInfo gst_decode_bin_info = {

   176       sizeof (GstDecodeBinClass),

   177       NULL,

   178       NULL,

   179       (GClassInitFunc) gst_decode_bin_class_init,

   180       NULL,

   181       NULL,

   182       sizeof (GstDecodeBin),

   183       0,

   184       (GInstanceInitFunc) gst_decode_bin_init,

   185       NULL

   186     };

   187 

   188     gst_decode_bin_type =

   189         g_type_register_static (GST_TYPE_BIN, "GstDecodeBin",

   190         &gst_decode_bin_info, 0);

   191   }

   192 

   193   return gst_decode_bin_type;

   194 }

   195 

   196 static void

   197 gst_decode_bin_class_init (GstDecodeBinClass * klass)

   198 {

   199   GObjectClass *gobject_klass;

   200   GstElementClass *gstelement_klass;

   201   GstBinClass *gstbin_klass;

   202 

   203   gobject_klass = (GObjectClass *) klass;

   204   gstelement_klass = (GstElementClass *) klass;

   205   gstbin_klass = (GstBinClass *) klass;

   206 

   207   parent_class = g_type_class_peek_parent (klass);

   208 

   209   gst_decode_bin_signals[SIGNAL_NEW_DECODED_PAD] =

   210       g_signal_new ("new-decoded-pad", G_TYPE_FROM_CLASS (klass),

   211       G_SIGNAL_RUN_LAST,

   212       G_STRUCT_OFFSET (GstDecodeBinClass, new_decoded_pad), NULL, NULL,

   213       gst_play_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, GST_TYPE_PAD,

   214       G_TYPE_BOOLEAN);

   215   gst_decode_bin_signals[SIGNAL_REMOVED_DECODED_PAD] =

   216       g_signal_new ("removed-decoded-pad", G_TYPE_FROM_CLASS (klass),

   217       G_SIGNAL_RUN_LAST,

   218       G_STRUCT_OFFSET (GstDecodeBinClass, removed_decoded_pad), NULL, NULL,

   219       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);

   220   gst_decode_bin_signals[SIGNAL_UNKNOWN_TYPE] =

   221       g_signal_new ("unknown-type", G_TYPE_FROM_CLASS (klass),

   222       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, unknown_type),

   223       NULL, NULL, gst_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2,

   224       GST_TYPE_PAD, GST_TYPE_CAPS);

   225 

   226   gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_decode_bin_dispose);

   227   gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_decode_bin_finalize);

   228 

   229   gst_element_class_add_pad_template (gstelement_klass,

   230       gst_static_pad_template_get (&decoder_bin_sink_template));

   231   gst_element_class_add_pad_template (gstelement_klass,

   232       gst_static_pad_template_get (&decoder_bin_src_template));

   233 

   234   gst_element_class_set_details (gstelement_klass, &gst_decode_bin_details);

   235 

   236   gstelement_klass->change_state =

   237       GST_DEBUG_FUNCPTR (gst_decode_bin_change_state);

   238 }

   239 

   240 /* check if the bin is dynamic.

   241  *

   242  * If there are no outstanding dynamic connections, the bin is

   243  * considered to be non-dynamic.

   244  */

   245 static gboolean

   246 gst_decode_bin_is_dynamic (GstDecodeBin * decode_bin)

   247 {

   248   return decode_bin->dynamics != NULL;

   249 }

   250 

   251 /* the filter function for selecting the elements we can use in

   252  * autoplugging */

   253 static gboolean

   254 gst_decode_bin_factory_filter (GstPluginFeature * feature,

   255     GstDecodeBin * decode_bin)

   256 {

   257   guint rank;

   258   const gchar *klass;

   259 

   260   /* we only care about element factories */

   261   if (!GST_IS_ELEMENT_FACTORY (feature))

   262     return FALSE;

   263 

   264   klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));

   265   /* only demuxers, decoders and parsers can play */

   266   if (strstr (klass, "Demux") == NULL &&

   267       strstr (klass, "Decoder") == NULL && strstr (klass, "Parse") == NULL &&

   268       strstr (klass, "Depayloader") == NULL) {

   269     return FALSE;

   270   }

   271 

   272   /* only select elements with autoplugging rank */

   273   rank = gst_plugin_feature_get_rank (feature);

   274   if (rank < GST_RANK_MARGINAL)

   275     return FALSE;

   276 

   277   return TRUE;

   278 }

   279 

   280 /* function used to sort element features */

   281 static gint

   282 compare_ranks (GstPluginFeature * f1, GstPluginFeature * f2)

   283 {

   284   gint diff;

   285   const gchar *rname1, *rname2;

   286 

   287   diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);

   288   if (diff != 0)

   289     return diff;

   290 

   291   rname1 = gst_plugin_feature_get_name (f1);

   292   rname2 = gst_plugin_feature_get_name (f2);

   293 

   294   diff = strcmp (rname2, rname1);

   295 

   296   return diff;

   297 }

   298 

   299 static void

   300 print_feature (GstPluginFeature * feature)

   301 {

   302   const gchar *rname;

   303 

   304   rname = gst_plugin_feature_get_name (feature);

   305 

   306   GST_DEBUG ("%s", rname);

   307 }

   308 

   309 static void

   310 gst_decode_bin_init (GstDecodeBin * decode_bin)

   311 {

   312   GList *factories;

   313 

   314   decode_bin->cb_mutex = g_mutex_new ();

   315 

   316   /* first filter out the interesting element factories */

   317   factories = gst_default_registry_feature_filter (

   318       (GstPluginFeatureFilter) gst_decode_bin_factory_filter,

   319       FALSE, decode_bin);

   320 

   321   /* sort them according to their ranks */

   322   decode_bin->factories = g_list_sort (factories, (GCompareFunc) compare_ranks);

   323   /* do some debugging */

   324   g_list_foreach (decode_bin->factories, (GFunc) print_feature, NULL);

   325 

   326   /* we create the typefind element only once */

   327   decode_bin->typefind = gst_element_factory_make ("typefind", "typefind");

   328   if (!decode_bin->typefind) {

   329     g_warning ("can't find typefind element, decodebin will not work");

   330   } else {

   331     GstPad *pad, *gpad;

   332 

   333     /* add the typefind element */

   334     if (!gst_bin_add (GST_BIN (decode_bin), decode_bin->typefind)) {

   335       g_warning ("Could not add typefind element, decodebin will not work");

   336       gst_object_unref (decode_bin->typefind);

   337       decode_bin->typefind = NULL;

   338     }

   339 

   340     /* get the sinkpad */

   341     pad = gst_element_get_pad (decode_bin->typefind, "sink");

   342 

   343     /* ghost the sink pad to ourself */

   344     gpad = gst_ghost_pad_new ("sink", pad);

   345     gst_pad_set_active (gpad, TRUE);

   346     gst_element_add_pad (GST_ELEMENT (decode_bin), gpad);

   347 

   348     gst_object_unref (pad);

   349 

   350     /* connect a signal to find out when the typefind element found

   351      * a type */

   352     decode_bin->have_type_id =

   353         g_signal_connect (G_OBJECT (decode_bin->typefind), "have_type",

   354         G_CALLBACK (type_found), decode_bin);

   355   }

   356   add_fakesink (decode_bin);

   357 

   358   decode_bin->dynamics = NULL;

   359   decode_bin->queues = NULL;

   360   decode_bin->probes = NULL;

   361 }

   362 

   363 static void

   364 gst_decode_bin_dispose (GObject * object)

   365 {

   366   GstDecodeBin *decode_bin;

   367 

   368   decode_bin = GST_DECODE_BIN (object);

   369 

   370   if (decode_bin->factories)

   371     gst_plugin_feature_list_free (decode_bin->factories);

   372   decode_bin->factories = NULL;

   373 

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

   375 

   376   /* our parent dispose might trigger new signals when pads are unlinked

   377    * etc. clean up the mess here. */

   378   /* FIXME do proper cleanup when going to NULL */

   379   free_dynamics (decode_bin);

   380 }

   381 

   382 static void

   383 gst_decode_bin_finalize (GObject * object)

   384 {

   385   GstDecodeBin *decode_bin = GST_DECODE_BIN (object);

   386 

   387   g_mutex_free (decode_bin->cb_mutex);

   388 

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

   390 }

   391 

   392 struct DynFind

   393 {

   394   GstElement *elem;

   395   GstPad *pad;

   396 };

   397 

   398 static gint

   399 find_dynamic (GstDynamic * dyn, struct DynFind *info)

   400 {

   401   if (dyn->element == info->elem && dyn->pad == info->pad)

   402     return 0;

   403   return 1;

   404 }

   405 

   406 /* Add either an element (for dynamic pads/pad-added watching) or a

   407  * pad (for delayed caps/notify::caps watching) to the dynamic list,

   408  * taking care to ignore repeat entries so we don't end up handling a

   409  * pad twice, for example */

   410 static void

   411 dynamic_add (GstElement * element, GstPad * pad, GstDecodeBin * decode_bin)

   412 {

   413   GstDynamic *dyn;

   414   struct DynFind find_info;

   415   GList *found;

   416 

   417   g_return_if_fail (element != NULL);

   418 

   419   /* do a search that this entry doesn't already exist */

   420   find_info.elem = element;

   421   find_info.pad = pad;

   422   found = g_list_find_custom (decode_bin->dynamics, &find_info,

   423       (GCompareFunc) find_dynamic);

   424   if (found != NULL)

   425     goto exit;

   426 

   427   /* take refs */

   428   dyn = g_new0 (GstDynamic, 1);

   429   dyn->element = gst_object_ref (element);

   430   dyn->decode_bin = gst_object_ref (decode_bin);

   431   if (pad) {

   432     dyn->pad = gst_object_ref (pad);

   433     GST_DEBUG_OBJECT (decode_bin, "dynamic create for pad %" GST_PTR_FORMAT,

   434         pad);

   435     dyn->caps_sig_id = g_signal_connect (G_OBJECT (pad), "notify::caps",

   436         G_CALLBACK (new_caps), dyn);

   437   } else {

   438     GST_DEBUG_OBJECT (decode_bin, "dynamic create for element %"

   439         GST_PTR_FORMAT, element);

   440     dyn->np_sig_id = g_signal_connect (G_OBJECT (element), "pad-added",

   441         G_CALLBACK (new_pad), dyn);

   442     dyn->nmp_sig_id = g_signal_connect (G_OBJECT (element), "no-more-pads",

   443         G_CALLBACK (no_more_pads), dyn);

   444   }

   445 

   446   /* and add this element to the dynamic elements */

   447   decode_bin->dynamics = g_list_prepend (decode_bin->dynamics, dyn);

   448 

   449   return;

   450 exit:

   451   if (element) {

   452     GST_DEBUG_OBJECT (decode_bin, "Dynamic element already added: %"

   453         GST_PTR_FORMAT, element);

   454   } else {

   455     GST_DEBUG_OBJECT (decode_bin, "Dynamic pad already added: %"

   456         GST_PTR_FORMAT, pad);

   457   }

   458 }

   459 

   460 static void

   461 dynamic_free (GstDynamic * dyn)

   462 {

   463   GST_DEBUG_OBJECT (dyn->decode_bin, "dynamic free");

   464 

   465   /* disconnect signals */

   466   if (dyn->np_sig_id)

   467     g_signal_handler_disconnect (G_OBJECT (dyn->element), dyn->np_sig_id);

   468   if (dyn->nmp_sig_id)

   469     g_signal_handler_disconnect (G_OBJECT (dyn->element), dyn->nmp_sig_id);

   470   if (dyn->caps_sig_id)

   471     g_signal_handler_disconnect (G_OBJECT (dyn->pad), dyn->caps_sig_id);

   472 

   473   if (dyn->pad)

   474     gst_object_unref (dyn->pad);

   475   dyn->pad = NULL;

   476   if (dyn->element)

   477     gst_object_unref (dyn->element);

   478   dyn->element = NULL;

   479 

   480   gst_object_unref (dyn->decode_bin);

   481   dyn->decode_bin = NULL;

   482 

   483   g_free (dyn);

   484 }

   485 

   486 static void

   487 free_dynamics (GstDecodeBin * decode_bin)

   488 {

   489   GList *dyns;

   490 

   491   for (dyns = decode_bin->dynamics; dyns; dyns = g_list_next (dyns)) {

   492     GstDynamic *dynamic = (GstDynamic *) dyns->data;

   493 

   494     dynamic_free (dynamic);

   495   }

   496   g_list_free (decode_bin->dynamics);

   497   decode_bin->dynamics = NULL;

   498 }

   499 

   500 /* this function runs through the element factories and returns a list

   501  * of all elements that are able to sink the given caps

   502  */

   503 static GList *

   504 find_compatibles (GstDecodeBin * decode_bin, const GstCaps * caps)

   505 {

   506   GList *factories;

   507   GList *to_try = NULL;

   508 

   509   /* loop over all the factories */

   510   for (factories = decode_bin->factories; factories;

   511       factories = g_list_next (factories)) {

   512     GstElementFactory *factory = GST_ELEMENT_FACTORY (factories->data);

   513     const GList *templates;

   514     GList *walk;

   515 

   516     /* get the templates from the element factory */

   517     templates = gst_element_factory_get_static_pad_templates (factory);

   518     for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {

   519       GstStaticPadTemplate *templ = walk->data;

   520 

   521       /* we only care about the sink templates */

   522       if (templ->direction == GST_PAD_SINK) {

   523         GstCaps *intersect;

   524         GstCaps *tmpl_caps;

   525 

   526         /* try to intersect the caps with the caps of the template */

   527         tmpl_caps = gst_static_caps_get (&templ->static_caps);

   528 

   529         intersect = gst_caps_intersect (caps, tmpl_caps);

   530         gst_caps_unref (tmpl_caps);

   531 

   532         /* check if the intersection is empty */

   533         if (!gst_caps_is_empty (intersect)) {

   534           /* non empty intersection, we can use this element */

   535           to_try = g_list_prepend (to_try, factory);

   536           gst_caps_unref (intersect);

   537           break;

   538         }

   539         gst_caps_unref (intersect);

   540       }

   541     }

   542   }

   543   to_try = g_list_reverse (to_try);

   544 

   545   return to_try;

   546 }

   547 

   548 static gboolean

   549 mimetype_is_raw (const gchar * mimetype)

   550 {

   551   return g_str_has_prefix (mimetype, "video/x-raw") ||

   552       g_str_has_prefix (mimetype, "audio/x-raw") ||

   553       g_str_has_prefix (mimetype, "text/plain") ||

   554       g_str_has_prefix (mimetype, "text/x-pango-markup");

   555 }

   556 

   557 static void

   558 free_pad_probes (GstDecodeBin * decode_bin)

   559 {

   560   GList *tmp;

   561 

   562   /* Remove pad probes */

   563   for (tmp = decode_bin->probes; tmp; tmp = g_list_next (tmp)) {

   564     PadProbeData *data = (PadProbeData *) tmp->data;

   565 

   566     gst_pad_remove_data_probe (data->pad, data->sigid);

   567     g_free (data);

   568   }

   569   g_list_free (decode_bin->probes);

   570   decode_bin->probes = NULL;

   571 }

   572 

   573 static gboolean

   574 add_fakesink (GstDecodeBin * decode_bin)

   575 {

   576   if (decode_bin->fakesink != NULL)

   577     return TRUE;

   578 

   579   g_mutex_lock (decode_bin->cb_mutex);

   580 

   581   decode_bin->fakesink = gst_element_factory_make ("fakesink", "fakesink");

   582   if (!decode_bin->fakesink)

   583     goto no_fakesink;

   584 

   585   /* hacky, remove sink flag, we don't want our decodebin to become a sink

   586    * just because we add a fakesink element to make us ASYNC */

   587   GST_OBJECT_FLAG_UNSET (decode_bin->fakesink, GST_ELEMENT_IS_SINK);

   588 

   589   /* takes ownership */

   590   if (!gst_bin_add (GST_BIN (decode_bin), decode_bin->fakesink)) {

   591     g_warning ("Could not add fakesink element, decodebin will not work");

   592     gst_object_unref (decode_bin->fakesink);

   593     decode_bin->fakesink = NULL;

   594   }

   595   g_mutex_unlock (decode_bin->cb_mutex);

   596   return TRUE;

   597 

   598   /* ERRORS */

   599 no_fakesink:

   600   {

   601     g_warning ("can't find fakesink element, decodebin will not work");

   602     g_mutex_unlock (decode_bin->cb_mutex);

   603     return FALSE;

   604   }

   605 }

   606 

   607 static void

   608 remove_fakesink (GstDecodeBin * decode_bin)

   609 {

   610   gboolean removed_fakesink = FALSE;

   611 

   612   if (decode_bin->fakesink == NULL)

   613     return;

   614 

   615   g_mutex_lock (decode_bin->cb_mutex);

   616   if (decode_bin->fakesink) {

   617     GST_DEBUG_OBJECT (decode_bin, "Removing fakesink and marking state dirty");

   618 

   619     /* setting the state to NULL is never async */

   620     gst_element_set_state (decode_bin->fakesink, GST_STATE_NULL);

   621     gst_bin_remove (GST_BIN (decode_bin), decode_bin->fakesink);

   622     decode_bin->fakesink = NULL;

   623 

   624     removed_fakesink = TRUE;

   625   }

   626   g_mutex_unlock (decode_bin->cb_mutex);

   627 

   628   if (removed_fakesink) {

   629     free_pad_probes (decode_bin);

   630   }

   631 }

   632 

   633 /* this should be implemented with _pad_block() */

   634 static gboolean

   635 pad_probe (GstPad * pad, GstMiniObject * data, GstDecodeBin * decode_bin)

   636 {

   637   GList *tmp;

   638   gboolean alldone = TRUE;

   639 

   640   for (tmp = decode_bin->probes; tmp; tmp = g_list_next (tmp)) {

   641     PadProbeData *pdata = (PadProbeData *) tmp->data;

   642 

   643     if (pdata->pad == pad) {

   644       if (GST_IS_BUFFER (data)) {

   645         if (!pdata->done)

   646           decode_bin->numwaiting--;

   647         pdata->done = TRUE;

   648       } else if (GST_IS_EVENT (data) &&

   649           ((GST_EVENT_TYPE (data) == GST_EVENT_EOS) ||

   650               (GST_EVENT_TYPE (data) == GST_EVENT_TAG) ||

   651               (GST_EVENT_TYPE (data) == GST_EVENT_FLUSH_START))) {

   652         /* FIXME, what about NEWSEGMENT? really, use _pad_block()... */

   653         if (!pdata->done)

   654           decode_bin->numwaiting--;

   655         pdata->done = TRUE;

   656       }

   657     }

   658 

   659     if (!(pdata->done)) {

   660       GST_LOG_OBJECT (decode_bin, "Pad probe on pad %" GST_PTR_FORMAT

   661           " but pad %" GST_PTR_FORMAT " still needs data.", pad, pdata->pad);

   662       alldone = FALSE;

   663     }

   664   }

   665   if (alldone)

   666     remove_fakesink (decode_bin);

   667   return TRUE;

   668 }

   669 

   670 /* given a pad and a caps from an element, find the list of elements

   671  * that could connect to the pad

   672  *

   673  * If the pad has a raw format, this function will create a ghostpad

   674  * for the pad onto the decodebin.

   675  *

   676  * If no compatible elements could be found, this function will signal

   677  * the unknown_type signal.

   678  */

   679 static void

   680 close_pad_link (GstElement * element, GstPad * pad, GstCaps * caps,

   681     GstDecodeBin * decode_bin, gboolean more)

   682 {

   683   GstStructure *structure;

   684   const gchar *mimetype;

   685   gchar *padname;

   686   gint diff;

   687 

   688   padname = gst_pad_get_name (pad);

   689   diff = strncmp (padname, "current_", 8);

   690   g_free (padname);

   691 

   692   /* hack.. ignore current pads */

   693   if (!diff)

   694     return;

   695 

   696   /* the caps is empty, this means the pad has no type, we can only

   697    * decide to fire the unknown_type signal. */

   698   if (caps == NULL || gst_caps_is_empty (caps))

   699     goto unknown_type;

   700 

   701   /* the caps is any, this means the pad can be anything and

   702    * we don't know yet */

   703   if (gst_caps_is_any (caps))

   704     goto dont_know_yet;

   705 

   706   GST_LOG_OBJECT (element, "trying to close %" GST_PTR_FORMAT, caps);

   707 

   708   /* FIXME, iterate over more structures? I guess it is possible that

   709    * this pad has some encoded and some raw pads. This code will fail

   710    * then if the first structure is not the raw type... */

   711   structure = gst_caps_get_structure (caps, 0);

   712   mimetype = gst_structure_get_name (structure);

   713 

   714   /* first see if this is raw. If the type is raw, we can

   715    * create a ghostpad for this pad. It's possible that the caps are not

   716    * fixed. */

   717   if (mimetype_is_raw (mimetype)) {

   718     gchar *padname;

   719     GstPad *ghost;

   720     PadProbeData *data;

   721 

   722     /* make a unique name for this new pad */

   723     padname = g_strdup_printf ("src%d", decode_bin->numpads);

   724     decode_bin->numpads++;

   725 

   726     /* make it a ghostpad */

   727     ghost = gst_ghost_pad_new (padname, pad);

   728     gst_pad_set_active (ghost, TRUE);

   729     gst_element_add_pad (GST_ELEMENT (decode_bin), ghost);

   730 

   731     data = g_new0 (PadProbeData, 1);

   732     data->pad = pad;

   733     data->done = FALSE;

   734 

   735     /* FIXME, use _pad_block() */

   736     data->sigid = gst_pad_add_data_probe (pad, G_CALLBACK (pad_probe),

   737         decode_bin);

   738     decode_bin->numwaiting++;

   739 

   740     decode_bin->probes = g_list_append (decode_bin->probes, data);

   741 

   742     GST_LOG_OBJECT (element, "closed pad %s", padname);

   743 

   744     /* our own signal with an extra flag that this is the only pad */

   745     GST_DEBUG_OBJECT (decode_bin, "emitting new-decoded-pad");

   746     g_signal_emit (G_OBJECT (decode_bin),

   747         gst_decode_bin_signals[SIGNAL_NEW_DECODED_PAD], 0, ghost, !more);

   748     GST_DEBUG_OBJECT (decode_bin, "emitted new-decoded-pad");

   749 

   750     g_free (padname);

   751   } else {

   752     GList *to_try;

   753 

   754     /* if the caps has many types, we need to delay */

   755     if (!gst_caps_is_fixed (caps))

   756       goto many_types;

   757 

   758     /* continue plugging, first find all compatible elements */

   759     to_try = find_compatibles (decode_bin, caps);

   760     if (to_try == NULL)

   761       /* no compatible elements, we cannot go on */

   762       goto unknown_type;

   763 

   764     if (try_to_link_1 (decode_bin, element, pad, to_try) == NULL) {

   765       g_list_free (to_try);

   766       GST_LOG_OBJECT (pad, "none of the allegedly available elements usable");

   767       goto unknown_type;

   768     }

   769 

   770     /* can free the list again now */

   771     g_list_free (to_try);

   772   }

   773   return;

   774 

   775   /* ERRORS */

   776 unknown_type:

   777   {

   778     GST_LOG_OBJECT (pad, "unknown type found, fire signal");

   779     g_signal_emit (G_OBJECT (decode_bin),

   780         gst_decode_bin_signals[SIGNAL_UNKNOWN_TYPE], 0, pad, caps);

   781 

   782     gst_element_post_message (GST_ELEMENT_CAST (decode_bin),

   783         gst_missing_decoder_message_new (GST_ELEMENT_CAST (decode_bin), caps));

   784 

   785     if (element == decode_bin->typefind) {

   786       gchar *desc;

   787 

   788       desc = gst_pb_utils_get_decoder_description (caps);

   789       GST_ELEMENT_ERROR (decode_bin, STREAM, CODEC_NOT_FOUND,

   790           (_("A %s plugin is required to play this stream, but not installed."),

   791               desc),

   792           ("No decoder to handle media type '%s'",

   793               gst_structure_get_name (gst_caps_get_structure (caps, 0))));

   794       g_free (desc);

   795     }

   796 

   797     return;

   798   }

   799 dont_know_yet:

   800   {

   801     GST_LOG_OBJECT (pad, "type is not known yet");

   802     goto setup_caps_delay;

   803   }

   804 many_types:

   805   {

   806     GST_LOG_OBJECT (pad, "many possible types");

   807     goto setup_caps_delay;

   808   }

   809 setup_caps_delay:

   810   {

   811     GST_LOG_OBJECT (pad, "setting up a delayed link");

   812     dynamic_add (element, pad, decode_bin);

   813     return;

   814   }

   815 }

   816 

   817 /* Decide whether an element is a demuxer based on the

   818  * klass and number/type of src pad templates it has */

   819 static gboolean

   820 is_demuxer_element (GstElement * srcelement)

   821 {

   822   GstElementFactory *srcfactory;

   823   GstElementClass *elemclass;

   824   GList *walk;

   825   const gchar *klass;

   826   gint potential_src_pads = 0;

   827 

   828   srcfactory = gst_element_get_factory (srcelement);

   829   klass = gst_element_factory_get_klass (srcfactory);

   830 

   831   /* Can't be a demuxer unless it has Demux in the klass name */

   832   if (klass == NULL || !strstr (klass, "Demux"))

   833     return FALSE;

   834 

   835   /* Walk the src pad templates and count how many the element

   836    * might produce */

   837   elemclass = GST_ELEMENT_GET_CLASS (srcelement);

   838 

   839   walk = gst_element_class_get_pad_template_list (elemclass);

   840   while (walk != NULL) {

   841     GstPadTemplate *templ;

   842 

   843     templ = (GstPadTemplate *) walk->data;

   844     if (GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_SRC) {

   845       switch (GST_PAD_TEMPLATE_PRESENCE (templ)) {

   846         case GST_PAD_ALWAYS:

   847         case GST_PAD_SOMETIMES:

   848           if (strstr (GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "%"))

   849             potential_src_pads += 2;    /* Might make multiple pads */

   850           else

   851             potential_src_pads += 1;

   852           break;

   853         case GST_PAD_REQUEST:

   854           potential_src_pads += 2;

   855           break;

   856       }

   857     }

   858     walk = g_list_next (walk);

   859   }

   860 

   861   if (potential_src_pads < 2)

   862     return FALSE;

   863 

   864   return TRUE;

   865 }

   866 

   867 /*

   868  * given a list of element factories, try to link one of the factories

   869  * to the given pad.

   870  *

   871  * The function returns the element that was successfully linked to the

   872  * pad.

   873  */

   874 static GstElement *

   875 try_to_link_1 (GstDecodeBin * decode_bin, GstElement * srcelement, GstPad * pad,

   876     GList * factories)

   877 {

   878   GList *walk;

   879   GstElement *result = NULL;

   880   gboolean isdemux = FALSE;

   881   GstPad *queuesinkpad = NULL, *queuesrcpad = NULL;

   882   GstElement *queue = NULL;

   883   GstPad *usedsrcpad = pad;

   884 

   885   /* Check if the parent of the src pad is a demuxer */

   886   isdemux = is_demuxer_element (srcelement);

   887 

   888   if (isdemux && factories != NULL) {

   889     GstPadLinkReturn dqlink;

   890 

   891     /* Insert a queue between demuxer and decoder */

   892     GST_DEBUG_OBJECT (decode_bin,

   893         "Element %s is a demuxer, inserting a queue",

   894         GST_OBJECT_NAME (srcelement));

   895     queue = gst_element_factory_make ("queue", NULL);

   896     decode_bin->queue_type = G_OBJECT_TYPE (queue);

   897 

   898     g_object_set (G_OBJECT (queue), "max-size-buffers", 0, NULL);

   899     g_object_set (G_OBJECT (queue), "max-size-time", G_GINT64_CONSTANT (0),

   900         NULL);

   901     g_object_set (G_OBJECT (queue), "max-size-bytes", 8192, NULL);

   902     gst_bin_add (GST_BIN (decode_bin), queue);

   903     gst_element_set_state (queue, GST_STATE_READY);

   904     queuesinkpad = gst_element_get_pad (queue, "sink");

   905     usedsrcpad = queuesrcpad = gst_element_get_pad (queue, "src");

   906 

   907     dqlink = gst_pad_link (pad, queuesinkpad);

   908     g_return_val_if_fail (dqlink == GST_PAD_LINK_OK, NULL);

   909   }

   910 

   911   /* loop over the factories */

   912   for (walk = factories; walk; walk = g_list_next (walk)) {

   913     GstElementFactory *factory = GST_ELEMENT_FACTORY (walk->data);

   914     GstElement *element;

   915     GstPadLinkReturn ret;

   916     GstPad *sinkpad;

   917 

   918     GST_DEBUG_OBJECT (decode_bin, "trying to link %s",

   919         gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));

   920 

   921     /* make an element from the factory first */

   922     if ((element = gst_element_factory_create (factory, NULL)) == NULL) {

   923       /* hmm, strange. Like with all things in life, let's move on.. */

   924       GST_WARNING_OBJECT (decode_bin, "could not create an element from %s",

   925           gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));

   926       continue;

   927     }

   928 

   929     /* try to link the given pad to a sinkpad */

   930     /* FIXME, find the sinkpad by looping over the pads instead of

   931      * looking it up by name */

   932     if ((sinkpad = gst_element_get_pad (element, "sink")) == NULL) {

   933       /* if no pad is found we can't do anything */

   934       GST_WARNING_OBJECT (decode_bin, "could not find sinkpad in element");

   935       continue;

   936     }

   937 

   938     /* now add the element to the bin first */

   939     GST_DEBUG_OBJECT (decode_bin, "adding %s", GST_OBJECT_NAME (element));

   940     gst_bin_add (GST_BIN (decode_bin), element);

   941 

   942     /* set to READY first so it is ready, duh. */

   943     if (gst_element_set_state (element,

   944             GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {

   945       GST_WARNING_OBJECT (decode_bin, "Couldn't set %s to READY",

   946           GST_ELEMENT_NAME (element));

   947       /* get rid of the sinkpad */

   948       gst_object_unref (sinkpad);

   949       /* this element did not work, remove it again and continue trying

   950        * other elements, the element will be disposed. */

   951       /* FIXME: shouldn't we do this before adding it to the bin so that no

   952        * error messages get through to the app? (tpm) */

   953       gst_bin_remove (GST_BIN (decode_bin), element);

   954       continue;

   955     }

   956 

   957     if ((ret = gst_pad_link (usedsrcpad, sinkpad)) != GST_PAD_LINK_OK) {

   958       GST_DEBUG_OBJECT (decode_bin, "link failed on pad %s:%s, reason %d",

   959           GST_DEBUG_PAD_NAME (pad), ret);

   960       /* get rid of the sinkpad */

   961       gst_object_unref (sinkpad);

   962       /* this element did not work, remove it again and continue trying

   963        * other elements, the element will be disposed. */

   964       gst_element_set_state (element, GST_STATE_NULL);

   965       gst_bin_remove (GST_BIN (decode_bin), element);

   966     } else {

   967       guint sig;

   968 

   969       GST_DEBUG_OBJECT (decode_bin, "linked on pad %s:%s",

   970           GST_DEBUG_PAD_NAME (usedsrcpad));

   971 

   972       /* configure the queue some more */

   973       if (queue != NULL) {

   974         decode_bin->queues = g_list_append (decode_bin->queues, queue);

   975         g_signal_connect (G_OBJECT (queue),

   976             "overrun", G_CALLBACK (queue_filled_cb), decode_bin);

   977         g_signal_connect (G_OBJECT (queue),

   978             "underrun", G_CALLBACK (queue_underrun_cb), decode_bin);

   979       }

   980 

   981       /* The link worked, now figure out what it was that we connected */

   982 

   983       /* make sure we catch unlink signals */

   984       sig = g_signal_connect (G_OBJECT (pad), "unlinked",

   985           G_CALLBACK (unlinked), decode_bin);

   986 

   987       /* now that we added the element we can try to continue autoplugging

   988        * on it until we have a raw type */

   989       close_link (element, decode_bin);

   990 

   991       /* change the state of the element to that of the parent */

   992       if ((gst_element_set_state (element,

   993                   GST_STATE_PAUSED)) == GST_STATE_CHANGE_FAILURE) {

   994         GST_WARNING_OBJECT (decode_bin, "Couldn't set %s to PAUSED",

   995             GST_ELEMENT_NAME (element));

   996         gst_element_set_state (element, GST_STATE_NULL);

   997         gst_bin_remove (GST_BIN (decode_bin), element);

   998         continue;

   999       }

  1000 

  1001       result = element;

  1002 

  1003       /* get rid of the sinkpad now */

  1004       gst_object_unref (sinkpad);

  1005 

  1006       /* Set the queue to paused and set the pointer to NULL so we don't

  1007        * remove it below */

  1008       if (queue != NULL) {

  1009         gst_element_set_state (queue, GST_STATE_PAUSED);

  1010         queue = NULL;

  1011         gst_object_unref (queuesrcpad);

  1012         gst_object_unref (queuesinkpad);

  1013       }

  1014 

  1015       /* and exit */

  1016       goto done;

  1017     }

  1018   }

  1019 done:

  1020   if (queue != NULL) {

  1021     /* We didn't successfully connect to the queue */

  1022     gst_pad_unlink (pad, queuesinkpad);

  1023     gst_element_set_state (queue, GST_STATE_NULL);

  1024     gst_object_unref (queuesrcpad);

  1025     gst_object_unref (queuesinkpad);

  1026     gst_bin_remove (GST_BIN (decode_bin), queue);

  1027   }

  1028   return result;

  1029 }

  1030 

  1031 static GstPad *

  1032 get_our_ghost_pad (GstDecodeBin * decode_bin, GstPad * pad)

  1033 {

  1034   GstIterator *pad_it = NULL;

  1035   GstPad *db_pad = NULL;

  1036   gboolean done = FALSE;

  1037 

  1038   if (pad == NULL || !GST_PAD_IS_SRC (pad)) {

  1039     GST_DEBUG_OBJECT (decode_bin, "pad NULL or not SRC pad");

  1040     return NULL;

  1041   }

  1042 

  1043   /* our ghostpads are the sourcepads */

  1044   pad_it = gst_element_iterate_src_pads (GST_ELEMENT (decode_bin));

  1045   while (!done) {

  1046     db_pad = NULL;

  1047     switch (gst_iterator_next (pad_it, (gpointer) & db_pad)) {

  1048       case GST_ITERATOR_OK:

  1049         GST_DEBUG_OBJECT (decode_bin, "looking at pad %s:%s",

  1050             GST_DEBUG_PAD_NAME (db_pad));

  1051         if (GST_IS_GHOST_PAD (db_pad)) {

  1052           GstPad *target_pad = NULL;

  1053 

  1054           target_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (db_pad));

  1055           done = (target_pad == pad);

  1056           if (target_pad)

  1057             gst_object_unref (target_pad);

  1058 

  1059           if (done) {

  1060             /* Found our ghost pad */

  1061             GST_DEBUG_OBJECT (decode_bin, "found ghostpad %s:%s for pad %s:%s",

  1062                 GST_DEBUG_PAD_NAME (db_pad), GST_DEBUG_PAD_NAME (pad));

  1063             break;

  1064           }

  1065         }

  1066         /* Not the right one */

  1067         gst_object_unref (db_pad);

  1068         break;

  1069       case GST_ITERATOR_RESYNC:

  1070         gst_iterator_resync (pad_it);

  1071         break;

  1072       case GST_ITERATOR_ERROR:

  1073         done = TRUE;

  1074         break;

  1075       case GST_ITERATOR_DONE:

  1076         done = TRUE;

  1077         break;

  1078     }

  1079   }

  1080   gst_iterator_free (pad_it);

  1081 

  1082   return db_pad;

  1083 }

  1084 

  1085 /* remove all downstream elements starting from the given pad.

  1086  * Also make sure to remove the ghostpad we created for the raw

  1087  * decoded stream.

  1088  */

  1089 static void

  1090 remove_element_chain (GstDecodeBin * decode_bin, GstPad * pad)

  1091 {

  1092   GList *int_links, *walk;

  1093   GstElement *elem = GST_ELEMENT (GST_OBJECT_PARENT (pad));

  1094 

  1095   while (GST_OBJECT_PARENT (elem) &&

  1096       GST_OBJECT_PARENT (elem) != GST_OBJECT (decode_bin))

  1097     elem = GST_ELEMENT (GST_OBJECT_PARENT (elem));

  1098 

  1099   if (G_OBJECT_TYPE (elem) == decode_bin->queue_type) {

  1100     GST_DEBUG_OBJECT (decode_bin,

  1101         "Encountered demuxer output queue while removing element chain");

  1102     decode_bin->queues = g_list_remove (decode_bin->queues, elem);

  1103   }

  1104 

  1105   GST_DEBUG_OBJECT (decode_bin, "%s:%s", GST_DEBUG_PAD_NAME (pad));

  1106   int_links = gst_pad_get_internal_links (pad);

  1107 

  1108   /* remove all elements linked to this pad up to the ghostpad

  1109    * that we created for this stream */

  1110   for (walk = int_links; walk; walk = g_list_next (walk)) {

  1111     GstPad *pad;

  1112     GstPad *ghostpad;

  1113     GstPad *peer;

  1114 

  1115     pad = GST_PAD (walk->data);

  1116     GST_DEBUG_OBJECT (decode_bin, "inspecting internal pad %s:%s",

  1117         GST_DEBUG_PAD_NAME (pad));

  1118 

  1119     ghostpad = get_our_ghost_pad (decode_bin, pad);

  1120     if (ghostpad) {

  1121       GST_DEBUG_OBJECT (decode_bin, "found our ghost pad %s:%s for %s:%s",

  1122           GST_DEBUG_PAD_NAME (ghostpad), GST_DEBUG_PAD_NAME (pad));

  1123 

  1124       g_signal_emit (G_OBJECT (decode_bin),

  1125           gst_decode_bin_signals[SIGNAL_REMOVED_DECODED_PAD], 0, ghostpad);

  1126 

  1127       gst_element_remove_pad (GST_ELEMENT (decode_bin), ghostpad);

  1128       gst_object_unref (ghostpad);

  1129       continue;

  1130     } else {

  1131       GST_DEBUG_OBJECT (decode_bin, "not one of our ghostpads");

  1132     }

  1133 

  1134     peer = gst_pad_get_peer (pad);