/* 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., 59 Temple Place - Suite 330,

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

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

#define GST_MESSAGE_SEQNUM(e) ((GstMessage*)e)->abidata.ABI.seqnum

static void gst_message_finalize (GstMessage * message);

static GstMessage *_gst_message_copy (GstMessage * message);

static GstMiniObjectClass *parent_class = NULL;

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_gst_message_initialize (void)

{

  GST_CAT_INFO (GST_CAT_GST_INIT, "init messages");

  /* 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},

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

  {0, NULL, 0}

};

/**

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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;

}

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

  } \

}

G_DEFINE_TYPE_WITH_CODE (GstMessage, gst_message, GST_TYPE_MINI_OBJECT,

    _do_init);

static void

gst_message_class_init (GstMessageClass * klass)

{

  parent_class = g_type_class_peek_parent (klass);

  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_finalize (GstMessage * 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_MESSAGE_LOCK (message);

    GST_MESSAGE_SIGNAL (message);

    GST_MESSAGE_UNLOCK (message);

  }

  if (message->structure) {

    gst_structure_set_parent_refcount (message->structure, NULL);

    gst_structure_free (message->structure);

  }

/*   GST_MINI_OBJECT_CLASS (parent_class)->finalize (GST_MINI_OBJECT (message)); */

}

static GstMessage *

_gst_message_copy (GstMessage * message)

{

  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,

        &copy->mini_object.refcount);

  }

  return copy;

}

/**

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

 *

 * 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: The new message.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstMessage *

gst_message_new_custom (GstMessageType type, GstObject * src,

    GstStructure * structure)

{

  GstMessage *message;

  message = (GstMessage *) gst_mini_object_new (GST_TYPE_MESSAGE);

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

  message->type = type;

  if (src)

    gst_object_ref (src);

  message->src = src;

  if (structure) {

    gst_structure_set_parent_refcount (structure,

        &message->mini_object.refcount);

  }

  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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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:

 * @src: The object originating the message.

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

 * occured. The pipeline will probably (partially) stop. The application

 * receiving this message should stop the pipeline.

 *

 * Returns: The new error message.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstMessage *

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

{

  GstMessage *message;

  GstStructure *structure;

  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.

 *

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

 * @debug.

 *

 * Returns: The new warning message.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstMessage *

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

{

  GstMessage *message;

  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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstMessage *

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

{

  GstMessage *message;

  GstStructure *structure;

  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;

}

/**

 * gst_message_new_tag:

 * @src: The object originating the 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.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstMessage *

gst_message_new_tag (GstObject * src, GstTagList * tag_list)

{

  GstMessage *message;

  g_return_val_if_fail (GST_IS_STRUCTURE (tag_list), NULL);

  message =

      gst_message_new_custom (GST_MESSAGE_TAG, src, (GstStructure *) tag_list);

  return message;