* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION:gstmessage
+ * @short_description: Lightweight objects to signal the application of
+ * pipeline events
+ * @see_also: #GstBus, #GstMiniObject, #GstElement
+ *
+ * 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:
+ *
+ * <example>
+ * <title>Posting a #GstMessage</title>
+ * <programlisting>
+ * gst_bus_post (bus, gst_message_new_eos());
+ * </programlisting>
+ * </example>
+ *
+ * A #GstElement usually posts messages on the bus provided by the parent
+ * container using gst_element_post_message().
+ *
+ * Last reviewed on 2005-11-09 (0.9.4)
+ */
-#include <string.h> /* memcpy */
#include "gst_private.h"
-#include "gstdata_private.h"
+#include <string.h> /* memcpy */
+#include "gsterror.h"
+#include "gstenumtypes.h"
#include "gstinfo.h"
-#include "gstmemchunk.h"
#include "gstmessage.h"
-#include "gsttag.h"
+#include "gsttaglist.h"
+#include "gstutils.h"
+#include "gstquark.h"
-#ifndef GST_DISABLE_TRACE
-/* #define GST_WITH_ALLOC_TRACE */
-#include "gsttrace.h"
-static GstAllocTrace *_message_trace;
-#endif
-static GstMemChunk *chunk;
+#define GST_MESSAGE_SEQNUM(e) ((GstMessage*)e)->abidata.ABI.seqnum
-/* #define MEMPROF */
+static void gst_message_finalize (GstMessage * message);
+static GstMessage *_gst_message_copy (GstMessage * message);
-GType _gst_message_type;
+static GstMiniObjectClass *parent_class = NULL;
void
_gst_message_initialize (void)
{
GST_CAT_INFO (GST_CAT_GST_INIT, "init messages");
- /* register the type */
- _gst_message_type = g_boxed_type_register_static ("GstMessage",
- (GBoxedCopyFunc) gst_data_copy, (GBoxedFreeFunc) gst_data_unref);
+ /* the GstMiniObject types need to be class_ref'd once before it can be
+ * done from multiple threads;
+ * see http://bugzilla.gnome.org/show_bug.cgi?id=304551 */
+ g_type_class_ref (gst_message_get_type ());
+}
+
+typedef struct
+{
+ const gint type;
+ const gchar *name;
+ GQuark quark;
+} GstMessageQuarks;
+
+static GstMessageQuarks message_quarks[] = {
+ {GST_MESSAGE_UNKNOWN, "unknown", 0},
+ {GST_MESSAGE_EOS, "eos", 0},
+ {GST_MESSAGE_ERROR, "error", 0},
+ {GST_MESSAGE_WARNING, "warning", 0},
+ {GST_MESSAGE_INFO, "info", 0},
+ {GST_MESSAGE_TAG, "tag", 0},
+ {GST_MESSAGE_BUFFERING, "buffering", 0},
+ {GST_MESSAGE_STATE_CHANGED, "state-changed", 0},
+ {GST_MESSAGE_STATE_DIRTY, "state-dirty", 0},
+ {GST_MESSAGE_STEP_DONE, "step-done", 0},
+ {GST_MESSAGE_CLOCK_PROVIDE, "clock-provide", 0},
+ {GST_MESSAGE_CLOCK_LOST, "clock-lost", 0},
+ {GST_MESSAGE_NEW_CLOCK, "new-clock", 0},
+ {GST_MESSAGE_STRUCTURE_CHANGE, "structure-change", 0},
+ {GST_MESSAGE_STREAM_STATUS, "stream-status", 0},
+ {GST_MESSAGE_APPLICATION, "application", 0},
+ {GST_MESSAGE_ELEMENT, "element", 0},
+ {GST_MESSAGE_SEGMENT_START, "segment-start", 0},
+ {GST_MESSAGE_SEGMENT_DONE, "segment-done", 0},
+ {GST_MESSAGE_DURATION, "duration", 0},
+ {GST_MESSAGE_LATENCY, "latency", 0},
+ {GST_MESSAGE_ASYNC_START, "async-start", 0},
+ {GST_MESSAGE_ASYNC_DONE, "async-done", 0},
+ {GST_MESSAGE_REQUEST_STATE, "request-state", 0},
+ {0, NULL, 0}
+};
-#ifndef GST_DISABLE_TRACE
- _message_trace = gst_alloc_trace_register (GST_MESSAGE_TRACE_NAME);
-#endif
+/**
+ * gst_message_type_get_name:
+ * @type: the message type
+ *
+ * Get a printable name for the given message type. Do not modify or free.
+ *
+ * Returns: a reference to the static name of the message.
+ */
+const gchar *
+gst_message_type_get_name (GstMessageType type)
+{
+ gint i;
- chunk = gst_mem_chunk_new ("GstMessageChunk", sizeof (GstMessage),
- sizeof (GstMessage) * 50, 0);
+ for (i = 0; message_quarks[i].name; i++) {
+ if (type == message_quarks[i].type)
+ return message_quarks[i].name;
+ }
+ return "unknown";
}
-static GstMessage *
-_gst_message_copy (GstMessage * message)
+/**
+ * gst_message_type_to_quark:
+ * @type: the message type
+ *
+ * Get the unique quark for the given message type.
+ *
+ * Returns: the quark associated with the message type
+ */
+GQuark
+gst_message_type_to_quark (GstMessageType type)
{
- GstMessage *copy;
+ gint i;
- GST_CAT_INFO (GST_CAT_MESSAGE, "copy message %p", message);
+ for (i = 0; message_quarks[i].name; i++) {
+ if (type == message_quarks[i].type)
+ return message_quarks[i].quark;
+ }
+ return 0;
+}
- copy = gst_mem_chunk_alloc (chunk);
-#ifndef GST_DISABLE_TRACE
- gst_alloc_trace_new (_message_trace, copy);
-#endif
+#define _do_init \
+{ \
+ gint i; \
+ \
+ for (i = 0; message_quarks[i].name; i++) { \
+ message_quarks[i].quark = \
+ g_quark_from_static_string (message_quarks[i].name); \
+ } \
+}
- memcpy (copy, message, sizeof (GstMessage));
- if (GST_MESSAGE_SRC (copy)) {
- gst_object_ref (GST_MESSAGE_SRC (copy));
- }
+G_DEFINE_TYPE_WITH_CODE (GstMessage, gst_message, GST_TYPE_MINI_OBJECT,
+ _do_init);
- if (message->structure) {
- copy->structure = gst_structure_copy (message->structure);
- gst_structure_set_parent_refcount (copy->structure,
- &GST_DATA_REFCOUNT (message));
- }
+static void
+gst_message_class_init (GstMessageClass * klass)
+{
+ parent_class = g_type_class_peek_parent (klass);
- return copy;
+ klass->mini_object_class.copy = (GstMiniObjectCopyFunction) _gst_message_copy;
+ klass->mini_object_class.finalize =
+ (GstMiniObjectFinalizeFunction) gst_message_finalize;
+}
+
+static void
+gst_message_init (GstMessage * message)
+{
+ GST_CAT_LOG (GST_CAT_MESSAGE, "new message %p", message);
+ GST_MESSAGE_TIMESTAMP (message) = GST_CLOCK_TIME_NONE;
}
static void
-_gst_message_free (GstMessage * message)
+gst_message_finalize (GstMessage * message)
{
- GST_CAT_INFO (GST_CAT_MESSAGE, "freeing message %p", message);
+ g_return_if_fail (message != NULL);
+
+ GST_CAT_LOG (GST_CAT_MESSAGE, "finalize message %p", message);
if (GST_MESSAGE_SRC (message)) {
gst_object_unref (GST_MESSAGE_SRC (message));
+ GST_MESSAGE_SRC (message) = NULL;
}
if (message->lock) {
gst_structure_free (message->structure);
}
- _GST_DATA_DISPOSE (GST_DATA (message));
-#ifndef GST_DISABLE_TRACE
- gst_alloc_trace_free (_message_trace, message);
-#endif
- gst_mem_chunk_free (chunk, message);
+ GST_MINI_OBJECT_CLASS (parent_class)->finalize (GST_MINI_OBJECT (message));
}
-GType
-gst_message_get_type (void)
+static GstMessage *
+_gst_message_copy (GstMessage * message)
{
- return _gst_message_type;
+ GstMessage *copy;
+
+ GST_CAT_LOG (GST_CAT_MESSAGE, "copy message %p", message);
+
+ copy = (GstMessage *) gst_mini_object_new (GST_TYPE_MESSAGE);
+
+ /* FIXME, need to copy relevant data from the miniobject. */
+ //memcpy (copy, message, sizeof (GstMessage));
+
+ GST_MESSAGE_GET_LOCK (copy) = GST_MESSAGE_GET_LOCK (message);
+ GST_MESSAGE_COND (copy) = GST_MESSAGE_COND (message);
+ GST_MESSAGE_TYPE (copy) = GST_MESSAGE_TYPE (message);
+ GST_MESSAGE_TIMESTAMP (copy) = GST_MESSAGE_TIMESTAMP (message);
+ GST_MESSAGE_SEQNUM (copy) = GST_MESSAGE_SEQNUM (message);
+
+ if (GST_MESSAGE_SRC (message)) {
+ GST_MESSAGE_SRC (copy) = gst_object_ref (GST_MESSAGE_SRC (message));
+ }
+
+ if (message->structure) {
+ copy->structure = gst_structure_copy (message->structure);
+ gst_structure_set_parent_refcount (copy->structure,
+ ©->mini_object.refcount);
+ }
+
+ return copy;
}
/**
- * gst_message_new:
- * @type: The type of the new message
+ * gst_message_new_custom:
+ * @type: The #GstMessageType to distinguish messages
+ * @src: The object originating the message.
+ * @structure: The structure for the message. The message will take ownership of
+ * the structure.
*
- * Allocate a new message of the given type.
+ * 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.
*
- * Returns: A new message.
+ * Returns: The new message.
*
* MT safe.
*/
GstMessage *
-gst_message_new (GstMessageType type, GstObject * src)
+gst_message_new_custom (GstMessageType type, GstObject * src,
+ GstStructure * structure)
{
GstMessage *message;
- message = gst_mem_chunk_alloc0 (chunk);
-#ifndef GST_DISABLE_TRACE
- gst_alloc_trace_new (_message_trace, message);
-#endif
+ message = (GstMessage *) gst_mini_object_new (GST_TYPE_MESSAGE);
- GST_CAT_INFO (GST_CAT_MESSAGE, "creating new message %p %d", message, type);
+ GST_CAT_LOG (GST_CAT_MESSAGE, "source %s: creating new message %p %s",
+ (src ? GST_OBJECT_NAME (src) : "NULL"), message,
+ gst_message_type_get_name (type));
- _GST_DATA_INIT (GST_DATA (message),
- _gst_message_type,
- 0,
- (GstDataFreeFunction) _gst_message_free,
- (GstDataCopyFunction) _gst_message_copy);
+ message->type = type;
- GST_MESSAGE_TYPE (message) = type;
- GST_MESSAGE_TIMESTAMP (message) = G_GINT64_CONSTANT (0);
- if (src) {
- GST_MESSAGE_SRC (message) = gst_object_ref (src);
- } else {
- GST_MESSAGE_SRC (message) = NULL;
+ if (src)
+ gst_object_ref (src);
+ message->src = src;
+
+ if (structure) {
+ gst_structure_set_parent_refcount (structure,
+ &message->mini_object.refcount);
}
- message->structure = NULL;
+ message->structure = structure;
+
+ GST_MESSAGE_SEQNUM (message) = gst_util_seqnum_next ();
return message;
}
+/**
+ * gst_message_get_seqnum:
+ * @message: A #GstMessage.
+ *
+ * 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 not have the same sequence number unless
+ * that correspondence was made explicitly.
+ *
+ * Returns: The message's sequence number.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.22
+ */
+guint32
+gst_message_get_seqnum (GstMessage * message)
+{
+ g_return_val_if_fail (GST_IS_MESSAGE (message), -1);
+
+ return GST_MESSAGE_SEQNUM (message);
+}
+
+/**
+ * gst_message_set_seqnum:
+ * @message: A #GstMessage.
+ * @seqnum: A sequence number.
+ *
+ * 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.
+ *
+ * Since: 0.10.22
+ */
+void
+gst_message_set_seqnum (GstMessage * message, guint32 seqnum)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+
+ GST_MESSAGE_SEQNUM (message) = seqnum;
+}
/**
* gst_message_new_eos:
+ * @src: The object originating the message.
*
- * Create a new eos message.
+ * Create a new eos message. This message is generated and posted in
+ * the sink elements of a GstBin. The bin will only forward the EOS
+ * message to the application if all sinks have posted an EOS message.
*
* Returns: The new eos message.
*
{
GstMessage *message;
- message = gst_message_new (GST_MESSAGE_EOS, src);
+ message = gst_message_new_custom (GST_MESSAGE_EOS, src, NULL);
return message;
}
* gst_message_new_error:
* @src: The object originating the message.
* @error: The GError for this message.
- * @debug: A debugging string for something or other.
+ * @debug: A debugging string.
*
- * Create a new error message. The message will take ownership of @error and
- * @debug.
+ * Create a new error message. The message will copy @error and
+ * @debug. This message is posted by element when a fatal event
+ * occured. The pipeline will probably (partially) stop. The application
+ * receiving this message should stop the pipeline.
*
* Returns: The new error message.
*
* MT safe.
*/
GstMessage *
-gst_message_new_error (GstObject * src, GError * error, gchar * debug)
+gst_message_new_error (GstObject * src, GError * error, const gchar * debug)
{
GstMessage *message;
- GstStructure *s;
+ GstStructure *structure;
- message = gst_message_new (GST_MESSAGE_ERROR, src);
- s = gst_structure_new ("GstMessageError", "gerror", G_TYPE_POINTER, error,
- "debug", G_TYPE_STRING, debug, NULL);
- gst_structure_set_parent_refcount (s, &GST_DATA_REFCOUNT (message));
- message->structure = s;
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_ERROR),
+ GST_QUARK (GERROR), GST_TYPE_G_ERROR, error,
+ GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_ERROR, src, structure);
return message;
}
* gst_message_new_warning:
* @src: The object originating the message.
* @error: The GError for this message.
- * @debug: A debugging string for something or other.
+ * @debug: A debugging string.
*
- * Create a new warning message. The message will take ownership of @error and
+ * Create a new warning message. The message will make copies of @error and
* @debug.
*
* Returns: The new warning message.
* MT safe.
*/
GstMessage *
-gst_message_new_warning (GstObject * src, GError * error, gchar * debug)
+gst_message_new_warning (GstObject * src, GError * error, const gchar * debug)
{
GstMessage *message;
- GstStructure *s;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_WARNING),
+ GST_QUARK (GERROR), GST_TYPE_G_ERROR, error,
+ GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_WARNING, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_new_info:
+ * @src: The object originating the message.
+ * @error: The GError for this message.
+ * @debug: A debugging string.
+ *
+ * Create a new info message. The message will make copies of @error and
+ * @debug.
+ *
+ * MT safe.
+ *
+ * Returns: The new info message.
+ *
+ * Since: 0.10.12
+ */
+GstMessage *
+gst_message_new_info (GstObject * src, GError * error, const gchar * debug)
+{
+ GstMessage *message;
+ GstStructure *structure;
- message = gst_message_new (GST_MESSAGE_WARNING, src);
- s = gst_structure_new ("GstMessageWarning", "gerror", G_TYPE_POINTER, error,
- "debug", G_TYPE_STRING, debug, NULL);
- gst_structure_set_parent_refcount (s, &GST_DATA_REFCOUNT (message));
- message->structure = s;
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_INFO),
+ GST_QUARK (GERROR), GST_TYPE_G_ERROR, error,
+ GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_INFO, src, structure);
return message;
}
* @tag_list: The tag list for the message.
*
* Create a new tag message. The message will take ownership of the tag list.
+ * The message is posted by elements that discovered a new taglist.
*
* Returns: The new tag message.
*
g_return_val_if_fail (GST_IS_STRUCTURE (tag_list), NULL);
- message = gst_message_new (GST_MESSAGE_TAG, src);
- gst_structure_set_parent_refcount (tag_list, &GST_DATA_REFCOUNT (message));
- message->structure = tag_list;
+ message =
+ gst_message_new_custom (GST_MESSAGE_TAG, src, (GstStructure *) tag_list);
return message;
}
/**
- * gst_message_new_state_change:
+ * gst_message_new_tag_full:
* @src: The object originating the message.
- * @old: The previous state.
- * @new: The new (current) state.
+ * @pad: The originating pad for the tag.
+ * @tag_list: The tag list for the message.
*
- * Create a state change message.
+ * Create a new tag message. The message will take ownership of the tag list.
+ * The message is posted by elements that discovered a new taglist.
*
- * Returns: The new state change message.
+ * Returns: The new tag message.
+ *
+ * Since: 0.10.24
*
* MT safe.
*/
GstMessage *
-gst_message_new_state_changed (GstObject * src, GstElementState old,
- GstElementState new)
+gst_message_new_tag_full (GstObject * src, GstPad * pad, GstTagList * tag_list)
{
GstMessage *message;
GstStructure *s;
- message = gst_message_new (GST_MESSAGE_STATE_CHANGED, src);
+ g_return_val_if_fail (GST_IS_STRUCTURE (tag_list), NULL);
+ g_return_val_if_fail (pad == NULL || GST_IS_PAD (pad), NULL);
+
+ s = (GstStructure *) tag_list;
+ if (pad)
+ gst_structure_set (s, "source-pad", GST_TYPE_PAD, pad, NULL);
- s = gst_structure_new ("GstMessageError", "old-state", G_TYPE_INT, (gint) old,
- "new-state", G_TYPE_INT, (gint) new, NULL);
- gst_structure_set_parent_refcount (s, &GST_DATA_REFCOUNT (message));
- message->structure = s;
+ message = gst_message_new_custom (GST_MESSAGE_TAG, src, s);
return message;
}
/**
- * gst_message_new_application:
- * @structure: The structure for the message. The message will take ownership of
- * the structure.
+ * gst_message_new_buffering:
+ * @src: The object originating the message.
+ * @percent: The buffering percent
*
- * Create a new application-specific message. These messages can be used by
- * application-specific plugins to pass data to the app.
+ * 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.
*
- * Returns: The new message.
+ * 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.
+ *
+ * Returns: The new buffering message.
+ *
+ * Since: 0.10.11
+ */
+GstMessage *
+gst_message_new_buffering (GstObject * src, gint percent)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ g_return_val_if_fail (percent >= 0 && percent <= 100, NULL);
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_BUFFERING),
+ GST_QUARK (BUFFER_PERCENT), G_TYPE_INT, percent,
+ GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, GST_BUFFERING_STREAM,
+ GST_QUARK (AVG_IN_RATE), G_TYPE_INT, -1,
+ GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, -1,
+ GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, G_GINT64_CONSTANT (-1),
+ GST_QUARK (ESTIMATED_TOTAL), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
+ message = gst_message_new_custom (GST_MESSAGE_BUFFERING, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_new_state_changed:
+ * @src: the object originating the message
+ * @oldstate: the previous state
+ * @newstate: the new (current) state
+ * @pending: the pending (target) state
+ *
+ * Create a state change message. This message is posted whenever an element
+ * changed its state.
+ *
+ * Returns: The new state change message.
*
* MT safe.
*/
GstMessage *
-gst_message_new_application (GstStructure * structure)
+gst_message_new_state_changed (GstObject * src,
+ GstState oldstate, GstState newstate, GstState pending)
{
GstMessage *message;
+ GstStructure *structure;
- g_return_val_if_fail (GST_IS_STRUCTURE (structure), NULL);
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_STATE),
+ GST_QUARK (OLD_STATE), GST_TYPE_STATE, (gint) oldstate,
+ GST_QUARK (NEW_STATE), GST_TYPE_STATE, (gint) newstate,
+ GST_QUARK (PENDING_STATE), GST_TYPE_STATE, (gint) pending, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_STATE_CHANGED, src, structure);
- message = gst_message_new (GST_MESSAGE_APPLICATION, NULL);
- gst_structure_set_parent_refcount (structure, &GST_DATA_REFCOUNT (message));
- message->structure = structure;
+ return message;
+}
+
+/**
+ * gst_message_new_state_dirty:
+ * @src: the object originating the message
+ *
+ * Create a state dirty message. This message is posted whenever an element
+ * changed its state asynchronously and is used internally to update the
+ * states of container objects.
+ *
+ * Returns: The new state dirty message.
+ *
+ * MT safe.
+ */
+GstMessage *
+gst_message_new_state_dirty (GstObject * src)
+{
+ GstMessage *message;
+
+ message = gst_message_new_custom (GST_MESSAGE_STATE_DIRTY, src, NULL);
return message;
}
/**
- * gst_message_get_structure:
- * @message: The #GstMessage.
+ * gst_message_new_clock_provide:
+ * @src: The object originating the message.
+ * @clock: The clock it provides
+ * @ready: TRUE if the sender can provide a clock
*
- * Access the structure of the message.
+ * 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).
*
- * Returns: The structure of the message. The structure is still
- * owned by the message, which means that you should not free it and
- * that the pointer becomes invalid when you free the message.
+ * This message is mainly used internally to manage the clock
+ * selection.
+ *
+ * Returns: The new provide clock message.
*
* MT safe.
*/
-const GstStructure *
-gst_message_get_structure (GstMessage * message)
+GstMessage *
+gst_message_new_clock_provide (GstObject * src, GstClock * clock,
+ gboolean ready)
{
- g_return_val_if_fail (GST_IS_MESSAGE (message), NULL);
+ GstMessage *message;
+ GstStructure *structure;
- return message->structure;
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_CLOCK_PROVIDE),
+ GST_QUARK (CLOCK), GST_TYPE_CLOCK, clock,
+ GST_QUARK (READY), G_TYPE_BOOLEAN, ready, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_CLOCK_PROVIDE, src, structure);
+
+ return message;
}
/**
- * gst_message_parse_tag:
- * @message: A valid #GstMessage of type GST_MESSAGE_TAG.
+ * gst_message_new_clock_lost:
+ * @src: The object originating the message.
+ * @clock: the clock that was lost
*
- * 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.
+ * 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.
+ *
+ * Returns: The new clock lost message.
*
* MT safe.
*/
-void
-gst_message_parse_tag (GstMessage * message, GstTagList ** tag_list)
+GstMessage *
+gst_message_new_clock_lost (GstObject * src, GstClock * clock)
{
- g_return_if_fail (GST_IS_MESSAGE (message));
- g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_TAG);
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_CLOCK_LOST),
+ GST_QUARK (CLOCK), GST_TYPE_CLOCK, clock, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_CLOCK_LOST, src, structure);
- *tag_list = (GstTagList *) gst_structure_copy (message->structure);
+ return message;
}
/**
- * gst_message_parse_tag:
- * @message: A valid #GstMessage of type GST_MESSAGE_STATE_CHANGED.
+ * gst_message_new_new_clock:
+ * @src: The object originating the message.
+ * @clock: the new selected clock
*
- * Extracts the old and new states from the GstMessage.
+ * Create a new clock message. This message is posted whenever the
+ * pipeline selectes a new clock for the pipeline.
+ *
+ * Returns: The new new clock message.
*
* MT safe.
*/
-void
-gst_message_parse_state_changed (GstMessage * message, GstElementState * old,
- GstElementState * new)
+GstMessage *
+gst_message_new_new_clock (GstObject * src, GstClock * clock)
{
- g_return_if_fail (GST_IS_MESSAGE (message));
- g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STATE_CHANGED);
+ GstMessage *message;
+ GstStructure *structure;
- if (!gst_structure_get_int (message->structure, "old-state", (gint *) old))
- g_assert_not_reached ();
- if (!gst_structure_get_int (message->structure, "new-state", (gint *) new))
- g_assert_not_reached ();
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_NEW_CLOCK),
+ GST_QUARK (CLOCK), GST_TYPE_CLOCK, clock, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_NEW_CLOCK, src, structure);
+
+ return message;
}
/**
- * gst_message_parse_error:
- * @message: A valid #GstMessage of type GST_MESSAGE_ERROR.
+ * gst_message_new_structure_change:
+ * @src: The object originating the message.
+ * @type: The change type.
+ * @owner: The owner element of @src.
+ * @busy: Whether the structure change is busy.
*
- * 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.
+ * 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 srcpad that unlinked or linked.
+ *
+ * Returns: The new structure change message.
*
* MT safe.
+ *
+ * Since: 0.10.22.
*/
-void
-gst_message_parse_error (GstMessage * message, GError ** gerror, gchar ** debug)
+GstMessage *
+gst_message_new_structure_change (GstObject * src, GstStructureChangeType type,
+ GstElement * owner, gboolean busy)
{
- const GValue *error_gvalue;
+ GstMessage *message;
+ GstStructure *structure;
- g_return_if_fail (GST_IS_MESSAGE (message));
- g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR);
+ g_return_val_if_fail (GST_IS_PAD (src), NULL);
+ g_return_val_if_fail (GST_PAD_DIRECTION (src) == GST_PAD_SRC, NULL);
+ g_return_val_if_fail (GST_IS_ELEMENT (owner), NULL);
- error_gvalue = gst_structure_get_value (message->structure, "gerror");
- g_return_if_fail (error_gvalue != NULL);
- g_return_if_fail (G_VALUE_TYPE (error_gvalue) == G_TYPE_POINTER);
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_STRUCTURE_CHANGE),
+ GST_QUARK (TYPE), GST_TYPE_STRUCTURE_CHANGE_TYPE, type,
+ GST_QUARK (OWNER), GST_TYPE_ELEMENT, owner,
+ GST_QUARK (BUSY), G_TYPE_BOOLEAN, busy, NULL);
- *gerror = g_error_copy (g_value_get_pointer (error_gvalue));
- *debug = g_strdup (gst_structure_get_string (message->structure, "debug"));
+ message = gst_message_new_custom (GST_MESSAGE_STRUCTURE_CHANGE, src,
+ structure);
+
+ return message;
}
/**
- * gst_message_parse_warning:
- * @message: A valid #GstMessage of type GST_MESSAGE_WARNING.
+ * gst_message_new_segment_start:
+ * @src: The object originating the message.
+ * @format: The format of the position being played
+ * @position: The position of the segment being played
*
- * 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.
+ * 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.
+ *
+ * Returns: The new segment start message.
*
* MT safe.
*/
-void
-gst_message_parse_warning (GstMessage * message, GError ** gerror,
- gchar ** debug)
+GstMessage *
+gst_message_new_segment_start (GstObject * src, GstFormat format,
+ gint64 position)
{
- const GValue *error_gvalue;
+ GstMessage *message;
+ GstStructure *structure;
- g_return_if_fail (GST_IS_MESSAGE (message));
- g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_WARNING);
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_SEGMENT_START),
+ GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
+ GST_QUARK (POSITION), G_TYPE_INT64, position, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_SEGMENT_START, src, structure);
- error_gvalue = gst_structure_get_value (message->structure, "gerror");
- g_return_if_fail (error_gvalue != NULL);
- g_return_if_fail (G_VALUE_TYPE (error_gvalue) == G_TYPE_POINTER);
+ return message;
+}
+
+/**
+ * gst_message_new_segment_done:
+ * @src: The object originating the message.
+ * @format: The format of the position being done
+ * @position: The position of the segment being done
+ *
+ * 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.
+ *
+ * Returns: The new segment done message.
+ *
+ * MT safe.
+ */
+GstMessage *
+gst_message_new_segment_done (GstObject * src, GstFormat format,
+ gint64 position)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_SEGMENT_DONE),
+ GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
+ GST_QUARK (POSITION), G_TYPE_INT64, position, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_SEGMENT_DONE, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_new_application:
+ * @src: The object originating the message.
+ * @structure: The structure for the message. The message will take ownership of
+ * the structure.
+ *
+ * Create a new application-typed message. GStreamer will never create these
+ * messages; they are a gift from us to you. Enjoy.
+ *
+ * Returns: The new application message.
+ *
+ * MT safe.
+ */
+GstMessage *
+gst_message_new_application (GstObject * src, GstStructure * structure)
+{
+ return gst_message_new_custom (GST_MESSAGE_APPLICATION, src, structure);
+}
+
+/**
+ * gst_message_new_element:
+ * @src: The object originating the message.
+ * @structure: The structure for the message. The message will take ownership of
+ * the structure.
+ *
+ * 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.
+ *
+ * Returns: The new element message.
+ *
+ * MT safe.
+ */
+GstMessage *
+gst_message_new_element (GstObject * src, GstStructure * structure)
+{
+ return gst_message_new_custom (GST_MESSAGE_ELEMENT, src, structure);
+}
+
+/**
+ * gst_message_new_duration:
+ * @src: The object originating the message.
+ * @format: The format of the duration
+ * @duration: The new duration
+ *
+ * Create a new duration message. This message is posted by elements that
+ * know the duration of a stream in a specific format. This message
+ * is received by bins and is used to calculate the total duration of a
+ * pipeline. Elements may post a duration message with a duration of
+ * GST_CLOCK_TIME_NONE to indicate that the duration has changed and the
+ * cached duration should be discarded. The new duration can then be
+ * retrieved via a query.
+ *
+ * Returns: The new duration message.
+ *
+ * MT safe.
+ */
+GstMessage *
+gst_message_new_duration (GstObject * src, GstFormat format, gint64 duration)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_DURATION),
+ GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
+ GST_QUARK (DURATION), G_TYPE_INT64, duration, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_DURATION, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_new_async_start:
+ * @src: The object originating the message.
+ * @new_base_time: if a new base_time should be set on the element
+ *
+ * This message is posted by elements when they start an ASYNC state change.
+ * @new_base_time is set to TRUE when the element lost its state when it was
+ * PLAYING.
+ *
+ * Returns: The new async_start message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.13
+ */
+GstMessage *
+gst_message_new_async_start (GstObject * src, gboolean new_base_time)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_ASYNC_START),
+ GST_QUARK (NEW_BASE_TIME), G_TYPE_BOOLEAN, new_base_time, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_ASYNC_START, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_new_async_done:
+ * @src: The object originating the message.
+ *
+ * The message is posted when elements completed an ASYNC state change.
+ *
+ * Returns: The new async_done message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.13
+ */
+GstMessage *
+gst_message_new_async_done (GstObject * src)
+{
+ GstMessage *message;
+
+ message = gst_message_new_custom (GST_MESSAGE_ASYNC_DONE, src, NULL);
+
+ return message;
+}
+
+/**
+ * gst_message_new_latency:
+ * @src: The object originating the message.
+ *
+ * This message can be posted by elements when their latency requirements have
+ * changed.
+ *
+ * Returns: The new latency message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.12
+ */
+GstMessage *
+gst_message_new_latency (GstObject * src)
+{
+ GstMessage *message;
+
+ message = gst_message_new_custom (GST_MESSAGE_LATENCY, src, NULL);
+
+ return message;
+}
+
+/**
+ * gst_message_new_request_state:
+ * @src: The object originating the message.
+ * @state: The new requested state
+ *
+ * This message can be posted by elements when they want to have their state
+ * changed. A typical use case would be an audio server that wants to pause the
+ * pipeline because a higher priority stream is being played.
+ *
+ * Returns: The new requst state message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.23
+ */
+GstMessage *
+gst_message_new_request_state (GstObject * src, GstState state)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_REQUEST_STATE),
+ GST_QUARK (NEW_STATE), GST_TYPE_STATE, (gint) state, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_REQUEST_STATE, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_get_structure:
+ * @message: The #GstMessage.
+ *
+ * Access the structure of the message.
+ *
+ * Returns: The structure of the message. The structure is still
+ * owned by the message, which means that you should not free it and
+ * that the pointer becomes invalid when you free the message.
+ *
+ * MT safe.
+ */
+const GstStructure *
+gst_message_get_structure (GstMessage * message)
+{
+ g_return_val_if_fail (GST_IS_MESSAGE (message), NULL);
+
+ return message->structure;
+}
+
+/**
+ * gst_message_parse_tag:
+ * @message: A valid #GstMessage of type GST_MESSAGE_TAG.
+ * @tag_list: Return location for the tag-list.
+ *
+ * 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.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_tag (GstMessage * message, GstTagList ** tag_list)
+{
+ GstStructure *ret;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_TAG);
+ g_return_if_fail (tag_list != NULL);
+
+ ret = gst_structure_copy (message->structure);
+ gst_structure_remove_field (ret, "source-pad");
+
+ *tag_list = (GstTagList *) ret;
+}
+
+/**
+ * gst_message_parse_tag_full:
+ * @message: A valid #GstMessage of type GST_MESSAGE_TAG.
+ * @pad: Location where the originating pad is stored, unref after usage
+ * @tag_list: Return location for the tag-list.
+ *
+ * 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.
+ *
+ * Since: 0.10.24
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_tag_full (GstMessage * message, GstPad ** pad,
+ GstTagList ** tag_list)
+{
+ GstStructure *ret;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_TAG);
+ g_return_if_fail (tag_list != NULL);
+
+ ret = gst_structure_copy (message->structure);
+
+ if (gst_structure_has_field (ret, "source-pad") && pad) {
+ const GValue *v;
+
+ v = gst_structure_get_value (ret, "source-pad");
+ if (v && G_VALUE_HOLDS (v, GST_TYPE_PAD))
+ *pad = g_value_dup_object (v);
+ else
+ *pad = NULL;
+ } else if (pad) {
+ *pad = NULL;
+ }
+ gst_structure_remove_field (ret, "source-pad");
+
+ *tag_list = (GstTagList *) ret;
+}
+
+/**
+ * gst_message_parse_buffering:
+ * @message: A valid #GstMessage of type GST_MESSAGE_BUFFERING.
+ * @percent: Return location for the percent.
+ *
+ * Extracts the buffering percent from the GstMessage. see also
+ * gst_message_new_buffering().
+ *
+ * MT safe.
+ *
+ * Since: 0.10.11
+ */
+void
+gst_message_parse_buffering (GstMessage * message, gint * percent)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_BUFFERING);
+
+ if (percent)
+ *percent = g_value_get_int (gst_structure_id_get_value (message->structure,
+ GST_QUARK (BUFFER_PERCENT)));
+}
+
+/**
+ * gst_message_set_buffering_stats:
+ * @message: A valid #GstMessage of type GST_MESSAGE_BUFFERING.
+ * @mode: a buffering mode
+ * @avg_in: the average input rate
+ * @avg_out: the average output rate
+ * @buffering_left: amount of buffering time left in milliseconds
+ *
+ * Configures the buffering stats values in @message.
+ *
+ * Since: 0.10.20
+ */
+void
+gst_message_set_buffering_stats (GstMessage * message, GstBufferingMode mode,
+ gint avg_in, gint avg_out, gint64 buffering_left)
+{
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_BUFFERING);
+
+ gst_structure_id_set (message->structure,
+ GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, mode,
+ GST_QUARK (AVG_IN_RATE), G_TYPE_INT, avg_in,
+ GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, avg_out,
+ GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, buffering_left, NULL);
+}
+
+/**
+ * gst_message_parse_buffering_stats:
+ * @message: A valid #GstMessage of type GST_MESSAGE_BUFFERING.
+ * @mode: a buffering mode
+ * @avg_in: the average input rate
+ * @avg_out: the average output rate
+ * @buffering_left: amount of buffering time left in milliseconds.
+ *
+ * Extracts the buffering stats values from @message.
+ *
+ * Since: 0.10.20
+ */
+void
+gst_message_parse_buffering_stats (GstMessage * message,
+ GstBufferingMode * mode, gint * avg_in, gint * avg_out,
+ gint64 * buffering_left)
+{
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_BUFFERING);
+
+ if (mode)
+ *mode = g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (BUFFERING_MODE)));
+ if (avg_in)
+ *avg_in = g_value_get_int (gst_structure_id_get_value (message->structure,
+ GST_QUARK (AVG_IN_RATE)));
+ if (avg_out)
+ *avg_out = g_value_get_int (gst_structure_id_get_value (message->structure,
+ GST_QUARK (AVG_OUT_RATE)));
+ if (buffering_left)
+ *buffering_left =
+ g_value_get_int64 (gst_structure_id_get_value (message->structure,
+ GST_QUARK (BUFFERING_LEFT)));
+}
+
+/**
+ * gst_message_parse_state_changed:
+ * @message: a valid #GstMessage of type GST_MESSAGE_STATE_CHANGED
+ * @oldstate: the previous state, or NULL
+ * @newstate: the new (current) state, or NULL
+ * @pending: the pending (target) state, or NULL
+ *
+ * Extracts the old and new states from the GstMessage.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_state_changed (GstMessage * message,
+ GstState * oldstate, GstState * newstate, GstState * pending)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STATE_CHANGED);
+
+ if (oldstate)
+ *oldstate =
+ g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (OLD_STATE)));
+ if (newstate)
+ *newstate =
+ g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (NEW_STATE)));
+ if (pending)
+ *pending = g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (PENDING_STATE)));
+}
+
+/**
+ * gst_message_parse_clock_provide:
+ * @message: A valid #GstMessage of type GST_MESSAGE_CLOCK_PROVIDE.
+ * @clock: A pointer to hold a clock object.
+ * @ready: A pointer to hold the ready flag.
+ *
+ * Extracts the clock and ready flag from the GstMessage.
+ * The clock object returned remains valid until the message is freed.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_clock_provide (GstMessage * message, GstClock ** clock,
+ gboolean * ready)
+{
+ const GValue *clock_gvalue;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_CLOCK_PROVIDE);
+
+ clock_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (CLOCK));
+ g_return_if_fail (clock_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (clock_gvalue) == GST_TYPE_CLOCK);
+
+ if (ready)
+ *ready =
+ g_value_get_boolean (gst_structure_id_get_value (message->structure,
+ GST_QUARK (READY)));
+ if (clock)
+ *clock = (GstClock *) g_value_get_object (clock_gvalue);
+}
+
+/**
+ * gst_message_parse_clock_lost:
+ * @message: A valid #GstMessage of type GST_MESSAGE_CLOCK_LOST.
+ * @clock: A pointer to hold the lost clock
+ *
+ * Extracts the lost clock from the GstMessage.
+ * The clock object returned remains valid until the message is freed.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_clock_lost (GstMessage * message, GstClock ** clock)
+{
+ const GValue *clock_gvalue;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_CLOCK_LOST);
+
+ clock_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (CLOCK));
+ g_return_if_fail (clock_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (clock_gvalue) == GST_TYPE_CLOCK);
+
+ if (clock)
+ *clock = (GstClock *) g_value_get_object (clock_gvalue);
+}
+
+/**
+ * gst_message_parse_new_clock:
+ * @message: A valid #GstMessage of type GST_MESSAGE_NEW_CLOCK.
+ * @clock: A pointer to hold the selected new clock
+ *
+ * Extracts the new clock from the GstMessage.
+ * The clock object returned remains valid until the message is freed.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_new_clock (GstMessage * message, GstClock ** clock)
+{
+ const GValue *clock_gvalue;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_NEW_CLOCK);
+
+ clock_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (CLOCK));
+ g_return_if_fail (clock_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (clock_gvalue) == GST_TYPE_CLOCK);
+
+ if (clock)
+ *clock = (GstClock *) g_value_get_object (clock_gvalue);
+}
+
+/**
+ * gst_message_parse_structure_change:
+ * @message: A valid #GstMessage of type GST_MESSAGE_STRUCTURE_CHANGE.
+ * @type: A pointer to hold the change type
+ * @owner: The owner element of the message source
+ * @busy: A pointer to hold whether the change is in progress or has been
+ * completed
+ *
+ * Extracts the change type and completion status from the GstMessage.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.22
+ */
+void
+gst_message_parse_structure_change (GstMessage * message,
+ GstStructureChangeType * type, GstElement ** owner, gboolean * busy)
+{
+ const GValue *owner_gvalue;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STRUCTURE_CHANGE);
+
+ owner_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (OWNER));
+ g_return_if_fail (owner_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (owner_gvalue) == GST_TYPE_ELEMENT);
+
+ if (type)
+ *type = g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (TYPE)));
+ if (owner)
+ *owner = (GstElement *) g_value_get_object (owner_gvalue);
+ if (busy)
+ *busy =
+ g_value_get_boolean (gst_structure_id_get_value (message->structure,
+ GST_QUARK (BUSY)));
+}
+
+/**
+ * gst_message_parse_error:
+ * @message: A valid #GstMessage of type GST_MESSAGE_ERROR.
+ * @gerror: Location for the GError
+ * @debug: Location for the debug message, or NULL
+ *
+ * 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.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_error (GstMessage * message, GError ** gerror, gchar ** debug)
+{
+ const GValue *error_gvalue;
+ GError *error_val;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR);
+
+ error_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (GERROR));
+ g_return_if_fail (error_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (error_gvalue) == GST_TYPE_G_ERROR);
+
+ error_val = (GError *) g_value_get_boxed (error_gvalue);
+ if (error_val)
+ *gerror = g_error_copy (error_val);
+ else
+ *gerror = NULL;
+
+ if (debug)
+ *debug =
+ g_value_dup_string (gst_structure_id_get_value (message->structure,
+ GST_QUARK (DEBUG)));
+}
+
+/**
+ * gst_message_parse_warning:
+ * @message: A valid #GstMessage of type GST_MESSAGE_WARNING.
+ * @gerror: Location for the GError
+ * @debug: Location for the debug message, or NULL
+ *
+ * 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.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_warning (GstMessage * message, GError ** gerror,
+ gchar ** debug)
+{
+ const GValue *error_gvalue;
+ GError *error_val;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_WARNING);
+
+ error_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (GERROR));
+ g_return_if_fail (error_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (error_gvalue) == GST_TYPE_G_ERROR);
+
+ error_val = (GError *) g_value_get_boxed (error_gvalue);
+ if (error_val)
+ *gerror = g_error_copy (error_val);
+ else
+ *gerror = NULL;
+
+ if (debug)
+ *debug =
+ g_value_dup_string (gst_structure_id_get_value (message->structure,
+ GST_QUARK (DEBUG)));
+}
+
+/**
+ * gst_message_parse_info:
+ * @message: A valid #GstMessage of type GST_MESSAGE_INFO.
+ * @gerror: Location for the GError
+ * @debug: Location for the debug message, or NULL
+ *
+ * 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.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.12
+ */
+void
+gst_message_parse_info (GstMessage * message, GError ** gerror, gchar ** debug)
+{
+ const GValue *error_gvalue;
+ GError *error_val;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_INFO);
+
+ error_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (GERROR));
+ g_return_if_fail (error_gvalue != NULL);
+ g_return_if_fail (G_VALUE_TYPE (error_gvalue) == GST_TYPE_G_ERROR);
+
+ error_val = (GError *) g_value_get_boxed (error_gvalue);
+ if (error_val)
+ *gerror = g_error_copy (error_val);
+ else
+ *gerror = NULL;
+
+ if (debug)
+ *debug =
+ g_value_dup_string (gst_structure_id_get_value (message->structure,
+ GST_QUARK (DEBUG)));
+}
+
+/**
+ * gst_message_parse_segment_start:
+ * @message: A valid #GstMessage of type GST_MESSAGE_SEGMENT_START.
+ * @format: Result location for the format, or NULL
+ * @position: Result location for the position, or NULL
+ *
+ * Extracts the position and format from the segment start message.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_segment_start (GstMessage * message, GstFormat * format,
+ gint64 * position)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_SEGMENT_START);
+
+ if (format)
+ *format =
+ g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (FORMAT)));
+ if (position)
+ *position =
+ g_value_get_int64 (gst_structure_id_get_value (message->structure,
+ GST_QUARK (POSITION)));
+}
+
+/**
+ * gst_message_parse_segment_done:
+ * @message: A valid #GstMessage of type GST_MESSAGE_SEGMENT_DONE.
+ * @format: Result location for the format, or NULL
+ * @position: Result location for the position, or NULL
+ *
+ * Extracts the position and format from the segment start message.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_segment_done (GstMessage * message, GstFormat * format,
+ gint64 * position)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_SEGMENT_DONE);
+
+ if (format)
+ *format =
+ g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (FORMAT)));
+ if (position)
+ *position =
+ g_value_get_int64 (gst_structure_id_get_value (message->structure,
+ GST_QUARK (POSITION)));
+}
+
+/**
+ * gst_message_parse_duration:
+ * @message: A valid #GstMessage of type GST_MESSAGE_DURATION.
+ * @format: Result location for the format, or NULL
+ * @duration: Result location for the duration, or NULL
+ *
+ * Extracts the duration and format from the duration message. The duration
+ * might be GST_CLOCK_TIME_NONE, which indicates that the duration has
+ * changed. Applications should always use a query to retrieve the duration
+ * of a pipeline.
+ *
+ * MT safe.
+ */
+void
+gst_message_parse_duration (GstMessage * message, GstFormat * format,
+ gint64 * duration)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_DURATION);
+
+ if (format)
+ *format =
+ g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (FORMAT)));
+ if (duration)
+ *duration =
+ g_value_get_int64 (gst_structure_id_get_value (message->structure,
+ GST_QUARK (DURATION)));
+}
+
+/**
+ * gst_message_parse_async_start:
+ * @message: A valid #GstMessage of type GST_MESSAGE_ASYNC_DONE.
+ * @new_base_time: Result location for the new_base_time or NULL
+ *
+ * Extract the new_base_time from the async_start message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.13
+ */
+void
+gst_message_parse_async_start (GstMessage * message, gboolean * new_base_time)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ASYNC_START);
+
+ if (new_base_time)
+ *new_base_time =
+ g_value_get_boolean (gst_structure_id_get_value (message->structure,
+ GST_QUARK (NEW_BASE_TIME)));
+}
+
+/**
+ * gst_message_parse_request_state:
+ * @message: A valid #GstMessage of type GST_MESSAGE_REQUEST_STATE.
+ * @state: Result location for the requested state or NULL
+ *
+ * Extract the requested state from the request_state message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.23
+ */
+void
+gst_message_parse_request_state (GstMessage * message, GstState * state)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_REQUEST_STATE);
+
+ if (state)
+ *state = g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (NEW_STATE)));
+}
+
+/**
+ * gst_message_new_stream_status:
+ * @src: The object originating the message.
+ * @type: The stream status type.
+ * @owner: The owner element of @src.
+ *
+ * Create a new stream status message. This message is posted when a streaming
+ * thread is created/destroyed or when the state changed.
+ *
+ * Returns: The new stream status message.
+ *
+ * MT safe.
+ *
+ * Since: 0.10.24.
+ */
+GstMessage *
+gst_message_new_stream_status (GstObject * src, GstStreamStatusType type,
+ GstElement * owner)
+{
+ GstMessage *message;
+ GstStructure *structure;
+
+ structure = gst_structure_id_new (GST_QUARK (MESSAGE_STREAM_STATUS),
+ GST_QUARK (TYPE), GST_TYPE_STREAM_STATUS_TYPE, (gint) type,
+ GST_QUARK (OWNER), GST_TYPE_ELEMENT, owner, NULL);
+ message = gst_message_new_custom (GST_MESSAGE_STREAM_STATUS, src, structure);
+
+ return message;
+}
+
+/**
+ * gst_message_parse_stream_status:
+ * @message: A valid #GstMessage of type GST_MESSAGE_STREAM_STATUS.
+ * @type: A pointer to hold the status type
+ * @owner: The owner element of the message source
+ *
+ * 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.
+ *
+ * Since: 0.10.24.
+ */
+void
+gst_message_parse_stream_status (GstMessage * message,
+ GstStreamStatusType * type, GstElement ** owner)
+{
+ const GValue *owner_gvalue;
+
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STREAM_STATUS);
+
+ owner_gvalue =
+ gst_structure_id_get_value (message->structure, GST_QUARK (OWNER));
+ g_return_if_fail (owner_gvalue != NULL);
+
+ if (type)
+ *type = g_value_get_enum (gst_structure_id_get_value (message->structure,
+ GST_QUARK (TYPE)));
+ if (owner)
+ *owner = (GstElement *) g_value_get_object (owner_gvalue);
+}
+
+/**
+ * gst_message_set_stream_status_object:
+ * @message: A valid #GstMessage of type GST_MESSAGE_STREAM_STATUS.
+ * @object: the object controlling the streaming
+ *
+ * Configures the object handling the streaming thread. This is usually a
+ * GstTask object but other objects might be added in the future.
+ *
+ * Since: 0.10.24
+ */
+void
+gst_message_set_stream_status_object (GstMessage * message,
+ const GValue * object)
+{
+ g_return_if_fail (GST_IS_MESSAGE (message));
+ g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STREAM_STATUS);
+
+ gst_structure_id_set_value (message->structure, GST_QUARK (OBJECT), object);
+}
+
+/**
+ * gst_message_get_stream_status_object:
+ * @message: A valid #GstMessage of type GST_MESSAGE_STREAM_STATUS.
+ *
+ * Extracts the object managing the streaming thread from @message.
+ *
+ * Returns: a GValue containing the object that manages the streaming thread.
+ * This object is usually of type GstTask but other types can be added in the
+ * future. The object remains valid as long as @message is valid.
+ *
+ * Since: 0.10.24
+ */
+const GValue *
+gst_message_get_stream_status_object (GstMessage * message)
+{
+ const GValue *result;
+
+ g_return_val_if_fail (GST_IS_MESSAGE (message), NULL);
+ g_return_val_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STREAM_STATUS,
+ NULL);
+
+ result = gst_structure_id_get_value (message->structure, GST_QUARK (OBJECT));
- *gerror = g_error_copy (g_value_get_pointer (error_gvalue));
- *debug = g_strdup (gst_structure_get_string (message->structure, "debug"));
+ return result;
}
projects / platform / upstream / gstreamer.git / blobdiff