/* GStreamer

 * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>

 *

 * gstmessage.c: GstMessage subsystem

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstmessage

 * @title: 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:

 * |[

 *   gst_bus_post (bus, gst_message_new_eos());

 * ]|

 *

 * A #GstElement usually posts messages on the bus provided by the parent

 * container using gst_element_post_message().

 */

#include "gst_private.h"

#include <string.h>             /* memcpy */

#include "gsterror.h"

#include "gstenumtypes.h"

#include "gstinfo.h"

#include "gstmessage.h"

#include "gsttaglist.h"

#include "gstutils.h"

#include "gstquark.h"

#include "gstvalue.h"

typedef struct

{

  GstMessage message;

  GstStructure *structure;

} GstMessageImpl;

#define GST_MESSAGE_STRUCTURE(m)  (((GstMessageImpl *)(m))->structure)

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_CHANGED, "duration-changed", 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},

  {GST_MESSAGE_STEP_START, "step-start", 0},

  {GST_MESSAGE_QOS, "qos", 0},

  {GST_MESSAGE_PROGRESS, "progress", 0},

  {GST_MESSAGE_TOC, "toc", 0},

  {GST_MESSAGE_RESET_TIME, "reset-time", 0},

  {GST_MESSAGE_STREAM_START, "stream-start", 0},

  {GST_MESSAGE_NEED_CONTEXT, "need-context", 0},

  {GST_MESSAGE_HAVE_CONTEXT, "have-context", 0},

  {GST_MESSAGE_DEVICE_ADDED, "device-added", 0},

  {GST_MESSAGE_DEVICE_REMOVED, "device-removed", 0},

  {GST_MESSAGE_PROPERTY_NOTIFY, "property-notify", 0},

  {GST_MESSAGE_STREAM_COLLECTION, "stream-collection", 0},

  {GST_MESSAGE_STREAMS_SELECTED, "streams-selected", 0},

  {GST_MESSAGE_REDIRECT, "redirect", 0},

  {0, NULL, 0}

};

static GQuark details_quark = 0;

GType _gst_message_type = 0;

GST_DEFINE_MINI_OBJECT_TYPE (GstMessage, gst_message);

void

_priv_gst_message_initialize (void)

{

  gint i;

  GST_CAT_INFO (GST_CAT_GST_INIT, "init messages");

  for (i = 0; message_quarks[i].name; i++) {

    message_quarks[i].quark =

        g_quark_from_static_string (message_quarks[i].name);

  }

  details_quark = g_quark_from_static_string ("details");

  _gst_message_type = gst_message_get_type ();

}

/**

 * 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;

  for (i = 0; message_quarks[i].name; i++) {

    if (type == message_quarks[i].type)

      return message_quarks[i].name;

  }

  return "unknown";

}

/**

 * 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)

{

  gint i;

  for (i = 0; message_quarks[i].name; i++) {

    if (type == message_quarks[i].type)

      return message_quarks[i].quark;

  }

  return 0;

}

static gboolean

_gst_message_dispose (GstMessage * message)

{

  gboolean do_free = TRUE;

  if (GST_MINI_OBJECT_FLAG_IS_SET (message, GST_MESSAGE_FLAG_ASYNC_DELIVERY)) {

    /* revive message, so bus can finish with it and clean it up */

    gst_message_ref (message);

    GST_INFO ("[msg %p] signalling async free", message);

    GST_MESSAGE_LOCK (message);

    GST_MESSAGE_SIGNAL (message);

    GST_MESSAGE_UNLOCK (message);

    /* don't free it yet, let bus finish with it first */

    do_free = FALSE;

  }

  return do_free;

}

static void

_gst_message_free (GstMessage * message)

{

  GstStructure *structure;

  g_return_if_fail (message != NULL);

  GST_CAT_LOG (GST_CAT_MESSAGE, "finalize message %p, %s from %s", message,

      GST_MESSAGE_TYPE_NAME (message), GST_MESSAGE_SRC_NAME (message));

  if (GST_MESSAGE_SRC (message)) {

    gst_object_unref (GST_MESSAGE_SRC (message));

    GST_MESSAGE_SRC (message) = NULL;

  }

  structure = GST_MESSAGE_STRUCTURE (message);

  if (structure) {

    gst_structure_set_parent_refcount (structure, NULL);

    gst_structure_free (structure);

  }

  g_slice_free1 (sizeof (GstMessageImpl), message);

}

static void

gst_message_init (GstMessageImpl * message, GstMessageType type,

    GstObject * src);

static GstMessage *

_gst_message_copy (GstMessage * message)

{

  GstMessageImpl *copy;

  GstStructure *structure;

  GST_CAT_LOG (GST_CAT_MESSAGE, "copy message %p, %s from %s", message,

      GST_MESSAGE_TYPE_NAME (message),

      GST_OBJECT_NAME (GST_MESSAGE_SRC (message)));

  copy = g_slice_new0 (GstMessageImpl);

  gst_message_init (copy, GST_MESSAGE_TYPE (message),

      GST_MESSAGE_SRC (message));

  GST_MESSAGE_TIMESTAMP (copy) = GST_MESSAGE_TIMESTAMP (message);

  GST_MESSAGE_SEQNUM (copy) = GST_MESSAGE_SEQNUM (message);

  structure = GST_MESSAGE_STRUCTURE (message);

  if (structure) {

    GST_MESSAGE_STRUCTURE (copy) = gst_structure_copy (structure);

    gst_structure_set_parent_refcount (GST_MESSAGE_STRUCTURE (copy),

        &copy->message.mini_object.refcount);

  } else {

    GST_MESSAGE_STRUCTURE (copy) = NULL;

  }

  return GST_MESSAGE_CAST (copy);

}

static void

gst_message_init (GstMessageImpl * message, GstMessageType type,

    GstObject * src)

{

  gst_mini_object_init (GST_MINI_OBJECT_CAST (message), 0, _gst_message_type,

      (GstMiniObjectCopyFunction) _gst_message_copy,

      (GstMiniObjectDisposeFunction) _gst_message_dispose,

      (GstMiniObjectFreeFunction) _gst_message_free);

  GST_MESSAGE_TYPE (message) = type;

  if (src)

    gst_object_ref (src);

  GST_MESSAGE_SRC (message) = src;

  GST_MESSAGE_TIMESTAMP (message) = GST_CLOCK_TIME_NONE;

  GST_MESSAGE_SEQNUM (message) = gst_util_seqnum_next ();

}

/**

 * gst_message_new_custom:

 * @type: The #GstMessageType to distinguish messages

 * @src: (transfer none) (allow-none): The object originating the message.

 * @structure: (transfer full) (allow-none): the structure for the

 *     message. The message will take ownership of the structure.

 *

 * 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: (transfer full) (nullable): The new message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_custom (GstMessageType type, GstObject * src,

    GstStructure * structure)

{

  GstMessageImpl *message;

  message = g_slice_new0 (GstMessageImpl);

  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));

  if (structure) {

    /* structure must not have a parent */

    if (!gst_structure_set_parent_refcount (structure,

            &message->message.mini_object.refcount))

      goto had_parent;

  }

  gst_message_init (message, type, src);

  GST_MESSAGE_STRUCTURE (message) = structure;

  return GST_MESSAGE_CAST (message);

  /* ERRORS */

had_parent:

  {

    g_slice_free1 (sizeof (GstMessageImpl), message);

    g_warning ("structure is already owned by another object");

    return NULL;

  }

}

/**

 * 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 have the same sequence number unless

 * that correspondence was made explicitly.

 *

 * Returns: The message's sequence number.

 *

 * MT safe.

 */

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.

 */

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: (transfer none) (allow-none): The object originating the 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: (transfer full): The new eos message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_eos (GstObject * src)

{

  GstMessage *message;

  message = gst_message_new_custom (GST_MESSAGE_EOS, src, NULL);

  return message;

}

/**

 * gst_message_new_error_with_details:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: A debugging string.

 * @details: (transfer full): (allow-none): A GstStructure with details

 *

 * 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.

 *

 * Returns: (transfer full) (nullable): the new error message.

 *

 * Since: 1.10

 */

GstMessage *

gst_message_new_error_with_details (GstObject * src, GError * error,

    const gchar * debug, GstStructure * details)

{

  GstMessage *message;

  GstStructure *structure;

  if (debug && !g_utf8_validate (debug, -1, NULL)) {

    debug = NULL;

    g_warning ("Trying to set debug field of error message, but "

        "string is not valid UTF-8. Please file a bug.");

  }

  structure = gst_structure_new_id (GST_QUARK (MESSAGE_ERROR),

      GST_QUARK (GERROR), G_TYPE_ERROR, error,

      GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);

  message = gst_message_new_custom (GST_MESSAGE_ERROR, src, structure);

  if (details) {

    GValue v = G_VALUE_INIT;

    g_value_init (&v, GST_TYPE_STRUCTURE);

    g_value_take_boxed (&v, details);

    gst_structure_id_take_value (GST_MESSAGE_STRUCTURE (message), details_quark,

        &v);

  }

  return message;

}

/**

 * gst_message_new_error:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: 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.

 *

 * Returns: (transfer full): the new error message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_error (GstObject * src, GError * error, const gchar * debug)

{

  return gst_message_new_error_with_details (src, error, debug, NULL);

}

/**

 * gst_message_parse_error_details:

 * @message: The message object

 * @structure: (transfer none) (out): A pointer to the returned details

 *

 * Returns the optional details structure, may be NULL if none.

 * The returned structure must not be freed.

 *

 * Since: 1.10

 */

void

gst_message_parse_error_details (GstMessage * message,

    const GstStructure ** structure)

{

  const GValue *v;

  g_return_if_fail (GST_IS_MESSAGE (message));

  g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR);

  g_return_if_fail (structure != NULL);

  *structure = NULL;

  v = gst_structure_id_get_value (GST_MESSAGE_STRUCTURE (message),

      details_quark);

  if (v) {

    *structure = g_value_get_boxed (v);

  }

}

/**

 * gst_message_new_warning_with_details:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: A debugging string.

 * @details: (transfer full): (allow-none): A GstStructure with details

 *

 * Create a new warning message. The message will make copies of @error and

 * @debug.

 *

 * Returns: (transfer full) (nullable): the new warning message.

 *

 * Since: 1.10

 */

GstMessage *

gst_message_new_warning_with_details (GstObject * src, GError * error,

    const gchar * debug, GstStructure * details)

{

  GstMessage *message;

  GstStructure *structure;

  if (debug && !g_utf8_validate (debug, -1, NULL)) {

    debug = NULL;

    g_warning ("Trying to set debug field of warning message, but "

        "string is not valid UTF-8. Please file a bug.");

  }

  structure = gst_structure_new_id (GST_QUARK (MESSAGE_WARNING),

      GST_QUARK (GERROR), G_TYPE_ERROR, error,

      GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);

  message = gst_message_new_custom (GST_MESSAGE_WARNING, src, structure);

  if (details) {

    GValue v = G_VALUE_INIT;

    g_value_init (&v, GST_TYPE_STRUCTURE);

    g_value_take_boxed (&v, details);

    gst_structure_id_take_value (GST_MESSAGE_STRUCTURE (message), details_quark,

        &v);

  }

  return message;

}

/**

 * gst_message_new_warning:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: A debugging string.

 *

 * Create a new warning message. The message will make copies of @error and

 * @debug.

 *

 * Returns: (transfer full): the new warning message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_warning (GstObject * src, GError * error, const gchar * debug)

{

  return gst_message_new_warning_with_details (src, error, debug, NULL);

}

/**

 * gst_message_parse_warning_details:

 * @message: The message object

 * @structure: (transfer none) (out): A pointer to the returned details structure

 *

 * Returns the optional details structure, may be NULL if none

 * The returned structure must not be freed.

 *

 * Since: 1.10

 */

void

gst_message_parse_warning_details (GstMessage * message,

    const GstStructure ** structure)

{

  const GValue *v;

  g_return_if_fail (GST_IS_MESSAGE (message));

  g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_WARNING);

  g_return_if_fail (structure != NULL);

  *structure = NULL;

  v = gst_structure_id_get_value (GST_MESSAGE_STRUCTURE (message),

      details_quark);

  if (v) {

    *structure = g_value_get_boxed (v);

  }

}

/**

 * gst_message_new_info_with_details:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: A debugging string.

 * @details: (transfer full): (allow-none): A GstStructure with details

 *

 * Create a new info message. The message will make copies of @error and

 * @debug.

 *

 * Returns: (transfer full) (nullable): the new warning message.

 *

 * Since: 1.10

 */

GstMessage *

gst_message_new_info_with_details (GstObject * src, GError * error,

    const gchar * debug, GstStructure * details)

{

  GstMessage *message;

  GstStructure *structure;

  if (debug && !g_utf8_validate (debug, -1, NULL)) {

    debug = NULL;

    g_warning ("Trying to set debug field of info message, but "

        "string is not valid UTF-8. Please file a bug.");

  }

  structure = gst_structure_new_id (GST_QUARK (MESSAGE_INFO),

      GST_QUARK (GERROR), G_TYPE_ERROR, error,

      GST_QUARK (DEBUG), G_TYPE_STRING, debug, NULL);

  message = gst_message_new_custom (GST_MESSAGE_INFO, src, structure);

  if (details) {

    GValue v = G_VALUE_INIT;

    g_value_init (&v, GST_TYPE_STRUCTURE);

    g_value_take_boxed (&v, details);

    gst_structure_id_take_value (GST_MESSAGE_STRUCTURE (message), details_quark,

        &v);

  }

  return message;

}

/**

 * gst_message_new_info:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @error: (transfer none): The GError for this message.

 * @debug: A debugging string.

 *

 * Create a new info message. The message will make copies of @error and

 * @debug.

 *

 * Returns: (transfer full): the new info message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_info (GstObject * src, GError * error, const gchar * debug)

{

  return gst_message_new_info_with_details (src, error, debug, NULL);

}

/**

 * gst_message_parse_info_details:

 * @message: The message object

 * @structure: (transfer none) (out): A pointer to the returned details structure

 *

 * Returns the optional details structure, may be NULL if none

 * The returned structure must not be freed.

 *

 * Since: 1.10

 */

void

gst_message_parse_info_details (GstMessage * message,

    const GstStructure ** structure)

{

  const GValue *v;

  g_return_if_fail (GST_IS_MESSAGE (message));

  g_return_if_fail (GST_MESSAGE_TYPE (message) == GST_MESSAGE_INFO);

  g_return_if_fail (structure != NULL);

  *structure = NULL;

  v = gst_structure_id_get_value (GST_MESSAGE_STRUCTURE (message),

      details_quark);

  if (v) {

    *structure = g_value_get_boxed (v);

  }

}

/**

 * gst_message_new_tag:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @tag_list: (transfer full): 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: (transfer full): the new tag message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_tag (GstObject * src, GstTagList * tag_list)

{

  GstStructure *s;

  GstMessage *message;

  GValue val = G_VALUE_INIT;

  g_return_val_if_fail (GST_IS_TAG_LIST (tag_list), NULL);

  s = gst_structure_new_id_empty (GST_QUARK (MESSAGE_TAG));

  g_value_init (&val, GST_TYPE_TAG_LIST);

  g_value_take_boxed (&val, tag_list);

  gst_structure_id_take_value (s, GST_QUARK (TAGLIST), &val;;

  message = gst_message_new_custom (GST_MESSAGE_TAG, src, s);

  return message;

}

/**

 * gst_message_new_buffering:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @percent: The buffering percent

 *

 * 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.

 *

 * Returns: (transfer full) (nullable): The new buffering message.

 */

GstMessage *

gst_message_new_buffering (GstObject * src, gint percent)

{

  GstMessage *message;

  GstStructure *structure;

  gint64 buffering_left;

  g_return_val_if_fail (percent >= 0 && percent <= 100, NULL);

  buffering_left = (percent == 100 ? 0 : -1);

  structure = gst_structure_new_id (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, buffering_left, NULL);

  message = gst_message_new_custom (GST_MESSAGE_BUFFERING, src, structure);

  return message;

}

/**

 * gst_message_new_state_changed:

 * @src: (transfer none) (allow-none): 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: (transfer full): the new state change message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_state_changed (GstObject * src,

    GstState oldstate, GstState newstate, GstState pending)

{

  GstMessage *message;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (MESSAGE_STATE_CHANGED),

      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);

  return message;

}

/**

 * gst_message_new_state_dirty:

 * @src: (transfer none) (allow-none): 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: (transfer full): 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_new_clock_provide:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @clock: (transfer none): the clock it provides

 * @ready: %TRUE if the sender can provide a clock

 *

 * 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.

 *

 * Returns: (transfer full): the new provide clock message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_clock_provide (GstObject * src, GstClock * clock,

    gboolean ready)

{

  GstMessage *message;

  GstStructure *structure;

  structure = gst_structure_new_id (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_new_clock_lost:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @clock: (transfer none): the clock that was lost

 *

 * 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: (transfer full): The new clock lost message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_clock_lost (GstObject * src, GstClock * clock)

{

  GstMessage *message;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (MESSAGE_CLOCK_LOST),

      GST_QUARK (CLOCK), GST_TYPE_CLOCK, clock, NULL);

  message = gst_message_new_custom (GST_MESSAGE_CLOCK_LOST, src, structure);

  return message;

}

/**

 * gst_message_new_new_clock:

 * @src: (transfer none) (allow-none): The object originating the message.

 * @clock: (transfer none): the new selected clock

 *

 * Create a new clock message. This message is posted whenever the

 * pipeline selects a new clock for the pipeline.

 *

 * Returns: (transfer full): The new new clock message.

 *

 * MT safe.

 */

GstMessage *

gst_message_new_new_clock (GstObject * src, GstClock * clock)

{

  GstMessage *message;

  GstStructure *structure;

  structure = gst_structure_new_id (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_new_structure_change: