FCL/sf/mw/gstreamer: comparison gstreamer

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 * gst_bin_iterate_elements(). Various other iterators exist to retrieve the
 * elements in a bin.
 *
 * gst_object_unref() is used to drop your reference to the bin.
 *
-* The #GstBin::element-added signal is fired whenever a new element is added to
+* The <link linkend="GstBin-element-added">element-added</link> signal is
-* the bin. Likewise the #GstBin::element-removed signal is fired whenever an
+* fired whenever a new element is added to the bin. Likewise the <link
-* element is removed from the bin.
+* linkend="GstBin-element-removed">element-removed</link> signal is fired
+* whenever an element is removed from the bin.
 *
 * <refsect2><title>Notes</title>
 * <para>
 * A #GstBin internally intercepts every #GstMessage posted by its children and
 * implements the following default behaviour for each of them:
 #include "gstchildproxy.h"
 #ifdef __SYMBIAN32__
 #include <glib_global.h>
 #endif
 /* enable for DURATION caching.
 * FIXME currently too many elements don't update
 * their duration when it changes so we return inaccurate values. */
 #undef DURATION_CACHING
 /* a bin is toplevel if it has no parent or when it is configured to behave like
 * a toplevel bin */
 #define BIN_IS_TOPLEVEL(bin) ((GST_OBJECT_PARENT (bin) == NULL) || bin->priv->asynchandling)
-#define GST_BIN_GET_PRIVATE(obj)  \
-(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BIN, GstBinPrivate))
 struct _GstBinPrivate
 {
 gboolean asynchandling;
-/* if we get an ASYNC_DONE message from ourselves, this means that the
-* subclass will simulate ASYNC behaviour without having ASYNC children. When
-* such an ASYNC_DONE message is posted while we are doing a state change, we
-* have to process the message after finishing the state change even when no
-* child returned GST_STATE_CHANGE_ASYNC. */
-gboolean pending_async_done;
-guint32 structure_cookie;
 };
 typedef struct
 {
 GstBin *bin;
 static GstStateChangeReturn gst_bin_change_state_func (GstElement * element,
 GstStateChange transition);
 static GstStateChangeReturn gst_bin_get_state_func (GstElement * element,
 GstState * state, GstState * pending, GstClockTime timeout);
-static void bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret,
+static void bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret);
-gboolean flag_pending);
 static void bin_handle_async_start (GstBin * bin, gboolean new_base_time);
 static void bin_push_state_continue (BinContinueData * data);
 static gboolean gst_bin_add_func (GstBin * bin, GstElement * element);
 static gboolean gst_bin_remove_func (GstBin * bin, GstElement * element);
+#ifndef GST_DISABLE_INDEX
 static void gst_bin_set_index_func (GstElement * element, GstIndex * index);
+#endif
 static GstClock *gst_bin_provide_clock_func (GstElement * element);
 static gboolean gst_bin_set_clock_func (GstElement * element, GstClock * clock);
 static void gst_bin_handle_message_func (GstBin * bin, GstMessage * message);
 static gboolean gst_bin_send_event (GstElement * element, GstEvent * event);
 static GstBusSyncReply bin_bus_handler (GstBus * bus,
 GstMessage * message, GstBin * bin);
 static gboolean gst_bin_query (GstElement * element, GstQuery * query);
-static gboolean gst_bin_do_latency_func (GstBin * bin);
 #ifndef GST_DISABLE_LOADSAVE
 static xmlNodePtr gst_bin_save_thyself (GstObject * object, xmlNodePtr parent);
 static void gst_bin_restore_thyself (GstObject * object, xmlNodePtr self);
 #endif
 /* Bin signals and properties */
 enum
 {
 ELEMENT_ADDED,
 ELEMENT_REMOVED,
-DO_LATENCY,
 LAST_SIGNAL
 };
 #define DEFAULT_ASYNC_HANDLING	FALSE
 PROP_0,
 PROP_ASYNC_HANDLING
 /* FILL ME */
 };
+static void gst_bin_base_init (gpointer g_class);
+static void gst_bin_class_init (GstBinClass * klass);
+static void gst_bin_init (GstBin * bin);
 static void gst_bin_child_proxy_init (gpointer g_iface, gpointer iface_data);
+static GstElementClass *parent_class = NULL;
 static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
-#define _do_init(type) \
+/**
-{ \
+* gst_bin_get_type:
-const gchar *compat; \
+*
-static const GInterfaceInfo iface_info = { \
+* Returns: the type of #GstBin
-gst_bin_child_proxy_init, \
+*/
-NULL, \
+#ifdef __SYMBIAN32__
-NULL}; \
+EXPORT_C
-\
+#endif
-g_type_add_interface_static (type, GST_TYPE_CHILD_PROXY, &iface_info); \
-\
+GType
-GST_DEBUG_CATEGORY_INIT (bin_debug, "bin", GST_DEBUG_BOLD, \
+gst_bin_get_type (void)
-"debugging info for the 'bin' container element"); \
+{
-\
+static GType gst_bin_type = 0;
-/* compatibility stuff */ \
+const gchar *compat;
-compat = g_getenv ("GST_COMPAT"); \
-if (compat != NULL) { \
+if (G_UNLIKELY (gst_bin_type == 0)) {
-if (strstr (compat, "no-live-preroll")) \
+static const GTypeInfo bin_info = {
-enable_latency = FALSE; \
+sizeof (GstBinClass),
-else if (strstr (compat, "live-preroll")) \
+gst_bin_base_init,
-enable_latency = TRUE; \
+NULL,
-} \
+(GClassInitFunc) gst_bin_class_init,
-}
+NULL,
+NULL,
-GST_BOILERPLATE_FULL (GstBin, gst_bin, GstElement, GST_TYPE_ELEMENT, _do_init);
+sizeof (GstBin),
+0,
+(GInstanceInitFunc) gst_bin_init,
+NULL
+};
+static const GInterfaceInfo child_proxy_info = {
+gst_bin_child_proxy_init,
+NULL,
+NULL
+};
+gst_bin_type =
+g_type_register_static (GST_TYPE_ELEMENT, "GstBin", &bin_info, 0);
+g_type_add_interface_static (gst_bin_type, GST_TYPE_CHILD_PROXY,
+&child_proxy_info);
+GST_DEBUG_CATEGORY_INIT (bin_debug, "bin", GST_DEBUG_BOLD,
+"debugging info for the 'bin' container element");
+/* compatibility stuff */
+compat = g_getenv ("GST_COMPAT");
+if (compat != NULL) {
+if (strstr (compat, "no-live-preroll"))
+enable_latency = FALSE;
+else if (strstr (compat, "live-preroll"))
+enable_latency = TRUE;
+}
+}
+return gst_bin_type;
+}
 static void
 gst_bin_base_init (gpointer g_class)
 {
 GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 iface->get_children_count = gst_bin_child_proxy_get_children_count;
 iface->get_child_by_index = gst_bin_child_proxy_get_child_by_index;
 }
-static gboolean
-_gst_boolean_accumulator (GSignalInvocationHint * ihint,
-GValue * return_accu, const GValue * handler_return, gpointer dummy)
-{
-gboolean myboolean;
-myboolean = g_value_get_boolean (handler_return);
-if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))
-g_value_set_boolean (return_accu, myboolean);
-GST_DEBUG ("invocation %d, %d", ihint->run_type, myboolean);
-/* stop emission */
-return FALSE;
-}
 static void
 gst_bin_class_init (GstBinClass * klass)
 {
 GObjectClass *gobject_class;
 GstObjectClass *gstobject_class;
 gobject_class = (GObjectClass *) klass;
 gstobject_class = (GstObjectClass *) klass;
 gstelement_class = (GstElementClass *) klass;
-g_type_class_add_private (klass, sizeof (GstBinPrivate));
+parent_class = g_type_class_peek_parent (klass);
 gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_bin_set_property);
 gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_bin_get_property);
 /**
 * Since: 0.10.13
 */
 g_object_class_install_property (gobject_class, PROP_ASYNC_HANDLING,
 g_param_spec_boolean ("async-handling", "Async Handling",
 "The bin will handle Asynchronous state changes",
-DEFAULT_ASYNC_HANDLING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+DEFAULT_ASYNC_HANDLING, G_PARAM_READWRITE));
 /**
 * GstBin::element-added:
 * @bin: the #GstBin
 * @element: the #GstElement that was added to the bin
 */
 gst_bin_signals[ELEMENT_REMOVED] =
 g_signal_new ("element-removed", G_TYPE_FROM_CLASS (klass),
 G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GstBinClass, element_removed), NULL,
 NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
-/**
-* GstBin::do-latency:
-* @bin: the #GstBin
-*
-* Will be emitted when the bin needs to perform latency calculations. This
-* signal is only emited for toplevel bins or when async-handling is
-* enabled.
-*
-* Only one signal handler is invoked. If no signals are connected, the
-* default handler is invoked, which will query and distribute the lowest
-* possible latency to all sinks.
-*
-* Connect to this signal if the default latency calculations are not
-* sufficient, like when you need different latencies for different sinks in
-* the same pipeline.
-*
-* Since: 0.10.22
-*/
-gst_bin_signals[DO_LATENCY] =
-g_signal_new ("do-latency", G_TYPE_FROM_CLASS (klass),
-G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstBinClass, do_latency),
-_gst_boolean_accumulator, NULL, gst_marshal_BOOLEAN__VOID,
-G_TYPE_BOOLEAN, 0, G_TYPE_NONE);
 gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_bin_dispose);
 #ifndef GST_DISABLE_LOADSAVE
 gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_bin_save_thyself);
 #endif
 gstelement_class->change_state =
 GST_DEBUG_FUNCPTR (gst_bin_change_state_func);
 gstelement_class->get_state = GST_DEBUG_FUNCPTR (gst_bin_get_state_func);
+#ifndef GST_DISABLE_INDEX
 gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_bin_set_index_func);
+#endif
 gstelement_class->provide_clock =
 GST_DEBUG_FUNCPTR (gst_bin_provide_clock_func);
 gstelement_class->set_clock = GST_DEBUG_FUNCPTR (gst_bin_set_clock_func);
 gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_bin_send_event);
 gstelement_class->query = GST_DEBUG_FUNCPTR (gst_bin_query);
 klass->add_element = GST_DEBUG_FUNCPTR (gst_bin_add_func);
 klass->remove_element = GST_DEBUG_FUNCPTR (gst_bin_remove_func);
 klass->handle_message = GST_DEBUG_FUNCPTR (gst_bin_handle_message_func);
-klass->do_latency = GST_DEBUG_FUNCPTR (gst_bin_do_latency_func);
 GST_DEBUG ("creating bin thread pool");
 err = NULL;
 klass->pool =
 g_thread_pool_new ((GFunc) gst_bin_continue_func, NULL, -1, FALSE, &err);
 g_critical ("could alloc threadpool %s", err->message);
 }
 }
 static void
-gst_bin_init (GstBin * bin, GstBinClass * klass)
+gst_bin_init (GstBin * bin)
 {
 GstBus *bus;
 bin->numchildren = 0;
 bin->children = NULL;
 bin->child_bus = bus;
 GST_DEBUG_OBJECT (bin, "using bus %" GST_PTR_FORMAT " to listen to children",
 bus);
 gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bin_bus_handler, bin);
-bin->priv = GST_BIN_GET_PRIVATE (bin);
+bin->priv = g_new0 (GstBinPrivate, 1);
 bin->priv->asynchandling = DEFAULT_ASYNC_HANDLING;
-bin->priv->structure_cookie = 0;
 }
 static void
 gst_bin_dispose (GObject * object)
 {
 GstClock **provided_clock_p = &bin->provided_clock;
 GstElement **clock_provider_p = &bin->clock_provider;
 GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object, "dispose");
-GST_OBJECT_LOCK (object);
+bin_remove_messages (bin, NULL, GST_MESSAGE_ANY);
 gst_object_replace ((GstObject **) child_bus_p, NULL);
 gst_object_replace ((GstObject **) provided_clock_p, NULL);
 gst_object_replace ((GstObject **) clock_provider_p, NULL);
-bin_remove_messages (bin, NULL, GST_MESSAGE_ANY);
-GST_OBJECT_UNLOCK (object);
 while (bin->children) {
 gst_bin_remove (bin, GST_ELEMENT_CAST (bin->children->data));
 }
 if (G_UNLIKELY (bin->children != NULL)) {
 g_critical ("could not remove elements from bin %s",
 GST_STR_NULL (GST_OBJECT_NAME (object)));
+}
+if (bin->priv) {
+g_free (bin->priv);
+bin->priv = NULL;
 }
 G_OBJECT_CLASS (parent_class)->dispose (object);
 }
 /* set the index on all elements in this bin
 *
 * MT safe
 */
+#ifndef GST_DISABLE_INDEX
 static void
 gst_bin_set_index_func (GstElement * element, GstIndex * index)
 {
 GstBin *bin;
-gboolean done;
+GList *children;
-GstIterator *it;
 bin = GST_BIN (element);
-it = gst_bin_iterate_elements (bin);
+GST_OBJECT_LOCK (bin);
+for (children = bin->children; children; children = g_list_next (children)) {
-done = FALSE;
+GstElement *child = GST_ELEMENT (children->data);
-while (!done) {
-gpointer data;
+gst_element_set_index (child, index);
+}
-switch (gst_iterator_next (it, &data)) {
+GST_OBJECT_UNLOCK (bin);
-case GST_ITERATOR_OK:
+}
-{
+#endif
-GstElement *child = GST_ELEMENT_CAST (data);
-GST_DEBUG_OBJECT (bin, "setting index on %s", GST_ELEMENT_NAME (child));
-gst_element_set_index (child, index);
-gst_object_unref (child);
-break;
-}
-case GST_ITERATOR_RESYNC:
-GST_DEBUG_OBJECT (bin, "iterator doing resync");
-gst_iterator_resync (it);
-break;
-default:
-case GST_ITERATOR_DONE:
-GST_DEBUG_OBJECT (bin, "iterator done");
-done = TRUE;
-break;
-}
-}
-gst_iterator_free (it);
-}
 /* set the clock on all elements in this bin
 *
 * MT safe
 */
 static gboolean
 gst_bin_set_clock_func (GstElement * element, GstClock * clock)
 {
+GList *children;
 GstBin *bin;
-gboolean done;
-GstIterator *it;
 gboolean res = TRUE;
 bin = GST_BIN (element);
-it = gst_bin_iterate_elements (bin);
+GST_OBJECT_LOCK (bin);
+if (element->clock != clock) {
-done = FALSE;
+for (children = bin->children; children; children = g_list_next (children)) {
-while (!done) {
+GstElement *child = GST_ELEMENT (children->data);
-gpointer data;
+res &= gst_element_set_clock (child, clock);
-switch (gst_iterator_next (it, &data)) {
+}
-case GST_ITERATOR_OK:
+}
-{
+GST_OBJECT_UNLOCK (bin);
-GstElement *child = GST_ELEMENT_CAST (data);
-res &= gst_element_set_clock (child, clock);
-gst_object_unref (child);
-break;
-}
-case GST_ITERATOR_RESYNC:
-GST_DEBUG_OBJECT (bin, "iterator doing resync");
-gst_iterator_resync (it);
-res = TRUE;
-break;
-default:
-case GST_ITERATOR_DONE:
-GST_DEBUG_OBJECT (bin, "iterator done");
-done = TRUE;
-break;
-}
-}
-gst_iterator_free (it);
 return res;
 }
 /* get the clock for this bin by asking all of the children in this bin
 if (target->src)
 eq &= GST_MESSAGE_SRC (message) == target->src;
 if (target->types)
 eq &= (GST_MESSAGE_TYPE (message) & target->types) != 0;
-GST_LOG ("looking at message %p: %d", message, eq);
 return (eq ? 0 : 1);
 }
 static GList *
 }
 return result;
 }
-/* with LOCK, returns TRUE if message had a valid SRC, takes ownership of
+/* with LOCK, returns TRUE if message had a valid SRC, takes ref on
 * the message.
 *
 * A message that is cached and has the same SRC and type is replaced
 * by the given message.
 */
 name = GST_MESSAGE_TYPE_NAME (message);
 if ((src = GST_MESSAGE_SRC (message))) {
 /* first find the previous message posted by this element */
 if ((previous = find_message (bin, src, types))) {
-GstMessage *previous_msg;
 /* if we found a previous message, replace it */
-previous_msg = previous->data;
+gst_message_unref (previous->data);
 previous->data = message;
-GST_DEBUG_OBJECT (bin, "replace old message %s from %s with %s message",
+GST_DEBUG_OBJECT (bin, "replace old message %s from %s",
-GST_MESSAGE_TYPE_NAME (previous_msg), GST_ELEMENT_NAME (src), name);
+name, GST_ELEMENT_NAME (src));
-gst_message_unref (previous_msg);
 } else {
 /* keep new message */
 bin->messages = g_list_prepend (bin->messages, message);
 GST_DEBUG_OBJECT (bin, "got new message %p, %s from %s",
 }
 bin->children = g_list_prepend (bin->children, element);
 bin->numchildren++;
 bin->children_cookie++;
-bin->priv->structure_cookie++;
 /* distribute the bus */
 gst_element_set_bus (element, bin->child_bus);
-/* propagate the current base_time, start_time and clock */
+/* propagate the current base_time and clock */
 gst_element_set_base_time (element, GST_ELEMENT (bin)->base_time);
-gst_element_set_start_time (element, GST_ELEMENT_START_TIME (bin));
 /* it's possible that the element did not accept the clock but
 * that is not important right now. When the pipeline goes to PLAYING,
 * a new clock will be selected */
 gst_element_set_clock (element, GST_ELEMENT_CLOCK (bin));
 gst_message_new_async_start (GST_OBJECT_CAST (element), FALSE);
 break;
 }
 case GST_STATE_CHANGE_NO_PREROLL:
 /* ignore all async elements we might have and commit our state */
-bin_handle_async_done (bin, ret, FALSE);
+bin_handle_async_done (bin, ret);
 break;
 case GST_STATE_CHANGE_FAILURE:
 break;
 default:
 break;
 {
 gchar *elem_name;
 GstIterator *it;
 gboolean is_sink, othersink, found;
 GstMessage *clock_message = NULL;
-GstClock **provided_clock_p;
-GstElement **clock_provider_p;
 GList *walk, *next;
 gboolean other_async, this_async, have_no_preroll;
 GstStateChangeReturn ret;
 GST_DEBUG_OBJECT (bin, "element :%s", GST_ELEMENT_NAME (element));
 /* we now removed the element from the list of elements, increment the cookie
 * so that others can detect a change in the children list. */
 bin->numchildren--;
 bin->children_cookie++;
-bin->priv->structure_cookie++;
 if (is_sink && !othersink) {
 /* we're not a sink anymore */
 GST_DEBUG_OBJECT (bin, "we removed the last sink");
 GST_OBJECT_FLAG_UNSET (bin, GST_ELEMENT_IS_SINK);
 if (bin->clock_provider == element) {
 GST_DEBUG_OBJECT (bin, "element \"%s\" provided the clock", elem_name);
 bin->clock_dirty = TRUE;
 clock_message =
 gst_message_new_clock_lost (GST_OBJECT_CAST (bin), bin->provided_clock);
-provided_clock_p = &bin->provided_clock;
-clock_provider_p = &bin->clock_provider;
-gst_object_replace ((GstObject **) provided_clock_p, NULL);
-gst_object_replace ((GstObject **) clock_provider_p, NULL);
 }
 /* remove messages for the element, if there was a pending ASYNC_START
 * message we must see if removing the element caused the bin to lose its
 * async state. */
 this_async = FALSE;
 other_async = FALSE;
 for (walk = bin->messages; walk; walk = next) {
 GstMessage *message = (GstMessage *) walk->data;
 GstElement *src = GST_ELEMENT_CAST (GST_MESSAGE_SRC (message));
-gboolean remove;
 next = g_list_next (walk);
-remove = FALSE;
+if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ASYNC_START) {
-switch (GST_MESSAGE_TYPE (message)) {
+if (src == element)
-case GST_MESSAGE_ASYNC_START:
+this_async = TRUE;
-if (src == element)
+else
-this_async = TRUE;
+other_async = TRUE;
-else
-other_async = TRUE;
+GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message),
+"looking at message %p", message);
-GST_DEBUG_OBJECT (src, "looking at message %p", message);
+}
-break;
+if (src == element) {
-case GST_MESSAGE_STRUCTURE_CHANGE:
-{
-GstElement *owner;
-GST_DEBUG_OBJECT (src, "looking at structure change message %p",
-message);
-/* it's unlikely that this message is still in the list of messages
-* because this would mean that a link/unlink is busy in another thread
-* while we remove the element. We still have to remove the message
-* because we might not receive the done message anymore when the element
-* is removed from the bin. */
-gst_message_parse_structure_change (message, NULL, &owner, NULL);
-if (owner == element)
-remove = TRUE;
-break;
-}
-default:
-break;
-}
-if (src == element)
-remove = TRUE;
-if (remove) {
 /* delete all message types */
-GST_DEBUG_OBJECT (src, "deleting message %p of element \"%s\"",
+GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message),
-message, elem_name);
+"deleting message %p of element \"%s\"", message, elem_name);
 bin->messages = g_list_delete_link (bin->messages, walk);
 gst_message_unref (message);
 }
 }
 if (have_no_preroll)
 ret = GST_STATE_CHANGE_NO_PREROLL;
 else
 ret = GST_STATE_CHANGE_SUCCESS;
-bin_handle_async_done (bin, ret, FALSE);
+bin_handle_async_done (bin, ret);
 } else {
 GST_DEBUG_OBJECT (bin,
 "recalc state preroll: %d, other async: %d, this async %d",
 have_no_preroll, other_async, this_async);
 update_degree (GstElement * element, GstBinSortIterator * bit)
 {
 gboolean linked = FALSE;
 GST_OBJECT_LOCK (element);
-/* don't touch degree if element has no sinkpads */
+/* don't touch degree if element has no sourcepads */
 if (element->numsinkpads != 0) {
 /* loop over all sinkpads, decrement degree for all connected
 * elements in this bin */
 GList *pads;
 for (pads = element->sinkpads; pads; pads = g_list_next (pads)) {
-GstPad *pad, *peer;
+GstPad *peer;
-pad = GST_PAD_CAST (pads->data);
+if ((peer = gst_pad_get_peer (GST_PAD_CAST (pads->data)))) {
-if ((peer = gst_pad_get_peer (pad))) {
 GstElement *peer_element;
-/* we're iterating over the sinkpads, this is the peer and thus the
-* srcpad, check if it's busy in a link/unlink */
-if (G_UNLIKELY (find_message (bit->bin, GST_OBJECT_CAST (peer),
-GST_MESSAGE_STRUCTURE_CHANGE))) {
-gst_object_unref (peer);
-continue;
-}
 if ((peer_element = gst_pad_get_parent_element (peer))) {
 GST_OBJECT_LOCK (peer_element);
 /* check that we don't go outside of this bin */
 if (GST_OBJECT_CAST (peer_element)->parent ==
 GST_DEBUG_OBJECT (bit->bin,
 "change element %s, degree %d->%d, linked to %s",
 GST_ELEMENT_NAME (peer_element), old_deg, new_deg,
 GST_ELEMENT_NAME (element));
-/* update degree, it is possible that an element was in 0 and
+/* update degree */
-* reaches -1 here. This would mean that the element had no sinkpads
-* but became linked while the state change was happening. We will
-* resync on this with the structure change message. */
 if (new_deg == 0) {
 /* degree hit 0, add to queue */
 add_to_queue (bit, peer_element);
 } else {
 HASH_SET_DEGREE (bit, peer_element, new_deg);
 * method already */
 result = (GstBinSortIterator *)
 gst_iterator_new (sizeof (GstBinSortIterator),
 GST_TYPE_ELEMENT,
 GST_OBJECT_GET_LOCK (bin),
-&bin->priv->structure_cookie,
+&bin->children_cookie,
 (GstIteratorNextFunction) gst_bin_sort_iterator_next,
 (GstIteratorItemFunction) NULL,
 (GstIteratorResyncFunction) gst_bin_sort_iterator_resync,
 (GstIteratorFreeFunction) gst_bin_sort_iterator_free);
 result->queue = g_queue_new ();
 return result;
 }
 static GstStateChangeReturn
 gst_bin_element_set_state (GstBin * bin, GstElement * element,
-GstClockTime base_time, GstClockTime start_time, GstState current,
+GstClockTime base_time, GstState current, GstState next)
-GstState next)
 {
 GstStateChangeReturn ret;
 gboolean locked;
 GList *found;
-GST_STATE_LOCK (element);
+/* peel off the locked flag */
 GST_OBJECT_LOCK (element);
-/* set base_time and start time on child */
-GST_ELEMENT_START_TIME (element) = start_time;
-element->base_time = base_time;
-/* peel off the locked flag */
 locked = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_LOCKED_STATE);
 /* get previous state return */
 ret = GST_STATE_RETURN (element);
 GST_OBJECT_UNLOCK (element);
 GST_DEBUG_OBJECT (bin,
 "setting element %s to %s, base_time %" GST_TIME_FORMAT,
 GST_ELEMENT_NAME (element), gst_element_state_get_name (next),
 GST_TIME_ARGS (base_time));
+/* set base_time on child */
+gst_element_set_base_time (element, base_time);
 /* change state */
 ret = gst_element_set_state (element, next);
-GST_STATE_UNLOCK (element);
 return ret;
 locked:
 {
 GST_DEBUG_OBJECT (element,
 "element is locked, return previous return %s",
 gst_element_state_change_return_get_name (ret));
-GST_STATE_UNLOCK (element);
 return ret;
 }
 was_busy:
 {
 GST_DEBUG_OBJECT (element, "element was busy, delaying state change");
 GST_OBJECT_UNLOCK (bin);
-GST_STATE_UNLOCK (element);
 return GST_STATE_CHANGE_ASYNC;
 }
 }
 /* gst_iterator_fold functions for pads_activate
 GST_DEBUG_OBJECT (bin, "source pads_activate failed");
 return FALSE;
 }
 }
-/**
+/* do latency correction. We do a latency query on the bin, and then send a
-* gst_bin_recalculate_latency:
+* LATENCY event on the elements fo configure them */
-* @bin: a #GstBin
-*
-* Query @bin for the current latency using and reconfigures this latency to all the
-* elements with a LATENCY event.
-*
-* This method is typically called on the pipeline when a #GST_MESSAGE_LATENCY
-* is posted on the bus.
-*
-* This function simply emits the 'do-latency' signal so any custom latency
-* calculations will be performed.
-*
-* Returns: %TRUE if the latency could be queried and reconfigured.
-*
-* Since: 0.10.22.
-*/
-#ifdef __SYMBIAN32__
-EXPORT_C
-#endif
-gboolean
-gst_bin_recalculate_latency (GstBin * bin)
-{
-gboolean res;
-g_signal_emit (G_OBJECT (bin), gst_bin_signals[DO_LATENCY], 0, &res);
-GST_DEBUG_OBJECT (bin, "latency returned %d", res);
-return res;
-}
 static gboolean
-gst_bin_do_latency_func (GstBin * bin)
+do_bin_latency (GstElement * element)
 {
 GstQuery *query;
-GstElement *element;
 GstClockTime min_latency, max_latency;
 gboolean res;
-g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
-element = GST_ELEMENT_CAST (bin);
 GST_DEBUG_OBJECT (element, "querying latency");
 query = gst_query_new_latency ();
 if ((res = gst_element_query (element, query))) {
 GstBin *bin;
 GstStateChangeReturn ret;
 GstState current, next;
 gboolean have_async;
 gboolean have_no_preroll;
-GstClockTime base_time, start_time;
+GstClockTime base_time;
 GstIterator *it;
 gboolean done;
 /* we don't need to take the STATE_LOCK, it is already taken */
 current = (GstState) GST_STATE_TRANSITION_CURRENT (transition);
 GST_OBJECT_LOCK (bin);
 toplevel = BIN_IS_TOPLEVEL (bin);
 GST_OBJECT_UNLOCK (bin);
 if (toplevel)
-gst_bin_recalculate_latency (bin);
+do_bin_latency (element);
 break;
 }
 case GST_STATE_PAUSED:
 /* Clear EOS list on next PAUSED */
 GST_OBJECT_LOCK (bin);
 have_async = FALSE;
 restart:
 /* take base_time */
 base_time = gst_element_get_base_time (element);
-start_time = gst_element_get_start_time (element);
 have_no_preroll = FALSE;
 done = FALSE;
 while (!done) {
 GstElement *child;
 child = GST_ELEMENT_CAST (data);
 /* set state and base_time now */
-ret =
+ret = gst_bin_element_set_state (bin, child, base_time, current, next);
-gst_bin_element_set_state (bin, child, base_time, start_time,
-current, next);
 switch (ret) {
 case GST_STATE_CHANGE_SUCCESS:
 GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
 "child '%s' changed state to %d(%s) successfully",
 ret = parent_class->change_state (element, transition);
 if (G_UNLIKELY (ret == GST_STATE_CHANGE_FAILURE))
 goto done;
 if (have_no_preroll) {
-GST_CAT_DEBUG (GST_CAT_STATES,
-"we have NO_PREROLL elements %s -> NO_PREROLL",
-gst_element_state_change_return_get_name (ret));
 ret = GST_STATE_CHANGE_NO_PREROLL;
 } else if (have_async) {
-GST_CAT_DEBUG (GST_CAT_STATES, "we have ASYNC elements %s -> ASYNC",
-gst_element_state_change_return_get_name (ret));
 ret = GST_STATE_CHANGE_ASYNC;
 }
 done:
 gst_iterator_free (it);
 GST_OBJECT_LOCK (bin);
 bin->polling = FALSE;
-/* it's possible that we did not get ASYNC from the children while the bin is
+if (ret != GST_STATE_CHANGE_ASYNC) {
-* simulating ASYNC behaviour by posting an ASYNC_DONE message on the bus with
+/* no element returned ASYNC, we can just complete. */
-* itself as the source. In that case we still want to check if the state
-* change completed. */
-if (ret != GST_STATE_CHANGE_ASYNC && !bin->priv->pending_async_done) {
-/* no element returned ASYNC and there are no pending async_done messages,
-* we can just complete. */
 GST_DEBUG_OBJECT (bin, "no async elements");
 goto state_end;
 }
 /* when we get here an ASYNC element was found */
 if (GST_STATE_TARGET (bin) <= GST_STATE_READY) {
 * change. We will still return ASYNC for consistency but we commit the
 * state already so that a _get_state() will return immediatly. */
 bin_remove_messages (bin, NULL, GST_MESSAGE_ASYNC_DONE);
 GST_DEBUG_OBJECT (bin, "async elements commited");
-bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS, FALSE);
+bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS);
 }
 state_end:
-bin->priv->pending_async_done = FALSE;
 GST_OBJECT_UNLOCK (bin);
 GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
 "done changing bin's state from %s to %s, now in %s, ret %s",
 gst_element_state_get_name (current),
 gst_bin_continue_func (BinContinueData * data)
 {
 GstBin *bin;
 GstState current, next, pending;
 GstStateChange transition;
+GstStateChangeReturn ret;
 bin = data->bin;
 pending = data->pending;
 GST_DEBUG_OBJECT (bin, "waiting for state lock");
 current = GST_STATE (bin);
 next = GST_STATE_GET_NEXT (current, pending);
 transition = (GstStateChange) GST_STATE_TRANSITION (current, next);
 GST_STATE_NEXT (bin) = next;
-GST_STATE_PENDING (bin) = pending;
 /* mark busy */
 GST_STATE_RETURN (bin) = GST_STATE_CHANGE_ASYNC;
 GST_OBJECT_UNLOCK (bin);
 GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
 "continue state change %s to %s, final %s",
 gst_element_state_get_name (current),
 gst_element_state_get_name (next), gst_element_state_get_name (pending));
-gst_element_change_state (GST_ELEMENT_CAST (bin), transition);
+ret = gst_element_change_state (GST_ELEMENT_CAST (bin), transition);
 GST_STATE_UNLOCK (bin);
 GST_DEBUG_OBJECT (bin, "state continue done");
 gst_object_unref (bin);
 g_free (data);
 /* async starts are ignored when we are NO_PREROLL */
 if (GST_STATE_RETURN (bin) == GST_STATE_CHANGE_NO_PREROLL)
 goto was_no_preroll;
 old_state = GST_STATE (bin);
 /* when we PLAYING we go back to PAUSED, when preroll happens, we go back to
 * PLAYING after optionally redistributing the base_time. */
 if (old_state > GST_STATE_PAUSED)
 /* this function is called when there are no more async elements in the bin. We
 * post a state changed message and an ASYNC_DONE message.
 * This function is called with the OBJECT lock.
 */
 static void
-bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret,
+bin_handle_async_done (GstBin * bin, GstStateChangeReturn ret)
-gboolean flag_pending)
 {
 GstState current, pending, target;
 GstStateChangeReturn old_ret;
 GstState old_state, old_next;
 gboolean toplevel;
 gst_element_state_get_name (pending));
 /* update current state */
 current = GST_STATE (bin) = old_next;
 } else {
-GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin,
-"setting state from %s to %s, pending %s",
-gst_element_state_get_name (old_state),
-gst_element_state_get_name (old_state),
-gst_element_state_get_name (pending));
 current = old_state;
 }
 /* get our toplevel state */
 toplevel = BIN_IS_TOPLEVEL (bin);
 cont->cookie = GST_ELEMENT_CAST (bin)->state_cookie;
 /* pending target state */
 cont->pending = pending;
 /* mark busy */
 GST_STATE_RETURN (bin) = GST_STATE_CHANGE_ASYNC;
-GST_STATE_NEXT (bin) = GST_STATE_GET_NEXT (old_state, pending);
+GST_STATE_NEXT (bin) = pending;
 }
 if (old_next != GST_STATE_PLAYING) {
 if (old_state != old_next || old_ret == GST_STATE_CHANGE_ASYNC) {
 smessage = gst_message_new_state_changed (GST_OBJECT_CAST (bin),
 return;
 }
 was_busy:
 {
 GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin, "state change busy");
-/* if we were busy with a state change and we are requested to flag a
-* pending async done, we do so here */
-if (flag_pending)
-bin->priv->pending_async_done = TRUE;
 return;
 }
 nothing_pending:
 {
 GST_CAT_INFO_OBJECT (GST_CAT_STATES, bin, "nothing pending");
 static void
 gst_bin_handle_message_func (GstBin * bin, GstMessage * message)
 {
 GstObject *src;
 GstMessageType type;
-GstMessage *tmessage;
-guint32 seqnum;
 src = GST_MESSAGE_SRC (message);
 type = GST_MESSAGE_TYPE (message);
+// Message src can be NULL
+if(src)
 GST_DEBUG_OBJECT (bin, "[msg %p] handling child %s message of type %s",
-message, src ? GST_ELEMENT_NAME (src) : "(NULL)",
+message, GST_ELEMENT_NAME (src), GST_MESSAGE_TYPE_NAME (message));
-GST_MESSAGE_TYPE_NAME (message));
+else
+GST_DEBUG_OBJECT (bin, "[msg %p] handling child %s message of type %s",
+message, "Null ", GST_MESSAGE_TYPE_NAME (message));
 switch (type) {
 case GST_MESSAGE_EOS:
 {
 gboolean eos;
 eos = is_eos (bin);
 GST_OBJECT_UNLOCK (bin);
 /* if we are completely EOS, we forward an EOS message */
 if (eos) {
-seqnum = gst_message_get_seqnum (message);
+GST_DEBUG_OBJECT (bin, "all sinks posted EOS");
-tmessage = gst_message_new_eos (GST_OBJECT_CAST (bin));
+gst_element_post_message (GST_ELEMENT_CAST (bin),
-gst_message_set_seqnum (tmessage, seqnum);
+gst_message_new_eos (GST_OBJECT_CAST (bin)));
-GST_DEBUG_OBJECT (bin,
-"all sinks posted EOS, posting seqnum #%" G_GUINT32_FORMAT, seqnum);
-gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
 }
 break;
 }
 case GST_MESSAGE_STATE_DIRTY:
 {
 /* free message */
 gst_message_unref (message);
 break;
 }
-case GST_MESSAGE_SEGMENT_START:{
+case GST_MESSAGE_SEGMENT_START:
-gboolean post = FALSE;
-GstFormat format;
-gint64 position;
-gst_message_parse_segment_start (message, &format, &position);
-seqnum = gst_message_get_seqnum (message);
 GST_OBJECT_LOCK (bin);
-/* if this is the first segment-start, post to parent but not to the
-* application */
-if (!find_message (bin, NULL, GST_MESSAGE_SEGMENT_START) &&
-(GST_OBJECT_PARENT (bin) != NULL)) {
-post = TRUE;
-}
 /* replace any previous segment_start message from this source
 * with the new segment start message */
 bin_replace_message (bin, message, GST_MESSAGE_SEGMENT_START);
 GST_OBJECT_UNLOCK (bin);
-if (post) {
-tmessage = gst_message_new_segment_start (GST_OBJECT_CAST (bin),
-format, position);
-gst_message_set_seqnum (tmessage, seqnum);
-/* post segment start with initial format and position. */
-GST_DEBUG_OBJECT (bin, "posting SEGMENT_START (%u) bus message: %p",
-seqnum, message);
-gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
-}
 break;
-}
 case GST_MESSAGE_SEGMENT_DONE:
 {
 gboolean post = FALSE;
 GstFormat format;
 gint64 position;
 gst_message_parse_segment_done (message, &format, &position);
-seqnum = gst_message_get_seqnum (message);
 GST_OBJECT_LOCK (bin);
 bin_replace_message (bin, message, GST_MESSAGE_SEGMENT_START);
 /* if there are no more segment_start messages, everybody posted
 * a segment_done and we can post one on the bus. */
 /* remove all old segment_done messages */
 bin_remove_messages (bin, NULL, GST_MESSAGE_SEGMENT_DONE);
 }
 GST_OBJECT_UNLOCK (bin);
 if (post) {
-tmessage = gst_message_new_segment_done (GST_OBJECT_CAST (bin),
-format, position);
-gst_message_set_seqnum (tmessage, seqnum);
 /* post segment done with latest format and position. */
-GST_DEBUG_OBJECT (bin, "posting SEGMENT_DONE (%u) bus message: %p",
+gst_element_post_message (GST_ELEMENT_CAST (bin),
-seqnum, message);
+gst_message_new_segment_done (GST_OBJECT_CAST (bin),
-gst_element_post_message (GST_ELEMENT_CAST (bin), tmessage);
+format, position));
 }
 break;
 }
 case GST_MESSAGE_DURATION:
 {
 }
 case GST_MESSAGE_ASYNC_START:
 {
 gboolean new_base_time;
 GstState target;
+	if(src)
 GST_DEBUG_OBJECT (bin, "ASYNC_START message %p, %s", message,
-src ? GST_OBJECT_NAME (src) : "(NULL)");
+GST_OBJECT_NAME (src));
+	else
+	GST_DEBUG_OBJECT (bin, "ASYNC_START message %p, %s", message,
+"Null Source");
 gst_message_parse_async_start (message, &new_base_time);
 GST_OBJECT_LOCK (bin);
 /* we ignore the message if we are going to <= READY */
 }
 }
 case GST_MESSAGE_ASYNC_DONE:
 {
 GstState target;
+	  if(src)
 GST_DEBUG_OBJECT (bin, "ASYNC_DONE message %p, %s", message,
-src ? GST_OBJECT_NAME (src) : "(NULL)");
+GST_OBJECT_NAME (src));
+	  else
+	  GST_DEBUG_OBJECT (bin, "ASYNC_DONE message %p, %s", message,
+"Null Source");
 GST_OBJECT_LOCK (bin);
 target = GST_STATE_TARGET (bin);
 /* ignore messages if we are shutting down */
 if (target <= GST_STATE_READY)
 if (!find_message (bin, NULL, GST_MESSAGE_ASYNC_START)) {
 /* nothing found, remove all old ASYNC_DONE messages */
 bin_remove_messages (bin, NULL, GST_MESSAGE_ASYNC_DONE);
 GST_DEBUG_OBJECT (bin, "async elements commited");
-/* when we get an async done message when a state change was busy, we
+bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS);
-* need to set the pending_done flag so that at the end of the state
-* change we can see if we need to verify pending async elements, hence
-* the TRUE argument here. */
-bin_handle_async_done (bin, GST_STATE_CHANGE_SUCCESS, TRUE);
-} else {
-GST_DEBUG_OBJECT (bin, "there are more async elements pending");
 }
 GST_OBJECT_UNLOCK (bin);
 break;
 ignore_done_message:
 GST_OBJECT_UNLOCK (bin);
 gst_message_unref (message);
 break;
 }
 }
-case GST_MESSAGE_STRUCTURE_CHANGE:
-{
-gboolean busy;
-gst_message_parse_structure_change (message, NULL, NULL, &busy);
-GST_OBJECT_LOCK (bin);
-if (busy) {
-/* while the pad is busy, avoid following it when doing state changes.
-* Don't update the cookie yet, we will do that after the structure
-* change finished and we are ready to inspect the new updated
-* structure. */
-bin_replace_message (bin, message, GST_MESSAGE_STRUCTURE_CHANGE);
-message = NULL;
-} else {
-/* a pad link/unlink ended, signal the state change iterator that we
-* need to resync by updating the structure_cookie. */
-bin_remove_messages (bin, GST_MESSAGE_SRC (message),
-GST_MESSAGE_STRUCTURE_CHANGE);
-bin->priv->structure_cookie++;
-}
-GST_OBJECT_UNLOCK (bin);
-if (message)
-gst_message_unref (message);
-break;
-}
 default:
 goto forward;
 }
 return;
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 bin_query_duration_done (GstBin * bin, QueryFold * fold)
 {
 GstFormat format;
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 bin_query_position_done (GstBin * bin, QueryFold * fold)
 {
 GstFormat format;
 "got latency min %" GST_TIME_FORMAT ", max %" GST_TIME_FORMAT
 ", live %d", GST_TIME_ARGS (min), GST_TIME_ARGS (max), live);
 /* for the combined latency we collect the MAX of all min latencies and
 * the MIN of all max latencies */
-if (live) {
+if (min > fold->min)
-if (min > fold->min)
+fold->min = min;
-fold->min = min;
+if (fold->max == -1)
-if (fold->max == -1)
+fold->max = max;
-fold->max = max;
+else if (max < fold->max)
-else if (max < fold->max)
+fold->max = max;
-fold->max = max;
+if (fold->live == FALSE)
-if (fold->live == FALSE)
+fold->live = live;
-fold->live = live;
-}
 } else {
 g_value_set_boolean (ret, FALSE);
 GST_DEBUG_OBJECT (item, "failed query");
 }
 break;
 }
 fold_data.query = query;
-/* set the result of the query to FALSE initially */
 g_value_init (&ret, G_TYPE_BOOLEAN);
 g_value_set_boolean (&ret, res);
 iter = gst_bin_iterate_sinks (bin);
 GST_DEBUG_OBJECT (bin, "Sending query %p (type %s) to sink children",
 childlist = xmlNewChild (parent, NULL, (xmlChar *) "children", NULL);
 GST_CAT_INFO (GST_CAT_XML, "[%s]: saving %d children",
 GST_ELEMENT_NAME (bin), bin->numchildren);
-children = g_list_last (bin->children);
+children = bin->children;
 while (children) {
 child = GST_ELEMENT (children->data);
 elementnode = xmlNewChild (childlist, NULL, (xmlChar *) "element", NULL);
 gst_object_save_thyself (GST_OBJECT (child), elementnode);
-children = g_list_previous (children);
+children = g_list_next (children);
 }
 return childlist;
 }
 static void

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3