GST_FILTER_GET_LOCK()

#define GST_FILTER_GET_LOCK(obj)      (GST_FILTER(obj)->lock)

Acquire a reference to the mutex of this filter.

GST_FILTER_LOCK()

#define GST_FILTER_LOCK(obj)	       g_mutex_lock(GST_FILTER_GET_LOCK(obj))

This macro will obtain a lock on the filter, making serialization possible. It blocks until the lock can be obtained. All virtual methods get called with the mutex locked so filters do not need to bother with threading. However, if the filter needs to lock the mutex to do something outside of the virtual methods (like in a g_object_set or in a timer), then it should lock the filter's mutex by calling this macro.

See also: GST_FILTER_UNLOCK()

GST_FILTER_TRYLOCK()

#define GST_FILTER_TRYLOCK(obj)	       g_mutex_trylock(GST_FILTER_GET_LOCK(obj))

This macro will try to obtain a lock on the filter, but will return with FALSE if it can't get it immediately.

GST_FILTER_UNLOCK()

#define GST_FILTER_UNLOCK(obj)         g_mutex_unlock(GST_FILTER_GET_LOCK(obj))

This macro releases a lock on the filter. All virtual methods get called with the mutex locked so filters do not need to bother with threading. However, if the filter needs to lock the mutex to do something outside of the virtual methods (like in a g_object_set or in a timer), then it should call GST_FILTER_LOCK() then unlock it's mutex by calling this macro.

See also: GST_FILTER_LOCK()

GST_DEFINE_FILTER()

#define             GST_DEFINE_FILTER(type, filter_name)

This will define a new GstFilter derived class by calling G_DEFINE_TYPE() and by declaring and setting the apply, revert and name fields of the GstFilter parent class. The defined apply/revert methods will be gst_$(filter_name)_filter_apply and gst_$(filter_name)_filter_revert

gst_filter_add_element ()

gboolean            gst_filter_add_element              (GstBin *bin,
                                                         GstPad *pad,
                                                         GstElement *element,
                                                         GstPad *element_pad);

This helper function will add an element to the bin and link it's element_pad with the pad. Make sure the pad and element_pad pads have the correct directions and can be linked together. This will sink the reference on the element on success.

gst_filter_add_element_by_name ()

GstElement *        gst_filter_add_element_by_name      (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *element_name,
                                                         const gchar *pad_name,
                                                         const gchar *out_pad_name,
                                                         GstPad **out_pad);

This helper function will create a new GstElement by name (element_name) and add it to the bin and link it's pad (pad_name) with the pad. It will also return the output pad from the element through out_pad if set by using the out_pad_name. Make sure the pad_name specifies the correct pad direction to link with pad

gst_filter_add_element_by_name_default ()

GstElement *        gst_filter_add_element_by_name_default
                                                        (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *element_name,
                                                         GstPad **out_pad);

This helper function will create a new GstElement by name (element_name) and add it to the bin. It is equivalent to gst_filter_add_element_by_name() but uses "src" for the source pad's name and "sink" for the sink pad's name. The name is dependent on the direction of the pad it needs to link to.

See also: gst_filter_add_element_by_name()

gst_filter_add_element_by_description ()

GstElement *        gst_filter_add_element_by_description
                                                        (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *description,
                                                         GstPad **out_pad);

This helper function will create a new GstElement described the the pipeline description in description and add it to the bin and link it's pad with the pad. It will also return the output pad from the element through out_pad if set. Since gst_parse_bin_from_description() is used, it already knows the name of the source and sink pads, so it is unnecessary to specify them. It will also use the pad direction from pad to know in which direction to link.

gst_filter_apply_element_by_name ()

GstPad *            gst_filter_apply_element_by_name    (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *element_name,
                                                         const gchar *pad_name,
                                                         const gchar *out_pad_name,
                                                         GstElement **element,
                                                         GList **elements);

This helper function will create a new GstElement by its name and add it to the bin and link it's appropriate pad with the pad and return the applied pad. It will call gst_filter_add_element_by_name(), unref the returned element or add it to the element pointer, and return the output pad.

gst_filter_apply_element_by_name_default ()

GstPad *            gst_filter_apply_element_by_name_default
                                                        (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *element_name,
                                                         GstElement **element,
                                                         GList **elements);

This helper function will create a new GstElement by its name and add it to the bin and link it's appropriate pad with the pad and return the applied pad. It will call gst_filter_add_element_by_name(), unref the returned element or add it to the element pointer, and return the output pad. The difference between this and gst_filter_apply_element_by_name() is that this expects the created element to have its pads names with the default 'src' and a 'sink' names for the source and sink pads respectively. Both pads would need to be ALWAYS pads.

gst_filter_apply_element_by_description ()

GstPad *            gst_filter_apply_element_by_description
                                                        (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *description,
                                                         GstElement **element,
                                                         GList **elements);

This helper function will create a new GstElement described the the pipeline description in description and add it to the bin and return the applied pad. Since gst_parse_bin_from_description() is used, it already knows the name of the source and sink pads, so it is unnecessary to specify them. It will also use the pad direction from pad to know in which direction to link.

gst_filter_revert_element ()

GstPad *            gst_filter_revert_element           (GstBin *bin,
                                                         GstPad *pad,
                                                         const gchar *applied_pad_name,
                                                         GList **elements);

This helper function will automatically revert a GstElement from the bin and return the expected output pad. It will get the element the pad belongs to, and revert that element, while returning the gst_peer_pad() of the applied_pad_name of the element. If it finds the element in the elements list, it will unref it and remove it from the list.

gst_filter_revert_element_default ()

GstPad *            gst_filter_revert_element_default   (GstBin *bin,
                                                         GstPad *pad,
                                                         GList **elements);

This helper function will automatically revert an element or bin previously created by gst_filter_apply_element_by_description() or gst_filter_apply_element_by_name_default() from the bin and return the expected output pad.