#include "gstscheduler.h"
#include "gstevent.h"
#include "gstutils.h"
+#include "gstlog.h"
/* Element signals and args */
enum {
}
}
+/**
+ * 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;
- const GValue *value;
+ GValue value;
} prop_value_t;
static void
prop_value_t *prop_value = g_new0 (prop_value_t, 1);
prop_value->pspec = pspec;
- prop_value->value = value;
+ prop_value->value = *value;
g_async_queue_push (element->prop_value_queue, prop_value);
}
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)
{
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)
{
/* 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_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_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_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)
{
g_return_if_fail (GST_IS_ELEMENT (element));
- object = (GObject*)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);
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)
{
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)
+gst_element_set_property (GstElement *element, const gchar *property_name,
+ const GValue *value)
{
GParamSpec *pspec;
GObject *object;
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
- object = (GObject*)element;
+ 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);
+ 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_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)
{
/**
* gst_element_release_request_pad:
- * @element: a #GstElement to release the request pad of
- * @pad: The pad to release
+ * @element: a #GstElement to release the request pad of.
+ * @pad: the #GstPad to release.
*
- * Make the element free the previously requested pad as obtained
+ * Makes the element free the previously requested pad as obtained
* with gst_element_get_request_pad().
*/
void
/**
* 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.
*/
/**
* 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
- * @jitter: The difference between requested time and actual time
+ * @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, GstClockTimeDiff *jitter)
/**
* gst_element_release_locks:
- * @element: an element
+ * @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, ...
/**
* 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
- * @compattempl: 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_compatible_pad_template()");
+ 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));
+ 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);
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)) {
+ if (peerpad &&
+ (GST_OBJECT_PARENT (GST_PAD_PEER (peerpad)) == (GstObject*) src)) {
gst_pad_disconnect (pad, peerpad);
}
}
}
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));
}
}
GstPad *pad = GST_PAD_CAST (pads->data);
if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
- if (GST_PAD_IS_CONNECTED (pad)) {
+ if (GST_PAD_IS_USABLE (pad)) {
res = gst_pad_send_event (GST_PAD_PEER (pad), event);
break;
}
/**
* gst_element_send_event:
- * @element: The element to send the event to.
- * @event: The event to send to the object.
+ * @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 sinkpad.
+ * to a random sink pad.
*
* Returns: TRUE if the event was handled.
*/
GstPad *pad = GST_PAD_CAST (pads->data);
if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
- if (GST_PAD_IS_CONNECTED (pad)) {
+ if (GST_PAD_IS_USABLE (pad)) {
res = gst_pad_query (GST_PAD_PEER (pad), type, format, value);
break;
}
/**
* gst_element_query:
- * @element: The element to perform the query on.
- * @type: The query type
- * @format: a pointer to hold the format of the result
- * @value: a pointer to the value of the result
+ * @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.
*
- * Perform a query on the given element. If the format is set
+ * 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
/**
* 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, ...)
/**
* 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
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);
#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_scheduler:
- * @element: Element to set manager of.
- * @sched: @GstScheduler to set.
+ * @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.
GST_INFO_ELEMENT (GST_CAT_PARENTAGE, element, "setting scheduler to %p", sched);
- element->sched = sched;
+ GST_ELEMENT_SCHED (element) = sched;
}
/**
* gst_element_get_scheduler:
- * @element: Element to get manager of.
+ * @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_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 gchar *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 == dump_id) {
- pspec = g_param_spec_boolean ("dump", "Dump", "Dump bytes to stdout", FALSE, flags);
+ pspec = g_param_spec_boolean ("dump", "Dump",
+ "Dump bytes to stdout",
+ FALSE, flags);
}
else if (prop_id == filesize_id) {
/**
* 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 gchar *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)
projects / platform / upstream / gstreamer.git / blobdiff