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