struct GstElement

struct GstElement;

GST_NUM_STATES

#define GST_NUM_STATES 4

The maximun number of states.

GST_STATE()

#define GST_STATE(obj)			(GST_ELEMENT(obj)->current_state)

This macro returns the current state of the element.

GST_STATE_PENDING()

#define GST_STATE_PENDING(obj)		(GST_ELEMENT(obj)->pending_state)

This macro returns the currently pending state of the element.

GST_STATE_TRANSITION()

#define GST_STATE_TRANSITION(obj)	((GST_STATE(obj)<<8) | GST_STATE_PENDING(obj))

Returns the state transition this object is going through.

GST_STATE_NULL_TO_READY

#define GST_STATE_NULL_TO_READY		((GST_STATE_NULL<<8) | GST_STATE_READY)

The Element is going from the NULL state to the READY state.

GST_STATE_READY_TO_PAUSED

#define GST_STATE_READY_TO_PAUSED	((GST_STATE_READY<<8) | GST_STATE_PAUSED)

The Element is going from the READY state to the PAUSED state.

GST_STATE_PAUSED_TO_PLAYING

#define GST_STATE_PAUSED_TO_PLAYING	((GST_STATE_PAUSED<<8) | GST_STATE_PLAYING)

The Element is going from the PAUSED state to the PLAYING state.

GST_STATE_PLAYING_TO_PAUSED

#define GST_STATE_PLAYING_TO_PAUSED	((GST_STATE_PLAYING<<8) | GST_STATE_PAUSED)

The Element is going from the PLAYING state to the PAUSED state.

GST_STATE_PAUSED_TO_READY

#define GST_STATE_PAUSED_TO_READY	((GST_STATE_PAUSED<<8) | GST_STATE_READY)

The Element is going from the PAUSED state to the READY state.

GST_STATE_READY_TO_NULL

#define GST_STATE_READY_TO_NULL		((GST_STATE_READY<<8) | GST_STATE_NULL)

The Element is going from the READY state to the NULL state.

GST_ELEMENT_QUERY_TYPE_FUNCTION()

#define     GST_ELEMENT_QUERY_TYPE_FUNCTION(functionname, ...)

Helper macro to create query type functions

GST_ELEMENT_FORMATS_FUNCTION()

#define     GST_ELEMENT_FORMATS_FUNCTION(functionname, ...)

Halper macro to create element format functions

GST_ELEMENT_EVENT_MASK_FUNCTION()

#define     GST_ELEMENT_EVENT_MASK_FUNCTION(functionname, ...)

A helper macro to create a mask function

enum GstElementFlags

typedef enum {
  /* element is complex (for some def.) and generally require a cothread */
  GST_ELEMENT_COMPLEX		= GST_OBJECT_FLAG_LAST,
  /* input and output pads aren't directly coupled to each other
     examples: queues, multi-output async readers, etc. */
  GST_ELEMENT_DECOUPLED,
  /* this element should be placed in a thread if at all possible */
  GST_ELEMENT_THREAD_SUGGESTED,
  /* this element, for some reason, has a loop function that performs
   * an infinite loop without calls to gst_element_yield () */
  GST_ELEMENT_INFINITE_LOOP,
  /* there is a new loopfunction ready for placement */
  GST_ELEMENT_NEW_LOOPFUNC,
  /* if this element can handle events */
  GST_ELEMENT_EVENT_AWARE,
  /* use threadsafe property get/set implementation */
  GST_ELEMENT_USE_THREADSAFE_PROPERTIES,

  /* private flags that can be used by the scheduler */
  GST_ELEMENT_SCHEDULER_PRIVATE1,
  GST_ELEMENT_SCHEDULER_PRIVATE2,

  /* ignore state changes from parent */
  GST_ELEMENT_LOCKED_STATE,

  /* element is in error */
  GST_ELEMENT_IN_ERROR,

  /* use some padding for future expansion */
  GST_ELEMENT_FLAG_LAST		= GST_OBJECT_FLAG_LAST + 16
} GstElementFlags;

This enum defines the standard flags that an element may have.

GST_ELEMENT_IS_THREAD_SUGGESTED()

#define GST_ELEMENT_IS_THREAD_SUGGESTED(obj)	(GST_FLAG_IS_SET(obj,GST_ELEMENT_THREAD_SUGGESTED))

Queries whether the Element should be placed in a thread.

GST_ELEMENT_IS_EVENT_AWARE()

#define GST_ELEMENT_IS_EVENT_AWARE(obj)		(GST_FLAG_IS_SET(obj,GST_ELEMENT_EVENT_AWARE))

Query wether this element can handle events.

GST_ELEMENT_IS_DECOUPLED()

#define GST_ELEMENT_IS_DECOUPLED(obj)		(GST_FLAG_IS_SET(obj,GST_ELEMENT_DECOUPLED))

Queries if the Element is decoupled.

GST_ELEMENT_NAME()

#define GST_ELEMENT_NAME(obj)			(GST_OBJECT_NAME(obj))

Gets the name of this element. Used in the core. Not ABI-compatible.

GST_ELEMENT_PARENT()

#define GST_ELEMENT_PARENT(obj)			(GST_OBJECT_PARENT(obj))

Get the parent object of this element.

GST_ELEMENT_SCHED()

#define GST_ELEMENT_SCHED(obj)			(((GstElement*)(obj))->sched)

Get the scheduler of this element.

GST_ELEMENT_CLOCK()

#define GST_ELEMENT_CLOCK(obj)			(((GstElement*)(obj))->clock)

Get the clock of this element

GST_ELEMENT_PADS()

#define GST_ELEMENT_PADS(obj)			((obj)->pads)

Get the pads of this elements.

GST_ELEMENT_ERROR()

#define     GST_ELEMENT_ERROR(el, domain, code, message, debug)

Utility function that elements can use in case they encountered a fatal data processing error. The pipeline will throw an error signal and the application will be requested to stop further media processing.

GstElementLoopFunction ()

void        (*GstElementLoopFunction)       (GstElement *element);

This function type is used to specify a loop function for the element. It is passed the element in question, and is expect to return only in error circumstances.

GstElementPreRunFunction ()

void        (*GstElementPreRunFunction)     (GstElement *element);

The signature of the function to execute after this element is scheduled.

GstElementPostRunFunction ()

void        (*GstElementPostRunFunction)    (GstElement *element);

The signature of the function to execute before this element is scheduled.

gst_element_class_add_pad_template ()

void        gst_element_class_add_pad_template
                                            (GstElementClass *klass,
                                             GstPadTemplate *templ);

Adds a padtemplate to an element class. This is mainly used in the _base_init functions of classes.

gst_element_class_install_std_props ()

void        gst_element_class_install_std_props
                                            (GstElementClass *klass,
                                             const gchar *first_name,
                                             ...);

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.

gst_element_class_set_details ()

void        gst_element_class_set_details   (GstElementClass *klass,
                                             const GstElementDetails *details);

Sets the detailed information for a GstElementClass.

gst_element_default_deep_notify

#define 		gst_element_default_deep_notify 	gst_object_default_deep_notify

The default deep notify handler that prints out the property change notifications to stdout.

gst_element_default_error ()

void        gst_element_default_error       (GObject *object,
                                             GstObject *orig,
                                             GError *error,
                                             gchar *debug);

A default error signal callback to attach 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.

gst_element_set_loop_function ()

void        gst_element_set_loop_function   (GstElement *element,
                                             GstElementLoopFunction loop);

This sets the loop function for the element. The function pointed to can deviate from the GstElementLoopFunction definition in type of pointer only.

NOTE: in order for this to take effect, the current loop function *must* exit. Assuming the loop function itself is the only one who will cause a new loopfunc to be assigned, this should be no problem.

gst_element_get_name()

#define			gst_element_get_name(elem)	gst_object_get_name(GST_OBJECT(elem))

Gets the name of the element.

gst_element_set_name()

#define			gst_element_set_name(elem,name)	gst_object_set_name(GST_OBJECT(elem),name)

Sets the name of the element, getting rid of the old name if there was one.

gst_element_get_parent()

#define			gst_element_get_parent(elem)	gst_object_get_parent(GST_OBJECT(elem))

Gets the parent of an element.

gst_element_set_parent()

#define			gst_element_set_parent(elem,parent)	gst_object_set_parent(GST_OBJECT(elem),parent)

Sets the parent of an element.

gst_element_set ()

void        gst_element_set                 (GstElement *element,
                                             const gchar *first_property_name,
                                             ...);

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.

gst_element_get ()

void        gst_element_get                 (GstElement *element,
                                             const gchar *first_property_name,
                                             ...);

Gets properties from an element. If the element uses threadsafe properties, the element will be locked before getting the given properties.

gst_element_set_valist ()

void        gst_element_set_valist          (GstElement *element,
                                             const gchar *first_property_name,
                                             va_list var_args);

Sets properties on an element. If the element uses threadsafe properties, the property change will be put on the async queue.

gst_element_get_valist ()

void        gst_element_get_valist          (GstElement *element,
                                             const gchar *first_property_name,
                                             va_list var_args);

Gets properties from an element. If the element uses threadsafe properties, the element will be locked before getting the given properties.

gst_element_set_property ()

void        gst_element_set_property        (GstElement *element,
                                             const gchar *property_name,
                                             const GValue *value);

Sets a property on an element. If the element uses threadsafe properties, the property will be put on the async queue.

gst_element_get_property ()

void        gst_element_get_property        (GstElement *element,
                                             const gchar *property_name,
                                             GValue *value);

Gets a property from an element. If the element uses threadsafe properties, the element will be locked before getting the given property.

gst_element_enable_threadsafe_properties ()

void        gst_element_enable_threadsafe_properties
                                            (GstElement *element);

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.

gst_element_disable_threadsafe_properties ()

void        gst_element_disable_threadsafe_properties
                                            (GstElement *element);

Removes the threadsafe properties, post- and pre-run locks from this element.

gst_element_set_pending_properties ()

void        gst_element_set_pending_properties
                                            (GstElement *element);

Sets all pending properties on the threadsafe properties enabled element.

gst_element_requires_clock ()

gboolean    gst_element_requires_clock      (GstElement *element);

Query if the element requiresd a clock

gst_element_provides_clock ()

gboolean    gst_element_provides_clock      (GstElement *element);

Query if the element provides a clock

gst_element_get_clock ()

GstClock*   gst_element_get_clock           (GstElement *element);

Gets the clock of the element.

gst_element_set_clock ()

void        gst_element_set_clock           (GstElement *element,
                                             GstClock *clock);

Sets the clock for the element.

gst_element_clock_wait ()

GstClockReturn gst_element_clock_wait       (GstElement *element,
                                             GstClockID id,
                                             GstClockTimeDiff *jitter);

Waits for a specific time on the clock.

gst_element_get_time ()

GstClockTime gst_element_get_time           (GstElement *element);

Query the element's time. FIXME: The element must use

gst_element_wait ()

gboolean    gst_element_wait                (GstElement *element,
                                             GstClockTime timestamp);

Waits until the given relative time stamp for the element has arrived. When this function returns successfully, the relative time point specified in the timestamp has passed for this element.

gst_element_set_time ()

void        gst_element_set_time            (GstElement *element,
                                             GstClockTime time);

Sets the current time of the element. This function can be used when handling discont events. You can only call this function on an element with a clock in GST_STATE_PAUSED or GST_STATE_PLAYING. You might want to have a look at gst_element_adjust_time(), if you want to adjust by a difference as that is more accurate.

gst_element_set_time_delay ()

void        gst_element_set_time_delay      (GstElement *element,
                                             GstClockTime time,
                                             GstClockTime delay);

Sets the current time of the element to time - delay. This function can be used when handling discont events in elements writing to an external buffer, i. e., an audio sink that writes to a sound card that buffers the sound before playing it. The delay should be the current buffering delay.

You can only call this function on an element with a clock in GST_STATE_PAUSED or GST_STATE_PLAYING. You might want to have a look at gst_element_adjust_time(), if you want to adjust by a difference as that is more accurate.

gst_element_adjust_time ()

void        gst_element_adjust_time         (GstElement *element,
                                             GstClockTimeDiff diff);

Adjusts the current time of the element by the specified difference. This function can be used when handling discont events. You can only call this function on an element with a clock in GST_STATE_PAUSED or GST_STATE_PLAYING. It is more accurate than gst_element_set_time().

gst_element_is_indexable ()

gboolean    gst_element_is_indexable        (GstElement *element);

Queries if the element can be indexed.

gst_element_set_index ()

void        gst_element_set_index           (GstElement *element,
                                             GstIndex *index);

Set the specified GstIndex on the element.

gst_element_get_index ()

GstIndex*   gst_element_get_index           (GstElement *element);

Gets the index from the element.

gst_element_release_locks ()

gboolean    gst_element_release_locks       (GstElement *element);

Instruct the element to release all the locks it is holding, such as blocking reads, waiting for the clock, ...

gst_element_yield ()

void        gst_element_yield               (GstElement *element);

Requests a yield operation for the element. The scheduler will typically give control to another element.

gst_element_interrupt ()

gboolean    gst_element_interrupt           (GstElement *element);

Requests the scheduler of this element to interrupt the execution of this element and scheduler another one.

gst_element_set_scheduler ()

void        gst_element_set_scheduler       (GstElement *element,
                                             GstScheduler *sched);

Sets the scheduler of the element. For internal use only, unless you're writing a new bin subclass.

gst_element_get_scheduler ()

GstScheduler* gst_element_get_scheduler     (GstElement *element);

Returns the scheduler of the element.

gst_element_add_pad ()

void        gst_element_add_pad             (GstElement *element,
                                             GstPad *pad);

Adds a pad (link point) to element. pad's parent will be set to element; see gst_object_set_parent() for refcounting information.

Pads are automatically activated when the element is in state PLAYING.

gst_element_remove_pad ()

void        gst_element_remove_pad          (GstElement *element,
                                             GstPad *pad);

Removes pad from element. pad will be destroyed if it has not been referenced elsewhere.

gst_element_add_ghost_pad ()

GstPad*     gst_element_add_ghost_pad       (GstElement *element,
                                             GstPad *pad,
                                             const gchar *name);

Creates a ghost pad from pad, and adds it to element via gst_element_add_pad().

gst_element_remove_ghost_pad ()

void        gst_element_remove_ghost_pad    (GstElement *element,
                                             GstPad *pad);

Removes a ghost pad from an element. Deprecated, use gst_element_remove_pad() instead.

gst_element_get_pad ()

GstPad*     gst_element_get_pad             (GstElement *element,
                                             const gchar *name);

Retrieves a pad from element by name. Tries gst_element_get_static_pad() first, then gst_element_get_request_pad().

gst_element_get_static_pad ()

GstPad*     gst_element_get_static_pad      (GstElement *element,
                                             const gchar *name);

Retrieves a pad from element by name. This version only retrieves already-existing (i.e. 'static') pads.

gst_element_get_request_pad ()

GstPad*     gst_element_get_request_pad     (GstElement *element,
                                             const gchar *name);

Retrieves a pad from the element by name. This version only retrieves request pads.

gst_element_release_request_pad ()

void        gst_element_release_request_pad (GstElement *element,
                                             GstPad *pad);

Makes the element free the previously requested pad as obtained with gst_element_get_request_pad().

gst_element_get_pad_list ()

G_CONST_RETURN GList* gst_element_get_pad_list
                                            (GstElement *element);

Retrieves a list of element's pads. The list must not be modified by the calling code.

gst_element_get_compatible_pad ()

GstPad*     gst_element_get_compatible_pad  (GstElement *element,
                                             GstPad *pad);

Looks for an unlinked pad to which the given pad can link to. It is not guaranteed that linking the pads will work, though it should work in most cases.

gst_element_get_compatible_pad_filtered ()

GstPad*     gst_element_get_compatible_pad_filtered
                                            (GstElement *element,
                                             GstPad *pad,
                                             const GstCaps *filtercaps);

Looks for an unlinked pad to which the given pad can link. It is not guaranteed that linking the pads will work, though it should work in most cases.

gst_element_class_get_pad_template ()

GstPadTemplate* gst_element_class_get_pad_template
                                            (GstElementClass *element_class,
                                             const gchar *name);

Retrieves a padtemplate from element_class with the given name.

gst_element_class_get_pad_template_list ()

GList*      gst_element_class_get_pad_template_list
                                            (GstElementClass *element_class);

Retrieves a list of the pad templates associated with element_class. The list must not be modified by the calling code.

gst_element_get_pad_template ()

GstPadTemplate* gst_element_get_pad_template
                                            (GstElement *element,
                                             const gchar *name);

Retrieves a padtemplate from this element with the given name. (FIXME: Should be deprecated in favor of gst_element_class_get_pad_template).

gst_element_get_pad_template_list ()

GList*      gst_element_get_pad_template_list
                                            (GstElement *element);

Retrieves a list of the pad templates associated with the element. (FIXME: Should be deprecated in favor of gst_element_class_get_pad_template_list).

gst_element_get_compatible_pad_template ()

GstPadTemplate* gst_element_get_compatible_pad_template
                                            (GstElement *element,
                                             GstPadTemplate *compattempl);

Retrieves a pad template from element that is compatible with compattempl. Pads from compatible templates can be linked together.

gst_element_link ()

gboolean    gst_element_link                (GstElement *src,
                                             GstElement *dest);

Links src to dest with no filter caps. See gst_element_link_filtered() for more information.

gst_element_link_many ()

gboolean    gst_element_link_many           (GstElement *element_1,
                                             GstElement *element_2,
                                             ...);

Chain together a series of elements. Uses gst_element_link().

gst_element_link_filtered ()

gboolean    gst_element_link_filtered       (GstElement *src,
                                             GstElement *dest,
                                             const GstCaps *filtercaps);

Links src to dest, filtered by filtercaps. The link must be from source to destination; the other direction will not be tried. The function looks for existing pads that aren't linked yet. It will request new pads if necessary. If multiple links are possible, only one is established.

gst_element_unlink ()

void        gst_element_unlink              (GstElement *src,
                                             GstElement *dest);

Unlinks all source pads of the source element with all sink pads of the sink element to which they are linked.

gst_element_unlink_many ()

void        gst_element_unlink_many         (GstElement *element_1,
                                             GstElement *element_2,
                                             ...);

Unlinks a series of elements. Uses gst_element_unlink().

gst_element_link_pads ()

gboolean    gst_element_link_pads           (GstElement *src,
                                             const gchar *srcpadname,
                                             GstElement *dest,
                                             const gchar *destpadname);

Links 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 link fails.

gst_element_link_pads_filtered ()

gboolean    gst_element_link_pads_filtered  (GstElement *src,
                                             const gchar *srcpadname,
                                             GstElement *dest,
                                             const gchar *destpadname,
                                             const GstCaps *filtercaps);

Links 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 link fails.

gst_element_unlink_pads ()

void        gst_element_unlink_pads         (GstElement *src,
                                             const gchar *srcpadname,
                                             GstElement *dest,
                                             const gchar *destpadname);

Unlinks the two named pads of the source and destination elements.

gst_element_get_event_masks ()

G_CONST_RETURN GstEventMask* gst_element_get_event_masks
                                            (GstElement *element);

Get an array of event masks from the element. If the element doesn't implement an event masks function, the query will be forwarded to a random linked sink pad.

gst_element_send_event ()

gboolean    gst_element_send_event          (GstElement *element,
                                             GstEvent *event);

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.

gst_element_seek ()

gboolean    gst_element_seek                (GstElement *element,
                                             GstSeekType seek_type,
                                             guint64 offset);

Sends a seek event to an element.

gst_element_get_query_types ()

G_CONST_RETURN GstQueryType* gst_element_get_query_types
                                            (GstElement *element);

Get an array of query types from the element. If the element doesn't implement a query types function, the query will be forwarded to a random sink pad.

gst_element_query ()

gboolean    gst_element_query               (GstElement *element,
                                             GstQueryType type,
                                             GstFormat *format,
                                             gint64 *value);

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 usable sinkpad of this element.

gst_element_get_formats ()

G_CONST_RETURN GstFormat* gst_element_get_formats
                                            (GstElement *element);

Get an array of formats from the element. If the element doesn't implement a formats function, the query will be forwarded to a random sink pad.

gst_element_convert ()

gboolean    gst_element_convert             (GstElement *element,
                                             GstFormat src_format,
                                             gint64 src_value,
                                             GstFormat *dest_format,
                                             gint64 *dest_value);

Invokes a conversion on the element. If the element doesn't implement a convert function, the query will be forwarded to a random sink pad.

gst_element_found_tags ()

void        gst_element_found_tags          (GstElement *element,
                                             const GstTagList *tag_list);

This function emits the found_tags signal. This is a recursive signal, so every parent will emit that signal, too, before this function returns. Only emit this signal, when you extracted these tags out of the data stream, not when you handle an event.

gst_element_found_tags_for_pad ()

void        gst_element_found_tags_for_pad  (GstElement *element,
                                             GstPad *pad,
                                             GstClockTime timestamp,
                                             GstTagList *list);

This is a convenience routine for tag finding. Most of the time you only want to push the found tags down one pad, in that case this function is for you. It takes ownership of the taglist, emits the found-tag signal and pushes a tag event down the pad.

gst_element_set_eos ()

void        gst_element_set_eos             (GstElement *element);

Perform the actions needed to bring the element in the EOS state.

gst_element_error_full ()

void        gst_element_error_full          (GstElement *element,
                                             GQuark domain,
                                             gint code,
                                             gchar *message,
                                             gchar *debug,
                                             const gchar *file,
                                             const gchar *function,
                                             gint line);

Signals an error condition on an element. This function is used internally by elements. It results in the "error" signal.

gst_element_is_locked_state ()

gboolean    gst_element_is_locked_state     (GstElement *element);

Checks if the state of an element is locked. If the state of an element is locked, state changes of the parent don't affect the element. This way you can leave currently unused elements inside bins. Just lock their state before changing the state from GST_STATE_NULL.

gst_element_set_locked_state ()

void        gst_element_set_locked_state    (GstElement *element,
                                             gboolean locked_state);

Locks the state of an element, so state changes of the parent don't affect this element anymore.

gst_element_sync_state_with_parent ()

gboolean    gst_element_sync_state_with_parent
                                            (GstElement *element);

Tries to change the state of the element to the same as its parent. If this function returns FALSE, the state of element is undefined.

gst_element_get_state ()

GstElementState gst_element_get_state       (GstElement *element);

Gets the state of the element.

gst_element_set_state ()

GstElementStateReturn gst_element_set_state (GstElement *element,
                                             GstElementState state);

Sets the state of the element. This function will try to set the requested state by going through all the intermediary states and calling the class's state change function for each.

gst_element_wait_state_change ()

void        gst_element_wait_state_change   (GstElement *element);

Waits and blocks until the element changed its state.

gst_element_state_get_name ()

G_CONST_RETURN gchar* gst_element_state_get_name
                                            (GstElementState state);

Gets a string representing the given state.

gst_element_get_factory ()

GstElementFactory* gst_element_get_factory  (GstElement *element);

Retrieves the factory that was used to create this element.

gst_element_get_managing_bin ()

GstBin*     gst_element_get_managing_bin    (GstElement *element);

Gets the managing bin (a pipeline or a thread, for example) of an element.

gst_element_no_more_pads ()

void        gst_element_no_more_pads        (GstElement *element);

Use this function to signal that the element does not expect any more pads to show up in the current pipeline. This function should be called whenever pads have been added by the element itself. Elements with GST_PAD_SOMETIMES pad templates use this in combination with autopluggers to figure out that the element is done initializing its pads.

The "eos" signal

void        user_function                  (GstElement *gstelement,
                                            gpointer user_data);

the end of the stream has been reached

The "error" signal

void        user_function                  (GstElement *gstelement,
                                            GstElement *element,
                                            GstGError *error,
                                            gchar *message,
                                            gpointer user_data);

a GstError has occured during data processing

The "found-tag" signal

void        user_function                  (GstElement *gstelement,
                                            GstElement *element,
                                            GstTagList *tags,
                                            gpointer user_data);

tags for the incomming stream have been received

The "new-pad" signal

void        user_function                  (GstElement *gstelement,
                                            GObject *object,
                                            gpointer user_data);

a new GstPad has been added to the element

The "no-more-pads" signal

void        user_function                  (GstElement *gstelement,
                                            gpointer user_data);

?

The "pad-removed" signal

void        user_function                  (GstElement *gstelement,
                                            GObject *object,
                                            gpointer user_data);

a GstPad has been removed from the element

The "state-change" signal

void        user_function                  (GstElement *gstelement,
                                            gint int,
                                            gint int,
                                            gpointer user_data);

the GstElementState of the element has been changed