the parent structure
the sequence number of the message
the src of the message
the timestamp of the message
the #GstMessageType of the message
Creates and appends a new entry.
The specified location string is copied. However, ownership over the tag list and structure are transferred to the message.
location string for the new entry
tag list for the new entry
structure for the new entry
Retrieve the sequence number of a message.
Messages have ever-incrementing sequence numbers, which may also be set explicitly via gst_message_set_seqnum(). Sequence numbers are typically used to indicate that a message corresponds to some other set of messages or events, for example a SEGMENT_DONE message corresponding to a SEEK event. It is considered good practice to make this correspondence when possible, though it is not required.
Note that events and messages share the same sequence number incrementor; two events or messages will never have the same sequence number unless that correspondence was made explicitly.
Extracts the object managing the streaming thread from message.
Checks if message has the given name. This function is usually used to
check the name of a custom message.
name to check
Extract the running_time from the async_done message.
MT safe.
Extracts the buffering percent from the GstMessage. see also gst_message_new_buffering().
MT safe.
Extracts the buffering stats values from message.
Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.
Parses a device-changed message. The device-changed message is produced by
#GstDeviceProvider or a #GstDeviceMonitor. It announces the
disappearance of monitored devices. * It announce that a device properties has
changed and device represents the new modified version of changed_device.
Extracts the GError and debug string from the GstMessage. The values returned in the output arguments are copies; the caller must free them when done.
Typical usage of this function might be:
...
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR: {
GError *err = NULL;
gchar *dbg_info = NULL;
gst_message_parse_error (msg, &err, &dbg_info);
g_printerr ("ERROR from element %s: %s\n",
GST_OBJECT_NAME (msg->src), err->message);
g_printerr ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none");
g_error_free (err);
g_free (dbg_info);
break;
}
...
}
...
MT safe.
Extract the group from the STREAM_START message.
Parses the rate_multiplier from the instant-rate-request message.
Parses the progress type, code and text.
Extract the timestamps and live status from the QoS message.
The returned values give the running_time, stream_time, timestamp and duration of the dropped buffer. Values of GST_CLOCK_TIME_NONE mean unknown values.
MT safe.
Extract the QoS values that have been calculated/analysed from the QoS data
MT safe.
Parses the location and/or structure from the entry with the given index. The index must be between 0 and gst_message_get_num_redirect_entries() - 1. Returned pointers are valid for as long as this message exists.
index of the entry to parse
Extract the running-time from the RESET_TIME message.
MT safe.
Extracts the old and new states from the GstMessage.
Typical usage of this function might be:
...
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_STATE_CHANGED: {
GstState old_state, new_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
g_print ("Element %s changed state from %s to %s.\n",
GST_OBJECT_NAME (msg->src),
gst_element_state_get_name (old_state),
gst_element_state_get_name (new_state));
break;
}
...
}
...
MT safe.
Parses a stream-collection message.
Extracts the stream status type and owner the GstMessage. The returned
owner remains valid for as long as the reference to message is valid and
should thus not be unreffed.
MT safe.
Parses a streams-selected message.
Extracts the change type and completion status from the GstMessage.
MT safe.
Extracts the tag list from the GstMessage. The tag list returned in the output argument is a copy; the caller must free it when done.
Typical usage of this function might be:
...
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_TAG: {
GstTagList *tags = NULL;
gst_message_parse_tag (msg, &tags);
g_print ("Got tags from element %s\n", GST_OBJECT_NAME (msg->src));
handle_tags (tags);
gst_tag_list_unref (tags);
break;
}
...
}
...
MT safe.
Extract the TOC from the #GstMessage. The TOC returned in the output argument is a copy; the caller must free it with gst_toc_unref() when done.
MT safe.
Configures the buffering stats values in message.
a buffering mode
the average input rate
the average output rate
amount of buffering time left in milliseconds
Sets the group id on the stream-start message.
All streams that have the same group id are supposed to be played together, i.e. all streams inside a container file should have the same group id but different stream ids. The group id should change each time the stream is started, resulting in different group ids each time a file is played for example.
MT safe.
the group id
Set the QoS stats representing the history of the current continuous pipeline playback period.
When format is GST_FORMAT_UNDEFINED both dropped and processed are
invalid. Values of -1 for either processed or dropped mean unknown values.
MT safe.
Units of the 'processed' and 'dropped' fields. Video sinks and video filters will use GST_FORMAT_BUFFERS (frames). Audio sinks and audio filters will likely use GST_FORMAT_DEFAULT (samples).
Total number of units correctly processed since the last state change to READY or a flushing operation.
Total number of units dropped since the last state change to READY or a flushing operation.
Set the QoS values that have been calculated/analysed from the QoS data
MT safe.
The difference of the running-time against the deadline.
Long term prediction of the ideal rate relative to normal rate to get optimal quality.
An element dependent integer value that specifies the current quality level of the element. The default maximum quality is 1000000.
Set the sequence number of a message.
This function might be called by the creator of a message to indicate that the message relates to other messages or events. See gst_message_get_seqnum() for more information.
MT safe.
A sequence number.
Configures the object handling the streaming thread. This is usually a GstTask object but other objects might be added in the future.
the object controlling the streaming
Returns the number of streams contained in the message.
Create a new application-typed message. GStreamer will never create these messages; they are a gift from us to you. Enjoy.
The object originating the message.
the structure for the message. The message will take ownership of the structure.
The message is posted when elements completed an ASYNC state change.
running_time contains the time of the desired running_time when this
elements goes to PLAYING. A value of #GST_CLOCK_TIME_NONE for running_time
means that the element has no clock interaction and thus doesn't care about
the running_time of the pipeline.
Create a new buffering message. This message can be posted by an element that
needs to buffer data before it can continue processing. percent should be a
value between 0 and 100. A value of 100 means that the buffering completed.
When percent is < 100 the application should PAUSE a PLAYING pipeline. When
percent is 100, the application can set the pipeline (back) to PLAYING.
The application must be prepared to receive BUFFERING messages in the
PREROLLING state and may only set the pipeline to PLAYING after receiving a
message with percent set to 100, which can happen after the pipeline
completed prerolling.
MT safe.
Create a clock lost message. This message is posted whenever the clock is not valid anymore.
If this message is posted by the pipeline, the pipeline will select a new clock again when it goes to PLAYING. It might therefore be needed to set the pipeline to PAUSED and PLAYING again.
Create a clock provide message. This message is posted whenever an element is ready to provide a clock or lost its ability to provide a clock (maybe because it paused or became EOS).
This message is mainly used internally to manage the clock selection.
The object originating the message.
the clock it provides
%TRUE if the sender can provide a clock
Create a new custom-typed message. This can be used for anything not handled by other message-specific functions to pass a message to the app. The structure field can be %NULL.
The #GstMessageType to distinguish messages
The object originating the message.
the structure for the message. The message will take ownership of the structure.
Creates a new device-changed message. The device-changed message is produced
by #GstDeviceProvider or a #GstDeviceMonitor. They announce that a device
properties has changed and device represent the new modified version of changed_device.
The #GstObject that created the message
The newly created device representing replaced_device with its new configuration.
Create a new element-specific message. This is meant as a generic way of allowing one-way communication from an element to an application, for example "the firewire cable was unplugged". The format of the message should be documented in the element's documentation. The structure field can be %NULL.
The object originating the message.
The structure for the message. The message will take ownership of the structure.
Create a new error message. The message will copy error and
debug. This message is posted by element when a fatal event
occurred. The pipeline will probably (partially) stop. The application
receiving this message should stop the pipeline.
The object originating the message.
The GError for this message.
A debugging string.
Create a new error message. The message will copy error and
debug. This message is posted by element when a fatal event
occurred. The pipeline will probably (partially) stop. The application
receiving this message should stop the pipeline.
The object originating the message.
The GError for this message.
A debugging string.
A GstStructure with details
Creates a new instant-rate-request message. Elements handling the
instant-rate-change event must post this message. The message is
handled at the pipeline, and allows the pipeline to select the
running time when the rate change should happen and to send an
GST_EVENT_INSTANT_RATE_SYNC_TIME event to notify the elements
in the pipeline.
The #GstObject that posted the message
the rate multiplier factor that should be applied
Progress messages are posted by elements when they use an asynchronous task to perform actions triggered by a state change.
code contains a well defined string describing the action.
text should contain a user visible string detailing the current action.
The object originating the message.
a #GstProgressType
a progress code
free, user visible text describing the progress
A QOS message is posted on the bus whenever an element decides to drop a buffer because of QoS reasons or whenever it changes its processing strategy because of QoS reasons (quality adjustments such as processing at lower accuracy).
This message can be posted by an element that performs synchronisation against the clock (live) or it could be dropped by an element that performs QoS because of QOS events received from a downstream element (!live).
running_time, stream_time, timestamp, duration should be set to the
respective running-time, stream-time, timestamp and duration of the (dropped)
buffer that generated the QoS event. Values can be left to
GST_CLOCK_TIME_NONE when unknown.
The object originating the message.
if the message was generated by a live element
the running time of the buffer that generated the message
the stream time of the buffer that generated the message
the timestamps of the buffer that generated the message
the duration of the buffer that generated the message
Creates a new redirect message and adds a new entry to it. Redirect messages are posted when an element detects that the actual data has to be retrieved from a different location. This is useful if such a redirection cannot be handled inside a source element, for example when HTTP 302/303 redirects return a non-HTTP URL.
The redirect message can hold multiple entries. The first one is added when the redirect message is created, with the given location, tag_list, entry_struct arguments. Use gst_message_add_redirect_entry() to add more entries.
Each entry has a location, a tag list, and a structure. All of these are optional. The tag list and structure are useful for additional metadata, such as bitrate statistics for the given location.
By default, message recipients should treat entries in the order they are stored. The recipient should therefore try entry #0 first, and if this entry is not acceptable or working, try entry #1 etc. Senders must make sure that they add entries in this order. However, recipients are free to ignore the order and pick an entry that is "best" for them. One example would be a recipient that scans the entries for the one with the highest bitrate tag.
The specified location string is copied. However, ownership over the tag list and structure are transferred to the message.
The #GstObject whose property changed (may or may not be a #GstElement)
location string for the new entry
tag list for the new entry
structure for the new entry
Create a new segment done message. This message is posted by elements that finish playback of a segment as a result of a segment seek. This message is received by the application after all elements that posted a segment_start have posted the segment_done.
The object originating the message.
The format of the position being done
The position of the segment being done
Create a new segment message. This message is posted by elements that start playback of a segment as a result of a segment seek. This message is not received by the application but is used for maintenance reasons in container elements.
The object originating the message.
The format of the position being played
The position of the segment being played
Create a state change message. This message is posted whenever an element changed its state.
The object originating the message.
the previous state
the new (current) state
the pending (target) state
This message is posted by elements when they complete a part, when intermediate set
to %TRUE, or a complete step operation.
duration will contain the amount of time (in GST_FORMAT_TIME) of the stepped
amount of media in format format.
The object originating the message.
the format of amount
the amount of stepped data
the rate of the stepped amount
is this an flushing step
is this an intermediate step
the duration of the data
the step caused EOS
This message is posted by elements when they accept or activate a new step
event for amount in format.
active is set to %FALSE when the element accepted the new step event and has
queued it for execution in the streaming threads.
active is set to %TRUE when the element has activated the step operation and
is now ready to start executing the step in the streaming thread. After this
message is emitted, the application can queue a new step operation in the
element.
The object originating the message.
if the step is active or queued
the format of amount
the amount of stepped data
the rate of the stepped amount
is this an flushing step
is this an intermediate step
Creates a new stream-collection message. The message is used to announce new #GstStreamCollection
The #GstObject that created the message
The #GstStreamCollection
Create a new stream status message. This message is posted when a streaming thread is created/destroyed or when the state changed.
The object originating the message.
The stream status type.
the owner element of src.
Creates a new steams-selected message. The message is used to announce that an array of streams has been selected. This is generally in response to a #GST_EVENT_SELECT_STREAMS event, or when an element (such as decodebin3) makes an initial selection of streams.
The message also contains the #GstStreamCollection to which the various streams belong to.
Users of gst_message_new_streams_selected() can add the selected streams with gst_message_streams_selected_add().
The #GstObject that created the message
The #GstStreamCollection
Create a new structure change message. This message is posted when the structure of a pipeline is in the process of being changed, for example when pads are linked or unlinked.
src should be the sinkpad that unlinked or linked.
The object originating the message.
The change type.
The owner element of src.
Whether the structure change is busy.
Modifies a pointer to a #GstMessage to point to a different #GstMessage. This
function is similar to gst_message_replace() except that it takes ownership
of new_message.
pointer to a pointer to a #GstMessage to be replaced.
pointer to a #GstMessage that will replace the message pointed to by old_message.
Messages are implemented as a subclass of #GstMiniObject with a generic #GstStructure as the content. This allows for writing custom messages without requiring an API change while allowing a wide range of different types of messages.
Messages are posted by objects in the pipeline and are passed to the application using the #GstBus.
The basic use pattern of posting a message on a #GstBus is as follows:
A #GstElement usually posts messages on the bus provided by the parent container using gst_element_post_message().