/* #define GST_DEBUG_ENABLED */
#include <glib.h>
#include <stdarg.h>
+#include <gobject/gvaluecollector.h>
#include "gst_private.h"
#include "gstelement.h"
#include "gstscheduler.h"
#include "gstevent.h"
#include "gstutils.h"
+#include "gstlog.h"
/* Element signals and args */
enum {
PAD_REMOVED,
ERROR,
EOS,
+ DEEP_NOTIFY,
LAST_SIGNAL
};
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_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);
(GInstanceInitFunc)gst_element_init,
NULL
};
- _gst_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 _gst_element_type;
}
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);
+ /* see the comments at gst_element_dispatch_properties_changed */
+ gobject_class->dispatch_properties_changed
+ = GST_DEBUG_FUNCPTR (gst_element_dispatch_properties_changed);
- gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_element_set_property);
- gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_element_get_property);
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_element_dispose);
#ifndef GST_DISABLE_LOADSAVE
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
element->pads = NULL;
element->loopfunc = 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_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+gst_element_real_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
GstElementClass *oclass = CLASS (object);
}
static void
-gst_element_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+gst_element_real_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
GstElementClass *oclass = CLASS (object);
(oclass->get_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;
+
+ 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_threadsafe_properties_pre_run (GstElement *element)
+{
+ GST_DEBUG (GST_CAT_THREAD, "locking element %s", GST_OBJECT_NAME (element));
+ g_mutex_lock (element->property_mutex);
+ gst_element_set_pending_properties (element);
+}
+
+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);
+}
+
+/**
+ * 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;
+ }
+
+ 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)
{
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)
{
/**
* gst_element_set_name:
- * @element: a #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.
*
* Sets the name of the element, getting rid of the old name if there was
* one.
/**
* gst_element_get_name:
- * @element: a #GstElement to get name of
+ * @element: a #GstElement to get the name of.
*
* 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: a #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.
*
* Sets the parent of the element.
*/
/**
* gst_element_get_parent:
- * @element: a #GstElement to get the parent of
+ * @element: a #GstElement to get the parent of.
*
* Gets the parent of the element.
*
- * Returns: the #GstElement 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
+ * @element: a #GstElement to set the clock for.
+ * @clock: the #GstClock to set for the element.
*
* Sets the clock for the element.
*/
if (element->setclockfunc)
element->setclockfunc (element, clock);
+
+ element->clock = clock;
}
/**
* gst_element_get_clock:
- * @element: a #GstElement to get the clock of
+ * @element: a #GstElement to get the clock of.
*
* Gets the clock of the element.
*
/**
* gst_element_clock_wait:
- * @element: a #GstElement
- * @clock: the #GstClock to use
- * @time: the #GstClockTime to wait for on the clock
+ * @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
+ * Returns: the #GstClockReturn result of the wait operation.
*/
GstClockReturn
-gst_element_clock_wait (GstElement *element, GstClock *clock, GstClockTime time)
+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)) {
- return gst_scheduler_clock_wait (GST_ELEMENT_SCHED (element), element, clock, time);
+ res = gst_scheduler_clock_wait (GST_ELEMENT_SCHED (element), element, clock, time, jitter);
}
else
- return GST_CLOCK_TIMEOUT;
+ 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).
/**
* 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)
/**
* 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 pad or NULL, if no ghost pad was created.
+ * Returns: the added ghost #GstPad, or NULL, if no ghost pad was created.
*/
GstPad *
-gst_element_add_ghost_pad (GstElement *element, GstPad *pad, gchar *name)
+gst_element_add_ghost_pad (GstElement *element, GstPad *pad, const gchar *name)
{
GstPad *ghostpad;
/* 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",
- 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_element_remove_ghost_pad:
- * @element: element to remove the ghost pad from
- * @pad: ghost pad to remove
+ * @element: a #GstElement to remove the ghost pad from.
+ * @pad: ghost #GstPad to remove.
*
- * removes a ghost pad from an element
+ * Removes a ghost pad from an element.
*/
void
gst_element_remove_ghost_pad (GstElement *element, GstPad *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)
/**
* gst_element_get_static_pad:
- * @element: element to find pad of
- * @name: name of pad to retrieve
+ * @element: a #GstElement to find a static pad of.
+ * @name: the name of the static #GstPad to retrieve.
*
- * Retrieve a pad from the element by name. This version only retrieves
+ * Retrieves a pad from the element by name. This version only retrieves
* already-existing (i.e. 'static') pads.
*
- * Returns: requested pad if found, otherwise NULL.
+ * Returns: the requested #GstPad if found, otherwise NULL.
*/
GstPad *
gst_element_get_static_pad (GstElement *element, const gchar *name)
/**
* gst_element_get_request_pad:
- * @element: element to find pad of
- * @name: name of pad to retrieve
+ * @element: a #GstElement to find a request pad of.
+ * @name: the name of the request #GstPad to retrieve.
*
- * Retrieve a pad from the element by name. This version only retrieves
+ * Retrieves a pad from the element by name. This version only retrieves
* request pads.
*
- * Returns: requested pad if found, otherwise NULL.
+ * Returns: requested #GstPad if found, otherwise NULL.
*/
GstPad*
gst_element_get_request_pad (GstElement *element, const gchar *name)
/**
* 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_pad_template:
- * @klass: element class to add padtemplate to
- * @templ: padtemplate to add
+ * @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
+ * 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_pad_template (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));
/**
* gst_element_get_pad_template_list:
- * @element: element to get padtemplates of
+ * @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_pad_template_list (GstElement *element)
/**
* gst_element_get_pad_template:
- * @element: element to get padtemplate of
- * @name: the name of the padtemplate to get.
+ * @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. No unreferencing is necessary.
+ * Returns: the #GstPadTemplate with the given name, or NULL if none was found.
+ * No unreferencing is necessary.
*/
GstPadTemplate*
-gst_element_get_pad_template (GstElement *element, const guchar *name)
+gst_element_get_pad_template (GstElement *element, const gchar *name)
{
GList *padlist;
/**
* gst_element_get_compatible_pad_template:
- * @element: element to get padtemplate of
- * @templ: a template to find a compatible template for
+ * @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. No unreferencing is necessary.
+ * Returns: the #GstPadTemplate of the element that is compatible with
+ * the given GstPadTemplate, or NULL if none was found. No unreferencing
+ * is necessary.
*/
GstPadTemplate*
-gst_element_get_compatible_pad_template (GstElement *element, GstPadTemplate *compattempl)
+gst_element_get_compatible_pad_template (GstElement *element,
+ GstPadTemplate *compattempl)
{
GstPadTemplate *newtempl = NULL;
GList *padlist;
- GST_DEBUG(GST_CAT_ELEMENT_PADS,"gst_element_get_pad_template_by_compatible()");
+ 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);
while (padlist) {
GstPadTemplate *padtempl = (GstPadTemplate*) padlist->data;
- gboolean compat = FALSE;
+ gboolean comp = FALSE;
/* Ignore name
* Ignore presence
* Check direction (must be opposite)
* Check caps
*/
- GST_DEBUG(GST_CAT_CAPS,"checking direction and 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");
- compat = gst_caps_check_compatibility(GST_PAD_TEMPLATE_CAPS (padtempl),
- GST_PAD_TEMPLATE_CAPS (compattempl));
- GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible", (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");
- compat = gst_caps_check_compatibility(GST_PAD_TEMPLATE_CAPS (compattempl),
- GST_PAD_TEMPLATE_CAPS (padtempl));
- GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible", (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;
}
/**
* 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)
/**
* gst_element_get_compatible_pad_filtered:
- * @element: the element in which the pad should be found
- * @pad: the pad to find a compatible one for
- * @filtercaps: the caps to use as a filter
+ * @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.
*
* 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 pad to which a connection can be made
+ * Returns: the #GstPad to which a connection can be made.
*/
GstPad*
-gst_element_get_compatible_pad_filtered (GstElement *element, GstPad *pad, GstCaps *filtercaps)
+gst_element_get_compatible_pad_filtered (GstElement *element, GstPad *pad,
+ GstCaps *filtercaps)
{
- GList *pads;
+ const GList *pads;
GstPadTemplate *templ;
GstCaps *templcaps;
GstPad *foundpad = NULL;
/**
* gst_element_get_compatible_pad:
- * @element: the element in which the pad should be found
- * @pad: the pad to find a compatible one for
+ * @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 pad to which a connection can be made
+ * 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)
/**
* gst_element_connect_filtered:
- * @src: the element containing source pad
- * @dest: the element containing destination pad
- * @filtercaps: the caps to use as filter
+ * @src: a #GstElement containing the source pad.
+ * @dest: the #GstElement containing the destination pad.
+ * @filtercaps: the #GstCaps to use as a filter.
*
- * Connect the source to the destination element using the filtercaps.
+ * 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.
+ * 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)
+ GstCaps *filtercaps)
{
- GList *srcpads, *destpads, *srctempls, *desttempls, *l;
+ 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 (GST_IS_ELEMENT (src), FALSE);
g_return_val_if_fail (dest != NULL, FALSE);
- g_return_val_if_fail (GST_IS_ELEMENT(dest), FALSE);
+ g_return_val_if_fail (GST_IS_ELEMENT (dest), FALSE);
- GST_DEBUG (GST_CAT_ELEMENT_PADS, "attempting to connect element %s to element %s", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "trying to connect element %s to element %s",
+ GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
- /* loop through the existing pads in the source */
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);
+ 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));
+ 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;
}
}
/* 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);
+ 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));
+ 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;
}
}
}
}
- GST_DEBUG (GST_CAT_ELEMENT_PADS, "we might have request pads on both sides, checking...");
+ 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 (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_check_compatibility (gst_pad_template_get_caps (srctempl),
+ 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);
+ 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));
+ 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 */
}
}
- GST_DEBUG (GST_CAT_ELEMENT_PADS, "no connection possible from %s to %s", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
+ GST_DEBUG (GST_CAT_ELEMENT_PADS, "no connection possible from %s to %s",
+ GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
return FALSE;
}
/**
* gst_element_connect_many:
- * @element_1: the first element in the connection chain
- * @element_2: the second element in the connection chain
- * @...: NULL-terminated list of elements to connect in order
+ * @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.
*
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);
+ g_return_val_if_fail (GST_IS_ELEMENT (element_1) &&
+ GST_IS_ELEMENT (element_2), FALSE);
va_start (args, element_2);
/**
* gst_element_connect:
- * @src: element containing source pad
- * @dest: element containing destination pad
+ * @src: a #GstElement containing the source pad.
+ * @dest: the #GstElement containing the destination pad.
*
- * Connect the source to the destination element.
+ * 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
/**
* gst_element_connect_pads_filtered:
- * @src: element containing source pad
- * @srcpadname: name of pad in source element
- * @dest: element containing destination pad
- * @destpadname: name of pad in destination element
- * @filtercaps: the caps to use as a filter
+ * @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.
/**
* gst_element_connect_pads:
- * @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.
+ * @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.
*
- * 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.
/**
* gst_element_disconnect_pads:
- * @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.
+ * @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.
*
- * Disconnect the two named pads of the source and destination elements.
+ * Disconnects the two named pads of the source and destination elements.
*/
void
gst_element_disconnect_pads (GstElement *src, const gchar *srcpadname,
/**
* gst_element_disconnect_many:
- * @element_1: the first element in the connection chain
- * @element_2: the second element in the connection chain
- * @...: NULL-terminated list of elements to disconnect in order
+ * @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.
*
- * Disconnect a series of elements. Uses #gst_element_disconnect.
+ * Disconnects a series of elements. Uses #gst_element_disconnect.
*/
void
gst_element_disconnect_many (GstElement *element_1, GstElement *element_2, ...)
/**
* gst_element_disconnect:
- * @src: source element
- * @dest: sink element
+ * @src: the source #GstElement to disconnect.
+ * @dest: the sink #GstElement to disconnect.
*
- * Disconnect all pads connecting the two elements in the direction src -> dest.
+ * 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)
{
- GList *srcpads;
+ const GList *srcpads;
GstPad *pad;
- g_return_if_fail (GST_IS_ELEMENT(src));
- g_return_if_fail (GST_IS_ELEMENT(dest));
+ 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 (srcpads->data);
+ pad = GST_PAD_CAST (srcpads->data);
- if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC)
- if (GST_OBJECT_PARENT (GST_PAD_PEER (pad)) == (GstObject*) dest)
- gst_pad_disconnect (pad, GST_PAD_PEER (pad));
+ 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)
+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_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);
+ 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: A printf-like string describing the error
- * @...: optional arguments for the string
+ * @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, ...)
/* checks */
g_return_if_fail (GST_IS_ELEMENT (element));
- g_return_if_fail (element != NULL);
g_return_if_fail (error != NULL);
/* create error message */
/**
* gst_element_get_state:
- * @element: a #GstElement to get state of
+ * @element: a #GstElement to get the state of.
*
* Gets the state of the element.
*
- * Returns: The #GstElementState of the element
+ * Returns: the #GstElementState of the element.
*/
GstElementState
gst_element_get_state (GstElement *element)
/**
* gst_element_wait_state_change:
- * @element: a #GstElement to wait for
+ * @element: a #GstElement to wait for a state change on.
*
* Waits and blocks until the element changed its state.
*/
/**
* gst_element_set_state:
- * @element: a #GstElement to change state of
- * @state: the element's new #GstElementState
+ * @element: a #GstElement to change state of.
+ * @state: the element's new #GstElementState.
*
* 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
if (curpending != state) {
GST_DEBUG_ELEMENT (GST_CAT_STATES, element,
"intermediate: setting state from %s to %s",
- gst_element_state_get_name (state),
+ gst_element_state_get_name (GST_STATE (element)),
gst_element_state_get_name (curpending));
}
switch (return_val) {
case GST_STATE_FAILURE:
- GST_DEBUG_ELEMENT (GST_CAT_STATES, element, "have failed change_state return");
+ 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");
+ 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));
+ "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;
/* if we have a connection on this pad and it doesn't have caps
* allready, try to negotiate */
- if (GST_PAD_IS_CONNECTED (srcpad) && !GST_PAD_CAPS (srcpad)) {
+ if (GST_PAD_IS_USABLE (srcpad) && !GST_PAD_CAPS (srcpad)) {
GstRealPad *sinkpad;
GstElementState otherstate;
GstElement *parent;
/* 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));
+ 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 negotiatiating %s:%s and %s:%s, not in READY yet",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
+ 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));
}
}
}
old_pending = GST_STATE_PENDING (element);
old_transition = GST_STATE_TRANSITION (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));
+ 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;
}
- 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));
+ 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;
- /* if we are going to paused, we try to negotiate the pads */
- if (old_transition == GST_STATE_NULL_TO_READY) {
- if (!gst_element_negotiate_pads (element))
- goto failure;
- }
- /* going to the READY state clears all pad caps */
- else if (old_transition == GST_STATE_READY_TO_NULL) {
- gst_element_clear_pad_caps (element);
+ 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;
}
/* tell the scheduler if we have one */
if (element->sched) {
- if (gst_scheduler_state_transition (element->sched, element, old_transition)
- != GST_STATE_SUCCESS) {
+ 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);
+ gst_bin_child_state_change (GST_BIN (parent), old_state,
+ GST_STATE (element), element);
}
- g_signal_emit (G_OBJECT (element), gst_element_signals[STATE_CHANGE],
- 0, old_state, GST_STATE (element));
-
/* signal the state change in case somebody is waiting for us */
g_mutex_lock (element->state_mutex);
g_cond_signal (element->state_cond);
/**
* gst_element_get_factory:
- * @element: element to request the factory
+ * @element: a #GstElement to request the element factory of.
*
- * Retrieves the factory that was used to create this element
+ * Retrieves the factory that was used to create this element.
*
- * Returns: the factory used for creating this element
+ * Returns: the #GstElementFactory used for creating this element.
*/
GstElementFactory*
gst_element_get_factory (GstElement *element)
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_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);
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,
spec = specs[i];
if (spec->flags & G_PARAM_READABLE) {
xmlNodePtr param;
+ char *contents;
g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE (spec));
xmlNewChild (param, NULL, "name", spec->name);
if (G_IS_PARAM_SPEC_STRING (spec))
- xmlNewChild (param, NULL, "value", g_value_dup_string (&value));
+ contents = g_value_dup_string (&value);
else if (G_IS_PARAM_SPEC_ENUM (spec))
- xmlNewChild (param, NULL, "value", g_strdup_printf ("%d", g_value_get_enum (&value)));
+ contents = g_strdup_printf ("%d", g_value_get_enum (&value));
else if (G_IS_PARAM_SPEC_INT64 (spec))
- xmlNewChild (param, NULL, "value", g_strdup_printf ("%lld", g_value_get_int64 (&value)));
+ contents = g_strdup_printf ("%lld", g_value_get_int64 (&value));
else
- xmlNewChild (param, NULL, "value", g_strdup_value_contents (&value));
+ contents = g_strdup_value_contents (&value);
+
+ xmlNewChild (param, NULL, "value", contents);
+ g_free (contents);
g_value_unset(&value);
}
{
xmlNodePtr children;
GstElement *element;
- guchar *name = NULL;
- guchar *value = NULL;
+ gchar *name = NULL;
+ gchar *value = NULL;
element = GST_ELEMENT (object);
g_return_if_fail (element != NULL);
child = child->next;
}
/* FIXME: can this just be g_object_set ? */
- gst_util_set_object_arg ((GObject *)G_OBJECT (element), name, value);
+ gst_util_set_object_arg (G_OBJECT (element), name, value);
}
children = children->next;
}
/**
* gst_element_yield:
- * @element: Element to yield
+ * @element: a #GstElement to yield.
*
- * Request a yield operation for the child. The scheduler will typically
+ * Requests a yield operation for the element. The scheduler will typically
* give control to another element.
*/
void
/**
* gst_element_interrupt:
- * @element: Element to interrupt
+ * @element: a #GstElement to interrupt.
*
- * Request the scheduler of this element to interrupt the execution of
+ * Requests the scheduler of this element to interrupt the execution of
* this element and scheduler another one.
*
- * Returns: a boolean indicating that the child should exit its chain/loop/get
+ * Returns: TRUE if the element should exit its chain/loop/get
* function ASAP, depending on the scheduler implementation.
*/
gboolean
}
/**
- * gst_element_set_sched:
- * @element: Element to set manager of.
- * @sched: @GstScheduler 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,
+gst_element_set_scheduler (GstElement *element,
GstScheduler *sched)
{
g_return_if_fail (GST_IS_ELEMENT (element));
GST_INFO_ELEMENT (GST_CAT_PARENTAGE, element, "setting scheduler to %p", sched);
- element->sched = 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.
*/
GstScheduler*
-gst_element_get_sched (GstElement *element)
+gst_element_get_scheduler (GstElement *element)
{
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
- return element->sched;
+ 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
/**
* gst_element_set_eos:
- * @element: element to set to the EOS state
+ * @element: a #GstElement to set to the EOS state.
*
* Perform the actions needed to bring the element in the EOS state.
*/
{
g_return_if_fail (GST_IS_ELEMENT (element));
- GST_DEBUG (GST_CAT_EVENT, "setting EOS on element %s", 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);
/**
* gst_element_state_get_name:
- * @state: a #GstElementState to get the name of
+ * @state: a #GstElementState to get the name of.
*
* Gets a string representing the given state.
*
- * Returns: a string with the statename.
+ * Returns: a string with the name of the state.
*/
const gchar*
gst_element_state_get_name (GstElementState state)
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 g_strdup_printf ("\033[01;37;41mUNKNOWN!\033[00m(%d)", state);
+ 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;
}
static void
-gst_element_populate_std_props (GObjectClass * klass,
- const char *prop_name, guint arg_id, GParamFlags flags)
+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;
}
else if (prop_id == bytesperread_id) {
- pspec = g_param_spec_int ("bytesperread", "bytesperread",
- "bytesperread",
+ 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", FALSE, flags);
+ pspec = g_param_spec_boolean ("dump", "Dump",
+ "Dump bytes to stdout",
+ FALSE, flags);
}
else if (prop_id == filesize_id) {
}
else if (prop_id == silent_id) {
- pspec = g_param_spec_boolean ("silent", "silent", "silent",
+ pspec = g_param_spec_boolean ("silent", "Silent", "Don't produce events",
FALSE, flags);
}
/**
* gst_element_class_install_std_props:
- * @klass: the class to add the properties to
- * @first_name: the first in a NULL terminated
- * 'name', 'id', 'flags' triplet list.
- * @...: the triplet list
+ * @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.
*
- * Add a list of standardized properties with types to the @klass.
+ * 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 char *first_name, ...)
+gst_element_class_install_std_props (GstElementClass * klass,
+ const gchar *first_name, ...)
{
const char *name;
/**
* gst_element_get_managing_bin:
- * @element: a #GstElement
+ * @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
+ * Returns: the #GstBin, or NULL on failure.
**/
GstBin*
gst_element_get_managing_bin (GstElement *element)