2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
*
|
|
|
|
* gstelement.c: The base element, all elements derive from this
|
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
|
|
|
//#define GST_DEBUG_ENABLED
|
|
|
|
#include "gst_private.h"
|
|
|
|
|
2000-12-15 01:57:34 +00:00
|
|
|
#include "gstelement.h"
|
|
|
|
#include "gstextratypes.h"
|
2001-01-13 13:51:08 +00:00
|
|
|
#include "gstbin.h"
|
2001-05-25 21:00:07 +00:00
|
|
|
#include "gstscheduler.h"
|
2001-03-03 17:38:26 +00:00
|
|
|
#include "gstutils.h"
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* Element signals and args */
|
|
|
|
enum {
|
|
|
|
STATE_CHANGE,
|
|
|
|
NEW_PAD,
|
2001-05-25 21:00:07 +00:00
|
|
|
PAD_REMOVED,
|
2000-01-30 09:03:00 +00:00
|
|
|
NEW_GHOST_PAD,
|
2001-05-25 21:00:07 +00:00
|
|
|
GHOST_PAD_REMOVED,
|
2000-01-30 09:03:00 +00:00
|
|
|
ERROR,
|
2000-12-29 02:28:04 +00:00
|
|
|
EOS,
|
2000-01-30 09:03:00 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
ARG_0,
|
|
|
|
/* FILL ME */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
static void gst_element_class_init (GstElementClass *klass);
|
|
|
|
static void gst_element_init (GstElement *element);
|
2001-05-26 22:58:15 +00:00
|
|
|
static void gst_element_base_class_init (GstElementClass *klass);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-08-21 20:16:48 +00:00
|
|
|
static void gst_element_set_property (GObject *object, guint prop_id,
|
|
|
|
const GValue *value, GParamSpec *pspec);
|
|
|
|
static void gst_element_get_property (GObject *object, guint prop_id, GValue *value,
|
|
|
|
GParamSpec *pspec);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
static void gst_element_shutdown (GObject *object);
|
|
|
|
static void gst_element_real_destroy (GObject *object);
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
static GstElementStateReturn gst_element_change_state (GstElement *element);
|
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-01-29 00:06:02 +00:00
|
|
|
static xmlNodePtr gst_element_save_thyself (GstObject *object, xmlNodePtr parent);
|
2001-06-24 21:18:28 +00:00
|
|
|
GstElement* gst_element_restore_thyself (xmlNodePtr self, GstObject *parent);
|
|
|
|
#endif
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-09-30 22:01:14 +00:00
|
|
|
GType _gst_element_type = 0;
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
static GstObjectClass *parent_class = NULL;
|
|
|
|
static guint gst_element_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
2001-09-30 22:01:14 +00:00
|
|
|
GType gst_element_get_type (void)
|
|
|
|
{
|
|
|
|
if (!_gst_element_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo element_info = {
|
2000-01-30 09:03:00 +00:00
|
|
|
sizeof(GstElementClass),
|
2001-06-25 01:20:11 +00:00
|
|
|
(GBaseInitFunc)gst_element_base_class_init,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_element_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstElement),
|
|
|
|
0,
|
|
|
|
(GInstanceInitFunc)gst_element_init,
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
2001-09-30 22:01:14 +00:00
|
|
|
_gst_element_type = g_type_register_static(GST_TYPE_OBJECT, "GstElement", &element_info, G_TYPE_FLAG_ABSTRACT);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-09-30 22:01:14 +00:00
|
|
|
return _gst_element_type;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
|
|
|
gst_element_class_init (GstElementClass *klass)
|
2000-11-11 15:13:50 +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
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*) klass;
|
2001-01-29 00:06:02 +00:00
|
|
|
gstobject_class = (GstObjectClass*) 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_OBJECT);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
gst_element_signals[STATE_CHANGE] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("state_change", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, state_change), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__INT, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_INT);
|
2000-01-30 09:03:00 +00:00
|
|
|
gst_element_signals[NEW_PAD] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("new_pad", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, new_pad), NULL, NULL,
|
2001-09-12 22:53:56 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
|
2000-11-11 15:13:50 +00:00
|
|
|
GST_TYPE_PAD);
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_element_signals[PAD_REMOVED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("pad_removed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, pad_removed), NULL, NULL,
|
2001-09-12 22:53:56 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_TYPE_PAD);
|
2000-01-30 09:03:00 +00:00
|
|
|
gst_element_signals[NEW_GHOST_PAD] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("new_ghost_pad", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, new_ghost_pad), NULL, NULL,
|
2001-09-12 22:53:56 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
|
2000-11-11 15:13:50 +00:00
|
|
|
GST_TYPE_PAD);
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_element_signals[GHOST_PAD_REMOVED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("ghost_pad_removed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, ghost_pad_removed), NULL, NULL,
|
2001-09-12 22:53:56 +00:00
|
|
|
gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_TYPE_PAD);
|
2000-01-30 09:03:00 +00:00
|
|
|
gst_element_signals[ERROR] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("error", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass, error), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__STRING, G_TYPE_NONE,1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_STRING);
|
2000-12-29 02:28:04 +00:00
|
|
|
gst_element_signals[EOS] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("eos", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstElementClass,eos), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_element_set_property);
|
|
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_element_get_property);
|
2001-08-13 19:00:13 +00:00
|
|
|
// gobject_class->shutdown = GST_DEBUG_FUNCPTR(gst_element_shutdown);
|
2001-06-25 01:20:11 +00:00
|
|
|
// FIXME!
|
|
|
|
// gobject_class->destroy = GST_DEBUG_FUNCPTR(gst_element_real_destroy);
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-05-25 21:00:07 +00:00
|
|
|
gstobject_class->save_thyself = GST_DEBUG_FUNCPTR(gst_element_save_thyself);
|
|
|
|
gstobject_class->restore_thyself = GST_DEBUG_FUNCPTR(gst_element_restore_thyself);
|
2001-06-24 21:18:28 +00:00
|
|
|
#endif
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
klass->change_state = GST_DEBUG_FUNCPTR(gst_element_change_state);
|
2000-12-28 00:18:26 +00:00
|
|
|
klass->elementfactory = NULL;
|
2001-07-11 12:33:17 +00:00
|
|
|
klass->padtemplates = NULL;
|
|
|
|
klass->numpadtemplates = 0;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-26 22:58:15 +00:00
|
|
|
static void
|
|
|
|
gst_element_base_class_init (GstElementClass *klass)
|
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2001-05-26 22:58:15 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*) klass;
|
2001-05-26 22:58:15 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_element_set_property);
|
|
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_element_get_property);
|
2001-05-26 22:58:15 +00:00
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
|
|
|
gst_element_init (GstElement *element)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-07-17 17:14:15 +00:00
|
|
|
element->current_state = GST_STATE_NULL;
|
|
|
|
element->pending_state = -1;
|
2000-01-30 09:03:00 +00:00
|
|
|
element->numpads = 0;
|
2000-12-20 09:39:43 +00:00
|
|
|
element->numsrcpads = 0;
|
|
|
|
element->numsinkpads = 0;
|
2000-01-30 09:03:00 +00:00
|
|
|
element->pads = NULL;
|
|
|
|
element->loopfunc = NULL;
|
Another big set of changes. Connections are now also pullfunc based. gstqueue has been updated, I don't know of any ...
Original commit message from CVS:
Another big set of changes. Connections are now also pullfunc based.
gstqueue has been updated, I don't know of any other connections offhand.
There are still a few things that need doing, specifically the concept
of a source or connection with connections to multiple thread contexts is
not dealt with. This may force us to move the threadstate from the
element to the pad, maybe keeping the element's copy for simple cases.
Then the Bin would create a structure to pass to the cothreaded _wrappers
of any such elements, which would detail the pads that are to be dealt with
by this particular cothread context.
That will speed things up to, since we don't have to look through the list
of all pads for every Src or Connection element for every iteration, we can
simply step through the list provided by the plan. Special case might even
have a single pad pointer sitting there to trump the list, if there's only
one (the common case anyway).
Task 23098 is tracking these changes. The main task 22588 depends on that
subtask, as well as 22240, which is a consistency check on PAD_DISABLED.
2000-12-08 10:33:01 +00:00
|
|
|
element->threadstate = NULL;
|
2001-05-25 21:00:07 +00:00
|
|
|
element->sched = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_element_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GstElementClass *oclass = (GstElementClass *)G_OBJECT_GET_CLASS(object);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_SCHEDULE_LOCK_ELEMENT ( GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
if (oclass->set_property)
|
|
|
|
(oclass->set_property)(object,prop_id,value,pspec);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_SCHEDULE_UNLOCK_ELEMENT ( GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2001-06-25 17:22:58 +00:00
|
|
|
gst_element_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GstElementClass *oclass = (GstElementClass *)G_OBJECT_GET_CLASS(object);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_SCHEDULE_LOCK_ELEMENT (GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
if (oclass->get_property)
|
|
|
|
(oclass->get_property)(object,prop_id,value,pspec);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_SCHEDULE_UNLOCK_ELEMENT (GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
/**
|
|
|
|
* gst_element_set_name:
|
|
|
|
* @element: GstElement to set name of
|
|
|
|
* @name: new name of element
|
|
|
|
*
|
|
|
|
* Set the name of the element, getting rid of the old name if there was
|
|
|
|
* one.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_element_set_name (GstElement *element, const gchar *name)
|
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (name != NULL);
|
|
|
|
|
|
|
|
gst_object_set_name (GST_OBJECT (element), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_element_get_name:
|
|
|
|
* @element: GstElement to get name of
|
|
|
|
*
|
|
|
|
* Get the name of the element.
|
|
|
|
*
|
|
|
|
* Returns: name of the element
|
|
|
|
*/
|
|
|
|
const gchar*
|
|
|
|
gst_element_get_name (GstElement *element)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
|
|
|
|
return GST_OBJECT_NAME (element);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_element_set_parent:
|
|
|
|
* @element: GstElement to set parent of
|
2001-01-31 20:27:00 +00:00
|
|
|
* @parent: new parent of the object
|
2001-01-29 00:06:02 +00:00
|
|
|
*
|
|
|
|
* Set the parent of the element.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_element_set_parent (GstElement *element, GstObject *parent)
|
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (GST_OBJECT_PARENT (element) == NULL);
|
|
|
|
g_return_if_fail (parent != NULL);
|
2001-06-25 01:20:11 +00:00
|
|
|
g_return_if_fail (GST_IS_OBJECT (parent));
|
2001-01-29 00:06:02 +00:00
|
|
|
g_return_if_fail ((gpointer)element != (gpointer)parent);
|
|
|
|
|
|
|
|
gst_object_set_parent (GST_OBJECT (element), parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_element_get_parent:
|
|
|
|
* @element: GstElement to get the parent of
|
|
|
|
*
|
|
|
|
* Get the parent of the element.
|
|
|
|
*
|
|
|
|
* Returns: parent of the element
|
|
|
|
*/
|
|
|
|
GstObject*
|
|
|
|
gst_element_get_parent (GstElement *element)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
|
|
|
|
return GST_OBJECT_PARENT (element);
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_element_add_pad:
|
|
|
|
* @element: element to add pad to
|
|
|
|
* @pad: pad to add
|
|
|
|
*
|
|
|
|
* Add a pad (connection point) to the element, setting the parent of the
|
|
|
|
* pad to the element (and thus adding a reference).
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
|
|
|
gst_element_add_pad (GstElement *element, GstPad *pad)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
// first check to make sure the pad's parent is already set
|
|
|
|
g_return_if_fail (GST_PAD_PARENT (pad) == NULL);
|
|
|
|
|
|
|
|
// then check to see if there's already a pad by that name here
|
|
|
|
g_return_if_fail (gst_object_check_uniqueness (element->pads, GST_PAD_NAME(pad)) == TRUE);
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/* set the pad's parent */
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_ELEMENT_PADS,"setting parent of pad '%s' to '%s'\n",
|
|
|
|
GST_PAD_NAME (pad), GST_ELEMENT_NAME (element));
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_set_parent (GST_OBJECT (pad), GST_OBJECT (element));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* add it to the list */
|
2000-11-11 15:13:50 +00:00
|
|
|
element->pads = g_list_append (element->pads, pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
element->numpads++;
|
2000-12-20 09:39:43 +00:00
|
|
|
if (gst_pad_get_direction (pad) == GST_PAD_SRC)
|
|
|
|
element->numsrcpads++;
|
|
|
|
else
|
|
|
|
element->numsinkpads++;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* emit the NEW_PAD signal */
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[NEW_PAD], 0, pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
/**
|
|
|
|
* gst_element_remove_pad:
|
|
|
|
* @element: element to remove pad from
|
|
|
|
* @pad: pad to remove
|
|
|
|
*
|
|
|
|
* Remove a pad (connection point) from the element,
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_element_remove_pad (GstElement *element, GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
|
|
|
|
|
|
|
g_return_if_fail (GST_PAD_PARENT (pad) == element);
|
|
|
|
|
|
|
|
/* add it to the list */
|
|
|
|
element->pads = g_list_remove (element->pads, pad);
|
|
|
|
element->numpads--;
|
|
|
|
if (gst_pad_get_direction (pad) == GST_PAD_SRC)
|
|
|
|
element->numsrcpads--;
|
|
|
|
else
|
|
|
|
element->numsinkpads--;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[PAD_REMOVED], 0, pad);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
gst_object_unparent (GST_OBJECT (pad));
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_element_add_ghost_pad:
|
|
|
|
* @element: element to add ghost pad to
|
2001-01-20 02:57:46 +00:00
|
|
|
* @pad: pad from which the new ghost pad will be created
|
|
|
|
* @name: name of the new ghost pad
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
2001-01-20 02:57:46 +00:00
|
|
|
* Create a ghost pad from the given pad, and add it to the list of pads
|
|
|
|
* for this element.
|
2000-01-30 09:03:00 +00:00
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
|
|
|
gst_element_add_ghost_pad (GstElement *element, GstPad *pad, gchar *name)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2001-01-20 02:57:46 +00:00
|
|
|
GstPad *ghostpad;
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
// then check to see if there's already a pad by that name here
|
|
|
|
g_return_if_fail (gst_object_check_uniqueness (element->pads, name) == TRUE);
|
|
|
|
|
|
|
|
GST_DEBUG(GST_CAT_ELEMENT_PADS,"creating new ghost pad called %s, from pad %s:%s\n",
|
|
|
|
name,GST_DEBUG_PAD_NAME(pad));
|
2001-01-20 02:57:46 +00:00
|
|
|
ghostpad = gst_ghost_pad_new (name, pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* add it to the list */
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_ELEMENT_PADS,"adding ghost pad %s to element %s\n",
|
|
|
|
name, GST_ELEMENT_NAME (element));
|
2001-01-20 02:57:46 +00:00
|
|
|
element->pads = g_list_append (element->pads, ghostpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
element->numpads++;
|
2001-01-20 02:57:46 +00:00
|
|
|
// set the parent of the ghostpad
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_set_parent (GST_OBJECT (ghostpad), GST_OBJECT (element));
|
2001-01-20 02:57:46 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_ELEMENT_PADS,"added ghostpad %s:%s\n",GST_DEBUG_PAD_NAME(ghostpad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-12-31 22:18:05 +00:00
|
|
|
/* emit the NEW_GHOST_PAD signal */
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[NEW_GHOST_PAD], 0, ghostpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-01 17:25:43 +00:00
|
|
|
/**
|
|
|
|
* gst_element_remove_ghost_pad:
|
|
|
|
* @element: element to remove the ghost pad from
|
|
|
|
* @pad: ghost pad to remove
|
|
|
|
*
|
|
|
|
* removes a ghost pad from an element
|
2001-01-20 03:10:44 +00:00
|
|
|
*
|
2001-01-01 17:25:43 +00:00
|
|
|
*/
|
2000-12-31 22:18:05 +00:00
|
|
|
void
|
|
|
|
gst_element_remove_ghost_pad (GstElement *element, GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
g_return_if_fail (pad != NULL);
|
2001-07-11 12:33:17 +00:00
|
|
|
g_return_if_fail (GST_IS_GHOST_PAD (pad));
|
2000-12-31 22:18:05 +00:00
|
|
|
|
2001-01-20 02:57:46 +00:00
|
|
|
// FIXME this is redundant?
|
2001-07-11 12:33:17 +00:00
|
|
|
// wingo 10-july-2001: I don't think so, you have to actually remove the pad
|
|
|
|
// from the element. gst_pad_remove_ghost_pad just removes the ghostpad from
|
|
|
|
// the real pad's ghost pad list
|
|
|
|
gst_pad_remove_ghost_pad (GST_PAD (GST_PAD_REALIZE (pad)), pad);
|
|
|
|
gst_element_remove_pad (element, pad);
|
2000-12-31 22:18:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_element_get_pad:
|
|
|
|
* @element: element to find pad of
|
|
|
|
* @name: name of pad to retrieve
|
|
|
|
*
|
|
|
|
* Retrieve a pad from the element by name.
|
|
|
|
*
|
|
|
|
* Returns: requested pad if found, otherwise NULL.
|
|
|
|
*/
|
2000-11-11 15:13:50 +00:00
|
|
|
GstPad*
|
2001-01-20 03:10:44 +00:00
|
|
|
gst_element_get_pad (GstElement *element, const gchar *name)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GList *walk;
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
2001-01-03 20:44:28 +00:00
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
|
|
|
// if there aren't any pads, well, we're not likely to find one
|
2000-01-30 09:03:00 +00:00
|
|
|
if (!element->numpads)
|
|
|
|
return NULL;
|
|
|
|
|
2001-01-03 20:44:28 +00:00
|
|
|
// look through the list, matching by name
|
2000-01-30 09:03:00 +00:00
|
|
|
walk = element->pads;
|
|
|
|
while (walk) {
|
2001-01-29 00:06:02 +00:00
|
|
|
GstPad *pad = GST_PAD(walk->data);
|
2001-05-25 21:00:07 +00:00
|
|
|
if (!strcmp (GST_PAD_NAME(pad), name)) {
|
|
|
|
GST_INFO(GST_CAT_ELEMENT_PADS,"found pad %s:%s",GST_DEBUG_PAD_NAME(pad));
|
2001-01-29 00:06:02 +00:00
|
|
|
return pad;
|
2001-01-03 20:44:28 +00:00
|
|
|
}
|
2000-11-11 15:13:50 +00:00
|
|
|
walk = g_list_next (walk);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO(GST_CAT_ELEMENT_PADS,"no such pad '%s' in element \"%s\"",name,GST_ELEMENT_NAME(element));
|
2000-01-30 09:03:00 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_element_get_pad_list:
|
|
|
|
* @element: element to get pads of
|
|
|
|
*
|
|
|
|
* Retrieve a list of the pads associated with the element.
|
|
|
|
*
|
2000-03-27 19:53:43 +00:00
|
|
|
* Returns: GList of pads
|
2000-01-30 09:03:00 +00:00
|
|
|
*/
|
2000-11-11 15:13:50 +00:00
|
|
|
GList*
|
2001-01-20 03:10:44 +00:00
|
|
|
gst_element_get_pad_list (GstElement *element)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* return the list of pads */
|
2000-01-30 09:03:00 +00:00
|
|
|
return element->pads;
|
|
|
|
}
|
|
|
|
|
2001-07-11 12:33:17 +00:00
|
|
|
/**
|
|
|
|
* gst_element_class_add_padtemplate:
|
|
|
|
* @klass: element class to add padtemplate to
|
|
|
|
* @templ: padtemplate to add
|
|
|
|
*
|
|
|
|
* Add a padtemplate to an element class. This is useful if you have derived a custom
|
|
|
|
* bin and wish to provide an on-request pad at runtime. Plugin writers should use
|
|
|
|
* gst_elementfactory_add_padtemplate instead.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_element_class_add_padtemplate (GstElementClass *klass, GstPadTemplate *templ)
|
|
|
|
{
|
|
|
|
g_return_if_fail (klass != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT_CLASS (klass));
|
|
|
|
g_return_if_fail (templ != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PADTEMPLATE (templ));
|
|
|
|
|
|
|
|
klass->padtemplates = g_list_append (klass->padtemplates, templ);
|
|
|
|
klass->numpadtemplates++;
|
|
|
|
}
|
|
|
|
|
2000-12-28 00:18:26 +00:00
|
|
|
/**
|
|
|
|
* gst_element_get_padtemplate_list:
|
|
|
|
* @element: element to get padtemplates of
|
|
|
|
*
|
|
|
|
* Retrieve a list of the padtemplates associated with the element.
|
|
|
|
*
|
|
|
|
* Returns: GList of padtemplates
|
|
|
|
*/
|
|
|
|
GList*
|
|
|
|
gst_element_get_padtemplate_list (GstElement *element)
|
|
|
|
{
|
|
|
|
GstElementClass *oclass;
|
|
|
|
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
|
2000-12-28 00:18:26 +00:00
|
|
|
|
2001-07-11 12:33:17 +00:00
|
|
|
return oclass->padtemplates;
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
|
|
|
|
2001-01-18 23:46:15 +00:00
|
|
|
/**
|
|
|
|
* gst_element_get_padtemplate_by_name:
|
|
|
|
* @element: element to get padtemplate of
|
|
|
|
* @name: the name of the padtemplate to get.
|
|
|
|
*
|
|
|
|
* Retrieve a padtemplate from this element with the
|
|
|
|
* given name.
|
|
|
|
*
|
|
|
|
* Returns: the padtemplate with the given name
|
|
|
|
*/
|
|
|
|
GstPadTemplate*
|
|
|
|
gst_element_get_padtemplate_by_name (GstElement *element, const guchar *name)
|
|
|
|
{
|
|
|
|
GList *padlist;
|
|
|
|
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
|
|
|
padlist = gst_element_get_padtemplate_list (element);
|
|
|
|
|
|
|
|
while (padlist) {
|
|
|
|
GstPadTemplate *padtempl = (GstPadTemplate*) padlist->data;
|
|
|
|
|
|
|
|
if (!strcmp (padtempl->name_template, name))
|
|
|
|
return padtempl;
|
2001-01-19 22:15:21 +00:00
|
|
|
|
2001-01-18 23:46:15 +00:00
|
|
|
padlist = g_list_next (padlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2001-01-23 18:42:23 +00:00
|
|
|
/**
|
|
|
|
* gst_element_get_padtemplate_by_compatible:
|
|
|
|
* @element: element to get padtemplate of
|
|
|
|
* @templ: a template to find a compatible template for
|
|
|
|
*
|
|
|
|
* Generate a padtemplate for this element compatible with the given
|
|
|
|
* template, ie able to link to it.
|
|
|
|
*
|
|
|
|
* Returns: the padtemplate
|
|
|
|
*/
|
|
|
|
static GstPadTemplate*
|
|
|
|
gst_element_get_padtemplate_by_compatible (GstElement *element, GstPadTemplate *compattempl)
|
|
|
|
{
|
|
|
|
GstPadTemplate *newtempl = NULL;
|
|
|
|
GList *padlist;
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_ELEMENT_PADS,"gst_element_get_padtemplate_by_compatible()\n");
|
2001-01-23 18:42:23 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
g_return_val_if_fail (compattempl != NULL, NULL);
|
|
|
|
|
|
|
|
padlist = gst_element_get_padtemplate_list (element);
|
|
|
|
|
|
|
|
while (padlist) {
|
|
|
|
GstPadTemplate *padtempl = (GstPadTemplate*) padlist->data;
|
|
|
|
gboolean compat = FALSE;
|
|
|
|
|
|
|
|
// Ignore name
|
|
|
|
// Ignore presence
|
|
|
|
// Check direction (must be opposite)
|
|
|
|
// Check caps
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_CAPS,"checking direction and caps\n");
|
2001-01-23 18:42:23 +00:00
|
|
|
if (padtempl->direction == GST_PAD_SRC &&
|
|
|
|
compattempl->direction == GST_PAD_SINK) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found src pad template\n");
|
2001-03-12 21:02:12 +00:00
|
|
|
compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (padtempl),
|
|
|
|
GST_PADTEMPLATE_CAPS (compattempl));
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
|
2001-01-23 18:42:23 +00:00
|
|
|
} else if (padtempl->direction == GST_PAD_SINK &&
|
|
|
|
compattempl->direction == GST_PAD_SRC) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found sink pad template\n");
|
2001-03-12 21:02:12 +00:00
|
|
|
compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (compattempl),
|
|
|
|
GST_PADTEMPLATE_CAPS (padtempl));
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
|
2001-01-23 18:42:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (compat) {
|
|
|
|
newtempl = padtempl;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
padlist = g_list_next (padlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
return newtempl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static GstPad*
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
gst_element_request_pad (GstElement *element, GstPadTemplate *templ, const gchar* name)
|
2001-01-18 23:46:15 +00:00
|
|
|
{
|
|
|
|
GstPad *newpad = NULL;
|
|
|
|
GstElementClass *oclass;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
|
2001-01-18 23:46:15 +00:00
|
|
|
if (oclass->request_new_pad)
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
newpad = (oclass->request_new_pad)(element, templ, name);
|
2001-01-18 23:46:15 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
return newpad;
|
2001-01-18 23:46:15 +00:00
|
|
|
}
|
|
|
|
|
2001-01-23 18:42:23 +00:00
|
|
|
/**
|
|
|
|
* gst_element_request_compatible_pad:
|
|
|
|
* @element: element to request a new pad from
|
|
|
|
* @templ: a pad template to which the new pad should be able to connect
|
|
|
|
*
|
|
|
|
* Request a new pad from the element. The template will
|
|
|
|
* be used to decide what type of pad to create. This function
|
|
|
|
* is typically used for elements with a padtemplate with presence
|
|
|
|
* GST_PAD_REQUEST.
|
|
|
|
*
|
|
|
|
* Returns: the new pad that was created.
|
|
|
|
*/
|
|
|
|
GstPad*
|
|
|
|
gst_element_request_compatible_pad (GstElement *element, GstPadTemplate *templ)
|
|
|
|
{
|
|
|
|
GstPadTemplate *templ_new;
|
|
|
|
GstPad *pad = NULL;
|
|
|
|
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
g_return_val_if_fail (templ != NULL, NULL);
|
|
|
|
|
|
|
|
templ_new = gst_element_get_padtemplate_by_compatible (element, templ);
|
2001-03-07 21:52:56 +00:00
|
|
|
if (templ_new != NULL)
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
pad = gst_element_request_pad (element, templ_new, NULL);
|
2001-01-23 18:42:23 +00:00
|
|
|
|
|
|
|
return pad;
|
|
|
|
}
|
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
/**
|
|
|
|
* gst_element_request_pad_by_name:
|
|
|
|
* @element: element to request a new pad from
|
|
|
|
* @name: the name of the padtemplate to use.
|
|
|
|
*
|
|
|
|
* Request a new pad from the element. The name argument will
|
|
|
|
* be used to decide what padtemplate to use. This function
|
|
|
|
* is typically used for elements with a padtemplate with presence
|
|
|
|
* GST_PAD_REQUEST.
|
|
|
|
*
|
|
|
|
* Returns: the new pad that was created.
|
|
|
|
*/
|
2001-01-18 23:46:15 +00:00
|
|
|
GstPad*
|
|
|
|
gst_element_request_pad_by_name (GstElement *element, const gchar *name)
|
|
|
|
{
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
GstPadTemplate *templ = NULL;
|
2001-01-18 23:46:15 +00:00
|
|
|
GstPad *pad;
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
const gchar *req_name = NULL;
|
|
|
|
gboolean templ_found = FALSE;
|
|
|
|
GList *list;
|
|
|
|
gint n;
|
2001-01-18 23:46:15 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
if (strstr (name, "%d")) {
|
|
|
|
templ = gst_element_get_padtemplate_by_name (element, name);
|
|
|
|
req_name = NULL;
|
|
|
|
} else {
|
|
|
|
list = gst_element_get_padtemplate_list(element);
|
|
|
|
while (!templ_found && list) {
|
|
|
|
templ = (GstPadTemplate*) list->data;
|
|
|
|
if (strstr (templ->name_template, "%d")) {
|
|
|
|
if (sscanf(name, templ->name_template, &n)) {
|
|
|
|
templ_found = TRUE;
|
|
|
|
req_name = name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-15 19:13:45 +00:00
|
|
|
if (templ == NULL)
|
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name and there is a "sink%d" template, t...
Original commit message from CVS:
- if you call gst_element_request_pad_by_name() with, say "sink4" as the pad name
and there is a "sink%d" template, the request_new_pad function will be called.
this is to allow for, for example, requesting a certain channel on a multichannel
device.
- to this end, request_new_pad now has the following prototype:
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar *name)
if request_pad_by_name was called with a name like "sink%d" (i.e. no parsing
was necessary) then NULL is passed as 'name'.
- all plugins that use request pads have been changed to the new api.
also, some incremental (untested) alsa updates, switching to the bytestream api...
2001-09-23 22:52:32 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pad = gst_element_request_pad (element, templ, req_name);
|
|
|
|
|
2001-01-18 23:46:15 +00:00
|
|
|
return pad;
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_element_connect:
|
|
|
|
* @src: element containing source pad
|
|
|
|
* @srcpadname: name of pad in source element
|
|
|
|
* @dest: element containing destination pad
|
|
|
|
* @destpadname: name of pad in destination element
|
|
|
|
*
|
|
|
|
* Connect the two named pads of the source and destination elements.
|
|
|
|
* Side effect is that if one of the pads has no parent, it becomes a
|
|
|
|
* child of the parent of the other element. If they have different
|
|
|
|
* parents, the connection fails.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
2001-01-06 02:35:17 +00:00
|
|
|
gst_element_connect (GstElement *src, const gchar *srcpadname,
|
2001-01-20 03:10:44 +00:00
|
|
|
GstElement *dest, const gchar *destpadname)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GstPad *srcpad,*destpad;
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
g_return_if_fail (src != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT(src));
|
|
|
|
g_return_if_fail (srcpadname != NULL);
|
|
|
|
g_return_if_fail (dest != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT(dest));
|
|
|
|
g_return_if_fail (destpadname != NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* obtain the pads requested */
|
2000-11-11 15:13:50 +00:00
|
|
|
srcpad = gst_element_get_pad (src, srcpadname);
|
2000-12-29 10:02:17 +00:00
|
|
|
if (srcpad == NULL) {
|
2001-01-01 03:14:40 +00:00
|
|
|
GST_ERROR(src,"source element has no pad \"%s\"",srcpadname);
|
2000-12-29 10:02:17 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-12-09 09:13:09 +00:00
|
|
|
destpad = gst_element_get_pad (dest, destpadname);
|
2000-12-29 10:02:17 +00:00
|
|
|
if (srcpad == NULL) {
|
2001-01-01 03:14:40 +00:00
|
|
|
GST_ERROR(dest,"destination element has no pad \"%s\"",destpadname);
|
2000-12-29 10:02:17 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* we're satisified they can be connected, let's do it */
|
|
|
|
gst_pad_connect(srcpad,destpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-06 02:35:17 +00:00
|
|
|
/**
|
|
|
|
* gst_element_disconnect:
|
|
|
|
* @src: element containing source pad
|
|
|
|
* @srcpadname: name of pad in source element
|
|
|
|
* @dest: element containing destination pad
|
|
|
|
* @destpadname: name of pad in destination element
|
|
|
|
*
|
|
|
|
* Disconnect the two named pads of the source and destination elements.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
2001-01-06 02:35:17 +00:00
|
|
|
gst_element_disconnect (GstElement *src, const gchar *srcpadname,
|
2001-01-20 03:10:44 +00:00
|
|
|
GstElement *dest, const gchar *destpadname)
|
2001-01-06 02:35:17 +00:00
|
|
|
{
|
|
|
|
GstPad *srcpad,*destpad;
|
|
|
|
|
|
|
|
g_return_if_fail (src != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT(src));
|
|
|
|
g_return_if_fail (srcpadname != NULL);
|
|
|
|
g_return_if_fail (dest != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT(dest));
|
|
|
|
g_return_if_fail (destpadname != NULL);
|
|
|
|
|
|
|
|
/* obtain the pads requested */
|
|
|
|
srcpad = gst_element_get_pad (src, srcpadname);
|
|
|
|
if (srcpad == NULL) {
|
|
|
|
GST_ERROR(src,"source element has no pad \"%s\"",srcpadname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
destpad = gst_element_get_pad (dest, destpadname);
|
|
|
|
if (srcpad == NULL) {
|
|
|
|
GST_ERROR(dest,"destination element has no pad \"%s\"",destpadname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we're satisified they can be disconnected, let's do it */
|
|
|
|
gst_pad_disconnect(srcpad,destpad);
|
|
|
|
}
|
|
|
|
|
2000-02-02 06:26:44 +00:00
|
|
|
/**
|
|
|
|
* gst_element_error:
|
|
|
|
* @element: Element with the error
|
|
|
|
* @error: String describing the error
|
|
|
|
*
|
|
|
|
* This function is used internally by elements to signal an error
|
|
|
|
* condition. It results in the "error" signal.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
|
|
|
gst_element_error (GstElement *element, const gchar *error)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2001-05-25 21:00:07 +00:00
|
|
|
g_error("GstElement: error in element '%s': %s\n", GST_ELEMENT_NAME(element), error);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* FIXME: this is not finished!!! */
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[ERROR], 0, error);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-09-26 23:14:32 +00:00
|
|
|
GstElementState
|
|
|
|
gst_element_get_state (GstElement *elem)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (elem), GST_STATE_VOID_PENDING);
|
|
|
|
|
|
|
|
return GST_STATE (elem);
|
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_element_set_state:
|
|
|
|
* @element: element to change state of
|
|
|
|
* @state: new element state
|
|
|
|
*
|
2000-09-14 20:31:03 +00:00
|
|
|
* Sets the state of the element. This function will only set
|
|
|
|
* the elements pending state.
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
|
|
|
* Returns: whether or not the state was successfully set.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
gint
|
|
|
|
gst_element_set_state (GstElement *element, GstElementState state)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GstElementClass *oclass;
|
2000-11-23 08:13:43 +00:00
|
|
|
GstElementState curpending;
|
2000-07-17 17:14:15 +00:00
|
|
|
GstElementStateReturn return_val = GST_STATE_SUCCESS;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
// g_print("gst_element_set_state(\"%s\",%08lx)\n",
|
|
|
|
// element->name,state);
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
g_return_val_if_fail (element != NULL, GST_STATE_FAILURE);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), GST_STATE_FAILURE);
|
2001-05-25 21:00:07 +00:00
|
|
|
g_return_val_if_fail (element->sched != NULL, GST_STATE_FAILURE);
|
|
|
|
|
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_STATES,element, "setting state from %s to %s\n",
|
|
|
|
gst_element_statename(GST_STATE(element)),
|
|
|
|
gst_element_statename(state));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* start with the current state */
|
2000-11-23 08:13:43 +00:00
|
|
|
curpending = GST_STATE(element);
|
2000-11-23 20:39:54 +00:00
|
|
|
|
|
|
|
/* loop until the final requested state is set */
|
2000-11-23 08:13:43 +00:00
|
|
|
while (GST_STATE(element) != state) {
|
2000-11-23 20:39:54 +00:00
|
|
|
/* move the curpending state in the correct direction */
|
2001-01-15 19:25:26 +00:00
|
|
|
if (curpending < state) curpending<<=1;
|
|
|
|
else curpending>>=1;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* set the pending state variable */
|
|
|
|
// FIXME: should probably check to see that we don't already have one
|
2000-11-23 08:13:43 +00:00
|
|
|
GST_STATE_PENDING (element) = curpending;
|
2001-05-25 21:00:07 +00:00
|
|
|
if (curpending != state)
|
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_STATES,element,"intermediate: setting state to %s\n",
|
|
|
|
gst_element_statename(curpending));
|
2000-11-23 08:13:43 +00:00
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* call the state change function so it can set the state */
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
|
2000-11-23 08:13:43 +00:00
|
|
|
if (oclass->change_state)
|
|
|
|
return_val = (oclass->change_state)(element);
|
|
|
|
|
2000-11-23 20:39:54 +00:00
|
|
|
/* if that outright didn't work, we need to bail right away */
|
|
|
|
/* NOTE: this will bail on ASYNC as well! */
|
2000-12-28 22:12:02 +00:00
|
|
|
if (return_val == GST_STATE_FAILURE) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_STATES,element,"have failed change_state return\n");
|
2000-12-28 00:18:26 +00:00
|
|
|
return return_val;
|
2000-12-28 22:12:02 +00:00
|
|
|
}
|
2001-08-06 20:37:21 +00:00
|
|
|
|
|
|
|
/* Last thing we do is verify that a successful state change really
|
|
|
|
* did change the state... */
|
|
|
|
if (GST_STATE(element) != curpending) {
|
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_STATES, element, "element claimed state-change success, but state didn't change\n");
|
|
|
|
return GST_STATE_FAILURE;
|
|
|
|
}
|
2000-11-23 08:13:43 +00:00
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-07-17 17:14:15 +00:00
|
|
|
return return_val;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 20:31:03 +00:00
|
|
|
/**
|
|
|
|
* gst_element_get_factory:
|
|
|
|
* @element: element to request the factory
|
|
|
|
*
|
|
|
|
* Retrieves the factory that was used to create this element
|
|
|
|
*
|
|
|
|
* Returns: the factory used for creating this element
|
|
|
|
*/
|
2000-11-11 15:13:50 +00:00
|
|
|
GstElementFactory*
|
2001-01-20 03:10:44 +00:00
|
|
|
gst_element_get_factory (GstElement *element)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-08-21 21:20:38 +00:00
|
|
|
GstElementClass *oclass;
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
2001-01-20 03:10:44 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
|
2000-08-21 21:20:38 +00:00
|
|
|
|
|
|
|
return oclass->elementfactory;
|
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_element_change_state:
|
|
|
|
* @element: element to change state of
|
|
|
|
*
|
|
|
|
* Changes the state of the element, but more importantly fires off a signal
|
2001-01-20 03:10:44 +00:00
|
|
|
* indicating the new state.
|
2000-09-14 20:31:03 +00:00
|
|
|
* The element will have no pending states anymore.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
|
|
|
* Returns: whether or not the state change was successfully set.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
GstElementStateReturn
|
|
|
|
gst_element_change_state (GstElement *element)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (element != NULL, GST_STATE_FAILURE);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), GST_STATE_FAILURE);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
// GST_DEBUG_ELEMENT (GST_CAT_STATES, element, "default handler sets state to %s\n",
|
|
|
|
// gst_element_statename(GST_STATE_PENDING(element)));
|
|
|
|
|
|
|
|
if (GST_STATE_TRANSITION(element) == GST_STATE_PAUSED_TO_PLAYING) {
|
|
|
|
g_return_val_if_fail(GST_ELEMENT_SCHED(element), GST_STATE_FAILURE);
|
|
|
|
if (GST_ELEMENT_PARENT(element))
|
2001-05-25 21:25:36 +00:00
|
|
|
GST_DEBUG(GST_CAT_STATES,"PAUSED->PLAYING: element \"%s\" has parent \"%s\" and sched %p\n",
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_ELEMENT_NAME(element),GST_ELEMENT_NAME(GST_ELEMENT_PARENT(element)),GST_ELEMENT_SCHED(element));
|
|
|
|
GST_SCHEDULE_ENABLE_ELEMENT (element->sched,element);
|
|
|
|
}
|
|
|
|
else if (GST_STATE_TRANSITION(element) == GST_STATE_PLAYING_TO_PAUSED) {
|
|
|
|
if (GST_ELEMENT_PARENT(element))
|
2001-05-25 21:25:36 +00:00
|
|
|
GST_DEBUG(GST_CAT_STATES,"PLAYING->PAUSED: element \"%s\" has parent \"%s\" and sched %p\n",
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_ELEMENT_NAME(element),GST_ELEMENT_NAME(GST_ELEMENT_PARENT(element)),GST_ELEMENT_SCHED(element));
|
|
|
|
GST_SCHEDULE_DISABLE_ELEMENT (element->sched,element);
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
GST_STATE (element) = GST_STATE_PENDING (element);
|
2001-06-25 01:20:11 +00:00
|
|
|
GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;
|
2000-08-18 20:35:48 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
// note: queues' state_change is a special case because it needs to lock
|
|
|
|
// for synchronization (from another thread). since this signal may block
|
|
|
|
// or (worse) make another state change, the queue needs to unlock before
|
|
|
|
// calling. thus, gstqueue.c::gst_queue_state_change() blocks, unblocks,
|
|
|
|
// unlocks, then emits this.
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[STATE_CHANGE], 0,
|
2000-11-11 15:13:50 +00:00
|
|
|
GST_STATE (element));
|
2001-05-25 21:00:07 +00:00
|
|
|
return GST_STATE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_element_shutdown (GObject *object)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
|
|
|
GstElement *element = GST_ELEMENT (object);
|
|
|
|
|
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_REFCOUNTING, element, "shutdown\n");
|
|
|
|
|
|
|
|
if (GST_IS_BIN (GST_OBJECT_PARENT (element)))
|
|
|
|
gst_bin_remove (GST_BIN (GST_OBJECT_PARENT (element)), element);
|
|
|
|
|
2001-08-13 19:00:13 +00:00
|
|
|
// if (G_OBJECT_CLASS (parent_class)->shutdown)
|
|
|
|
// G_OBJECT_CLASS (parent_class)->shutdown (G_OBJECT (object));
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_element_real_destroy (GObject *object)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
|
|
|
GstElement *element = GST_ELEMENT (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
GList *pads;
|
|
|
|
GstPad *pad;
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG_ELEMENT (GST_CAT_REFCOUNTING, element, "destroy\n");
|
|
|
|
|
|
|
|
if (element->pads) {
|
|
|
|
GList *orig;
|
|
|
|
orig = pads = g_list_copy (element->pads);
|
|
|
|
while (pads) {
|
|
|
|
pad = GST_PAD (pads->data);
|
|
|
|
//gst_object_destroy (GST_OBJECT (pad));
|
|
|
|
gst_object_ref (GST_OBJECT (pad));
|
|
|
|
gst_element_remove_pad (element, pad);
|
|
|
|
gst_object_unref (GST_OBJECT (pad));
|
|
|
|
pads = g_list_next (pads);
|
|
|
|
}
|
|
|
|
g_list_free (orig);
|
|
|
|
g_list_free (element->pads);
|
|
|
|
element->pads = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
element->numsrcpads = 0;
|
|
|
|
element->numsinkpads = 0;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
// FIXME!
|
|
|
|
// if (G_OBJECT_CLASS (parent_class)->destroy)
|
|
|
|
// G_OBJECT_CLASS (parent_class)->destroy (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-02-27 23:18:38 +00:00
|
|
|
/*
|
2000-01-30 09:03:00 +00:00
|
|
|
static gchar *_gst_element_type_names[] = {
|
|
|
|
"invalid",
|
|
|
|
"none",
|
|
|
|
"char",
|
|
|
|
"uchar",
|
|
|
|
"bool",
|
|
|
|
"int",
|
|
|
|
"uint",
|
|
|
|
"long",
|
|
|
|
"ulong",
|
|
|
|
"float",
|
|
|
|
"double",
|
|
|
|
"string",
|
|
|
|
};
|
2000-02-27 23:18:38 +00:00
|
|
|
*/
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_element_save_thyself:
|
|
|
|
* @element: GstElement to save
|
|
|
|
* @parent: the xml parent node
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Saves the element as part of the given XML structure
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
|
|
|
* Returns: the new xml node
|
|
|
|
*/
|
2001-01-29 00:06:02 +00:00
|
|
|
static xmlNodePtr
|
|
|
|
gst_element_save_thyself (GstObject *object,
|
2001-01-20 03:10:44 +00:00
|
|
|
xmlNodePtr parent)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GList *pads;
|
|
|
|
GstElementClass *oclass;
|
2001-06-25 01:20:11 +00:00
|
|
|
// GType type;
|
2001-01-29 00:06:02 +00:00
|
|
|
GstElement *element;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (object), parent);
|
|
|
|
|
|
|
|
element = GST_ELEMENT (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
xmlNewChild(parent, NULL, "name", GST_ELEMENT_NAME(element));
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
if (oclass->elementfactory != NULL) {
|
2001-01-29 00:06:02 +00:00
|
|
|
GstElementFactory *factory = (GstElementFactory *)oclass->elementfactory;
|
|
|
|
|
2001-08-21 20:16:48 +00:00
|
|
|
xmlNewChild (parent, NULL, "type", GST_OBJECT_NAME (factory));
|
2001-01-29 00:06:02 +00:00
|
|
|
xmlNewChild (parent, NULL, "version", factory->details->version);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
// if (element->manager)
|
|
|
|
// xmlNewChild(parent, NULL, "manager", GST_ELEMENT_NAME(element->manager));
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
/* FIXME FIXME FIXME!
|
2000-01-30 09:03:00 +00:00
|
|
|
// output all args to the element
|
2001-06-25 01:20:11 +00:00
|
|
|
type = G_OBJECT_TYPE (element);
|
|
|
|
while (type != G_TYPE_INVALID) {
|
2000-01-30 09:03:00 +00:00
|
|
|
GtkArg *args;
|
|
|
|
guint32 *flags;
|
|
|
|
guint num_args,i;
|
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
args = gtk_object_query_args (type, &flags, &num_args);
|
2001-01-20 03:10:44 +00:00
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
for (i=0; i<num_args; i++) {
|
2001-06-25 01:20:11 +00:00
|
|
|
if ((args[i].type > G_TYPE_NONE) &&
|
2000-11-11 15:13:50 +00:00
|
|
|
(flags[i] & GTK_ARG_READABLE)) {
|
2000-01-30 09:03:00 +00:00
|
|
|
xmlNodePtr arg;
|
2001-06-25 01:20:11 +00:00
|
|
|
gtk_object_getv (G_OBJECT (element), 1, &args[i]);
|
2001-01-29 00:06:02 +00:00
|
|
|
arg = xmlNewChild (parent, NULL, "arg", NULL);
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "name", args[i].name);
|
2000-01-30 09:03:00 +00:00
|
|
|
switch (args[i].type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_CHAR:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%c", G_VALUE_CHAR (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_UCHAR:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%d", G_VALUE_UCHAR (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_BOOL:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
G_VALUE_BOOL (args[i]) ? "true" : "false");
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_INT:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%d", G_VALUE_INT (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_LONG:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%ld", G_VALUE_LONG (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_ULONG:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%lu", G_VALUE_ULONG (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_FLOAT:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%f", G_VALUE_FLOAT (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_DOUBLE:
|
2000-11-11 15:13:50 +00:00
|
|
|
xmlNewChild (arg, NULL, "value",
|
2001-06-25 01:20:11 +00:00
|
|
|
g_strdup_printf ("%g", G_VALUE_DOUBLE (args[i])));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2001-06-25 01:20:11 +00:00
|
|
|
case G_TYPE_STRING:
|
|
|
|
xmlNewChild (arg, NULL, "value", G_VALUE_STRING (args[i]));
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2000-11-11 15:13:50 +00:00
|
|
|
default:
|
|
|
|
if (args[i].type == GST_TYPE_FILENAME) {
|
2001-06-25 01:20:11 +00:00
|
|
|
xmlNewChild (arg, NULL, "value", G_VALUE_STRING (args[i]));
|
2000-11-11 15:13:50 +00:00
|
|
|
}
|
|
|
|
break;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-11-11 15:13:50 +00:00
|
|
|
type = gtk_type_parent (type);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-06-25 01:20:11 +00:00
|
|
|
*/
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
pads = GST_ELEMENT_PADS (element);
|
|
|
|
|
2000-12-28 00:18:26 +00:00
|
|
|
while (pads) {
|
2001-01-29 00:06:02 +00:00
|
|
|
GstPad *pad = GST_PAD (pads->data);
|
2000-12-28 00:18:26 +00:00
|
|
|
// figure out if it's a direct pad or a ghostpad
|
2001-03-07 21:52:56 +00:00
|
|
|
if (GST_ELEMENT (GST_OBJECT_PARENT (pad)) == element) {
|
|
|
|
xmlNodePtr padtag = xmlNewChild (parent, NULL, "pad", NULL);
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_save_thyself (GST_OBJECT (pad), padtag);
|
2001-03-07 21:52:56 +00:00
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
pads = g_list_next (pads);
|
|
|
|
}
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
return parent;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-09-27 19:33:10 +00:00
|
|
|
/**
|
2001-05-25 21:00:07 +00:00
|
|
|
* gst_element_restore_thyself:
|
2001-01-29 00:06:02 +00:00
|
|
|
* @self: the xml node
|
2001-01-31 20:27:00 +00:00
|
|
|
* @parent: the parent of this object when it's loaded
|
2000-09-27 19:33:10 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Load the element from the XML description
|
2000-09-27 19:33:10 +00:00
|
|
|
*
|
|
|
|
* Returns: the new element
|
|
|
|
*/
|
2000-11-11 15:13:50 +00:00
|
|
|
GstElement*
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_element_restore_thyself (xmlNodePtr self, GstObject *parent)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2001-01-29 00:06:02 +00:00
|
|
|
xmlNodePtr children = self->xmlChildrenNode;
|
2000-09-27 19:33:10 +00:00
|
|
|
GstElement *element;
|
2001-01-29 00:06:02 +00:00
|
|
|
GstObjectClass *oclass;
|
2000-09-27 19:33:10 +00:00
|
|
|
guchar *name = NULL;
|
|
|
|
guchar *value = NULL;
|
|
|
|
guchar *type = NULL;
|
|
|
|
|
2000-12-29 10:02:17 +00:00
|
|
|
// first get the needed tags to construct the element
|
2000-09-27 19:33:10 +00:00
|
|
|
while (children) {
|
2000-11-11 15:13:50 +00:00
|
|
|
if (!strcmp (children->name, "name")) {
|
|
|
|
name = g_strdup (xmlNodeGetContent (children));
|
2000-12-29 10:02:17 +00:00
|
|
|
} else if (!strcmp (children->name, "type")) {
|
2000-11-11 15:13:50 +00:00
|
|
|
type = g_strdup (xmlNodeGetContent (children));
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
|
|
|
children = children->next;
|
|
|
|
}
|
2000-12-23 03:17:52 +00:00
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
g_return_val_if_fail (type != NULL, NULL);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO (GST_CAT_XML,"loading \"%s\" of type \"%s\"", name, type);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2000-11-11 15:13:50 +00:00
|
|
|
element = gst_elementfactory_make (type, name);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2000-12-23 03:17:52 +00:00
|
|
|
g_return_val_if_fail (element != NULL, NULL);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
// ne need to set the parent on this object bacause the pads
|
|
|
|
// will go through the hierarchy to connect to thier peers
|
|
|
|
if (parent)
|
|
|
|
gst_object_set_parent (GST_OBJECT (element), parent);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-20 03:10:44 +00:00
|
|
|
// we have the element now, set the arguments
|
2001-01-29 00:06:02 +00:00
|
|
|
children = self->xmlChildrenNode;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
|
|
|
while (children) {
|
2000-12-28 00:18:26 +00:00
|
|
|
if (!strcmp (children->name, "arg")) {
|
2001-01-18 11:16:53 +00:00
|
|
|
xmlNodePtr child = children->xmlChildrenNode;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
|
|
|
while (child) {
|
2000-11-11 15:13:50 +00:00
|
|
|
if (!strcmp (child->name, "name")) {
|
|
|
|
name = g_strdup (xmlNodeGetContent (child));
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
2000-11-11 15:13:50 +00:00
|
|
|
else if (!strcmp (child->name, "value")) {
|
|
|
|
value = g_strdup (xmlNodeGetContent (child));
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
|
|
|
child = child->next;
|
|
|
|
}
|
2001-07-11 12:33:17 +00:00
|
|
|
gst_util_set_object_arg ((GObject *)G_OBJECT (element), name, value);
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
children = children->next;
|
|
|
|
}
|
|
|
|
// we have the element now, set the pads
|
2001-01-29 00:06:02 +00:00
|
|
|
children = self->xmlChildrenNode;
|
2000-12-28 00:18:26 +00:00
|
|
|
|
|
|
|
while (children) {
|
|
|
|
if (!strcmp (children->name, "pad")) {
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_pad_load_and_connect (children, GST_OBJECT (element));
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
2000-09-27 19:33:10 +00:00
|
|
|
children = children->next;
|
|
|
|
}
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
oclass = GST_OBJECT_CLASS (G_OBJECT_GET_CLASS(element));
|
2000-09-27 19:33:10 +00:00
|
|
|
if (oclass->restore_thyself)
|
2001-01-29 00:06:02 +00:00
|
|
|
(oclass->restore_thyself) (GST_OBJECT (element), self);
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
gst_object_unparent (GST_OBJECT (element));
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-30 23:53:04 +00:00
|
|
|
gst_class_signal_emit_by_name (GST_OBJECT (element), "object_loaded", self);
|
|
|
|
|
2000-09-27 19:33:10 +00:00
|
|
|
return element;
|
|
|
|
}
|
2001-06-25 06:45:56 +00:00
|
|
|
#endif // GST_DISABLE_LOADSAVE
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2000-02-02 06:26:44 +00:00
|
|
|
/**
|
2001-05-25 21:00:07 +00:00
|
|
|
* gst_element_set_sched:
|
2000-02-02 06:26:44 +00:00
|
|
|
* @element: Element to set manager of.
|
2001-05-25 21:00:07 +00:00
|
|
|
* @sched: @GstSchedule to set.
|
2000-02-02 06:26:44 +00:00
|
|
|
*
|
2001-05-25 21:00:07 +00:00
|
|
|
* Sets the scheduler of the element. For internal use only, unless you're
|
2000-02-02 06:26:44 +00:00
|
|
|
* writing a new bin subclass.
|
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_element_set_sched (GstElement *element,
|
|
|
|
GstSchedule *sched)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO_ELEMENT (GST_CAT_PARENTAGE, element, "setting scheduler to %p",sched);
|
|
|
|
element->sched = sched;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-02-02 06:26:44 +00:00
|
|
|
/**
|
2001-05-25 21:00:07 +00:00
|
|
|
* gst_element_get_sched:
|
2000-02-02 06:26:44 +00:00
|
|
|
* @element: Element to get manager of.
|
|
|
|
*
|
2001-05-25 21:00:07 +00:00
|
|
|
* Returns the scheduler of the element.
|
2000-02-02 06:26:44 +00:00
|
|
|
*
|
2001-05-25 21:00:07 +00:00
|
|
|
* Returns: Element's scheduler
|
2000-02-02 06:26:44 +00:00
|
|
|
*/
|
2001-05-25 21:00:07 +00:00
|
|
|
GstSchedule*
|
|
|
|
gst_element_get_sched (GstElement *element)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2001-05-25 21:00:07 +00:00
|
|
|
return element->sched;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-02-02 06:26:44 +00:00
|
|
|
/**
|
|
|
|
* gst_element_set_loop_function:
|
|
|
|
* @element: Element to set loop function of.
|
|
|
|
* @loop: Pointer to loop function.
|
|
|
|
*
|
|
|
|
* This sets the loop function for the element. The function pointed to
|
|
|
|
* can deviate from the GstElementLoopFunction definition in type of
|
|
|
|
* pointer only.
|
2000-11-23 21:49:09 +00:00
|
|
|
*
|
|
|
|
* NOTE: in order for this to take effect, the current loop function *must*
|
|
|
|
* exit. Assuming the loop function itself is the only one who will cause
|
|
|
|
* a new loopfunc to be assigned, this should be no problem.
|
2000-02-02 06:26:44 +00:00
|
|
|
*/
|
2001-01-20 03:10:44 +00:00
|
|
|
void
|
2000-11-11 15:13:50 +00:00
|
|
|
gst_element_set_loop_function(GstElement *element,
|
2001-01-20 03:10:44 +00:00
|
|
|
GstElementLoopFunction loop)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2000-11-23 21:49:09 +00:00
|
|
|
/* set the loop function */
|
2000-01-30 09:03:00 +00:00
|
|
|
element->loopfunc = loop;
|
2000-11-23 21:49:09 +00:00
|
|
|
|
|
|
|
/* set the NEW_LOOPFUNC flag so everyone knows to go try again */
|
|
|
|
GST_FLAG_SET(element,GST_ELEMENT_NEW_LOOPFUNC);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2000-12-29 02:28:04 +00:00
|
|
|
|
|
|
|
/**
|
2000-12-30 16:13:17 +00:00
|
|
|
* gst_element_signal_eos:
|
|
|
|
* @element: element to trigger the eos signal of
|
2001-01-20 03:10:44 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Throws the eos signal to indicate that the end of the stream is reached.
|
2000-12-29 02:28:04 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_element_signal_eos (GstElement *element)
|
2001-01-13 13:51:08 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (element != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (element));
|
|
|
|
|
2001-08-06 20:37:21 +00:00
|
|
|
GST_DEBUG(GST_CAT_EVENT, "signaling EOS on element %s\n",GST_OBJECT_NAME(element));
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT (element), gst_element_signals[EOS], 0);
|
2001-01-20 03:28:37 +00:00
|
|
|
GST_FLAG_SET(element,GST_ELEMENT_COTHREAD_STOPPING);
|
2001-01-13 13:51:08 +00:00
|
|
|
}
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-08-21 20:16:48 +00:00
|
|
|
const gchar *gst_element_statename(GstElementState state) {
|
2001-05-25 21:00:07 +00:00
|
|
|
switch (state) {
|
|
|
|
#ifdef GST_DEBUG_COLOR
|
2001-06-25 01:20:11 +00:00
|
|
|
case GST_STATE_VOID_PENDING: return "NONE_PENDING";break;
|
2001-05-25 21:00:07 +00:00
|
|
|
case GST_STATE_NULL: return "\033[01;37mNULL\033[00m";break;
|
|
|
|
case GST_STATE_READY: return "\033[01;31mREADY\033[00m";break;
|
|
|
|
case GST_STATE_PLAYING: return "\033[01;32mPLAYING\033[00m";break;
|
|
|
|
case GST_STATE_PAUSED: return "\033[01;33mPAUSED\033[00m";break;
|
|
|
|
default: return "\033[01;37;41mUNKNOWN!\033[00m";
|
|
|
|
#else
|
2001-06-25 01:20:11 +00:00
|
|
|
case GST_STATE_VOID_PENDING: return "NONE_PENDING";break;
|
2001-05-25 21:00:07 +00:00
|
|
|
case GST_STATE_NULL: return "NULL";break;
|
|
|
|
case GST_STATE_READY: return "READY";break;
|
|
|
|
case GST_STATE_PLAYING: return "PLAYING";break;
|
|
|
|
case GST_STATE_PAUSED: return "PAUSED";break;
|
|
|
|
default: return "UNKNOWN!";
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|