2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000 Wim Taymans <wtay@chello.be>
5 * gstbin.c: GstBin container object and support code
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
23 //#define GST_DEBUG_ENABLED
25 #include "gst_private.h"
29 #include "gstscheduler.h"
31 GstElementDetails gst_bin_details = {
34 "Simple container object",
36 "Erik Walthinsen <omega@cse.ogi.edu>",
41 static void gst_bin_real_destroy (GtkObject *object);
43 static GstElementStateReturn gst_bin_change_state (GstElement *element);
44 static GstElementStateReturn gst_bin_change_state_norecurse (GstBin *bin);
45 static gboolean gst_bin_change_state_type (GstBin *bin,
46 GstElementState state,
49 static void gst_bin_create_plan_func (GstBin *bin);
50 static gboolean gst_bin_iterate_func (GstBin *bin);
52 static xmlNodePtr gst_bin_save_thyself (GstObject *object, xmlNodePtr parent);
53 static void gst_bin_restore_thyself (GstObject *object, xmlNodePtr self);
55 /* Bin signals and args */
67 static void gst_bin_class_init (GstBinClass *klass);
68 static void gst_bin_init (GstBin *bin);
71 static GstElementClass *parent_class = NULL;
72 static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
75 gst_bin_get_type (void)
77 static GtkType bin_type = 0;
80 static const GtkTypeInfo bin_info = {
84 (GtkClassInitFunc)gst_bin_class_init,
85 (GtkObjectInitFunc)gst_bin_init,
88 (GtkClassInitFunc)NULL,
90 bin_type = gtk_type_unique (GST_TYPE_ELEMENT, &bin_info);
96 gst_bin_class_init (GstBinClass *klass)
98 GtkObjectClass *gtkobject_class;
99 GstObjectClass *gstobject_class;
100 GstElementClass *gstelement_class;
102 gtkobject_class = (GtkObjectClass*)klass;
103 gstobject_class = (GstObjectClass*)klass;
104 gstelement_class = (GstElementClass*)klass;
106 parent_class = gtk_type_class (GST_TYPE_ELEMENT);
108 gst_bin_signals[OBJECT_ADDED] =
109 gtk_signal_new ("object_added", GTK_RUN_FIRST, gtkobject_class->type,
110 GTK_SIGNAL_OFFSET (GstBinClass, object_added),
111 gtk_marshal_NONE__POINTER, GTK_TYPE_NONE, 1,
113 gtk_object_class_add_signals (gtkobject_class, gst_bin_signals, LAST_SIGNAL);
115 klass->change_state_type = gst_bin_change_state_type;
116 klass->create_plan = gst_bin_create_plan_func;
117 klass->schedule = gst_bin_schedule_func;
118 klass->iterate = gst_bin_iterate_func;
120 gstobject_class->save_thyself = gst_bin_save_thyself;
121 gstobject_class->restore_thyself = gst_bin_restore_thyself;
123 gstelement_class->change_state = gst_bin_change_state;
125 gtkobject_class->destroy = gst_bin_real_destroy;
129 gst_bin_init (GstBin *bin)
131 // in general, we prefer to use cothreads for most things
132 GST_FLAG_SET (bin, GST_BIN_FLAG_PREFER_COTHREADS);
134 bin->numchildren = 0;
135 bin->children = NULL;
136 bin->eos_providers = NULL;
137 bin->num_eos_providers = 0;
139 bin->eoscond = g_cond_new ();
140 // FIXME temporary testing measure
141 // bin->use_cothreads = TRUE;
146 * @name: name of new bin
148 * Create a new bin with given name.
153 gst_bin_new (const gchar *name)
155 return gst_elementfactory_make ("bin", name);
160 * @bin: #GstBin to add element to
161 * @element: #GstElement to add to bin
163 * Add the given element to the bin. Set the elements parent, and thus
167 gst_bin_add (GstBin *bin,
170 g_return_if_fail (bin != NULL);
171 g_return_if_fail (GST_IS_BIN (bin));
172 g_return_if_fail (element != NULL);
173 g_return_if_fail (GST_IS_ELEMENT (element));
175 // must be NULL or PAUSED state in order to modify bin
176 g_return_if_fail ((GST_STATE (bin) == GST_STATE_NULL) ||
177 (GST_STATE (bin) == GST_STATE_PAUSED));
179 bin->children = g_list_append (bin->children, element);
181 gst_object_set_parent (GST_OBJECT (element), GST_OBJECT (bin));
183 GST_INFO_ELEMENT (GST_CAT_PARENTAGE, bin, "added child %s", GST_ELEMENT_NAME (element));
185 /* we know we have at least one child, we just added one... */
186 // if (GST_STATE(element) < GST_STATE_READY)
187 // gst_bin_change_state_norecurse(bin,GST_STATE_READY);
189 gtk_signal_emit (GTK_OBJECT (bin), gst_bin_signals[OBJECT_ADDED], element);
194 * @bin: #GstBin to remove element from
195 * @element: #GstElement to remove
197 * Remove the element from its associated bin, unparenting as well.
200 gst_bin_remove (GstBin *bin,
203 g_return_if_fail (bin != NULL);
204 g_return_if_fail (GST_IS_BIN (bin));
205 g_return_if_fail (element != NULL);
206 g_return_if_fail (GST_IS_ELEMENT (element));
207 g_return_if_fail (bin->children != NULL);
209 // must be NULL or PAUSED state in order to modify bin
210 g_return_if_fail ((GST_STATE (bin) == GST_STATE_NULL) ||
211 (GST_STATE (bin) == GST_STATE_PAUSED));
213 if (g_list_find(bin->children, element) == NULL) {
214 // FIXME this should be a warning!!!
215 GST_ERROR_OBJECT(bin,element,"no such element in bin");
219 gst_object_unparent (GST_OBJECT (element));
220 bin->children = g_list_remove (bin->children, element);
223 GST_INFO_ELEMENT (GST_CAT_PARENTAGE, bin, "removed child %s", GST_ELEMENT_NAME (element));
225 /* if we're down to zero children, force state to NULL */
226 if (bin->numchildren == 0)
227 gst_element_set_state (GST_ELEMENT (bin), GST_STATE_NULL);
231 static GstElementStateReturn
232 gst_bin_change_state (GstElement *element)
238 GST_DEBUG_ENTER("(\"%s\")",GST_ELEMENT_NAME (element));
240 g_return_val_if_fail (GST_IS_BIN (element), GST_STATE_FAILURE);
242 bin = GST_BIN (element);
244 // GST_DEBUG (0,"currently %d(%s), %d(%s) pending\n",GST_STATE (element),
245 // _gst_print_statename (GST_STATE (element)), GST_STATE_PENDING (element),
246 // _gst_print_statename (GST_STATE_PENDING (element)));
248 GST_INFO_ELEMENT (GST_CAT_STATES, element, "changing bin's state from %s to %s",
249 _gst_print_statename (GST_STATE (element)),
250 _gst_print_statename (GST_STATE_PENDING (element)));
252 // g_return_val_if_fail(bin->numchildren != 0, GST_STATE_FAILURE);
254 switch (GST_STATE_TRANSITION (element)) {
255 case GST_STATE_NULL_TO_READY:
259 parent = gst_object_get_parent (GST_OBJECT (element));
261 if (!parent || !GST_IS_BIN (parent))
262 gst_bin_create_plan (bin);
271 children = bin->children;
273 child = GST_ELEMENT (children->data);
274 GST_DEBUG (0,"setting state on '%s'\n",GST_ELEMENT_NAME (child));
275 switch (gst_element_set_state (child, GST_STATE_PENDING (element))) {
276 case GST_STATE_FAILURE:
277 GST_STATE_PENDING (element) = GST_STATE_NONE_PENDING;
278 GST_DEBUG (0,"child '%s' failed to go to state %d(%s)\n", GST_ELEMENT_NAME (child),
279 GST_STATE_PENDING (element), _gst_print_statename (GST_STATE_PENDING (element)));
280 return GST_STATE_FAILURE;
282 case GST_STATE_ASYNC:
283 GST_DEBUG (0,"child '%s' is changing state asynchronously\n", GST_ELEMENT_NAME (child));
287 children = g_list_next (children);
289 // g_print("<-- \"%s\"\n",gst_object_get_name(GST_OBJECT(bin)));
292 return gst_bin_change_state_norecurse (bin);
296 static GstElementStateReturn
297 gst_bin_change_state_norecurse (GstBin *bin)
300 if (GST_ELEMENT_CLASS (parent_class)->change_state)
301 return GST_ELEMENT_CLASS (parent_class)->change_state (GST_ELEMENT (bin));
303 return GST_STATE_FAILURE;
307 gst_bin_change_state_type(GstBin *bin,
308 GstElementState state,
314 // g_print("gst_bin_change_state_type(\"%s\",%d,%d);\n",
315 // gst_object_get_name(GST_OBJECT(bin)),state,type);
317 g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
318 g_return_val_if_fail (bin->numchildren != 0, FALSE);
321 children = bin->children;
323 child = GST_ELEMENT (children->data);
324 if (GST_IS_BIN (child)) {
325 if (!gst_bin_set_state_type (GST_BIN (child), state,type))
327 } else if (GTK_CHECK_TYPE (child,type)) {
328 if (!gst_element_set_state (child,state))
332 children = g_list_next (children);
334 if (type == GST_TYPE_BIN)
335 gst_element_set_state (GST_ELEMENT (bin),state);
341 * gst_bin_set_state_type:
342 * @bin: #GstBin to set the state
343 * @state: the new state to set the elements to
344 * @type: the type of elements to change
346 * Sets the state of only those objects of the given type.
348 * Returns: indication if the state change was successfull
351 gst_bin_set_state_type (GstBin *bin,
352 GstElementState state,
357 GST_DEBUG (0,"gst_bin_set_state_type(\"%s\",%d,%d)\n",
358 GST_ELEMENT_NAME (bin), state,type);
360 g_return_val_if_fail (bin != NULL, FALSE);
361 g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
363 oclass = GST_BIN_CLASS (GTK_OBJECT (bin)->klass);
365 if (oclass->change_state_type)
366 (oclass->change_state_type) (bin,state,type);
371 gst_bin_real_destroy (GtkObject *object)
373 GstBin *bin = GST_BIN (object);
377 GST_DEBUG (0,"in gst_bin_real_destroy()\n");
379 children = bin->children;
381 child = GST_ELEMENT (children->data);
382 gst_element_destroy (child);
383 children = g_list_next (children);
386 g_list_free (bin->children);
390 * gst_bin_get_by_name:
391 * @bin: #Gstbin to search
392 * @name: the element name to search for
394 * Get the element with the given name from this bin.
396 * Returns: the element with the given name
399 gst_bin_get_by_name (GstBin *bin,
405 g_return_val_if_fail (bin != NULL, NULL);
406 g_return_val_if_fail (GST_IS_BIN (bin), NULL);
407 g_return_val_if_fail (name != NULL, NULL);
409 GST_INFO_ELEMENT (GST_CAT_PARENTAGE, bin, "looking up child element %s", name);
411 children = bin->children;
413 child = GST_ELEMENT (children->data);
414 if (!strcmp (gst_object_get_name (GST_OBJECT (child)),name))
416 if (GST_IS_BIN (child)) {
417 GstElement *res = gst_bin_get_by_name (GST_BIN (child), name);
421 children = g_list_next (children);
428 * gst_bin_get_by_name_recurse_up:
429 * @bin: #Gstbin to search
430 * @name: the element name to search for
432 * Get the element with the given name from this bin. If the
433 * element is not found, a recursion is performed on the parent bin.
435 * Returns: the element with the given name
438 gst_bin_get_by_name_recurse_up (GstBin *bin,
441 GstElement *result = NULL;
444 g_return_val_if_fail (bin != NULL, NULL);
445 g_return_val_if_fail (GST_IS_BIN (bin), NULL);
446 g_return_val_if_fail (name != NULL, NULL);
448 result = gst_bin_get_by_name (bin, name);
453 parent = gst_object_get_parent (GST_OBJECT (bin));
455 if (parent && GST_IS_BIN (parent)) {
456 result = gst_bin_get_by_name_recurse_up (GST_BIN (parent), name);
464 * @bin: #Gstbin to get the list from
466 * Get the list of elements in this bin.
468 * Returns: a GList of elements
471 gst_bin_get_list (GstBin *bin)
473 g_return_val_if_fail (bin != NULL, NULL);
474 g_return_val_if_fail (GST_IS_BIN (bin), NULL);
476 return bin->children;
480 gst_bin_save_thyself (GstObject *object,
483 GstBin *bin = GST_BIN (object);
484 xmlNodePtr childlist, elementnode;
488 if (GST_OBJECT_CLASS (parent_class)->save_thyself)
489 GST_OBJECT_CLASS (parent_class)->save_thyself (GST_OBJECT (bin), parent);
491 childlist = xmlNewChild (parent, NULL, "children", NULL);
493 GST_INFO_ELEMENT (GST_CAT_XML, bin, "saving %d children", bin->numchildren);
495 children = bin->children;
497 child = GST_ELEMENT (children->data);
498 elementnode = xmlNewChild (childlist, NULL, "element", NULL);
499 gst_object_save_thyself (GST_OBJECT (child), elementnode);
500 children = g_list_next (children);
506 gst_bin_restore_thyself (GstObject *object,
509 GstBin *bin = GST_BIN (object);
510 xmlNodePtr field = self->xmlChildrenNode;
511 xmlNodePtr childlist;
514 if (!strcmp (field->name, "children")) {
515 GST_INFO_ELEMENT (GST_CAT_XML, GST_ELEMENT (object), "loading children");
516 childlist = field->xmlChildrenNode;
518 if (!strcmp (childlist->name, "element")) {
519 GstElement *element = gst_element_load_thyself (childlist, GST_OBJECT (bin));
521 gst_bin_add (bin, element);
523 childlist = childlist->next;
532 gst_bin_use_cothreads (GstBin *bin,
535 g_return_if_fail (GST_IS_BIN (bin));
537 bin->use_cothreads = enabled;
542 * @bin: #Gstbin to iterate
544 * Iterates over the elements in this bin.
546 * Returns: TRUE if the bin did something usefull. This value
547 * can be used to determine it the bin is in EOS.
550 gst_bin_iterate (GstBin *bin)
555 GST_DEBUG_ENTER("(\"%s\")",GST_ELEMENT_NAME (bin));
557 oclass = GST_BIN_CLASS (GTK_OBJECT (bin)->klass);
560 eos = (oclass->iterate) (bin);
562 GST_DEBUG_LEAVE("(\"%s\")",GST_ELEMENT_NAME (bin));
568 * gst_bin_create_plan:
569 * @bin: #GstBin to create the plan for
571 * Let the bin figure out how to handle its children.
574 gst_bin_create_plan (GstBin *bin)
578 oclass = GST_BIN_CLASS (GTK_OBJECT (bin)->klass);
580 if (oclass->create_plan)
581 (oclass->create_plan) (bin);
584 /* out internal element fired EOS, we decrement the number of pending EOS childs */
586 gst_bin_received_eos (GstElement *element, GstBin *bin)
588 GST_INFO_ELEMENT (GST_CAT_PLANNING, bin, "child %s fired eos, pending %d\n", GST_ELEMENT_NAME (element),
589 bin->num_eos_providers);
592 if (bin->num_eos_providers) {
593 bin->num_eos_providers--;
594 g_cond_signal (bin->eoscond);
601 * @bin: #GstBin to schedule
603 * Let the bin figure out how to handle its children.
606 gst_bin_schedule (GstBin *bin)
610 oclass = GST_BIN_CLASS (GTK_OBJECT (bin)->klass);
612 if (oclass->schedule)
613 (oclass->schedule) (bin);
623 gst_bin_create_plan_func (GstBin *bin)
628 #ifdef GST_DEBUG_ENABLED
629 const gchar *elementname;
631 GSList *pending = NULL;
634 GST_DEBUG_ENTER("(\"%s\")",GST_ELEMENT_NAME (bin));
636 GST_INFO_ELEMENT (GST_CAT_PLANNING, bin, "creating plan");
638 // first figure out which element is the manager of this and all child elements
639 // if we're a managing bin ourselves, that'd be us
640 if (GST_FLAG_IS_SET (bin, GST_BIN_FLAG_MANAGER)) {
641 manager = GST_ELEMENT (bin);
642 GST_DEBUG (0,"setting manager to self\n");
643 // otherwise, it's what our parent says it is
645 manager = gst_element_get_manager (GST_ELEMENT (bin));
647 GST_DEBUG (0,"manager not set for element \"%s\" assuming manager is self\n", GST_ELEMENT_NAME (bin));
648 manager = GST_ELEMENT (bin);
649 GST_FLAG_SET (bin, GST_BIN_FLAG_MANAGER);
651 GST_DEBUG (0,"setting manager to \"%s\"\n", GST_ELEMENT_NAME (manager));
653 gst_element_set_manager (GST_ELEMENT (bin), manager);
655 // perform the first recursive pass of plan generation
656 // we set the manager of every element but those who manage themselves
657 // the need for cothreads is also determined recursively
658 GST_DEBUG (0,"performing first-phase recursion\n");
659 bin->need_cothreads = bin->use_cothreads;
660 if (bin->need_cothreads)
661 GST_DEBUG (0,"requiring cothreads because we're forced to\n");
663 elements = bin->children;
665 element = GST_ELEMENT (elements->data);
666 elements = g_list_next (elements);
667 #ifdef GST_DEBUG_ENABLED
668 elementname = GST_ELEMENT_NAME (element);
670 GST_DEBUG (0,"have element \"%s\"\n",elementname);
672 // first set their manager
673 GST_DEBUG (0,"setting manager of \"%s\" to \"%s\"\n",elementname,GST_ELEMENT_NAME (manager));
674 gst_element_set_manager (element, manager);
676 // we do recursion and such for Bins
677 if (GST_IS_BIN (element)) {
678 // recurse into the child Bin
679 GST_DEBUG (0,"recursing into child Bin \"%s\" with manager \"%s\"\n",elementname,
680 GST_ELEMENT_NAME (element->manager));
681 gst_bin_create_plan (GST_BIN (element));
682 GST_DEBUG (0,"after recurse got manager \"%s\"\n",
683 GST_ELEMENT_NAME (element->manager));
684 // check to see if it needs cothreads and isn't self-managing
685 if (((GST_BIN (element))->need_cothreads) && !GST_FLAG_IS_SET(element,GST_BIN_FLAG_MANAGER)) {
686 GST_DEBUG (0,"requiring cothreads because child bin \"%s\" does\n",elementname);
687 bin->need_cothreads = TRUE;
690 // then we need to determine whether they need cothreads
691 // if it's a loop-based element, use cothreads
692 if (element->loopfunc != NULL) {
693 GST_DEBUG (0,"requiring cothreads because \"%s\" is a loop-based element\n",elementname);
694 GST_FLAG_SET (element, GST_ELEMENT_USE_COTHREAD);
695 // if it's a 'complex' element, use cothreads
696 } else if (GST_FLAG_IS_SET (element, GST_ELEMENT_COMPLEX)) {
697 GST_DEBUG (0,"requiring cothreads because \"%s\" is complex\n",elementname);
698 GST_FLAG_SET (element, GST_ELEMENT_USE_COTHREAD);
699 // if the element has more than one sink pad, use cothreads
700 } else if (element->numsinkpads > 1) {
701 GST_DEBUG (0,"requiring cothreads because \"%s\" has more than one sink pad\n",elementname);
702 GST_FLAG_SET (element, GST_ELEMENT_USE_COTHREAD);
704 if (GST_FLAG_IS_SET (element, GST_ELEMENT_USE_COTHREAD))
705 bin->need_cothreads = TRUE;
710 // if we're not a manager thread, we're done.
711 if (!GST_FLAG_IS_SET (bin, GST_BIN_FLAG_MANAGER)) {
712 GST_DEBUG_LEAVE("(\"%s\")",GST_ELEMENT_NAME (bin));
716 // clear previous plan state
717 g_list_free (bin->managed_elements);
718 bin->managed_elements = NULL;
719 bin->num_managed_elements = 0;
721 // find all the managed children
722 // here we pull off the trick of walking an entire arbitrary tree without recursion
723 GST_DEBUG (0,"attempting to find all the elements to manage\n");
724 pending = g_slist_prepend (pending, bin);
726 // retrieve the top of the stack and pop it
727 pending_bin = GST_BIN (pending->data);
728 pending = g_slist_remove (pending, pending_bin);
730 // walk the list of elements, find bins, and do stuff
731 GST_DEBUG (0,"checking Bin \"%s\" for managed elements\n",
732 GST_ELEMENT_NAME (pending_bin));
733 elements = pending_bin->children;
735 element = GST_ELEMENT (elements->data);
736 elements = g_list_next (elements);
737 #ifdef GST_DEBUG_ENABLED
738 elementname = GST_ELEMENT_NAME (element);
741 // if it's ours, add it to the list
742 if (element->manager == GST_ELEMENT(bin)) {
743 // if it's a Bin, add it to the list of Bins to check
744 if (GST_IS_BIN (element)) {
745 GST_DEBUG (0,"flattened recurse into \"%s\"\n",elementname);
746 pending = g_slist_prepend (pending, element);
748 // otherwise add it to the list of elements
750 GST_DEBUG (0,"found element \"%s\" that I manage\n",elementname);
751 bin->managed_elements = g_list_prepend (bin->managed_elements, element);
752 bin->num_managed_elements++;
755 // else it's not ours and we need to wait for EOS notifications
757 gtk_signal_connect (GTK_OBJECT (element), "eos", gst_bin_received_eos, bin);
758 bin->eos_providers = g_list_prepend (bin->eos_providers, element);
759 bin->num_eos_providers++;
764 GST_DEBUG (0,"have %d elements to manage, implementing plan\n",bin->num_managed_elements);
766 gst_bin_schedule(bin);
768 g_print ("gstbin \"%s\", eos providers:%d\n",
769 GST_ELEMENT_NAME (bin),
770 bin->num_eos_providers);
772 GST_DEBUG_LEAVE("(\"%s\")",GST_ELEMENT_NAME (bin));
776 gst_bin_iterate_func (GstBin *bin)
784 GstBuffer *buf = NULL;
785 gint num_scheduled = 0;
786 gboolean eos = FALSE;
788 GST_DEBUG_ENTER("(\"%s\")", GST_ELEMENT_NAME (bin));
790 g_return_val_if_fail (bin != NULL, TRUE);
791 g_return_val_if_fail (GST_IS_BIN (bin), TRUE);
792 g_return_val_if_fail (GST_STATE (bin) == GST_STATE_PLAYING, TRUE);
794 // step through all the chains
795 chains = bin->chains;
797 chain = (_GstBinChain *)(chains->data);
798 chains = g_list_next (chains);
800 if (!chain->need_scheduling) continue;
802 if (chain->need_cothreads) {
803 // all we really have to do is switch to the first child
804 // FIXME this should be lots more intelligent about where to start
805 GST_DEBUG (0,"starting iteration via cothreads\n");
807 entry = GST_ELEMENT (chain->elements->data);
808 GST_FLAG_SET (entry, GST_ELEMENT_COTHREAD_STOPPING);
809 GST_DEBUG (0,"set COTHREAD_STOPPING flag on \"%s\"(@%p)\n",
810 GST_ELEMENT_NAME (entry),entry);
811 cothread_switch (entry->threadstate);
814 GST_DEBUG (0,"starting iteration via chain-functions\n");
816 entries = chain->entries;
818 g_assert (entries != NULL);
821 entry = GST_ELEMENT (entries->data);
822 entries = g_list_next (entries);
824 GST_DEBUG (0,"have entry \"%s\"\n",GST_ELEMENT_NAME (entry));
826 if (GST_IS_BIN (entry)) {
827 gst_bin_iterate (GST_BIN (entry));
831 pad = GST_PAD (pads->data);
832 if (GST_RPAD_DIRECTION(pad) == GST_PAD_SRC) {
833 GST_DEBUG (0,"calling getfunc of %s:%s\n",GST_DEBUG_PAD_NAME(pad));
834 if (GST_REAL_PAD(pad)->getfunc == NULL)
835 fprintf(stderr, "error, no getfunc in \"%s\"\n", GST_ELEMENT_NAME (entry));
837 buf = (GST_REAL_PAD(pad)->getfunc)(pad);
838 if (buf) gst_pad_push(pad,buf);
840 pads = g_list_next (pads);
848 // check if nothing was scheduled that was ours..
849 if (!num_scheduled) {
850 // are there any other elements that are still busy?
851 if (bin->num_eos_providers) {
853 GST_DEBUG (0,"waiting for eos providers\n");
854 g_cond_wait (bin->eoscond, GST_OBJECT(bin)->lock);
855 GST_DEBUG (0,"num eos providers %d\n", bin->num_eos_providers);
859 gst_element_signal_eos (GST_ELEMENT (bin));
864 GST_DEBUG_LEAVE("(%s)", GST_ELEMENT_NAME (bin));