* Boston, MA 02111-1307, USA.
*/
-//#define GST_DEBUG_ENABLED
+/* #define GST_DEBUG_ENABLED */
+#include <glib.h>
+#include <stdarg.h>
+#include <gobject/gvaluecollector.h>
#include "gst_private.h"
#include "gstelement.h"
#include "gstextratypes.h"
#include "gstbin.h"
#include "gstscheduler.h"
+#include "gstevent.h"
#include "gstutils.h"
+#include "gstlog.h"
/* Element signals and args */
enum {
STATE_CHANGE,
NEW_PAD,
PAD_REMOVED,
- NEW_GHOST_PAD,
- GHOST_PAD_REMOVED,
ERROR,
EOS,
+ DEEP_NOTIFY,
LAST_SIGNAL
};
/* FILL ME */
};
+#define CLASS(element) GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element))
static void gst_element_class_init (GstElementClass *klass);
static void gst_element_init (GstElement *element);
static void gst_element_base_class_init (GstElementClass *klass);
-static void gst_element_set_property (GObject *object, guint prop_id,
+static void gst_element_real_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,
+static void gst_element_real_get_property (GObject *object, guint prop_id, GValue *value,
GParamSpec *pspec);
+static void gst_element_dispatch_properties_changed (GObject * object, guint n_pspecs, GParamSpec **pspecs);
-static void gst_element_shutdown (GObject *object);
-static void gst_element_real_destroy (GObject *object);
+static void gst_element_dispose (GObject *object);
+
+static gboolean gst_element_send_event_default (GstElement *element, GstEvent *event);
+static gboolean gst_element_query_default (GstElement *element, GstPadQueryType type,
+ GstFormat *format, gint64 *value);
static GstElementStateReturn gst_element_change_state (GstElement *element);
+static void gst_element_error_func (GstElement* element, GstElement *source, gchar *errormsg);
#ifndef GST_DISABLE_LOADSAVE
static xmlNodePtr gst_element_save_thyself (GstObject *object, xmlNodePtr parent);
-GstElement* gst_element_restore_thyself (xmlNodePtr self, GstObject *parent);
+static void gst_element_restore_thyself (GstObject *parent, xmlNodePtr self);
#endif
+GType _gst_element_type = 0;
+
static GstObjectClass *parent_class = NULL;
static guint gst_element_signals[LAST_SIGNAL] = { 0 };
-GType gst_element_get_type(void) {
- static GType element_type = 0;
-
- if (!element_type) {
+GType gst_element_get_type (void)
+{
+ if (!_gst_element_type) {
static const GTypeInfo element_info = {
sizeof(GstElementClass),
(GBaseInitFunc)gst_element_base_class_init,
(GInstanceInitFunc)gst_element_init,
NULL
};
- element_type = g_type_register_static(GST_TYPE_OBJECT, "GstElement", &element_info, G_TYPE_FLAG_ABSTRACT);
+ _gst_element_type = g_type_register_static(GST_TYPE_OBJECT, "GstElement",
+ &element_info, G_TYPE_FLAG_ABSTRACT);
}
- return element_type;
+ return _gst_element_type;
}
static void
parent_class = g_type_class_ref(GST_TYPE_OBJECT);
gst_element_signals[STATE_CHANGE] =
- g_signal_new ("state_change", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, state_change), NULL, NULL,
- gst_marshal_VOID__INT, G_TYPE_NONE, 1,
- G_TYPE_INT);
+ g_signal_new ("state_change", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstElementClass, state_change), NULL, NULL,
+ gst_marshal_VOID__INT_INT, G_TYPE_NONE, 2,
+ G_TYPE_INT, G_TYPE_INT);
gst_element_signals[NEW_PAD] =
- g_signal_new ("new_pad", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, new_pad), NULL, NULL,
- gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
- GST_TYPE_PAD);
+ g_signal_new ("new_pad", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstElementClass, new_pad), NULL, NULL,
+ gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
+ G_TYPE_OBJECT);
gst_element_signals[PAD_REMOVED] =
- g_signal_new ("pad_removed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, pad_removed), NULL, NULL,
- gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
- GST_TYPE_PAD);
- gst_element_signals[NEW_GHOST_PAD] =
- g_signal_new ("new_ghost_pad", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, new_ghost_pad), NULL, NULL,
- gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
- GST_TYPE_PAD);
- gst_element_signals[GHOST_PAD_REMOVED] =
- g_signal_new ("ghost_pad_removed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, ghost_pad_removed), NULL, NULL,
- gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
- GST_TYPE_PAD);
+ g_signal_new ("pad_removed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstElementClass, pad_removed), NULL, NULL,
+ gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
+ G_TYPE_OBJECT);
gst_element_signals[ERROR] =
- g_signal_new ("error", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass, error), NULL, NULL,
- gst_marshal_VOID__STRING, G_TYPE_NONE,1,
- G_TYPE_STRING);
+ g_signal_new ("error", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstElementClass, error), NULL, NULL,
+ gst_marshal_VOID__OBJECT_STRING, G_TYPE_NONE, 2,
+ G_TYPE_OBJECT, G_TYPE_STRING);
gst_element_signals[EOS] =
- g_signal_new ("eos", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstElementClass,eos), NULL, NULL,
- gst_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ g_signal_new ("eos", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstElementClass,eos), NULL, NULL,
+ gst_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ gst_element_signals[DEEP_NOTIFY] =
+ g_signal_new ("deep_notify", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,
+ G_STRUCT_OFFSET (GstElementClass, deep_notify), NULL, NULL,
+ gst_marshal_VOID__OBJECT_PARAM, G_TYPE_NONE,
+ 2, G_TYPE_OBJECT, G_TYPE_PARAM);
+ gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_element_real_set_property);
+ gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_element_real_get_property);
- gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_element_set_property);
- gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_element_get_property);
-// gobject_class->shutdown = GST_DEBUG_FUNCPTR(gst_element_shutdown);
-// FIXME!
-// gobject_class->destroy = GST_DEBUG_FUNCPTR(gst_element_real_destroy);
+ /* see the comments at gst_element_dispatch_properties_changed */
+ gobject_class->dispatch_properties_changed
+ = GST_DEBUG_FUNCPTR (gst_element_dispatch_properties_changed);
+
+ gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_element_dispose);
#ifndef GST_DISABLE_LOADSAVE
- gstobject_class->save_thyself = GST_DEBUG_FUNCPTR(gst_element_save_thyself);
- gstobject_class->restore_thyself = GST_DEBUG_FUNCPTR(gst_element_restore_thyself);
+ gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_element_save_thyself);
+ gstobject_class->restore_thyself = GST_DEBUG_FUNCPTR (gst_element_restore_thyself);
#endif
- klass->change_state = GST_DEBUG_FUNCPTR(gst_element_change_state);
- klass->elementfactory = NULL;
- klass->padtemplates = NULL;
- klass->numpadtemplates = 0;
+ klass->change_state = GST_DEBUG_FUNCPTR (gst_element_change_state);
+ klass->error = GST_DEBUG_FUNCPTR (gst_element_error_func);
+ klass->elementfactory = NULL;
+ klass->padtemplates = NULL;
+ klass->numpadtemplates = 0;
+ klass->send_event = GST_DEBUG_FUNCPTR (gst_element_send_event_default);
+ klass->query = GST_DEBUG_FUNCPTR (gst_element_query_default);
}
static void
gobject_class = (GObjectClass*) klass;
- gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_element_set_property);
- gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_element_get_property);
+ gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_element_real_set_property);
+ gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_element_real_get_property);
}
static void
gst_element_init (GstElement *element)
{
element->current_state = GST_STATE_NULL;
- element->pending_state = -1;
+ element->pending_state = GST_STATE_VOID_PENDING;
element->numpads = 0;
element->numsrcpads = 0;
element->numsinkpads = 0;
element->pads = NULL;
element->loopfunc = NULL;
- element->threadstate = NULL;
element->sched = NULL;
+ element->clock = NULL;
+ element->sched_private = NULL;
+ element->state_mutex = g_mutex_new ();
+ element->state_cond = g_cond_new ();
}
+static void
+gst_element_real_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+ GstElementClass *oclass = CLASS (object);
+
+ if (oclass->set_property)
+ (oclass->set_property) (object, prop_id, value, pspec);
+}
static void
-gst_element_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+gst_element_real_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
- GstElementClass *oclass = (GstElementClass *)G_OBJECT_GET_CLASS(object);
+ GstElementClass *oclass = CLASS (object);
- GST_SCHEDULE_LOCK_ELEMENT ( GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
+ if (oclass->get_property)
+ (oclass->get_property) (object, prop_id, value, pspec);
+}
- if (oclass->set_property)
- (oclass->set_property)(object,prop_id,value,pspec);
+/* Changing a GObject property of an element will result in "deep_notify"
+ * signals being emitted by the element itself, as well as in each parent
+ * element. This is so that an application can connect a listener to the
+ * top-level bin to catch property-change notifications for all contained
+ * elements. */
+static void
+gst_element_dispatch_properties_changed (GObject *object,
+ guint n_pspecs,
+ GParamSpec **pspecs)
+{
+ GstObject *gst_object;
+ guint i;
+
+ /* do the standard dispatching */
+ G_OBJECT_CLASS (parent_class)->dispatch_properties_changed (object, n_pspecs, pspecs);
+
+ /* now let the parent dispatch those, too */
+ gst_object = GST_OBJECT_PARENT (object);
+ while (gst_object) {
+ /* need own category? */
+ for (i = 0; i < n_pspecs; i++) {
+ GST_DEBUG (GST_CAT_EVENT, "deep notification from %s to %s (%s)", GST_OBJECT_NAME (object),
+ GST_OBJECT_NAME (gst_object), pspecs[i]->name);
+ g_signal_emit (gst_object, gst_element_signals[DEEP_NOTIFY], g_quark_from_string (pspecs[i]->name),
+ (GstObject *) object, pspecs[i]);
+ }
+
+ gst_object = GST_OBJECT_PARENT (gst_object);
+ }
+}
+
+/**
+ * gst_element_default_deep_notify:
+ * @object: the #GObject that signalled the notify.
+ * @orig: a #GstObject that initiated the notify.
+ * @pspec: a #GParamSpec of the property.
+ * @excluded_props: a set of user-specified properties to exclude.
+ *
+ * Adds a default deep_notify signal callback to an
+ * element. The user data should contain a pointer to an array of
+ * strings that should be excluded from the notify.
+ * The default handler will print the new value of the property
+ * using g_print.
+ */
+void
+gst_element_default_deep_notify (GObject *object, GstObject *orig,
+ GParamSpec *pspec, gchar **excluded_props)
+{
+ GValue value = { 0, }; /* the important thing is that value.type = 0 */
+ gchar *str = 0;
+
+ if (pspec->flags & G_PARAM_READABLE) {
+ /* let's not print these out for excluded properties... */
+ while (excluded_props != NULL && *excluded_props != NULL) {
+ if (strcmp (pspec->name, *excluded_props) == 0)
+ return;
+ excluded_props++;
+ }
+ g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+ g_object_get_property (G_OBJECT (orig), pspec->name, &value);
+
+ if (G_IS_PARAM_SPEC_ENUM (pspec)) {
+ GEnumValue *enum_value;
+ enum_value = g_enum_get_value (G_ENUM_CLASS (g_type_class_ref (pspec->value_type)),
+ g_value_get_enum (&value));
+
+ str = g_strdup_printf ("%s (%d)", enum_value->value_nick,
+ enum_value->value);
+ }
+ else {
+ str = g_strdup_value_contents (&value);
+ }
+ g_print ("%s: %s = %s\n", GST_OBJECT_NAME (orig), pspec->name, str);
+ g_free (str);
+ g_value_unset (&value);
+ } else {
+ g_warning ("Parameter %s not readable in %s.",
+ pspec->name, GST_OBJECT_NAME (orig));
+ }
+}
+
+/**
+ * gst_element_default_error:
+ * @object: a #GObject that signalled the error.
+ * @orig: the #GstObject that initiated the error.
+ * @error: the error message.
+ *
+ * Adds a default error signal callback to an
+ * element. The user data passed to the g_signal_connect is
+ * ignored.
+ * The default handler will simply print the error string
+ * using g_print.
+ */
+void
+gst_element_default_error (GObject *object, GstObject *orig, gchar *error)
+{
+ g_print ("ERROR: %s: %s\n", GST_OBJECT_NAME (orig), error);
+}
+
+typedef struct {
+ const GParamSpec *pspec;
+ GValue value;
+} prop_value_t;
+
+static void
+element_set_property (GstElement *element, const GParamSpec *pspec, const GValue *value)
+{
+ prop_value_t *prop_value = g_new0 (prop_value_t, 1);
+
+ prop_value->pspec = pspec;
+ prop_value->value = *value;
- GST_SCHEDULE_UNLOCK_ELEMENT ( GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
+ g_async_queue_push (element->prop_value_queue, prop_value);
}
+static void
+element_get_property (GstElement *element, const GParamSpec *pspec, GValue *value)
+{
+ g_mutex_lock (element->property_mutex);
+ g_object_get_property ((GObject*)element, pspec->name, value);
+ g_mutex_unlock (element->property_mutex);
+}
static void
-gst_element_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+gst_element_threadsafe_properties_pre_run (GstElement *element)
{
- GstElementClass *oclass = (GstElementClass *)G_OBJECT_GET_CLASS(object);
+ GST_DEBUG (GST_CAT_THREAD, "locking element %s", GST_OBJECT_NAME (element));
+ g_mutex_lock (element->property_mutex);
+ gst_element_set_pending_properties (element);
+}
- GST_SCHEDULE_LOCK_ELEMENT (GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
+static void
+gst_element_threadsafe_properties_post_run (GstElement *element)
+{
+ GST_DEBUG (GST_CAT_THREAD, "unlocking element %s", GST_OBJECT_NAME (element));
+ g_mutex_unlock (element->property_mutex);
+}
- if (oclass->get_property)
- (oclass->get_property)(object,prop_id,value,pspec);
+/**
+ * gst_element_enable_threadsafe_properties:
+ * @element: a #GstElement to enable threadsafe properties on.
+ *
+ * Installs an asynchronous queue, a mutex and pre- and post-run functions on
+ * this element so that properties on the element can be set in a
+ * threadsafe way.
+ */
+void
+gst_element_enable_threadsafe_properties (GstElement *element)
+{
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ GST_FLAG_SET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES);
+ element->pre_run_func = gst_element_threadsafe_properties_pre_run;
+ element->post_run_func = gst_element_threadsafe_properties_post_run;
+ if (!element->prop_value_queue)
+ element->prop_value_queue = g_async_queue_new ();
+ if (!element->property_mutex)
+ element->property_mutex = g_mutex_new ();
+}
+
+/**
+ * gst_element_disable_threadsafe_properties:
+ * @element: a #GstElement to disable threadsafe properties on.
+ *
+ * Removes the threadsafe properties, post- and pre-run locks from
+ * this element.
+ */
+void
+gst_element_disable_threadsafe_properties (GstElement *element)
+{
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ GST_FLAG_UNSET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES);
+ element->pre_run_func = NULL;
+ element->post_run_func = NULL;
+ /* let's keep around that async queue */
+}
+
+/**
+ * gst_element_set_pending_properties:
+ * @element: a #GstElement to set the pending properties on.
+ *
+ * Sets all pending properties on the threadsafe properties enabled
+ * element.
+ */
+void
+gst_element_set_pending_properties (GstElement *element)
+{
+ prop_value_t *prop_value;
+
+ while ((prop_value = g_async_queue_try_pop (element->prop_value_queue))) {
+ g_object_set_property ((GObject*)element, prop_value->pspec->name, &prop_value->value);
+ g_value_unset (&prop_value->value);
+ g_free (prop_value);
+ }
+}
+
+/* following 6 functions taken mostly from gobject.c */
+
+/**
+ * gst_element_set:
+ * @element: a #GstElement to set properties on.
+ * @first_property_name: the first property to set.
+ * @...: value of the first property, and more properties to set, ending
+ * with NULL.
+ *
+ * Sets properties on an element. If the element uses threadsafe properties,
+ * they will be queued and set on the object when it is scheduled again.
+ */
+void
+gst_element_set (GstElement *element, const gchar *first_property_name, ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ va_start (var_args, first_property_name);
+ gst_element_set_valist (element, first_property_name, var_args);
+ va_end (var_args);
+}
+
+/**
+ * gst_element_get:
+ * @element: a #GstElement to get properties of.
+ * @first_property_name: the first property to get.
+ * @...: pointer to a variable to store the first property in, as well as
+ * more properties to get, ending with NULL.
+ *
+ * Gets properties from an element. If the element uses threadsafe properties,
+ * the element will be locked before getting the given properties.
+ */
+void
+gst_element_get (GstElement *element, const gchar *first_property_name, ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ va_start (var_args, first_property_name);
+ gst_element_get_valist (element, first_property_name, var_args);
+ va_end (var_args);
+}
+
+/**
+ * gst_element_set_valist:
+ * @element: a #GstElement to set properties on.
+ * @first_property_name: the first property to set.
+ * @var_args: the var_args list of other properties to get.
+ *
+ * Sets properties on an element. If the element uses threadsafe properties,
+ * the property change will be put on the async queue.
+ */
+void
+gst_element_set_valist (GstElement *element, const gchar *first_property_name, va_list var_args)
+{
+ const gchar *name;
+ GObject *object;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ object = (GObject *) element;
+
+ GST_DEBUG (GST_CAT_PROPERTIES,
+ "setting valist of properties starting with %s on element %s",
+ first_property_name, gst_element_get_name (element));
+
+ if (!GST_FLAG_IS_SET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES)) {
+ g_object_set_valist (object, first_property_name, var_args);
+ return;
+ }
+
+ g_object_ref (object);
+
+ name = first_property_name;
+
+ while (name)
+ {
+ GValue value = { 0, };
+ GParamSpec *pspec;
+ gchar *error = NULL;
+
+ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), name);
+
+ if (!pspec)
+ {
+ g_warning ("%s: object class `%s' has no property named `%s'",
+ G_STRLOC,
+ G_OBJECT_TYPE_NAME (object),
+ name);
+ break;
+ }
+ if (!(pspec->flags & G_PARAM_WRITABLE))
+ {
+ g_warning ("%s: property `%s' of object class `%s' is not writable",
+ G_STRLOC,
+ pspec->name,
+ G_OBJECT_TYPE_NAME (object));
+ break;
+ }
+
+ g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+
+ G_VALUE_COLLECT (&value, var_args, 0, &error);
+ if (error)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+
+ /* we purposely leak the value here, it might not be
+ * in a sane state if an error condition occoured
+ */
+ break;
+ }
+
+ element_set_property (element, pspec, &value);
+ g_value_unset (&value);
+
+ name = va_arg (var_args, gchar*);
+ }
+
+ g_object_unref (object);
+}
+
+/**
+ * gst_element_get_valist:
+ * @element: a #GstElement to get properties of.
+ * @first_property_name: the first property to get.
+ * @var_args: the var_args list of other properties to get.
+ *
+ * Gets properties from an element. If the element uses threadsafe properties,
+ * the element will be locked before getting the given properties.
+ */
+void
+gst_element_get_valist (GstElement *element, const gchar *first_property_name, va_list var_args)
+{
+ const gchar *name;
+ GObject *object;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ object = (GObject*)element;
+
+ if (!GST_FLAG_IS_SET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES)) {
+ g_object_get_valist (object, first_property_name, var_args);
+ return;
+ }
- GST_SCHEDULE_UNLOCK_ELEMENT (GST_ELEMENT_SCHED(object), GST_ELEMENT(object) );
+ g_object_ref (object);
+
+ name = first_property_name;
+
+ while (name)
+ {
+ GValue value = { 0, };
+ GParamSpec *pspec;
+ gchar *error;
+
+ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), name);
+
+ if (!pspec)
+ {
+ g_warning ("%s: object class `%s' has no property named `%s'",
+ G_STRLOC,
+ G_OBJECT_TYPE_NAME (object),
+ name);
+ break;
+ }
+ if (!(pspec->flags & G_PARAM_READABLE))
+ {
+ g_warning ("%s: property `%s' of object class `%s' is not readable",
+ G_STRLOC,
+ pspec->name,
+ G_OBJECT_TYPE_NAME (object));
+ break;
+ }
+
+ g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+
+ element_get_property (element, pspec, &value);
+
+ G_VALUE_LCOPY (&value, var_args, 0, &error);
+ if (error)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+ g_value_unset (&value);
+ break;
+ }
+
+ g_value_unset (&value);
+
+ name = va_arg (var_args, gchar*);
+ }
+
+ g_object_unref (object);
+}
+
+/**
+ * gst_element_set_property:
+ * @element: a #GstElement to set properties on.
+ * @property_name: the first property to get.
+ * @value: the #GValue that holds the value to set.
+ *
+ * Sets a property on an element. If the element uses threadsafe properties,
+ * the property will be put on the async queue.
+ */
+void
+gst_element_set_property (GstElement *element, const gchar *property_name,
+ const GValue *value)
+{
+ GParamSpec *pspec;
+ GObject *object;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+ g_return_if_fail (property_name != NULL);
+ g_return_if_fail (G_IS_VALUE (value));
+
+ object = (GObject*) element;
+
+ GST_DEBUG (GST_CAT_PROPERTIES, "setting property %s on element %s",
+ property_name, gst_element_get_name (element));
+ if (!GST_FLAG_IS_SET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES)) {
+ g_object_set_property (object, property_name, value);
+ return;
+ }
+
+ g_object_ref (object);
+
+ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object),
+ property_name);
+
+ if (!pspec)
+ g_warning ("%s: object class `%s' has no property named `%s'",
+ G_STRLOC,
+ G_OBJECT_TYPE_NAME (object),
+ property_name);
+ else
+ element_set_property (element, pspec, value);
+
+ g_object_unref (object);
+}
+
+/**
+ * gst_element_get_property:
+ * @element: a #GstElement to get properties of.
+ * @property_name: the first property to get.
+ * @value: the #GValue to store the property value in.
+ *
+ * Gets a property from an element. If the element uses threadsafe properties,
+ * the element will be locked before getting the given property.
+ */
+void
+gst_element_get_property (GstElement *element, const gchar *property_name, GValue *value)
+{
+ GParamSpec *pspec;
+ GObject *object;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+ g_return_if_fail (property_name != NULL);
+ g_return_if_fail (G_IS_VALUE (value));
+
+ object = (GObject*)element;
+
+ if (!GST_FLAG_IS_SET (element, GST_ELEMENT_USE_THREADSAFE_PROPERTIES)) {
+ g_object_get_property (object, property_name, value);
+ return;
+ }
+
+ g_object_ref (object);
+
+ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), property_name);
+
+ if (!pspec)
+ g_warning ("%s: object class `%s' has no property named `%s'",
+ G_STRLOC,
+ G_OBJECT_TYPE_NAME (object),
+ property_name);
+ else
+ {
+ GValue *prop_value, tmp_value = { 0, };
+
+ /* auto-conversion of the callers value type
+ */
+ if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
+ {
+ g_value_reset (value);
+ prop_value = value;
+ }
+ else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
+ {
+ g_warning ("can't retrieve property `%s' of type `%s' as value of type `%s'",
+ pspec->name,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ G_VALUE_TYPE_NAME (value));
+ g_object_unref (object);
+ return;
+ }
+ else
+ {
+ g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+ prop_value = &tmp_value;
+ }
+ element_get_property (element, pspec, prop_value);
+ if (prop_value != value)
+ {
+ g_value_transform (prop_value, value);
+ g_value_unset (&tmp_value);
+ }
+ }
+
+ g_object_unref (object);
+}
+
+static GstPad*
+gst_element_request_pad (GstElement *element, GstPadTemplate *templ, const gchar* name)
+{
+ GstPad *newpad = NULL;
+ GstElementClass *oclass;
+
+ oclass = CLASS (element);
+ if (oclass->request_new_pad)
+ newpad = (oclass->request_new_pad)(element, templ, name);
+
+ return newpad;
+}
+
+/**
+ * gst_element_release_request_pad:
+ * @element: a #GstElement to release the request pad of.
+ * @pad: the #GstPad to release.
+ *
+ * Makes the element free the previously requested pad as obtained
+ * with gst_element_get_request_pad().
+ */
+void
+gst_element_release_request_pad (GstElement *element, GstPad *pad)
+{
+ GstElementClass *oclass;
+
+ g_return_if_fail (GST_IS_ELEMENT (element));
+ g_return_if_fail (GST_IS_PAD (pad));
+
+ oclass = CLASS (element);
+ if (oclass->release_pad)
+ (oclass->release_pad) (element, pad);
}
/**
* gst_element_set_name:
- * @element: GstElement to set name of
- * @name: new name of element
+ * @element: a #GstElement to set the name of.
+ * @name: the new name of the element.
*
- * Set the name of the element, getting rid of the old name if there was
+ * Sets the name of the element, getting rid of the old name if there was
* one.
*/
void
{
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
+ * @element: a #GstElement to get the name of.
*
- * Get the name of the element.
+ * Gets the name of the element.
*
- * Returns: name of the element
+ * Returns: the name of the element.
*/
const gchar*
gst_element_get_name (GstElement *element)
/**
* gst_element_set_parent:
- * @element: GstElement to set parent of
- * @parent: new parent of the object
+ * @element: a #GstElement to set parent of.
+ * @parent: the new #GstObject parent of the object.
*
- * Set the parent of the element.
+ * Sets the parent of the element.
*/
void
gst_element_set_parent (GstElement *element, GstObject *parent)
/**
* gst_element_get_parent:
- * @element: GstElement to get the parent of
+ * @element: a #GstElement to get the parent of.
*
- * Get the parent of the element.
+ * Gets the parent of the element.
*
- * Returns: parent of the element
+ * Returns: the #GstObject parent of the element.
*/
GstObject*
gst_element_get_parent (GstElement *element)
}
/**
+ * gst_element_set_clock:
+ * @element: a #GstElement to set the clock for.
+ * @clock: the #GstClock to set for the element.
+ *
+ * Sets the clock for the element.
+ */
+void
+gst_element_set_clock (GstElement *element, GstClock *clock)
+{
+ g_return_if_fail (element != NULL);
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ if (element->setclockfunc)
+ element->setclockfunc (element, clock);
+
+ element->clock = clock;
+}
+
+/**
+ * gst_element_get_clock:
+ * @element: a #GstElement to get the clock of.
+ *
+ * Gets the clock of the element.
+ *
+ * Returns: the #GstClock of the element.
+ */
+GstClock*
+gst_element_get_clock (GstElement *element)
+{
+ g_return_val_if_fail (element != NULL, NULL);
+ g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
+
+ if (element->getclockfunc)
+ return element->getclockfunc (element);
+
+ return NULL;
+}
+
+/**
+ * gst_element_clock_wait:
+ * @element: a #GstElement.
+ * @clock: the #GstClock to use.
+ * @time: the #GstClockTime to wait for on the clock.
+ * @jitter: the difference between requested time and actual time.
+ *
+ * Waits for a specific time on the clock.
+ *
+ * Returns: the #GstClockReturn result of the wait operation.
+ */
+GstClockReturn
+gst_element_clock_wait (GstElement *element, GstClock *clock, GstClockTime time, GstClockTimeDiff *jitter)
+{
+ GstClockReturn res;
+
+ g_return_val_if_fail (element != NULL, GST_CLOCK_ERROR);
+ g_return_val_if_fail (GST_IS_ELEMENT (element), GST_CLOCK_ERROR);
+
+ if (GST_ELEMENT_SCHED (element)) {
+ res = gst_scheduler_clock_wait (GST_ELEMENT_SCHED (element), element, clock, time, jitter);
+ }
+ else
+ res = GST_CLOCK_TIMEOUT;
+
+ return res;
+}
+
+
+/**
+ * gst_element_release_locks:
+ * @element: a #GstElement to release all locks on.
+ *
+ * Instruct the element to release all the locks it is holding, such as
+ * blocking reads, waiting for the clock, ...
+ *
+ * Returns: TRUE if the locks could be released.
+ */
+gboolean
+gst_element_release_locks (GstElement *element)
+{
+ g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
+
+ if (CLASS (element)->release_locks)
+ return CLASS (element)->release_locks (element);
+
+ return TRUE;
+}
+
+/**
* gst_element_add_pad:
- * @element: element to add pad to
- * @pad: pad to add
+ * @element: a #GstElement to add the pad to.
+ * @pad: the #GstPad to add to the element.
*
* Add a pad (connection point) to the element, setting the parent of the
* pad to the element (and thus adding a reference).
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
- // first check to make sure the pad's parent is already set
+ /* 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
+ /* 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);
/* set the pad's parent */
- GST_DEBUG (GST_CAT_ELEMENT_PADS,"setting parent of pad '%s' to '%s'\n",
+ GST_DEBUG (GST_CAT_ELEMENT_PADS,"setting parent of pad '%s' to '%s'",
GST_PAD_NAME (pad), GST_ELEMENT_NAME (element));
gst_object_set_parent (GST_OBJECT (pad), GST_OBJECT (element));
/**
* gst_element_remove_pad:
- * @element: element to remove pad from
- * @pad: pad to remove
+ * @element: a #GstElement to remove pad from.
+ * @pad: the #GstPad to remove from the element.
*
- * Remove a pad (connection point) from the element,
+ * Remove a pad (connection point) from the element.
*/
void
gst_element_remove_pad (GstElement *element, GstPad *pad)
g_return_if_fail (GST_PAD_PARENT (pad) == element);
- /* add it to the list */
+ /* check to see if the pad is still connected */
+ /* FIXME: what if someone calls _remove_pad instead of
+ _remove_ghost_pad? */
+ if (GST_IS_REAL_PAD (pad)) {
+ g_return_if_fail (GST_RPAD_PEER (pad) == NULL);
+ }
+
+ /* remove it from the list */
element->pads = g_list_remove (element->pads, pad);
element->numpads--;
if (gst_pad_get_direction (pad) == GST_PAD_SRC)
/**
* gst_element_add_ghost_pad:
- * @element: element to add ghost pad to
- * @pad: pad from which the new ghost pad will be created
- * @name: name of the new ghost pad
+ * @element: a #GstElement to add the ghost pad to.
+ * @pad: the #GstPad from which the new ghost pad will be created.
+ * @name: the name of the new ghost pad.
*
- * Create a ghost pad from the given pad, and add it to the list of pads
+ * Creates a ghost pad from the given pad, and adds it to the list of pads
* for this element.
+ *
+ * Returns: the added ghost #GstPad, or NULL, if no ghost pad was created.
*/
-void
-gst_element_add_ghost_pad (GstElement *element, GstPad *pad, gchar *name)
+GstPad *
+gst_element_add_ghost_pad (GstElement *element, GstPad *pad, const gchar *name)
{
GstPad *ghostpad;
- 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_val_if_fail (element != NULL, NULL);
+ g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
+ g_return_val_if_fail (pad != NULL, NULL);
+ g_return_val_if_fail (GST_IS_PAD (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, name) == TRUE);
+ /* then check to see if there's already a pad by that name here */
+ g_return_val_if_fail (gst_object_check_uniqueness (element->pads, name) == TRUE, NULL);
- GST_DEBUG(GST_CAT_ELEMENT_PADS,"creating new ghost pad called %s, from pad %s:%s\n",
- name,GST_DEBUG_PAD_NAME(pad));
+ GST_DEBUG (GST_CAT_ELEMENT_PADS,
+ "creating new ghost pad called %s, from pad %s:%s",
+ name, GST_DEBUG_PAD_NAME(pad));
ghostpad = gst_ghost_pad_new (name, pad);
/* add it to the list */
- GST_DEBUG(GST_CAT_ELEMENT_PADS,"adding ghost pad %s to element %s\n",
+ GST_DEBUG(GST_CAT_ELEMENT_PADS,"adding ghost pad %s to element %s",
name, GST_ELEMENT_NAME (element));
element->pads = g_list_append (element->pads, ghostpad);
element->numpads++;
- // set the parent of the ghostpad
+ /* set the parent of the ghostpad */
gst_object_set_parent (GST_OBJECT (ghostpad), GST_OBJECT (element));
- GST_DEBUG(GST_CAT_ELEMENT_PADS,"added ghostpad %s:%s\n",GST_DEBUG_PAD_NAME(ghostpad));
+ GST_DEBUG(GST_CAT_ELEMENT_PADS,"added ghostpad %s:%s",GST_DEBUG_PAD_NAME(ghostpad));
/* emit the NEW_GHOST_PAD signal */
- g_signal_emit (G_OBJECT (element), gst_element_signals[NEW_GHOST_PAD], 0, ghostpad);
+ g_signal_emit (G_OBJECT (element), gst_element_signals[NEW_PAD], 0, ghostpad);
+
+ return ghostpad;
}
/**
* 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
+ * @element: a #GstElement to remove the ghost pad from.
+ * @pad: ghost #GstPad to remove.
*
+ * Removes a ghost pad from an element.
*/
void
gst_element_remove_ghost_pad (GstElement *element, GstPad *pad)
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_GHOST_PAD (pad));
- // FIXME this is redundant?
- // 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
+ /* FIXME this is redundant?
+ * 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);
}
/**
* gst_element_get_pad:
- * @element: element to find pad of
- * @name: name of pad to retrieve
+ * @element: a #GstElement to find pad of.
+ * @name: the name of the pad to retrieve.
*
- * Retrieve a pad from the element by name.
+ * Retrieves a pad from the element by name.
*
- * Returns: requested pad if found, otherwise NULL.
+ * Returns: requested #GstPad if found, otherwise NULL.
*/
GstPad*
gst_element_get_pad (GstElement *element, const gchar *name)
{
- GList *walk;
+ GstPad *pad;
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 there aren't any pads, well, we're not likely to find one
- if (!element->numpads)
- return NULL;
-
- // look through the list, matching by name
+ if ((pad = gst_element_get_static_pad (element, name)))
+ return pad;
+
+ pad = gst_element_get_request_pad (element, name);
+
+ return pad;
+}
+
+/**
+ * gst_element_get_static_pad:
+ * @element: a #GstElement to find a static pad of.
+ * @name: the name of the static #GstPad to retrieve.
+ *
+ * Retrieves a pad from the element by name. This version only retrieves
+ * already-existing (i.e. 'static') pads.
+ *
+ * Returns: the requested #GstPad if found, otherwise NULL.
+ */
+GstPad *
+gst_element_get_static_pad (GstElement *element, const gchar *name)
+{
+ GList *walk;
+
+ 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);
+
walk = element->pads;
while (walk) {
- GstPad *pad = GST_PAD(walk->data);
- if (!strcmp (GST_PAD_NAME(pad), name)) {
- GST_INFO(GST_CAT_ELEMENT_PADS,"found pad %s:%s",GST_DEBUG_PAD_NAME(pad));
+ GstPad *pad;
+
+ pad = GST_PAD(walk->data);
+ if (strcmp (GST_PAD_NAME(pad), name) == 0) {
+ GST_INFO (GST_CAT_ELEMENT_PADS, "found pad %s:%s", GST_DEBUG_PAD_NAME (pad));
return pad;
}
walk = g_list_next (walk);
}
- GST_INFO(GST_CAT_ELEMENT_PADS,"no such pad '%s' in element \"%s\"",name,GST_ELEMENT_NAME(element));
+ GST_INFO (GST_CAT_ELEMENT_PADS, "no such pad '%s' in element \"%s\"", name, GST_OBJECT_NAME (element));
return NULL;
}
/**
+ * gst_element_get_request_pad:
+ * @element: a #GstElement to find a request pad of.
+ * @name: the name of the request #GstPad to retrieve.
+ *
+ * Retrieves a pad from the element by name. This version only retrieves
+ * request pads.
+ *
+ * Returns: requested #GstPad if found, otherwise NULL.
+ */
+GstPad*
+gst_element_get_request_pad (GstElement *element, const gchar *name)
+{
+ GstPadTemplate *templ = NULL;
+ GstPad *pad;
+ const gchar *req_name = NULL;
+ gboolean templ_found = FALSE;
+ GList *list;
+ gint n;
+ const gchar *data;
+ gchar *str, *endptr = NULL;
+
+ 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 (strstr (name, "%")) {
+ templ = gst_element_get_pad_template (element, name);
+ req_name = NULL;
+ if (templ)
+ templ_found = TRUE;
+ } else {
+ list = gst_element_get_pad_template_list(element);
+ while (!templ_found && list) {
+ templ = (GstPadTemplate*) list->data;
+ if (templ->presence == GST_PAD_REQUEST) {
+ /* we know that %s and %d are the only possibilities because of sanity
+ checks in gst_pad_template_new */
+ GST_DEBUG (GST_CAT_PADS, "comparing %s to %s", name, templ->name_template);
+ if ((str = strchr (templ->name_template, '%')) &&
+ strncmp (templ->name_template, name, str - templ->name_template) == 0 &&
+ strlen (name) > str - templ->name_template) {
+ data = name + (str - templ->name_template);
+ if (*(str+1) == 'd') {
+ /* it's an int */
+ n = (gint) strtol (data, &endptr, 10);
+ if (endptr && *endptr == '\0') {
+ templ_found = TRUE;
+ req_name = name;
+ break;
+ }
+ } else {
+ /* it's a string */
+ templ_found = TRUE;
+ req_name = name;
+ break;
+ }
+ }
+ }
+ list = list->next;
+ }
+ }
+
+ if (!templ_found)
+ return NULL;
+
+ pad = gst_element_request_pad (element, templ, req_name);
+
+ return pad;
+}
+
+/**
* gst_element_get_pad_list:
- * @element: element to get pads of
+ * @element: a #GstElement to get pads of.
*
- * Retrieve a list of the pads associated with the element.
+ * Retrieves a list of the pads associated with the element.
*
- * Returns: GList of pads
+ * Returns: the #GList of pads.
*/
-GList*
+const GList*
gst_element_get_pad_list (GstElement *element)
{
g_return_val_if_fail (element != NULL, NULL);
}
/**
- * gst_element_class_add_padtemplate:
- * @klass: element class to add padtemplate to
- * @templ: padtemplate to add
+ * gst_element_class_add_pad_template:
+ * @klass: the #GstElementClass to add the pad template to.
+ * @templ: a #GstPadTemplate to add to the element class.
*
- * 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.
+ * Adds 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. Plug-in writers should use
+ * gst_element_factory_add_pad_template instead.
*/
void
-gst_element_class_add_padtemplate (GstElementClass *klass, GstPadTemplate *templ)
+gst_element_class_add_pad_template (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));
+ g_return_if_fail (GST_IS_PAD_TEMPLATE (templ));
klass->padtemplates = g_list_append (klass->padtemplates, templ);
klass->numpadtemplates++;
}
/**
- * gst_element_get_padtemplate_list:
- * @element: element to get padtemplates of
+ * gst_element_get_pad_template_list:
+ * @element: a #GstElement to get pad templates of.
*
- * Retrieve a list of the padtemplates associated with the element.
+ * Retrieves a list of the pad templates associated with the element.
*
- * Returns: GList of padtemplates
+ * Returns: the #GList of padtemplates.
*/
GList*
-gst_element_get_padtemplate_list (GstElement *element)
+gst_element_get_pad_template_list (GstElement *element)
{
- GstElementClass *oclass;
-
g_return_val_if_fail (element != NULL, NULL);
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
- oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
-
- return oclass->padtemplates;
+ return CLASS (element)->padtemplates;
}
/**
- * gst_element_get_padtemplate_by_name:
- * @element: element to get padtemplate of
- * @name: the name of the padtemplate to get.
+ * gst_element_get_pad_template:
+ * @element: a #GstElement to get the pad template of.
+ * @name: the name of the #GstPadTemplate to get.
*
- * Retrieve a padtemplate from this element with the
+ * Retrieves a padtemplate from this element with the
* given name.
*
- * Returns: the padtemplate with the given name
+ * Returns: the #GstPadTemplate with the given name, or NULL if none was found.
+ * No unreferencing is necessary.
*/
GstPadTemplate*
-gst_element_get_padtemplate_by_name (GstElement *element, const guchar *name)
+gst_element_get_pad_template (GstElement *element, const gchar *name)
{
GList *padlist;
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);
+ padlist = gst_element_get_pad_template_list (element);
while (padlist) {
GstPadTemplate *padtempl = (GstPadTemplate*) padlist->data;
}
/**
- * gst_element_get_padtemplate_by_compatible:
- * @element: element to get padtemplate of
- * @templ: a template to find a compatible template for
+ * gst_element_get_compatible_pad_template:
+ * @element: a #GstElement to get a compatible pad template for.
+ * @compattempl: the #GstPadTemplate to find a compatible template for.
*
- * Generate a padtemplate for this element compatible with the given
- * template, ie able to link to it.
+ * Generates a pad template for this element compatible with the given
+ * template (meaning it is able to connect with it).
*
- * Returns: the padtemplate
+ * Returns: the #GstPadTemplate of the element that is compatible with
+ * the given GstPadTemplate, or NULL if none was found. No unreferencing
+ * is necessary.
*/
-static GstPadTemplate*
-gst_element_get_padtemplate_by_compatible (GstElement *element, GstPadTemplate *compattempl)
+GstPadTemplate*
+gst_element_get_compatible_pad_template (GstElement *element,
+ GstPadTemplate *compattempl)
{
GstPadTemplate *newtempl = NULL;
GList *padlist;
- GST_DEBUG(GST_CAT_ELEMENT_PADS,"gst_element_get_padtemplate_by_compatible()\n");
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "gst_element_get_compatible_pad_template()");
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);
+ padlist = gst_element_get_pad_template_list (element);
while (padlist) {
GstPadTemplate *padtempl = (GstPadTemplate*) padlist->data;
- gboolean compat = FALSE;
-
- // Ignore name
- // Ignore presence
- // Check direction (must be opposite)
- // Check caps
-
- GST_DEBUG(GST_CAT_CAPS,"checking direction and caps\n");
+ gboolean comp = FALSE;
+
+ /* Ignore name
+ * Ignore presence
+ * Check direction (must be opposite)
+ * Check caps
+ */
+ GST_DEBUG (GST_CAT_CAPS, "checking direction and caps");
if (padtempl->direction == GST_PAD_SRC &&
compattempl->direction == GST_PAD_SINK) {
- GST_DEBUG(GST_CAT_CAPS,"compatible direction: found src pad template\n");
- compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (padtempl),
- GST_PADTEMPLATE_CAPS (compattempl));
- GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
+ GST_DEBUG (GST_CAT_CAPS, "compatible direction: found src pad template");
+ comp = gst_caps_is_always_compatible (GST_PAD_TEMPLATE_CAPS (padtempl),
+ GST_PAD_TEMPLATE_CAPS (compattempl));
+ GST_DEBUG(GST_CAT_CAPS, "caps are %scompatible", (comp ? "" : "not "));
} else if (padtempl->direction == GST_PAD_SINK &&
compattempl->direction == GST_PAD_SRC) {
- GST_DEBUG(GST_CAT_CAPS,"compatible direction: found sink pad template\n");
- compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (compattempl),
- GST_PADTEMPLATE_CAPS (padtempl));
- GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
+ GST_DEBUG (GST_CAT_CAPS, "compatible direction: found sink pad template");
+ comp = gst_caps_is_always_compatible (GST_PAD_TEMPLATE_CAPS (compattempl),
+ GST_PAD_TEMPLATE_CAPS (padtempl));
+ GST_DEBUG (GST_CAT_CAPS, "caps are %scompatible", (comp ? "" : "not "));
}
- if (compat) {
+ if (comp) {
newtempl = padtempl;
break;
}
return newtempl;
}
-static GstPad*
-gst_element_request_pad (GstElement *element, GstPadTemplate *templ)
-{
- GstPad *newpad = NULL;
- GstElementClass *oclass;
-
- oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
- if (oclass->request_new_pad)
- newpad = (oclass->request_new_pad)(element, templ);
-
- return newpad;
-}
-
/**
* 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
+ * @element: a #GstElement to request a new pad from.
+ * @templ: the #GstPadTemplate to which the new pad should be able to connect.
*
- * Request a new pad from the element. The template will
+ * Requests 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.
+ * Returns: the new #GstPad that was created, or NULL if none could be created.
*/
GstPad*
gst_element_request_compatible_pad (GstElement *element, GstPadTemplate *templ)
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);
+ templ_new = gst_element_get_compatible_pad_template (element, templ);
if (templ_new != NULL)
- pad = gst_element_request_pad (element, templ_new);
+ pad = gst_element_request_pad (element, templ_new, NULL);
return pad;
}
+
/**
- * gst_element_request_pad_by_name:
- * @element: element to request a new pad from
- * @name: the name of the padtemplate to use.
+ * gst_element_get_compatible_pad_filtered:
+ * @element: a #GstElement in which the pad should be found.
+ * @pad: the #GstPad to find a compatible one for.
+ * @filtercaps: the #GstCaps to use as a filter.
*
- * 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.
+ * Looks for an unconnected pad to which the given pad can connect to.
+ * It is not guaranteed that connecting the pads will work, though
+ * it should work in most cases.
*
- * Returns: the new pad that was created.
+ * Returns: the #GstPad to which a connection can be made.
*/
-GstPad*
-gst_element_request_pad_by_name (GstElement *element, const gchar *name)
+GstPad*
+gst_element_get_compatible_pad_filtered (GstElement *element, GstPad *pad,
+ GstCaps *filtercaps)
{
+ const GList *pads;
GstPadTemplate *templ;
- GstPad *pad;
-
+ GstCaps *templcaps;
+ GstPad *foundpad = NULL;
+
+ /* checks */
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);
+ g_return_val_if_fail (pad != NULL, NULL);
+ g_return_val_if_fail (GST_IS_PAD (pad), NULL);
+
+ /* let's use the real pad */
+ pad = (GstPad *) GST_PAD_REALIZE (pad);
+ g_return_val_if_fail (pad != NULL, NULL);
+ g_return_val_if_fail (GST_RPAD_PEER (pad) == NULL, NULL);
+
+ /* try to get an existing unconnected pad */
+ pads = gst_element_get_pad_list (element);
+ while (pads) {
+ GstPad *current = GST_PAD (pads->data);
+ if ((GST_PAD_PEER (GST_PAD_REALIZE (current)) == NULL) &&
+ gst_pad_can_connect_filtered (pad, current, filtercaps)) {
+ return current;
+ }
+ pads = g_list_next (pads);
+ }
+
+ /* try to create a new one */
+ /* requesting is a little crazy, we need a template. Let's create one */
+ if (filtercaps != NULL) {
+ templcaps = gst_caps_intersect (filtercaps, (GstCaps *) GST_RPAD_CAPS (pad));
+ if (templcaps == NULL)
+ return NULL;
+ } else {
+ templcaps = gst_caps_copy (gst_pad_get_caps (pad));
+ }
+
+ templ = gst_pad_template_new ((gchar *) GST_PAD_NAME (pad), GST_RPAD_DIRECTION (pad),
+ GST_PAD_ALWAYS, templcaps, NULL);
+ foundpad = gst_element_request_compatible_pad (element, templ);
+ gst_object_unref (GST_OBJECT (templ)); /* this will take care of the caps too */
+
+ /* FIXME: this is broken, but it's in here so autoplugging elements that don't
+ have caps on their source padtemplates (spider) can connect... */
+ if (!foundpad && !filtercaps) {
+ templ = gst_pad_template_new ((gchar *) GST_PAD_NAME (pad), GST_RPAD_DIRECTION (pad),
+ GST_PAD_ALWAYS, NULL, NULL);
+ foundpad = gst_element_request_compatible_pad (element, templ);
+ gst_object_unref (GST_OBJECT (templ));
+ }
+
+ return foundpad;
+}
- templ = gst_element_get_padtemplate_by_name (element, name);
- if (templ == NULL)
- return NULL;
+/**
+ * gst_element_get_compatible_pad:
+ * @element: a #GstElement in which the pad should be found.
+ * @pad: the #GstPad to find a compatible one for.
+ *
+ * Looks for an unconnected pad to which the given pad can connect to.
+ * It is not guaranteed that connecting the pads will work, though
+ * it should work in most cases.
+ *
+ * Returns: the #GstPad to which a connection can be made, or NULL if none
+ * could be found.
+ */
+GstPad*
+gst_element_get_compatible_pad (GstElement *element, GstPad *pad)
+{
+ return gst_element_get_compatible_pad_filtered (element, pad, NULL);
+}
+
+/**
+ * gst_element_connect_filtered:
+ * @src: a #GstElement containing the source pad.
+ * @dest: the #GstElement containing the destination pad.
+ * @filtercaps: the #GstCaps to use as a filter.
+ *
+ * Connects the source to the destination element using the filtercaps.
+ * The connection must be from source to destination, the other
+ * direction will not be tried.
+ * The functions looks for existing pads that aren't connected yet.
+ * It will use request pads if possible. But both pads will not be requested.
+ * If multiple connections are possible, only one is established.
+ *
+ * Returns: TRUE if the elements could be connected.
+ */
+gboolean
+gst_element_connect_filtered (GstElement *src, GstElement *dest,
+ GstCaps *filtercaps)
+{
+ const GList *srcpads, *destpads, *srctempls, *desttempls, *l;
+ GstPad *srcpad, *destpad;
+ GstPadTemplate *srctempl, *desttempl;
+
+ /* checks */
+ g_return_val_if_fail (src != NULL, FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (src), FALSE);
+ g_return_val_if_fail (dest != NULL, FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (dest), FALSE);
+
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "trying to connect element %s to element %s",
+ GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
+
+ srcpads = gst_element_get_pad_list (src);
+ destpads = gst_element_get_pad_list (dest);
+
+ if (srcpads || destpads) {
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "looping through src and dest pads");
+ /* loop through the existing pads in the source, trying to find a
+ * compatible destination pad */
+ while (srcpads) {
+ srcpad = (GstPad *) GST_PAD_REALIZE (srcpads->data);
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "trying src pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad));
+ if ((GST_RPAD_DIRECTION (srcpad) == GST_PAD_SRC) &&
+ (GST_PAD_PEER (srcpad) == NULL)) {
+ destpad = gst_element_get_compatible_pad_filtered (dest, srcpad,
+ filtercaps);
+ if (destpad && gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
+ return TRUE;
+ }
+ }
+ srcpads = g_list_next (srcpads);
+ }
+
+ /* loop through the existing pads in the destination */
+ while (destpads) {
+ destpad = (GstPad *) GST_PAD_REALIZE (destpads->data);
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "trying dest pad %s:%s",
+ GST_DEBUG_PAD_NAME (destpad));
+ if ((GST_RPAD_DIRECTION (destpad) == GST_PAD_SINK) &&
+ (GST_PAD_PEER (destpad) == NULL)) {
+ srcpad = gst_element_get_compatible_pad_filtered (src, destpad,
+ filtercaps);
+ if (srcpad && gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
+ return TRUE;
+ }
+ }
+ destpads = g_list_next (destpads);
+ }
+ }
- pad = gst_element_request_pad (element, templ);
+ GST_DEBUG (GST_CAT_ELEMENT_PADS,
+ "we might have request pads on both sides, checking...");
+ srctempls = gst_element_get_pad_template_list (src);
+ desttempls = gst_element_get_pad_template_list (dest);
+
+ if (srctempls && desttempls) {
+ while (srctempls) {
+ srctempl = (GstPadTemplate*) srctempls->data;
+ if (srctempl->presence == GST_PAD_REQUEST) {
+ for (l=desttempls; l; l=l->next) {
+ desttempl = (GstPadTemplate*) desttempls->data;
+ if (desttempl->presence == GST_PAD_REQUEST &&
+ desttempl->direction != srctempl->direction) {
+ if (gst_caps_is_always_compatible (gst_pad_template_get_caps (srctempl),
+ gst_pad_template_get_caps (desttempl))) {
+ srcpad = gst_element_get_request_pad (src,
+ srctempl->name_template);
+ destpad = gst_element_get_request_pad (dest,
+ desttempl->name_template);
+ if (gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
+ GST_DEBUG (GST_CAT_ELEMENT_PADS,
+ "connected pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad),
+ GST_DEBUG_PAD_NAME (destpad));
+ return TRUE;
+ }
+ /* FIXME: we have extraneous request pads lying around */
+ }
+ }
+ }
+ }
+ srctempls = srctempls->next;
+ }
+ }
+
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "no connection possible from %s to %s",
+ GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
+ return FALSE;
+}
- return pad;
+/**
+ * gst_element_connect_many:
+ * @element_1: the first #GstElement in the connection chain.
+ * @element_2: the second #GstElement in the connection chain.
+ * @...: the NULL-terminated list of elements to connect in order.
+ *
+ * Chain together a series of elements. Uses #gst_element_connect.
+ *
+ * Returns: TRUE on success, FALSE otherwise.
+ */
+gboolean
+gst_element_connect_many (GstElement *element_1, GstElement *element_2, ...)
+{
+ va_list args;
+
+ g_return_val_if_fail (element_1 != NULL && element_2 != NULL, FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (element_1) &&
+ GST_IS_ELEMENT (element_2), FALSE);
+
+ va_start (args, element_2);
+
+ while (element_2) {
+ if (!gst_element_connect (element_1, element_2))
+ return FALSE;
+
+ element_1 = element_2;
+ element_2 = va_arg (args, GstElement*);
+ }
+
+ va_end (args);
+
+ return TRUE;
}
/**
* 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
+ * @src: a #GstElement containing the source pad.
+ * @dest: the #GstElement containing the destination pad.
+ *
+ * Connects the source to the destination element.
+ * The connection must be from source to destination, the other
+ * direction will not be tried.
+ * The functions looks for existing pads and request pads that aren't
+ * connected yet. If multiple connections are possible, only one is
+ * established.
+ *
+ * Returns: TRUE if the elements could be connected.
+ */
+gboolean
+gst_element_connect (GstElement *src, GstElement *dest)
+{
+ return gst_element_connect_filtered (src, dest, NULL);
+}
+
+/**
+ * gst_element_connect_pads_filtered:
+ * @src: a #GstElement containing the source pad.
+ * @srcpadname: the name of the #GstPad in source element.
+ * @dest: the #GstElement containing the destination pad.
+ * @destpadname: the name of the #GstPad in destination element.
+ * @filtercaps: the #GstCaps to use as a filter.
*
- * Connect the two named pads of the source and destination elements.
+ * Connects 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.
+ *
+ * Returns: TRUE if the pads could be connected.
*/
-void
-gst_element_connect (GstElement *src, const gchar *srcpadname,
- GstElement *dest, const gchar *destpadname)
+gboolean
+gst_element_connect_pads_filtered (GstElement *src, const gchar *srcpadname,
+ GstElement *dest, const gchar *destpadname,
+ GstCaps *filtercaps)
{
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);
+ g_return_val_if_fail (src != NULL, FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (src), FALSE);
+ g_return_val_if_fail (srcpadname != NULL, FALSE);
+ g_return_val_if_fail (dest != NULL, FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (dest), FALSE);
+ g_return_val_if_fail (destpadname != NULL, FALSE);
/* 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;
+ GST_ERROR (src, "source element has no pad \"%s\"", srcpadname);
+ return FALSE;
}
destpad = gst_element_get_pad (dest, destpadname);
if (srcpad == NULL) {
- GST_ERROR(dest,"destination element has no pad \"%s\"",destpadname);
- return;
+ GST_ERROR (dest, "destination element has no pad \"%s\"", destpadname);
+ return FALSE;
}
/* we're satisified they can be connected, let's do it */
- gst_pad_connect(srcpad,destpad);
+ return gst_pad_connect_filtered (srcpad, destpad, filtercaps);
}
/**
- * 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
+ * gst_element_connect_pads:
+ * @src: a #GstElement containing the source pad.
+ * @srcpadname: the name of the #GstPad in the source element.
+ * @dest: the #GstElement containing the destination pad.
+ * @destpadname: the name of the #GstPad in destination element.
*
- * Disconnect the two named pads of the source and destination elements.
+ * Connects 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.
+ *
+ * Returns: TRUE if the pads could be connected.
+ */
+gboolean
+gst_element_connect_pads (GstElement *src, const gchar *srcpadname,
+ GstElement *dest, const gchar *destpadname)
+{
+ return gst_element_connect_pads_filtered (src, srcpadname, dest, destpadname, NULL);
+}
+
+/**
+ * gst_element_disconnect_pads:
+ * @src: a #GstElement containing the source pad.
+ * @srcpadname: the name of the #GstPad in source element.
+ * @dest: a #GstElement containing the destination pad.
+ * @destpadname: the name of the #GstPad in destination element.
+ *
+ * Disconnects the two named pads of the source and destination elements.
*/
void
-gst_element_disconnect (GstElement *src, const gchar *srcpadname,
- GstElement *dest, const gchar *destpadname)
+gst_element_disconnect_pads (GstElement *src, const gchar *srcpadname,
+ GstElement *dest, const gchar *destpadname)
{
GstPad *srcpad,*destpad;
}
/**
+ * gst_element_disconnect_many:
+ * @element_1: the first #GstElement in the connection chain.
+ * @element_2: the second #GstElement in the connection chain.
+ * @...: the NULL-terminated list of elements to disconnect in order.
+ *
+ * Disconnects a series of elements. Uses #gst_element_disconnect.
+ */
+void
+gst_element_disconnect_many (GstElement *element_1, GstElement *element_2, ...)
+{
+ va_list args;
+
+ g_return_if_fail (element_1 != NULL && element_2 != NULL);
+ g_return_if_fail (GST_IS_ELEMENT (element_1) && GST_IS_ELEMENT (element_2));
+
+ va_start (args, element_2);
+
+ while (element_2) {
+ gst_element_disconnect (element_1, element_2);
+
+ element_1 = element_2;
+ element_2 = va_arg (args, GstElement*);
+ }
+
+ va_end (args);
+}
+
+/**
+ * gst_element_disconnect:
+ * @src: the source #GstElement to disconnect.
+ * @dest: the sink #GstElement to disconnect.
+ *
+ * Disconnects all source pads of the source element with all sink pads
+ * of the sink element to which they are connected.
+ */
+void
+gst_element_disconnect (GstElement *src, GstElement *dest)
+{
+ const GList *srcpads;
+ GstPad *pad;
+
+ g_return_if_fail (GST_IS_ELEMENT (src));
+ g_return_if_fail (GST_IS_ELEMENT (dest));
+
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "disconnecting \"%s\" and \"%s\"",
+ GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
+
+ srcpads = gst_element_get_pad_list (src);
+
+ while (srcpads) {
+ pad = GST_PAD_CAST (srcpads->data);
+
+ if (GST_IS_REAL_PAD (pad) && GST_PAD_DIRECTION (pad) == GST_PAD_SRC) {
+ GstPad *peerpad = GST_PAD_PEER (pad);
+
+ if (peerpad &&
+ (GST_OBJECT_PARENT (GST_PAD_PEER (peerpad)) == (GstObject*) src)) {
+ gst_pad_disconnect (pad, peerpad);
+ }
+ }
+
+ srcpads = g_list_next (srcpads);
+ }
+}
+
+static void
+gst_element_error_func (GstElement* element, GstElement *source,
+ gchar *errormsg)
+{
+ /* tell the parent */
+ if (GST_OBJECT_PARENT (element)) {
+ GST_DEBUG (GST_CAT_EVENT, "forwarding error \"%s\" from %s to %s",
+ errormsg, GST_ELEMENT_NAME (element),
+ GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
+
+ gst_object_ref (GST_OBJECT (element));
+ g_signal_emit (G_OBJECT (GST_OBJECT_PARENT (element)),
+ gst_element_signals[ERROR], 0, source, errormsg);
+ gst_object_unref (GST_OBJECT (element));
+ }
+}
+
+static gboolean
+gst_element_send_event_default (GstElement *element, GstEvent *event)
+{
+ GList *pads = element->pads;
+ gboolean res = FALSE;
+
+ while (pads) {
+ GstPad *pad = GST_PAD_CAST (pads->data);
+
+ if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
+ if (GST_PAD_IS_USABLE (pad)) {
+ res = gst_pad_send_event (GST_PAD_PEER (pad), event);
+ break;
+ }
+ }
+ pads = g_list_next (pads);
+ }
+ return res;
+}
+
+/**
+ * gst_element_send_event:
+ * @element: a #GstElement to send the event to.
+ * @event: the #GstEvent to send to the element.
+ *
+ * Sends an event to an element. If the element doesn't
+ * implement an event handler, the event will be forwarded
+ * to a random sink pad.
+ *
+ * Returns: TRUE if the event was handled.
+ */
+gboolean
+gst_element_send_event (GstElement *element, GstEvent *event)
+{
+ g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ if (CLASS (element)->send_event)
+ return CLASS (element)->send_event (element, event);
+
+ return FALSE;
+}
+
+static gboolean
+gst_element_query_default (GstElement *element, GstPadQueryType type,
+ GstFormat *format, gint64 *value)
+{
+ GList *pads = element->pads;
+ gboolean res = FALSE;
+
+ while (pads) {
+ GstPad *pad = GST_PAD_CAST (pads->data);
+
+ if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
+ if (GST_PAD_IS_USABLE (pad)) {
+ res = gst_pad_query (GST_PAD_PEER (pad), type, format, value);
+ break;
+ }
+ }
+ pads = g_list_next (pads);
+ }
+ return res;
+}
+
+/**
+ * gst_element_query:
+ * @element: a #GstElement to perform the query on.
+ * @type: the #GstPadQueryType.
+ * @format: the #GstFormat pointer to hold the format of the result.
+ * @value: the pointer to the value of the result.
+ *
+ * Performs a query on the given element. If the format is set
+ * to GST_FORMAT_DEFAULT and this function returns TRUE, the
+ * format pointer will hold the default format.
+ * For element that don't implement a query handler, this function
+ * forwards the query to a random connected sinkpad of this element.
+ *
+ * Returns: TRUE if the query could be performed.
+ */
+gboolean
+gst_element_query (GstElement *element, GstPadQueryType type,
+ GstFormat *format, gint64 *value)
+{
+ g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
+ g_return_val_if_fail (format != NULL, FALSE);
+ g_return_val_if_fail (value != NULL, FALSE);
+
+ if (CLASS (element)->query)
+ return CLASS (element)->query (element, type, format, value);
+
+ return FALSE;
+}
+
+/**
* gst_element_error:
- * @element: Element with the error
- * @error: String describing the error
+ * @element: a #GstElement with the error.
+ * @error: the printf-style string describing the error.
+ * @...: the optional arguments for the string.
*
- * This function is used internally by elements to signal an error
- * condition. It results in the "error" signal.
+ * signals an error condition on an element.
+ * This function is used internally by elements.
+ * It results in the "error" signal.
*/
void
-gst_element_error (GstElement *element, const gchar *error)
+gst_element_error (GstElement *element, const gchar *error, ...)
{
- g_error("GstElement: error in element '%s': %s\n", GST_ELEMENT_NAME(element), error);
+ va_list var_args;
+ gchar *string;
+
+ /* checks */
+ g_return_if_fail (GST_IS_ELEMENT (element));
+ g_return_if_fail (error != NULL);
- /* FIXME: this is not finished!!! */
+ /* create error message */
+ va_start (var_args, error);
+ string = g_strdup_vprintf (error, var_args);
+ va_end (var_args);
+ GST_INFO (GST_CAT_EVENT, "ERROR in %s: %s", GST_ELEMENT_NAME (element), string);
- g_signal_emit (G_OBJECT (element), gst_element_signals[ERROR], 0, error);
+ /* emit the signal, make sure the element stays available */
+ gst_object_ref (GST_OBJECT (element));
+ g_signal_emit (G_OBJECT (element), gst_element_signals[ERROR], 0, element, string);
+
+ /* tell the scheduler */
+ if (element->sched) {
+ gst_scheduler_error (element->sched, element);
+ }
+
+ /* cleanup */
+ gst_object_unref (GST_OBJECT (element));
+ g_free (string);
}
+/**
+ * gst_element_get_state:
+ * @element: a #GstElement to get the state of.
+ *
+ * Gets the state of the element.
+ *
+ * Returns: the #GstElementState of the element.
+ */
+GstElementState
+gst_element_get_state (GstElement *element)
+{
+ g_return_val_if_fail (GST_IS_ELEMENT (element), GST_STATE_VOID_PENDING);
+
+ return GST_STATE (element);
+}
+
+/**
+ * gst_element_wait_state_change:
+ * @element: a #GstElement to wait for a state change on.
+ *
+ * Waits and blocks until the element changed its state.
+ */
+void
+gst_element_wait_state_change (GstElement *element)
+{
+ g_mutex_lock (element->state_mutex);
+ g_cond_wait (element->state_cond, element->state_mutex);
+ g_mutex_unlock (element->state_mutex);
+}
/**
* gst_element_set_state:
- * @element: element to change state of
- * @state: new element state
+ * @element: a #GstElement to change state of.
+ * @state: the element's new #GstElementState.
*
- * Sets the state of the element. This function will only set
- * the elements pending state.
+ * Sets the state of the element. This function will try to set the
+ * requested state by going through all the intermediary states and calling
+ * the class's state change function for each.
*
- * Returns: whether or not the state was successfully set.
+ * Returns: TRUE if the state was successfully set.
+ * (using #GstElementStateReturn).
*/
gint
gst_element_set_state (GstElement *element, GstElementState state)
GstElementState curpending;
GstElementStateReturn return_val = GST_STATE_SUCCESS;
-// g_print("gst_element_set_state(\"%s\",%08lx)\n",
-// element->name,state);
-
- g_return_val_if_fail (element != NULL, GST_STATE_FAILURE);
g_return_val_if_fail (GST_IS_ELEMENT (element), GST_STATE_FAILURE);
- 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));
/* start with the current state */
curpending = GST_STATE(element);
+ GST_DEBUG_ELEMENT (GST_CAT_STATES, element, "setting state from %s to %s",
+ gst_element_state_get_name (curpending),
+ gst_element_state_get_name (state));
+
/* loop until the final requested state is set */
- while (GST_STATE(element) != state) {
+ while (GST_STATE (element) != state
+ && GST_STATE (element) != GST_STATE_VOID_PENDING) {
/* move the curpending state in the correct direction */
- if (curpending < state) curpending<<=1;
- else curpending>>=1;
+ if (curpending < state)
+ curpending <<= 1;
+ else
+ curpending >>= 1;
/* set the pending state variable */
- // FIXME: should probably check to see that we don't already have one
+ /* FIXME: should probably check to see that we don't already have one */
GST_STATE_PENDING (element) = curpending;
- if (curpending != state)
- GST_DEBUG_ELEMENT (GST_CAT_STATES,element,"intermediate: setting state to %s\n",
- gst_element_statename(curpending));
-
- /* call the state change function so it can set the state */
- oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
- if (oclass->change_state)
- return_val = (oclass->change_state)(element);
- /* if that outright didn't work, we need to bail right away */
- /* NOTE: this will bail on ASYNC as well! */
- if (return_val == GST_STATE_FAILURE) {
- GST_DEBUG_ELEMENT (GST_CAT_STATES,element,"have failed change_state return\n");
- return return_val;
+ if (curpending != state) {
+ GST_DEBUG_ELEMENT (GST_CAT_STATES, element,
+ "intermediate: setting state from %s to %s",
+ gst_element_state_get_name (GST_STATE (element)),
+ gst_element_state_get_name (curpending));
}
- /* 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;
+ /* call the state change function so it can set the state */
+ oclass = CLASS (element);
+ if (oclass->change_state)
+ return_val = (oclass->change_state) (element);
+
+ switch (return_val) {
+ case GST_STATE_FAILURE:
+ GST_DEBUG_ELEMENT (GST_CAT_STATES, element,
+ "have failed change_state return");
+ goto exit;
+ case GST_STATE_ASYNC:
+ GST_DEBUG_ELEMENT (GST_CAT_STATES, element,
+ "element will change state async");
+ goto exit;
+ case GST_STATE_SUCCESS:
+ /* 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 %s, %s <-> %s",
+ gst_element_state_get_name (GST_STATE (element)),
+ gst_element_state_get_name (GST_STATE_PENDING (element)),
+ gst_element_state_get_name (curpending));
+ return GST_STATE_FAILURE;
+ }
+ break;
+ default:
+ /* somebody added a GST_STATE_ and forgot to do stuff here ! */
+ g_assert_not_reached ();
}
}
+exit:
- /* this is redundant, really, it will always return SUCCESS */
return return_val;
}
-/**
- * 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
- */
-GstElementFactory*
-gst_element_get_factory (GstElement *element)
+static gboolean
+gst_element_negotiate_pads (GstElement *element)
{
- GstElementClass *oclass;
+ GList *pads = GST_ELEMENT_PADS (element);
- g_return_val_if_fail (element != NULL, NULL);
- g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
+ GST_DEBUG_ELEMENT (GST_CAT_CAPS, element, "negotiating pads");
- oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
+ while (pads) {
+ GstPad *pad = GST_PAD (pads->data);
+ GstRealPad *srcpad;
- return oclass->elementfactory;
+ pads = g_list_next (pads);
+
+ if (!GST_IS_REAL_PAD (pad))
+ continue;
+
+ srcpad = GST_PAD_REALIZE (pad);
+
+ /* if we have a connection on this pad and it doesn't have caps
+ * allready, try to negotiate */
+ if (GST_PAD_IS_USABLE (srcpad) && !GST_PAD_CAPS (srcpad)) {
+ GstRealPad *sinkpad;
+ GstElementState otherstate;
+ GstElement *parent;
+
+ sinkpad = GST_RPAD_PEER (GST_PAD_REALIZE (srcpad));
+
+ /* check the parent of the peer pad, if there is no parent do nothing */
+ parent = GST_PAD_PARENT (sinkpad);
+ if (!parent)
+ continue;
+
+ otherstate = GST_STATE (parent);
+
+ /* swap pads if needed */
+ if (!GST_PAD_IS_SRC (srcpad)) {
+ GstRealPad *temp;
+
+ temp = srcpad;
+ srcpad = sinkpad;
+ sinkpad = temp;
+ }
+
+ /* only try to negotiate if the peer element is in PAUSED or higher too */
+ if (otherstate >= GST_STATE_READY) {
+ GST_DEBUG_ELEMENT (GST_CAT_CAPS, element,
+ "perform negotiate for %s:%s and %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad),
+ GST_DEBUG_PAD_NAME (sinkpad));
+ if (!gst_pad_perform_negotiate (GST_PAD (srcpad), GST_PAD (sinkpad)))
+ return FALSE;
+ }
+ else {
+ GST_DEBUG_ELEMENT (GST_CAT_CAPS, element,
+ "not negotiating %s:%s and %s:%s, not in READY yet",
+ GST_DEBUG_PAD_NAME (srcpad),
+ GST_DEBUG_PAD_NAME (sinkpad));
+ }
+ }
+ }
+
+ return TRUE;
}
+static void
+gst_element_clear_pad_caps (GstElement *element)
+{
+ GList *pads = GST_ELEMENT_PADS (element);
-/**
- * gst_element_change_state:
- * @element: element to change state of
- *
- * Changes the state of the element, but more importantly fires off a signal
- * indicating the new state.
- * The element will have no pending states anymore.
- *
- * Returns: whether or not the state change was successfully set.
- */
-GstElementStateReturn
+ GST_DEBUG_ELEMENT (GST_CAT_CAPS, element, "clearing pad caps");
+
+ while (pads) {
+ GstRealPad *pad = GST_PAD_REALIZE (pads->data);
+
+ if (GST_PAD_CAPS (pad)) {
+ GST_PAD_CAPS (pad) = NULL;
+ }
+ pads = g_list_next (pads);
+ }
+}
+
+static GstElementStateReturn
gst_element_change_state (GstElement *element)
{
- g_return_val_if_fail (element != NULL, GST_STATE_FAILURE);
+ GstElementState old_state;
+ GstObject *parent;
+ gint old_pending, old_transition;
+
g_return_val_if_fail (GST_IS_ELEMENT (element), GST_STATE_FAILURE);
-// GST_DEBUG_ELEMENT (GST_CAT_STATES, element, "default handler sets state to %s\n",
-// gst_element_statename(GST_STATE_PENDING(element)));
+ old_state = GST_STATE (element);
+ old_pending = GST_STATE_PENDING (element);
+ old_transition = GST_STATE_TRANSITION (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))
- GST_DEBUG(GST_CAT_STATES,"PAUSED->PLAYING: element \"%s\" has parent \"%s\" and sched %p\n",
-GST_ELEMENT_NAME(element),GST_ELEMENT_NAME(GST_ELEMENT_PARENT(element)),GST_ELEMENT_SCHED(element));
- GST_SCHEDULE_ENABLE_ELEMENT (element->sched,element);
+ if (old_pending == GST_STATE_VOID_PENDING ||
+ old_state == GST_STATE_PENDING (element)) {
+ GST_INFO (GST_CAT_STATES,
+ "no state change needed for element %s (VOID_PENDING)",
+ GST_ELEMENT_NAME (element));
+ return GST_STATE_SUCCESS;
}
- else if (GST_STATE_TRANSITION(element) == GST_STATE_PLAYING_TO_PAUSED) {
- if (GST_ELEMENT_PARENT(element))
- GST_DEBUG(GST_CAT_STATES,"PLAYING->PAUSED: element \"%s\" has parent \"%s\" and sched %p\n",
-GST_ELEMENT_NAME(element),GST_ELEMENT_NAME(GST_ELEMENT_PARENT(element)),GST_ELEMENT_SCHED(element));
- GST_SCHEDULE_DISABLE_ELEMENT (element->sched,element);
+
+ GST_INFO (GST_CAT_STATES, "%s default handler sets state from %s to %s %d",
+ GST_ELEMENT_NAME (element),
+ gst_element_state_get_name (old_state),
+ gst_element_state_get_name (old_pending),
+ GST_STATE_TRANSITION (element));
+
+ /* we set the state change early for the negotiation functions */
+ GST_STATE (element) = old_pending;
+ GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;
+
+ switch (old_transition) {
+ /* if we are going to paused, we try to negotiate the pads */
+ case GST_STATE_READY_TO_PAUSED:
+ if (!gst_element_negotiate_pads (element))
+ goto failure;
+ break;
+ /* going to the READY state clears all pad caps */
+ case GST_STATE_PAUSED_TO_READY:
+ gst_element_clear_pad_caps (element);
+ break;
+ default:
+ break;
}
- GST_STATE (element) = GST_STATE_PENDING (element);
- GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;
+ /* tell the scheduler if we have one */
+ if (element->sched) {
+ if (gst_scheduler_state_transition (element->sched, element,
+ old_transition) != GST_STATE_SUCCESS) {
+ goto failure;
+ }
+ }
+
+ parent = GST_ELEMENT_PARENT (element);
+
+ GST_DEBUG_ELEMENT (GST_CAT_STATES, element,
+ "signaling state change from %s to %s",
+ gst_element_state_get_name (old_state),
+ gst_element_state_get_name (GST_STATE (element)));
+ g_signal_emit (G_OBJECT (element), gst_element_signals[STATE_CHANGE],
+ 0, old_state, GST_STATE (element));
+
+ /* tell our parent about the state change */
+ if (parent && GST_IS_BIN (parent)) {
+ gst_bin_child_state_change (GST_BIN (parent), old_state,
+ GST_STATE (element), element);
+ }
+
+ /* signal the state change in case somebody is waiting for us */
+ g_mutex_lock (element->state_mutex);
+ g_cond_signal (element->state_cond);
+ g_mutex_unlock (element->state_mutex);
- // 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.
- g_signal_emit (G_OBJECT (element), gst_element_signals[STATE_CHANGE], 0,
- GST_STATE (element));
return GST_STATE_SUCCESS;
+
+failure:
+ /* undo the state change */
+ GST_STATE (element) = old_state;
+ GST_STATE_PENDING (element) = old_pending;
+
+ return GST_STATE_FAILURE;
}
-static void
-gst_element_shutdown (GObject *object)
+/**
+ * gst_element_get_factory:
+ * @element: a #GstElement to request the element factory of.
+ *
+ * Retrieves the factory that was used to create this element.
+ *
+ * Returns: the #GstElementFactory used for creating this element.
+ */
+GstElementFactory*
+gst_element_get_factory (GstElement *element)
{
- GstElement *element = GST_ELEMENT (object);
+ GstElementClass *oclass;
- GST_DEBUG_ELEMENT (GST_CAT_REFCOUNTING, element, "shutdown\n");
+ g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
- if (GST_IS_BIN (GST_OBJECT_PARENT (element)))
- gst_bin_remove (GST_BIN (GST_OBJECT_PARENT (element)), element);
+ oclass = CLASS (element);
-// if (G_OBJECT_CLASS (parent_class)->shutdown)
-// G_OBJECT_CLASS (parent_class)->shutdown (G_OBJECT (object));
+ return oclass->elementfactory;
}
static void
-gst_element_real_destroy (GObject *object)
+gst_element_dispose (GObject *object)
{
GstElement *element = GST_ELEMENT (object);
GList *pads;
GstPad *pad;
+
+ GST_DEBUG_ELEMENT (GST_CAT_REFCOUNTING, element, "dispose");
- GST_DEBUG_ELEMENT (GST_CAT_REFCOUNTING, element, "destroy\n");
+ gst_element_set_state (element, GST_STATE_NULL);
+ /* first we break all our connections with the ouside */
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));
+
+ if (GST_PAD_PEER (pad)) {
+ GST_DEBUG (GST_CAT_REFCOUNTING, "disconnecting pad '%s'",
+ GST_OBJECT_NAME (GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
+ gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
+ }
gst_element_remove_pad (element, pad);
- gst_object_unref (GST_OBJECT (pad));
+
pads = g_list_next (pads);
}
g_list_free (orig);
element->numsrcpads = 0;
element->numsinkpads = 0;
-
-// FIXME!
-// if (G_OBJECT_CLASS (parent_class)->destroy)
-// G_OBJECT_CLASS (parent_class)->destroy (object);
-}
-
-/*
-static gchar *_gst_element_type_names[] = {
- "invalid",
- "none",
- "char",
- "uchar",
- "bool",
- "int",
- "uint",
- "long",
- "ulong",
- "float",
- "double",
- "string",
-};
-*/
+ element->numpads = 0;
+ g_mutex_free (element->state_mutex);
+ g_cond_free (element->state_cond);
+
+ if (element->prop_value_queue)
+ g_async_queue_unref (element->prop_value_queue);
+ element->prop_value_queue = NULL;
+ if (element->property_mutex)
+ g_mutex_free (element->property_mutex);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
#ifndef GST_DISABLE_LOADSAVE
/**
* gst_element_save_thyself:
- * @element: GstElement to save
- * @parent: the xml parent node
+ * @element: a #GstElement to save.
+ * @parent: the xml parent node.
*
- * Saves the element as part of the given XML structure
+ * Saves the element as part of the given XML structure.
*
- * Returns: the new xml node
+ * Returns: the new #xmlNodePtr.
*/
static xmlNodePtr
gst_element_save_thyself (GstObject *object,
{
GList *pads;
GstElementClass *oclass;
-// GType type;
+ GParamSpec **specs, *spec;
+ gint nspecs, i;
+ GValue value = { 0, };
GstElement *element;
g_return_val_if_fail (GST_IS_ELEMENT (object), parent);
element = GST_ELEMENT (object);
- oclass = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS(element));
+ oclass = CLASS (element);
xmlNewChild(parent, NULL, "name", GST_ELEMENT_NAME(element));
xmlNewChild (parent, NULL, "version", factory->details->version);
}
-// if (element->manager)
-// xmlNewChild(parent, NULL, "manager", GST_ELEMENT_NAME(element->manager));
-
-/* FIXME FIXME FIXME!
- // output all args to the element
- type = G_OBJECT_TYPE (element);
- while (type != G_TYPE_INVALID) {
- GtkArg *args;
- guint32 *flags;
- guint num_args,i;
-
- args = gtk_object_query_args (type, &flags, &num_args);
-
- for (i=0; i<num_args; i++) {
- if ((args[i].type > G_TYPE_NONE) &&
- (flags[i] & GTK_ARG_READABLE)) {
- xmlNodePtr arg;
- gtk_object_getv (G_OBJECT (element), 1, &args[i]);
- arg = xmlNewChild (parent, NULL, "arg", NULL);
- xmlNewChild (arg, NULL, "name", args[i].name);
- switch (args[i].type) {
- case G_TYPE_CHAR:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%c", G_VALUE_CHAR (args[i])));
- break;
- case G_TYPE_UCHAR:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%d", G_VALUE_UCHAR (args[i])));
- break;
- case G_TYPE_BOOL:
- xmlNewChild (arg, NULL, "value",
- G_VALUE_BOOL (args[i]) ? "true" : "false");
- break;
- case G_TYPE_INT:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%d", G_VALUE_INT (args[i])));
- break;
- case G_TYPE_LONG:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%ld", G_VALUE_LONG (args[i])));
- break;
- case G_TYPE_ULONG:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%lu", G_VALUE_ULONG (args[i])));
- break;
- case G_TYPE_FLOAT:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%f", G_VALUE_FLOAT (args[i])));
- break;
- case G_TYPE_DOUBLE:
- xmlNewChild (arg, NULL, "value",
- g_strdup_printf ("%g", G_VALUE_DOUBLE (args[i])));
- break;
- case G_TYPE_STRING:
- xmlNewChild (arg, NULL, "value", G_VALUE_STRING (args[i]));
- break;
- default:
- if (args[i].type == GST_TYPE_FILENAME) {
- xmlNewChild (arg, NULL, "value", G_VALUE_STRING (args[i]));
- }
- break;
- }
- }
+/* FIXME: what is this? */
+/* if (element->manager) */
+/* xmlNewChild(parent, NULL, "manager", GST_ELEMENT_NAME(element->manager)); */
+
+ /* params */
+ specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (object), &nspecs);
+
+ for (i=0; i<nspecs; i++) {
+ spec = specs[i];
+ if (spec->flags & G_PARAM_READABLE) {
+ xmlNodePtr param;
+ char *contents;
+
+ g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE (spec));
+
+ g_object_get_property (G_OBJECT (element), spec->name, &value);
+ param = xmlNewChild (parent, NULL, "param", NULL);
+ xmlNewChild (param, NULL, "name", spec->name);
+
+ if (G_IS_PARAM_SPEC_STRING (spec))
+ contents = g_value_dup_string (&value);
+ else if (G_IS_PARAM_SPEC_ENUM (spec))
+ contents = g_strdup_printf ("%d", g_value_get_enum (&value));
+ else if (G_IS_PARAM_SPEC_INT64 (spec))
+ contents = g_strdup_printf ("%lld", g_value_get_int64 (&value));
+ else
+ contents = g_strdup_value_contents (&value);
+
+ xmlNewChild (param, NULL, "value", contents);
+ g_free (contents);
+
+ g_value_unset(&value);
}
- type = gtk_type_parent (type);
}
-*/
pads = GST_ELEMENT_PADS (element);
while (pads) {
GstPad *pad = GST_PAD (pads->data);
- // figure out if it's a direct pad or a ghostpad
+ /* figure out if it's a direct pad or a ghostpad */
if (GST_ELEMENT (GST_OBJECT_PARENT (pad)) == element) {
xmlNodePtr padtag = xmlNewChild (parent, NULL, "pad", NULL);
gst_object_save_thyself (GST_OBJECT (pad), padtag);
return parent;
}
-/**
- * gst_element_restore_thyself:
- * @self: the xml node
- * @parent: the parent of this object when it's loaded
- *
- * Load the element from the XML description
- *
- * Returns: the new element
- */
-GstElement*
-gst_element_restore_thyself (xmlNodePtr self, GstObject *parent)
+static void
+gst_element_restore_thyself (GstObject *object, xmlNodePtr self)
{
- xmlNodePtr children = self->xmlChildrenNode;
+ xmlNodePtr children;
GstElement *element;
- GstObjectClass *oclass;
- guchar *name = NULL;
- guchar *value = NULL;
- guchar *type = NULL;
-
- // first get the needed tags to construct the element
- while (children) {
- if (!strcmp (children->name, "name")) {
- name = xmlNodeGetContent (children);
- } else if (!strcmp (children->name, "type")) {
- type = xmlNodeGetContent (children);
- }
- children = children->next;
- }
- g_return_val_if_fail (name != NULL, NULL);
- g_return_val_if_fail (type != NULL, NULL);
+ gchar *name = NULL;
+ gchar *value = NULL;
- GST_INFO (GST_CAT_XML,"loading \"%s\" of type \"%s\"", name, type);
-
- element = gst_elementfactory_make (type, name);
-
- g_return_val_if_fail (element != NULL, NULL);
-
- // 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);
+ element = GST_ELEMENT (object);
+ g_return_if_fail (element != NULL);
- // we have the element now, set the arguments
+ /* parameters */
children = self->xmlChildrenNode;
-
while (children) {
- if (!strcmp (children->name, "arg")) {
+ if (!strcmp (children->name, "param")) {
xmlNodePtr child = children->xmlChildrenNode;
while (child) {
}
child = child->next;
}
- gst_util_set_object_arg ((GObject *)G_OBJECT (element), name, value);
+ /* FIXME: can this just be g_object_set ? */
+ gst_util_set_object_arg (G_OBJECT (element), name, value);
}
children = children->next;
}
- // we have the element now, set the pads
+
+ /* pads */
children = self->xmlChildrenNode;
-
while (children) {
if (!strcmp (children->name, "pad")) {
gst_pad_load_and_connect (children, GST_OBJECT (element));
children = children->next;
}
- oclass = GST_OBJECT_CLASS (G_OBJECT_GET_CLASS(element));
- if (oclass->restore_thyself)
- (oclass->restore_thyself) (GST_OBJECT (element), self);
-
- if (parent)
- gst_object_unparent (GST_OBJECT (element));
+ if (GST_OBJECT_CLASS(parent_class)->restore_thyself)
+ (GST_OBJECT_CLASS(parent_class)->restore_thyself) (object, self);
+}
+#endif /* GST_DISABLE_LOADSAVE */
- gst_class_signal_emit_by_name (GST_OBJECT (element), "object_loaded", self);
+/**
+ * gst_element_yield:
+ * @element: a #GstElement to yield.
+ *
+ * Requests a yield operation for the element. The scheduler will typically
+ * give control to another element.
+ */
+void
+gst_element_yield (GstElement *element)
+{
+ if (GST_ELEMENT_SCHED (element)) {
+ gst_scheduler_yield (GST_ELEMENT_SCHED (element), element);
+ }
+}
- return element;
+/**
+ * gst_element_interrupt:
+ * @element: a #GstElement to interrupt.
+ *
+ * Requests the scheduler of this element to interrupt the execution of
+ * this element and scheduler another one.
+ *
+ * Returns: TRUE if the element should exit its chain/loop/get
+ * function ASAP, depending on the scheduler implementation.
+ */
+gboolean
+gst_element_interrupt (GstElement *element)
+{
+ if (GST_ELEMENT_SCHED (element)) {
+ return gst_scheduler_interrupt (GST_ELEMENT_SCHED (element), element);
+ }
+ else
+ return FALSE;
}
-#endif // GST_DISABLE_LOADSAVE
/**
- * gst_element_set_sched:
- * @element: Element to set manager of.
- * @sched: @GstSchedule to set.
+ * gst_element_set_scheduler:
+ * @element: a #GstElement to set the scheduler of.
+ * @sched: the #GstScheduler to set.
*
* Sets the scheduler of the element. For internal use only, unless you're
* writing a new bin subclass.
*/
void
-gst_element_set_sched (GstElement *element,
- GstSchedule *sched)
+gst_element_set_scheduler (GstElement *element,
+ GstScheduler *sched)
{
- GST_INFO_ELEMENT (GST_CAT_PARENTAGE, element, "setting scheduler to %p",sched);
- element->sched = sched;
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
+ GST_INFO_ELEMENT (GST_CAT_PARENTAGE, element, "setting scheduler to %p", sched);
+
+ GST_ELEMENT_SCHED (element) = sched;
}
/**
- * gst_element_get_sched:
- * @element: Element to get manager of.
+ * gst_element_get_scheduler:
+ * @element: a #GstElement to get the scheduler of.
*
* Returns the scheduler of the element.
*
- * Returns: Element's scheduler
+ * Returns: the element's #GstScheduler.
*/
-GstSchedule*
-gst_element_get_sched (GstElement *element)
+GstScheduler*
+gst_element_get_scheduler (GstElement *element)
{
- return element->sched;
+ g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
+
+ return GST_ELEMENT_SCHED (element);
}
/**
* gst_element_set_loop_function:
- * @element: Element to set loop function of.
- * @loop: Pointer to loop function.
+ * @element: a #GstElement to set the loop function of.
+ * @loop: Pointer to #GstElementLoopFunction.
*
* This sets the loop function for the element. The function pointed to
* can deviate from the GstElementLoopFunction definition in type of
* a new loopfunc to be assigned, this should be no problem.
*/
void
-gst_element_set_loop_function(GstElement *element,
- GstElementLoopFunction loop)
+gst_element_set_loop_function (GstElement *element,
+ GstElementLoopFunction loop)
{
+ g_return_if_fail (GST_IS_ELEMENT (element));
+
/* set the loop function */
element->loopfunc = loop;
/* set the NEW_LOOPFUNC flag so everyone knows to go try again */
- GST_FLAG_SET(element,GST_ELEMENT_NEW_LOOPFUNC);
+ GST_FLAG_SET (element, GST_ELEMENT_NEW_LOOPFUNC);
}
/**
- * gst_element_signal_eos:
- * @element: element to trigger the eos signal of
+ * gst_element_set_eos:
+ * @element: a #GstElement to set to the EOS state.
*
- * Throws the eos signal to indicate that the end of the stream is reached.
+ * Perform the actions needed to bring the element in the EOS state.
*/
void
-gst_element_signal_eos (GstElement *element)
+gst_element_set_eos (GstElement *element)
{
- g_return_if_fail (element != NULL);
g_return_if_fail (GST_IS_ELEMENT (element));
- GST_DEBUG(GST_CAT_EVENT, "signaling EOS on element %s\n",GST_OBJECT_NAME(element));
+ GST_DEBUG (GST_CAT_EVENT, "setting EOS on element %s",
+ GST_OBJECT_NAME (element));
+
+ gst_element_set_state (element, GST_STATE_PAUSED);
+
g_signal_emit (G_OBJECT (element), gst_element_signals[EOS], 0);
- GST_FLAG_SET(element,GST_ELEMENT_COTHREAD_STOPPING);
}
-const gchar *gst_element_statename(GstElementState state) {
+/**
+ * gst_element_state_get_name:
+ * @state: a #GstElementState to get the name of.
+ *
+ * Gets a string representing the given state.
+ *
+ * Returns: a string with the name of the state.
+ */
+const gchar*
+gst_element_state_get_name (GstElementState state)
+{
switch (state) {
#ifdef GST_DEBUG_COLOR
case GST_STATE_VOID_PENDING: return "NONE_PENDING";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";
+ default:
+ /* This is a memory leak */
+ return g_strdup_printf ("\033[01;37;41mUNKNOWN!\033[00m(%d)", state);
#else
case GST_STATE_VOID_PENDING: return "NONE_PENDING";break;
case GST_STATE_NULL: return "NULL";break;
}
return "";
}
+
+static void
+gst_element_populate_std_props (GObjectClass * klass, const gchar *prop_name,
+ guint arg_id, GParamFlags flags)
+{
+ GQuark prop_id = g_quark_from_string (prop_name);
+ GParamSpec *pspec;
+
+ static GQuark fd_id = 0;
+ static GQuark blocksize_id;
+ static GQuark bytesperread_id;
+ static GQuark dump_id;
+ static GQuark filesize_id;
+ static GQuark mmapsize_id;
+ static GQuark location_id;
+ static GQuark offset_id;
+ static GQuark silent_id;
+ static GQuark touch_id;
+
+ if (!fd_id) {
+ fd_id = g_quark_from_static_string ("fd");
+ blocksize_id = g_quark_from_static_string ("blocksize");
+ bytesperread_id = g_quark_from_static_string ("bytesperread");
+ dump_id = g_quark_from_static_string ("dump");
+ filesize_id = g_quark_from_static_string ("filesize");
+ mmapsize_id = g_quark_from_static_string ("mmapsize");
+ location_id = g_quark_from_static_string ("location");
+ offset_id = g_quark_from_static_string ("offset");
+ silent_id = g_quark_from_static_string ("silent");
+ touch_id = g_quark_from_static_string ("touch");
+ }
+
+ if (prop_id == fd_id) {
+ pspec = g_param_spec_int ("fd", "File-descriptor",
+ "File-descriptor for the file being read",
+ 0, G_MAXINT, 0, flags);
+ }
+ else if (prop_id == blocksize_id) {
+ pspec = g_param_spec_ulong ("blocksize", "Block Size",
+ "Block size to read per buffer",
+ 0, G_MAXULONG, 4096, flags);
+
+ }
+ else if (prop_id == bytesperread_id) {
+ pspec = g_param_spec_int ("bytesperread", "Bytes per read",
+ "Number of bytes to read per buffer",
+ G_MININT, G_MAXINT, 0, flags);
+
+ }
+ else if (prop_id == dump_id) {
+ pspec = g_param_spec_boolean ("dump", "Dump",
+ "Dump bytes to stdout",
+ FALSE, flags);
+
+ }
+ else if (prop_id == filesize_id) {
+ pspec = g_param_spec_int64 ("filesize", "File Size",
+ "Size of the file being read",
+ 0, G_MAXINT64, 0, flags);
+
+ }
+ else if (prop_id == mmapsize_id) {
+ pspec = g_param_spec_ulong ("mmapsize", "mmap() Block Size",
+ "Size in bytes of mmap()d regions",
+ 0, G_MAXULONG, 4 * 1048576, flags);
+
+ }
+ else if (prop_id == location_id) {
+ pspec = g_param_spec_string ("location", "File Location",
+ "Location of the file to read",
+ NULL, flags);
+
+ }
+ else if (prop_id == offset_id) {
+ pspec = g_param_spec_int64 ("offset", "File Offset",
+ "Byte offset of current read pointer",
+ 0, G_MAXINT64, 0, flags);
+
+ }
+ else if (prop_id == silent_id) {
+ pspec = g_param_spec_boolean ("silent", "Silent", "Don't produce events",
+ FALSE, flags);
+
+ }
+ else if (prop_id == touch_id) {
+ pspec = g_param_spec_boolean ("touch", "Touch read data",
+ "Touch data to force disk read before "
+ "push ()", TRUE, flags);
+ }
+ else {
+ g_warning ("Unknown - 'standard' property '%s' id %d from klass %s",
+ prop_name, arg_id, g_type_name (G_OBJECT_CLASS_TYPE (klass)));
+ pspec = NULL;
+ }
+
+ if (pspec) {
+ g_object_class_install_property (klass, arg_id, pspec);
+ }
+}
+
+/**
+ * gst_element_class_install_std_props:
+ * @klass: the #GstElementClass to add the properties to.
+ * @first_name: the name of the first property.
+ * in a NULL terminated
+ * @...: the id and flags of the first property, followed by
+ * further 'name', 'id', 'flags' triplets and terminated by NULL.
+ *
+ * Adds a list of standardized properties with types to the @klass.
+ * the id is for the property switch in your get_prop method, and
+ * the flags determine readability / writeability.
+ **/
+void
+gst_element_class_install_std_props (GstElementClass * klass,
+ const gchar *first_name, ...)
+{
+ const char *name;
+
+ va_list args;
+
+ g_return_if_fail (GST_IS_ELEMENT_CLASS (klass));
+
+ va_start (args, first_name);
+
+ name = first_name;
+
+ while (name) {
+ int arg_id = va_arg (args, int);
+ int flags = va_arg (args, int);
+
+ gst_element_populate_std_props ((GObjectClass *) klass, name, arg_id, flags);
+
+ name = va_arg (args, char *);
+ }
+
+ va_end (args);
+}
+
+/**
+ * gst_element_get_managing_bin:
+ * @element: a #GstElement to get the managing bin of.
+ *
+ * Gets the managing bin (a pipeline or a thread, for example) of an element.
+ *
+ * Returns: the #GstBin, or NULL on failure.
+ **/
+GstBin*
+gst_element_get_managing_bin (GstElement *element)
+{
+ GstBin *bin;
+
+ g_return_val_if_fail (element != NULL, NULL);
+
+ bin = GST_BIN (gst_object_get_parent (GST_OBJECT_CAST (element)));
+
+ while (bin && !GST_FLAG_IS_SET (GST_OBJECT_CAST (bin), GST_BIN_FLAG_MANAGER))
+ bin = GST_BIN (gst_object_get_parent (GST_OBJECT_CAST (bin)));
+
+ return bin;
+}
projects / platform / upstream / gstreamer.git / blobdiff