2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
2002-06-11 21:03:48 +00:00
|
|
|
*
|
2000-12-28 22:12:02 +00:00
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
*
|
|
|
|
* gstbin.c: GstBin container object and support code
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
* License along with this library; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2000-12-28 22:12:02 +00:00
|
|
|
#include "gst_private.h"
|
2000-12-08 18:24:16 +00:00
|
|
|
|
2001-12-18 19:03:07 +00:00
|
|
|
#include "gstevent.h"
|
2000-12-15 01:57:34 +00:00
|
|
|
#include "gstbin.h"
|
2004-02-03 03:31:26 +00:00
|
|
|
#include "gstmarshal.h"
|
2002-02-03 20:07:09 +00:00
|
|
|
#include "gstxml.h"
|
2003-06-29 14:05:49 +00:00
|
|
|
#include "gstinfo.h"
|
2000-08-21 21:20:38 +00:00
|
|
|
|
2000-12-26 23:51:04 +00:00
|
|
|
#include "gstscheduler.h"
|
2002-12-19 21:31:03 +00:00
|
|
|
#include "gstindex.h"
|
2000-12-26 23:51:04 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
static GstElementDetails gst_bin_details = GST_ELEMENT_DETAILS (
|
2000-01-30 09:03:00 +00:00
|
|
|
"Generic bin",
|
2002-04-20 21:42:53 +00:00
|
|
|
"Generic/Bin",
|
2000-01-30 09:03:00 +00:00
|
|
|
"Simple container object",
|
2003-10-31 19:32:47 +00:00
|
|
|
"Erik Walthinsen <omega@cse.ogi.edu>"
|
|
|
|
);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-10-21 18:00:31 +00:00
|
|
|
GType _gst_bin_type = 0;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-10-14 00:00:37 +00:00
|
|
|
static gboolean _gst_boolean_did_something_accumulator (GSignalInvocationHint *ihint,
|
|
|
|
GValue *return_accu, const GValue *handler_return, gpointer dummy);
|
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
static void gst_bin_dispose (GObject * object);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-18 19:03:07 +00:00
|
|
|
static GstElementStateReturn gst_bin_change_state (GstElement *element);
|
|
|
|
static GstElementStateReturn gst_bin_change_state_norecurse (GstBin *bin);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_INDEX
|
2003-02-10 07:53:58 +00:00
|
|
|
static void gst_bin_set_index (GstElement *element, GstIndex *index);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
2002-12-19 21:31:03 +00:00
|
|
|
|
2003-01-11 20:08:03 +00:00
|
|
|
static void gst_bin_add_func (GstBin *bin, GstElement *element);
|
|
|
|
static void gst_bin_remove_func (GstBin *bin, GstElement *element);
|
2003-04-18 23:34:21 +00:00
|
|
|
static void gst_bin_child_state_change_func (GstBin *bin, GstElementState oldstate,
|
|
|
|
GstElementState newstate, GstElement *child);
|
2003-01-11 20:08:03 +00:00
|
|
|
|
2003-02-11 20:15:50 +00:00
|
|
|
static GstClock* gst_bin_get_clock_func (GstElement *element);
|
|
|
|
static void gst_bin_set_clock_func (GstElement *element, GstClock *clock);
|
2003-02-10 20:32:32 +00:00
|
|
|
|
|
|
|
static gboolean gst_bin_iterate_func (GstBin *bin);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-12-15 22:37:35 +00:00
|
|
|
static xmlNodePtr gst_bin_save_thyself (GstObject * object, xmlNodePtr parent);
|
|
|
|
static void gst_bin_restore_thyself (GstObject * object, xmlNodePtr self);
|
2001-06-24 21:18:28 +00:00
|
|
|
#endif
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* Bin signals and args */
|
2001-12-15 22:37:35 +00:00
|
|
|
enum
|
|
|
|
{
|
2002-12-19 21:31:03 +00:00
|
|
|
ELEMENT_ADDED,
|
|
|
|
ELEMENT_REMOVED,
|
2003-10-14 00:00:37 +00:00
|
|
|
ITERATE,
|
2000-01-30 09:03:00 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
enum
|
|
|
|
{
|
2003-05-15 22:46:37 +00:00
|
|
|
ARG_0
|
2000-01-30 09:03:00 +00:00
|
|
|
/* FILL ME */
|
|
|
|
};
|
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
static void gst_bin_base_init (gpointer g_class);
|
2001-12-15 22:37:35 +00:00
|
|
|
static void gst_bin_class_init (GstBinClass * klass);
|
|
|
|
static void gst_bin_init (GstBin * bin);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
static GstElementClass *parent_class = NULL;
|
|
|
|
static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-01-20 03:10:44 +00:00
|
|
|
gst_bin_get_type (void)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-10-21 18:00:31 +00:00
|
|
|
if (!_gst_bin_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo bin_info = {
|
2001-12-15 22:37:35 +00:00
|
|
|
sizeof (GstBinClass),
|
2003-10-31 19:32:47 +00:00
|
|
|
gst_bin_base_init,
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
2001-12-15 22:37:35 +00:00
|
|
|
(GClassInitFunc) gst_bin_class_init,
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2001-12-15 22:37:35 +00:00
|
|
|
sizeof (GstBin),
|
2001-06-25 01:20:11 +00:00
|
|
|
8,
|
2001-12-15 22:37:35 +00:00
|
|
|
(GInstanceInitFunc) gst_bin_init,
|
2001-09-14 22:16:47 +00:00
|
|
|
NULL
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
2001-12-15 22:37:35 +00:00
|
|
|
|
2001-10-21 18:00:31 +00:00
|
|
|
_gst_bin_type = g_type_register_static (GST_TYPE_ELEMENT, "GstBin", &bin_info, 0);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-10-21 18:00:31 +00:00
|
|
|
return _gst_bin_type;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
static void
|
|
|
|
gst_bin_base_init (gpointer g_class)
|
|
|
|
{
|
|
|
|
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
|
|
|
|
|
|
|
|
gst_element_class_set_details (gstelement_class, &gst_bin_details);
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
static void
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_class_init (GstBinClass * klass)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2001-01-29 00:06:02 +00:00
|
|
|
GstObjectClass *gstobject_class;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstElementClass *gstelement_class;
|
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
|
|
gstobject_class = (GstObjectClass *) klass;
|
|
|
|
gstelement_class = (GstElementClass *) klass;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
gst_bin_signals[ELEMENT_ADDED] =
|
|
|
|
g_signal_new ("element_added", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST,
|
|
|
|
G_STRUCT_OFFSET (GstBinClass, element_added), NULL, NULL,
|
2004-01-02 15:41:08 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
|
2002-12-19 21:31:03 +00:00
|
|
|
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,
|
2004-01-02 15:41:08 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
|
2003-10-14 00:00:37 +00:00
|
|
|
gst_bin_signals[ITERATE] =
|
|
|
|
g_signal_new ("iterate", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (GstBinClass, iterate),
|
|
|
|
_gst_boolean_did_something_accumulator, NULL,
|
|
|
|
gst_marshal_BOOLEAN__VOID, G_TYPE_BOOLEAN, 0);
|
2001-12-18 19:03:07 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_bin_dispose);
|
2002-01-18 22:44:19 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-12-15 22:37:35 +00:00
|
|
|
gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_bin_save_thyself);
|
|
|
|
gstobject_class->restore_thyself = GST_DEBUG_FUNCPTR (gst_bin_restore_thyself);
|
2001-06-24 21:18:28 +00:00
|
|
|
#endif
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_bin_change_state);
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_INDEX
|
2002-12-19 21:31:03 +00:00
|
|
|
gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_bin_set_index);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
2001-10-17 10:21:27 +00:00
|
|
|
|
2003-01-11 20:08:03 +00:00
|
|
|
klass->add_element = GST_DEBUG_FUNCPTR (gst_bin_add_func);
|
|
|
|
klass->remove_element = GST_DEBUG_FUNCPTR (gst_bin_remove_func);
|
2003-04-18 23:34:21 +00:00
|
|
|
klass->child_state_change = GST_DEBUG_FUNCPTR (gst_bin_child_state_change_func);
|
2001-12-15 22:37:35 +00:00
|
|
|
klass->iterate = GST_DEBUG_FUNCPTR (gst_bin_iterate_func);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2003-10-14 00:00:37 +00:00
|
|
|
static gboolean
|
|
|
|
_gst_boolean_did_something_accumulator (GSignalInvocationHint *ihint,
|
|
|
|
GValue *return_accu, const GValue *handler_return, gpointer dummy)
|
|
|
|
{
|
|
|
|
gboolean did_something;
|
|
|
|
|
|
|
|
did_something = g_value_get_boolean (handler_return);
|
|
|
|
if (did_something) {
|
|
|
|
g_value_set_boolean (return_accu, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* always continue emission */
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_init (GstBin * bin)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-12-14 22:59:21 +00:00
|
|
|
/* in general, we prefer to use cothreads for most things */
|
2000-12-20 09:39:43 +00:00
|
|
|
GST_FLAG_SET (bin, GST_BIN_FLAG_PREFER_COTHREADS);
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
bin->numchildren = 0;
|
|
|
|
bin->children = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_bin_new:
|
|
|
|
* @name: name of new bin
|
|
|
|
*
|
|
|
|
* Create a new bin with given name.
|
|
|
|
*
|
|
|
|
* Returns: new bin
|
|
|
|
*/
|
2001-12-15 22:37:35 +00:00
|
|
|
GstElement *
|
|
|
|
gst_bin_new (const gchar * name)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2002-04-11 20:35:18 +00:00
|
|
|
return gst_element_factory_make ("bin", name);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
static GstClock*
|
2003-02-11 20:15:50 +00:00
|
|
|
gst_bin_get_clock_func (GstElement *element)
|
2003-02-10 20:32:32 +00:00
|
|
|
{
|
2003-02-11 20:15:50 +00:00
|
|
|
if (GST_ELEMENT_SCHED (element))
|
|
|
|
return gst_scheduler_get_clock (GST_ELEMENT_SCHED (element));
|
2003-02-10 20:32:32 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-02-11 20:15:50 +00:00
|
|
|
gst_bin_set_clock_func (GstElement *element, GstClock *clock)
|
2003-02-10 20:32:32 +00:00
|
|
|
{
|
2003-02-11 20:15:50 +00:00
|
|
|
if (GST_ELEMENT_SCHED (element))
|
|
|
|
gst_scheduler_use_clock (GST_ELEMENT_SCHED (element), clock);
|
2003-02-10 20:32:32 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_get_clock:
|
2002-04-23 15:02:35 +00:00
|
|
|
* @bin: a #GstBin to get the clock of
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2002-04-23 15:02:35 +00:00
|
|
|
* Gets the current clock of the (scheduler of the) bin.
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2002-04-23 15:02:35 +00:00
|
|
|
* Returns: the #GstClock of the bin
|
2002-03-31 14:04:50 +00:00
|
|
|
*/
|
2002-02-03 20:07:09 +00:00
|
|
|
GstClock*
|
|
|
|
gst_bin_get_clock (GstBin *bin)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (bin != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
|
|
|
|
2003-02-11 20:15:50 +00:00
|
|
|
return gst_bin_get_clock_func (GST_ELEMENT (bin));
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_use_clock:
|
|
|
|
* @bin: the bin to set the clock for
|
|
|
|
* @clock: the clock to use.
|
|
|
|
*
|
|
|
|
* Force the bin to use the given clock. Use NULL to
|
|
|
|
* force it to use no clock at all.
|
|
|
|
*/
|
2002-02-03 20:07:09 +00:00
|
|
|
void
|
|
|
|
gst_bin_use_clock (GstBin *bin, GstClock *clock)
|
|
|
|
{
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
|
2003-02-12 17:23:45 +00:00
|
|
|
gst_bin_set_clock_func (GST_ELEMENT (bin), clock);
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_auto_clock:
|
|
|
|
* @bin: the bin to autoclock
|
|
|
|
*
|
|
|
|
* Let the bin select a clock automatically.
|
|
|
|
*/
|
2002-02-03 20:07:09 +00:00
|
|
|
void
|
|
|
|
gst_bin_auto_clock (GstBin *bin)
|
|
|
|
{
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
|
2002-03-30 17:05:03 +00:00
|
|
|
if (GST_ELEMENT_SCHED (bin))
|
|
|
|
gst_scheduler_auto_clock (GST_ELEMENT_SCHED (bin));
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_INDEX
|
2001-09-14 22:16:47 +00:00
|
|
|
static void
|
2003-02-10 07:53:58 +00:00
|
|
|
gst_bin_set_index (GstElement *element, GstIndex *index)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
2003-02-10 07:53:58 +00:00
|
|
|
GstBin *bin = GST_BIN (element);
|
2002-12-19 21:31:03 +00:00
|
|
|
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
|
2003-04-14 18:38:11 +00:00
|
|
|
g_list_foreach (bin->children, (GFunc) gst_element_set_index, index);
|
2002-12-19 21:31:03 +00:00
|
|
|
}
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
2002-12-19 21:31:03 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
gst_bin_set_element_sched (GstElement *element, GstScheduler *sched)
|
|
|
|
{
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_SCHEDULING, "setting element \"%s\" sched to %p", GST_ELEMENT_NAME (element),
|
2001-12-15 22:37:35 +00:00
|
|
|
sched);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* if it's actually a Bin */
|
2001-12-15 22:37:35 +00:00
|
|
|
if (GST_IS_BIN (element)) {
|
2001-12-04 22:12:50 +00:00
|
|
|
if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: child is already a manager, not resetting", GST_ELEMENT_NAME (element));
|
2002-07-28 01:46:38 +00:00
|
|
|
if (GST_ELEMENT_SCHED (element))
|
|
|
|
gst_scheduler_add_scheduler (sched, GST_ELEMENT_SCHED (element));
|
2001-05-25 21:00:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: setting children's schedule to parent's", GST_ELEMENT_NAME (element));
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_scheduler_add_element (sched, element);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* set the children's schedule */
|
2003-04-14 18:38:11 +00:00
|
|
|
g_list_foreach (GST_BIN (element)->children, (GFunc) gst_bin_set_element_sched, sched);
|
2001-12-15 22:37:35 +00:00
|
|
|
}
|
2001-12-14 22:59:21 +00:00
|
|
|
/* otherwise, if it's just a regular old element */
|
2001-12-15 22:37:35 +00:00
|
|
|
else {
|
2002-11-02 13:54:34 +00:00
|
|
|
GList *pads;
|
2003-01-09 14:15:37 +00:00
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_scheduler_add_element (sched, element);
|
2003-01-09 14:15:37 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/* set the sched pointer in all the pads */
|
|
|
|
pads = element->pads;
|
|
|
|
while (pads) {
|
|
|
|
GstPad *pad;
|
|
|
|
|
|
|
|
pad = GST_PAD (pads->data);
|
|
|
|
pads = g_list_next (pads);
|
2003-01-09 14:15:37 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/* we only operate on real pads */
|
|
|
|
if (!GST_IS_REAL_PAD (pad))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* if the peer element exists and is a candidate */
|
|
|
|
if (GST_PAD_PEER (pad)) {
|
|
|
|
if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_SCHEDULING,
|
2003-01-09 14:15:37 +00:00
|
|
|
"peer is in same scheduler, telling scheduler");
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
if (GST_PAD_IS_SRC (pad))
|
2003-01-09 14:15:37 +00:00
|
|
|
gst_scheduler_pad_link (sched, pad, GST_PAD_PEER (pad));
|
2002-11-02 13:54:34 +00:00
|
|
|
else
|
2003-01-09 14:15:37 +00:00
|
|
|
gst_scheduler_pad_link (sched, GST_PAD_PEER (pad), pad);
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-09-14 22:16:47 +00:00
|
|
|
static void
|
2002-03-30 17:05:03 +00:00
|
|
|
gst_bin_unset_element_sched (GstElement *element, GstScheduler *sched)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
2001-12-19 19:22:53 +00:00
|
|
|
if (GST_ELEMENT_SCHED (element) == NULL) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_SCHEDULING, "element \"%s\" has no scheduler",
|
2001-12-19 19:22:53 +00:00
|
|
|
GST_ELEMENT_NAME (element));
|
|
|
|
return;
|
|
|
|
}
|
2003-01-09 14:15:37 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_SCHEDULING, "removing element \"%s\" from its sched %p",
|
2001-12-15 22:37:35 +00:00
|
|
|
GST_ELEMENT_NAME (element), GST_ELEMENT_SCHED (element));
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* if it's actually a Bin */
|
2001-12-15 22:37:35 +00:00
|
|
|
if (GST_IS_BIN (element)) {
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: child is already a manager, not unsetting sched",
|
|
|
|
GST_ELEMENT_NAME (element));
|
2002-03-30 17:05:03 +00:00
|
|
|
if (sched) {
|
|
|
|
gst_scheduler_remove_scheduler (sched, GST_ELEMENT_SCHED (element));
|
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2001-12-14 22:59:21 +00:00
|
|
|
/* for each child, remove them from their schedule */
|
2003-04-14 18:38:11 +00:00
|
|
|
g_list_foreach (GST_BIN (element)->children, (GFunc) gst_bin_unset_element_sched, sched);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2002-03-30 17:05:03 +00:00
|
|
|
gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
|
2001-12-15 22:37:35 +00:00
|
|
|
}
|
2001-12-14 22:59:21 +00:00
|
|
|
/* otherwise, if it's just a regular old element */
|
2001-12-15 22:37:35 +00:00
|
|
|
else {
|
2002-11-02 13:54:34 +00:00
|
|
|
GList *pads;
|
|
|
|
|
|
|
|
/* set the sched pointer in all the pads */
|
|
|
|
pads = element->pads;
|
|
|
|
while (pads) {
|
|
|
|
GstPad *pad;
|
|
|
|
|
|
|
|
pad = GST_PAD (pads->data);
|
|
|
|
pads = g_list_next (pads);
|
|
|
|
|
|
|
|
/* we only operate on real pads */
|
|
|
|
if (!GST_IS_REAL_PAD (pad))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* if the peer element exists and is a candidate */
|
|
|
|
if (GST_PAD_PEER (pad)) {
|
|
|
|
if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_SCHEDULING, "peer is in same scheduler, telling scheduler");
|
2002-11-02 13:54:34 +00:00
|
|
|
|
|
|
|
if (GST_PAD_IS_SRC (pad))
|
2003-01-09 14:15:37 +00:00
|
|
|
gst_scheduler_pad_unlink (sched, pad, GST_PAD_PEER (pad));
|
2002-11-02 13:54:34 +00:00
|
|
|
else
|
2003-01-09 14:15:37 +00:00
|
|
|
gst_scheduler_pad_unlink (sched, GST_PAD_PEER (pad), pad);
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
|
2001-05-25 21:00:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-02-21 14:44:27 +00:00
|
|
|
/**
|
2002-03-31 14:04:50 +00:00
|
|
|
* gst_bin_add_many:
|
|
|
|
* @bin: the bin to add the elements to
|
2002-02-21 14:44:27 +00:00
|
|
|
* @element_1: the first element to add to the bin
|
|
|
|
* @...: NULL-terminated list of elements to add to the bin
|
|
|
|
*
|
|
|
|
* Add a list of elements to a bin. Uses #gst_bin_add.
|
2002-03-31 14:04:50 +00:00
|
|
|
*/
|
2002-02-21 14:44:27 +00:00
|
|
|
void
|
|
|
|
gst_bin_add_many (GstBin *bin, GstElement *element_1, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element_1));
|
|
|
|
|
|
|
|
va_start (args, element_1);
|
|
|
|
|
|
|
|
while (element_1) {
|
|
|
|
gst_bin_add (bin, element_1);
|
|
|
|
|
|
|
|
element_1 = va_arg (args, GstElement*);
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end (args);
|
|
|
|
}
|
|
|
|
|
2003-01-11 20:08:03 +00:00
|
|
|
static void
|
|
|
|
gst_bin_add_func (GstBin *bin, GstElement *element)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-12-10 18:08:35 +00:00
|
|
|
gint state_idx = 0;
|
|
|
|
GstElementState state;
|
2002-03-30 17:05:03 +00:00
|
|
|
GstScheduler *sched;
|
2001-12-10 18:08:35 +00:00
|
|
|
|
2003-03-25 19:39:18 +00:00
|
|
|
/* the element must not already have a parent */
|
|
|
|
g_return_if_fail (GST_ELEMENT_PARENT (element) == NULL);
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* then check to see if the element's name is already taken in the bin */
|
2002-04-21 14:16:36 +00:00
|
|
|
if (gst_object_check_uniqueness (bin->children,
|
|
|
|
GST_ELEMENT_NAME (element)) == FALSE)
|
|
|
|
{
|
|
|
|
g_warning ("Name %s is not unique in bin %s, not adding\n",
|
|
|
|
GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
|
|
|
|
return;
|
|
|
|
}
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* set the element's parent and add the element to the bin's list of children */
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_object_set_parent (GST_OBJECT (element), GST_OBJECT (bin));
|
2001-12-04 22:12:50 +00:00
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
bin->children = g_list_append (bin->children, element);
|
2000-01-30 09:03:00 +00:00
|
|
|
bin->numchildren++;
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* bump our internal state counter */
|
2001-12-10 18:08:35 +00:00
|
|
|
state = GST_STATE (element);
|
2001-12-15 22:37:35 +00:00
|
|
|
while (state >>= 1) state_idx++;
|
2001-12-10 18:08:35 +00:00
|
|
|
bin->child_states[state_idx]++;
|
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
/* now we have to deal with manager stuff
|
|
|
|
* we can only do this if there's a scheduler:
|
|
|
|
* if we're not a manager, and aren't attached to anything, we have no sched (yet) */
|
2002-03-30 17:05:03 +00:00
|
|
|
sched = GST_ELEMENT_SCHED (bin);
|
|
|
|
if (sched) {
|
|
|
|
gst_bin_set_element_sched (element, sched);
|
2001-12-04 22:12:50 +00:00
|
|
|
}
|
2000-12-30 02:41:15 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: added child \"%s\"",
|
|
|
|
GST_ELEMENT_NAME (bin), GST_ELEMENT_NAME (element));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
g_signal_emit (G_OBJECT (bin), gst_bin_signals[ELEMENT_ADDED], 0, element);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2003-01-11 20:08:03 +00:00
|
|
|
* gst_bin_add:
|
|
|
|
* @bin: #GstBin to add element to
|
|
|
|
* @element: #GstElement to add to bin
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
2003-01-11 20:08:03 +00:00
|
|
|
* Add the given element to the bin. Set the elements parent, and thus
|
|
|
|
* add a reference.
|
2000-01-30 09:03:00 +00:00
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
2003-01-11 20:08:03 +00:00
|
|
|
gst_bin_add (GstBin *bin, GstElement *element)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2003-01-11 20:08:03 +00:00
|
|
|
GstBinClass *bclass;
|
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_PARENTAGE, "adding element \"%s\" to bin \"%s\"",
|
2003-01-11 20:08:03 +00:00
|
|
|
GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
|
|
|
|
|
|
|
|
bclass = GST_BIN_GET_CLASS (bin);
|
|
|
|
|
|
|
|
if (bclass->add_element) {
|
|
|
|
bclass->add_element (bin, element);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_warning ("cannot add elements to bin %s\n", GST_ELEMENT_NAME (bin));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_bin_remove_func (GstBin *bin, GstElement *element)
|
|
|
|
{
|
|
|
|
gint state_idx = 0;
|
|
|
|
GstElementState state;
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* the element must have its parent set to the current bin */
|
2001-12-15 22:37:35 +00:00
|
|
|
g_return_if_fail (GST_ELEMENT_PARENT (element) == (GstObject *) bin);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* the element must be in the bin's list of children */
|
2001-12-15 22:37:35 +00:00
|
|
|
if (g_list_find (bin->children, element) == NULL) {
|
|
|
|
g_warning ("no element \"%s\" in bin \"%s\"\n", GST_ELEMENT_NAME (element),
|
|
|
|
GST_ELEMENT_NAME (bin));
|
2000-12-30 02:41:15 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* remove this element from the list of managed elements */
|
2002-03-30 17:05:03 +00:00
|
|
|
gst_bin_unset_element_sched (element, GST_ELEMENT_SCHED (bin));
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* now remove the element from the list of elements */
|
2000-11-04 18:54:07 +00:00
|
|
|
bin->children = g_list_remove (bin->children, element);
|
2000-01-30 09:03:00 +00:00
|
|
|
bin->numchildren--;
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* bump our internal state counter */
|
2001-12-10 18:08:35 +00:00
|
|
|
state = GST_STATE (element);
|
2001-12-15 22:37:35 +00:00
|
|
|
while (state >>= 1) state_idx++;
|
2001-12-10 18:08:35 +00:00
|
|
|
bin->child_states[state_idx]--;
|
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: removed child %s",
|
|
|
|
GST_ELEMENT_NAME (bin), GST_ELEMENT_NAME (element));
|
2000-12-30 02:41:15 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
/* ref as we're going to emit a signal */
|
|
|
|
gst_object_ref (GST_OBJECT (element));
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_object_unparent (GST_OBJECT (element));
|
|
|
|
|
2000-07-17 17:14:15 +00:00
|
|
|
/* if we're down to zero children, force state to NULL */
|
2001-12-20 20:03:10 +00:00
|
|
|
if (bin->numchildren == 0 && GST_ELEMENT_SCHED (bin) != NULL) {
|
|
|
|
GST_STATE_PENDING (bin) = GST_STATE_NULL;
|
|
|
|
gst_bin_change_state_norecurse (bin);
|
|
|
|
}
|
2002-12-19 21:31:03 +00:00
|
|
|
g_signal_emit (G_OBJECT (bin), gst_bin_signals[ELEMENT_REMOVED], 0, element);
|
|
|
|
|
|
|
|
/* element is really out of our control now */
|
|
|
|
gst_object_unref (GST_OBJECT (element));
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2003-01-11 20:08:03 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_remove:
|
|
|
|
* @bin: #GstBin to remove element from
|
|
|
|
* @element: #GstElement to remove
|
|
|
|
*
|
|
|
|
* Remove the element from its associated bin, unparenting as well.
|
|
|
|
* The element will also be unreferenced so there's no need to call
|
|
|
|
* gst_object_unref on it.
|
|
|
|
* If you want the element to still exist after removing, you need to call
|
|
|
|
* #gst_object_ref before removing it from the bin.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_bin_remove (GstBin *bin, GstElement *element)
|
|
|
|
{
|
|
|
|
GstBinClass *bclass;
|
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_PARENTAGE, "[%s]: trying to remove child %s", GST_ELEMENT_NAME (bin), GST_ELEMENT_NAME (element));
|
2003-01-11 20:08:03 +00:00
|
|
|
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (bin->children != NULL);
|
|
|
|
|
|
|
|
bclass = GST_BIN_GET_CLASS (bin);
|
|
|
|
|
|
|
|
if (bclass->remove_element) {
|
|
|
|
bclass->remove_element (bin, element);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_warning ("cannot remove elements from bin %s\n", GST_ELEMENT_NAME (bin));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-11 20:15:50 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_remove_many:
|
|
|
|
* @bin: the bin to remove the elements from
|
|
|
|
* @element_1: the first element to remove from the bin
|
|
|
|
* @...: NULL-terminated list of elements to remove from the bin
|
|
|
|
*
|
|
|
|
* Remove a list of elements from a bin. Uses #gst_bin_remove.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_bin_remove_many (GstBin *bin, GstElement *element_1, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element_1));
|
|
|
|
|
|
|
|
va_start (args, element_1);
|
|
|
|
|
|
|
|
while (element_1) {
|
|
|
|
gst_bin_remove (bin, element_1);
|
|
|
|
|
|
|
|
element_1 = va_arg (args, GstElement*);
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end (args);
|
|
|
|
}
|
|
|
|
|
2002-01-01 15:58:51 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_child_state_change:
|
|
|
|
* @bin: #GstBin with the child
|
|
|
|
* @oldstate: The old child state
|
|
|
|
* @newstate: The new child state
|
|
|
|
* @child: #GstElement that signaled an changed state
|
|
|
|
*
|
|
|
|
* An internal function to inform the parent bin about a state change
|
|
|
|
* of a child.
|
|
|
|
*/
|
2001-12-20 20:03:10 +00:00
|
|
|
void
|
2003-04-18 23:34:21 +00:00
|
|
|
gst_bin_child_state_change (GstBin *bin, GstElementState oldstate,
|
|
|
|
GstElementState newstate, GstElement *child)
|
2001-12-04 22:12:50 +00:00
|
|
|
{
|
2003-04-18 23:34:21 +00:00
|
|
|
GstBinClass *bclass;
|
|
|
|
|
|
|
|
g_return_if_fail (GST_IS_BIN (bin));
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (child));
|
2001-12-04 22:12:50 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "child %s changed state in bin %s from %s to %s",
|
2001-12-15 22:37:35 +00:00
|
|
|
GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin),
|
2002-04-23 11:15:18 +00:00
|
|
|
gst_element_state_get_name (oldstate), gst_element_state_get_name (newstate));
|
2001-12-04 22:12:50 +00:00
|
|
|
|
2003-04-18 23:34:21 +00:00
|
|
|
bclass = GST_BIN_GET_CLASS (bin);
|
|
|
|
|
|
|
|
if (bclass->child_state_change) {
|
|
|
|
bclass->child_state_change (bin, oldstate, newstate, child);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_warning ("cannot signal state change of child %s to bin %s\n",
|
|
|
|
GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_bin_child_state_change_func (GstBin *bin, GstElementState oldstate,
|
|
|
|
GstElementState newstate, GstElement *child)
|
|
|
|
{
|
|
|
|
gint old_idx = 0, new_idx = 0, i;
|
|
|
|
|
2002-01-01 16:01:00 +00:00
|
|
|
while (oldstate >>= 1) old_idx++;
|
|
|
|
while (newstate >>= 1) new_idx++;
|
2001-12-04 22:12:50 +00:00
|
|
|
|
|
|
|
GST_LOCK (bin);
|
|
|
|
bin->child_states[old_idx]--;
|
|
|
|
bin->child_states[new_idx]++;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
for (i = GST_NUM_STATES - 1; i >= 0; i--) {
|
2001-12-04 22:12:50 +00:00
|
|
|
if (bin->child_states[i] != 0) {
|
2002-01-01 13:51:04 +00:00
|
|
|
gint state = (1 << i);
|
|
|
|
if (GST_STATE (bin) != state) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "bin %s need state change to %s",
|
2002-04-23 11:15:18 +00:00
|
|
|
GST_ELEMENT_NAME (bin), gst_element_state_get_name (state));
|
2002-01-01 13:51:04 +00:00
|
|
|
GST_STATE_PENDING (bin) = state;
|
2002-03-30 17:05:03 +00:00
|
|
|
GST_UNLOCK (bin);
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_bin_change_state_norecurse (bin);
|
2002-11-02 13:54:34 +00:00
|
|
|
if (state != GST_STATE (bin)) {
|
|
|
|
g_warning ("%s: state change in cllback %d %d",
|
|
|
|
GST_ELEMENT_NAME (bin),
|
|
|
|
state, GST_STATE (bin));
|
|
|
|
}
|
2002-03-30 17:05:03 +00:00
|
|
|
return;
|
2001-12-04 22:12:50 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
GST_UNLOCK (bin);
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static GstElementStateReturn
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_change_state (GstElement * element)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GstBin *bin;
|
|
|
|
GList *children;
|
|
|
|
GstElement *child;
|
2001-03-07 21:52:56 +00:00
|
|
|
GstElementStateReturn ret;
|
2001-12-04 22:12:50 +00:00
|
|
|
GstElementState old_state, pending;
|
2002-02-03 20:07:09 +00:00
|
|
|
gint transition;
|
2001-12-04 22:12:50 +00:00
|
|
|
gboolean have_async = FALSE;
|
2000-12-20 09:39:43 +00:00
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
g_return_val_if_fail (GST_IS_BIN (element), GST_STATE_FAILURE);
|
Changed the way things are scheduled, especially sources. A Src used to have a push() function, and optionally a pus...
Original commit message from CVS:
Changed the way things are scheduled, especially sources. A Src used to
have a push() function, and optionally a pushregion() to deal with async
reads, etc. That whole thing has gone away, in favor of providing a
pull() function for the output (Src) pad instead, ala chain functions.
This makes constructing cothreaded schedules out of non-loop elements
somewhat easier. Basically there was always a question as to which pad
was being dealt with. In the pullregion case, cothread-specific data was
used to try to pass the region struct to the right place, which is a slow
hack. And in general, the push function severely limited the kind of
tricks that could be played when there's more than one output pad, such as
a multi-out file reader with async capabilities on each pad independently.
This changes the way cothread scheduling occurs. Instead of the hack to
deal with Src's by calling their push() function (or optionally the
pushregion(), in certain cases), we now are working towards a general
mechanism where pads are the only thing that are dealt with directly.
An optimization was made in the process of doing this: the loopfunction
actually run as the outer [stack] frame of the cothread is now set more
intelligently in create_plan() based on what kind of element it is. We
now have:
loopfunc_wrapper: used for loop-based elements, it simply calls the
loopfunc in a loop, paying attention to COTHREAD_STOPPING (see
below). It currently does other, soon to be depracated, stuff.
pullsrc_wrapper: wraps a Src that's not loop-based (since your options
are now loop- or pull-based)
There will be a couple more to deal with other cases, such as Connections
and chain-based elements. The general idea is that it's a lot more
efficient to make the decisions once in create_plan than to keep doing
this huge if/else chain in the wrapper. Just choose the right wrapper up
front. It'll be most apparent performance-wise in the case of whichever
element context is switched to first for each iteration, since the whole
wrapper setup is done for every iteration.
The tricky part is that there is now a bit of overloading of the function
pointers in a pad. The current meanings (possibly to change a bit more
soon) are:
chainfunc: as always, chainfunc pointer is mirrored between peer pads
(this may change, and the chain func may end up in pushfunc)
pushfunc: SrcPad: gst_pad_pushfunc_proxy, cothread_switch to peer
SinkPad: none (may take over chainfunc, see below) pullfunc:
SrcPad: Src or Connection's function to construct buffers
SinkPad: gst_pad_pullfunc_proxy, cothread_switch to peer
There are a number of issues remaining with the scheduling, not the least
of which is the fact that Connections are still dealt with the old way,
with _push() functions and such. I'm trying to figure out a way to unify
the system so it makes sense. Following the scheduling system is hard
enough, trying to change it is murder.
Another useful scheduling addition, mentioned above, is COTHREAD_STOPPING.
It's an element flag that's used to signal whatever code is running in
cothread context that it should be finishing up and exiting soon. An
example of this is in plugins/cobin/spindentity.c. All the loops should
now be composed of do/while loops, rather than while(1) loops:
do {
buf = gst_pad_pull(spindentity->sinkpad);
gst_pad_push(spindentity->srcpad,buf);
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
The reason for this is that COTHREAD_STOPPING may be set before the above
loop ever gets started. It wouldn't do for the body of the loop to never
once get called, that would simply stall the pipeline. Note that only the
core library code is ever responsible for setting and unsetting this flag.
All elements have to do is respond to it by cleanly exiting the loop and
the function holding it.
This is needed primarily to allow iterations to occur properly.
Basically, there's a single entry point in the cothread scheduling loop,
gst_bin_iterate_func() simply switches to this cothread. If the element
in this context is allowed to loop infinitely, nothing would even switch
back to the context from which the iterate() was originally called. This
is a bit of a problem. The solution is for there to be an implicit switch
back to the originating context. Now, even I'm not sure exactly how this
works, but if the cothread that's switched to actually returns, execution
returns back to the calling context, i.e. iterate_func().
COTHREAD_STOPPING is therefore set just before switching into this
(currently randomly chosen) context, on the assumption that it will return
promptly after finishing its duties. The burden of clearing the flag
falls to the various wrapper functions provided by the Bin code, thus
element writers don't have to worry about doing that at all (and simply
shouldn't).
Related changes:
All the sources in elements/ have been changed to reflect the new system.
FIXMEs:
1) gstpipeline.c calls gst_src_push at some point, dunno why, it's
commented out now.
2) any other sources, including vcdsrc, dvdsrc, and v4lsrc will break
badly and need to be modified to work as pull-based sources.
2000-12-04 10:52:30 +00:00
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
bin = GST_BIN (element);
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
old_state = GST_STATE (element);
|
|
|
|
pending = GST_STATE_PENDING (element);
|
2002-02-03 20:07:09 +00:00
|
|
|
transition = GST_STATE_TRANSITION (element);
|
2000-12-30 02:41:15 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "[%s]: changing childrens' state from %s to %s",
|
|
|
|
GST_ELEMENT_NAME (element),
|
|
|
|
gst_element_state_get_name (old_state), gst_element_state_get_name (pending));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-03-30 17:05:03 +00:00
|
|
|
if (pending == GST_STATE_VOID_PENDING)
|
|
|
|
return GST_STATE_SUCCESS;
|
|
|
|
|
2003-06-07 22:39:11 +00:00
|
|
|
if (old_state == pending)
|
|
|
|
{
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "[%s]: old and pending state are both %s, returning",
|
|
|
|
GST_ELEMENT_NAME (element), gst_element_state_get_name (pending));
|
2003-06-07 22:39:11 +00:00
|
|
|
return GST_STATE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
children = bin->children;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
while (children) {
|
2002-06-17 16:00:10 +00:00
|
|
|
GstElementState old_child_state;
|
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
child = GST_ELEMENT (children->data);
|
2001-12-04 22:12:50 +00:00
|
|
|
children = g_list_next (children);
|
|
|
|
|
2003-03-25 19:39:18 +00:00
|
|
|
if (GST_FLAG_IS_SET (child, GST_ELEMENT_LOCKED_STATE))
|
|
|
|
continue;
|
|
|
|
|
2002-06-17 16:00:10 +00:00
|
|
|
old_child_state = GST_STATE (child);
|
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
switch (gst_element_set_state (child, pending)) {
|
2000-07-17 17:14:15 +00:00
|
|
|
case GST_STATE_FAILURE:
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_STATES, "child '%s' failed to go to state %d(%s)",
|
2002-04-23 11:15:18 +00:00
|
|
|
GST_ELEMENT_NAME (child), pending, gst_element_state_get_name (pending));
|
2001-12-04 22:12:50 +00:00
|
|
|
|
2002-06-17 16:00:10 +00:00
|
|
|
gst_element_set_state (child, old_child_state);
|
2003-06-03 21:53:15 +00:00
|
|
|
/* FIXME, this is legacy code, a failed state change of a child should
|
|
|
|
* return a failure in all cases */
|
2001-12-04 22:12:50 +00:00
|
|
|
if (GST_ELEMENT_SCHED (child) == GST_ELEMENT_SCHED (element)) {
|
2003-04-08 21:50:32 +00:00
|
|
|
/* try to reset it to what is was */
|
2001-12-22 21:18:17 +00:00
|
|
|
GST_STATE_PENDING (element) = old_state;
|
2002-06-17 16:00:10 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
return GST_STATE_FAILURE;
|
2001-12-04 22:12:50 +00:00
|
|
|
}
|
2001-12-15 22:37:35 +00:00
|
|
|
break;
|
2000-07-17 17:14:15 +00:00
|
|
|
case GST_STATE_ASYNC:
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_STATES, "child '%s' is changing state asynchronously",
|
2001-12-15 22:37:35 +00:00
|
|
|
GST_ELEMENT_NAME (child));
|
2001-12-04 22:12:50 +00:00
|
|
|
have_async = TRUE;
|
2001-12-15 22:37:35 +00:00
|
|
|
break;
|
2002-10-29 21:34:14 +00:00
|
|
|
case GST_STATE_SUCCESS:
|
|
|
|
break;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "[%s]: done changing bin's state from %s to %s, now in %s",
|
|
|
|
GST_ELEMENT_NAME (element),
|
2002-04-23 11:15:18 +00:00
|
|
|
gst_element_state_get_name (old_state),
|
|
|
|
gst_element_state_get_name (pending),
|
|
|
|
gst_element_state_get_name (GST_STATE (element)));
|
2001-12-04 22:12:50 +00:00
|
|
|
|
|
|
|
if (have_async)
|
|
|
|
ret = GST_STATE_ASYNC;
|
2002-07-28 01:46:38 +00:00
|
|
|
else {
|
|
|
|
if (parent_class->change_state) {
|
|
|
|
ret = parent_class->change_state(element);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ret = GST_STATE_SUCCESS;
|
|
|
|
}
|
2001-03-07 21:52:56 +00:00
|
|
|
return ret;
|
2000-07-17 17:14:15 +00:00
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static GstElementStateReturn
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_change_state_norecurse (GstBin * bin)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2002-02-03 20:07:09 +00:00
|
|
|
GstElementStateReturn ret;
|
|
|
|
|
2002-07-28 01:46:38 +00:00
|
|
|
if (parent_class->change_state) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_STATES, "[%s]: setting bin's own state", GST_ELEMENT_NAME (bin));
|
2002-07-28 01:46:38 +00:00
|
|
|
ret = parent_class->change_state (GST_ELEMENT (bin));
|
2002-02-03 20:07:09 +00:00
|
|
|
|
|
|
|
return ret;
|
2001-12-15 22:37:35 +00:00
|
|
|
}
|
|
|
|
else
|
2000-07-17 17:14:15 +00:00
|
|
|
return GST_STATE_FAILURE;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_dispose (GObject * object)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
|
|
|
GstBin *bin = GST_BIN (object);
|
2001-05-25 21:00:07 +00:00
|
|
|
GList *children, *orig;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstElement *child;
|
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_REFCOUNTING, "dispose");
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-02-17 19:58:29 +00:00
|
|
|
if (gst_element_get_state (GST_ELEMENT (object)) == GST_STATE_PLAYING)
|
|
|
|
gst_element_set_state (GST_ELEMENT (object), GST_STATE_PAUSED);
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
if (bin->children) {
|
|
|
|
orig = children = g_list_copy (bin->children);
|
|
|
|
while (children) {
|
|
|
|
child = GST_ELEMENT (children->data);
|
|
|
|
gst_bin_remove (bin, child);
|
|
|
|
children = g_list_next (children);
|
|
|
|
}
|
|
|
|
g_list_free (bin->children);
|
2001-12-15 22:37:35 +00:00
|
|
|
g_list_free (orig);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
bin->children = NULL;
|
|
|
|
bin->numchildren = 0;
|
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_get_by_name:
|
|
|
|
* @bin: #Gstbin to search
|
|
|
|
* @name: the element name to search for
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the element with the given name from this bin.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
|
|
|
* Returns: the element with the given name
|
|
|
|
*/
|
2001-12-15 22:37:35 +00:00
|
|
|
GstElement *
|
|
|
|
gst_bin_get_by_name (GstBin * bin, const gchar * name)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GList *children;
|
|
|
|
GstElement *child;
|
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
g_return_val_if_fail (bin != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_PARENTAGE, "[%s]: looking up child element %s",
|
|
|
|
GST_ELEMENT_NAME (bin), name);
|
2000-12-30 02:41:15 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
children = bin->children;
|
|
|
|
while (children) {
|
2000-11-04 18:54:07 +00:00
|
|
|
child = GST_ELEMENT (children->data);
|
2001-12-15 22:37:35 +00:00
|
|
|
if (!strcmp (GST_OBJECT_NAME (child), name))
|
2000-01-30 09:03:00 +00:00
|
|
|
return child;
|
2000-11-04 18:54:07 +00:00
|
|
|
if (GST_IS_BIN (child)) {
|
|
|
|
GstElement *res = gst_bin_get_by_name (GST_BIN (child), name);
|
2001-12-15 22:37:35 +00:00
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
if (res)
|
2001-12-15 22:37:35 +00:00
|
|
|
return res;
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
2000-11-04 18:54:07 +00:00
|
|
|
children = g_list_next (children);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_get_by_name_recurse_up:
|
|
|
|
* @bin: #Gstbin to search
|
|
|
|
* @name: the element name to search for
|
|
|
|
*
|
|
|
|
* Get the element with the given name from this bin. If the
|
|
|
|
* element is not found, a recursion is performed on the parent bin.
|
|
|
|
*
|
|
|
|
* Returns: the element with the given name
|
|
|
|
*/
|
2001-12-15 22:37:35 +00:00
|
|
|
GstElement *
|
|
|
|
gst_bin_get_by_name_recurse_up (GstBin * bin, const gchar * name)
|
2001-01-29 00:06:02 +00:00
|
|
|
{
|
|
|
|
GstElement *result = NULL;
|
|
|
|
GstObject *parent;
|
|
|
|
|
|
|
|
g_return_val_if_fail (bin != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
|
|
|
result = gst_bin_get_by_name (bin, name);
|
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
if (!result) {
|
|
|
|
parent = gst_object_get_parent (GST_OBJECT (bin));
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2001-12-15 22:37:35 +00:00
|
|
|
if (parent && GST_IS_BIN (parent)) {
|
|
|
|
result = gst_bin_get_by_name_recurse_up (GST_BIN (parent), name);
|
|
|
|
}
|
2001-01-29 00:06:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_get_list:
|
|
|
|
* @bin: #Gstbin to get the list from
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the list of elements in this bin.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
|
|
|
* Returns: a GList of elements
|
|
|
|
*/
|
2002-04-19 19:49:41 +00:00
|
|
|
const GList *
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_get_list (GstBin * bin)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
return bin->children;
|
|
|
|
}
|
|
|
|
|
2003-12-16 19:35:26 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_get_by_interface:
|
|
|
|
* @bin: bin to find element in
|
|
|
|
* @interface: interface to be implemented by interface
|
|
|
|
*
|
|
|
|
* Looks for the first element inside the bin that implements the given
|
|
|
|
* interface. If such an element is found, it returns the element. You can
|
|
|
|
* cast this element to the given interface afterwards.
|
|
|
|
* If you want all elements that implement the interface, use
|
|
|
|
* gst_bin_get_all_by_interface(). The function recurses bins inside bins.
|
|
|
|
*
|
|
|
|
* Returns: An element inside the bin implementing the interface.
|
|
|
|
*/
|
|
|
|
GstElement *
|
gst/gstpad.c (_gst_real_pad_fixate_accumulator): s/pointer/boxed/.
Original commit message from CVS:
2004-02-05 Andy Wingo <wingo@pobox.com>
* gst/gstpad.c (_gst_real_pad_fixate_accumulator):
s/pointer/boxed/.
* gst/gstmarshal.list (VOID:BOXED, BOXED:BOXED): New marshallers.
* gst/gstpad.c (gst_real_pad_class_init): Use a BOXED:BOXED
marshaller for ::fixate, and VOID:BOXED for ::caps-nego-failed,
with the type=GST_TYPE_CAPS. This allows language bindings to know
what kind of data they're dealing with.
* gst/gstcaps.c (_gst_caps_value_init): GBoxed values initialize
to NULL when g_value_init is called. GstCaps, which rolls its own
type implementation, now does the same instead of allocating empty
caps.
(_gst_caps_initialize, _gst_caps_collect_value,
_gst_caps_lcopy_value): Provide collect_value and lcopy_value type
table methods. This allows G_VALUE_COLLECT to work.
2004-02-05 Andy Wingo <wingo@pobox.com>
* configure.ac:
* testsuite/Makefile.am (SUBDIRS):
* testsuite/ghostpads/Makefile.am:
* testsuite/ghostpads/ghostpads.c: A new test for ghost pads.
* gst/gstpad.c (gst_pad_add_ghost_pad, gst_pad_remove_ghost_pad):
These two routines are the only ones that set
GST_GPAD_REALPAD(gpad), the ghost pad list, and the ghost pad's
pad template. They should be made static, depending on ABI needs.
(gst_real_pad_dispose): Handle the case of ghost pads without a
parent. Assert after dealing with ghost pads that the ghost pad
list is empty.
(gst_ghost_pad_class_init): New property added, ::real-pad. Can be
set after creation.
(gst_ghost_pad_dispose): Set ::real-pad to NULL.
(gst_ghost_pad_set_property, gst_ghost_pad_get_property): New
functions. set_property will call add_ghost_pad/remove_ghost_pad
as appropriate.
(gst_ghost_pad_new): All the work is offloaded to g_object_new.
* gst/gstelement.c (gst_element_add_pad): Handle ghost pads as well.
(gst_element_add_ghost_pad): Remove code duplicated from _add_pad.
(gst_element_remove_pad): Handle ghost pads as well.
(gst_element_remove_ghost_pad): Deprecated (could be removed,
depending on API-stability needs).
2004-02-05 Andy Wingo <wingo@pobox.com>
* gst/gstbin.[ch]: (gst_bin_get_by_interface): GTypes are scalars,
of course they're const
2004-02-05 13:51:26 +00:00
|
|
|
gst_bin_get_by_interface (GstBin *bin, GType interface)
|
2003-12-16 19:35:26 +00:00
|
|
|
{
|
|
|
|
GList *walk;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
|
|
|
g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface), NULL);
|
|
|
|
|
|
|
|
walk = bin->children;
|
|
|
|
while (walk) {
|
|
|
|
if (G_TYPE_CHECK_INSTANCE_TYPE (walk->data, interface))
|
|
|
|
return GST_ELEMENT (walk->data);
|
|
|
|
if (GST_IS_BIN (walk->data)) {
|
|
|
|
GstElement *ret;
|
|
|
|
ret = gst_bin_get_by_interface (GST_BIN (walk->data), interface);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
walk = g_list_next (walk);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_bin_get_all_by_interface:
|
|
|
|
* @bin: bin to find elements in
|
|
|
|
* @interface: interface to be implemented by interface
|
|
|
|
*
|
|
|
|
* Looks for all element inside the bin that implements the given
|
|
|
|
* interface. You can safely cast all returned elements to the given interface.
|
|
|
|
* The function recurses bins inside bins. You need to free the list using
|
|
|
|
* g_list_free() after use.
|
|
|
|
*
|
|
|
|
* Returns: An element inside the bin implementing the interface.
|
|
|
|
*/
|
|
|
|
GList *
|
gst/gstpad.c (_gst_real_pad_fixate_accumulator): s/pointer/boxed/.
Original commit message from CVS:
2004-02-05 Andy Wingo <wingo@pobox.com>
* gst/gstpad.c (_gst_real_pad_fixate_accumulator):
s/pointer/boxed/.
* gst/gstmarshal.list (VOID:BOXED, BOXED:BOXED): New marshallers.
* gst/gstpad.c (gst_real_pad_class_init): Use a BOXED:BOXED
marshaller for ::fixate, and VOID:BOXED for ::caps-nego-failed,
with the type=GST_TYPE_CAPS. This allows language bindings to know
what kind of data they're dealing with.
* gst/gstcaps.c (_gst_caps_value_init): GBoxed values initialize
to NULL when g_value_init is called. GstCaps, which rolls its own
type implementation, now does the same instead of allocating empty
caps.
(_gst_caps_initialize, _gst_caps_collect_value,
_gst_caps_lcopy_value): Provide collect_value and lcopy_value type
table methods. This allows G_VALUE_COLLECT to work.
2004-02-05 Andy Wingo <wingo@pobox.com>
* configure.ac:
* testsuite/Makefile.am (SUBDIRS):
* testsuite/ghostpads/Makefile.am:
* testsuite/ghostpads/ghostpads.c: A new test for ghost pads.
* gst/gstpad.c (gst_pad_add_ghost_pad, gst_pad_remove_ghost_pad):
These two routines are the only ones that set
GST_GPAD_REALPAD(gpad), the ghost pad list, and the ghost pad's
pad template. They should be made static, depending on ABI needs.
(gst_real_pad_dispose): Handle the case of ghost pads without a
parent. Assert after dealing with ghost pads that the ghost pad
list is empty.
(gst_ghost_pad_class_init): New property added, ::real-pad. Can be
set after creation.
(gst_ghost_pad_dispose): Set ::real-pad to NULL.
(gst_ghost_pad_set_property, gst_ghost_pad_get_property): New
functions. set_property will call add_ghost_pad/remove_ghost_pad
as appropriate.
(gst_ghost_pad_new): All the work is offloaded to g_object_new.
* gst/gstelement.c (gst_element_add_pad): Handle ghost pads as well.
(gst_element_add_ghost_pad): Remove code duplicated from _add_pad.
(gst_element_remove_pad): Handle ghost pads as well.
(gst_element_remove_ghost_pad): Deprecated (could be removed,
depending on API-stability needs).
2004-02-05 Andy Wingo <wingo@pobox.com>
* gst/gstbin.[ch]: (gst_bin_get_by_interface): GTypes are scalars,
of course they're const
2004-02-05 13:51:26 +00:00
|
|
|
gst_bin_get_all_by_interface (GstBin *bin, GType interface)
|
2003-12-16 19:35:26 +00:00
|
|
|
{
|
|
|
|
GList *walk, *ret = NULL;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), NULL);
|
|
|
|
g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface), NULL);
|
|
|
|
|
|
|
|
walk = bin->children;
|
|
|
|
while (walk) {
|
|
|
|
if (G_TYPE_CHECK_INSTANCE_TYPE (walk->data, interface))
|
|
|
|
ret = g_list_prepend (ret, walk->data);
|
|
|
|
if (GST_IS_BIN (walk->data)) {
|
|
|
|
ret = g_list_concat (ret,
|
|
|
|
gst_bin_get_all_by_interface (GST_BIN (walk->data), interface));
|
|
|
|
}
|
|
|
|
walk = g_list_next (walk);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2003-04-18 23:34:21 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_sync_children_state:
|
|
|
|
* @bin: #Gstbin to sync state
|
|
|
|
*
|
|
|
|
* Tries to set the state of the children of this bin to the same state of the
|
|
|
|
* bin by calling gst_element_set_state for each child not already having a
|
|
|
|
* synchronized state.
|
|
|
|
*
|
|
|
|
* Returns: The worst return value of any gst_element_set_state. So if one child
|
|
|
|
* returns #GST_STATE_FAILURE while all others return #GST_STATE_SUCCESS
|
|
|
|
* this function returns #GST_STATE_FAILURE.
|
|
|
|
*/
|
|
|
|
GstElementStateReturn
|
|
|
|
gst_bin_sync_children_state (GstBin *bin)
|
|
|
|
{
|
|
|
|
GList *children;
|
|
|
|
GstElement *element;
|
|
|
|
GstElementState state;
|
|
|
|
GstElementStateReturn ret = GST_STATE_SUCCESS;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), GST_STATE_FAILURE);
|
|
|
|
|
|
|
|
state = GST_STATE (bin);
|
|
|
|
children = bin->children;
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_STATES, "syncing state of children with bin \"%s\"'s state %s",
|
2003-04-18 23:34:21 +00:00
|
|
|
GST_ELEMENT_NAME (bin), gst_element_state_get_name (state));
|
|
|
|
|
|
|
|
while (children) {
|
|
|
|
element = GST_ELEMENT (children->data);
|
|
|
|
children = children->next;
|
|
|
|
if (GST_STATE(element) != state) {
|
|
|
|
switch (gst_element_set_state (element, state)) {
|
|
|
|
case GST_STATE_SUCCESS:
|
|
|
|
break;
|
|
|
|
case GST_STATE_ASYNC:
|
|
|
|
if (ret == GST_STATE_SUCCESS)
|
|
|
|
ret = GST_STATE_ASYNC;
|
|
|
|
break;
|
|
|
|
case GST_STATE_FAILURE:
|
|
|
|
ret = GST_STATE_FAILURE;
|
|
|
|
default:
|
|
|
|
/* make sure gst_element_set_state never returns this */
|
|
|
|
g_assert_not_reached ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-01-20 03:10:44 +00:00
|
|
|
static xmlNodePtr
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_save_thyself (GstObject * object, xmlNodePtr parent)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-01-29 00:06:02 +00:00
|
|
|
GstBin *bin = GST_BIN (object);
|
|
|
|
xmlNodePtr childlist, elementnode;
|
2000-01-30 09:03:00 +00:00
|
|
|
GList *children;
|
|
|
|
GstElement *child;
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
if (GST_OBJECT_CLASS (parent_class)->save_thyself)
|
|
|
|
GST_OBJECT_CLASS (parent_class)->save_thyself (GST_OBJECT (bin), parent);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
childlist = xmlNewChild (parent, NULL, "children", NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_XML, "[%s]: saving %d children",
|
|
|
|
GST_ELEMENT_NAME (bin), bin->numchildren);
|
2000-12-30 02:41:15 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
children = bin->children;
|
|
|
|
while (children) {
|
2000-11-04 18:54:07 +00:00
|
|
|
child = GST_ELEMENT (children->data);
|
2001-01-29 00:06:02 +00:00
|
|
|
elementnode = xmlNewChild (childlist, NULL, "element", NULL);
|
|
|
|
gst_object_save_thyself (GST_OBJECT (child), elementnode);
|
2000-11-04 18:54:07 +00:00
|
|
|
children = g_list_next (children);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2000-09-27 19:33:10 +00:00
|
|
|
return childlist;
|
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_restore_thyself (GstObject * object, xmlNodePtr self)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-01-29 00:06:02 +00:00
|
|
|
GstBin *bin = GST_BIN (object);
|
|
|
|
xmlNodePtr field = self->xmlChildrenNode;
|
2000-09-27 19:33:10 +00:00
|
|
|
xmlNodePtr childlist;
|
|
|
|
|
|
|
|
while (field) {
|
2000-11-04 18:54:07 +00:00
|
|
|
if (!strcmp (field->name, "children")) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_INFO (GST_CAT_XML, "[%s]: loading children", GST_ELEMENT_NAME (object));
|
2001-01-18 11:16:53 +00:00
|
|
|
childlist = field->xmlChildrenNode;
|
2000-09-27 19:33:10 +00:00
|
|
|
while (childlist) {
|
2001-12-15 22:37:35 +00:00
|
|
|
if (!strcmp (childlist->name, "element")) {
|
2002-01-11 15:49:47 +00:00
|
|
|
GstElement *element = gst_xml_make_element (childlist, GST_OBJECT (bin));
|
|
|
|
|
|
|
|
/* it had to be parented to find the pads, now we ref and unparent so
|
|
|
|
* we can add it to the bin */
|
|
|
|
gst_object_ref (GST_OBJECT (element));
|
|
|
|
gst_object_unparent (GST_OBJECT (element));
|
|
|
|
|
2000-11-04 18:54:07 +00:00
|
|
|
gst_bin_add (bin, element);
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
2001-12-15 22:37:35 +00:00
|
|
|
childlist = childlist->next;
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
field = field->next;
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
#endif /* GST_DISABLE_LOADSAVE */
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
static gboolean
|
2001-12-15 22:37:35 +00:00
|
|
|
gst_bin_iterate_func (GstBin * bin)
|
2001-12-04 22:12:50 +00:00
|
|
|
{
|
2001-12-14 22:59:21 +00:00
|
|
|
/* only iterate if this is the manager bin */
|
2002-01-18 22:44:19 +00:00
|
|
|
if (GST_ELEMENT_SCHED (bin) &&
|
|
|
|
GST_ELEMENT_SCHED (bin)->parent == GST_ELEMENT (bin)) {
|
2001-12-24 15:14:03 +00:00
|
|
|
GstSchedulerState state;
|
|
|
|
|
|
|
|
state = gst_scheduler_iterate (GST_ELEMENT_SCHED (bin));
|
|
|
|
|
|
|
|
if (state == GST_SCHEDULER_STATE_RUNNING) {
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else if (state == GST_SCHEDULER_STATE_ERROR) {
|
|
|
|
gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PAUSED);
|
|
|
|
}
|
2001-12-15 22:37:35 +00:00
|
|
|
}
|
|
|
|
else {
|
2002-09-15 18:20:41 +00:00
|
|
|
g_warning ("bin \"%s\" is not the managing bin, can't be iterated on!\n",
|
|
|
|
GST_ELEMENT_NAME (bin));
|
2001-12-04 22:12:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
2000-08-14 10:55:35 +00:00
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_bin_iterate:
|
2002-09-12 18:55:21 +00:00
|
|
|
* @bin: a#GstBin to iterate.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Iterates over the elements in this bin.
|
2001-01-21 23:20:46 +00:00
|
|
|
*
|
2002-09-12 18:55:21 +00:00
|
|
|
* Returns: TRUE if the bin did something useful. This value
|
2001-01-21 23:20:46 +00:00
|
|
|
* can be used to determine it the bin is in EOS.
|
2000-03-27 19:53:43 +00:00
|
|
|
*/
|
2001-01-20 17:59:25 +00:00
|
|
|
gboolean
|
2002-09-12 18:55:21 +00:00
|
|
|
gst_bin_iterate (GstBin *bin)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2003-10-14 00:00:37 +00:00
|
|
|
gboolean running;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-03-18 04:41:37 +00:00
|
|
|
g_return_val_if_fail (bin != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_BIN (bin), FALSE);
|
|
|
|
|
2003-10-14 00:00:37 +00:00
|
|
|
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, bin, "starting iteration");
|
2001-01-20 03:10:44 +00:00
|
|
|
|
2003-02-27 18:18:32 +00:00
|
|
|
gst_object_ref (GST_OBJECT (bin));
|
|
|
|
|
2003-10-14 00:00:37 +00:00
|
|
|
running = FALSE;
|
|
|
|
g_signal_emit (G_OBJECT (bin), gst_bin_signals[ITERATE], 0, &running);
|
2002-06-10 16:48:47 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, bin, "finished iteration");
|
2001-01-20 17:59:25 +00:00
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
if (!running) {
|
2002-09-12 18:55:21 +00:00
|
|
|
if (GST_STATE (bin) == GST_STATE_PLAYING &&
|
|
|
|
GST_STATE_PENDING (bin) == GST_STATE_VOID_PENDING) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_CAT_DEBUG (GST_CAT_DATAFLOW, "[%s]: polling for child shutdown after useless iteration",
|
|
|
|
GST_ELEMENT_NAME (bin));
|
|
|
|
g_usleep (1);
|
2002-06-03 19:50:41 +00:00
|
|
|
running = TRUE;
|
2001-12-04 22:12:50 +00:00
|
|
|
}
|
|
|
|
}
|
2003-02-27 18:18:32 +00:00
|
|
|
gst_object_unref (GST_OBJECT (bin));
|
2001-11-14 21:06:15 +00:00
|
|
|
|
|
|
|
return running;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2002-06-10 16:48:47 +00:00
|
|
|
|