1 /* GStreamer

     2  * Copyright (C) <2006> Edward Hervey <edward@fluendo.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 /**

    21  * SECTION:element-decodebin2

    22  * @short_description: Next-generation automatic decoding bin

    23  *

    24  * #GstBin that auto-magically constructs a decoding pipeline using available

    25  * decoders and demuxers via auto-plugging.

    26  *

    27  * At this stage, decodebin2 is considered UNSTABLE. The API provided in the

    28  * signals is expected to change in the near future. 

    29  *

    30  * To try out decodebin2, you can set the USE_DECODEBIN2 environment 

    31  * variable (USE_DECODEBIN2=1 for example). This will cause playbin to use

    32  * decodebin2 instead of the older decodebin for its internal auto-plugging.

    33  */

    34 

    35 #ifdef HAVE_CONFIG_H

    36 #include "config.h"

    37 #endif

    38 

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

    40 

    41 #include <string.h>

    42 #include <gst/gst.h>

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

    44 

    45 #include "gstplay-marshal.h"

    46 #include "gstplay-enum.h"

    47 #include "gstfactorylists.h"

    48 

    49 #ifdef __SYMBIAN32__

    50 #include <glib_global.h>

    51 #endif

    52 /* generic templates */

    53 static GstStaticPadTemplate decoder_bin_sink_template =

    54 GST_STATIC_PAD_TEMPLATE ("sink",

    55     GST_PAD_SINK,

    56     GST_PAD_ALWAYS,

    57     GST_STATIC_CAPS_ANY);

    58 

    59 static GstStaticPadTemplate decoder_bin_src_template =

    60 GST_STATIC_PAD_TEMPLATE ("src%d",

    61     GST_PAD_SRC,

    62     GST_PAD_SOMETIMES,

    63     GST_STATIC_CAPS_ANY);

    64 

    65 GST_DEBUG_CATEGORY_STATIC (gst_decode_bin_debug);

    66 #define GST_CAT_DEFAULT gst_decode_bin_debug

    67 

    68 typedef struct _GstDecodeGroup GstDecodeGroup;

    69 typedef struct _GstDecodePad GstDecodePad;

    70 typedef struct _GstDecodeBin GstDecodeBin;

    71 typedef struct _GstDecodeBin GstDecodeBin2;

    72 typedef struct _GstDecodeBinClass GstDecodeBinClass;

    73 

    74 #define GST_TYPE_DECODE_BIN             (gst_decode_bin_get_type())

    75 #define GST_DECODE_BIN_CAST(obj)        ((GstDecodeBin*)(obj))

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

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

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

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

    80 

    81 /**

    82  *  GstDecodeBin2:

    83  *

    84  *  The opaque #DecodeBin2 data structure

    85  */

    86 struct _GstDecodeBin

    87 {

    88   GstBin bin;                   /* we extend GstBin */

    89 

    90   /* properties */

    91   GstCaps *caps;                /* caps on which to stop decoding */

    92   gchar *encoding;              /* encoding of subtitles */

    93 

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

    95   GstElement *fakesink;

    96 

    97   GMutex *lock;                 /* Protects activegroup and groups */

    98   GstDecodeGroup *activegroup;  /* group currently active */

    99   GList *groups;                /* List of non-active GstDecodeGroups, sorted in

   100                                  * order of creation. */

   101   GList *oldgroups;             /* List of no-longer-used GstDecodeGroups. 

   102                                  * Should be freed in dispose */

   103   gint nbpads;                  /* unique identifier for source pads */

   104 

   105   GValueArray *factories;       /* factories we can use for selecting elements */

   106 

   107   gboolean have_type;           /* if we received the have_type signal */

   108   guint have_type_id;           /* signal id for have-type from typefind */

   109 };

   110 

   111 struct _GstDecodeBinClass

   112 {

   113   GstBinClass parent_class;

   114 

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

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

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

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

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

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

   121 

   122   /* signal fired to know if we continue trying to decode the given caps */

   123     gboolean (*autoplug_continue) (GstElement * element, GstPad * pad,

   124       GstCaps * caps);

   125   /* signal fired to get a list of factories to try to autoplug */

   126   GValueArray *(*autoplug_factories) (GstElement * element, GstPad * pad,

   127       GstCaps * caps);

   128   /* signal fired to sort the factories */

   129   GValueArray *(*autoplug_sort) (GstElement * element, GstPad * pad,

   130       GstCaps * caps, GValueArray * factories);

   131   /* signal fired to select from the proposed list of factories */

   132     GstAutoplugSelectResult (*autoplug_select) (GstElement * element,

   133       GstPad * pad, GstCaps * caps, GstElementFactory * factory);

   134 

   135   /* fired when the last group is drained */

   136   void (*drained) (GstElement * element);

   137 };

   138 

   139 /* signals */

   140 enum

   141 {

   142   SIGNAL_NEW_DECODED_PAD,

   143   SIGNAL_REMOVED_DECODED_PAD,

   144   SIGNAL_UNKNOWN_TYPE,

   145   SIGNAL_AUTOPLUG_CONTINUE,

   146   SIGNAL_AUTOPLUG_FACTORIES,

   147   SIGNAL_AUTOPLUG_SELECT,

   148   SIGNAL_AUTOPLUG_SORT,

   149   SIGNAL_DRAINED,

   150   LAST_SIGNAL

   151 };

   152 

   153 /* Properties */

   154 enum

   155 {

   156   PROP_0,

   157   PROP_CAPS,

   158   PROP_SUBTITLE_ENCODING

   159 };

   160 

   161 static GstBinClass *parent_class;

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

   163 

   164 static const GstElementDetails gst_decode_bin_details =

   165 GST_ELEMENT_DETAILS ("Decoder Bin",

   166     "Generic/Bin/Decoder",

   167     "Autoplug and decode to raw media",

   168     "Edward Hervey <edward@fluendo.com>");

   169 

   170 

   171 static gboolean add_fakesink (GstDecodeBin * decode_bin);

   172 static void remove_fakesink (GstDecodeBin * decode_bin);

   173 

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

   175     GstCaps * caps, GstDecodeBin * decode_bin);

   176 

   177 static gboolean gst_decode_bin_autoplug_continue (GstElement * element,

   178     GstPad * pad, GstCaps * caps);

   179 static GValueArray *gst_decode_bin_autoplug_factories (GstElement *

   180     element, GstPad * pad, GstCaps * caps);

   181 static GValueArray *gst_decode_bin_autoplug_sort (GstElement * element,

   182     GstPad * pad, GstCaps * caps, GValueArray * factories);

   183 static GstAutoplugSelectResult gst_decode_bin_autoplug_select (GstElement *

   184     element, GstPad * pad, GstCaps * caps, GstElementFactory * factory);

   185 

   186 static void gst_decode_bin_set_property (GObject * object, guint prop_id,

   187     const GValue * value, GParamSpec * pspec);

   188 static void gst_decode_bin_get_property (GObject * object, guint prop_id,

   189     GValue * value, GParamSpec * pspec);

   190 static void gst_decode_bin_set_caps (GstDecodeBin * dbin, GstCaps * caps);

   191 static GstCaps *gst_decode_bin_get_caps (GstDecodeBin * dbin);

   192 static void caps_notify_group_cb (GstPad * pad, GParamSpec * unused,

   193     GstDecodeGroup * group);

   194 static void caps_notify_cb (GstPad * pad, GParamSpec * unused,

   195     GstDecodeBin * dbin);

   196 

   197 static GstPad *find_sink_pad (GstElement * element);

   198 static GstStateChangeReturn gst_decode_bin_change_state (GstElement * element,

   199     GstStateChange transition);

   200 

   201 #define DECODE_BIN_LOCK(dbin) G_STMT_START {				\

   202     GST_LOG_OBJECT (dbin,						\

   203 		    "locking from thread %p",				\

   204 		    g_thread_self ());					\

   205     g_mutex_lock (GST_DECODE_BIN_CAST(dbin)->lock);			\

   206     GST_LOG_OBJECT (dbin,						\

   207 		    "locked from thread %p",				\

   208 		    g_thread_self ());					\

   209 } G_STMT_END

   210 

   211 #define DECODE_BIN_UNLOCK(dbin) G_STMT_START {				\

   212     GST_LOG_OBJECT (dbin,						\

   213 		    "unlocking from thread %p",				\

   214 		    g_thread_self ());					\

   215     g_mutex_unlock (GST_DECODE_BIN_CAST(dbin)->lock);			\

   216 } G_STMT_END

   217 

   218 /* GstDecodeGroup

   219  *

   220  * Streams belonging to the same group/chain of a media file

   221  *

   222  */

   223 struct _GstDecodeGroup

   224 {

   225   GstDecodeBin *dbin;

   226   GMutex *lock;

   227   GstElement *multiqueue;

   228   gboolean exposed;             /* TRUE if this group is exposed */

   229   gboolean drained;             /* TRUE if EOS went throug all endpads */

   230   gboolean blocked;             /* TRUE if all endpads are blocked */

   231   gboolean complete;            /* TRUE if we are not expecting anymore streams 

   232                                  * on this group */

   233   gulong overrunsig;

   234   gulong underrunsig;

   235   guint nbdynamic;              /* number of dynamic pads in the group. */

   236 

   237   GList *endpads;               /* List of GstDecodePad of source pads to be exposed */

   238   GList *ghosts;                /* List of GstGhostPad for the endpads */

   239   GList *reqpads;               /* List of RequestPads for multiqueue. */

   240 };

   241 

   242 #define GROUP_MUTEX_LOCK(group) G_STMT_START {				\

   243     GST_LOG_OBJECT (group->dbin,					\

   244 		    "locking group %p from thread %p",			\

   245 		    group, g_thread_self ());				\

   246     g_mutex_lock (group->lock);						\

   247     GST_LOG_OBJECT (group->dbin,					\

   248 		    "locked group %p from thread %p",			\

   249 		    group, g_thread_self ());				\

   250 } G_STMT_END

   251 

   252 #define GROUP_MUTEX_UNLOCK(group) G_STMT_START {                        \

   253     GST_LOG_OBJECT (group->dbin,					\

   254 		    "unlocking group %p from thread %p",		\

   255 		    group, g_thread_self ());				\

   256     g_mutex_unlock (group->lock);					\

   257 } G_STMT_END

   258 

   259 

   260 static GstDecodeGroup *gst_decode_group_new (GstDecodeBin * decode_bin,

   261     gboolean use_queue);

   262 static GstPad *gst_decode_group_control_demuxer_pad (GstDecodeGroup * group,

   263     GstPad * pad);

   264 static gboolean gst_decode_group_control_source_pad (GstDecodeGroup * group,

   265     GstPad * pad);

   266 static gboolean gst_decode_group_expose (GstDecodeGroup * group);

   267 static void gst_decode_group_check_if_blocked (GstDecodeGroup * group);

   268 static void gst_decode_group_set_complete (GstDecodeGroup * group);

   269 static void gst_decode_group_hide (GstDecodeGroup * group);

   270 static void gst_decode_group_free (GstDecodeGroup * group);

   271 

   272 /* GstDecodePad

   273  *

   274  * GstPad private used for source pads of groups

   275  */

   276 

   277 struct _GstDecodePad

   278 {

   279   GstPad *pad;

   280   GstDecodeGroup *group;

   281   gboolean blocked;

   282   gboolean drained;

   283 };

   284 

   285 static GstDecodePad *gst_decode_pad_new (GstDecodeGroup * group, GstPad * pad,

   286     gboolean block);

   287 static void source_pad_blocked_cb (GstPad * pad, gboolean blocked,

   288     GstDecodePad * dpad);

   289 

   290 /* TempPadStruct

   291  * Internal structure used for pads which have more than one structure.

   292  */

   293 typedef struct _TempPadStruct

   294 {

   295   GstDecodeBin *dbin;

   296   GstDecodeGroup *group;

   297 } TempPadStruct;

   298 

   299 /********************************

   300  * Standard GObject boilerplate *

   301  ********************************/

   302 

   303 static void gst_decode_bin_class_init (GstDecodeBinClass * klass);

   304 static void gst_decode_bin_init (GstDecodeBin * decode_bin);

   305 static void gst_decode_bin_dispose (GObject * object);

   306 static void gst_decode_bin_finalize (GObject * object);

   307 

   308 static GType

   309 gst_decode_bin_get_type (void)

   310 {

   311   static GType gst_decode_bin_type = 0;

   312 

   313   if (!gst_decode_bin_type) {

   314     static const GTypeInfo gst_decode_bin_info = {

   315       sizeof (GstDecodeBinClass),

   316       NULL,

   317       NULL,

   318       (GClassInitFunc) gst_decode_bin_class_init,

   319       NULL,

   320       NULL,

   321       sizeof (GstDecodeBin),

   322       0,

   323       (GInstanceInitFunc) gst_decode_bin_init,

   324       NULL

   325     };

   326 

   327     gst_decode_bin_type =

   328         g_type_register_static (GST_TYPE_BIN, "GstDecodeBin2",

   329         &gst_decode_bin_info, 0);

   330   }

   331 

   332   return gst_decode_bin_type;

   333 }

   334 

   335 static gboolean

   336 _gst_boolean_accumulator (GSignalInvocationHint * ihint,

   337     GValue * return_accu, const GValue * handler_return, gpointer dummy)

   338 {

   339   gboolean myboolean;

   340 

   341   myboolean = g_value_get_boolean (handler_return);

   342   if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))

   343     g_value_set_boolean (return_accu, myboolean);

   344 

   345   /* stop emission if FALSE */

   346   return myboolean;

   347 }

   348 

   349 /* we collect the first result */

   350 static gboolean

   351 _gst_array_accumulator (GSignalInvocationHint * ihint,

   352     GValue * return_accu, const GValue * handler_return, gpointer dummy)

   353 {

   354   gpointer array;

   355 

   356   array = g_value_get_boxed (handler_return);

   357   if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))

   358     g_value_set_boxed (return_accu, array);

   359 

   360   return FALSE;

   361 }

   362 

   363 static gboolean

   364 _gst_select_accumulator (GSignalInvocationHint * ihint,

   365     GValue * return_accu, const GValue * handler_return, gpointer dummy)

   366 {

   367   GstAutoplugSelectResult res;

   368 

   369   res = g_value_get_enum (handler_return);

   370   if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))

   371     g_value_set_enum (return_accu, res);

   372 

   373   return FALSE;

   374 }

   375 

   376 static void

   377 gst_decode_bin_class_init (GstDecodeBinClass * klass)

   378 {

   379   GObjectClass *gobject_klass;

   380   GstElementClass *gstelement_klass;

   381   GstBinClass *gstbin_klass;

   382 

   383   gobject_klass = (GObjectClass *) klass;

   384   gstelement_klass = (GstElementClass *) klass;

   385   gstbin_klass = (GstBinClass *) klass;

   386 

   387   parent_class = g_type_class_peek_parent (klass);

   388 

   389   gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_decode_bin_dispose);

   390   gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_decode_bin_finalize);

   391   gobject_klass->set_property = GST_DEBUG_FUNCPTR (gst_decode_bin_set_property);

   392   gobject_klass->get_property = GST_DEBUG_FUNCPTR (gst_decode_bin_get_property);

   393 

   394   /**

   395    * GstDecodeBin2::new-decoded-pad:

   396    * @pad: the newly created pad

   397    * @islast: #TRUE if this is the last pad to be added. Deprecated.

   398    *

   399    * This signal gets emitted as soon as a new pad of the same type as one of

   400    * the valid 'raw' types is added.

   401    */

   402   gst_decode_bin_signals[SIGNAL_NEW_DECODED_PAD] =

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

   404       G_SIGNAL_RUN_LAST,

   405       G_STRUCT_OFFSET (GstDecodeBinClass, new_decoded_pad), NULL, NULL,

   406       gst_play_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, GST_TYPE_PAD,

   407       G_TYPE_BOOLEAN);

   408 

   409   /**

   410    * GstDecodeBin2::removed-decoded-pad:

   411    * @pad: the pad that was removed

   412    *

   413    * This signal is emitted when a 'final' caps pad has been removed.

   414    */

   415   gst_decode_bin_signals[SIGNAL_REMOVED_DECODED_PAD] =

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

   417       G_SIGNAL_RUN_LAST,

   418       G_STRUCT_OFFSET (GstDecodeBinClass, removed_decoded_pad), NULL, NULL,

   419       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);

   420 

   421   /**

   422    * GstDecodeBin2::unknown-type:

   423    * @pad: the new pad containing caps that cannot be resolved to a 'final' stream type.

   424    * @caps: the #GstCaps of the pad that cannot be resolved.

   425    *

   426    * This signal is emitted when a pad for which there is no further possible

   427    * decoding is added to the decodebin.

   428    */

   429   gst_decode_bin_signals[SIGNAL_UNKNOWN_TYPE] =

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

   431       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, unknown_type),

   432       NULL, NULL, gst_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2,

   433       GST_TYPE_PAD, GST_TYPE_CAPS);

   434 

   435   /**

   436    * GstDecodeBin2::autoplug-continue:

   437    * @pad: The #GstPad.

   438    * @caps: The #GstCaps found.

   439    *

   440    * This signal is emitted whenever decodebin2 finds a new stream. It is

   441    * emitted before looking for any elements that can handle that stream.

   442    *

   443    * Returns: #TRUE if you wish decodebin2 to look for elements that can

   444    * handle the given @caps. If #FALSE, those caps will be considered as

   445    * final and the pad will be exposed as such (see 'new-decoded-pad'

   446    * signal).

   447    */

   448   gst_decode_bin_signals[SIGNAL_AUTOPLUG_CONTINUE] =

   449       g_signal_new ("autoplug-continue", G_TYPE_FROM_CLASS (klass),

   450       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, autoplug_continue),

   451       _gst_boolean_accumulator, NULL, gst_play_marshal_BOOLEAN__OBJECT_OBJECT,

   452       G_TYPE_BOOLEAN, 2, GST_TYPE_PAD, GST_TYPE_CAPS);

   453 

   454   /**

   455    * GstDecodeBin2::autoplug-factories:

   456    * @pad: The #GstPad.

   457    * @caps: The #GstCaps found.

   458    *

   459    * This function is emited when an array of possible factories for @caps on

   460    * @pad is needed. Decodebin2 will by default return an array with all

   461    * compatible factories, sorted by rank. 

   462    *

   463    * If this function returns NULL, @pad will be exposed as a final caps.

   464    *

   465    * If this function returns an empty array, the pad will be considered as 

   466    * having an unhandled type media type.

   467    *

   468    * Returns: a #GValueArray* with a list of factories to try. The factories are

   469    * by default tried in the returned order or based on the index returned by

   470    * "autoplug-select".

   471    */

   472   gst_decode_bin_signals[SIGNAL_AUTOPLUG_FACTORIES] =

   473       g_signal_new ("autoplug-factories", G_TYPE_FROM_CLASS (klass),

   474       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass,

   475           autoplug_factories), _gst_array_accumulator, NULL,

   476       gst_play_marshal_BOXED__OBJECT_OBJECT, G_TYPE_VALUE_ARRAY, 2,

   477       GST_TYPE_PAD, GST_TYPE_CAPS);

   478 

   479   /**

   480    * GstDecodeBin2::autoplug-sort:

   481    * @pad: The #GstPad.

   482    * @caps: The #GstCaps.

   483    * @factories: A #GValueArray of possible #GstElementFactory to use.

   484    *

   485    * Once decodebin2 has found the possible #GstElementFactory objects to try

   486    * for @caps on @pad, this signal is emited. The purpose of the signal is for

   487    * the application to perform additional sorting or filtering on the element

   488    * factory array.

   489    *

   490    * The callee should copy and modify @factories.

   491    *

   492    * Returns: A new sorted array of #GstElementFactory objects.

   493    */

   494   gst_decode_bin_signals[SIGNAL_AUTOPLUG_SORT] =

   495       g_signal_new ("autoplug-sort", G_TYPE_FROM_CLASS (klass),

   496       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, autoplug_sort),

   497       NULL, NULL, gst_play_marshal_BOXED__OBJECT_OBJECT_BOXED,

   498       G_TYPE_VALUE_ARRAY, 3, GST_TYPE_PAD, GST_TYPE_CAPS, G_TYPE_VALUE_ARRAY);

   499 

   500   /**

   501    * GstDecodeBin2::autoplug-select:

   502    * @pad: The #GstPad.

   503    * @caps: The #GstCaps.

   504    * @factories: A #GValueArray of possible #GstElementFactory to use, sorted by

   505    * rank (higher ranks come first).

   506    *

   507    * This signal is emitted once decodebin2 has found all the possible

   508    * #GstElementFactory that can be used to handle the given @caps.

   509    *

   510    * Returns: A #gint indicating what factory index from the @factories array

   511    * that you wish decodebin2 to use for trying to decode the given @caps.

   512    * Return -1 to stop selection of a factory and expose the pad as a raw type. 

   513    * The default handler always returns the first possible factory (index 0).

   514    */

   515   gst_decode_bin_signals[SIGNAL_AUTOPLUG_SELECT] =

   516       g_signal_new ("autoplug-select", G_TYPE_FROM_CLASS (klass),

   517       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, autoplug_select),

   518       _gst_select_accumulator, NULL,

   519       gst_play_marshal_ENUM__OBJECT_OBJECT_OBJECT,

   520       GST_TYPE_AUTOPLUG_SELECT_RESULT, 3, GST_TYPE_PAD, GST_TYPE_CAPS,

   521       GST_TYPE_ELEMENT_FACTORY);

   522 

   523   /**

   524    * GstDecodeBin2::drained

   525    *

   526    * This signal is emitted once decodebin2 has finished decoding all the data.

   527    *

   528    * Since: 0.10.16

   529    */

   530   gst_decode_bin_signals[SIGNAL_DRAINED] =

   531       g_signal_new ("drained", G_TYPE_FROM_CLASS (klass),

   532       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, drained),

   533       NULL, NULL, gst_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);

   534 

   535   g_object_class_install_property (gobject_klass, PROP_CAPS,

   536       g_param_spec_boxed ("caps", "Caps", "The caps on which to stop decoding.",

   537           GST_TYPE_CAPS, G_PARAM_READWRITE));

   538 

   539   g_object_class_install_property (gobject_klass, PROP_SUBTITLE_ENCODING,

   540       g_param_spec_string ("subtitle-encoding", "subtitle encoding",

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

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

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

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

   545 

   546   klass->autoplug_continue =

   547       GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_continue);

   548   klass->autoplug_factories =

   549       GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_factories);

   550   klass->autoplug_sort = GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_sort);

   551   klass->autoplug_select = GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_select);

   552 

   553   gst_element_class_add_pad_template (gstelement_klass,

   554       gst_static_pad_template_get (&decoder_bin_sink_template));

   555   gst_element_class_add_pad_template (gstelement_klass,

   556       gst_static_pad_template_get (&decoder_bin_src_template));

   557 

   558   gst_element_class_set_details (gstelement_klass, &gst_decode_bin_details);

   559 

   560   gstelement_klass->change_state =

   561       GST_DEBUG_FUNCPTR (gst_decode_bin_change_state);

   562 }

   563 

   564 static void

   565 gst_decode_bin_init (GstDecodeBin * decode_bin)

   566 {

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

   568   decode_bin->factories =

   569       gst_factory_list_get_elements (GST_FACTORY_LIST_DECODER);

   570 

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

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

   573   if (!decode_bin->typefind) {

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

   575   } else {

   576     GstPad *pad;

   577     GstPad *gpad;

   578 

   579     /* add the typefind element */

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

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

   582       gst_object_unref (decode_bin->typefind);

   583       decode_bin->typefind = NULL;

   584     }

   585 

   586     /* get the sinkpad */

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

   588 

   589     /* ghost the sink pad to ourself */

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

   591     gst_pad_set_active (gpad, TRUE);

   592     gst_element_add_pad (GST_ELEMENT (decode_bin), gpad);

   593 

   594     gst_object_unref (pad);

   595 

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

   597      * a type */

   598     decode_bin->have_type_id =

   599         g_signal_connect (G_OBJECT (decode_bin->typefind), "have-type",

   600         G_CALLBACK (type_found), decode_bin);

   601   }

   602 

   603   decode_bin->lock = g_mutex_new ();

   604   decode_bin->activegroup = NULL;

   605   decode_bin->groups = NULL;

   606 

   607   decode_bin->caps =

   608       gst_caps_from_string ("video/x-raw-yuv;video/x-raw-rgb;video/x-raw-gray;"

   609       "audio/x-raw-int;audio/x-raw-float;" "text/plain;text/x-pango-markup");

   610 

   611   add_fakesink (decode_bin);

   612 

   613   /* FILLME */

   614 }

   615 

   616 static void

   617 gst_decode_bin_dispose (GObject * object)

   618 {

   619   GstDecodeBin *decode_bin;

   620   GList *tmp;

   621 

   622   decode_bin = GST_DECODE_BIN (object);

   623 

   624   if (decode_bin->factories)

   625     g_value_array_free (decode_bin->factories);

   626   decode_bin->factories = NULL;

   627 

   628   if (decode_bin->activegroup) {

   629     gst_decode_group_free (decode_bin->activegroup);

   630     decode_bin->activegroup = NULL;

   631   }

   632 

   633   /* remove groups */

   634   for (tmp = decode_bin->groups; tmp; tmp = g_list_next (tmp)) {

   635     GstDecodeGroup *group = (GstDecodeGroup *) tmp->data;

   636 

   637     gst_decode_group_free (group);

   638   }

   639   g_list_free (decode_bin->groups);

   640   decode_bin->groups = NULL;

   641 

   642   for (tmp = decode_bin->oldgroups; tmp; tmp = g_list_next (tmp)) {

   643     GstDecodeGroup *group = (GstDecodeGroup *) tmp->data;

   644 

   645     gst_decode_group_free (group);

   646   }

   647   g_list_free (decode_bin->oldgroups);

   648   decode_bin->oldgroups = NULL;

   649 

   650   if (decode_bin->caps)

   651     gst_caps_unref (decode_bin->caps);

   652   decode_bin->caps = NULL;

   653 

   654   g_free (decode_bin->encoding);

   655   decode_bin->encoding = NULL;

   656 

   657   remove_fakesink (decode_bin);

   658 

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

   660 }

   661 

   662 static void

   663 gst_decode_bin_finalize (GObject * object)

   664 {

   665   GstDecodeBin *decode_bin;

   666 

   667   decode_bin = GST_DECODE_BIN (object);

   668 

   669   if (decode_bin->lock) {

   670     g_mutex_free (decode_bin->lock);

   671     decode_bin->lock = NULL;

   672   }

   673 

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

   675 }

   676 

   677 /* _set_caps

   678  * Changes the caps on which decodebin will stop decoding.

   679  * Will unref the previously set one. The refcount of the given caps will be

   680  * increased.

   681  * @caps can be NULL.

   682  *

   683  * MT-safe

   684  */

   685 static void

   686 gst_decode_bin_set_caps (GstDecodeBin * dbin, GstCaps * caps)

   687 {

   688   GST_DEBUG_OBJECT (dbin, "Setting new caps: %" GST_PTR_FORMAT, caps);

   689 

   690   DECODE_BIN_LOCK (dbin);

   691   if (dbin->caps)

   692     gst_caps_unref (dbin->caps);

   693   if (caps)

   694     gst_caps_ref (caps);

   695   dbin->caps = caps;

   696   DECODE_BIN_UNLOCK (dbin);

   697 }

   698 

   699 /* _get_caps

   700  * Returns the currently configured caps on which decodebin will stop decoding.

   701  * The returned caps (if not NULL), will have its refcount incremented.

   702  *

   703  * MT-safe

   704  */

   705 

   706 static GstCaps *

   707 gst_decode_bin_get_caps (GstDecodeBin * dbin)

   708 {

   709   GstCaps *caps;

   710 

   711   GST_DEBUG_OBJECT (dbin, "Getting currently set caps");

   712 

   713   DECODE_BIN_LOCK (dbin);

   714   caps = dbin->caps;

   715   if (caps)

   716     gst_caps_ref (caps);

   717   DECODE_BIN_UNLOCK (dbin);

   718 

   719   return caps;

   720 }

   721 

   722 static void

   723 gst_decode_bin_set_subs_encoding (GstDecodeBin * dbin, const gchar * encoding)

   724 {

   725   GST_DEBUG_OBJECT (dbin, "Setting new encoding: %s", GST_STR_NULL (encoding));

   726 

   727   DECODE_BIN_LOCK (dbin);

   728   g_free (dbin->encoding);

   729   dbin->encoding = g_strdup (encoding);

   730   DECODE_BIN_UNLOCK (dbin);

   731 }

   732 

   733 static gchar *

   734 gst_decode_bin_get_subs_encoding (GstDecodeBin * dbin)

   735 {

   736   gchar *encoding;

   737 

   738   GST_DEBUG_OBJECT (dbin, "Getting currently set encoding");

   739 

   740   DECODE_BIN_LOCK (dbin);

   741   encoding = g_strdup (dbin->encoding);

   742   DECODE_BIN_UNLOCK (dbin);

   743 

   744   return encoding;

   745 }

   746 

   747 static void

   748 gst_decode_bin_set_property (GObject * object, guint prop_id,

   749     const GValue * value, GParamSpec * pspec)

   750 {

   751   GstDecodeBin *dbin;

   752 

   753   dbin = GST_DECODE_BIN (object);

   754 

   755   switch (prop_id) {

   756     case PROP_CAPS:

   757       gst_decode_bin_set_caps (dbin, g_value_get_boxed (value));

   758       break;

   759     case PROP_SUBTITLE_ENCODING:

   760       gst_decode_bin_set_subs_encoding (dbin, g_value_get_string (value));

   761       break;

   762     default:

   763       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   764       break;

   765   }

   766 }

   767 

   768 static void

   769 gst_decode_bin_get_property (GObject * object, guint prop_id,

   770     GValue * value, GParamSpec * pspec)

   771 {

   772   GstDecodeBin *dbin;

   773 

   774   dbin = GST_DECODE_BIN (object);

   775   switch (prop_id) {

   776     case PROP_CAPS:

   777       g_value_take_boxed (value, gst_decode_bin_get_caps (dbin));

   778       break;

   779     case PROP_SUBTITLE_ENCODING:

   780       g_value_take_string (value, gst_decode_bin_get_subs_encoding (dbin));

   781       break;

   782     default:

   783       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   784       break;

   785   }

   786 }

   787 

   788 

   789 static GValueArray *find_compatibles (GstDecodeBin * decode_bin,

   790     GstPad * pad, const GstCaps * caps);

   791 

   792 /*****

   793  * Default autoplug signal handlers

   794  *****/

   795 static gboolean

   796 gst_decode_bin_autoplug_continue (GstElement * element, GstPad * pad,

   797     GstCaps * caps)

   798 {

   799   GST_DEBUG_OBJECT (element, "autoplug-continue returns TRUE");

   800 

   801   /* by default we always continue */

   802   return TRUE;

   803 }

   804 

   805 static GValueArray *

   806 gst_decode_bin_autoplug_factories (GstElement * element, GstPad * pad,

   807     GstCaps * caps)

   808 {

   809   GValueArray *result;

   810 

   811   /* return all compatible factories for caps */

   812   result = find_compatibles (GST_DECODE_BIN (element), pad, caps);

   813 

   814   GST_DEBUG_OBJECT (element, "autoplug-factories returns %p", result);

   815 

   816   return result;

   817 }

   818 

   819 static GValueArray *

   820 gst_decode_bin_autoplug_sort (GstElement * element, GstPad * pad,

   821     GstCaps * caps, GValueArray * factories)

   822 {

   823   GValueArray *result;

   824 

   825   result = g_value_array_copy (factories);

   826 

   827   GST_DEBUG_OBJECT (element, "autoplug-sort returns %p", result);

   828 

   829   /* return input */

   830   return result;

   831 }

   832 

   833 static GstAutoplugSelectResult

   834 gst_decode_bin_autoplug_select (GstElement * element, GstPad * pad,

   835     GstCaps * caps, GstElementFactory * factory)

   836 {

   837   GST_DEBUG_OBJECT (element, "default autoplug-select returns TRY");

   838 

   839   /* Try factory. */

   840   return GST_AUTOPLUG_SELECT_TRY;

   841 }

   842 

   843 /********

   844  * Discovery methods

   845  *****/

   846 

   847 static gboolean are_raw_caps (GstDecodeBin * dbin, GstCaps * caps);

   848 static gboolean is_demuxer_element (GstElement * srcelement);

   849 

   850 static gboolean connect_pad (GstDecodeBin * dbin, GstElement * src,

   851     GstPad * pad, GstCaps * caps, GValueArray * factories,

   852     GstDecodeGroup * group);

   853 static gboolean connect_element (GstDecodeBin * dbin, GstElement * element,

   854     GstDecodeGroup * group);

   855 static void expose_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

   856     GstDecodeGroup * group);

   857 

   858 static void pad_added_group_cb (GstElement * element, GstPad * pad,

   859     GstDecodeGroup * group);

   860 static void pad_removed_group_cb (GstElement * element, GstPad * pad,

   861     GstDecodeGroup * group);

   862 static void no_more_pads_group_cb (GstElement * element,

   863     GstDecodeGroup * group);

   864 static void pad_added_cb (GstElement * element, GstPad * pad,

   865     GstDecodeBin * dbin);

   866 static void pad_removed_cb (GstElement * element, GstPad * pad,

   867     GstDecodeBin * dbin);

   868 static void no_more_pads_cb (GstElement * element, GstDecodeBin * dbin);

   869 

   870 static GstDecodeGroup *get_current_group (GstDecodeBin * dbin);

   871 

   872 /* called when a new pad is discovered. It will perform some basic actions

   873  * before trying to link something to it.

   874  *

   875  *  - Check the caps, don't do anything when there are no caps or when they have

   876  *    no good type.

   877  *  - signal AUTOPLUG_CONTINUE to check if we need to continue autoplugging this

   878  *    pad.

   879  *  - if the caps are non-fixed, setup a handler to continue autoplugging when

   880  *    the caps become fixed (connect to notify::caps).

   881  *  - get list of factories to autoplug.

   882  *  - continue autoplugging to one of the factories.

   883  */

   884 static void

   885 analyze_new_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

   886     GstCaps * caps, GstDecodeGroup * group)

   887 {

   888   gboolean apcontinue = TRUE;

   889   GValueArray *factories = NULL, *result = NULL;

   890 

   891   GST_DEBUG_OBJECT (dbin, "Pad %s:%s caps:%" GST_PTR_FORMAT,

   892       GST_DEBUG_PAD_NAME (pad), caps);

   893 

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

   895     goto unknown_type;

   896 

   897   if (gst_caps_is_any (caps))

   898     goto any_caps;

   899 

   900   /* 1. Emit 'autoplug-continue' the result will tell us if this pads needs

   901    * further autoplugging. */

   902   g_signal_emit (G_OBJECT (dbin),

   903       gst_decode_bin_signals[SIGNAL_AUTOPLUG_CONTINUE], 0, pad, caps,

   904       &apcontinue);

   905 

   906   /* 1.a if autoplug-continue is FALSE or caps is a raw format, goto pad_is_final */

   907   if ((!apcontinue) || are_raw_caps (dbin, caps))

   908     goto expose_pad;

   909 

   910   /* 1.b when the caps are not fixed yet, we can't be sure what element to

   911    * connect. We delay autoplugging until the caps are fixed */

   912   if (!gst_caps_is_fixed (caps))

   913     goto non_fixed;

   914 

   915   /* 1.c else get the factories and if there's no compatible factory goto

   916    * unknown_type */

   917   g_signal_emit (G_OBJECT (dbin),

   918       gst_decode_bin_signals[SIGNAL_AUTOPLUG_FACTORIES], 0, pad, caps,

   919       &factories);

   920 

   921   /* NULL means that we can expose the pad */

   922   if (factories == NULL)

   923     goto expose_pad;

   924 

   925   /* if the array is empty, we have an unknown type */

   926   if (factories->n_values == 0) {

   927     /* no compatible factories */

   928     g_value_array_free (factories);

   929     goto unknown_type;

   930   }

   931 

   932   /* 1.d sort some more. */

   933   g_signal_emit (G_OBJECT (dbin),

   934       gst_decode_bin_signals[SIGNAL_AUTOPLUG_SORT], 0, pad, caps, factories,

   935       &result);

   936   g_value_array_free (factories);

   937   factories = result;

   938 

   939   /* 1.e else continue autoplugging something from the list. */

   940   GST_LOG_OBJECT (pad, "Let's continue discovery on this pad");

   941   connect_pad (dbin, src, pad, caps, factories, group);

   942 

   943   g_value_array_free (factories);

   944 

   945   return;

   946 

   947 expose_pad:

   948   {

   949     GST_LOG_OBJECT (dbin, "Pad is final. autoplug-continue:%d", apcontinue);

   950     expose_pad (dbin, src, pad, group);

   951     return;

   952   }

   953 unknown_type:

   954   {

   955     GST_LOG_OBJECT (pad, "Unknown type, firing signal");

   956     g_signal_emit (G_OBJECT (dbin),

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

   958 

   959     /* Check if there are no pending groups, if so, remove fakesink */

   960     if (dbin->groups == NULL)

   961       remove_fakesink (dbin);

   962 

   963     if (src == dbin->typefind) {

   964       gchar *desc;

   965 

   966       desc = gst_pb_utils_get_decoder_description (caps);

   967       GST_ELEMENT_ERROR (dbin, STREAM, CODEC_NOT_FOUND,

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

   969               desc),

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

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

   972       g_free (desc);

   973     }

   974 

   975     gst_element_post_message (GST_ELEMENT_CAST (dbin),

   976         gst_missing_decoder_message_new (GST_ELEMENT_CAST (dbin), caps));

   977     return;

   978   }

   979 non_fixed:

   980   {

   981     GST_DEBUG_OBJECT (pad, "pad has non-fixed caps delay autoplugging");

   982     goto setup_caps_delay;

   983   }

   984 any_caps:

   985   {

   986     GST_WARNING_OBJECT (pad,

   987         "pad has ANY caps, not able to autoplug to anything");

   988     goto setup_caps_delay;

   989   }

   990 setup_caps_delay:

   991   {

   992     /* connect to caps notification */

   993     if (group) {

   994       GROUP_MUTEX_LOCK (group);

   995       group->nbdynamic++;

   996       GST_LOG ("Group %p has now %d dynamic elements", group, group->nbdynamic);

   997       GROUP_MUTEX_UNLOCK (group);

   998       g_signal_connect (G_OBJECT (pad), "notify::caps",

   999           G_CALLBACK (caps_notify_group_cb), group);

  1000     } else

  1001       g_signal_connect (G_OBJECT (pad), "notify::caps",

  1002           G_CALLBACK (caps_notify_cb), dbin);

  1003     return;

  1004   }

  1005 }

  1006 

  1007 

  1008 /* connect_pad:

  1009  *

  1010  * Try to connect the given pad to an element created from one of the factories,

  1011  * and recursively.

  1012  *

  1013  * Returns TRUE if an element was properly created and linked

  1014  */

  1015 static gboolean

  1016 connect_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

  1017     GstCaps * caps, GValueArray * factories, GstDecodeGroup * group)

  1018 {

  1019   gboolean res = FALSE;

  1020   GstPad *mqpad = NULL;

  1021 

  1022   g_return_val_if_fail (factories != NULL, FALSE);

  1023   g_return_val_if_fail (factories->n_values > 0, FALSE);

  1024 

  1025   GST_DEBUG_OBJECT (dbin, "pad %s:%s , group:%p",

  1026       GST_DEBUG_PAD_NAME (pad), group);

  1027 

  1028   /* 1. is element demuxer or parser */

  1029   if (is_demuxer_element (src)) {

  1030     GST_LOG_OBJECT (src, "is a demuxer, connecting the pad through multiqueue");

  1031 

  1032     if (!group)

  1033       if (!(group = get_current_group (dbin))) {

  1034         group = gst_decode_group_new (dbin, TRUE);

  1035         DECODE_BIN_LOCK (dbin);

  1036         dbin->groups = g_list_append (dbin->groups, group);

  1037         DECODE_BIN_UNLOCK (dbin);

  1038       }

  1039 

  1040     if (!(mqpad = gst_decode_group_control_demuxer_pad (group, pad)))

  1041       goto beach;

  1042     src = group->multiqueue;

  1043     pad = mqpad;

  1044   }

  1045 

  1046   /* 2. Try to create an element and link to it */

  1047   while (factories->n_values > 0) {

  1048     GstAutoplugSelectResult ret;

  1049     GstElementFactory *factory;

  1050     GstElement *element;

  1051     GstPad *sinkpad;

  1052 

  1053     /* take first factory */

  1054     factory = g_value_get_object (g_value_array_get_nth (factories, 0));

  1055     /* Remove selected factory from the list. */

  1056     g_value_array_remove (factories, 0);

  1057 

  1058     /* emit autoplug-select to see what we should do with it. */

  1059     g_signal_emit (G_OBJECT (dbin),

  1060         gst_decode_bin_signals[SIGNAL_AUTOPLUG_SELECT],

  1061         0, pad, caps, factory, &ret);

  1062 

  1063     switch (ret) {

  1064       case GST_AUTOPLUG_SELECT_TRY:

  1065         GST_DEBUG_OBJECT (dbin, "autoplug select requested try");

  1066         break;

  1067       case GST_AUTOPLUG_SELECT_EXPOSE:

  1068         GST_DEBUG_OBJECT (dbin, "autoplug select requested expose");

  1069         /* expose the pad, we don't have the source element */

  1070         expose_pad (dbin, src, pad, group);

  1071         res = TRUE;

  1072         goto beach;

  1073       case GST_AUTOPLUG_SELECT_SKIP:

  1074         GST_DEBUG_OBJECT (dbin, "autoplug select requested skip");

  1075         continue;

  1076       default:

  1077         GST_WARNING_OBJECT (dbin, "autoplug select returned unhandled %d", ret);

  1078         break;

  1079     }

  1080 

  1081     /* 2.1. Try to create an element */

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

  1083       GST_WARNING_OBJECT (dbin, "Could not create an element from %s",

  1084           gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));

  1085       continue;

  1086     }

  1087 

  1088     /* ... activate it ... We do this before adding it to the bin so that we

  1089      * don't accidentally make it post error messages that will stop

  1090      * everything. */

  1091     if ((gst_element_set_state (element,

  1092                 GST_STATE_READY)) == GST_STATE_CHANGE_FAILURE) {

  1093       GST_WARNING_OBJECT (dbin, "Couldn't set %s to READY",

  1094           GST_ELEMENT_NAME (element));

  1095       gst_object_unref (element);

  1096       continue;

  1097     }

  1098 

  1099     /* 2.3. Find its sink pad, this should work after activating it. */

  1100     if (!(sinkpad = find_sink_pad (element))) {

  1101       GST_WARNING_OBJECT (dbin, "Element %s doesn't have a sink pad",

  1102           GST_ELEMENT_NAME (element));

  1103       gst_object_unref (element);

  1104       continue;

  1105     }

  1106 

  1107     /* 2.4 add it ... */

  1108     if (!(gst_bin_add (GST_BIN_CAST (dbin), element))) {

  1109       GST_WARNING_OBJECT (dbin, "Couldn't add %s to the bin",

  1110           GST_ELEMENT_NAME (element));

  1111       gst_object_unref (sinkpad);

  1112       gst_object_unref (element);

  1113       continue;

  1114     }

  1115 

  1116     /* 2.5 ...and try to link */

  1117     if ((gst_pad_link (pad, sinkpad)) != GST_PAD_LINK_OK) {

  1118       GST_WARNING_OBJECT (dbin, "Link failed on pad %s:%s",

  1119           GST_DEBUG_PAD_NAME (sinkpad));

  1120       gst_element_set_state (element, GST_STATE_NULL);

  1121       gst_object_unref (sinkpad);

  1122       gst_bin_remove (GST_BIN (dbin), element);

  1123       continue;

  1124     }

  1125     gst_object_unref (sinkpad);

  1126     GST_LOG_OBJECT (dbin, "linked on pad %s:%s", GST_DEBUG_PAD_NAME (pad));

  1127 

  1128     /* link this element further */

  1129     connect_element (dbin, element, group);

  1130 

  1131     /* Bring the element to the state of the parent */

  1132     if ((gst_element_set_state (element,

  1133                 GST_STATE_PAUSED)) == GST_STATE_CHANGE_FAILURE) {

  1134       GST_WARNING_OBJECT (dbin, "Couldn't set %s to PAUSED",