gst/gstbin.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   4  *                    2000 Wim Taymans <wtay@chello.be>
   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
  24 #include "gst_private.h"
  25
  26 #include "gstevent.h"
  27 #include "gstbin.h"
  28 #include "gstmarshal.h"
  29 #include "gstxml.h"
  30 #include "gstinfo.h"
  31 #include "gsterror.h"
  32
  33 #include "gstscheduler.h"
  34 #include "gstindex.h"
  35
  36 static GstElementDetails gst_bin_details = GST_ELEMENT_DETAILS ("Generic bin",
  37     "Generic/Bin",
  38     "Simple container object",
  39     "Erik Walthinsen <omega@cse.ogi.edu>");
  40
  41 GType _gst_bin_type = 0;
  42
  43 static gboolean _gst_boolean_did_something_accumulator (GSignalInvocationHint *
  44     ihint, GValue * return_accu, const GValue * handler_return, gpointer dummy);
  45
  46 static void gst_bin_dispose (GObject * object);
  47
  48 static GstElementStateReturn gst_bin_change_state (GstElement * element);
  49 static GstElementStateReturn gst_bin_change_state_norecurse (GstBin * bin);
  50
  51 #ifndef GST_DISABLE_INDEX
  52 static void gst_bin_set_index (GstElement * element, GstIndex * index);
  53 #endif
  54
  55 static void gst_bin_add_func (GstBin * bin, GstElement * element);
  56 static void gst_bin_remove_func (GstBin * bin, GstElement * element);
  57 static void gst_bin_child_state_change_func (GstBin * bin,
  58     GstElementState oldstate, GstElementState newstate, GstElement * child);
  59
  60 static GstClock *gst_bin_get_clock_func (GstElement * element);
  61 static void gst_bin_set_clock_func (GstElement * element, GstClock * clock);
  62
  63 static gboolean gst_bin_iterate_func (GstBin * bin);
  64
  65 #ifndef GST_DISABLE_LOADSAVE
  66 static xmlNodePtr gst_bin_save_thyself (GstObject * object, xmlNodePtr parent);
  67 static void gst_bin_restore_thyself (GstObject * object, xmlNodePtr self);
  68 #endif
  69
  70 /* Bin signals and args */
  71 enum
  72 {
  73   ELEMENT_ADDED,
  74   ELEMENT_REMOVED,
  75   ITERATE,
  76   LAST_SIGNAL
  77 };
  78
  79 enum
  80 {
  81   ARG_0
  82       /* FILL ME */
  83 };
  84
  85 static void gst_bin_base_init (gpointer g_class);
  86 static void gst_bin_class_init (GstBinClass * klass);
  87 static void gst_bin_init (GstBin * bin);
  88
  89 static GstElementClass *parent_class = NULL;
  90 static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
  91
  92 /**
  93  * gst_bin_get_type:
  94  *
  95  * Returns: the type of #GstBin
  96  */
  97 GType
  98 gst_bin_get_type (void)
  99 {
 100   if (!_gst_bin_type) {
 101     static const GTypeInfo bin_info = {
 102       sizeof (GstBinClass),
 103       gst_bin_base_init,
 104       NULL,
 105       (GClassInitFunc) gst_bin_class_init,
 106       NULL,
 107       NULL,
 108       sizeof (GstBin),
 109       0,
 110       (GInstanceInitFunc) gst_bin_init,
 111       NULL
 112     };
 113
 114     _gst_bin_type =
 115         g_type_register_static (GST_TYPE_ELEMENT, "GstBin", &bin_info, 0);
 116   }
 117   return _gst_bin_type;
 118 }
 119
 120 static void
 121 gst_bin_base_init (gpointer g_class)
 122 {
 123   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 124
 125   gst_element_class_set_details (gstelement_class, &gst_bin_details);
 126 }
 127
 128 static void
 129 gst_bin_class_init (GstBinClass * klass)
 130 {
 131   GObjectClass *gobject_class;
 132   GstObjectClass *gstobject_class;
 133   GstElementClass *gstelement_class;
 134
 135   gobject_class = (GObjectClass *) klass;
 136   gstobject_class = (GstObjectClass *) klass;
 137   gstelement_class = (GstElementClass *) klass;
 138
 139   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 140
 141   gst_bin_signals[ELEMENT_ADDED] =
 142       g_signal_new ("element-added", G_TYPE_FROM_CLASS (klass),
 143       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GstBinClass, element_added), NULL,
 144       NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
 145   gst_bin_signals[ELEMENT_REMOVED] =
 146       g_signal_new ("element-removed", G_TYPE_FROM_CLASS (klass),
 147       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GstBinClass, element_removed), NULL,
 148       NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
 149   gst_bin_signals[ITERATE] =
 150       g_signal_new ("iterate", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 151       G_STRUCT_OFFSET (GstBinClass, iterate),
 152       _gst_boolean_did_something_accumulator, NULL, gst_marshal_BOOLEAN__VOID,
 153       G_TYPE_BOOLEAN, 0);
 154
 155   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_bin_dispose);
 156
 157 #ifndef GST_DISABLE_LOADSAVE
 158   gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_bin_save_thyself);
 159   gstobject_class->restore_thyself =
 160       GST_DEBUG_FUNCPTR (gst_bin_restore_thyself);
 161 #endif
 162
 163   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_bin_change_state);
 164 #ifndef GST_DISABLE_INDEX
 165   gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_bin_set_index);
 166 #endif
 167
 168   klass->add_element = GST_DEBUG_FUNCPTR (gst_bin_add_func);
 169   klass->remove_element = GST_DEBUG_FUNCPTR (gst_bin_remove_func);
 170   klass->child_state_change =
 171       GST_DEBUG_FUNCPTR (gst_bin_child_state_change_func);
 172   klass->iterate = GST_DEBUG_FUNCPTR (gst_bin_iterate_func);
 173 }
 174
 175 static gboolean
 176 _gst_boolean_did_something_accumulator (GSignalInvocationHint * ihint,
 177     GValue * return_accu, const GValue * handler_return, gpointer dummy)
 178 {
 179   gboolean did_something;
 180
 181   did_something = g_value_get_boolean (handler_return);
 182   if (did_something) {
 183     g_value_set_boolean (return_accu, TRUE);
 184   }
 185
 186   /* always continue emission */
 187   return TRUE;
 188 }
 189
 190 static void
 191 gst_bin_init (GstBin * bin)
 192 {
 193   /* in general, we prefer to use cothreads for most things */
 194   GST_FLAG_SET (bin, GST_BIN_FLAG_PREFER_COTHREADS);
 195
 196   bin->numchildren = 0;
 197   bin->children = NULL;
 198 }
 199
 200 /**
 201  * gst_bin_new:
 202  * @name: name of new bin
 203  *
 204  * Create a new bin with given name.
 205  *
 206  * Returns: new bin
 207  */
 208 GstElement *
 209 gst_bin_new (const gchar * name)
 210 {
 211   return gst_element_factory_make ("bin", name);
 212 }
 213
 214 static GstClock *
 215 gst_bin_get_clock_func (GstElement * element)
 216 {
 217   if (GST_ELEMENT_SCHED (element))
 218     return gst_scheduler_get_clock (GST_ELEMENT_SCHED (element));
 219
 220   return NULL;
 221 }
 222
 223 static void
 224 gst_bin_set_clock_func (GstElement * element, GstClock * clock)
 225 {
 226   if (GST_ELEMENT_SCHED (element))
 227     gst_scheduler_use_clock (GST_ELEMENT_SCHED (element), clock);
 228 }
 229
 230 /**
 231  * gst_bin_get_clock:
 232  * @bin: a #GstBin to get the clock of
 233  *
 234  * Gets the current clock of the (scheduler of the) bin.
 235  *
 236  * Returns: the #GstClock of the bin
 237  */
 238 GstClock *
 239 gst_bin_get_clock (GstBin * bin)
 240 {
 241   g_return_val_if_fail (bin != NULL, NULL);
 242   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 243
 244   return gst_bin_get_clock_func (GST_ELEMENT (bin));
 245 }
 246
 247 /**
 248  * gst_bin_use_clock:
 249  * @bin: the bin to set the clock for
 250  * @clock: the clock to use.
 251  *
 252  * Force the bin to use the given clock. Use NULL to
 253  * force it to use no clock at all.
 254  */
 255 void
 256 gst_bin_use_clock (GstBin * bin, GstClock * clock)
 257 {
 258   g_return_if_fail (GST_IS_BIN (bin));
 259
 260   gst_bin_set_clock_func (GST_ELEMENT (bin), clock);
 261 }
 262
 263 /**
 264  * gst_bin_auto_clock:
 265  * @bin: the bin to autoclock
 266  *
 267  * Let the bin select a clock automatically.
 268  */
 269 void
 270 gst_bin_auto_clock (GstBin * bin)
 271 {
 272   g_return_if_fail (GST_IS_BIN (bin));
 273
 274   if (GST_ELEMENT_SCHED (bin))
 275     gst_scheduler_auto_clock (GST_ELEMENT_SCHED (bin));
 276 }
 277
 278 #ifndef GST_DISABLE_INDEX
 279 static void
 280 gst_bin_set_index (GstElement * element, GstIndex * index)
 281 {
 282   GstBin *bin = GST_BIN (element);
 283
 284   g_return_if_fail (GST_IS_BIN (bin));
 285
 286   g_list_foreach (bin->children, (GFunc) gst_element_set_index, index);
 287 }
 288 #endif
 289
 290 static void
 291 gst_bin_set_element_sched (GstElement * element, GstScheduler * sched)
 292 {
 293   GST_CAT_LOG (GST_CAT_SCHEDULING, "setting element \"%s\" sched to %p",
 294       GST_ELEMENT_NAME (element), sched);
 295
 296   /* if it's actually a Bin */
 297   if (GST_IS_BIN (element)) {
 298     if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
 299       GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
 300           "child is already a manager, not resetting sched");
 301       if (GST_ELEMENT_SCHED (element))
 302         gst_scheduler_add_scheduler (sched, GST_ELEMENT_SCHED (element));
 303       return;
 304     }
 305
 306     GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
 307         "setting child bin's scheduler to be the same as the parent's");
 308     gst_scheduler_add_element (sched, element);
 309
 310     /* set the children's schedule */
 311     g_list_foreach (GST_BIN (element)->children,
 312         (GFunc) gst_bin_set_element_sched, sched);
 313   }
 314   /* otherwise, if it's just a regular old element */
 315   else if (!GST_FLAG_IS_SET (element, GST_ELEMENT_DECOUPLED)) {
 316     GList *pads;
 317
 318     gst_scheduler_add_element (sched, element);
 319
 320     /* set the sched pointer in all the pads */
 321     pads = element->pads;
 322     while (pads) {
 323       GstPad *pad;
 324
 325       pad = GST_PAD (pads->data);
 326       pads = g_list_next (pads);
 327
 328       /* we only operate on real pads */
 329       if (!GST_IS_REAL_PAD (pad))
 330         continue;
 331
 332       /* if the peer element exists and is a candidate */
 333       if (GST_PAD_PEER (pad)) {
 334         if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
 335           GST_CAT_LOG (GST_CAT_SCHEDULING,
 336               "peer is in same scheduler, telling scheduler");
 337
 338           if (GST_PAD_IS_SRC (pad))
 339             gst_scheduler_pad_link (sched, pad, GST_PAD_PEER (pad));
 340           else
 341             gst_scheduler_pad_link (sched, GST_PAD_PEER (pad), pad);
 342         }
 343       }
 344     }
 345   }
 346 }
 347
 348
 349 static void
 350 gst_bin_unset_element_sched (GstElement * element, GstScheduler * sched)
 351 {
 352   if (GST_ELEMENT_SCHED (element) == NULL) {
 353     GST_CAT_DEBUG (GST_CAT_SCHEDULING, "element \"%s\" has no scheduler",
 354         GST_ELEMENT_NAME (element));
 355     return;
 356   }
 357
 358   GST_CAT_DEBUG (GST_CAT_SCHEDULING,
 359       "removing element \"%s\" from its sched %p", GST_ELEMENT_NAME (element),
 360       GST_ELEMENT_SCHED (element));
 361
 362   /* if it's actually a Bin */
 363   if (GST_IS_BIN (element)) {
 364
 365     if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
 366       GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
 367           "child is already a manager, not unsetting sched");
 368       if (sched) {
 369         gst_scheduler_remove_scheduler (sched, GST_ELEMENT_SCHED (element));
 370       }
 371       return;
 372     }
 373     /* for each child, remove them from their schedule */
 374     g_list_foreach (GST_BIN (element)->children,
 375         (GFunc) gst_bin_unset_element_sched, sched);
 376
 377     gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
 378   } else if (!GST_FLAG_IS_SET (element, GST_ELEMENT_DECOUPLED)) {
 379     /* otherwise, if it's just a regular old element */
 380     GList *pads;
 381
 382     /* set the sched pointer in all the pads */
 383     pads = element->pads;
 384     while (pads) {
 385       GstPad *pad;
 386
 387       pad = GST_PAD (pads->data);
 388       pads = g_list_next (pads);
 389
 390       /* we only operate on real pads */
 391       if (!GST_IS_REAL_PAD (pad))
 392         continue;
 393
 394       /* if the peer element exists and is a candidate */
 395       if (GST_PAD_PEER (pad)) {
 396         if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
 397           GST_CAT_LOG (GST_CAT_SCHEDULING,
 398               "peer is in same scheduler, telling scheduler");
 399
 400           if (GST_PAD_IS_SRC (pad))
 401             gst_scheduler_pad_unlink (sched, pad, GST_PAD_PEER (pad));
 402           else
 403             gst_scheduler_pad_unlink (sched, GST_PAD_PEER (pad), pad);
 404         }
 405       }
 406     }
 407     gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
 408   }
 409 }
 410
 411
 412 /**
 413  * gst_bin_add_many:
 414  * @bin: the bin to add the elements to
 415  * @element_1: the first element to add to the bin
 416  * @...: additional elements to add to the bin
 417  *
 418  * Adds a NULL-terminated list of elements to a bin.  This function is
 419  * equivalent to calling #gst_bin_add() for each member of the list.
 420  */
 421 void
 422 gst_bin_add_many (GstBin * bin, GstElement * element_1, ...)
 423 {
 424   va_list args;
 425
 426   g_return_if_fail (GST_IS_BIN (bin));
 427   g_return_if_fail (GST_IS_ELEMENT (element_1));
 428
 429   va_start (args, element_1);
 430
 431   while (element_1) {
 432     gst_bin_add (bin, element_1);
 433
 434     element_1 = va_arg (args, GstElement *);
 435   }
 436
 437   va_end (args);
 438 }
 439
 440 static void
 441 gst_bin_add_func (GstBin * bin, GstElement * element)
 442 {
 443   gint state_idx = 0;
 444   GstElementState state;
 445   GstScheduler *sched;
 446
 447   /* the element must not already have a parent */
 448   g_return_if_fail (GST_ELEMENT_PARENT (element) == NULL);
 449
 450   /* then check to see if the element's name is already taken in the bin */
 451   if (gst_object_check_uniqueness (bin->children,
 452           GST_ELEMENT_NAME (element)) == FALSE) {
 453     g_warning ("Name %s is not unique in bin %s, not adding\n",
 454         GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
 455     return;
 456   }
 457
 458   /* set the element's parent and add the element to the bin's list of children */
 459   gst_object_set_parent (GST_OBJECT (element), GST_OBJECT (bin));
 460
 461   bin->children = g_list_append (bin->children, element);
 462   bin->numchildren++;
 463
 464   /* bump our internal state counter */
 465   state = GST_STATE (element);
 466   while (state >>= 1)
 467     state_idx++;
 468   bin->child_states[state_idx]++;
 469
 470   /* now we have to deal with manager stuff
 471    * we can only do this if there's a scheduler:
 472    * if we're not a manager, and aren't attached to anything, we have no sched (yet) */
 473   sched = GST_ELEMENT_SCHED (bin);
 474   if (sched) {
 475     gst_bin_set_element_sched (element, sched);
 476   }
 477
 478   GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, bin, "added element \"%s\"",
 479       GST_OBJECT_NAME (element));
 480
 481   g_signal_emit (G_OBJECT (bin), gst_bin_signals[ELEMENT_ADDED], 0, element);
 482 }
 483
 484 /**
 485  * gst_bin_add:
 486  * @bin: #GstBin to add element to
 487  * @element: #GstElement to add to bin
 488  *
 489  * Adds the given element to the bin.  Sets the element's parent, and thus
 490  * adds a reference.
 491  */
 492 void
 493 gst_bin_add (GstBin * bin, GstElement * element)
 494 {
 495   GstBinClass *bclass;
 496
 497   g_return_if_fail (GST_IS_BIN (bin));
 498   g_return_if_fail (GST_IS_ELEMENT (element));
 499
 500   GST_CAT_INFO_OBJECT (GST_CAT_PARENTAGE, bin, "adding element \"%s\"",
 501       GST_OBJECT_NAME (element));
 502
 503   bclass = GST_BIN_GET_CLASS (bin);
 504
 505   if (bclass->add_element) {
 506     bclass->add_element (bin, element);
 507   } else {
 508     GST_ELEMENT_ERROR (bin, CORE, FAILED, (NULL),
 509         ("cannot add element %s to bin %s",
 510             GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin)));
 511   }
 512 }
 513
 514 static void
 515 gst_bin_remove_func (GstBin * bin, GstElement * element)
 516 {
 517   gint state_idx = 0;
 518   GstElementState state;
 519
 520   /* the element must have its parent set to the current bin */
 521   g_return_if_fail (GST_ELEMENT_PARENT (element) == (GstObject *) bin);
 522
 523   /* the element must be in the bin's list of children */
 524   if (g_list_find (bin->children, element) == NULL) {
 525     g_warning ("no element \"%s\" in bin \"%s\"\n", GST_ELEMENT_NAME (element),
 526         GST_ELEMENT_NAME (bin));
 527     return;
 528   }
 529
 530   /* remove this element from the list of managed elements */
 531   gst_bin_unset_element_sched (element, GST_ELEMENT_SCHED (bin));
 532
 533   /* now remove the element from the list of elements */
 534   bin->children = g_list_remove (bin->children, element);
 535   bin->numchildren--;
 536
 537   /* bump our internal state counter */
 538   state = GST_STATE (element);
 539   while (state >>= 1)
 540     state_idx++;
 541   bin->child_states[state_idx]--;
 542
 543   GST_CAT_INFO_OBJECT (GST_CAT_PARENTAGE, bin, "removed child \"%s\"",
 544       GST_OBJECT_NAME (element));
 545
 546   /* ref as we're going to emit a signal */
 547   gst_object_ref (GST_OBJECT (element));
 548   gst_object_unparent (GST_OBJECT (element));
 549
 550   /* if we're down to zero children, force state to NULL */
 551   while (bin->numchildren == 0 && GST_ELEMENT_SCHED (bin) != NULL &&
 552       GST_STATE (bin) > GST_STATE_NULL) {
 553     GstElementState next = GST_STATE (bin) >> 1;
 554
 555     GST_STATE_PENDING (bin) = next;
 556     gst_bin_change_state_norecurse (bin);
 557     if (!GST_STATE (bin) == next) {
 558       g_warning ("bin %s failed state change to %d", GST_ELEMENT_NAME (bin),
 559           next);
 560       break;
 561     }
 562   }
 563   g_signal_emit (G_OBJECT (bin), gst_bin_signals[ELEMENT_REMOVED], 0, element);
 564
 565   /* element is really out of our control now */
 566   gst_object_unref (GST_OBJECT (element));
 567 }
 568
 569 /**
 570  * gst_bin_remove:
 571  * @bin: #GstBin to remove element from
 572  * @element: #GstElement to remove
 573  *
 574  * Remove the element from its associated bin, unparenting it as well.
 575  * Unparenting the element means that the element will be dereferenced,
 576  * so if the bin holds the only reference to the element, the element
 577  * will be freed in the process of removing it from the bin.  If you
 578  * want the element to still exist after removing, you need to call
 579  * #gst_object_ref before removing it from the bin.
 580  */
 581 void
 582 gst_bin_remove (GstBin * bin, GstElement * element)
 583 {
 584   GstBinClass *bclass;
 585
 586   GST_CAT_DEBUG (GST_CAT_PARENTAGE, "[%s]: trying to remove child %s",
 587       GST_ELEMENT_NAME (bin), GST_ELEMENT_NAME (element));
 588
 589   g_return_if_fail (GST_IS_BIN (bin));
 590   g_return_if_fail (GST_IS_ELEMENT (element));
 591   g_return_if_fail (bin->children != NULL);
 592
 593   bclass = GST_BIN_GET_CLASS (bin);
 594
 595   if (bclass->remove_element) {
 596     bclass->remove_element (bin, element);
 597   } else {
 598     g_warning ("cannot remove elements from bin %s\n", GST_ELEMENT_NAME (bin));
 599   }
 600 }
 601
 602 /**
 603  * gst_bin_remove_many:
 604  * @bin: the bin to remove the elements from
 605  * @element_1: the first element to remove from the bin
 606  * @...: NULL-terminated list of elements to remove from the bin
 607  *
 608  * Remove a list of elements from a bin. This function is equivalent
 609  * to calling #gst_bin_remove with each member of the list.
 610  */
 611 void
 612 gst_bin_remove_many (GstBin * bin, GstElement * element_1, ...)
 613 {
 614   va_list args;
 615
 616   g_return_if_fail (GST_IS_BIN (bin));
 617   g_return_if_fail (GST_IS_ELEMENT (element_1));
 618
 619   va_start (args, element_1);
 620
 621   while (element_1) {
 622     gst_bin_remove (bin, element_1);
 623
 624     element_1 = va_arg (args, GstElement *);
 625   }
 626
 627   va_end (args);
 628 }
 629
 630 /**
 631  * gst_bin_child_state_change:
 632  * @bin: #GstBin with the child
 633  * @oldstate: The old child state
 634  * @newstate: The new child state
 635  * @child: #GstElement that signaled an changed state
 636  *
 637  * An internal function to inform the parent bin about a state change
 638  * of a child.
 639  */
 640 void
 641 gst_bin_child_state_change (GstBin * bin, GstElementState oldstate,
 642     GstElementState newstate, GstElement * child)
 643 {
 644   GstBinClass *bclass;
 645
 646   g_return_if_fail (GST_IS_BIN (bin));
 647   g_return_if_fail (GST_IS_ELEMENT (child));
 648
 649   GST_CAT_LOG (GST_CAT_STATES, "child %s changed state in bin %s from %s to %s",
 650       GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin),
 651       gst_element_state_get_name (oldstate),
 652       gst_element_state_get_name (newstate));
 653
 654   bclass = GST_BIN_GET_CLASS (bin);
 655
 656   if (bclass->child_state_change) {
 657     bclass->child_state_change (bin, oldstate, newstate, child);
 658   } else {
 659     g_warning ("cannot signal state change of child %s to bin %s\n",
 660         GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin));
 661   }
 662 }
 663
 664 static void
 665 gst_bin_child_state_change_func (GstBin * bin, GstElementState oldstate,
 666     GstElementState newstate, GstElement * child)
 667 {
 668   gint old_idx = 0, new_idx = 0, i;
 669
 670   while (oldstate >>= 1)
 671     old_idx++;
 672   while (newstate >>= 1)
 673     new_idx++;
 674
 675   GST_LOCK (bin);
 676   bin->child_states[old_idx]--;
 677   bin->child_states[new_idx]++;
 678
 679   for (i = GST_NUM_STATES - 1; i >= 0; i--) {
 680     if (bin->child_states[i] != 0) {
 681       gint state = (1 << i);
 682
 683       if (GST_STATE (bin) != state) {
 684         GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
 685             "highest child state is %s, changing bin state accordingly",
 686             gst_element_state_get_name (state));
 687         GST_STATE_PENDING (bin) = state;
 688         GST_UNLOCK (bin);
 689         gst_bin_change_state_norecurse (bin);
 690         if (state != GST_STATE (bin)) {
 691           g_warning ("%s: state change in callback %d %d",
 692               GST_ELEMENT_NAME (bin), state, GST_STATE (bin));
 693         }
 694         return;
 695       }
 696       break;
 697     }
 698   }
 699   GST_UNLOCK (bin);
 700 }
 701
 702 static GstElementStateReturn
 703 gst_bin_change_state (GstElement * element)
 704 {
 705   GstBin *bin;
 706   GList *children;
 707   GstElement *child;
 708   GstElementStateReturn ret;
 709   GstElementState old_state, pending;
 710   gint transition;
 711   gboolean have_async = FALSE;
 712
 713   g_return_val_if_fail (GST_IS_BIN (element), GST_STATE_FAILURE);
 714
 715   bin = GST_BIN (element);
 716
 717   old_state = GST_STATE (element);
 718   pending = GST_STATE_PENDING (element);
 719   transition = GST_STATE_TRANSITION (element);
 720
 721   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
 722       "changing state of children from %s to %s",
 723       gst_element_state_get_name (old_state),
 724       gst_element_state_get_name (pending));
 725
 726   if (pending == GST_STATE_VOID_PENDING)
 727     return GST_STATE_SUCCESS;
 728
 729   /* we want to recurse into children anyway, regardless of our old
 730    * state */
 731   /*
 732      if (old_state == pending) {
 733      GST_CAT_LOG_OBJECT (GST_CAT_STATES, element,
 734      "old and pending state are both %s, returning",
 735      gst_element_state_get_name (pending));
 736      return GST_STATE_SUCCESS;
 737      }
 738    */
 739
 740   children = bin->children;
 741
 742   while (children) {
 743     GstElementState old_child_state;
 744
 745     child = GST_ELEMENT (children->data);
 746
 747     if (GST_FLAG_IS_SET (child, GST_ELEMENT_LOCKED_STATE)) {
 748       children = g_list_next (children);
 749       continue;
 750     }
 751
 752     old_child_state = GST_STATE (child);
 753
 754     GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
 755         "changing state of child %s from current %s to pending %s",
 756         GST_ELEMENT_NAME (child), gst_element_state_get_name (old_child_state),
 757         gst_element_state_get_name (pending));
 758
 759     switch (gst_element_set_state (child, pending)) {
 760       case GST_STATE_FAILURE:
 761         GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
 762             "child '%s' failed to go to state %d(%s)",
 763             GST_ELEMENT_NAME (child),
 764             pending, gst_element_state_get_name (pending));
 765
 766         gst_element_set_state (child, old_child_state);
 767         /* There was a check for elements being in the same scheduling group
 768            here. Removed by dolphy <julien@moutte.net>. No matter the
 769            scheduling group we should always return a failure. This change
 770            seems to work on my machine and fixes tons of issues. If anyone
 771            want to revert please tell me what it breaks first, Thanks. */
 772         GST_STATE_PENDING (element) = old_state;
 773         return GST_STATE_FAILURE;
 774         break;
 775       case GST_STATE_ASYNC:
 776         GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
 777             "child '%s' is changing state asynchronously",
 778             GST_ELEMENT_NAME (child));
 779         have_async = TRUE;
 780         break;
 781       case GST_STATE_SUCCESS:
 782         GST_CAT_DEBUG (GST_CAT_STATES,
 783             "child '%s' changed state to %d(%s) successfully",
 784             GST_ELEMENT_NAME (child), pending,
 785             gst_element_state_get_name (pending));
 786         break;
 787     }
 788     /* we need to do this down here, because there might be elements removed
 789      * from this bin during state changes, so g_list_next (children) might
 790      * change as well */
 791     children = g_list_next (children);
 792   }
 793
 794   GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
 795       "done changing bin's state from %s to %s, now in %s",
 796       gst_element_state_get_name (old_state),
 797       gst_element_state_get_name (pending),
 798       gst_element_state_get_name (GST_STATE (element)));
 799
 800   if (have_async)
 801     ret = GST_STATE_ASYNC;
 802   else {
 803     if (parent_class->change_state) {
 804       ret = parent_class->change_state (element);
 805     } else
 806       ret = GST_STATE_SUCCESS;
 807   }
 808   return ret;
 809 }
 810
 811
 812 static GstElementStateReturn
 813 gst_bin_change_state_norecurse (GstBin * bin)
 814 {
 815   GstElementStateReturn ret;
 816
 817   if (parent_class->change_state) {
 818     GST_CAT_LOG_OBJECT (GST_CAT_STATES, bin, "setting bin's own state");
 819     ret = parent_class->change_state (GST_ELEMENT (bin));
 820
 821     return ret;
 822   } else
 823     return GST_STATE_FAILURE;
 824 }
 825
 826 static void
 827 gst_bin_dispose (GObject * object)
 828 {
 829   GstBin *bin = GST_BIN (object);
 830
 831   GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object, "dispose");
 832
 833   if (gst_element_get_state (GST_ELEMENT (object)) == GST_STATE_PLAYING)
 834     gst_element_set_state (GST_ELEMENT (object), GST_STATE_PAUSED);
 835
 836   while (bin->children) {
 837     gst_bin_remove (bin, GST_ELEMENT (bin->children->data));
 838   }
 839   g_assert (bin->children == NULL);
 840   g_assert (bin->numchildren == 0);
 841
 842   G_OBJECT_CLASS (parent_class)->dispose (object);
 843 }
 844
 845 /**
 846  * gst_bin_get_by_name:
 847  * @bin: #Gstbin to search
 848  * @name: the element name to search for
 849  *
 850  * Get the element with the given name from this bin.
 851  *
 852  * Returns: the element with the given name
 853  */
 854 GstElement *
 855 gst_bin_get_by_name (GstBin * bin, const gchar * name)
 856 {
 857   GList *children;
 858   GstElement *child;
 859
 860   g_return_val_if_fail (bin != NULL, NULL);
 861   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 862   g_return_val_if_fail (name != NULL, NULL);
 863
 864   GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: looking up child element %s",
 865       GST_ELEMENT_NAME (bin), name);
 866
 867   children = bin->children;
 868   while (children) {
 869     child = GST_ELEMENT (children->data);
 870     if (!strcmp (GST_OBJECT_NAME (child), name))
 871       return child;
 872     if (GST_IS_BIN (child)) {
 873       GstElement *res = gst_bin_get_by_name (GST_BIN (child), name);
 874
 875       if (res)
 876         return res;
 877     }
 878     children = g_list_next (children);
 879   }
 880
 881   return NULL;
 882 }
 883
 884 /**
 885  * gst_bin_get_by_name_recurse_up:
 886  * @bin: #Gstbin to search
 887  * @name: the element name to search for
 888  *
 889  * Get the element with the given name from this bin. If the
 890  * element is not found, a recursion is performed on the parent bin.
 891  *
 892  * Returns: the element with the given name
 893  */
 894 GstElement *
 895 gst_bin_get_by_name_recurse_up (GstBin * bin, const gchar * name)
 896 {
 897   GstElement *result = NULL;
 898   GstObject *parent;
 899
 900   g_return_val_if_fail (bin != NULL, NULL);
 901   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 902   g_return_val_if_fail (name != NULL, NULL);
 903
 904   result = gst_bin_get_by_name (bin, name);
 905
 906   if (!result) {
 907     parent = gst_object_get_parent (GST_OBJECT (bin));
 908
 909     if (parent && GST_IS_BIN (parent)) {
 910       result = gst_bin_get_by_name_recurse_up (GST_BIN (parent), name);
 911     }
 912   }
 913
 914   return result;
 915 }
 916
 917 /**
 918  * gst_bin_get_list:
 919  * @bin: #Gstbin to get the list from
 920  *
 921  * Get the list of elements in this bin.
 922  *
 923  * Returns: a GList of elements
 924  */
 925 const GList *
 926 gst_bin_get_list (GstBin * bin)
 927 {
 928   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 929
 930   return bin->children;
 931 }
 932
 933 /**
 934  * gst_bin_get_by_interface:
 935  * @bin: bin to find element in
 936  * @interface: interface to be implemented by interface
 937  *
 938  * Looks for the first element inside the bin that implements the given
 939  * interface. If such an element is found, it returns the element. You can
 940  * cast this element to the given interface afterwards.
 941  * If you want all elements that implement the interface, use
 942  * gst_bin_get_all_by_interface(). The function recurses bins inside bins.
 943  *
 944  * Returns: An element inside the bin implementing the interface.
 945  */
 946 GstElement *
 947 gst_bin_get_by_interface (GstBin * bin, GType interface)
 948 {
 949   GList *walk;
 950
 951   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 952   g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface), NULL);
 953
 954   walk = bin->children;
 955   while (walk) {
 956     if (G_TYPE_CHECK_INSTANCE_TYPE (walk->data, interface))
 957       return GST_ELEMENT (walk->data);
 958     if (GST_IS_BIN (walk->data)) {
 959       GstElement *ret;
 960
 961       ret = gst_bin_get_by_interface (GST_BIN (walk->data), interface);
 962       if (ret)
 963         return ret;
 964     }
 965     walk = g_list_next (walk);
 966   }
 967
 968   return NULL;
 969 }
 970
 971 /**
 972  * gst_bin_get_all_by_interface:
 973  * @bin: bin to find elements in
 974  * @interface: interface to be implemented by interface
 975  *
 976  * Looks for all elements inside the bin that implements the given
 977  * interface. You can safely cast all returned elements to the given interface.
 978  * The function recurses bins inside bins. You need to free the list using
 979  * g_list_free() after use.
 980  *
 981  * Returns: An element inside the bin implementing the interface.
 982  */
 983 GList *
 984 gst_bin_get_all_by_interface (GstBin * bin, GType interface)
 985 {
 986   GList *walk, *ret = NULL;
 987
 988   g_return_val_if_fail (GST_IS_BIN (bin), NULL);
 989   g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface), NULL);
 990
 991   walk = bin->children;
 992   while (walk) {
 993     if (G_TYPE_CHECK_INSTANCE_TYPE (walk->data, interface)) {
 994       GST_DEBUG_OBJECT (bin, "element %s implements requested interface",
 995           GST_ELEMENT_NAME (GST_ELEMENT (walk->data)));
 996       ret = g_list_prepend (ret, walk->data);
 997     }
 998     if (GST_IS_BIN (walk->data)) {
 999       ret = g_list_concat (ret,
1000           gst_bin_get_all_by_interface (GST_BIN (walk->data), interface));
1001     }
1002     walk = g_list_next (walk);
1003   }
1004
1005   return ret;
1006 }
1007
1008 /**
1009  * gst_bin_sync_children_state:
1010  * @bin: #Gstbin to sync state
1011  *
1012  * Tries to set the state of the children of this bin to the same state of the
1013  * bin by calling gst_element_set_state for each child not already having a
1014  * synchronized state.
1015  *
1016  * Returns: The worst return value of any gst_element_set_state. So if one child
1017  *          returns #GST_STATE_FAILURE while all others return #GST_STATE_SUCCESS
1018  *          this function returns #GST_STATE_FAILURE.
1019  */
1020 GstElementStateReturn
1021 gst_bin_sync_children_state (GstBin * bin)
1022 {
1023   GList *children;
1024   GstElement *element;
1025   GstElementState state;
1026   GstElementStateReturn ret = GST_STATE_SUCCESS;
1027
1028   g_return_val_if_fail (GST_IS_BIN (bin), GST_STATE_FAILURE);
1029
1030   state = GST_STATE (bin);
1031   children = bin->children;
1032   GST_CAT_INFO (GST_CAT_STATES,
1033       "syncing state of children with bin \"%s\"'s state %s",
1034       GST_ELEMENT_NAME (bin), gst_element_state_get_name (state));
1035
1036   while (children) {
1037     element = GST_ELEMENT (children->data);
1038     children = children->next;
1039     if (GST_STATE (element) != state) {
1040       switch (gst_element_set_state (element, state)) {
1041         case GST_STATE_SUCCESS:
1042           break;
1043         case GST_STATE_ASYNC:
1044           if (ret == GST_STATE_SUCCESS)
1045             ret = GST_STATE_ASYNC;
1046           break;
1047         case GST_STATE_FAILURE:
1048           ret = GST_STATE_FAILURE;
1049         default:
1050           /* make sure gst_element_set_state never returns this */
1051           g_assert_not_reached ();
1052       }
1053     }
1054   }
1055
1056   return ret;
1057 }
1058
1059 #ifndef GST_DISABLE_LOADSAVE
1060 static xmlNodePtr
1061 gst_bin_save_thyself (GstObject * object, xmlNodePtr parent)
1062 {
1063   GstBin *bin = GST_BIN (object);
1064   xmlNodePtr childlist, elementnode;
1065   GList *children;
1066   GstElement *child;
1067
1068   if (GST_OBJECT_CLASS (parent_class)->save_thyself)
1069     GST_OBJECT_CLASS (parent_class)->save_thyself (GST_OBJECT (bin), parent);
1070
1071   childlist = xmlNewChild (parent, NULL, "children", NULL);
1072
1073   GST_CAT_INFO (GST_CAT_XML, "[%s]: saving %d children",
1074       GST_ELEMENT_NAME (bin), bin->numchildren);
1075
1076   children = bin->children;
1077   while (children) {
1078     child = GST_ELEMENT (children->data);
1079     elementnode = xmlNewChild (childlist, NULL, "element", NULL);
1080     gst_object_save_thyself (GST_OBJECT (child), elementnode);
1081     children = g_list_next (children);
1082   }
1083   return childlist;
1084 }
1085
1086 static void
1087 gst_bin_restore_thyself (GstObject * object, xmlNodePtr self)
1088 {
1089   GstBin *bin = GST_BIN (object);
1090   xmlNodePtr field = self->xmlChildrenNode;
1091   xmlNodePtr childlist;
1092
1093   while (field) {
1094     if (!strcmp (field->name, "children")) {
1095       GST_CAT_INFO (GST_CAT_XML, "[%s]: loading children",
1096           GST_ELEMENT_NAME (object));
1097       childlist = field->xmlChildrenNode;
1098       while (childlist) {
1099         if (!strcmp (childlist->name, "element")) {
1100           GstElement *element =
1101               gst_xml_make_element (childlist, GST_OBJECT (bin));
1102
1103           /* it had to be parented to find the pads, now we ref and unparent so
1104            * we can add it to the bin */
1105           gst_object_ref (GST_OBJECT (element));
1106           gst_object_unparent (GST_OBJECT (element));
1107
1108           gst_bin_add (bin, element);
1109         }
1110         childlist = childlist->next;
1111       }
1112     }
1113
1114     field = field->next;
1115   }
1116   if (GST_OBJECT_CLASS (parent_class)->restore_thyself)
1117     (GST_OBJECT_CLASS (parent_class)->restore_thyself) (object, self);
1118 }
1119 #endif /* GST_DISABLE_LOADSAVE */
1120
1121 static gboolean
1122 gst_bin_iterate_func (GstBin * bin)
1123 {
1124   GstScheduler *sched = GST_ELEMENT_SCHED (bin);
1125
1126   /* only iterate if this is the manager bin */
1127   if (sched && sched->parent == GST_ELEMENT (bin)) {
1128     GstSchedulerState state;
1129
1130     state = gst_scheduler_iterate (sched);
1131
1132     if (state == GST_SCHEDULER_STATE_RUNNING) {
1133       return TRUE;
1134     } else if (state == GST_SCHEDULER_STATE_ERROR) {
1135       gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PAUSED);
1136     } else if (state == GST_SCHEDULER_STATE_STOPPED) {
1137       /* check if we have children scheds that are still running */
1138       /* FIXME: remove in 0.9? autouseless because iterations gone? */
1139       GList *walk;
1140
1141       for (walk = sched->schedulers; walk; walk = g_list_next (walk)) {
1142         GstScheduler *test = walk->data;
1143
1144         g_return_val_if_fail (test->parent, FALSE);
1145         if (GST_STATE (test->parent) == GST_STATE_PLAYING) {
1146           GST_CAT_DEBUG_OBJECT (GST_CAT_SCHEDULING, bin,
1147               "current bin is not iterating, but children are, "
1148               "so returning TRUE anyway...");
1149           g_usleep (1);
1150           return TRUE;
1151         }
1152       }
1153     }
1154   } else {
1155     g_warning ("bin \"%s\" is not the managing bin, can't be iterated on!\n",
1156         GST_ELEMENT_NAME (bin));
1157   }
1158
1159   return FALSE;
1160 }
1161
1162 /**
1163  * gst_bin_iterate:
1164  * @bin: a#GstBin to iterate.
1165  *
1166  * Iterates over the elements in this bin.
1167  *
1168  * Returns: TRUE if the bin did something useful. This value
1169  *          can be used to determine it the bin is in EOS.
1170  */
1171 gboolean
1172 gst_bin_iterate (GstBin * bin)
1173 {
1174   gboolean running;
1175
1176   g_return_val_if_fail (bin != NULL, FALSE);
1177   g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
1178
1179   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, bin, "starting iteration");
1180   gst_object_ref (GST_OBJECT (bin));
1181
1182   running = FALSE;
1183   g_signal_emit (G_OBJECT (bin), gst_bin_signals[ITERATE], 0, &running);
1184
1185   gst_object_unref (GST_OBJECT (bin));
1186   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, bin, "finished iteration");
1187
1188   return running;
1189 }