/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2003 Benjamin Otte <in7y118@public.uni-hamburg.de>

 *

 * gstinfo.c: debugging functions

 *

 * 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:gstinfo

 * @short_description: Debugging and logging facilities

 * @see_also: #GstConfig, #Gst for command line parameters

 * and environment variables that affect the debugging output.

 *

 * GStreamer's debugging subsystem is an easy way to get information about what

 * the application is doing.  It is not meant for programming errors. Use GLib

 * methods (g_warning and friends) for that.

 *

 * The debugging subsystem works only after GStreamer has been initialized

 * - for example by calling gst_init().

 *

 * The debugging subsystem is used to log informational messages while the

 * application runs.  Each messages has some properties attached to it. Among

 * these properties are the debugging category, the severity (called "level"

 * here) and an optional #GObject it belongs to. Each of these messages is sent

 * to all registered debugging handlers, which then handle the messages.

 * GStreamer attaches a default handler on startup, which outputs requested

 * messages to stderr.

 *

 * Messages are output by using shortcut macros like #GST_DEBUG,

 * #GST_CAT_ERROR_OBJECT or similar. These all expand to calling gst_debug_log()

 * with the right parameters.

 * The only thing a developer will probably want to do is define his own

 * categories. This is easily done with 3 lines. At the top of your code,

 * declare

 * the variables and set the default category.

 * <informalexample>

 * <programlisting>

 * GST_DEBUG_CATEGORY_STATIC (my_category);     // define category (statically)

 * &hash;define GST_CAT_DEFAULT my_category     // set as default

 * </programlisting>

 * </informalexample>

 * After that you only need to initialize the category.

 * <informalexample>

 * <programlisting>

 * GST_DEBUG_CATEGORY_INIT (my_category, "my category",

 *                          0, "This is my very own");

 * </programlisting>

 * </informalexample>

 * Initialization must be done before the category is used first.

 * Plugins do this

 * in their plugin_init function, libraries and applications should do that

 * during their initialization.

 *

 * The whole debugging subsystem can be disabled at build time with passing the

 * --disable-gst-debug switch to configure. If this is done, every function,

 * macro and even structs described in this file evaluate to default values or

 * nothing at all.

 * So don't take addresses of these functions or use other tricks.

 * If you must do that for some reason, there is still an option.

 * If the debugging

 * subsystem was compiled out, #GST_DISABLE_GST_DEBUG is defined in

 * <gst/gst.h>,

 * so you can check that before doing your trick.

 * Disabling the debugging subsystem will give you a slight (read: unnoticeable)

 * speed increase and will reduce the size of your compiled code. The GStreamer

 * library itself becomes around 10% smaller.

 *

 * Please note that there are naming conventions for the names of debugging

 * categories. These are explained at GST_DEBUG_CATEGORY_INIT().

 */

#include "gst_private.h"

#include "gstinfo.h"

#ifndef GST_DISABLE_GST_DEBUG

#ifdef HAVE_DLFCN_H

#  include <dlfcn.h>

#endif

#ifdef HAVE_PRINTF_EXTENSION

#  include <printf.h>

#endif

#include <stdio.h>              /* fprintf */

#ifdef HAVE_UNISTD_H

#  include <unistd.h>           /* getpid on UNIX */

#endif

#ifdef HAVE_PROCESS_H

#  include <process.h>          /* getpid on win32 */

#endif

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

#include "gst_private.h"

#include "gstutils.h"

#include "gstsegment.h"

#ifdef HAVE_VALGRIND

#  include <valgrind/valgrind.h>

#endif

#include <glib/gprintf.h>       /* g_sprintf */

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

/* underscore is to prevent conflict with GST_CAT_DEBUG define */

GST_DEBUG_CATEGORY_STATIC (_GST_CAT_DEBUG);

/* time of initialization, so we get useful debugging output times

 * FIXME: we use this in gstdebugutils.c, what about a function + macro to

 * get the running time: GST_DEBUG_RUNNING_TIME

 */

GstClockTime _priv_gst_info_start_time;

#if 0

#if defined __sgi__

#include <rld_interface.h>

typedef struct DL_INFO

{

  const char *dli_fname;

  void *dli_fbase;

  const char *dli_sname;

  void *dli_saddr;

  int dli_version;

  int dli_reserved1;

  long dli_reserved[4];

}

Dl_info;

#define _RLD_DLADDR             14

int dladdr (void *address, Dl_info * dl);

int

dladdr (void *address, Dl_info * dl)

{

  void *v;

  v = _rld_new_interface (_RLD_DLADDR, address, dl);

  return (int) v;

}

#endif /* __sgi__ */

#endif

static void gst_debug_reset_threshold (gpointer category, gpointer unused);

static void gst_debug_reset_all_thresholds (void);

#ifdef HAVE_PRINTF_EXTENSION

static int _gst_info_printf_extension_ptr (FILE * stream,

    const struct printf_info *info, const void *const *args);

static int _gst_info_printf_extension_segment (FILE * stream,

    const struct printf_info *info, const void *const *args);

static int _gst_info_printf_extension_arginfo (const struct printf_info *info,

    size_t n, int *argtypes);

#endif

struct _GstDebugMessage

{

  gchar *message;

  const gchar *format;

  va_list arguments;

};

/* list of all name/level pairs from --gst-debug and GST_DEBUG */

static GStaticMutex __level_name_mutex = G_STATIC_MUTEX_INIT;

static GSList *__level_name = NULL;

typedef struct

{

  GPatternSpec *pat;

  GstDebugLevel level;

}

LevelNameEntry;

/* list of all categories */

static GStaticMutex __cat_mutex = G_STATIC_MUTEX_INIT;

static GSList *__categories = NULL;

/* all registered debug handlers */

typedef struct

{

  GstLogFunction func;

  gpointer user_data;

}

LogFuncEntry;

static GStaticMutex __log_func_mutex = G_STATIC_MUTEX_INIT;

static GSList *__log_functions = NULL;

static gint __default_level;

static gint __use_color;

/* disabled by default, as soon as some threshold is set > NONE,

 * it becomes enabled. */

gboolean __gst_debug_enabled = FALSE;

GstDebugLevel __gst_debug_min = GST_LEVEL_NONE;

GstDebugCategory *GST_CAT_DEFAULT = NULL;

GstDebugCategory *GST_CAT_GST_INIT = NULL;

GstDebugCategory *GST_CAT_AUTOPLUG = NULL;

GstDebugCategory *GST_CAT_AUTOPLUG_ATTEMPT = NULL;

GstDebugCategory *GST_CAT_PARENTAGE = NULL;

GstDebugCategory *GST_CAT_STATES = NULL;

GstDebugCategory *GST_CAT_SCHEDULING = NULL;

GstDebugCategory *GST_CAT_BUFFER = NULL;

GstDebugCategory *GST_CAT_BUS = NULL;

GstDebugCategory *GST_CAT_CAPS = NULL;

GstDebugCategory *GST_CAT_CLOCK = NULL;

GstDebugCategory *GST_CAT_ELEMENT_PADS = NULL;

GstDebugCategory *GST_CAT_PADS = NULL;

GstDebugCategory *GST_CAT_PIPELINE = NULL;

GstDebugCategory *GST_CAT_PLUGIN_LOADING = NULL;

GstDebugCategory *GST_CAT_PLUGIN_INFO = NULL;

GstDebugCategory *GST_CAT_PROPERTIES = NULL;

GstDebugCategory *GST_CAT_TYPES = NULL;

GstDebugCategory *GST_CAT_XML = NULL;

GstDebugCategory *GST_CAT_NEGOTIATION = NULL;

GstDebugCategory *GST_CAT_REFCOUNTING = NULL;

GstDebugCategory *GST_CAT_ERROR_SYSTEM = NULL;

GstDebugCategory *GST_CAT_EVENT = NULL;

GstDebugCategory *GST_CAT_MESSAGE = NULL;

GstDebugCategory *GST_CAT_PARAMS = NULL;

GstDebugCategory *GST_CAT_CALL_TRACE = NULL;

GstDebugCategory *GST_CAT_SIGNAL = NULL;

GstDebugCategory *GST_CAT_PROBE = NULL;

GstDebugCategory *GST_CAT_REGISTRY = NULL;

GstDebugCategory *GST_CAT_QOS = NULL;

/* FIXME: export this? */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

_priv_gst_in_valgrind (void)

{

  static enum

  {

    GST_VG_UNCHECKED,

    GST_VG_NO_VALGRIND,

    GST_VG_INSIDE

  }

  in_valgrind = GST_VG_UNCHECKED;

  if (in_valgrind == GST_VG_UNCHECKED) {

#ifdef HAVE_VALGRIND

    if (RUNNING_ON_VALGRIND) {

      GST_CAT_INFO (GST_CAT_GST_INIT, "we're running inside valgrind");

      printf ("GStreamer has detected that it is running inside valgrind.\n");

      printf ("It might now take different code paths to ease debugging.\n");

      printf ("Of course, this may also lead to different bugs.\n");

      in_valgrind = GST_VG_INSIDE;

    } else {

      GST_CAT_LOG (GST_CAT_GST_INIT, "not doing extra valgrind stuff");

      in_valgrind = GST_VG_NO_VALGRIND;

    }

#else

    in_valgrind = GST_VG_NO_VALGRIND;

#endif

    g_assert (in_valgrind == GST_VG_NO_VALGRIND ||

        in_valgrind == GST_VG_INSIDE);

  }

  return (in_valgrind == GST_VG_INSIDE) ? TRUE : FALSE;

}

/**

 * _gst_debug_init:

 *

 * Initializes the debugging system.

 * Normally you don't want to call this, because gst_init() does it for you.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_gst_debug_init (void)

{

  gst_atomic_int_set (&__default_level, GST_LEVEL_DEFAULT);

  gst_atomic_int_set (&__use_color, 1);

  /* get time we started for debugging messages */

  _priv_gst_info_start_time = gst_util_get_timestamp ();

#ifdef HAVE_PRINTF_EXTENSION

  register_printf_function (GST_PTR_FORMAT[0], _gst_info_printf_extension_ptr,

      _gst_info_printf_extension_arginfo);

  register_printf_function (GST_SEGMENT_FORMAT[0],

      _gst_info_printf_extension_segment, _gst_info_printf_extension_arginfo);

#endif

  /* do NOT use a single debug function before this line has been run */

  GST_CAT_DEFAULT = _gst_debug_category_new ("default",

      GST_DEBUG_UNDERLINE, NULL);

  _GST_CAT_DEBUG = _gst_debug_category_new ("GST_DEBUG",

      GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, "debugging subsystem");

  gst_debug_add_log_function (gst_debug_log_default, NULL);

  /* FIXME: add descriptions here */

  GST_CAT_GST_INIT = _gst_debug_category_new ("GST_INIT",

      GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);

  GST_CAT_AUTOPLUG = _gst_debug_category_new ("GST_AUTOPLUG",

      GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);

  GST_CAT_AUTOPLUG_ATTEMPT = _gst_debug_category_new ("GST_AUTOPLUG_ATTEMPT",

      GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN | GST_DEBUG_BG_BLUE, NULL);

  GST_CAT_PARENTAGE = _gst_debug_category_new ("GST_PARENTAGE",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_STATES = _gst_debug_category_new ("GST_STATES",

      GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);

  GST_CAT_SCHEDULING = _gst_debug_category_new ("GST_SCHEDULING",

      GST_DEBUG_BOLD | GST_DEBUG_FG_MAGENTA, NULL);

  GST_CAT_BUFFER = _gst_debug_category_new ("GST_BUFFER",

      GST_DEBUG_BOLD | GST_DEBUG_BG_GREEN, NULL);

  GST_CAT_BUS = _gst_debug_category_new ("GST_BUS", GST_DEBUG_BG_YELLOW, NULL);

  GST_CAT_CAPS = _gst_debug_category_new ("GST_CAPS",

      GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);

  GST_CAT_CLOCK = _gst_debug_category_new ("GST_CLOCK",

      GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, NULL);

  GST_CAT_ELEMENT_PADS = _gst_debug_category_new ("GST_ELEMENT_PADS",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_PADS = _gst_debug_category_new ("GST_PADS",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_PIPELINE = _gst_debug_category_new ("GST_PIPELINE",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_PLUGIN_LOADING = _gst_debug_category_new ("GST_PLUGIN_LOADING",

      GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);

  GST_CAT_PLUGIN_INFO = _gst_debug_category_new ("GST_PLUGIN_INFO",

      GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);

  GST_CAT_PROPERTIES = _gst_debug_category_new ("GST_PROPERTIES",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_BLUE, NULL);

  GST_CAT_TYPES = _gst_debug_category_new ("GST_TYPES",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_XML = _gst_debug_category_new ("GST_XML",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_NEGOTIATION = _gst_debug_category_new ("GST_NEGOTIATION",

      GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);

  GST_CAT_REFCOUNTING = _gst_debug_category_new ("GST_REFCOUNTING",

      GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_BLUE, NULL);

  GST_CAT_ERROR_SYSTEM = _gst_debug_category_new ("GST_ERROR_SYSTEM",

      GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_WHITE, NULL);

  GST_CAT_EVENT = _gst_debug_category_new ("GST_EVENT",

      GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);

  GST_CAT_MESSAGE = _gst_debug_category_new ("GST_MESSAGE",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_PARAMS = _gst_debug_category_new ("GST_PARAMS",

      GST_DEBUG_BOLD | GST_DEBUG_FG_BLACK | GST_DEBUG_BG_YELLOW, NULL);

  GST_CAT_CALL_TRACE = _gst_debug_category_new ("GST_CALL_TRACE",

      GST_DEBUG_BOLD, NULL);

  GST_CAT_SIGNAL = _gst_debug_category_new ("GST_SIGNAL",

      GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);

  GST_CAT_PROBE = _gst_debug_category_new ("GST_PROBE",

      GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "pad probes");

  GST_CAT_REGISTRY = _gst_debug_category_new ("GST_REGISTRY", 0, "registry");

  GST_CAT_QOS = _gst_debug_category_new ("GST_QOS", 0, "QoS");

  /* print out the valgrind message if we're in valgrind */

  _priv_gst_in_valgrind ();

}

/* we can't do this further above, because we initialize the GST_CAT_DEFAULT struct */

#define GST_CAT_DEFAULT _GST_CAT_DEBUG

/**

 * gst_debug_log:

 * @category: category to log

 * @level: level of the message is in

 * @file: the file that emitted the message, usually the __FILE__ identifier

 * @function: the function that emitted the message

 * @line: the line from that the message was emitted, usually __LINE__

 * @object: the object this message relates to or NULL if none

 * @format: a printf style format string

 * @...: optional arguments for the format

 *

 * Logs the given message using the currently registered debugging handlers.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_debug_log (GstDebugCategory * category, GstDebugLevel level,

    const gchar * file, const gchar * function, gint line,

    GObject * object, const gchar * format, ...)

{

  va_list var_args;

  va_start (var_args, format);

  gst_debug_log_valist (category, level, file, function, line, object, format,

      var_args);

  va_end (var_args);

}

/**

 * gst_debug_log_valist:

 * @category: category to log

 * @level: level of the message is in

 * @file: the file that emitted the message, usually the __FILE__ identifier

 * @function: the function that emitted the message

 * @line: the line from that the message was emitted, usually __LINE__

 * @object: the object this message relates to or NULL if none

 * @format: a printf style format string

 * @args: optional arguments for the format

 *

 * Logs the given message using the currently registered debugging handlers.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_debug_log_valist (GstDebugCategory * category, GstDebugLevel level,

    const gchar * file, const gchar * function, gint line,

    GObject * object, const gchar * format, va_list args)

{

  GstDebugMessage message;

  LogFuncEntry *entry;

  GSList *handler;

  g_return_if_fail (category != NULL);

  g_return_if_fail (file != NULL);

  g_return_if_fail (function != NULL);

  g_return_if_fail (format != NULL);

  message.message = NULL;

  message.format = format;

  G_VA_COPY (message.arguments, args);

  handler = __log_functions;

  while (handler) {

    entry = handler->data;

    handler = g_slist_next (handler);

    entry->func (category, level, file, function, line, object, &message,

        entry->user_data);

  }

  g_free (message.message);

  va_end (message.arguments);

}

/**

 * gst_debug_message_get:

 * @message: a debug message

 *

 * Gets the string representation of a #GstDebugMessage. This function is used

 * in debug handlers to extract the message.

 *

 * Returns: the string representation of a #GstDebugMessage.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const gchar *

gst_debug_message_get (GstDebugMessage * message)

{

  if (message->message == NULL) {

    message->message = g_strdup_vprintf (message->format, message->arguments);

  }

  return message->message;

}

static gchar *

gst_debug_print_object (gpointer ptr)

{

  GObject *object = (GObject *) ptr;

#ifdef unused

  /* This is a cute trick to detect unmapped memory, but is unportable,

   * slow, screws around with madvise, and not actually that useful. */

  {

    int ret;

    ret = madvise ((void *) ((unsigned long) ptr & (~0xfff)), 4096, 0);

    if (ret == -1 && errno == ENOMEM) {

      buffer = g_strdup_printf ("%p (unmapped memory)", ptr);

    }

  }

#endif

  /* nicely printed object */

  if (object == NULL) {

    return g_strdup ("(NULL)");

  }

  if (*(GType *) ptr == GST_TYPE_CAPS) {

    return gst_caps_to_string ((GstCaps *) ptr);

  }

  if (*(GType *) ptr == GST_TYPE_STRUCTURE) {

    return gst_structure_to_string ((GstStructure *) ptr);

  }

#ifdef USE_POISONING

  if (*(guint32 *) ptr == 0xffffffff) {

    return g_strdup_printf ("<poisoned@%p>", ptr);

  }

#endif

  if (GST_IS_PAD (object) && GST_OBJECT_NAME (object)) {

    return g_strdup_printf ("<%s:%s>", GST_DEBUG_PAD_NAME (object));

  }

  if (GST_IS_OBJECT (object) && GST_OBJECT_NAME (object)) {

    return g_strdup_printf ("<%s>", GST_OBJECT_NAME (object));

  }

  if (G_IS_OBJECT (object)) {

    return g_strdup_printf ("<%s@%p>", G_OBJECT_TYPE_NAME (object), object);

  }

  if (GST_IS_MESSAGE (object)) {

    GstMessage *msg = GST_MESSAGE_CAST (object);

    gchar *s, *ret;

    if (msg->structure) {

      s = gst_structure_to_string (msg->structure);

    } else {

      s = g_strdup ("(NULL)");

    }