Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / gst / gstbin.c
1 /* GStreamer
2  *
3  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
4  *                    2004 Wim Taymans <wim.taymans@gmail.com>
5  *
6  * gstbin.c: GstBin container object and support code
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  *
23  * MT safe.
24  */
25
26 /**
27  * SECTION:gstbin
28  * @short_description: Base class and element that can contain other elements
29  *
30  * #GstBin is an element that can contain other #GstElement, allowing them to be
31  * managed as a group.
32  * Pads from the child elements can be ghosted to the bin, see #GstGhostPad.
33  * This makes the bin look like any other elements and enables creation of
34  * higher-level abstraction elements.
35  *
36  * A new #GstBin is created with gst_bin_new(). Use a #GstPipeline instead if you
37  * want to create a toplevel bin because a normal bin doesn't have a bus or
38  * handle clock distribution of its own.
39  *
40  * After the bin has been created you will typically add elements to it with
41  * gst_bin_add(). You can remove elements with gst_bin_remove().
42  *
43  * An element can be retrieved from a bin with gst_bin_get_by_name(), using the
44  * elements name. gst_bin_get_by_name_recurse_up() is mainly used for internal
45  * purposes and will query the parent bins when the element is not found in the
46  * current bin.
47  *
48  * An iterator of elements in a bin can be retrieved with
49  * gst_bin_iterate_elements(). Various other iterators exist to retrieve the
50  * elements in a bin.
51  *
52  * gst_object_unref() is used to drop your reference to the bin.
53  *
54  * The #GstBin::element-added signal is fired whenever a new element is added to
55  * the bin. Likewise the #GstBin::element-removed signal is fired whenever an
56  * element is removed from the bin.
57  *
58  * <refsect2><title>Notes</title>
59  * <para>
60  * A #GstBin internally intercepts every #GstMessage posted by its children and
61  * implements the following default behaviour for each of them:
62  * <variablelist>
63  *   <varlistentry>
64  *     <term>GST_MESSAGE_EOS</term>
65  *     <listitem><para>This message is only posted by sinks in the PLAYING
66  *     state. If all sinks posted the EOS message, this bin will post and EOS
67  *     message upwards.</para></listitem>
68  *   </varlistentry>
69  *   <varlistentry>
70  *     <term>GST_MESSAGE_SEGMENT_START</term>
71  *     <listitem><para>just collected and never forwarded upwards.
72  *     The messages are used to decide when all elements have completed playback
73  *     of their segment.</para></listitem>
74  *   </varlistentry>
75  *   <varlistentry>
76  *     <term>GST_MESSAGE_SEGMENT_DONE</term>
77  *     <listitem><para> Is posted by #GstBin when all elements that posted
78  *     a SEGMENT_START have posted a SEGMENT_DONE.</para></listitem>
79  *   </varlistentry>
80  *   <varlistentry>
81  *     <term>GST_MESSAGE_DURATION</term>
82  *     <listitem><para> Is posted by an element that detected a change
83  *     in the stream duration. The default bin behaviour is to clear any
84  *     cached duration values so that the next duration query will perform
85  *     a full duration recalculation. The duration change is posted to the
86  *     application so that it can refetch the new duration with a duration
87  *     query. Note that these messages can be posted before the bin is
88  *     prerolled, in which case the duration query might fail.
89  *     </para></listitem>
90  *   </varlistentry>
91  *   <varlistentry>
92  *     <term>GST_MESSAGE_CLOCK_LOST</term>
93  *     <listitem><para> This message is posted by an element when it
94  *     can no longer provide a clock. The default bin behaviour is to
95  *     check if the lost clock was the one provided by the bin. If so and
96  *     the bin is currently in the PLAYING state, the message is forwarded to
97  *     the bin parent.
98  *     This message is also generated when a clock provider is removed from
99  *     the bin. If this message is received by the application, it should
100  *     PAUSE the pipeline and set it back to PLAYING to force a new clock
101  *     distribution.
102  *     </para></listitem>
103  *   </varlistentry>
104  *   <varlistentry>
105  *     <term>GST_MESSAGE_CLOCK_PROVIDE</term>
106  *     <listitem><para> This message is generated when an element
107  *     can provide a clock. This mostly happens when a new clock
108  *     provider is added to the bin. The default behaviour of the bin is to
109  *     mark the currently selected clock as dirty, which will perform a clock
110  *     recalculation the next time the bin is asked to provide a clock.
111  *     This message is never sent tot the application but is forwarded to
112  *     the parent of the bin.
113  *     </para></listitem>
114  *   </varlistentry>
115  *   <varlistentry>
116  *     <term>OTHERS</term>
117  *     <listitem><para> posted upwards.</para></listitem>
118  *   </varlistentry>
119  * </variablelist>
120  *
121  *
122  * A #GstBin implements the following default behaviour for answering to a
123  * #GstQuery:
124  * <variablelist>
125  *   <varlistentry>
126  *     <term>GST_QUERY_DURATION</term>
127  *     <listitem><para>If the query has been asked before with the same format
128  *     and the bin is a toplevel bin (ie. has no parent),
129  *     use the cached previous value. If no previous value was cached, the
130  *     query is sent to all sink elements in the bin and the MAXIMUM of all
131  *     values is returned. If the bin is a toplevel bin the value is cached.
132  *     If no sinks are available in the bin, the query fails.
133  *     </para></listitem>
134  *   </varlistentry>
135  *   <varlistentry>
136  *     <term>GST_QUERY_POSITION</term>
137  *     <listitem><para>The query is sent to all sink elements in the bin and the
138  *     MAXIMUM of all values is returned. If no sinks are available in the bin,
139  *     the query fails.
140  *     </para></listitem>
141  *   </varlistentry>
142  *   <varlistentry>
143  *     <term>OTHERS</term>
144  *     <listitem><para>the query is forwarded to all sink elements, the result
145  *     of the first sink that answers the query successfully is returned. If no
146  *     sink is in the bin, the query fails.</para></listitem>
147  *   </varlistentry>
148  * </variablelist>
149  *
150  * A #GstBin will by default forward any event sent to it to all sink elements.
151  * If all the sinks return TRUE, the bin will also return TRUE, else FALSE is
152  * returned. If no sinks are in the bin, the event handler will return TRUE.
153  *
154  * </para>
155  * </refsect2>
156  *
157  * Last reviewed on 2006-04-28 (0.10.6)
158  */
159
160 #include "gst_private.h"
161
162 #include "gstevent.h"
163 #include "gstbin.h"
164 #include "gstmarshal.h"
165 #include "gstinfo.h"
166 #include "gsterror.h"
167
168 #include "gstutils.h"
169 #include "gstchildproxy.h"
170
171 /* latency is by default enabled now.
172  * live-preroll and no-live-preroll in the environment var GST_COMPAT
173  * to enables or disable it respectively.
174  */
175 static gboolean enable_latency = TRUE;
176
177 GST_DEBUG_CATEGORY_STATIC (bin_debug);
178 #define GST_CAT_DEFAULT bin_debug
179
180 /* a bin is toplevel if it has no parent or when it is configured to behave like
181  * a toplevel bin */
182 #define BIN_IS_TOPLEVEL(bin) ((GST_OBJECT_PARENT (bin) == NULL) || bin->priv->asynchandling)
183
184 #define GST_BIN_GET_PRIVATE(obj)  \
185    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BIN, GstBinPrivate))
186
187 struct _GstBinPrivate
188 {
189   gboolean asynchandling;
190   /* if we get an ASYNC_DONE message from ourselves, this means that the
191    * subclass will simulate ASYNC behaviour without having ASYNC children. When
192    * such an ASYNC_DONE message is posted while we are doing a state change, we
193    * have to process the message after finishing the state change even when no
194    * child returned GST_STATE_CHANGE_ASYNC. */
195   gboolean pending_async_done;
196
197   guint32 structure_cookie;
198
199 #if 0
200   /* cached index */
201   GstIndex *index;
202 #endif
203
204   /* forward messages from our children */
205   gboolean message_forward;
206
207   gboolean posted_eos;
208 };
209
210 typedef struct
211 {
212   GstBin *bin;
213   guint32 cookie;
214   GstState pending;
215 } BinContinueData;
216
217 static void gst_bin_dispose (GObject * object);
218
219 static void gst_bin_set_property (GObject * object, guint prop_id,
220     const GValue * value, GParamSpec * pspec);
221 static void gst_bin_get_property (GObject * object, guint prop_id,
222     GValue * value, GParamSpec * pspec);
223
224 static GstStateChangeReturn gst_bin_change_state_func (GstElement * element,
225     GstStateChange transition);
226 static void gst_bin_state_changed (GstElement * element, GstState oldstate,
227     GstState newstate, GstState pending);
228 static GstStateChangeReturn gst_bin_get_state_func (GstElement * element,
229     GstState * state, GstState * pending, GstClockTime timeout);
230 static void bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret,
231     gboolean flag_pending, gboolean reset_time);
232 static void bin_handle_async_start (GstBin * bin);
233 static void bin_push_state_continue (BinContinueData * data);
234 static void bin_do_eos (GstBin * bin);
235
236 static gboolean gst_bin_add_func (GstBin * bin, GstElement * element);
237 static gboolean gst_bin_remove_func (GstBin * bin, GstElement * element);
238
239 #if 0
240 static void gst_bin_set_index_func (GstElement * element, GstIndex * index);
241 static GstIndex *gst_bin_get_index_func (GstElement * element);
242 #endif
243
244 static GstClock *gst_bin_provide_clock_func (GstElement * element);
245 static gboolean gst_bin_set_clock_func (GstElement * element, GstClock * clock);
246
247 static void gst_bin_handle_message_func (GstBin * bin, GstMessage * message);
248 static gboolean gst_bin_send_event (GstElement * element, GstEvent * event);
249 static GstBusSyncReply bin_bus_handler (GstBus * bus,
250     GstMessage * message, GstBin * bin);
251 static gboolean gst_bin_query (GstElement * element, GstQuery * query);
252
253 static gboolean gst_bin_do_latency_func (GstBin * bin);
254
255 static void bin_remove_messages (GstBin * bin, GstObject * src,
256     GstMessageType types);
257 static void gst_bin_continue_func (BinContinueData * data);
258 static gint bin_element_is_sink (GstElement * child, GstBin * bin);
259 static gint bin_element_is_src (GstElement * child, GstBin * bin);
260
261 static GstIterator *gst_bin_sort_iterator_new (GstBin * bin);
262
263 /* Bin signals and properties */
264 enum
265 {
266   ELEMENT_ADDED,
267   ELEMENT_REMOVED,
268   DO_LATENCY,
269   LAST_SIGNAL
270 };
271
272 #define DEFAULT_ASYNC_HANDLING  FALSE
273 #define DEFAULT_MESSAGE_FORWARD FALSE
274
275 enum
276 {
277   PROP_0,
278   PROP_ASYNC_HANDLING,
279   PROP_MESSAGE_FORWARD,
280   PROP_LAST
281 };
282
283 static void gst_bin_child_proxy_init (gpointer g_iface, gpointer iface_data);
284
285 static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
286
287 #define _do_init \
288 { \
289   const gchar *compat; \
290   static const GInterfaceInfo iface_info = { \
291     gst_bin_child_proxy_init, \
292     NULL, \
293     NULL}; \
294   \
295   g_type_add_interface_static (g_define_type_id, GST_TYPE_CHILD_PROXY, &iface_info); \
296   \
297   GST_DEBUG_CATEGORY_INIT (bin_debug, "bin", GST_DEBUG_BOLD, \
298       "debugging info for the 'bin' container element"); \
299   \
300   /* compatibility stuff */ \
301   compat = g_getenv ("GST_COMPAT"); \
302   if (compat != NULL) { \
303     if (strstr (compat, "no-live-preroll")) \
304       enable_latency = FALSE; \
305     else if (strstr (compat, "live-preroll")) \
306       enable_latency = TRUE; \
307   } \
308 }
309
310 #define gst_bin_parent_class parent_class
311 G_DEFINE_TYPE_WITH_CODE (GstBin, gst_bin, GST_TYPE_ELEMENT, _do_init);
312
313 static GstObject *
314 gst_bin_child_proxy_get_child_by_index (GstChildProxy * child_proxy,
315     guint index)
316 {
317   GstObject *res;
318   GstBin *bin;
319
320   bin = GST_BIN_CAST (child_proxy);
321
322   GST_OBJECT_LOCK (bin);
323   if ((res = g_list_nth_data (bin->children, index)))
324     gst_object_ref (res);
325   GST_OBJECT_UNLOCK (bin);
326
327   return res;
328 }
329
330 static guint
331 gst_bin_child_proxy_get_children_count (GstChildProxy * child_proxy)
332 {
333   guint num;
334   GstBin *bin;
335
336   bin = GST_BIN_CAST (child_proxy);
337
338   GST_OBJECT_LOCK (bin);
339   num = bin->numchildren;
340   GST_OBJECT_UNLOCK (bin);
341
342   return num;
343 }
344
345 static void
346 gst_bin_child_proxy_init (gpointer g_iface, gpointer iface_data)
347 {
348   GstChildProxyInterface *iface = g_iface;
349
350   iface->get_children_count = gst_bin_child_proxy_get_children_count;
351   iface->get_child_by_index = gst_bin_child_proxy_get_child_by_index;
352 }
353
354 static gboolean
355 _gst_boolean_accumulator (GSignalInvocationHint * ihint,
356     GValue * return_accu, const GValue * handler_return, gpointer dummy)
357 {
358   gboolean myboolean;
359
360   myboolean = g_value_get_boolean (handler_return);
361   if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))
362     g_value_set_boolean (return_accu, myboolean);
363
364   GST_DEBUG ("invocation %d, %d", ihint->run_type, myboolean);
365
366   /* stop emission */
367   return FALSE;
368 }
369
370 static void
371 gst_bin_class_init (GstBinClass * klass)
372 {
373   GObjectClass *gobject_class;
374   GstElementClass *gstelement_class;
375   GError *err;
376
377   gobject_class = (GObjectClass *) klass;
378   gstelement_class = (GstElementClass *) klass;
379
380   g_type_class_add_private (klass, sizeof (GstBinPrivate));
381
382   gobject_class->set_property = gst_bin_set_property;
383   gobject_class->get_property = gst_bin_get_property;
384
385   /**
386    * GstBin:async-handling
387    *
388    * If set to #TRUE, the bin will handle asynchronous state changes.
389    * This should be used only if the bin subclass is modifying the state
390    * of its children on its own.
391    *
392    * Since: 0.10.13
393    */
394   g_object_class_install_property (gobject_class, PROP_ASYNC_HANDLING,
395       g_param_spec_boolean ("async-handling", "Async Handling",
396           "The bin will handle Asynchronous state changes",
397           DEFAULT_ASYNC_HANDLING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
398
399   /**
400    * GstBin::element-added:
401    * @bin: the #GstBin
402    * @element: the #GstElement that was added to the bin
403    *
404    * Will be emitted after the element was added to the bin.
405    */
406   gst_bin_signals[ELEMENT_ADDED] =
407       g_signal_new ("element-added", G_TYPE_FROM_CLASS (klass),
408       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GstBinClass, element_added), NULL,
409       NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
410   /**
411    * GstBin::element-removed:
412    * @bin: the #GstBin
413    * @element: the #GstElement that was removed from the bin
414    *
415    * Will be emitted after the element was removed from the bin.
416    */
417   gst_bin_signals[ELEMENT_REMOVED] =
418       g_signal_new ("element-removed", G_TYPE_FROM_CLASS (klass),
419       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GstBinClass, element_removed), NULL,
420       NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
421   /**
422    * GstBin::do-latency:
423    * @bin: the #GstBin
424    *
425    * Will be emitted when the bin needs to perform latency calculations. This
426    * signal is only emited for toplevel bins or when async-handling is
427    * enabled.
428    *
429    * Only one signal handler is invoked. If no signals are connected, the
430    * default handler is invoked, which will query and distribute the lowest
431    * possible latency to all sinks.
432    *
433    * Connect to this signal if the default latency calculations are not
434    * sufficient, like when you need different latencies for different sinks in
435    * the same pipeline.
436    *
437    * Since: 0.10.22
438    */
439   gst_bin_signals[DO_LATENCY] =
440       g_signal_new ("do-latency", G_TYPE_FROM_CLASS (klass),
441       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstBinClass, do_latency),
442       _gst_boolean_accumulator, NULL, gst_marshal_BOOLEAN__VOID,
443       G_TYPE_BOOLEAN, 0, G_TYPE_NONE);
444
445   /**
446    * GstBin:message-forward
447    *
448    * Forward all children messages, even those that would normally be filtered by
449    * the bin. This can be interesting when one wants to be notified of the EOS
450    * state of individual elements, for example.
451    *
452    * The messages are converted to an ELEMENT message with the bin as the
453    * source. The structure of the message is named 'GstBinForwarded' and contains
454    * a field named 'message' of type GST_TYPE_MESSAGE that contains the original
455    * forwarded message.
456    *
457    * Since: 0.10.31
458    */
459   g_object_class_install_property (gobject_class, PROP_MESSAGE_FORWARD,
460       g_param_spec_boolean ("message-forward", "Message Forward",
461           "Forwards all children messages",
462           DEFAULT_MESSAGE_FORWARD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
463
464   gobject_class->dispose = gst_bin_dispose;
465
466   gst_element_class_set_metadata (gstelement_class, "Generic bin",
467       "Generic/Bin",
468       "Simple container object",
469       "Erik Walthinsen <omega@cse.ogi.edu>,"
470       "Wim Taymans <wim.taymans@gmail.com>");
471
472   gstelement_class->change_state =
473       GST_DEBUG_FUNCPTR (gst_bin_change_state_func);
474   gstelement_class->state_changed = GST_DEBUG_FUNCPTR (gst_bin_state_changed);
475   gstelement_class->get_state = GST_DEBUG_FUNCPTR (gst_bin_get_state_func);
476 #if 0
477   gstelement_class->get_index = GST_DEBUG_FUNCPTR (gst_bin_get_index_func);
478   gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_bin_set_index_func);
479 #endif
480   gstelement_class->provide_clock =
481       GST_DEBUG_FUNCPTR (gst_bin_provide_clock_func);
482   gstelement_class->set_clock = GST_DEBUG_FUNCPTR (gst_bin_set_clock_func);
483
484   gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_bin_send_event);
485   gstelement_class->query = GST_DEBUG_FUNCPTR (gst_bin_query);
486
487   klass->add_element = GST_DEBUG_FUNCPTR (gst_bin_add_func);
488   klass->remove_element = GST_DEBUG_FUNCPTR (gst_bin_remove_func);
489   klass->handle_message = GST_DEBUG_FUNCPTR (gst_bin_handle_message_func);
490
491   klass->do_latency = GST_DEBUG_FUNCPTR (gst_bin_do_latency_func);
492
493   GST_DEBUG ("creating bin thread pool");
494   err = NULL;
495   klass->pool =
496       g_thread_pool_new ((GFunc) gst_bin_continue_func, NULL, -1, FALSE, &err);
497   if (err != NULL) {
498     g_critical ("could alloc threadpool %s", err->message);
499   }
500 }
501
502 static void
503 gst_bin_init (GstBin * bin)
504 {
505   GstBus *bus;
506
507   bin->numchildren = 0;
508   bin->children = NULL;
509   bin->children_cookie = 0;
510   bin->messages = NULL;
511   bin->provided_clock = NULL;
512   bin->clock_dirty = FALSE;
513
514   /* Set up a bus for listening to child elements */
515   bus = g_object_new (GST_TYPE_BUS, "enable-async", FALSE, NULL);
516   bin->child_bus = bus;
517   GST_DEBUG_OBJECT (bin, "using bus %" GST_PTR_FORMAT " to listen to children",
518       bus);
519   gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bin_bus_handler, bin);
520
521   bin->priv = GST_BIN_GET_PRIVATE (bin);
522   bin->priv->asynchandling = DEFAULT_ASYNC_HANDLING;
523   bin->priv->structure_cookie = 0;
524   bin->priv->message_forward = DEFAULT_MESSAGE_FORWARD;
525 }
526
527 static void
528 gst_bin_dispose (GObject * object)
529 {
530   GstBin *bin = GST_BIN_CAST (object);
531   GstBus **child_bus_p = &bin->child_bus;
532   GstClock **provided_clock_p = &bin->provided_clock;
533   GstElement **clock_provider_p = &bin->clock_provider;
534
535   GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object, "dispose");
536
537   GST_OBJECT_LOCK (object);
538   gst_object_replace ((GstObject **) child_bus_p, NULL);
539   gst_object_replace ((GstObject **) provided_clock_p, NULL);
540   gst_object_replace ((GstObject **) clock_provider_p, NULL);
541   bin_remove_messages (bin, NULL, GST_MESSAGE_ANY);
542   GST_OBJECT_UNLOCK (object);
543
544   while (bin->children) {
545     gst_bin_remove (bin, GST_ELEMENT_CAST (bin->children->data));
546   }
547   if (G_UNLIKELY (bin->children != NULL)) {
548     g_critical ("could not remove elements from bin '%s'",
549         GST_STR_NULL (GST_OBJECT_NAME (object)));
550   }
551
552   G_OBJECT_CLASS (parent_class)->dispose (object);
553 }
554
555 /**
556  * gst_bin_new:
557  * @name: the name of the new bin
558  *
559  * Creates a new bin with the given name.
560  *
561  * Returns: (transfer floating): a new #GstBin
562  */
563 GstElement *
564 gst_bin_new (const gchar * name)
565 {
566   return gst_element_factory_make ("bin", name);
567 }
568
569 static void
570 gst_bin_set_property (GObject * object, guint prop_id,
571     const GValue * value, GParamSpec * pspec)
572 {
573   GstBin *gstbin;
574
575   gstbin = GST_BIN_CAST (object);
576
577   switch (prop_id) {
578     case PROP_ASYNC_HANDLING:
579       GST_OBJECT_LOCK (gstbin);
580       gstbin->priv->asynchandling = g_value_get_boolean (value);
581       GST_OBJECT_UNLOCK (gstbin);
582       break;
583     case PROP_MESSAGE_FORWARD:
584       GST_OBJECT_LOCK (gstbin);
585       gstbin->priv->message_forward = g_value_get_boolean (value);
586       GST_OBJECT_UNLOCK (gstbin);
587       break;
588     default:
589       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
590       break;
591   }
592 }
593
594 static void
595 gst_bin_get_property (GObject * object, guint prop_id,
596     GValue * value, GParamSpec * pspec)
597 {
598   GstBin *gstbin;
599
600   gstbin = GST_BIN_CAST (object);
601
602   switch (prop_id) {
603     case PROP_ASYNC_HANDLING:
604       GST_OBJECT_LOCK (gstbin);
605       g_value_set_boolean (value, gstbin->priv->asynchandling);
606       GST_OBJECT_UNLOCK (gstbin);
607       break;
608     case PROP_MESSAGE_FORWARD:
609       GST_OBJECT_LOCK (gstbin);
610       g_value_set_boolean (value, gstbin->priv->message_forward);
611       GST_OBJECT_UNLOCK (gstbin);
612       break;
613     default:
614       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
615       break;
616   }
617 }
618
619 #if 0
620 /* return the cached index */
621 static GstIndex *
622 gst_bin_get_index_func (GstElement * element)
623 {
624   GstBin *bin;
625   GstIndex *result;
626
627   bin = GST_BIN_CAST (element);
628
629   GST_OBJECT_LOCK (bin);
630   if ((result = bin->priv->index))
631     gst_object_ref (result);
632   GST_OBJECT_UNLOCK (bin);
633
634   return result;
635 }
636
637 /* set the index on all elements in this bin
638  *
639  * MT safe
640  */
641 static void
642 gst_bin_set_index_func (GstElement * element, GstIndex * index)
643 {
644   GstBin *bin;
645   gboolean done;
646   GstIterator *it;
647   GstIndex *old;
648   GValue data = { 0, };
649
650   bin = GST_BIN_CAST (element);
651
652   GST_OBJECT_LOCK (bin);
653   old = bin->priv->index;
654   if (G_UNLIKELY (old == index))
655     goto was_set;
656   if (index)
657     gst_object_ref (index);
658   bin->priv->index = index;
659   GST_OBJECT_UNLOCK (bin);
660
661   if (old)
662     gst_object_unref (old);
663
664   it = gst_bin_iterate_elements (bin);
665
666   /* set the index on all elements in the bin */
667   done = FALSE;
668   while (!done) {
669     switch (gst_iterator_next (it, &data)) {
670       case GST_ITERATOR_OK:
671       {
672         GstElement *child = g_value_get_object (&data);
673
674         GST_DEBUG_OBJECT (bin, "setting index on '%s'",
675             GST_ELEMENT_NAME (child));
676         gst_element_set_index (child, index);
677
678         g_value_reset (&data);
679         break;
680       }
681       case GST_ITERATOR_RESYNC:
682         GST_DEBUG_OBJECT (bin, "iterator doing resync");
683         gst_iterator_resync (it);
684         break;
685       default:
686       case GST_ITERATOR_DONE:
687         GST_DEBUG_OBJECT (bin, "iterator done");
688         done = TRUE;
689         break;
690     }
691   }
692   g_value_unset (&data);
693   gst_iterator_free (it);
694   return;
695
696 was_set:
697   {
698     GST_DEBUG_OBJECT (bin, "index was already set");
699     GST_OBJECT_UNLOCK (bin);
700     return;
701   }
702 }
703 #endif
704
705 /* set the clock on all elements in this bin
706  *
707  * MT safe
708  */
709 static gboolean
710 gst_bin_set_clock_func (GstElement * element, GstClock * clock)
711 {
712   GstBin *bin;
713   gboolean done;
714   GstIterator *it;
715   gboolean res = TRUE;
716   GValue data = { 0, };
717
718   bin = GST_BIN_CAST (element);
719
720   it = gst_bin_iterate_elements (bin);
721
722   done = FALSE;
723   while (!done) {
724     switch (gst_iterator_next (it, &data)) {
725       case GST_ITERATOR_OK:
726       {
727         GstElement *child = g_value_get_object (&data);
728
729         res &= gst_element_set_clock (child, clock);
730
731         g_value_reset (&data);
732         break;
733       }
734       case GST_ITERATOR_RESYNC:
735         GST_DEBUG_OBJECT (bin, "iterator doing resync");
736         gst_iterator_resync (it);
737         res = TRUE;
738         break;
739       default:
740       case GST_ITERATOR_DONE:
741         GST_DEBUG_OBJECT (bin, "iterator done");
742         done = TRUE;
743         break;
744     }
745   }
746   g_value_unset (&data);
747   gst_iterator_free (it);
748
749   if (res)
750     res = GST_ELEMENT_CLASS (parent_class)->set_clock (element, clock);
751
752   return res;
753 }
754
755 /* get the clock for this bin by asking all of the children in this bin
756  *
757  * The ref of the returned clock in increased so unref after usage.
758  *
759  * We loop the elements in state order and pick the last clock we can
760  * get. This makes sure we get a clock from the source.
761  *
762  * MT safe
763  */
764 static GstClock *
765 gst_bin_provide_clock_func (GstElement * element)
766 {
767   GstClock *result = NULL;
768   GstElement *provider = NULL;
769   GstBin *bin;
770   GstIterator *it;
771   gboolean done;
772   GValue val = { 0, };
773   GstClock **provided_clock_p;
774   GstElement **clock_provider_p;
775
776   bin = GST_BIN_CAST (element);
777
778   GST_OBJECT_LOCK (bin);
779   if (!bin->clock_dirty)
780     goto not_dirty;
781
782   GST_DEBUG_OBJECT (bin, "finding new clock");
783
784   it = gst_bin_sort_iterator_new (bin);
785   GST_OBJECT_UNLOCK (bin);
786
787   done = FALSE;
788   while (!done) {
789     switch (gst_iterator_next (it, &val)) {
790       case GST_ITERATOR_OK:
791       {
792         GstElement *child = g_value_get_object (&val);
793         GstClock *clock;
794
795         clock = gst_element_provide_clock (child);
796         if (clock) {
797           GST_DEBUG_OBJECT (bin, "found candidate clock %p by element %s",
798               clock, GST_ELEMENT_NAME (child));
799           if (result) {
800             gst_object_unref (result);
801             gst_object_unref (provider);
802           }
803           result = clock;
804           provider = gst_object_ref (child);
805         }
806
807         g_value_reset (&val);
808         break;
809       }
810       case GST_ITERATOR_RESYNC:
811         gst_iterator_resync (it);
812         break;
813       default:
814       case GST_ITERATOR_DONE:
815         done = TRUE;
816         break;
817     }
818   }
819   g_value_unset (&val);
820   gst_iterator_free (it);
821
822   GST_OBJECT_LOCK (bin);
823   if (!bin->clock_dirty) {
824     if (provider)
825       gst_object_unref (provider);
826     if (result)
827       gst_object_unref (result);
828     result = NULL;
829
830     goto not_dirty;
831   }
832
833   provided_clock_p = &bin->provided_clock;
834   clock_provider_p = &bin->clock_provider;
835   gst_object_replace ((GstObject **) provided_clock_p, (GstObject *) result);
836   gst_object_replace ((GstObject **) clock_provider_p, (GstObject *) provider);
837   bin->clock_dirty = FALSE;
838   GST_DEBUG_OBJECT (bin,
839       "provided new clock %" GST_PTR_FORMAT " by provider %" GST_PTR_FORMAT,
840       result, provider);
841   /* Provider is not being returned to caller, just the result */
842   if (provider)
843     gst_object_unref (provider);
844   GST_OBJECT_UNLOCK (bin);
845
846   return result;
847
848 not_dirty:
849   {
850     if ((result = bin->provided_clock))
851       gst_object_ref (result);
852     GST_DEBUG_OBJECT (bin, "returning old clock %p", result);
853     GST_OBJECT_UNLOCK (bin);
854
855     return result;
856   }
857 }
858
859 /*
860  * functions for manipulating cached messages
861  */
862 typedef struct
863 {
864   GstObject *src;
865   GstMessageType types;
866 } MessageFind;
867
868 /* check if a message is of given src and type */
869 static gint
870 message_check (GstMessage * message, MessageFind * target)
871 {
872   gboolean eq = TRUE;
873
874   if (target->src)
875     eq &= GST_MESSAGE_SRC (message) == target->src;
876   if (target->types)
877     eq &= (GST_MESSAGE_TYPE (message) & target->types) != 0;
878   GST_LOG ("looking at message %p: %d", message, eq);
879
880   return (eq ? 0 : 1);
881 }
882
883 static GList *
884 find_message (GstBin * bin, GstObject * src, GstMessageType types)
885 {
886   GList *result;
887   MessageFind find;
888
889   find.src = src;
890   find.types = types;
891
892   result = g_list_find_custom (bin->messages, &find,
893       (GCompareFunc) message_check);
894
895   if (result) {
896     GST_DEBUG_OBJECT (bin, "we found a message %p from %s matching types %08x",
897         result->data, GST_OBJECT_NAME (GST_MESSAGE_CAST (result->data)->src),
898         types);
899   } else {
900     GST_DEBUG_OBJECT (bin, "no message found matching types %08x", types);
901 #ifndef GST_DISABLE_GST_DEBUG
902     {
903       guint i;
904
905       for (i = 0; i < 32; i++)
906         if (types & (1 << i))
907           GST_DEBUG_OBJECT (bin, "  %s", gst_message_type_get_name (1 << i));
908     }
909 #endif
910   }
911
912   return result;
913 }
914
915 /* with LOCK, returns TRUE if message had a valid SRC, takes ownership of
916  * the message.
917  *
918  * A message that is cached and has the same SRC and type is replaced
919  * by the given message.
920  */
921 static gboolean
922 bin_replace_message (GstBin * bin, GstMessage * message, GstMessageType types)
923 {
924   GList *previous;
925   GstObject *src;
926   gboolean res = TRUE;
927
928   if ((src = GST_MESSAGE_SRC (message))) {
929     /* first find the previous message posted by this element */
930     if ((previous = find_message (bin, src, types))) {
931       GstMessage *previous_msg;
932
933       /* if we found a previous message, replace it */
934       previous_msg = previous->data;
935       previous->data = message;
936
937       GST_DEBUG_OBJECT (bin, "replace old message %s from %s with %s message",
938           GST_MESSAGE_TYPE_NAME (previous_msg), GST_ELEMENT_NAME (src),
939           GST_MESSAGE_TYPE_NAME (message));
940
941       gst_message_unref (previous_msg);
942     } else {
943       /* keep new message */
944       bin->messages = g_list_prepend (bin->messages, message);
945
946       GST_DEBUG_OBJECT (bin, "got new message %p, %s from %s",
947           message, GST_MESSAGE_TYPE_NAME (message), GST_ELEMENT_NAME (src));
948     }
949   } else {
950     GST_DEBUG_OBJECT (bin, "got message %s from (NULL), not processing",
951         GST_MESSAGE_TYPE_NAME (message));
952     res = FALSE;
953     gst_message_unref (message);
954   }
955   return res;
956 }
957
958 /* with LOCK. Remove all messages of given types */
959 static void
960 bin_remove_messages (GstBin * bin, GstObject * src, GstMessageType types)
961 {
962   MessageFind find;
963   GList *walk, *next;
964
965   find.src = src;
966   find.types = types;
967
968   for (walk = bin->messages; walk; walk = next) {
969     GstMessage *message = (GstMessage *) walk->data;
970
971     next = g_list_next (walk);
972
973     if (message_check (message, &find) == 0) {
974       GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message),
975           "deleting message %p of types 0x%08x", message, types);
976       bin->messages = g_list_delete_link (bin->messages, walk);
977       gst_message_unref (message);
978     } else {
979       GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message),
980           "not deleting message %p of type 0x%08x", message,
981           GST_MESSAGE_TYPE (message));
982     }
983   }
984 }
985
986
987 /* Check if the bin is EOS. We do this by scanning all sinks and
988  * checking if they posted an EOS message.
989  *
990  * call with bin LOCK */
991 static gboolean
992 is_eos (GstBin * bin, guint32 * seqnum)
993 {
994   gboolean result;
995   gint n_eos = 0;
996   GList *walk, *msgs;
997
998   result = TRUE;
999   for (walk = bin->children; walk; walk = g_list_next (walk)) {
1000     GstElement *element;
1001
1002     element = GST_ELEMENT_CAST (walk->data);
1003     if (bin_element_is_sink (element, bin) == 0) {
1004       /* check if element posted EOS */
1005       if ((msgs =
1006               find_message (bin, GST_OBJECT_CAST (element), GST_MESSAGE_EOS))) {
1007         GST_DEBUG ("sink '%s' posted EOS", GST_ELEMENT_NAME (element));
1008         *seqnum = gst_message_get_seqnum (GST_MESSAGE_CAST (msgs->data));
1009         n_eos++;
1010       } else {
1011         GST_DEBUG ("sink '%s' did not post EOS yet",
1012             GST_ELEMENT_NAME (element));
1013         result = FALSE;
1014         break;
1015       }
1016     }
1017   }
1018   /* FIXME: Some tests (e.g. elements/capsfilter) use
1019    * pipelines with a dangling sinkpad but no sink element.
1020    * These tests assume that no EOS message is ever
1021    * posted on the bus so let's keep that behaviour.
1022    * In valid pipelines this doesn't make a difference.
1023    */
1024   return result && n_eos > 0;
1025 }
1026
1027 static void
1028 unlink_pads (const GValue * item, gpointer user_data)
1029 {
1030   GstPad *pad;
1031   GstPad *peer;
1032
1033   pad = g_value_get_object (item);
1034
1035   if ((peer = gst_pad_get_peer (pad))) {
1036     if (gst_pad_get_direction (pad) == GST_PAD_SRC)
1037       gst_pad_unlink (pad, peer);
1038     else
1039       gst_pad_unlink (peer, pad);
1040     gst_object_unref (peer);
1041   }
1042 }
1043
1044 /* vmethod that adds an element to a bin
1045  *
1046  * MT safe
1047  */
1048 static gboolean
1049 gst_bin_add_func (GstBin * bin, GstElement * element)
1050 {
1051   gchar *elem_name;
1052   GstIterator *it;
1053   gboolean is_sink, is_source, provides_clock, requires_clock;
1054   GstMessage *clock_message = NULL, *async_message = NULL;
1055   GstStateChangeReturn ret;
1056
1057   GST_DEBUG_OBJECT (bin, "element :%s", GST_ELEMENT_NAME (element));
1058
1059   /* we obviously can't add ourself to ourself */
1060   if (G_UNLIKELY (GST_ELEMENT_CAST (element) == GST_ELEMENT_CAST (bin)))
1061     goto adding_itself;
1062
1063   /* get the element name to make sure it is unique in this bin. */
1064   GST_OBJECT_LOCK (element);
1065   elem_name = g_strdup (GST_ELEMENT_NAME (element));
1066   is_sink = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SINK);
1067   is_source = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SOURCE);
1068   provides_clock =
1069       GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
1070   requires_clock =
1071       GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_REQUIRE_CLOCK);
1072   GST_OBJECT_UNLOCK (element);
1073
1074   GST_OBJECT_LOCK (bin);
1075
1076   /* then check to see if the element's name is already taken in the bin,
1077    * we can safely take the lock here. This check is probably bogus because
1078    * you can safely change the element name after this check and before setting
1079    * the object parent. The window is very small though... */
1080   if (G_UNLIKELY (!gst_object_check_uniqueness (bin->children, elem_name)))
1081     goto duplicate_name;
1082
1083   /* set the element's parent and add the element to the bin's list of children */
1084   if (G_UNLIKELY (!gst_object_set_parent (GST_OBJECT_CAST (element),
1085               GST_OBJECT_CAST (bin))))
1086     goto had_parent;
1087
1088   /* if we add a sink we become a sink */
1089   if (is_sink) {
1090     GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, bin, "element \"%s\" was sink",
1091         elem_name);
1092     GST_OBJECT_FLAG_SET (bin, GST_ELEMENT_FLAG_SINK);
1093   }
1094   if (is_source) {
1095     GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, bin, "element \"%s\" was source",
1096         elem_name);
1097     GST_OBJECT_FLAG_SET (bin, GST_ELEMENT_FLAG_SOURCE);
1098   }
1099   if (provides_clock) {
1100     GST_DEBUG_OBJECT (bin, "element \"%s\" can provide a clock", elem_name);
1101     clock_message =
1102         gst_message_new_clock_provide (GST_OBJECT_CAST (element), NULL, TRUE);
1103     GST_OBJECT_FLAG_SET (bin, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
1104   }
1105   if (requires_clock) {
1106     GST_DEBUG_OBJECT (bin, "element \"%s\" requires a clock", elem_name);
1107     GST_OBJECT_FLAG_SET (bin, GST_ELEMENT_FLAG_REQUIRE_CLOCK);
1108   }
1109
1110   bin->children = g_list_prepend (bin->children, element);
1111   bin->numchildren++;
1112   bin->children_cookie++;
1113   bin->priv->structure_cookie++;
1114
1115   /* distribute the bus */
1116   gst_element_set_bus (element, bin->child_bus);
1117
1118   /* propagate the current base_time, start_time and clock */
1119   gst_element_set_base_time (element, GST_ELEMENT_CAST (bin)->base_time);
1120   gst_element_set_start_time (element, GST_ELEMENT_START_TIME (bin));
1121   /* it's possible that the element did not accept the clock but
1122    * that is not important right now. When the pipeline goes to PLAYING,
1123    * a new clock will be selected */
1124   gst_element_set_clock (element, GST_ELEMENT_CLOCK (bin));
1125
1126 #if 0
1127   /* set the cached index on the children */
1128   if (bin->priv->index)
1129     gst_element_set_index (element, bin->priv->index);
1130 #endif
1131
1132   ret = GST_STATE_RETURN (bin);
1133   /* no need to update the state if we are in error */
1134   if (ret == GST_STATE_CHANGE_FAILURE)
1135     goto no_state_recalc;
1136
1137   /* update the bin state, the new element could have been an ASYNC or
1138    * NO_PREROLL element */
1139   ret = GST_STATE_RETURN (element);
1140   GST_DEBUG_OBJECT (bin, "added %s element",
1141       gst_element_state_change_return_get_name (ret));
1142
1143   switch (ret) {
1144     case GST_STATE_CHANGE_ASYNC:
1145     {
1146       /* create message to track this aync element when it posts an async-done
1147        * message */
1148       async_message = gst_message_new_async_start (GST_OBJECT_CAST (element));
1149       break;
1150     }
1151     case GST_STATE_CHANGE_NO_PREROLL:
1152       /* ignore all async elements we might have and commit our state */
1153       bin_handle_async_done (bin, ret, FALSE, FALSE);
1154       break;
1155     case GST_STATE_CHANGE_FAILURE:
1156       break;
1157     default:
1158       break;
1159   }
1160
1161 no_state_recalc:
1162   GST_OBJECT_UNLOCK (bin);
1163
1164   /* post the messages on the bus of the element so that the bin can handle
1165    * them */
1166   if (clock_message)
1167     gst_element_post_message (GST_ELEMENT_CAST (element), clock_message);
1168
1169   if (async_message)
1170     gst_element_post_message (GST_ELEMENT_CAST (element), async_message);
1171
1172   /* unlink all linked pads */
1173   it = gst_element_iterate_pads (element);
1174   gst_iterator_foreach (it, (GstIteratorForeachFunction) unlink_pads, NULL);
1175   gst_iterator_free (it);
1176
1177   GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, bin, "added element \"%s\"",
1178       elem_name);
1179   g_free (elem_name);
1180
1181   g_signal_emit (bin, gst_bin_signals[ELEMENT_ADDED], 0, element);
1182   gst_child_proxy_child_added ((GstObject *) bin, (GstObject *) element);
1183
1184   return TRUE;
1185
1186   /* ERROR handling here */
1187 adding_itself:
1188   {
1189     GST_OBJECT_LOCK (bin);
1190     g_warning ("Cannot add bin '%s' to itself", GST_ELEMENT_NAME (bin));
1191     GST_OBJECT_UNLOCK (bin);
1192     return FALSE;
1193   }
1194 duplicate_name:
1195   {
1196     g_warning ("Name '%s' is not unique in bin '%s', not adding",
1197         elem_name, GST_ELEMENT_NAME (bin));
1198     GST_OBJECT_UNLOCK (bin);
1199     g_free (elem_name);
1200     return FALSE;
1201   }
1202 had_parent:
1203   {
1204     g_warning ("Element '%s' already has parent", elem_name);
1205     GST_OBJECT_UNLOCK (bin);
1206     g_free (elem_name);
1207     return FALSE;
1208   }
1209 }
1210
1211 /**
1212  * gst_bin_add:
1213  * @bin: a #GstBin
1214  * @element: (transfer full): the #GstElement to add
1215  *
1216  * Adds the given element to the bin.  Sets the element's parent, and thus
1217  * takes ownership of the element. An element can only be added to one bin.
1218  *
1219  * If the element's pads are linked to other pads, the pads will be unlinked
1220  * before the element is added to the bin.
1221  *
1222  * <note>
1223  * When you add an element to an already-running pipeline, you will have to
1224  * take care to set the state of the newly-added element to the desired
1225  * state (usually PLAYING or PAUSED, same you set the pipeline to originally)
1226  * with gst_element_set_state(), or use gst_element_sync_state_with_parent().
1227  * The bin or pipeline will not take care of this for you.
1228  * </note>
1229  *
1230  * MT safe.
1231  *
1232  * Returns: TRUE if the element could be added, FALSE if
1233  * the bin does not want to accept the element.
1234  */
1235 gboolean
1236 gst_bin_add (GstBin * bin, GstElement * element)
1237 {
1238   GstBinClass *bclass;
1239   gboolean result;
1240
1241   g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
1242   g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
1243
1244   bclass = GST_BIN_GET_CLASS (bin);
1245
1246   if (G_UNLIKELY (bclass->add_element == NULL))
1247     goto no_function;
1248
1249   GST_CAT_DEBUG (GST_CAT_PARENTAGE, "adding element %s to bin %s",
1250       GST_STR_NULL (GST_ELEMENT_NAME (element)),
1251       GST_STR_NULL (GST_ELEMENT_NAME (bin)));
1252
1253   result = bclass->add_element (bin, element);
1254
1255   return result;
1256
1257   /* ERROR handling */
1258 no_function:
1259   {
1260     g_warning ("adding elements to bin '%s' is not supported",
1261         GST_ELEMENT_NAME (bin));
1262     return FALSE;
1263   }
1264 }
1265
1266 /* remove an element from the bin
1267  *
1268  * MT safe
1269  */
1270 static gboolean
1271 gst_bin_remove_func (GstBin * bin, GstElement * element)
1272 {
1273   gchar *elem_name;
1274   GstIterator *it;
1275   gboolean is_sink, is_source, provides_clock, requires_clock;
1276   gboolean othersink, othersource, otherprovider, otherrequirer, found;
1277   GstMessage *clock_message = NULL;
1278   GstClock **provided_clock_p;
1279   GstElement **clock_provider_p;
1280   GList *walk, *next;
1281   gboolean other_async, this_async, have_no_preroll;
1282   GstStateChangeReturn ret;
1283
1284   GST_DEBUG_OBJECT (bin, "element :%s", GST_ELEMENT_NAME (element));
1285
1286   GST_OBJECT_LOCK (element);
1287   /* Check if the element is already being removed and immediately
1288    * return */
1289   if (G_UNLIKELY (GST_OBJECT_FLAG_IS_SET (element,
1290               GST_ELEMENT_FLAG_UNPARENTING)))
1291     goto already_removing;
1292
1293   GST_OBJECT_FLAG_SET (element, GST_ELEMENT_FLAG_UNPARENTING);
1294   /* grab element name so we can print it */
1295   elem_name = g_strdup (GST_ELEMENT_NAME (element));
1296   is_sink = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SINK);
1297   is_source = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SOURCE);
1298   provides_clock =
1299       GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
1300   requires_clock =
1301       GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_REQUIRE_CLOCK);
1302   GST_OBJECT_UNLOCK (element);
1303
1304   /* unlink all linked pads */
1305   it = gst_element_iterate_pads (element);
1306   gst_iterator_foreach (it, (GstIteratorForeachFunction) unlink_pads, NULL);
1307   gst_iterator_free (it);
1308
1309   GST_OBJECT_LOCK (bin);
1310   found = FALSE;
1311   othersink = FALSE;
1312   othersource = FALSE;
1313   otherprovider = FALSE;
1314   otherrequirer = FALSE;
1315   have_no_preroll = FALSE;
1316   /* iterate the elements, we collect which ones are async and no_preroll. We
1317    * also remove the element when we find it. */
1318   for (walk = bin->children; walk; walk = next) {
1319     GstElement *child = GST_ELEMENT_CAST (walk->data);
1320
1321     next = g_list_next (walk);
1322
1323     if (child == element) {
1324       found = TRUE;
1325       /* remove the element */
1326       bin->children = g_list_delete_link (bin->children, walk);
1327     } else {
1328       gboolean child_sink, child_source, child_provider, child_requirer;
1329
1330       GST_OBJECT_LOCK (child);
1331       child_sink = GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_SINK);
1332       child_source = GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_SOURCE);
1333       child_provider =
1334           GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
1335       child_requirer =
1336           GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_REQUIRE_CLOCK);
1337       /* when we remove a sink, check if there are other sinks. */
1338       if (is_sink && !othersink && child_sink)
1339         othersink = TRUE;
1340       if (is_source && !othersource && child_source)
1341         othersource = TRUE;
1342       if (provides_clock && !otherprovider && child_provider)
1343         otherprovider = TRUE;
1344       if (requires_clock && !otherrequirer && child_requirer)
1345         otherrequirer = TRUE;
1346       /* check if we have NO_PREROLL children */
1347       if (GST_STATE_RETURN (child) == GST_STATE_CHANGE_NO_PREROLL)
1348         have_no_preroll = TRUE;
1349       GST_OBJECT_UNLOCK (child);
1350     }
1351   }
1352
1353   /* the element must have been in the bin's list of children */
1354   if (G_UNLIKELY (!found))
1355     goto not_in_bin;
1356
1357   /* we now removed the element from the list of elements, increment the cookie
1358    * so that others can detect a change in the children list. */
1359   bin->numchildren--;
1360   bin->children_cookie++;
1361   bin->priv->structure_cookie++;
1362
1363   if (is_sink && !othersink) {
1364     /* we're not a sink anymore */
1365     GST_DEBUG_OBJECT (bin, "we removed the last sink");
1366     GST_OBJECT_FLAG_UNSET (bin, GST_ELEMENT_FLAG_SINK);
1367   }
1368   if (is_source && !othersource) {
1369     /* we're not a source anymore */
1370     GST_DEBUG_OBJECT (bin, "we removed the last source");
1371     GST_OBJECT_FLAG_UNSET (bin, GST_ELEMENT_FLAG_SOURCE);
1372   }
1373   if (provides_clock && !otherprovider) {
1374     /* we're not a clock provider anymore */
1375     GST_DEBUG_OBJECT (bin, "we removed the last clock provider");
1376     GST_OBJECT_FLAG_UNSET (bin, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
1377   }
1378   if (requires_clock && !otherrequirer) {
1379     /* we're not a clock requirer anymore */
1380     GST_DEBUG_OBJECT (bin, "we removed the last clock requirer");
1381     GST_OBJECT_FLAG_UNSET (bin, GST_ELEMENT_FLAG_REQUIRE_CLOCK);
1382   }
1383
1384   /* if the clock provider for this element is removed, we lost
1385    * the clock as well, we need to inform the parent of this
1386    * so that it can select a new clock */
1387   if (bin->clock_provider == element) {
1388     GST_DEBUG_OBJECT (bin, "element \"%s\" provided the clock", elem_name);
1389     bin->clock_dirty = TRUE;
1390     clock_message =
1391         gst_message_new_clock_lost (GST_OBJECT_CAST (bin), bin->provided_clock);
1392     provided_clock_p = &bin->provided_clock;
1393     clock_provider_p = &bin->clock_provider;
1394     gst_object_replace ((GstObject **) provided_clock_p, NULL);
1395     gst_object_replace ((GstObject **) clock_provider_p, NULL);
1396   }
1397
1398   /* remove messages for the element, if there was a pending ASYNC_START
1399    * message we must see if removing the element caused the bin to lose its
1400    * async state. */
1401   this_async = FALSE;
1402   other_async = FALSE;
1403   for (walk = bin->messages; walk; walk = next) {
1404     GstMessage *message = (GstMessage *) walk->data;
1405     GstElement *src = GST_ELEMENT_CAST (GST_MESSAGE_SRC (message));
1406     gboolean remove;
1407
1408     next = g_list_next (walk);
1409     remove = FALSE;
1410
1411     switch (GST_MESSAGE_TYPE (message)) {
1412       case GST_MESSAGE_ASYNC_START:
1413         if (src == element)
1414           this_async = TRUE;
1415         else
1416           other_async = TRUE;
1417
1418         GST_DEBUG_OBJECT (src, "looking at message %p", message);
1419         break;
1420       case GST_MESSAGE_STRUCTURE_CHANGE:
1421       {
1422         GstElement *owner;
1423
1424         GST_DEBUG_OBJECT (src, "looking at structure change message %p",
1425             message);
1426         /* it's unlikely that this message is still in the list of messages
1427          * because this would mean that a link/unlink is busy in another thread
1428          * while we remove the element. We still have to remove the message
1429          * because we might not receive the done message anymore when the element
1430          * is removed from the bin. */
1431         gst_message_parse_structure_change (message, NULL, &owner, NULL);
1432         if (owner == element)
1433           remove = TRUE;
1434         break;
1435       }
1436       default:
1437         break;
1438     }
1439     if (src == element)
1440       remove = TRUE;
1441
1442     if (remove) {
1443       /* delete all message types */
1444       GST_DEBUG_OBJECT (src, "deleting message %p of element \"%s\"",
1445           message, elem_name);
1446       bin->messages = g_list_delete_link (bin->messages, walk);
1447       gst_message_unref (message);
1448     }
1449   }
1450
1451   /* get last return */
1452   ret = GST_STATE_RETURN (bin);
1453
1454   /* no need to update the state if we are in error */
1455   if (ret == GST_STATE_CHANGE_FAILURE)
1456     goto no_state_recalc;
1457
1458   if (!other_async && this_async) {
1459     /* all other elements were not async and we removed the async one,
1460      * handle the async-done case because we are not async anymore now. */
1461     GST_DEBUG_OBJECT (bin,
1462         "we removed the last async element, have no_preroll %d",
1463         have_no_preroll);
1464
1465     /* the current state return of the bin depends on if there are no_preroll
1466      * elements in the pipeline or not */
1467     if (have_no_preroll)
1468       ret = GST_STATE_CHANGE_NO_PREROLL;
1469     else
1470       ret = GST_STATE_CHANGE_SUCCESS;
1471
1472     bin_handle_async_done (bin, ret, FALSE, FALSE);
1473   } else {
1474     GST_DEBUG_OBJECT (bin,
1475         "recalc state preroll: %d, other async: %d, this async %d",
1476         have_no_preroll, other_async, this_async);
1477
1478     if (have_no_preroll) {
1479       ret = GST_STATE_CHANGE_NO_PREROLL;
1480     } else if (other_async) {
1481       /* there are other async elements and we were not doing an async state
1482        * change, change our pending state and go async */
1483       if (GST_STATE_PENDING (bin) == GST_STATE_VOID_PENDING) {
1484         GST_STATE_NEXT (bin) = GST_STATE (bin);
1485         GST_STATE_PENDING (bin) = GST_STATE (bin);
1486       }
1487       ret = GST_STATE_CHANGE_ASYNC;
1488     }
1489     GST_STATE_RETURN (bin) = ret;
1490   }
1491 no_state_recalc:
1492   GST_OBJECT_UNLOCK (bin);
1493
1494   if (clock_message)
1495     gst_element_post_message (GST_ELEMENT_CAST (bin), clock_message);
1496
1497   GST_CAT_INFO_OBJECT (GST_CAT_PARENTAGE, bin, "removed child \"%s\"",
1498       elem_name);
1499   g_free (elem_name);
1500
1501   gst_element_set_bus (element, NULL);
1502
1503   /* Clear the clock we provided to the element */
1504   gst_element_set_clock (element, NULL);
1505
1506   /* we ref here because after the _unparent() the element can be disposed
1507    * and we still need it to reset the UNPARENTING flag and fire a signal. */
1508   gst_object_ref (element);
1509   gst_object_unparent (GST_OBJECT_CAST (element));
1510
1511   GST_OBJECT_LOCK (element);
1512   GST_OBJECT_FLAG_UNSET (element, GST_ELEMENT_FLAG_UNPARENTING);
1513   GST_OBJECT_UNLOCK (element);
1514
1515   g_signal_emit (bin, gst_bin_signals[ELEMENT_REMOVED], 0, element);
1516   gst_child_proxy_child_removed ((GstObject *) bin, (GstObject *) element);
1517
1518   /* element is really out of our control now */
1519   gst_object_unref (element);
1520
1521   return TRUE;
1522
1523   /* ERROR handling */
1524 not_in_bin:
1525   {
1526     g_warning ("Element '%s' is not in bin '%s'", elem_name,
1527         GST_ELEMENT_NAME (bin));
1528     GST_OBJECT_UNLOCK (bin);
1529     g_free (elem_name);
1530     return FALSE;
1531   }
1532 already_removing:
1533   {
1534     GST_CAT_INFO_OBJECT (GST_CAT_PARENTAGE, bin, "already removing child");
1535     GST_OBJECT_UNLOCK (element);
1536     return FALSE;
1537   }
1538 }
1539
1540 /**
1541  * gst_bin_remove:
1542  * @bin: a #GstBin
1543  * @element: (transfer none): the #GstElement to remove
1544  *
1545  * Removes the element from the bin, unparenting it as well.
1546  * Unparenting the element means that the element will be dereferenced,
1547  * so if the bin holds the only reference to the element, the element
1548  * will be freed in the process of removing it from the bin.  If you
1549  * want the element to still exist after removing, you need to call
1550  * gst_object_ref() before removing it from the bin.
1551  *
1552  * If the element's pads are linked to other pads, the pads will be unlinked
1553  * before the element is removed from the bin.
1554  *
1555  * MT safe.
1556  *
1557  * Returns: TRUE if the element could be removed, FALSE if
1558  * the bin does not want to remove the element.
1559  */
1560 gboolean
1561 gst_bin_remove (GstBin * bin, GstElement * element)
1562 {
1563   GstBinClass *bclass;
1564   gboolean result;
1565
1566   g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
1567   g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
1568
1569   bclass = GST_BIN_GET_CLASS (bin);
1570
1571   if (G_UNLIKELY (bclass->remove_element == NULL))
1572     goto no_function;
1573
1574   GST_CAT_DEBUG (GST_CAT_PARENTAGE, "removing element %s from bin %s",
1575       GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
1576
1577   result = bclass->remove_element (bin, element);
1578
1579   return result;
1580
1581   /* ERROR handling */
1582 no_function:
1583   {
1584     g_warning ("removing elements from bin '%s' is not supported",
1585         GST_ELEMENT_NAME (bin));
1586     return FALSE;
1587   }
1588 }
1589
1590 /**
1591  * gst_bin_iterate_elements:
1592  * @bin: a #GstBin
1593  *
1594  * Gets an iterator for the elements in this bin.
1595  *
1596  * Each element yielded by the iterator will have its refcount increased, so
1597  * unref after use.
1598  *
1599  * MT safe.  Caller owns returned value.
1600  *
1601  * Returns: (transfer full): a #GstIterator of #GstElement, or NULL
1602  */
1603 GstIterator *
1604 gst_bin_iterate_elements (GstBin * bin)
1605 {
1606   GstIterator *result;
1607
1608   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
1609
1610   GST_OBJECT_LOCK (bin);
1611   result = gst_iterator_new_list (GST_TYPE_ELEMENT,
1612       GST_OBJECT_GET_LOCK (bin),
1613       &bin->children_cookie, &bin->children, (GObject *) bin, NULL);
1614   GST_OBJECT_UNLOCK (bin);
1615
1616   return result;
1617 }
1618
1619 static GstIteratorItem
1620 iterate_child_recurse (GstIterator * it, const GValue * item)
1621 {
1622   GstElement *child = g_value_get_object (item);
1623
1624   if (GST_IS_BIN (child)) {
1625     GstIterator *other = gst_bin_iterate_recurse (GST_BIN_CAST (child));
1626
1627     gst_iterator_push (it, other);
1628   }
1629   return GST_ITERATOR_ITEM_PASS;
1630 }
1631
1632 /**
1633  * gst_bin_iterate_recurse:
1634  * @bin: a #GstBin
1635  *
1636  * Gets an iterator for the elements in this bin.
1637  * This iterator recurses into GstBin children.
1638  *
1639  * Each element yielded by the iterator will have its refcount increased, so
1640  * unref after use.
1641  *
1642  * MT safe.  Caller owns returned value.
1643  *
1644  * Returns: (transfer full): a #GstIterator of #GstElement, or NULL
1645  */
1646 GstIterator *
1647 gst_bin_iterate_recurse (GstBin * bin)
1648 {
1649   GstIterator *result;
1650
1651   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
1652
1653   GST_OBJECT_LOCK (bin);
1654   result = gst_iterator_new_list (GST_TYPE_ELEMENT,
1655       GST_OBJECT_GET_LOCK (bin),
1656       &bin->children_cookie,
1657       &bin->children,
1658       (GObject *) bin, (GstIteratorItemFunction) iterate_child_recurse);
1659   GST_OBJECT_UNLOCK (bin);
1660
1661   return result;
1662 }
1663
1664 /* returns 0 when TRUE because this is a GCompareFunc */
1665 /* MT safe */
1666 static gint
1667 bin_element_is_sink (GstElement * child, GstBin * bin)
1668 {
1669   gboolean is_sink;
1670
1671   /* we lock the child here for the remainder of the function to
1672    * get its name and flag safely. */
1673   GST_OBJECT_LOCK (child);
1674   is_sink = GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_SINK);
1675
1676   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
1677       "child %s %s sink", GST_OBJECT_NAME (child), is_sink ? "is" : "is not");
1678
1679   GST_OBJECT_UNLOCK (child);
1680   return is_sink ? 0 : 1;
1681 }
1682
1683 static gint
1684 sink_iterator_filter (const GValue * vchild, GValue * vbin)
1685 {
1686   GstBin *bin = g_value_get_object (vbin);
1687   GstElement *child = g_value_get_object (vchild);
1688
1689   return (bin_element_is_sink (child, bin));
1690 }
1691
1692 /**
1693  * gst_bin_iterate_sinks:
1694  * @bin: a #GstBin
1695  *
1696  * Gets an iterator for all elements in the bin that have the
1697  * #GST_ELEMENT_FLAG_SINK flag set.
1698  *
1699  * Each element yielded by the iterator will have its refcount increased, so
1700  * unref after use.
1701  *
1702  * MT safe.  Caller owns returned value.
1703  *
1704  * Returns: (transfer full): a #GstIterator of #GstElement, or NULL
1705  */
1706 GstIterator *
1707 gst_bin_iterate_sinks (GstBin * bin)
1708 {
1709   GstIterator *children;
1710   GstIterator *result;
1711   GValue vbin = { 0, };
1712
1713   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
1714
1715   g_value_init (&vbin, GST_TYPE_BIN);
1716   g_value_set_object (&vbin, bin);
1717
1718   children = gst_bin_iterate_elements (bin);
1719   result = gst_iterator_filter (children,
1720       (GCompareFunc) sink_iterator_filter, &vbin);
1721
1722   g_value_unset (&vbin);
1723
1724   return result;
1725 }
1726
1727 /* returns 0 when TRUE because this is a GCompareFunc */
1728 /* MT safe */
1729 static gint
1730 bin_element_is_src (GstElement * child, GstBin * bin)
1731 {
1732   gboolean is_src;
1733
1734   /* we lock the child here for the remainder of the function to
1735    * get its name and other info safely. */
1736   GST_OBJECT_LOCK (child);
1737   is_src = GST_OBJECT_FLAG_IS_SET (child, GST_ELEMENT_FLAG_SOURCE);
1738
1739   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
1740       "child %s %s src", GST_OBJECT_NAME (child), is_src ? "is" : "is not");
1741
1742   GST_OBJECT_UNLOCK (child);
1743   return is_src ? 0 : 1;
1744 }
1745
1746 static gint
1747 src_iterator_filter (const GValue * vchild, GValue * vbin)
1748 {
1749   GstBin *bin = g_value_get_object (vbin);
1750   GstElement *child = g_value_get_object (vchild);
1751
1752   return (bin_element_is_src (child, bin));
1753 }
1754
1755 /**
1756  * gst_bin_iterate_sources:
1757  * @bin: a #GstBin
1758  *
1759  * Gets an iterator for all elements in the bin that have the
1760  * #GST_ELEMENT_FLAG_SOURCE flag set.
1761  *
1762  * Each element yielded by the iterator will have its refcount increased, so
1763  * unref after use.
1764  *
1765  * MT safe.  Caller owns returned value.
1766  *
1767  * Returns: (transfer full): a #GstIterator of #GstElement, or NULL
1768  */
1769 GstIterator *
1770 gst_bin_iterate_sources (GstBin * bin)
1771 {
1772   GstIterator *children;
1773   GstIterator *result;
1774   GValue vbin = { 0, };
1775
1776   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
1777
1778   g_value_init (&vbin, GST_TYPE_BIN);
1779   g_value_set_object (&vbin, bin);
1780
1781   children = gst_bin_iterate_elements (bin);
1782   result = gst_iterator_filter (children,
1783       (GCompareFunc) src_iterator_filter, &vbin);
1784
1785   g_value_unset (&vbin);
1786
1787   return result;
1788 }
1789
1790 /*
1791  * MT safe
1792  */
1793 static GstStateChangeReturn
1794 gst_bin_get_state_func (GstElement * element, GstState * state,
1795     GstState * pending, GstClockTime timeout)
1796 {
1797   GstStateChangeReturn ret;
1798
1799   GST_CAT_INFO_OBJECT (GST_CAT_STATES, element, "getting state");
1800
1801   ret =
1802       GST_ELEMENT_CLASS (parent_class)->get_state (element, state, pending,
1803       timeout);
1804
1805   return ret;
1806 }
1807
1808 /***********************************************
1809  * Topologically sorted iterator
1810  * see http://en.wikipedia.org/wiki/Topological_sorting
1811  *
1812  * For each element in the graph, an entry is kept in a HashTable
1813  * with its number of srcpad connections (degree).
1814  * We then change state of all elements without dependencies
1815  * (degree 0) and decrement the degree of all elements connected
1816  * on the sinkpads. When an element reaches degree 0, its state is
1817  * changed next.
1818  * When all elements are handled the algorithm stops.
1819  */
1820 typedef struct _GstBinSortIterator
1821 {
1822   GstIterator it;
1823   GQueue queue;                 /* elements queued for state change */
1824   GstBin *bin;                  /* bin we iterate */
1825   gint mode;                    /* adding or removing dependency */
1826   GstElement *best;             /* next element with least dependencies */
1827   gint best_deg;                /* best degree */
1828   GHashTable *hash;             /* hashtable with element dependencies */
1829   gboolean dirty;               /* we detected structure change */
1830 } GstBinSortIterator;
1831
1832 static void
1833 gst_bin_sort_iterator_copy (const GstBinSortIterator * it,
1834     GstBinSortIterator * copy)
1835 {
1836   GHashTableIter iter;
1837   gpointer key, value;
1838
1839   copy->queue = it->queue;
1840   g_queue_foreach (&copy->queue, (GFunc) gst_object_ref, NULL);
1841
1842   copy->bin = gst_object_ref (it->bin);
1843   if (it->best)
1844     copy->best = gst_object_ref (it->best);
1845
1846   copy->hash = g_hash_table_new (NULL, NULL);
1847   g_hash_table_iter_init (&iter, it->hash);
1848   while (g_hash_table_iter_next (&iter, &key, &value))
1849     g_hash_table_insert (copy->hash, key, value);
1850 }
1851
1852 /* we add and subtract 1 to make sure we don't confuse NULL and 0 */
1853 #define HASH_SET_DEGREE(bit, elem, deg) \
1854     g_hash_table_replace (bit->hash, elem, GINT_TO_POINTER(deg+1))
1855 #define HASH_GET_DEGREE(bit, elem) \
1856     (GPOINTER_TO_INT(g_hash_table_lookup (bit->hash, elem))-1)
1857
1858 /* add element to queue of next elements in the iterator.
1859  * We push at the tail to give higher priority elements a
1860  * chance first */
1861 static void
1862 add_to_queue (GstBinSortIterator * bit, GstElement * element)
1863 {
1864   GST_DEBUG_OBJECT (bit->bin, "adding '%s' to queue",
1865       GST_ELEMENT_NAME (element));
1866   gst_object_ref (element);
1867   g_queue_push_tail (&bit->queue, element);
1868   HASH_SET_DEGREE (bit, element, -1);
1869 }
1870
1871 static void
1872 remove_from_queue (GstBinSortIterator * bit, GstElement * element)
1873 {
1874   GList *find;
1875
1876   if ((find = g_queue_find (&bit->queue, element))) {
1877     GST_DEBUG_OBJECT (bit->bin, "removing '%s' from queue",
1878         GST_ELEMENT_NAME (element));
1879
1880     g_queue_delete_link (&bit->queue, find);
1881     gst_object_unref (element);
1882   } else {
1883     GST_DEBUG_OBJECT (bit->bin, "unable to remove '%s' from queue",
1884         GST_ELEMENT_NAME (element));
1885   }
1886 }
1887
1888 /* clear the queue, unref all objects as we took a ref when
1889  * we added them to the queue */
1890 static void
1891 clear_queue (GQueue * queue)
1892 {
1893   gpointer p;
1894
1895   while ((p = g_queue_pop_head (queue)))
1896     gst_object_unref (p);
1897 }
1898
1899 /* set all degrees to 0. Elements marked as a sink are
1900  * added to the queue immediately. Since we only look at the SINK flag of the
1901  * element, it is possible that we add non-sinks to the queue. These will be
1902  * removed from the queue again when we can prove that it provides data for some
1903  * other element. */
1904 static void
1905 reset_degree (GstElement * element, GstBinSortIterator * bit)
1906 {
1907   gboolean is_sink;
1908
1909   /* sinks are added right away */
1910   GST_OBJECT_LOCK (element);
1911   is_sink = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SINK);
1912   GST_OBJECT_UNLOCK (element);
1913
1914   if (is_sink) {
1915     add_to_queue (bit, element);
1916   } else {
1917     /* others are marked with 0 and handled when sinks are done */
1918     HASH_SET_DEGREE (bit, element, 0);
1919   }
1920 }
1921
1922 /* adjust the degree of all elements connected to the given
1923  * element. If a degree of an element drops to 0, it is
1924  * added to the queue of elements to schedule next.
1925  *
1926  * We have to make sure not to cross the bin boundary this element
1927  * belongs to.
1928  */
1929 static void
1930 update_degree (GstElement * element, GstBinSortIterator * bit)
1931 {
1932   gboolean linked = FALSE;
1933
1934   GST_OBJECT_LOCK (element);
1935   /* don't touch degree if element has no sinkpads */
1936   if (element->numsinkpads != 0) {
1937     /* loop over all sinkpads, decrement degree for all connected
1938      * elements in this bin */
1939     GList *pads;
1940
1941     for (pads = element->sinkpads; pads; pads = g_list_next (pads)) {
1942       GstPad *pad, *peer;
1943
1944       pad = GST_PAD_CAST (pads->data);
1945
1946       /* we're iterating over the sinkpads, check if it's busy in a link/unlink */
1947       if (G_UNLIKELY (find_message (bit->bin, GST_OBJECT_CAST (pad),
1948                   GST_MESSAGE_STRUCTURE_CHANGE))) {
1949         /* mark the iterator as dirty because we won't be updating the degree
1950          * of the peer parent now. This would result in the 'loop detected'
1951          * later on because the peer parent element could become the best next
1952          * element with a degree > 0. We will simply continue our state
1953          * changes and we'll eventually resync when the unlink completed and
1954          * the iterator cookie is updated. */
1955         bit->dirty = TRUE;
1956         continue;
1957       }
1958
1959       if ((peer = gst_pad_get_peer (pad))) {
1960         GstElement *peer_element;
1961
1962         if ((peer_element = gst_pad_get_parent_element (peer))) {
1963           GST_OBJECT_LOCK (peer_element);
1964           /* check that we don't go outside of this bin */
1965           if (GST_OBJECT_CAST (peer_element)->parent ==
1966               GST_OBJECT_CAST (bit->bin)) {
1967             gint old_deg, new_deg;
1968
1969             old_deg = HASH_GET_DEGREE (bit, peer_element);
1970
1971             /* check to see if we added an element as sink that was not really a
1972              * sink because it was connected to some other element. */
1973             if (old_deg == -1) {
1974               remove_from_queue (bit, peer_element);
1975               old_deg = 0;
1976             }
1977             new_deg = old_deg + bit->mode;
1978
1979             GST_DEBUG_OBJECT (bit->bin,
1980                 "change element %s, degree %d->%d, linked to %s",
1981                 GST_ELEMENT_NAME (peer_element), old_deg, new_deg,
1982                 GST_ELEMENT_NAME (element));
1983
1984             /* update degree, it is possible that an element was in 0 and
1985              * reaches -1 here. This would mean that the element had no sinkpads
1986              * but became linked while the state change was happening. We will
1987              * resync on this with the structure change message. */
1988             if (new_deg == 0) {
1989               /* degree hit 0, add to queue */
1990               add_to_queue (bit, peer_element);
1991             } else {
1992               HASH_SET_DEGREE (bit, peer_element, new_deg);
1993             }
1994             linked = TRUE;
1995           }
1996           GST_OBJECT_UNLOCK (peer_element);
1997           gst_object_unref (peer_element);
1998         }
1999         gst_object_unref (peer);
2000       }
2001     }
2002   }
2003   if (!linked) {
2004     GST_DEBUG_OBJECT (bit->bin, "element %s not linked on any sinkpads",
2005         GST_ELEMENT_NAME (element));
2006   }
2007   GST_OBJECT_UNLOCK (element);
2008 }
2009
2010 /* find the next best element not handled yet. This is the one
2011  * with the lowest non-negative degree */
2012 static void
2013 find_element (GstElement * element, GstBinSortIterator * bit)
2014 {
2015   gint degree;
2016
2017   /* element is already handled */
2018   if ((degree = HASH_GET_DEGREE (bit, element)) < 0)
2019     return;
2020
2021   /* first element or element with smaller degree */
2022   if (bit->best == NULL || bit->best_deg > degree) {
2023     bit->best = element;
2024     bit->best_deg = degree;
2025   }
2026 }
2027
2028 /* get next element in iterator. the returned element has the
2029  * refcount increased */
2030 static GstIteratorResult
2031 gst_bin_sort_iterator_next (GstBinSortIterator * bit, GValue * result)
2032 {
2033   GstElement *best;
2034   GstBin *bin = bit->bin;
2035
2036   /* empty queue, we have to find a next best element */
2037   if (g_queue_is_empty (&bit->queue)) {
2038     bit->best = NULL;
2039     bit->best_deg = G_MAXINT;
2040     g_list_foreach (bin->children, (GFunc) find_element, bit);
2041     if ((best = bit->best)) {
2042       /* when we detected an unlink, don't warn because our degrees might be
2043        * screwed up. We will resync later */
2044       if (bit->best_deg != 0 && !bit->dirty) {
2045         /* we don't fail on this one yet */
2046         GST_WARNING_OBJECT (bin, "loop dected in graph");
2047         g_warning ("loop detected in the graph of bin '%s'!!",
2048             GST_ELEMENT_NAME (bin));
2049       }
2050       /* best unhandled element, schedule as next element */
2051       GST_DEBUG_OBJECT (bin, "queue empty, next best: %s",
2052           GST_ELEMENT_NAME (best));
2053       HASH_SET_DEGREE (bit, best, -1);
2054       g_value_set_object (result, best);
2055     } else {
2056       GST_DEBUG_OBJECT (bin, "queue empty, elements exhausted");
2057       /* no more unhandled elements, we are done */
2058       return GST_ITERATOR_DONE;
2059     }
2060   } else {
2061     /* everything added to the queue got reffed */
2062     best = g_queue_pop_head (&bit->queue);
2063     g_value_set_object (result, best);
2064     gst_object_unref (best);
2065   }
2066
2067   GST_DEBUG_OBJECT (bin, "queue head gives %s", GST_ELEMENT_NAME (best));
2068   /* update degrees of linked elements */
2069   update_degree (best, bit);
2070
2071   return GST_ITERATOR_OK;
2072 }
2073
2074 /* clear queues, recalculate the degrees and restart. */
2075 static void
2076 gst_bin_sort_iterator_resync (GstBinSortIterator * bit)
2077 {
2078   GstBin *bin = bit->bin;
2079
2080   GST_DEBUG_OBJECT (bin, "resync");
2081   bit->dirty = FALSE;
2082   clear_queue (&bit->queue);
2083   /* reset degrees */
2084   g_list_foreach (bin->children, (GFunc) reset_degree, bit);
2085   /* calc degrees, incrementing */
2086   bit->mode = 1;
2087   g_list_foreach (bin->children, (GFunc) update_degree, bit);
2088   /* for the rest of the function we decrement the degrees */
2089   bit->mode = -1;
2090 }
2091
2092 /* clear queues, unref bin and free iterator. */
2093 static void
2094 gst_bin_sort_iterator_free (GstBinSortIterator * bit)
2095 {
2096   GstBin *bin = bit->bin;
2097
2098   GST_DEBUG_OBJECT (bin, "free");
2099   clear_queue (&bit->queue);
2100   g_hash_table_destroy (bit->hash);
2101   gst_object_unref (bin);
2102 }
2103
2104 /* should be called with the bin LOCK held */
2105 static GstIterator *
2106 gst_bin_sort_iterator_new (GstBin * bin)
2107 {
2108   GstBinSortIterator *result;
2109
2110   /* we don't need an ItemFunction because we ref the items in the _next
2111    * method already */
2112   result = (GstBinSortIterator *)
2113       gst_iterator_new (sizeof (GstBinSortIterator),
2114       GST_TYPE_ELEMENT,
2115       GST_OBJECT_GET_LOCK (bin),
2116       &bin->priv->structure_cookie,
2117       (GstIteratorCopyFunction) gst_bin_sort_iterator_copy,
2118       (GstIteratorNextFunction) gst_bin_sort_iterator_next,
2119       (GstIteratorItemFunction) NULL,
2120       (GstIteratorResyncFunction) gst_bin_sort_iterator_resync,
2121       (GstIteratorFreeFunction) gst_bin_sort_iterator_free);
2122   g_queue_init (&result->queue);
2123   result->hash = g_hash_table_new (NULL, NULL);
2124   gst_object_ref (bin);
2125   result->bin = bin;
2126   gst_bin_sort_iterator_resync (result);
2127
2128   return (GstIterator *) result;
2129 }
2130
2131 /**
2132  * gst_bin_iterate_sorted:
2133  * @bin: a #GstBin
2134  *
2135  * Gets an iterator for the elements in this bin in topologically
2136  * sorted order. This means that the elements are returned from
2137  * the most downstream elements (sinks) to the sources.
2138  *
2139  * This function is used internally to perform the state changes
2140  * of the bin elements and for clock selection.
2141  *
2142  * Each element yielded by the iterator will have its refcount increased, so
2143  * unref after use.
2144  *
2145  * MT safe.  Caller owns returned value.
2146  *
2147  * Returns: (transfer full): a #GstIterator of #GstElement, or NULL
2148  */
2149 GstIterator *
2150 gst_bin_iterate_sorted (GstBin * bin)
2151 {
2152   GstIterator *result;
2153
2154   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
2155
2156   GST_OBJECT_LOCK (bin);
2157   result = gst_bin_sort_iterator_new (bin);
2158   GST_OBJECT_UNLOCK (bin);
2159
2160   return result;
2161 }
2162
2163 static GstStateChangeReturn
2164 gst_bin_element_set_state (GstBin * bin, GstElement * element,
2165     GstClockTime base_time, GstClockTime start_time, GstState current,
2166     GstState next)
2167 {
2168   GstStateChangeReturn ret;
2169   GstState pending, child_current, child_pending;
2170   gboolean locked;
2171   GList *found;
2172
2173   GST_STATE_LOCK (element);
2174
2175   GST_OBJECT_LOCK (element);
2176   /* set base_time and start time on child */
2177   GST_ELEMENT_START_TIME (element) = start_time;
2178   element->base_time = base_time;
2179   /* peel off the locked flag */
2180   locked = GST_ELEMENT_IS_LOCKED_STATE (element);
2181   /* Get the previous set_state result to preserve NO_PREROLL and ASYNC */
2182   ret = GST_STATE_RETURN (element);
2183   child_current = GST_STATE (element);
2184   child_pending = GST_STATE_PENDING (element);
2185   GST_OBJECT_UNLOCK (element);
2186
2187   /* skip locked elements */
2188   if (G_UNLIKELY (locked))
2189     goto locked;
2190
2191   /* if the element was no preroll, just start changing the state regardless
2192    * if it had async elements (in the case of a bin) because they won't preroll
2193    * anyway. */
2194   if (G_UNLIKELY (ret == GST_STATE_CHANGE_NO_PREROLL)) {
2195     GST_DEBUG_OBJECT (element, "element is NO_PREROLL, ignore async elements");
2196     goto no_preroll;
2197   }
2198
2199   GST_OBJECT_LOCK (bin);
2200   pending = GST_STATE_PENDING (bin);
2201
2202   /* Try not to change the state of elements that are already in the state we're
2203    * going to */
2204   if (!(next == GST_STATE_PLAYING || child_pending != GST_STATE_VOID_PENDING ||
2205           (child_pending == GST_STATE_VOID_PENDING &&
2206               ((pending > child_current && next > child_current) ||
2207                   (pending < child_current && next < child_current)))))
2208     goto unneeded;
2209
2210   /* the element was busy with an upwards async state change, we must wait for
2211    * an ASYNC_DONE message before we attemp to change the state. */
2212   if ((found =
2213           find_message (bin, GST_OBJECT_CAST (element),
2214               GST_MESSAGE_ASYNC_START))) {
2215 #ifndef GST_DISABLE_GST_DEBUG
2216     GstMessage *message = GST_MESSAGE_CAST (found->data);
2217
2218     GST_DEBUG_OBJECT (element, "element message %p, %s async busy",
2219         message, GST_ELEMENT_NAME (GST_MESSAGE_SRC (message)));
2220 #endif
2221     /* only wait for upward state changes */
2222     if (next > current) {
2223       /* We found an async element check if we can force its state to change or
2224        * if we have to wait for it to preroll. */
2225       if (G_UNLIKELY (!enable_latency)) {
2226         g_warning ("Future versions of GStreamer will wait for element \"%s\"\n"
2227             "\tto preroll in order to perform correct latency calculations.\n"
2228             "\tPlease verify that the application continues to work correctly by\n"
2229             "\tsetting the environment variable GST_COMPAT to a value containing\n"
2230             "\tthe string 'live-preroll'.", GST_ELEMENT_NAME (element));
2231         goto no_latency;
2232       }
2233       goto was_busy;
2234     }
2235   }
2236 no_latency:
2237   GST_OBJECT_UNLOCK (bin);
2238
2239 no_preroll:
2240   GST_DEBUG_OBJECT (bin,
2241       "setting element %s to %s, base_time %" GST_TIME_FORMAT,
2242       GST_ELEMENT_NAME (element), gst_element_state_get_name (next),
2243       GST_TIME_ARGS (base_time));
2244
2245   /* change state */
2246   ret = gst_element_set_state (element, next);
2247
2248   GST_STATE_UNLOCK (element);
2249
2250   return ret;
2251
2252 locked:
2253   {
2254     GST_DEBUG_OBJECT (element,
2255         "element is locked, return previous return %s",
2256         gst_element_state_change_return_get_name (ret));
2257     GST_STATE_UNLOCK (element);
2258     return ret;
2259   }
2260 was_busy:
2261   {
2262     GST_DEBUG_OBJECT (element, "element was busy, delaying state change");
2263     GST_OBJECT_UNLOCK (bin);
2264     GST_STATE_UNLOCK (element);
2265     return GST_STATE_CHANGE_ASYNC;
2266   }
2267 unneeded:
2268   {
2269     GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2270         "skipping transition from %s to  %s, since bin pending"
2271         " is %s : last change state return follows",
2272         gst_element_state_get_name (child_current),
2273         gst_element_state_get_name (next),
2274         gst_element_state_get_name (pending));
2275     GST_OBJECT_UNLOCK (bin);
2276     GST_STATE_UNLOCK (element);
2277     return ret;
2278   }
2279 }
2280
2281 /* gst_iterator_fold functions for pads_activate
2282  * Stop the iterator if activating one pad failed. */
2283 static gboolean
2284 activate_pads (const GValue * vpad, GValue * ret, gboolean * active)
2285 {
2286   GstPad *pad = g_value_get_object (vpad);
2287   gboolean cont = TRUE;
2288
2289   if (!(cont = gst_pad_set_active (pad, *active)))
2290     g_value_set_boolean (ret, FALSE);
2291
2292   return cont;
2293 }
2294
2295 /* returns false on error or early cutout of the fold, true if all
2296  * pads in @iter were (de)activated successfully. */
2297 static gboolean
2298 iterator_activate_fold_with_resync (GstIterator * iter, gpointer user_data)
2299 {
2300   GstIteratorResult ires;
2301   GValue ret = { 0 };
2302
2303   /* no need to unset this later, it's just a boolean */
2304   g_value_init (&ret, G_TYPE_BOOLEAN);
2305   g_value_set_boolean (&ret, TRUE);
2306
2307   while (1) {
2308     ires = gst_iterator_fold (iter, (GstIteratorFoldFunction) activate_pads,
2309         &ret, user_data);
2310     switch (ires) {
2311       case GST_ITERATOR_RESYNC:
2312         /* need to reset the result again */
2313         g_value_set_boolean (&ret, TRUE);
2314         gst_iterator_resync (iter);
2315         break;
2316       case GST_ITERATOR_DONE:
2317         /* all pads iterated, return collected value */
2318         goto done;
2319       default:
2320         /* iterator returned _ERROR or premature end with _OK,
2321          * mark an error and exit */
2322         g_value_set_boolean (&ret, FALSE);
2323         goto done;
2324     }
2325   }
2326 done:
2327   /* return collected value */
2328   return g_value_get_boolean (&ret);
2329 }
2330
2331 /* is called with STATE_LOCK
2332  */
2333 static gboolean
2334 gst_bin_src_pads_activate (GstBin * bin, gboolean active)
2335 {
2336   GstIterator *iter;
2337   gboolean fold_ok;
2338
2339   GST_DEBUG_OBJECT (bin, "src_pads_activate with active %d", active);
2340
2341   iter = gst_element_iterate_src_pads ((GstElement *) bin);
2342   fold_ok = iterator_activate_fold_with_resync (iter, &active);
2343   gst_iterator_free (iter);
2344   if (G_UNLIKELY (!fold_ok))
2345     goto failed;
2346
2347   GST_DEBUG_OBJECT (bin, "pads_activate successful");
2348
2349   return TRUE;
2350
2351   /* ERRORS */
2352 failed:
2353   {
2354     GST_DEBUG_OBJECT (bin, "source pads_activate failed");
2355     return FALSE;
2356   }
2357 }
2358
2359 /**
2360  * gst_bin_recalculate_latency:
2361  * @bin: a #GstBin
2362  *
2363  * Query @bin for the current latency using and reconfigures this latency to all the
2364  * elements with a LATENCY event.
2365  *
2366  * This method is typically called on the pipeline when a #GST_MESSAGE_LATENCY
2367  * is posted on the bus.
2368  *
2369  * This function simply emits the 'do-latency' signal so any custom latency
2370  * calculations will be performed.
2371  *
2372  * Returns: %TRUE if the latency could be queried and reconfigured.
2373  *
2374  * Since: 0.10.22.
2375  */
2376 gboolean
2377 gst_bin_recalculate_latency (GstBin * bin)
2378 {
2379   gboolean res;
2380
2381   g_signal_emit (bin, gst_bin_signals[DO_LATENCY], 0, &res);
2382   GST_DEBUG_OBJECT (bin, "latency returned %d", res);
2383
2384   return res;
2385 }
2386
2387 static gboolean
2388 gst_bin_do_latency_func (GstBin * bin)
2389 {
2390   GstQuery *query;
2391   GstElement *element;
2392   GstClockTime min_latency, max_latency;
2393   gboolean res;
2394
2395   g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
2396
2397   element = GST_ELEMENT_CAST (bin);
2398
2399   GST_DEBUG_OBJECT (element, "querying latency");
2400
2401   query = gst_query_new_latency ();
2402   if ((res = gst_element_query (element, query))) {
2403     gboolean live;
2404
2405     gst_query_parse_latency (query, &live, &min_latency, &max_latency);
2406
2407     GST_DEBUG_OBJECT (element,
2408         "got min latency %" GST_TIME_FORMAT ", max latency %"
2409         GST_TIME_FORMAT ", live %d", GST_TIME_ARGS (min_latency),
2410         GST_TIME_ARGS (max_latency), live);
2411
2412     if (max_latency < min_latency) {
2413       /* this is an impossible situation, some parts of the pipeline might not
2414        * work correctly. We post a warning for now. */
2415       GST_ELEMENT_WARNING (element, CORE, CLOCK, (NULL),
2416           ("Impossible to configure latency: max %" GST_TIME_FORMAT " < min %"
2417               GST_TIME_FORMAT ". Add queues or other buffering elements.",
2418               GST_TIME_ARGS (max_latency), GST_TIME_ARGS (min_latency)));
2419     }
2420
2421     /* configure latency on elements */
2422     res = gst_element_send_event (element, gst_event_new_latency (min_latency));
2423     if (res) {
2424       GST_INFO_OBJECT (element, "configured latency of %" GST_TIME_FORMAT,
2425           GST_TIME_ARGS (min_latency));
2426     } else {
2427       GST_WARNING_OBJECT (element,
2428           "did not really configure latency of %" GST_TIME_FORMAT,
2429           GST_TIME_ARGS (min_latency));
2430     }
2431   } else {
2432     /* this is not a real problem, we just don't configure any latency. */
2433     GST_WARNING_OBJECT (element, "failed to query latency");
2434   }
2435   gst_query_unref (query);
2436
2437   return res;
2438 }
2439
2440 static void
2441 gst_bin_state_changed (GstElement * element, GstState oldstate,
2442     GstState newstate, GstState pending)
2443 {
2444   GstElementClass *pklass = (GstElementClass *) parent_class;
2445
2446   if (newstate == GST_STATE_PLAYING && pending == GST_STATE_VOID_PENDING)
2447     bin_do_eos (GST_BIN_CAST (element));
2448
2449   if (pklass->state_changed)
2450     pklass->state_changed (element, oldstate, newstate, pending);
2451 }
2452
2453 static GstStateChangeReturn
2454 gst_bin_change_state_func (GstElement * element, GstStateChange transition)
2455 {
2456   GstBin *bin;
2457   GstStateChangeReturn ret;
2458   GstState current, next;
2459   gboolean have_async;
2460   gboolean have_no_preroll;
2461   GstClockTime base_time, start_time;
2462   GstIterator *it;
2463   gboolean done;
2464   GValue data = { 0, };
2465
2466   /* we don't need to take the STATE_LOCK, it is already taken */
2467   current = (GstState) GST_STATE_TRANSITION_CURRENT (transition);
2468   next = (GstState) GST_STATE_TRANSITION_NEXT (transition);
2469
2470   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
2471       "changing state of children from %s to %s",
2472       gst_element_state_get_name (current), gst_element_state_get_name (next));
2473
2474   bin = GST_BIN_CAST (element);
2475
2476   switch (next) {
2477     case GST_STATE_PLAYING:
2478     {
2479       gboolean toplevel;
2480
2481       GST_OBJECT_LOCK (bin);
2482       toplevel = BIN_IS_TOPLEVEL (bin);
2483       GST_OBJECT_UNLOCK (bin);
2484
2485       if (toplevel)
2486         gst_bin_recalculate_latency (bin);
2487       break;
2488     }
2489     case GST_STATE_PAUSED:
2490       /* Clear EOS list on next PAUSED */
2491       GST_OBJECT_LOCK (bin);
2492       GST_DEBUG_OBJECT (element, "clearing EOS elements");
2493       bin_remove_messages (bin, NULL, GST_MESSAGE_EOS);
2494       bin->priv->posted_eos = FALSE;
2495       GST_OBJECT_UNLOCK (bin);
2496       if (current == GST_STATE_READY)
2497         if (!(gst_bin_src_pads_activate (bin, TRUE)))
2498           goto activate_failure;
2499       break;
2500     case GST_STATE_READY:
2501       /* Clear message list on next READY */
2502       GST_OBJECT_LOCK (bin);
2503       GST_DEBUG_OBJECT (element, "clearing all cached messages");
2504       bin_remove_messages (bin, NULL, GST_MESSAGE_ANY);
2505       GST_OBJECT_UNLOCK (bin);
2506       if (current == GST_STATE_PAUSED)
2507         if (!(gst_bin_src_pads_activate (bin, FALSE)))
2508           goto activate_failure;
2509       break;
2510     case GST_STATE_NULL:
2511       if (current == GST_STATE_READY)
2512         if (!(gst_bin_src_pads_activate (bin, FALSE)))
2513           goto activate_failure;
2514       break;
2515     default:
2516       break;
2517   }
2518
2519   /* this flag is used to make the async state changes return immediately. We
2520    * don't want them to interfere with this state change */
2521   GST_OBJECT_LOCK (bin);
2522   bin->polling = TRUE;
2523   GST_OBJECT_UNLOCK (bin);
2524
2525   /* iterate in state change order */
2526   it = gst_bin_iterate_sorted (bin);
2527
2528   /* mark if we've seen an ASYNC element in the bin when we did a state change.
2529    * Note how we don't reset this value when a resync happens, the reason being
2530    * that the async element posted ASYNC_START and we want to post ASYNC_DONE
2531    * even after a resync when the async element is gone */
2532   have_async = FALSE;
2533
2534 restart:
2535   /* take base_time */
2536   base_time = gst_element_get_base_time (element);
2537   start_time = gst_element_get_start_time (element);
2538
2539   have_no_preroll = FALSE;
2540
2541   done = FALSE;
2542   while (!done) {
2543     switch (gst_iterator_next (it, &data)) {
2544       case GST_ITERATOR_OK:
2545       {
2546         GstElement *child;
2547
2548         child = g_value_get_object (&data);
2549
2550         /* set state and base_time now */
2551         ret = gst_bin_element_set_state (bin, child, base_time, start_time,
2552             current, next);
2553
2554         switch (ret) {
2555           case GST_STATE_CHANGE_SUCCESS:
2556             GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2557                 "child '%s' changed state to %d(%s) successfully",
2558                 GST_ELEMENT_NAME (child), next,
2559                 gst_element_state_get_name (next));
2560             break;
2561           case GST_STATE_CHANGE_ASYNC:
2562           {
2563             GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2564                 "child '%s' is changing state asynchronously to %s",
2565                 GST_ELEMENT_NAME (child), gst_element_state_get_name (next));
2566             have_async = TRUE;
2567             break;
2568           }
2569           case GST_STATE_CHANGE_FAILURE:{
2570             GstObject *parent;
2571
2572             GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2573                 "child '%s' failed to go to state %d(%s)",
2574                 GST_ELEMENT_NAME (child),
2575                 next, gst_element_state_get_name (next));
2576
2577             /* Only fail if the child is still inside
2578              * this bin. It might've been removed already
2579              * because of the error by the bin subclass
2580              * to ignore the error.  */
2581             parent = gst_object_get_parent (GST_OBJECT_CAST (child));
2582             if (parent == GST_OBJECT_CAST (element)) {
2583               /* element is still in bin, really error now */
2584               gst_object_unref (parent);
2585               goto done;
2586             }
2587             /* child removed from bin, let the resync code redo the state
2588              * change */
2589             GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2590                 "child '%s' was removed from the bin",
2591                 GST_ELEMENT_NAME (child));
2592
2593             if (parent)
2594               gst_object_unref (parent);
2595
2596             break;
2597           }
2598           case GST_STATE_CHANGE_NO_PREROLL:
2599             GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
2600                 "child '%s' changed state to %d(%s) successfully without preroll",
2601                 GST_ELEMENT_NAME (child), next,
2602                 gst_element_state_get_name (next));
2603             have_no_preroll = TRUE;
2604             break;
2605           default:
2606             g_assert_not_reached ();
2607             break;
2608         }
2609         g_value_reset (&data);
2610         break;
2611       }
2612       case GST_ITERATOR_RESYNC:
2613         GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element, "iterator doing resync");
2614         gst_iterator_resync (it);
2615         goto restart;
2616       default:
2617       case GST_ITERATOR_DONE:
2618         GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element, "iterator done");
2619         done = TRUE;
2620         break;
2621     }
2622   }
2623
2624   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
2625   if (G_UNLIKELY (ret == GST_STATE_CHANGE_FAILURE))
2626     goto done;
2627
2628   if (have_no_preroll) {
2629     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
2630         "we have NO_PREROLL elements %s -> NO_PREROLL",
2631         gst_element_state_change_return_get_name (ret));
2632     ret = GST_STATE_CHANGE_NO_PREROLL;
2633   } else if (have_async) {
2634     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
2635         "we have ASYNC elements %s -> ASYNC",
2636         gst_element_state_change_return_get_name (ret));
2637     ret = GST_STATE_CHANGE_ASYNC;
2638   }
2639
2640 done:
2641   g_value_unset (&data);
2642   gst_iterator_free (it);
2643
2644   GST_OBJECT_LOCK (bin);
2645   bin->polling = FALSE;
2646   /* it's possible that we did not get ASYNC from the children while the bin is
2647    * simulating ASYNC behaviour by posting an ASYNC_DONE message on the bus with
2648    * itself as the source. In that case we still want to check if the state
2649    * change completed. */
2650   if (ret != GST_STATE_CHANGE_ASYNC && !bin->priv->pending_async_done) {
2651     /* no element returned ASYNC and there are no pending async_done messages,
2652      * we can just complete. */
2653     GST_DEBUG_OBJECT (bin, "no async elements");
2654     goto state_end;
2655   }
2656   /* when we get here an ASYNC element was found */
2657   if (GST_STATE_TARGET (bin) <= GST_STATE_READY) {
2658     /* we ignore ASYNC state changes when we go to READY or NULL */
2659     GST_DEBUG_OBJECT (bin, "target state %s <= READY",
2660         gst_element_state_get_name (GST_STATE_TARGET (bin)));
2661     goto state_end;
2662   }
2663
2664   GST_DEBUG_OBJECT (bin, "check async elements");
2665   /* check if all elements managed to commit their state already */
2666   if (!find_message (bin, NULL, GST_MESSAGE_ASYNC_START)) {
2667     /* nothing found, remove all old ASYNC_DONE messages. This can happen when
2668      * all the elements commited their state while we were doing the state
2669      * change. We will still return ASYNC for consistency but we commit the
2670      * state already so that a _get_state() will return immediately. */
2671     bin_remove_messages (bin, NULL, GST_MESSAGE_ASYNC_DONE);
2672
2673     GST_DEBUG_OBJECT (bin, "async elements commited");
2674     bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS, FALSE, FALSE);
2675   }
2676
2677 state_end:
2678   bin->priv->pending_async_done = FALSE;
2679   GST_OBJECT_UNLOCK (bin);
2680
2681   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
2682       "done changing bin's state from %s to %s, now in %s, ret %s",
2683       gst_element_state_get_name (current),
2684       gst_element_state_get_name (next),
2685       gst_element_state_get_name (GST_STATE (element)),
2686       gst_element_state_change_return_get_name (ret));
2687
2688   return ret;
2689
2690   /* ERRORS */
2691 activate_failure:
2692   {
2693     GST_CAT_WARNING_OBJECT (GST_CAT_STATES, element,
2694         "failure (de)activating src pads");
2695     return GST_STATE_CHANGE_FAILURE;
2696   }
2697 }
2698
2699 /*
2700  * This function is a utility event handler for seek events.
2701  * It will send the event to all sinks or sources depending on the
2702  * event-direction.
2703  *
2704  * Applications are free to override this behaviour and
2705  * implement their own seek handler, but this will work for
2706  * pretty much all cases in practice.
2707  */
2708 static gboolean
2709 gst_bin_send_event (GstElement * element, GstEvent * event)
2710 {
2711   GstBin *bin = GST_BIN_CAST (element);
2712   GstIterator *iter;
2713   gboolean res = TRUE;
2714   gboolean done = FALSE;
2715   GValue data = { 0, };
2716
2717   if (GST_EVENT_IS_DOWNSTREAM (event)) {
2718     iter = gst_bin_iterate_sources (bin);
2719     GST_DEBUG_OBJECT (bin, "Sending %s event to src children",
2720         GST_EVENT_TYPE_NAME (event));
2721   } else {
2722     iter = gst_bin_iterate_sinks (bin);
2723     GST_DEBUG_OBJECT (bin, "Sending %s event to sink children",
2724         GST_EVENT_TYPE_NAME (event));
2725   }
2726
2727   while (!done) {
2728     switch (gst_iterator_next (iter, &data)) {
2729       case GST_ITERATOR_OK:
2730       {
2731         GstElement *child = g_value_get_object (&data);;
2732
2733         gst_event_ref (event);
2734         res &= gst_element_send_event (child, event);
2735         GST_LOG_OBJECT (child, "After handling %s event: %d",
2736             GST_EVENT_TYPE_NAME (event), res);
2737         break;
2738       }
2739       case GST_ITERATOR_RESYNC:
2740         gst_iterator_resync (iter);
2741         res = TRUE;
2742         break;
2743       case GST_ITERATOR_DONE:
2744         done = TRUE;
2745         break;
2746       case GST_ITERATOR_ERROR:
2747         g_assert_not_reached ();
2748         break;
2749     }
2750   }
2751   g_value_unset (&data);
2752   gst_iterator_free (iter);
2753   gst_event_unref (event);
2754
2755   return res;
2756 }
2757
2758 /* this is the function called by the threadpool. When async elements commit
2759  * their state, this function will attempt to bring the bin to the next state.
2760  */
2761 static void
2762 gst_bin_continue_func (BinContinueData * data)
2763 {
2764   GstBin *bin;
2765   GstState current, next, pending;
2766   GstStateChange transition;
2767
2768   bin = data->bin;
2769   pending = data->pending;
2770
2771   GST_DEBUG_OBJECT (bin, "waiting for state lock");
2772   GST_STATE_LOCK (bin);
2773
2774   GST_DEBUG_OBJECT (bin, "doing state continue");
2775   GST_OBJECT_LOCK (bin);
2776
2777   /* if a new state change happened after this thread was scheduled, we return
2778    * immediately. */
2779   if (data->cookie != GST_ELEMENT_CAST (bin)->state_cookie)
2780     goto interrupted;
2781
2782   current = GST_STATE (bin);
2783   next = GST_STATE_GET_NEXT (current, pending);
2784   transition = (GstStateChange) GST_STATE_TRANSITION (current, next);
2785
2786   GST_STATE_NEXT (bin) = next;
2787   GST_STATE_PENDING (bin) = pending;
2788   /* mark busy */
2789   GST_STATE_RETURN (bin) = GST_STATE_CHANGE_ASYNC;
2790   GST_OBJECT_UNLOCK (bin);
2791
2792   GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
2793       "continue state change %s to %s, final %s",
2794       gst_element_state_get_name (current),
2795       gst_element_state_get_name (next), gst_element_state_get_name (pending));
2796
2797   gst_element_change_state (GST_ELEMENT_CAST (bin), transition);
2798
2799   GST_STATE_UNLOCK (bin);
2800   GST_DEBUG_OBJECT (bin, "state continue done");
2801
2802   gst_object_unref (bin);
2803   g_slice_free (BinContinueData, data);
2804   return;
2805
2806 interrupted:
2807   {
2808     GST_OBJECT_UNLOCK (bin);
2809     GST_STATE_UNLOCK (bin);
2810     GST_DEBUG_OBJECT (bin, "state continue aborted due to intervening change");
2811     gst_object_unref (bin);
2812     g_slice_free (BinContinueData, data);
2813     return;
2814   }
2815 }
2816
2817 static GstBusSyncReply
2818 bin_bus_handler (GstBus * bus, GstMessage * message, GstBin * bin)
2819 {
2820   GstBinClass *bclass;
2821
2822   bclass = GST_BIN_GET_CLASS (bin);
2823   if (bclass->handle_message)
2824     bclass->handle_message (bin, message);
2825   else
2826     gst_message_unref (message);
2827
2828   return GST_BUS_DROP;
2829 }
2830
2831 static void
2832 bin_push_state_continue (BinContinueData * data)
2833 {
2834   GstBinClass *klass;
2835   GstBin *bin;
2836
2837   /* ref was taken */
2838   bin = data->bin;
2839   klass = GST_BIN_GET_CLASS (bin);
2840
2841   GST_DEBUG_OBJECT (bin, "pushing continue on thread pool");
2842   g_thread_pool_push (klass->pool, data, NULL);
2843 }
2844
2845 /* an element started an async state change, if we were not busy with a state
2846  * change, we perform a lost state.
2847  * This function is called with the OBJECT lock.
2848  */
2849 static void
2850 bin_handle_async_start (GstBin * bin)
2851 {
2852   GstState old_state, new_state;
2853   gboolean toplevel;
2854   GstMessage *amessage = NULL;
2855
2856   if (GST_STATE_RETURN (bin) == GST_STATE_CHANGE_FAILURE)
2857     goto had_error;
2858
2859   /* get our toplevel state */
2860   toplevel = BIN_IS_TOPLEVEL (bin);
2861
2862   /* prepare an ASYNC_START message, we always post the start message even if we
2863    * are busy with a state change or when we are NO_PREROLL. */
2864   if (!toplevel)
2865     /* non toplevel bin, prepare async-start for the parent */
2866     amessage = gst_message_new_async_start (GST_OBJECT_CAST (bin));
2867
2868   if (bin->polling || GST_STATE_PENDING (bin) != GST_STATE_VOID_PENDING)
2869     goto was_busy;
2870
2871   /* async starts are ignored when we are NO_PREROLL */
2872   if (GST_STATE_RETURN (bin) == GST_STATE_CHANGE_NO_PREROLL)
2873     goto was_no_preroll;
2874
2875   old_state = GST_STATE (bin);
2876
2877   /* when we PLAYING we go back to PAUSED, when preroll happens, we go back to
2878    * PLAYING after optionally redistributing the base_time. */
2879   if (old_state > GST_STATE_PAUSED)
2880     new_state = GST_STATE_PAUSED;
2881   else
2882     new_state = old_state;
2883
2884   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
2885       "lost state of %s, new %s", gst_element_state_get_name (old_state),
2886       gst_element_state_get_name (new_state));
2887
2888   GST_STATE (bin) = new_state;
2889   GST_STATE_NEXT (bin) = new_state;
2890   GST_STATE_PENDING (bin) = new_state;
2891   GST_STATE_RETURN (bin) = GST_STATE_CHANGE_ASYNC;
2892   GST_OBJECT_UNLOCK (bin);
2893
2894   /* post message */
2895   _priv_gst_element_state_changed (GST_ELEMENT_CAST (bin), new_state, new_state,
2896       new_state);
2897
2898 post_start:
2899   if (amessage) {
2900     /* post our ASYNC_START. */
2901     GST_DEBUG_OBJECT (bin, "posting ASYNC_START to parent");
2902     gst_element_post_message (GST_ELEMENT_CAST (bin), amessage);
2903   }
2904   GST_OBJECT_LOCK (bin);
2905
2906   return;
2907
2908 had_error:
2909   {
2910     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "we had an error");
2911     return;
2912   }
2913 was_busy:
2914   {
2915     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "state change busy");
2916     GST_OBJECT_UNLOCK (bin);
2917     goto post_start;
2918   }
2919 was_no_preroll:
2920   {
2921     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "ignoring, we are NO_PREROLL");
2922     GST_OBJECT_UNLOCK (bin);
2923     goto post_start;
2924   }
2925 }
2926
2927 /* this function is called when there are no more async elements in the bin. We
2928  * post a state changed message and an ASYNC_DONE message.
2929  * This function is called with the OBJECT lock.
2930  */
2931 static void
2932 bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret,
2933     gboolean flag_pending, gboolean reset_time)
2934 {
2935   GstState current, pending, target;
2936   GstStateChangeReturn old_ret;
2937   GstState old_state, old_next;
2938   gboolean toplevel, state_changed = FALSE;
2939   GstMessage *amessage = NULL;
2940   BinContinueData *cont = NULL;
2941
2942   if (GST_STATE_RETURN (bin) == GST_STATE_CHANGE_FAILURE)
2943     goto had_error;
2944
2945   pending = GST_STATE_PENDING (bin);
2946
2947   if (bin->polling)
2948     goto was_busy;
2949
2950   /* check if there is something to commit */
2951   if (pending == GST_STATE_VOID_PENDING)
2952     goto nothing_pending;
2953
2954   old_ret = GST_STATE_RETURN (bin);
2955   GST_STATE_RETURN (bin) = ret;
2956
2957   /* move to the next target state */
2958   target = GST_STATE_TARGET (bin);
2959   pending = GST_STATE_PENDING (bin) = target;
2960
2961   amessage = gst_message_new_async_done (GST_OBJECT_CAST (bin), reset_time);
2962
2963   old_state = GST_STATE (bin);
2964   /* this is the state we should go to next */
2965   old_next = GST_STATE_NEXT (bin);
2966
2967   if (old_next != GST_STATE_PLAYING) {
2968     GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
2969         "committing state from %s to %s, old pending %s",
2970         gst_element_state_get_name (old_state),
2971         gst_element_state_get_name (old_next),
2972         gst_element_state_get_name (pending));
2973
2974     /* update current state */
2975     current = GST_STATE (bin) = old_next;
2976   } else {
2977     GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
2978         "setting state from %s to %s, pending %s",
2979         gst_element_state_get_name (old_state),
2980         gst_element_state_get_name (old_state),
2981         gst_element_state_get_name (pending));
2982     current = old_state;
2983   }
2984
2985   /* get our toplevel state */
2986   toplevel = BIN_IS_TOPLEVEL (bin);
2987
2988   /* see if we reached the final state. If we are not toplevel, we also have to
2989    * stop here, the parent will continue our state. */
2990   if ((pending == current) || !toplevel) {
2991     GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
2992         "completed state change, pending VOID");
2993
2994     /* mark VOID pending */
2995     pending = GST_STATE_VOID_PENDING;
2996     GST_STATE_PENDING (bin) = pending;
2997     GST_STATE_NEXT (bin) = GST_STATE_VOID_PENDING;
2998   } else {
2999     GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
3000         "continue state change, pending %s",
3001         gst_element_state_get_name (pending));
3002
3003     cont = g_slice_new (BinContinueData);
3004
3005     /* ref to the bin */
3006     cont->bin = gst_object_ref (bin);
3007     /* cookie to detect concurrent state change */
3008     cont->cookie = GST_ELEMENT_CAST (bin)->state_cookie;
3009     /* pending target state */
3010     cont->pending = pending;
3011     /* mark busy */
3012     GST_STATE_RETURN (bin) = GST_STATE_CHANGE_ASYNC;
3013     GST_STATE_NEXT (bin) = GST_STATE_GET_NEXT (old_state, pending);
3014   }
3015
3016   if (old_next != GST_STATE_PLAYING) {
3017     if (old_state != old_next || old_ret == GST_STATE_CHANGE_ASYNC) {
3018       state_changed = TRUE;
3019     }
3020   }
3021   GST_OBJECT_UNLOCK (bin);
3022
3023   if (state_changed) {
3024     _priv_gst_element_state_changed (GST_ELEMENT_CAST (bin), old_state,
3025         old_next, pending);
3026   }
3027   if (amessage) {
3028     /* post our combined ASYNC_DONE when all is ASYNC_DONE. */
3029     GST_DEBUG_OBJECT (bin, "posting ASYNC_DONE to parent");
3030     gst_element_post_message (GST_ELEMENT_CAST (bin), amessage);
3031   }
3032
3033   GST_OBJECT_LOCK (bin);
3034   if (cont) {
3035     /* toplevel, start continue state */
3036     GST_DEBUG_OBJECT (bin, "all async-done, starting state continue");
3037     bin_push_state_continue (cont);
3038   } else {
3039     GST_DEBUG_OBJECT (bin, "state change complete");
3040     GST_STATE_BROADCAST (bin);
3041   }
3042   return;
3043
3044 had_error:
3045   {
3046     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "we had an error");
3047     return;
3048   }
3049 was_busy:
3050   {
3051     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "state change busy");
3052     /* if we were busy with a state change and we are requested to flag a
3053      * pending async done, we do so here */
3054     if (flag_pending)
3055       bin->priv->pending_async_done = TRUE;
3056     return;
3057   }
3058 nothing_pending:
3059   {
3060     GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin, "nothing pending");
3061     return;
3062   }
3063 }
3064
3065 static void
3066 bin_do_eos (GstBin * bin)
3067 {
3068   guint32 seqnum = 0;
3069   gboolean eos;
3070
3071   GST_OBJECT_LOCK (bin);
3072   /* If all sinks are EOS, we're in PLAYING and no state change is pending
3073    * we forward the EOS message to the parent bin or application
3074    */
3075   eos = GST_STATE (bin) == GST_STATE_PLAYING
3076       && GST_STATE_PENDING (bin) == GST_STATE_VOID_PENDING
3077       && is_eos (bin, &seqnum);
3078   GST_OBJECT_UNLOCK (bin);
3079
3080   if (eos
3081       && g_atomic_int_compare_and_exchange (&bin->priv->posted_eos, FALSE,
3082           TRUE)) {
3083     GstMessage *tmessage;
3084
3085     /* Clear out any further messages, and reset posted_eos so we can
3086        detect any new EOS that happens (eg, after a seek). Since all
3087        sinks have now posted an EOS, there will be no further EOS events
3088        seen unless there is a new logical EOS */
3089     GST_OBJECT_LOCK (bin);
3090     bin_remove_messages (bin, NULL, GST_MESSAGE_EOS);
3091     bin->priv->posted_eos = FALSE;
3092     GST_OBJECT_UNLOCK (bin);
3093
3094     tmessage = gst_message_new_eos (GST_OBJECT_CAST (bin));
3095     gst_message_set_seqnum (tmessage, seqnum);
3096     GST_DEBUG_OBJECT (bin,
3097         "all sinks posted EOS, posting seqnum #%" G_GUINT32_FORMAT, seqnum);
3098     gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
3099   }
3100 }
3101
3102 /* must be called with the object lock. This function releases the lock to post
3103  * the message. */
3104 static void
3105 bin_do_message_forward (GstBin * bin, GstMessage * message)
3106 {
3107   if (bin->priv->message_forward) {
3108     GstMessage *forwarded;
3109
3110     GST_DEBUG_OBJECT (bin, "pass %s message upward",
3111         GST_MESSAGE_TYPE_NAME (message));
3112     GST_OBJECT_UNLOCK (bin);
3113
3114     /* we need to convert these messages to element messages so that our parent
3115      * bin can easily ignore them and so that the application can easily
3116      * distinguish between the internally forwarded and the real messages. */
3117     forwarded = gst_message_new_element (GST_OBJECT_CAST (bin),
3118         gst_structure_new ("GstBinForwarded",
3119             "message", GST_TYPE_MESSAGE, message, NULL));
3120
3121     gst_element_post_message (GST_ELEMENT_CAST (bin), forwarded);
3122
3123     GST_OBJECT_LOCK (bin);
3124   }
3125 }
3126
3127 /* handle child messages:
3128  *
3129  * This method is called synchronously when a child posts a message on
3130  * the internal bus.
3131  *
3132  * GST_MESSAGE_EOS: This message is only posted by sinks
3133  *     in the PLAYING state. If all sinks posted the EOS message, post
3134  *     one upwards.
3135  *
3136  * GST_MESSAGE_STATE_DIRTY: Deprecated
3137  *
3138  * GST_MESSAGE_SEGMENT_START: just collect, never forward upwards. If an
3139  *     element posts segment_start twice, only the last message is kept.
3140  *
3141  * GST_MESSAGE_SEGMENT_DONE: replace SEGMENT_START message from same poster
3142  *     with the segment_done message. If there are no more segment_start
3143  *     messages, post segment_done message upwards.
3144  *
3145  * GST_MESSAGE_DURATION: remove all previously cached duration messages.
3146  *     Whenever someone performs a duration query on the bin, we store the
3147  *     result so we can answer it quicker the next time. Any element that
3148  *     changes its duration marks our cached values invalid.
3149  *     This message is also posted upwards. This is currently disabled
3150  *     because too many elements don't post DURATION messages when the
3151  *     duration changes.
3152  *
3153  * GST_MESSAGE_CLOCK_LOST: This message is posted by an element when it
3154  *     can no longer provide a clock. The default bin behaviour is to
3155  *     check if the lost clock was the one provided by the bin. If so and
3156  *     we are currently in the PLAYING state, we forward the message to
3157  *     our parent.
3158  *     This message is also generated when we remove a clock provider from
3159  *     a bin. If this message is received by the application, it should
3160  *     PAUSE the pipeline and set it back to PLAYING to force a new clock
3161  *     and a new base_time distribution.
3162  *
3163  * GST_MESSAGE_CLOCK_PROVIDE: This message is generated when an element
3164  *     can provide a clock. This mostly happens when we add a new clock
3165  *     provider to the bin. The default behaviour of the bin is to mark the
3166  *     currently selected clock as dirty, which will perform a clock
3167  *     recalculation the next time we are asked to provide a clock.
3168  *     This message is never sent to the application but is forwarded to
3169  *     the parent.
3170  *
3171  * GST_MESSAGE_ASYNC_START: Create an internal ELEMENT message that stores
3172  *     the state of the element and the fact that the element will need a
3173  *     new base_time. This message is not forwarded to the application.
3174  *
3175  * GST_MESSAGE_ASYNC_DONE: Find the internal ELEMENT message we kept for the
3176  *     element when it posted ASYNC_START. If all elements are done, post a
3177  *     ASYNC_DONE message to the parent.
3178  *
3179  * OTHER: post upwards.
3180  */
3181 static void
3182 gst_bin_handle_message_func (GstBin * bin, GstMessage * message)
3183 {
3184   GstObject *src;
3185   GstMessageType type;
3186   GstMessage *tmessage;
3187   guint32 seqnum;
3188
3189   src = GST_MESSAGE_SRC (message);
3190   type = GST_MESSAGE_TYPE (message);
3191
3192   GST_DEBUG_OBJECT (bin, "[msg %p] handling child %s message of type %s",
3193       message, src ? GST_ELEMENT_NAME (src) : "(NULL)",
3194       GST_MESSAGE_TYPE_NAME (message));
3195
3196   switch (type) {
3197     case GST_MESSAGE_ERROR:
3198     {
3199       GST_OBJECT_LOCK (bin);
3200       /* flag error */
3201       GST_DEBUG_OBJECT (bin, "got ERROR message, unlocking state change");
3202       GST_STATE_RETURN (bin) = GST_STATE_CHANGE_FAILURE;
3203       GST_STATE_BROADCAST (bin);
3204       GST_OBJECT_UNLOCK (bin);
3205
3206       goto forward;
3207     }
3208     case GST_MESSAGE_EOS:
3209     {
3210
3211       /* collect all eos messages from the children */
3212       GST_OBJECT_LOCK (bin);
3213       bin_do_message_forward (bin, message);
3214       /* ref message for future use  */
3215       bin_replace_message (bin, message, GST_MESSAGE_EOS);
3216       GST_OBJECT_UNLOCK (bin);
3217
3218       bin_do_eos (bin);
3219       break;
3220     }
3221     case GST_MESSAGE_STATE_DIRTY:
3222     {
3223       GST_WARNING_OBJECT (bin, "received deprecated STATE_DIRTY message");
3224
3225       /* free message */
3226       gst_message_unref (message);
3227       break;
3228     }
3229     case GST_MESSAGE_SEGMENT_START:{
3230       gboolean post = FALSE;
3231       GstFormat format;
3232       gint64 position;
3233
3234       gst_message_parse_segment_start (message, &format, &position);
3235       seqnum = gst_message_get_seqnum (message);
3236
3237       GST_OBJECT_LOCK (bin);
3238       bin_do_message_forward (bin, message);
3239       /* if this is the first segment-start, post to parent but not to the
3240        * application */
3241       if (!find_message (bin, NULL, GST_MESSAGE_SEGMENT_START) &&
3242           (GST_OBJECT_PARENT (bin) != NULL)) {
3243         post = TRUE;
3244       }
3245       /* replace any previous segment_start message from this source
3246        * with the new segment start message */
3247       bin_replace_message (bin, message, GST_MESSAGE_SEGMENT_START);
3248       GST_OBJECT_UNLOCK (bin);
3249       if (post) {
3250         tmessage = gst_message_new_segment_start (GST_OBJECT_CAST (bin),
3251             format, position);
3252         gst_message_set_seqnum (tmessage, seqnum);
3253
3254         /* post segment start with initial format and position. */
3255         GST_DEBUG_OBJECT (bin, "posting SEGMENT_START (%u) bus message: %p",
3256             seqnum, message);
3257         gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
3258       }
3259       break;
3260     }
3261     case GST_MESSAGE_SEGMENT_DONE:
3262     {
3263       gboolean post = FALSE;
3264       GstFormat format;
3265       gint64 position;
3266
3267       gst_message_parse_segment_done (message, &format, &position);
3268       seqnum = gst_message_get_seqnum (message);
3269
3270       GST_OBJECT_LOCK (bin);
3271       bin_do_message_forward (bin, message);
3272       bin_replace_message (bin, message, GST_MESSAGE_SEGMENT_START);
3273       /* if there are no more segment_start messages, everybody posted
3274        * a segment_done and we can post one on the bus. */
3275
3276       /* we don't care who still has a pending segment start */
3277       if (!find_message (bin, NULL, GST_MESSAGE_SEGMENT_START)) {
3278         /* nothing found */
3279         post = TRUE;
3280         /* remove all old segment_done messages */
3281         bin_remove_messages (bin, NULL, GST_MESSAGE_SEGMENT_DONE);
3282       }
3283       GST_OBJECT_UNLOCK (bin);
3284       if (post) {
3285         tmessage = gst_message_new_segment_done (GST_OBJECT_CAST (bin),
3286             format, position);
3287         gst_message_set_seqnum (tmessage, seqnum);
3288
3289         /* post segment done with latest format and position. */
3290         GST_DEBUG_OBJECT (bin, "posting SEGMENT_DONE (%u) bus message: %p",
3291             seqnum, message);
3292         gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
3293       }
3294       break;
3295     }
3296     case GST_MESSAGE_DURATION:
3297     {
3298       /* remove all cached duration messages, next time somebody asks
3299        * for duration, we will recalculate. */
3300       GST_OBJECT_LOCK (bin);
3301       bin_remove_messages (bin, NULL, GST_MESSAGE_DURATION);
3302       GST_OBJECT_UNLOCK (bin);
3303       goto forward;
3304     }
3305     case GST_MESSAGE_CLOCK_LOST:
3306     {
3307       GstClock **provided_clock_p;
3308       GstElement **clock_provider_p;
3309       gboolean playing, provided, forward;
3310       GstClock *clock;
3311
3312       gst_message_parse_clock_lost (message, &clock);
3313
3314       GST_OBJECT_LOCK (bin);
3315       bin->clock_dirty = TRUE;
3316       /* if we lost the clock that we provided, post to parent but
3317        * only if we are PLAYING. */
3318       provided = (clock == bin->provided_clock);
3319       playing = (GST_STATE (bin) == GST_STATE_PLAYING);
3320       forward = playing & provided;
3321       if (provided) {
3322         GST_DEBUG_OBJECT (bin,
3323             "Lost clock %" GST_PTR_FORMAT " provided by %" GST_PTR_FORMAT,
3324             bin->provided_clock, bin->clock_provider);
3325         provided_clock_p = &bin->provided_clock;
3326         clock_provider_p = &bin->clock_provider;
3327         gst_object_replace ((GstObject **) provided_clock_p, NULL);
3328         gst_object_replace ((GstObject **) clock_provider_p, NULL);
3329       }
3330       GST_DEBUG_OBJECT (bin, "provided %d, playing %d, forward %d",
3331           provided, playing, forward);
3332       GST_OBJECT_UNLOCK (bin);
3333
3334       if (forward)
3335         goto forward;
3336
3337       /* free message */
3338       gst_message_unref (message);
3339       break;
3340     }
3341     case GST_MESSAGE_CLOCK_PROVIDE:
3342     {
3343       gboolean forward;
3344
3345       GST_OBJECT_LOCK (bin);
3346       bin->clock_dirty = TRUE;
3347       /* a new clock is available, post to parent but not
3348        * to the application */
3349       forward = GST_OBJECT_PARENT (bin) != NULL;
3350       GST_OBJECT_UNLOCK (bin);
3351
3352       if (forward)
3353         goto forward;
3354
3355       /* free message */
3356       gst_message_unref (message);
3357       break;
3358     }
3359     case GST_MESSAGE_ASYNC_START:
3360     {
3361       GstState target;
3362
3363       GST_DEBUG_OBJECT (bin, "ASYNC_START message %p, %s", message,
3364           src ? GST_OBJECT_NAME (src) : "(NULL)");
3365
3366       GST_OBJECT_LOCK (bin);
3367       bin_do_message_forward (bin, message);
3368
3369       /* we ignore the message if we are going to <= READY */
3370       if ((target = GST_STATE_TARGET (bin)) <= GST_STATE_READY)
3371         goto ignore_start_message;
3372
3373       /* takes ownership of the message */
3374       bin_replace_message (bin, message, GST_MESSAGE_ASYNC_START);
3375
3376       bin_handle_async_start (bin);
3377       GST_OBJECT_UNLOCK (bin);
3378       break;
3379
3380     ignore_start_message:
3381       {
3382         GST_DEBUG_OBJECT (bin, "ignoring message, target %s",
3383             gst_element_state_get_name (target));
3384         GST_OBJECT_UNLOCK (bin);
3385         gst_message_unref (message);
3386         break;
3387       }
3388     }
3389     case GST_MESSAGE_ASYNC_DONE:
3390     {
3391       gboolean reset_time;
3392       GstState target;
3393
3394       GST_DEBUG_OBJECT (bin, "ASYNC_DONE message %p, %s", message,
3395           src ? GST_OBJECT_NAME (src) : "(NULL)");
3396
3397       gst_message_parse_async_done (message, &reset_time);
3398
3399       GST_OBJECT_LOCK (bin);
3400       bin_do_message_forward (bin, message);
3401
3402       /* ignore messages if we are shutting down */
3403       if ((target = GST_STATE_TARGET (bin)) <= GST_STATE_READY)
3404         goto ignore_done_message;
3405
3406       bin_replace_message (bin, message, GST_MESSAGE_ASYNC_START);
3407       /* if there are no more ASYNC_START messages, everybody posted
3408        * a ASYNC_DONE and we can post one on the bus. When checking, we
3409        * don't care who still has a pending ASYNC_START */
3410       if (!find_message (bin, NULL, GST_MESSAGE_ASYNC_START)) {
3411         /* nothing found, remove all old ASYNC_DONE messages */
3412         bin_remove_messages (bin, NULL, GST_MESSAGE_ASYNC_DONE);
3413
3414         GST_DEBUG_OBJECT (bin, "async elements commited");
3415         /* when we get an async done message when a state change was busy, we
3416          * need to set the pending_done flag so that at the end of the state
3417          * change we can see if we need to verify pending async elements, hence
3418          * the TRUE argument here. */
3419         bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS, TRUE, reset_time);
3420       } else {
3421         GST_DEBUG_OBJECT (bin, "there are more async elements pending");
3422       }
3423       GST_OBJECT_UNLOCK (bin);
3424       break;
3425
3426     ignore_done_message:
3427       {
3428         GST_DEBUG_OBJECT (bin, "ignoring message, target %s",
3429             gst_element_state_get_name (target));
3430         GST_OBJECT_UNLOCK (bin);
3431         gst_message_unref (message);
3432         break;
3433       }
3434     }
3435     case GST_MESSAGE_STRUCTURE_CHANGE:
3436     {
3437       gboolean busy;
3438
3439       gst_message_parse_structure_change (message, NULL, NULL, &busy);
3440
3441       GST_OBJECT_LOCK (bin);
3442       if (busy) {
3443         /* while the pad is busy, avoid following it when doing state changes.
3444          * Don't update the cookie yet, we will do that after the structure
3445          * change finished and we are ready to inspect the new updated
3446          * structure. */
3447         bin_replace_message (bin, message, GST_MESSAGE_STRUCTURE_CHANGE);
3448         message = NULL;
3449       } else {
3450         /* a pad link/unlink ended, signal the state change iterator that we
3451          * need to resync by updating the structure_cookie. */
3452         bin_remove_messages (bin, GST_MESSAGE_SRC (message),
3453             GST_MESSAGE_STRUCTURE_CHANGE);
3454         bin->priv->structure_cookie++;
3455       }
3456       GST_OBJECT_UNLOCK (bin);
3457
3458       if (message)
3459         gst_message_unref (message);
3460
3461       break;
3462     }
3463     default:
3464       goto forward;
3465   }
3466   return;
3467
3468 forward:
3469   {
3470     /* Send all other messages upward */
3471     GST_DEBUG_OBJECT (bin, "posting message upward");
3472     gst_element_post_message (GST_ELEMENT_CAST (bin), message);
3473     return;
3474   }
3475 }
3476
3477 /* generic struct passed to all query fold methods */
3478 typedef struct
3479 {
3480   GstQuery *query;
3481   gint64 min;
3482   gint64 max;
3483   gboolean live;
3484 } QueryFold;
3485
3486 typedef void (*QueryInitFunction) (GstBin * bin, QueryFold * fold);
3487 typedef void (*QueryDoneFunction) (GstBin * bin, QueryFold * fold);
3488
3489 /* for duration/position we collect all durations/positions and take
3490  * the MAX of all valid results */
3491 static void
3492 bin_query_min_max_init (GstBin * bin, QueryFold * fold)
3493 {
3494   fold->min = 0;
3495   fold->max = -1;
3496   fold->live = FALSE;
3497 }
3498
3499 static gboolean
3500 bin_query_duration_fold (const GValue * vitem, GValue * ret, QueryFold * fold)
3501 {
3502   GstElement *item = g_value_get_object (vitem);
3503
3504   if (gst_element_query (item, fold->query)) {
3505     gint64 duration;
3506
3507     g_value_set_boolean (ret, TRUE);
3508
3509     gst_query_parse_duration (fold->query, NULL, &duration);
3510
3511     GST_DEBUG_OBJECT (item, "got duration %" G_GINT64_FORMAT, duration);
3512
3513     if (duration > fold->max)
3514       fold->max = duration;
3515   }
3516
3517   return TRUE;
3518 }
3519
3520 static void
3521 bin_query_duration_done (GstBin * bin, QueryFold * fold)
3522 {
3523   GstFormat format;
3524
3525   gst_query_parse_duration (fold->query, &format, NULL);
3526   /* store max in query result */
3527   gst_query_set_duration (fold->query, format, fold->max);
3528
3529   GST_DEBUG_OBJECT (bin, "max duration %" G_GINT64_FORMAT, fold->max);
3530
3531   /* and cache now */
3532   GST_OBJECT_LOCK (bin);
3533   bin->messages = g_list_prepend (bin->messages,
3534       gst_message_new_duration (GST_OBJECT_CAST (bin), format, fold->max));
3535   GST_OBJECT_UNLOCK (bin);
3536 }
3537
3538 static gboolean
3539 bin_query_position_fold (const GValue * vitem, GValue * ret, QueryFold * fold)
3540 {
3541   GstElement *item = g_value_get_object (vitem);
3542
3543   if (gst_element_query (item, fold->query)) {
3544     gint64 position;
3545
3546     g_value_set_boolean (ret, TRUE);
3547
3548     gst_query_parse_position (fold->query, NULL, &position);
3549
3550     GST_DEBUG_OBJECT (item, "got position %" G_GINT64_FORMAT, position);
3551
3552     if (position > fold->max)
3553       fold->max = position;
3554   }
3555
3556   return TRUE;
3557 }
3558
3559 static void
3560 bin_query_position_done (GstBin * bin, QueryFold * fold)
3561 {
3562   GstFormat format;
3563
3564   gst_query_parse_position (fold->query, &format, NULL);
3565   /* store max in query result */
3566   gst_query_set_position (fold->query, format, fold->max);
3567
3568   GST_DEBUG_OBJECT (bin, "max position %" G_GINT64_FORMAT, fold->max);
3569 }
3570
3571 static gboolean
3572 bin_query_latency_fold (const GValue * vitem, GValue * ret, QueryFold * fold)
3573 {
3574   GstElement *item = g_value_get_object (vitem);
3575
3576   if (gst_element_query (item, fold->query)) {
3577     GstClockTime min, max;
3578     gboolean live;
3579
3580     gst_query_parse_latency (fold->query, &live, &min, &max);
3581
3582     GST_DEBUG_OBJECT (item,
3583         "got latency min %" GST_TIME_FORMAT ", max %" GST_TIME_FORMAT
3584         ", live %d", GST_TIME_ARGS (min), GST_TIME_ARGS (max), live);
3585
3586     /* for the combined latency we collect the MAX of all min latencies and
3587      * the MIN of all max latencies */
3588     if (live) {
3589       if (min > fold->min)
3590         fold->min = min;
3591       if (fold->max == -1)
3592         fold->max = max;
3593       else if (max < fold->max)
3594         fold->max = max;
3595       if (fold->live == FALSE)
3596         fold->live = live;
3597     }
3598   } else {
3599     g_value_set_boolean (ret, FALSE);
3600     GST_DEBUG_OBJECT (item, "failed query");
3601   }
3602
3603   return TRUE;
3604 }
3605
3606 static void
3607 bin_query_latency_done (GstBin * bin, QueryFold * fold)
3608 {
3609   /* store max in query result */
3610   gst_query_set_latency (fold->query, fold->live, fold->min, fold->max);
3611
3612   GST_DEBUG_OBJECT (bin,
3613       "latency min %" GST_TIME_FORMAT ", max %" GST_TIME_FORMAT
3614       ", live %d", GST_TIME_ARGS (fold->min), GST_TIME_ARGS (fold->max),
3615       fold->live);
3616 }
3617
3618 /* generic fold, return first valid result */
3619 static gboolean
3620 bin_query_generic_fold (const GValue * vitem, GValue * ret, QueryFold * fold)
3621 {
3622   GstElement *item = g_value_get_object (vitem);
3623   gboolean res;
3624
3625   if ((res = gst_element_query (item, fold->query))) {
3626     g_value_set_boolean (ret, TRUE);
3627     GST_DEBUG_OBJECT (item, "answered query %p", fold->query);
3628   }
3629
3630   /* and stop as soon as we have a valid result */
3631   return !res;
3632 }
3633
3634 static gboolean
3635 gst_bin_query (GstElement * element, GstQuery * query)
3636 {
3637   GstBin *bin = GST_BIN_CAST (element);
3638   GstIterator *iter;
3639   gboolean res = FALSE;
3640   GstIteratorFoldFunction fold_func;
3641   QueryInitFunction fold_init = NULL;
3642   QueryDoneFunction fold_done = NULL;
3643   QueryFold fold_data;
3644   GValue ret = { 0 };
3645
3646   switch (GST_QUERY_TYPE (query)) {
3647     case GST_QUERY_DURATION:
3648     {
3649       GList *cached;
3650       GstFormat qformat;
3651
3652       gst_query_parse_duration (query, &qformat, NULL);
3653
3654       /* find cached duration query */
3655       GST_OBJECT_LOCK (bin);
3656       for (cached = bin->messages; cached; cached = g_list_next (cached)) {
3657         GstMessage *message = (GstMessage *) cached->data;
3658
3659         if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_DURATION &&
3660             GST_MESSAGE_SRC (message) == GST_OBJECT_CAST (bin)) {
3661           GstFormat format;
3662           gint64 duration;
3663
3664           gst_message_parse_duration (message, &format, &duration);
3665
3666           /* if cached same format, copy duration in query result */
3667           if (format == qformat) {
3668             GST_DEBUG_OBJECT (bin, "return cached duration %" G_GINT64_FORMAT,
3669                 duration);
3670             GST_OBJECT_UNLOCK (bin);
3671
3672             gst_query_set_duration (query, qformat, duration);
3673             res = TRUE;
3674             goto exit;
3675           }
3676         }
3677       }
3678       GST_OBJECT_UNLOCK (bin);
3679       /* no cached value found, iterate and collect durations */
3680       fold_func = (GstIteratorFoldFunction) bin_query_duration_fold;
3681       fold_init = bin_query_min_max_init;
3682       fold_done = bin_query_duration_done;
3683       break;
3684     }
3685     case GST_QUERY_POSITION:
3686     {
3687       fold_func = (GstIteratorFoldFunction) bin_query_position_fold;
3688       fold_init = bin_query_min_max_init;
3689       fold_done = bin_query_position_done;
3690       break;
3691     }
3692     case GST_QUERY_LATENCY:
3693     {
3694       fold_func = (GstIteratorFoldFunction) bin_query_latency_fold;
3695       fold_init = bin_query_min_max_init;
3696       fold_done = bin_query_latency_done;
3697       res = TRUE;
3698       break;
3699     }
3700     default:
3701       fold_func = (GstIteratorFoldFunction) bin_query_generic_fold;
3702       break;
3703   }
3704
3705   fold_data.query = query;
3706
3707   /* set the result of the query to FALSE initially */
3708   g_value_init (&ret, G_TYPE_BOOLEAN);
3709   g_value_set_boolean (&ret, res);
3710
3711   iter = gst_bin_iterate_sinks (bin);
3712   GST_DEBUG_OBJECT (bin, "Sending query %p (type %s) to sink children",
3713       query, GST_QUERY_TYPE_NAME (query));
3714
3715   if (fold_init)
3716     fold_init (bin, &fold_data);
3717
3718   while (TRUE) {
3719     GstIteratorResult ires;
3720
3721     ires = gst_iterator_fold (iter, fold_func, &ret, &fold_data);
3722
3723     switch (ires) {
3724       case GST_ITERATOR_RESYNC:
3725         gst_iterator_resync (iter);
3726         if (fold_init)
3727           fold_init (bin, &fold_data);
3728         g_value_set_boolean (&ret, res);
3729         break;
3730       case GST_ITERATOR_OK:
3731       case GST_ITERATOR_DONE:
3732         res = g_value_get_boolean (&ret);
3733         if (fold_done != NULL && res)
3734           fold_done (bin, &fold_data);
3735         goto done;
3736       default:
3737         res = FALSE;
3738         goto done;
3739     }
3740   }
3741 done:
3742   gst_iterator_free (iter);
3743
3744 exit:
3745   GST_DEBUG_OBJECT (bin, "query %p result %d", query, res);
3746
3747   return res;
3748 }
3749
3750 static gint
3751 compare_name (const GValue * velement, const gchar * name)
3752 {
3753   gint eq;
3754   GstElement *element = g_value_get_object (velement);
3755
3756   GST_OBJECT_LOCK (element);
3757   eq = strcmp (GST_ELEMENT_NAME (element), name);
3758   GST_OBJECT_UNLOCK (element);
3759
3760   return eq;
3761 }
3762
3763 /**
3764  * gst_bin_get_by_name:
3765  * @bin: a #GstBin
3766  * @name: the element name to search for
3767  *
3768  * Gets the element with the given name from a bin. This
3769  * function recurses into child bins.
3770  *
3771  * Returns NULL if no element with the given name is found in the bin.
3772  *
3773  * MT safe.  Caller owns returned reference.
3774  *
3775  * Returns: (transfer full): the #GstElement with the given name, or NULL
3776  */
3777 GstElement *
3778 gst_bin_get_by_name (GstBin * bin, const gchar * name)
3779 {
3780   GstIterator *children;
3781   GValue result = { 0, };
3782   GstElement *element;
3783   gboolean found;
3784
3785   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
3786
3787   GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: looking up child element %s",
3788       GST_ELEMENT_NAME (bin), name);
3789
3790   children = gst_bin_iterate_recurse (bin);
3791   found = gst_iterator_find_custom (children,
3792       (GCompareFunc) compare_name, &result, (gpointer) name);
3793   gst_iterator_free (children);
3794
3795   if (found) {
3796     element = g_value_dup_object (&result);
3797     g_value_unset (&result);
3798   } else {
3799     element = NULL;
3800   }
3801
3802   return element;
3803 }
3804
3805 /**
3806  * gst_bin_get_by_name_recurse_up:
3807  * @bin: a #GstBin
3808  * @name: the element name to search for
3809  *
3810  * Gets the element with the given name from this bin. If the
3811  * element is not found, a recursion is performed on the parent bin.
3812  *
3813  * Returns NULL if:
3814  * - no element with the given name is found in the bin
3815  *
3816  * MT safe.  Caller owns returned reference.
3817  *
3818  * Returns: (transfer full): the #GstElement with the given name, or NULL
3819  */
3820 GstElement *
3821 gst_bin_get_by_name_recurse_up (GstBin * bin, const gchar * name)
3822 {
3823   GstElement *result;
3824
3825   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
3826   g_return_val_if_fail (name != NULL, NULL);
3827
3828   result = gst_bin_get_by_name (bin, name);
3829
3830   if (!result) {
3831     GstObject *parent;
3832
3833     parent = gst_object_get_parent (GST_OBJECT_CAST (bin));
3834     if (parent) {
3835       if (GST_IS_BIN (parent)) {
3836         result = gst_bin_get_by_name_recurse_up (GST_BIN_CAST (parent), name);
3837       }
3838       gst_object_unref (parent);
3839     }
3840   }
3841
3842   return result;
3843 }
3844
3845 static gint
3846 compare_interface (const GValue * velement, GValue * interface)
3847 {
3848   GstElement *element = g_value_get_object (velement);
3849   GType interface_type = (GType) g_value_get_pointer (interface);
3850   gint ret;
3851
3852   if (G_TYPE_CHECK_INSTANCE_TYPE (element, interface_type)) {
3853     ret = 0;
3854   } else {
3855     ret = 1;
3856   }
3857   return ret;
3858 }
3859
3860 /**
3861  * gst_bin_get_by_interface:
3862  * @bin: a #GstBin
3863  * @iface: the #GType of an interface
3864  *
3865  * Looks for an element inside the bin that implements the given
3866  * interface. If such an element is found, it returns the element.
3867  * You can cast this element to the given interface afterwards.  If you want
3868  * all elements that implement the interface, use
3869  * gst_bin_iterate_all_by_interface(). This function recurses into child bins.
3870  *
3871  * MT safe.  Caller owns returned reference.
3872  *
3873  * Returns: (transfer full): A #GstElement inside the bin implementing the interface
3874  */
3875 GstElement *
3876 gst_bin_get_by_interface (GstBin * bin, GType iface)
3877 {
3878   GstIterator *children;
3879   GValue result = { 0, };
3880   GstElement *element;
3881   gboolean found;
3882   GValue viface = { 0, };
3883
3884   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
3885   g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface), NULL);
3886
3887   g_value_init (&viface, G_TYPE_POINTER);
3888   g_value_set_pointer (&viface, (gpointer) iface);
3889
3890   children = gst_bin_iterate_recurse (bin);
3891   found = gst_iterator_find_custom (children, (GCompareFunc) compare_interface,
3892       &result, &viface);
3893   gst_iterator_free (children);
3894
3895   if (found) {
3896     element = g_value_dup_object (&result);
3897     g_value_unset (&result);
3898   } else {
3899     element = NULL;
3900   }
3901   g_value_unset (&viface);
3902
3903   return element;
3904 }
3905
3906 /**
3907  * gst_bin_iterate_all_by_interface:
3908  * @bin: a #GstBin
3909  * @iface: the #GType of an interface
3910  *
3911  * Looks for all elements inside the bin that implements the given
3912  * interface. You can safely cast all returned elements to the given interface.
3913  * The function recurses inside child bins. The iterator will yield a series
3914  * of #GstElement that should be unreffed after use.
3915  *
3916  * Each element yielded by the iterator will have its refcount increased, so
3917  * unref after use.
3918  *
3919  * MT safe.  Caller owns returned value.
3920  *
3921  * Returns: (transfer full): a #GstIterator of #GstElement for all elements
3922  *          in the bin implementing the given interface, or NULL
3923  */
3924 GstIterator *
3925 gst_bin_iterate_all_by_interface (GstBin * bin, GType iface)
3926 {
3927   GstIterator *children;
3928   GstIterator *result;
3929   GValue viface = { 0, };
3930
3931   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
3932   g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface), NULL);
3933
3934   g_value_init (&viface, G_TYPE_POINTER);
3935   g_value_set_pointer (&viface, (gpointer) iface);
3936
3937   children = gst_bin_iterate_recurse (bin);
3938   result = gst_iterator_filter (children, (GCompareFunc) compare_interface,
3939       &viface);
3940
3941   g_value_unset (&viface);
3942
3943   return result;
3944 }